LightSystem.cpp

#ifdef _WIN32
// TODO: Remove when we update past GLM 0.9.9.7
#pragma warning(push)
#pragma warning(disable: 4127)  // conditional expression is constant
#include <glm/ext/matrix_clip_space.hpp>
#pragma warning(pop)
#endif
 
#include "LightSystem.h"
 
#include "Rendering/ICapabilities.h"
 
#include "Context.h"
#include "Services/Time.h"
 
#include "Scene/GetBounds.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Renderer/CullingManager.h"
#include "Renderer/IRenderer.h"
 
#include "Resources/TextureManager.h"
#include "Resources/MaterialManager.h"
 
#include "Utilities/Parsing.h"
#include "Utilities/Math.h"
 
#include <glm/glm.hpp>
#include <glm/gtx/compatibility.hpp>
#include <glm/gtc/color_space.hpp>
 
namespace
{
  using namespace Cogs::Core;
 
  struct CamState
  {
    const CameraData * cameraData = nullptr;
    glm::mat4 rawInverseProjection;
    glm::mat4 rawInverseViewProjection;
  };
 
  static const glm::vec3 corners[] =
  {
    { -1, -1, -1 },
    { 1, -1, -1 },
    { 1,  1, -1 },
    { -1,  1, -1 },
    { -1, -1,  1 },
    { 1, -1,  1 },
    { 1,  1,  1 },
    { -1,  1,  1 },
  };
 
  static const uint32_t edgeIndicesData[][2] = {
    {0, 1},
    {0, 2},
    {0, 4},
    {1, 3},
    {1, 5},
    {2, 3},
    {2, 6},
    {3, 7},
    {4, 5},
    {4, 6},
    {5, 7},
    {6, 7}
  };
 
  static void clipLineSegments(std::vector<glm::vec3>& E, const glm::vec4 plane)
  {
    size_t o = 0;
    for (size_t i = 0; i < E.size(); i += 2) {
      const auto a = E[i + 0];
      const auto b = E[i + 1];
      const float d0 = glm::dot(glm::vec4(a, 1.f), plane);
      const float d1 = glm::dot(glm::vec4(b, 1.f), plane);
 
      bool b0 = 0.f <= d0;
      bool b1 = 0.f <= d1;
 
      auto d = b - a;
      auto num = glm::dot(d, glm::vec3(plane));
      if (glm::abs(num) < 0.01f) {         // close to parallel, discard and let other edges find intersection.
        b0 = b1 = false;
      }
      if (b0) E[o++] = a;
      if (b1) E[o++] = b;
      if (b0 == b1) continue;
 
      // <a + t(b-a), m> = 0  <=>    <a,m> + t<b-a,m> = 0    <=>    t = -<a,m> / <b-a,m>
 
      auto t = -glm::dot(glm::vec4(a, 1.f), plane) / num;
 
      E[o++] = a + t * d;
    }
    E.resize(o);
    assert((E.size() & 1) == 0);
 
  }
 
  static glm::mat4 rotateVecToY(const glm::vec2& d)
  {
    auto l2 = glm::dot(d, d);
    float c = 1.f;
    float s = 0.f;
    if (0.001f <= l2) {
      const auto r = 1.f / glm::sqrt(l2);
      c = r * d.y;  // Cosine of rotation
      s = r * d.x;  // Sine of rotation
    }
    return glm::mat4( c, s, 0, 0,      // Rotation about Z matrix.
                     -s, c, 0, 0,
                      0, 0, 1, 0,
                      0, 0, 0, 1);
  }
 
  static glm::mat4 createLightViewMatrix(const glm::vec4 & /*cascadeLine*/, const glm::quat& rotation)
  {
    const glm::mat4 lightView = glm::mat4_cast(glm::conjugate(rotation));
 
    auto lz = glm::abs(euclidean(lightView * glm::vec4(0, 0, 1, 1)));
 
    glm::vec3 align_axis = glm::vec3(0, 1, 0);
    if (lz.y > lz.x && lz.y > lz.z) {
      // light mainly from y-dir, align light y with z.
      align_axis = glm::vec3(0, 0, 1);
    }
 
    // Try to rotate such that the light view Y-axis aligns with the cascade-line,
    // so the cascade frustum enclose the cascade as tight as possible.
    auto cascadeAxisLW = glm::vec3(glm::vec2(glm::mat3(lightView) * glm::vec3(align_axis)), 0.f);
    return rotateVecToY(cascadeAxisLW) * lightView;
  }
 
  static glm::mat4 createRotaryAlignmentMatrix(const glm::mat4& M)
  {
    auto ro = euclidean(M * glm::vec4(0, 0, 0, 1));
    auto rx = euclidean(M * glm::vec4(1, 0, 0, 1)) - ro;
    auto ry = euclidean(M * glm::vec4(0, 1, 0, 1)) - ro;
    auto rz = euclidean(M * glm::vec4(0, 0, 1, 1)) - ro;
 
    auto xz = glm::abs(rx.z);
    auto yz = glm::abs(ry.z);
    auto zz = glm::abs(rz.z);
 
    glm::vec2 d;
    if (xz < yz && xz < zz) {
      d = glm::vec2(rx);
    }
    else if (yz < zz) {
      d = glm::vec2(ry);
    }
    else {
      d = glm::vec2(rz);
    }
    return rotateVecToY(d);
  }
 
  static void createFrustumFitMatrix(Context * context,
                                     glm::mat4& rawCascadeProjectionMatrix,
                                     glm::mat4& rawCascadeCullMatrix,
                                     LightCascadeFrustaPoints* frustaPoints,
                                     const CameraData* refCamData,
                                     const std::vector<CamState>& camStates,
                                     const glm::mat4& lightView,
                                     const glm::vec4& cascadeLine,
                                     const float n, const float f,
                                     float frustumSlack,
                                     uint32_t resolution,
                                     glm::uvec2 &blueNoiseOffset)
  {
 
    auto toCull = createRotaryAlignmentMatrix(lightView * refCamData->inverseViewMatrix);
 
    glm::vec3 min_lv(std::numeric_limits<float>::max());
    glm::vec3 min_cv = min_lv;
    glm::vec3 max_lv(-std::numeric_limits<float>::max());
    glm::vec3 max_cv = max_lv;
 
    for (const auto & camState : camStates) {
      const auto M = lightView * camState.rawInverseViewProjection;
      if (camState.cameraData == refCamData) {
        // cascadeLine is per definition aligned with the reference camera,
        // so we can avoid the more elaborate and numerically challenging
        // approach of arbitrary clipping.
 
        // First, we find the z and w clip-space values of points on the near
        // and far-planes.
        const auto row2 = glm::transpose(refCamData->rawProjectionMatrix)[2];
        const auto row3 = glm::transpose(refCamData->rawProjectionMatrix)[3];
        const auto zn = glm::dot(row2, glm::vec4(0, 0, -n, 1));
        const auto wn = glm::dot(row3, glm::vec4(0, 0, -n, 1));
        const auto zf = glm::dot(row2, glm::vec4(0, 0, -f, 1));
        const auto wf = glm::dot(row3, glm::vec4(0, 0, -f, 1));
 
        // Then we transform the corners of the truncated frustum into light
        // space, and use this to form a bounding box.
        for (unsigned i = 0; i < 4; i++) {
          const auto pn = euclidean(M * glm::vec4(wn*glm::vec2(corners[i]), zn, wn));
          const auto pf = euclidean(M * glm::vec4(wf*glm::vec2(corners[i]), zf, wf));
          if (frustaPoints) {
            frustaPoints->points.push_back(pn);
            frustaPoints->points.push_back(pf);
          }
          min_lv = glm::min(min_lv, glm::min(pn, pf));
          max_lv = glm::max(max_lv, glm::max(pn, pf));
 
          min_cv = glm::min(min_cv, glm::min(glm::vec3(toCull * glm::vec4(pn, 1)),      // toCull is just a rotation, so it is safe to skip 1/w.
                                             glm::vec3(toCull * glm::vec4(pf, 1))));
          max_cv = glm::max(max_cv, glm::max(glm::vec3(toCull * glm::vec4(pn, 1)),
                                             glm::vec3(toCull * glm::vec4(pf, 1))));
        }
      }
      else {
        // Cascade-line is not aligned, so we use a more elaborate approach:
        // First, we transform the (un-truncated) view frustum to light space.
        glm::vec3 p[8];
        for (unsigned i = 0; i < 8; i++) {
          p[i] = euclidean(M * glm::vec4(corners[i], 1.f));
        }
 
        // And we form all edges of the frustum. We will clip these edges against
        // planes orthogonal to the cascade line at near and far values. In the
        // end, the clipped edges will span the convex hull of the clipped frustum.
        // We use the end-points of the clipped edges to form a bounding box.
        std::vector<glm::vec3> E;
        for (const auto & e : edgeIndicesData) {
          E.push_back(p[e[0]]);
          E.push_back(p[e[1]]);
        }
        // Assuming ligthView is just rotations (i.e., no need for inverse-transpose).
        clipLineSegments(E, lightView * glm::vec4(glm::vec3(cascadeLine), cascadeLine.w - n));
        clipLineSegments(E, -lightView * glm::vec4(glm::vec3(cascadeLine), cascadeLine.w - f));
        for (const auto & pp : E) {
          if (frustaPoints) {
            frustaPoints->points.push_back(pp);
          }
          min_lv = glm::min(min_lv, pp);
          max_lv = glm::max(max_lv, pp);
 
          min_cv = glm::min(min_cv, glm::vec3(toCull * glm::vec4(pp, 1)));
          max_cv = glm::max(max_cv, glm::vec3(toCull * glm::vec4(pp, 1)));
        }
      }
 
      if (frustaPoints) {
        frustaPoints->offsets.push_back(unsigned(frustaPoints->points.size()));
      }
    }
 
    // Quadratic viewport that exactly fits the frustum. This viewport will be
    // slightly expanded with a margin later.
    const float size = std::max((max_lv.x - min_lv.x),
                                (max_lv.y - min_lv.y));
    glm::vec2 center_lv = 0.5f * glm::vec2(min_lv + max_lv);
    const float zNear = -max_lv.z - std::max(0.1f, frustumSlack) * (max_lv.z - min_lv.z);
    const float zFar = -min_lv.z + frustumSlack * (max_lv.z - min_lv.z);
 
    // Check if viewport fits in the frustum used in the previous frame, and is
    // not way smaller. If it is an OK fit, we recylce the frustum to minimize
    // jittering of the shadows when the view changes slightly.
    bool needNewFrustum = frustumSlack == 0.f;
    const float factor = 0.5f * (1.f + frustumSlack);
    const float greaterThanValue = glm::max(0.f, 1.f - 2.f * frustumSlack);
    for (unsigned i = 0; i < 8u; i++) {
      glm::vec4 p = rawCascadeProjectionMatrix * glm::vec4(center_lv.x + 0.5 * (((i >> 0) & 1) ? -size : size),
                                                           center_lv.y + 0.5 * (((i >> 1) & 1) ? -size : size),
                                                           ((i >> 2) & 1) ? min_lv.z : max_lv.z,
                                                           1.f);
 
      bool xOk = ((-p.w <= p.x) && (p.x <= -greaterThanValue * p.w)) || ((greaterThanValue * p.w <= p.x) && (p.x <= p.w));
      bool yOk = ((-p.w <= p.y) && (p.y <= -greaterThanValue * p.w)) || ((greaterThanValue * p.y <= p.y) && (p.y <= p.w));
      bool zOk = ((-p.w <= p.z) && (p.z <= -0.5f * p.w)) || ((0.5f * p.z <= p.z) && (p.z <= p.w));
      needNewFrustum = needNewFrustum || !(xOk && yOk && zOk);
    }
 
    if (needNewFrustum) {
      // Last frame's frustum didn't match, so we create a new one.
 
      {
        // Adjust for origin offset.
        const float steppyness = 5.f;
        const float texelSize = std::exp2(std::ceil(log2(size / resolution) * steppyness) / steppyness);
        const glm::dvec3 origin = context->transformSystem->getOrigin();
        const glm::dvec3 offset = glm::dmat3(lightView) * origin;
        const double snappX = std::floor((center_lv.x + offset.x) / texelSize);
        const double snappY = std::floor((center_lv.y + offset.y) / texelSize);
        double snapX_ = std::fmod(snappX, 64.0);
        if (snapX_ < 0.0) snapX_ += 64;
        double snapY_ = std::fmod(snappY, 64.0);
        if (snapY_ < 0.0) snapY_ += 64;
 
        blueNoiseOffset = glm::uvec2(static_cast<uint32_t>(snapX_), static_cast<uint32_t>(snapY_));
        blueNoiseOffset = glm::uvec2(blueNoiseOffset.x, (64u - blueNoiseOffset.y) % 64u);
      }
 
      // Grow viewport slightly
      const glm::vec2 viewportMin = center_lv - glm::vec2(factor * size);
      const glm::vec2 viewportMax = center_lv + glm::vec2(factor * size);
      if (frustaPoints) {
        frustaPoints->viewportMin = viewportMin;
        frustaPoints->viewportMax = viewportMax;
      }
      rawCascadeProjectionMatrix = glm::ortho(viewportMin.x, viewportMax.x,
                                              viewportMin.y, viewportMax.y,
                                              zNear, zFar);
    }
    rawCascadeCullMatrix = glm::ortho(min_cv.x, max_cv.x,
                                      min_cv.y, max_cv.y,
                                      zNear, zFar) * toCull;
  }
 
  static void getCameras(Context* context, const CameraData* & refCamData, std::vector<CamState>& camStates, const LightComponent& light)
  {
    if (auto e = light.lodReference.lock(); e) {
      if (auto * c = e->getComponent<CameraComponent>(); c && ((c->lightingMask & light.lightingLayer) != LightingLayers::None)) {
        refCamData = &context->cameraSystem->getData(c);
      }
    }
    if (!refCamData) {
      refCamData = &context->cameraSystem->getMainCameraData();
    }
 
    for (auto & we : light.cameras) {
      if (auto e = we.lock(); e) {
        if (const auto * c = e->getComponent<CameraComponent>(); c && ((c->lightingMask & light.lightingLayer) != LightingLayers::None)) {
          camStates.emplace_back();
          camStates.back().cameraData = &context->cameraSystem->getData(c);
        }
      }
    }
    if (camStates.empty() && refCamData) {
      camStates.emplace_back();
      camStates.back().cameraData = refCamData;
    }
    for (auto & camState : camStates) {
      camState.rawInverseViewProjection = glm::inverse(camState.cameraData->rawViewProjection);
    }
  }
 
  static void calculateCascadeCount(LightData & lightData, float zNear, float zFar, float FOV)
  {
    if(!lightData.dynamicCascadeCount) return;
    float a = FOV*0.5f;
    float tana = tanf(a);
    float ns = tana*zNear;
    float fs = tana*zFar;
    float r = fs/ns-1.0f;
    lightData.numViewports = (uint16_t)ceil(r);
    lightData.numViewports = std::max(lightData.numViewports, (uint16_t)1);
    lightData.numViewports = std::min(lightData.numViewports, (uint16_t)lightData.maxViewports);
  }
 
  static void calculateSplits(Context* context, LightData & lightData, float zNear, float zFar)
  {
    const auto expFactor = context->variables->get("shadows.cascades.expFactor")->getFloat();
    const auto overlapFactor = 0.5f * context->variables->get("shadows.cascades.overlapFactor")->getFloat();
 
 
    const float cascadeWidth = 1.f / static_cast<float>(lightData.numViewports);
    if(lightData.numViewports == 1){
      lightData.nearDepths[0] = zNear;
      lightData.farDepths[0] = zFar;
    }
    else{
      for (int i = 0; i < lightData.numViewports; ++i) {
        const float iF = std::min(1.f, cascadeWidth * (static_cast<float>(i) + 1.f + overlapFactor));
        const float iN = std::max(0.f, cascadeWidth * (static_cast<float>(i) - overlapFactor));
 
        const float zExpNear = zNear * glm::pow(zFar / zNear, iN);
        const float zLinearNear = zNear + iN * (zFar - zNear);
        lightData.nearDepths[i] = glm::max(glm::lerp(zLinearNear, zExpNear, expFactor), zNear);
        assert(std::isfinite(lightData.nearDepths[i]));
 
        const float zExp = zNear * glm::pow(zFar / zNear, iF);
        const float zLinear = zNear + iF * (zFar - zNear);
 
        lightData.farDepths[i] = glm::lerp(zLinear, zExp, expFactor);
        assert(std::isfinite(lightData.farDepths[i]));
      }
    }
  }
 
  static float calculateSplits(Context * context, LightData & lightData, const glm::mat4& rotation, const CameraData* refCamData, const std::vector<CamState>& camStates, const float maxShadowDistance)
  {
    // Determine axis along which we will calculate cascades.
    const glm::mat4 & M = refCamData->inverseViewMatrix;
    const glm::vec3 o = glm::vec3(M * glm::vec4(0, 0, 0, 1));
    const glm::vec3 a = glm::normalize(glm::vec3(M * glm::vec4(0, 0, -1, 0)));
    const float d = -glm::dot(o, a);
    assert(std::isfinite(d));
    lightData.cascadeLine = glm::vec4(a, d);
 
    // Determine range along cascade axis
    auto zNear = refCamData->nearDistance;
    auto zFar = refCamData->farDistance;
    for (auto & camState : camStates) {
      for (auto c : corners) {
        auto q = camState.rawInverseViewProjection * glm::vec4(c, 1.f);
        if (std::numeric_limits<float>::epsilon() < q.w) {
          auto t = glm::dot(a, (1.f / q.w)*glm::vec3(q)) + d;
          assert(std::isfinite(t));
 
          zNear = glm::min(zNear, t);
          zFar = glm::max(zFar, t);
        }
      }
    }
 
    if(!lightData.tightShadowBounds){
      calculateCascadeCount(lightData, zNear, zFar, refCamData->fieldOfView);
      calculateSplits(context, lightData, refCamData->nearDistance, std::min(zFar, refCamData->nearDistance + maxShadowDistance));
      return std::max(zNear, refCamData->nearDistance - maxShadowDistance);
    }
    else{
      const Cogs::Geometry::BoundingBox bbox = context->bounds->getShadowBounds(context);
      const glm::vec3 bbox_corners[] = {
        glm::vec3(bbox.min.x, bbox.min.y, bbox.min.z),
        glm::vec3(bbox.max.x, bbox.min.y, bbox.min.z),
        glm::vec3(bbox.max.x, bbox.max.y, bbox.min.z),
        glm::vec3(bbox.min.x, bbox.max.y, bbox.min.z),
        glm::vec3(bbox.min.x, bbox.min.y, bbox.max.z),
        glm::vec3(bbox.max.x, bbox.min.y, bbox.max.z),
        glm::vec3(bbox.max.x, bbox.max.y, bbox.max.z),
        glm::vec3(bbox.min.x, bbox.max.y, bbox.max.z),
      };
      const glm::vec2 viewport_corners[] = { {-1, -1}, {1, -1}, {1, 1}, {-1, 1} };
 
      // zmin, zmax: bounding box z-extent (cascade line extent)
      float zmin = std::numeric_limits<float>::max();
      float zmax = 0.0f;
 
      //glm::vec3 lightDir = glm::vec3(lightData.lightDirection);
      glm::vec3 lightDir = glm::mat3(rotation) * glm::vec3(0, 0, -1);
 
      // Construct a shadow frustrum slice (A plane containing the light vector):
      glm::vec3 planeTangent = glm::cross(a, lightDir);
      glm::vec3 n = glm::normalize(glm::cross(lightDir, planeTangent)); // Plane Normal
 
      for (auto &camState : camStates) {
        const CameraData &cameraData = *camState.cameraData;
        const glm::vec3 ndcLightDir = euclidean(cameraData.rawProjectionMatrix*glm::vec4(glm::mat3(cameraData.viewMatrix)*lightDir, 1.0f));
        const float eps = 0.0001f;
        const bool along = ndcLightDir.z <= 0.0f;
 
        // Find z-range for bounding volume
        float azmin = std::numeric_limits<float>::max();
        float azmax = -std::numeric_limits<float>::max();
        for (const glm::vec3 &p0 : bbox_corners){
          float t = glm::dot(a, p0) + d;
          azmin = std::min(azmin, t);
          azmax = std::max(azmax, t);
        }
 
        // Check that shadows cannot travel infinitely far into the view frustrum.
        // Is camPos+lightDir inside the view frustrum? Then don't cull the with this camera.
        if(std::abs(ndcLightDir.x)-eps <= 1.0f && std::abs(ndcLightDir.y)-eps <= 1.0f){// && ndcLightDir.z <= 0.0f){
          zmin = zNear;
          zmax = zFar;
          if(along) zmin = std::max(zmin, azmin);
          else zmax = std::min(zmax, azmax);
          break;
        }
 
        // Generate a slice for all points on the bbox
        for (const glm::vec3 &p0 : bbox_corners){
          // Intersect with frustrum
          for (const glm::vec2 &corn : viewport_corners){
            // Frustrum corner line:
            glm::vec3 l0 = glm::vec3(cameraData.inverseViewMatrix * glm::vec4(0, 0, 0, 1));
            glm::vec3 l = glm::normalize(euclidean(camState.rawInverseViewProjection * glm::vec4(corn, 1.0f, 1.f))-l0);
            // Intersect plane with frustrum lines:
            float LdotN = glm::dot(l, n);
            float ld = glm::dot(p0-l0, n)/LdotN;
            glm::vec3 p = l0+ld*l;
            float t = glm::dot(a, p) + d;
 
            if(along) t = std::max(t, azmin);
            else t = std::min(t, azmax);
 
            t = std::max(0.0f, t);
            zmin = std::min(zmin, t);
            zmax = std::max(zmax, t);
          }
        }
      }
 
      zNear = glm::max(zNear, zmin);
      zFar = glm::min(zFar, zmax);
 
      zFar = glm::max(zNear, zFar);
 
      zNear = std::max(zNear, refCamData->nearDistance);
      zFar = std::min(zFar, refCamData->nearDistance + maxShadowDistance);
      calculateCascadeCount(lightData, zNear, zFar, refCamData->fieldOfView);
      calculateSplits(context, lightData, zNear, zFar);
      return zNear;
    }
  }
} // namespace ...
 
void Cogs::Core::LightSystem::initialize(Context* context)
{
  ComponentSystemWithDataPool::initialize(context);
  context->variables->set("shadows.cascades.expFactor", 0.9f);
  context->variables->set("shadows.cascades.overlapFactor", 0.2f);
  context->variables->set("renderer.maxShadowDistance", 30000.0f);
}
 
void Cogs::Core::LightSystem::update(Context * /*context*/)
{
}
 
void Cogs::Core::LightSystem::preRender(Context * context)
{
  const bool originOnTop = context->device->getCapabilities()->getDeviceCapabilities().OriginOnTop;
 
  if (!cascadeArray) {
    cascadeArray = context->textureManager->create();
    cascadeArray->setName("Light.ShadowCascades");
  }
 
  bool useTextureCubeArrays = context->device->getCapabilities()->getDeviceCapabilities().TextureCubeArrays;
  if(context->device->getType() == GraphicsDeviceType::WebGPU){
    useTextureCubeArrays = false; // TODO: Add support for texture cube arrays for WebGPU
  }
 
  if (!cubeArray) {
    cubeArray = context->textureManager->create();
    if(useTextureCubeArrays)
      cubeArray->setName("Light.ShadowCubeArray");
    else
      cubeArray->setName("Light.ShadowCube");
  }
 
  auto transformSystem = context->transformSystem;
  auto variables = context->variables.get();
 
  softShadows = parseEnum<SoftShadows>(variables->get("shadows.softShadows", "Default"));
  auto shadowUpdate = parseEnum<ShadowUpdate>(variables->get("shadows.update", "Default"));
  const auto pointShadowResolution = static_cast<unsigned>(std::max(1, variables->get("shadows.pointShadowResolution", 256)));
 
  unsigned cascadeShadowResolution = (unsigned)std::max(0, variables->get("shadows.cascadeShadowResolution", 1024));
 
  // How much larger the light frustum will be to avoid jittery shadows when camera moves
  const float frustumSlack = glm::clamp(variables->get("shadows.frustumSlack", 0.1f), 0.f, 1.f);
 
  const auto pointShadowFormat = parseTextureFormat(variables->get("shadows.pointShadowFormat", "R32_TYPELESS"));
  const auto cascadeShadowFormat = parseTextureFormat(variables->get("shadows.cascadeShadowFormat", "R32_TYPELESS"));
  const bool shadowsEnabled = variables->get("renderer.shadowsEnabled", false);
 
  const bool lightSystemRun = variables->getOrAdd("lightSystem.run", true);
  if (!lightSystemRun) {
    return;
  }
 
  bool anyChanged = false;
  for (const auto & light : pool) {
    anyChanged |= light.hasChanged();
  }
 
  lightsChanged |= anyChanged;
 
  uint32_t cascadeInstances = 0;
  uint32_t layerCount = 0;
 
  uint32_t cubeInstances = 0;
  for (const auto & light : pool) {
    const auto transformComponent = light.getComponent<TransformComponent>();
 
    auto & lightData = getData(&light);
    lightData.enabled = light.enabled;
    lightData.castShadows = light.enabled && light.castShadows && shadowsEnabled;
    lightData.tightShadowBounds = light.tightShadowBounds;
    lightData.dynamicCascadeCount = light.dynamicCascadeCount;
    lightData.lightColor = glm::vec4(glm::convertSRGBToLinear(glm::vec3(light.lightColor)),
                                     light.lightColor.a);
 
    if (!light.enabled) continue;
 
    lightData.shadowIntensityOffset = light.shadowIntensityOffset;
 
    if (light.lightType == LightType::Directional) {
 
      lightData.lightDirection = transformSystem->getLocalToWorld(transformComponent) * glm::vec4(0, 0, -1, 0);
      lightData.lightDirection = glm::normalize(lightData.lightDirection);
 
      lightData.lightPosition = glm::vec4(0, 0, 0, 0);
 
      if (lightData.castShadows) {
 
        uint32_t framesSinceDirty = context->time->getFrame() - context->engine->getLastDirtyFrame();
        if (framesSinceDirty <= lightData.maxViewports) {
          context->engine->triggerUpdate();
        }
 
        auto passOptions = &lightData.passOptions;
        passOptions->setFlag(RenderPassOptions::Flags::NoDepthClip);
        passOptions->depthBias = light.shadowBias;
        passOptions->depthSlopedBias = light.shadowSlopedBias;
        passOptions->depthBiasClamp = light.shadowBiasClamp;
 
        lightData.textureSize = cascadeShadowResolution;
        lightData.shadowUpdate = shadowUpdate;
 
        lightData.maxViewports = 4;
        lightData.numViewports = lightData.maxViewports;
        lightData.shadowTexture = cascadeArray;
        lightData.arrayOffset = layerCount;
 
        layerCount += lightData.maxViewports;
        ++cascadeInstances;
 
        const CameraData * refCamData = nullptr;
        std::vector<CamState> cameras;
        getCameras(context, refCamData, cameras, light);
        auto nearest = calculateSplits(context, lightData, transformSystem->getLocalToWorld(transformComponent), refCamData, cameras, context->variables->get("renderer.maxShadowDistance", 30000.0f));
 
        for (size_t i = 0; i < lightData.numViewports; ++i) {
          auto frame = context->time->getFrame();
          if (lightData.shadowUpdate == ShadowUpdate::Partial) {
            lightData.frameMod[i] = (uint16_t)lightData.numViewports;
            lightData.frameOffset[i] = (uint16_t)i;
          }
          else if (lightData.shadowUpdate == ShadowUpdate::Static) {
            lightData.frameMod[i] = 0;
            lightData.frameOffset[i] = 0;
          }
          else if (lightData.shadowUpdate == ShadowUpdate::StaticPartial) {
            lightData.frameMod[i] = (uint16_t)lightData.numViewports;
            lightData.frameOffset[i] = (uint16_t)i;
          }
          else if (lightData.shadowUpdate == ShadowUpdate::None) {
            lightData.frameMod[i] = 1;
            lightData.frameOffset[i] = static_cast<uint16_t>(-1);
          }
          else {
            lightData.frameMod[i] = 0;
            lightData.frameOffset[i] = 0;
          }
          if (lightData.frameMod[i] != 0) {
            if ((frame % lightData.frameMod[i]) != lightData.frameOffset[i]) {
              continue;
            }
          }
 
          // Note nearDepth[i] is for cascade i-1, while farDepth[i] is for cascade i.
          auto n = 0 < i ? lightData.nearDepths[i - 1] : nearest;
          auto f = lightData.farDepths[i];
 
          auto frustaPoints = lightData.frustaPointsCapture ? &lightData.frustaPoints[i] : nullptr;
          if (frustaPoints) {
            frustaPoints->points.clear();
            frustaPoints->offsets.clear();
          }
 
          glm::mat4 lightView = createLightViewMatrix(lightData.cascadeLine, transformComponent->rotation);
          glm::uvec2 blueNoiseOffset;
          glm::mat4 rawCascadeCullMatrix;
          createFrustumFitMatrix(context, lightData.lightRawProjection[i], rawCascadeCullMatrix, frustaPoints, refCamData, cameras,
                                 lightView, lightData.cascadeLine, n, f, frustumSlack, lightData.textureSize, blueNoiseOffset);
 
          auto cascadeProjectionMatrix = context->renderer->getProjectionMatrix(lightData.lightRawProjection[i]);
 
          // Set of cascade render view
          // --------------------------
          //
          // Handling of y-flip for GL backends is done when updating engine buffers
          //
          CameraData& lightCameraData = lightData.lightCameraData[i];
 
          lightCameraData.layerMask = RenderLayers::Default;
 
          lightCameraData.viewMatrix = lightView;
          lightCameraData.projectionMatrix = cascadeProjectionMatrix;
 
          lightCameraData.viewProjection = cascadeProjectionMatrix * lightView;
          lightCameraData.inverseViewMatrix = glm::inverse(lightView);
          lightCameraData.inverseViewProjectionMatrix = glm::inverse(lightCameraData.viewProjection);
          lightCameraData.inverseProjectionMatrix = glm::inverse(cascadeProjectionMatrix);
 
          lightCameraData.rawProjectionMatrix = lightData.lightRawProjection[i];
          lightCameraData.rawViewProjection = lightData.lightRawProjection[i] * lightView;
          lightCameraData.rawViewCullMatrix = rawCascadeCullMatrix * lightView;
 
          lightCameraData.passOptions = passOptions;
 
          lightCameraData.viewportOrigin = { 0, 0 };
 
          lightCameraData.viewportSize = { lightData.textureSize , lightData.textureSize };
          lightCameraData.blueNoiseOffset = blueNoiseOffset;
 
          // Enable shadow pancaking for cascades.
          lightCameraData.depthClamp = 0;
 
          lightCameraData.frustum = Geometry::calculateFrustum<Geometry::Frustum, glm::mat4>(lightCameraData.viewProjection);
        }
      }
    }
    else if (light.lightType == LightType::Point) {
 
      if (!useTextureCubeArrays && lightData.castShadows) {
 
        if (cubeInstances) { // we only support one cube
          lightData.castShadows = false;
        }
      }
 
      glm::vec3 lightPosition = transformSystem->getLocalToWorld(transformComponent) * glm::vec4(0, 0, 0, 1);
      lightData.lightDirection = glm::vec4(0, 0, -1, 1);
      lightData.lightPosition = glm::vec4(lightPosition, 1);
 
      if (lightData.castShadows) {
 
        auto passOptions = &lightData.passOptions;
        passOptions->unsetFlag(RenderPassOptions::Flags::NoDepthClip);
        passOptions->depthBias = light.shadowBias;
        passOptions->depthSlopedBias = light.shadowSlopedBias;
        passOptions->depthBiasClamp = light.shadowBiasClamp;
 
        lightData.shadowUpdate = shadowUpdate;
        lightData.shadowTexture = cubeArray;
        lightData.maxViewports = 6;
        lightData.numViewports = lightData.maxViewports;
        lightData.arrayOffset = cubeInstances * lightData.numViewports;
        ++cubeInstances;
 
        if (light.shadowNearPlane != 0) {
          lightData.nearDepths[0] = light.shadowNearPlane;
        } else {
          lightData.nearDepths[0] = glm::max(0.1f, light.range / 1000.0f);
        }
 
        lightData.farDepths[0] = light.range;
 
        for (size_t i = 0; i < lightData.numViewports; ++i) {
          auto frame = context->time->getFrame();
          if (lightData.shadowUpdate == ShadowUpdate::Partial) {
            lightData.frameMod[i] = (uint16_t)lightData.numViewports;
            lightData.frameOffset[i] = (uint16_t)i;
          }
          else if (lightData.shadowUpdate == ShadowUpdate::Static) {
            lightData.frameMod[i] = 0;
            lightData.frameOffset[i] = 0;
          }
          else if (lightData.shadowUpdate == ShadowUpdate::StaticPartial) {
            lightData.frameMod[i] = (uint16_t)lightData.numViewports;
            lightData.frameOffset[i] = (uint16_t)i;
          }
          else if (lightData.shadowUpdate == ShadowUpdate::None) {
            lightData.frameMod[i] = 1;
            lightData.frameOffset[i] = static_cast<uint16_t>(-1);
          }
          else {
            lightData.frameMod[i] = 0;
            lightData.frameOffset[i] = 0;
          }
          if (lightData.frameMod[i] != 0) {
            if ((frame % lightData.frameMod[i]) != lightData.frameOffset[i]) {
              continue;
            }
          }
          CameraData& lightCameraData = lightData.lightCameraData[i];
 
 
          // Calculate point light projection
          // --------------------------------
          //
          // If origin is on botton (GL backends), we flip the Y axis out of the
          // projection so that we match engine conventions. Note that this flips
          // orientation so we must flip the winding order used for culling.
          //
          glm::mat4 lightProjection = glm::perspective(glm::pi<float>() / 2.0f,
                                                       1.0f,
                                                       lightData.nearDepths[0],
                                                       lightData.farDepths[0]);
          if (!originOnTop) {
            lightProjection = glm::mat4(1.f,  0.f, 0.f, 0.f,
                                        0.f, -1.f, 0.f, 0.f,
                                        0.f,  0.f, 1.f, 0.f,
                                        0.f,  0.f, 0.f, 1.f) * lightProjection;
            lightCameraData.flipWindingOrder = true;
          }
          lightProjection = context->renderer->getProjectionMatrix(lightProjection);
 
          glm::vec3 directions[6] = {
            glm::vec3(1, 0, 0),
            glm::vec3(-1, 0, 0),
            glm::vec3(0, 0, 1),
            glm::vec3(0, 0, -1),
            glm::vec3(0, 1, 0),
            glm::vec3(0, -1, 0),
          };
 
          glm::vec3 ups[6] = {
            glm::vec3(0, 0, 1),
            glm::vec3(0, 0, 1),
            glm::vec3(0, -1, 0),
            glm::vec3(0, 1, 0),
            glm::vec3(0, 0, 1),
            glm::vec3(0, 0, 1),
          };
 
          const glm::mat4 lightView = glm::lookAt(lightPosition, lightPosition + directions[i], ups[i]);
 
          lightCameraData.layerMask = RenderLayers::Default;
          lightCameraData.viewMatrix = lightView;
          lightCameraData.projectionMatrix = lightProjection;
          lightCameraData.inverseViewMatrix = glm::inverse(lightView);
          lightCameraData.viewProjection = lightProjection * lightView;
          lightCameraData.inverseViewProjectionMatrix = glm::inverse(lightCameraData.viewProjection);
          lightCameraData.inverseProjectionMatrix = glm::inverse(lightProjection);
          lightCameraData.rawProjectionMatrix = lightProjection;
          lightCameraData.rawViewProjection = lightProjection * lightCameraData.viewMatrix;
          lightCameraData.rawViewCullMatrix = lightCameraData.rawViewProjection;
          lightCameraData.passOptions = passOptions;
          lightCameraData.viewportOrigin = { 0, 0 };
          lightCameraData.viewportSize = { pointShadowResolution, pointShadowResolution };
          lightCameraData.depthClamp = -std::numeric_limits<float>::max();
 
          lightCameraData.frustum = Geometry::calculateFrustum<Geometry::Frustum, glm::mat4>(lightCameraData.viewProjection);
        }
      }
    }
  }
 
  if (!cascadeInstances) cascadeInstances = 1;
 
  if (cascadeInstances && (layerCount != currentLayerCount ||
                           cascadeShadowResolution != currentTextureSize ||
                           cascadeShadowFormat != currentShadowFormat))
  {
    assert(cascadeArray);
 
    cascadeArray->description.target = ResourceDimensions::Texture2DArray;
    cascadeArray->description.layers = layerCount;
    cascadeArray->description.width = cascadeShadowResolution;
    cascadeArray->description.height = cascadeShadowResolution;
    cascadeArray->description.format = cascadeShadowFormat;
    cascadeArray->description.flags = TextureFlags::DepthBuffer | TextureFlags::Texture;
    if (layerCount) {
      cascadeArray->setChanged();
    }
    currentLayerCount = layerCount;
    currentTextureSize = cascadeShadowResolution;
    currentShadowFormat = cascadeShadowFormat;
  }
 
  if (cubeInstances && (cubeInstances != currentCubeCount ||
                        pointShadowResolution != currentPointShadowResolution ||
                        pointShadowFormat != currentPointShadowFormat))
  {
    assert(cubeArray);
    cubeArray->description.target = useTextureCubeArrays ? ResourceDimensions::TextureCubeArray : ResourceDimensions::TextureCube;
    cubeArray->description.layers = useTextureCubeArrays ? cubeInstances : 1;
    cubeArray->description.faces = 6;
    cubeArray->description.width = pointShadowResolution;
    cubeArray->description.height = pointShadowResolution;
    cubeArray->description.format = pointShadowFormat;
    cubeArray->description.flags = TextureFlags::DepthBuffer | TextureFlags::Texture | TextureFlags::CubeMap;
    if (cubeInstances) {
      cubeArray->setChanged();
    }
    currentCubeCount = cubeInstances;
    currentPointShadowResolution = pointShadowResolution;
    currentPointShadowFormat = pointShadowFormat;
  }
 
  for (const auto & light : pool) {
    auto & lightData = getData(&light);
    if (!light.enabled) continue;
    if (!lightData.castShadows) continue;
 
    if (light.lightType == LightType::Directional) {
      for (size_t i = 0; i < lightData.numViewports; ++i) {
        auto & lightCameraData = lightData.lightCameraData[i];
        context->cullingManager->dispatchCulling(&lightCameraData);
      }
    }
    else if (light.lightType == LightType::Point) {
      for (size_t i = 0; i < 6; ++i) {
        auto & lightCameraData = lightData.lightCameraData[i];
        context->cullingManager->dispatchCulling(&lightCameraData);
      }
    }
  }
 
}