void World::Render() { ResourceManager* resourceManager = ResourceManager::GetInstance(); glm::mat4 depthProj = glm::ortho<float>(-5, 5, -5, 5, -100, 100); glm::mat4 depthView = glm::lookAt(mCamera->GetPosition() - glm::normalize(glm::vec3(1.0f, -3.0f, 2.0f)) * 10.0f, mCamera->GetPosition(), glm::vec3(0, 1, 0)); Shader* depthShader = resourceManager->GetShader("depth"); Shader* defaultShader = resourceManager->GetShader("default"); // Depth map rendering mFbo->Bind(); depthShader->Bind(); RenderObjects(depthShader, depthProj, depthView, false); mFbo->Unbind(); // World rendering defaultShader->Bind(); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, mFbo->textureID); glUniform1i(defaultShader->GetUniformLocation("shadowMap"), 1); GLuint depthMVPLocation = defaultShader->GetUniformLocation("depthMVP"); glUniformMatrix4fv(depthMVPLocation, 1, GL_FALSE, &(depthProj * depthView)[0][0]); RenderObjects(defaultShader, mProjection, mCamera->GetView(), true); }
void RenderScene() { // First render shadows renderer_->CullFace(sht::graphics::CullFaceType::kFront); ShadowPass(); renderer_->CullFace(sht::graphics::CullFaceType::kBack); if (show_shadow_texture_) { quad_shader_->Bind(); quad_shader_->Uniform1i("u_texture", 0); renderer_->ChangeTexture(shadow_depth_rt_, 0); quad_->Render(); renderer_->ChangeTexture(nullptr, 0); quad_shader_->Unbind(); } else { // Render objects object_shader_->Bind(); object_shader_->UniformMatrix4fv("u_projection_view", projection_view_matrix_); object_shader_->UniformMatrix4fv("u_depth_bias_projection_view", depth_bias_projection_view_matrix_); renderer_->ChangeTexture(shadow_depth_rt_, 0); RenderObjects(object_shader_); renderer_->ChangeTexture(nullptr, 0); object_shader_->Unbind(); } }
void ShadowPass() { // Generate matrix for shadows // Ortho matrix is used for directional light sources and perspective for spot ones. float znear = light_distance_ - 2.0f; float zfar = light_distance_ + 2.0f; sht::math::Matrix4 depth_projection = sht::math::PerspectiveMatrix(45.0f, 1, 1, znear, zfar);//sht::math::OrthoMatrix() sht::math::Matrix4 depth_view = sht::math::LookAt(light_position_, vec3(0.0f)); sht::math::Matrix4 depth_projection_view = depth_projection * depth_view; sht::math::Matrix4 bias_matrix( 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.5f, 0.5f, 0.5f, 1.0f ); depth_bias_projection_view_matrix_ = bias_matrix * depth_projection_view; renderer_->ChangeRenderTarget(nullptr, shadow_depth_rt_); renderer_->ClearColorAndDepthBuffers(); object_shadow_shader_->Bind(); object_shadow_shader_->UniformMatrix4fv("u_projection_view", depth_projection_view); RenderObjects(object_shadow_shader_); object_shadow_shader_->Unbind(); renderer_->ChangeRenderTarget(nullptr, nullptr); }
void MainScene::Render() { switch (renderState) { case isGameOver: ScreenManager::FailureScreen(); break; case isLevelUpdate: ScreenManager::ReadyScreen(); break; case isMissionClear: ScreenManager::SuccesScreen(); break; case isPrimeDraw: ScreenManager::PrimeScreen(); case isUiDraw: ScreenManager::ScoreUIScreen(); case isGameing: RenderObjects(); break; default: break; } }
void Render() final { renderer_->SetViewport(width_, height_); renderer_->ClearColor(0.0f, 0.0f, 0.0f, 1.0f); renderer_->ClearColorAndDepthBuffers(); RenderObjects(); RenderInterface(); }
// Handler for activating the inerita processor VOID CComTouchDriver::ProcessChanges() { // Run through the list of core objects and process any of its active inertia processors std::list<CCoreObject*>::iterator it; for(it = m_lCoreObjects.begin(); it != m_lCoreObjects.end(); ++it) { if((*it)->bIsInertiaActive == TRUE) { BOOL bCompleted = FALSE; (*it)->inertiaProc->Process(&bCompleted); } } // Render all the changes RenderObjects(); }
VOID CComTouchDriver::DownEvent(CCoreObject* coRef, const TOUCHINPUT* inData, BOOL* bFound) { DWORD dwCursorID = inData->dwID; DWORD dwPTime = inData->dwTime; int x = GetLocalizedPointX(inData->x); int y = GetLocalizedPointY(inData->y); BOOL success = TRUE; // Check that the user has touched within an objects region and feed to the objects manipulation processor if(coRef->doDrawing->InRegion(x, y)) { // Feed values to the Manipulation Processor success = SUCCEEDED(coRef->manipulationProc->ProcessDownWithTime(dwCursorID, (FLOAT)x, (FLOAT)y, dwPTime)); if(success) { try { // Add to the cursor id -> object mapping m_mCursorObject.insert(std::pair<DWORD, CCoreObject*>(dwCursorID, coRef)); } catch(std::bad_alloc) { coRef->manipulationProc->CompleteManipulation(); success = FALSE; } } if(success) { // Make the current object the new head of the list m_lCoreObjects.remove(coRef); m_lCoreObjects.push_front(coRef); *bFound = TRUE; // Renders objects to bring new object to front RenderObjects(); } } else { *bFound = FALSE; } }
void display(void) { // Clear frame buffer and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Set up viewing transformation, looking down -Z axis glLoadIdentity(); gluLookAt(0, 0, -g_fViewDistance, 0, 0, -1, 0, 1, 0); // Set up the stationary light glLightfv(GL_LIGHT0, GL_POSITION, g_lightPos); // Render the scene RenderObjects(); // Make sure changes appear onscreen glutSwapBuffers(); }
void TSRSceneWorld::RenderObjectsAlpha( TSRCamera* _pCamera ) { if ( KEYDOWN( TWISTER_KEY_b ) ) { LightsManager()->DebugRender( m_Camera.m_Loc, m_Camera.m_Fwd ); } RenderObjects( _pCamera ); // render Particles if ( m_pParticlesManager ) { m_pParticlesManager->RenderParticles( m_aParticles, false ); } // m_pParticlesRenderer->CombineParticles(); Graphics()->SetDepthStencilState( Graphics()->m_DepthTestDisabledWriteEnabled ); if ( KEYDOWN( TWISTER_KEY_n ) ) { for ( unsigned int i = 0; i < m_aEntities.size(); i++ ) { m_aEntities[ i ]->DebugRender(); } } TSRGlobalConstants.PushMatrix(); TSRVector3& focus = m_CameraController.m_FocusPoint; TSRGlobalConstants.LoadIdentity(); TSRGlobalConstants.Translate( focus.x, focus.y, focus.z ); TSRDebugDraw::RenderAxis( 0.025f ); if ( KEYDOWN( TWISTER_KEY_m ) ) { TSRCascadedShadowsManager* pCSM = TSRCascadedShadowsManager::GetSingletonPtr(); if ( pCSM ) { pCSM->DebugRenderCascades(); } } TSRGlobalConstants.PopMatrix(); }
VOID CComTouchDriver::RenderInitialState(const int iCWidth, const int iCHeight) { m_iCWidth = iCWidth; m_iCHeight = iCHeight; int widthScaled = GetLocalizedPointX(iCWidth); int heightScaled = GetLocalizedPointY(iCHeight); // Defines default position for objects POINTF pfObjPos[NUM_CORE_OBJECTS]; CDrawingObject::DrawingColor uObjColor[NUM_CORE_OBJECTS]; int i = 0; pfObjPos[0].x = widthScaled / 2.0f-205.0f; pfObjPos[0].y = heightScaled / 2.0f-205.0f; pfObjPos[1].x = widthScaled / 2.0f+5.0f; pfObjPos[1].y = heightScaled / 2.0f-205.0f; pfObjPos[2].x = widthScaled / 2.0f-205.0f; pfObjPos[2].y = heightScaled / 2.0f+5.0f; pfObjPos[3].x = widthScaled / 2.0f+5.0f; pfObjPos[3].y = heightScaled / 2.0f+5.0f; // Defines color for objects uObjColor[0] = CDrawingObject::Red; uObjColor[1] = CDrawingObject::Green; uObjColor[2] = CDrawingObject::Blue; uObjColor[3] = CDrawingObject::Orange; // Assign the setup defined above to each of the core objects std::list<CCoreObject*>::iterator it; for(it = m_lCoreObjects.begin(); it != m_lCoreObjects.end(); ++it) { (*it)->doDrawing->ResetState(pfObjPos[i].x, pfObjPos[i].y, iCWidth, iCHeight, widthScaled, heightScaled, uObjColor[i]); i++; } RenderObjects(); }
void SCRenderer::RenderWorldPoints(RSArea* area, int LOD, int verticesPerBlock) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); Matrix* projectionMatrix = camera.GetProjectionMatrix(); glLoadMatrixf(projectionMatrix->ToGL()); glPointSize(4); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); running = true; static float counter = 0; while (running) { glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); Point3D lookAt = { 256*16,100,256*16 }; Renderer.GetCamera()->LookAt(&lookAt); Point3D newPosition = camera.GetPosition(); newPosition.x= lookAt.x + 5256*cos(counter/2); newPosition.y= 3700; newPosition.z= lookAt.z + 5256*sin(counter/2); camera.SetPosition(&newPosition); Matrix* modelViewMatrix = camera.GetViewMatrix(); glLoadMatrixf(modelViewMatrix->ToGL()); glBegin(GL_POINTS); for(int i=0 ; i < 324 ; i++){ //for(int i=96 ; i < 99 ; i++){ AreaBlock* block = area->GetAreaBlockByID(LOD, i); for (size_t i=0 ; i < verticesPerBlock ; i ++){ MapVertex* v = &block->vertice[i]; glColor3fv(v->color); glVertex3f(v->v.x, v->v.y, v->v.z ); } } glEnd(); //Render objects on the map for(int i=0 ; i < 324 ; i++) RenderObjects(area,i); } }
void Display::RenderContents() { RenderObjects(); RenderState(); }
void Display() { float buffer[16]; RenderInit(); //Pass1 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glViewport(0, 0, view1->w, view1->h); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt( light1->lightList[0].position[0], light1->lightList[0].position[1], light1->lightList[0].position[2],// eye view1->center[0], view1->center[1], view1->center[2], // center view1->up[0]+1, view1->up[1], view1->up[2]); // up //kkk 9.4 problem glGetFloatv(GL_MODELVIEW_MATRIX, buffer); for(int i = 0; i < 16; i++) LightViewMatrix.M[i] = buffer[i]; glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(view1->fovy*1.4, (GLfloat)WinW/(GLfloat)WinH, view1->dnear*4, view1->dfar);//fovy aspect near far glGetFloatv(GL_PROJECTION_MATRIX, buffer); for(int i = 0; i < 16; i++) LightProjectionMatrix.M[i] = buffer[i]; glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FBO); glDrawBuffers(0, NULL); glReadBuffer(GL_NONE); glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, ShadowMap, 0); glClear(GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); //we don't use it because there are thin plane. If we cull front, shadowmap can't see thin plane. //glCullFace(GL_FRONT); //kkk problem glShadeModel(GL_FLAT); glColorMask(0, 0, 0, 0); //kkk RenderObjects switch(scene_num) { case 1: RenderObjects(true, object1, 0); RenderObjects(true, object2, 1); break; case 2: RenderObjects(true, object1, 0); RenderObjects(true, object2, 1); break; case 3: RenderObjects(true, object1, 0); RenderObjects(true, object2, 1); RenderObjects(true, object3, 2); break; } //glCullFace(GL_BACK); glShadeModel(GL_SMOOTH); glColorMask(1, 1, 1, 1); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); //Pass2 glViewport(view1->x, view1->y, view1->w, view1->h); // Reset The Current Viewport glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); //glLoadMatrixf(&ViewMatrix); glLoadIdentity(); gluLookAt( view1->eye[0], view1->eye[1], view1->eye[2],// eye view1->center[0], view1->center[1], view1->center[2], // center view1->up[0], view1->up[1], view1->up[2]); // up glGetFloatv(GL_MODELVIEW_MATRIX, buffer); for(int i = 0; i < 16; i++) ViewMatrix.M[i] = buffer[i]; ViewMatrixInverse = inverse(ViewMatrix); glMatrixMode(GL_PROJECTION); // Select The Projection Matrix glLoadIdentity(); gluPerspective(view1->fovy, (GLfloat)WinW/(GLfloat)WinH, view1->dnear, view1->dfar);//fovy aspect near far if(scene_num == 3) light1->lightList[0].position[3] = 1; glEnable(GL_LIGHTING); for(int i = 0; i < light1->now; i++) { glEnable(GL_LIGHT0 + i); //some problem about GL_POSITION glLightfv(GL_LIGHT0 + i, GL_POSITION, light1->lightList[i].position); glLightfv(GL_LIGHT0 + i, GL_AMBIENT, light1->lightList[i].ambient); glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, light1->lightList[i].diffuse); glLightfv(GL_LIGHT0 + i, GL_SPECULAR, light1->lightList[i].specular); //glLightModelfv(GL_LIGHT_MODEL_AMBIENT, light1->total_ambient); //cout << "i:" << i << " " << light1->position[i] << light1->ambient[i] << light1->diffuse[i] << light1->specular[i] << endl; } glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glUseProgram(MyShader); ShadowMatrix = BiasMatrix * LightProjectionMatrix * LightViewMatrix * ViewMatrixInverse; //kkk glUniformMatrix4fv(UniformLocations[0], 1, GL_FALSE, &ShadowMatrix); glBindTexture(GL_TEXTURE_2D, ShadowMap); //kkk RenderObjects switch(scene_num) { case 1: RenderObjects(false, object1, 0); RenderObjects(false, object2, 1); break; case 2: RenderObjects(false, object1, 0); RenderObjects(false, object2, 1); break; case 3: RenderObjects(false, object1, 0); RenderObjects(false, object2, 1); RenderObjects(false, object3, 2); break; } glDisable(GL_LIGHTING); glUseProgram(0); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_TEXTURE_2D); if(ShowShadowMap) { glViewport(0, 0, 512, 512); glMatrixMode(GL_PROJECTION); glLoadMatrixf(&ortho(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f)); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, ShadowMap); glColor3f(100.0f, 100.0f, 100.0f); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f); glTexCoord2f(1.0f, 0.0f); glVertex2f(1.0f, 0.0f); glTexCoord2f(1.0f, 1.0f); glVertex2f(1.0f, 1.0f); glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 1.0f); glEnd(); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D); } glutSwapBuffers(); glutPostRedisplay(); }
/* TODO: Use measure ratios instead of song time for the barline. */ bool ScreenGameplay::Run(double TimeDelta) { if (Music && LeadInTime <= 0) { SongDelta = Music->GetStreamedTime() - SongTime; SongTime += SongDelta; } float ScreenTime = Screen::GetScreenTime(); if (ScreenTime > ScreenPauseTime || !ShouldChangeScreenAtEnd) // we're over the pause? { if (SongTime <= 0) { if (LeadInTime > 0) { LeadInTime -= TimeDelta; SongTime = -LeadInTime; } else startMusic(); } if (Next) // We have a pending screen? return RunNested(TimeDelta); // use that instead. RunMeasure(SongDelta); if (LeadInTime) Barline.Run(TimeDelta, MeasureRatio); else Barline.Run(SongDelta, MeasureRatio); if (SongTime > CurrentDiff->Offset) { while (BarlineRatios.size() && BarlineRatios.at(0).Time <= SongTime) { RatioPerSecond = BarlineRatios.front().Value; BarlineRatios.erase(BarlineRatios.begin()); } MeasureRatio += RatioPerSecond * SongDelta; if (SongDelta == 0 && !IsPaused) { if ((!Music || !Music->IsPlaying())) MeasureRatio += RatioPerSecond * TimeDelta; } if (MeasureRatio > 1.0f) { MeasureRatio -= 1.0f; Measure += 1; } Lifebar.Run(SongDelta); aJudgment.Run(TimeDelta); } } if (ShouldChangeScreenAtEnd) { float TotalTime = (CurrentDiff->Offset + MySong->LeadInTime + ScreenPauseTime); float X = GetScreenTime() / TotalTime; float xPos; if (X < 0.5) xPos = ((-2)*X*X + 2 * X) * ScreenWidth; else xPos = ScreenWidth - ((-2)*X*X + 2 * X) * ScreenWidth; ReadySign.SetPosition(xPos, ScreenHeight / 2); ReadySign.Alpha = 2 * ((-2)*X*X + 2 * X); // Lights float LightProgress = GetScreenTime() / 1.5; if (LightProgress <= 1) WindowFrame.SetLightMultiplier(LightProgress * 1.2); } else ReadySign.Alpha = 0; RenderObjects(TimeDelta); if (ShouldChangeScreenAtEnd && Measure >= CurrentDiff->Measures.size()) { auto Eval = std::make_shared<ScreenEvaluation>(); Eval->Init(Evaluation, MySong->SongAuthor, MySong->SongName); Next = Eval; Music->Stop(); } // You died? Not editing? Failing is enabled? if (Lifebar.Health <= 0 && !EditMode && FailEnabled) Running = false; // It's over. return Running; }
void GameScene::Render() { RenderObjects(); RenderInterface(); }