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();
}
