void REV_process(tMapQ3 * map)
{
//Variables
f32 preWait = 0, postWait = 0;
static u8 firstFrame = 1;
TRACKER * auxT;
setUp3D();
//Wait just before drawing (instead of after), this should enhance performance
VIDEO_Flush();
preWait = (f32)(ticks_to_millisecs(gettime()));
VIDEO_WaitVSync();
postWait = (f32)(ticks_to_millisecs(gettime()));
GPUWaitTime = 0.001f * (postWait - preWait);
//Update physics
updatePhysics();
setBGColor(SC_BLUE);
//Clasify objects into solid or transparent queues
//This is done before everything else because this clasification is the same for every viewport
clasify3D(mainRoot->rootNode);
//Now we use the clasified queues to render shadows
//if(mainRoot->shadowCaster)
//mainRoot->shadowScene();
//Render each Viewport into it's texture
GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
//GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE);
std::multimap<CAMERA*, TRender2Texture*>::iterator iter = mainRoot->m_Render2Textures.begin();
for(;iter != mainRoot->m_Render2Textures.end(); ++iter)
{
(*iter).second->setForRender(perspective);
(*iter).second->getCamera()->setForRender(view);
//Before rendering the scene, render the skyBox
GX_SetZMode (GX_FALSE, GX_LEQUAL, GX_TRUE);
mainRoot->skyBox.render((*iter).second->getCamera());
GX_SetZMode (GX_TRUE, GX_LEQUAL, GX_TRUE);
//Now render the map
//GX_LoadPosMtxImm(view, GX_PNMTX0);
//if(map)
//renderQ3Map(tTex->cam->getPos(), map);
//Now render objects
GX_SetCullMode(GX_CULL_NONE);
auxT = solidQueue;
while(auxT)
{
render(auxT->target, (*iter).second->getCamera()->getPos());
auxT = auxT->next;
}
orderQueue((*iter).second->getCamera());
auxT = transQueue;
while(auxT)
{
render(auxT->target, (*iter).second->getCamera()->getPos());
auxT = auxT->next;
}
//Copy the embeded frame buffer to the texture
(*iter).second->copyTexture();
}
while(solidQueue)
{
auxT = solidQueue;
solidQueue = solidQueue->next;
free(auxT);
}
while(transQueue)
{
auxT = transQueue;
transQueue = transQueue->next;
free(auxT);
}
setBGColor(SC_WHITE);
//2D System
//GX_SetZMode (GX_FALSE, GX_LEQUAL, GX_TRUE);
GX_SetCopyFilter(rMode->aa,rMode->sample_pattern,GX_TRUE,rMode->vfilter);
GX_SetViewport(0,0, w, h,0,1);
GX_SetScissor(0,0, w, h);
guOrtho(perspective,0,h,0,w, 1.0,100.0);
GX_LoadProjectionMtx(perspective, GX_ORTHOGRAPHIC);
GX_SetCullMode(GX_CULL_NONE);
setUp2D();
parse2D(mainRoot->rootN2D);
order2D();
render2D();
GX_DrawDone();
GX_CopyDisp(frameBuffer[fb],GX_TRUE);
VIDEO_SetNextFramebuffer(frameBuffer[fb]);
//Set out black screen after first frame
if(firstFrame)
{
firstFrame = 0;
VIDEO_SetBlack(FALSE);
}
fb ^= 1;
}
Game::Game(const sf::ContextSettings& settings)
: mWindow({ 800,600 }, "opengl template", sf::Style::Close, settings)
, mFont()
, mStatisticsText()
, mText()
, mTitle()
, mStatisticsUpdateTime()
, mStatisticsNumFrames()
, mRunning(true)
//, mCamera(mWindow.getView())
, mTextures()
, mShaders()
, mMeshes()
, mSprite()
, mCubeMaterial()
, mCube()
, mEntityMaterial()
, mLightManager()
, mEntity()
, cubeMatrices(1000000)
, mCube1()
{
//mWindow.setVerticalSyncEnabled(true);
mCamera.setSize(mWindow.getSizef());
mShaders.load(Shaders::Basic2D, "Media/Shaders/Basic2D");
mShaders.load(Shaders::Basic, "Media/Shaders/Basic");
mShaders.load(Shaders::BasicInstance, "Media/Shaders/Basic-instance");
mShaders.load(Shaders::Light00, "Media/Shaders/Light00");
mTextures.load(Textures::Checker, "Media/Textures/test.jpg");
mTextures.load(Textures::Box, "Media/Textures/box.png");
mTextures.load(Textures::White, "Media/Textures/white.png");
mMeshes.load(Meshes::Cube, "Media/Models/cube.obj");
mMeshes.load(Meshes::Cube1, "Media/Models/cube.obj");
mMeshes.load(Meshes::Dragon, "Media/Models/dragon.obj");
mCubeMaterial.append(Material::Diffuse, mTextures.get(Textures::Box));
for (int i = 0; i < 500; ++i) {
mCubes.emplace_back(mShaders.get(Shaders::Basic), mMeshes.get(Meshes::Cube), mCubeMaterial);
mCubes.back().setPosition(random(-50.f, 50.f), random(-50.f, 50.f), random(-50.f, 50.f));
mCubes.back().loadShaderData(mCamera);
}
////GLuint amount = 50000;
//GLuint amount = 100000;
////GLuint amount = 200000;
GLfloat range = 1500.f;
//std::vector<glm::mat4> cubeMatrices(amount);
GLuint amount = cubeMatrices.size();
for (GLuint i = 0; i < amount; ++i) {
glm::vec3 position(random(-range, range), random(-range, range), random(-range, range));
cubeMatrices[i] = glm::translate(position);
}
mCube1 = mMeshes.get(Meshes::Cube1);
mMeshes.get(Meshes::Cube1).setupInstanceBuffer(cubeMatrices);
//mCube.setMaterial(mCubeMaterial);
mCube.setTexture(mTextures.get(Textures::Box));
mCube.setMesh(mMeshes.get(Meshes::Cube1));
mCube.updateTransformation(cubeMatrices);
mCube.setPosition(0, 0, -25);
mCube.setShader(mShaders.get(Shaders::BasicInstance));
mCube.loadShaderData(mCamera);
Light sun;
sun.position = { 200,200, 200 };
sun.color = { 1,1,1,1 };
mLightManager.append(sun);
mEntityMaterial.append(Material::Diffuse, mTextures.get(Textures::White));
mEntity.setMaterial(mEntityMaterial);
mEntity.setLightManager(mLightManager);
mEntity.setMesh(mMeshes.get(Meshes::Dragon));
mEntity.setPosition(0, 0, -25);
mEntity.setShader(mShaders.get(Shaders::Light00));
mEntity.loadShaderData(mCamera);
setUp2D();
setUpTexts();
mCamera.setProjectionType(Camera::Prespective);
mWindow.pushGLStates();
}
