ZBinning.hpp

Go to the documentation of this file.

#pragma once
 
#include "Light.hpp"
#include "Isocahedron.hpp"
 
#include <vector>
#include <glm/glm.hpp>
 
namespace Video {
 
class LowLevelRenderer;
class Buffer;
class CommandBuffer;
class ComputePipeline;
class GraphicsPipeline;
class Shader;
class ShaderProgram;
 
class ZBinning {
  public:
    struct LightInfo {
        uint32_t directionalLightCount;
 
        Buffer* directionalLightBuffer;
 
        uint32_t lightCount;
 
        Buffer* lightBuffer;
 
        uint32_t maskCount;
 
        uint32_t tileSize;
 
        glm::uvec2 tiles;
 
        Buffer* tileMaskBuffer;
 
        uint32_t zBins;
 
        Buffer* zMaskBuffer;
 
        float zNear;
 
        float zFar;
    };
 
 
    ZBinning(LowLevelRenderer* lowLevelRenderer, const glm::uvec2& screenSize);
 
    ~ZBinning();
 
 
    void SetRenderSurfaceSize(const glm::uvec2& size);
 
 
    void BinLights(CommandBuffer& commandBuffer, const std::vector<DirectionalLight>& directionalLights, const std::vector<Light>& lights, const glm::mat4& projectionMatrix, float zNear, float zFar);
 
 
    const LightInfo& GetLightInfo();
 
  private:
    void ClearBuffers(CommandBuffer& commandBuffer);
    void Binning(CommandBuffer& commandBuffer);
    void Tiling(CommandBuffer& commandBuffer, const glm::mat4& projectionMatrix);
 
    LowLevelRenderer* lowLevelRenderer;
 
    LightInfo lightInfo;
    bool conservativeRasterization;
 
    static const uint32_t MAX_DIRECTIONAL_LIGHTS = 128;
    DirectionalLight directionalLightData[MAX_DIRECTIONAL_LIGHTS];
 
    static const uint32_t MAX_LIGHTS = 2048;
    Light lightData[MAX_LIGHTS];
 
    static const uint32_t TILE_MASK_BUFFER_SIZE = 8 * 1024 * 1024;
 
    Shader* binningShader;
    ShaderProgram* binningShaderProgram;
    ComputePipeline* binningPipeline[2];
    uint32_t pipelineCount = 0u;
 
    Shader* tilingVertexShader;
    Shader* tilingFragmentShader;
    ShaderProgram* tilingShaderProgram;
    GraphicsPipeline* tilingPipeline;
    Isocahedron isocahedron;
 
    struct TilingMatricesData {
        glm::mat4 projectionMatrix;
        glm::vec2 scale;
        float invIsocahedronError;
    };
 
    struct TilingUniformData {
        uint32_t tileSize;
        uint32_t maskCount;
        uint32_t tilesX;
    };
 
    glm::uvec2 screenSize;
    glm::uvec2 tilingSize;
 
    uint32_t msaa = 1u;
    uint32_t msaaScale = 1u;
};
 
} // namespace Video