#include "MyApp.h"

#include <math.h>
#include <vector>

#include <array>
#include <list>
#include <tuple>
#include <imgui/imgui.h>
#include <iostream>

#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */

CMyApp::CMyApp(void)
{
	m_camera.SetView(glm::vec3(5, 5, 5), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
}


CMyApp::~CMyApp(void)
{
	std::cout << "dtor!\n";
}

float CMyApp::getHeight(int x, int z) {
	return height[x + z * mapSize + 1];
}


int db;

glm::vec3 CMyApp::GetPos(float u, float v)
{
	u *= 2 * 3.1415f;
	v *= 3.1415f;
	float cu = cosf(u), su = sinf(u), cv = cosf(v), sv = sinf(v);
	float r = 2;

	return glm::vec3(r * cu * sv, r * su * sv, r * cv);
}

glm::vec3 CMyApp::GetNorm(float u, float v)
{
	// Képlettel
	u *= 2 * 3.1415f;
	v *= 3.1415f;
	float cu = cosf(u), su = sinf(u), cv = cosf(v), sv = sinf(v);
	return glm::vec3(cu * sv, cv, su * sv);

}

void CMyApp::initFa() {
	std::vector<glm::vec3> vert;
	vert.reserve((resolution + 1) * (resolution + 1));
	for (int i = 0; i <= resolution; ++i)
		for (int j = 0; j <= resolution; ++j)
		{
			float u = i / (float)resolution;
			float v = j / (float)resolution;
			vert.push_back(GetPos(u, v));
			vert.push_back(GetNorm(u, v));
			vert.push_back(glm::vec3(GetTex(u, v),0));
		}
	std::vector<int> indices;
	indices.resize(3 * 2 * resolution * resolution);
	for (int i = 0; i < resolution; ++i)
		for (int j = 0; j < resolution; ++j)
		{
			indices[6 * i + j * 3 * 2 * resolution +0] = (i)+(j) * (resolution + 1);
			indices[6 * i + j * 3 * 2 * resolution +1] = (i + 1) + (j) * (resolution + 1);
			indices[6 * i + j * 3 * 2 * resolution +2] = (i)+(j + 1) * (resolution + 1);
			indices[6 * i + j * 3 * 2 * resolution +3] = (i + 1) + (j) * (resolution + 1);
			indices[6 * i + j * 3 * 2 * resolution +4] = (i + 1) + (j + 1) * (resolution + 1);
			indices[6 * i + j * 3 * 2 * resolution +5] = (i)+(j + 1) * (resolution + 1);
		}
	m_gpuBufferPos_fa.BufferData(vert);
	m_gpuBufferIndices_fa.BufferData(indices);


	m_vao_fa.Init(
		{
			// 0-ás attribútum "lényegében" glm::vec3-ak sorozata és az adatok az m_gpuBufferPos GPU pufferben vannak
			{ CreateAttribute<		0,						// csatorna: 0
									glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
									0,						// offset: az attribútum tároló elejétől vett offset-je, byte-ban
									sizeof(glm::vec3) * 3		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
								>, m_gpuBufferPos_fa },
			{ CreateAttribute<		1,						// csatorna: 0
									glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
									sizeof(glm::vec3),		// offset: az attribútum tároló elejétől vett offset-je, byte-ban
									sizeof(glm::vec3) * 3		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
								>,m_gpuBufferPos_fa
								},
			{ CreateAttribute<		2,						// csatorna: 0
									glm::vec2,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
									sizeof(glm::vec3) * 2,		// offset: az attribútum tároló elejétől vett offset-je, byte-ban
									sizeof(glm::vec3) * 3		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
								>,m_gpuBufferPos_fa
								}
		},
		m_gpuBufferIndices_fa
	);

	glGenTextures(1, &m_levelTexture);

	glBindTexture(GL_TEXTURE_2D, m_levelTexture);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	TextureFromFileAttach("leaves.jpg", GL_TEXTURE_2D);
	glGenerateMipmap(GL_TEXTURE_2D);

	glBindTexture(GL_TEXTURE_2D, 0);



	m_mesh = ObjParser::parse("henger.obj");
	m_mesh->initBuffers();
	glGenTextures(1, &m_faTexture);

	glBindTexture(GL_TEXTURE_2D, m_faTexture);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	TextureFromFileAttach("bark.jpg", GL_TEXTURE_2D);
	glGenerateMipmap(GL_TEXTURE_2D);

	glBindTexture(GL_TEXTURE_2D, 0);

}

void CMyApp::renderFa() {
	m_vao_fa.Bind();
	m_program.Use();
	glm::mat4 cubeWorld = glm::translate(glm::vec3(0, 5, 0))* glm::scale(glm::vec3(0.75, 0.75, 0.75));
	m_program.SetUniform("MVP", m_camera.GetViewProj()*cubeWorld);
	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, m_levelTexture);
	glUniform1i(m_program.GetLocation("tex"), 1);


	glDrawElements(GL_TRIANGLES, 3 * 2 * (resolution) * (resolution), GL_UNSIGNED_INT, nullptr);
	cubeWorld = glm::scale(glm::vec3(1, 1, 1))* glm::translate(glm::vec3(0,1.7,0));
	m_program.SetUniform("MVP", m_camera.GetViewProj()*cubeWorld);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, m_faTexture);
	glUniform1i(m_program.GetLocation("tex"), 0);

	m_mesh->draw();

	m_vao_fa.Unbind();
}

bool CMyApp::Init()
{
	// törlési szín legyen kékes
	glClearColor(0.125f, 0.25f, 0.5f, 1.0f);

	glEnable(GL_CULL_FACE); // kapcsoljuk be a hatrafele nezo lapok eldobasat
	glEnable(GL_DEPTH_TEST); // mélységi teszt bekapcsolása (takarás)

	//
	// shaderek betöltése
	//

	// a shadereket tároló program létrehozása az OpenGL-hez hasonló módon:
	m_program.AttachShaders({
		{ GL_VERTEX_SHADER, "myVert.vert"},
		{ GL_FRAGMENT_SHADER, "myFrag.frag"}
	});

	// attributomok osszerendelese a VAO es shader kozt
	m_program.BindAttribLocations({
		{ 0, "vs_in_pos" },				// VAO 0-as csatorna menjen a vs_in_pos-ba
		{ 1, "vs_in_norm" },				// VAO 1-es csatorna menjen a vs_in_norm-ba
		{ 2, "vs_in_tex" }				// VAO 2-es csatorna menjen a vs_in_tex-be
	});

	m_program.LinkProgram();

	// shader program rövid létrehozása, egyetlen függvényhívással a fenti három:
	m_programSkybox.Init(
	{
		{ GL_VERTEX_SHADER, "skybox.vert" },
		{ GL_FRAGMENT_SHADER, "skybox.frag" }
	},
	{
		{ 0, "vs_in_pos" },				// VAO 0-as csatorna menjen a vs_in_pos-ba
	}
	);


	for (int i = 0; i < treeCount; ++i) {

		treepos.push_back(glm::vec3());
	}

	//
	// geometria definiálása (std::vector<...>) és GPU pufferekbe (m_buffer*) való feltöltése BufferData-val
	//

	// vertexek pozíciói:
	/*
	Az m_gpuBufferPos konstruktora már létrehozott egy GPU puffer azonosítót és a most következő BufferData hívás ezt
	1. bind-olni fogja GL_ARRAY_BUFFER target-re (hiszen m_gpuBufferPos típusa ArrayBuffer) és
	2. glBufferData segítségével áttölti a GPU-ra az argumentumban adott tároló értékeit

	*/

	//init vertex
	srand(time(NULL));
	std::vector<glm::vec3> vert;

	for (int i = 0; i <= mapSize; ++i)
		for (int j = 0; j <= mapSize; ++j)
		{
			float x = i-10;
			float z = j-10;
			float random = sin(rand());
			height.push_back(random);
			vert.push_back(glm::vec3(x, random, z));
			vert.push_back(glm::vec3(-z, random, x));
			vert.push_back(glm::vec3(i - 1 / mapSize, j - 1 / mapSize,0));
		}

	//init indicies
	std::vector<int> indicies;
	for (int i = 0; i <mapSize; ++i)
		for (int j = 0; j <mapSize; ++j)
		{

			indicies.push_back( (i)+(j)*(mapSize+1));
			indicies.push_back( (i + 1) + (j)* (mapSize+1 ));
			indicies.push_back( (i)+(j + 1) * (mapSize+1 ));
			indicies.push_back( (i) + (j+1)* (mapSize+1 ));
			indicies.push_back( (i + 1) + (j ) * (mapSize+1 ));
			indicies.push_back( (i+1)+(j + 1) * (mapSize+1 ));
		}
	db = indicies.size();
	m_gpuBufferPos.BufferData(vert);
	m_gpuBufferIndices.BufferData(indicies);
	for (int i = 0; i < indicies.size(); ++i) {
		//std::cout << indicies[i] << " ";
	}




	// geometria VAO-ban való regisztrálása
	m_vao.Init(
	{
		// 0-ás attribútum "lényegében" glm::vec3-ak sorozata és az adatok az m_gpuBufferPos GPU pufferben vannak
		{ CreateAttribute<		0,						// csatorna: 0
								glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
								0,						// offset: az attribútum tároló elejétől vett offset-je, byte-ban
								sizeof(glm::vec3) * 3		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
							>, m_gpuBufferPos },
		{ CreateAttribute<		1,						// csatorna: 0
								glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
								sizeof(glm::vec3),		// offset: az attribútum tároló elejétől vett offset-je, byte-ban
								sizeof(glm::vec3) * 3		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
							>,m_gpuBufferPos
							},
		{ CreateAttribute<		2,						// csatorna: 0
								glm::vec2,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
								sizeof(glm::vec3)*2,		// offset: az attribútum tároló elejétől vett offset-je, byte-ban
								sizeof(glm::vec3) * 3		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
							>,m_gpuBufferPos
							}
	},
	m_gpuBufferIndices
	);

	//maptexture
	glGenTextures(1, &m_mapTexture);

	glBindTexture(GL_TEXTURE_2D, m_mapTexture);

	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	TextureFromFileAttach("fasz.jpg", GL_TEXTURE_2D);
	glGenerateMipmap(GL_TEXTURE_2D);

	glBindTexture(GL_TEXTURE_2D, 0);
	glGenTextures(1, &m_keretTexture);
	//keret
	glBindTexture(GL_TEXTURE_2D, m_keretTexture);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	TextureFromFileAttach("forest.jpg", GL_TEXTURE_2D);
	glGenerateMipmap(GL_TEXTURE_2D);

	glBindTexture(GL_TEXTURE_2D, 0);

	m_gpuBufferPos_keret.BufferData(
		std::vector<glm::vec3>{
		// hátsó lap
		glm::vec3(-1, -1, -1),
			glm::vec3(1,1,0),
			glm::vec3(1, -1, -1),
			glm::vec3(0, 1, 0),
			glm::vec3(1, 1, -1),
			glm::vec3(0, 0, 0),
			glm::vec3(-1, 1, -1),
			glm::vec3(1, 0, 0),
			// elülső lap
			glm::vec3(-1, -1, 1),
			glm::vec3(0, 1, 0),
			glm::vec3(1, -1, 1),
			glm::vec3(1, 1, 0),
			glm::vec3(1, 1, 1),
			glm::vec3(1, 0, 0),
			glm::vec3(-1, 1, 1),
			glm::vec3(0, 0, 0),

	}
	);

	m_gpuBufferIndices_keret.BufferData(
		std::vector<int>{
		// hátsó lap
		0, 1, 2,
			2, 3, 0,
			// elülső lap
			4, 6, 5,
			6, 4, 7,
			// bal
			0, 3, 4,
			4, 3, 7,
			// jobb
			1, 5, 2,
			5, 6, 2,
	}
	);
	//4, 6, 5,
	//6, 4, 7,

	m_vao_keret.Init(
		{
			// 0-ás attribútum "lényegében" glm::vec3-ak sorozata és az adatok az m_gpuBufferPos GPU pufferben vannak
			{ CreateAttribute<		0,						// csatorna: 0
									glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
									0,						// offset: az attribútum tároló elejétől vett offset-je, byte-ban
									sizeof(glm::vec3)*2		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
								>, m_gpuBufferPos_keret },
		{ CreateAttribute<		2,						// csatorna: 0
									glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
									sizeof(glm::vec3),						// offset: az attribútum tároló elejétől vett offset-je, byte-ban
									sizeof(glm::vec3)*2		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
								>, m_gpuBufferPos_keret }
		},
		m_gpuBufferIndices_keret
	);

	initFa();
	// skybox

	m_gpuBufferPos_skybox.BufferData(
		std::vector<glm::vec3>{
		// hátsó lap
		glm::vec3(-1, -1, -1),
			glm::vec3(1, -1, -1),
			glm::vec3(1, 1, -1),
			glm::vec3(-1, 1, -1),
			// elülső lap
			glm::vec3(-1, -1, 1),
			glm::vec3(1, -1, 1),
			glm::vec3(1, 1, 1),
			glm::vec3(-1, 1, 1),

	}
	);

	m_gpuBufferIndices_skybox.BufferData(
		std::vector<int>{
		// hátsó lap
		0, 1, 2,
			2, 3, 0,
			// elülső lap
			4, 6, 5,
			6, 4, 7,
			// bal
			0, 3, 4,
			4, 3, 7,
			// jobb
			1, 5, 2,
			5, 6, 2,
			// alsó
			1, 0, 4,
			1, 4, 5,
			// felső
			3, 2, 6,
			3, 6, 7,
	}
	);

	m_vao_skybox.Init(
		{
			// 0-ás attribútum "lényegében" glm::vec3-ak sorozata és az adatok az m_gpuBufferPos GPU pufferben vannak
			{ CreateAttribute<		0,						// csatorna: 0
									glm::vec3,				// CPU oldali adattípus amit a 0-ás csatorna attribútumainak meghatározására használtunk <- az eljárás a glm::vec3-ból kikövetkezteti, hogy 3 darab float-ból áll a 0-ás attribútum
									0,						// offset: az attribútum tároló elejétől vett offset-je, byte-ban
									sizeof(glm::vec3)		// stride: a következő csúcspont ezen attribútuma hány byte-ra van az aktuálistól
								>, m_gpuBufferPos_skybox },
		},
		m_gpuBufferIndices_skybox
	);



	glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);

	glGenTextures(1, &m_skyboxTexture);
	glBindTexture(GL_TEXTURE_CUBE_MAP, m_skyboxTexture);

	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

	TextureFromFileAttach("xpos.png", GL_TEXTURE_CUBE_MAP_POSITIVE_X);
	TextureFromFileAttach("xneg.png", GL_TEXTURE_CUBE_MAP_NEGATIVE_X);
	TextureFromFileAttach("ypos.png", GL_TEXTURE_CUBE_MAP_POSITIVE_Y);
	TextureFromFileAttach("yneg.png", GL_TEXTURE_CUBE_MAP_NEGATIVE_Y);
	TextureFromFileAttach("zpos.png", GL_TEXTURE_CUBE_MAP_POSITIVE_Z);
	TextureFromFileAttach("zneg.png", GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);

	glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

	// kamera
	m_camera.SetProj(45.0f, 640.0f / 480.0f, 0.01f, 1000.0f);

	return true;
}

void CMyApp::TextureFromFileAttach(const char* filename, GLuint role) const
{
	SDL_Surface* loaded_img = IMG_Load(filename);

	int img_mode = 0;

	if (loaded_img == 0)
	{
		std::cout << "[TextureFromFile] Hiba a kép betöltése közben: " << filename << std::endl;
		return;
	}

#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	if (loaded_img->format->BytesPerPixel == 4)
		img_mode = GL_RGBA;
	else
		img_mode = GL_RGB;
#else
	if (loaded_img->format->BytesPerPixel == 4)
		img_mode = GL_RGBA;
	else
		img_mode = GL_RGB;
#endif

	glTexImage2D(role, 0, GL_RGBA, loaded_img->w, loaded_img->h, 0, img_mode, GL_UNSIGNED_BYTE, loaded_img->pixels);

	SDL_FreeSurface(loaded_img);
}

void CMyApp::Clean()
{
	glDeleteTextures(1, &m_skyboxTexture);
}

void CMyApp::Update()
{
	static Uint32 last_time = SDL_GetTicks();
	float delta_time = (SDL_GetTicks() - last_time) / 1000.0f;

	m_camera.Update(delta_time);

	last_time = SDL_GetTicks();
}

void CMyApp::Render()
{
	// töröljük a frampuffert (GL_COLOR_BUFFER_BIT) és a mélységi Z puffert (GL_DEPTH_BUFFER_BIT)
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// kocka
	m_vao.Bind();

	m_program.Use();

	// fő kocka
	//glm::mat4 cubeWorld = glm::scale(glm::vec3(-1,-1,-1));	// kifordítjuk, mert egyébként "kívül a belül"
	m_program.SetUniform("MVP", m_camera.GetViewProj());
	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, m_mapTexture);
	glUniform1i(m_program.GetLocation("tex"), 1);


	glDrawElements(GL_TRIANGLES, db, GL_UNSIGNED_INT, nullptr);





	// mentsük el az előző Z-test eredményt, azaz azt a relációt, ami alapján update-eljük a pixelt.
	GLint prevDepthFnc;
	glGetIntegerv(GL_DEPTH_FUNC, &prevDepthFnc);

	// most kisebb-egyenlőt használjunk, mert mindent kitolunk a távoli vágósíkokra
	glDepthFunc(GL_LEQUAL);
	m_vao.Unbind();
	m_vao_keret.Bind();


	//mapkeret
	m_program.Use();

	glm::mat4 cubeWorld = glm::translate(glm::vec3(0,4,0))*glm::scale(glm::vec3(10,5,10));	// kifordítjuk, mert egyébként "kívül a belül"
	m_program.SetUniform("MVP", m_camera.GetViewProj()*cubeWorld);

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, m_keretTexture);
	glUniform1i(m_program.GetLocation("tex"), 0);


	glDrawElements(GL_TRIANGLES, 24, GL_UNSIGNED_INT, nullptr);


	// skybox

	m_vao_keret.Unbind();


	renderFa();

	m_vao_skybox.Bind();
	m_programSkybox.Use();
	m_programSkybox.SetUniform("MVP", m_camera.GetViewProj() * glm::translate( m_camera.GetEye()) );

	// cube map textúra beállítása 0-ás mintavételezőre és annak a shaderre beállítása
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_CUBE_MAP, m_skyboxTexture);
	glUniform1i(m_programSkybox.GetLocation("skyboxTexture"), 0);

	// az előző három sor <=> m_programSkybox.SetCubeTexture("skyboxTexture", 0, m_skyboxTexture);

	glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, nullptr);

	// végül állítsuk vissza
	glDepthFunc(prevDepthFnc);

	m_vao_skybox.Unbind();

	// 1. feladat: készíts egy vertex shader-fragment shader párt, ami tárolt geometria _nélkül_ kirajzol egy tetszőleges pozícióba egy XYZ tengely-hármast,
	//			   ahol az X piros, az Y zöld a Z pedig kék!

	//ImGui Testwindow
	//ImGui::ShowTestWindow();
}

void CMyApp::KeyboardDown(SDL_KeyboardEvent& key)
{
	m_camera.KeyboardDown(key);
}

void CMyApp::KeyboardUp(SDL_KeyboardEvent& key)
{
	m_camera.KeyboardUp(key);
}

void CMyApp::MouseMove(SDL_MouseMotionEvent& mouse)
{
	m_camera.MouseMove(mouse);
}

void CMyApp::MouseDown(SDL_MouseButtonEvent& mouse)
{
}

void CMyApp::MouseUp(SDL_MouseButtonEvent& mouse)
{
}

void CMyApp::MouseWheel(SDL_MouseWheelEvent& wheel)
{
}

// a két paraméterbe az új ablakméret szélessége (_w) és magassága (_h) található
void CMyApp::Resize(int _w, int _h)
{
	glViewport(0, 0, _w, _h );

	m_camera.Resize(_w, _h);
}