CSE::DepthOnlyRenderGroup Class Reference

#include <DepthOnlyRenderGroup.h>

Inheritance diagram for CSE::DepthOnlyRenderGroup:

Public Member Functions
	DepthOnlyRenderGroup (const RenderMgr &renderMgr)
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 responsible for rendering depth only objects for use in creating shadow maps.

Definition at line 13 of file DepthOnlyRenderGroup.h.

Constructor & Destructor Documentation

DepthOnlyRenderGroup()

DepthOnlyRenderGroup::DepthOnlyRenderGroup ( const RenderMgr & renderMgr )

explicit

Constructor for the DepthOnlyRenderGroup.

Parameters

renderMgr

The render manager to use.

Definition at line 15 of file DepthOnlyRenderGroup.cpp.

                                                                     : SRenderGroup(renderMgr) {
}

Member Function Documentation

Exterminate()

void DepthOnlyRenderGroup::Exterminate ( )

overridevirtual

Removes all objects from the render group.

Implements CSE::SRenderGroup.

Definition at line 72 of file DepthOnlyRenderGroup.cpp.

                                       {
    m_depthObjects.clear();
}

RegisterObject()

void DepthOnlyRenderGroup::RegisterObject ( SIRender * object )

overridevirtual

Register an object to the render group.

Parameters

object

The object to be registered.

Implements CSE::SRenderGroup.

Definition at line 18 of file DepthOnlyRenderGroup.cpp.

                                                          {
    const auto& material = object->GetMaterialReference();
    if (material == nullptr) return;
 
    auto& depthGroup = m_depthObjects[material->GetShaders()];
    depthGroup.push_back(object);
}

RemoveObjects()

void DepthOnlyRenderGroup::RemoveObjects ( SIRender * object )

overridevirtual

Remove an object from the render group.

Parameters

object

The object to be removed.

Implements CSE::SRenderGroup.

Definition at line 26 of file DepthOnlyRenderGroup.cpp.

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

RenderAll()

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

overridevirtual

Rendering for a depth buffer to use for shadows. The render target depends on the shadow settings.

Parameters

camera

The light(camera) you want to render.

Implements CSE::SRenderGroup.

Definition at line 44 of file DepthOnlyRenderGroup.cpp.

                                                                   {
    const auto cameraMatrix = camera.GetCameraMatrixStruct();
    const auto& frameBuffer = camera.GetFrameBuffer();
    if (frameBuffer == nullptr) {
        m_renderMgr->GetMainBuffer()->AttachFrameBuffer();
    } else {
        frameBuffer->AttachFrameBuffer();
    }
 
    glClear(GL_DEPTH_BUFFER_BIT);
    for (const auto& shadowObject : m_depthObjects) {
        const auto& handle = shadowObject.first->GetDepthOnlyHandle();
        if (handle == nullptr) continue;
        glUseProgram(handle->Program);
        for(const auto& render : shadowObject.second) {
            if (!render->isRenderActive) continue;
            const auto& shadowTransform = static_cast<RenderComponent*>(render)->GetGameObject()->GetTransform();
 
            if (LightMgr::SHADOW_DISTANCE < vec3::Distance(cameraMatrix.cameraPosition, shadowTransform->m_position))
                continue;
 
            render->SetMatrix(cameraMatrix, handle);
            render->Render(handle);
        }
    }
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

References CSE::LightMgr::SHADOW_DISTANCE.

---

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

• Manager/Render/DepthOnlyRenderGroup.h
• Manager/Render/DepthOnlyRenderGroup.cpp