LightComponent.h

#pragma once
 
#include "../../EntityPtr.h"
 
#include "Foundation/Geometry/Glm.hpp"
 
namespace Cogs
{
  namespace Core
  {
    enum class LightType
    {
      Directional,
      Point,
      Spot,
    };
 
    enum class LightingLayers : uint32_t
    {
      None = 0,
      Default = 1 << 0,
      All = 0xFFFFFFFFu
    };
 
    ENABLE_ENUM_FLAGS(LightingLayers);
 
    enum class ShadowUpdate
    {
      Default = 0,
      Dynamic = 1,
      Partial = 2,
      Static = 3,
      StaticPartial = 4,
      None = 5,
    };
 
    enum class SoftShadows
    {
      None = 0,
      Low,
      High,
      Default = High
    };
 
    class LightComponent : public ComponentModel::Component
    {
    public:
      static void registerType();
 
      glm::vec4 lightColor = glm::vec4(1, 1, 1, 1);
 
      LightType lightType = LightType::Directional;
 
      LightingLayers lightingLayer = LightingLayers::Default;
 
      float intensity = 1;
 
      float range = 1000.0f;
 
      float shadowNearPlane = 0.0f;
 
      bool enabled = true;
 
      bool mainLight = false;
 
      bool castShadows = false;
 
      bool tightShadowBounds = false;
 
      bool dynamicCascadeCount = false;
 
      float shadowIntensityOffset = 0;
 
      float shadowSampleBias = 0.004f;
 
      float shadowBias = 2.f;
 
      float shadowSlopedBias = 5.f;
 
      float shadowBiasClamp = 4.f;
 
      float _shadowNormalOffsetBias = 0.1f;
 
      WeakEntityPtr lodReference;
 
      std::vector<WeakEntityPtr> cameras;
 
      size_t hash(size_t hashValue = Cogs::hash()) const {
        hashValue = Component::hash(hashValue);
 
        hashValue = Cogs::hash(lightColor, hashValue);
        hashValue = Cogs::hash(lightType, hashValue);
        hashValue = Cogs::hash(lightingLayer, hashValue);
        hashValue = Cogs::hash(intensity, hashValue);
        hashValue = Cogs::hash(range, hashValue);
        hashValue = Cogs::hash(shadowNearPlane, hashValue);
        hashValue = Cogs::hash(enabled, hashValue);
        hashValue = Cogs::hash(mainLight, hashValue);
        hashValue = Cogs::hash(castShadows, hashValue);
        hashValue = Cogs::hash(tightShadowBounds, hashValue);
        hashValue = Cogs::hash(dynamicCascadeCount, hashValue);
        hashValue = Cogs::hash(shadowIntensityOffset, hashValue);
        hashValue = Cogs::hash(shadowSampleBias, hashValue);
        hashValue = Cogs::hash(shadowBias, hashValue);
        hashValue = Cogs::hash(shadowSlopedBias, hashValue);
        hashValue = Cogs::hash(shadowBiasClamp, hashValue);
        hashValue = Cogs::hash(_shadowNormalOffsetBias, hashValue);
 
        return hashValue;
      }
    };
  }
}
 
template<> inline Cogs::StringView getName<Cogs::Core::LightComponent>() { return "LightComponent"; }
 
template<> inline Cogs::StringView getName<Cogs::Core::LightType>() { return "LightType"; }
template<> inline Cogs::StringView getName<Cogs::Core::LightingLayers>() { return "LightingLayers"; }
template<> inline Cogs::StringView getName<Cogs::Core::ShadowUpdate>() { return "ShadowUpdate"; }
template<> inline Cogs::StringView getName<Cogs::Core::SoftShadows>() { return "SoftShadows"; }