void Tutorial9_Animation::onUpdate(float a_deltaTime)
{
// update our camera matrix using the keyboard/mouse
Utility::freeMovement(m_cameraMatrix, a_deltaTime, 10);
// clear all gizmos from last frame
Gizmos::clear();
// add an identity matrix gizmo
Gizmos::addTransform(glm::mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1));
// add a 20x20 grid on the XZ-plane
for (int i = 0; i < 21; ++i)
{
Gizmos::addLine(glm::vec3(-10 + i, 0, 10), glm::vec3(-10 + i, 0, -10),
i == 10 ? glm::vec4(1, 1, 1, 1) : glm::vec4(0, 0, 0, 1));
Gizmos::addLine(glm::vec3(10, 0, -10 + i), glm::vec3(-10, 0, -10 + i),
i == 10 ? glm::vec4(1, 1, 1, 1) : glm::vec4(0, 0, 0, 1));
}
// quit our application when escape is pressed
if (glfwGetKey(m_window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
quit();
// grab the skeleton and animation we want to use
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
FBXAnimation* animation = m_fbx->getAnimationByIndex(0);
// evaluate the animation to update bones
skeleton->evaluate(animation, Utility::getTotalTime());
UpdateFBXSceneResource(m_fbx);
}
void Tutorial9_Animation::RenderFBXSceneResource(FBXFile *a_pScene, glm::mat4 a_view, glm::mat4 a_projection)
{
// activate a shader
glUseProgram(m_shader);
// update the bones to include the bind pose
// so that the offset is local
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
skeleton->updateBones();
// get the location of uniforms on the shader
GLint uDiffuseTexture = glGetUniformLocation(m_shader, "DiffuseTexture");
GLint uDiffuseColor = glGetUniformLocation(m_shader, "DiffuseColor");
GLint uProjectionView = glGetUniformLocation(m_shader, "projectionView");
GLint uGlobal = glGetUniformLocation(m_shader, "global");
GLint uLocation = glGetUniformLocation(m_shader, "bones");
// for each mesh in the model...
for (int i = 0; i<a_pScene->getMeshCount(); ++i)
{
// get the current mesh
FBXMeshNode *mesh = a_pScene->getMeshByIndex(i);
// get the render data attached to the m_userData pointer for this mesh
OGL_FBXRenderData *ro = (OGL_FBXRenderData *)mesh->m_userData;
// Bind the texture to one of the ActiveTextures
// if your shader supported multiple textures, you would bind each texture to a new Active Texture ID here
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::DiffuseTexture]->handle);
// reset back to the default active texture
glActiveTexture(GL_TEXTURE0);
// tell the shader which texture to use
glUniform1i(uDiffuseTexture, 1);
m_projectionView = a_projection * a_view;
// send the Model, View and Projection Matrices to the shader
glUniformMatrix4fv(uProjectionView, 1, false, glm::value_ptr(m_projectionView));
glUniformMatrix4fv(uGlobal, 1, false, glm::value_ptr(mesh->m_globalTransform));
glUniformMatrix4fv(uLocation, skeleton->m_boneCount, GL_FALSE, (float*)skeleton->m_bones);
// bind our vertex array object
// remember in the initialise function, we bound the VAO and IBO to the VAO
// so when we bind the VAO, openGL knows what what vertices,
// indices and vertex attributes to send to the shader
glBindVertexArray(ro->VAO);
glDrawElements(GL_TRIANGLES, mesh->m_indices.size(), GL_UNSIGNED_INT, 0);
}
// finally, we have finished rendering the meshes
// disable this shader
glUseProgram(0);
}
void FBXObject::Draw(glm::vec3 _lightDir, glm::vec3 _lightColour)
{
glUseProgram(m_programID);
unsigned int uiProjViewLocation = glGetUniformLocation(m_programID, "ProjectionView");
glUniformMatrix4fv(uiProjViewLocation, 1, GL_FALSE, glm::value_ptr(m_camera->GetProjectionView()));
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
skeleton->updateBones();
int bones_location = glGetUniformLocation(m_programID, "bones");
glUniformMatrix4fv(bones_location, skeleton->m_boneCount, GL_FALSE, (float*)skeleton->m_bones);
for (unsigned int i = 0; i < m_fbx->getMeshCount(); ++i)
{
FBXMeshNode* mesh = m_fbx->getMeshByIndex(i);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::DiffuseTexture]->handle);
unsigned int* glData = (unsigned int*)mesh->m_userData;
glBindVertexArray(glData[0]);
// diffuse
// ambient colour uniform
// diffuse colour uniform
unsigned int diffuse = glGetUniformLocation(m_programID, "diffuse");
glUniform1i(diffuse, 0);
unsigned int normal = glGetUniformLocation(m_programID, "normal");
glUniform1i(normal, 1);
unsigned int uiLightPositionLocation = glGetUniformLocation(m_programID, "LightPos");
glUniform3fv(uiLightPositionLocation, 1, glm::value_ptr(m_lightYPos));
vec3 lightDir = glm::normalize(_lightDir);
unsigned int uiLightDirectionLocation = glGetUniformLocation(m_programID, "LightDir");
glUniform3f(uiLightDirectionLocation, lightDir.x, lightDir.y, lightDir.z);
unsigned int uiLightColourLocation = glGetUniformLocation(m_programID, "LightColour");
glUniform3f(uiLightColourLocation, _lightColour.x, _lightColour.y, _lightColour.z);
unsigned int uiCameraLocation = glGetUniformLocation(m_programID, "CameraPos");
glUniform3fv(uiCameraLocation, 0, glm::value_ptr(m_camera->GetPosition())); // 0.0f, 1.0f, 0.0f); // glm::value_ptr(m_lightYPos));
unsigned int uiSpecPow = glGetUniformLocation(m_programID, "SpecPow");
glUniform1f(uiSpecPow, 125.0f);
glDrawElements(GL_TRIANGLES, (unsigned int)mesh->m_indices.size(), GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}
}
void FBXObject::Update(float deltaTime)
{
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
FBXAnimation* animation = m_fbx->getAnimationByIndex(0);
m_timer += deltaTime;
skeleton->evaluate(animation, m_timer);
for (unsigned int bone_index = 0; bone_index < skeleton->m_boneCount; ++bone_index)
{
skeleton->m_nodes[bone_index]->updateGlobalTransform();
}
}
void APP_Animation::Update(float a_dt)
{
GameCam->Update(a_dt); //update camera
// if (m_timer > 5)
// m_timer = 0;
m_timer += a_dt;
// grab the skeleton and animation we want to use
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
FBXAnimation* animation = m_fbx->getAnimationByIndex(0);
// evaluate the animation to update bones
skeleton->evaluate(animation, m_timer);
for (unsigned int bone_index = 0; bone_index < skeleton->m_boneCount; ++bone_index)
{
skeleton->m_nodes[bone_index]->updateGlobalTransform();
}
}
void FBXObject::Update(float dT)
{
if (m_animated)
{
// grab the skeleton and animation we want to use
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
m_timer += dT * 2;
FBXAnimation* animation = m_fbx->getAnimationByIndex(0);
// evaluate the animation to update bones
skeleton->evaluate(animation, m_timer);
for (unsigned int bone_index = 0; bone_index < skeleton->m_boneCount; ++bone_index)
{
skeleton->m_nodes[bone_index]->updateGlobalTransform();
}
}
}
void FBXObject::Draw(FlyCamera *camera)
{
glUseProgram(m_programID);
if(m_animated)
{
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
skeleton->updateBones();
int bones_location = glGetUniformLocation(m_programID, "bones");
glUniformMatrix4fv(bones_location, skeleton->m_boneCount, GL_FALSE, (float*)skeleton->m_bones);
unsigned int projectionViewUniform = glGetUniformLocation(m_programID,"ProjectionView");
unsigned int lightPosUniform = glGetUniformLocation(m_programID, "LightPos");
unsigned int lightColourUniform = glGetUniformLocation(m_programID, "LightColour");
unsigned int cameraPosUniform = glGetUniformLocation(m_programID, "CameraPos");
unsigned int specPow = glGetUniformLocation(m_programID, "SpecPow");
glm::vec3 camPos = camera->GetPosition();
glm::vec3 clr = m_tweaks->m_lightColour;
glm::vec3 pos = m_tweaks->m_lightPos;
glUniformMatrix4fv(projectionViewUniform, 1, false, glm::value_ptr(camera->GetProjectionView()));
glUniform3f(lightPosUniform, pos.x, pos.y, pos.z);
glUniform3f(lightColourUniform, clr.r, clr.g, clr.b);
glUniform3f(cameraPosUniform, camPos.x, camPos.y, camPos.z);
glUniform1f(specPow, m_tweaks->m_specPower);
for (unsigned int i = 0; i < m_fbx->getMeshCount(); ++i)
{
FBXMeshNode* mesh = m_fbx->getMeshByIndex(i);
int m_global = glGetUniformLocation(m_programID, "global");
glUniformMatrix4fv(m_global, 1, GL_FALSE, &(mesh->m_globalTransform)[0][0]);
if ( mesh->m_material->textures[FBXMaterial::DiffuseTexture] != nullptr )
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::DiffuseTexture]->handle);
}
if ( mesh->m_material->textures[FBXMaterial::NormalTexture] != nullptr )
{
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::NormalTexture]->handle);
}
if ( mesh->m_material->textures[FBXMaterial::SpecularTexture] != nullptr )
{
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::SpecularTexture]->handle);
}
unsigned int* glData = (unsigned int*)mesh->m_userData;
glBindVertexArray(glData[0]);
glDrawElements(GL_TRIANGLES, (unsigned int)mesh->m_indices.size(), GL_UNSIGNED_INT, 0);
}
}
else
{
unsigned int projectionViewUniform = glGetUniformLocation(m_programID,"ProjectionView");
unsigned int lightPosUniform = glGetUniformLocation(m_programID, "LightPos");
unsigned int lightColourUniform = glGetUniformLocation(m_programID, "LightColour");
unsigned int cameraPosUniform = glGetUniformLocation(m_programID, "CameraPos");
unsigned int specPow = glGetUniformLocation(m_programID, "SpecPow");
glm::vec3 camPos = camera->GetPosition();
glm::vec3 clr = m_tweaks->m_lightColour;
glm::vec3 pos = m_tweaks->m_lightPos;
glUniformMatrix4fv(projectionViewUniform, 1, false, glm::value_ptr(camera->GetProjectionView()));
glUniform3f(lightPosUniform, pos.x, pos.y, pos.z);
glUniform3f(lightColourUniform, clr.r, clr.g, clr.b);
glUniform3f(cameraPosUniform, camPos.x, camPos.y, camPos.z);
glUniform1f(specPow, m_tweaks->m_specPower);
for (unsigned int i = 0; i < m_fbx->getMeshCount(); ++i)
{
FBXMeshNode* mesh = m_fbx->getMeshByIndex(i);
int m_global = glGetUniformLocation(m_programID, "global");
glUniformMatrix4fv(m_global, 1, GL_FALSE, &(mesh->m_globalTransform)[0][0]);
if ( mesh->m_material->textures[FBXMaterial::DiffuseTexture] != nullptr )
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::DiffuseTexture]->handle);
}
if ( mesh->m_material->textures[FBXMaterial::NormalTexture] != nullptr )
{
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::NormalTexture]->handle);
}
if ( mesh->m_material->textures[FBXMaterial::SpecularTexture] != nullptr )
{
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, mesh->m_material->textures[FBXMaterial::SpecularTexture]->handle);
}
unsigned int* glData = (unsigned int*)mesh->m_userData;
glBindVertexArray(glData[0]);
glDrawElements(GL_TRIANGLES, (unsigned int)mesh->m_indices.size(), GL_UNSIGNED_INT, 0);
}
}
}
void APP_Animation::Draw()
{
Gizmos::clear();
Gizmos::addTransform(glm::mat4(1));
vec4 white(1);
vec4 black(0, 0, 0, 1);
// draws the home grid
for (int i = 0; i < 21; ++i) {
Gizmos::addLine(vec3(-10 + i, 0, 10),
vec3(-10 + i, 0, -10),
i == 10 ? white : black);
Gizmos::addLine(vec3(10, 0, -10 + i),
vec3(-10, 0, -10 + i),
i == 10 ? white : black);
}
Gizmos::draw(GameCam->GetProjectionView());
glUseProgram(m_program);
// bind the camera
int loc = glGetUniformLocation(m_program, "ProjectionView");
glUniformMatrix4fv(loc, 1, GL_FALSE, &(GameCam->GetProjectionView()[0][0]));
int lightDirUniform = -1;
// bind the directional light position for a directional light
lightDirUniform = glGetUniformLocation(m_program, "directionalLight"); //get the directional light uniform index from the vertex shader
glm::vec3 dirLight = glm::vec3(0, 1, -10); //controls the lights position in the world
glUniform3fv(lightDirUniform, 1, glm::value_ptr(dirLight)); //set the lightDir uniform variabe in the vertex shader
// bind the point light position for a directional light
lightDirUniform = glGetUniformLocation(m_program, "pointLight"); //get the point light uniform index from the vertex shader
glm::vec3 pointLight = glm::vec3(0, -1, -1); //controls the lights position in the world
glUniform3fv(lightDirUniform, 1, glm::value_ptr(pointLight)); //set the lightDir uniform variabe in the vertex shader
// bind change the light colour
int lightColUniform = glGetUniformLocation(m_program, "lightColour"); //get the Time uniform index from the vertex shader
glm::vec3 lightColour = glm::vec3(1, 1, 1); //controls the lights colour
glUniform3fv(lightColUniform, 1, glm::value_ptr(lightColour)); //set the lightDir uniform variabe in the vertex shader
// bind change the camera position
int cameraPosUniform = glGetUniformLocation(m_program, "CameraPos"); //get the Time uniform index from the vertex shader
glm::vec3 cameraPos = glm::vec3(GameCam->GetWorldTransform()[3]); //controls the lights position in the world
glUniform3fv(cameraPosUniform, 1, glm::value_ptr(cameraPos)); //set the lightDir uniform variabe in the vertex shader
// bind change the spec power
int specPosUniform = glGetUniformLocation(m_program, "SpecPow"); //get the Time uniform index from the vertex shader
GLfloat specPow = 512; //controls the lights position in the world
glUniform1f(specPosUniform, specPow); //set the lightDir uniform variabe in the vertex shader
// grab the skeleton and animation we want to use
FBXSkeleton* skeleton = m_fbx->getSkeletonByIndex(0);
skeleton->updateBones();
int bones_location = glGetUniformLocation(m_program, "bones");
glUniformMatrix4fv(bones_location, skeleton->m_boneCount, GL_FALSE, (float*)skeleton->m_bones);
int global_location = glGetUniformLocation(m_program, "Global"); //apply a global scale
glUniformMatrix4fv(global_location, 1, GL_FALSE, glm::value_ptr(glm::scale(glm::vec3(.005, .005, .005))));
// bind our vertex array object and draw the mesh
unsigned int meshCount = m_fbx->getMeshCount();
for (unsigned int i = 0; i < meshCount; ++i) {
FBXMeshNode* mesh = m_fbx->getMeshByIndex(i);
unsigned int* glData = (unsigned int*)mesh->m_userData;
glBindVertexArray(glData[0]);
//set diffuse texture
glActiveTexture(GL_TEXTURE0); //set for initial active texture
glBindTexture(GL_TEXTURE_2D, glData[3]); //bind the diffuse texture
int difLoc = glGetUniformLocation(m_program, "Diffuse"); //get diffuse location
glUniform1i(difLoc, 0); //set to the diffuse to the texture index
glDrawElements(GL_TRIANGLES,
(unsigned int)mesh->m_indices.size(), GL_UNSIGNED_INT, 0);
}
}
