ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Data: Include crt-royale 

From https://github.com/akgunter/crt-royale-reshade
This commit is contained in:
Stenzek 2024-02-04 17:28:33 +10:00
parent 3bd9cbdfec
commit 3f0aa6b559
No known key found for this signature in database
28 changed files with 10637 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

244
data/resources/shaders/reshade/Shaders/crt-royale.fx Normal file
View File

@ -0,0 +1,244 @@
#include "ReShade.fxh"
///////////////////////////// GPL LICENSE NOTICE /////////////////////////////
// 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
// Enable or disable the shader
#ifndef CONTENT_BOX_VISIBLE
#define CONTENT_BOX_VISIBLE 0
#endif
#include "crt-royale/shaders/content-box.fxh"
#if !CONTENT_BOX_VISIBLE
#include "crt-royale/shaders/input-blurring.fxh"
#include "crt-royale/shaders/electron-beams.fxh"
#include "crt-royale/shaders/blurring.fxh"
#include "crt-royale/shaders/deinterlace.fxh"
#include "crt-royale/shaders/phosphor-mask.fxh"
#include "crt-royale/shaders/brightpass.fxh"
#include "crt-royale/shaders/bloom.fxh"
#include "crt-royale/shaders/geometry-aa-last-pass.fxh"
#endif
technique CRT_Royale
{
// Toggle the content box to help users configure it
#if CONTENT_BOX_VISIBLE
pass contentBoxPass
{
// content-box.fxh
// Draw a box that displays the crop we'll perform.
VertexShader = PostProcessVS;
PixelShader = contentBoxPixelShader;
}
#else
#if ENABLE_PREBLUR
pass PreblurVert
{
// input-blurring.fxh
// Optionally blur the input buffer a little
VertexShader = contentCropVS;
PixelShader = preblurVertPS;
RenderTarget = texPreblurVert;
PrimitiveTopology = TRIANGLESTRIP;
VertexCount = 4;
}
pass PreblurHoriz
{
// input-blurring.fxh
VertexShader = PostProcessVS;
PixelShader = preblurHorizPS;
RenderTarget = texPreblurHoriz;
}
#endif
pass beamDistPass
{
// electron-beams.fxh
// Simulate emission of the interlaced video as electron beams.
VertexShader = calculateBeamDistsVS;
PixelShader = calculateBeamDistsPS;
RenderTarget = texBeamDist;
// This lets us improve performance by only computing the mask every k frames
ClearRenderTargets = false;
}
pass electronBeamPass
{
// electron-beams.fxh
// Simulate emission of the interlaced video as electron beams.
VertexShader = simulateEletronBeamsVS;
PixelShader = simulateEletronBeamsPS;
RenderTarget = texElectronBeams;
// If the preblur passes are disabled, we have to crop in this pass
#if !ENABLE_PREBLUR
PrimitiveTopology = TRIANGLESTRIP;
VertexCount = 4;
#endif
}
pass beamConvergencePass
{
// electron-beams.fxh
// Simulate beam convergence miscalibration
// Not to be confused with beam purity
VertexShader = beamConvergenceVS;
PixelShader = beamConvergencePS;
RenderTarget = texBeamConvergence;
}
pass bloomApproxPassVert
{
// bloom.fxh
VertexShader = PostProcessVS;
PixelShader = approximateBloomVertPS;
RenderTarget = texBloomApproxVert;
}
pass bloomApproxPassHoriz
{
// bloom.fxh
VertexShader = PostProcessVS;
PixelShader = approximateBloomHorizPS;
RenderTarget = texBloomApproxHoriz;
}
pass blurVerticalPass
{
// blurring.fxh
// Vertically blur the approx bloom
VertexShader = blurVerticalVS;
PixelShader = blurVerticalPS;
RenderTarget = texBlurVertical;
}
pass blurHorizontalPass
{
// blurring.fxh
// Horizontally blur the approx bloom
VertexShader = blurHorizontalVS;
PixelShader = blurHorizontalPS;
RenderTarget = texBlurHorizontal;
}
pass deinterlacePass
{
// deinterlace.fxh
// Optionally deinterlace the video if interlacing is enabled.
// Can help approximate the original crt-royale's appearance
// without some issues like image retention.
VertexShader = deinterlaceVS;
PixelShader = deinterlacePS;
RenderTarget = texDeinterlace;
}
pass freezeFramePass
{
// deinterlace.fxh
// Capture the current frame, so we can use it in the next
// frame's deinterlacing pass.
VertexShader = freezeFrameVS;
PixelShader = freezeFramePS;
RenderTarget = texFreezeFrame;
// Explicitly disable clearing render targets
// scanlineBlendPass will not work properly if this ever defaults to true
ClearRenderTargets = false;
}
pass generatePhosphorMask
{
// phosphor-mask.fxh
VertexShader = generatePhosphorMaskVS;
PixelShader = generatePhosphorMaskPS;
RenderTarget = texPhosphorMask;
// This lets us improve performance by only computing the mask every k frames
ClearRenderTargets = false;
PrimitiveTopology = TRIANGLESTRIP;
VertexCount = 4;
}
pass applyPhosphormask
{
// phosphor-mask.fxh
// Tile the scaled phosphor mask and apply it to
// the deinterlaced image.
VertexShader = PostProcessVS;
PixelShader = applyComputedPhosphorMaskPS;
RenderTarget = texMaskedScanlines;
// RenderTarget = texGeometry;
}
pass brightpassPass
{
// brightpass.fxh
// Apply a brightpass filter for the bloom effect
VertexShader = brightpassVS;
PixelShader = brightpassPS;
RenderTarget = texBrightpass;
}
pass bloomVerticalPass
{
// bloom.fxh
// Blur vertically for the bloom effect
VertexShader = bloomVerticalVS;
PixelShader = bloomVerticalPS;
RenderTarget = texBloomVertical;
}
pass bloomHorizontalPass
{
// bloom.fxh
// Blur horizontally for the bloom effect.
// Also apply various color changes and effects.
VertexShader = bloomHorizontalVS;
PixelShader = bloomHorizontalPS;
RenderTarget = texBloomHorizontal;
}
pass geometryPass
{
// geometry-aa-last-pass.fxh
// Apply screen geometry and anti-aliasing.
VertexShader = geometryVS;
PixelShader = geometryPS;
RenderTarget = texGeometry;
}
pass uncropPass
{
// content-box.fxh
// Uncrop the video, so we draw the game's content
// in the same position it started in.
VertexShader = contentUncropVS;
PixelShader = uncropContentPixelShader;
PrimitiveTopology = TRIANGLESTRIP;
VertexCount = 4;
}
#endif
}

908
data/resources/shaders/reshade/Shaders/crt-royale/lib/bind-shader-params.fxh Normal file
View File

@ -0,0 +1,908 @@
#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

320
data/resources/shaders/reshade/Shaders/crt-royale/lib/bloom-functions.fxh Normal file
View File

@ -0,0 +1,320 @@
#ifndef _BLOOM_FUNCTIONS_H
#define _BLOOM_FUNCTIONS_H
///////////////////////////// GPL LICENSE NOTICE /////////////////////////////
// crt-royale: A full-featured CRT shader, with cheese.
// Copyright (C) 2014 TroggleMonkey <trogglemonkey@gmx.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
///////////////////////////////// DESCRIPTION ////////////////////////////////
// These utility functions and constants help several passes determine the
// size and center texel weight of the phosphor bloom in a uniform manner.
////////////////////////////////// INCLUDES //////////////////////////////////
// We need to calculate the correct blur sigma using some .cgp constants:
//#include "../user-settings.h"
#include "user-settings.fxh"
#include "derived-settings-and-constants.fxh"
#include "bind-shader-params.fxh"
#include "blur-functions.fxh"
/////////////////////////////// BLOOM CONSTANTS //////////////////////////////
// Compute constants with manual inlines of the functions below:
static const float bloom_diff_thresh = 1.0/256.0;
/////////////////////////////////// HELPERS //////////////////////////////////
float get_min_sigma_to_blur_triad(const float triad_size,
const float thresh)
{
// Requires: 1.) triad_size is the final phosphor triad size in pixels
// 2.) thresh is the max desired pixel difference in the
// blurred triad (e.g. 1.0/256.0).
// Returns: Return the minimum sigma that will fully blur a phosphor
// triad on the screen to an even color, within thresh.
// This closed-form function was found by curve-fitting data.
// Estimate: max error = ~0.086036, mean sq. error = ~0.0013387:
return -0.05168 + 0.6113*triad_size -
1.122*triad_size*sqrt(0.000416 + thresh);
// Estimate: max error = ~0.16486, mean sq. error = ~0.0041041:
//return 0.5985*triad_size - triad_size*sqrt(thresh)
}
float get_absolute_scale_blur_sigma(const float thresh)
{
// Requires: 1.) min_expected_triads must be a global float. The number
// of horizontal phosphor triads in the final image must be
// >= min_allowed_viewport_triads.x for realistic results.
// 2.) bloom_approx_scale_x must be a global float equal to the
// absolute horizontal scale of BLOOM_APPROX.
// 3.) bloom_approx_scale_x/min_allowed_viewport_triads.x
// should be <= 1.1658025090 to keep the final result <
// 0.62666015625 (the largest sigma ensuring the largest
// unused texel weight stays < 1.0/256.0 for a 3x3 blur).
// 4.) thresh is the max desired pixel difference in the
// blurred triad (e.g. 1.0/256.0).
// Returns: Return the minimum Gaussian sigma that will blur the pass
// output as much as it would have taken to blur away
// bloom_approx_scale_x horizontal phosphor triads.
// Description:
// BLOOM_APPROX should look like a downscaled phosphor blur. Ideally, we'd
// use the same blur sigma as the actual phosphor bloom and scale it down
// to the current resolution with (bloom_approx_scale_x/viewport_size_x), but
// we don't know the viewport size in this pass. Instead, we'll blur as
// much as it would take to blur away min_allowed_viewport_triads.x. This
// will blur "more than necessary" if the user actually uses more triads,
// but that's not terrible either, because blurring a constant fraction of
// the viewport may better resemble a true optical bloom anyway (since the
// viewport will generally be about the same fraction of each player's
// field of view, regardless of screen size and resolution).
// Assume an extremely large viewport size for asymptotic results.
return bloom_approx_scale_x/max_viewport_size_x *
get_min_sigma_to_blur_triad(
max_viewport_size_x/min_allowed_viewport_triads.x, thresh);
}
float get_center_weight(const float sigma)
{
// Given a Gaussian blur sigma, get the blur weight for the center texel.
#if _RUNTIME_PHOSPHOR_BLOOM_SIGMA
return get_fast_gaussian_weight_sum_inv(sigma);
#else
const float denom_inv = 0.5/(sigma*sigma);
const float w0 = 1.0;
const float w1 = exp(-1.0 * denom_inv);
const float w2 = exp(-4.0 * denom_inv);
const float w3 = exp(-9.0 * denom_inv);
const float w4 = exp(-16.0 * denom_inv);
const float w5 = exp(-25.0 * denom_inv);
const float w6 = exp(-36.0 * denom_inv);
const float w7 = exp(-49.0 * denom_inv);
const float w8 = exp(-64.0 * denom_inv);
const float w9 = exp(-81.0 * denom_inv);
const float w10 = exp(-100.0 * denom_inv);
const float w11 = exp(-121.0 * denom_inv);
const float w12 = exp(-144.0 * denom_inv);
const float w13 = exp(-169.0 * denom_inv);
const float w14 = exp(-196.0 * denom_inv);
const float w15 = exp(-225.0 * denom_inv);
const float w16 = exp(-256.0 * denom_inv);
const float w17 = exp(-289.0 * denom_inv);
const float w18 = exp(-324.0 * denom_inv);
const float w19 = exp(-361.0 * denom_inv);
const float w20 = exp(-400.0 * denom_inv);
const float w21 = exp(-441.0 * denom_inv);
// Note: If the implementation uses a smaller blur than the max allowed,
// the worst case scenario is that the center weight will be overestimated,
// so we'll put a bit more energy into the brightpass...no huge deal.
// Then again, if the implementation uses a larger blur than the max
// "allowed" because of dynamic branching, the center weight could be
// underestimated, which is more of a problem...consider always using
#if PHOSPHOR_BLOOM_TRIAD_SIZE_MODE >= _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS
// 43x blur:
const float weight_sum_inv = 1.0 /
(w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 +
w11 + w12 + w13 + w14 + w15 + w16 + w17 + w18 + w19 + w20 + w21));
#else
#if PHOSPHOR_BLOOM_TRIAD_SIZE_MODE >= _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS
// 31x blur:
const float weight_sum_inv = 1.0 /
(w0 + 2.0 * (w1 + w2 + w3 + w4 + w5 + w6 + w7 +
w8 + w9 + w10 + w11 + w12 + w13 + w14 + w15));
#else
#if PHOSPHOR_BLOOM_TRIAD_SIZE_MODE >= _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS
// 25x blur:
const float weight_sum_inv = 1.0 / (w0 + 2.0 * (
w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11 + w12));
#else
#if PHOSPHOR_BLOOM_TRIAD_SIZE_MODE >= _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS
// 17x blur:
const float weight_sum_inv = 1.0 / (w0 + 2.0 * (
w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8));
#else
// 9x blur:
const float weight_sum_inv = 1.0 / (w0 + 2.0 * (w1 + w2 + w3 + w4));
#endif // _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS
#endif // _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS
#endif // _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS
#endif // _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS
const float center_weight = weight_sum_inv * weight_sum_inv;
return center_weight;
#endif
}
float3 tex2DblurNfast(const sampler2D tex, const float2 tex_uv,
const float2 dxdy, const float sigma,
const float input_gamma)
{
// If sigma is static, we can safely branch and use the smallest blur
// that's big enough. Ignore #define hints, because we'll only use a
// large blur if we actually need it, and the branches cost nothing.
#if !_RUNTIME_PHOSPHOR_BLOOM_SIGMA
#define PHOSPHOR_BLOOM_BRANCH_FOR_BLUR_SIZE
#else
// It's still worth branching if the profile supports dynamic branches:
// It's much faster than using a hugely excessive blur, but each branch
// eats ~1% FPS.
#if _DRIVERS_ALLOW_DYNAMIC_BRANCHES
#define PHOSPHOR_BLOOM_BRANCH_FOR_BLUR_SIZE
#endif
#endif
// Failed optimization notes:
// I originally created a same-size mipmapped 5-tap separable blur10 that
// could handle any sigma by reaching into lower mip levels. It was
// as fast as blur25fast for runtime sigmas and a tad faster than
// blur31fast for static sigmas, but mipmapping two viewport-size passes
// ate 10% of FPS across all codepaths, so it wasn't worth it.
#ifdef PHOSPHOR_BLOOM_BRANCH_FOR_BLUR_SIZE
if(sigma <= blur9_std_dev)
{
return tex2Dblur9fast(tex, tex_uv, dxdy, sigma, input_gamma);
}
else if(sigma <= blur17_std_dev)
{
return tex2Dblur17fast(tex, tex_uv, dxdy, sigma, input_gamma);
}
else if(sigma <= blur25_std_dev)
{
return tex2Dblur25fast(tex, tex_uv, dxdy, sigma, input_gamma);
}
else if(sigma <= blur31_std_dev)
{
return tex2Dblur31fast(tex, tex_uv, dxdy, sigma, input_gamma);
}
else
{
return tex2Dblur43fast(tex, tex_uv, dxdy, sigma, input_gamma);
}
#else
// If we can't afford to branch, we can only guess at what blur
// size we need. Therefore, use the largest blur allowed.
#ifdef PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS
return tex2Dblur43fast(tex, tex_uv, dxdy, sigma, input_gamma);
#else
#ifdef PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS
return tex2Dblur31fast(tex, tex_uv, dxdy, sigma, input_gamma);
#else
#ifdef PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS
return tex2Dblur25fast(tex, tex_uv, dxdy, sigma, input_gamma);
#else
#if PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS
return tex2Dblur17fast(tex, tex_uv, dxdy, sigma, input_gamma);
#else
return tex2Dblur9fast(tex, tex_uv, dxdy, sigma, input_gamma);
#endif // PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS
#endif // PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS
#endif // PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS
#endif // PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS
#endif // PHOSPHOR_BLOOM_BRANCH_FOR_BLUR_SIZE
}
float get_bloom_approx_sigma(const float output_size_x_runtime,
const float estimated_viewport_size_x)
{
// Requires: 1.) output_size_x_runtime == BLOOM_APPROX.output_size.x.
// This is included for dynamic codepaths just in case the
// following two globals are incorrect:
// 2.) bloom_approx_size_x_for_skip should == the same
// if PHOSPHOR_BLOOM_FAKE is #defined
// 3.) bloom_approx_size_x should == the same otherwise
// Returns: For gaussian4x4, return a dynamic small bloom sigma that's
// as close to optimal as possible given available information.
// For blur3x3, return the a static small bloom sigma that
// works well for typical cases. Otherwise, we're using simple
// bilinear filtering, so use static calculations.
// Assume the default static value. This is a compromise that ensures
// typical triads are blurred, even if unusually large ones aren't.
static const float mask_num_triads_static =
max(min_allowed_viewport_triads.x, mask_num_triads_across_static);
const float mask_num_triads_from_size =
estimated_viewport_size_x/mask_triad_width;
const float mask_num_triads_runtime = max(min_allowed_viewport_triads.x,
lerp(mask_num_triads_from_size, mask_num_triads_across,
mask_size_param));
// Assume an extremely large viewport size for asymptotic results:
static const float max_viewport_size_x = 1080.0*1024.0*(4.0/3.0);
if(bloom_approx_filter > 1.5) // 4x4 true Gaussian resize
{
// Use the runtime num triads and output size:
const float asymptotic_triad_size =
max_viewport_size_x/mask_num_triads_runtime;
const float asymptotic_sigma = get_min_sigma_to_blur_triad(
asymptotic_triad_size, bloom_diff_thresh);
const float bloom_approx_sigma =
asymptotic_sigma * output_size_x_runtime/max_viewport_size_x;
// The BLOOM_APPROX input has to be ORIG_LINEARIZED to avoid moire, but
// account for the Gaussian scanline sigma from the last pass too.
// The bloom will be too wide horizontally but tall enough vertically.
return length(float2(bloom_approx_sigma, gaussian_beam_max_sigma));
}
else // 3x3 blur resize (the bilinear resize doesn't need a sigma)
{
// We're either using blur3x3 or bilinear filtering. The biggest
// reason to choose blur3x3 is to avoid dynamic weights, so use a
// static calculation.
#ifdef PHOSPHOR_BLOOM_FAKE
static const float output_size_x_static =
bloom_approx_size_x_for_fake;
#else
static const float output_size_x_static = bloom_approx_size_x;
#endif
static const float asymptotic_triad_size =
max_viewport_size_x/mask_num_triads_static;
const float asymptotic_sigma = get_min_sigma_to_blur_triad(
asymptotic_triad_size, bloom_diff_thresh);
const float bloom_approx_sigma =
asymptotic_sigma * output_size_x_static/max_viewport_size_x;
// The BLOOM_APPROX input has to be ORIG_LINEARIZED to avoid moire, but
// try accounting for the Gaussian scanline sigma from the last pass
// too; use the static default value:
return length(float2(bloom_approx_sigma, gaussian_beam_max_sigma_static));
}
}
float get_final_bloom_sigma(const float bloom_sigma_runtime)
{
// Requires: 1.) bloom_sigma_runtime is a precalculated sigma that's
// optimal for the [known] triad size.
// 2.) Call this from a fragment shader (not a vertex shader),
// or blurring with static sigmas won't be constant-folded.
// Returns: Return the optimistic static sigma if the triad size is
// known at compile time. Otherwise return the optimal runtime
// sigma (10% slower) or an implementation-specific compromise
// between an optimistic or pessimistic static sigma.
// Notes: Call this from the fragment shader, NOT the vertex shader,
// so static sigmas can be constant-folded!
const float bloom_sigma_optimistic = get_min_sigma_to_blur_triad(
mask_triad_width_static, bloom_diff_thresh);
#if _RUNTIME_PHOSPHOR_BLOOM_SIGMA
return bloom_sigma_runtime;
#else
// Overblurring looks as bad as underblurring, so assume average-size
// triads, not worst-case huge triads:
return bloom_sigma_optimistic;
#endif
}
#endif // _BLOOM_FUNCTIONS_H

1966
data/resources/shaders/reshade/Shaders/crt-royale/lib/blur-functions.fxh Normal file
View File

File diff suppressed because it is too large Load Diff

405
data/resources/shaders/reshade/Shaders/crt-royale/lib/derived-settings-and-constants.fxh Normal file
View File

@ -0,0 +1,405 @@
#ifndef _DERIVED_SETTINGS_AND_CONSTANTS_H
#define _DERIVED_SETTINGS_AND_CONSTANTS_H
#include "helper-functions-and-macros.fxh"
#include "user-settings.fxh"
///////////////////////////// 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
///////////////////////////////// DESCRIPTION ////////////////////////////////
// These macros and constants can be used across the whole codebase.
// Unlike the values in user-settings.cgh, end users shouldn't modify these.
/////////////////////////////// BEGIN INCLUDES ///////////////////////////////
//#include "../user-settings.h"
//#include "user-cgp-constants.h"
///////////////////////// BEGIN USER-CGP-CONSTANTS /////////////////////////
#ifndef _USER_CGP_CONSTANTS_H
#define _USER_CGP_CONSTANTS_H
// IMPORTANT:
// These constants MUST be set appropriately for the settings in crt-royale.cgp
// (or whatever related .cgp file you're using). If they aren't, you're likely
// to get artifacts, the wrong phosphor mask size, etc. I wish these could be
// set directly in the .cgp file to make things easier, but...they can't.
// PASS SCALES AND RELATED CONSTANTS:
// Copy the absolute scale_x for BLOOM_APPROX. There are two major versions of
// this shader: One does a viewport-scale bloom, and the other skips it. The
// latter benefits from a higher bloom_approx_scale_x, so save both separately:
static const float bloom_approx_scale_x = 4.0 / 3.0;
static const float max_viewport_size_x = 1080.0*1024.0*(4.0/3.0);
static const float bloom_diff_thresh_ = 1.0/256.0;
static const float bloom_approx_size_x = 320.0;
static const float bloom_approx_size_x_for_fake = 400.0;
// Copy the viewport-relative scales of the phosphor mask resize passes
// (MASK_RESIZE and the pass immediately preceding it):
static const float2 mask_resize_viewport_scale = float2(0.0625, 0.0625);
// Copy the geom_max_aspect_ratio used to calculate the MASK_RESIZE scales, etc.:
static const float geom_max_aspect_ratio = 4.0/3.0;
// PHOSPHOR MASK TEXTURE CONSTANTS:
// Set the following constants to reflect the properties of the phosphor mask
// texture named in crt-royale.cgp. The shader optionally resizes a mask tile
// based on user settings, then repeats a single tile until filling the screen.
// The shader must know the input texture size (default 64x64), and to manually
// resize, it must also know the horizontal triads per tile (default 8).
static const float2 mask_texture_small_size = float2(64.0, 64.0);
static const float2 mask_texture_large_size = float2(512.0, 512.0);
static const float mask_triads_per_tile = 8.0;
// We need the average brightness of the phosphor mask to compensate for the
// dimming it causes. The following four values are roughly correct for the
// masks included with the shader. Update the value for any LUT texture you
// change. [Un]comment "#define PHOSPHOR_MASK_GRILLE14" depending on whether
// the loaded aperture grille uses 14-pixel or 15-pixel stripes (default 15).
// #ifndef PHOSPHOR_MASK_GRILLE14
// #define PHOSPHOR_MASK_GRILLE14 0
// #endif
static const float mask_grille14_avg_color = 50.6666666/255.0;
// TileableLinearApertureGrille14Wide7d33Spacing*.png
// TileableLinearApertureGrille14Wide10And6Spacing*.png
static const float mask_grille15_avg_color = 53.0/255.0;
// TileableLinearApertureGrille15Wide6d33Spacing*.png
// TileableLinearApertureGrille15Wide8And5d5Spacing*.png
static const float mask_slot_avg_color = 46.0/255.0;
// TileableLinearSlotMask15Wide9And4d5Horizontal8VerticalSpacing*.png
// TileableLinearSlotMaskTall15Wide9And4d5Horizontal9d14VerticalSpacing*.png
static const float mask_shadow_avg_color = 41.0/255.0;
// TileableLinearShadowMask*.png
// TileableLinearShadowMaskEDP*.png
// #if PHOSPHOR_MASK_GRILLE14
// static const float mask_grille_avg_color = mask_grille14_avg_color;
// #else
static const float mask_grille_avg_color = mask_grille15_avg_color;
// #endif
#endif // _USER_CGP_CONSTANTS_H
////////////////////////// END USER-CGP-CONSTANTS //////////////////////////
//////////////////////////////// END INCLUDES ////////////////////////////////
/////////////////////////////// FIXED SETTINGS ///////////////////////////////
#define _SIMULATE_CRT_ON_LCD 1
#define _SIMULATE_GBA_ON_LCD 2
#define _SIMULATE_LCD_ON_CRT 3
#define _SIMULATE_GBA_ON_CRT 4
// Ensure the first pass decodes CRT gamma and the last encodes LCD gamma.
#define GAMMA_SIMULATION_MODE _SIMULATE_CRT_ON_LCD
// Manually tiling a manually resized texture creates texture coord derivative
// discontinuities and confuses anisotropic filtering, causing discolored tile
// seams in the phosphor mask. Workarounds:
// a.) Using tex2Dlod disables anisotropic filtering for tiled masks. It's
// downgraded to tex2Dbias without _DRIVERS_ALLOW_TEX2DLOD #defined and
// disabled without _DRIVERS_ALLOW_TEX2DBIAS #defined either.
// b.) "Tile flat twice" requires drawing two full tiles without border padding
// to the resized mask FBO, and it's incompatible with same-pass curvature.
// (Same-pass curvature isn't used but could be in the future...maybe.)
// c.) "Fix discontinuities" requires derivatives and drawing one tile with
// border padding to the resized mask FBO, but it works with same-pass
// curvature. It's disabled without _DRIVERS_ALLOW_DERIVATIVES #defined.
// Precedence: a, then, b, then c (if multiple strategies are #defined).
// #ifndef ANISOTROPIC_TILING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD 1 // 129.7 FPS, 4x, flat; 101.8 at fullscreen
// #endif
// #ifndef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE 1 // 128.1 FPS, 4x, flat; 101.5 at fullscreen
// #endif
// #ifndef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 1 // 124.4 FPS, 4x, flat; 97.4 at fullscreen
// #endif
// Also, manually resampling the phosphor mask is slightly blurrier with
// anisotropic filtering. (Resampling with mipmapping is even worse: It
// creates artifacts, but only with the fully bloomed shader.) The difference
// is subtle with small triads, but you can fix it for a small cost.
// #ifndef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD 0
// #endif
////////////////////////////// DERIVED SETTINGS //////////////////////////////
// Intel HD 4000 GPU's can't handle manual mask resizing (for now), setting the
// geometry mode at runtime, or a 4x4 true Gaussian resize. Disable
// incompatible settings ASAP. (_INTEGRATED_GRAPHICS_COMPATIBILITY_MODE may be
// #defined by either user-settings.h or a wrapper .cg that #includes the
// current .cg pass.)
#if _INTEGRATED_GRAPHICS_COMPATIBILITY_MODE
#if _PHOSPHOR_MASK_MANUALLY_RESIZE
#undef _PHOSPHOR_MASK_MANUALLY_RESIZE
#define _PHOSPHOR_MASK_MANUALLY_RESIZE 0
#endif
#if _RUNTIME_GEOMETRY_MODE
#undef _RUNTIME_GEOMETRY_MODE
#define _RUNTIME_GEOMETRY_MODE 0
#endif
// Mode 2 (4x4 Gaussian resize) won't work, and mode 1 (3x3 blur) is
// inferior in most cases, so replace 2.0 with 0.0:
static const float bloom_approx_filter = macro_cond(
bloom_approx_filter_static > 1.5,
0.0,
bloom_approx_filter_static
);
#else
static const float bloom_approx_filter = bloom_approx_filter_static;
#endif
// Disable slow runtime paths if static parameters are used. Most of these
// won't be a problem anyway once the params are disabled, but some will.
#if !_RUNTIME_SHADER_PARAMS_ENABLE
#if _RUNTIME_PHOSPHOR_BLOOM_SIGMA
#undef _RUNTIME_PHOSPHOR_BLOOM_SIGMA
#define _RUNTIME_PHOSPHOR_BLOOM_SIGMA 0
#endif
#if _RUNTIME_ANTIALIAS_WEIGHTS
#undef _RUNTIME_ANTIALIAS_WEIGHTS
#define _RUNTIME_ANTIALIAS_WEIGHTS 0
#endif
#if _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
#undef _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
#define _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS 0
#endif
#if _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
#undef _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
#define _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE 0
#endif
#if _RUNTIME_GEOMETRY_TILT
#undef _RUNTIME_GEOMETRY_TILT
#define _RUNTIME_GEOMETRY_TILT 0
#endif
#if _RUNTIME_GEOMETRY_MODE
#undef _RUNTIME_GEOMETRY_MODE
#define _RUNTIME_GEOMETRY_MODE 0
#endif
// #if FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #undef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT 0
// #endif
#endif
// Make tex2Dbias a backup for tex2Dlod for wider compatibility.
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #endif
// #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
// #endif
// Rule out unavailable anisotropic compatibility strategies:
#if !_DRIVERS_ALLOW_DERIVATIVES
// #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
// #endif
#endif
// #if !_DRIVERS_ALLOW_TEX2DLOD
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
// #undef ANISOTROPIC_TILING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD 0
// #endif
// #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
// #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD 0
// #endif
// #ifdef ANTIALIAS_DISABLE_ANISOTROPIC
// #undef ANTIALIAS_DISABLE_ANISOTROPIC
// #endif
// #endif
// #if !_DRIVERS_ALLOW_TEX2DBIAS
// #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #endif
// #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
// #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
// #endif
// #endif
// Prioritize anisotropic tiling compatibility strategies by performance and
// disable unused strategies. This concentrates all the nesting in one place.
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
// #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #endif
// #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE 0
// #endif
// #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
// #endif
// #else
// #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE 0
// #endif
// #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
// #endif
// #else
// // ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE is only compatible with
// // flat texture coords in the same pass, but that's all we use.
// #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
// #endif
// #endif
// #endif
// #endif
// The tex2Dlod and tex2Dbias strategies share a lot in common, and we can
// reduce some #ifdef nesting in the next section by essentially OR'ing them:
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
// #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY
// #endif
// #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY
// #endif
// Prioritize anisotropic resampling compatibility strategies the same way:
// #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
// #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
// #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
// #endif
// #endif
/////////////////////// DERIVED PHOSPHOR MASK CONSTANTS //////////////////////
// If we can use the large mipmapped LUT without mipmapping artifacts, we
// should: It gives us more options for using fewer samples.
// #if USE_LARGE_PHOSPHOR_MASK
// #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
// // TODO: Take advantage of this!
// #define PHOSPHOR_MASK_RESIZE_MIPMAPPED_LUT
// static const float2 mask_resize_src_lut_size = mask_texture_large_size;
// #else
static const float2 mask_resize_src_lut_size = mask_texture_large_size;
// #endif
// #else
// static const float2 mask_resize_src_lut_size = mask_texture_small_size;
// #endif
static const float tile_aspect_inv = mask_resize_src_lut_size.y/mask_resize_src_lut_size.x;
// tex2D's sampler2D parameter MUST be a uniform global, a uniform input to
// main_fragment, or a static alias of one of the above. This makes it hard
// to select the phosphor mask at runtime: We can't even assign to a uniform
// global in the vertex shader or select a sampler2D in the vertex shader and
// pass it to the fragment shader (even with explicit TEXUNIT# bindings),
// because it just gives us the input texture or a black screen. However, we
// can get around these limitations by calling tex2D three times with different
// uniform samplers (or resizing the phosphor mask three times altogether).
// With dynamic branches, we can process only one of these branches on top of
// quickly discarding fragments we don't need (cgc seems able to overcome
// limigations around dependent texture fetches inside of branches). Without
// dynamic branches, we have to process every branch for every fragment...which
// is slower. Runtime sampling mode selection is slower without dynamic
// branches as well. Let the user's static #defines decide if it's worth it.
#if _DRIVERS_ALLOW_DYNAMIC_BRANCHES
#define _RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #else
// #if FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #define _RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #endif
#endif
// We need to render some minimum number of tiles in the resize passes.
// We need at least 1.0 just to repeat a single tile, and we need extra
// padding beyond that for anisotropic filtering, discontinuitity fixing,
// antialiasing, same-pass curvature (not currently used), etc. First
// determine how many border texels and tiles we need, based on how the result
// will be sampled:
#ifdef GEOMETRY_EARLY
static const float max_subpixel_offset = aa_subpixel_r_offset_static.x;
// Most antialiasing filters have a base radius of 4.0 pixels:
static const float max_aa_base_pixel_border = 4.0 +
max_subpixel_offset;
#else
static const float max_aa_base_pixel_border = 0.0;
#endif
// Anisotropic filtering adds about 0.5 to the pixel border:
// #ifndef ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY
static const float max_aniso_pixel_border = max_aa_base_pixel_border + 0.5;
// #else
// static const float max_aniso_pixel_border = max_aa_base_pixel_border;
// #endif
// Fixing discontinuities adds 1.0 more to the pixel border:
// #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
// static const float max_tiled_pixel_border = max_aniso_pixel_border + 1.0;
// #else
static const float max_tiled_pixel_border = max_aniso_pixel_border;
// #endif
// Convert the pixel border to an integer texel border. Assume same-pass
// curvature about triples the texel frequency:
#ifdef GEOMETRY_EARLY
#define max_mask_texel_border macro_ceil(max_tiled_pixel_border * 3.0f)
#else
#define max_mask_texel_border macro_ceil(max_tiled_pixel_border)
#endif
// Convert the texel border to a tile border using worst-case assumptions:
static const float max_mask_tile_border = max_mask_texel_border/
(mask_min_allowed_triad_size * mask_triads_per_tile);
// Finally, set the number of resized tiles to render to MASK_RESIZE, and set
// the starting texel (inside borders) for sampling it.
#ifndef GEOMETRY_EARLY
// #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
// Special case: Render two tiles without borders. Anisotropic
// filtering doesn't seem to be a problem here.
// static const float mask_resize_num_tiles = 1.0 + 1.0;
// static const float mask_start_texels = 0.0;
// #else
static const float mask_resize_num_tiles = 1.0 + 2.0 * max_mask_tile_border;
static const float mask_start_texels = max_mask_texel_border;
// #endif
#else
static const float mask_resize_num_tiles = 1.0 + 2.0*max_mask_tile_border;
static const float mask_start_texels = max_mask_texel_border;
#endif
// We have to fit mask_resize_num_tiles into an FBO with a viewport scale of
// mask_resize_viewport_scale. This limits the maximum final triad size.
// Estimate the minimum number of triads we can split the screen into in each
// dimension (we'll be as correct as mask_resize_viewport_scale is):
static const float mask_resize_num_triads = mask_resize_num_tiles * mask_triads_per_tile;
static const float2 min_allowed_viewport_triads =
float2(mask_resize_num_triads, mask_resize_num_triads) / mask_resize_viewport_scale;
#endif // _DERIVED_SETTINGS_AND_CONSTANTS_H

84
data/resources/shaders/reshade/Shaders/crt-royale/lib/downsampling-functions.fxh Normal file
View File

@ -0,0 +1,84 @@
#ifndef _DOWNSAMPLING_FUNCTIONS_H
#define _DOWNSAMPLING_FUNCTIONS_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2020 Alex Gunter <akg7634@gmail.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
float3 opaque_linear_downsample(
const sampler2D tex,
const float2 texcoord,
const uint num_pairs,
const float2 delta_uv
) {
const uint total_num_samples = num_pairs * 2 + 1;
const float2 coord_left = texcoord - delta_uv * num_pairs;
float3 acc = 0;
for(int i = 0; i < total_num_samples; i++) {
const float2 coord = coord_left + i * delta_uv;
acc += tex2D_nograd(tex, coord).rgb;
}
return acc / total_num_samples;
}
float3 opaque_lanczos_downsample(
const sampler2D tex,
const float2 texcoord,
const uint num_pairs,
const float2 delta_uv,
const float num_sinc_lobes,
const float weight_at_center
) {
const uint total_num_samples = num_pairs * 2 + 1;
const float2 coord_left = texcoord - delta_uv * num_pairs;
const float sinc_dx = num_sinc_lobes / num_pairs; // 2 * num_sinc_lobes / (total_num_samples - 1)
float3 acc = 0;
float w_sum = 0;
for(int i = 0; i < total_num_samples; i++) {
const float2 coord = coord_left + i * delta_uv;
const float sinc_x = i * sinc_dx;
const float weight = (i != num_pairs) ?
num_sinc_lobes * sin(pi*sinc_x) * sin(pi*sinc_x/num_sinc_lobes) / (pi*pi * sinc_x*sinc_x) :
weight_at_center;
acc += weight * tex2D_nograd(tex, coord).rgb;
w_sum += weight;
}
return acc / w_sum;
}
float3 opaque_lanczos_downsample(
const sampler2D tex,
const float2 texcoord,
const uint num_pairs,
const float2 delta_uv,
const float num_sinc_lobes
) {
return opaque_lanczos_downsample(tex, texcoord, num_pairs, delta_uv, num_sinc_lobes, 1);
}
#endif // _DOWNSAMPLING_FUNCTIONS_H

225
data/resources/shaders/reshade/Shaders/crt-royale/lib/gamma-management.fxh Normal file
View File

@ -0,0 +1,225 @@
#ifndef _GAMMA_MANAGEMENT_H
#define _GAMMA_MANAGEMENT_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2014 TroggleMonkey
// Copyright (C) 2020 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "helper-functions-and-macros.fxh"
/////////////////////////////// BASE CONSTANTS ///////////////////////////////
// Set standard gamma constants, but allow users to override them:
#ifndef OVERRIDE_STANDARD_GAMMA
// Standard encoding gammas:
static const float ntsc_gamma = 2.2; // Best to use NTSC for PAL too?
static const float pal_gamma = 2.8; // Never actually 2.8 in practice
// Typical device decoding gammas (only use for emulating devices):
// CRT/LCD reference gammas are higher than NTSC and Rec.709 video standard
// gammas: The standards purposely undercorrected for an analog CRT's
// assumed 2.5 reference display gamma to maintain contrast in assumed
// [dark] viewing conditions: http://www.poynton.com/PDFs/GammaFAQ.pdf
// These unstated assumptions about display gamma and perceptual rendering
// intent caused a lot of confusion, and more modern CRT's seemed to target
// NTSC 2.2 gamma with circuitry. LCD displays seem to have followed suit
// (they struggle near black with 2.5 gamma anyway), especially PC/laptop
// displays designed to view sRGB in bright environments. (Standards are
// also in flux again with BT.1886, but it's underspecified for displays.)
static const float crt_reference_gamma_high = 2.5; // In (2.35, 2.55)
static const float crt_reference_gamma_low = 2.35; // In (2.35, 2.55)
static const float lcd_reference_gamma = 2.5; // To match CRT
static const float crt_office_gamma = 2.2; // Circuitry-adjusted for NTSC
static const float lcd_office_gamma = 2.2; // Approximates sRGB
#endif // OVERRIDE_STANDARD_GAMMA
// Assuming alpha == 1.0 might make it easier for users to avoid some bugs,
// but only if they're aware of it.
#ifndef OVERRIDE_ALPHA_ASSUMPTIONS
static const bool assume_opaque_alpha = false;
#endif
/////////////////////// DERIVED CONSTANTS AS FUNCTIONS ///////////////////////
// gamma-management.h should be compatible with overriding gamma values with
// runtime user parameters, but we can only define other global constants in
// terms of static constants, not uniform user parameters. To get around this
// limitation, we need to define derived constants using functions.
// Set device gamma constants, but allow users to override them:
#if _OVERRIDE_DEVICE_GAMMA
// The user promises to globally define the appropriate constants:
float get_crt_gamma() { return crt_gamma; }
float get_gba_gamma() { return gba_gamma; }
float get_lcd_gamma() { return lcd_gamma; }
#else
float get_crt_gamma() { return crt_reference_gamma_high; }
float get_gba_gamma() { return 3.5; } // Game Boy Advance; in (3.0, 4.0)
float get_lcd_gamma() { return lcd_office_gamma; }
#endif // _OVERRIDE_DEVICE_GAMMA
// Set decoding/encoding gammas for the first/lass passes, but allow overrides:
#ifdef OVERRIDE_FINAL_GAMMA
// The user promises to globally define the appropriate constants:
float get_intermediate_gamma() { return intermediate_gamma; }
float get_input_gamma() { return input_gamma; }
float get_output_gamma() { return output_gamma; }
#else
// If we gamma-correct every pass, always use ntsc_gamma between passes to
// ensure middle passes don't need to care if anything is being simulated:
// TODO: Figure out the correct way to configure this now that intermediate
// FBOs all use get_intermediate_gamma() directly. Also refer to the
// original code to confirm when a shader uses ntsc_gamma despite
// GAMMA_ENCODE_EVERY_FBO being undefined.
// float get_intermediate_gamma() { return ntsc_gamma; }
float get_intermediate_gamma() { return 1.0; }
#if GAMMA_SIMULATION_MODE == _SIMULATE_CRT_ON_LCD
float get_input_gamma() { return get_crt_gamma(); }
float get_output_gamma() { return get_lcd_gamma(); }
#else
#if GAMMA_SIMULATION_MODE == _SIMULATE_GBA_ON_LCD
float get_input_gamma() { return get_gba_gamma(); }
float get_output_gamma() { return get_lcd_gamma(); }
#else
#if GAMMA_SIMULATION_MODE == _SIMULATE_LCD_ON_CRT
float get_input_gamma() { return get_lcd_gamma(); }
float get_output_gamma() { return get_crt_gamma(); }
#else
#if GAMMA_SIMULATION_MODE == _SIMULATE_GBA_ON_CRT
float get_input_gamma() { return get_gba_gamma(); }
float get_output_gamma() { return get_crt_gamma(); }
#else // Don't simulate anything:
float get_input_gamma() { return ntsc_gamma; }
float get_output_gamma() { return ntsc_gamma; }
#endif // _SIMULATE_GBA_ON_CRT
#endif // _SIMULATE_LCD_ON_CRT
#endif // _SIMULATE_GBA_ON_LCD
#endif // _SIMULATE_CRT_ON_LCD
#endif // OVERRIDE_FINAL_GAMMA
// Set decoding/encoding gammas for the current pass. Use static constants for
// linearize_input and gamma_encode_output, because they aren't derived, and
// they let the compiler do dead-code elimination.
// #ifndef GAMMA_ENCODE_EVERY_FBO
// #ifdef FIRST_PASS
// static const bool linearize_input = true;
// float get_pass_input_gamma() { return get_input_gamma(); }
// #else
// static const bool linearize_input = false;
// float get_pass_input_gamma() { return 1.0; }
// #endif
// #ifdef LAST_PASS
// static const bool gamma_encode_output = true;
// float get_pass_output_gamma() { return get_output_gamma(); }
// #else
// static const bool gamma_encode_output = false;
// float get_pass_output_gamma() { return 1.0; }
// #endif
// #else
// static const bool linearize_input = true;
// static const bool gamma_encode_output = true;
// #ifdef FIRST_PASS
// float get_pass_input_gamma() { return get_input_gamma(); }
// #else
// float get_pass_input_gamma() { return get_intermediate_gamma(); }
// #endif
// #ifdef LAST_PASS
// float get_pass_output_gamma() { return get_output_gamma(); }
// #else
// float get_pass_output_gamma() { return get_intermediate_gamma(); }
// #endif
// #endif
// Users might want to know if bilinear filtering will be gamma-correct:
// static const bool gamma_aware_bilinear = !linearize_input;
////////////////////// COLOR ENCODING/DECODING FUNCTIONS /////////////////////
float4 encode_output_opaque(const float4 color, const float gamma)
{
static const float3 g = 1.0 / float3(gamma, gamma, gamma);
return float4(pow(color.rgb, g), 1);
}
float4 decode_input_opaque(const float4 color, const float gamma)
{
static const float3 g = float3(gamma, gamma, gamma);
return float4(pow(color.rgb, g), 1);
}
float4 encode_output(const float4 color, const float gamma)
{
static const float3 g = 1.0 / float3(gamma, gamma, gamma);
return float4(pow(color.rgb, g), color.a);
}
float4 decode_input(const float4 color, const float gamma)
{
static const float3 g = float3(gamma, gamma, gamma);
return float4(pow(color.rgb, g), color.a);
}
/////////////////////////// TEXTURE LOOKUP WRAPPERS //////////////////////////
// "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS:
// Provide a wide array of linearizing texture lookup wrapper functions. The
// Cg shader spec Retroarch uses only allows for 2D textures, but 1D and 3D
// lookups are provided for completeness in case that changes someday. Nobody
// is likely to use the *fetch and *proj functions, but they're included just
// in case. The only tex*D texture sampling functions omitted are:
// - tex*Dcmpbias
// - tex*Dcmplod
// - tex*DARRAY*
// - tex*DMS*
// - Variants returning integers
// Standard line length restrictions are ignored below for vertical brevity.
// tex2D:
float4 tex2D_linearize(const sampler2D tex, const float2 tex_coords, const float gamma)
{ return decode_input(tex2D(tex, tex_coords), gamma); }
float4 tex2D_linearize(const sampler2D tex, const float3 tex_coords, const float gamma)
{ return decode_input(tex2D(tex, tex_coords.xy), gamma); }
// float4 tex2D_linearize(const sampler2D tex, const float2 tex_coords, const int texel_off, const float gamma)
// { return decode_input(tex2Dlod(tex, float4(tex_coords.x, tex_coords.y, 0, 0), texel_off), gamma); }
// float4 tex2D_linearize(const sampler2D tex, const float3 tex_coords, const int texel_off, const float gamma)
// { return decode_input(tex2Dlod(tex, float4(tex_coords.x, tex_coords.y, 0, 0), texel_off), gamma); }
// tex2Dlod:
float4 tex2Dlod_linearize(const sampler2D tex, const float2 tex_coords, const float gamma)
{ return decode_input(tex2Dlod(tex, float4(tex_coords, 0, 0), 0.0), gamma); }
float4 tex2Dlod_linearize(const sampler2D tex, const float4 tex_coords, const float gamma)
{ return decode_input(tex2Dlod(tex, float4(tex_coords.xy, 0, 0), 0.0), gamma); }
// float4 tex2Dlod_linearize(const sampler2D tex, const float4 tex_coords, const int texel_off, const float gamma)
// { return decode_input(tex2Dlod(tex, float4(tex_coords.x, tex_coords.y, 0, 0), texel_off), gamma); }
#endif // _GAMMA_MANAGEMENT_H

715
data/resources/shaders/reshade/Shaders/crt-royale/lib/geometry-functions.fxh Normal file
View File

@ -0,0 +1,715 @@
#ifndef _GEOMETRY_FUNCTIONS_H
#define _GEOMETRY_FUNCTIONS_H
///////////////////////////// GPL LICENSE NOTICE /////////////////////////////
// crt-royale: A full-featured CRT shader, with cheese.
// Copyright (C) 2014 TroggleMonkey <trogglemonkey@gmx.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
////////////////////////////////// INCLUDES //////////////////////////////////
#include "user-settings.fxh"
#include "derived-settings-and-constants.fxh"
#include "bind-shader-params.fxh"
//////////////////////////// MACROS AND CONSTANTS ////////////////////////////
// Curvature-related constants:
#define MAX_POINT_CLOUD_SIZE 9
///////////////////////////// CURVATURE FUNCTIONS /////////////////////////////
float2 quadratic_solve(const float a, const float b_over_2, const float c)
{
// Requires: 1.) a, b, and c are quadratic formula coefficients
// 2.) b_over_2 = b/2.0 (simplifies terms to factor 2 out)
// 3.) b_over_2 must be guaranteed < 0.0 (avoids a branch)
// Returns: Returns float2(first_solution, discriminant), so the caller
// can choose how to handle the "no intersection" case. The
// Kahan or Citardauq formula is used for numerical robustness.
const float discriminant = b_over_2*b_over_2 - a*c;
const float solution0 = c/(-b_over_2 + sqrt(discriminant));
return float2(solution0, discriminant);
}
float2 intersect_sphere(const float3 view_vec, const float3 eye_pos_vec)
{
// Requires: 1.) view_vec and eye_pos_vec are 3D vectors in the sphere's
// local coordinate frame (eye_pos_vec is a position, i.e.
// a vector from the origin to the eye/camera)
// 2.) geom_radius is a global containing the sphere's radius
// Returns: Cast a ray of direction view_vec from eye_pos_vec at a
// sphere of radius geom_radius, and return the distance to
// the first intersection in units of length(view_vec).
// http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
// Quadratic formula coefficients (b_over_2 is guaranteed negative):
const float a = dot(view_vec, view_vec);
const float b_over_2 = dot(view_vec, eye_pos_vec); // * 2.0 factored out
const float c = dot(eye_pos_vec, eye_pos_vec) - geom_radius*geom_radius;
return quadratic_solve(a, b_over_2, c);
}
float2 intersect_cylinder(const float3 view_vec, const float3 eye_pos_vec)
{
// Requires: 1.) view_vec and eye_pos_vec are 3D vectors in the sphere's
// local coordinate frame (eye_pos_vec is a position, i.e.
// a vector from the origin to the eye/camera)
// 2.) geom_radius is a global containing the cylinder's radius
// Returns: Cast a ray of direction view_vec from eye_pos_vec at a
// cylinder of radius geom_radius, and return the distance to
// the first intersection in units of length(view_vec). The
// derivation of the coefficients is in Christer Ericson's
// Real-Time Collision Detection, p. 195-196, and this version
// uses LaGrange's identity to reduce operations.
// Arbitrary "cylinder top" reference point for an infinite cylinder:
const float3 cylinder_top_vec = float3(0.0, geom_radius, 0.0);
const float3 cylinder_axis_vec = float3(0.0, 1.0, 0.0);//float3(0.0, 2.0*geom_radius, 0.0);
const float3 top_to_eye_vec = eye_pos_vec - cylinder_top_vec;
const float3 axis_x_view = cross(cylinder_axis_vec, view_vec);
const float3 axis_x_top_to_eye = cross(cylinder_axis_vec, top_to_eye_vec);
// Quadratic formula coefficients (b_over_2 is guaranteed negative):
const float a = dot(axis_x_view, axis_x_view);
const float b_over_2 = dot(axis_x_top_to_eye, axis_x_view);
const float c = dot(axis_x_top_to_eye, axis_x_top_to_eye) -
geom_radius*geom_radius;//*dot(cylinder_axis_vec, cylinder_axis_vec);
return quadratic_solve(a, b_over_2, c);
}
float2 cylinder_xyz_to_uv(const float3 intersection_pos_local,
const float2 geom_aspect)
{
// Requires: An xyz intersection position on a cylinder.
// Returns: video_uv coords mapped to range [-0.5, 0.5]
// Mapping: Define square_uv.x to be the signed arc length in xz-space,
// and define square_uv.y = -intersection_pos_local.y (+v = -y).
// Start with a numerically robust arc length calculation.
const float angle_from_image_center = atan2(intersection_pos_local.x,
intersection_pos_local.z);
const float signed_arc_len = angle_from_image_center * geom_radius;
// Get a uv-mapping where [-0.5, 0.5] maps to a "square" area, then divide
// by the aspect ratio to stretch the mapping appropriately:
const float2 square_uv = float2(signed_arc_len, -intersection_pos_local.y);
const float2 video_uv = square_uv / geom_aspect;
return video_uv;
}
float3 cylinder_uv_to_xyz(const float2 video_uv, const float2 geom_aspect)
{
// Requires: video_uv coords mapped to range [-0.5, 0.5]
// Returns: An xyz intersection position on a cylinder. This is the
// inverse of cylinder_xyz_to_uv().
// Expand video_uv by the aspect ratio to get proportionate x/y lengths,
// then calculate an xyz position for the cylindrical mapping above.
const float2 square_uv = video_uv * geom_aspect;
const float arc_len = square_uv.x;
const float angle_from_image_center = arc_len / geom_radius;
const float x_pos = sin(angle_from_image_center) * geom_radius;
const float z_pos = cos(angle_from_image_center) * geom_radius;
// Or: z = sqrt(geom_radius**2 - x**2)
// Or: z = geom_radius/sqrt(1.0 + tan(angle)**2), x = z * tan(angle)
const float3 intersection_pos_local = float3(x_pos, -square_uv.y, z_pos);
return intersection_pos_local;
}
float2 sphere_xyz_to_uv(const float3 intersection_pos_local,
const float2 geom_aspect)
{
// Requires: An xyz intersection position on a sphere.
// Returns: video_uv coords mapped to range [-0.5, 0.5]
// Mapping: First define square_uv.x/square_uv.y ==
// intersection_pos_local.x/intersection_pos_local.y. Then,
// length(square_uv) is the arc length from the image center
// at (0.0, 0.0, geom_radius) along the tangent great circle.
// Credit for this mapping goes to cgwg: I never managed to
// understand his code, but he told me his mapping was based on
// great circle distances when I asked him about it, which
// informed this very similar (almost identical) mapping.
// Start with a numerically robust arc length calculation between the ray-
// sphere intersection point and the image center using a method posted by
// Roger Stafford on comp.soft-sys.matlab:
// https://groups.google.com/d/msg/comp.soft-sys.matlab/zNbUui3bjcA/c0HV_bHSx9cJ
const float3 image_center_pos_local = float3(0.0, 0.0, geom_radius);
const float cp_len =
length(cross(intersection_pos_local, image_center_pos_local));
const float dp = dot(intersection_pos_local, image_center_pos_local);
const float angle_from_image_center = atan2(cp_len, dp);
const float arc_len = angle_from_image_center * geom_radius;
// Get a uv-mapping where [-0.5, 0.5] maps to a "square" area, then divide
// by the aspect ratio to stretch the mapping appropriately:
const float2 square_uv_unit = normalize(float2(intersection_pos_local.x,
-intersection_pos_local.y));
const float2 square_uv = arc_len * square_uv_unit;
const float2 video_uv = square_uv / geom_aspect;
return video_uv;
}
float3 sphere_uv_to_xyz(const float2 video_uv, const float2 geom_aspect)
{
// Requires: video_uv coords mapped to range [-0.5, 0.5]
// Returns: An xyz intersection position on a sphere. This is the
// inverse of sphere_xyz_to_uv().
// Expand video_uv by the aspect ratio to get proportionate x/y lengths,
// then calculate an xyz position for the spherical mapping above.
if (video_uv.x != 0 && video_uv.y != 0) {
const float2 square_uv = video_uv * geom_aspect;
// Using length or sqrt here butchers the framerate on my 8800GTS if
// this function is called too many times, and so does taking the max
// component of square_uv/square_uv_unit (program length threshold?).
//float arc_len = length(square_uv);
const float2 square_uv_unit = normalize(square_uv);
const float arc_len = square_uv.y/square_uv_unit.y;
const float angle_from_image_center = arc_len / geom_radius;
const float xy_dist_from_sphere_center =
sin(angle_from_image_center) * geom_radius;
//float2 xy_pos = xy_dist_from_sphere_center * (square_uv/FIX_ZERO(arc_len));
const float2 xy_pos = xy_dist_from_sphere_center * square_uv_unit;
const float z_pos = cos(angle_from_image_center) * geom_radius;
const float3 intersection_pos_local = float3(xy_pos.x, -xy_pos.y, z_pos);
return intersection_pos_local;
}
else if (video_uv.x != 0) {
const float2 square_uv = video_uv * geom_aspect;
// Using length or sqrt here butchers the framerate on my 8800GTS if
// this function is called too many times, and so does taking the max
// component of square_uv/square_uv_unit (program length threshold?).
//float arc_len = length(square_uv);
const float2 square_uv_unit = normalize(square_uv);
const float angle_from_image_center = 0;
const float xy_dist_from_sphere_center = sin(angle_from_image_center) * geom_radius;
const float2 xy_pos = xy_dist_from_sphere_center * square_uv_unit;
const float z_pos = cos(angle_from_image_center) * geom_radius;
const float3 intersection_pos_local = float3(xy_pos.x, -xy_pos.y, z_pos);
return intersection_pos_local;
}
else {
const float2 xy_pos = float2(0, 0);
const float z_pos = geom_radius;
const float3 intersection_pos_local = float3(xy_pos.x, -xy_pos.y, z_pos);
return intersection_pos_local;
}
}
float2 sphere_alt_xyz_to_uv(const float3 intersection_pos_local,
const float2 geom_aspect)
{
// Requires: An xyz intersection position on a cylinder.
// Returns: video_uv coords mapped to range [-0.5, 0.5]
// Mapping: Define square_uv.x to be the signed arc length in xz-space,
// and define square_uv.y == signed arc length in yz-space.
// See cylinder_xyz_to_uv() for implementation details (very similar).
const float2 angle_from_image_center = atan2(
float2(intersection_pos_local.x, -intersection_pos_local.y),
intersection_pos_local.zz);
const float2 signed_arc_len = angle_from_image_center * geom_radius;
const float2 video_uv = signed_arc_len / geom_aspect;
return video_uv;
}
float3 sphere_alt_uv_to_xyz(const float2 video_uv, const float2 geom_aspect)
{
// Requires: video_uv coords mapped to range [-0.5, 0.5]
// Returns: An xyz intersection position on a sphere. This is the
// inverse of sphere_alt_xyz_to_uv().
// See cylinder_uv_to_xyz() for implementation details (very similar).
const float2 square_uv = video_uv * geom_aspect;
const float2 arc_len = square_uv;
const float2 angle_from_image_center = arc_len / geom_radius;
const float2 xy_pos = sin(angle_from_image_center) * geom_radius;
const float z_pos = sqrt(geom_radius*geom_radius - dot(xy_pos, xy_pos));
return float3(xy_pos.x, -xy_pos.y, z_pos);
}
float2 intersect(const float3 view_vec_local, const float3 eye_pos_local,
const float geom_mode)
{
return geom_mode < 2.5 ? intersect_sphere(view_vec_local, eye_pos_local) :
intersect_cylinder(view_vec_local, eye_pos_local);
}
float2 xyz_to_uv(const float3 intersection_pos_local,
const float2 geom_aspect, const float geom_mode)
{
return geom_mode < 1.5 ?
sphere_xyz_to_uv(intersection_pos_local, geom_aspect) :
geom_mode < 2.5 ?
sphere_alt_xyz_to_uv(intersection_pos_local, geom_aspect) :
cylinder_xyz_to_uv(intersection_pos_local, geom_aspect);
}
float3 uv_to_xyz(const float2 uv, const float2 geom_aspect,
const float geom_mode)
{
return geom_mode < 1.5 ? sphere_uv_to_xyz(uv, geom_aspect) :
geom_mode < 2.5 ? sphere_alt_uv_to_xyz(uv, geom_aspect) :
cylinder_uv_to_xyz(uv, geom_aspect);
}
float2 view_vec_to_uv(const float3 view_vec_local, const float3 eye_pos_local,
const float2 geom_aspect, const float geom_mode, out float3 intersection_pos)
{
// Get the intersection point on the primitive, given an eye position
// and view vector already in its local coordinate frame:
const float2 intersect_dist_and_discriminant = intersect(view_vec_local,
eye_pos_local, geom_mode);
const float3 intersection_pos_local = eye_pos_local +
view_vec_local * intersect_dist_and_discriminant.x;
// Save the intersection position to an output parameter:
intersection_pos = intersection_pos_local;
// Transform into uv coords, but give out-of-range coords if the
// view ray doesn't intersect the primitive in the first place:
return intersect_dist_and_discriminant.y > 0.005 ?
xyz_to_uv(intersection_pos_local, geom_aspect, geom_mode) : float2(1.0, 1.0);
}
float3 get_ideal_global_eye_pos_for_points(float3 eye_pos,
const float2 geom_aspect, const float3 global_coords[MAX_POINT_CLOUD_SIZE],
const int num_points)
{
// Requires: Parameters:
// 1.) Starting eye_pos is a global 3D position at which the
// camera contains all points in global_coords[] in its FOV
// 2.) geom_aspect = get_aspect_vector(
// IN.output_size.x / IN.output_size.y);
// 3.) global_coords is a point cloud containing global xyz
// coords of extreme points on the simulated CRT screen.
// Globals:
// 1.) geom_view_dist must be > 0.0. It controls the "near
// plane" used to interpret flat_video_uv as a view
// vector, which controls the field of view (FOV).
// Eyespace coordinate frame: +x = right, +y = up, +z = back
// Returns: Return an eye position at which the point cloud spans as
// much of the screen as possible (given the FOV controlled by
// geom_view_dist) without being cropped or sheared.
// Algorithm:
// 1.) Move the eye laterally to a point which attempts to maximize the
// the amount we can move forward without clipping the CRT screen.
// 2.) Move forward by as much as possible without clipping the CRT.
// Get the allowed movement range by solving for the eye_pos offsets
// that result in each point being projected to a screen edge/corner in
// pseudo-normalized device coords (where xy ranges from [-0.5, 0.5]
// and z = eyespace z):
// pndc_coord = float3(float2(eyespace_xyz.x, -eyespace_xyz.y)*
// geom_view_dist / (geom_aspect * -eyespace_xyz.z), eyespace_xyz.z);
// Notes:
// The field of view is controlled by geom_view_dist's magnitude relative to
// the view vector's x and y components:
// view_vec.xy ranges from [-0.5, 0.5] * geom_aspect
// view_vec.z = -geom_view_dist
// But for the purposes of perspective divide, it should be considered:
// view_vec.xy ranges from [-0.5, 0.5] * geom_aspect / geom_view_dist
// view_vec.z = -1.0
static const int max_centering_iters = 1; // Keep for easy testing.
for(int iter = 0; iter < max_centering_iters; iter++)
{
// 0.) Get the eyespace coordinates of our point cloud:
float3 eyespace_coords[MAX_POINT_CLOUD_SIZE];
for(int i = 0; i < num_points; i++)
{
eyespace_coords[i] = global_coords[i] - eye_pos;
}
// 1a.)For each point, find out how far we can move eye_pos in each
// lateral direction without the point clipping the frustum.
// Eyespace +y = up, screenspace +y = down, so flip y after
// applying the eyespace offset (on the way to "clip space").
// Solve for two offsets per point based on:
// (eyespace_xyz.xy - offset_dr) * float2(1.0, -1.0) *
// geom_view_dist / (geom_aspect * -eyespace_xyz.z) = float2(-0.5)
// (eyespace_xyz.xy - offset_dr) * float2(1.0, -1.0) *
// geom_view_dist / (geom_aspect * -eyespace_xyz.z) = float2(0.5)
// offset_ul and offset_dr represent the farthest we can move the
// eye_pos up-left and down-right. Save the min of all offset_dr's
// and the max of all offset_ul's (since it's negative).
float abs_radius = abs(geom_radius); // In case anyone gets ideas. ;)
float2 offset_dr_min = float2(10.0 * abs_radius, 10.0 * abs_radius);
float2 offset_ul_max = float2(-10.0 * abs_radius, -10.0 * abs_radius);
for(int i = 0; i < num_points; i++)
{
static const float2 flipy = float2(1.0, -1.0);
float3 eyespace_xyz = eyespace_coords[i];
float2 offset_dr = eyespace_xyz.xy - float2(-0.5, -0.5) *
(geom_aspect * -eyespace_xyz.z) / (geom_view_dist * flipy);
float2 offset_ul = eyespace_xyz.xy - float2(0.5, 0.5) *
(geom_aspect * -eyespace_xyz.z) / (geom_view_dist * flipy);
offset_dr_min = min(offset_dr_min, offset_dr);
offset_ul_max = max(offset_ul_max, offset_ul);
}
// 1b.)Update eye_pos: Adding the average of offset_ul_max and
// offset_dr_min gives it equal leeway on the top vs. bottom
// and left vs. right. Recalculate eyespace_coords accordingly.
float2 center_offset = 0.5 * (offset_ul_max + offset_dr_min);
eye_pos.xy += center_offset;
for(int i = 0; i < num_points; i++)
{
eyespace_coords[i] = global_coords[i] - eye_pos;
}
// 2a.)For each point, find out how far we can move eye_pos forward
// without the point clipping the frustum. Flip the y
// direction in advance (matters for a later step, not here).
// Solve for four offsets per point based on:
// eyespace_xyz_flipy.x * geom_view_dist /
// (geom_aspect.x * (offset_z - eyespace_xyz_flipy.z)) =-0.5
// eyespace_xyz_flipy.y * geom_view_dist /
// (geom_aspect.y * (offset_z - eyespace_xyz_flipy.z)) =-0.5
// eyespace_xyz_flipy.x * geom_view_dist /
// (geom_aspect.x * (offset_z - eyespace_xyz_flipy.z)) = 0.5
// eyespace_xyz_flipy.y * geom_view_dist /
// (geom_aspect.y * (offset_z - eyespace_xyz_flipy.z)) = 0.5
// We'll vectorize the actual computation. Take the maximum of
// these four for a single offset, and continue taking the max
// for every point (use max because offset.z is negative).
float offset_z_max = -10.0 * geom_radius * geom_view_dist;
for(int i = 0; i < num_points; i++)
{
float3 eyespace_xyz_flipy = eyespace_coords[i] *
float3(1.0, -1.0, 1.0);
float4 offset_zzzz = eyespace_xyz_flipy.zzzz +
(eyespace_xyz_flipy.xyxy * geom_view_dist) /
(float4(-0.5, -0.5, 0.5, 0.5) * float4(geom_aspect, geom_aspect));
// Ignore offsets that push positive x/y values to opposite
// boundaries, and vice versa, and don't let the camera move
// past a point in the dead center of the screen:
offset_z_max = (eyespace_xyz_flipy.x < 0.0) ?
max(offset_z_max, offset_zzzz.x) : offset_z_max;
offset_z_max = (eyespace_xyz_flipy.y < 0.0) ?
max(offset_z_max, offset_zzzz.y) : offset_z_max;
offset_z_max = (eyespace_xyz_flipy.x > 0.0) ?
max(offset_z_max, offset_zzzz.z) : offset_z_max;
offset_z_max = (eyespace_xyz_flipy.y > 0.0) ?
max(offset_z_max, offset_zzzz.w) : offset_z_max;
offset_z_max = max(offset_z_max, eyespace_xyz_flipy.z);
}
// 2b.)Update eye_pos: Add the maximum (smallest negative) z offset.
eye_pos.z += offset_z_max;
}
return eye_pos;
}
float3 get_ideal_global_eye_pos(const float3x3 local_to_global,
const float2 geom_aspect, const float geom_mode)
{
// Start with an initial eye_pos that includes the entire primitive
// (sphere or cylinder) in its field-of-view:
const float3 high_view = float3(0.0, geom_aspect.y, -geom_view_dist);
const float3 low_view = high_view * float3(1.0, -1.0, 1.0);
const float len_sq = dot(high_view, high_view);
const float fov = abs(acos(dot(high_view, low_view)/len_sq));
// Trigonometry/similar triangles say distance = geom_radius/sin(fov/2):
const float eye_z_spherical = geom_radius/sin(fov*0.5);
const float3 eye_pos = geom_mode < 2.5 ?
float3(0.0, 0.0, eye_z_spherical) :
float3(0.0, 0.0, max(geom_view_dist, eye_z_spherical));
// Get global xyz coords of extreme sample points on the simulated CRT
// screen. Start with the center, edge centers, and corners of the
// video image. We can't ignore backfacing points: They're occluded
// by closer points on the primitive, but they may NOT be occluded by
// the convex hull of the remaining samples (i.e. the remaining convex
// hull might not envelope points that do occlude a back-facing point.)
static const int num_points = MAX_POINT_CLOUD_SIZE;
float3 global_coords[MAX_POINT_CLOUD_SIZE];
global_coords[0] = mul(local_to_global, uv_to_xyz(float2(0.0, 0.0), geom_aspect, geom_mode));
global_coords[1] = mul(local_to_global, uv_to_xyz(float2(0.0, -0.5), geom_aspect, geom_mode));
global_coords[2] = mul(local_to_global, uv_to_xyz(float2(0.0, 0.5), geom_aspect, geom_mode));
global_coords[3] = mul(local_to_global, uv_to_xyz(float2(-0.5, 0.0), geom_aspect, geom_mode));
global_coords[4] = mul(local_to_global, uv_to_xyz(float2(0.5, 0.0), geom_aspect, geom_mode));
global_coords[5] = mul(local_to_global, uv_to_xyz(float2(-0.5, -0.5), geom_aspect, geom_mode));
global_coords[6] = mul(local_to_global, uv_to_xyz(float2(0.5, -0.5), geom_aspect, geom_mode));
global_coords[7] = mul(local_to_global, uv_to_xyz(float2(-0.5, 0.5), geom_aspect, geom_mode));
global_coords[8] = mul(local_to_global, uv_to_xyz(float2(0.5, 0.5), geom_aspect, geom_mode));
// Adding more inner image points could help in extreme cases, but too many
// points will kille the framerate. For safety, default to the initial
// eye_pos if any z coords are negative:
float num_negative_z_coords = 0.0;
for(int i = 0; i < num_points; i++)
{
num_negative_z_coords += float(global_coords[0].z < 0.0);
}
// Outsource the optimized eye_pos calculation:
return num_negative_z_coords > 0.5 ? eye_pos :
get_ideal_global_eye_pos_for_points(eye_pos, geom_aspect,
global_coords, num_points);
}
float3x3 get_pixel_to_object_matrix(const float3x3 global_to_local,
const float3 eye_pos_local, const float3 view_vec_global,
const float3 intersection_pos_local, const float3 normal,
const float2 output_size_inv)
{
// Requires: See get_curved_video_uv_coords_and_tangent_matrix for
// descriptions of each parameter.
// Returns: Return a transformation matrix from 2D pixel-space vectors
// (where (+1.0, +1.0) is a vector to one pixel down-right,
// i.e. same directionality as uv texels) to 3D object-space
// vectors in the CRT's local coordinate frame (right-handed)
// ***which are tangent to the CRT surface at the intersection
// position.*** (Basically, we want to convert pixel-space
// vectors to 3D vectors along the CRT's surface, for later
// conversion to uv vectors.)
// Shorthand inputs:
const float3 pos = intersection_pos_local;
const float3 eye_pos = eye_pos_local;
// Get a piecewise-linear matrix transforming from "pixelspace" offset
// vectors (1.0 = one pixel) to object space vectors in the tangent
// plane (faster than finding 3 view-object intersections).
// 1.) Get the local view vecs for the pixels to the right and down:
const float3 view_vec_right_global = view_vec_global +
float3(output_size_inv.x, 0.0, 0.0);
const float3 view_vec_down_global = view_vec_global +
float3(0.0, -output_size_inv.y, 0.0);
const float3 view_vec_right_local =
mul(global_to_local, view_vec_right_global);
const float3 view_vec_down_local =
mul(global_to_local, view_vec_down_global);
// 2.) Using the true intersection point, intersect the neighboring
// view vectors with the tangent plane:
const float3 intersection_vec_dot_normal = float3(dot(pos - eye_pos, normal), dot(pos - eye_pos, normal), dot(pos - eye_pos, normal));
const float3 right_pos = eye_pos + (intersection_vec_dot_normal /
dot(view_vec_right_local, normal))*view_vec_right_local;
const float3 down_pos = eye_pos + (intersection_vec_dot_normal /
dot(view_vec_down_local, normal))*view_vec_down_local;
// 3.) Subtract the original intersection pos from its neighbors; the
// resulting vectors are object-space vectors tangent to the plane.
// These vectors are the object-space transformations of (1.0, 0.0)
// and (0.0, 1.0) pixel offsets, so they form the first two basis
// vectors of a pixelspace to object space transformation. This
// transformation is 2D to 3D, so use (0, 0, 0) for the third vector.
const float3 object_right_vec = right_pos - pos;
const float3 object_down_vec = down_pos - pos;
const float3x3 pixel_to_object = float3x3(
object_right_vec.x, object_down_vec.x, 0.0,
object_right_vec.y, object_down_vec.y, 0.0,
object_right_vec.z, object_down_vec.z, 0.0);
return pixel_to_object;
}
float3x3 get_object_to_tangent_matrix(const float3 intersection_pos_local,
const float3 normal, const float2 geom_aspect, const float geom_mode)
{
// Requires: See get_curved_video_uv_coords_and_tangent_matrix for
// descriptions of each parameter.
// Returns: Return a transformation matrix from 3D object-space vectors
// in the CRT's local coordinate frame (right-handed, +y = up)
// to 2D video_uv vectors (+v = down).
// Description:
// The TBN matrix formed by the [tangent, bitangent, normal] basis
// vectors transforms ordinary vectors from tangent->object space.
// The cotangent matrix formed by the [cotangent, cobitangent, normal]
// basis vectors transforms normal vectors (covectors) from
// tangent->object space. It's the inverse-transpose of the TBN matrix.
// We want the inverse of the TBN matrix (transpose of the cotangent
// matrix), which transforms ordinary vectors from object->tangent space.
// Start by calculating the relevant basis vectors in accordance with
// Christian Schüler's blog post "Followup: Normal Mapping Without
// Precomputed Tangents": http://www.thetenthplanet.de/archives/1180
// With our particular uv mapping, the scale of the u and v directions
// is determined entirely by the aspect ratio for cylindrical and ordinary
// spherical mappings, and so tangent and bitangent lengths are also
// determined by it (the alternate mapping is more complex). Therefore, we
// must ensure appropriate cotangent and cobitangent lengths as well.
// Base these off the uv<=>xyz mappings for each primitive.
const float3 pos = intersection_pos_local;
static const float3 x_vec = float3(1.0, 0.0, 0.0);
static const float3 y_vec = float3(0.0, 1.0, 0.0);
// The tangent and bitangent vectors correspond with increasing u and v,
// respectively. Mathematically we'd base the cotangent/cobitangent on
// those, but we'll compute the cotangent/cobitangent directly when we can.
float3 cotangent_unscaled, cobitangent_unscaled;
// geom_mode should be constant-folded without _RUNTIME_GEOMETRY_MODE.
if(geom_mode < 1.5)
{
// Sphere:
// tangent = normalize(cross(normal, cross(x_vec, pos))) * geom_aspect.x
// bitangent = normalize(cross(cross(y_vec, pos), normal)) * geom_aspect.y
// inv_determinant = 1.0/length(cross(bitangent, tangent))
// cotangent = cross(normal, bitangent) * inv_determinant
// == normalize(cross(y_vec, pos)) * geom_aspect.y * inv_determinant
// cobitangent = cross(tangent, normal) * inv_determinant
// == normalize(cross(x_vec, pos)) * geom_aspect.x * inv_determinant
// Simplified (scale by inv_determinant below):
cotangent_unscaled = normalize(cross(y_vec, pos)) * geom_aspect.y;
cobitangent_unscaled = normalize(cross(x_vec, pos)) * geom_aspect.x;
}
else if(geom_mode < 2.5)
{
// Sphere, alternate mapping:
// This mapping works a bit like the cylindrical mapping in two
// directions, which makes the lengths and directions more complex.
// Unfortunately, I can't find much of a shortcut:
const float3 tangent = normalize(
cross(y_vec, float3(pos.x, 0.0, pos.z))) * geom_aspect.x;
const float3 bitangent = normalize(
cross(x_vec, float3(0.0, pos.yz))) * geom_aspect.y;
cotangent_unscaled = cross(normal, bitangent);
cobitangent_unscaled = cross(tangent, normal);
}
else
{
// Cylinder:
// tangent = normalize(cross(y_vec, normal)) * geom_aspect.x;
// bitangent = float3(0.0, -geom_aspect.y, 0.0);
// inv_determinant = 1.0/length(cross(bitangent, tangent))
// cotangent = cross(normal, bitangent) * inv_determinant
// == normalize(cross(y_vec, pos)) * geom_aspect.y * inv_determinant
// cobitangent = cross(tangent, normal) * inv_determinant
// == float3(0.0, -geom_aspect.x, 0.0) * inv_determinant
cotangent_unscaled = cross(y_vec, normal) * geom_aspect.y;
cobitangent_unscaled = float3(0.0, -geom_aspect.x, 0.0);
}
const float3 computed_normal =
cross(cobitangent_unscaled, cotangent_unscaled);
const float inv_determinant = rsqrt(dot(computed_normal, computed_normal));
const float3 cotangent = cotangent_unscaled * inv_determinant;
const float3 cobitangent = cobitangent_unscaled * inv_determinant;
// The [cotangent, cobitangent, normal] column vecs form the cotangent
// frame, i.e. the inverse-transpose TBN matrix. Get its transpose:
const float3x3 object_to_tangent = float3x3(cotangent, cobitangent, normal);
return object_to_tangent;
}
float2 get_curved_video_uv_coords_and_tangent_matrix(
const float2 flat_video_uv, const float3 eye_pos_local,
const float2 output_size_inv, const float2 geom_aspect,
const float geom_mode, const float3x3 global_to_local,
out float2x2 pixel_to_tangent_video_uv)
{
// Requires: Parameters:
// 1.) flat_video_uv coords are in range [0.0, 1.0], where
// (0.0, 0.0) is the top-left corner of the screen and
// (1.0, 1.0) is the bottom-right corner.
// 2.) eye_pos_local is the 3D camera position in the simulated
// CRT's local coordinate frame. For best results, it must
// be computed based on the same geom_view_dist used here.
// 3.) output_size_inv = float2(1.0)/IN.output_size
// 4.) geom_aspect = get_aspect_vector(
// IN.output_size.x / IN.output_size.y);
// 5.) geom_mode is a static or runtime mode setting:
// 0 = off, 1 = sphere, 2 = sphere alt., 3 = cylinder
// 6.) global_to_local is a 3x3 matrix transforming (ordinary)
// worldspace vectors to the CRT's local coordinate frame
// Globals:
// 1.) geom_view_dist must be > 0.0. It controls the "near
// plane" used to interpret flat_video_uv as a view
// vector, which controls the field of view (FOV).
// Returns: Return final uv coords in [0.0, 1.0], and return a pixel-
// space to video_uv tangent-space matrix in the out parameter.
// (This matrix assumes pixel-space +y = down, like +v = down.)
// We'll transform flat_video_uv into a view vector, project
// the view vector from the camera/eye, intersect with a sphere
// or cylinder representing the simulated CRT, and convert the
// intersection position into final uv coords and a local
// transformation matrix.
// First get the 3D view vector (geom_aspect and geom_view_dist are globals):
// 1.) Center uv around (0.0, 0.0) and make (-0.5, -0.5) and (0.5, 0.5)
// correspond to the top-left/bottom-right output screen corners.
// 2.) Multiply by geom_aspect to preemptively "undo" Retroarch's screen-
// space 2D aspect correction. We'll reapply it in uv-space.
// 3.) (x, y) = (u, -v), because +v is down in 2D screenspace, but +y
// is up in 3D worldspace (enforce a right-handed system).
// 4.) The view vector z controls the "near plane" distance and FOV.
// For the effect of "looking through a window" at a CRT, it should be
// set equal to the user's distance from their physical screen, in
// units of the viewport's physical diagonal size.
const float2 view_uv = (flat_video_uv - float2(0.5, 0.5)) * geom_aspect;
const float3 view_vec_global =
float3(view_uv.x, -view_uv.y, -geom_view_dist);
// Transform the view vector into the CRT's local coordinate frame, convert
// to video_uv coords, and get the local 3D intersection position:
const float3 view_vec_local = mul(global_to_local, view_vec_global);
float3 pos;
const float2 centered_uv = view_vec_to_uv(
view_vec_local, eye_pos_local, geom_aspect, geom_mode, pos);
const float2 video_uv = centered_uv + float2(0.5, 0.5);
// Get a pixel-to-tangent-video-uv matrix. The caller could deal with
// all but one of these cases, but that would be more complicated.
#if _DRIVERS_ALLOW_DERIVATIVES
// Derivatives obtain a matrix very fast, but the direction of pixel-
// space +y seems to depend on the pass. Enforce the correct direction
// on a best-effort basis (but it shouldn't matter for antialiasing).
const float2 duv_dx = ddx(video_uv);
const float2 duv_dy = ddy(video_uv);
#ifdef LAST_PASS
pixel_to_tangent_video_uv = float2x2(
duv_dx.x, duv_dy.x,
-duv_dx.y, -duv_dy.y);
#else
pixel_to_tangent_video_uv = float2x2(
duv_dx.x, duv_dy.x,
duv_dx.y, duv_dy.y);
#endif
#else
// Manually define a transformation matrix. We'll assume pixel-space
// +y = down, just like +v = down.
if(geom_force_correct_tangent_matrix)
{
// Get the surface normal based on the local intersection position:
const float3 normal_base = geom_mode < 2.5 ? pos :
float3(pos.x, 0.0, pos.z);
const float3 normal = normalize(normal_base);
// Get pixel-to-object and object-to-tangent matrices and combine
// them into a 2x2 pixel-to-tangent matrix for video_uv offsets:
const float3x3 pixel_to_object = get_pixel_to_object_matrix(
global_to_local, eye_pos_local, view_vec_global, pos, normal,
output_size_inv);
const float3x3 object_to_tangent = get_object_to_tangent_matrix(
pos, normal, geom_aspect, geom_mode);
const float3x3 pixel_to_tangent3x3 =
mul(object_to_tangent, pixel_to_object);
pixel_to_tangent_video_uv = float2x2(
pixel_to_tangent3x3[0][0], pixel_to_tangent3x3[0][1], pixel_to_tangent3x3[1][0], pixel_to_tangent3x3[1][1]);//._m00_m01_m10_m11);
}
else
{
// Ignore curvature, and just consider flat scaling. The
// difference is only apparent with strong curvature:
pixel_to_tangent_video_uv = float2x2(
output_size_inv.x, 0.0, 0.0, output_size_inv.y);
}
#endif
return video_uv;
}
float get_border_dim_factor(const float2 video_uv, const float2 geom_aspect)
{
// COPYRIGHT NOTE FOR THIS FUNCTION:
// Copyright (C) 2010-2012 cgwg, 2014 TroggleMonkey
// This function uses an algorithm first coded in several of cgwg's GPL-
// licensed lines in crt-geom-curved.cg and its ancestors. The line
// between algorithm and code is nearly indistinguishable here, so it's
// unclear whether I could even release this project under a non-GPL
// license with this function included.
// Calculate border_dim_factor from the proximity to uv-space image
// borders; geom_aspect/border_size/border/darkness/border_compress are globals:
const float2 edge_dists = min(video_uv, float2(1.0, 1.0) - video_uv) *
geom_aspect;
const float2 border_penetration =
max(float2(border_size, border_size) - edge_dists, float2(0.0, 0.0));
const float penetration_ratio = border_size > 0 ? length(border_penetration)/border_size : 0;
const float border_escape_ratio = max(1.0 - penetration_ratio, 0.0);
const float border_dim_factor =
pow(border_escape_ratio, border_darkness) * max(1.0, border_compress);
return min(border_dim_factor, 1.0);
}
#endif // _GEOMETRY_FUNCTIONS_H

76
data/resources/shaders/reshade/Shaders/crt-royale/lib/helper-functions-and-macros.fxh Normal file
View File

@ -0,0 +1,76 @@
#ifndef _HELPER_FUNCTIONS_AND_MACROS_H
#define _HELPER_FUNCTIONS_AND_MACROS_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2020 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
float4 tex2D_nograd(sampler2D tex, float2 tex_coords)
{
return tex2Dlod(tex, float4(tex_coords, 0, 0), 0.0);
}
// ReShade 4 does not permit the use of functions or the ternary operator
// outside of a function definition. This is a problem for this port
// because the original crt-royale shader makes heavy use of these
// constructs at the root level.
// These preprocessor definitions are a workaround for this limitation.
// Note that they are strictly intended for defining complex global
// constants. I doubt they're more performant than the built-in
// equivalents, so I recommend using the built-ins whenever you can.
#define macro_sign(c) -((int) ((c) != 0)) * -((int) ((c) > 0))
#define macro_abs(c) (c) * macro_sign(c)
#define macro_min(c, d) (c) * ((int) ((c) <= (d))) + (d) * ((int) ((c) > (d)))
#define macro_max(c, d) (c) * ((int) ((c) >= (d))) + (d) * ((int) ((c) < (d)))
#define macro_clamp(c, l, u) macro_min(macro_max(c, l), u)
#define macro_ceil(c) (float) ((int) (c) + (int) (((int) (c)) < (c)))
#define macro_cond(c, a, b) float(c) * (a) + float(!(c)) * (b)
//////////////////////// COMMON MATHEMATICAL CONSTANTS ///////////////////////
static const float pi = 3.141592653589;
// We often want to find the location of the previous texel, e.g.:
// const float2 curr_texel = uv * texture_size;
// const float2 prev_texel = floor(curr_texel - float2(0.5)) + float2(0.5);
// const float2 prev_texel_uv = prev_texel / texture_size;
// However, many GPU drivers round incorrectly around exact texel locations.
// We need to subtract a little less than 0.5 before flooring, and some GPU's
// require this value to be farther from 0.5 than others; define it here.
// const float2 prev_texel =
// floor(curr_texel - float2(under_half)) + float2(0.5);
static const float under_half = 0.4995;
// Avoid dividing by zero; using a macro overloads for float, float2, etc.:
#define FIX_ZERO(c) (macro_max(macro_abs(c), 0.0000152587890625)) // 2^-16
// #define fmod(x, y) ((x) - (y) * floor((x)/(y) + FIX_ZERO(0.0)))
#define fmod(x, y) (frac((x) / (y)) * (y))
#endif // _HELPER_FUNCTIONS_AND_MACROS_H

624
data/resources/shaders/reshade/Shaders/crt-royale/lib/phosphor-mask-calculations.fxh Normal file
View File

@ -0,0 +1,624 @@
#ifndef _PHOSHOR_MASK_CALCULATIONS_H
#define _PHOSHOR_MASK_CALCULATIONS_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2020 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
/*
* Our goal is to use arithmetic to generate the phosphor mask.
* Phosphor masks are regular patterns, so we want something periodic.
* We need to avoid integer arithmetic because it tends to cause rounding errors.
*
* For all masks, we want to approximate a pulse wave in at least one dimension. This pulse wave
* will have narrow peaks, wide troughs, and constant periodicity.
* GRILLE will have a pulse wave along the x-axis and will be constant along the y-axis.
* SLOT and SHADOW will likely have a superposition of two out-of-phase pulse waves along each axis.
* For SHADOW, the width of the peaks will vary such that they generate ellipsoids on the screen.
*
* We can get a periodic function by starting with a triangle wave: T(t, f) = abs(1 - 2*frac(t * f)).
* This function gives us a triangle wave with f cycles in the domain [0, 1].
* Note that T(0, f) = 1.
*
* Then we can compose this with a sigmoid curve to squish the triangle wave into a pulse wave.
* P(s, p, q) = exp(q s - q/2) / (exp(q s - q/2) + exp(-p))
* s(t, f, o) = T(t*f - o, 1)
*
* f is the number of pulses to render along the given axis.
* o is the channel's horizontal ofset along the given axis, normalized via the quotient raw_offset / raw_triad width.
* p and q control how closely P resembles an ideal pulse wave and also how wide the peaks and troughs are.
*
* The interaction between p and q is rather complicated and difficult to describe, so they're not a good pair
* of parameters for users. But we have the info necessary to solve for p in terms of q.
* We know the width of a phosphor and the width of a triad, and we know the domain and range of P.
* We can choose a coordinate (t0, y0) that will denote the edge of the phosphor.
* Note that y0 = P(t0, p, q) for some p and q.
* We let t0 = raw_phosphor_width / raw_triad_width, since we need to respect the shape of the phosphor.
* We let the user define P(t0).
* Technically, this means the user is defining the brightness of the phosphor's furthest edge.
* Visually, this looks like the user is defining the width of the phosphor.
* We'll call this the Phosphor Thickness.
* We let the user define q.
* Technically, this means the user is defining the squareness of the pulse wave.
* Visually, this looks like the user is defining the sharpness of the phosphor.
* We'll call this the Phosphor Sharpness.
*
* We can solve for p in terms of q very efficiently.
* p = (ln(y0 / (1 - y0)) - q) / (0.5 - 2 t0)
*
* Note that, if you work through the algebra, you get a denominator of (t0 - 0.5).
* Using (0.5 - 2 t0) actually works better. It also matches up when you try plotting P and (t0, y0).
*
* For the GRILLE and SLOT masks, we can compute p once and recycle it.
* For the SHADOW mask, we can either compute p on each iteration or find a way to interpolate between min_p and max_p.
*
* One might expect it'd be way better to use a clamped triangle wave rather than a sigmoid or exponentiated cosine wave.
* As far as I can tell, this ends up being incorrect surprisingly enough. Although it's a good bit faster,
* it has terrible aliasing artifacts at small scales. The other implementations are slower, but they produce
* evenly-sized RGB phosphors for a variety of configurations even when the triad width is 3 pixels. At that
* scale, the triangle wave approach produces triads where one of the phosphors is thicker than the others.
* Taking into account the compute_mask_factor trick, the triangle wave approach would be a negligible
* performance improvement at the cost of a large drop in visual quality and user friendliness.
*/
#include "bind-shader-params.fxh"
#include "scanline-functions.fxh"
/*
* The GRILLE mask consists of an array of vertical stripes, so each channel will vary along the x-axis and will be constant
* along the y-axis.
*
* It has the following dimensions:
* Phosphors are 18 units wide with unbounded height.
* Phosphors in a triad are 2 units apart.
* Triads are 6 units apart.
* Triad centers are 64 units apart.
* The phosphors follow an RGB pattern.
* The left-most phosphor is red and offset by 3 units to the right.
*/
static const float grille_raw_phosphor_width = 18;
static const float grille_raw_phosphor_gap = 2;
static const float grille_raw_triad_horiz_gap = 6;
static const float grille_raw_triad_width = 3*grille_raw_phosphor_width + 2*grille_raw_phosphor_gap + grille_raw_triad_horiz_gap;
static const float grille_raw_r_offset = (grille_raw_triad_horiz_gap + grille_raw_phosphor_width) / 2;
static const float grille_raw_g_offset = grille_raw_r_offset + grille_raw_phosphor_width + grille_raw_phosphor_gap;
static const float grille_raw_b_offset = grille_raw_g_offset + grille_raw_phosphor_width + grille_raw_phosphor_gap;
static const float3 grille_norm_center_offsets = float3(
grille_raw_r_offset,
grille_raw_g_offset,
grille_raw_b_offset
) / grille_raw_triad_width;
static const float grille_edge_t = grille_raw_phosphor_width / 2;
static const float grille_edge_norm_t = grille_edge_t / grille_raw_triad_width;
/*
* The SLOT mask consists of an array of rectangles, so each channel will vary along both the x- and y-axes.
*
* It has the following dimensions:
* Phosphors are 18 units wide and 66 units tall.
* Phosphors in a triad are 2 units apart.
* Triads are 6 units apart horizontally and 6 units apart vertically.
* Triad centers are 64 units apart horizontally and 73 units apart vertically.
* The phosphors follow an RGB pattern.
* The upper-left-most phosphor is red and offset by 3 units to the right and 3 units down.
*/
static const float slot_raw_phosphor_width = 18;
static const float slot_raw_phosphor_gap = 2;
static const float slot_raw_triad_horiz_gap = 6;
static const float slot_raw_triad_width = 3*slot_raw_phosphor_width + 2*slot_raw_phosphor_gap + slot_raw_triad_horiz_gap;
static const float slot_raw_phosphor_height = 66;
static const float slot_raw_triad_vert_gap = 6;
static const float slot_raw_triad_height = slot_raw_phosphor_height + slot_raw_triad_vert_gap;
static const float slot_aspect_ratio = slot_raw_triad_height / slot_raw_triad_width;
static const float slot_raw_r_offset_x = (slot_raw_triad_horiz_gap + slot_raw_phosphor_width) / 2;
static const float slot_raw_g_offset_x = slot_raw_r_offset_x + slot_raw_phosphor_width + slot_raw_phosphor_gap;
static const float slot_raw_b_offset_x = slot_raw_g_offset_x + slot_raw_phosphor_width + slot_raw_phosphor_gap;
static const float3 slot_norm_center_offsets_x = float3(
slot_raw_r_offset_x,
slot_raw_g_offset_x,
slot_raw_b_offset_x
) / slot_raw_triad_width;
static const float3 slot_norm_center_offsets_y = float3(0.5, 0.5, 0.5);
static const float slot_edge_tx = slot_raw_phosphor_width / 2;
// We draw the slot mask as two sets of columns. To do that, we have to pretend the horizontal gap is the size of a whole triad.
// Then we need to halve the position of the phosphor edge.
static const float slot_edge_norm_tx = 0.5 * slot_edge_tx / slot_raw_triad_width;
static const float slot_edge_ty = slot_raw_phosphor_height / 2;
static const float slot_edge_norm_ty = slot_edge_ty / slot_raw_triad_height;
/*
* The SHADOW mask consists of an array of circles, so each channel will vary along both the x- and y-axes.
*
* It has the following dimensions:
* Phosphors are 21 units in diameter.
* All phosphors are 0 units apart.
* Triad centers are 63 units apart horizontally and 21 units apart vertically.
* The phosphors follow a GBR pattern on odd rows and RBG on even rows.
* The upper-left-most phosphor is green and centered on the corner of the screen.
*/
static const float shadow_raw_phosphor_diam = 21;
static const float shadow_raw_phosphor_gap = 0;
static const float shadow_raw_triad_horiz_gap = 0;
static const float shadow_raw_triad_vert_gap = 0;
static const float shadow_raw_triad_width = 3*shadow_raw_phosphor_diam + 2*shadow_raw_phosphor_gap + shadow_raw_triad_horiz_gap;
static const float shadow_raw_triad_height = shadow_raw_phosphor_diam + shadow_raw_triad_vert_gap;
static const float shadow_aspect_ratio = shadow_raw_triad_height / shadow_raw_triad_width;
static const float shadow_raw_g_offset_x = 0;
static const float shadow_raw_b_offset_x = shadow_raw_g_offset_x + shadow_raw_phosphor_diam + shadow_raw_phosphor_gap;
static const float shadow_raw_r_offset_x = shadow_raw_b_offset_x + shadow_raw_phosphor_diam + shadow_raw_phosphor_gap;
static const float3 shadow_norm_center_offsets_x = float3(
shadow_raw_r_offset_x,
shadow_raw_g_offset_x,
shadow_raw_b_offset_x
) / shadow_raw_triad_width;
static const float3 shadow_norm_center_offsets_y = float3(0.0, 0.0, 0.0);
static const float shadow_edge_tx = shadow_raw_phosphor_diam / 2;
static const float shadow_edge_norm_tx = shadow_edge_tx / shadow_raw_triad_width;
static const float shadow_edge_ty = shadow_raw_phosphor_diam / 2;
// We draw the shadow mask as two sets of rows. To do that, we have to pretend the vertical gap is the size of a whole triad.
// Then we need to halve the position of the phosphor edge.
static const float shadow_edge_norm_ty = 0.5 * shadow_edge_ty / shadow_raw_triad_height;
static const float shadow_norm_phosphor_rad = (shadow_raw_phosphor_diam/2) / shadow_raw_triad_width;
/*
* The SMALL GRILLE mask is composed of magenta and green stripes.
* Sourced from http://filthypants.blogspot.com/2020/02/crt-shader-masks.html
*
* It has the following dimensions:
* Stripes are 32 units wide.
* Stripes in a triad are 0 units apart.
* Triads are 0 units apart horizontally.
*
* Each triad has two quads, side-by-side and aligned.
* Neighboring triads are offset vertically.
* Below is an array of 2 triads.
* x's denote magenta stripes, and o's denote green ones.
*
* xxooxxoo
* xxooxxoo
* xxooxxoo
* xxooxxoo
* xxooxxoo
* xxooxxoo
*
* The phosphors follow a MG pattern.
* The left-most phosphor is magenta and offset by 16 units to the right.
*/
static const float smallgrille_raw_stripe_width = 32;
static const float smallgrille_raw_triad_width = 2*smallgrille_raw_stripe_width;
static const float smallgrille_raw_r_offset_x = 0.5 * smallgrille_raw_stripe_width;
static const float smallgrille_raw_g_offset_x = smallgrille_raw_r_offset_x + smallgrille_raw_stripe_width;
static const float smallgrille_raw_b_offset_x = smallgrille_raw_r_offset_x;
static const float3 smallgrille_norm_center_offsets_x = float3(
smallgrille_raw_r_offset_x,
smallgrille_raw_g_offset_x,
smallgrille_raw_b_offset_x
) / smallgrille_raw_triad_width;
static const float smallgrille_edge_t = 0.5 * smallgrille_raw_stripe_width;
static const float smallgrille_edge_norm_t = smallgrille_edge_t / smallgrille_raw_triad_width;
/*
* The SMALL SLOT mask is composed of magenta and green quads.
* Sourced from http://filthypants.blogspot.com/2020/02/crt-shader-masks.html
*
* It has the following dimensions:
* Quads are 32 units wide and 48 units tall.
* Quads in a triad are 0 units apart.
* Triads are 0 units apart horizontally and 16 units apart vertically.
*
* Each triad has two quads, side-by-side and aligned.
* Neighboring triads are offset vertically.
* Below is a 2x2 matrix of 4 triads.
* x's denote magenta quads, and o's denote green ones.
*
* xxoo
* xxooxxoo
* xxooxxoo
* xxoo
* xxoo
* xxooxxoo
* xxooxxoo
* xxoo
*
* The phosphors follow a MG pattern.
* The upper-left-most phosphor is magenta and offset by 16 units to the right and 16 units down.
*/
static const float smallslot_raw_quad_width = 32;
static const float smallslot_raw_triad_width = 2*smallslot_raw_quad_width;
static const float smallslot_raw_quad_height = 1.5 * smallslot_raw_quad_width;
static const float smallslot_raw_triad_vert_gap = 0.5 * smallslot_raw_quad_width;
static const float smallslot_raw_triad_height = smallslot_raw_quad_height + smallslot_raw_triad_vert_gap;
static const float smallslot_aspect_ratio = smallslot_raw_triad_height / smallslot_raw_triad_width;
static const float smallslot_raw_r_offset_x = 0.5 * smallslot_raw_quad_width;
static const float smallslot_raw_g_offset_x = smallslot_raw_r_offset_x + smallslot_raw_quad_width;
static const float smallslot_raw_b_offset_x = smallslot_raw_r_offset_x;
static const float3 smallslot_norm_center_offsets_x = float3(
smallslot_raw_r_offset_x,
smallslot_raw_g_offset_x,
smallslot_raw_b_offset_x
) / smallslot_raw_triad_width;
static const float3 smallslot_norm_center_offsets_y1 = 0.5 * smallslot_raw_quad_height / smallslot_raw_triad_height;
static const float3 smallslot_norm_center_offsets_y2 = smallslot_norm_center_offsets_y1 + smallslot_raw_triad_vert_gap / smallslot_raw_triad_height;
static const float smallslot_edge_tx = 0.5 * smallslot_raw_quad_width;
// We draw the slot mask as two sets of columns. To do that, we have to pretend the horizontal gap is the size of a whole triad.
// Then we need to halve the position of the phosphor edge.
static const float smallslot_edge_norm_tx = 0.5 * smallslot_edge_tx / smallslot_raw_triad_width;
static const float smallslot_edge_ty = smallslot_raw_quad_height / 2;
static const float smallslot_edge_norm_ty = smallslot_edge_ty / smallslot_raw_triad_height;
/*
* The SMALL SHADOW mask is composed of magenta and green quads.
* Sourced from http://filthypants.blogspot.com/2020/02/crt-shader-masks.html
*
* It has the following dimensions:
* Quads are 17 units wide and 17 units tall.
* Quads in a triad are 0 units apart.
* Triads are 0 units apart horizontally and 0 units apart vertically.
*
* Each triad has two quads, side-by-side and aligned.
* Neighboring triads are offset vertically.
* Below is a 2x2 matrix of 4 triads.
* x's denote magenta quads, and o's denote green ones.
*
* xxooxxoo
* xxooxxoo
* ooxxooxx
* ooxxooxx
*
* The phosphors follow a MG pattern.
* The upper-left-most phosphor is magenta and offset by 16 units to the right and 16 units down.
*/
static const float smallshadow_raw_quad_width = 17;
static const float smallshadow_raw_triad_width = 2 * smallshadow_raw_quad_width;
static const float smallshadow_raw_quad_height = 17;
static const float smallshadow_raw_triad_height = smallshadow_raw_quad_height;
static const float smallshadow_aspect_ratio = smallshadow_raw_triad_height / smallshadow_raw_triad_width;
static const float smallshadow_raw_r_offset_x = 0.5 * smallshadow_raw_quad_width;
static const float smallshadow_raw_g_offset_x = smallshadow_raw_r_offset_x + smallshadow_raw_quad_width;
static const float smallshadow_raw_b_offset_x = smallshadow_raw_r_offset_x;
static const float3 smallshadow_norm_center_offsets_x = float3(
smallshadow_raw_r_offset_x,
smallshadow_raw_g_offset_x,
smallshadow_raw_b_offset_x
) / smallshadow_raw_triad_width;
static const float3 smallshadow_norm_center_offsets_y = 0.5 * smallshadow_raw_triad_height;
static const float smallshadow_edge_tx = 0.5 * smallshadow_raw_quad_width;
static const float smallshadow_edge_norm_tx = smallshadow_edge_tx / smallshadow_raw_triad_width;
static const float smallshadow_edge_ty = 0.5 * smallshadow_raw_quad_height;
// We draw the shadow mask as two sets of rows. To do that, we have to pretend the vertical gap is the size of a whole triad.
// Then we need to halve the position of the phosphor edge.
static const float smallshadow_edge_norm_ty = 0.5 * smallshadow_edge_ty / smallshadow_raw_triad_height;
float get_selected_aspect_ratio() {
float aspect_ratio;
[flatten]
if (mask_type == 0 || mask_type == 3) {
aspect_ratio = scale_triad_height;
}
else if (mask_type == 1 || mask_type == 4) {
aspect_ratio = scale_triad_height * slot_aspect_ratio;
}
else {
aspect_ratio = scale_triad_height * shadow_aspect_ratio;
}
[flatten]
switch (mask_type) {
case 0:
aspect_ratio = scale_triad_height;
break;
case 1:
aspect_ratio = scale_triad_height * slot_aspect_ratio;
break;
case 2:
aspect_ratio = scale_triad_height * shadow_aspect_ratio;
break;
case 3:
aspect_ratio = scale_triad_height;
break;
case 4:
aspect_ratio = scale_triad_height * smallslot_aspect_ratio;
break;
default:
aspect_ratio = scale_triad_height * smallshadow_aspect_ratio;
break;
}
return aspect_ratio;
}
float2 calc_triad_size() {
const float aspect_ratio = get_selected_aspect_ratio();
[branch]
if (mask_size_param == 0) {
return float2(1, aspect_ratio) * mask_triad_width;
}
else {
float triad_width = content_size.x * rcp(mask_num_triads_across);
return float2(1, aspect_ratio) * triad_width;
}
}
float2 calc_phosphor_viewport_frequency_factor() {
const float aspect_ratio = get_selected_aspect_ratio();
float2 triad_size_factor;
float2 num_triads_factor;
[branch]
if (geom_rotation_mode == 0 || geom_rotation_mode == 2) {
triad_size_factor = content_size * rcp(mask_triad_width * float2(1, aspect_ratio));
num_triads_factor = mask_num_triads_across * float2(1, content_size.y * rcp(content_size.x) * rcp(aspect_ratio));
}
else {
triad_size_factor = content_size * rcp(mask_triad_width * float2(1, aspect_ratio)).yx;
num_triads_factor = mask_num_triads_across * float2(1, content_size.y * rcp(content_size.x) * rcp(aspect_ratio)).yx;
}
return ((mask_size_param == 0) ? triad_size_factor : num_triads_factor);
}
/*
* We have a pulse wave f(t0_norm, p, q) = y0 with unknown p.
* This function solves for p.
*/
#define calculate_phosphor_p_value(t0_norm, y0, q) (log((y0) * rcp(1 - (y0))) - (q) * (0.5 - 2*(t0_norm)))
/*
* If we don't rescale the phosphor_thickness parameter, it has a logarithmic effect on the phosphor shape.
* Rescaling it makes it look closer to a linear effect.
*/
#define linearize_phosphor_thickness_param(p) (1 - exp(-(p)))
/*
* Generates a grille mask with the desired resolution and sharpness.
*/
float3 get_phosphor_intensity_grille(
const float2 texcoord,
const float2 viewport_frequency_factor,
const float2 grille_pq
) {
float3 center_offsets = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
grille_norm_center_offsets.bgr : grille_norm_center_offsets;
center_offsets += phosphor_offset_x * 0.5;
float3 theta = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets, 1);
float3 alpha = exp((theta - 0.5) * grille_pq.y);
return alpha * rcp(alpha + grille_pq.x);
}
/*
* Generates a slot mask with the desired resolution and sharpness.
*/
float3 get_phosphor_intensity_slot(
const float2 texcoord,
const float2 viewport_frequency_factor,
const float2 slot_pq_x,
const float2 slot_pq_y
) {
float3 center_offsets_x = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
slot_norm_center_offsets_x.bgr : slot_norm_center_offsets_x;
float3 center_offsets_y = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
slot_norm_center_offsets_y.bgr : slot_norm_center_offsets_y;
center_offsets_x += phosphor_offset_x * 0.5;
center_offsets_y += phosphor_offset_y * 0.5;
float3 theta_x1 = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x, 0.5);
float3 alpha_x1 = exp((theta_x1 - 0.5) * slot_pq_x.y);
alpha_x1 *= rcp(alpha_x1 + slot_pq_x.x);
float3 theta_x2 = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x + 1, 0.5);
float3 alpha_x2 = exp((theta_x2 - 0.5) * slot_pq_x.y);
alpha_x2 *= rcp(alpha_x2 + slot_pq_x.x);
float3 theta_y1 = triangle_wave(texcoord.y * viewport_frequency_factor.y - center_offsets_y, 1);
float3 alpha_y1 = exp((theta_y1 - 0.5) * slot_pq_y.y);
alpha_y1 *= rcp(alpha_y1 + slot_pq_y.x);
float3 theta_y2 = triangle_wave(texcoord.y * viewport_frequency_factor.y - center_offsets_y + 0.5, 1);
float3 alpha_y2 = exp((theta_y2 - 0.5) * slot_pq_y.y);
alpha_y2 *= rcp(alpha_y2 + slot_pq_y.x);
return alpha_x1 * alpha_y1 + alpha_x2 * alpha_y2;
}
/*
* Generates a shadow mask with the desired resolution and sharpness.
*/
float3 get_phosphor_intensity_shadow(
const float2 texcoord,
const float2 viewport_frequency_factor,
const float2 shadow_q
) {
float3 center_offsets_x = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
shadow_norm_center_offsets_x.bgr : shadow_norm_center_offsets_x;
float3 center_offsets_y = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
shadow_norm_center_offsets_y.bgr : shadow_norm_center_offsets_y;
center_offsets_x += phosphor_offset_x * 0.5;
center_offsets_y += phosphor_offset_y * 0.5;
const float2 thickness_scaled = linearize_phosphor_thickness_param(phosphor_thickness);
const float3 x_adj = texcoord.x * viewport_frequency_factor.x - center_offsets_x;
const float3 y_adj = texcoord.y * viewport_frequency_factor.y - center_offsets_y;
const float3 texcoord_x_periodic1 = shadow_norm_phosphor_rad * triangle_wave(x_adj * 3 - 0.5, 1.0);
const float3 texcoord_x_periodic2 = shadow_norm_phosphor_rad * triangle_wave(x_adj * 3, 1.0);
const float3 ty1 = sqrt(
shadow_norm_phosphor_rad*shadow_norm_phosphor_rad - texcoord_x_periodic1*texcoord_x_periodic1
);
const float3 ty2 = sqrt(
shadow_norm_phosphor_rad*shadow_norm_phosphor_rad - texcoord_x_periodic2*texcoord_x_periodic2
);
const float shadow_px = exp(-calculate_phosphor_p_value(shadow_edge_norm_tx, thickness_scaled.x, shadow_q.x));
const float3 shadow_py1 = exp(-calculate_phosphor_p_value(ty1 * 0.5 * rcp(shadow_aspect_ratio), thickness_scaled.y, shadow_q.y));
const float3 shadow_py2 = exp(-calculate_phosphor_p_value(ty2 * 0.5 * rcp(shadow_aspect_ratio), thickness_scaled.y, shadow_q.y));
float3 theta_x1 = triangle_wave(x_adj, 1);
float3 alpha_x1 = exp((theta_x1 - 0.5) * shadow_q.x);
alpha_x1 *= rcp(alpha_x1 + shadow_px);
float3 theta_x2 = triangle_wave(x_adj + 0.5, 1);
float3 alpha_x2 = exp((theta_x2 - 0.5) * shadow_q.x);
alpha_x2 *= rcp(alpha_x2 + shadow_px);
float3 theta_y1 = triangle_wave(y_adj, 0.5);
float3 alpha_y1 = exp((theta_y1 - 0.5) * shadow_q.y);
alpha_y1 *= rcp(alpha_y1 + shadow_py1);
float3 theta_y2 = triangle_wave(y_adj + 1, 0.5);
float3 alpha_y2 = exp((theta_y2 - 0.5) * shadow_q.y);
alpha_y2 *= rcp(alpha_y2 + shadow_py2);
return alpha_x1 * alpha_y1 + alpha_x2 * alpha_y2;
}
float3 get_phosphor_intensity_grille_small(
const float2 texcoord,
const float2 viewport_frequency_factor,
const float2 grille_pq_x
) {
float3 center_offsets_x = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
smallgrille_norm_center_offsets_x.grg : smallgrille_norm_center_offsets_x;
center_offsets_x += phosphor_offset_x * 0.5;
float3 theta = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x, 1);
float3 alpha = exp((theta - 0.5) * grille_pq_x.y);
alpha *= rcp(alpha + grille_pq_x.x);
// Taking a sqrt here helps hide the gaps between the pixels when the triad size is small
return sqrt(alpha);
}
float3 get_phosphor_intensity_slot_small(
const float2 texcoord,
const float2 viewport_frequency_factor,
const float2 slot_pq_x,
const float2 slot_pq_y
) {
float3 center_offsets_x = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
smallslot_norm_center_offsets_x.grg : smallslot_norm_center_offsets_x;
float3 center_offsets_y1 = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
smallslot_norm_center_offsets_y1.grg : smallslot_norm_center_offsets_y1;
float3 center_offsets_y2 = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
smallslot_norm_center_offsets_y2.grg : smallslot_norm_center_offsets_y2;
center_offsets_x += phosphor_offset_x * 0.5;
center_offsets_y1 += phosphor_offset_y * 0.5;
center_offsets_y2 += phosphor_offset_y * 0.5;
float3 theta_x1 = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x, 0.5);
float3 alpha_x1 = exp((theta_x1 - 0.5) * slot_pq_x.y);
alpha_x1 *= rcp(alpha_x1 + slot_pq_x.x);
float3 theta_x2 = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x + 1, 0.5);
float3 alpha_x2 = exp((theta_x2 - 0.5) * slot_pq_x.y);
alpha_x2 *= rcp(alpha_x2 + slot_pq_x.x);
float3 theta_y1 = triangle_wave(texcoord.y * viewport_frequency_factor.y - center_offsets_y1, 1);
float3 alpha_y1 = exp((theta_y1 - 0.5) * slot_pq_y.y);
alpha_y1 *= rcp(alpha_y1 + slot_pq_y.x);
float3 theta_y2 = triangle_wave(texcoord.y * viewport_frequency_factor.y - center_offsets_y2 + 0.5, 1);
float3 alpha_y2 = exp((theta_y2 - 0.5) * slot_pq_y.y);
alpha_y2 *= rcp(alpha_y2 + slot_pq_y.x);
// Taking a sqrt here helps hide the gaps between the pixels when the triad size is small
return (alpha_x1 * alpha_y1 + alpha_x2 * alpha_y2);
}
float3 get_phosphor_intensity_shadow_small(
const float2 texcoord,
const float2 viewport_frequency_factor,
const float2 shadow_pq_x,
const float2 shadow_pq_y
) {
float3 center_offsets_x = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
smallshadow_norm_center_offsets_x.grg : smallshadow_norm_center_offsets_x;
float3 center_offsets_y = (geom_rotation_mode == 2 || geom_rotation_mode == 3) ?
smallshadow_norm_center_offsets_y.grg : smallshadow_norm_center_offsets_y;
center_offsets_x += phosphor_offset_x * 0.5;
center_offsets_y += phosphor_offset_y * 0.5;
float3 theta_x1 = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x, 1);
float3 alpha_x1 = exp((theta_x1 - 0.5) * shadow_pq_x.y);
alpha_x1 *= rcp(alpha_x1 + shadow_pq_x.x);
float3 theta_x2 = triangle_wave(texcoord.x * viewport_frequency_factor.x - center_offsets_x + 0.5, 1);
float3 alpha_x2 = exp((theta_x2 - 0.5) * shadow_pq_x.y);
alpha_x2 *= rcp(alpha_x2 + shadow_pq_x.x);
float3 theta_y1 = triangle_wave(texcoord.y * viewport_frequency_factor.y - center_offsets_y, 0.5);
float3 alpha_y1 = exp((theta_y1 - 0.5) * shadow_pq_y.y);
alpha_y1 *= rcp(alpha_y1 + shadow_pq_y.x);
float3 theta_y2 = triangle_wave(texcoord.y * viewport_frequency_factor.y - center_offsets_y + 1, 0.5);
float3 alpha_y2 = exp((theta_y2 - 0.5) * shadow_pq_y.y);
alpha_y2 *= rcp(alpha_y2 + shadow_pq_y.x);
// Taking a sqrt here helps hide the gaps between the pixels when the triad size is small
return sqrt(alpha_x1 * alpha_y1 + alpha_x2 * alpha_y2);
}
#endif // _PHOSHOR_MASK_CALCULATIONS_H

243
data/resources/shaders/reshade/Shaders/crt-royale/lib/quad-pixel-communication.fxh Normal file
View File

@ -0,0 +1,243 @@
#ifndef _QUAD_PIXEL_COMMUNICATION_H
#define _QUAD_PIXEL_COMMUNICATION_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2014 TroggleMonkey*
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
///////////////////////////////// DISCLAIMER /////////////////////////////////
// *This code was inspired by "Shader Amortization using Pixel Quad Message
// Passing" by Eric Penner, published in GPU Pro 2, Chapter VI.2. My intent
// is not to plagiarize his fundamentally similar code and assert my own
// copyright, but the algorithmic helper functions require so little code that
// implementations can't vary by much except bugfixes and conventions. I just
// wanted to license my own particular code here to avoid ambiguity and make it
// clear that as far as I'm concerned, people can do as they please with it.
///////////////////////////////// DESCRIPTION ////////////////////////////////
// Given screen pixel numbers, derive a "quad vector" describing a fragment's
// position in its 2x2 pixel quad. Given that vector, obtain the values of any
// variable at neighboring fragments.
// Requires: Using this file in general requires:
// 1.) ddx() and ddy() are present in the current Cg profile.
// 2.) The GPU driver is using fine/high-quality derivatives.
// Functions will give incorrect results if this is not true,
// so a test function is included.
///////////////////// QUAD-PIXEL COMMUNICATION PRIMITIVES ////////////////////
float4 get_quad_vector_naive(float4 output_pixel_num_wrt_uvxy)
{
// Requires: Two measures of the current fragment's output pixel number
// in the range ([0, output_size.x), [0, output_size.y)):
// 1.) output_pixel_num_wrt_uvxy.xy increase with uv coords.
// 2.) output_pixel_num_wrt_uvxy.zw increase with screen xy.
// Returns: Two measures of the fragment's position in its 2x2 quad:
// 1.) The .xy components are its 2x2 placement with respect to
// uv direction (the origin (0, 0) is at the top-left):
// top-left = (-1.0, -1.0) top-right = ( 1.0, -1.0)
// bottom-left = (-1.0, 1.0) bottom-right = ( 1.0, 1.0)
// You need this to arrange/weight shared texture samples.
// 2.) The .zw components are its 2x2 placement with respect to
// screen xy direction (position); the origin varies.
// quad_gather needs this measure to work correctly.
// Note: quad_vector.zw = quad_vector.xy * float2(
// ddx(output_pixel_num_wrt_uvxy.x),
// ddy(output_pixel_num_wrt_uvxy.y));
// Caveats: This function assumes the GPU driver always starts 2x2 pixel
// quads at even pixel numbers. This assumption can be wrong
// for odd output resolutions (nondeterministically so).
float4 pixel_odd = frac(output_pixel_num_wrt_uvxy * 0.5) * 2.0;
float4 quad_vector = pixel_odd * 2.0 - float4(1.0, 1.0, 1.0, 1.0);
return quad_vector;
}
float4 get_quad_vector(float4 output_pixel_num_wrt_uvxy)
{
// Requires: Same as get_quad_vector_naive() (see that first).
// Returns: Same as get_quad_vector_naive() (see that first), but it's
// correct even if the 2x2 pixel quad starts at an odd pixel,
// which can occur at odd resolutions.
float4 quad_vector_guess =
get_quad_vector_naive(output_pixel_num_wrt_uvxy);
// If quad_vector_guess.zw doesn't increase with screen xy, we know
// the 2x2 pixel quad starts at an odd pixel:
float2 odd_start_mirror = 0.5 * float2(ddx(quad_vector_guess.z),
ddy(quad_vector_guess.w));
return quad_vector_guess * odd_start_mirror.xyxy;
}
float4 get_quad_vector(float2 output_pixel_num_wrt_uv)
{
// Requires: 1.) ddx() and ddy() are present in the current Cg profile.
// 2.) output_pixel_num_wrt_uv must increase with uv coords and
// measure the current fragment's output pixel number in:
// ([0, output_size.x), [0, output_size.y))
// Returns: Same as get_quad_vector_naive() (see that first), but it's
// correct even if the 2x2 pixel quad starts at an odd pixel,
// which can occur at odd resolutions.
// Caveats: This function requires less information than the version
// taking a float4, but it's potentially slower.
// Do screen coords increase with or against uv? Get the direction
// with respect to (uv.x, uv.y) for (screen.x, screen.y) in {-1, 1}.
float2 screen_uv_mirror = float2(ddx(output_pixel_num_wrt_uv.x),
ddy(output_pixel_num_wrt_uv.y));
float2 pixel_odd_wrt_uv = frac(output_pixel_num_wrt_uv * 0.5) * 2.0;
float2 quad_vector_uv_guess = (pixel_odd_wrt_uv - float2(0.5, 0.5)) * 2.0;
float2 quad_vector_screen_guess = quad_vector_uv_guess * screen_uv_mirror;
// If quad_vector_screen_guess doesn't increase with screen xy, we know
// the 2x2 pixel quad starts at an odd pixel:
float2 odd_start_mirror = 0.5 * float2(ddx(quad_vector_screen_guess.x),
ddy(quad_vector_screen_guess.y));
float4 quad_vector_guess = float4(
quad_vector_uv_guess, quad_vector_screen_guess);
return quad_vector_guess * odd_start_mirror.xyxy;
}
void quad_gather(float4 quad_vector, float4 curr,
out float4 adjx, out float4 adjy, out float4 diag)
{
// Requires: 1.) ddx() and ddy() are present in the current Cg profile.
// 2.) The GPU driver is using fine/high-quality derivatives.
// 3.) quad_vector describes the current fragment's location in
// its 2x2 pixel quad using get_quad_vector()'s conventions.
// 4.) curr is any vector you wish to get neighboring values of.
// Returns: Values of an input vector (curr) at neighboring fragments
// adjacent x, adjacent y, and diagonal (via out parameters).
adjx = curr - ddx(curr) * quad_vector.z;
adjy = curr - ddy(curr) * quad_vector.w;
diag = adjx - ddy(adjx) * quad_vector.w;
}
void quad_gather(float4 quad_vector, float3 curr,
out float3 adjx, out float3 adjy, out float3 diag)
{
// Float3 version
adjx = curr - ddx(curr) * quad_vector.z;
adjy = curr - ddy(curr) * quad_vector.w;
diag = adjx - ddy(adjx) * quad_vector.w;
}
void quad_gather(float4 quad_vector, float2 curr,
out float2 adjx, out float2 adjy, out float2 diag)
{
// Float2 version
adjx = curr - ddx(curr) * quad_vector.z;
adjy = curr - ddy(curr) * quad_vector.w;
diag = adjx - ddy(adjx) * quad_vector.w;
}
float4 quad_gather(float4 quad_vector, float curr)
{
// Float version:
// Returns: return.x == current
// return.y == adjacent x
// return.z == adjacent y
// return.w == diagonal
float4 all = float4(curr, curr, curr, curr);
all.y = all.x - ddx(all.x) * quad_vector.z;
all.zw = all.xy - ddy(all.xy) * quad_vector.w;
return all;
}
float4 quad_gather_sum(float4 quad_vector, float4 curr)
{
// Requires: Same as quad_gather()
// Returns: Sum of an input vector (curr) at all fragments in a quad.
float4 adjx, adjy, diag;
quad_gather(quad_vector, curr, adjx, adjy, diag);
return (curr + adjx + adjy + diag);
}
float3 quad_gather_sum(float4 quad_vector, float3 curr)
{
// Float3 version:
float3 adjx, adjy, diag;
quad_gather(quad_vector, curr, adjx, adjy, diag);
return (curr + adjx + adjy + diag);
}
float2 quad_gather_sum(float4 quad_vector, float2 curr)
{
// Float2 version:
float2 adjx, adjy, diag;
quad_gather(quad_vector, curr, adjx, adjy, diag);
return (curr + adjx + adjy + diag);
}
float quad_gather_sum(float4 quad_vector, float curr)
{
// Float version:
float4 all_values = quad_gather(quad_vector, curr);
return (all_values.x + all_values.y + all_values.z + all_values.w);
}
bool fine_derivatives_working(float4 quad_vector, float4 curr)
{
// Requires: 1.) ddx() and ddy() are present in the current Cg profile.
// 2.) quad_vector describes the current fragment's location in
// its 2x2 pixel quad using get_quad_vector()'s conventions.
// 3.) curr must be a test vector with non-constant derivatives
// (its value should change nonlinearly across fragments).
// Returns: true if fine/hybrid/high-quality derivatives are used, or
// false if coarse derivatives are used or inconclusive
// Usage: Test whether quad-pixel communication is working!
// Method: We can confirm fine derivatives are used if the following
// holds (ever, for any value at any fragment):
// (ddy(curr) != ddy(adjx)) or (ddx(curr) != ddx(adjy))
// The more values we test (e.g. test a float4 two ways), the
// easier it is to demonstrate fine derivatives are working.
// TODO: Check for floating point exact comparison issues!
float4 ddx_curr = ddx(curr);
float4 ddy_curr = ddy(curr);
float4 adjx = curr - ddx_curr * quad_vector.z;
float4 adjy = curr - ddy_curr * quad_vector.w;
bool ddy_different = any(bool4(ddy_curr.x != ddy(adjx).x, ddy_curr.y != ddy(adjx).y, ddy_curr.z != ddy(adjx).z, ddy_curr.w != ddy(adjx).w));
bool ddx_different = any(bool4(ddx_curr.x != ddx(adjy).x, ddx_curr.y != ddx(adjy).y, ddx_curr.z != ddx(adjy).z, ddx_curr.w != ddx(adjy).w));
return any(bool2(ddy_different, ddx_different));
}
bool fine_derivatives_working_fast(float4 quad_vector, float curr)
{
// Requires: Same as fine_derivatives_working()
// Returns: Same as fine_derivatives_working()
// Usage: This is faster than fine_derivatives_working() but more
// likely to return false negatives, so it's less useful for
// offline testing/debugging. It's also useless as the basis
// for dynamic runtime branching as of May 2014: Derivatives
// (and quad-pixel communication) are currently disallowed in
// branches. However, future GPU's may allow you to use them
// in dynamic branches if you promise the branch condition
// evaluates the same for every fragment in the quad (and/or if
// the driver enforces that promise by making a single fragment
// control branch decisions). If that ever happens, this
// version may become a more economical choice.
float ddx_curr = ddx(curr);
float ddy_curr = ddy(curr);
float adjx = curr - ddx_curr * quad_vector.z;
return (ddy_curr != ddy(adjx));
}
#endif // _QUAD_PIXEL_COMMUNICATION_H

501
data/resources/shaders/reshade/Shaders/crt-royale/lib/scanline-functions.fxh Normal file
View File

@ -0,0 +1,501 @@
#ifndef _SCANLINE_FUNCTIONS_H
#define _SCANLINE_FUNCTIONS_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
/////////////////////////////// BEGIN INCLUDES ///////////////////////////////
#include "bind-shader-params.fxh"
#include "gamma-management.fxh"
#include "special-functions.fxh"
//////////////////////////////// END INCLUDES ////////////////////////////////
///////////////////////////// SCANLINE FUNCTIONS /////////////////////////////
float2 round_coord(
const float2 c,
const float2 starting_position,
const float2 bin_size
) {
const float2 adj_c = c - starting_position;
return c - fmod(adj_c, bin_size) + bin_size * 0.5;
}
// Use preproc defs for these, so they work for arbitrary choices of float1/2/3/4
#define triangle_wave(t, f) abs(1 - 2*frac((t) * (f)))
#define sawtooth_incr_wave(t, f) frac((t) * (f))
// using fmod(-t*f, 1.0) outputs 0 at t == 0, but I want it to output 1
#define sawtooth_decr_wave(t, f) 1 - frac((t) * (f))
struct InterpolationFieldData {
float triangle_wave_freq;
bool field_parity;
bool scanline_parity;
bool wrong_field;
};
InterpolationFieldData precalc_interpolation_field_data(float2 texcoord) {
InterpolationFieldData data;
data.triangle_wave_freq = 2;
const float field_wave = triangle_wave(texcoord.y + rcp(2*data.triangle_wave_freq), data.triangle_wave_freq * 0.5) * 2 - 1;
data.scanline_parity = field_wave >= 0;
return data;
}
InterpolationFieldData calc_interpolation_field_data(float2 texcoord, float scale) {
InterpolationFieldData data;
data.triangle_wave_freq = scale * rcp(scanline_thickness);
// data.triangle_wave_freq = content_size.y * rcp(scanline_thickness);
const bool frame_count_parity = (frame_count % 2 == 1) && (scanline_deinterlacing_mode != 1);
data.field_parity = (frame_count_parity && !interlace_back_field_first) || (!frame_count_parity && interlace_back_field_first);
const float field_wave = triangle_wave(texcoord.y + rcp(2*data.triangle_wave_freq), data.triangle_wave_freq * 0.5) * 2 - 1;
data.scanline_parity = field_wave >= 0;
const bool wrong_field_raw = (data.scanline_parity && !data.field_parity) || (!data.scanline_parity && data.field_parity);
data.wrong_field = enable_interlacing && wrong_field_raw;
return data;
}
float get_gaussian_sigma(const float color, const float sigma_range)
{
// Requires: Globals:
// 1.) gaussian_beam_min_sigma and gaussian_beam_max_sigma are global floats
// containing the desired minimum and maximum beam standard
// deviations, for dim and bright colors respectively.
// 2.) gaussian_beam_max_sigma must be > 0.0
// 3.) gaussian_beam_min_sigma must be in (0.0, gaussian_beam_max_sigma]
// 4.) gaussian_beam_spot_power must be defined as a global float.
// Parameters:
// 1.) color is the underlying source color along a scanline
// 2.) sigma_range = gaussian_beam_max_sigma - gaussian_beam_min_sigma; we take
// sigma_range as a parameter to avoid repeated computation
// when beam_{min, max}_sigma are runtime shader parameters
// Optional: Users may set beam_spot_shape_function to 1 to define the
// inner f(color) subfunction (see below) as:
// f(color) = sqrt(1.0 - (color - 1.0)*(color - 1.0))
// Otherwise (technically, if beam_spot_shape_function < 0.5):
// f(color) = pow(color, gaussian_beam_spot_power)
// Returns: The standard deviation of the Gaussian beam for "color:"
// sigma = gaussian_beam_min_sigma + sigma_range * f(color)
// Details/Discussion:
// The beam's spot shape vaguely resembles an aspect-corrected f() in the
// range [0, 1] (not quite, but it's related). f(color) = color makes
// spots look like diamonds, and a spherical function or cube balances
// between variable width and a soft/realistic shape. A gaussian_beam_spot_power
// > 1.0 can produce an ugly spot shape and more initial clipping, but the
// final shape also differs based on the horizontal resampling filter and
// the phosphor bloom. For instance, resampling horizontally in nonlinear
// light and/or with a sharp (e.g. Lanczos) filter will sharpen the spot
// shape, but a sixth root is still quite soft. A power function (default
// 1.0/3.0 gaussian_beam_spot_power) is most flexible, but a fixed spherical curve
// has the highest variability without an awful spot shape.
//
// gaussian_beam_min_sigma affects scanline sharpness/aliasing in dim areas, and its
// difference from gaussian_beam_max_sigma affects beam width variability. It only
// affects clipping [for pure Gaussians] if gaussian_beam_spot_power > 1.0 (which is
// a conservative estimate for a more complex constraint).
//
// gaussian_beam_max_sigma affects clipping and increasing scanline width/softness
// as color increases. The wider this is, the more scanlines need to be
// evaluated to avoid distortion. For a pure Gaussian, the max_beam_sigma
// at which the first unused scanline always has a weight < 1.0/255.0 is:
// num scanlines = 2, max_beam_sigma = 0.2089; distortions begin ~0.34
// num scanlines = 3, max_beam_sigma = 0.3879; distortions begin ~0.52
// num scanlines = 4, max_beam_sigma = 0.5723; distortions begin ~0.70
// num scanlines = 5, max_beam_sigma = 0.7591; distortions begin ~0.89
// num scanlines = 6, max_beam_sigma = 0.9483; distortions begin ~1.08
// Generalized Gaussians permit more leeway here as steepness increases.
if(beam_spot_shape_function < 0.5)
{
// Use a power function:
return gaussian_beam_min_sigma + sigma_range * pow(color, gaussian_beam_spot_power);
}
else
{
// Use a spherical function:
const float color_minus_1 = color - 1;
return gaussian_beam_min_sigma + sigma_range * sqrt(1.0 - color_minus_1*color_minus_1);
}
}
float get_generalized_gaussian_beta(const float color, const float shape_range)
{
// Requires: Globals:
// 1.) gaussian_beam_min_shape and gaussian_beam_max_shape are global floats
// containing the desired min/max generalized Gaussian
// beta parameters, for dim and bright colors respectively.
// 2.) gaussian_beam_max_shape must be >= 2.0
// 3.) gaussian_beam_min_shape must be in [2.0, gaussian_beam_max_shape]
// 4.) gaussian_beam_shape_power must be defined as a global float.
// Parameters:
// 1.) color is the underlying source color along a scanline
// 2.) shape_range = gaussian_beam_max_shape - gaussian_beam_min_shape; we take
// shape_range as a parameter to avoid repeated computation
// when beam_{min, max}_shape are runtime shader parameters
// Returns: The type-I generalized Gaussian "shape" parameter beta for
// the given color.
// Details/Discussion:
// Beta affects the scanline distribution as follows:
// a.) beta < 2.0 narrows the peak to a spike with a discontinuous slope
// b.) beta == 2.0 just degenerates to a Gaussian
// c.) beta > 2.0 flattens and widens the peak, then drops off more steeply
// than a Gaussian. Whereas high sigmas widen and soften peaks, high
// beta widen and sharpen peaks at the risk of aliasing.
// Unlike high gaussian_beam_spot_powers, high gaussian_beam_shape_powers actually soften shape
// transitions, whereas lower ones sharpen them (at the risk of aliasing).
return gaussian_beam_min_shape + shape_range * pow(color, gaussian_beam_shape_power);
}
float3 get_raw_interpolated_color(const float3 color0,
const float3 color1, const float3 color2, const float3 color3,
const float4 weights)
{
// Use max to avoid bizarre artifacts from negative colors:
const float4x3 mtrx = float4x3(color0, color1, color2, color3);
const float3 m = mul(weights, mtrx);
return max(m, 0.0);
}
float3 get_interpolated_linear_color(const float3 color0, const float3 color1,
const float3 color2, const float3 color3, const float4 weights)
{
// Requires: 1.) Requirements of include/gamma-management.h must be met:
// intermediate_gamma must be globally defined, and input
// colors are interpreted as linear RGB unless you #define
// GAMMA_ENCODE_EVERY_FBO (in which case they are
// interpreted as gamma-encoded with intermediate_gamma).
// 2.) color0-3 are colors sampled from a texture with tex2D().
// They are interpreted as defined in requirement 1.
// 3.) weights contains weights for each color, summing to 1.0.
// 4.) beam_horiz_linear_rgb_weight must be defined as a global
// float in [0.0, 1.0] describing how much blending should
// be done in linear RGB (rest is gamma-corrected RGB).
// 5.) _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE must be #defined
// if beam_horiz_linear_rgb_weight is anything other than a
// static constant, or we may try branching at runtime
// without dynamic branches allowed (slow).
// Returns: Return an interpolated color lookup between the four input
// colors based on the weights in weights. The final color will
// be a linear RGB value, but the blending will be done as
// indicated above.
const float intermediate_gamma = get_intermediate_gamma();
const float inv_intermediate_gamma = 1.0 / intermediate_gamma;
// Branch if beam_horiz_linear_rgb_weight is static (for free) or if the
// profile allows dynamic branches (faster than computing extra pows):
#if !_RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
#define SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT
#else
#if _DRIVERS_ALLOW_DYNAMIC_BRANCHES
#define SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT
#endif
#endif
#ifdef SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT
// beam_horiz_linear_rgb_weight is static, so we can branch:
#ifdef GAMMA_ENCODE_EVERY_FBO
const float3 gamma_mixed_color = pow(
get_raw_interpolated_color(color0, color1, color2, color3, weights),
intermediate_gamma);
if(beam_horiz_linear_rgb_weight > 0.0)
{
const float3 linear_mixed_color = get_raw_interpolated_color(
pow(color0, intermediate_gamma),
pow(color1, intermediate_gamma),
pow(color2, intermediate_gamma),
pow(color3, intermediate_gamma),
weights);
return lerp(gamma_mixed_color, linear_mixed_color, beam_horiz_linear_rgb_weight);
}
else
{
return gamma_mixed_color;
}
#else
const float3 linear_mixed_color = get_raw_interpolated_color(
color0, color1, color2, color3, weights);
if(beam_horiz_linear_rgb_weight < 1.0)
{
const float3 gamma_mixed_color = get_raw_interpolated_color(
pow(color0, inv_intermediate_gamma),
pow(color1, inv_intermediate_gamma),
pow(color2, inv_intermediate_gamma),
pow(color3, inv_intermediate_gamma),
weights);
return lerp(gamma_mixed_color, linear_mixed_color, beam_horiz_linear_rgb_weight);
}
else
{
return linear_mixed_color;
}
#endif // GAMMA_ENCODE_EVERY_FBO
#else
#ifdef GAMMA_ENCODE_EVERY_FBO
// Inputs: color0-3 are colors in gamma-encoded RGB.
const float3 gamma_mixed_color = pow(get_raw_interpolated_color(
color0, color1, color2, color3, weights), intermediate_gamma);
const float3 linear_mixed_color = get_raw_interpolated_color(
pow(color0, intermediate_gamma),
pow(color1, intermediate_gamma),
pow(color2, intermediate_gamma),
pow(color3, intermediate_gamma),
weights);
return lerp(gamma_mixed_color, linear_mixed_color, beam_horiz_linear_rgb_weight);
#else
// Inputs: color0-3 are colors in linear RGB.
const float3 linear_mixed_color = get_raw_interpolated_color(
color0, color1, color2, color3, weights);
const float3 gamma_mixed_color = get_raw_interpolated_color(
pow(color0, inv_intermediate_gamma),
pow(color1, inv_intermediate_gamma),
pow(color2, inv_intermediate_gamma),
pow(color3, inv_intermediate_gamma),
weights);
// wtf fixme
// const float beam_horiz_linear_rgb_weight1 = 1.0;
return lerp(gamma_mixed_color, linear_mixed_color,
beam_horiz_linear_rgb_weight);
#endif // GAMMA_ENCODE_EVERY_FBO
#endif // SCANLINES_BRANCH_FOR_LINEAR_RGB_WEIGHT
}
float3 get_scanline_color(const sampler2D tex, const float2 scanline_uv,
const float2 uv_step_x, const float4 weights)
{
// Requires: 1.) scanline_uv must be vertically snapped to the caller's
// desired line or scanline and horizontally snapped to the
// texel just left of the output pixel (color1)
// 2.) uv_step_x must contain the horizontal uv distance
// between texels.
// 3.) weights must contain interpolation filter weights for
// color0, color1, color2, and color3, where color1 is just
// left of the output pixel.
// Returns: Return a horizontally interpolated texture lookup using 2-4
// nearby texels, according to weights and the conventions of
// get_interpolated_linear_color().
// We can ignore the outside texture lookups for Quilez resampling.
const float3 color1 = tex2D_linearize(tex, scanline_uv, get_input_gamma()).rgb;
const float3 color2 = tex2D_linearize(tex, scanline_uv + uv_step_x, get_input_gamma()).rgb;
float3 color0 = float3(0.0, 0.0, 0.0);
float3 color3 = float3(0.0, 0.0, 0.0);
if(beam_horiz_filter > 0.5)
{
color0 = tex2D_linearize(tex, scanline_uv - uv_step_x, get_input_gamma()).rgb;
color3 = tex2D_linearize(tex, scanline_uv + 2.0 * uv_step_x, get_input_gamma()).rgb;
}
// Sample the texture as-is, whether it's linear or gamma-encoded:
// get_interpolated_linear_color() will handle the difference.
return get_interpolated_linear_color(color0, color1, color2, color3, weights);
}
float3 sample_single_scanline_horizontal(const sampler2D tex,
const float2 tex_uv, const float2 tex_size,
const float2 texture_size_inv)
{
// TODO: Add function requirements.
// Snap to the previous texel and get sample dists from 2/4 nearby texels:
const float2 curr_texel = tex_uv * tex_size;
// Use under_half to fix a rounding bug right around exact texel locations.
const float2 prev_texel = floor(curr_texel - under_half) + 0.5;
const float2 prev_texel_hor = float2(prev_texel.x, curr_texel.y);
const float2 prev_texel_hor_uv = prev_texel_hor * texture_size_inv;
const float prev_dist = curr_texel.x - prev_texel_hor.x;
const float4 sample_dists = float4(1.0 + prev_dist, prev_dist,
1.0 - prev_dist, 2.0 - prev_dist);
// Get Quilez, Lanczos2, or Gaussian resize weights for 2/4 nearby texels:
float4 weights;
if (beam_horiz_filter < 0.5) {
// None:
weights = float4(0, 1, 0, 0);
}
else if(beam_horiz_filter < 1.5)
{
// Quilez:
const float x = sample_dists.y;
const float w2 = x*x*x*(x*(x*6.0 - 15.0) + 10.0);
weights = float4(0.0, 1.0 - w2, w2, 0.0);
}
else if(beam_horiz_filter < 2.5)
{
// Gaussian:
float inner_denom_inv = 1.0/(2.0*beam_horiz_sigma*beam_horiz_sigma);
weights = exp(-(sample_dists*sample_dists)*inner_denom_inv);
}
else
{
// Lanczos2:
const float4 pi_dists = FIX_ZERO(sample_dists * pi);
weights = 2.0 * sin(pi_dists) * sin(pi_dists * 0.5) /
(pi_dists * pi_dists);
}
// Ensure the weight sum == 1.0:
const float4 final_weights = weights/dot(weights, float4(1.0, 1.0, 1.0, 1.0));
// Get the interpolated horizontal scanline color:
const float2 uv_step_x = float2(texture_size_inv.x, 0.0);
return get_scanline_color(
tex, prev_texel_hor_uv, uv_step_x, final_weights);
}
float3 sample_rgb_scanline(
const sampler2D tex,
const float2 tex_uv, const float2 tex_size,
const float2 texture_size_inv
) {
if (beam_misconvergence) {
const float3 convergence_offsets_rgb_x = get_convergence_offsets_x_vector();
const float3 convergence_offsets_rgb_y = get_convergence_offsets_y_vector();
const float3 offset_u_rgb = convergence_offsets_rgb_x * texture_size_inv.x;
const float3 offset_v_rgb = convergence_offsets_rgb_y * texture_size_inv.y;
const float2 scanline_uv_r = tex_uv - float2(offset_u_rgb.r, offset_v_rgb.r);
const float2 scanline_uv_g = tex_uv - float2(offset_u_rgb.g, offset_v_rgb.g);
const float2 scanline_uv_b = tex_uv - float2(offset_u_rgb.b, offset_v_rgb.b);
/**/
const float4 sample_r = tex2D(tex, scanline_uv_r);
const float4 sample_g = tex2D(tex, scanline_uv_g);
const float4 sample_b = tex2D(tex, scanline_uv_b);
/**/
/*
const float3 sample_r = sample_single_scanline_horizontal(
tex, scanline_uv_r, tex_size, texture_size_inv);
const float3 sample_g = sample_single_scanline_horizontal(
tex, scanline_uv_g, tex_size, texture_size_inv);
const float3 sample_b = sample_single_scanline_horizontal(
tex, scanline_uv_b, tex_size, texture_size_inv);
*/
return float3(sample_r.r, sample_g.g, sample_b.b);
}
else {
// return tex2D(tex, tex_uv).rgb;
return sample_single_scanline_horizontal(tex, tex_uv, tex_size, texture_size_inv);
}
}
float3 sample_rgb_scanline_horizontal(const sampler2D tex,
const float2 tex_uv, const float2 tex_size,
const float2 texture_size_inv)
{
// TODO: Add function requirements.
// Rely on a helper to make convergence easier.
if(beam_misconvergence)
{
const float3 convergence_offsets_rgb = get_convergence_offsets_x_vector();
const float3 offset_u_rgb = convergence_offsets_rgb * texture_size_inv.xxx;
const float2 scanline_uv_r = tex_uv - float2(offset_u_rgb.r, 0.0);
const float2 scanline_uv_g = tex_uv - float2(offset_u_rgb.g, 0.0);
const float2 scanline_uv_b = tex_uv - float2(offset_u_rgb.b, 0.0);
const float3 sample_r = sample_single_scanline_horizontal(
tex, scanline_uv_r, tex_size, texture_size_inv);
const float3 sample_g = sample_single_scanline_horizontal(
tex, scanline_uv_g, tex_size, texture_size_inv);
const float3 sample_b = sample_single_scanline_horizontal(
tex, scanline_uv_b, tex_size, texture_size_inv);
return float3(sample_r.r, sample_g.g, sample_b.b);
}
else
{
return sample_single_scanline_horizontal(tex, tex_uv, tex_size, texture_size_inv);
}
}
float3 get_averaged_scanline_sample(
sampler2D tex, const float2 texcoord,
const float scanline_start_y, const float v_step_y,
const float input_gamma
) {
// Sample `scanline_thickness` vertically-contiguous pixels and average them.
float3 interpolated_line = 0.0;
for (int i = 0; i < scanline_thickness; i++) {
float4 coord = float4(texcoord.x, scanline_start_y + i * v_step_y, 0, 0);
interpolated_line += tex2Dlod_linearize(tex, coord, input_gamma).rgb;
}
interpolated_line /= float(scanline_thickness);
return interpolated_line;
}
float get_beam_strength(float dist, float color,
const float sigma_range, const float shape_range)
{
// entry point in original is scanline_contrib()
// this is based on scanline_gaussian_sampled_contrib() from original
// See scanline_gaussian_integral_contrib() for detailed comments!
// gaussian sample = 1/(sigma*sqrt(2*pi)) * e**(-(x**2)/(2*sigma**2))
const float sigma = get_gaussian_sigma(color, sigma_range);
// Avoid repeated divides:
const float sigma_inv = 1.0 / sigma;
const float inner_denom_inv = 0.5 * sigma_inv * sigma_inv;
const float outer_denom_inv = sigma_inv/sqrt(2.0*pi);
return color*exp(-(dist*dist)*inner_denom_inv)*outer_denom_inv;
}
float get_gaussian_beam_strength(
float dist,
float color,
const float sigma_range,
const float shape_range
) {
// entry point in original is scanline_contrib()
// this is based on scanline_generalized_gaussian_sampled_contrib() from original
// See scanline_generalized_gaussian_integral_contrib() for details!
// generalized sample =
// beta/(2*alpha*gamma(1/beta)) * e**(-(|x|/alpha)**beta)
const float alpha = sqrt(2.0) * get_gaussian_sigma(color, sigma_range);
const float beta = get_generalized_gaussian_beta(color, shape_range);
// Avoid repeated divides:
const float alpha_inv = 1.0 / alpha;
const float beta_inv = 1.0 / beta;
const float scale = color * beta * 0.5 * alpha_inv / gamma_impl(beta_inv, beta);
return scale * exp(-pow(abs(dist*alpha_inv), beta));
}
float get_linear_beam_strength(
const float dist,
const float color,
const float num_pixels,
const bool interlaced
) {
const float p = color * (1 - abs(dist));
return clamp(p, 0, color);
}
#endif // _SCANLINE_FUNCTIONS_H

504
data/resources/shaders/reshade/Shaders/crt-royale/lib/special-functions.fxh Normal file
View File

@ -0,0 +1,504 @@
#ifndef _SPECIAL_FUNCTIONS_H
#define _SPECIAL_FUNCTIONS_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2014 TroggleMonkey
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
///////////////////////////////// DESCRIPTION ////////////////////////////////
// This file implements the following mathematical special functions:
// 1.) erf() = 2/sqrt(pi) * indefinite_integral(e**(-x**2))
// 2.) gamma(s), a real-numbered extension of the integer factorial function
// It also implements normalized_ligamma(s, z), a normalized lower incomplete
// gamma function for s < 0.5 only. Both gamma() and normalized_ligamma() can
// be called with an _impl suffix to use an implementation version with a few
// extra precomputed parameters (which may be useful for the caller to reuse).
// See below for details.
//
// Design Rationale:
// Pretty much every line of code in this file is duplicated four times for
// different input types (float4/float3/float2/float). This is unfortunate,
// but Cg doesn't allow function templates. Macros would be far less verbose,
// but they would make the code harder to document and read. I don't expect
// these functions will require a whole lot of maintenance changes unless
// someone ever has need for more robust incomplete gamma functions, so code
// duplication seems to be the lesser evil in this case.
/////////////////////////// GAUSSIAN ERROR FUNCTION //////////////////////////
float4 erf6(float4 x)
{
// Requires: x is the standard parameter to erf().
// Returns: Return an Abramowitz/Stegun approximation of erf(), where:
// erf(x) = 2/sqrt(pi) * integral(e**(-x**2))
// This approximation has a max absolute error of 2.5*10**-5
// with solid numerical robustness and efficiency. See:
// https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions
const float4 sign_x = sign(x);
const float4 t = 1.0/(1.0 + 0.47047*abs(x));
const float4 result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))*
exp(-(x*x));
return result * sign_x;
}
float3 erf6(const float3 x)
{
// Float3 version:
const float3 sign_x = sign(x);
const float3 t = 1.0/(1.0 + 0.47047*abs(x));
const float3 result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))*
exp(-(x*x));
return result * sign_x;
}
float2 erf6(const float2 x)
{
// Float2 version:
const float2 sign_x = sign(x);
const float2 t = 1.0/(1.0 + 0.47047*abs(x));
const float2 result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))*
exp(-(x*x));
return result * sign_x;
}
float erf6(const float x)
{
// Float version:
const float sign_x = sign(x);
const float t = 1.0/(1.0 + 0.47047*abs(x));
const float result = 1.0 - t*(0.3480242 + t*(-0.0958798 + t*0.7478556))*
exp(-(x*x));
return result * sign_x;
}
float4 erft(const float4 x)
{
// Requires: x is the standard parameter to erf().
// Returns: Approximate erf() with the hyperbolic tangent. The error is
// visually noticeable, but it's blazing fast and perceptually
// close...at least on ATI hardware. See:
// http://www.maplesoft.com/applications/view.aspx?SID=5525&view=html
// Warning: Only use this if your hardware drivers correctly implement
// tanh(): My nVidia 8800GTS returns garbage output.
return tanh(1.202760580 * x);
}
float3 erft(const float3 x)
{
// Float3 version:
return tanh(1.202760580 * x);
}
float2 erft(const float2 x)
{
// Float2 version:
return tanh(1.202760580 * x);
}
float erft(const float x)
{
// Float version:
return tanh(1.202760580 * x);
}
float4 erf(const float4 x)
{
// Requires: x is the standard parameter to erf().
// Returns: Some approximation of erf(x), depending on user settings.
#ifdef ERF_FAST_APPROXIMATION
return erft(x);
#else
return erf6(x);
#endif
}
float3 erf(const float3 x)
{
// Float3 version:
#ifdef ERF_FAST_APPROXIMATION
return erft(x);
#else
return erf6(x);
#endif
}
float2 erf(const float2 x)
{
// Float2 version:
#ifdef ERF_FAST_APPROXIMATION
return erft(x);
#else
return erf6(x);
#endif
}
float erf(const float x)
{
// Float version:
#ifdef ERF_FAST_APPROXIMATION
return erft(x);
#else
return erf6(x);
#endif
}
/////////////////////////// COMPLETE GAMMA FUNCTION //////////////////////////
float4 gamma_impl(const float4 s, const float4 s_inv)
{
// Requires: 1.) s is the standard parameter to the gamma function, and
// it should lie in the [0, 36] range.
// 2.) s_inv = 1.0/s. This implementation function requires
// the caller to precompute this value, giving users the
// opportunity to reuse it.
// Returns: Return approximate gamma function (real-numbered factorial)
// output using the Lanczos approximation with two coefficients
// calculated using Paul Godfrey's method here:
// http://my.fit.edu/~gabdo/gamma.txt
// An optimal g value for s in [0, 36] is ~1.12906830989, with
// a maximum relative error of 0.000463 for 2**16 equally
// evals. We could use three coeffs (0.0000346 error) without
// hurting latency, but this allows more parallelism with
// outside instructions.
static const float g = 1.12906830989;
static const float c0 = 0.8109119309638332633713423362694399653724431;
static const float c1 = 0.4808354605142681877121661197951496120000040;
static const float e = 2.71828182845904523536028747135266249775724709;
const float4 sph = s + 0.5;
const float4 lanczos_sum = c0 + c1/(s + 1.0);
const float4 base = (sph + g)/e; // or (s + g + float4(0.5))/e
// gamma(s + 1) = base**sph * lanczos_sum; divide by s for gamma(s).
// This has less error for small s's than (s -= 1.0) at the beginning.
return (pow(base, sph) * lanczos_sum) * s_inv;
}
float3 gamma_impl(const float3 s, const float3 s_inv)
{
// Float3 version:
static const float g = 1.12906830989;
static const float c0 = 0.8109119309638332633713423362694399653724431;
static const float c1 = 0.4808354605142681877121661197951496120000040;
static const float e = 2.71828182845904523536028747135266249775724709;
const float3 sph = s + 0.5;
const float3 lanczos_sum = c0 + c1/(s + 1.0);
const float3 base = (sph + g)/e;
return (pow(base, sph) * lanczos_sum) * s_inv;
}
float2 gamma_impl(const float2 s, const float2 s_inv)
{
// Float2 version:
static const float g = 1.12906830989;
static const float c0 = 0.8109119309638332633713423362694399653724431;
static const float c1 = 0.4808354605142681877121661197951496120000040;
static const float e = 2.71828182845904523536028747135266249775724709;
const float2 sph = s + 0.5;
const float2 lanczos_sum = c0 + c1/(s + 1.0);
const float2 base = (sph + g)/e;
return (pow(base, sph) * lanczos_sum) * s_inv;
}
float gamma_impl(const float s, const float s_inv)
{
// Float version:
static const float g = 1.12906830989;
static const float c0 = 0.8109119309638332633713423362694399653724431;
static const float c1 = 0.4808354605142681877121661197951496120000040;
static const float e = 2.71828182845904523536028747135266249775724709;
const float sph = s + 0.5;
const float lanczos_sum = c0 + c1/(s + 1.0);
const float base = (sph + g)/e;
return (pow(base, sph) * lanczos_sum) * s_inv;
}
float4 gamma(const float4 s)
{
// Requires: s is the standard parameter to the gamma function, and it
// should lie in the [0, 36] range.
// Returns: Return approximate gamma function output with a maximum
// relative error of 0.000463. See gamma_impl for details.
return gamma_impl(s, 1.0/s);
}
float3 gamma(const float3 s)
{
// Float3 version:
return gamma_impl(s, 1.0/s);
}
float2 gamma(const float2 s)
{
// Float2 version:
return gamma_impl(s, 1.0/s);
}
float gamma(const float s)
{
// Float version:
return gamma_impl(s, 1.0/s);
}
//////////////// INCOMPLETE GAMMA FUNCTIONS (RESTRICTED INPUT) ///////////////
// Lower incomplete gamma function for small s and z (implementation):
float4 ligamma_small_z_impl(const float4 s, const float4 z, const float4 s_inv)
{
// Requires: 1.) s < ~0.5
// 2.) z <= ~0.775075
// 3.) s_inv = 1.0/s (precomputed for outside reuse)
// Returns: A series representation for the lower incomplete gamma
// function for small s and small z (4 terms).
// The actual "rolled up" summation looks like:
// last_sign = 1.0; last_pow = 1.0; last_factorial = 1.0;
// sum = last_sign * last_pow / ((s + k) * last_factorial)
// for(int i = 0; i < 4; ++i)
// {
// last_sign *= -1.0; last_pow *= z; last_factorial *= i;
// sum += last_sign * last_pow / ((s + k) * last_factorial);
// }
// Unrolled, constant-unfolded and arranged for madds and parallelism:
const float4 scale = pow(z, s);
float4 sum = s_inv; // Summation iteration 0 result
// Summation iterations 1, 2, and 3:
const float4 z_sq = z*z;
const float4 denom1 = s + 1.0;
const float4 denom2 = 2.0*s + 4.0;
const float4 denom3 = 6.0*s + 18.0;
//float4 denom4 = 24.0*s + float4(96.0);
sum -= z/denom1;
sum += z_sq/denom2;
sum -= z * z_sq/denom3;
//sum += z_sq * z_sq / denom4;
// Scale and return:
return scale * sum;
}
float3 ligamma_small_z_impl(const float3 s, const float3 z, const float3 s_inv)
{
// Float3 version:
const float3 scale = pow(z, s);
float3 sum = s_inv;
const float3 z_sq = z*z;
const float3 denom1 = s + 1.0;
const float3 denom2 = 2.0*s + 4.0;
const float3 denom3 = 6.0*s + 18.0;
sum -= z/denom1;
sum += z_sq/denom2;
sum -= z * z_sq/denom3;
return scale * sum;
}
float2 ligamma_small_z_impl(const float2 s, const float2 z, const float2 s_inv)
{
// Float2 version:
const float2 scale = pow(z, s);
float2 sum = s_inv;
const float2 z_sq = z*z;
const float2 denom1 = s + 1.0;
const float2 denom2 = 2.0*s + 4.0;
const float2 denom3 = 6.0*s + 18.0;
sum -= z/denom1;
sum += z_sq/denom2;
sum -= z * z_sq/denom3;
return scale * sum;
}
float ligamma_small_z_impl(const float s, const float z, const float s_inv)
{
// Float version:
const float scale = pow(z, s);
float sum = s_inv;
const float z_sq = z*z;
const float denom1 = s + 1.0;
const float denom2 = 2.0*s + 4.0;
const float denom3 = 6.0*s + 18.0;
sum -= z/denom1;
sum += z_sq/denom2;
sum -= z * z_sq/denom3;
return scale * sum;
}
// Upper incomplete gamma function for small s and large z (implementation):
float4 uigamma_large_z_impl(const float4 s, const float4 z)
{
// Requires: 1.) s < ~0.5
// 2.) z > ~0.775075
// Returns: Gauss's continued fraction representation for the upper
// incomplete gamma function (4 terms).
// The "rolled up" continued fraction looks like this. The denominator
// is truncated, and it's calculated "from the bottom up:"
// denom = float4('inf');
// float4 one = float4(1.0);
// for(int i = 4; i > 0; --i)
// {
// denom = ((i * 2.0) - one) + z - s + (i * (s - i))/denom;
// }
// Unrolled and constant-unfolded for madds and parallelism:
const float4 numerator = pow(z, s) * exp(-z);
float4 denom = 7.0 + z - s;
denom = 5.0 + z - s + (3.0*s - 9.0)/denom;
denom = 3.0 + z - s + (2.0*s - 4.0)/denom;
denom = 1.0 + z - s + (s - 1.0)/denom;
return numerator / denom;
}
float3 uigamma_large_z_impl(const float3 s, const float3 z)
{
// Float3 version:
const float3 numerator = pow(z, s) * exp(-z);
float3 denom = 7.0 + z - s;
denom = 5.0 + z - s + (3.0*s - 9.0)/denom;
denom = 3.0 + z - s + (2.0*s - 4.0)/denom;
denom = 1.0 + z - s + (s - 1.0)/denom;
return numerator / denom;
}
float2 uigamma_large_z_impl(const float2 s, const float2 z)
{
// Float2 version:
const float2 numerator = pow(z, s) * exp(-z);
float2 denom = 7.0 + z - s;
denom = 5.0 + z - s + (3.0*s - 9.0)/denom;
denom = 3.0 + z - s + (2.0*s - 4.0)/denom;
denom = 1.0 + z - s + (s - 1.0)/denom;
return numerator / denom;
}
float uigamma_large_z_impl(const float s, const float z)
{
// Float version:
const float numerator = pow(z, s) * exp(-z);
float denom = 7.0 + z - s;
denom = 5.0 + z - s + (3.0*s - 9.0)/denom;
denom = 3.0 + z - s + (2.0*s - 4.0)/denom;
denom = 1.0 + z - s + (s - 1.0)/denom;
return numerator / denom;
}
// Normalized lower incomplete gamma function for small s (implementation):
float4 normalized_ligamma_impl(const float4 s, const float4 z,
const float4 s_inv, const float4 gamma_s_inv)
{
// Requires: 1.) s < ~0.5
// 2.) s_inv = 1/s (precomputed for outside reuse)
// 3.) gamma_s_inv = 1/gamma(s) (precomputed for outside reuse)
// Returns: Approximate the normalized lower incomplete gamma function
// for s < 0.5. Since we only care about s < 0.5, we only need
// to evaluate two branches (not four) based on z. Each branch
// uses four terms, with a max relative error of ~0.00182. The
// branch threshold and specifics were adapted for fewer terms
// from Gil/Segura/Temme's paper here:
// http://oai.cwi.nl/oai/asset/20433/20433B.pdf
// Evaluate both branches: Real branches test slower even when available.
static const float thresh = 0.775075;
int4 z_is_large;
z_is_large.x = int(z.x > thresh);
z_is_large.y = int(z.y > thresh);
z_is_large.z = int(z.z > thresh);
z_is_large.w = int(z.w > thresh);
const float4 large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv;
const float4 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv;
// Combine the results from both branches:
int4 inverse_z_is_large = saturate(~(z_is_large));
return large_z * float4(z_is_large) + small_z * float4(inverse_z_is_large);
}
float3 normalized_ligamma_impl(const float3 s, const float3 z,
const float3 s_inv, const float3 gamma_s_inv)
{
// Float3 version:
static const float thresh = 0.775075;
int3 z_is_large;
z_is_large.x = int(z.x > thresh);
z_is_large.y = int(z.y > thresh);
z_is_large.z = int(z.z > thresh);
const float3 large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv;
const float3 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv;
int3 inverse_z_is_large = saturate(~(z_is_large));
return large_z * float3(z_is_large) + small_z * float3(inverse_z_is_large);
}
float2 normalized_ligamma_impl(const float2 s, const float2 z,
const float2 s_inv, const float2 gamma_s_inv)
{
// Float2 version:
static const float thresh = 0.775075;
int2 z_is_large;
z_is_large.x = int(z.x > thresh);
z_is_large.y = int(z.y > thresh);
const float2 large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv;
const float2 small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv;
int2 inverse_z_is_large = saturate(~(z_is_large));
return large_z * float2(z_is_large) + small_z * float2(inverse_z_is_large);
}
float normalized_ligamma_impl(const float s, const float z,
const float s_inv, const float gamma_s_inv)
{
// Float version:
static const float thresh = 0.775075;
const bool z_is_large = z > thresh;
const float large_z = 1.0 - uigamma_large_z_impl(s, z) * gamma_s_inv;
const float small_z = ligamma_small_z_impl(s, z, s_inv) * gamma_s_inv;
return large_z * float(z_is_large) + small_z * float(!z_is_large);
}
// Normalized lower incomplete gamma function for small s:
float4 normalized_ligamma(const float4 s, const float4 z)
{
// Requires: s < ~0.5
// Returns: Approximate the normalized lower incomplete gamma function
// for s < 0.5. See normalized_ligamma_impl() for details.
const float4 s_inv = 1.0/s;
const float4 gamma_s_inv = 1.0/gamma_impl(s, s_inv);
return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv);
}
float3 normalized_ligamma(const float3 s, const float3 z)
{
// Float3 version:
const float3 s_inv = 1.0/s;
const float3 gamma_s_inv = 1.0/gamma_impl(s, s_inv);
return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv);
}
float2 normalized_ligamma(const float2 s, const float2 z)
{
// Float2 version:
const float2 s_inv = 1.0/s;
const float2 gamma_s_inv = 1.0/gamma_impl(s, s_inv);
return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv);
}
float normalized_ligamma(const float s, const float z)
{
// Float version:
const float s_inv = 1.0/s;
const float gamma_s_inv = 1.0/gamma_impl(s, s_inv);
return normalized_ligamma_impl(s, z, s_inv, gamma_s_inv);
}
#endif // _SPECIAL_FUNCTIONS_H

1393
data/resources/shaders/reshade/Shaders/crt-royale/lib/tex2Dantialias.fxh Normal file
View File

File diff suppressed because it is too large Load Diff

428
data/resources/shaders/reshade/Shaders/crt-royale/lib/user-settings.fxh Normal file
View File

@ -0,0 +1,428 @@
#ifndef _USER_SETTINGS_H
#define _USER_SETTINGS_H
///////////////////////////// DRIVER CAPABILITIES ////////////////////////////
// The Cg compiler uses different "profiles" with different capabilities.
// This shader requires a Cg compilation profile >= arbfp1, but a few options
// require higher profiles like fp30 or fp40. The shader can't detect profile
// or driver capabilities, so instead you must comment or uncomment the lines
// below with "//" before "#define." Disable an option if you get compilation
// errors resembling those listed. Generally speaking, all of these options
// will run on nVidia cards, but only _DRIVERS_ALLOW_TEX2DBIAS (if that) is
// likely to run on ATI/AMD, due to the Cg compiler's profile limitations.
// Derivatives: Unsupported on fp20, ps_1_1, ps_1_2, ps_1_3, and arbfp1.
// Among other things, derivatives help us fix anisotropic filtering artifacts
// with curved manually tiled phosphor mask coords. Related errors:
// error C3004: function "float2 ddx(float2);" not supported in this profile
// error C3004: function "float2 ddy(float2);" not supported in this profile
#ifndef _DRIVERS_ALLOW_DERIVATIVES
#define _DRIVERS_ALLOW_DERIVATIVES 0
#endif
// Fine derivatives: Unsupported on older ATI cards.
// Fine derivatives enable 2x2 fragment block communication, letting us perform
// fast single-pass blur operations. If your card uses coarse derivatives and
// these are enabled, blurs could look broken. Derivatives are a prerequisite.
#if _DRIVERS_ALLOW_DERIVATIVES
#define _DRIVERS_ALLOW_FINE_DERIVATIVES
#endif
// Dynamic looping: Requires an fp30 or newer profile.
// This makes phosphor mask resampling faster in some cases. Related errors:
// error C5013: profile does not support "for" statements and "for" could not
// be unrolled
#ifndef _DRIVERS_ALLOW_DYNAMIC_BRANCHES
#define _DRIVERS_ALLOW_DYNAMIC_BRANCHES 0
#endif
// Without _DRIVERS_ALLOW_DYNAMIC_BRANCHES, we need to use unrollable loops.
// Using one static loop avoids overhead if the user is right, but if the user
// is wrong (loops are allowed), breaking a loop into if-blocked pieces with a
// binary search can potentially save some iterations. However, it may fail:
// error C6001: Temporary register limit of 32 exceeded; 35 registers
// needed to compile program
#ifndef _ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS
#define _ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS 0
#endif
// tex2Dlod: Requires an fp40 or newer profile. This can be used to disable
// anisotropic filtering, thereby fixing related artifacts. Related errors:
// error C3004: function "float4 tex2Dlod(sampler2D, float4);" not supported in
// this profile
// #ifndef _DRIVERS_ALLOW_TEX2DLOD
// #define _DRIVERS_ALLOW_TEX2DLOD 1
// #endif
// tex2Dbias: Requires an fp30 or newer profile. This can be used to alleviate
// artifacts from anisotropic filtering and mipmapping. Related errors:
// error C3004: function "float4 tex2Dbias(sampler2D, float4);" not supported
// in this profile
// #ifndef _DRIVERS_ALLOW_TEX2DBIAS
// #define _DRIVERS_ALLOW_TEX2DBIAS 0
// #endif
// Integrated graphics compatibility: Integrated graphics like Intel HD 4000
// impose stricter limitations on register counts and instructions. Enable
// _INTEGRATED_GRAPHICS_COMPATIBILITY_MODE if you still see error C6001 or:
// error C6002: Instruction limit of 1024 exceeded: 1523 instructions needed
// to compile program.
// Enabling integrated graphics compatibility mode will automatically disable:
// 1.) _PHOSPHOR_MASK_MANUALLY_RESIZE: The phosphor mask will be softer.
// (This may be reenabled in a later release.)
// 2.) _RUNTIME_GEOMETRY_MODE
// 3.) The high-quality 4x4 Gaussian resize for the bloom approximation
#ifndef _INTEGRATED_GRAPHICS_COMPATIBILITY_MODE
#define _INTEGRATED_GRAPHICS_COMPATIBILITY_MODE 0
#endif
//////////////////////////// USER CODEPATH OPTIONS ///////////////////////////
// To disable a #define option, turn its line into a comment with "//."
// RUNTIME VS. COMPILE-TIME OPTIONS (Major Performance Implications):
// Enable runtime shader parameters in the Retroarch (etc.) GUI? They override
// many of the options in this file and allow real-time tuning, but many of
// them are slower. Disabling them and using this text file will boost FPS.
#ifndef _RUNTIME_SHADER_PARAMS_ENABLE
#define _RUNTIME_SHADER_PARAMS_ENABLE 1
#endif
// Specify the phosphor bloom sigma at runtime? This option is 10% slower, but
// it's the only way to do a wide-enough full bloom with a runtime dot pitch.
#ifndef _RUNTIME_PHOSPHOR_BLOOM_SIGMA
#define _RUNTIME_PHOSPHOR_BLOOM_SIGMA 1
#endif
// Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics)
#ifndef _RUNTIME_ANTIALIAS_WEIGHTS
#define _RUNTIME_ANTIALIAS_WEIGHTS 1
#endif
// Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!)
#ifndef _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
#define _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS 0
#endif
// Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader
// parameters? This will require more math or dynamic branching.
#ifndef _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
#define _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE 1
#endif
// Specify the tilt at runtime? This makes things about 3% slower.
// akgunter:
// This is used in crt-royale-geometry-aa-last-pass.fxh.
// I've hard-coded it to 1 and hidden it from the UI in the ReShade version because
// I don't know a good way to port that logic. If anyone ever does figure that
// out, we can uncomment and port that logic and then unhide this definition.
#define _RUNTIME_GEOMETRY_TILT 1
// Specify the geometry mode at runtime?
#ifndef _RUNTIME_GEOMETRY_MODE
#define _RUNTIME_GEOMETRY_MODE 1
#endif
// Specify the phosphor mask type (aperture grille, slot mask, shadow mask) and
// mode (Lanczos-resize, hardware resize, or tile 1:1) at runtime, even without
// dynamic branches? This is cheap if mask_resize_viewport_scale is small.
// #ifndef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT 1
// #endif
// PHOSPHOR MASK:
// Choose between a 64x64 or 512x512 source for the phosphor mask
// Mainly affects Sample Mode 1
// #ifndef USE_LARGE_PHOSPHOR_MASK
// #define USE_LARGE_PHOSPHOR_MASK 1
// #endif
// Manually resize the phosphor mask for best results (slower)? Disabling this
// removes the option to do so, but it may be faster without dynamic branches.
#ifndef _PHOSPHOR_MASK_MANUALLY_RESIZE
#define _PHOSPHOR_MASK_MANUALLY_RESIZE 1
#endif
// If we sinc-resize the mask, should we Lanczos-window it (slower but better)?
// #ifndef PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW
// #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW 1
// #endif
// Larger blurs are expensive, but we need them to blur larger triads. We can
// detect the right blur if the triad size is static or our profile allows
// dynamic branches, but otherwise we use the largest blur the user indicates
// they might need:
#define _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS 1
#define _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS 2
#define _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS 3
#define _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS 4
#if !_RUNTIME_PHOSPHOR_BLOOM_SIGMA
#ifndef PHOSPHOR_BLOOM_TRIAD_SIZE_MODE
#define PHOSPHOR_BLOOM_TRIAD_SIZE_MODE _PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS // [0 - 4]
#endif
#endif
// Here's a helpful chart:
// MaxTriadSize BlurSize MinTriadCountsByResolution
// 3.0 9.0 480/640/960/1920 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
// 6.0 17.0 240/320/480/960 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
// 9.0 25.0 160/213/320/640 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
// 12.0 31.0 120/160/240/480 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
// 18.0 43.0 80/107/160/320 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
/////////////////////////////// USER PARAMETERS //////////////////////////////
// Note: Many of these static parameters are overridden by runtime shader
// parameters when those are enabled. However, many others are static codepath
// options that were cleaner or more convert to code as static constants.
// GAMMA:
static const float crt_gamma_static = 2.5; // range [1, 5]
static const float lcd_gamma_static = 2.2; // range [1, 5]
// LEVELS MANAGEMENT:
// Control the final multiplicative image contrast:
static const float levels_contrast_static = 1.0; // range [0, 4)
// We auto-dim to avoid clipping between passes and restore brightness
// later. Control the dim factor here: Lower values clip less but crush
// blacks more (static only for now).
static const float levels_autodim_temp = 0.5; // range (0, 1] default is 0.5 but that was unnecessarily dark for me, so I set it to 1.0
// HALATION/DIFFUSION/BLOOM:
// Halation weight: How much energy should be lost to electrons bounding
// around under the CRT glass and exciting random phosphors?
static const float halation_weight_static = 0.0; // range [0, 1]
// Refractive diffusion weight: How much light should spread/diffuse from
// refracting through the CRT glass?
static const float diffusion_weight_static = 0.075; // range [0, 1]
// Underestimate brightness: Bright areas bloom more, but we can base the
// bloom brightpass on a lower brightness to sharpen phosphors, or a higher
// brightness to soften them. Low values clip, but >= 0.8 looks okay.
static const float bloom_underestimate_levels_static = 0.8; // range [0, 5]
// Blur all colors more than necessary for a softer phosphor bloom?
static const float bloom_excess_static = 0.0; // range [0, 1]
// The BLOOM_APPROX pass approximates a phosphor blur early on with a small
// blurred resize of the input (convergence offsets are applied as well).
// There are three filter options (static option only for now):
// 0.) Bilinear resize: A fast, close approximation to a 4x4 resize
// if min_allowed_viewport_triads and the BLOOM_APPROX resolution are sane
// and gaussian_beam_max_sigma is low.
// 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring,
// always uses a static sigma regardless of gaussian_beam_max_sigma or
// mask_num_triads_across.
// 2.) True 4x4 Gaussian resize: Slowest, technically correct.
// These options are more pronounced for the fast, unbloomed shader version.
#ifndef RADEON_FIX
#define RADEON_FIX 0
#endif
#if !RADEON_FIX
static const float bloom_approx_filter_static = 2.0;
#else
static const float bloom_approx_filter_static = 1.0;
#endif
// ELECTRON BEAM SCANLINE DISTRIBUTION:
// How many scanlines should contribute light to each pixel? Using more
// scanlines is slower (especially for a generalized Gaussian) but less
// distorted with larger beam sigmas (especially for a pure Gaussian). The
// max_beam_sigma at which the closest unused weight is guaranteed <
// 1.0/255.0 (for a 3x antialiased pure Gaussian) is:
// 2 scanlines: max_beam_sigma = 0.2089; distortions begin ~0.34; 141.7 FPS pure, 131.9 FPS generalized
// 3 scanlines, max_beam_sigma = 0.3879; distortions begin ~0.52; 137.5 FPS pure; 123.8 FPS generalized
// 4 scanlines, max_beam_sigma = 0.5723; distortions begin ~0.70; 134.7 FPS pure; 117.2 FPS generalized
// 5 scanlines, max_beam_sigma = 0.7591; distortions begin ~0.89; 131.6 FPS pure; 112.1 FPS generalized
// 6 scanlines, max_beam_sigma = 0.9483; distortions begin ~1.08; 127.9 FPS pure; 105.6 FPS generalized
static const float beam_num_scanlines = 3.0; // range [2, 6]
// A generalized Gaussian beam varies shape with color too, now just width.
// It's slower but more flexible (static option only for now).
static const bool beam_generalized_gaussian = true;
// What kind of scanline antialiasing do you want?
// 0: Sample weights at 1x; 1: Sample weights at 3x; 2: Compute an integral
// Integrals are slow (especially for generalized Gaussians) and rarely any
// better than 3x antialiasing (static option only for now).
static const float beam_antialias_level = 1.0; // range [0, 2]
// Min/max standard deviations for scanline beams: Higher values widen and
// soften scanlines. Depending on other options, low min sigmas can alias.
static const float gaussian_beam_min_sigma_static = 0.02; // range (0, 1]
static const float gaussian_beam_max_sigma_static = 0.3; // range (0, 1]
// Beam width varies as a function of color: A power function (0) is more
// configurable, but a spherical function (1) gives the widest beam
// variability without aliasing (static option only for now).
static const float beam_spot_shape_function = 0.0;
// Spot shape power: Powers <= 1 give smoother spot shapes but lower
// sharpness. Powers >= 1.0 are awful unless mix/max sigmas are close.
static const float gaussian_beam_spot_power_static = 1.0/3.0; // range (0, 16]
// Generalized Gaussian max shape parameters: Higher values give flatter
// scanline plateaus and steeper dropoffs, simultaneously widening and
// sharpening scanlines at the cost of aliasing. 2.0 is pure Gaussian, and
// values > ~40.0 cause artifacts with integrals.
static const float gaussian_beam_min_shape_static = 2.0; // range [2, 32]
static const float gaussian_beam_max_shape_static = 4.0; // range [2, 32]
// Generalized Gaussian shape power: Affects how quickly the distribution
// changes shape from Gaussian to steep/plateaued as color increases from 0
// to 1.0. Higher powers appear softer for most colors, and lower powers
// appear sharper for most colors.
static const float gaussian_beam_shape_power_static = 1.0/4.0; // range (0, 16]
// What filter should be used to sample scanlines horizontally?
// 0: Quilez (fast), 1: Gaussian (configurable), 2: Lanczos2 (sharp)
static const float beam_horiz_filter_static = 0.0;
// Standard deviation for horizontal Gaussian resampling:
static const float beam_horiz_sigma_static = 0.35; // range (0, 2/3]
// Do horizontal scanline sampling in linear RGB (correct light mixing),
// gamma-encoded RGB (darker, hard spot shape, may better match bandwidth-
// limiting circuitry in some CRT's), or a weighted avg.?
static const float beam_horiz_linear_rgb_weight_static = 1.0; // range [0, 1]
// Simulate scanline misconvergence? This needs 3x horizontal texture
// samples and 3x texture samples of BLOOM_APPROX and HALATION_BLUR in
// later passes (static option only for now).
static const bool beam_misconvergence = true;
// Convergence offsets in x/y directions for R/G/B scanline beams in units
// of scanlines. Positive offsets go right/down; ranges [-2, 2]
static const float2 convergence_offsets_r_static = float2(0.1, 0.2);
static const float2 convergence_offsets_g_static = float2(0.3, 0.4);
static const float2 convergence_offsets_b_static = float2(0.5, 0.6);
// Detect interlacing (static option only for now)?
static const bool interlace_detect = true;
// Assume 1080-line sources are interlaced?
static const bool interlace_1080i_static = false;
// For interlaced sources, assume TFF (top-field first) or BFF order?
// (Whether this matters depends on the nature of the interlaced input.)
static const bool interlace_back_field_first_static = false;
// ANTIALIASING:
// What AA level do you want for curvature/overscan/subpixels? Options:
// 0x (none), 1x (sample subpixels), 4x, 5x, 6x, 7x, 8x, 12x, 16x, 20x, 24x
// (Static option only for now)
#ifndef antialias_level
#define antialias_level 0.0
#endif
// static const float aa_level = 12.0; // range [0, 24]
// static const float aa_level = 0.0; // range [0, 24]
// What antialiasing filter do you want (static option only)? Options:
// 0: Box (separable), 1: Box (cylindrical),
// 2: Tent (separable), 3: Tent (cylindrical),
// 4: Gaussian (separable), 5: Gaussian (cylindrical),
// 6: Cubic* (separable), 7: Cubic* (cylindrical, poor)
// 8: Lanczos Sinc (separable), 9: Lanczos Jinc (cylindrical, poor)
// * = Especially slow with _RUNTIME_ANTIALIAS_WEIGHTS
#ifndef antialias_filter
#define antialias_filter 6
#endif
static const float aa_filter = antialias_filter; // range [0, 9]
// Flip the sample grid on odd/even frames (static option only for now)?
#ifndef antialias_temporal
#define antialias_temporal false
#endif
static const bool aa_temporal = antialias_temporal;
// Use RGB subpixel offsets for antialiasing? The pixel is at green, and
// the blue offset is the negative r offset; range [0, 0.5]
static const float2 aa_subpixel_r_offset_static = float2(-1.0/3.0, 0.0);//float2(0.0);
// Cubics: See http://www.imagemagick.org/Usage/filter/#mitchell
// 1.) "Keys cubics" with B = 1 - 2C are considered the highest quality.
// 2.) C = 0.5 (default) is Catmull-Rom; higher C's apply sharpening.
// 3.) C = 1.0/3.0 is the Mitchell-Netravali filter.
// 4.) C = 0.0 is a soft spline filter.
static const float aa_cubic_c_static = 0.5; // range [0, 4]
// Standard deviation for Gaussian antialiasing: Try 0.5/aa_pixel_diameter.
static const float aa_gauss_sigma_static = 0.5; // range [0.0625, 1.0]
// PHOSPHOR MASK:
// Mask type: 0 = aperture grille, 1 = slot mask, 2 = shadow mask
// 3 = lowres grille, 4 = lowres slot, 5 = lowres shadow
static const float mask_type_static = 4.0; // range [0, 5]
// We can sample the mask three ways. Pick 2/3 from: Pretty/Fast/Flexible.
// 0.) Sinc-resize to the desired dot pitch manually (pretty/slow/flexible).
// This requires _PHOSPHOR_MASK_MANUALLY_RESIZE to be #defined.
// 1.) Hardware-resize to the desired dot pitch (ugly/fast/flexible). This
// is halfway decent with LUT mipmapping but atrocious without it.
// 2.) Tile it without resizing at a 1:1 texel:pixel ratio for flat coords
// (pretty/fast/inflexible). Each input LUT has a fixed dot pitch.
// This mode reuses the same masks, so triads will be enormous unless
// you change the mask LUT filenames in your .cgp file.
static const float mask_sample_mode_static = 0.0; // range [0, 2]
// Prefer setting the triad size (0.0) or number on the screen (1.0)?
// If _RUNTIME_PHOSPHOR_BLOOM_SIGMA isn't #defined, the specified triad size
// will always be used to calculate the full bloom sigma statically.
static const float mask_size_param_static = 0.0; // range [0, 1]
// Specify the phosphor triad size, in pixels. Each tile (usually with 8
// triads) will be rounded to the nearest integer tile size and clamped to
// obey minimum size constraints (imposed to reduce downsize taps) and
// maximum size constraints (imposed to have a sane MASK_RESIZE FBO size).
// To increase the size limit, double the viewport-relative scales for the
// two MASK_RESIZE passes in crt-royale.cgp and user-cgp-contants.h.
// range [1, mask_texture_small_size/mask_triads_per_tile]
static const float mask_triad_width_static = 24.0 / 8.0;
// If mask_size_param is 1.0/true, we'll go by this instead (the
// final size will be rounded and constrained as above); default 480.0
static const float mask_num_triads_across_static = 480.0;
// How many lobes should the sinc/Lanczos resizer use? More lobes require
// more samples and avoid moire a bit better, but some is unavoidable
// depending on the destination size (static option for now).
static const float mask_sinc_lobes = 3.0; // range [2, 4]
// The mask is resized using a variable number of taps in each dimension,
// but some Cg profiles always fetch a constant number of taps no matter
// what (no dynamic branching). We can limit the maximum number of taps if
// we statically limit the minimum phosphor triad size. Larger values are
// faster, but the limit IS enforced (static option only, forever);
// range [1, mask_texture_small_size/mask_triads_per_tile]
// TODO: Make this 1.0 and compensate with smarter sampling!
static const float mask_min_allowed_triad_size = 2.0;
// GEOMETRY:
// Geometry mode:
// 0: Off (default), 1: Spherical mapping (like cgwg's),
// 2: Alt. spherical mapping (more bulbous), 3: Cylindrical/Trinitron
static const float geom_mode_static = 0.0; // range [0, 3]
// Radius of curvature: Measured in units of your viewport's diagonal size.
static const float geom_radius_static = 2.0; // range [1/(2*pi), 1024]
// View dist is the distance from the player to their physical screen, in
// units of the viewport's diagonal size. It controls the field of view.
static const float geom_view_dist_static = 2.0; // range [0.5, 1024]
// Tilt angle in radians (clockwise around up and right vectors):
static const float2 geom_tilt_angle_static = float2(0.0, 0.0); // range [-pi, pi]
// Aspect ratio: When the true viewport size is unknown, this value is used
// to help convert between the phosphor triad size and count, along with
// the mask_resize_viewport_scale constant from user-cgp-constants.h. Set
// this equal to Retroarch's display aspect ratio (DAR) for best results;
// range [1, geom_max_aspect_ratio from user-cgp-constants.h];
// default (256/224)*(54/47) = 1.313069909 (see below)
static const float geom_aspect_ratio_static = 1.313069909;
// Before getting into overscan, here's some general aspect ratio info:
// - DAR = display aspect ratio = SAR * PAR; as in your Retroarch setting
// - SAR = storage aspect ratio = DAR / PAR; square pixel emulator frame AR
// - PAR = pixel aspect ratio = DAR / SAR; holds regardless of cropping
// Geometry processing has to "undo" the screen-space 2D DAR to calculate
// 3D view vectors, then reapplies the aspect ratio to the simulated CRT in
// uv-space. To ensure the source SAR is intended for a ~4:3 DAR, either:
// a.) Enable Retroarch's "Crop Overscan"
// b.) Readd horizontal padding: Set overscan to e.g. N*(1.0, 240.0/224.0)
// Real consoles use horizontal black padding in the signal, but emulators
// often crop this without cropping the vertical padding; a 256x224 [S]NES
// frame (8:7 SAR) is intended for a ~4:3 DAR, but a 256x240 frame is not.
// The correct [S]NES PAR is 54:47, found by blargg and NewRisingSun:
// http://board.zsnes.com/phpBB3/viewtopic.php?f=22&t=11928&start=50
// http://forums.nesdev.com/viewtopic.php?p=24815#p24815
// For flat output, it's okay to set DAR = [existing] SAR * [correct] PAR
// without doing a. or b., but horizontal image borders will be tighter
// than vertical ones, messing up curvature and overscan. Fixing the
// padding first corrects this.
// Overscan: Amount to "zoom in" before cropping. You can zoom uniformly
// or adjust x/y independently to e.g. readd horizontal padding, as noted
// above: Values < 1.0 zoom out; range (0, inf)
static const float2 geom_overscan_static = float2(1.0, 1.0);// * 1.005 * (1.0, 240/224.0)
// Compute a proper pixel-space to texture-space matrix even without ddx()/
// ddy()? This is ~8.5% slower but improves antialiasing/subpixel filtering
// with strong curvature (static option only for now).
static const bool geom_force_correct_tangent_matrix = true;
// BORDERS:
// Rounded border size in texture uv coords:
static const float border_size_static = 0.015; // range [0, 0.5]
// Border darkness: Moderate values darken the border smoothly, and high
// values make the image very dark just inside the border:
static const float border_darkness_static = 2.0; // range [0, inf)
// Border compression: High numbers compress border transitions, narrowing
// the dark border area.
static const float border_compress_static = 2.5; // range [1, inf)
// TODO: Nuke this
#define mask_size_xy float2(512, 512)
#endif // _USER_SETTINGS_H

149
data/resources/shaders/reshade/Shaders/crt-royale/shaders/bloom.fxh Normal file
View File

@ -0,0 +1,149 @@
#ifndef _BLOOM_H
#define _BLOOM_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
#include "../lib/user-settings.fxh"
#include "../lib/derived-settings-and-constants.fxh"
#include "../lib/bind-shader-params.fxh"
#include "../lib/gamma-management.fxh"
#include "../lib/downsampling-functions.fxh"
#include "../lib/blur-functions.fxh"
#include "../lib/bloom-functions.fxh"
#include "shared-objects.fxh"
void approximateBloomVertPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
const float2 delta_uv = blur_radius * float2(0.0, rcp(TEX_BEAMCONVERGENCE_HEIGHT));
color = float4(opaque_linear_downsample(
samplerBeamConvergence, texcoord,
uint((bloomapprox_downsizing_factor - 1)/2),
delta_uv
), 1);
}
void approximateBloomHorizPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
const float2 delta_uv = blur_radius * float2(rcp(TEX_BEAMCONVERGENCE_WIDTH), 0.0);
color = float4(opaque_linear_downsample(
samplerBloomApproxVert, texcoord,
uint((bloomapprox_downsizing_factor - 1)/2),
delta_uv
), 1);
}
void bloomHorizontalVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float bloom_sigma_runtime : TEXCOORD1
) {
PostProcessVS(id, position, texcoord);
bloom_sigma_runtime = get_min_sigma_to_blur_triad(calc_triad_size().x, bloom_diff_thresh_);
}
void bloomHorizontalPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float bloom_sigma_runtime : TEXCOORD1,
out float4 color : SV_Target
) {
const float2 bloom_dxdy = float2(rcp(TEX_BLOOMVERTICAL_WIDTH), 0);
// Blur the vertically blurred brightpass horizontally by 9/17/25/43x:
const float bloom_sigma = get_final_bloom_sigma(bloom_sigma_runtime);
const float3 blurred_brightpass = tex2DblurNfast(samplerBloomVertical,
texcoord, bloom_dxdy, bloom_sigma, get_intermediate_gamma());
// Sample the masked scanlines. Alpha contains the auto-dim factor:
const float3 intensity_dim = tex2D_linearize(samplerMaskedScanlines, texcoord, get_intermediate_gamma()).rgb;
const float auto_dim_factor = levels_autodim_temp;
const float undim_factor = 1.0/auto_dim_factor;
// Calculate the mask dimpass, add it to the blurred brightpass, and
// undim (from scanline auto-dim) and amplify (from mask dim) the result:
const float mask_amplify = get_mask_amplify();
const float3 brightpass = tex2D_linearize(samplerBrightpass, texcoord, get_intermediate_gamma()).rgb;
const float3 dimpass = intensity_dim - brightpass;
const float3 phosphor_bloom = (dimpass + blurred_brightpass) *
mask_amplify * undim_factor * levels_contrast;
// Sample the halation texture, and let some light bleed into refractive
// diffusion. Conceptually this occurs before the phosphor bloom, but
// adding it in earlier passes causes black crush in the diffusion colors.
const float3 raw_diffusion_color = tex2D_linearize(samplerBlurHorizontal, texcoord, get_intermediate_gamma()).rgb;
const float3 raw_halation_color = dot(raw_diffusion_color, float3(1, 1, 1)) / 3.0;
const float3 diffusion_color = levels_contrast * lerp(raw_diffusion_color, raw_halation_color, halation_weight);
const float3 final_bloom = lerp(phosphor_bloom, diffusion_color, diffusion_weight);
// Encode and output the bloomed image:
color = encode_output(float4(final_bloom, 1.0), get_intermediate_gamma());
}
void bloomVerticalVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float bloom_sigma_runtime : TEXCOORD1
) {
PostProcessVS(id, position, texcoord);
bloom_sigma_runtime = get_min_sigma_to_blur_triad(calc_triad_size().x, bloom_diff_thresh_);
}
void bloomVerticalPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float bloom_sigma_runtime : TEXCOORD1,
out float4 color : SV_Target
) {
const float2 bloom_dxdy = float2(0, rcp(TEX_BLOOMVERTICAL_HEIGHT));
// Blur the brightpass horizontally with a 9/17/25/43x blur:
const float bloom_sigma = get_final_bloom_sigma(bloom_sigma_runtime);
const float3 color3 = tex2DblurNfast(samplerBrightpass, texcoord,
bloom_dxdy, bloom_sigma, get_intermediate_gamma());
// Encode and output the blurred image:
color = encode_output(float4(color3, 1.0), get_intermediate_gamma());
}
#endif // _BLOOM_H

131
data/resources/shaders/reshade/Shaders/crt-royale/shaders/blurring.fxh Normal file
View File

@ -0,0 +1,131 @@
#ifndef _BLURRING_H
#define _BLURRING_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
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2014 TroggleMonkey
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "../lib/gamma-management.fxh"
#include "../lib/blur-functions.fxh"
#include "shared-objects.fxh"
void blurHorizontalVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float2 blur_dxdy : TEXCOORD1
) {
PostProcessVS(id, position, texcoord);
// Get the uv sample distance between output pixels. Blurs are not generic
// Gaussian resizers, and correct blurs require:
// 1.) OutputSize == InputSize * 2^m, where m is an integer <= 0.
// 2.) mipmap_inputN = "true" for this pass in the preset if m != 0
// 3.) filter_linearN = "true" except for 1x scale nearest neighbor blurs
// Gaussian resizers would upsize using the distance between input texels
// (not output pixels), but we avoid this and consistently blur at the
// destination size. Otherwise, combining statically calculated weights
// with bilinear sample exploitation would result in terrible artifacts.
static const float2 output_size = TEX_BLURHORIZONTAL_SIZE;
static const float2 dxdy = 1.0 / output_size;
// This blur is vertical-only, so zero out the horizontal offset:
blur_dxdy = float2(dxdy.x, 0.0);
}
void blurHorizontalPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float2 blur_dxdy : TEXCOORD1,
out float4 color : SV_Target
) {
static const float3 blur_color = tex2Dblur9fast(samplerBlurVertical, texcoord, blur_dxdy, get_intermediate_gamma());
// Encode and output the blurred image:
// color = encode_output(float4(blur_color, 1.0), 1.0);
color = encode_output(float4(blur_color, 1.0), get_intermediate_gamma());
}
void blurVerticalVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float2 blur_dxdy : TEXCOORD1
) {
PostProcessVS(id, position, texcoord);
// Get the uv sample distance between output pixels. Blurs are not generic
// Gaussian resizers, and correct blurs require:
// 1.) OutputSize == InputSize * 2^m, where m is an integer <= 0.
// 2.) mipmap_inputN = "true" for this pass in the preset if m != 0
// 3.) filter_linearN = "true" except for 1x scale nearest neighbor blurs
// Gaussian resizers would upsize using the distance between input texels
// (not output pixels), but we avoid this and consistently blur at the
// destination size. Otherwise, combining statically calculated weights
// with bilinear sample exploitation would result in terrible artifacts.
static const float2 output_size = TEX_BLURVERTICAL_SIZE;
static const float2 dxdy = 1.0 / output_size;
// This blur is vertical-only, so zero out the horizontal offset:
blur_dxdy = float2(0.0, dxdy.y);
}
void blurVerticalPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float2 blur_dxdy : TEXCOORD1,
out float4 color : SV_Target
) {
static const float3 blur_color = tex2Dblur9fast(samplerBloomApproxHoriz, texcoord, blur_dxdy, get_intermediate_gamma());
// Encode and output the blurred image:
// color = encode_output(float4(blur_color, 1.0), 1.0);
color = encode_output(float4(blur_color, 1.0), get_intermediate_gamma());
}
#endif // _BLURRING_H

90
data/resources/shaders/reshade/Shaders/crt-royale/shaders/brightpass.fxh Normal file
View File

@ -0,0 +1,90 @@
#ifndef _BRIGHTPASS_H
#define _BRIGHTPASS_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
#include "../lib/user-settings.fxh"
#include "../lib/derived-settings-and-constants.fxh"
#include "../lib/bind-shader-params.fxh"
#include "../lib/gamma-management.fxh"
#include "../lib/phosphor-mask-calculations.fxh"
#include "../lib/scanline-functions.fxh"
#include "../lib/bloom-functions.fxh"
#include "../lib/blur-functions.fxh"
void brightpassVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float bloom_sigma_runtime : TEXCOORD1
) {
PostProcessVS(id, position, texcoord);
bloom_sigma_runtime = get_min_sigma_to_blur_triad(calc_triad_size().x, bloom_diff_thresh_);
}
void brightpassPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float bloom_sigma_runtime : TEXCOORD1,
out float4 color : SV_Target
) {
// Sample the masked scanlines:
const float3 intensity_dim = tex2D_linearize(samplerMaskedScanlines, texcoord, get_intermediate_gamma()).rgb;
// Get the full intensity, including auto-undimming, and mask compensation:
const float mask_amplify = get_mask_amplify();
const float3 intensity = intensity_dim * rcp(levels_autodim_temp) * mask_amplify * levels_contrast;
// Sample BLOOM_APPROX to estimate what a straight blur of masked scanlines
// would look like, so we can estimate how much energy we'll receive from
// blooming neighbors:
const float3 phosphor_blur_approx = levels_contrast * tex2D_linearize(samplerBloomApproxHoriz, texcoord, get_intermediate_gamma()).rgb;
// Compute the blur weight for the center texel and the maximum energy we
// expect to receive from neighbors:
const float bloom_sigma = get_final_bloom_sigma(bloom_sigma_runtime);
const float center_weight = get_center_weight(bloom_sigma);
const float3 max_area_contribution_approx =
max(float3(0.0, 0.0, 0.0), phosphor_blur_approx - center_weight * intensity);
// Assume neighbors will blur 100% of their intensity (blur_ratio = 1.0),
// because it actually gets better results (on top of being very simple),
// but adjust all intensities for the user's desired underestimate factor:
const float3 area_contrib_underestimate = bloom_underestimate_levels * max_area_contribution_approx;
const float3 intensity_underestimate = bloom_underestimate_levels * intensity;
// Calculate the blur_ratio, the ratio of intensity we want to blur:
const float3 blur_ratio_temp =
((float3(1.0, 1.0, 1.0) - area_contrib_underestimate) /
intensity_underestimate - float3(1.0, 1.0, 1.0)) / (center_weight - 1.0);
const float3 blur_ratio = saturate(blur_ratio_temp);
// Calculate the brightpass based on the auto-dimmed, unamplified, masked
// scanlines, encode if necessary, and return!
const float3 brightpass = intensity_dim *
lerp(blur_ratio, float3(1.0, 1.0, 1.0), bloom_excess);
color = encode_output(float4(brightpass, 1.0), get_intermediate_gamma());
}
#endif // _BRIGHTPASS_H

221
data/resources/shaders/reshade/Shaders/crt-royale/shaders/content-box.fxh Normal file
View File

@ -0,0 +1,221 @@
#ifndef _CONTENT_BOX_H
#define _CONTENT_BOX_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2020 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "shared-objects.fxh"
void contentCropVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0
) {
#if _DX9_ACTIVE
texcoord.x = (id == 1 || id == 3) ? content_right : content_left;
texcoord.y = (id > 1) ? content_lower : content_upper;
position.x = (id == 1 || id == 3) ? 1 : -1;
position.y = (id > 1) ? -1 : 1;
position.zw = 1;
#else
texcoord.x = (id & 1) ? content_right : content_left;
texcoord.y = (id & 2) ? content_lower : content_upper;
position.x = (id & 1) ? 1 : -1;
position.y = (id & 2) ? -1 : 1;
position.zw = 1;
#endif
}
#if USE_VERTEX_UNCROPPING
/*
* Using the vertex shader for uncropping can save about 0.1ms in some apps.
* However, some apps like SNES9X w/ DX9 don't trigger a refresh of the entire screen,
* which in turn causes the ReShade UI to "stick around" after it's closed.
*
* The slower algorithm forces the entire screen to refresh, which forces the
* area outside the content box to be black. I assume most users will prefer
* the results of the slower algorithm and won't notice the 0.1ms. Users who
* need that 0.1ms can use a preprocessor def to recover that time.
*/
void contentUncropVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0
) {
#if _DX9_ACTIVE
texcoord.x = id == 1 || id == 3;
texcoord.y = id < 2;
position.x = (id == 1 || id == 3) ? content_scale.x : -content_scale.x;
position.y = (id > 1) ? content_scale.y : -content_scale.y;
position.zw = 1;
#else
texcoord.x = id & 1;
texcoord.y = !(id & 2);
position.x = (id & 1) ? content_scale.x : -content_scale.x;
position.y = (id & 2) ? content_scale.y : -content_scale.y;
position.zw = 1;
#endif
}
void uncropContentPixelShader(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
color = tex2D(samplerGeometry, texcoord);
}
#else
void contentUncropVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0
) {
// TODO: There's probably a better way to code this.
// I'll figure it out later.
#if _DX9_ACTIVE
texcoord.x = id == 1 || id == 3;
texcoord.y = id < 2;
position.x = (id == 1 || id == 3) ? 1 : -1;
position.y = (id > 1) ? 1 : -1;
position.zw = 1;
#else
texcoord.x = id & 1;
texcoord.y = !(id & 2);
position.x = (id & 1) ? 1 : -1;
position.y = (id & 2) ? 1 : -1;
position.zw = 1;
#endif
}
void uncropContentPixelShader(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
const bool is_in_boundary = float(
texcoord.x >= content_left && texcoord.x <= content_right &&
texcoord.y >= content_upper && texcoord.y <= content_lower
);
const float2 texcoord_uncropped = ((texcoord - content_offset) * buffer_size + 0) / content_size;
const float4 raw_color = tex2D(samplerGeometry, texcoord_uncropped);
color = float4(is_in_boundary * raw_color.rgb, raw_color.a);
}
#endif
#if CONTENT_BOX_VISIBLE
#ifndef CONTENT_BOX_INSCRIBED
#define CONTENT_BOX_INSCRIBED 1
#endif
#ifndef CONTENT_BOX_THICKNESS
#define CONTENT_BOX_THICKNESS 5
#endif
#ifndef CONTENT_BOX_COLOR_R
#define CONTENT_BOX_COLOR_R 1.0
#endif
#ifndef CONTENT_BOX_COLOR_G
#define CONTENT_BOX_COLOR_G 0.0
#endif
#ifndef CONTENT_BOX_COLOR_B
#define CONTENT_BOX_COLOR_B 0.0
#endif
static const float vert_line_thickness = float(CONTENT_BOX_THICKNESS) / BUFFER_WIDTH;
static const float horiz_line_thickness = float(CONTENT_BOX_THICKNESS) / BUFFER_HEIGHT;
#if CONTENT_BOX_INSCRIBED
// Set the outer borders to the edge of the content
static const float left_line_1 = content_left;
static const float left_line_2 = left_line_1 + vert_line_thickness;
static const float right_line_2 = content_right;
static const float right_line_1 = right_line_2 - vert_line_thickness;
static const float upper_line_1 = content_upper;
static const float upper_line_2 = upper_line_1 + horiz_line_thickness;
static const float lower_line_2 = content_lower;
static const float lower_line_1 = lower_line_2 - horiz_line_thickness;
#else
// Set the inner borders to the edge of the content
static const float left_line_2 = content_left;
static const float left_line_1 = left_line_2 - vert_line_thickness;
static const float right_line_1 = content_right;
static const float right_line_2 = right_line_1 + vert_line_thickness;
static const float upper_line_2 = content_upper;
static const float upper_line_1 = upper_line_2 - horiz_line_thickness;
static const float lower_line_1 = content_lower;
static const float lower_line_2 = lower_line_1 + horiz_line_thickness;
#endif
static const float4 box_color = float4(
CONTENT_BOX_COLOR_R,
CONTENT_BOX_COLOR_G,
CONTENT_BOX_COLOR_B,
1.0
);
void contentBoxPixelShader(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
const bool is_inside_outerbound = (
texcoord.x >= left_line_1 && texcoord.x <= right_line_2 &&
texcoord.y >= upper_line_1 && texcoord.y <= lower_line_2
);
const bool is_outside_innerbound = (
texcoord.x <= left_line_2 || texcoord.x >= right_line_1 ||
texcoord.y <= upper_line_2 || texcoord.y >= lower_line_1
);
if (is_inside_outerbound && is_outside_innerbound) {
color = box_color;
}
else {
color = tex2D(ReShade::BackBuffer, texcoord);
}
}
#endif // CONTENT_BOX_VISIBLE
#endif // _CONTENT_BOX_H

137
data/resources/shaders/reshade/Shaders/crt-royale/shaders/deinterlace.fxh Normal file
View File

@ -0,0 +1,137 @@
#ifndef _DEINTERLACE_H
#define _DEINTERLACE_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2020 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "../lib/user-settings.fxh"
#include "../lib/derived-settings-and-constants.fxh"
#include "../lib/bind-shader-params.fxh"
#include "../lib/gamma-management.fxh"
#include "../lib/scanline-functions.fxh"
void freezeFrameVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0
) {
float use_deinterlacing_tex = enable_interlacing && (
scanline_deinterlacing_mode == 2 || scanline_deinterlacing_mode == 3
);
texcoord.x = (id == 2) ? use_deinterlacing_tex*2.0 : 0.0;
texcoord.y = (id == 1) ? 2.0 : 0.0;
position = float4(texcoord * float2(2, -2) + float2(-1, 1), 0, 1);
}
void freezeFramePS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
color = tex2D(samplerBeamConvergence, texcoord);
}
void deinterlaceVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float2 v_step : TEXCOORD1
) {
freezeFrameVS(id, position, texcoord);
v_step = float2(0.0, scanline_thickness * rcp(TEX_FREEZEFRAME_HEIGHT));
}
void deinterlacePS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float2 v_step : TEXCOORD1,
out float4 color : SV_Target
) {
// float2 scanline_offset_norm;
// float triangle_wave_freq;
// bool field_parity;
// bool wrong_field;
// calc_wrong_field(texcoord, scanline_offset_norm, triangle_wave_freq, field_parity, wrong_field);
float2 rotated_coord = lerp(texcoord.yx, texcoord, geom_rotation_mode == 0 || geom_rotation_mode == 2);
float scale = lerp(CONTENT_WIDTH, CONTENT_HEIGHT, geom_rotation_mode == 0 || geom_rotation_mode == 2);
InterpolationFieldData interpolation_data = calc_interpolation_field_data(rotated_coord, scale);
// TODO: add scanline_parity to calc_wrong_field()
// Weaving
// Sample texcoord from this frame and the previous frame
// If we're in the correct field, use the current sample
// If we're in the wrong field, average the current and prev samples
// In this case, we're probably averaging a color with 0 and producing a brightness of 0.5.
[branch]
if (enable_interlacing && scanline_deinterlacing_mode == 2) {
// const float cur_scanline_idx = get_curr_scanline_idx(texcoord.y, content_size.y);
// const float wrong_field = curr_line_is_wrong_field(cur_scanline_idx);
const float4 cur_line_color = tex2D_nograd(samplerBeamConvergence, texcoord);
const float4 cur_line_prev_color = tex2D_nograd(samplerFreezeFrame, texcoord);
const float4 avg_color = (cur_line_color + cur_line_prev_color) / 2.0;
// Multiply by 1.5, so each pair of scanlines has total brightness 2
const float4 raw_out_color = lerp(1.5*cur_line_color, avg_color, interpolation_data.wrong_field);
color = encode_output(raw_out_color, deinterlacing_blend_gamma);
}
// Blended Weaving
// Sample texcoord from this frame
// From the previous frame, sample the current scanline's sibling
// Do this by shifting up or down by a line
// If we're in the correct field, use the current sample
// If we're in the wrong field, average the current and prev samples
// In this case, we're averaging two fully illuminated colors
else if (enable_interlacing && scanline_deinterlacing_mode == 3) {
const float2 raw_offset = lerp(1, -1, interpolation_data.scanline_parity) * v_step;
const float2 curr_offset = lerp(0, raw_offset, interpolation_data.wrong_field);
const float2 prev_offset = lerp(raw_offset, 0, interpolation_data.wrong_field);
const float4 cur_line_color = tex2D_nograd(samplerBeamConvergence, texcoord + curr_offset);
const float4 prev_line_color = tex2D_nograd(samplerFreezeFrame, texcoord + prev_offset);
const float4 avg_color = (cur_line_color + prev_line_color) / 2.0;
const float4 raw_out_color = lerp(cur_line_color, avg_color, interpolation_data.wrong_field);
color = encode_output(raw_out_color, deinterlacing_blend_gamma);
}
// No temporal blending
else {
color = tex2D_nograd(samplerBeamConvergence, texcoord);
}
}
#endif // _DEINTERLACE_H

347
data/resources/shaders/reshade/Shaders/crt-royale/shaders/electron-beams.fxh Normal file
View File

@ -0,0 +1,347 @@
#ifndef _ELECTRON_BEAMS_H
#define _ELECTRON_BEAMS_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
#include "../lib/bind-shader-params.fxh"
#include "../lib/gamma-management.fxh"
#include "../lib/scanline-functions.fxh"
#include "content-box.fxh"
#include "shared-objects.fxh"
void calculateBeamDistsVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0
) {
const float compute_mask_factor = frame_count % 60 == 0 || overlay_active > 0;
texcoord.x = (id == 2) ? compute_mask_factor*2.0 : 0.0;
texcoord.y = (id == 1) ? 2.0 : 0.0;
position = float4(texcoord * float2(2, -2) + float2(-1, 1), 0, 1);
}
void calculateBeamDistsPS(
in float4 position : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 beam_strength : SV_Target
) {
InterpolationFieldData interpolation_data = precalc_interpolation_field_data(texcoord);
// We have to subtract off the texcoord offset to make sure we're using domain [0, 1]
const float color_corrected = texcoord.x - 1.0 / TEX_BEAMDIST_WIDTH;
// Digital shape
// Beam will be perfectly rectangular
[branch]
if (beam_shape_mode == 0) {
// Double the intensity when interlacing to maintain the same apparent brightness
const float interlacing_brightness_factor = 1 + float(
enable_interlacing &&
(scanline_deinterlacing_mode != 2) &&
(scanline_deinterlacing_mode != 3)
);
const float raw_beam_strength = (1 - interpolation_data.scanline_parity * enable_interlacing) * interlacing_brightness_factor * levels_autodim_temp;
beam_strength = float4(color_corrected * raw_beam_strength, 0, 0, 1);
}
// Linear shape
// Beam intensity will drop off linarly with distance from center
// Works better than gaussian with narrow scanlines (about 1-6 pixels wide)
// Will only consider contribution from nearest scanline
else if (beam_shape_mode == 1) {
const float beam_dist_y = triangle_wave(texcoord.y, interpolation_data.triangle_wave_freq);
const bool scanline_is_wider_than_1 = scanline_thickness > 1;
const bool deinterlacing_mode_requires_boost = (
enable_interlacing &&
(scanline_deinterlacing_mode != 2) &&
(scanline_deinterlacing_mode != 3)
);
const float interlacing_brightness_factor = (1 + scanline_is_wider_than_1) * (1 + deinterlacing_mode_requires_boost);
// const float raw_beam_strength = (1 - beam_dist_y) * (1 - interpolation_data.scanline_parity * enable_interlacing) * interlacing_brightness_factor * levels_autodim_temp;
// const float raw_beam_strength = (1 - beam_dist_y);
const float raw_beam_strength = saturate(-beam_dist_y * rcp(linear_beam_thickness) + 1);
const float adj_beam_strength = raw_beam_strength * (1 - interpolation_data.scanline_parity * enable_interlacing) * interlacing_brightness_factor * levels_autodim_temp;
beam_strength = float4(color_corrected * adj_beam_strength, 0, 0, 1);
}
// Gaussian Shape
// Beam will be a distorted Gaussian, dependent on color brightness and hyperparameters
// Will only consider contribution from nearest scanline
else if (beam_shape_mode == 2) {
// Calculate {sigma, shape}_range outside of scanline_contrib so it's only
// done once per pixel (not 6 times) with runtime params. Don't reuse the
// vertex shader calculations, so static versions can be constant-folded.
const float sigma_range = max(gaussian_beam_max_sigma, gaussian_beam_min_sigma) - gaussian_beam_min_sigma;
const float shape_range = max(gaussian_beam_max_shape, gaussian_beam_min_shape) - gaussian_beam_min_shape;
const float beam_dist_factor = 1 + float(enable_interlacing);
const float freq_adj = interpolation_data.triangle_wave_freq * rcp(beam_dist_factor);
// The conditional 0.25*f offset ensures the interlaced scanlines align with the non-interlaced ones as in the other beam shapes
const float frame_offset = enable_interlacing * (!interpolation_data.field_parity * 0.5 + 0.25) * rcp(freq_adj);
const float beam_dist_y = triangle_wave((texcoord.y - frame_offset), freq_adj) * rcp(linear_beam_thickness);
const float interlacing_brightness_factor = 1 + float(
!enable_interlacing &&
(scanline_thickness > 1)
) + float(
enable_interlacing &&
(scanline_deinterlacing_mode != 2) &&
(scanline_deinterlacing_mode != 3)
);
const float raw_beam_strength = get_gaussian_beam_strength(
beam_dist_y, color_corrected,
sigma_range, shape_range
) * interlacing_brightness_factor * levels_autodim_temp;
beam_strength = float4(raw_beam_strength, 0, 0, 1);
}
// Gaussian Shape
// Beam will be a distorted Gaussian, dependent on color brightness and hyperparameters
// Will consider contributions from current scanline and two neighboring in-field scanlines
else {
// Calculate {sigma, shape}_range outside of scanline_contrib so it's only
// done once per pixel (not 6 times) with runtime params. Don't reuse the
// vertex shader calculations, so static versions can be constant-folded.
const float sigma_range = max(gaussian_beam_max_sigma, gaussian_beam_min_sigma) - gaussian_beam_min_sigma;
const float shape_range = max(gaussian_beam_max_shape, gaussian_beam_min_shape) - gaussian_beam_min_shape;
const float beam_dist_factor = (1 + float(enable_interlacing));
const float freq_adj = interpolation_data.triangle_wave_freq * rcp(beam_dist_factor);
// The conditional 0.25*f offset ensures the interlaced scanlines align with the non-interlaced ones as in the other beam shapes
const float frame_offset = enable_interlacing * (!interpolation_data.field_parity * 0.5 + 0.25) * rcp(freq_adj);
const float curr_beam_dist_y = triangle_wave(texcoord.y - frame_offset, freq_adj) * rcp(linear_beam_thickness);
const float upper_beam_dist_y = (sawtooth_incr_wave(texcoord.y - frame_offset, freq_adj)*2 + 1) * rcp(linear_beam_thickness);
const float lower_beam_dist_y = 4 * rcp(linear_beam_thickness) - upper_beam_dist_y;
const float upper_beam_strength = get_gaussian_beam_strength(
upper_beam_dist_y, color_corrected,
sigma_range, shape_range
);
const float curr_beam_strength = get_gaussian_beam_strength(
curr_beam_dist_y, color_corrected,
sigma_range, shape_range
);
const float lower_beam_strength = get_gaussian_beam_strength(
lower_beam_dist_y, color_corrected,
sigma_range, shape_range
);
const float interlacing_brightness_factor = 1 + float(
!enable_interlacing &&
(scanline_thickness > 1)
) + float(
enable_interlacing &&
(scanline_deinterlacing_mode != 2) &&
(scanline_deinterlacing_mode != 3)
);
const float3 raw_beam_strength = float3(curr_beam_strength, upper_beam_strength, lower_beam_strength) * interlacing_brightness_factor * levels_autodim_temp;
beam_strength = float4(raw_beam_strength, 1);
}
}
void simulateEletronBeamsVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float4 runtime_bin_shapes : TEXCOORD1
) {
#if ENABLE_PREBLUR
PostProcessVS(id, position, texcoord);
#else
// texcoord.x = (id == 0 || id == 2) ? content_left : content_right;
// texcoord.y = (id < 2) ? content_lower : content_upper;
// position.x = (id == 0 || id == 2) ? -1 : 1;
// position.y = (id < 2) ? -1 : 1;
// position.zw = 1;
contentCropVS(id, position, texcoord);
#endif
bool screen_is_landscape = geom_rotation_mode == 0 || geom_rotation_mode == 2;
// Mode 0: size of pixel in [0, 1] = pixel_dims / viewport_size
// Mode 1: size of pixel in [0, 1] = viewport_size / grid_dims
// float2 runtime_pixel_size = (pixel_grid_mode == 0) ? pixel_size * rcp(content_size) : rcp(pixel_grid_resolution);
float2 runtime_pixel_size = rcp(content_size);
float2 runtime_scanline_shape = lerp(
float2(scanline_thickness, 1),
float2(1, scanline_thickness),
screen_is_landscape
) * rcp(content_size);
runtime_bin_shapes = float4(runtime_pixel_size, runtime_scanline_shape);
}
void simulateEletronBeamsPS(
in float4 position : SV_Position,
in float2 texcoord : TEXCOORD0,
in float4 runtime_bin_shapes : TEXCOORD1,
out float4 color : SV_Target
) {
bool screen_is_landscape = geom_rotation_mode == 0 || geom_rotation_mode == 2;
float2 rotated_coord = lerp(texcoord.yx, texcoord, screen_is_landscape);
float scale = lerp(CONTENT_WIDTH, CONTENT_HEIGHT, screen_is_landscape);
// InterpolationFieldData interpolation_data = precalc_interpolation_field_data(rotated_coord);
// // We have to subtract off the texcoord offset to make sure we're using domain [0, 1]
// const float color_corrected = rotated_coord.x - 1.0 / scale;
InterpolationFieldData interpolation_data = calc_interpolation_field_data(rotated_coord, scale);
const float ypos = (rotated_coord.y * interpolation_data.triangle_wave_freq + interpolation_data.field_parity) * 0.5;
float2 texcoord_scanlined = round_coord(texcoord, 0, runtime_bin_shapes.zw);
// Sample from the neighboring scanline when in the wrong field
[branch]
if (interpolation_data.wrong_field && screen_is_landscape) {
const float coord_moved_up = texcoord_scanlined.y <= texcoord.y;
const float direction = lerp(-1, 1, coord_moved_up);
texcoord_scanlined.y += direction * scanline_thickness * rcp(content_size.y);
}
else if (interpolation_data.wrong_field) {
const float coord_moved_up = texcoord_scanlined.x <= texcoord.x;
const float direction = lerp(-1, 1, coord_moved_up);
texcoord_scanlined.x += direction * scanline_thickness * rcp(content_size.x);
}
// Now we apply pixellation and cropping
// float2 texcoord_pixellated = round_coord(
// texcoord_scanlined,
// pixel_grid_offset * rcp(content_size),
// runtime_bin_shapes.xy
// );
float2 texcoord_pixellated = texcoord_scanlined;
const float2 texcoord_uncropped = texcoord_pixellated;
#if ENABLE_PREBLUR
// If the pre-blur pass ran, then it's already handled cropping.
// const float2 texcoord_uncropped = texcoord_pixellated;
#define source_sampler samplerPreblurHoriz
#else
// const float2 texcoord_uncropped = texcoord_pixellated * content_scale + content_offset;
#define source_sampler ReShade::BackBuffer
#endif
[branch]
if (beam_shape_mode < 3) {
const float4 scanline_color = tex2Dlod_linearize(
source_sampler,
texcoord_uncropped,
get_input_gamma()
);
const float beam_strength_r = tex2D_nograd(samplerBeamDist, float2(scanline_color.r, ypos)).x;
const float beam_strength_g = tex2D_nograd(samplerBeamDist, float2(scanline_color.g, ypos)).x;
const float beam_strength_b = tex2D_nograd(samplerBeamDist, float2(scanline_color.b, ypos)).x;
const float4 beam_strength = float4(beam_strength_r, beam_strength_g, beam_strength_b, 1);
color = beam_strength;
}
else {
const float2 offset = float2(0, scanline_thickness) * (1 + enable_interlacing) * rcp(content_size);
const float4 curr_scanline_color = tex2Dlod_linearize(
source_sampler,
texcoord_uncropped,
get_input_gamma()
);
const float4 upper_scanline_color = tex2Dlod_linearize(
source_sampler,
texcoord_uncropped - offset,
get_input_gamma()
);
const float4 lower_scanline_color = tex2Dlod_linearize(
source_sampler,
texcoord_uncropped + offset,
get_input_gamma()
);
const float curr_beam_strength_r = tex2D_nograd(samplerBeamDist, float2(curr_scanline_color.r, ypos)).x;
const float curr_beam_strength_g = tex2D_nograd(samplerBeamDist, float2(curr_scanline_color.g, ypos)).x;
const float curr_beam_strength_b = tex2D_nograd(samplerBeamDist, float2(curr_scanline_color.b, ypos)).x;
const float upper_beam_strength_r = tex2D_nograd(samplerBeamDist, float2(upper_scanline_color.r, ypos)).y;
const float upper_beam_strength_g = tex2D_nograd(samplerBeamDist, float2(upper_scanline_color.g, ypos)).y;
const float upper_beam_strength_b = tex2D_nograd(samplerBeamDist, float2(upper_scanline_color.b, ypos)).y;
const float lower_beam_strength_r = tex2D_nograd(samplerBeamDist, float2(lower_scanline_color.r, ypos)).z;
const float lower_beam_strength_g = tex2D_nograd(samplerBeamDist, float2(lower_scanline_color.g, ypos)).z;
const float lower_beam_strength_b = tex2D_nograd(samplerBeamDist, float2(lower_scanline_color.b, ypos)).z;
color = float4(
curr_beam_strength_r + upper_beam_strength_r + lower_beam_strength_r,
curr_beam_strength_g + upper_beam_strength_g + lower_beam_strength_g,
curr_beam_strength_b + upper_beam_strength_b + lower_beam_strength_b,
1
);
}
}
void beamConvergenceVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float run_convergence : TEXCOORD1
) {
PostProcessVS(id, position, texcoord);
const uint3 x_flag = convergence_offset_x != 0;
const uint3 y_flag = convergence_offset_y != 0;
run_convergence = dot(x_flag, 1) + dot(y_flag, 1);
}
void beamConvergencePS(
in float4 position : SV_Position,
in float2 texcoord : TEXCOORD0,
in float run_convergence : TEXCOORD1,
out float4 color : SV_TARGET
) {
// [branch]
if (!run_convergence) {
color = tex2D(samplerElectronBeams, texcoord - float2(0, scanline_offset * rcp(content_size.y)));
}
else {
const float3 offset_sample = sample_rgb_scanline(
samplerElectronBeams, texcoord - float2(0, scanline_offset * rcp(content_size.y)),
TEX_ELECTRONBEAMS_SIZE, rcp(TEX_ELECTRONBEAMS_SIZE)
);
color = float4(offset_sample, 1);
}
}
#endif // _ELECTRON_BEAMS_H

220
data/resources/shaders/reshade/Shaders/crt-royale/shaders/geometry-aa-last-pass.fxh Normal file
View File

@ -0,0 +1,220 @@
#ifndef _GEOMETRY_AA_LAST_PASS_H
#define _GEOMETRY_AA_LAST_PASS_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
#include "../lib/user-settings.fxh"
#include "../lib/derived-settings-and-constants.fxh"
#include "../lib/bind-shader-params.fxh"
#include "../lib/gamma-management.fxh"
#include "../lib/tex2Dantialias.fxh"
#include "../lib/geometry-functions.fxh"
// Disabled in the ReShade port because I don't know a good way to make these
// static AND global AND defined with sin(), cos(), or pow().
// #if !_RUNTIME_GEOMETRY_TILT
// // Create a local-to-global rotation matrix for the CRT's coordinate frame
// // and its global-to-local inverse. See the vertex shader for details.
// // It's faster to compute these statically if possible.
// static const float2 sin_tilt = sin(geom_tilt_angle_static);
// static const float2 cos_tilt = cos(geom_tilt_angle_static);
// static const float3x3 geom_local_to_global_static = float3x3(
// cos_tilt.x, sin_tilt.y*sin_tilt.x, cos_tilt.y*sin_tilt.x,
// 0.0, cos_tilt.y, -sin_tilt.y,
// -sin_tilt.x, sin_tilt.y*cos_tilt.x, cos_tilt.y*cos_tilt.x);
// static const float3x3 geom_global_to_local_static = float3x3(
// cos_tilt.x, 0.0, -sin_tilt.x,
// sin_tilt.y*sin_tilt.x, cos_tilt.y, sin_tilt.y*cos_tilt.x,
// cos_tilt.y*sin_tilt.x, -sin_tilt.y, cos_tilt.y*cos_tilt.x);
// #endif
float2x2 mul_scale(float2 scale, float2x2 mtrx)
{
float4 temp_matrix = float4(mtrx[0][0], mtrx[0][1], mtrx[1][0], mtrx[1][1]) * scale.xxyy;
return float2x2(temp_matrix.x, temp_matrix.y, temp_matrix.z, temp_matrix.w);
}
void geometryVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float2 output_size_inv : TEXCOORD1,
out float4 geom_aspect_and_overscan : TEXCOORD2,
out float3 eye_pos_local : TEXCOORD3,
out float3 global_to_local_row0 : TEXCOORD4,
out float3 global_to_local_row1 : TEXCOORD5,
out float3 global_to_local_row2 : TEXCOORD6
) {
PostProcessVS(id, position, texcoord);
output_size_inv = 1.0 / content_size;
// Get aspect/overscan vectors from scalar parameters (likely uniforms):
const float viewport_aspect_ratio = output_size_inv.y / output_size_inv.x;
const float2 geom_aspect = get_aspect_vector(viewport_aspect_ratio);
const float2 geom_overscan = get_geom_overscan_vector();
geom_aspect_and_overscan = float4(geom_aspect, geom_overscan);
#if _RUNTIME_GEOMETRY_TILT
// Create a local-to-global rotation matrix for the CRT's coordinate
// frame and its global-to-local inverse. Rotate around the x axis
// first (pitch) and then the y axis (yaw) with yucky Euler angles.
// Positive angles go clockwise around the right-vec and up-vec.
// Runtime shader parameters prevent us from computing these globally,
// but we can still combine the pitch/yaw matrices by hand to cut a
// few instructions. Note that cg matrices fill row1 first, then row2,
// etc. (row-major order).
const float2 geom_tilt_angle = get_geom_tilt_angle_vector();
const float2 sin_tilt = sin(geom_tilt_angle);
const float2 cos_tilt = cos(geom_tilt_angle);
// Conceptual breakdown:
static const float3x3 rot_x_matrix = float3x3(
1.0, 0.0, 0.0,
0.0, cos_tilt.y, -sin_tilt.y,
0.0, sin_tilt.y, cos_tilt.y);
static const float3x3 rot_y_matrix = float3x3(
cos_tilt.x, 0.0, sin_tilt.x,
0.0, 1.0, 0.0,
-sin_tilt.x, 0.0, cos_tilt.x);
static const float3x3 local_to_global =
mul(rot_y_matrix, rot_x_matrix);
/* static const float3x3 global_to_local =
transpose(local_to_global);
const float3x3 local_to_global = float3x3(
cos_tilt.x, sin_tilt.y*sin_tilt.x, cos_tilt.y*sin_tilt.x,
0.0, cos_tilt.y, sin_tilt.y,
sin_tilt.x, sin_tilt.y*cos_tilt.x, cos_tilt.y*cos_tilt.x);
*/ // This is a pure rotation, so transpose = inverse:
const float3x3 global_to_local = transpose(local_to_global);
// Decompose the matrix into 3 float3's for output:
global_to_local_row0 = float3(global_to_local[0][0], global_to_local[0][1], global_to_local[0][2]);//._m00_m01_m02);
global_to_local_row1 = float3(global_to_local[1][0], global_to_local[1][1], global_to_local[1][2]);//._m10_m11_m12);
global_to_local_row2 = float3(global_to_local[2][0], global_to_local[2][1], global_to_local[2][2]);//._m20_m21_m22);
#else
static const float3x3 global_to_local = geom_global_to_local_static;
static const float3x3 local_to_global = geom_local_to_global_static;
#endif
// Get an optimal eye position based on geom_view_dist, viewport_aspect,
// and CRT radius/rotation:
#if _RUNTIME_GEOMETRY_MODE
const float geom_mode = geom_mode_runtime;
#else
static const float geom_mode = geom_mode_static;
#endif
const float3 eye_pos_global = get_ideal_global_eye_pos(local_to_global, geom_aspect, geom_mode);
eye_pos_local = mul(global_to_local, eye_pos_global);
}
void geometryPS(
in float4 position : SV_Position,
in float2 texcoord : TEXCOORD0,
in float2 output_size_inv : TEXCOORD1,
in float4 geom_aspect_and_overscan : TEXCOORD2,
in float3 eye_pos_local : TEXCOORD3,
in float3 global_to_local_row0 : TEXCOORD4,
in float3 global_to_local_row1 : TEXCOORD5,
in float3 global_to_local_row2 : TEXCOORD6,
out float4 color : SV_Target
) {
// Localize some parameters:
const float2 geom_aspect = geom_aspect_and_overscan.xy;
const float2 geom_overscan = geom_aspect_and_overscan.zw;
#if _RUNTIME_GEOMETRY_TILT
const float3x3 global_to_local = float3x3(global_to_local_row0,
global_to_local_row1, global_to_local_row2);
#else
static const float3x3 global_to_local = geom_global_to_local_static;
#endif
#if _RUNTIME_GEOMETRY_MODE
const float geom_mode = geom_mode_runtime;
#else
static const float geom_mode = geom_mode_static;
#endif
// Get flat and curved texture coords for the current fragment point sample
// and a pixel_to_tangent_video_uv matrix for transforming pixel offsets:
// video_uv = relative position in video frame, mapped to [0.0, 1.0] range
// tex_uv = relative position in padded texture, mapped to [0.0, 1.0] range
const float2 flat_video_uv = texcoord;
float2x2 pixel_to_video_uv;
float2 video_uv_no_geom_overscan;
if(geom_mode > 0.5)
{
video_uv_no_geom_overscan =
get_curved_video_uv_coords_and_tangent_matrix(flat_video_uv,
eye_pos_local, output_size_inv, geom_aspect,
geom_mode, global_to_local, pixel_to_video_uv);
}
else
{
video_uv_no_geom_overscan = flat_video_uv;
pixel_to_video_uv = float2x2(
output_size_inv.x, 0.0, 0.0, output_size_inv.y);
}
// Correct for overscan here (not in curvature code):
const float2 video_uv =
(video_uv_no_geom_overscan - float2(0.5, 0.5))/geom_overscan + float2(0.5, 0.5);
const float2 tex_uv = video_uv;
// Get a matrix transforming pixel vectors to tex_uv vectors:
const float2x2 pixel_to_tex_uv =
mul_scale(1.0 / geom_overscan, pixel_to_video_uv);
// Sample! Skip antialiasing if antialias_level < 0.5 or both of these hold:
// 1.) Geometry/curvature isn't used
// 2.) Overscan == float2(1.0, 1.0)
// Skipping AA is sharper, but it's only faster with dynamic branches.
const float2 abs_aa_r_offset = abs(get_aa_subpixel_r_offset());
// this next check seems to always return true, even when it shouldn't so disabling it for now
const bool need_subpixel_aa = false;//abs_aa_r_offset.x + abs_aa_r_offset.y > 0.0;
float3 raw_color;
if(antialias_level > 0.5 && (geom_mode > 0.5 || any(bool2((geom_overscan.x != 1.0), (geom_overscan.y != 1.0)))))
{
// Sample the input with antialiasing (due to sharp phosphors, etc.):
raw_color = tex2Daa(samplerBloomHorizontal, tex_uv, pixel_to_tex_uv, float(frame_count), get_intermediate_gamma());
}
else if(antialias_level > 0.5 && need_subpixel_aa)
{
// Sample at each subpixel location:
raw_color = tex2Daa_subpixel_weights_only(
samplerBloomHorizontal, tex_uv, pixel_to_tex_uv, get_intermediate_gamma());
}
else
{
raw_color = tex2D_linearize(samplerBloomHorizontal, tex_uv, get_intermediate_gamma()).rgb;
}
// Dim borders and output the final result:
const float border_dim_factor = get_border_dim_factor(video_uv, geom_aspect);
const float3 final_color = raw_color * border_dim_factor;
color = encode_output(float4(final_color, 1.0), get_output_gamma());
}
#endif // _GEOMETRY_AA_LAST_PASS_H

74
data/resources/shaders/reshade/Shaders/crt-royale/shaders/input-blurring.fxh Normal file
View File

@ -0,0 +1,74 @@
#ifndef _INPUT_BLURRING_H
#define _INPUT_BLURRING_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2022 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// Theoretically this could go in blurring.fxh
// But that file has a bunch of GPL stuff in it.
// Keeping it separate makes it easier to communicate that this portion is
// available under the MIT license.
#include "../lib/downsampling-functions.fxh"
#include "content-box.fxh"
#include "shared-objects.fxh"
void preblurVertPS(
in const float4 pos : SV_Position,
in const float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
const float2 texcoord_uncropped = texcoord;
const float2 max_delta_uv = float2(0.0, rcp(content_size.y)) * preblur_effect_radius;
const float2 delta_uv = max_delta_uv * rcp(max(preblur_sampling_radius.y, 1));
color = float4(opaque_linear_downsample(
ReShade::BackBuffer,
texcoord_uncropped,
preblur_sampling_radius.y,
delta_uv
), 1);
}
void preblurHorizPS(
in const float4 pos : SV_Position,
in const float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
const float2 max_delta_uv = float2(rcp(content_size.x), 0.0) * preblur_effect_radius;
const float2 delta_uv = max_delta_uv * rcp(max(preblur_sampling_radius.x, 1));
color = float4(opaque_linear_downsample(
samplerPreblurVert,
texcoord,
preblur_sampling_radius.x,
delta_uv
), 1);
}
#endif // _INPUT_BLURRING_H

211
data/resources/shaders/reshade/Shaders/crt-royale/shaders/phosphor-mask.fxh Normal file
View File

@ -0,0 +1,211 @@
#ifndef _PHOSPHOR_MASK_H
#define _PHOSPHOR_MASK_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2022 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "../lib/bind-shader-params.fxh"
#include "../lib/phosphor-mask-calculations.fxh"
#include "shared-objects.fxh"
// Split into 64 segments that overlap a little bit
static const float num_segments = 64;
static const float segment_offset = 0.015625; // 1/64
static const float segment_width = 0.0234375; // 1/128
void generatePhosphorMaskVS(
in uint id : SV_VertexID,
out float4 position : SV_Position,
out float2 texcoord : TEXCOORD0,
out float2 viewport_frequency_factor: TEXCOORD1,
out float2 mask_pq_x : TEXCOORD2,
out float2 mask_pq_y : TEXCOORD3
) {
const float screen_segment_idx = frame_count % num_segments;
const float left_coord = lerp(segment_offset * screen_segment_idx, 0, overlay_active > 0);
const float right_coord = lerp(left_coord + segment_width, 1, overlay_active > 0);
const float pos_center = 2 * (left_coord + 0.5 * segment_width - 0.5);
const float pos_left = lerp(pos_center - segment_width, -1, overlay_active > 0);
const float pos_right = lerp(pos_center + segment_width, 1, overlay_active > 0);
#if _DX9_ACTIVE
texcoord.x = (id == 1 || id == 3) ? right_coord : left_coord;
texcoord.y = (id > 1) ? 1 : 0;
position.x = (id == 1 || id == 3) ? pos_right : pos_left;
position.y = (id > 1) ? -1 : 1;
position.zw = 1;
#else
texcoord.x = (id & 1) ? right_coord : left_coord;
texcoord.y = (id & 2) ? 1 : 0;
position.x = (id & 1) ? pos_right : pos_left;
position.y = (id & 2) ? -1 : 1;
position.zw = 1;
#endif
viewport_frequency_factor = calc_phosphor_viewport_frequency_factor();
// We don't alter these based on screen rotation because they're independent of screen dimensions.
float edge_norm_tx;
float edge_norm_ty;
[flatten]
switch (mask_type) {
case 0:
edge_norm_tx = grille_edge_norm_t;
break;
case 1:
edge_norm_tx = slot_edge_norm_tx;
edge_norm_ty = slot_edge_norm_ty;
break;
case 2:
edge_norm_tx = shadow_edge_norm_tx;
edge_norm_ty = shadow_edge_norm_ty;
break;
case 3:
edge_norm_tx = smallgrille_edge_norm_t;
break;
case 4:
edge_norm_tx = smallslot_edge_norm_tx;
edge_norm_ty = smallslot_edge_norm_ty;
break;
default:
edge_norm_tx = smallshadow_edge_norm_tx;
edge_norm_ty = smallshadow_edge_norm_ty;
break;
}
const float2 thickness_scaled = linearize_phosphor_thickness_param(phosphor_thickness);
const float mask_p_x = exp(-calculate_phosphor_p_value(edge_norm_tx, thickness_scaled.x, phosphor_sharpness.x));
const float mask_p_y = exp(-calculate_phosphor_p_value(edge_norm_ty, thickness_scaled.y, phosphor_sharpness.y));
mask_pq_x = float2(mask_p_x, phosphor_sharpness.x);
mask_pq_y = float2(mask_p_y, phosphor_sharpness.y);
}
void generatePhosphorMaskPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
in float2 viewport_frequency_factor: TEXCOORD1,
in float2 mask_pq_x : TEXCOORD2,
in float2 mask_pq_y : TEXCOORD3,
out float4 color : SV_Target
) {
[branch]
if (geom_rotation_mode == 1 || geom_rotation_mode == 3) {
texcoord = texcoord.yx;
viewport_frequency_factor = viewport_frequency_factor.yx;
}
float3 phosphor_color;
[branch]
if (mask_type == 0) {
phosphor_color = get_phosphor_intensity_grille(
texcoord,
viewport_frequency_factor,
mask_pq_x
);
}
else if (mask_type == 1) {
phosphor_color = get_phosphor_intensity_slot(
texcoord,
viewport_frequency_factor,
mask_pq_x,
mask_pq_y
);
}
else if (mask_type == 2) {
phosphor_color = get_phosphor_intensity_shadow(
texcoord,
viewport_frequency_factor,
float2(mask_pq_x.y, mask_pq_y.y)
);
}
else if (mask_type == 3) {
phosphor_color = get_phosphor_intensity_grille_small(
texcoord,
viewport_frequency_factor,
mask_pq_x
);
}
else if (mask_type == 4) {
phosphor_color = get_phosphor_intensity_slot_small(
texcoord,
viewport_frequency_factor,
mask_pq_x,
mask_pq_y
);
}
else {
phosphor_color = get_phosphor_intensity_shadow_small(
texcoord,
viewport_frequency_factor,
mask_pq_x,
mask_pq_y
);
}
color = float4(phosphor_color, 1.0);
}
void applyComputedPhosphorMaskPS(
in float4 pos : SV_Position,
in float2 texcoord : TEXCOORD0,
out float4 color : SV_Target
) {
bool use_deinterlacing_tex = enable_interlacing && (
scanline_deinterlacing_mode == 2 || scanline_deinterlacing_mode == 3
);
float3 scanline_color_dim;
[branch]
if (use_deinterlacing_tex) scanline_color_dim = tex2D(samplerDeinterlace, texcoord).rgb;
else scanline_color_dim = tex2D(samplerBeamConvergence, texcoord).rgb;
const float3 phosphor_color = tex2D(samplerPhosphorMask, texcoord).rgb;
// Sample the halation texture (auto-dim to match the scanlines), and
// account for both horizontal and vertical convergence offsets, given
// in units of texels horizontally and same-field scanlines vertically:
const float3 halation_color = tex2D_linearize(samplerBlurHorizontal, texcoord, get_intermediate_gamma()).rgb;
// Apply halation: Halation models electrons flying around under the glass
// and hitting the wrong phosphors (of any color). It desaturates, so
// average the halation electrons to a scalar. Reduce the local scanline
// intensity accordingly to conserve energy.
const float halation_intensity_dim_scalar = dot(halation_color, float3(1, 1, 1)) / 3.0;
const float3 halation_intensity_dim = halation_intensity_dim_scalar;
const float3 electron_intensity_dim = lerp(scanline_color_dim, halation_intensity_dim, halation_weight);
// Apply the phosphor mask:
const float3 phosphor_emission_dim = electron_intensity_dim * phosphor_color;
color = float4(phosphor_emission_dim, 1.0);
}
#endif // _PHOSPHOR_MASK_H

370
data/resources/shaders/reshade/Shaders/crt-royale/shaders/shared-objects.fxh Normal file
View File

@ -0,0 +1,370 @@
#ifndef _SHARED_OBJECTS_H
#define _SHARED_OBJECTS_H
///////////////////////////// GPL LICENSE NOTICE /////////////////////////////
// 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
#include "../lib/helper-functions-and-macros.fxh"
#include "../lib/derived-settings-and-constants.fxh"
#include "../lib/bind-shader-params.fxh"
// Yes, the WIDTH/HEIGHT/SIZE defines are kinda weird.
// Yes, we have to have them or something similar. This is for D3D11 which
// returns (0, 0) when you call tex2Dsize() on the pass's render target.
// Pass 0 Buffer (cropPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is in interlacingPass
// electronBeamPass -> beamConvergencePass
// deinterlacePass -> phosphorMaskPass
// brightpassPass -> bloomHorizontalPass
// #define TEX_CROP_WIDTH content_size.x
// #define TEX_CROP_HEIGHT content_size.y
// #define TEX_CROP_SIZE int2(TEX_CROP_WIDTH, TEX_CROP_HEIGHT)
// texture2D texCrop {
// Width = TEX_CROP_WIDTH;
// Height = TEX_CROP_HEIGHT;
// Format = RGBA16;
// };
// sampler2D samplerCrop { Texture = texCrop; };
// Pass 1 Buffer (interlacingPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is in electronBeamPass
// beamConvergencPass -> freezeFramePass
// phosphorMaskPass -> bloomHorizontalPass
// #define TEX_INTERLACED_WIDTH content_size.x
// #define TEX_INTERLACED_HEIGHT content_size.y
// #define TEX_INTERLACED_SIZE int2(TEX_INTERLACED_WIDTH, TEX_INTERLACED_HEIGHT)
// texture2D texInterlaced {
// Width = TEX_INTERLACED_WIDTH;
// Height = TEX_INTERLACED_HEIGHT;
// Format = RGBA16;
// };
// sampler2D samplerInterlaced { Texture = texInterlaced; };
// Pass 2 Buffer (electronBeamPass)
// Last usage is in beamConvergencePass
#define TEX_PREBLUR_VERT_WIDTH content_size.x
#define TEX_PREBLUR_VERT_HEIGHT content_size.y
static const uint2 TEX_PREBLUR_SIZE = uint2(TEX_PREBLUR_VERT_WIDTH, TEX_PREBLUR_VERT_HEIGHT);
texture2D texPreblurVert < pooled = true; > {
Width = TEX_PREBLUR_VERT_WIDTH;
Height = TEX_PREBLUR_VERT_HEIGHT;
Format = RGBA16;
};
sampler2D samplerPreblurVert { Texture = texPreblurVert; };
#define TEX_PREBLUR_HORIZ_WIDTH content_size.x
#define TEX_PREBLUR_HORIZ_HEIGHT content_size.y
static const uint2 TEX_PREBLUR_SIZE = uint2(TEX_PREBLUR_HORIZ_WIDTH, TEX_PREBLUR_HORIZ_HEIGHT);
texture2D texPreblurHoriz < pooled = true; > {
Width = TEX_PREBLUR_HORIZ_WIDTH;
Height = TEX_PREBLUR_HORIZ_HEIGHT;
Format = RGBA16;
};
sampler2D samplerPreblurHoriz { Texture = texPreblurHoriz; };
#define TEX_BEAMDIST_WIDTH num_beamdist_color_samples
#define TEX_BEAMDIST_HEIGHT num_beamdist_dist_samples
#define TEX_BEAMDIST_SIZE int2(TEX_BEAMDIST_WIDTH, TEX_BEAMDIST_HEIGHT)
texture2D texBeamDist < pooled = false; > {
Width = TEX_BEAMDIST_WIDTH;
Height = TEX_BEAMDIST_HEIGHT;
Format = RGB10A2;
};
sampler2D samplerBeamDist {
Texture = texBeamDist;
AddressV = WRAP;
};
// Pass 2 Buffer (electronBeamPass)
// Last usage is in beamConvergencePass
#define TEX_ELECTRONBEAMS_WIDTH content_size.x
#define TEX_ELECTRONBEAMS_HEIGHT content_size.y
#define TEX_ELECTRONBEAMS_SIZE int2(TEX_ELECTRONBEAMS_WIDTH, TEX_ELECTRONBEAMS_HEIGHT)
texture2D texElectronBeams < pooled = true; > {
Width = TEX_ELECTRONBEAMS_WIDTH;
Height = TEX_ELECTRONBEAMS_HEIGHT;
Format = RGBA16;
};
sampler2D samplerElectronBeams {
Texture = texElectronBeams;
AddressU = BORDER;
AddressV = BORDER;
};
// #define texElectronBeams texCrop
// #define samplerElectronBeams samplerCrop
// Pass 3 Buffer (beamConvergencPass)
// Last usage is freezeFramePass
#define TEX_BEAMCONVERGENCE_WIDTH content_size.x
#define TEX_BEAMCONVERGENCE_HEIGHT content_size.y
#define TEX_BEAMCONVERGENCE_SIZE int2(TEX_BEAMCONVERGENCE_WIDTH, TEX_BEAMCONVERGENCE_HEIGHT)
texture2D texBeamConvergence < pooled = true; > {
Width = TEX_BEAMCONVERGENCE_WIDTH;
Height = TEX_BEAMCONVERGENCE_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBeamConvergence { Texture = texBeamConvergence; };
// #define texBeamConvergence texInterlaced
// #define samplerBeamConvergence samplerInterlaced
/*
// Pass 4 Buffer (bloomApproxPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is in brightpassPass
#define TEX_BLOOMAPPROX_WIDTH 320
#define TEX_BLOOMAPPROX_HEIGHT 240
#define TEX_BLOOMAPPROX_SIZE int2(TEX_BLOOMAPPROX_WIDTH, TEX_BLOOMAPPROX_HEIGHT)
texture2D texBloomApprox {
Width = TEX_BLOOMAPPROX_WIDTH;
Height = TEX_BLOOMAPPROX_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBloomApprox { Texture = texBloomApprox; };
*/
// Pass 4a Buffer (bloomApproxVerticalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is in brightpassPass
#define TEX_BLOOMAPPROXVERT_WIDTH content_size.x
// #define TEX_BLOOMAPPROXVERT_HEIGHT 240
#define TEX_BLOOMAPPROXVERT_HEIGHT int(content_size.y / bloomapprox_downsizing_factor)
#define TEX_BLOOMAPPROXVERT_SIZE int2(TEX_BLOOMAPPROXVERT_WIDTH, TEX_BLOOMAPPROXVERT_HEIGHT)
texture2D texBloomApproxVert < pooled = true; > {
Width = TEX_BLOOMAPPROXVERT_WIDTH;
Height = TEX_BLOOMAPPROXVERT_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBloomApproxVert { Texture = texBloomApproxVert; };
// Pass 4b Buffer (bloomApproxHorizontalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is in brightpassPass
// #define TEX_BLOOMAPPROXHORIZ_WIDTH 320
// #define TEX_BLOOMAPPROXHORIZ_HEIGHT 240
#define TEX_BLOOMAPPROXHORIZ_WIDTH int(content_size.x / bloomapprox_downsizing_factor)
#define TEX_BLOOMAPPROXHORIZ_HEIGHT TEX_BLOOMAPPROXVERT_HEIGHT
#define TEX_BLOOMAPPROXHORIZ_SIZE int2(TEX_BLOOMAPPROXHORIZ_WIDTH, TEX_BLOOMAPPROXHORIZ_HEIGHT)
texture2D texBloomApproxHoriz < pooled = true; > {
Width = TEX_BLOOMAPPROXHORIZ_WIDTH;
Height = TEX_BLOOMAPPROXHORIZ_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBloomApproxHoriz { Texture = texBloomApproxHoriz; };
// Pass 5 Buffer (blurVerticalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is blurHorizontalPass
#define TEX_BLURVERTICAL_WIDTH TEX_BLOOMAPPROXHORIZ_WIDTH
#define TEX_BLURVERTICAL_HEIGHT TEX_BLOOMAPPROXHORIZ_HEIGHT
#define TEX_BLURVERTICAL_SIZE int2(TEX_BLURVERTICAL_WIDTH, TEX_BLURVERTICAL_HEIGHT)
texture2D texBlurVertical < pooled = true; > {
Width = TEX_BLURVERTICAL_WIDTH;
Height = TEX_BLURVERTICAL_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBlurVertical { Texture = texBlurVertical; };
// Pass 6 Buffer (blurHorizontalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is bloomHorizontalPass
#define TEX_BLURHORIZONTAL_WIDTH TEX_BLOOMAPPROXHORIZ_WIDTH
#define TEX_BLURHORIZONTAL_HEIGHT TEX_BLOOMAPPROXHORIZ_HEIGHT
#define TEX_BLURHORIZONTAL_SIZE int2(TEX_BLURHORIZONTAL_WIDTH, TEX_BLURHORIZONTAL_HEIGHT)
texture2D texBlurHorizontal < pooled = true; > {
Width = TEX_BLURHORIZONTAL_WIDTH;
Height = TEX_BLURHORIZONTAL_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBlurHorizontal { Texture = texBlurHorizontal; };
// Pass 7 (deinterlacePass)
// Last usage is phosphorMaskPass
#define TEX_DEINTERLACE_WIDTH content_size.x
#define TEX_DEINTERLACE_HEIGHT content_size.y
#define TEX_DEINTERLACE_SIZE int2(TEX_DEINTERLACE_WIDTH, TEX_DEINTERLACE_HEIGHT)
#if _DX9_ACTIVE == 0
texture2D texDeinterlace < pooled = true; > {
Width = TEX_DEINTERLACE_WIDTH;
Height = TEX_DEINTERLACE_HEIGHT;
Format = RGBA16;
};
sampler2D samplerDeinterlace { Texture = texDeinterlace; };
#else
#define texDeinterlace texElectronBeams
#define samplerDeinterlace samplerElectronBeams
#endif
// Pass 8 (freezeFramePass)
// Do not condition this on __RENDERER__. It will not work if another
// pass corrupts it.
#define TEX_FREEZEFRAME_WIDTH content_size.x
#define TEX_FREEZEFRAME_HEIGHT content_size.y
#define TEX_FREEZEFRAME_SIZE int2(TEX_FREEZEFRAME_WIDTH, TEX_FREEZEFRAME_HEIGHT
texture2D texFreezeFrame < pooled = false; > {
Width = TEX_FREEZEFRAME_WIDTH;
Height = TEX_FREEZEFRAME_HEIGHT;
Format = RGBA16;
};
sampler2D samplerFreezeFrame { Texture = texFreezeFrame; };
// Pass 10 Mask Texture (phosphorMaskResizeHorizontalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
#define TEX_PHOSPHORMASK_WIDTH content_size.x
#define TEX_PHOSPHORMASK_HEIGHT content_size.y
#define TEX_PHOSPHORMASKL_SIZE int2(TEX_PHOSPHORMASK_WIDTH, TEX_PHOSPHORMASK_HEIGHT)
texture2D texPhosphorMask < pooled = false; > {
Width = TEX_PHOSPHORMASK_WIDTH;
Height = TEX_PHOSPHORMASK_HEIGHT;
Format = RGBA16;
};
sampler2D samplerPhosphorMask { Texture = texPhosphorMask; };
// Pass 11 Buffer (phosphorMaskPass)
// Last usage is bloomHorizontalPass
#define TEX_MASKEDSCANLINES_WIDTH content_size.x
#define TEX_MASKEDSCANLINES_HEIGHT content_size.y
#define TEX_MASKEDSCANLINES_SIZE int2(TEX_MASKEDSCANLINES_WIDTH, TEX_MASKEDSCANLINES_HEIGHT)
#if _DX9_ACTIVE == 0
texture2D texMaskedScanlines < pooled = true; > {
Width = TEX_MASKEDSCANLINES_WIDTH;
Height = TEX_MASKEDSCANLINES_HEIGHT;
Format = RGBA16;
};
sampler2D samplerMaskedScanlines { Texture = texMaskedScanlines; };
#else
#define texMaskedScanlines texBeamConvergence
#define samplerMaskedScanlines samplerBeamConvergence
#endif
// Pass 12 Buffer (brightpassPass)
// Last usage is bloomHorizontalPass
#define TEX_BRIGHTPASS_WIDTH content_size.x
#define TEX_BRIGHTPASS_HEIGHT content_size.y
#define TEX_BRIGHTPASS_SIZE int2(TEX_BRIGHTPASS_WIDTH, TEX_BRIGHTPASS_HEIGHT)
#if _DX9_ACTIVE == 0
texture2D texBrightpass < pooled = true; > {
Width = TEX_BRIGHTPASS_WIDTH;
Height = TEX_BRIGHTPASS_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBrightpass { Texture = texBrightpass; };
#else
#define texBrightpass texElectronBeams
#define samplerBrightpass samplerElectronBeams
#endif
// Pass 13 Buffer (bloomVerticalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is bloomHorizontalPass
#define TEX_BLOOMVERTICAL_WIDTH content_size.x
#define TEX_BLOOMVERTICAL_HEIGHT content_size.y
#define TEX_BLOOMVERTICAL_SIZE int2(TEX_BLOOMVERTICAL_WIDTH, TEX_BLOOMVERTICAL_HEIGHT)
texture2D texBloomVertical < pooled = true; > {
Width = TEX_BLOOMVERTICAL_WIDTH;
Height = TEX_BLOOMVERTICAL_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBloomVertical { Texture = texBloomVertical; };
// Pass 14 Buffer (bloomHorizontalPass)
// Cannot be conditioned on __RENDERER__ b/c there are no
// available buffers of the same size
// Last usage is geometryPass
#define TEX_BLOOMHORIZONTAL_WIDTH content_size.x
#define TEX_BLOOMHORIZONTAL_HEIGHT content_size.y
#define TEX_BLOOMHORIZONTAL_SIZE int2(TEX_BLOOMHORIZONTAL_WIDTH, TEX_BLOOMHORIZONTAL_HEIGHT)
texture2D texBloomHorizontal < pooled = true; > {
Width = TEX_BLOOMHORIZONTAL_WIDTH;
Height = TEX_BLOOMHORIZONTAL_HEIGHT;
Format = RGBA16;
};
sampler2D samplerBloomHorizontal { Texture = texBloomHorizontal; };
// Pass 15 Buffer (geometryPass)
// Last usage is uncropPass
#define TEX_GEOMETRY_WIDTH content_size.x
#define TEX_GEOMETRY_HEIGHT content_size.y
#define TEX_GEOMETRY_SIZE int2(TEX_GEOMETRY_WIDTH, TEX_GEOMETRY_HEIGHT)
#if _DX9_ACTIVE == 0
texture2D texGeometry < pooled = true; > {
Width = TEX_GEOMETRY_WIDTH;
Height = TEX_GEOMETRY_HEIGHT;
Format = RGBA16;
};
sampler2D samplerGeometry { Texture = texGeometry; };
#else
#define texGeometry texElectronBeams
#define samplerGeometry samplerElectronBeams
#endif
#endif // _SHARED_OBJECTS_H

44
data/resources/shaders/reshade/Shaders/crt-royale/version-number.fxh Normal file
View File

@ -0,0 +1,44 @@
#ifndef _VERSION_NUMBER_H
#define _VERSION_NUMBER_H
///////////////////////////////// MIT LICENSE ////////////////////////////////
// Copyright (C) 2022 Alex Gunter
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#define MAJOR_VERSION 2
#define MINOR_VERSION 1
#define PATCH_VERSION 0
// Yes, both sibling preprocessor functions are necessary.
// Don't "simplify" this, or the substitution won't work.
#define BUILD_DOT_VERSION_(mav, miv, pav) #mav "." #miv "." #pav
#define BUILD_DOT_VERSION(mav, miv, pav) BUILD_DOT_VERSION_(mav, miv, pav)
#define DOT_VERSION_STR BUILD_DOT_VERSION(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
// Again, yes, both sibling preprocessor functions are necessary.
// Don't "simplify" this, or the substitution won't work.
#define BUILD_UNDERSCORE_VERSION_(prefix, mav, miv, pav) prefix ## _ ## mav ## _ ## miv ## _ ## pav
#define BUILD_UNDERSCORE_VERSION(p, mav, miv, pav) BUILD_UNDERSCORE_VERSION_(p, mav, miv, pav)
#define APPEND_VERSION_SUFFIX(prefix) BUILD_UNDERSCORE_VERSION(prefix, MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
#endif // _VERSION_NUMBER_H

1
data/resources/shaders/reshade/source.txt
View File

@ -1,2 +1,3 @@
https://github.com/crosire/reshade-shaders
https://github.com/Matsilagi/RSRetroArch/
https://github.com/akgunter/crt-royale-reshade

8
data/resources/thirdparty.html
View File

@ -3,7 +3,7 @@
<body>
<pre>
DuckStation PS1 Emulator
Copyright (C) 2019-2023 Connor McLaughlin &lt;stenzek@gmail.com&gt;
Copyright (C) 2019-2024 Connor McLaughlin &lt;stenzek@gmail.com&gt;
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
@ -1758,7 +1758,11 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
</pre>
Some shaders provided with the application are sourced from <a href="https://github.com/Matsilagi/RSRetroArch/">https://github.com/Matsilagi/RSRetroArch/</a>.<br>
Some shaders provided with the application are sourced from:
<ul>
<li><a href="https://github.com/Matsilagi/RSRetroArch/">https://github.com/Matsilagi/RSRetroArch/</a></li>
<li><a href="https://github.com/akgunter/crt-royale-reshade">https://github.com/akgunter/crt-royale-reshade</a></li>
</ul>
License details are included in the relevant shader source files, under resources\shaders\reshade.
</body>