VoxelConeTracing.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Renderer/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Renderer/RendererCameraSettings.hpp"
 
#include "CeresEngine/Renderer/RenderGraph/RenderResource.hpp"
#include "CeresEngine/Renderer/RenderGraph/RenderTask.hpp"
 
namespace CeresEngine {
 
    class VoxelConeTracing final {
    public:
        using Settings = VoxelConeTracingSettings;
 
        struct Context;
 
    public:
        class VoxelizationRenderTask final : public SimpleGraphicsRenderTask {
        public:
            struct {
                ImageRenderResourceRef albedo;
                ImageRenderResourceRef normal;
                ImageRenderResourceRef emission;
            } output;
 
        private:
            GPUSamplerPtr mSampler;
 
            RendererScene& mScene;
            RendererCamera& mCamera;
            const Settings& mSettings [[maybe_unused]];
 
        public:
            explicit VoxelizationRenderTask(RenderGraph& renderGraph, RendererScene& scene, RendererCamera& camera, const Settings& settings);
            ~VoxelizationRenderTask() final;
 
        protected:
            void compile(RenderTaskCompiler& compiler) final;
 
            void initialize(GPUDevice& device) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) final;
 
            using SimpleGraphicsRenderTask::execute;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, GPUGraphicsPipeline& pipeline) final;
 
            GPUGraphicsPipelinePtr createGraphicsPipeline(GPUDevice& device, GPURenderPass& renderPass) final;
        };
 
        class InjectRadianceRenderTask final : public SimpleComputeRenderTask {
        public:
            struct {
                ImageRenderResourceRef albedo;
                ImageRenderResourceRef normal;
                ImageRenderResourceRef emission;
            } input;
 
            struct {
                ImageRenderResourceRef voxel;
            } output;
 
        private:
            RendererScene& mScene;
            RendererCamera& mCamera;
            const Settings& mSettings [[maybe_unused]];
 
            GPUSamplerPtr mSampler;
 
        public:
            explicit InjectRadianceRenderTask(RenderGraph& renderGraph, RendererScene& scene, RendererCamera& camera, const Settings& settings);
            ~InjectRadianceRenderTask() final;
 
        protected:
            void compile(RenderTaskCompiler& compiler) final;
 
            void initialize(GPUDevice& device) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPUComputePipeline& pipeline) final;
 
            GPUComputePipelinePtr createComputePipeline(GPUDevice& device) final;
        };
 
        class PropagateRadianceRenderTask final : public SimpleComputeRenderTask {
        public:
            struct {
                ImageRenderResourceRef albedo;
                ImageRenderResourceRef normal;
                ImageRenderResourceRef voxel;
            } input;
 
            struct {
                ImageRenderResourceRef voxel;
            } output;
 
        private:
            Renderer& mRenderer [[maybe_unused]];
            RendererCamera& mCamera;
            const Settings& mSettings [[maybe_unused]];
            bool mShouldClear;
 
            GPUSamplerPtr mSampler;
 
        public:
            explicit PropagateRadianceRenderTask(RenderGraph& renderGraph, Renderer& renderer, RendererCamera& camera, const Settings& settings,
                bool shouldClear = true);
            ~PropagateRadianceRenderTask() final;
 
        protected:
            void compile(RenderTaskCompiler& compiler) final;
 
            void initialize(GPUDevice& device) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPUComputePipeline& pipeline) final;
 
            GPUComputePipelinePtr createComputePipeline(GPUDevice& device) final;
        };
 
        class IndirectLightingRenderTask final : public SimpleGraphicsRenderTask {
        public:
            struct {
                ImageRenderResourceRef depth;
 
                ImageRenderResourceRef normalAndRoughness;
 
                ImageRenderResourceRef albedoAndAmbientOcclusion;
 
                ImageRenderResourceRef emissionAndMetallic;
 
                ImageRenderResourceRef voxel;
            } input;
 
            struct {
                ImageRenderResourceRef lighting;
            } output;
 
        private:
            RendererCamera& mCamera;
            const Settings& mSettings [[maybe_unused]];
 
            GPUSamplerPtr mGeometrySampler;
 
            GPUSamplerPtr mVoxelSampler;
 
        public:
            explicit IndirectLightingRenderTask(RenderGraph& renderGraph, RendererCamera& camera, const Settings& settings);
            ~IndirectLightingRenderTask() final;
 
        protected:
            void initialize(GPUDevice& devic) final;
 
            void compile(RenderTaskCompiler& compiler) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, GPUGraphicsPipeline& pipeline) final;
 
            GPUGraphicsPipelinePtr createGraphicsPipeline(GPUDevice& device, GPURenderPass& renderPass) final;
        };
 
        class UpscalingRenderTask final : public SimpleGraphicsRenderTask {
        private:
            const Settings& mSettings [[maybe_unused]];
 
            GPUSamplerPtr mSampler;
 
        public:
            explicit UpscalingRenderTask(RenderGraph& renderGraph, const Settings& settings);
            ~UpscalingRenderTask() final;
 
        protected:
            void compile(RenderTaskCompiler& compiler) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, GPUGraphicsPipeline& pipeline) final;
 
            GPUGraphicsPipelinePtr createGraphicsPipeline(GPUDevice& device, GPURenderPass& renderPass) final;
        };
 
        class DebugRenderTask final : public SimpleGraphicsRenderTask {
        public:
            struct {
                ImageRenderResourceRef voxel;
            } input;
 
            struct {
                ImageRenderResourceRef color;
                ImageRenderResourceRef depth;
            } output;
 
        private:
            GPUGraphicsPipelinePtr mPipeline;
 
            RendererCamera& mCamera;
            const Settings& mSettings [[maybe_unused]];
 
        public:
            explicit DebugRenderTask(RenderGraph& renderGraph, RendererCamera& camera, const Settings& settings);
            ~DebugRenderTask() final;
 
        protected:
            void compile(RenderTaskCompiler& compiler) final;
 
            void execute(RenderGraphContext& context, GPUCommandBuffer& commandBuffer, GPURenderTarget& renderTarget, GPUGraphicsPipeline& pipeline) final;
 
            GPUGraphicsPipelinePtr createGraphicsPipeline(GPUDevice& device, GPURenderPass& renderPass) final;
        };
    };
 
} // namespace CeresEngine