Light.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 "SceneObject.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/ScopeExit.hpp"
 
#include "CeresEngine/Entity/Component.hpp"
#include "CeresEngine/Entity/Entity.hpp"
#include "CeresEngine/Renderer/RendererLightSettings.hpp"
 
#include <glm/vec3.hpp>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() LightType {
        Point,
 
        Directional,
 
        Spot,
 
        Area,
    };
 
    struct CE_SCRIPT_EXPORT() LightComponent final : public Component<LightComponent> {
        CE_REFLECTABLE_STRUCT
        struct Accessor;
 
        CE_SCRIPT_EXPORT()
        LightType type = LightType::Point;
 
        CE_SCRIPT_EXPORT()
        Vector3 color = Vector3(1.0);
 
        double power = 1.0;
 
        double radius = 1.0;
 
        CE_SCRIPT_EXPORT()
        double strength = 1.0;
 
        CE_SCRIPT_EXPORT()
        bool shouldCastShadows = false;
 
        CE_SCRIPT_EXPORT()
        double shadowOcclusionStrength = 1.0;
 
        CE_SCRIPT_EXPORT()
        double constant = 0.0;
 
        CE_SCRIPT_EXPORT()
        double linear = 0.0;
 
        CE_SCRIPT_EXPORT()
        double quadratic = 1.0;
 
        CE_SCRIPT_EXPORT()
        double cutOff = 10.0;
 
        CE_SCRIPT_EXPORT()
        double outerCutOff = 15.0;
 
        RendererLightSettings rendererSettings;
 
        CE_SCRIPT_EXPORT()
        LightComponent() = default;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(type);
            CE_REFL_DATA(color);
            CE_REFL_DATA(strength);
            CE_REFL_DATA(shouldCastShadows);
            CE_REFL_DATA(shadowOcclusionStrength);
            CE_REFL_DATA(constant);
            CE_REFL_DATA(linear);
            CE_REFL_DATA(quadratic);
            CE_REFL_DATA(cutOff);
            CE_REFL_DATA(outerCutOff);
            CE_REFL_DATA(rendererSettings);
        }
    };
 
    struct CE_SCRIPT_EXPORT() LightComponent::Accessor : public Component<LightComponent>::Accessor {
        using Component<LightComponent>::Accessor::Accessor;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        LightType getType() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setType(LightType type) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getColor() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setColor(Vector3 color) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getStrength() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setStrength(double strength) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool getShouldCastShadows() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setShouldCastShadows(bool shouldCastShadows) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getShadowOcclusionStrength() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setShadowOcclusionStrength(double shadowOcclusionStrength) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getConstant() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setConstant(double constant) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getLinear() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setLinear(double linear) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getQuadratic() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setQuadratic(double quadratic) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getCutOff() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setCutOff(double cutOff) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        double getOuterCutOff() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setOuterCutOff(double outerCutOff) noexcept;
 
        [[nodiscard]] const RendererLightSettings& getRendererSettings() const;
 
        void setRendererSettings(const RendererLightSettings& rendererSettings);
 
        template<CInvocable<RendererLightSettings&> Func> decltype(auto) updateRendererSettings(Func&& func) noexcept {
            RendererLightSettings settings = getRendererSettings();
            const ScopeExit commitSettings([&]() { setRendererSettings(settings); });
            return func(settings);
        }
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA_GETSET(type, getType, setType);
            CE_REFL_DATA_GETSET(color, getColor, setColor);
            CE_REFL_DATA_GETSET(strength, getStrength, setStrength);
            CE_REFL_DATA_GETSET(shouldCastShadows, getShouldCastShadows, setShouldCastShadows);
            CE_REFL_DATA_GETSET(shadowOcclusionStrength, getShadowOcclusionStrength, setShadowOcclusionStrength);
            CE_REFL_DATA_GETSET(constant, getConstant, setConstant);
            CE_REFL_DATA_GETSET(linear, getLinear, setLinear);
            CE_REFL_DATA_GETSET(quadratic, getQuadratic, setQuadratic);
            CE_REFL_DATA_GETSET(cutOff, getCutOff, setCutOff);
            CE_REFL_DATA_GETSET(outerCutOff, getOuterCutOff, setOuterCutOff);
            CE_REFL_DATA_GETSET(rendererSettings, getRendererSettings, setRendererSettings);
        }
    };
 
    class CE_SCRIPT_EXPORT() Light final : public TSceneObject<LightComponent> {
    public:
        Light(EntityManager& entityManager, const Entity& parent, LightType type);
        using TSceneObject::TSceneObject;
    };
    extern template class TSceneObject<LightComponent>;
 
} // namespace CeresEngine
 
CE_EXTERN_COMPONENT(CeresEngine::LightComponent);
 
CE_REFLECT_HASH(CeresEngine::LightComponent);
 
CE_ENTITY_OBJECT_HASH(CeresEngine::Light);