CSE::DeferredRenderGroup Class Reference

#include <DeferredRenderGroup.h>

Inheritance diagram for CSE::DeferredRenderGroup:

Public Member Functions
	DeferredRenderGroup (const RenderMgr &renderMgr)
void	RegisterObject (SIRender *object) override
void	RemoveObjects (SIRender *object) override
void	RenderAll (const CameraBase &camera) const override
void	RenderGbuffer (const CameraBase &camera, const SGBuffer &gbuffer, const SShaderGroup &shaders) const
void	SetViewport ()
void	Exterminate () override
Public Member Functions inherited from CSE::SRenderGroup
	SRenderGroup (const RenderMgr &renderMgr)

Additional Inherited Members
Static Protected Member Functions inherited from CSE::SRenderGroup
static void	BindSourceBuffer (const SFrameBuffer &buffer, const GLProgramHandle &handle, int layout)
Protected Attributes inherited from CSE::SRenderGroup
const RenderMgr *	m_renderMgr

Detailed Description

This class is responsible for deferred rendering of G-Buffer objects.

Definition at line 15 of file DeferredRenderGroup.h.

Constructor & Destructor Documentation

DeferredRenderGroup()

DeferredRenderGroup::DeferredRenderGroup ( const RenderMgr & renderMgr )

explicit

Constructor for DeferredRenderGroup

Parameters

renderMgr

Reference to the RenderMgr object.

Definition at line 15 of file DeferredRenderGroup.cpp.

                                                                   : SRenderGroup(renderMgr) {
    m_width = renderMgr.GetWidth();
    m_height = renderMgr.GetHeight();
 
    m_lightMgr = CORE->GetCore(LightMgr);
}

References CSE::RenderMgr::GetHeight(), and CSE::RenderMgr::GetWidth().

Member Function Documentation

Exterminate()

void DeferredRenderGroup::Exterminate ( )

overridevirtual

Free all allocated resources.

Implements CSE::SRenderGroup.

Definition at line 154 of file DeferredRenderGroup.cpp.

                                      {
    for (auto gbuffer_pair : m_gbufferLayer) {
        auto gbuffer = gbuffer_pair.second;
        SAFE_DELETE(gbuffer);
    }
    m_gbufferLayer.clear();
}

RegisterObject()

void DeferredRenderGroup::RegisterObject ( SIRender * object )

overridevirtual

Register an object to the render group.

Parameters

object

A pointer to the object to be registered.

Implements CSE::SRenderGroup.

Definition at line 24 of file DeferredRenderGroup.cpp.

                                                         {
    const auto& material = object->GetMaterialReference();
    const auto& shaders = material->GetShaders();
    if (shaders == nullptr) return;
    auto* handle = const_cast<GLProgramHandle*>(shaders->GetHandle("deferred"));
 
    auto gbuffer = m_gbufferLayer[shaders];
    if (!gbuffer) {
        gbuffer = new SGBuffer();
        gbuffer->GenerateGBuffer(*m_width, *m_height);
        m_gbufferLayer[shaders] = gbuffer;
    }
    gbuffer->PushBackToLayer(object);
    gbuffer->BindLightPass(handle);
}

RemoveObjects()

void DeferredRenderGroup::RemoveObjects ( SIRender * object )

overridevirtual

Remove an object from the render group.

Parameters

object

A pointer to the object to be removed.

Implements CSE::SRenderGroup.

Definition at line 40 of file DeferredRenderGroup.cpp.

                                                        {
    const auto& material = object->GetMaterialReference();
    const auto& programLayer = m_gbufferLayer;
    auto it = std::find_if(programLayer.begin(), programLayer.end(), [&material](const auto& elem) {
        return elem.first == material->GetShaders();
    });
    if (it != programLayer.end()) {
        it->second->RemoveToLayer(object);
    }
}

RenderAll()

void DeferredRenderGroup::RenderAll ( const CameraBase & camera ) const

overridevirtual

Deferred rendering for each G-Buffer object.

Parameters

camera

Structure containing information values of the camera to be drawn.

Implements CSE::SRenderGroup.

Definition at line 51 of file DeferredRenderGroup.cpp.

                                                                  {
    for (const auto& gbuffer_pair : m_gbufferLayer) {
        const auto& shaders = gbuffer_pair.first;
        const auto& gbuffer = gbuffer_pair.second;
        RenderGbuffer(camera, *gbuffer, *shaders);
    }
}

References RenderGbuffer().

RenderGbuffer()

void DeferredRenderGroup::RenderGbuffer	(	const CameraBase &	camera,
		const SGBuffer &	gbuffer,
		const SShaderGroup &	shaders ) const

Deferred rendering for each G-Buffer object.

Parameters

camera	Structure containing information values of the camera to be drawn.
gbuffer	G-Buffer object to be drawn.

======================

1. Geometry Pass

======================

1. Light Pass

======================

1. Blit the depth buffer

Definition at line 60 of file DeferredRenderGroup.cpp.

                                                                      {
    const auto cameraMatrix = camera.GetCameraMatrixStruct();
    const auto& frameBuffer = camera.GetFrameBuffer();
    const bool hasFrameBuffer = frameBuffer != nullptr;
    const auto& lightPassHandle = gbuffer.GetLightPassHandle();
 
    const int bufferWidth = hasFrameBuffer ? frameBuffer->GetWidth() : (int) *m_width;
    const int bufferHeight = hasFrameBuffer ? frameBuffer->GetHeight() : (int) *m_height;
 
    gbuffer.AttachGeometryFrameBuffer();
    glViewport(0, 0, *m_width, *m_height);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    const auto& renderLayer = gbuffer.GetRendersLayer();
    const auto& handle = shaders.GetGeometryHandle();
    glUseProgram(handle->Program);
 
    if (handle->CullFace == 0) {
        glDisable(GL_CULL_FACE);
    }else {
        glEnable(GL_CULL_FACE);
        glCullFace(handle->CullFace);
    }
 
    for (const auto& render : renderLayer) {
        if (render == nullptr) continue;
        if (!render->isRenderActive) continue;
 
        const auto& material = render->GetMaterial();
        material->AttachElement(0);
        render->SetMatrix(cameraMatrix, handle);
        render->Render(handle);
    }
 
    const auto& deferredBuffer =
            frameBuffer == nullptr ? m_renderMgr->GetMainBuffer() : frameBuffer;
    deferredBuffer->AttachFrameBuffer();
    gbuffer.AttachLightPass();
    //Attach Light
    int layoutBegin =  m_lightMgr->AttachLightToShader(lightPassHandle);
    layoutBegin += m_lightMgr->AttachLightMapToShader(lightPassHandle, layoutBegin);
#ifdef CSE_SETTINGS_RENDER_SDFGI_SUPPORT
    {
        m_renderMgr->BindSdfMapUniforms(*lightPassHandle);
        layoutBegin += m_renderMgr->BindSdfMapTextures(*lightPassHandle, layoutBegin);
    }
#endif
    if (lightPassHandle->CullFace == 0) {
        glDisable(GL_CULL_FACE);
    }else {
        glEnable(GL_CULL_FACE);
        glCullFace(lightPassHandle->CullFace);
    }
 
    gbuffer.AttachLightPassTexture(layoutBegin);
    BindSourceBuffer(*deferredBuffer, *lightPassHandle, layoutBegin + 3);
 
    ShaderUtil::BindCameraToShader(*lightPassHandle, cameraMatrix.camera, cameraMatrix.cameraPosition,
                                   cameraMatrix.projection, cameraMatrix.camera);
    gbuffer.RenderLightPass();
 
//    if (frameBuffer == nullptr) {
//        m_renderMgr->GetMainBuffer()->BlitFrameBuffer(*deferredBuffer);
//    } else {
//        frameBuffer->BlitFrameBuffer(*deferredBuffer);
//    }
//    gbuffer.AttachGeometryFrameBuffer(GL_READ_FRAMEBUFFER);
//    if(frameBuffer == nullptr) {
//        GetMainBuffer()->AttachFrameBuffer(GL_DRAW_FRAMEBUFFER);
//    }
//    else {
//        frameBuffer->AttachFrameBuffer(GL_DRAW_FRAMEBUFFER);
//    }
//
//    glBlitFramebuffer(0, 0, *m_width, *m_height, 0, 0, bufferWidth, bufferHeight, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
}

References CSE::LightMgr::AttachLightMapToShader(), CSE::LightMgr::AttachLightToShader(), CSE::ShaderUtil::BindCameraToShader(), and CSE::SRenderGroup::BindSourceBuffer().

Referenced by RenderAll().

SetViewport()

void DeferredRenderGroup::SetViewport

(

)

Set the viewport size.

Definition at line 147 of file DeferredRenderGroup.cpp.

                                      {
    for (const auto& gbufferPair : m_gbufferLayer) {
        const auto& gbuffer = gbufferPair.second;
        gbuffer->ResizeGBuffer((int) *m_width, (int) *m_height);
    }
}

---

The documentation for this class was generated from the following files:

• Manager/Render/DeferredRenderGroup.h
• Manager/Render/DeferredRenderGroup.cpp