CSE::ForwardRenderGroup Class Reference

#include <ForwardRenderGroup.h>

Inheritance diagram for CSE::ForwardRenderGroup:

Public Member Functions
	ForwardRenderGroup (const RenderMgr &renderMgr)
	~ForwardRenderGroup () override
void	RegisterObject (SIRender *object) override
void	RemoveObjects (SIRender *object) override
void	RenderAll (const CameraBase &camera) const override
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 used for forward-rendering objects. It contains a collection of objects which should be forward-rendered.

Definition at line 16 of file ForwardRenderGroup.h.

Constructor & Destructor Documentation

ForwardRenderGroup()

ForwardRenderGroup::ForwardRenderGroup ( const RenderMgr & renderMgr )

explicit

Constructor for the ForwardRenderGroup class.

Parameters

renderMgr

The render manager object.

Definition at line 15 of file ForwardRenderGroup.cpp.

                                                                 : SRenderGroup(renderMgr) {
    m_lightMgr = CORE->GetCore(LightMgr);
}

~ForwardRenderGroup()

ForwardRenderGroup::~ForwardRenderGroup ( )

overridedefault

Destructor for the ForwardRenderGroup class.

Member Function Documentation

Exterminate()

void ForwardRenderGroup::Exterminate ( )

overridevirtual

Clear all objects in the forward-rendering list.

Implements CSE::SRenderGroup.

Definition at line 109 of file ForwardRenderGroup.cpp.

                                     {
    m_rendersLayer.clear();
}

RegisterObject()

void ForwardRenderGroup::RegisterObject ( SIRender * object )

overridevirtual

Register an object to be forward-rendered.

Parameters

object

The object to be registered.

Implements CSE::SRenderGroup.

Definition at line 21 of file ForwardRenderGroup.cpp.

                                                        {
    const auto& material = object->GetMaterialReference();
    if (material == nullptr) return;
 
    short orderLayer = material->GetOrderLayer();
    const auto& shaders = material->GetShaders();
    if (shaders == nullptr) return;
 
    auto& layer = m_rendersLayer[orderLayer][shaders];
    layer.push_back(object);
}

RemoveObjects()

void ForwardRenderGroup::RemoveObjects ( SIRender * object )

overridevirtual

Remove an object from the forward-rendering list.

Parameters

object

The object to be removed.

Implements CSE::SRenderGroup.

Definition at line 33 of file ForwardRenderGroup.cpp.

                                                       {
    const auto& material = object->GetMaterialReference();
    if (material == nullptr) return;
 
    short orderLayer = material->GetOrderLayer();
    const auto& shaders = material->GetShaders();
    if (shaders == nullptr) return;
 
    auto orderLayerIter = m_rendersLayer.find(orderLayer);
    if (orderLayerIter != m_rendersLayer.end()) {
        auto& programLayer = orderLayerIter->second;
        auto handlerPair = programLayer.find(shaders);
        if (handlerPair != programLayer.end()) {
            auto& layerVector = handlerPair->second;
            layerVector.erase(std::remove(layerVector.begin(), layerVector.end(), object),
                              layerVector.end());
 
            // 렌더링 객체가 제거된 뒤에도 공간이 비어 있는 경우, 그 공간을 제거한다.
            if (layerVector.empty()) programLayer.erase(handlerPair);
        }
        if (programLayer.empty()) m_rendersLayer.erase(orderLayerIter);
    }
}

RenderAll()

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

overridevirtual

Render the objects to be forward-rendered.

Parameters

camera

Structure containing information values of the camera to be drawn.

Implements CSE::SRenderGroup.

Definition at line 57 of file ForwardRenderGroup.cpp.

                                                                 {
    const auto cameraMatrix = camera.GetCameraMatrixStruct();
    const auto& cameraBuffer = camera.GetFrameBuffer();
    const auto& frameBuffer = cameraBuffer == nullptr
                              ? m_renderMgr->GetMainBuffer() : cameraBuffer;
    OrderRenderLayer orderRenderLayer(m_rendersLayer.begin(), m_rendersLayer.end());
    frameBuffer->AttachFrameBuffer();
 
    for (const auto& orderLayerPair : orderRenderLayer) {
        const auto& orderLayer = orderLayerPair.second;
        ProgramRenderLayer programComp(orderLayer.begin(), orderLayer.end());
 
        for (const auto& programPair : programComp) {
            const auto& handler = *programPair.first->GetForwardHandle();
            const auto& renderComp = programPair.second;
 
            if (programPair.first == nullptr) continue;
            if (renderComp.empty()) continue;
 
            glUseProgram(handler.Program);
            //Attach Light
            int layoutBegin = m_lightMgr->AttachLightToShader(&handler);
            layoutBegin += m_lightMgr->AttachLightMapToShader(&handler, layoutBegin);
#ifdef CSE_SETTINGS_RENDER_SDFGI_SUPPORT
            m_renderMgr->BindSdfMapUniforms(handler);
            layoutBegin += m_renderMgr->BindSdfMapTextures(handler, layoutBegin);
#endif
            if (handler.CullFace == 0) {
                glDisable(GL_CULL_FACE);
            }else {
                glEnable(GL_CULL_FACE);
                glCullFace(handler.CullFace);
            }
 
            for (const auto& render : renderComp) {
                if (render == nullptr) continue;
                if (!render->isRenderActive) continue;
 
                const auto& material = render->GetMaterial();
                int materialLayout = material->AttachElement(layoutBegin);
                render->SetMatrix(cameraMatrix, &handler);
                BindSourceBuffer(*frameBuffer, handler, layoutBegin + materialLayout + 1);
                render->Render(&handler);
            }
        }
    }
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

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

---

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

• Manager/Render/ForwardRenderGroup.h
• Manager/Render/ForwardRenderGroup.cpp