postprocess.h

Go to the documentation of this file.

 
#ifndef POSTPROCESS_H
#define POSTPROCESS_H
 
#include "effects/fx_auto_exposure.h"
#include "effects/fx_bloom.h"
#include "effects/fx_dof.h"
#include "effects/fx_lut3d.h"
#include "effects/fx_lut_viz.h"
#include "effects/fx_motion_blur.h"
#include "gl_common.h"
#include "gpu_profiler.h"
#include "shader.h"
#include <cglm/cglm.h>
#include <cglm/types.h>
 
/* --- DEFAULT VALUES --- */
#define POSTPROCESS_HISTOGRAM_BUCKETS 256
 
#define DEFAULT_VIGNETTE_INTENSITY 0.8F  
#define DEFAULT_VIGNETTE_SMOOTHNESS 0.5F 
#define DEFAULT_VIGNETTE_ROUNDNESS 1.0F  
#define DEFAULT_GRAIN_INTENSITY 0.02F    
#define DEFAULT_GRAIN_SHADOWS_MAX 0.09F
#define DEFAULT_GRAIN_HIGHLIGHTS_MIN 0.5F
#define DEFAULT_GRAIN_TEXEL_SIZE 1.0F
#define DEFAULT_EXPOSURE 1.00F
#define DEFAULT_CHROM_ABBR_STRENGTH 0.005F
#define DEFAULT_BLOOM_INTENSITY 0.0F
#define DEFAULT_BLOOM_THRESHOLD 1.0F
#define DEFAULT_BLOOM_SOFT_THRESHOLD 0.5F
#define DEFAULT_BLOOM_RADIUS 1.0F
 
/* FXAA Defaults */
#define DEFAULT_FXAA_SUBPIX 0.75F
#define DEFAULT_FXAA_EDGE_THRESHOLD 0.125F
#define DEFAULT_FXAA_EDGE_THRESHOLD_MIN 0.063F
 
/* DoF defaults */
#define DEFAULT_DOF_FOCAL_DISTANCE 20.0F
#define DEFAULT_DOF_FOCAL_RANGE 5.0F
#define DEFAULT_DOF_BOKEH_SCALE 10.0F
#define DEFAULT_DOF_ANAMORPHIC_RATIO \
    1.0F 
/* Banding defaults */
#define DEFAULT_BANDING_LEVELS 256.0F 
/* Fog Defaults */
#define DEFAULT_FOG_DENSITY 0.0F
#define DEFAULT_FOG_START 10.0F
#define DEFAULT_FOG_HEIGHT_FALLOFF 0.1F
#define DEFAULT_FOG_COLOR_R 0.5F
#define DEFAULT_FOG_COLOR_G 0.6F
#define DEFAULT_FOG_COLOR_B 0.7F
 
/* White Balance Defaults */
#define DEFAULT_WB_TEMP 6500.0F
#define DEFAULT_WB_TINT 0.0F
 
/* Filmic Defaults (Safe Neutrals) */
#define DEFAULT_FILMIC_SLOPE 1.0F
#define DEFAULT_FILMIC_TOE 0.0F
#define DEFAULT_FILMIC_SHOULDER 0.0F
#define DEFAULT_FILMIC_BLACK_CLIP 0.0F
#define DEFAULT_FILMIC_WHITE_CLIP 0.0F
 
typedef enum {
    POSTFX_VIGNETTE = (1U << 0U),   
    POSTFX_GRAIN = (1U << 1U),      
    POSTFX_EXPOSURE = (1U << 2U),   
    POSTFX_CHROM_ABBR = (1U << 3U), 
    POSTFX_BLOOM = (1U << 4U),      
    POSTFX_COLOR_GRADING =
        (1U << 5U),          
    POSTFX_DOF = (1U << 6U), 
    POSTFX_DOF_DEBUG = (1U << 7U), 
    POSTFX_AUTO_EXPOSURE =
        (1U << 8U), 
    POSTFX_EXPOSURE_DEBUG =
        (1U << 9U), 
    POSTFX_MOTION_BLUR = (1U << 10U), 
    POSTFX_MOTION_BLUR_DEBUG =
        (1U << 11U),                 
    POSTFX_FXAA = (1U << 12U),       
    POSTFX_FXAA_DEBUG = (1U << 13U), 
    POSTFX_BANDING = (1U << 14U),    
    POSTFX_VECTOR_FIELD_DEBUG =
        (1U << 15U), 
    POSTFX_STENCIL_DEBUG = (1U << 16U), 
    POSTFX_BLOOM_DEBUG = (1U << 17U),   
    POSTFX_FOG = (1U << 18U),           
    POSTFX_FOG_DEBUG = (1U << 19U),     
    POSTFX_LUT3D = (1U << 20U),         
    POSTFX_LUT_VIZ = (1U << 21U), 
} PostProcessEffect;
 
#define DEFAULT_ACTIVE_EFFECTS                                                \
    ((unsigned int)POSTFX_EXPOSURE | (unsigned int)POSTFX_COLOR_GRADING | \
     (unsigned int)POSTFX_FXAA)
 
typedef struct {
    float saturation; 
    float contrast;   
    float gamma;      
    float gain;       
    float offset;     
    float lift;       
} ColorGradingParams;
 
typedef struct {
    float intensity;  
    float smoothness; 
    float roundness;  
} VignetteParams;
 
typedef struct {
    float intensity;            
    float intensity_shadows;    
    float intensity_midtones;   
    float intensity_highlights; 
    float shadows_max;          
    float highlights_min;       
    float texel_size;           
} GrainParams;
 
typedef struct {
    float exposure; 
} ExposureParams;
 
typedef struct {
    float strength; 
} ChromAbberationParams;
 
typedef struct {
    float temperature; 
    float tint;        
} WhiteBalanceParams;
 
typedef struct {
    float slope;      
    float toe;        
    float shoulder;   
    float black_clip; 
    float white_clip; 
} TonemapParams;
 
typedef struct {
    float subpix;         
    float edge_threshold; 
    float edge_threshold_min; 
} FXAAParams;
 
typedef enum {
    BANDING_MODE_LINEAR = 0,     
    BANDING_MODE_DITHERED = 1,   
    BANDING_MODE_PERCEPTUAL = 2, 
    BANDING_MODE_CHANNEL = 3,    
    BANDING_MODE_LUMINANCE = 4   
} BandingMode;
 
typedef struct {
    int32_t mode;           
    float levels;           
    float dither_strength;  
    float perceptual_gamma; 
    vec3 channel_levels;    
} BandingParams;
 
typedef struct {
    float density;        
    float start;          
    float height_falloff; 
    float color[3];       
} FogParams;
 
typedef struct {
    unsigned int flags;
    Shader* shader;
} ShaderCacheEntry;
 
enum { SHADER_CACHE_SIZE = 64 };
 
typedef struct {
    uint32_t active_effects;
    float time;
    float screen_texel_size[2]; 
    /* Vignette */
    float vignette_intensity;
    float vignette_smoothness;
    float vignette_roundness;
    float _pad1;
 
    /* Grain */
    float grain_intensity;
    float grain_intensity_shadows;
    float grain_intensity_midtones;
    float grain_intensity_highlights;
    float grain_shadows_max;
    float grain_highlights_min;
    float grain_texel_size;
    float _pad2;
 
    /* Exposure */
    float exposure_manual;
    float _pad3[3];
 
    /* Chrom Abbr */
    float chrom_abbr_strength;
    float _pad4[3];
 
    /* White Balance */
    float wb_temperature;
    float wb_tint;
    float _pad5[2];
 
    /* Color Grading */
    float grading_saturation;
    float grading_contrast;
    float grading_gamma;
    float grading_gain;
    float grading_offset;
    float grading_lift;
    float _pad6[2];
 
    /* Tonemapper */
    float tonemap_slope;
    float tonemap_toe;
    float tonemap_shoulder;
    float tonemap_black_clip;
    float tonemap_white_clip;
    float _pad7[3];
 
    /* Bloom */
    float bloom_intensity;
    float bloom_threshold;
    float bloom_soft_threshold;
    float bloom_radius;
 
    /* DoF */
    float dof_focal_distance;
    float dof_focal_range;
    float dof_bokeh_scale;
    float dof_anamorphic_ratio;
 
    /* Motion Blur */
    float mb_intensity;
    float mb_max_velocity;
    int32_t mb_samples;
    float _pad9;
 
    /* FXAA */
    float fxaa_quality_subpix;
    float fxaa_quality_edge_threshold;
    float fxaa_quality_edge_threshold_min;
    float _pad10;
 
    /* Banding (32 bytes) */
    int32_t banding_mode;
    float banding_levels;
    float banding_dither_strength;
    float banding_perceptual_gamma;
    float banding_channel_levels[3];
    float _pad11;
 
    /* Fog (32 bytes) */
    float fog_density;
    float fog_start;
    float fog_height_falloff;
    float _pad12;
    vec3 fog_color;
    float _pad13;
 
    /* 3D LUT (16 bytes) */
    float lut3d_intensity;
    float _pad14[3];
} GL_UBO_ALIGNED PostProcessUBO;
 
GL_ASSERT_UBO_ALIGNMENT(PostProcessUBO);
 
typedef struct PostProcess {
    /* FBO principal et textures */
    GLuint scene_fbo;          
    GLuint scene_color_tex;    
    GLuint velocity_tex;       
    GLuint scene_depth_tex;    
    GLuint scene_stencil_view; 
    /* Module Resources */
    BloomFX bloom_fx;                
    DoFFX dof_fx;                    
    AutoExposureFX auto_exposure_fx; 
    MotionBlurFX motion_blur_fx;     
    LUT3DFX lut3d_fx;                
    LUTVizFX lut_viz_fx;             
    /* Render Utilities */
    GLuint screen_quad_vao; 
    GLuint screen_quad_vbo; 
    GLuint settings_ubo; 
    /* Core Shaders */
    Shader* postprocess_shader;  
    Shader* tile_max_shader;     
    Shader* neighbor_max_shader; 
    int width;  
    int height; 
    unsigned int active_effects; 
    /* Logic Parameters */
    VignetteParams vignette;
    GrainParams grain;
    ExposureParams exposure;
    ChromAbberationParams chrom_abbr;
    WhiteBalanceParams white_balance;
    ColorGradingParams color_grading;
    TonemapParams tonemapper;
    BloomParams bloom;
    DoFParams dof;
    AutoExposureParams auto_exposure;
    MotionBlurParams motion_blur;
    FXAAParams fxaa;
    BandingParams banding;
    FogParams fog;
    LUT3DParams lut3d;
 
    float time;             
    float delta_time;       
    GLuint dummy_black_tex; 
    GLuint dummy_uint_tex;
 
    bool is_optimized; 
    bool ubo_dirty;    
    unsigned int
        compiled_flags; 
    ShaderCacheEntry shader_cache[SHADER_CACHE_SIZE];
    int shader_cache_count;
 
    GPUProfiler* gpu_profiler;
    int banding_preset_idx; 
    /* --- Exposure Readback --- */
    GLuint
        exposure_pbo[2]; 
    GLuint histogram_pbo[2];  
    GLsync exposure_sync[2];  
    GLsync histogram_sync[2]; 
    float current_exposure; 
    float auto_threshold;   
    /* --- Histogram Cache (Avoid UI flickering) --- */
    int last_buckets[POSTPROCESS_HISTOGRAM_BUCKETS];
    float last_min_lum;
    float last_max_lum;
    int last_histogram_updated;
 
    uint64_t frame_count; 
} PostProcess;
 
/* --- Lifecycle --- */
 
int postprocess_init(PostProcess* post_processing,
                     GPUProfiler* external_profiler, int width, int height);
 
void postprocess_cleanup(PostProcess* post_processing);
 
void postprocess_compile_optimized(PostProcess* post_processing,
                                   unsigned int static_flags);
 
void postprocess_use_dynamic(PostProcess* post_processing);
 
void postprocess_set_dummy_textures(PostProcess* post_processing,
                                    GLuint dummy_black);
 
void postprocess_resize(PostProcess* post_processing, int width, int height);
 
/* --- Effect Control --- */
 
void postprocess_enable(PostProcess* post_processing, PostProcessEffect effect);
void postprocess_disable(PostProcess* post_processing,
                         PostProcessEffect effect);
void postprocess_toggle(PostProcess* post_processing, PostProcessEffect effect);
int postprocess_is_enabled(PostProcess* post_processing,
                           PostProcessEffect effect);
 
/* --- Parameter Tuning --- */
 
void postprocess_set_white_balance(PostProcess* post_processing,
                                   float temperature, float tint);
void postprocess_set_color_grading(PostProcess* post_processing,
                                   float saturation, float contrast,
                                   float gamma, float gain, float offset,
                                   float lift);
void postprocess_set_tonemapper(PostProcess* post_processing, float slope,
                                float toe, float shoulder, float black_clip,
                                float white_clip);
void postprocess_set_grading_ue_default(PostProcess* post_processing);
void postprocess_set_vignette(PostProcess* post_processing, float intensity,
                              float smoothness, float roundness);
void postprocess_set_grain(PostProcess* post_processing, float intensity);
void postprocess_set_exposure(PostProcess* post_processing, float exposure);
void postprocess_set_chrom_abbr(PostProcess* post_processing, float strength);
void postprocess_set_bloom(PostProcess* post_processing, float intensity,
                           float threshold, float soft_threshold);
void postprocess_set_dof(PostProcess* post_processing, float focal_distance,
                         float focal_range, float bokeh_scale);
void postprocess_set_dof_anamorphic(PostProcess* post_processing,
                                    float anamorphic_ratio);
float postprocess_get_exposure(PostProcess* post_processing);
void postprocess_set_auto_exposure(PostProcess* post_processing,
                                   float min_luminance, float max_luminance,
                                   float speed_up, float speed_down,
                                   float key_value);
void postprocess_set_fxaa(PostProcess* post_processing, float subpix,
                          float edge_threshold, float edge_threshold_min);
void postprocess_set_banding(PostProcess* post_processing, BandingMode mode,
                             float levels);
void postprocess_set_banding_dither(PostProcess* post_processing,
                                    float strength);
void postprocess_set_banding_perceptual(PostProcess* post_processing,
                                        float gamma);
void postprocess_set_banding_channels(PostProcess* post_processing, float red,
                                      float green, float blue);
void postprocess_set_fog(PostProcess* post_processing, float density,
                         float start, float height_falloff, float fog_r,
                         float fog_g, float fog_b);
void postprocess_set_lut3d(PostProcess* post_processing, float intensity,
                           GLuint texture);
int postprocess_load_lut3d(PostProcess* post_processing, const char* path);
void postprocess_update_matrices(PostProcess* post_processing, mat4 view_proj);
 
typedef struct {
    unsigned int active_effects;
    VignetteParams vignette;
    GrainParams grain;
    ExposureParams exposure;
    ChromAbberationParams chrom_abbr;
    WhiteBalanceParams white_balance;
    ColorGradingParams color_grading;
    TonemapParams tonemapper;
    BloomParams bloom;
    DoFParams dof;
    FXAAParams fxaa;
    BandingParams banding;
    FogParams fog;
    LUT3DParams lut3d;
} PostProcessPreset;
 
void postprocess_apply_preset(PostProcess* post_processing,
                              const PostProcessPreset* preset);
 
/* --- Render Pass Management --- */
 
void postprocess_begin(PostProcess* post_processing);
 
void postprocess_end(PostProcess* post_processing);
 
void postprocess_update_time(PostProcess* post_processing, float delta_time);
 
GLuint postprocess_get_exposure_pbo(PostProcess* post_processing, int index);
GLuint postprocess_get_histogram_pbo(PostProcess* post_processing, int index);
GLsync postprocess_get_exposure_sync(PostProcess* post_processing, int index);
GLsync postprocess_get_histogram_sync(PostProcess* post_processing, int index);
void postprocess_set_exposure_sync(PostProcess* post_processing, int index,
                                   GLsync sync);
void postprocess_set_histogram_sync(PostProcess* post_processing, int index,
                                    GLsync sync);
 
void postprocess_update_readbacks(PostProcess* post_processing,
                                  uint64_t frame_count);
 
void postprocess_set_exposure_target(PostProcess* post_processing,
                                     float threshold);
 
int postprocess_compute_luminance_histogram(PostProcess* post_processing,
                                            uint64_t frame_count, int* buckets,
                                            int size, float* min_lum,
                                            float* max_lum);
 
#endif /* POSTPROCESS_H */