void RenderMeshComponent::RenderAllEntities(fplbase::Renderer& renderer,
const CameraInterface& camera) {
// Make sure we only draw the front-facing polygons:
renderer.SetCulling(fplbase::Renderer::kCullBack);
// Render the actual game:
for (int pass = 0; pass < RenderPass_Count; pass++) {
RenderPass(pass, camera, renderer);
}
}
virtual void RenderSceneCB()
{
m_pGameCamera->OnRender();
m_scale += 0.05f;
ShadowMapPass();
RenderPass();
glutSwapBuffers();
}
bool Renderer::initialize(const std::vector <RealtimeExportPassInfo> & config, StringIdMap & stringMap, const std::string & shaderPath, unsigned int w,unsigned int h, const std::set <std::string> & globalDefines, std::ostream & errorOutput)
{
// Clear existing passes.
clear();
// Add new passes.
int passCount = 0;
for (std::vector <RealtimeExportPassInfo>::const_iterator i = config.begin(); i != config.end(); i++, passCount++)
{
// Create unique names based on the path and define list.
std::string vertexShaderName = i->vertexShader;
if (!i->vertexShaderDefines.empty())
vertexShaderName += " "+UTILS::implode(i->vertexShaderDefines," ");
std::string fragmentShaderName = i->fragmentShader;
if (!i->fragmentShaderDefines.empty())
fragmentShaderName += " "+UTILS::implode(i->fragmentShaderDefines," ");
// Load shaders from the pass if necessary.
if ((shaders.find(vertexShaderName) == shaders.end()) && (!loadShader(shaderPath.empty() ? i->vertexShader : shaderPath+"/"+i->vertexShader, vertexShaderName, mergeSets(i->vertexShaderDefines, globalDefines), GL_VERTEX_SHADER, errorOutput)))
return false;
if ((shaders.find(fragmentShaderName) == shaders.end()) && (!loadShader(shaderPath.empty() ? i->fragmentShader : shaderPath+"/"+i->fragmentShader, fragmentShaderName, mergeSets(i->fragmentShaderDefines, globalDefines), GL_FRAGMENT_SHADER, errorOutput)))
return false;
// Note which draw groups the pass uses.
for (std::vector <std::string>::const_iterator g = i->drawGroups.begin(); g != i->drawGroups.end(); g++)
drawGroupToPasses[stringMap.addStringId(*g)].push_back(passes.size());
// Initialize the pass.
int passIdx = passes.size();
passes.push_back(RenderPass());
if (!passes.back().initialize(passCount, *i, stringMap, gl, shaders.find(vertexShaderName)->second, shaders.find(fragmentShaderName)->second, sharedTextures, w, h, errorOutput))
return false;
// Put the pass's output render targets into a map so we can feed them to subsequent passes.
const std::map <StringId, RenderTexture> & passRTs = passes.back().getRenderTargets();
for (std::map <StringId, RenderTexture>::const_iterator rt = passRTs.begin(); rt != passRTs.end(); rt++)
{
StringId nameId = rt->first;
sharedTextures.insert(std::make_pair(nameId, RenderTextureEntry(nameId, rt->second.handle, rt->second.target)));
}
// Remember the pass index.
passIndexMap[stringMap.addStringId(i->name)] = passIdx;
}
return true;
}
MBGL_CONSTEXPR RenderPass operator&(RenderPass a, RenderPass b) {
return RenderPass(mbgl::underlying_type(a) & mbgl::underlying_type(b));
}
void Lux::Graphics::RenderingSystem::ProcessUpdate(const float a_DeltaTime)
{
m_RenderWindow->Clear();
RenderPass();
m_RenderWindow->SwapBuffers();
}
// Render a pass.
void RenderMeshComponent::RenderPass(int pass_id, const CameraInterface& camera,
fplbase::Renderer& renderer) {
RenderPass(pass_id, camera, renderer, nullptr);
}
constexpr RenderPass operator&(RenderPass a, RenderPass b) {
return RenderPass(mbgl::underlying_type(a) & mbgl::underlying_type(b));
}
void GraphicsContext::RenderAll(){
for(int i = 0; i < numPasses; ++i){
RenderPass(i, defShaderPerPass[i], cameraPerPass[i]);
}
}
/**
****************************************************************************************************
@brief Render scene - camera, lights and objects(run through object list and call render function
for every object)
@param delete_buffer should we delete color and depth buffer?
***************************************************************************************************/
void TScene::Redraw(bool delete_buffer)
{
GLenum mrt[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
///draw all lights
unsigned i;
for(i=0, m_il = m_lights.begin(); m_il != m_lights.end(), i<m_lights.size(); ++m_il, i++)
{
///if light has a shadow, render scene from light view to texture (TScene::RenderShadowMap())
if((*m_il)->IsCastingShadow())
{
//render shadow map
if((*m_il)->GetType() == OMNI)
{
RenderShadowMapOmni(*m_il);
}
else
RenderShadowMap(*m_il);
}
}
//HDR/SSAO renderer - render to texture
if(m_useHDR || m_useSSAO)
{
//render target viewport size
glViewport(0,0,m_RT_resX,m_RT_resY);
//attach framebuffer to render to
glBindFramebuffer(GL_FRAMEBUFFER, m_f_buffer);
//attach render texture
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex_cache["render_texture"], 0);
///use multisampled FBO if required
if(m_msamples > 1)
glBindFramebuffer(GL_FRAMEBUFFER, m_f_bufferMSAA);
//multiple render targets - only when using SSAO and/or normal buffer
if(m_useNormalBuffer)
glDrawBuffers(2, mrt);
//clear screen (if desired)
if(delete_buffer)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
else //else render to default framebuffer, clear it(if desired)
{
if(delete_buffer)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if(m_wireframe)
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glViewport(0,0,m_RT_resX,m_RT_resY);
//render all opaque objects
DrawScene(DRAW_OPAQUE);
//then transparent objects
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND);
DrawScene(DRAW_TRANSPARENT);
glDisable(GL_BLEND);
if(m_wireframe)
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
//HDR/SSAO renderer
if(m_useHDR || m_useSSAO)
{
//if MSAA enabled, copy from multisampled FBO to normal FBO
if(m_msamples > 1)
{
//blit colors
glReadBuffer(GL_COLOR_ATTACHMENT0);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_f_bufferMSAA);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_f_buffer);
glBlitFramebuffer(0, 0, m_resx, m_resy, 0, 0, m_resx, m_resy, GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT, GL_NEAREST);
//blit normals
if(m_useNormalBuffer)
{
glReadBuffer(GL_COLOR_ATTACHMENT1);
glDrawBuffer(GL_COLOR_ATTACHMENT1);
glBlitFramebuffer(0, 0, m_resx, m_resy, 0, 0, m_resx, m_resy, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
}
if(m_useNormalBuffer)
glDrawBuffer(GL_COLOR_ATTACHMENT0);
//attach bloom texture
glBindFramebuffer(GL_FRAMEBUFFER, m_f_buffer);
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex_cache["bloom_texture"], 0);
//downsample bloom texture by setting new viewport
glViewport(0,0,m_RT_resX/2,m_RT_resY/2);
//Bloom/SSAO pass
RenderPass("mat_bloom_hdr_ssao");
//horizontal blur pass
RenderPass("mat_blur_horiz");
//vertical blur pass
glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_tex_cache["blur_texture"], 0);
RenderPass("mat_blur_vert");
//go back to regular framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//final draw with bloom and tone mapping
glViewport(0,0,m_resx,m_resy); //restore original scene viewport
RenderPass("mat_tonemap");
}
//show shadow maps
if(m_draw_shadow_map)
{
for(int i=0; i<2; i++)
{
const float q_size = 0.5f;
if(m_lights[0]->GetType() == OMNI)
{
SetUniform("show_depth_omni", "far_plane", SHADOW_FAR);
SetUniform("show_depth_omni", "index", float(i));
RenderSmallQuad("show_depth_omni", 0.0f, i*q_size, q_size);
}
else
{
SetUniform("show_depth", "far_plane", SHADOW_FAR);
RenderSmallQuad("show_depth", 0.0f, 0.0f, q_size);
break;
}
}
}
//finish drawing, restore buffers
glBindVertexArray(0);
}
