// Sets the rotation matrix to a given value. void GameObject::SetRotation(glm::mat4* rotMatrix) { rotation = *rotMatrix; // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
// Sets the translations to the exact x, y, and z position values given. void GameObject::SetTranslation(glm::vec3 transFactor) { // Translates the identity matrix. translation = glm::translate(glm::mat4(), transFactor); // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
// Translates in the x, y, and z directions based on the given values. void GameObject::Translate(glm::vec3 transFactor) { // Translates the translation matrix. translation = glm::translate(translation, transFactor); // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
// Sets the scale in the x, y, and z position to the given values. void GameObject::SetScale(glm::vec3 scaleFactor) { // Scales the identity matrix. scale = glm::scale(glm::mat4(), scaleFactor); // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
// Scales the current scale value by the x, y and z values given. (So if the scale is [0.5, 0.5, 0.5] and we pass in [0.5, 0.5, 0.5] we end up with [0.25, 0.25, 0.25].) void GameObject::Scale(glm::vec3 scaleFactor) { // Scales the scale matrix. scale = glm::scale(scale, scaleFactor); // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
void cShadowMapping::BeginRenderToShadowMap(opengl::cContext& context, const spitfire::math::cVec3& lightPosition, const spitfire::math::cVec3& lightDirection) { const spitfire::math::cColour clearColour(0.0f, 0.0f, 0.0f); context.SetClearColour(clearColour); context.BeginRenderToTexture(textureDepthTexture); context.BindShader(shaderRenderToDepthTexture); CalculateMatrices(context, lightPosition, lightDirection); }
// Sets the rotation matrix to a given value of x, y, and z radians. void GameObject::SetRotation(glm::vec3 rotFactor) { // WARNING: These are interpreted as radian values, so be sure to specify them not as degrees. // Set our quaternion equal to a quaternion created from the given euler angles. quaternion = glm::quat(rotFactor); // Turn our quaternion into a mat4. rotation = glm::toMat4(quaternion); // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
// Rotates in x, y, and z radians based on given values. void GameObject::Rotate(glm::vec3 rotFactor) { // WARNING: These are interpreted as radian values, so be sure to specify them not as degrees. // Create a quaternion based on the euler angles given. glm::quat q = glm::quat(rotFactor); // Rotate our quaternion by that quaternion's value. quaternion *= q; // Turn our quaternion into a mat4. rotation = glm::toMat4(quaternion); // Then we have to recalculate the transformation matrix. CalculateMatrices(); }
void Model::Render( ComPtr<ID3D11DeviceContext> const devcon, const D3DXMATRIX& viewProjectionMatrix) { // Set the model's input layout as active devcon->IASetInputLayout(modelLayout.Get()); // Set the vertex buffer UINT stride = sizeof(Vertex); UINT offset = 0; devcon->IASetVertexBuffers(0, 1, vertexBuffer.GetAddressOf(), &stride, &offset); devcon->IASetIndexBuffer(indexBuffer.Get(), INDEX_FORMAT, 0); // Render the model's texture material->Render(devcon); // Calculate the transformation matrices CalculateMatrices(viewProjectionMatrix); }
// adjust the camera planes to contain the visible scene as tightly as possible void ShadowCamera::AdjustPlanes(const std::vector<SceneObject *> &VisibleObjects) { if(VisibleObjects.size() == 0) return; // find the nearest and farthest points of given // scene objects in camera's view space // float fMaxZ = 0; float fMinZ = FLT_MAX; noVec3 vDir = Normalize(m_vTarget - m_vSource); // for each object for(unsigned int i = 0; i < VisibleObjects.size(); i++) { SceneObject *pObject = VisibleObjects[i]; // for each point in AABB for(int j = 0; j < 8; j++) { // calculate z-coordinate distance to near plane of camera noVec3 vPointToCam = pObject->m_AABB.m_pPoints[j] - m_vSource; float fZ = Dot(vPointToCam, vDir); // find boundary values if(fZ > fMaxZ) fMaxZ = fZ; if(fZ < fMinZ) fMinZ = fZ; } } // use smallest distance as new near plane // and make sure it is not too small m_fNear = Max(fMinZ, m_fNearMin); // use largest distance as new far plane // and make sure it is larger than nearPlane m_fFar = Max(fMaxZ, m_fNear + 1.0f); // update matrices CalculateMatrices(); }
// processes camera controls void ShadowCamera::DoControls(void) { float fDeltaTime = DeltaTimeUpdate(m_ControlState.fLastUpdate); noVec3 vZ = Normalize(m_vTarget - m_vSource); noVec3 vX = Normalize(Cross(m_vUpVector, vZ)); noVec3 vY = Normalize(Cross(vZ, vX)); // Rotating with mouse left // // if(GetMouseDown(VK_LBUTTON)) { if(!m_ControlState.bRotating) { GetCursorPos(&m_ControlState.pntMouse); m_ControlState.bZooming = false; m_ControlState.bStrafing = false; m_ControlState.bRotating = true; } POINT pntMouseCurrent; GetCursorPos(&pntMouseCurrent); noVec3 vTargetToSource = m_vTarget - m_vSource; float fLength = vTargetToSource.Length(); m_ControlState.fRotX += 0.005f * (float)(pntMouseCurrent.x - m_ControlState.pntMouse.x); m_ControlState.fRotY += 0.005f * (float)(pntMouseCurrent.y - m_ControlState.pntMouse.y); m_ControlState.fRotY = Clamp(m_ControlState.fRotY, DegreeToRadian(-89.9f), DegreeToRadian(89.9f)); Matrix mRotation; mRotation.SetIdentity(); mRotation.SetRotation(noVec3(m_ControlState.fRotX, m_ControlState.fRotY,0)); m_vTarget.x = mRotation._31 * fLength + m_vSource.x; m_vTarget.y = mRotation._32 * fLength + m_vSource.y; m_vTarget.z = mRotation._33 * fLength + m_vSource.z; m_ControlState.pntMouse = pntMouseCurrent; // Strafing with mouse middle // // } else if(GetMouseDown(VK_MBUTTON)) { if(!m_ControlState.bStrafing) { GetCursorPos(&m_ControlState.pntMouse); m_ControlState.bZooming = false; m_ControlState.bRotating = false; m_ControlState.bStrafing = true; } POINT pntMouseCurrent; GetCursorPos(&pntMouseCurrent); m_vSource -= vX * 0.15f * (float)(pntMouseCurrent.x - m_ControlState.pntMouse.x); m_vTarget -= vX * 0.15f * (float)(pntMouseCurrent.x - m_ControlState.pntMouse.x); m_vSource += vY * 0.15f * (float)(pntMouseCurrent.y - m_ControlState.pntMouse.y); m_vTarget += vY * 0.15f * (float)(pntMouseCurrent.y - m_ControlState.pntMouse.y); m_ControlState.pntMouse = pntMouseCurrent; // Zooming with mouse right // // } else if(GetMouseDown(VK_RBUTTON)) { if(!m_ControlState.bZooming) { GetCursorPos(&m_ControlState.pntMouse); m_ControlState.bZooming = true; m_ControlState.bRotating = false; m_ControlState.bStrafing = false; } POINT pntMouseCurrent; GetCursorPos(&pntMouseCurrent); m_vSource += vZ * 0.5f * (float)(pntMouseCurrent.y - m_ControlState.pntMouse.y); m_vTarget += vZ * 0.5f * (float)(pntMouseCurrent.y - m_ControlState.pntMouse.y); m_ControlState.pntMouse = pntMouseCurrent; // Mouse is idle // } else { m_ControlState.bZooming = false; m_ControlState.bRotating = false; m_ControlState.bStrafing = false; } // Move forward/backward // if(GetKeyDown('W')) { m_vSource += vZ * fDeltaTime; m_vTarget += vZ * fDeltaTime; } else if(GetKeyDown('S')) { m_vSource -= vZ * fDeltaTime; m_vTarget -= vZ * fDeltaTime; } // Strafing // if(GetKeyDown('D')) { m_vSource += vX * fDeltaTime; m_vTarget += vX * fDeltaTime; } else if(GetKeyDown('A')) { m_vSource -= vX * fDeltaTime; m_vTarget -= vX * fDeltaTime; } // Up/down (many control preferences here :) // if(GetKeyDown('Q') || GetKeyDown(VK_SPACE)) { m_vSource += vY * fDeltaTime; m_vTarget += vY * fDeltaTime; } else if(GetKeyDown('E') || GetKeyDown('C') || GetKeyDown(VK_CONTROL)) { m_vSource -= vY * fDeltaTime; m_vTarget -= vY * fDeltaTime; } CalculateMatrices(); }