passes.h

Go to the documentation of this file.

#pragma once
 
#include "components/rendering/rendering.h"
#include "components/rendering/bgfx/types.h"
#include "api/v1/types/tags/classes/light.h"
 
/*
@todo REFACTOR/REORGANIZE ALL THIS SHIT
*/
 
// Number of additional view IDs the shadow pass needs to reserve beyond the
// one it gets by default. Worst case is hitting every per-type cap in the
// same frame:
//   directional casters * cascades + spot casters * 1 + point casters * 6
// With the default macros: 1*4 + 2*1 + 2*6 = 18 view IDs total, so we need
// to reserve 17 additional ones beyond the default.
//
// If shadow caster caps are increased, this constant updates automatically.
#define BLAM_SHADOW_VIEW_IDS_TOTAL ( \
    BLAM_SHADOW_MAX_DIRECTIONAL_CASTERS * BLAM_SHADOW_CASCADE_COUNT + \
    BLAM_SHADOW_MAX_SPOT_CASTERS + \
    BLAM_SHADOW_MAX_POINT_CASTERS * 6)
 
#define BLAM_SHADOW_VIEW_IDS_TO_RESERVE (BLAM_SHADOW_VIEW_IDS_TOTAL - 1)
 
#define MAX_LIGHTS 64
 
class BlamGBufferPass : public BlamRenderPass
{
private:
    // Group key for bucketing submeshes by (submesh, material). Two draws can
    // be merged into one instanced draw if they share both. Material here is
    // represented by the baked state pointer rather than the tag-path string,
    // because the bake pointer is already resolved/cached on the submesh.
    //
    // Note: this means a submesh that hasn't been drawn yet (baked_state still
    // nullptr) gets grouped separately from itself in subsequent frames after
    // it's resolved. That's fine - the grouping works correctly either way,
    // just at varying granularity in transition frames.
    struct group_key
    {
        mesh::submesh* submesh;
        BlamMaterialBakedState* baked_state;
 
        bool operator==(const group_key& other) const
        {
            return submesh == other.submesh && baked_state == other.baked_state;
        }
    };
 
    struct group_key_hash
    {
        size_t operator()(const group_key& k) const
        {
            // Mix submesh and baked_state pointers. Standard pointer-pair hash.
            size_t h1 = std::hash<void*>()((void*)k.submesh);
            size_t h2 = std::hash<void*>()((void*)k.baked_state);
            return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
        }
    };
 
    // Per-group accumulated state. Holds the row-major model matrices ready to
    // memcpy into a bgfx instance data buffer.
    //
    // We pack 16 floats per instance representing the 4x4 model matrix in row-
    // major order (4 vec4 rows). bx::mtxSRT produces column-major; we transpose
    // at insertion time so the buffer is already row-major when we hand it to
    // bgfx. The instanced vertex shader uses mtxFromRows to reconstruct the
    // matrix from the four row vec4s.
    struct group_data
    {
        mesh::submesh* submesh;
        std::string             material_tag_path;
        std::vector<float>      packed_transforms; // 16 floats per instance
    };
 
    // Helper: append a row-major model matrix into a group's packed_transforms.
    // `srt_matrix` is the column-major output from bx::mtxSRT (or any other
    // bx::mtx* function).
    void AppendTransformRowMajor(std::vector<float>& packed, const float* srt_matrix);
 
    // Submit a single submesh as a non-instanced draw. Used for groups of size 1
    // (the fallback path) and as the path when instancing is globally disabled.
    void SubmitNonInstanced(mesh::submesh* submesh, const std::string& material_tag_path, const float* srt_matrix, 
        bgfx::ProgramHandle program, bgfx::ViewId view_id, uint64_t state_flags, BlamVector4 render_params);
 
    // Submit a group as one or more instanced draws. Splits into multiple draws
    // if the group exceeds the available transient instance buffer capacity.
    void SubmitInstancedGroup(group_data& group, bgfx::ProgramHandle program, 
        bgfx::ViewId view_id, uint64_t state_flags, BlamVector4 render_params);
 
    // Reusable per-frame storage. Cleared each frame, but vector capacity is
    // retained so we don't re-allocate every frame in steady state.
    std::unordered_map<group_key, group_data, group_key_hash> g_groups;
    bgfx::UniformHandle u_renderParams = BGFX_INVALID_HANDLE;
 
protected:
    void _Execute(float delta) override;
 
public:
    bgfx::TextureHandle albedo = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle normal = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle pbr = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle emissive = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle depth = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle worldpos = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle coverage = BGFX_INVALID_HANDLE;
    bgfx::FrameBufferHandle gbuffer = BGFX_INVALID_HANDLE;
 
    uint16_t render_clear_flags = BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH;
 
    BlamGBufferPass();
    ~BlamGBufferPass();
 
    void RecreateBuffers(BlamVector2 size) override;
};
 
class BlamForwardPass : public BlamRenderPass
{
protected:
    void _Execute(float delta) override;
 
public:
    BlamForwardPass();
};
 
class BlamLightingPass : public BlamRenderPass
{
protected:
    void _Execute(float delta) override;
 
public:
    BlamLightingPass();
};
 
class BlamUIPass : public BlamRenderPass
{
protected:
    void _Execute(float delta) override;
 
public:
    BlamUIPass();
};
 
class BlamPostprocessPass : public BlamRenderPass
{
protected:
    void _Execute(float delta) override;
 
public:
    // HDR lighting result
    bgfx::TextureHandle hdr_color = BGFX_INVALID_HANDLE;
    bgfx::FrameBufferHandle hdr_buffer = BGFX_INVALID_HANDLE;
 
    BlamPostprocessPass();
 
    void RecreateBuffers(BlamVector2 size) override;
};
 
class BlamSSAOPass : public BlamRenderPass
{
private:
    bgfx::ViewId blur_view_id = 0;
 
protected:
    void _Execute(float delta) override;
 
public:
    bgfx::TextureHandle ssao_result = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle ssao_blurred = BGFX_INVALID_HANDLE;
    bgfx::TextureHandle noise_texture = BGFX_INVALID_HANDLE;
 
    bgfx::FrameBufferHandle ssao_buffer = BGFX_INVALID_HANDLE;
    bgfx::FrameBufferHandle ssao_blur_buffer = BGFX_INVALID_HANDLE;
 
    BlamSSAOPass();
 
    void RecreateBuffers(BlamVector2 size) override;
    void GenerateKernel();
    void GenerateNoiseTexture();
};
 
// Cascaded shadow map system for the directional light.
//
// Builds on the working minimal version: same R32F color attachment per
// cascade, same depth renderbuffer for z-test, same SubmitShadowGeometry
// path. The only new pieces are: 4 array layers instead of 1 plain texture,
// 4 framebuffers (one per layer), 4 view IDs (one per cascade), 4 light
// matrices fit to camera frustum slices, and cascade selection in shader.
 
#define BLAM_SHADOW_CASCADE_COUNT      8
 
// Maximum number of concurrent shadow-casting spot lights. More spots in the
// scene are allowed but only the closest BLAM_SHADOW_SPOT_COUNT to the camera
// will cast shadows. Must match the SHADOW_SPOT_COUNT define in
// fs_deferred_light_pass.sc.
#define BLAM_SHADOW_SPOT_COUNT         4
 
#define BLAM_SHADOW_POINT_COUNT        4
#define BLAM_SHADOW_CUBE_FACE_COUNT    6
 
// Number of view IDs the shadow pass needs to reserve beyond its default one.
// We need one view per shadow map target: N cascades + M spot slots - 1
// (the -1 is because GetViewID() provides one by default).
#define BLAM_SHADOW_VIEW_IDS_TO_RESERVE \
    ((BLAM_SHADOW_CASCADE_COUNT + BLAM_SHADOW_SPOT_COUNT + \
      (BLAM_SHADOW_POINT_COUNT * BLAM_SHADOW_CUBE_FACE_COUNT)) - 1)
 
// Practical split scheme blend factor between log and uniform partitioning.
// Higher values bias toward log (better near-camera detail), lower values
// bias toward uniform (more even far-camera coverage). 0.75 is a good default.
#define BLAM_SHADOW_CASCADE_LAMBDA      0.75f
 
class BlamShadowPass : public BlamRenderPass
{
private:
    struct shadow_instance
    {
        float transform[16];          // row-major model matrix (as before)
        BlamVector3 world_aabb_min;
        BlamVector3 world_aabb_max;
        BlamVector3 world_sphere_center;
        float       world_sphere_radius;
        bool        infinite_bounds;  // skip culling for this instance
        bool        use_sphere;       // sphere test rather than AABB test
        bool        bounds_valid;     // if false, treat as always-visible
    };
 
    struct shadow_group_data
    {
        mesh::submesh* submesh;
        std::vector<shadow_instance> instances;
    };
 
 
    // ----- Directional -----
    bgfx::FrameBufferHandle shadow_framebuffers[BLAM_SHADOW_CASCADE_COUNT];
    bgfx::TextureHandle     shadow_texture_array;
    bgfx::TextureHandle     shadow_depth_renderbuffer;
 
    float cascade_matrices[BLAM_SHADOW_CASCADE_COUNT * 16];
    float cascade_splits[BLAM_SHADOW_CASCADE_COUNT];
    float cascade_splits_packed[((BLAM_SHADOW_CASCADE_COUNT + 3) / 4) * 4];
    int   cascade_resolution;
 
    // ----- Spot -----
    bgfx::FrameBufferHandle spot_framebuffers[BLAM_SHADOW_SPOT_COUNT];
    bgfx::TextureHandle     spot_texture_array;
    bgfx::TextureHandle     spot_depth_renderbuffer;
 
    float spot_matrices[BLAM_SHADOW_SPOT_COUNT * 16];
    int   spot_resolution;
    int   active_spot_count;
 
    // Mapping from spot tag object pointer to assigned shadow layer this
    // frame. A raw array is fine since SPOT_COUNT is small.
    class BlamWorldObject_Tag* spot_layer_to_object[BLAM_SHADOW_SPOT_COUNT];
 
    // ----- Point -----
    // 6 framebuffers per point light (one per cube face). Flat index =
    // light_index * 6 + face_index.
    bgfx::FrameBufferHandle point_framebuffers[BLAM_SHADOW_POINT_COUNT * BLAM_SHADOW_CUBE_FACE_COUNT];
 
    // One cubemap per point light slot. bgfx's cross-platform shader
    // abstraction doesn't support cubemap arrays on HLSL, so each
    // shadow-casting point gets its own SAMPLERCUBE binding in the
    // lighting shader.
    bgfx::TextureHandle point_cubes[BLAM_SHADOW_POINT_COUNT];
    bgfx::TextureHandle point_depth_renderbuffer;
 
    // Per-point: light world position in xyz, far plane in w. The shader
    // uses light_pos to compute direction from light to fragment, and
    // far_plane to normalize stored/compared distances.
    float point_data[BLAM_SHADOW_POINT_COUNT * 4];
 
    int   point_resolution;
    int   active_point_count;
 
    class BlamWorldObject_Tag* point_layer_to_object[BLAM_SHADOW_POINT_COUNT];
 
    std::unordered_map<mesh::submesh*, shadow_group_data> g_shadow_groups;
 
    // ----- Infrastructure -----
    bgfx::ViewId base_view_id;
    bool         resources_initialized;
 
    void InitializeResources();
    void DestroyResources();
    void SubmitShadowGeometry(bgfx::ViewId view_id, bgfx::ProgramHandle program, bool flip_cull, const BlamFrustum* frustum);
 
    // Subsystem entry points - called from _Execute
    void RenderDirectionalCascades(bgfx::ProgramHandle shadow_program);
    void RenderSpotShadows(bgfx::ProgramHandle shadow_program);
    void RenderPointShadows(bgfx::ProgramHandle point_shadow_program);
 
    void CollectShadowGeometry();
    int ResolveLightPriority(BlamWorldObject_Tag* obj);
    void ComputePointFaceMatrix(BlamVector3 light_pos, int face, float near_plane, float far_plane, float* out_matrix);
    void ComputeSpotMatrix(BlamWorldObject_Tag* spot, float* out_matrix);
    void ComputeCascadeMatrix(BlamVector3 light_dir, float split_near, float split_far, int cascade_resolution, float* out_matrix);
    void ComputeCascadeSplits(float near_plane, float far_plane, float* out_splits);
    int GatherShadowCasters(BlamWorldObject_Tag** out_points, int max_count, light::shape_enum shape);
 
public:
    BlamShadowPass();
 
    void _Execute(float delta) override;
 
    // Directional
    bgfx::TextureHandle GetShadowTextureArray();
    float* GetCascadeMatrices();       // mat4[CASCADE_COUNT]
    float* GetCascadeSplits();         // float[CASCADE_COUNT]
    float* GetCascadeSplitsPacked();   // vec4[ceil(N/4)]
    int GetCascadeResolution();
 
    // Spot
    bgfx::TextureHandle GetSpotShadowTextureArray();
    float* GetSpotShadowMatrices();    // mat4[SPOT_COUNT]
    int GetSpotResolution();
    int GetSpotShadowCount();       // active this frame, 0..SPOT_COUNT
 
    // Returns the shadow layer assigned to the given spot light object, or
    // -1 if the object isn't being shadow-rendered this frame. Used by the
    // lighting pass to correlate lights to shadow maps.
    int GetSpotShadowLayerFor(class BlamWorldObject_Tag* spot_object);
 
    // Point
    // Returns one of the N individual cubemaps by index. Returns invalid
    // handle if index is out of range.
    bgfx::TextureHandle GetPointShadowCube(int index);
    float* GetPointShadowData();       // vec4[POINT_COUNT], .xyz=light_pos, .w=far_plane
    int GetPointResolution();
    int GetPointShadowCount();      // active this frame, 0..POINT_COUNT
    int GetPointShadowLayerFor(class BlamWorldObject_Tag* point_object);
 
};