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();
}
}
/*virtual*/ void UIScreenEldMirror::Render( bool HasFocus )
{
XTRACE_FUNCTION;
UIScreen::Render( HasFocus );
RenderMesh( m_HeadMesh );
RenderMesh( m_BodyMesh );
RenderMesh( m_BackdropMesh );
}
void SceneSkyBox::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);
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.Scale(10, 10, 10);
RenderMesh(meshList[GEO_QUAD], false);
modelStack.PopMatrix();*/
//Loads the Skybox
RenderSkyBox();
//Mario
modelStack.PushMatrix();
modelStack.Scale(10, 10, 10);
modelStack.Translate(0.0f, 1.f, -0.4f);
modelStack.Rotate(90, 0.f, 1.f, 0.f);
modelStack.Rotate(90, 0.f, 0.f, 1.f);
RenderMesh(meshList[GEO_MARIO], false);
modelStack.PopMatrix();
}
//--------------------------------------------------------------------------------------
// Name: RenderFrame()
// Desc: Renders a frame (save state, apply matrix, render children, restore)
//--------------------------------------------------------------------------------------
VOID Mesh::RenderFrame( const MESH_FRAME* pFrame, DWORD dwFlags )
{
// Apply the frame's local transform
XMMATRIX matSavedWorld = m_matWorld;
m_matWorld = XMMatrixMultiply( pFrame->m_matTransform, m_matWorld );
// Render the mesh data
if( pFrame->m_pMeshData->m_dwNumSubsets )
{
// Call the callback, so the app can tweak state before rendering the mesh
DWORD dwFrame = pFrame - m_pFrames;
RenderMeshCallback( dwFrame, pFrame, dwFlags );
RenderMesh( pFrame->m_pMeshData, dwFlags );
}
// Render any child frames
if( pFrame->m_pChild )
RenderFrame( pFrame->m_pChild, dwFlags );
// Restore the transformation matrix
m_matWorld = matSavedWorld;
// Render any sibling frames
if( pFrame->m_pNext )
RenderFrame( pFrame->m_pNext, dwFlags );
}
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 CLcMdlSM::Render()
{
LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)LcDev_GetD3Device();
pDev->SetTransform(D3DTS_WORLD, &m_mtWld);
RenderMesh();
}
bool DexSkinMesh::Render()
{
DEX_ENSURE_B(DexModelBase::Render());
#ifdef _DEBUG
if (GetRenderFlag(SKINMESH_RENDER_JOINT))
{
DexMatrix4x4 jointScaleMatrix;
jointScaleMatrix.Scale(DexVector3(m_fJointScale, m_fJointScale, m_fJointScale));
for (size_t i = 0; i < m_vecJoints.size(); ++i)
DexGameEngine::getEngine()->RenderCube(jointScaleMatrix * m_vecJoints[i]->world_matrix);
}
if (GetRenderFlag(SKINMESH_RENDER_JOINT2JOINT))
{
m_pRootJoint->Render2Joint();
}
#endif
if (GetRenderFlag(SKINMESH_RENDER_MESH))
{//shader render
RenderMesh();
}
if (GetRenderFlag(SKINMESH_RENDER_VERTEXNORMAL))
{//render vertex normal, just use for debug
RenderVertexNormal();
}
if (GetRenderFlag(SKINMESH_RENDER_VERTEX2JOINT))
{//render vertex to joint
RenderVertexToJoint();
}
return true;
}
void PLANET5::RenderSkyBox()
{
modelStack.PushMatrix();
modelStack.Translate(0.f, 30.f, 0.f);
modelStack.Scale(5.f, 3.f, 5.f);
RenderMesh(meshList[GALLERY_WALL], false);
modelStack.PopMatrix();
}
void SP2::RenderDome(float scale, float x, float y, float z)
{
modelStack.PushMatrix();
modelStack.Translate(x, y, z);
modelStack.Scale(scale, scale, scale);
RenderMesh(meshList[GEO_DOME], false);
modelStack.PopMatrix();
}
void OpeningCutScene2::Render()
{
// Render VBO here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Set view matrix using camera settings
viewStack.LoadIdentity();
viewStack.Rotate(MoveCamera1, 0, 1, 0);
viewStack.Rotate(RotateCamera, 1, 0, 0);
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();
RenderSceneStart();
RenderTextWord();
// Light Source 1
if (light[0].type == Light::LIGHT_DIRECTIONAL)
{
Vector3 lightDir(light[0].position.x, light[0].position.y, light[0].position.z);
Vector3 lightDirection_cameraspace = viewStack.Top() * lightDir;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightDirection_cameraspace.x);
}
else if (light[0].type == Light::LIGHT_SPOT)
{
Position lightPosition_cameraspace = viewStack.Top() * light[0].position;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightPosition_cameraspace.x);
Vector3 spotDirection_cameraspace = viewStack.Top() * light[0].spotDirection;
glUniform3fv(m_parameters[U_LIGHT0_SPOTDIRECTION], 1, &spotDirection_cameraspace.x);
}
else
{
Position lightPosition_cameraspace = viewStack.Top() * light[0].position;
glUniform3fv(m_parameters[U_LIGHT0_POSITION], 1, &lightPosition_cameraspace.x);
}
//basic renders
modelStack.PushMatrix();
RenderModelOnScreen(meshList[GEO_QUAD], 80, 60, 5, 90, 1, 0, 0, 0.5f, 1+eyeOpening, 1, false);
modelStack.PopMatrix();
modelStack.PushMatrix();
RenderModelOnScreen(meshList[GEO_QUAD], 80, 60, 5, 90, 1, 0, 0, 0.5f, -eyeOpening, 1, false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 0, 53);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Scale(15, 15, 15);
RenderMesh(meshList[GEO_DEADBODY], true);
modelStack.PopMatrix();
}
void GameScene::RenderSkybox() {
modelStack.PushMatrix();
modelStack.Translate(camera.GetPosition().x, camera.GetPosition().y, camera.GetPosition().z);
float scaleSkybox = 1000.0f;
for (GEOMETRY_TYPE i = SKYBOX_FRONT; i <= SKYBOX_RIGHT; i = static_cast<GEOMETRY_TYPE>(i + 1)) {
modelStack.PushMatrix();
modelStack.Rotate(90 * (i - SKYBOX_FRONT), 0, 1, 0);
modelStack.Translate(scaleSkybox/2.0f - 1.0f, 0, 0);
modelStack.Rotate(90, 0, 0, 1);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Scale(scaleSkybox, 1, scaleSkybox);
RenderMesh(mesh[i], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, scaleSkybox/2.0f - 1.0f, 0);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(scaleSkybox, 1, scaleSkybox);
RenderMesh(mesh[SKYBOX_TOP], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, -scaleSkybox/2.0f + 1.0f, 0);
modelStack.Scale(scaleSkybox, 1, scaleSkybox);
RenderMesh(mesh[SKYBOX_BOTTOM], false);
modelStack.PopMatrix();
}
modelStack.PopMatrix();
}
void Scene::RenderGroundPlane(Camera* pCamera) {
static bool renderGroundPlane = false;
if(!renderGroundPlane)
return;
static Mat4f groundOrientation = Mat4f().storeIdentity();
static Vec4f groundPosition = Vec4f().storeZero();
RenderMesh(pCamera, m_pGroundShader, m_pGroundPlane,
groundPosition, groundOrientation);
}
void PLANET3::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();
RenderSkyBox();
}
const AniResult CEditModel::RenderFrame( const CMatrix& matWorld, float uCurFrame, RenderObjStyle* pRORS)
{
UpdateBox();
if (m_matCached!=matWorld)
{
m_matCached = matWorld;
m_bNeedUpdate = false;
}
float DeltaFrame = uCurFrame - m_RenderMatrix.m_CurFrame;
int32 DeltaTime = int32(DeltaFrame * GetCurFrameRatio());
CalculateMatrix( DeltaTime );
m_RenderMatrix.m_MatWorld = m_matCached;
m_RenderMatrix.m_CurrentTime += DeltaTime;
if (!m_isVisible)
return m_RenderMatrix.m_Result;
RenderObjStyle* pRenderRS = (pRORS && pRORS->m_eType == ROS_UNKNOWN) ? NULL : pRORS;
if ( pRORS && m_eRenderStyle!=pRORS->m_eType)
ClearModelRender();
if (NULL != pRenderRS)
{
if (m_bNeedPushRender)
{
m_eRenderStyle = pRORS->m_eType;
sMaterial* material = (sMaterial*)(pRORS->m_nParam2);
if (NULL != material)
m_Material = *(sMaterial*)(pRORS->m_nParam2);
CGraphic::GetInst()->BeginModel(this);
if ( pRORS->m_bRenderMesh )
RenderMesh( pRenderRS );
CGraphic::GetInst()->EndModel();
m_bNeedPushRender= false;
}
else
{
UpdateRenderStyle(pRenderRS);
}
}
m_RenderMatrix.m_CurrentTime = max(1,m_RenderMatrix.m_CurrentTime);
/*if ( !pRORS || pRORS->m_bRenderLink )
RenderLink( m_RenderMatrix.m_CurrentTime, pRenderRS );*/
if(m_OrgAABB.isNull())
UpdateDynamicBox();
//RenderDebugLine();
return m_RenderMatrix.m_Result;
}
void MeshLoader::RenderMesh(const aiNode* node) {
aiMatrix4x4 Mx = mAnimator->GetLocalTransform(node);
Mx.Transpose();
glPushMatrix();
glMultMatrixf((float*)&Mx);
for (unsigned int i = 0; i < node->mNumMeshes; i++) {
const aiMesh* mesh = m_Scene->mMeshes[node->mMeshes[i]];
std::vector<aiVector3D> CachedPosition(mesh->mNumVertices);
std::vector<aiVector3D> CachedNormal(mesh->mNumVertices);
if (mesh->HasBones()) {
const std::vector<aiMatrix4x4>& boneMatrices = mAnimator->GetBoneMatrices(node, i);
for (unsigned int a = 0; a < mesh->mNumBones; a++) {
const aiBone *bone = mesh->mBones[a];
const aiMatrix4x4& posTrafo = boneMatrices[a];
aiMatrix3x3 normTrafo = aiMatrix3x3(posTrafo);
for (unsigned int b = 0; b < bone->mNumWeights; b++)
{
const aiVertexWeight& weight = bone->mWeights[b];
unsigned int vertexId = weight.mVertexId;
const aiVector3D& srcPos = mesh->mVertices[vertexId];
const aiVector3D& srcNorm = mesh->mNormals[vertexId];
CachedPosition[vertexId] += weight.mWeight * (posTrafo * srcPos);
CachedNormal[vertexId] += weight.mWeight * (normTrafo * srcNorm);
}
}
}
ApplyMaterial(m_Scene->mMaterials[mesh->mMaterialIndex]);
for (unsigned int j = 0; j < mesh->mNumFaces; ++j) {
const aiFace* face = &mesh->mFaces[j];
glBegin(GL_TRIANGLES);
for (unsigned int k = 0; k < face->mNumIndices; k++) {
int v_index = face->mIndices[k];
if (mesh->mColors[0] != NULL)
glColor4fv((GLfloat*)&mesh->mColors[0][v_index]);
if (mesh->mNormals != NULL)
glNormal3fv(&CachedNormal[v_index].x);
glVertex3fv(&CachedPosition[v_index].x);
}
glEnd();
}
}
for (unsigned int i = 0; i < node->mNumChildren; i++) {
RenderMesh(node->mChildren[i]);
}
glPopMatrix();
}
void PLANET3::RenderNPC(StopNPC &temp, bool enableLight)
{
///////////////////////////HUMAN/////////////////////////////////
modelStack.PushMatrix();
modelStack.Translate(temp.getTranslate().x, temp.getTranslate().y, temp.getTranslate().z);
modelStack.Rotate(temp.getRotate().x, 1, 0, 0);
modelStack.Rotate(temp.getRotate().y + temp.rotateNPC, 0, 1, 0);
modelStack.Rotate(temp.getRotate().z, 0, 0, 1);
modelStack.Scale(3.f, 3.f, 3.f);
RenderMesh(meshList[NPC1_ARM], enableLight);
RenderMesh(meshList[NPC1_ARM2], enableLight);
modelStack.PushMatrix();
modelStack.Translate(0.f, -2.95f, 0.f);
RenderMesh(meshList[NPC1_LEG], enableLight);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0.f, -2.95f, 0.f);
RenderMesh(meshList[NPC1_LEG2], enableLight);
modelStack.PopMatrix();
RenderMesh(meshList[NPC1_CHEST], enableLight);
RenderMesh(meshList[NPC1_HEAD], enableLight);
modelStack.PopMatrix();
///////////////////////////HUMAN/////////////////////////////////
}
void RagDoll::Render() {
if (KeyDown(VK_RETURN)) {
for (int i=0; i<(int)m_boxes.size(); i++) {
m_boxes[i]->Render();
}
}
//Update Ragdoll from physical representation
UpdateSkeleton((Bone*)m_pRootBone);
//Render the ragdoll
RenderMesh(NULL);
}
void Assignment3::RenderAlien()
{
modelStack.PushMatrix();
modelStack.Translate(0, -3.2, 0);
RenderMesh(meshList[GEO_ALIENHEAD], true);
RenderMesh(meshList[GEO_ALIENBODY], true);
modelStack.PushMatrix();
modelStack.Translate(0, 2.9, 0);
modelStack.Rotate(alienArmRotate, 1, 0, 0);
modelStack.Translate(0, -2.9, 0);
modelStack.PushMatrix(); // arms
modelStack.Translate(-0.3, 2.7, 0);
modelStack.Scale(0.2, 0.4, 0.4);
RenderMesh(meshList[GEO_ALIENPART], true);
modelStack.PushMatrix();
modelStack.Translate(3, 0, 0);
RenderMesh(meshList[GEO_ALIENPART], true);
modelStack.PopMatrix();
modelStack.PopMatrix();
modelStack.PopMatrix();
modelStack.PopMatrix();
}
// TODO: if this gets used more, will probably need split between alpha/non
void Scene::RenderDynamicEntities(Camera* pCamera) {
for(const auto pEntity : m_dynamicEntities) {
if(pEntity->m_pMesh && pEntity->m_pMesh->hasSkinning()) {
//TODO: sort by shader transition
RenderMesh(pCamera, pEntity->m_pShader, pEntity->m_pMesh,
pEntity->m_position, pEntity->m_orientation);
} else {
RenderMeshSkinned(pCamera, pEntity->m_pShader, pEntity->m_pMesh,
pEntity->m_position, pEntity->m_orientation);
}
}
//printf("dynamic entities took %f\n", dyn.GetElapsed());
}
void SP2::RenderMuseum()
{
modelStack.PushMatrix();
//to do: transformation code here
modelStack.Translate(0, -20, -398);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Rotate(180, 0, 0, 1);
modelStack.Scale(700, 700, 700);
RenderMesh(meshList[GEO_FRONT], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
//to do: transformation code here
modelStack.Translate(0, 0, -0.9);
modelStack.Translate(0, -20, 600);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Scale(700, 700, 700);
RenderMesh(meshList[GEO_BACK], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
//to do: transformation code here
modelStack.Translate(5, 0, 0);
modelStack.Translate(-500, -20, 100);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(-180, 1, 0, 0);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Scale(700, 700, 700);
RenderMesh(meshList[GEO_LEFT], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
//to do: transformation code here
modelStack.Translate(-5, 0, 0);
modelStack.Translate(500, -20, 100);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Scale(700, 700, 700);
RenderMesh(meshList[GEO_RIGHT], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
//to do: transformation code here
modelStack.Translate(0, -500, 100);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(700, 700, 700);
RenderMesh(meshList[GEO_BOTTOM], true);
modelStack.PopMatrix();
modelStack.PushMatrix();
//to do: transformation code here
modelStack.Translate(0, -11, 0);
modelStack.Translate(0, 490, 100);
modelStack.Rotate(90, 0, 1, 0);
modelStack.Rotate(360, 0, 0, 1);
modelStack.Scale(700, 700, 700);
RenderMesh(meshList[GEO_TOP], true);
modelStack.PopMatrix();
}
void CModel::Render() {
//create display list, if not already there
if (mDisplayList.get() == nullptr) {
mDisplayList.reset(new GLUtils::CGLDisplayList());
if (mDisplayList->IsValid()) {
mDisplayList->BeginDefine();
RenderMesh();
mDisplayList->EndDefine();
}
}
mDisplayList->Render();
}
void Model::ProcessNode(aiNode* node, const aiScene* scene)
{
for (uint i = 0; i < node->mNumMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
Mesh m = ProcessMesh(mesh, scene);
m_Meshs.push_back(m);
m_RenderMeshs.push_back(RenderMesh(m));
}
for (uint i = 0; i < node->mNumChildren; i++)
{
this->ProcessNode(node->mChildren[i], scene);
}
}
void Indoor3::RenderSkybox()
{
modelStack.PushMatrix();
modelStack.Rotate(rotateskybox, 0, 1, 0);
{
modelStack.PushMatrix();
modelStack.Translate(0, 49.875, -498.75);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Scale(1000, 50, 100);
RenderMesh(meshList[SPACE_FRONT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 49.875, 498.75);
modelStack.Rotate(180, 0, 0, 1);
modelStack.Rotate(-90, 1, 0, 0);
modelStack.Scale(1000, 50, 100);
RenderMesh(meshList[SPACE_BACK], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 99.75, 0);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(1000, 1000, 1000);
RenderMesh(meshList[SPACE_TOP], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 0, 0);
modelStack.Rotate(-180, 0, 1, 0);
modelStack.Scale(1000, 1000, 1000);
RenderMesh(meshList[SPACE_BOTTOM], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-498.75, 49.875, 0);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Scale(1000, 50, 100);
RenderMesh(meshList[SPACE_LEFT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(498.75, 49.875, 0);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Rotate(90, 0, 0, 1);
modelStack.Scale(1000, 50, 100);
RenderMesh(meshList[SPACE_RIGHT], false);
modelStack.PopMatrix();
}
modelStack.PopMatrix();
}
int GameScene::render()
{
D3DXMATRIXA16* pmat=new D3DXMATRIXA16;
D3DXMatrixTranslation(pmat,0,0,0);
ostringstream oss;
oss<<rendercs*x;
TextOutA(Hwdc,50,50,oss.str().c_str(),5);
rendercs++;
//测试SceneObject对象run
pOList->resetIterator();
do
{
SceneObject*pSOm=pOList->getObject();
if(NULL==pSOm)
{
break;
}
//渲染场景的位置-------------------------------------------------------------------------------------------------------------------
if(pSOm->pShap!=NULL)
{
RenderMesh(pSOm->pShap->mesh,pSOm->pShap->pMeshMaterials,pSOm->pShap->pMeshTextures,pSOm->pShap->dwNumMaterials,&(pSOm->mMat));
}
TextOutA(Hwdc,50,100,pOList->getObject()->sName.c_str(),5);
ostringstream oss2;
oss2<<pOList->L_SceneObject.size();
TextOutA(Hwdc,50,150,oss2.str().c_str(),5);
}while(NULL!=pOList->nextObject());
//lua测试
/*
luaL_openlibs(pSLua);
lua_pushcfunction(pSLua, luatestGlue);
lua_setglobal(pSLua, "luatestGlue");
luaL_dofile(pSLua,"testlua.lua");
TextOutA(Hwdc,50,50,,5);
*/
return 1;
}
void SceneSkyBox::RenderSkyBox()
{
modelStack.PushMatrix();//For da entire skybox
modelStack.Scale(100, 100, 100);
//top
modelStack.PushMatrix();
modelStack.Translate(0, 1, 0);
modelStack.Rotate(180, 0.f, 0.f, 1.f);
RenderMesh(meshList[GEO_TOP], false);
modelStack.PopMatrix();
//bottom
modelStack.PushMatrix();
modelStack.Translate(0, 0, 0);
RenderMesh(meshList[GEO_BOTTOM], false);
modelStack.PopMatrix();
//Left
modelStack.PushMatrix();
modelStack.Translate(-0.5, 0.5, 0);
modelStack.Rotate(180, 0.f, 1.f, 0.f);
modelStack.Rotate(90, 0.f, 0.f, 1.f);
RenderMesh(meshList[GEO_LEFT], false);
modelStack.PopMatrix();
//Right
modelStack.PushMatrix();
modelStack.Translate(0.5, 0.5, 0);
modelStack.Rotate(90, 0.f, 0.f, 1.f);
RenderMesh(meshList[GEO_RIGHT], false);
modelStack.PopMatrix();
//front
modelStack.PushMatrix();
modelStack.Translate(0.0f, 0.5, -0.5f);
modelStack.Rotate(90, 0.f, 1.f, 0.f);
modelStack.Rotate(90, 0.f, 0.f, 1.f);
RenderMesh(meshList[GEO_FRONT], false);
modelStack.PopMatrix();
//Back
modelStack.PushMatrix();
modelStack.Translate(0.0f, 0.5, 0.5f);
modelStack.Rotate(-90, 0.f, 1.f, 0.f);
modelStack.Rotate(90, 0.f, 0.f, 1.f);
RenderMesh(meshList[GEO_BACK], false);
modelStack.PopMatrix();
modelStack.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();
}
//--------------------------------------------------------------------------------------
_Use_decl_annotations_
void CMultiDeviceContextDXUTMesh::RenderFrame( UINT iFrame,
bool bAdjacent,
ID3D11DeviceContext* pd3dDeviceContext,
UINT iDiffuseSlot,
UINT iNormalSlot,
UINT iSpecularSlot )
{
if( !m_pStaticMeshData || !m_pFrameArray )
return;
if( m_pFrameArray[iFrame].Mesh != INVALID_MESH )
{
if ( !m_pRenderMeshCallback )
{
RenderMesh( m_pFrameArray[iFrame].Mesh,
bAdjacent,
pd3dDeviceContext,
iDiffuseSlot,
iNormalSlot,
iSpecularSlot );
}
else
{
m_pRenderMeshCallback( this,
m_pFrameArray[iFrame].Mesh,
bAdjacent,
pd3dDeviceContext,
iDiffuseSlot,
iNormalSlot,
iSpecularSlot );
}
}
// Render our children
if( m_pFrameArray[iFrame].ChildFrame != INVALID_FRAME )
RenderFrame( m_pFrameArray[iFrame].ChildFrame, bAdjacent, pd3dDeviceContext, iDiffuseSlot,
iNormalSlot, iSpecularSlot );
// Render our siblings
if( m_pFrameArray[iFrame].SiblingFrame != INVALID_FRAME )
RenderFrame( m_pFrameArray[iFrame].SiblingFrame, bAdjacent, pd3dDeviceContext, iDiffuseSlot,
iNormalSlot, iSpecularSlot );
}
//******************************************************************************************************//
void Assignment3::RenderSkybox() // rendering of skybox
{
modelStack.PushMatrix();
modelStack.Rotate(skyBoxRotate*2, 1, 1, 0);
modelStack.PushMatrix();
modelStack.Translate(0, -499, 0);
modelStack.Scale(1001, 1001, 1001);
RenderMesh(meshList[GEO_BOTTOM], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 500, 0);
modelStack.Rotate(180, 0, 1, 0);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(1005, 1005, 1005);
RenderMesh(meshList[GEO_TOP], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 0, 499);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(-90, 1, 0, 0);
modelStack.Scale(1000, 1000, 1000);
RenderMesh(meshList[GEO_LEFT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(0, 0, -499);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(90, 1, 0, 0);
modelStack.Scale(1001, 1001, 1001);
RenderMesh(meshList[GEO_RIGHT], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(499, 0, 0);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(180, 1, 0, 0);
modelStack.Scale(1001, 1001, 1001);
RenderMesh(meshList[GEO_BACK], false);
modelStack.PopMatrix();
modelStack.PushMatrix();
modelStack.Translate(-499, 0, 0);
modelStack.Rotate(-90, 0, 0, 1);
modelStack.Rotate(0, 1, 0, 0);
modelStack.Scale(1001, 1001, 1001);
RenderMesh(meshList[GEO_FRONT], false);
modelStack.PopMatrix();
modelStack.PopMatrix();
}
void GameScene::RenderObjects() {
for (list<GameObject*>::iterator iter = gameObjects.begin(); iter != gameObjects.end(); ++iter) {
if ((*iter)->IsDisabled()) {
modelStack.PushMatrix();
modelStack.Translate((*iter)->GetPosition().x, (*iter)->GetPosition().y, (*iter)->GetPosition().z);
modelStack.MultMatrix((*iter)->GetRotationMatrix());
RenderMesh((*iter)->GetMesh(), true);
modelStack.PopMatrix();
}
}
}
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();
}
