RendererCameraSettings.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/Texture/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine {
 
    struct RendererHDRSettings final {
        double exposure = 1.0;
 
        double gamma = 2.2;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(exposure);
            CE_REFL_DATA(gamma);
        }
    };
 
    struct RendererBloomSettings final {
        bool enabled = false;
 
        double threshold = 1.0;
 
        int strength = 5;
 
        Vector3 brightnessFactor = Vector3(0.2126, 0.7152, 0.0722);
 
        bool toneMapping = false;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(enabled);
            CE_REFL_DATA(threshold);
            CE_REFL_DATA(strength);
            CE_REFL_DATA(brightnessFactor);
            CE_REFL_DATA(toneMapping);
        }
    };
 
    struct VoxelConeTracingSettings final {
        UInt32 volumeDimension = 256;
 
        bool normalWeightedLambert = true;
 
        bool useShadowMapIfAvailable = true;
 
        UInt32 voxelUpdateChunkSize = 8;
 
        double maximumVolumeGridSize = 60.0;
 
        UInt32 bounces = 1;
 
    public: // Diffuse Tracing
        bool traceDiffuse = true;
 
        double diffuseSamplingFactor = 0.9;
 
        double diffuseMaxTracingDistance = 1.0;
 
        double diffuseBounceStrength = 1.0;
 
        bool traceSimplifiedDiffuseCone = false;
 
        bool traceNormalOrientedDiffuseCone = true;
 
    public: // Specular Tracing
        bool traceSpecular = true;
 
        double specularSamplingFactor = 0.9;
 
        double specularMaxTracingDistance = 1.0;
 
        double specularBounceStrength = 1.0;
 
    public: // Ambient Occlusion Tracing
        bool traceAmbientOcclusion = true;
 
        double ambientOcclusionFalloff = 725.0;
 
        double ambientOcclusionAlpha = 0.01;
 
    public:
        double emissiveInjectionFactor = 100.0;
 
        double scalingFactor = 1.0;
 
        bool scalingMultisampling = true;
 
        bool alwaysVoxelize = false;
 
        bool alwaysInjectRadiance = false;
 
        bool debug = false;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(volumeDimension);
            CE_REFL_DATA(normalWeightedLambert);
            CE_REFL_DATA(useShadowMapIfAvailable);
            CE_REFL_DATA(voxelUpdateChunkSize);
            CE_REFL_DATA(maximumVolumeGridSize);
            CE_REFL_DATA(bounces);
            CE_REFL_DATA(traceDiffuse);
            CE_REFL_DATA(diffuseSamplingFactor);
            CE_REFL_DATA(diffuseMaxTracingDistance);
            CE_REFL_DATA(diffuseBounceStrength);
            CE_REFL_DATA(traceSimplifiedDiffuseCone);
            CE_REFL_DATA(traceNormalOrientedDiffuseCone);
            CE_REFL_DATA(traceSpecular);
            CE_REFL_DATA(specularSamplingFactor);
            CE_REFL_DATA(specularMaxTracingDistance);
            CE_REFL_DATA(specularBounceStrength);
            CE_REFL_DATA(traceAmbientOcclusion);
            CE_REFL_DATA(ambientOcclusionFalloff);
            CE_REFL_DATA(ambientOcclusionAlpha);
            CE_REFL_DATA(emissiveInjectionFactor);
            CE_REFL_DATA(scalingFactor);
            CE_REFL_DATA(scalingMultisampling);
            CE_REFL_DATA(alwaysVoxelize);
            CE_REFL_DATA(alwaysInjectRadiance);
            CE_REFL_DATA(debug);
        }
    };
 
    struct GlobalIlluminationSettings final {
        bool enabled = false;
 
        VoxelConeTracingSettings voxelConeTracingSettings;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(enabled);
            CE_REFL_DATA(voxelConeTracingSettings);
        }
    };
 
    struct RendererCameraSettings final {
        RendererHDRSettings hdr;
 
        RendererBloomSettings bloom;
 
        GlobalIlluminationSettings globalIllumination;
 
        bool depthPrePass = false;
 
        bool frustumCulling = false;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(hdr);
            CE_REFL_DATA(bloom);
            CE_REFL_DATA(globalIllumination);
            CE_REFL_DATA(depthPrePass);
            CE_REFL_DATA(frustumCulling);
        }
    };
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::RendererHDRSettings);
 
CE_REFLECT_HASH(CeresEngine::RendererBloomSettings);
 
CE_REFLECT_HASH(CeresEngine::VoxelConeTracingSettings);
 
CE_REFLECT_HASH(CeresEngine::GlobalIlluminationSettings);
 
CE_REFLECT_HASH(CeresEngine::RendererCameraSettings);