void RenderScene() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The matrix // Give OpenGL our camera position g_Camera.Look(); // Render the height map RenderHeightMap(g_HeightMap); /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * // Just for an added effect, I created a sky box that surrounds the terrain, // along with a check to make sure the camera doesn't go through the terrain. // It's as simple and checking the height of the current x and z position // of the camera, and making sure that the camera's y position isn't lower // than the height of the terrain at that point. This is a simple check, // and of course will produce choppy results. In a future tutorial we will // have some good smooth collision detection along the terrain. // Create the sky box and center it around the terrain CreateSkyBox(500, 0, 500, 2000, 2000, 2000); // Get the current position of the camera CVector3 vPos = g_Camera.Position(); CVector3 vNewPos = vPos; // Check if the camera is below the height of the terrain at x and z, // but we add 10 to make it so the camera isn't on the floor. if(vPos.y < Height(g_HeightMap, (int)vPos.x, (int)vPos.z ) + 10) { // Set the new position of the camera so it's above the terrain + 10 vNewPos.y = (float)Height(g_HeightMap, (int)vPos.x, (int)vPos.z ) + 10; // Get the difference of the y that the camera was pushed back up float temp = vNewPos.y - vPos.y; // Get the current view and increase it by the different the position was moved CVector3 vView = g_Camera.View(); vView.y += temp; // Set the new camera position. g_Camera.PositionCamera(vNewPos.x, vNewPos.y, vNewPos.z, vView.x, vView.y, vView.z, 0, 1, 0); } /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * // Swap the backbuffers to the foreground SwapBuffers(g_hDC); assert(glGetError() == GL_NO_ERROR); }
///////////// //DisplayLoop ///////////// void display(void) { //glPushMatrix(); //start matrix glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //glColor3f(1.0, 1.0, 1.0); //set color of rectangle //glEnable( GL_TEXTURE_2D ); //glBindTexture( GL_TEXTURE_2D, tex ); //glTranslatef(0.0, 0.0, -5.0); //set origin of shape (5 units into the distance) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The Matrix // Position View Up Vector gluLookAt(212, 60, 194, 186, 55, 171, 0, 1, 0); // This Determines Where The Camera's Position And View Is glRotatef(rot, 0.0, 1.0, 0.0); //rotate 20 degrees around the x axis glTranslatef(-65.0, 00.0, -50.0); glScalef(scaleValue, scaleValue * HEIGHT_RATIO, scaleValue); RenderHeightMap(g_HeightMap); // Render The Height Map /* glBegin(GL_QUADS); //begin shape //glColor4f(1.0, 0.0, 0.0, 1.0); //glTexCoord2f(0, 0); glVertex3f(-1.0, -1.0, 0.0); //draw each vertex //glColor4f(0.0, 1.0, 0.0, 1.0); //glTexCoord2f(1, 0); glVertex3f(1.0, -1.0, 0.0); //glColor4f(0.0, 0.0, 1.0, 1.0); //glTexCoord2f(1, 1); glVertex3f(1.0, 1.0, 0.0); //glColor4f(1.0, 1.0, 0.0, 1.0); //glTexCoord2f(0, 1); glVertex3f(-1.0, 1.0, 0.0); glEnd(); */ //end shape //glPopMatrix(); //end matrix glutSwapBuffers(); rot += .1; //increase rotation amount }
int drawGLScene(GLvoid) /* Here's Where We Do All The Drawing */ { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* Clear The Screen And The Depth Buffer */ glLoadIdentity(); /* Reset The Matrix */ /* Position View Up Vector */ gluLookAt(212, 60, 194, 186, 55, 171, 0, 1, 0); /* This Determines Where The Camera's Position And View Is */ glScalef(scaleValue, scaleValue * HEIGHT_RATIO, scaleValue); RenderHeightMap(g_HeightMap); /* Render The Height Map */ return True; /* Keep Going */ }
/** * Clear the screen, then render the mesh using the given camera. * @param camera The logical camera to use. * @see math/camera.hpp */ void OpenglProject::render( const Camera* camera ) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(camera->fov * 180 / PI, camera->aspect, camera->near_clip, camera->far_clip); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); Vector3 eye = camera->get_position(); Vector3 target = camera->get_position() + camera->get_direction(); gluLookAt(eye.x, eye.y, eye.z, target.x, target.y, target.z, camera->get_up().x, camera->get_up().y, camera->get_up().z); RenderMesh(); RenderHeightMap(); }
void RenderScene() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The matrix // Get the current position of the camera CVector3 vPos = g_Camera.Position(); CVector3 vNewPos = vPos; // Check if the camera is below the height of the terrain at x and z, // but we add 10 to make it so the camera isn't on the floor. if(vPos.y < Height(g_HeightMap, (int)vPos.x, (int)vPos.z ) + 10) { // Set the new position of the camera so it's above the terrain + 10 vNewPos.y = (float)Height(g_HeightMap, (int)vPos.x, (int)vPos.z ) + 10; // Get the difference of the y that the camera was pushed back up float temp = vNewPos.y - vPos.y; // Get the current view and increase it by the different the position was moved CVector3 vView = g_Camera.View(); vView.y += temp; // Set the new camera position. g_Camera.PositionCamera(vNewPos.x, vNewPos.y, vNewPos.z, vView.x, vView.y, vView.z, 0, 1, 0); } // Give OpenGL our camera position g_Camera.Look(); // Render the height map RenderHeightMap(g_HeightMap); // Create the sky box and center it around the terrain CreateSkyBox(500, 0, 500, 2000, 2000, 2000); // Swap the backbuffers to the foreground SwapBuffers(g_hDC); }
void RenderScene() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The matrix /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * // Give OpenGL our camera position g_Camera.Look(); // If we pass the g_HeightMap data into our RenderHeightMap() function it will // render the terrain in QUADS. If you are going to make any use of this function, // it might be a good idea to put in an (X, Y) parameter to draw it at, or just use // OpenGL's matrix operations (glTranslatef() glRotate(), etc...) RenderHeightMap(g_HeightMap); // Render the height map /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * SwapBuffers(g_hDC); // Swap the backbuffers to the foreground }
void RenderScene() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The matrix // Get the current position of the camera CVector3 vPos = g_Camera.Position(); CVector3 vNewPos = vPos; // Check if the camera is below the height of the terrain at x and z, // but we add 10 to make it so the camera isn't on the floor. if(vPos.y < Height(g_HeightMap, (int)vPos.x, (int)vPos.z ) + 10) { // Set the new position of the camera so it's above the terrain + 10 vNewPos.y = (float)Height(g_HeightMap, (int)vPos.x, (int)vPos.z ) + 10; // Get the difference of the y that the camera was pushed back up float temp = vNewPos.y - vPos.y; // Get the current view and increase it by the different the position was moved CVector3 vView = g_Camera.View(); vView.y += temp; // Set the new camera position. g_Camera.PositionCamera(vNewPos.x, vNewPos.y, vNewPos.z, vView.x, vView.y, vView.z, 0, 1, 0); } // Give OpenGL our camera position g_Camera.Look(); /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * // Here comes the most technical part of our tutorial--clipping planes. // We turn the terrain upside-down, so we don't want the bottom sticking // out of the water, so we need to create a clipping plane that will // clip anything that is above it. In this case, (0, -1, 0) is the normal // of the plane to clip, and we finally give it out distance from the // origin--g_WaterHeight. double reflectPlane[] = {0.0f, -1.0f, 0.0f, g_WaterHeight}; glEnable(GL_CLIP_PLANE0); // Turn on clipping for plane 0 // This is where we select the clipping plane we want to use, and then the // plane's data is passed in as an array of floats (ABC and D). You can have // many clipping planes going, which is why we need to specify which one we want. glClipPlane(GL_CLIP_PLANE0, reflectPlane); // Now comes the reflection! // Pop on a new matrix so our translation/scaling doesn't effect other data glPushMatrix(); // We first need to translate the terrain to the water height multiplied by 2, // since we are reflecting it upside down at that height. glTranslatef(0.0f, g_WaterHeight*2.0f, 0.0f); // We then use glScale() to flip the terrain upside-down (-1 flips it). glScalef(1.0, -1.0, 1.0); // Since the terrain is upside-down we need to do front-face culling. glCullFace(GL_FRONT); // Now we render the terrain and the skybx upside-down for the reflection. RenderHeightMap(g_HeightMap); CreateSkyBox(500, 0, 500, 2000, 2000, 2000); // Now we can restore the app to back-face culling glCullFace(GL_BACK); // Leave the previous matrix and go back to the original matrix glPopMatrix(); // Since the reflection is already drawn, let's turn off clipping. glDisable(GL_CLIP_PLANE0); // Now we actually draw the water blended over the reflection, which // creates the effect that the reflection is in the water. We blend // with a simple alpha to one minus alpha blending function. The color // is set to a blue, with the alpha value at 50% (0.5). We don't want // the alpha too high or else we wouldn't see the reflection. glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(0.5f, 0.5f, 0.9f, 0.5f); DrawWater(g_WaterHeight); glDisable(GL_BLEND); // Render the height map normally, right-side-up. RenderHeightMap(g_HeightMap); // Create the sky box and center it around the terrain CreateSkyBox(500, 0, 500, 2000, 2000, 2000); // This block of code right here is for an added effect of // what is draw when you are under the water. This isn't necessary, // but I thought I would add it to improve the tutorial's realism. // When we go underwater we want to be able to look up out of the // water. To do that we just render the water again, but change // the culling to front-face, then change our water color. Nothing special. // We could just do a check to see if we are under or over the water, // then only render the water once, but I think you can do that yourself. glCullFace(GL_FRONT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(0.0f, 0.0f, 0.9f, 0.5f); DrawWater(g_WaterHeight); glDisable(GL_BLEND); glCullFace(GL_BACK); /////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// * // Swap the backbuffers to the foreground SwapBuffers(g_hDC); }
////////////////////////////////////////////////////////////////////////// //캐릭터 툴을 위한 렌더 함수 //render를 pre - main - post renderring 구조에서 main을 담당 ////////////////////////////////////////////////////////////////////////// YAMANGDXDLL_API void RenderingTool( MESHOBJECT* inputVal ) { if ( NULL == g_D3dDevice ) { return; } if ( g_Mesh == nullptr ) { InitGroundMesh( 100, 100 ); } g_D3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 30, 10, 10 ), 1.0f, 0 ); // 렌더 방어코드 if ( SUCCEEDED( g_D3dDevice->BeginScene() ) ) { // SetupTranslateMatricesTool(); // 일단 height map 등 다른 쪽을 생각할 것 // ViewSetting(); // lightsetting // 일단 1로 진행, 향후 라이트 개수 등 확정되면 인자 받아 설정 int lightNum = 1; Lighting( lightNum ); // Log( "라이팅 세팅!\n" ); g_D3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE ); g_D3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); g_D3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ); g_D3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE ); // Log( "Render Begin \n" ); // Log( "pre render 완료!\n" ); } // 카메라 셋팅 D3DXMATRIXA16 viewMatrix; D3DXMatrixLookAtLH( &viewMatrix, &g_EyePoint, &g_LookAtPoint, &g_UpVector ); SetCameraMatrix( &viewMatrix ); // 보여주기 위한 땅을 만듬 //InitGroundMesh(100, 100); CreateRawGround( 100, 100, 10 ); RenderHeightMap(); g_D3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); // Log( "Now Render : %p \n", inputVal ); for ( DWORD i = 0; i < inputVal->NumMaterials; ++i ) { g_D3dDevice->SetMaterial( &inputVal->MeshMarterials[i] ); g_D3dDevice->SetTexture( 0, inputVal->MeshTexture[i] ); ( inputVal->importedMesh )->DrawSubset( i ); } g_D3dDevice->EndScene(); // Log( "Render End \n" ); g_D3dDevice->Present( NULL, NULL, NULL, NULL ); }