LightInteractions.cpp

#include "LightInteractions.h"

#include "OpenGLShader.h"
#include "ObjectRenderer.h"

namespace render
{

void LightInteractions::addObject(IRenderableObject& object, IRenderEntity& entity, OpenGLShader* shader)
{
    auto& objectsByMaterial = _objectsByEntity.emplace(
        &entity, ObjectsByMaterial{}).first->second;

    auto& surfaces = objectsByMaterial.emplace(
        shader, ObjectList{}).first->second;

    surfaces.emplace_back(std::ref(object));

    ++_objectCount;
}

bool LightInteractions::isInView(const IRenderView& view)
{
    return view.TestAABB(_lightBounds) != VOLUME_OUTSIDE;
}

void LightInteractions::collectSurfaces(const std::set<IRenderEntityPtr>& entities)
{
    // Now check all the entities intersecting with this light
    for (const auto& entity : entities)
    {
        entity->foreachRenderableTouchingBounds(_lightBounds,
            [&](const IRenderableObject::Ptr& object, Shader* shader)
        {
            // Skip empty objects
            if (!object->isVisible()) return;

            // Don't collect invisible shaders
            if (!shader->isVisible()) return;

            auto glShader = static_cast<OpenGLShader*>(shader);

            // We only consider materials designated for camera rendering
            if (!glShader->isApplicableTo(RenderViewType::Camera))
            {
                return;
            }

            if (!glShader->getInteractionPass())
            {
                return; // This material doesn't interact with lighting
            }

            addObject(*object, *entity, glShader);
        });
    }
}

void LightInteractions::fillDepthBuffer(OpenGLState& state, RenderStateFlags globalFlagsMask, 
    const IRenderView& view, std::size_t renderTime)
{
    std::vector<IGeometryStore::Slot> untransformedObjects;
    untransformedObjects.reserve(10000);

    for (const auto& [entity, objectsByShader] : _objectsByEntity)
    {
        for (const auto& [shader, objects] : objectsByShader)
        {
            if (!shader->getDepthFillPass()) continue;

            // Skip translucent materials
            if (shader->getMaterial() && shader->getMaterial()->getCoverage() == Material::MC_TRANSLUCENT)
            {
                continue;
            }
            
            // Apply our state to the current state object
            shader->getDepthFillPass()->applyState(state, globalFlagsMask, view.getViewer(), renderTime, entity);

            for (const auto& object : objects)
            {
                // We submit all objects with an identity matrix in a single multi draw call
                if (!object.get().isOriented())
                {
                    untransformedObjects.push_back(object.get().getStorageLocation());
                    continue;
                }

                ObjectRenderer::SubmitObject(object.get(), _store);
                ++_drawCalls;
            }

            if (!untransformedObjects.empty())
            {
                ObjectRenderer::SubmitGeometry(untransformedObjects, GL_TRIANGLES, _store);
                ++_drawCalls;

                untransformedObjects.clear();
            }
        }
    }
}

void LightInteractions::render(OpenGLState& state, RenderStateFlags globalFlagsMask, const IRenderView& view, std::size_t renderTime)
{
    auto worldToLight = _light.getLightTextureTransformation();

    std::vector<IGeometryStore::Slot> untransformedObjects;
    untransformedObjects.reserve(10000);

    for (const auto& [entity, objectsByShader] : _objectsByEntity)
    {
        for (const auto& [shader, objects] : objectsByShader)
        {
            const auto pass = shader->getInteractionPass();

            if (pass && pass->stateIsActive())
            {
                // Apply our state to the current state object
                pass->applyState(state, globalFlagsMask, view.getViewer(), renderTime, entity);

                for (const auto& object : objects)
                {
                    // We submit all objects with an identity matrix in a single multi draw call
                    if (!object.get().isOriented())
                    {
                        untransformedObjects.push_back(object.get().getStorageLocation());
                        continue;
                    }

                    OpenGLShaderPass::SetUpLightingCalculation(state, &_light, worldToLight,
                        view.getViewer(), object.get().getObjectTransform(), renderTime);

                    ObjectRenderer::SubmitObject(object.get(), _store);
                    ++_drawCalls;
                }

                if (!untransformedObjects.empty())
                {
                    OpenGLShaderPass::SetUpLightingCalculation(state, &_light, worldToLight,
                        view.getViewer(), Matrix4::getIdentity(), renderTime);

                    ObjectRenderer::SubmitGeometry(untransformedObjects, GL_TRIANGLES, _store);
                    ++_drawCalls;

                    untransformedObjects.clear();
                }
            }
        }
    }
}

}