void MS::ReflectXZPlane()
{
Mtx44 mat;
mat.SetToReflectionXZplane();
ms.top() = ms.top() * mat;
}
void PLANET5::Init()
{
// Init VBO here
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Set background color
glEnable(GL_DEPTH_TEST); // Enable depth buffer and depth testing
glEnable(GL_CULL_FACE); // Enable back face culling
// Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Default to fill mode
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Text.fragmentshader");
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_LIGHT1_TYPE] = glGetUniformLocation(m_programID, "lights[1].type");
m_parameters[U_LIGHT1_POSITION] = glGetUniformLocation(m_programID, "lights[1].position_cameraspace");
m_parameters[U_LIGHT1_COLOR] = glGetUniformLocation(m_programID, "lights[1].color");
m_parameters[U_LIGHT1_POWER] = glGetUniformLocation(m_programID, "lights[1].power");
m_parameters[U_LIGHT1_KC] = glGetUniformLocation(m_programID, "lights[1].kC");
m_parameters[U_LIGHT1_KL] = glGetUniformLocation(m_programID, "lights[1].kL");
m_parameters[U_LIGHT1_KQ] = glGetUniformLocation(m_programID, "lights[1].kQ");
m_parameters[U_LIGHT1_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[1].spotDirection");
m_parameters[U_LIGHT1_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[1].cosCutoff");
m_parameters[U_LIGHT1_COSINNER] = glGetUniformLocation(m_programID, "lights[1].cosInner");
m_parameters[U_LIGHT1_EXPONENT] = glGetUniformLocation(m_programID, "lights[1].exponent");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights"); //in case you missed out practical 7
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
glUseProgram(m_programID);
//variable to rotate geometry
//Initialize camera settings
camera.Init(Vector3(0, 5, 100), Vector3(0, 5, 0), Vector3(0, 1, 0));
meshList[GEO_AXES] = MeshBuilder::GenerateAxes("AXES", 1000, 1000, 1000);
Mtx44 projection;
projection.SetToPerspective(45.f, 4.f / 3.f, 0.1f, 100000.f);
projectionStack.LoadMatrix(projection);
light[0].type = Light::LIGHT_POINT;
light[0].position.Set(0, 48, 0);
light[0].color.Set(1, 1, 1);
light[0].power = 1.f;
light[0].kC = 1.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
light[1].type = Light::LIGHT_DIRECTIONAL;
light[1].position.Set(0, 300, -400);
light[1].color.Set(1, 1, 1);
light[1].power = 1;
light[1].kC = 1.f;
light[1].kL = 0.01f;
light[1].kQ = 0.001f;
light[1].cosCutoff = cos(Math::DegreeToRadian(45));
light[1].cosInner = cos(Math::DegreeToRadian(30));
light[1].exponent = 3.f;
light[1].spotDirection.Set(0.f, 1.f, 0.f);
// Make sure you pass uniform parameters after glUseProgram()
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1i(m_parameters[U_LIGHT1_TYPE], light[1].type);
glUniform3fv(m_parameters[U_LIGHT1_COLOR], 1, &light[1].color.r);
glUniform1f(m_parameters[U_LIGHT1_POWER], light[1].power);
glUniform1f(m_parameters[U_LIGHT1_KC], light[1].kC);
glUniform1f(m_parameters[U_LIGHT1_KL], light[1].kL);
glUniform1f(m_parameters[U_LIGHT1_KQ], light[1].kQ);
glUniform1i(m_parameters[U_NUMLIGHTS], 2);
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSphere("LIGHT", Color(1, 1, 1), 36, 36);
meshList[PICFRAME] = MeshBuilder::GenerateOBJ("frame", "OBJ//PicFrame.obj");
meshList[PICFRAME]->textureID = LoadTGA("Image//Painting.tga");
meshList[SPIN] = MeshBuilder::GenerateOBJ("spin", "OBJ//spin.obj");
meshList[SPIN]->textureID = LoadTGA("Image//spin.tga");
meshList[SPIN]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[SPIN]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[SPIN]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[SPIN]->material.kShininess = 1.5f;
meshList[SPINCAP] = MeshBuilder::GenerateOBJ("spincap", "OBJ//spincap.obj");
meshList[SPINCAP]->textureID = LoadTGA("Image//spincap.tga");
meshList[SPINCAP]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[SPINCAP]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[SPINCAP]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[SPINCAP]->material.kShininess = 1.5f;
meshList[BUTTON] = MeshBuilder::GenerateOBJ("button", "OBJ//button.obj");
meshList[BUTTON]->textureID = LoadTGA("Image//redbutton.tga");
meshList[BUTTON]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[BUTTON]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[BUTTON]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[BUTTON]->material.kShininess = 1.5f;
meshList[BUTTONSTAND] = MeshBuilder::GenerateOBJ("spincap", "OBJ//buttonstand.obj");
meshList[BUTTONSTAND]->textureID = LoadTGA("Image//buttonstand.tga");
meshList[BUTTONSTAND]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[BUTTONSTAND]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[BUTTONSTAND]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[BUTTONSTAND]->material.kShininess = 1.5f;
meshList[ARM2] = MeshBuilder::GenerateOBJ("arm2", "OBJ//arm2.obj");
meshList[ARM2]->textureID = LoadTGA("Image//Human.tga");
meshList[ARM2]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[ARM2]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[ARM2]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[ARM2]->material.kShininess = 1.5f;
rotatespin = 0;
rotategem1 = 0;
rotategem2 = 0;
rotategem3 = 0;
rotategem4 = 0;
spin1 = false;
gem1 = false;
gem2 = false;
gem3 = false;
gem4 = false;
complete1 = false;
complete2 = false;
complete3 = false;
complete4 = false;
translateButton = 3.55f;
translategem1 = 3.55f;
translategem2 = 3.55f;
translategem3 = 3.55f;
translategem4 = 3.55f;
flygem1 = 6.0f;
flygem2 = 6.3f;
flygem3 = 5.7f;
flygem4 = 5.5f;
scaleFinish = 0.1f;
MS_rotate = 0.f;
MS_reverse = false;
meshList[POSITION] = MeshBuilder::GenerateText("keymsg", 16, 16);
meshList[POSITION]->textureID = LoadTGA("Image//Redressed.tga");
meshList[GALLERY_WALL] = MeshBuilder::GenerateOBJ("asteroid", "OBJ//GalleryBox.obj");
meshList[GALLERY_WALL]->textureID = LoadTGA("Image//BiegeWall.tga");
meshList[GEM] = MeshBuilder::GenerateOBJ("gem", "OBJ//gem1.obj");
meshList[GEM]->textureID = LoadTGA("Image//portal.tga");
meshList[GEM]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[GEM]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[GEM]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[GEM]->material.kShininess = 1.5f;
meshList[GEM2] = MeshBuilder::GenerateOBJ("gem2", "OBJ//gem2.obj");
meshList[GEM2]->textureID = LoadTGA("Image//portal2.tga");
meshList[GEM2]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[GEM2]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[GEM2]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[GEM2]->material.kShininess = 1.5f;
meshList[GEM3] = MeshBuilder::GenerateOBJ("gem3", "OBJ//gem3.obj");
meshList[GEM3]->textureID = LoadTGA("Image//portalcase.tga");
meshList[GEM3]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[GEM3]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[GEM3]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[GEM3]->material.kShininess = 1.5f;
meshList[GEM4] = MeshBuilder::GenerateOBJ("gem4", "OBJ//gem4.obj");
meshList[GEM4]->textureID = LoadTGA("Image//portal4.tga");
meshList[GEM4]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[GEM4]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[GEM4]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[GEM4]->material.kShininess = 1.5f;
meshList[GEMCASE] = MeshBuilder::GenerateOBJ("gemcase", "OBJ//Barrier.obj");
meshList[GEMCASE]->textureID = LoadTGA("Image//BarrierTextures.tga");
meshList[GEMCASE]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[GEMCASE]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[GEMCASE]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[GEMCASE]->material.kShininess = 1.5f;
meshList[END] = MeshBuilder::GenerateOBJ("end", "OBJ//END.obj");
meshList[END]->textureID = LoadTGA("Image//END.tga");
meshList[END]->material.kAmbient.Set(0.8f, 0.8f, 0.8f);
meshList[END]->material.kDiffuse.Set(0.8f, 0.8f, 0.8f);
meshList[END]->material.kSpecular.Set(0.8f, 0.8f, 0.8f);
meshList[END]->material.kShininess = 1.5f;
}
void Camera2::Update(double dt)
{
//Mouse shit
POINT currentposition_;
GetCursorPos(¤tposition_);
static const float CAMERA_SPEED = 40.f;
//Move front
if (Application::IsKeyPressed('W'))
{
Vector3 view = (target - position).Normalized();
view.y = 0;
position += (view * dt * 10.f);
target += (view * dt * 10.f);
}
//Move Back
if (Application::IsKeyPressed('S'))
{
Vector3 view = (target - position).Normalized();
view.y = 0;
position -= (view * dt * 10.f);
target -= (view * dt * 10.f);
}
//Move Right
if (Application::IsKeyPressed('D'))
{
Vector3 view = (target - position).Normalized();
Vector3 right=view.Cross(up);
right.y = 0;
position += (right * dt * 10.f);
target += (right * dt * 10.f);
}
//Move Left
if (Application::IsKeyPressed('A'))
{
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
position -= (right * dt * 10.f);
target -= (right * dt * 10.f);
}
//Rotate up
if (Application::IsKeyPressed(VK_UP)) //Pitch
{
//Original
float pitch = (float)(CAMERA_SPEED * dt);
/*Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
position = rotation * position;*/
// FOr FP view
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
//Rotate Down
if (Application::IsKeyPressed(VK_DOWN)) //Pitch, down
{
float pitch = (float)(-CAMERA_SPEED * dt);
//Original
/*Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
position = rotation * position;*/
//Fp Camera
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
//Rotate Right
if (Application::IsKeyPressed(VK_RIGHT))
{
float yaw = (float)(-CAMERA_SPEED * dt);
//Original
/* Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
position = rotation * position;
up = rotation * up;*/
//FP camera
Vector3 view = (target - position).Normalized();
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
up = rotation*up;
}
//Rotate Left
if (Application::IsKeyPressed(VK_LEFT))
{
float yaw = (float)(CAMERA_SPEED * dt);
//Original
/*Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
position = rotation * position;
up = rotation * up;*/
//FP camera
Vector3 view = (target - position).Normalized();
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
up = rotation*up;
}
if (currentposition_.x > (1600/2))
{
float yaw = (float)(-CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
up = rotation*up;
}
if (currentposition_.x < (1600 / 2))
{
float yaw = (float)(CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
up = rotation*up;
}
if (currentposition_.y > (900 / 2))
{
float pitch = (float)(-CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
if (currentposition_.y < (900 / 2))
{
float pitch = (float)(CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
if (Application::IsKeyPressed('R'))
{
Reset();
}
SetCursorPos(1600 / 2, 900 / 2);
}
void Assignment1::Render()
{
// Render VBO here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Mtx44 translate, rotate, scale;
Mtx44 model;
Mtx44 view;
Mtx44 projection;
Mtx44 MVP;
translate.SetToIdentity();
rotate.SetToIdentity();
scale.SetToIdentity();
model.SetToIdentity();
view.SetToIdentity();
projection.SetToOrtho(-40, 40, -30, 30, -10, 10);
glEnableVertexAttribArray(0);// 1st attribute buffer: vertices
glEnableVertexAttribArray(1); // 2nd attribute buffer : colors
//<landscape>
scale.SetToScale(125, 125, 125);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(0,-125,1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[LANDSCAPE_1]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[LANDSCAPE_1]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 5);
model.SetToIdentity();
scale.SetToScale(20, 20, 20);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(25, 0, 0);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[LANDSCAPE_1]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[LANDSCAPE_1]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 5);
model.SetToIdentity();
scale.SetToScale(50, 20, 20);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(10, -5, -0.5);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[LANDSCAPE_1]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[LANDSCAPE_1]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 5);
//</landscape>
//<cloud>
scale.SetToScale(10, 10, 10);
rotate.SetToRotation(25, 0, 0, 1);
translate.SetToTranslation(cloudMovement , 25, 0.5f);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CLOUDS_2]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CLOUDS_2]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 12);
//</cloud>
//<sun>
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(rotateAngle, 0, 0, 1);
translate.SetToTranslation(-25, 20, 0);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[SUN_3]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[SUN_3]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 9);
//</sun>
//<explosion>
scale.SetToScale(explosionSize, explosionSize, explosionSize);
rotate.SetToRotation(explosionRotation, 0, 0, 1);
translate.SetToTranslation(-25, 20, 0);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[EXPLOSION_4]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[EXPLOSION_4]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 12);
//</explosion>
//<cactus>
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-25, 0, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CACTUS_5]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CACTUS_5]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 13);
model.SetToIdentity();
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(15, -5, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CACTUS_5]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CACTUS_5]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 13);
model.SetToIdentity();
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(7, 5, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CACTUS_5]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CACTUS_5]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 13);
model.SetToIdentity();
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(180, 0, 1, 0);
translate.SetToTranslation(25, 0, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CACTUS_5]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CACTUS_5]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 13);
model.SetToIdentity();
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(180, 0, 1, 0);
translate.SetToTranslation(-15, -5, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CACTUS_5]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CACTUS_5]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 13);
model.SetToIdentity();
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(180, 0, 1, 0);
translate.SetToTranslation(-7, 5, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[CACTUS_5]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[CACTUS_5]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLE_FAN, 0, 13);
//</cactus>
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
}
void SceneText::Render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Mtx44 perspective;
perspective.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 10000.0f);
//perspective.SetToOrtho(-80, 80, -60, 60, -1000, 1000);
projectionStack.LoadMatrix(perspective);
// Camera matrix
viewStack.LoadIdentity();
viewStack.LookAt(
camera.position.x, camera.position.y, camera.position.z,
camera.target.x, camera.target.y, camera.target.z,
camera.up.x, camera.up.y, camera.up.z
);
// Model matrix : an identity matrix (model will be at the origin)
modelStack.LoadIdentity();
if(lights[0].type == Light::LIGHT_DIRECTIONAL)
{
Vector3 lightDir(lights[0].position.x, lights[0].position.y, lights[0].position.z);
Vector3 lightDirection_cameraspace = viewStack.Top() * lightDir;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightDirection_cameraspace.x);
}
else if(lights[0].type == Light::LIGHT_SPOT)
{
Position lightPosition_cameraspace = viewStack.Top() * lights[0].position;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightPosition_cameraspace.x);
Vector3 spotDirection_cameraspace = viewStack.Top() * lights[0].spotDirection;
glUniform3fv(m_parameters[U_LIGHT0_SPOTDIRECTION], 1, &spotDirection_cameraspace.x);
}
else
{
Position lightPosition_cameraspace = viewStack.Top() * lights[0].position;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightPosition_cameraspace.x);
}
if(lights[1].type == Light::LIGHT_DIRECTIONAL)
{
Vector3 lightDir(lights[1].position.x, lights[1].position.y, lights[1].position.z);
Vector3 lightDirection_cameraspace = viewStack.Top() * lightDir;
glUniform3fv(m_parameters[U_LIGHT1_POSITION], 1, &lightDirection_cameraspace.x);
}
else if(lights[1].type == Light::LIGHT_SPOT)
{
Position lightPosition_cameraspace = viewStack.Top() * lights[1].position;
glUniform3fv(m_parameters[U_LIGHT1_POSITION], 1, &lightPosition_cameraspace.x);
Vector3 spotDirection_cameraspace = viewStack.Top() * lights[1].spotDirection;
glUniform3fv(m_parameters[U_LIGHT1_SPOTDIRECTION], 1, &spotDirection_cameraspace.x);
}
else
{
Position lightPosition_cameraspace = viewStack.Top() * lights[1].position;
glUniform3fv(m_parameters[U_LIGHT1_POSITION], 1, &lightPosition_cameraspace.x);
}
RenderMesh(meshList[GEO_AXES], false);
modelStack.PushMatrix();
modelStack.Translate(lights[0].position.x, lights[0].position.y, lights[0].position.z);
RenderMesh(meshList[GEO_LIGHTBALL], false);
modelStack.PopMatrix();
/** crosshair **/
RenderMeshIn2D(meshList[GEO_CROSSHAIR], false);
RenderSkybox();
// perspective;
////perspective.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 10000.0f);
//perspective.SetToOrtho(-80, 80, -60, 60, -1000, 1000);
//projectionStack.LoadMatrix(perspective);
//viewStack.LoadIdentity();
//
//modelStack.PushMatrix();
////modelStack.Translate(20, 0, -20);
////modelStack.Scale(0.1f, 0.1f, 0.1f);
//modelStack.Scale(50, 50, 50);
////RenderMesh(meshList[GEO_QUAD], false);
//RenderText(meshList[GEO_TEXT], "HelloWorld", Color(0, 1, 0));
//modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-20, 0, -20);
RenderMesh(meshList[GEO_OBJECT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(20, 0, -20);
RenderMesh(meshList[GEO_OBJECT], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Scale(10, 10, 10);
//RenderText(meshList[GEO_TEXT], "Hello World", Color(0, 1, 0));
RenderText(meshList[GEO_TEXT], "Hello World", Color(0, 1, 0));
modelStack.PopMatrix();
//On screen text
std::ostringstream ss;
ss.precision(5);
ss << "FPS: " << fps;
RenderTextOnScreen(meshList[GEO_TEXT], ss.str(), Color(0, 1, 0), 3, 0, 6);
std::ostringstream ss1;
ss1.precision(4);
ss1 << "Light(" << lights[0].position.x << ", " << lights[0].position.y << ", " << lights[0].position.z << ")";
RenderTextOnScreen(meshList[GEO_TEXT], ss1.str(), Color(0, 1, 0), 3, 0, 3);
RenderTextOnScreen(meshList[GEO_TEXT], "Hello Screen", Color(0, 1, 0), 3, 0, 0);
}
void OpeningCutScene2::Init()
{
// Init VBO here
// Set background color to dark blue
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//Enable depth buffer and depth testing
glEnable(GL_DEPTH_TEST);
//Enable back face culling
glEnable(GL_CULL_FACE);
//Default to fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Text.fragmentshader");
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
glUseProgram(m_programID);
light[0].type = Light::LIGHT_SPOT;
light[0].position.Set(camera.position.x, camera.position.y, camera.position.z);
light[0].color.Set(1, 1, 1);
light[0].power = 2.0f;
light[0].kC = 1.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
light[0].cosCutoff = cos(Math::DegreeToRadian(30));
light[0].cosInner = cos(Math::DegreeToRadian(15));
light[0].exponent = 3.f;
light[0].spotDirection.Set(-(camera.target.x - camera.position.x), -(camera.target.y - camera.position.y), -(camera.target.z - camera.position.z));
// Pass information
glUniform1i(m_parameters[U_NUMLIGHTS], 1);
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], light[0].cosCutoff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], light[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], light[0].exponent);
//Initialize camera settings
camera.Init(Vector3(0, 10, 0), Vector3(0, 15, 1), Vector3(0, 1, 0));
meshList[GEO_AXES] = MeshBuilder::GenerateAxes("reference", 1000, 1000, 1000);
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSphere("lightball", Color(1, 1, 1), 10, 20);
meshList[GEO_FRONT] = MeshBuilder::GenerateQuad("front", Color(1, 1, 1));
meshList[GEO_FRONT]->textureID = LoadTGA("Image//SkyBox1_front.tga");
meshList[GEO_LEFT] = MeshBuilder::GenerateQuad("left", Color(1, 1, 1));
meshList[GEO_LEFT]->textureID = LoadTGA("Image//SkyBox1_left.tga");
meshList[GEO_RIGHT] = MeshBuilder::GenerateQuad("right", Color(1, 1, 1));
meshList[GEO_RIGHT]->textureID = LoadTGA("Image//SkyBox1_right.tga");
meshList[GEO_TOP] = MeshBuilder::GenerateQuad("top", Color(1, 1, 1));
meshList[GEO_TOP]->textureID = LoadTGA("Image//SkyBox1_up.tga");
meshList[GEO_BOTTOM] = MeshBuilder::GenerateQuad("SkyBox1_down", Color(1, 1, 1));
meshList[GEO_BOTTOM]->textureID = LoadTGA("Image//SkyBox1_down.tga");
meshList[GEO_BACK] = MeshBuilder::GenerateQuad("SkyBox1_back", Color(1, 1, 1));
meshList[GEO_BACK]->textureID = LoadTGA("Image//SkyBox1_back.tga");
meshList[GEO_QUAD] = MeshBuilder::GenerateQuad("SceneOpening", Color(0, 0, 0));
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//calibri.tga");
meshList[GEO_PLANETFLOOR] = MeshBuilder::GenerateQuad("planet floor", Color(1, 1, 1));
meshList[GEO_PLANETFLOOR]->textureID = LoadTGA("Image//PlanetFloor.tga");
meshList[GEO_FACILITYOUT] = MeshBuilder::GenerateOBJ("Facility Outer", "OBJ//FacilityOUT.obj");
meshList[GEO_FACILITYOUT]->textureID = LoadTGA("Image//FacilityOUT.tga");
meshList[GEO_FACILITYOUTWALL] = MeshBuilder::GenerateQuad("FacilityOUT wall", Color(1, 1, 1));
meshList[GEO_FACILITYOUTWALL]->textureID = LoadTGA("Image//OutsideWALL.tga");
meshList[GEO_DEADBODY] = MeshBuilder::GenerateOBJ("Pile of dead body", "OBJ//DeadBody.obj");
meshList[GEO_DEADBODY]->textureID = LoadTGA("Image//DeadBody.tga");
Mtx44 projection;
projection.SetToPerspective(45.f, 16.f / 9.f, 0.1f, 10000.f);
projectionStack.LoadMatrix(projection);
rotateCamX = false;
MoveCamera1 = 0;
camera_check1 = true;
camera_check2 = false;
camera_check3 = false;
rotateCamY = false;
RotateCamera = 0;
wokeUp = true;
check1 = true;
check2 = false;
check3 = false;
eyeOpening = 0;
text1 = false;
text2 = false;
// All Switches Debounce Key
}
void Helicopter::Update(double dt, bool controlling)
{
static const float THRUST_SPEED = 10.f;
static const float THRUST_LIMIT = 5.f;
static const float TURN_SPEED = 100.f;
bool piloting = false;
if (controlling) {
if (Application::IsKeyPressed('W'))
{
if (thrustSpeed < THRUST_LIMIT)
thrustSpeed += (float)(THRUST_SPEED * dt);
piloting = true;
}
if (Application::IsKeyPressed('S'))
{
if (thrustSpeed > -THRUST_LIMIT)
thrustSpeed -= (float)(THRUST_SPEED * dt);
piloting = true;
}
if (Application::IsKeyPressed('A'))
{
float yaw = (float)(TURN_SPEED * dt);
rotateYaw += yaw;
camera.Rotate(yaw, 0, 1, 0);
Mtx44 rotate;
rotate.SetToRotation(yaw, 0, 1, 0);
thrustDir = rotate * thrustDir;
frontDir = rotate * frontDir;
right = rotate * right;
}
if (Application::IsKeyPressed('D'))
{
float yaw = (float)(-TURN_SPEED * dt);
rotateYaw += yaw;
camera.Rotate(yaw, 0, 1, 0);
Mtx44 rotate;
rotate.SetToRotation(yaw, 0, 1, 0);
thrustDir = rotate * thrustDir;
frontDir = rotate * frontDir;
right = rotate * right;
}
if (Application::IsKeyPressed(VK_NUMPAD8))
{
float pitch = (float)(-TURN_SPEED * dt);
rotatePitch += pitch;
//camera.Rotate(pitch, right.x, right.y, right.z);
Mtx44 rotate;
rotate.SetToRotation(pitch, right.x, right.y, right.z);
thrustDir = rotate * thrustDir;
frontDir = rotate * frontDir;
std::cout << frontDir << std::endl;
}
if (Application::IsKeyPressed(VK_NUMPAD5))
{
float pitch = (float)(TURN_SPEED * dt);
rotatePitch += pitch;
//camera.Rotate(pitch, right.x, right.y, right.z);
Mtx44 rotate;
rotate.SetToRotation(pitch, right.x, right.y, right.z);
thrustDir = rotate * thrustDir;
frontDir = rotate * frontDir;
}
if (Application::IsKeyPressed(VK_NUMPAD4))
{
float roll = (float)(-TURN_SPEED * dt);
rotateRoll += roll;
Mtx44 rotate;
rotate.SetToRotation(roll, frontDir.x, frontDir.y, frontDir.z);
thrustDir = rotate * thrustDir;
right = rotate * right;
}
if (Application::IsKeyPressed(VK_NUMPAD6))
{
float roll = (float)(TURN_SPEED * dt);
rotateRoll += roll;
Mtx44 rotate;
rotate.SetToRotation(roll, frontDir.x, frontDir.y, frontDir.z);
thrustDir = rotate * thrustDir;
right = rotate * right;
}
}
if (!piloting) {
if (thrustSpeed > 0.f) {
thrustSpeed -= (float)(THRUST_SPEED * dt);
}
else if (thrustSpeed < 0.f) {
thrustSpeed += (float)(THRUST_SPEED * dt);
}
}
frontDir.Normalize();
right.Normalize();
thrustDir.Normalize();
Vector3 oldPos = position;
vSpeed += ((thrustDir.y * thrustSpeed) - WV_GRAVITY) * dt;
xSpeed += ((thrustDir.x * thrustSpeed)) * dt;
zSpeed += ((thrustDir.z * thrustSpeed)) * dt;
position.x += xSpeed * dt;
position.z += zSpeed * dt;
position.y += vSpeed * dt;
hitbox.SetPosition(position);
if (Hitbox::CheckHitBox(hitbox, position, oldPos, &hitbox)) {
vSpeed = 0.f;
xSpeed = 0.f;
zSpeed = 0.f;
}
camera.target = position;
camera.Update(dt);
}
void MS::Translate(float translateX, float translateY, float translateZ) {
Mtx44 mat;
mat.SetToTranslation(translateX, translateY, translateZ);
ms.top() = ms.top() * mat;
}
MS::MS() {
Mtx44 mat;
mat.SetToIdentity();
ms.push(mat);
}
void MS::Rotate(float degrees, float axisX, float axisY, float axisZ) {
Mtx44 mat;
mat.SetToRotation(degrees, axisX, axisY, axisZ);
ms.top() = ms.top() * mat;
}
void MS::Scale(float scaleX, float scaleY, float scaleZ) {
Mtx44 mat;
mat.SetToScale(scaleX, scaleY, scaleZ);
ms.top() = ms.top() * mat;
}
void Assignment1::Render()
{
// Clear color buffer & depth every frame
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Mtx44 translate, rotate, scale;
Mtx44 model;
Mtx44 view;
Mtx44 projection;
Mtx44 MVP;
translate.SetToIdentity();
rotate.SetToIdentity();
scale.SetToIdentity();
model.SetToIdentity();
view.SetToIdentity(); // no need camera for now, set it at World's origin
projection.SetToOrtho(-40, +40, -30, +30, -10, +10); // Our world is a cube defined by these boundaries
glEnableVertexAttribArray(0); // 1st attribute buffer : vertices
glEnableVertexAttribArray(1); // 2nd attribute buffer : colors
////////////////////This Section Places the Objects////////////////////
//Ground();
{
scale.SetToScale(50, 50, 50);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-40, -48, -1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Rectangle
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
scale.SetToScale(50, 50, 50);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-40, -60, -0);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_BLUECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Rectangle
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
/////////////////////////////////////////////////////////////////////////////////
//Mountains();
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-40, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(6, 6, 6);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-36, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-32, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
//Mountains();
scale.SetToScale(8, 8, 8);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-30, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(7, 7, 7);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-25, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-18,-9 , -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(9, 9, 9);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-16, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-3, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(7, 7, 7);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(3, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(4, 4, 4);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(12, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(8, 8, 8);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(17, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(28, -9, -2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Tower HP bar
scale.SetToScale(3, 3, 3);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(29, -23, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_LINE_LOOP, 0, 4);
//till here
scale.SetToScale(3, 3, 3);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(29, -23, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_REDCOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//till here
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//Tower 1
scale.SetToScale(6, 6, 6);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(8, -20, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TOWER]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
//till here
scale.SetToScale(3, 3, 3);
rotate.SetToRotation(62, 0, 0, 1);
translate.SetToTranslation(11, -6, 3);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_REDCOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
//till here
scale.SetToScale(2, 2, 2);
rotate.SetToRotation(62, 0, 0, 1);
translate.SetToTranslation(11, -6, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
//till here
scale.SetToScale(6, 6, 6);
rotate.SetToRotation(90, 0, 0, 1);
translate.SetToTranslation(16, -19, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TOWER]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//till here
scale.SetToScale(6, 2, 6);
rotate.SetToRotation(225, 0, rotateAngle, 1);
translate.SetToTranslation(10, -2.5, 0);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_REDCOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
scale.SetToScale(6, 6, 0);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(14, 0, 3);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_CIRCLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_CIRCLE]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 36);
//till here
////////////////////////////////////////////////////////////////////////////////////////////////////
//Tower 2
scale.SetToScale(6, 6, 6);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(28, -20, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TOWER]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
//till here
scale.SetToScale(6, 6, 6);
rotate.SetToRotation(90, 0, 0, 1);
translate.SetToTranslation(35, -19, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TOWER]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//till here
scale.SetToScale(6, 6, 6);
rotate.SetToRotation(90, 0, 0, 1);
translate.SetToTranslation(38, -19, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TOWER]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
scale.SetToScale(3, 3, 3);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(33, -2, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TOWER]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(3, 3, 3);
rotate.SetToRotation(180 , 0, 0, 1);
translate.SetToTranslation(37, -10, 2);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_REDCOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(1.5, 1.5, 1.5);
rotate.SetToRotation(180, 0, 0, 1);
translate.SetToTranslation(35.5, -11, 3);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_YELLOWCOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(1, 1, 1);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(35.1, -10, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
scale.SetToScale(1, 1, 1);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(31, -10, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLES, 0, 3);
/////////////////////////////////////////////////////////////////////////
//Stickman()
scale.SetToScale(5, 5, 5);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-25, -15, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_STICKMAN]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_REDCOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_LINE_LOOP, 0, 20);
scale.SetToScale(2, 2, 0);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-25, -13, 5);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_CIRCLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_CIRCLE]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 36);
//till here
//Magic arrows
scale.SetToScale(1, 1, 6);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(translateX, -15.5, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_BLUECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
scale.SetToScale(1, 1, 6);
rotate.SetToRotation(270, 0, 0, 1);
translate.SetToTranslation(translateX, -14, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_BLUECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
scale.SetToScale(1, 1, 6);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(translateX, -13.5, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_RECTANGLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_BLUECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
scale.SetToScale(1, 1, 6);
rotate.SetToRotation(270, 0, 0, 1);
translate.SetToTranslation(translateX, -12, 1);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_MOUNTAINS]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_BLUECOLOR]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
//Clouds
scale.SetToScale(3,3, 0);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-7, 15, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_WHITECIRCLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECIRCLE]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 36);
//till here
scale.SetToScale(3, 3, 0);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-10, 15, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_WHITECIRCLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECIRCLE]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 36);
//till here
scale.SetToScale(3, 3, 0);
rotate.SetToRotation(0, 0, 0, 1);
translate.SetToTranslation(-4, 15, 4);
model = translate * rotate * scale;
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); // update the shader with new MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_WHITECIRCLE]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_WHITECIRCLE]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Draw the Triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 36);
//till here
/*---------------------------------------------------------------------------------------------------------*/
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(0);
}
void SceneText::Init()
{
// Load vertex and fragment shaders
m_programID = LoadShaders(
"Shader//Texture.vertexshader",
"Shader//Text.fragmentshader"
);
// Get a handle for our "MVP" uniform
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
// Use our shader
glUseProgram(m_programID);
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Enable culling
glEnable(GL_CULL_FACE);
// Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
Mtx44 projection;
projection.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 2000.0f);
projectionStack.LoadMatrix(projection);
// Set background color to dark blue
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
camera.Init(Vector3(0, 0, 10), Vector3(0, 0, 0), Vector3(0, 1, 0));
//MESH GENERATORS
meshList[GEO_AXES] = MeshBuilder::GenerateAxes("axis", 1000, 1000, 1000);
meshList[GEO_FRONT] = MeshBuilder::GenerateQuad("front", Color(1, 1, 1));
meshList[GEO_FRONT]->textureID = LoadTGA("Image//front.tga");
meshList[GEO_BACK] = MeshBuilder::GenerateQuad("back", Color(1, 1, 1));
meshList[GEO_BACK]->textureID = LoadTGA("Image//back.tga");
meshList[GEO_LEFT] = MeshBuilder::GenerateQuad("left", Color(1, 1, 1));
meshList[GEO_LEFT]->textureID = LoadTGA("Image//left.tga");
meshList[GEO_RIGHT] = MeshBuilder::GenerateQuad("right", Color(1, 1, 1));
meshList[GEO_RIGHT]->textureID = LoadTGA("Image//right.tga");
meshList[GEO_TOP] = MeshBuilder::GenerateQuad("top", Color(1, 1, 1));
meshList[GEO_TOP]->textureID = LoadTGA("Image//top.tga");
meshList[GEO_BOTTOM] = MeshBuilder::GenerateQuad("bottom", Color(1, 1, 1));
meshList[GEO_BOTTOM]->textureID = LoadTGA("Image//bottom.tga");
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSphere("sphere", Color(1, 1, 1));
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//calibri.tga");
//meshList[GEO_MODEL1] = MeshBuilder::GenerateOBJ("model1", "OBJ//chair.obj");
//meshList[GEO_MODEL1]->textureID = LoadTGA("Image//chair.tga");
//meshList[GEO_MODEL2] = MeshBuilder::GenerateOBJ("model2", "OBJ//dart.obj");
//meshList[GEO_MODEL2]->textureID = LoadTGA("Image//dart.tga");
//meshList[GEO_MODEL3] = MeshBuilder::GenerateOBJ("model3", "OBJ//dartboard.obj");
//meshList[GEO_MODEL3]->textureID = LoadTGA("Image//dartboard.tga");
//meshList[GEO_MODEL4] = MeshBuilder::GenerateOBJ("model4", "OBJ//doorman.obj");
//meshList[GEO_MODEL4]->textureID = LoadTGA("Image//doorman.tga");
//meshList[GEO_MODEL5] = MeshBuilder::GenerateOBJ("model5", "OBJ//shoe.obj");
//meshList[GEO_MODEL5]->textureID = LoadTGA("Image//shoe.tga");
//meshList[GEO_MODEL6] = MeshBuilder::GenerateOBJ("model6", "OBJ//winebottle.obj");
//meshList[GEO_MODEL6]->textureID = LoadTGA("Image//winebottle.tga");
meshList[GEO_VEHICLE_SPACE_AIR] = MeshBuilder::GenerateOBJ("model_air", "OBJ//vehicle_space_air.obj");
//meshList[GEO_VEHICLE_SPACE_AIR]->textureID = LoadTGA("Image//chair.tga");
meshList[GEO_VEHICLE_SPACE_LAND] = MeshBuilder::GenerateOBJ("model_land", "OBJ//vehicle_space_land.obj");
//meshList[GEO_VEHICLE_SPACE_LAND]->textureID = LoadTGA("Image//chair.tga");
//setting up light object
light[0].type = Light::LIGHT_POINT;
light[0].position.Set(0, 20, 0);
light[0].color.Set(1, 1, 1);
light[0].power = 1;
light[0].kC = 1.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
light[0].cosCutoff = cos(Math::DegreeToRadian(45));
light[0].cosInner = cos(Math::DegreeToRadian(30));
light[0].exponent = 3.f;
light[0].spotDirection.Set(0.f, 1.f, 0.f);
//pass uniform parameters ( MUST BE AFTER glUseProgram() )
glUniform1i(m_parameters[U_NUMLIGHTS], 1);
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], light[0].cosCutoff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], light[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], light[0].exponent);
//Initializing transforming matrices
readyToUse = 2.f;
enableLight = true;
}
void MS::Perspective(double fovy, double aspect, double zNear, double zFar) {
Mtx44 mat;
mat.SetToPerspective(fovy, aspect, zNear, zFar);
ms.top() = ms.top() * mat;
}
void SecurityCam::update(const double &dt, Vector3 &playerPos, std::vector<GameObject*> m_goList)
{
Vector3 SCPos = pos;
Vector3 SCLookat = Lookat;
SCPos.y = SCLookat.y = 0;
switch(c_State)
{
case SPOTTED:
{
float rotationdiff = (CalAnglefromPosition(playerPos, pos, true) - CalAnglefromPosition(Lookat, pos, true)) * 2.f;
Mtx44 rotation;
Lookat = Lookat - pos;
f_rotationLimiter += rotationdiff * static_cast<float>(dt);
rotation.SetToRotation(rotationdiff * static_cast<float>(dt), 0, 1, 0);
Lookat = rotation * Lookat;
Lookat = Lookat + pos;
//Check whether player is still in the fov of security camera
if (((isVisible(SCPos, SCLookat, static_cast<float>(f_cameraFOV), playerPos)) && (SCPos - playerPos).LengthSquared() < f_cameraRange))
{
//Give player 1 sec to prevent detection by the security camera
if (alerttimer < 1)
{
alerttimer += static_cast<float>(dt);
}
else
{
c_State = FOUND;
alerttimer = 0;
}
}
else
{
//if player is no longer in the fov of the security camera
c_State = NOTFOUND;
alerttimer = 0;
}
}
break;
case FOUND:
{
float rotationdiff = (CalAnglefromPosition(playerPos, pos, true) - CalAnglefromPosition(Lookat, pos, true));
if (rotationdiff >= 180)
{
Mtx44 rotation;
Lookat = Lookat - pos;
rotation.SetToRotation(-360, 0, 1, 0);
Lookat = rotation * Lookat;
Lookat = Lookat + pos;
rotationdiff -= 360;
}
else if (rotationdiff <= -180)
{
Mtx44 rotation;
Lookat = Lookat - pos;
rotation.SetToRotation(360, 0, 1, 0);
Lookat = rotation * Lookat;
Lookat = Lookat + pos;
rotationdiff += 360;
}
Mtx44 rotation;
Lookat = Lookat - pos;
f_rotationLimiter += rotationdiff * static_cast<float>(dt);
rotation.SetToRotation(rotationdiff * 2 * static_cast<float>(dt), 0, 1, 0);
Lookat = rotation * Lookat;
Lookat = Lookat + pos;
//Alert all the ai to the camera's position
if (b_alertAI)
{
for (std::vector<GameObject*>::iterator it = m_goList.begin(); it != m_goList.end(); it++)
{
GameObject *go = (GameObject *)*it;
AI *ai = dynamic_cast<AI*>(go);
if (ai != NULL)
{
if (ai->getState() == AI::WALKING)
{
ai->setState(AI::ALERT);
ai->setcurrentLookat(pos);
ai->setDestination(pos);
}
}
}
b_alertAI = false;
}
else
{
if (!isVisible(pos, Lookat, f_cameraFOV, playerPos) || (playerPos - pos).LengthSquared() > f_cameraRange)
{
c_State = NOTFOUND;
}
}
}
break;
case NOTFOUND:
{
//Check whether enemy is within security camera's FOV
b_alertAI = true;
if (((isVisible(SCPos, SCLookat, static_cast<float>(f_cameraFOV), playerPos)) && (SCPos - playerPos).LengthSquared() < f_cameraRange))
{
c_State = SPOTTED;
}
}
break;
}
if (c_State == NOTFOUND)
{
float f_currentRotation = 0;
if (rotationState)
{
f_currentRotation = 20;
if (f_rotationLimiter > f_rotationAngle)
{
rotationState = false;
}
}
else
{
f_currentRotation = -20;
if (f_rotationLimiter < -f_rotationAngle)
{
rotationState = true;
}
}
if (f_currentRotation != 0)
{
Mtx44 rotation;
Lookat = Lookat - pos;
f_rotationLimiter += f_currentRotation * static_cast<float>(dt);
rotation.SetToRotation(f_currentRotation * static_cast<float>(dt), 0, 1, 0);
Lookat = rotation * Lookat;
Lookat = Lookat + pos;
}
}
//CollisionChecking(m_goList);
}
void MS::Scale(Vector3 scaleFactor) {
Mtx44 mat;
mat.SetToScale(scaleFactor.x, scaleFactor.y, scaleFactor.z);
ms.top() = ms.top() * mat;
}
void Camera3::Update(double dt)
{
static const float CAMERA_LOOK_SPEED = 200.f;
static const float CAMERA_MOVE_SPEED = 100.f;
if(Application::IsKeyPressed('A'))
{
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
position -= right * CAMERA_MOVE_SPEED * (float)dt;
target -= right * CAMERA_MOVE_SPEED * (float)dt;
}
if(Application::IsKeyPressed('D'))
{
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
position += right * CAMERA_MOVE_SPEED * (float)dt;
target += right * CAMERA_MOVE_SPEED * (float)dt;
}
if(Application::IsKeyPressed('W'))
{
Vector3 view = (target - position).Normalized();
position += view * CAMERA_MOVE_SPEED * (float)dt;
target += view * CAMERA_MOVE_SPEED * (float)dt;
}
if(Application::IsKeyPressed('S'))
{
Vector3 view = (target - position).Normalized();
position -= view * CAMERA_MOVE_SPEED * (float)dt;
target -= view * CAMERA_MOVE_SPEED * (float)dt;
}
if(Application::IsKeyPressed(VK_LEFT))
{
Vector3 view = (target - position).Normalized();
float yaw = (float)(CAMERA_MOVE_SPEED * (float)dt);
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
}
if(Application::IsKeyPressed(VK_RIGHT))
{
Vector3 view = (target - position).Normalized();
float yaw = (float)(-CAMERA_MOVE_SPEED * (float)dt);
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
}
if(Application::IsKeyPressed(VK_UP))
{
float pitch = (float)(CAMERA_MOVE_SPEED * (float)dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
if(Application::IsKeyPressed(VK_DOWN))
{
float pitch = (float)(-CAMERA_MOVE_SPEED * (float)dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
//Update the camera direction based on mouse move
// left-right rotate
{
Vector3 view = (target - position).Normalized();
float yaw = (float)(-CAMERA_LOOK_SPEED * Application::camera_yaw * (float)dt);
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
view = rotation * view;
target = position + view;
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
}
{
float pitch = (float)(-CAMERA_LOOK_SPEED * Application::camera_pitch * (float)dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
view = rotation * view;
target = position + view;
}
if(Application::IsKeyPressed('R'))
{
Reset();
}
}
void MS::Frustum(double left, double right, double bottom, double top, double near, double far) {
Mtx44 mat;
mat.SetToFrustum(left, right, bottom, top, near, far);
ms.top() = ms.top() * mat;
}
void CSceneManager2D::Init()
{
// Blue background
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
// Switch on culling
glEnable(GL_CULL_FACE);
// Render mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Activate blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Generate and bind vertex array
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
// Load the shaders
m_programID = LoadShaders( "Shader//Texture.vertexshader", "Shader//Text.fragmentshader" );
// Get a handle for our uniform
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
//m_parameters[U_MODEL] = glGetUniformLocation(m_programID, "M");
//m_parameters[U_VIEW] = glGetUniformLocation(m_programID, "V");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
// Get a handle for our "textColor" uniform
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
// Use our shader
glUseProgram(m_programID);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
// Initialise the camera
camera.Init(Vector3(0, 0, 10), Vector3(0, 0, 0), Vector3(0, 1, 0));
// Create the meshes
for(int i = 0; i < NUM_GEOMETRY; ++i)
{
meshList[i] = NULL;
}
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//calibri.tga");
meshList[GEO_TEXT]->material.kAmbient.Set(1, 0, 0);
// Load the ground mesh and texture
meshList[GEO_BACKGROUND] = MeshBuilder::Generate2DMesh("GEO_BACKGROUND", Color(1, 1, 1), 0, 0, 800, 600);
meshList[GEO_BACKGROUND]->textureID = LoadTGA("Image//sky_background.tga");
meshList[GEO_TILEGROUND] = MeshBuilder::Generate2DMesh("GEO_TILEGROUND", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEGROUND]->textureID = LoadTGA("Image//tile1_ground.tga");
meshList[GEO_TILEHERO] = MeshBuilder::Generate2DMesh("GEO_TILEHERO", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEHERO]->textureID = LoadTGA("Image//tile2_hero.tga");
meshList[GEO_TILETREE] = MeshBuilder::Generate2DMesh("GEO_TILETREE", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILETREE]->textureID = LoadTGA("Image//tile3_tree.tga");
meshList[GEO_TILESTRUCTURE] = MeshBuilder::Generate2DMesh("GEO_TILESTRUCTURE", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILESTRUCTURE]->textureID = LoadTGA("Image//tile3_structure.tga");
meshList[GEO_TILEHERO_FRAME0] = MeshBuilder::Generate2DMesh("GEO_TILEHERO_FRAME0", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEHERO_FRAME0]->textureID = LoadTGA("Image//tile2_hero_frame_0.tga");
meshList[GEO_TILEHERO_FRAME1] = MeshBuilder::Generate2DMesh("GEO_TILEHERO_FRAME1", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEHERO_FRAME1]->textureID = LoadTGA("Image//tile2_hero_frame_1.tga");
meshList[GEO_TILEHERO_FRAME2] = MeshBuilder::Generate2DMesh("GEO_TILEHERO_FRAME2", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEHERO_FRAME2]->textureID = LoadTGA("Image//tile2_hero_frame_2.tga");
meshList[GEO_TILEHERO_FRAME3] = MeshBuilder::Generate2DMesh("GEO_TILEHERO_FRAME3", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEHERO_FRAME3]->textureID = LoadTGA("Image//tile2_hero_frame_3.tga");
meshList[GEO_TILE_KILLZONE] = MeshBuilder::Generate2DMesh("GEO_TILE_KILLZONE", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILE_KILLZONE]->textureID = LoadTGA("Image//tile10_killzone.tga");
meshList[GEO_TILE_SAFEZONE] = MeshBuilder::Generate2DMesh("GEO_TILE_SAFEZONE", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILE_SAFEZONE]->textureID = LoadTGA("Image//tile11_safezone.tga");
meshList[GEO_TILEENEMY_FRAME0] = MeshBuilder::Generate2DMesh("GEO_TILEENEMY_FRAME0", Color(1, 1, 1), 0, 0, 25, 25);
meshList[GEO_TILEENEMY_FRAME0]->textureID = LoadTGA("Image//tile20_enemy.tga");
meshList[GEO_MENU] = MeshBuilder::Generate2DMesh("GEO_MENU", Color(1, 1, 1), 0, 0, 800, 600);
meshList[GEO_MENU]->textureID = LoadTGA("Image//MainMenu.tga");
meshList[GEO_HIGHSCORE] = MeshBuilder::Generate2DMesh("GEO_HIGHSCORE", Color(1, 1, 1), 0, 0, 800, 600);
meshList[GEO_HIGHSCORE]->textureID = LoadTGA("Image//Highscore.tga");
meshList[GEO_OPTION1] = MeshBuilder::Generate2DMesh("GEO_OPTION1", Color(1, 1, 1), 0, 0, 800, 600);
meshList[GEO_OPTION1]->textureID = LoadTGA("Image//OptionsSoundOn.tga");
meshList[GEO_INSTRUCTION] = MeshBuilder::Generate2DMesh("GEO_INSTRUCTIONS", Color(1, 1, 1), 0, 0, 800, 600);
meshList[GEO_INSTRUCTION]->textureID = LoadTGA("Image//Instructions.tga");
meshList[GEO_SELECT] = MeshBuilder::Generate2DMesh("GEO_SELECT", Color(1, 1, 1), 0, 0, 75, 55);
meshList[GEO_SELECT]->textureID = LoadTGA("Image//Select.tga");
meshList[GEO_SPRITE_ANIMATION] = MeshBuilder::GenerateSpriteAnimation("cat", 1, 6);
meshList[GEO_SPRITE_ANIMATION]->textureID = LoadTGA("Image//cat.tga");
m_spriteAnimation = dynamic_cast<SpriteAnimation*>(meshList[GEO_SPRITE_ANIMATION]);
if (m_spriteAnimation)
{
m_spriteAnimation->m_anim = new Animation();
m_spriteAnimation->m_anim->Set(0, 5, 0, 0.1f);
}
/*
// Initialise and load the tile map
m_cMap = new CMap();
m_cMap->Init( 600, 800, 24, 32, 600, 1600 );
m_cMap->LoadMap( "Image//MapDesign.csv" );
// Initialise and load the REAR tile map
m_cRearMap = new CMap();
m_cRearMap->Init( 600, 800, 24, 32, 600, 1600 );
m_cRearMap->LoadMap( "Image//MapDesign_Rear.csv" );
// Initialise the hero's position
theHero = new CPlayerInfo();
theHero->SetPos_x(50);
theHero->SetPos_y(100);
// Load the texture for minimap
m_cMinimap = new CMinimap();
m_cMinimap->SetBackground(MeshBuilder::GenerateMinimap("MINIMAP", Color(1, 1, 1), 1.f));
m_cMinimap->GetBackground()->textureID = LoadTGA("Image//grass_darkgreen.tga");
m_cMinimap->SetBorder( MeshBuilder::GenerateMinimapBorder("MINIMAPBORDER", Color(1, 1, 0), 1.f) );
m_cMinimap->SetAvatar( MeshBuilder::GenerateMinimapAvatar("MINIMAPAVATAR", Color(1, 1, 0), 1.f) );
// Set the strategy for the enemy
theEnemy = new CEnemy();
theEnemy->ChangeStrategy( NULL, false);
theEnemy->SetPos_x(575);
theEnemy->SetPos_y(100);
theArrayOfGoodies = new CGoodies*[10];
for (int i=0; i<10; i++)
{
theArrayOfGoodies[i] = theGoodiesFactory.Create( TREASURECHEST );
theArrayOfGoodies[i]->SetPos( 150 + i*25, 150 );
theArrayOfGoodies[i]->SetMesh(MeshBuilder::Generate2DMesh("GEO_TILE_TREASURECHEST", Color(1, 1, 1), 0, 0, 25, 25));
theArrayOfGoodies[i]->SetTextureID(LoadTGA("Image//tile4_treasurechest.tga"));
}
*/
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 1000 units
Mtx44 perspective;
perspective.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 10000.0f);
//perspective.SetToOrtho(-80, 80, -60, 60, -1000, 1000);
projectionStack.LoadMatrix(perspective);
rotateAngle = 0;
m_save = new Save();
m_player = new Player();
m_player->PlayerInit("Player.lua");
//initailise grid system
Playfield = new GridSystem();
// in this order: position of the whole grid system, size of grid x, size of grid y, number of grid x, number of grid y
Playfield->Init(Vector3(400, 300, 0), 25.f, 25.f, 5, 5);
AddHighscore();
}
void MS::LoadIdentity() {
Mtx44 mat;
mat.SetToIdentity();
ms.top() = mat;
}
void SceneSkyBox::Init()
{
// Init VBO here
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Set background color
glEnable(GL_DEPTH_TEST); // Enable depth buffer and depth testing
glEnable(GL_CULL_FACE); // Enable back face culling
glEnable(GL_BLEND); //Enable Blending
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Default to fill mode
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Blending.fragmentshader");
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights"); //in case you missed out practical 7
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
glUseProgram(m_programID);
//variable to rotate geometry
//Initialize camera settings
camera.Init(Vector3(4, 3, 3), Vector3(0, 0, 0), Vector3(0, 1, 0));
meshList[GEO_AXES] = MeshBuilder::GenerateAxes("AXES", 1000, 1000, 1000);
Mtx44 projection;
projection.SetToPerspective(45.f, 4.f / 3.f, 0.1f, 1000.f);
projectionStack.LoadMatrix(projection);
light[0].position.Set(0, 20, 0);
light[0].color.Set(1, 1, 1);
light[0].power = 1;
light[0].kC = 1.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
// Make sure you pass uniform parameters after glUseProgram()
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1i(m_parameters[U_NUMLIGHTS], 1);
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSphere("LIGHT", Color(1, 1, 1), 36, 36);
meshList[GEO_QUAD] = MeshBuilder::GenerateQuad("quad", Color(1, 1, 1));
meshList[GEO_QUAD]->textureID = LoadTGA("Image//color2.tga");
//Front
meshList[GEO_FRONT] = MeshBuilder::GenerateQuad("front", Color(1, 1, 1));
meshList[GEO_FRONT]->textureID = LoadTGA("Image//blizzardfront.tga");
//Back
meshList[GEO_BACK] = MeshBuilder::GenerateQuad("back", Color(1, 1, 1));
meshList[GEO_BACK]->textureID = LoadTGA("Image//blizzardback.tga");
//Left
meshList[GEO_LEFT] = MeshBuilder::GenerateQuad("left", Color(1, 1, 1));
meshList[GEO_LEFT]->textureID = LoadTGA("Image//blizzardright.tga");
//Right
meshList[GEO_RIGHT] = MeshBuilder::GenerateQuad("right", Color(1, 1, 1));
meshList[GEO_RIGHT]->textureID = LoadTGA("Image//blizzardleft.tga");
//Top
meshList[GEO_TOP] = MeshBuilder::GenerateQuad("top", Color(1, 1, 1));
meshList[GEO_TOP]->textureID = LoadTGA("Image//blizzardtop.tga");
//Bottom
meshList[GEO_BOTTOM] = MeshBuilder::GenerateQuad("quad", Color(1, 1, 1));
meshList[GEO_BOTTOM]->textureID = LoadTGA("Image//blizzardbottom.tga");
//Mario Jumpman Mario
meshList[GEO_MARIO] = MeshBuilder::GenerateQuad("Mario", Color(1, 1, 1));
meshList[GEO_MARIO]->textureID = LoadTGA("Image//Mario.tga");
}
void SceneGalaxy::Init()
{
//// Init VBO here
//// Set background color to dark blue
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//Enable depth buffer and depth testing
glEnable(GL_DEPTH_TEST);
//Enable back face culling
glEnable(GL_CULL_FACE);
//Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Default to fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
//Load vertex and fragment shaders
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Text.fragmentshader");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_LIGHT1_POSITION] = glGetUniformLocation(m_programID, "lights[1].position_cameraspace");
m_parameters[U_LIGHT1_COLOR] = glGetUniformLocation(m_programID, "lights[1].color");
m_parameters[U_LIGHT1_POWER] = glGetUniformLocation(m_programID, "lights[1].power");
m_parameters[U_LIGHT1_KC] = glGetUniformLocation(m_programID, "lights[1].kC");
m_parameters[U_LIGHT1_KL] = glGetUniformLocation(m_programID, "lights[1].kL");
m_parameters[U_LIGHT1_KQ] = glGetUniformLocation(m_programID, "lights[1].kQ");
m_parameters[U_LIGHT1_TYPE] = glGetUniformLocation(m_programID, "lights[1].type");
m_parameters[U_LIGHT1_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[1].spotDirection");
m_parameters[U_LIGHT1_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[1].cosCutoff");
m_parameters[U_LIGHT1_COSINNER] = glGetUniformLocation(m_programID, "lights[1].cosInner");
m_parameters[U_LIGHT1_EXPONENT] = glGetUniformLocation(m_programID, "lights[1].exponent");
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
// Get a handle for our "textColor" uniform
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
glUseProgram(m_programID);
glUniform1i(m_parameters[U_NUMLIGHTS], 2);
light[0].type = Light::LIGHT_SPOT;
light[0].position.Set(-5, 2, -10);
light[0].color.Set(1, 1, 1);
light[0].power = 1;
light[0].kC = 1.f;
light[0].kL = 0.01f;
light[0].kQ = 0.01f;
light[0].cosCutoff = cos(Math::DegreeToRadian(45));
light[0].cosInner = cos(Math::DegreeToRadian(30));
light[0].exponent = 3.f;
light[0].spotDirection.Set(0.f, 1.f, 0.f);
light[1].type = Light::LIGHT_DIRECTIONAL;
light[1].position.Set(2, 2, 0);
light[1].color.Set(1, 1, 1);
light[1].power = 1;
light[1].kC = 1.f;
light[1].kL = 0.01f;
light[1].kQ = 0.01f;
light[1].cosCutoff = cos(Math::DegreeToRadian(45));
light[1].cosInner = cos(Math::DegreeToRadian(30));
light[1].exponent = 3.f;
light[1].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], light[0].cosCutoff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], light[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], light[0].exponent);
glUniform1i(m_parameters[U_LIGHT1_TYPE], light[1].type);
glUniform3fv(m_parameters[U_LIGHT1_COLOR], 1, &light[1].color.r);
glUniform1f(m_parameters[U_LIGHT1_POWER], light[1].power);
glUniform1f(m_parameters[U_LIGHT1_KC], light[1].kC);
glUniform1f(m_parameters[U_LIGHT1_KL], light[1].kL);
glUniform1f(m_parameters[U_LIGHT1_KQ], light[1].kQ);
glUniform1f(m_parameters[U_LIGHT1_COSCUTOFF], light[1].cosCutoff);
glUniform1f(m_parameters[U_LIGHT1_COSINNER], light[1].cosInner);
glUniform1f(m_parameters[U_LIGHT1_EXPONENT], light[1].exponent);
//Initialize camera settings
camera.Init(Vector3(0, 500, 0), Vector3(0, 500, -600), Vector3(0, 1, 0));
meshList[GEO_AXES] = MeshBuilder::GenerateAxes("reference", 1000, 1000, 1000);
meshList[GEO_CUBE] = MeshBuilder::GenerateCube("reference", Color(0, 0, 0));
meshList[GEO_QUAD] = MeshBuilder::GenerateQuad("quad", Color(1, 1, 1));
meshList[GEO_GALAXYFRONT] = MeshBuilder::GenerateQuad("front", Color(1, 1, 1));
meshList[GEO_GALAXYFRONT]->textureID = LoadTGA("Image//NebulaFront.tga");
meshList[GEO_GALAXYBACK] = MeshBuilder::GenerateQuad("back", Color(1, 1, 1));
meshList[GEO_GALAXYBACK]->textureID = LoadTGA("Image//NebulaLeft.tga");
meshList[GEO_GALAXYTOP] = MeshBuilder::GenerateQuad("top", Color(1, 1, 1));
meshList[GEO_GALAXYTOP]->textureID = LoadTGA("Image//NebulaTop_Kai.tga");
meshList[GEO_GALAXYBOTTOM] = MeshBuilder::GenerateQuad("bottom", Color(1, 1, 1));
meshList[GEO_GALAXYBOTTOM]->textureID = LoadTGA("Image//NebulaBottom_Kai.tga");
meshList[GEO_GALAXYLEFT] = MeshBuilder::GenerateQuad("left", Color(1, 1, 1));
meshList[GEO_GALAXYLEFT]->textureID = LoadTGA("Image//NebulaBack_Kai.tga");
meshList[GEO_GALAXYRIGHT] = MeshBuilder::GenerateQuad("right", Color(1, 1, 1));
meshList[GEO_GALAXYRIGHT]->textureID = LoadTGA("Image//NebulaRight.tga");
meshList[GEO_XWING] = MeshBuilder::GenerateOBJ("xwing", "OBJ//XWing.obj");
meshList[GEO_XWING]->textureID = LoadTGA("Image//XWing_Texture.tga");
meshList[GEO_XWING]->material.kAmbient.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_XWING]->material.kDiffuse.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_XWING]->material.kSpecular.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_XWING]->material.kShininess = 5.f;
meshList[GEO_ASTEROID] = MeshBuilder::GenerateOBJ("asteroid", "OBJ//asteroid.obj");
meshList[GEO_ASTEROID]->textureID = LoadTGA("Image//asteroid.tga");
meshList[GEO_ASTEROID]->material.kAmbient.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_ASTEROID]->material.kDiffuse.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_ASTEROID]->material.kSpecular.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_ASTEROID]->material.kShininess = 5.f;
meshList[GEO_MISSILE] = MeshBuilder::GenerateOBJ("missile", "OBJ//missile.obj");
meshList[GEO_MISSILE]->textureID = LoadTGA("Image//missile.tga");
meshList[GEO_MISSILE]->material.kAmbient.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_MISSILE]->material.kDiffuse.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_MISSILE]->material.kSpecular.Set(0.5f, 0.5f, 0.5f);
meshList[GEO_MISSILE]->material.kShininess = 5.f;
meshList[GEO_BLACKSCREEN] = MeshBuilder::GenerateQuad("BlackScreen", Color(0, 0, 0));
meshList[GEO_BLACKSCREEN]->textureID = LoadTGA("Image//QuestShown.tga");
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//TimesNewRoman.tga");
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSphere("lightball", Color(1, 1, 1), 18, 36);
Mtx44 projection;
projection.SetToPerspective(45.f, 16.f / 9.f, 0.1f, 10000.f);
projectionStack.LoadMatrix(projection);
camera.SceneGalaxy = true;
camera.SceneMun = false;
camera.SceneSoraJewel = false;
missile.init(&camera);
}
void SceneText::Init()
{
// Black background
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
m_programID = LoadShaders( "Shader//Texture.vertexshader", "Shader//Text.fragmentshader" );
// Get a handle for our uniform
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
//m_parameters[U_MODEL] = glGetUniformLocation(m_programID, "M");
//m_parameters[U_VIEW] = glGetUniformLocation(m_programID, "V");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_LIGHT1_TYPE] = glGetUniformLocation(m_programID, "lights[1].type");
m_parameters[U_LIGHT1_POSITION] = glGetUniformLocation(m_programID, "lights[1].position_cameraspace");
m_parameters[U_LIGHT1_COLOR] = glGetUniformLocation(m_programID, "lights[1].color");
m_parameters[U_LIGHT1_POWER] = glGetUniformLocation(m_programID, "lights[1].power");
m_parameters[U_LIGHT1_KC] = glGetUniformLocation(m_programID, "lights[1].kC");
m_parameters[U_LIGHT1_KL] = glGetUniformLocation(m_programID, "lights[1].kL");
m_parameters[U_LIGHT1_KQ] = glGetUniformLocation(m_programID, "lights[1].kQ");
m_parameters[U_LIGHT1_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[1].spotDirection");
m_parameters[U_LIGHT1_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[1].cosCutoff");
m_parameters[U_LIGHT1_COSINNER] = glGetUniformLocation(m_programID, "lights[1].cosInner");
m_parameters[U_LIGHT1_EXPONENT] = glGetUniformLocation(m_programID, "lights[1].exponent");
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
// Get a handle for our "textColor" uniform
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
// Use our shader
glUseProgram(m_programID);
lights[0].type = Light::LIGHT_DIRECTIONAL;
lights[0].position.Set(0, 20, 0);
lights[0].color.Set(1, 1, 1);
lights[0].power = 1;
lights[0].kC = 1.f;
lights[0].kL = 0.01f;
lights[0].kQ = 0.001f;
lights[0].cosCutoff = cos(Math::DegreeToRadian(45));
lights[0].cosInner = cos(Math::DegreeToRadian(30));
lights[0].exponent = 3.f;
lights[0].spotDirection.Set(0.f, 1.f, 0.f);
lights[1].type = Light::LIGHT_DIRECTIONAL;
lights[1].position.Set(1, 1, 0);
lights[1].color.Set(1, 1, 0.5f);
lights[1].power = 0.4f;
//lights[1].kC = 1.f;
//lights[1].kL = 0.01f;
//lights[1].kQ = 0.001f;
//lights[1].cosCutoff = cos(Math::DegreeToRadian(45));
//lights[1].cosInner = cos(Math::DegreeToRadian(30));
//lights[1].exponent = 3.f;
//lights[1].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_NUMLIGHTS], 1);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
glUniform1i(m_parameters[U_LIGHT0_TYPE], lights[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &lights[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], lights[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], lights[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], lights[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], lights[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], lights[0].cosCutoff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], lights[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], lights[0].exponent);
glUniform1i(m_parameters[U_LIGHT1_TYPE], lights[1].type);
glUniform3fv(m_parameters[U_LIGHT1_COLOR], 1, &lights[1].color.r);
glUniform1f(m_parameters[U_LIGHT1_POWER], lights[1].power);
glUniform1f(m_parameters[U_LIGHT1_KC], lights[1].kC);
glUniform1f(m_parameters[U_LIGHT1_KL], lights[1].kL);
glUniform1f(m_parameters[U_LIGHT1_KQ], lights[1].kQ);
glUniform1f(m_parameters[U_LIGHT1_COSCUTOFF], lights[1].cosCutoff);
glUniform1f(m_parameters[U_LIGHT1_COSINNER], lights[1].cosInner);
glUniform1f(m_parameters[U_LIGHT1_EXPONENT], lights[1].exponent);
camera.Init(Vector3(0, 0, 10), Vector3(0, 0, 0), Vector3(0, 1, 0));
for(int i = 0; i < NUM_GEOMETRY; ++i)
{
meshList[i] = NULL;
}
meshList[GEO_AXES] = MeshBuilder::GenerateAxes("reference", 1000, 1000, 1000);
meshList[GEO_QUAD] = MeshBuilder::GenerateQuad("quad", Color(1, 1, 1), 1.f);
meshList[GEO_QUAD]->textureID[0] = LoadTGA("Image//calibri.tga");
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID[0] = LoadTGA("Image//calibri.tga");
meshList[GEO_TEXT]->material.kAmbient.Set(1, 0, 0);
meshList[GEO_OBJECT] = MeshBuilder::GenerateOBJ("OBJ1", "OBJ//chair.obj");//MeshBuilder::GenerateCube("cube", 1);
meshList[GEO_OBJECT]->textureID[0] = LoadTGA("Image//chair.tga");
meshList[GEO_RING] = MeshBuilder::GenerateRing("ring", Color(1, 0, 1), 36, 1, 0.5f);
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSphere("lightball", Color(1, 1, 1), 18, 36, 1.f);
meshList[GEO_SPHERE] = MeshBuilder::GenerateSphere("sphere", Color(1, 0, 0), 18, 36, 10.f);
//meshList[GEO_CUBE] = MeshBuilder::GenerateCube("cube", 1, 1, 1);
//meshList[GEO_TORUS] = MeshBuilder::GenerateCylinder("torus", 36, 36, 5, 1);
meshList[GEO_CONE] = MeshBuilder::GenerateCone("cone", Color(0.5f, 1, 0.3f), 36, 10.f, 10.f);
meshList[GEO_CONE]->material.kDiffuse.Set(0.99f, 0.99f, 0.99f);
meshList[GEO_CONE]->material.kSpecular.Set(0.f, 0.f, 0.f);
meshList[GEO_LEFT] = MeshBuilder::GenerateQuad("LEFT", Color(1, 1, 1), 1.f);
meshList[GEO_LEFT]->textureID[0] = LoadTGA("Image//left.tga");
meshList[GEO_RIGHT] = MeshBuilder::GenerateQuad("RIGHT", Color(1, 1, 1), 1.f);
meshList[GEO_RIGHT]->textureID[0] = LoadTGA("Image//right.tga");
meshList[GEO_TOP] = MeshBuilder::GenerateQuad("TOP", Color(1, 1, 1), 1.f);
meshList[GEO_TOP]->textureID[0] = LoadTGA("Image//top.tga");
meshList[GEO_BOTTOM] = MeshBuilder::GenerateQuad("BOTTOM", Color(1, 1, 1), 1.f);
meshList[GEO_BOTTOM]->textureID[0] = LoadTGA("Image//bottom.tga");
meshList[GEO_FRONT] = MeshBuilder::GenerateQuad("FRONT", Color(1, 1, 1), 1.f);
meshList[GEO_FRONT]->textureID[0] = LoadTGA("Image//front.tga");
meshList[GEO_BACK] = MeshBuilder::GenerateQuad("BACK", Color(1, 1, 1), 1.f);
meshList[GEO_BACK]->textureID[0] = LoadTGA("Image//back.tga");
meshList[GEO_CROSSHAIR] = MeshBuilder::GenerateCrossHair("CRosshair", 0, 1, 1, 5);
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 1000 units
Mtx44 perspective;
perspective.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 10000.0f);
//perspective.SetToOrtho(-80, 80, -60, 60, -1000, 1000);
projectionStack.LoadMatrix(perspective);
rotateAngle = 0;
bLightEnabled = true;
}
void SceneMenu::Init()
{
srand(time(NULL));
icon = 31.6;
icon2 = 19;
menuIcon = 116;
choose = menushop.STARTGAME;
c_option = menushop.O_SETTING;
Input = "Menu";
Dialogue("Text//Dialogue1.txt");
// Set background color to dark blue
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
//Enable depth buffer and depth testing
glEnable(GL_DEPTH_TEST);
//Enable back face culling
//glEnable(GL_CULL_FACE);
//Default to fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
//m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Blending.fragmentshader");
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Text.fragmentshader");
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
// Get a handle for our "textColor" uniform
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
//Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(m_programID);
light[0].type = Light::LIGHT_POINT;
light[0].position.Set(250, 55, -90);
light[0].color.Set(1, 1, 1);
light[0].power = 4;
light[0].kC = 5.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
light[0].cosCutOff = cos(Math::DegreeToRadian(45));
light[0].cosInner = cos(Math::DegreeToRadian(30));
light[0].exponent = 3.f;
light[0].spotDirection.Set(0.f, 1.f, 0.f);
//Make sure you pass uniform parameters after glUseProgram()
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], light[0].cosCutOff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], light[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], light[0].exponent);
glUniform1i(m_parameters[U_NUMLIGHTS], 6);
//Initialize camera settings
camera.Init(Vector3(-300, -10, 0), Vector3(0, 0, 0), Vector3(0, 1, 0));
meshList[GEO_REF_AXES] = MeshBuilder::GenerateAxes("reference", 1000, 1000, 1000);
//meshList[GEO_CUBE] = MeshBuilder::GenerateCube("cube", Color(1, 1, 0));
meshList[GEO_QUAD] = MeshBuilder::GenerateRepeatQuad("quad", Color(1, 1, 0), 1, 1, 10);
meshList[GEO_QUAD]->textureID = LoadTGA("Image//Tile.tga");
meshList[GEO_QUAD]->material.kAmbient.Set(0.1f, 0.1f, 0.1f);
meshList[GEO_QUAD]->material.kDiffuse.Set(0.6f, 0.6f, 0.6f);
meshList[GEO_QUAD]->material.kSpecular.Set(0.7f, 0.7f, 0.7f);
meshList[GEO_QUAD]->material.kShininess = 1.f;
meshList[GEO_FLOOR] = MeshBuilder::GenerateRepeatQuad("floor", Color(1, 1, 1), 1.015, 1, 10);
meshList[GEO_FLOOR]->textureID = LoadTGA("Image//Tile2.tga");
meshList[GEO_FLOOR]->material.kAmbient.Set(0.1f, 0.1f, 0.1f);
meshList[GEO_FLOOR]->material.kDiffuse.Set(0.6f, 0.6f, 0.6f);
meshList[GEO_FLOOR]->material.kSpecular.Set(0.7f, 0.7f, 0.7f);
meshList[GEO_FLOOR]->material.kShininess = 1.f;
meshList[GEO_PATH] = MeshBuilder::GenerateQuad("land", Color(1, 1, 1), 14, 13);
meshList[GEO_PATH]->textureID = LoadTGA("Image//Menu.tga");
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//Text2.tga");
GLuint wood = LoadTGA("Image//book.tga");
GLuint textID = LoadTGA("Image//Chair.tga");
meshList[GEO_BENCH] = MeshBuilder::GenerateOBJ("bench", "OBJ//Bench.obj");
meshList[GEO_BENCH]->textureID = wood;
GLuint santa = LoadTGA("Image//Santa.tga");
meshList[GEO_VENDING] = MeshBuilder::GenerateOBJ("VM", "OBJ//shelves.obj");
meshList[GEO_VENDING]->textureID = LoadTGA("Image//vending.tga");
meshList[GEO_BUILDING] = MeshBuilder::GenerateOBJ("Building", "OBJ//building.obj");
meshList[GEO_BUILDING]->textureID = LoadTGA("Image//b1.tga");
meshList[GEO_COKE] = MeshBuilder::GenerateOBJ("coke", "OBJ//coke.obj");
meshList[GEO_COKE]->textureID = LoadTGA("Image//coke.tga");
meshList[GEO_STAR] = MeshBuilder::GenerateOBJ("Star", "OBJ//Star.obj");
meshList[GEO_STAR]->textureID = LoadTGA("Image//sand_2.tga");
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSpheres("Sph", Color(1, 1, 1), 18, 36);
Mtx44 projection;
projection.SetToPerspective(45.0f, 16.0f / 9.0f, 0.1f, 10000.0f);
projectionStack.LoadMatrix(projection);
}
void Camera2::Update(double dt)
{
static const float CAMERA_SPEED = 50.f;
if(Application::IsKeyPressed(VK_LEFT) || Application::IsKeyPressed('A'))
{
float yaw = (float)(-CAMERA_SPEED * dt);
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
position = rotation * position;
up = rotation * up;
}
if(Application::IsKeyPressed(VK_RIGHT) || Application::IsKeyPressed('D'))
{
float yaw = (float)(CAMERA_SPEED * dt);
Mtx44 rotation;
rotation.SetToRotation(yaw, 0, 1, 0);
position = rotation * position;
up = rotation * up;
}
if(Application::IsKeyPressed(VK_UP) || Application::IsKeyPressed('W'))
{
float pitch = (float)(-CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
position = rotation * position;
}
if(Application::IsKeyPressed(VK_DOWN) || Application::IsKeyPressed('S'))
{
float pitch = (float)(CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotation;
rotation.SetToRotation(pitch, right.x, right.y, right.z);
position = rotation * position;
}
if(Application::IsKeyPressed('N'))
{
Vector3 direction = target - position;
if(direction.Length() > 5)
{
Vector3 view = (target - position).Normalized();
position += view * (float)(100.f * dt);
}
}
if(Application::IsKeyPressed('M'))
{
Vector3 view = (target - position).Normalized();
position -= view * (float)(100.f * dt);
}
if(Application::IsKeyPressed('R'))
{
Reset();
}
}
void SP2::Init()
{
// Init VBO here
// Set background color to dark blue
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
//Enable depth buffer and depth testing
glEnable(GL_DEPTH_TEST);
//Enable back face culling
//glEnable(GL_CULL_FACE);
//Default to fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
//m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Blending.fragmentshader");
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Text.fragmentshader");
m_parameters[U_MVP] = glGetUniformLocation(m_programID,"MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID,"MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_LIGHT1_POSITION] = glGetUniformLocation(m_programID, "lights[1].position_cameraspace");
m_parameters[U_LIGHT1_COLOR] = glGetUniformLocation(m_programID, "lights[1].color");
m_parameters[U_LIGHT1_POWER] = glGetUniformLocation(m_programID, "lights[1].power");
m_parameters[U_LIGHT1_KC] = glGetUniformLocation(m_programID, "lights[1].kC");
m_parameters[U_LIGHT1_KL] = glGetUniformLocation(m_programID, "lights[1].kL");
m_parameters[U_LIGHT1_KQ] = glGetUniformLocation(m_programID, "lights[1].kQ");
m_parameters[U_LIGHT1_TYPE] = glGetUniformLocation(m_programID, "lights[1].type");
m_parameters[U_LIGHT1_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[1].spotDirection");
m_parameters[U_LIGHT1_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[1].cosCutoff");
m_parameters[U_LIGHT1_COSINNER] = glGetUniformLocation(m_programID, "lights[1].cosInner");
m_parameters[U_LIGHT1_EXPONENT] = glGetUniformLocation(m_programID, "lights[1].exponent");
m_parameters[U_LIGHT2_POSITION] = glGetUniformLocation(m_programID, "lights[2].position_cameraspace");
m_parameters[U_LIGHT2_COLOR] = glGetUniformLocation(m_programID, "lights[2].color");
m_parameters[U_LIGHT2_POWER] = glGetUniformLocation(m_programID, "lights[2].power");
m_parameters[U_LIGHT2_KC] = glGetUniformLocation(m_programID, "lights[2].kC");
m_parameters[U_LIGHT2_KL] = glGetUniformLocation(m_programID, "lights[2].kL");
m_parameters[U_LIGHT2_KQ] = glGetUniformLocation(m_programID, "lights[2].kQ");
m_parameters[U_LIGHT2_TYPE] = glGetUniformLocation(m_programID, "lights[2].type");
m_parameters[U_LIGHT2_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[2].spotDirection");
m_parameters[U_LIGHT2_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[2].cosCutoff");
m_parameters[U_LIGHT2_COSINNER] = glGetUniformLocation(m_programID, "lights[2].cosInner");
m_parameters[U_LIGHT2_EXPONENT] = glGetUniformLocation(m_programID, "lights[2].exponent");
m_parameters[U_LIGHT3_POSITION] = glGetUniformLocation(m_programID, "lights[3].position_cameraspace");
m_parameters[U_LIGHT3_COLOR] = glGetUniformLocation(m_programID, "lights[3].color");
m_parameters[U_LIGHT3_POWER] = glGetUniformLocation(m_programID, "lights[3].power");
m_parameters[U_LIGHT3_KC] = glGetUniformLocation(m_programID, "lights[3].kC");
m_parameters[U_LIGHT3_KL] = glGetUniformLocation(m_programID, "lights[3].kL");
m_parameters[U_LIGHT3_KQ] = glGetUniformLocation(m_programID, "lights[3].kQ");
m_parameters[U_LIGHT3_TYPE] = glGetUniformLocation(m_programID, "lights[3].type");
m_parameters[U_LIGHT3_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[3].spotDirection");
m_parameters[U_LIGHT3_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[3].cosCutoff");
m_parameters[U_LIGHT3_COSINNER] = glGetUniformLocation(m_programID, "lights[3].cosInner");
m_parameters[U_LIGHT3_EXPONENT] = glGetUniformLocation(m_programID, "lights[3].exponent");
m_parameters[U_LIGHT4_POSITION] = glGetUniformLocation(m_programID, "lights[4].position_cameraspace");
m_parameters[U_LIGHT4_COLOR] = glGetUniformLocation(m_programID, "lights[4].color");
m_parameters[U_LIGHT4_POWER] = glGetUniformLocation(m_programID, "lights[4].power");
m_parameters[U_LIGHT4_KC] = glGetUniformLocation(m_programID, "lights[4].kC");
m_parameters[U_LIGHT4_KL] = glGetUniformLocation(m_programID, "lights[4].kL");
m_parameters[U_LIGHT4_KQ] = glGetUniformLocation(m_programID, "lights[4].kQ");
m_parameters[U_LIGHT4_TYPE] = glGetUniformLocation(m_programID, "lights[4].type");
m_parameters[U_LIGHT4_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[4].spotDirection");
m_parameters[U_LIGHT4_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[4].cosCutoff");
m_parameters[U_LIGHT4_COSINNER] = glGetUniformLocation(m_programID, "lights[4].cosInner");
m_parameters[U_LIGHT4_EXPONENT] = glGetUniformLocation(m_programID, "lights[4].exponent");
m_parameters[U_LIGHT5_POSITION] = glGetUniformLocation(m_programID, "lights[5].position_cameraspace");
m_parameters[U_LIGHT5_COLOR] = glGetUniformLocation(m_programID, "lights[5].color");
m_parameters[U_LIGHT5_POWER] = glGetUniformLocation(m_programID, "lights[5].power");
m_parameters[U_LIGHT5_KC] = glGetUniformLocation(m_programID, "lights[5].kC");
m_parameters[U_LIGHT5_KL] = glGetUniformLocation(m_programID, "lights[5].kL");
m_parameters[U_LIGHT5_KQ] = glGetUniformLocation(m_programID, "lights[5].kQ");
m_parameters[U_LIGHT5_TYPE] = glGetUniformLocation(m_programID, "lights[5].type");
m_parameters[U_LIGHT5_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[5].spotDirection");
m_parameters[U_LIGHT5_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[5].cosCutoff");
m_parameters[U_LIGHT5_COSINNER] = glGetUniformLocation(m_programID, "lights[5].cosInner");
m_parameters[U_LIGHT5_EXPONENT] = glGetUniformLocation(m_programID, "lights[5].exponent");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
// Get a handle for our "colorTexture" uniform
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
// Get a handle for our "textColor" uniform
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
//Enable blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(m_programID);
light[0].type = Light::LIGHT_POINT;
light[0].position.Set(250, 55, -90);
light[0].color.Set(1, 1, 1);
light[0].power = 4;
light[0].kC = 5.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
light[0].cosCutOff = cos(Math::DegreeToRadian(45));
light[0].cosInner = cos(Math::DegreeToRadian(30));
light[0].exponent = 3.f;
light[0].spotDirection.Set(0.f, 1.f, 0.f);
//Make sure you pass uniform parameters after glUseProgram()
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], light[0].cosCutOff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], light[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], light[0].exponent);
light[1].type = Light::LIGHT_SPOT;
light[1].position.Set(-300, 37, 185);
light[1].color.Set(1, 1, 1);
light[1].power = 3;
light[1].kC = 5.f;
light[1].kL = 0.1f;
light[1].kQ = 0.001f;
light[1].cosCutOff = cos(Math::DegreeToRadian(45));
light[1].cosInner = cos(Math::DegreeToRadian(30));
light[1].exponent = 3.f;
light[1].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_LIGHT1_TYPE], light[1].type);
glUniform3fv(m_parameters[U_LIGHT1_COLOR], 1, &light[1].color.r);
glUniform1f(m_parameters[U_LIGHT1_POWER], light[1].power);
glUniform1f(m_parameters[U_LIGHT1_KC], light[1].kC);
glUniform1f(m_parameters[U_LIGHT1_KL], light[1].kL);
glUniform1f(m_parameters[U_LIGHT1_KQ], light[1].kQ);
glUniform1f(m_parameters[U_LIGHT1_COSCUTOFF], light[1].cosCutOff);
glUniform1f(m_parameters[U_LIGHT1_COSINNER], light[1].cosInner);
glUniform1f(m_parameters[U_LIGHT1_EXPONENT], light[1].exponent);
light[2].type = Light::LIGHT_SPOT;
light[2].position.Set(0, 37, 135);
light[2].color.Set(1, 1, 1);
light[2].power = 3;
light[2].kC = 1.f;
light[2].kL = 0.1f;
light[2].kQ = 0.001f;
light[2].cosCutOff = cos(Math::DegreeToRadian(45));
light[2].cosInner = cos(Math::DegreeToRadian(30));
light[2].exponent = 3.f;
light[2].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_LIGHT2_TYPE], light[2].type);
glUniform3fv(m_parameters[U_LIGHT2_COLOR], 1, &light[2].color.r);
glUniform1f(m_parameters[U_LIGHT2_POWER], light[2].power);
glUniform1f(m_parameters[U_LIGHT2_KC], light[2].kC);
glUniform1f(m_parameters[U_LIGHT2_KL], light[2].kL);
glUniform1f(m_parameters[U_LIGHT2_KQ], light[2].kQ);
glUniform1f(m_parameters[U_LIGHT2_COSCUTOFF], light[2].cosCutOff);
glUniform1f(m_parameters[U_LIGHT2_COSINNER], light[2].cosInner);
glUniform1f(m_parameters[U_LIGHT2_EXPONENT], light[2].exponent);
light[3].type = Light::LIGHT_SPOT;
light[3].position.Set(300, 37, 185);
light[3].color.Set(1, 1, 1);
light[3].power = 3;
light[3].kC = 1.f;
light[3].kL = 0.1f;
light[3].kQ = 0.001f;
light[3].cosCutOff = cos(Math::DegreeToRadian(45));
light[3].cosInner = cos(Math::DegreeToRadian(30));
light[3].exponent = 3.f;
light[3].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_LIGHT3_TYPE], light[3].type);
glUniform3fv(m_parameters[U_LIGHT3_COLOR], 1, &light[3].color.r);
glUniform1f(m_parameters[U_LIGHT3_POWER], light[3].power);
glUniform1f(m_parameters[U_LIGHT3_KC], light[3].kC);
glUniform1f(m_parameters[U_LIGHT3_KL], light[3].kL);
glUniform1f(m_parameters[U_LIGHT3_KQ], light[3].kQ);
glUniform1f(m_parameters[U_LIGHT3_COSCUTOFF], light[3].cosCutOff);
glUniform1f(m_parameters[U_LIGHT3_COSINNER], light[3].cosInner);
glUniform1f(m_parameters[U_LIGHT3_EXPONENT], light[3].exponent);
light[4].type = Light::LIGHT_POINT;
light[4].position.Set(0, 200, 300);
light[4].color.Set(1, 1, 1);
light[4].power = 40;
light[4].kC = 1.f;
light[4].kL = 0.1f;
light[4].kQ = 0.001f;
light[4].cosCutOff = cos(Math::DegreeToRadian(45));
light[4].cosInner = cos(Math::DegreeToRadian(30));
light[4].exponent = 3.f;
light[4].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_LIGHT4_TYPE], light[4].type);
glUniform3fv(m_parameters[U_LIGHT4_COLOR], 1, &light[4].color.r);
glUniform1f(m_parameters[U_LIGHT4_POWER], light[4].power);
glUniform1f(m_parameters[U_LIGHT4_KC], light[4].kC);
glUniform1f(m_parameters[U_LIGHT4_KL], light[4].kL);
glUniform1f(m_parameters[U_LIGHT4_KQ], light[4].kQ);
glUniform1f(m_parameters[U_LIGHT4_COSCUTOFF], light[4].cosCutOff);
glUniform1f(m_parameters[U_LIGHT4_COSINNER], light[4].cosInner);
glUniform1f(m_parameters[U_LIGHT4_EXPONENT], light[4].exponent);
light[5].type = Light::LIGHT_SPOT;
light[5].position.Set(40, 37, -70);
light[5].color.Set(1, 1, 1);
light[5].power = 3;
light[5].kC = 1.f;
light[5].kL = 0.1f;
light[5].kQ = 0.001f;
light[5].cosCutOff = cos(Math::DegreeToRadian(45));
light[5].cosInner = cos(Math::DegreeToRadian(30));
light[5].exponent = 3.f;
light[5].spotDirection.Set(0.f, 1.f, 0.f);
glUniform1i(m_parameters[U_LIGHT5_TYPE], light[5].type);
glUniform3fv(m_parameters[U_LIGHT5_COLOR], 1, &light[5].color.r);
glUniform1f(m_parameters[U_LIGHT5_POWER], light[5].power);
glUniform1f(m_parameters[U_LIGHT5_KC], light[5].kC);
glUniform1f(m_parameters[U_LIGHT5_KL], light[5].kL);
glUniform1f(m_parameters[U_LIGHT5_KQ], light[5].kQ);
glUniform1f(m_parameters[U_LIGHT5_COSCUTOFF], light[5].cosCutOff);
glUniform1f(m_parameters[U_LIGHT5_COSINNER], light[5].cosInner);
glUniform1f(m_parameters[U_LIGHT5_EXPONENT], light[5].exponent);
glUniform1i(m_parameters[U_NUMLIGHTS],6);
//Initialize camera settings
camera.Init(Vector3(-3, 0, 70), Vector3(0, 0, 0), Vector3(0, 1, 0));
meshList[GEO_REF_AXES] = MeshBuilder::GenerateAxes("reference", 1000, 1000, 1000);
//meshList[GEO_CUBE] = MeshBuilder::GenerateCube("cube", Color(1, 1, 0));
meshList[GEO_QUAD] = MeshBuilder::GenerateRepeatQuad("quad", Color(1, 1, 0), 1, 1,10);
meshList[GEO_QUAD]->textureID = LoadTGA("Image//Tile.tga");
meshList[GEO_QUAD]->material.kAmbient.Set(0.1f, 0.1f, 0.1f);
meshList[GEO_QUAD]->material.kDiffuse.Set(0.6f, 0.6f, 0.6f);
meshList[GEO_QUAD]->material.kSpecular.Set(0.7f, 0.7f, 0.7f);
meshList[GEO_QUAD]->material.kShininess = 1.f;
meshList[GEO_FLOOR] = MeshBuilder::GenerateRepeatQuad("floor", Color(1, 1, 1),1.015,1,10);
meshList[GEO_FLOOR]->textureID = LoadTGA("Image//Tile2.tga");
meshList[GEO_FLOOR]->material.kAmbient.Set(0.1f, 0.1f, 0.1f);
meshList[GEO_FLOOR]->material.kDiffuse.Set(0.6f, 0.6f, 0.6f);
meshList[GEO_FLOOR]->material.kSpecular.Set(0.7f, 0.7f, 0.7f);
meshList[GEO_FLOOR]->material.kShininess = 1.f;
meshList[GEO_BROAD] = MeshBuilder::GenerateRepeatQuad("floor", Color(1, 1, 1), 30, 7,10);
meshList[GEO_BROAD]->textureID = LoadTGA("Image//tile3.tga");
meshList[GEO_BROAD]->material.kAmbient.Set(0.1f, 0.1f, 0.1f);
meshList[GEO_BROAD]->material.kDiffuse.Set(0.6f, 0.6f, 0.6f);
meshList[GEO_BROAD]->material.kSpecular.Set(0.7f, 0.7f, 0.7f);
meshList[GEO_BROAD]->material.kShininess = 1.f;
meshList[GEO_PATH] = MeshBuilder::GenerateRepeatQuad("floor", Color(1, 1, 1), 10, 0.5,10);
meshList[GEO_PATH]->textureID = LoadTGA("Image//path.tga");
meshList[GEO_PATH]->material.kAmbient.Set(0.1f, 0.1f, 0.1f);
meshList[GEO_PATH]->material.kDiffuse.Set(0.6f, 0.6f, 0.6f);
meshList[GEO_PATH]->material.kSpecular.Set(0.7f, 0.7f, 0.7f);
meshList[GEO_PATH]->material.kShininess = 1.f;
meshList[GEO_FRONT] = MeshBuilder::GenerateQuad("front", Color(1, 1, 1), 1, 1);
meshList[GEO_FRONT]->textureID = LoadTGA("Image//m_front.tga");
meshList[GEO_BACK] = MeshBuilder::GenerateQuad("back", Color(1, 1, 1), 1, 1);
meshList[GEO_BACK]->textureID = LoadTGA("Image//m_back.tga");
meshList[GEO_LEFT] = MeshBuilder::GenerateQuad("left", Color(1, 1, 1), 1, 1);
meshList[GEO_LEFT]->textureID = LoadTGA("Image//m_left.tga");
meshList[GEO_RIGHT] = MeshBuilder::GenerateQuad("right", Color(1, 1, 1), 1, 1);
meshList[GEO_RIGHT]->textureID = LoadTGA("Image//m_right.tga");
meshList[GEO_TOP] = MeshBuilder::GenerateQuad("top", Color(1, 1, 1), 1, 1);
meshList[GEO_TOP]->textureID = LoadTGA("Image//m_top.tga");
meshList[GEO_BOTTOM] = MeshBuilder::GenerateQuad("bottom", Color(1, 1, 1), 1, 1);
meshList[GEO_BOTTOM]->textureID = LoadTGA("Image//m_bottom.tga");
meshList[GEO_FRONT1] = MeshBuilder::GenerateQuad("front", Color(1, 1, 1), 1, 1);
meshList[GEO_FRONT1]->textureID = LoadTGA("Image//d_front.tga");
meshList[GEO_BACK1] = MeshBuilder::GenerateQuad("back", Color(1, 1, 1), 1, 1);
meshList[GEO_BACK1]->textureID = LoadTGA("Image//d_back.tga");
meshList[GEO_LEFT1] = MeshBuilder::GenerateQuad("left", Color(1, 1, 1), 1, 1);
meshList[GEO_LEFT1]->textureID = LoadTGA("Image//d_left.tga");
meshList[GEO_RIGHT1] = MeshBuilder::GenerateQuad("right", Color(1, 1, 1), 1, 1);
meshList[GEO_RIGHT1]->textureID = LoadTGA("Image//d_right.tga");
meshList[GEO_TOP1] = MeshBuilder::GenerateQuad("top", Color(1, 1, 1), 1, 1);
meshList[GEO_TOP1]->textureID = LoadTGA("Image//d_top.tga");
meshList[GEO_BOTTOM1] = MeshBuilder::GenerateQuad("bottom", Color(1, 1, 1), 1, 1);
meshList[GEO_BOTTOM1]->textureID = LoadTGA("Image//d_bottom.tga");
meshList[GEO_MLAND] = MeshBuilder::GenerateOBJ("land", "OBJ//Land.obj");
meshList[GEO_MLAND]->textureID = LoadTGA("Image//Land.tga");
meshList[GEO_MFLY] = MeshBuilder::GenerateOBJ("fly", "OBJ//Fly.obj");
meshList[GEO_MFLY]->textureID = LoadTGA("Image//Fly.tga");
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//GungsuhChe.tga");
GLuint wood = LoadTGA("Image//book.tga");
GLuint textID = LoadTGA("Image//Chair.tga");
meshList[GEO_BENCH] = MeshBuilder::GenerateOBJ("bench", "OBJ//Bench.obj");
meshList[GEO_BENCH]->textureID = wood;
meshList[GEO_OUTER] = MeshBuilder::GenerateOBJ("Wall", "OBJ//WallOuter.obj");
meshList[GEO_OUTER]->textureID = LoadTGA("Image//Outside.tga");
GLuint santa = LoadTGA("Image//Santa.tga");
meshList[GEO_SANTA] = MeshBuilder::GenerateOBJ("Wall", "OBJ//Char.obj");
meshList[GEO_SANTA]->textureID = santa;
meshList[GEO_SANTAR] = MeshBuilder::GenerateOBJ("Wall", "OBJ//CharR.obj");
meshList[GEO_SANTAR]->textureID = santa;
meshList[GEO_SANTAL] = MeshBuilder::GenerateOBJ("Wall", "OBJ//CharL.obj");
meshList[GEO_SANTAL]->textureID = santa;
meshList[GEO_SANTALEG] = MeshBuilder::GenerateOBJ("Wall", "OBJ//CharLeg.obj");
meshList[GEO_SANTALEG]->textureID = santa;
GLuint steve = LoadTGA("Image//Steve.tga");
meshList[GEO_STEVE] = MeshBuilder::GenerateOBJ("Wall", "OBJ//Char.obj");
meshList[GEO_STEVE]->textureID = steve;
meshList[GEO_STEVER] = MeshBuilder::GenerateOBJ("Wall", "OBJ//CharR.obj");
meshList[GEO_STEVER]->textureID = steve;
meshList[GEO_STEVEL] = MeshBuilder::GenerateOBJ("Wall", "OBJ//CharL.obj");
meshList[GEO_STEVEL]->textureID = steve;
meshList[GEO_STEVELEG] = MeshBuilder::GenerateOBJ("Wall", "OBJ//CharLeg.obj");
meshList[GEO_STEVELEG]->textureID = steve;
meshList[GEO_DOOR] = MeshBuilder::GenerateOBJ("Wall", "OBJ//Door.obj");
meshList[GEO_DOOR]->textureID = LoadTGA("Image//Door.tga");
meshList[GEO_LAMP] = MeshBuilder::GenerateOBJ("Lamp", "OBJ//Lamp.obj");
meshList[GEO_LAMP]->textureID = textID;
meshList[GEO_SHELVES] = MeshBuilder::GenerateOBJ("Shelves", "OBJ//shelves.obj");
meshList[GEO_SHELVES]->textureID = wood;
meshList[GEO_TABLE] = MeshBuilder::GenerateOBJ("Shelves", "OBJ//table.obj");
meshList[GEO_TABLE]->textureID = wood;
meshList[GEO_VENDING] = MeshBuilder::GenerateOBJ("VM", "OBJ//shelves.obj");
meshList[GEO_VENDING]->textureID = LoadTGA("Image//vending.tga");
meshList[GEO_TREE] = MeshBuilder::GenerateOBJ("Tree", "OBJ//Tree.obj");
meshList[GEO_TREE]->textureID = wood;
meshList[GEO_BUILDING] = MeshBuilder::GenerateOBJ("Building", "OBJ//building.obj");
meshList[GEO_BUILDING]->textureID = LoadTGA("Image//b1.tga");
meshList[GEO_BUILDING1] = MeshBuilder::GenerateOBJ("Building", "OBJ//building.obj");
meshList[GEO_BUILDING1]->textureID = LoadTGA("Image//b2.tga");
meshList[GEO_COKE] = MeshBuilder::GenerateOBJ("coke", "OBJ//coke.obj");
meshList[GEO_COKE]->textureID = LoadTGA("Image//coke.tga");
meshList[GEO_LIGHTBALL] = MeshBuilder::GenerateSpheres("Sph", Color(1, 1, 1), 18, 36);
Mtx44 projection;
projection.SetToPerspective(45.0f, 16.0f / 9.0f, 0.1f, 10000.0f);
projectionStack.LoadMatrix(projection);
door = false;
string no1 = "I found a key, do you want it? Y/N"; //0
string no2 = "Here you go!"; //1
string no3 = "Oh, ok then.."; //2
string no4 = "I gave you the key already"; //3
string no5 = "Pick the can of coke up? Y/N"; //4
string no6 = "Picked up can of coke"; //5
string no7 = "You did not pick up the coke"; //6
string no8 = "Out of drinks"; //7
string no9 = "Return can of coke? Y/N"; //8
string no10 = "Returned can of coke"; //9
string no11 = "You did not return the coke"; //10
string no12 = "You need a key first, hint: Santa"; //11
string no13 = "Press E"; //12
string no14 = "Hi! I'm here to help! Press Y!"; //13
string no15 = "Keep pressing Y to continue!"; //14
string no16 = "W,A,S,D to move!"; //15
string no17 = "Up,down,left,right to change view!";//16
string no18 = "Hold V to see all the instructions!";//17
data.push_back(no1);
data.push_back(no2);
data.push_back(no3);
data.push_back(no4);
data.push_back(no5);
data.push_back(no6);
data.push_back(no7);
data.push_back(no8);
data.push_back(no9);
data.push_back(no10);
data.push_back(no11);
data.push_back(no12);
data.push_back(no13);
data.push_back(no14);
data.push_back(no15);
data.push_back(no16);
data.push_back(no17);
data.push_back(no18);
night = true;
}
void PLANET5::Render()
{
// Render VBO here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//These will be replaced by matrix stack soon
Mtx44 model;
Mtx44 view;
Mtx44 projection;
model.SetToIdentity();
//Set view matrix using camera settings
view.SetToLookAt(
camera.position.x, camera.position.y, camera.position.z,
camera.target.x, camera.target.y, camera.target.z,
camera.up.x, camera.up.y, camera.up.z
);
//Set projection matrix to perspective mode
projection.SetToPerspective(45.0f, 4.0f / 3.0f, 0.1f, 1000.0f); //FOV, Aspect Ratio, Near plane, Far plane
viewStack.LoadIdentity();
viewStack.LookAt(camera.position.x, camera.position.y, camera.position.z,
camera.target.x, camera.target.y, camera.target.z,
camera.up.x, camera.up.y, camera.up.z);
modelStack.LoadIdentity();
Position lightPosition_cameraspace = viewStack.Top() * light[0].position;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightPosition_cameraspace.x);
Vector3 lightDir(light[1].position.x, light[1].position.y, light[1].position.z);
Vector3 lightDirection_cameraspace2 = viewStack.Top() * lightDir;
glUniform3fv(m_parameters[U_LIGHT1_POSITION], 1, &lightDirection_cameraspace2.x);
RenderMesh(meshList[GEO_AXES], false);
/*modelStack.PushMatrix();
modelStack.Translate(light[0].position.x, light[0].position.y, light[0].position.z);
RenderMesh(meshList[GEO_LIGHTBALL], false);
modelStack.PopMatrix();
/* modelStack.PushMatrix();
modelStack.Translate(0.f, 0.f, 0.f);
RenderMesh(meshList[ASTEROID], false);
modelStack.PopMatrix();*/
std::ostringstream fps;
fps << camera.position.x << " " << camera.position.y << " " << camera.position.z;
std::ostringstream fpss;
fpss << camera.target.x << " " << camera.target.y << " " << camera.target.z;
RenderSkyBox();
modelStack.PushMatrix();
modelStack.Translate(0.0f, -35.0f, 0.f);
modelStack.Rotate(rotatespin - 45, 0, 1, 0);
modelStack.Scale(22.0f, 24.0f, 22.0f);
RenderMesh(meshList[SPIN], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0.0f, 8.0f, 0.f);
modelStack.Scale(10.0f, 10.f, 10.f);
RenderMesh(meshList[SPINCAP], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(5.0f, translateButton - 6.f, 43.5f);
modelStack.Rotate(25.0f, 1, 0, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[BUTTON], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(5.0f, -6.0f, 45.0f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(2.0f, 2.0f, 2.0f);
RenderMesh(meshList[BUTTONSTAND], false);
modelStack.PopMatrix();
//////////////////////GEMS ARE OUTRAGREOUS//////////////////////////
modelStack.PushMatrix();
modelStack.Translate(-50.0f, translategem1 - 5.7f, -81.5f);
modelStack.Rotate(22.0f, 1, 0, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[BUTTON], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-50.0f, -6.0f, -80.0f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(2.0f, 2.0f, 2.0f);
RenderMesh(meshList[BUTTONSTAND], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-50.0f, flygem1, -90.0f);
modelStack.Rotate(rotategem1, 0, 1, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[GEM], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-50.0f, -5.0f, -90.0f);
modelStack.Scale(2.f, 2.0f, 2.f);
RenderMesh(meshList[GEMCASE], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-25.0f, translategem2 - 5.7f, -81.5f);
modelStack.Rotate(22.0f, 1, 0, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[BUTTON], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-25.0f, -6.0f, -80.0f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(2.0f, 2.0f, 2.0f);
RenderMesh(meshList[BUTTONSTAND], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-25.0f, flygem2, -90.0f);
modelStack.Rotate(rotategem2, 0, 1, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[GEM2], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-25.0f, -5.0f, -90.0f);
modelStack.Scale(2.f, 2.0f, 2.f);
RenderMesh(meshList[GEMCASE], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0.0f, translategem3 - 5.7f, -81.5f);
modelStack.Rotate(22.0f, 1, 0, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[BUTTON], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0.0f, -6.0f, -80.0f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(2.0f, 2.0f, 2.0f);
RenderMesh(meshList[BUTTONSTAND], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0.0f, flygem3, -90.0f);
modelStack.Rotate(rotategem3, 0, 1, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[GEM3], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0.0f, -5.0f, -90.0f);
modelStack.Scale(2.f, 2.0f, 2.f);
RenderMesh(meshList[GEMCASE], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(25.0f, translategem4 - 5.7f, -81.5f);
modelStack.Rotate(22.0f, 1, 0, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[BUTTON], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(25.0f, -6.0f, -80.0f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(2.0f, 2.0f, 2.0f);
RenderMesh(meshList[BUTTONSTAND], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(25.0f, flygem4, -90.0f);
modelStack.Rotate(rotategem4, 0, 2, 0);
modelStack.Scale(2.f, 3.0f, 2.f);
RenderMesh(meshList[GEM4], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(25.0f, -5.0f, -90.0f);
modelStack.Scale(2.f, 2.0f, 2.f);
RenderMesh(meshList[GEMCASE], true);
modelStack.PopMatrix();
//////////////////////THEY ARE TRULY, TRULY, TRULY OUTRAGREOUS//////////////////////////
modelStack.PushMatrix();
modelStack.Translate(-10.0f, translateEND, -123.0f);
modelStack.Scale(scaleFinish, scaleFinish, scaleFinish);
RenderMesh(meshList[END], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(124.0f, 12.0f, -40.f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(10.0f, 10.0f, 3.0f);
RenderMesh(meshList[PICFRAME], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(124.0f, 12.0f, 40.f);
modelStack.Rotate(-90.0f, 0, 1, 0);
modelStack.Scale(10.0f, 10.0f, 3.0f);
RenderMesh(meshList[PICFRAME], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-124.0f, 12.0f, -40.f);
modelStack.Rotate(90.0f, 0, 1, 0);
modelStack.Scale(10.0f, 10.0f, 3.0f);
RenderMesh(meshList[PICFRAME], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-124.0f, 12.0f, 40.f);
modelStack.Rotate(90.0f, 0, 1, 0);
modelStack.Scale(10.0f, 10.0f, 3.0f);
RenderMesh(meshList[PICFRAME], false);
modelStack.PopMatrix();
RenderHandOnScreen();
RenderTextOnScreen(meshList[POSITION], fps.str(), Color(0, 1, 1), 3, 10, 10);
RenderTextOnScreen(meshList[POSITION], fpss.str(), Color(0, 1, 1), 3, 10, 7);
}
void Camera3::Update(double dt)
{
static const float CAMERA_SPEED = 80.f;
static const float MOVEMENT_SPEED = 30.f;
if (Application::IsKeyPressed('W'))
{
Vector3 camDir = (target - position).Normalized();
position += (camDir * MOVEMENT_SPEED * dt);
target += (camDir * MOVEMENT_SPEED * dt);
}
if (Application::IsKeyPressed('S'))
{
Vector3 camDir = (target - position).Normalized();
position -= (camDir * MOVEMENT_SPEED * dt);
target -= (camDir * MOVEMENT_SPEED * dt);
}
if (Application::IsKeyPressed('A'))
{
Vector3 camDir = (target - position).Normalized();
Vector3 leftDir = (up.Cross(camDir)).Normalized();
position += (leftDir * MOVEMENT_SPEED * dt);
target += (leftDir * MOVEMENT_SPEED * dt);
}
if (Application::IsKeyPressed('D'))
{
Vector3 camDir = (target - position).Normalized();
Vector3 rightDir = (camDir.Cross(up)).Normalized();
position += (rightDir * MOVEMENT_SPEED * dt);
target += (rightDir * MOVEMENT_SPEED * dt);
}
if (Application::IsKeyPressed(VK_LEFT))
{
float yaw = (float)(CAMERA_SPEED * dt);
Mtx44 rotate;
rotate.SetToRotation(yaw, 0, 1, 0);
target.x -= position.x;
target.y -= position.y;
target.z -= position.z;
target = rotate * target;
target.x += position.x;
target.y += position.y;
target.z += position.z;
up = rotate * up;
}
if (Application::IsKeyPressed(VK_RIGHT))
{
float yaw = (float)(-CAMERA_SPEED * dt);
Mtx44 rotate;
rotate.SetToRotation(yaw, 0, 1, 0);
target.x -= position.x;
target.y -= position.y;
target.z -= position.z;
target = rotate * target;
target.x += position.x;
target.y += position.y;
target.z += position.z;
up = rotate * up;
}
if (Application::IsKeyPressed(VK_UP))
{
float pitch = (float)(CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotate;
rotate.SetToRotation(pitch, right.x, right.y, right.z);
target.x -= position.x;
target.y -= position.y;
target.z -= position.z;
target = rotate * target;
target.x += position.x;
target.y += position.y;
target.z += position.z;
}
if (Application::IsKeyPressed(VK_DOWN))
{
float pitch = (float)(-CAMERA_SPEED * dt);
Vector3 view = (target - position).Normalized();
Vector3 right = view.Cross(up);
right.y = 0;
right.Normalize();
up = right.Cross(view).Normalized();
Mtx44 rotate;
rotate.SetToRotation(pitch, right.x, right.y, right.z);
target.x -= position.x;
target.y -= position.y;
target.z -= position.z;
target = rotate * target;
target.x += position.x;
target.y += position.y;
target.z += position.z;
}
if (Application::IsKeyPressed('R'))
{
Reset();
}
}
void Credits::Init()
{
// Init VBO here
// Set background color to dark blue
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
//Enable depth buffer and depth testing
glEnable(GL_DEPTH_TEST);
//Enable back face culling
glEnable(GL_CULL_FACE);
//Default to fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Generate a default VAO for now
glGenVertexArrays(1, &m_vertexArrayID);
glBindVertexArray(m_vertexArrayID);
m_programID = LoadShaders("Shader//Texture.vertexshader", "Shader//Text.fragmentshader");
m_parameters[U_MVP] = glGetUniformLocation(m_programID, "MVP");
m_parameters[U_MODELVIEW] = glGetUniformLocation(m_programID, "MV");
m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE] = glGetUniformLocation(m_programID, "MV_inverse_transpose");
m_parameters[U_MATERIAL_AMBIENT] = glGetUniformLocation(m_programID, "material.kAmbient");
m_parameters[U_MATERIAL_DIFFUSE] = glGetUniformLocation(m_programID, "material.kDiffuse");
m_parameters[U_MATERIAL_SPECULAR] = glGetUniformLocation(m_programID, "material.kSpecular");
m_parameters[U_MATERIAL_SHININESS] = glGetUniformLocation(m_programID, "material.kShininess");
m_parameters[U_LIGHT0_POSITION] = glGetUniformLocation(m_programID, "lights[0].position_cameraspace");
m_parameters[U_LIGHT0_COLOR] = glGetUniformLocation(m_programID, "lights[0].color");
m_parameters[U_LIGHT0_POWER] = glGetUniformLocation(m_programID, "lights[0].power");
m_parameters[U_LIGHT0_KC] = glGetUniformLocation(m_programID, "lights[0].kC");
m_parameters[U_LIGHT0_KL] = glGetUniformLocation(m_programID, "lights[0].kL");
m_parameters[U_LIGHT0_KQ] = glGetUniformLocation(m_programID, "lights[0].kQ");
m_parameters[U_LIGHT0_TYPE] = glGetUniformLocation(m_programID, "lights[0].type");
m_parameters[U_LIGHT0_SPOTDIRECTION] = glGetUniformLocation(m_programID, "lights[0].spotDirection");
m_parameters[U_LIGHT0_COSCUTOFF] = glGetUniformLocation(m_programID, "lights[0].cosCutoff");
m_parameters[U_LIGHT0_COSINNER] = glGetUniformLocation(m_programID, "lights[0].cosInner");
m_parameters[U_LIGHT0_EXPONENT] = glGetUniformLocation(m_programID, "lights[0].exponent");
m_parameters[U_LIGHTENABLED] = glGetUniformLocation(m_programID, "lightEnabled");
m_parameters[U_NUMLIGHTS] = glGetUniformLocation(m_programID, "numLights");
m_parameters[U_COLOR_TEXTURE_ENABLED] = glGetUniformLocation(m_programID, "colorTextureEnabled");
m_parameters[U_COLOR_TEXTURE] = glGetUniformLocation(m_programID, "colorTexture");
m_parameters[U_TEXT_ENABLED] = glGetUniformLocation(m_programID, "textEnabled");
m_parameters[U_TEXT_COLOR] = glGetUniformLocation(m_programID, "textColor");
glUseProgram(m_programID);
light[0].type = Light::LIGHT_SPOT;
light[0].position.Set(camera.position.x, camera.position.y, camera.position.z);
light[0].color.Set(1, 1, 1);
light[0].power = 1.0f;
light[0].kC = 1.f;
light[0].kL = 0.01f;
light[0].kQ = 0.001f;
light[0].cosCutoff = cos(Math::DegreeToRadian(30));
light[0].cosInner = cos(Math::DegreeToRadian(15));
light[0].exponent = 3.f;
light[0].spotDirection.Set(-(camera.target.x - camera.position.x), -(camera.target.y - camera.position.y), -(camera.target.z - camera.position.z));
// Pass information
glUniform1i(m_parameters[U_NUMLIGHTS], 1);
glUniform1i(m_parameters[U_LIGHT0_TYPE], light[0].type);
glUniform3fv(m_parameters[U_LIGHT0_COLOR], 1, &light[0].color.r);
glUniform1f(m_parameters[U_LIGHT0_POWER], light[0].power);
glUniform1f(m_parameters[U_LIGHT0_KC], light[0].kC);
glUniform1f(m_parameters[U_LIGHT0_KL], light[0].kL);
glUniform1f(m_parameters[U_LIGHT0_KQ], light[0].kQ);
glUniform1f(m_parameters[U_LIGHT0_COSCUTOFF], light[0].cosCutoff);
glUniform1f(m_parameters[U_LIGHT0_COSINNER], light[0].cosInner);
glUniform1f(m_parameters[U_LIGHT0_EXPONENT], light[0].exponent);
//Initialize camera settings
camera.Init(Vector3(0, 10, 0), Vector3(0, 10, -1), Vector3(0, 1, 0));
meshList[GEO_TEXT] = MeshBuilder::GenerateText("text", 16, 16);
meshList[GEO_TEXT]->textureID = LoadTGA("Image//calibri.tga");
meshList[GEO_TEXTBACKGROUND] = MeshBuilder::GenerateQuad("text background", Color(1, 1, 1));
meshList[GEO_NAME1] = MeshBuilder::GenerateQuad("Benny", Color(1, 1, 1));
meshList[GEO_NAME1]->textureID = LoadTGA("Image//Benny.tga");
meshList[GEO_NAME2] = MeshBuilder::GenerateQuad("Kewpie", Color(1, 1, 1));
meshList[GEO_NAME2]->textureID = LoadTGA("Image//Kewpie.tga");
meshList[GEO_NAME3] = MeshBuilder::GenerateQuad("Lyk", Color(1, 1, 1));
meshList[GEO_NAME3]->textureID = LoadTGA("Image//Lyk.tga");
meshList[GEO_NAME4] = MeshBuilder::GenerateQuad("Kenichi", Color(1, 1, 1));
meshList[GEO_NAME4]->textureID = LoadTGA("Image//Kenichi.tga");
meshList[GEO_TITLE] = MeshBuilder::GenerateQuad("Title", Color(1, 1, 1));
meshList[GEO_TITLE]->textureID = LoadTGA("Image//Title.tga");
Mtx44 projection;
projection.SetToPerspective(45.0f, 16.f / 9.f, 0.1f, 10000.f);
projectionStack.LoadMatrix(projection);
}
void MS::ShearingXY(float x, float y)
{
Mtx44 mat;
mat.SetToShearing(x, y);
ms.top() = ms.top() * mat;
}
