ParameterBuffers.h

#pragma once
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
 
#include "Constants.h"
 
#define COGS_SCENEFLAGS_NONE                  (   0)
#define COGS_SCENEFLAGS_OUTPUT_SRGB           (1<<0)
#define COGS_SCENEFLAGS_SUBMERGED             (1<<1)
 
namespace Cogs
{
  namespace Core
  {
    struct SceneParameters
    {
      glm::mat4 projectionMatrix;
      glm::mat4 viewMatrix;
      glm::mat4 inverseViewMatrix;
      glm::mat4 inverseProjectionMatrix;
      glm::mat4 worldToClipMatrix;
      glm::mat4 viewFromViewportMatrix;
      glm::mat4 viewportFromViewMatrix;
      glm::vec4 projectionParameters;
      glm::vec4 clippingPlanes[6];
      glm::vec4 originHigh;
      glm::vec4 originLow;
      glm::uvec4 blueNoiseOffset;
      glm::vec2 viewportOrigin;
      glm::vec2 viewportSize;
      glm::vec2 viewportSizeRcp;
      float shadowDepthClamp;
      float animationTime;
      float exposure;
      unsigned sceneFlags;
      unsigned clientFlags;                 
      float numEnvironmentRadianceMips;
      float numEnvironmentIrradianceMips;
 
      float pack0;
      float pack1;
      float pack2;
    };
 
    struct ViewBufferEntry {
      glm::mat4 clipFromView;
      glm::mat4 clipFromWorld;
      glm::mat4 viewFromWorld;
      glm::mat4 viewFromClip;
      glm::mat4 worldFromView;
      glm::mat4 viewFromViewport;
    };
 
    struct ObjectBuffer
    {
      glm::vec4 _worldMatrix_row0;
      glm::vec4 _worldMatrix_row1;
      glm::vec4 _worldMatrix_row2;
      uint32_t _objectId;
      uint32_t _padding1;
      uint32_t _padding2;
      uint32_t _padding3;
 
      void encodeWorldMatrix(const glm::mat4& worldMatrix)
      {
        _worldMatrix_row0 = glm::vec4(worldMatrix[0][0], worldMatrix[1][0], worldMatrix[2][0], worldMatrix[3][0]);
        _worldMatrix_row1 = glm::vec4(worldMatrix[0][1], worldMatrix[1][1], worldMatrix[2][1], worldMatrix[3][1]);
        _worldMatrix_row2 = glm::vec4(worldMatrix[0][2], worldMatrix[1][2], worldMatrix[2][2], worldMatrix[3][2]);
      }
 
      void encodeObjectId(uint32_t objectId)
      {
        _objectId = objectId;
      }
    };
    static_assert(sizeof(ObjectBuffer) == 64);
 
    struct AnimationBuffer
    {
      glm::mat4 boneTransforms[256];
    };
 
    struct LightBuffer
    {
      glm::vec4 lightPositions[kMaxLights];
      glm::vec4 lightDirections[kMaxLights];
      glm::vec4 lightColorIntensity[kMaxLights];
      glm::vec4 lightParameters[kMaxLights];
      uint32_t numLights[4];
      glm::vec4 eyePosition;
      glm::vec4 fogColor;
      float fogDistance;
      float fogAmount;
      int fogEnabled;
      float ambientIntensity;
      glm::vec3 ambientColor;
      float environmentBrightness;
      float skyMultiplier;
      int seaFlags;
      int flags;
 
      int pack3;
    };
 
    struct ShadowData
    {
      glm::vec4 cascadeLine;
      glm::vec4 nearSplits;
      glm::vec4 farSplits;
      glm::mat4 lightMatrix[Cogs::Core::kMaxCascades];
      float shadowSampleBias;
      uint32_t numCascades;
      int shadowsEnabled;
      float texelSize;
    };
 
    struct ShadowBuffer
    {
      glm::vec4 softShadowJitter[36];  // 36-tap samples in xy, 9-tap samples in zw.
      ShadowData shadowData[kMaxLights];
      glm::uvec4 cascadeOffsets[kMaxLights];  // hlsl array elements starts on 4*32-bit offsets.
    };
 
    struct SceneBuffer
    {
      SceneParameters scene;
      LightBuffer light;
      ShadowBuffer shadow;
    };
  }
}