static void renderStrand(Strand *s, RenderConf *rc) {
glLightfv(GL_LIGHT0, GL_DIFFUSE, S_col);
renderParticles(s->numMonomers, s->Ss, rc);
glLightfv(GL_LIGHT0, GL_DIFFUSE, P_col);
renderParticles(s->numMonomers, s->Ps, rc);
for (int i = 0; i < s->numMonomers; i++)
renderBase(&s->Bs[i], rc);
/* Connections */
glLightfv(GL_LIGHT0, GL_DIFFUSE, gray);
renderConnection(&s->Ps[0], &s->Ss[0], rc);
renderConnection(&s->Ss[0], &s->Bs[0], rc);
for(int i = 1; i < s->numMonomers; i++) {
renderConnection(&s->Ps[i], &s->Ss[i], rc);
renderConnection(&s->Ss[i], &s->Bs[i], rc);
renderConnection(&s->Ss[i], &s->Ps[i-1], rc);
}
/* Forces */
if (rc->drawForces) {
glColor3f(0.8, 0.0, 0.0);
glBegin(GL_LINES);
for(int i = 0; i < 3 * s->numMonomers; i++) {
Particle *p = &s->all[i];
drawLine(p->pos, add(p->pos, p->F));
}
glEnd();
}
}
int render(void)
{
double ws = config.worldSize;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* view_angle += 0.01;*/
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -ws*2.5);
glRotatef(view_angle, 0, 1, 0);
/* Constituents of the monomers */
glLightfv(GL_LIGHT0, GL_DIFFUSE, red);
renderParticles(config.numMonomers, world.Ss);
glLightfv(GL_LIGHT0, GL_DIFFUSE, green);
renderParticles(config.numMonomers, world.As);
glLightfv(GL_LIGHT0, GL_DIFFUSE, blue);
renderParticles(config.numMonomers, world.Ps);
/* Connections */
glLightfv(GL_LIGHT0, GL_DIFFUSE, gray);
drawCilinder(&world.Ps[0].pos, &world.Ss[0].pos,
CILINDER_FACES, CILINDER_RADIUS);
drawCilinder(&world.Ss[0].pos, &world.As[0].pos,
CILINDER_FACES, CILINDER_RADIUS);
for(int i = 1; i < config.numMonomers; i++) {
drawCilinder(&world.Ps[i].pos, &world.Ss[i].pos,
CILINDER_FACES, CILINDER_RADIUS);
drawCilinder(&world.Ss[i].pos, &world.As[i].pos,
CILINDER_FACES, CILINDER_RADIUS);
drawCilinder(&world.Ss[i].pos, &world.Ps[i-1].pos,
CILINDER_FACES, CILINDER_RADIUS);
}
#if DRAWFORCES
/* Forces */
glColor3f(0.8, 0.0, 0.0);
glBegin(GL_LINES);
for(int i = 0; i < 3 * config.numMonomers; i++) {
Vec3 tmp;
add(&world.all[i].pos, &world.all[i].F, &tmp);
drawLine(&world.all[i].pos, &tmp);
}
glEnd();
#endif
SDL_GL_SwapBuffers();
return 0;
}
void Dot::render() {
//Show the dot
gDotTexture.render( mPosX, mPosY );
//Show particles on top of dot
renderParticles();
}
void ClientMap::render () const
{
ExecutionTime renderTime("ClientMapRender", 2000L);
const int x = _screenRumbleOffsetX + _x + _camera.getViewportX();
const int y = _screenRumbleOffsetY + _y + _camera.getViewportY();
const int scissorX = std::max(0, x);
const int scissorY = std::max(0, y);
const bool debug = Config.isDebug();
if (debug) {
_frontend->renderRect(scissorX, scissorY, getPixelWidth() * _zoom, getPixelHeight() * _zoom, colorRed);
} else {
_frontend->enableScissor(scissorX, scissorY, getPixelWidth() * _zoom, getPixelHeight() * _zoom);
}
renderLayer(x, y, LAYER_BACK);
renderLayer(x, y, LAYER_MIDDLE);
renderLayer(x, y, LAYER_FRONT);
if (_restartDue != 0) {
renderFadeOutOverlay();
}
Config.setDebugRendererData(x, y, getWidth(), getHeight(), _scale * _zoom);
Config.getDebugRenderer().render();
renderParticles(x, y);
if (!debug) {
_frontend->disableScissor();
}
}
void ParticleVisualization::updateMainNode( osg::Node* node )
{
std::cout << "UpdateMainNode" << std::endl;
if(updated)
renderParticles();
updated = false;
}
void ParticleSystem::renderWithDT(float dt)
{
time += (dt * 1000.0f);
updateParticles(dt);
renderParticles();
currVB = currTFB;
currTFB = (currTFB + 1) & 0x1;
}
void renderFn()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
g_program.use();
setPerspective();
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, omap2);
g_program.setUniform("MaxTessLevel", max_tess);
g_program.setUniform("ModelView", g_modelview);
g_program.setUniform("Projection", g_projection);
g_program.setUniform("MVP", g_projection * g_modelview);
g_program.setUniform("NormalMatrix",
glm::inverseTranspose(mat3(g_modelview)));
g_program.setUniform("MousePosition", mouse);
g_program.setUniform("Time", elapsed);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
renderLand();
d_program.use();
glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &plv);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &plf);
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_2D, plane);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
renderPlane(scene->mRootNode);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
d_program.setUniform("FrameTime", clockdiff);
d_program.setUniform("Elapsed", elapsed);
glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &pav);
glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &paf);
renderParticles();
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
SDL_Texture* VsGameRenderer::renderGame() {
SDL_Texture* gbq = _gbqr0.renderQueue();
SDL_Texture* gbq2 = _gbqr1.renderQueue();
SDL_SetRenderTarget(_SDLRenderer, _texture);
SDL_SetRenderDrawColor(_SDLRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
SDL_RenderClear(_SDLRenderer);
SDL_RenderCopy(_SDLRenderer, _bg, NULL, NULL);
SDL_RenderCopy(_SDLRenderer, _2pbg, NULL, NULL);
if (!_game.isPaused()) {
renderBoard(0);
renderBoard(1);
SDL_Rect gbqp = { 258, 307, 38, 120 };
SDL_RenderCopy(_SDLRenderer, gbq, NULL, &gbqp);
gbqp.x = 344;
SDL_RenderCopy(_SDLRenderer, gbq2, NULL, &gbqp);
renderParticles();
}
renderStatsText();
renderMatchPoints();
if (_game.isPaused()) {
SDL_SetTextureColorMod(_texture, 0x50, 0x50, 0x50);
SDL_RenderCopy(_SDLRenderer, _texture, NULL, NULL);
SDL_SetTextureColorMod(_texture, 0xFF, 0xFF, 0xFF);
_game.getPauseMenu().render();
} else {
SDL_SetTextureColorMod(_texture, 0xFF, 0xFF, 0xFF);
}
//TODO: make this state more fancy
if (_game.getState() == Game::State::ENDED
&& SDL_GetTicks() % 1000 >= 500) {
_SDLContext.renderText("PUSH START", { 255, 255, 255 },
_SDLContext._fontSquare, 134, 342);
}
return _texture;
}
int Main(void)
{
// Load resources
texsmallball = CORE_LoadBmp("data/tyrian_ball.32.bmp" , false);
texcursor = CORE_LoadBmp("data/cursor.bmp", false);
initCursor();
initParticlePool(MAX_PARTICLES);
initEmmiter();
// Set up rendering
glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT); // Sets up clipping
glClearColor( 0.0f, 0.1f, 0.3f, 0.0f );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho( 0.0, SCR_WIDTH, 0.0, SCR_HEIGHT, 0.0, 1.0);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
DWORD start_tick= GetTickCount();
while (!SYS_GottaQuit())
{
// Render
glClear( GL_COLOR_BUFFER_BIT );
CORE_RenderCenteredSprite(cursor->pos,
vmake(cursor->radius , cursor->radius ), cursor->index);
//fixed substep
float dt =1.0f/(substep*FPS);
//add gravity
// tVector emitterforces=vmake(0.0f,0.0f);
tVector emitterforces= GRAVITY; //vmake(0,gravityForce);
updateEmitter( myEmmiter, emitterforces, dt);
applyDeflectors(myEmmiter);
renderParticles(myEmmiter);
SYS_Show();
start_tick= GetTickCount();
// Keypress!
const float scale=2.0f;
if (SYS_KeyPressed('O'))
{
if(cursor)cursor->pos.x-=1.0f*scale;
}
if (SYS_KeyPressed('P'))
{
if(cursor)cursor->pos.x+=1.0f*scale;
}
if (SYS_KeyPressed('Q'))
{
if(cursor)cursor->pos.y+=1.0f*scale;
}
if (SYS_KeyPressed('A'))
{
if(cursor)cursor->pos.y-=1.0f*scale;
}
if (SYS_KeyPressed('S'))
{
atractorScale*=1.1f;
if( atractorScale > 1000.0f)atractorScale=1000.0f;
}
if (SYS_KeyPressed('W'))
{
atractorScale*=0.9f;
}
// Keep system running
SYS_Pump();
SYS_Sleep(17);
}
CORE_UnloadBmp(texsmallball);
CORE_UnloadBmp(texcursor);
destroyEmmmiter(myEmmiter);
destroyParticlePool();
destroyCursor();
return 0;
}
void ofxPhysics2d::debugRender(){
renderParticles();
renderConstraints();
}
void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
glBindBufferBase(GL_UNIFORM_BUFFER, 1, SharedObject::LightingDataUBO);
m_scene_manager->setActiveCamera(camnode);
PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
PrepareDrawCalls(camnode);
PROFILER_POP_CPU_MARKER();
// Shadows
{
// To avoid wrong culling, use the largest view possible
m_scene_manager->setActiveCamera(m_suncam);
if (CVS->isDefferedEnabled() &&
CVS->isShadowEnabled() && hasShadow)
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
renderShadows();
PROFILER_POP_CPU_MARKER();
if (CVS->isGlobalIlluminationEnabled())
{
PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
renderRSM();
PROFILER_POP_CPU_MARKER();
}
}
m_scene_manager->setActiveCamera(camnode);
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
if (CVS->isDefferedEnabled() || forceRTT)
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
renderSolidFirstPass();
}
else
{
// We need a cleared depth buffer for some effect (eg particles depth blending)
if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_FRAMEBUFFER_SRGB_WORKING))
glDisable(GL_FRAMEBUFFER_SRGB);
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
// Bind() modifies the viewport. In order not to affect anything else,
// the viewport is just reset here and not removed in Bind().
const core::recti &vp = Camera::getActiveCamera()->getViewport();
glViewport(vp.UpperLeftCorner.X,
irr_driver->getActualScreenSize().Height - vp.LowerRightCorner.Y,
vp.LowerRightCorner.X - vp.UpperLeftCorner.X,
vp.LowerRightCorner.Y - vp.UpperLeftCorner.Y);
glClear(GL_DEPTH_BUFFER_BIT);
if (GraphicsRestrictions::isDisabled(GraphicsRestrictions::GR_FRAMEBUFFER_SRGB_WORKING))
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
PROFILER_POP_CPU_MARKER();
// Lights
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
if (CVS->isDefferedEnabled())
renderLights(pointlightcount, hasShadow);
PROFILER_POP_CPU_MARKER();
}
// Handle SSAO
{
PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_SSAO));
if (UserConfigParams::m_ssao)
renderSSAO();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
if (CVS->isDefferedEnabled() || forceRTT)
{
m_rtts->getFBO(FBO_COLORS).Bind();
SColor clearColor(0, 150, 150, 150);
if (World::getWorld() != NULL)
clearColor = World::getWorld()->getClearColor();
glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f,
clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f);
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
}
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (getNormals())
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
renderNormalsVisualisation();
m_rtts->getFBO(FBO_COLORS).Bind();
}
// Render ambient scattering
if (CVS->isDefferedEnabled() && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Ambient scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_FOG));
renderAmbientScatter();
PROFILER_POP_CPU_MARKER();
}
{
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
ScopedGPUTimer Timer(getGPUTimer(Q_SKYBOX));
renderSkybox(camnode);
PROFILER_POP_CPU_MARKER();
}
// Render discrete lights scattering
if (CVS->isDefferedEnabled() && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- PointLight Scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_FOG));
renderLightsScatter(pointlightcount);
PROFILER_POP_CPU_MARKER();
}
if (getRH())
{
glDisable(GL_BLEND);
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2], rh_matrix, rh_extend);
}
if (getGI())
{
glDisable(GL_BLEND);
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]);
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
{
ScopedGPUTimer Timer(getGPUTimer(Q_GLOW));
irr_driver->setPhase(GLOW_PASS);
renderGlow(glows);
} // end glow
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
computeSunVisibility();
PROFILER_POP_CPU_MARKER();
// Render transparent
{
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_TRANSPARENT));
renderTransparent();
PROFILER_POP_CPU_MARKER();
}
m_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
// Render particles
{
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_PARTICLES));
renderParticles();
PROFILER_POP_CPU_MARKER();
}
if (!CVS->isDefferedEnabled() && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
}
void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
m_scene_manager->setActiveCamera(camnode);
PROFILER_PUSH_CPU_MARKER("- Draw Call Generation", 0xFF, 0xFF, 0xFF);
PrepareDrawCalls(camnode);
PROFILER_POP_CPU_MARKER();
// Shadows
{
// To avoid wrong culling, use the largest view possible
m_scene_manager->setActiveCamera(m_suncam);
if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights &&
UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround() && hasShadow)
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
renderShadows();
PROFILER_POP_CPU_MARKER();
if (UserConfigParams::m_gi)
{
PROFILER_PUSH_CPU_MARKER("- RSM", 0xFF, 0x0, 0xFF);
renderRSM();
PROFILER_POP_CPU_MARKER();
}
}
m_scene_manager->setActiveCamera(camnode);
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
if (UserConfigParams::m_dynamic_lights || forceRTT)
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
renderSolidFirstPass();
}
PROFILER_POP_CPU_MARKER();
// Lights
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
if (UserConfigParams::m_dynamic_lights)
renderLights(pointlightcount, hasShadow);
PROFILER_POP_CPU_MARKER();
}
// Handle SSAO
{
PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_SSAO));
if (UserConfigParams::m_ssao)
renderSSAO();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
if (UserConfigParams::m_dynamic_lights || forceRTT)
{
m_rtts->getFBO(FBO_COLORS).Bind();
SColor clearColor(0, 150, 150, 150);
if (World::getWorld() != NULL)
clearColor = World::getWorld()->getClearColor();
glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f,
clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f);
glClear(GL_COLOR_BUFFER_BIT);
glDepthMask(GL_FALSE);
}
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (getNormals())
{
m_rtts->getFBO(FBO_NORMAL_AND_DEPTHS).Bind();
renderNormalsVisualisation();
m_rtts->getFBO(FBO_COLORS).Bind();
}
if (UserConfigParams::m_dynamic_lights && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
m_post_processing->renderFog();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
renderSkybox(camnode);
PROFILER_POP_CPU_MARKER();
if (getRH())
{
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderRHDebug(m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2], rh_matrix, rh_extend);
}
if (getGI())
{
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]);
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
{
irr_driver->setPhase(GLOW_PASS);
renderGlow(glows);
} // end glow
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
computeSunVisibility();
PROFILER_POP_CPU_MARKER();
// Render transparent
{
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_TRANSPARENT));
renderTransparent();
PROFILER_POP_CPU_MARKER();
}
m_sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
// Render particles
{
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_PARTICLES));
renderParticles();
PROFILER_POP_CPU_MARKER();
}
if (!UserConfigParams::m_dynamic_lights && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
}
void SceneRenderer::renderFrame()
{
m_fbos->updateBuffers();
// Update screen FBO
glGetIntegerv(0x8CA6, (GLint*)&(m_fbos->m_backBufferFbo->fbo));
CPU_TIMER_SCOPE(CPU_TIMER_TOTAL);
GPU_TIMER_SCOPE(GPU_TIMER_TOTAL);
MatrixStorage mats;
setupMatrices(mats);
{
// render a full-screen depth pass.
CPU_TIMER_SCOPE(CPU_TIMER_SCENE_DEPTH);
GPU_TIMER_SCOPE(GPU_TIMER_SCENE_DEPTH);
if (m_params.useDepthPrepass)
renderSceneDepth(mats, m_fbos->m_sceneFbo);
// render scene depth to buffer for particle to be depth tested against
// This may just down-sample the above depth pre-pass.
renderLowResSceneDepth(mats);
CHECK_GL_ERROR();
}
{
// the opaque colors need to be rendered after the particles
//LOGI("OE renderFullResSceneColor\n");
CPU_TIMER_SCOPE(CPU_TIMER_SCENE_COLOR);
GPU_TIMER_SCOPE(GPU_TIMER_SCENE_COLOR);
renderFullResSceneColor(mats);
CHECK_GL_ERROR();
}
if (m_particles->getParams().render)
{
CPU_TIMER_SCOPE(CPU_TIMER_PARTICLES);
GPU_TIMER_SCOPE(GPU_TIMER_PARTICLES);
renderParticles(mats);
CHECK_GL_ERROR();
if (m_particles->getParams().renderLowResolution)
{
// upsample the particles & composite them on top of the opaque scene colors
CPU_TIMER_SCOPE(CPU_TIMER_UPSAMPLE_PARTICLES);
GPU_TIMER_SCOPE(GPU_TIMER_UPSAMPLE_PARTICLES);
m_upsampler->upsampleParticleColors(*m_fbos->m_sceneFbo);
CHECK_GL_ERROR();
}
}
{
// final bilinear upsampling from scene resolution to backbuffer resolution
CPU_TIMER_SCOPE(CPU_TIMER_UPSAMPLE_SCENE);
GPU_TIMER_SCOPE(GPU_TIMER_UPSAMPLE_SCENE);
m_upsampler->upsampleSceneColors(*m_fbos->m_backBufferFbo);
CHECK_GL_ERROR();
}
m_particles->swapBuffers();
}
int Main(void)
{
// Load resources
texsmallball = CORE_LoadBmp("data/tyrian_ball.32.bmp" , false);
texcursor = CORE_LoadBmp("data/cursor.bmp", false);
initCursor();
initParticlePool(MAX_PARTICLES);
//checking pool
//while(particlePool.current)
//{
// particlePool.current=particlePool.current->next;
//}
//particlePool.current = particlePool.head->next;
initEmmiter();
//for (int i = 0; i < NUM_PARTICLES; i++)
//{
//float radius;
//radius = 8.f;
//particle[i]=particlePool.current;
//particlePool.current=particlePool.current->next;
//particle[i]->radius = radius;
//particle[i]->mass = 1.f;
//particle[i]->index = texsmallball;
//particle[i]->pos = vmake(CORE_FRand(radius, SCR_WIDTH-radius), CORE_FRand(radius, SCR_HEIGHT-radius));
//particle[i]->vel = vmake(CORE_FRand(-MAX_BALL_SPEED, +MAX_BALL_SPEED), CORE_FRand(-MAX_BALL_SPEED, +MAX_BALL_SPEED));
//}
// Set up rendering
glViewport(0, 0, SCR_WIDTH, SCR_HEIGHT); // Sets up clipping
glClearColor( 0.0f, 0.1f, 0.3f, 0.0f );
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho( 0.0, SCR_WIDTH, 0.0, SCR_HEIGHT, 0.0, 1.0);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
DWORD start_tick= GetTickCount();
while (!SYS_GottaQuit())
{
// Render
glClear( GL_COLOR_BUFFER_BIT );
CORE_RenderCenteredSprite(cursor->pos,
vmake(cursor->radius , cursor->radius ), cursor->index);
//fixed substep
float dt =1.0f/(substep*FPS);
//adaptive substep
//DWORD elapsed_ticks= GetTickCount()- start_tick;
//float elapsed_dt= elapsed_ticks/TICKS_PER_SECOND;
//float edt_dt = elapsed_dt/dt;
//int ite = (int)edt_dt;
//float lastdt= edt_dt - ite;
tVector forces=vmake(0,-100.0f);
// for( int i=0; i < ite; i++)
updateEmitter( myEmmiter, forces, dt);
// updateEmitter( myEmmiter, forces, lastdt);
applyDeflectors(myEmmiter);
renderParticles(myEmmiter);
SYS_Show();
start_tick= GetTickCount();
// Keypress!
if (SYS_KeyPressed('O'))
{
if(cursor)cursor->pos.x-=1.0f;;
}
if (SYS_KeyPressed('P'))
{
if(cursor)cursor->pos.x+=1.0f;;
}
if (SYS_KeyPressed('Q'))
{
if(cursor)cursor->pos.y+=1.0f;;
}
if (SYS_KeyPressed('A'))
{
if(cursor)cursor->pos.y-=1.0f;;
}
if (0)//SYS_KeyPressed('I'))
{
//start single ball at random
float radius=16.f;
GLuint texBall=texsmallball;
float mass=1.0f;
int index=(int)CORE_FRand(0, MAX_PARTICLES-1);
//particle[index]->mass = mass;
//particle[index]->index = texBall;
//particle[index]->radius = radius;
// particle[index]->pos = vmake(CORE_FRand(radius, SCR_WIDTH-radius), CORE_FRand(SCR_HEIGHT*.5f, SCR_HEIGHT-radius));
//particle[index]->vel = vmake(0, 10);
}
if (0)//SYS_KeyPressed(' '))
{
//give an impulse to all balss
// for (int i = 0; i < MAX_PARTICLES; i++)
// {
//if (fabs(particle[i]->vel.x) < 0.1f)
// particle[i]->vel.x = CORE_FRand(-MAX_BALL_SPEED, +MAX_BALL_SPEED);
//particle[i]->vel.y = CORE_FRand(0, JUMP_SPEED);
// }
}
if (0)//SYS_KeyPressed(VK_CONTROL))
{
//reset all
glClear( GL_COLOR_BUFFER_BIT );
// for (int i = 0; i < MAX_PARTICLES; i++)
// {
//float radius=particle[i]->radius;
//particle[i]->pos = vmake(CORE_FRand(radius, SCR_WIDTH-radius), CORE_FRand(radius, SCR_HEIGHT-radius));
//particle[i]->vel = vmake(0, 10);
// }
SYS_Show();
}
// Keep system running
SYS_Pump();
SYS_Sleep(17);
}
CORE_UnloadBmp(texsmallball);
CORE_UnloadBmp(texcursor);
destroyEmmmiter(myEmmiter);
destroyParticlePool();
destroyCursor();
return 0;
}
void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned pointlightcount, std::vector<GlowData>& glows, float dt, bool hasShadow, bool forceRTT)
{
glBindBufferBase(GL_UNIFORM_BUFFER, 0, SharedObject::ViewProjectionMatrixesUBO);
// Shadows
{
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
ScopedGPUTimer Timer(getGPUTimer(Q_SHADOWS));
// To avoid wrong culling, use the largest view possible
m_scene_manager->setActiveCamera(m_suncam);
if (!m_mipviz && !m_wireframe && UserConfigParams::m_dynamic_lights &&
UserConfigParams::m_shadows && !irr_driver->needUBOWorkaround() && hasShadow)
renderShadows();
m_scene_manager->setActiveCamera(camnode);
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
renderSolidFirstPass();
PROFILER_POP_CPU_MARKER();
// Lights
{
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
renderLights(pointlightcount);
PROFILER_POP_CPU_MARKER();
}
// Handle SSAO
{
PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_SSAO));
if (UserConfigParams::m_ssao)
renderSSAO();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
if (!UserConfigParams::m_dynamic_lights && ! forceRTT)
{
glEnable(GL_FRAMEBUFFER_SRGB);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
else
m_rtts->getFBO(FBO_COLORS).Bind();
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (UserConfigParams::m_dynamic_lights && World::getWorld() != NULL &&
World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
m_post_processing->renderFog();
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
renderSkybox(camnode);
PROFILER_POP_CPU_MARKER();
if (getRH())
{
glEnable(GL_PROGRAM_POINT_SIZE);
m_rtts->getFBO(FBO_COLORS).Bind();
glUseProgram(FullScreenShader::RHDebug::Program);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_3D, m_rtts->getRH().getRTT()[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_3D, m_rtts->getRH().getRTT()[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_3D, m_rtts->getRH().getRTT()[2]);
FullScreenShader::RHDebug::setUniforms(rh_matrix, rh_extend, 0, 1, 2);
glDrawArrays(GL_POINTS, 0, 32 * 16 * 32);
glDisable(GL_PROGRAM_POINT_SIZE);
}
if (getGI())
{
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderGI(rh_matrix, rh_extend, m_rtts->getRH().getRTT()[0], m_rtts->getRH().getRTT()[1], m_rtts->getRH().getRTT()[2]);
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe && UserConfigParams::m_glow)
{
irr_driver->setPhase(GLOW_PASS);
renderGlow(glows);
} // end glow
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
computeSunVisibility();
PROFILER_POP_CPU_MARKER();
// Render transparent
{
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_TRANSPARENT));
renderTransparent();
PROFILER_POP_CPU_MARKER();
}
// Render particles
{
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
ScopedGPUTimer Timer(getGPUTimer(Q_PARTICLES));
renderParticles();
PROFILER_POP_CPU_MARKER();
}
if (!UserConfigParams::m_dynamic_lights && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}
// Ensure that no object will be drawn after that by using invalid pass
irr_driver->setPhase(PASS_COUNT);
}
