Duckstation/data/resources/shaders/reshade/Shaders/crt-royale/lib/bind-shader-params.fxh

#ifndef _BIND_SHADER_PARAMS_H
#define _BIND_SHADER_PARAMS_H

/////////////////////////////  GPL LICENSE NOTICE  /////////////////////////////

//  crt-royale: A full-featured CRT shader, with cheese.
//  Copyright (C) 2014 TroggleMonkey <trogglemonkey@gmx.com>
//
//  crt-royale-reshade: A port of TroggleMonkey's crt-royale from libretro to ReShade.
//  Copyright (C) 2020 Alex Gunter <akg7634@gmail.com>
//
//  This program is free software; you can redistribute it and/or modify it
//  under the terms of the GNU General Public License as published by the Free
//  Software Foundation; either version 2 of the License, or any later version.
//
//  This program is distributed in the hope that it will be useful, but WITHOUT
//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
//  more details.
//
//  You should have received a copy of the GNU General Public License along with
//  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
//  Place, Suite 330, Boston, MA 02111-1307 USA


/////////////////////////////  SETTINGS MANAGEMENT  ////////////////////////////

///////////////////////////////  BEGIN INCLUDES  ///////////////////////////////
#include "helper-functions-and-macros.fxh"
#include "user-settings.fxh"
#include "derived-settings-and-constants.fxh"
#include "../version-number.fxh"

////////////////////////////////  END INCLUDES  ////////////////////////////////

//  Override some parameters for gamma-management.h and tex2Dantialias.h:
#ifndef _OVERRIDE_DEVICE_GAMMA
    #define _OVERRIDE_DEVICE_GAMMA 1
#endif

#if __RENDERER__ != 0x9000
    #define _DX9_ACTIVE 0
#else
    #define _DX9_ACTIVE 1
#endif

// #ifndef ANTIALIAS_OVERRIDE_BASICS
//     #define ANTIALIAS_OVERRIDE_BASICS 1
// #endif

// #ifndef ANTIALIAS_OVERRIDE_PARAMETERS
//     #define ANTIALIAS_OVERRIDE_PARAMETERS 1
// #endif

#ifndef ADVANCED_SETTINGS
    #define ADVANCED_SETTINGS 0
#endif 

// The width of the game's content
#ifndef CONTENT_WIDTH
	#define CONTENT_WIDTH BUFFER_WIDTH
#endif
// The height of the game's content
#ifndef CONTENT_HEIGHT
	#define CONTENT_HEIGHT BUFFER_HEIGHT
#endif

#if ADVANCED_SETTINGS == 1
    // Using vertex uncropping is marginally faster, but vulnerable to DX9 weirdness.
    // Most users will likely prefer the slower algorithm.
    #ifndef USE_VERTEX_UNCROPPING
        #define USE_VERTEX_UNCROPPING 0
    #endif

    #ifndef NUM_BEAMDIST_COLOR_SAMPLES
        #define NUM_BEAMDIST_COLOR_SAMPLES 1024
    #endif

    #ifndef NUM_BEAMDIST_DIST_SAMPLES
        #define NUM_BEAMDIST_DIST_SAMPLES 120
    #endif

    #ifndef BLOOMAPPROX_DOWNSIZING_FACTOR
        #define BLOOMAPPROX_DOWNSIZING_FACTOR 4.0
    #endif

    // Define this internal value, so ADVANCED_SETTINGS == 0 doesn't cause a redefinition error when
    //   NUM_BEAMDIST_COLOR_SAMPLES defined in the preset file. Also makes it easy to avoid bugs
    //   related to parentheses and order-of-operations when the user defines this arithmetically.
    static const uint num_beamdist_color_samples = uint(NUM_BEAMDIST_COLOR_SAMPLES);
    static const uint num_beamdist_dist_samples = uint(NUM_BEAMDIST_DIST_SAMPLES);
    static const float bloomapprox_downsizing_factor = float(BLOOMAPPROX_DOWNSIZING_FACTOR);
#else
    static const uint USE_VERTEX_CROPPING = 0;
    static const uint num_beamdist_color_samples = 1024;
    static const uint num_beamdist_dist_samples = 120;
    static const float bloomapprox_downsizing_factor = 4.0;
#endif

#ifndef HIDE_HELP_SECTIONS
    #define HIDE_HELP_SECTIONS 0
#endif


// Offset the center of the game's content (horizontal)
#ifndef CONTENT_CENTER_X
	#define CONTENT_CENTER_X 0
#endif
// Offset the center of the game's content (vertical)
#ifndef CONTENT_CENTER_Y
	#define CONTENT_CENTER_Y 0
#endif

// Wrap the content size in parenthesis for internal use, so the user doesn't have to
static const float2 content_size = float2(int(CONTENT_WIDTH), int(CONTENT_HEIGHT));

#ifndef ENABLE_PREBLUR
    #define ENABLE_PREBLUR 1
#endif


static const float2 buffer_size = float2(BUFFER_WIDTH, BUFFER_HEIGHT);


// The normalized center is 0.5 plus the normalized offset
static const float2 content_center = float2(CONTENT_CENTER_X, CONTENT_CENTER_Y) / buffer_size + 0.5;
// The content's normalized diameter d is its size divided by the buffer's size. The radius is d/2.
static const float2 content_radius = content_size / (2.0 * buffer_size);
static const float2 content_scale = content_size / buffer_size;

static const float content_left = content_center.x - content_radius.x;
static const float content_right = content_center.x + content_radius.x;
static const float content_upper = content_center.y - content_radius.y;
static const float content_lower = content_center.y + content_radius.y;

// The xy-offset of the top-left pixel in the content box
static const float2 content_offset = float2(content_left, content_upper);
static const float2 content_offset_from_right = float2(content_right, content_lower);

uniform uint frame_count < source = "framecount"; >;
uniform int overlay_active < source = "overlay_active"; >;

static const float gba_gamma = 3.5; //  Irrelevant but necessary to define.


// === HELP AND INFO ===

uniform int APPEND_VERSION_SUFFIX(version) <
	ui_text = "Version: " DOT_VERSION_STR;
	ui_label = " ";
	ui_type = "radio";
>;

uniform int basic_setup_help <
	ui_text = "1. Configure the Content Box if your game has letter-boxing.\n"
			  "2. Configure the Phosphor Mask.\n"
              "3. Configure the Scanlines.\n"
              "4. Configure the Colors and Effects.\n"
              "5. Configure the Screen Geometry.\n"
              "6. Configure or disable Preblur\n\n"
              "- In Preprocessor Definitions, set ADVANCED_SETTINGS to 1 to access more settings.\n";
	ui_category = "Basic Setup Instructions";
    ui_category_closed = true;
	ui_label = " ";
	ui_type = "radio";
    hidden = HIDE_HELP_SECTIONS;
>;

uniform int content_box_help <
	ui_text = "1. Expand the Preprocessor Definitions section.\n"
              "2. Set CONTENT_BOX_VISIBLE to 1.\n"
              "3. Use the \"CONTENT_\" parameters to configure the Content Box.\n"
			  "4. Align the content box with the border of your game.\n"
              "5. Set CONTENT_BOX_VISIBLE to 0 when you're done.\n\n"
              "Parameters to focus on:\n"
              "- CONTENT_HEIGHT and CONTENT_WIDTH\n"
              "- CONTENT_CENTER_X and CONTENT_CENTER_Y\n"
              "- CONTENT_BOX_INSCRIBED\n\n"
              "Fancy Trick 1:\n"
              "\tCONTENT_HEIGHT = BUFFER_HEIGHT\n"
              "\tCONTENT_WIDTH = CONTENT_HEIGHT * 4.0 / 3.0\n"
              "- Good if your game fills the screen vertically and has a 4:3 aspect ratio.\n"
              "- Will also rescale automatically if you resize the window.\n\n"
              "Fancy Trick 2:\n"
              "\tCONTENT_HEIGHT = CONTENT_WIDTH * 9.0 / 16.0\n"
              "\tCONTENT_WIDTH = 1500\n"
              "- Good if your game is 1500 pixels wide with a 16:9 aspect ratio.\n"
              "- Won't rescale automatically, but you'd only have to change the width.\n";
	ui_category = "Content Box Instructions";
    ui_category_closed = true;
	ui_label = " ";
	ui_type = "radio";
    hidden = HIDE_HELP_SECTIONS;
>;


// ==== PHOSPHOR MASK ====
uniform int mask_type <
        #if !HIDE_HELP_SECTIONS
        ui_text    = "Choose which kind of CRT you want.\n\n";
        #endif
        ui_label   = "Mask Type";
        ui_tooltip = "Selects the phosphor shape";
        ui_type    = "combo";
        ui_items   = "Grille\0"
                    "Slot\0"
                    "Shadow\0"
                    "LowRes Grille\0"
                    "LowRes Slot\0"
                    "LowRes Shadow\0";

    ui_category = "Phosphor Mask";
    ui_category_closed = true;
> = mask_type_static;

uniform uint mask_size_param <
        ui_label   = "Mask Size Param";
        ui_tooltip = "Switch between using Mask Triad Size or Mask Num Triads";
        ui_type    = "combo";
        ui_items   = "Triad Width\0"
                    "Num Triads Across\0";
        hidden     = !ADVANCED_SETTINGS;

    ui_spacing = 2;
    ui_category = "Phosphor Mask";
> = mask_size_param_static;

uniform float mask_triad_width <
        ui_label   = "Mask Triad Width";
        ui_tooltip = "The width of a triad in pixels";
        ui_type    = "slider";
        ui_min     = 1.0;
        ui_max     = 60.0;
        ui_step    = 0.1;

    ui_category = "Phosphor Mask";
> = mask_triad_width_static;

uniform float mask_num_triads_across <
        ui_label   = "Mask Num Triads Across";
        ui_tooltip = "The number of triads in the viewport (horizontally)";
        ui_type    = "drag";
        ui_min     = 1.0;
        ui_max     = 1280.0;
        ui_step    = 1.0;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Phosphor Mask";
> = mask_num_triads_across_static;

uniform float scale_triad_height<
        ui_label   = "Scale Triad Height";
        ui_tooltip = "Scales the height of a triad";
        ui_type    = "drag";
        ui_min     = 0.01;
        ui_max     = 10.0;
        ui_step    = 0.001;

    ui_spacing = 2;
    ui_category = "Phosphor Mask";
> = 1.0;

uniform float2 phosphor_thickness <
        ui_label   = "Phosphor Thickness XY";
        ui_tooltip = "Makes the phosphors appear thicker in each direction";
        ui_type    = "drag";
        ui_min     = 0.01;
        ui_max     = 0.99;
        ui_step    = 0.01;
        // hidden     = !ADVANCED_SETTINGS;

    ui_category = "Phosphor Mask";
> = 0.2;

uniform float2 phosphor_sharpness <
        ui_label   = "Phosphor Sharpness XY";
        ui_tooltip = "Makes the phosphors appear more crisp in each direction";
        ui_type    = "drag";
        ui_min     = 1;
        ui_max     = 100;
        ui_step    = 1;
        // hidden     = !ADVANCED_SETTINGS;

    ui_category = "Phosphor Mask";
> = 50;

uniform float3 phosphor_offset_x <
        ui_label   = "Phosphor Offset RGB X";
        ui_tooltip = "Very slightly shifts the phosphor mask. Can help with subpixel alignment.";
        ui_type    = "drag";
        ui_min     = -1;
        ui_max     = 1;
        ui_step    = 0.01;
        // hidden     = !ADVANCED_SETTINGS;

    ui_spacing = 2;
    ui_category = "Phosphor Mask";
> = 0;

uniform float3 phosphor_offset_y <
        ui_label   = "Phosphor Offset RGB Y";
        ui_tooltip = "Very slightly shifts the phosphor mask. Can help with subpixel alignment.";
        ui_type    = "drag";
        ui_min     = -1;
        ui_max     = 1;
        ui_step    = 0.01;
        // hidden     = !ADVANCED_SETTINGS;

    ui_category = "Phosphor Mask";
> = 0;

// static const uint pixel_grid_mode = 0;
// static const float2 pixel_size = 1;
/*
// ==== PIXELATION ===
uniform uint pixel_grid_mode <
        #if !HIDE_HELP_SECTIONS
        ui_text    = "- Fix issues displaying pixel art.\n"
                     "- Force high-res games to look low-res.\n\n";
        #endif
        ui_label   = "Pixel Grid Param";
        ui_tooltip = "Switch between using Pixel Size or Num Pixels";
        ui_type    = "combo";
        ui_items   = "Pixel Size\0"
                    "Content Resolution\0";
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Pixelation";
    ui_category_closed = true;
> = 0;

uniform float2 pixel_size <
        #if !HIDE_HELP_SECTIONS && !ADVANCED_SETTINGS
        ui_text    = "- Fix issues displaying pixel art.\n"
                     "- Force high-res games to look low-res.\n\n";
        #endif
        ui_label   = "Pixel Size";
        ui_tooltip = "The size of an in-game pixel on screen, in real-world pixels";
        ui_type    = "slider";
        ui_min     = 1.0;
        ui_max     = 30.0;
        ui_step    = 1.0;

    ui_category = "Pixelation";
    ui_category_closed = true;
> = float2(1, 1);

uniform float2 pixel_grid_resolution <
        ui_label   = "Num Pixels";
        ui_tooltip = "The number of in-game pixels displayed on-screen in each direction";
        ui_type    = "drag";
        ui_min     = 1.0;
        ui_max     = 10000.0;
        ui_step    = 1.0;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Pixelation";
> = content_size;
uniform float2 pixel_grid_offset <
        ui_label   = "Pixel Grid Offset";
        ui_tooltip = "Shifts the pixel-grid to help with alignment";
        ui_type    = "slider";
        ui_min     = -15.0;
        ui_max     = 15.0;
        ui_step    = 1.0;

    #if ADVANCED_SETTINGS
    ui_spacing = 2;
    #endif
    ui_category = "Pixelation";
> = float2(0, 0);
*/

// ==== SCANLINES ====
uniform uint scanline_thickness <
        #if !HIDE_HELP_SECTIONS
        ui_text    = "Configure the electron beams and interlacing.\n\n";
        #endif
        ui_label   = "Scanline Thickness";
        ui_tooltip = "Sets the height of each scanline";
        ui_type    = "slider";
        ui_min     = 1;
        ui_max     = 30;
        ui_step    = 1;

    ui_category = "Scanlines";
    ui_category_closed = true;
> = 2;

uniform float scanline_offset <
        ui_label   = "Scanline Offset";
        ui_tooltip = "Vertically shifts the scanlines to help with alignment";
        ui_type    = "slider";
        ui_min     = -30;
        ui_max     = 30;
        ui_step    = 1;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Scanlines";
> = 0;

uniform uint beam_shape_mode <
        ui_label   = "Beam Shape Mode";
        ui_tooltip = "Select the kind of beam to use.";
        ui_type    = "combo";
        ui_items   = "Digital (Fast)\0"
                    "Linear (Simple)\0"
                    "Gaussian (Realistic)\0"
                    "Multi-Source Gaussian (Expensive)\0";

    ui_category = "Scanlines";
> = 1;

uniform bool enable_interlacing <
        ui_label   = "Enable Interlacing";

    ui_spacing = 5;
    ui_category = "Scanlines";
> = false;

uniform bool interlace_back_field_first <
        ui_label   = "Draw Back-Field First";
        ui_tooltip = "Draw odd-numbered scanlines first (often has no effect)";

    ui_category = "Scanlines";
> = interlace_back_field_first_static;

uniform uint scanline_deinterlacing_mode <
        ui_label   = "Deinterlacing Mode";
        ui_tooltip = "Selects the deinterlacing algorithm, if any.";
        ui_type    = "combo";
        ui_items   = "None\0"
                     "Fake-Progressive\0"  
                     "Weaving\0"
                     "Blended Weaving\0";

    ui_category = "Scanlines";
> = 1;

uniform float deinterlacing_blend_gamma <
        ui_label   = "Deinterlacing Blend Gamma";
        ui_tooltip = "Nudge this if deinterlacing changes your colors too much";
        ui_type    = "slider";
        ui_min     = 0.01;
        ui_max     = 5.0;
        ui_step    = 0.01;

    ui_category = "Scanlines";
> = 1.0;

uniform float linear_beam_thickness <
        ui_label   = "Linear Beam Thickness";
        ui_tooltip = "Linearly widens or narrows the beam";
        ui_type    = "slider";
        ui_min     = 0.01;
        ui_max     = 3.0;
        ui_step    = 0.01;

    ui_spacing = 5;
    ui_category = "Scanlines";
> = 1.0;

uniform float gaussian_beam_min_sigma <
        ui_label   = "Gaussian Beam Min Sigma";
        ui_tooltip = "For Gaussian Beam Shape, sets thickness of dim pixels";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;

    ui_spacing = 5;
    ui_category = "Scanlines";
> = gaussian_beam_min_sigma_static;

uniform float gaussian_beam_max_sigma <
        ui_label   = "Gaussian Beam Max Sigma";
        ui_tooltip = "For Gaussian Beam Shape, sets thickness of bright pixels";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;

    ui_category = "Scanlines";
> = gaussian_beam_max_sigma_static;

uniform float gaussian_beam_spot_power <
        ui_label   = "Gaussian Beam Spot Power";
        ui_tooltip = "For Gaussian Beam Shape, balances between Min and Max Sigma";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;

    ui_category = "Scanlines";
> = gaussian_beam_spot_power_static;

uniform float gaussian_beam_min_shape <
        ui_label   = "Gaussian Beam Min Shape";
        ui_tooltip = "For Gaussian Beam Shape, sets sharpness of dim pixels";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_spacing = 2;
    ui_category = "Scanlines";
> = gaussian_beam_min_shape_static;

uniform float gaussian_beam_max_shape <
        ui_label   = "Gaussian Beam Max Shape";
        ui_tooltip = "For Gaussian Beam Shape, sets sharpness of bright pixels";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Scanlines";
> = gaussian_beam_max_shape_static;

uniform float gaussian_beam_shape_power <
        ui_label   = "Gaussian Beam Shape Power";
        ui_tooltip = "For Gaussian Beam Shape, balances between Min and Max Shape";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Scanlines";
> = gaussian_beam_shape_power_static;

uniform float3 convergence_offset_x <
        ui_label   = "Convergence Offset X RGB";
        ui_tooltip = "Shift the color channels horizontally";
        ui_type    = "drag";
        ui_min     = -10;
        ui_max     = 10;
        ui_step    = 0.05;
        hidden     = !ADVANCED_SETTINGS;

    ui_spacing = 5;
    ui_category = "Scanlines";
> = 0;
uniform float3 convergence_offset_y <
        ui_label   = "Convergence Offset Y RGB";
        ui_tooltip = "Shift the color channels vertically";
        ui_type    = "drag";
        ui_min     = -10;
        ui_max     = 10;
        ui_step    = 0.05;
        hidden     = !ADVANCED_SETTINGS;
    ui_category = "Scanlines";
> = 0;

static uint beam_horiz_filter = beam_horiz_filter_static;
static float beam_horiz_sigma = beam_horiz_sigma_static;
static float beam_horiz_linear_rgb_weight = beam_horiz_linear_rgb_weight_static;

// ==== IMAGE COLORIZATION ====
uniform float crt_gamma <
        #if !HIDE_HELP_SECTIONS
        ui_text    = "Apply gamma, contrast, and blurring.\n\n";
        #endif
        ui_label   = "CRT Gamma";
        ui_tooltip = "The gamma-level of the original content";
        ui_type    = "slider";
        ui_min     = 1.0;
        ui_max     = 5.0;
        ui_step    = 0.01;

    ui_category = "Colors and Effects";
    ui_category_closed = true;
> = crt_gamma_static;

uniform float lcd_gamma <
        ui_label   = "LCD Gamma";
        ui_tooltip = "The gamma-level of your display";
        ui_type    = "slider";
        ui_min     = 1.0;
        ui_max     = 5.0;
        ui_step    = 0.01;

    ui_category = "Colors and Effects";
> = lcd_gamma_static;

uniform float levels_contrast <
        ui_label   = "Levels Contrast";
        ui_tooltip = "Sets the contrast of the CRT";
        ui_type    = "slider";
        ui_min     = 0.0;
        ui_max     = 4.0;
        ui_step    = 0.01;

    ui_spacing = 5;
    ui_category = "Colors and Effects";
> = levels_contrast_static;

uniform float halation_weight <
        ui_label   = "Halation";
        ui_tooltip = "Desaturation due to eletrons exciting the wrong phosphors";
        ui_type    = "slider";
        ui_min     = 0.0;
        ui_max     = 1.0;
        ui_step    = 0.01;
        
    ui_spacing = 2;
    ui_category = "Colors and Effects";
> = halation_weight_static;

uniform float diffusion_weight <
        ui_label   = "Diffusion";
        ui_tooltip = "Blurring due to refraction from the screen's glass";
        ui_type    = "slider";
        ui_min     = 0.0;
        ui_max     = 1.0;
        ui_step    = 0.01;

    ui_category = "Colors and Effects";
> = diffusion_weight_static;

uniform float blur_radius <
        ui_label   = "Blur Radius";
        ui_tooltip = "Scales the radius of the halation and diffusion effects";
        ui_type    = "slider";
        ui_min     = 0.01;
        ui_max     = 5.0;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Colors and Effects";
> = 1.0;

uniform float bloom_underestimate_levels <
        ui_label   = "Bloom Underestimation";
        ui_tooltip = "Scale the bloom effect's intensity";
        ui_type    = "drag";
        ui_min     = FIX_ZERO(0.0);
        ui_step    = 0.01;

    ui_spacing = 2;
    ui_category = "Colors and Effects";
> = bloom_underestimate_levels_static;

uniform float bloom_excess <
        ui_label   = "Bloom Excess";
        ui_tooltip = "Extra bloom applied to all colors";
        ui_type    = "slider";
        ui_min     = 0.0;
        ui_max     = 1.0;
        ui_step    = 0.01;

    ui_category = "Colors and Effects";
> = bloom_excess_static;

uniform float2 aa_subpixel_r_offset_runtime <
        ui_label   = "AA Subpixel R Offet XY";
        ui_type    = "drag";
        ui_min     = -0.5;
        ui_max     = 0.5;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS || !_RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS;

    ui_category = "Colors and Effects";
> = aa_subpixel_r_offset_static;

static const float aa_cubic_c = aa_cubic_c_static;
static const float aa_gauss_sigma = aa_gauss_sigma_static;


// ==== GEOMETRY ====
uniform uint geom_rotation_mode <
        #if !HIDE_HELP_SECTIONS
        ui_text    = "Change the geometry of the screen's glass.\n\n";
        #endif
        ui_label   = "Rotate Screen";
        ui_type    = "combo";
        ui_items   = "0 degrees\0"
                     "90 degrees\0"
                     "180 degrees\0"
                     "270 degrees\0";

    ui_category = "Screen Geometry";
    ui_category_closed = true;
> = 0;
uniform uint geom_mode_runtime <
        ui_label   = "Geometry Mode";
        ui_tooltip = "Select screen curvature type";
        ui_type    = "combo";
        ui_items   = "Flat\0"
                    "Spherical\0"
                    "Spherical (Alt)\0"
                    "Cylindrical (Trinitron)\0";
                    
    ui_category = "Screen Geometry";
> = geom_mode_static;

uniform float geom_radius <
        ui_label   = "Geometry Radius";
        ui_tooltip = "Select screen curvature radius";
        ui_type    = "slider";
        ui_min     = 1.0 / (2.0 * pi);
        ui_max     = 1024;
        ui_step    = 0.01;

    ui_category = "Screen Geometry";
> = geom_radius_static;

uniform float geom_view_dist <
        ui_label   = "View Distance";
        ui_type    = "slider";
        ui_min     = 0.5;
        ui_max     = 1024;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_spacing = 2;
    ui_category = "Screen Geometry";
> = geom_view_dist_static;

uniform float2 geom_tilt_angle <
        ui_label   = "Screen Tilt Angles";
        ui_type    = "drag";
        ui_min     = -pi;
        ui_max     = pi;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Screen Geometry";
> = geom_tilt_angle_static;

uniform float2 geom_aspect_ratio <
        ui_label   = "Screen Aspect Ratios";
        ui_type    = "drag";
        ui_min     = 1.0;
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_category = "Screen Geometry";
> = float2(geom_aspect_ratio_static, 1);
uniform float2 geom_overscan <
        ui_label   = "Geom Overscan";
        ui_type    = "drag";
        ui_min     = FIX_ZERO(0.0);
        ui_step    = 0.01;
        hidden     = !ADVANCED_SETTINGS;

    ui_spacing = 2;
    ui_category = "Screen Geometry";
> = geom_overscan_static;

// ==== BORDER ====
uniform float border_size <
        #if !HIDE_HELP_SECTIONS
        ui_text    = "Apply a thin vignette to the edge of the screen.\n\n";
        #endif
        ui_label   = "Border Size";
        ui_category_closed = true;
        ui_type    = "slider";
        ui_min     = 0.0;
        ui_max     = 0.5;
        ui_step    = 0.01;

    ui_category = "Screen Border";
> = border_size_static;

uniform float border_darkness <
        ui_label   = "Border Darkness";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;

    ui_category = "Screen Border";
> = border_darkness_static;

uniform float border_compress <
        ui_label   = "Border Compress";
        ui_type    = "drag";
        ui_min     = 0.0;
        ui_step    = 0.01;
        
    ui_category = "Screen Border";
> = border_compress_static;

// ==== PREBLUR ====
#if ENABLE_PREBLUR
    uniform float2 preblur_effect_radius <
            #if !HIDE_HELP_SECTIONS
            ui_text    = "- Apply a linear blur to the input image. Kind of like an NTSC/Composite shader, but much faster.\n"
                         "- If you want to use an NTSC shader or don't like this effect, disable it by setting ENABLE_PREBLUR to 0\n"
                         "- If you leave all of these set to 0, then they don't do anything. Consider disabling the effect to improve performance.\n\n";
            #endif
            ui_type    = "drag";
            ui_min     = 0;
            ui_max     = 100;
            ui_step    = 1;
            ui_label   = "Effect Radius XY";
            ui_tooltip = "The radius of the effect visible on the screen (measured in pixels)";
        
        ui_category   = "Pre-Blur";
        ui_category_closed = true;
    > = 0;
    uniform uint2 preblur_sampling_radius <
            ui_type = "drag";
            ui_min = 0;
            ui_max = 100;
            ui_step = 1;
            ui_label = "Sampling Radius XY";
            ui_tooltip = "The number of samples to take on either side of each pixel";
        
        ui_category   = "Pre-Blur";
    > = 0;
#else
    static const float2 preblur_effect_radius = 0;
    static const uint2 preblur_sampling_radius = 0;
#endif

//  Provide accessors for vector constants that pack scalar uniforms:
float2 get_aspect_vector(const float geom_aspect_ratio)
{
    //  Get an aspect ratio vector.  Enforce geom_max_aspect_ratio, and prevent
    //  the absolute scale from affecting the uv-mapping for curvature:
    const float geom_clamped_aspect_ratio =
        min(geom_aspect_ratio, geom_max_aspect_ratio);
    const float2 geom_aspect =
        normalize(float2(geom_clamped_aspect_ratio, 1.0));
    return geom_aspect;
}

float2 get_geom_overscan_vector()
{
    return geom_overscan;
}

float2 get_geom_tilt_angle_vector()
{
    return geom_tilt_angle;
}

float3 get_convergence_offsets_x_vector()
{
    return convergence_offset_x;
}

float3 get_convergence_offsets_y_vector()
{
    return convergence_offset_y;
}

float2 get_convergence_offsets_r_vector()
{
    return float2(convergence_offset_x.r, convergence_offset_y.r);
}

float2 get_convergence_offsets_g_vector()
{
    return float2(convergence_offset_x.g, convergence_offset_y.g);
}

float2 get_convergence_offsets_b_vector()
{
    return float2(convergence_offset_x.b, convergence_offset_y.b);
}

float2 get_aa_subpixel_r_offset()
{
    #if _RUNTIME_ANTIALIAS_WEIGHTS
        #if _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
            //  WARNING: THIS IS EXTREMELY EXPENSIVE.
            return aa_subpixel_r_offset_runtime;
        #else
            return aa_subpixel_r_offset_static;
        #endif
    #else
        return aa_subpixel_r_offset_static;
    #endif
}

//  Provide accessors settings which still need "cooking:"
float get_mask_amplify()
{
    static const float mask_grille_amplify = 1.0/mask_grille_avg_color;
    static const float mask_slot_amplify = 1.0/mask_slot_avg_color;
    static const float mask_shadow_amplify = 1.0/mask_shadow_avg_color;

    float mask_amplify;
    [flatten]
    switch (mask_type) {
        case 0:
            mask_amplify = mask_grille_amplify;
            break;
        case 1:
            mask_amplify = mask_slot_amplify;
            break;
        case 2:
            mask_amplify = mask_shadow_amplify;
            break;
        case 3:
            mask_amplify = mask_grille_amplify;
            break;
        case 4:
            mask_amplify = mask_slot_amplify;
            break;
        default:
            mask_amplify = mask_shadow_amplify;
            break;
                    
    }
    
    return mask_amplify;
}

#endif  //  _BIND_SHADER_PARAMS_H