Xargon/Duckstation
1
0
Fork 0
mirror of https://github.com/RetroDECK/Duckstation.git synced 2025-04-10 19:15:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Duckstation/data/resources/shaders/reshade/Shaders/crt-royale/lib/bind-shader-params.fxh

908 lines
28 KiB
HLSL
Raw Blame History

#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
Reference in a new issue View git blame Copy permalink