void Text2D::PrintText(const char* text, Color color, float size, float x, float y)
{
if(!m_mesh || m_mesh->textureID <= 0)
{
std::cout << "No text loaded\n";
return;
}
if(!text)
{
std::cout << "No text\n";
}
glUseProgram(m_shaderID);
glUniform3fv(m_uniformTextColor, 1, &color.r);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, m_mesh->textureID);
glUniform1i(m_uniformTexture, 0);
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 40, 0, 30, -10, 10);
for(unsigned i = 0; i < strlen(text); ++i)
{
Mtx44 translate;
translate.SetToTranslation(i * 0.5f, 0, i * 0.001f);
Mtx44 MVP = ortho * translate;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
mesh->Render((unsigned)text[i] * 6, 6);
}
glEnable(GL_DEPTH_TEST);
glBindTexture(GL_TEXTURE_2D, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
}
void SceneGalaxy::QuestDetail()
{
if (QuestDetailShown == false)
{
Mtx44 ortho;
glDisable(GL_DEPTH_TEST);
ortho.SetToOrtho(0, 80, 0, 60, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Translate(37.5, 27.5, -2);
modelStack.Scale(30, 50, 10);
modelStack.Rotate(90, 1, 0, 0);
renderMesh(meshList[GEO_BLACKSCREEN], false);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
if (Application::IsKeyPressed('E'))
{
QuestDetailShown = true;
}
}
}
void UI::Render(const unsigned& screenX, const unsigned& screenY)
{
Mtx44 projection;
const unsigned depth = 100;
projection.SetToOrtho(0, screenX, 0, screenY, -depth, depth);
displaysFactory.Render(projection);
}
void PLANET5::RenderHandOnScreen()
{
glDisable(GL_DEPTH_TEST);
//Add these code just after glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -20, 20); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Translate(55 + MS_rotate / 2, -10 - MS_rotate / 6, 15);
modelStack.Rotate(155, 1, 0, 0);
modelStack.Rotate(-127, 0, 1, 0);
modelStack.Rotate(23, 0, 0, 1);
modelStack.Scale(6, 12, 8);
RenderMesh(meshList[ARM2], false);
//Add these code just before glEnable(GL_DEPTH_TEST);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void Scene2::Render()
{
// clear color 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();//camera set at world origin
projection.SetToOrtho(-40, +40, -30, +30, -10, +10); //define the world in a cube by these boundaries
glEnableVertexAttribArray(0); //1st attri buffer: vertices
glEnableVertexAttribArray(1);
scale.SetToScale(10, 10, 10);
rotate.SetToRotation(45, 0, 0, 1);
translate.SetToTranslation(5, 5, 0);
model = translate * rotate *scale; //scale, fcollowed by rotate then translate
MVP = projection * view * model;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]); //update new shader w MVP
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_TRIANGLE_1]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TRIANGLE_1]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
//draw triangle
glDrawArrays(GL_TRIANGLES, 0, 6); //starting from vertex 0; 3 vertices = 1 triangle
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer[GEO_TRIANGLE_1]);
glVertexAttribPointer
(
0, //Attribute 0. Must match layout in shader. usually 0 is for vertex
3, //size
GL_FLOAT, //type
GL_FALSE, //normalised
0, //stride
0 //array buffer offset
);
glEnableVertexAttribArray(1);//2nd attr buffer: colors
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer[GEO_TRIANGLE_1]);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(0);
}
void View::LoadOrthoCamera()
{
this->m_eViewState = VIEW_ORTHO;
Mtx44 Projection;
Projection.SetToOrtho(0, (float)m_viewPort[VIEWPORT_WIDTH], 0, (float)m_viewPort[VIEWPORT_HEIGHT], -10, 100);
projectionStack.LoadIdentity();
projectionStack.LoadMatrix(Projection);
}
void View::Render2DMesh(Mesh *mesh, bool enableLight, bool enableFog, float sizeX, float sizeY, float transX, float transY, float rotateValue)
{
if (mesh == NULL)
return;
Mtx44 ortho;
ortho.SetToOrtho(0, (float)m_viewPort[VIEWPORT_WIDTH], 0, (float)m_viewPort[VIEWPORT_HEIGHT], -10, 100);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(transX, transY, 0);
modelStack.Rotate(rotateValue, 0, 0, 1);
modelStack.Scale(sizeX, sizeY, 1);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
// Alpha
glUniform1f(m_parameters[U_OBJECT_ALPHA], mesh->alpha);
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
for (int i = 0; i < MAX_TEXTURES; i++)
{
if (mesh->textureArray[i] > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED + i], 1);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED + i], 0);
}
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, mesh->textureArray[i]);
//
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//
glUniform1i(m_parameters[U_COLOR_TEXTURE + i], i);
}
mesh->Render();
glBindTexture(GL_TEXTURE_2D, 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
}
void SP3::Render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Projection matrix : Orthographic Projection
Mtx44 projection;
projection.SetToOrtho(0, m_worldWidth, 0, m_worldHeight, -10, 10);
projectionStack.LoadMatrix(projection);
// 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();
RenderMesh(meshList[GEO_AXES], false);
for (std::vector<GameObject *>::iterator it = m_goList.begin(); it != m_goList.end(); ++it)
{
GameObject *go = (GameObject *)*it;
if (go->active)
{
RenderGO(go);
}
}
std::ostringstream ss;
ss.str(string());
ss.precision(5);
ss << "FPS: " << fps;
RenderTextOnScreen(meshList[GEO_TEXT], ss.str(), Color(0, 1, 0), 3, 0, 0);
if (gameState == Menu)
{
modelStack.PushMatrix();
modelStack.Translate(65.f, 50.f, 0.f);
modelStack.Scale(115, 90, 0);
RenderMesh(meshList[GEO_UI], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
RenderTextOnScreen(meshList[GEO_TEXT], "Welcome", Color(0, 0, 1), 4, 25, 50);
RenderTextOnScreen(meshList[GEO_TEXT], "To", Color(0, 0, 1), 4, 35, 45);
RenderTextOnScreen(meshList[GEO_TEXT], "Suk Malcolm Deek", Color(0, 0, 1), 4, 8, 40);
RenderTextOnScreen(meshList[GEO_TEXT], "Start Game", Color(1, 0, 0), 4, 20, 20);
RenderTextOnScreen(meshList[GEO_TEXT], "Quit Game", Color(1, 0, 0), 4, 22, 15);
modelStack.PopMatrix();
}
}
void SceneText::Render2DMesh(Mesh *mesh, bool enableLight, float size, float x, float y, bool rotate)
{
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 1024, 0, 800, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, 0);
modelStack.Scale(size, size, size);
if(rotate)
{
//glDisable(GL_CULL_FACE);
//modelStack.Rotate(180, 0, 1, 0);
}
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
if(mesh->textureID > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 0);
}
mesh->Render();
if(mesh->textureID > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void GameScene::RenderTextOnScreen(Mesh* mesh, std::string text, Colour colour, float size, float x, float y) {
if(!mesh || mesh->textureID <= 0) {//Proper error check
return;
}
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, glfwGetVideoMode(glfwGetPrimaryMonitor())->width, 0, glfwGetVideoMode(glfwGetPrimaryMonitor())->height, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Scale(size, size, size);
modelStack.Translate(x, y, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 1);
glUniform3fv(m_parameters[U_TEXT_COLOR], 1, &colour.r);
glUniform1i(m_parameters[U_LIGHTENABLED], 0);
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
for(unsigned i = 0; i < text.length(); ++i) {
Mtx44 characterSpacing;
characterSpacing.SetToTranslation(i * 0.3f, 0, 0); //1.0f is the spacing of each character, you may change this value
Mtx44 MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top() * characterSpacing;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
mesh->Render((unsigned)text[i] * 6, 6);
}
glBindTexture(GL_TEXTURE_2D, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
/********************************************************************************
Render a mesh in 2D
********************************************************************************/
void SceneManager::Render2DMesh(Mesh *mesh, const bool enableLight, const Vector2 scale, const Vector2 pos, const float rotation)
{
if (!mesh || mesh->textureID <= 0)
return;
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, double(sceneWidth), 0, double(sceneHeight), -100, 100);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(pos.x, pos.y, 0);
modelStack.Scale(scale.x, scale.y, 1);
if (rotation != 0.f)
modelStack.Rotate(rotation, 0, 0, 1);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
if (mesh->textureID != NULL)
{
glUniform1i(parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(parameters[U_COLOR_TEXTURE], 0);
}
else
{
glUniform1i(parameters[U_COLOR_TEXTURE_ENABLED], 0);
}
mesh->Render();
if (mesh->textureID > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void SceneBase::SetHUD(const bool m_bHUDmode)
{
if (m_bHUDmode)
{
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
}
else
{
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
}
void SceneBase::RenderMeshIn2D(Mesh *mesh, bool enableLight, float size, float x, float y, float rotate)
{
Mtx44 ortho;
//ortho.SetToOrtho(-m_window_width * 0.5f, m_window_width * 0.5f, -m_window_height * 0.5f, m_window_height * 0.5f, -10, 10);
ortho.SetToOrtho(0, m_window_width, 0, m_window_height, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
/*modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x,y,0);
modelStack.Rotate(rotate, 0, 0, 1);
modelStack.Scale(size, size, size);*/
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
for (int i = 0; i < Mesh::MAX_TEXTURES; ++i)
{
if(mesh->textureID[i] > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED + (i * 2)], 1);
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, mesh->textureID[i]);
glUniform1i(m_parameters[U_COLOR_TEXTURE + (i * 2)], i);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED + (i * 2)], 0);
}
}
mesh->Render();
for (int i = 0; i < Mesh::MAX_TEXTURES; ++i)
{
if(mesh->textureID[i] > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
}
//modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
}
/********************************************************************************
Render this scene
********************************************************************************/
void CSceneManager2D::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(0, m_window_width, 0, m_window_height, -1000, 1000);
projectionStack.LoadMatrix(perspective);
// Set up the view
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();
}
/********************************************************************************
Render a mesh in 2D W/Transparent
********************************************************************************/
void CSceneManager2D::RenderMeshIn2DTrans(Mesh *mesh, int transparency, float sizeX, float sizeY, float x, float y, float z, float rotate, float centerOffsetX, float centerOffsetY)
{
Mtx44 ortho;
ortho.SetToOrtho(0, m_window_width, 0, m_window_height, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
//modelStack.LoadIdentity();
modelStack.Translate((float)x, (float)y, (float)z);
if (rotate)
{
modelStack.Rotate(rotate, 0, 0, 1);
}
modelStack.Scale((float)sizeX, (float)sizeY, 1);
if (centerOffsetX || centerOffsetY)
modelStack.Translate(centerOffsetX, centerOffsetY, 0);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniform1i(m_parameters[U_TEXTURE_ALPHA], transparency);
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
if (mesh->textureID > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 0);
}
mesh->Render();
if (mesh->textureID > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
glUniform1i(m_parameters[U_TEXTURE_ALPHA], 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
}
/********************************************************************************
Render text onto the screen
********************************************************************************/
void SceneManager::RenderTextOnScreen(Mesh* mesh, std::string text, Color color, float size, float x, float y, float rotation)
{
if (!mesh || mesh->textureID <= 0)
return;
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, double(sceneWidth), 0, double(sceneHeight), -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, 0);
if (rotation != 0.f)
{
modelStack.Rotate(rotation, 0, 0, 1);
}
modelStack.Scale(size, size, size);
glUniform1i(parameters[U_TEXT_ENABLED], 1);
glUniform3fv(parameters[U_TEXT_COLOR], 1, &color.r);
glUniform1i(parameters[U_LIGHTENABLED], 0);
glUniform1i(parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(parameters[U_COLOR_TEXTURE], 0);
float temp = 0;
for (unsigned i = 0; i < text.length(); ++i)
{
Mtx44 characterSpacing;
characterSpacing.SetToTranslation(temp * 1.5f, 0, 0); //1.0f is the spacing of each character, you may change this value
Mtx44 MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top() * characterSpacing;
glUniformMatrix4fv(parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
temp += textWidth[text[i]] * 0.01;
mesh->Render((unsigned)text[i] * 6, 6);
}
glBindTexture(GL_TEXTURE_2D, 0);
glUniform1i(parameters[U_TEXT_ENABLED], 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void SceneText::RenderMeshIn2D(Mesh *mesh, const bool enableLight, const float size, const float x, const float y, const bool rotate)
{
Mtx44 ortho;
ortho.SetToOrtho(-80, 80, -60, 60, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, 0);
modelStack.Scale(size, size, size);
if(rotate)
modelStack.Rotate(rotateAngle, 0, 0, 1);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
if(mesh->textureID > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 0);
}
mesh->Render();
if(mesh->textureID > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
}
void SceneMenu::RenderQuadOnScreen(Mesh* mesh, float size, float x, float y, float rotate, float rx, float ry, float rz, float z)
{
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Scale(size, size, size);
modelStack.Translate(x, y, z);
modelStack.Rotate(rotate, rx, ry, rz);
RenderMesh(mesh, false);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
}
void SceneCredits::SetHUD(const bool m_bHUDmode) // Remember to call this in pairs
{
if(m_bHUDmode)
{
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, m_window_width, 0, m_window_height, -10, 10); // Origin at bottom left
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
glUniform1f(m_parameters[U_FOG_ENABLE], 0);
}
else
{
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
glUniform1f(m_parameters[U_FOG_ENABLE], fogEnabled);
}
}
void View::RenderTextOnScreen(Mesh* mesh, std::string text, Color color, float size, float x, float y)
{
if (mesh == NULL)
return;
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, (float)m_viewPort[VIEWPORT_WIDTH], 0, (float)m_viewPort[VIEWPORT_HEIGHT], -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, 0);
modelStack.Scale(size, size, size);
glUniform1i(m_parameters[U_TEXT_ENABLED], 1);
glUniform3fv(m_parameters[U_TEXT_COLOR], 1, &color.r);
glUniform1i(m_parameters[U_LIGHTENABLED], 0);
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
// Alpha
glUniform1f(m_parameters[U_OBJECT_ALPHA], mesh->alpha);
for (unsigned i = 0; i < text.length(); ++i)
{
Mtx44 characterSpacing;
characterSpacing.SetToTranslation((i*0.4f) + 0.5f, 0.5f, 0); //1.0f is the spacing of each character, you may change this value
Mtx44 MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top() * characterSpacing;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
mesh->Render((unsigned)text[i] * 6, 6);
}
glBindTexture(GL_TEXTURE_2D, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void SceneText::RenderTextOnScreen(Mesh* mesh, std::string text, Color color, float size, float x, float y)
{
if (!mesh || mesh->textureID <= 0) //Proper error check
return;
glDisable(GL_DEPTH_TEST);
//Add these code just after glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Scale(size, size, size);
modelStack.Translate(x, y, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 1);
glUniform3fv(m_parameters[U_TEXT_COLOR], 1, &color.r);
glUniform1i(m_parameters[U_LIGHTENABLED], 0);
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
for (unsigned i = 0; i < text.length(); ++i)
{
Mtx44 characterSpacing;
characterSpacing.SetToTranslation(i * 1.0f + 0.5f, 0.5f, 0); // for text on screen
Mtx44 MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top() * characterSpacing;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
mesh->Render((unsigned)text[i] * 6, 6);
}
glBindTexture(GL_TEXTURE_2D, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
//Add these code just before glEnable(GL_DEPTH_TEST);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void SceneBase::RenderMeshIn2D(Mesh *mesh, Vector3 size, float x, float y, float rot/* = 0.0f*/)
{
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(-80, 80, -60, 60, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, 0);
modelStack.Scale(size.x, size.y, size.z);
modelStack.Rotate(rot, 0.0f, 0.0f, 1.0f);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
for (int i = 0; i < Mesh::MAX_TEXTURES; ++i)
{
if (mesh->textureArray[i] > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED + i], 1);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED + i], 0);
}
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, mesh->textureArray[i]);
glUniform1i(m_parameters[U_COLOR_TEXTURE + i], i);
}
mesh->Render();
glBindTexture(GL_TEXTURE_2D, 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void CSceneManager2D::RenderTextOnScreenTrans(Mesh* mesh, std::string text, Color color, int transparency, float size, float x, float y, float z)
{
if (!mesh || mesh->textureID <= 0)
return;
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
//ortho.SetToOrtho(0, m_window_width, 0, m_window_height, -10, 10);
ortho.SetToOrtho(0, m_window_width, 0, m_window_height, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, z);
modelStack.Scale(size, size, size);
glUniform1i(m_parameters[U_TEXT_ENABLED], 1);
glUniform1i(m_parameters[U_TEXTURE_ALPHA], transparency);
glUniform3fv(m_parameters[U_TEXT_COLOR], 1, &color.r);
glUniform1i(m_parameters[U_LIGHTENABLED], 0);
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
for (unsigned i = 0; i < text.length(); ++i)
{
Mtx44 characterSpacing;
characterSpacing.SetToTranslation((i*0.5f) + 0.5f, 0.5f, 0); //1.0f is the spacing of each character, you may change this value
Mtx44 MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top() * characterSpacing;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
mesh->Render((unsigned)text[i] * 6, 6);
}
glBindTexture(GL_TEXTURE_2D, 0);
glUniform1i(m_parameters[U_TEXT_ENABLED], 0);
glUniform1i(m_parameters[U_TEXTURE_ALPHA], 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void Credits::RenderModelOnScreen(Mesh* mesh, float Sx, float Sy, float Sz, float Rotate, float rX, float rY, float rZ, float Tx, float Ty, float Tz, bool LightYN)
{
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -50, 50); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Scale(Sx, Sy, Sz);
modelStack.Translate(Tx, Ty, Tz);
modelStack.Rotate(Rotate, (float)rX, (float)rY, (float)rZ);
RenderMesh(mesh, LightYN);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
}
/********************************************************************************
Render 2D Mesh
********************************************************************************/
void CSceneManager2D::Render2DMesh(Mesh *mesh, bool enableLight, int size, int x, int y, bool rotate, bool flip)
{
Mtx44 ortho;
ortho.SetToOrtho(0, m_window_width, 0, m_window_height, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate( (float)x, (float)y, 0);
modelStack.Scale( (float)size, (float)size, (float)size);
if (rotate)
modelStack.Rotate(rotateAngle, 0, 0, 1);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
if(mesh->textureID > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 0);
}
mesh->Render();
if(mesh->textureID > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
}
void SceneBase::RenderModelOnScreen(Mesh *mesh, bool enableLight, Vector3 size, float x, float y, float z, Vector3 rotation)
{
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -100, 70); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Translate(x, y, z);
modelStack.Scale(size.x, size.y, size.z);
modelStack.Rotate(rotation.x, 1, 0, 0);
modelStack.Rotate(rotation.y, 0, 1, 0);
modelStack.Rotate(rotation.z, 0, 0, 1);
RenderMesh(mesh, enableLight);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
}
void SceneText::RenderSprites(Mesh* mesh, const float size, const float x, const float y)
{
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 1024, 0, 800, -10, 10);
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity();
modelStack.PushMatrix();
modelStack.LoadIdentity();
modelStack.Translate(x, y, 0);
modelStack.Scale(size, size, size);
//if (!mesh || mesh->textureID <= 0)
// return;
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
Mtx44 characterSpacing;
characterSpacing.SetToTranslation(0.5f, 0.5f, 0); //1.0f is the spacing of each character, you may change this value
Mtx44 MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top() * characterSpacing;
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
mesh->Render((unsigned)increase * 6, 6);
glBindTexture(GL_TEXTURE_2D, 0);
modelStack.PopMatrix();
viewStack.PopMatrix();
projectionStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
void Assignment3::RenderModelOnScreen(Mesh *mesh, bool enableLight, float size, float x, float y) // used to render helmet on screen
{
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Scale(size, size, size);
modelStack.Translate(x, y, 0);
modelStack.Rotate(90, 0, 0, 1);
modelStack.Rotate(90, 1, 0, 0);
RenderMesh(mesh, enableLight);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
}
void SceneText::RenderQuadOnScreen(Mesh* mesh, float sizeX, float sizeY, float x, float y, bool enableLight)
{
if(!mesh || mesh->textureID <= 0) //Proper error check
return;
glDisable(GL_DEPTH_TEST);
Mtx44 ortho;
ortho.SetToOrtho(0, 80, 0, 60, -10, 10); //size of screen UI
projectionStack.PushMatrix();
projectionStack.LoadMatrix(ortho);
viewStack.PushMatrix();
viewStack.LoadIdentity(); //No need camera for ortho mode
modelStack.PushMatrix();
modelStack.LoadIdentity(); //Reset modelStack
modelStack.Translate(x, y, 0);
modelStack.Scale(sizeX, sizeY, 0);
Mtx44 MVP, modelView, modelView_inverse_transpose;
MVP = projectionStack.Top() * viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MVP], 1, GL_FALSE, &MVP.a[0]);
if(enableLight)
{
glUniform1i(m_parameters[U_LIGHTENABLED], 1);
modelView = viewStack.Top() * modelStack.Top();
glUniformMatrix4fv(m_parameters[U_MODELVIEW], 1, GL_FALSE, &modelView.a[0]);
modelView_inverse_transpose = modelView.GetInverse().GetTranspose();
glUniformMatrix4fv(m_parameters[U_MODELVIEW_INVERSE_TRANSPOSE], 1, GL_FALSE, &modelView_inverse_transpose.a[0]);
//load material
glUniform3fv(m_parameters[U_MATERIAL_AMBIENT], 1, &mesh->material.kAmbient.r);
glUniform3fv(m_parameters[U_MATERIAL_DIFFUSE], 1, &mesh->material.kDiffuse.r);
glUniform3fv(m_parameters[U_MATERIAL_SPECULAR], 1, &mesh->material.kSpecular.r);
glUniform1f(m_parameters[U_MATERIAL_SHININESS], mesh->material.kShininess);
}
else
{
glUniform1i(m_parameters[U_LIGHTENABLED], 0);
}
if(mesh->textureID > 0)
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->textureID);
glUniform1i(m_parameters[U_COLOR_TEXTURE], 0);
}
else
{
glUniform1i(m_parameters[U_COLOR_TEXTURE_ENABLED], 0);
}
mesh->Render();
if(mesh->textureID > 0)
{
glBindTexture(GL_TEXTURE_2D, 0);
}
glBindTexture(GL_TEXTURE_2D, 0);
projectionStack.PopMatrix();
viewStack.PopMatrix();
modelStack.PopMatrix();
glEnable(GL_DEPTH_TEST);
}
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);
}