#version 450 #extension GL_GOOGLE_cpp_style_line_directive : require #line 2 "crt-royale-geometry-aa-last-pass.slang" #line 1 "crt-royale-geometry-aa-last-pass.h" ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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 layout(push_constant) uniform Push { vec4 SourceSize; vec4 OriginalSize; vec4 OutputSize; uint FrameCount; } params; layout(std140, set = 0, binding = 0) uniform UBO { mat4 MVP; float crt_gamma; float lcd_gamma; float levels_contrast; float halation_weight; float diffusion_weight; float bloom_underestimate_levels; float bloom_excess; float beam_min_sigma; float beam_max_sigma; float beam_spot_power; float beam_min_shape; float beam_max_shape; float beam_shape_power; float beam_horiz_filter; float beam_horiz_sigma; float beam_horiz_linear_rgb_weight; float convergence_offset_x_r; float convergence_offset_x_g; float convergence_offset_x_b; float convergence_offset_y_r; float convergence_offset_y_g; float convergence_offset_y_b; float mask_type; float mask_sample_mode_desired; float mask_num_triads_desired; float mask_triad_size_desired; float mask_specify_num_triads; float aa_subpixel_r_offset_x_runtime; float aa_subpixel_r_offset_y_runtime; float aa_cubic_c; float aa_gauss_sigma; float geom_mode_runtime; float geom_radius; float geom_view_dist; float geom_tilt_angle_x; float geom_tilt_angle_y; float geom_aspect_ratio_x; float geom_aspect_ratio_y; float geom_overscan_x; float geom_overscan_y; float border_size; float border_darkness; float border_compress; float interlace_bff; float interlace_1080i; vec4 MASKED_SCANLINESSize; vec4 HALATION_BLURSize; vec4 BRIGHTPASSSize; } global; ///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// #define LAST_PASS #define SIMULATE_CRT_ON_LCD #line 1 "compat_macros.inc" // compatibility macros for transparently converting HLSLisms into GLSLisms #define mul(a,b) (b*a) #define lerp(a,b,c) mix(a,b,c) #define saturate(c) clamp(c, 0.0, 1.0) #define frac(x) (fract(x)) #define float2 vec2 #define float3 vec3 #define float4 vec4 #define bool2 bvec2 #define bool3 bvec3 #define bool4 bvec4 #define float2x2 mat2x2 #define float3x3 mat3x3 #define float4x4 mat4x4 #define float4x3 mat4x3 #define float2x4 mat2x4 #define IN params #define texture_size SourceSize.xy #define video_size SourceSize.xy #define output_size OutputSize.xy #define frame_count FrameCount #define static #define inline #define fmod(x,y) mod(x,y) #define ddx(c) dFdx(c) #define ddy(c) dFdy(c) #define atan2(x,y) atan(y,x) #define rsqrt(c) inversesqrt(c) #line 84 "crt-royale-geometry-aa-last-pass.h" #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 85 "crt-royale-geometry-aa-last-pass.h" #line 1 "derived-settings-and-constants.h" #ifndef DERIVED_SETTINGS_AND_CONSTANTS_H #define DERIVED_SETTINGS_AND_CONSTANTS_H ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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. ////////////////////////////////// INCLUDES ////////////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 31 "derived-settings-and-constants.h" #line 1 "user-cgp-constants.h" #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_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). //#define PHOSPHOR_MASK_GRILLE14 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 #ifdef 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 #line 55 "user-cgp-constants.h" #endif // USER_CGP_CONSTANTS_H #line 58 "user-cgp-constants.h" #line 32 "derived-settings-and-constants.h" /////////////////////////////// FIXED SETTINGS /////////////////////////////// // Avoid dividing by zero; using a macro overloads for float, float2, etc.: #define FIX_ZERO(c) (max(abs(c), 0.0000152587890625)) // 2^-16 // Ensure the first pass decodes CRT gamma and the last encodes LCD gamma. #ifndef SIMULATE_CRT_ON_LCD #define SIMULATE_CRT_ON_LCD #endif #line 44 "derived-settings-and-constants.h" // 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). #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD // 129.7 FPS, 4x, flat; 101.8 at fullscreen #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE // 128.1 FPS, 4x, flat; 101.5 at fullscreen #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES // 124.4 FPS, 4x, flat; 97.4 at fullscreen // 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. //#define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD ////////////////////////////// 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.) #ifdef INTEGRATED_GRAPHICS_COMPATIBILITY_MODE #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE #undef PHOSPHOR_MASK_MANUALLY_RESIZE #endif #line 79 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 82 "derived-settings-and-constants.h" // 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 = bloom_approx_filter_static > 1.5 ? 0.0 : bloom_approx_filter_static; #else static const float bloom_approx_filter = bloom_approx_filter_static; #endif #line 89 "derived-settings-and-constants.h" // 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. #ifndef RUNTIME_SHADER_PARAMS_ENABLE #ifdef RUNTIME_PHOSPHOR_BLOOM_SIGMA #undef RUNTIME_PHOSPHOR_BLOOM_SIGMA #endif #line 96 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_WEIGHTS #undef RUNTIME_ANTIALIAS_WEIGHTS #endif #line 99 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #undef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #endif #line 102 "derived-settings-and-constants.h" #ifdef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #undef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #endif #line 105 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_TILT #undef RUNTIME_GEOMETRY_TILT #endif #line 108 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 111 "derived-settings-and-constants.h" #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #undef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 114 "derived-settings-and-constants.h" #endif #line 115 "derived-settings-and-constants.h" // Make tex2Dbias a backup for tex2Dlod for wider compatibility. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 120 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 123 "derived-settings-and-constants.h" // Rule out unavailable anisotropic compatibility strategies: #ifndef DRIVERS_ALLOW_DERIVATIVES #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 128 "derived-settings-and-constants.h" #endif #line 129 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #undef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #endif #line 133 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #endif #line 136 "derived-settings-and-constants.h" #ifdef ANTIALIAS_DISABLE_ANISOTROPIC #undef ANTIALIAS_DISABLE_ANISOTROPIC #endif #line 139 "derived-settings-and-constants.h" #endif #line 140 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 144 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 147 "derived-settings-and-constants.h" #endif #line 148 "derived-settings-and-constants.h" // Prioritize anisotropic tiling compatibility strategies by performance and // disable unused strategies. This concentrates all the nesting in one place. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 154 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 157 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 160 "derived-settings-and-constants.h" #else #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 165 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 168 "derived-settings-and-constants.h" #else // ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE is only compatible with // flat texture coords in the same pass, but that's all we use. #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 175 "derived-settings-and-constants.h" #endif #line 176 "derived-settings-and-constants.h" #endif #line 177 "derived-settings-and-constants.h" #endif #line 178 "derived-settings-and-constants.h" // 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: #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 183 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 186 "derived-settings-and-constants.h" // Prioritize anisotropic resampling compatibility strategies the same way: #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 191 "derived-settings-and-constants.h" #endif #line 192 "derived-settings-and-constants.h" /////////////////////// 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. #ifdef DRIVERS_ALLOW_TEX2DLOD #ifdef 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_small_size; #endif #line 206 "derived-settings-and-constants.h" #else static const float2 mask_resize_src_lut_size = mask_texture_small_size; #endif #line 209 "derived-settings-and-constants.h" // 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. #ifdef DRIVERS_ALLOW_DYNAMIC_BRANCHES #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #else #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 231 "derived-settings-and-constants.h" #endif #line 232 "derived-settings-and-constants.h" // 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 #line 247 "derived-settings-and-constants.h" // 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 #line 253 "derived-settings-and-constants.h" // Fixing discontinuities adds 1.0 more to the pixel border: #ifdef 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 #line 259 "derived-settings-and-constants.h" // Convert the pixel border to an integer texel border. Assume same-pass // curvature about triples the texel frequency: #ifdef GEOMETRY_EARLY static const float max_mask_texel_border = ceil(max_tiled_pixel_border * 3.0); #else static const float max_mask_texel_border = ceil(max_tiled_pixel_border); #endif #line 267 "derived-settings-and-constants.h" // 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 #ifdef 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 #line 284 "derived-settings-and-constants.h" #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 #line 288 "derived-settings-and-constants.h" // 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_viewport_scale; //////////////////////// 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; #endif // DERIVED_SETTINGS_AND_CONSTANTS_H #line 315 "derived-settings-and-constants.h" #line 86 "crt-royale-geometry-aa-last-pass.h" #line 1 "bind-shader-params.h" #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 // // 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 //////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 25 "bind-shader-params.h" #line 1 "derived-settings-and-constants.h" #ifndef DERIVED_SETTINGS_AND_CONSTANTS_H #define DERIVED_SETTINGS_AND_CONSTANTS_H ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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. ////////////////////////////////// INCLUDES ////////////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 31 "derived-settings-and-constants.h" #line 1 "user-cgp-constants.h" #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_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). //#define PHOSPHOR_MASK_GRILLE14 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 #ifdef 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 #line 55 "user-cgp-constants.h" #endif // USER_CGP_CONSTANTS_H #line 58 "user-cgp-constants.h" #line 32 "derived-settings-and-constants.h" /////////////////////////////// FIXED SETTINGS /////////////////////////////// // Avoid dividing by zero; using a macro overloads for float, float2, etc.: #define FIX_ZERO(c) (max(abs(c), 0.0000152587890625)) // 2^-16 // Ensure the first pass decodes CRT gamma and the last encodes LCD gamma. #ifndef SIMULATE_CRT_ON_LCD #define SIMULATE_CRT_ON_LCD #endif #line 44 "derived-settings-and-constants.h" // 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). #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD // 129.7 FPS, 4x, flat; 101.8 at fullscreen #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE // 128.1 FPS, 4x, flat; 101.5 at fullscreen #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES // 124.4 FPS, 4x, flat; 97.4 at fullscreen // 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. //#define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD ////////////////////////////// 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.) #ifdef INTEGRATED_GRAPHICS_COMPATIBILITY_MODE #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE #undef PHOSPHOR_MASK_MANUALLY_RESIZE #endif #line 79 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 82 "derived-settings-and-constants.h" // 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 = bloom_approx_filter_static > 1.5 ? 0.0 : bloom_approx_filter_static; #else static const float bloom_approx_filter = bloom_approx_filter_static; #endif #line 89 "derived-settings-and-constants.h" // 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. #ifndef RUNTIME_SHADER_PARAMS_ENABLE #ifdef RUNTIME_PHOSPHOR_BLOOM_SIGMA #undef RUNTIME_PHOSPHOR_BLOOM_SIGMA #endif #line 96 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_WEIGHTS #undef RUNTIME_ANTIALIAS_WEIGHTS #endif #line 99 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #undef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #endif #line 102 "derived-settings-and-constants.h" #ifdef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #undef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #endif #line 105 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_TILT #undef RUNTIME_GEOMETRY_TILT #endif #line 108 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 111 "derived-settings-and-constants.h" #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #undef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 114 "derived-settings-and-constants.h" #endif #line 115 "derived-settings-and-constants.h" // Make tex2Dbias a backup for tex2Dlod for wider compatibility. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 120 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 123 "derived-settings-and-constants.h" // Rule out unavailable anisotropic compatibility strategies: #ifndef DRIVERS_ALLOW_DERIVATIVES #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 128 "derived-settings-and-constants.h" #endif #line 129 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #undef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #endif #line 133 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #endif #line 136 "derived-settings-and-constants.h" #ifdef ANTIALIAS_DISABLE_ANISOTROPIC #undef ANTIALIAS_DISABLE_ANISOTROPIC #endif #line 139 "derived-settings-and-constants.h" #endif #line 140 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 144 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 147 "derived-settings-and-constants.h" #endif #line 148 "derived-settings-and-constants.h" // Prioritize anisotropic tiling compatibility strategies by performance and // disable unused strategies. This concentrates all the nesting in one place. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 154 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 157 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 160 "derived-settings-and-constants.h" #else #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 165 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 168 "derived-settings-and-constants.h" #else // ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE is only compatible with // flat texture coords in the same pass, but that's all we use. #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 175 "derived-settings-and-constants.h" #endif #line 176 "derived-settings-and-constants.h" #endif #line 177 "derived-settings-and-constants.h" #endif #line 178 "derived-settings-and-constants.h" // 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: #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 183 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 186 "derived-settings-and-constants.h" // Prioritize anisotropic resampling compatibility strategies the same way: #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 191 "derived-settings-and-constants.h" #endif #line 192 "derived-settings-and-constants.h" /////////////////////// 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. #ifdef DRIVERS_ALLOW_TEX2DLOD #ifdef 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_small_size; #endif #line 206 "derived-settings-and-constants.h" #else static const float2 mask_resize_src_lut_size = mask_texture_small_size; #endif #line 209 "derived-settings-and-constants.h" // 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. #ifdef DRIVERS_ALLOW_DYNAMIC_BRANCHES #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #else #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 231 "derived-settings-and-constants.h" #endif #line 232 "derived-settings-and-constants.h" // 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 #line 247 "derived-settings-and-constants.h" // 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 #line 253 "derived-settings-and-constants.h" // Fixing discontinuities adds 1.0 more to the pixel border: #ifdef 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 #line 259 "derived-settings-and-constants.h" // Convert the pixel border to an integer texel border. Assume same-pass // curvature about triples the texel frequency: #ifdef GEOMETRY_EARLY static const float max_mask_texel_border = ceil(max_tiled_pixel_border * 3.0); #else static const float max_mask_texel_border = ceil(max_tiled_pixel_border); #endif #line 267 "derived-settings-and-constants.h" // 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 #ifdef 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 #line 284 "derived-settings-and-constants.h" #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 #line 288 "derived-settings-and-constants.h" // 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_viewport_scale; //////////////////////// 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; #endif // DERIVED_SETTINGS_AND_CONSTANTS_H #line 315 "derived-settings-and-constants.h" #line 26 "bind-shader-params.h" // Override some parameters for gamma-management.h and tex2Dantialias.h: #define OVERRIDE_DEVICE_GAMMA static const float gba_gamma = 3.5; // Irrelevant but necessary to define. #define ANTIALIAS_OVERRIDE_BASICS #define ANTIALIAS_OVERRIDE_PARAMETERS // Disable runtime shader params if the user doesn't explicitly want them. // Static constants will be defined in place of uniforms of the same name. #ifdef RUNTIME_SHADER_PARAMS_ENABLE #ifndef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE static const float beam_horiz_filter = clamp(beam_horiz_filter_static, 0.0, 2.0); static const float beam_horiz_linear_rgb_weight = clamp(beam_horiz_linear_rgb_weight_static, 0.0, 1.0); #endif #line 41 "bind-shader-params.h" #ifndef RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT static const float mask_type = clamp(mask_type_static, 0.0, 2.0); #endif #line 44 "bind-shader-params.h" #ifndef RUNTIME_ANTIALIAS_WEIGHTS static const float aa_cubic_c = aa_cubic_c_static; // Clamp to [0, 4]? static const float aa_gauss_sigma = max(FIX_ZERO(0.0), aa_gauss_sigma_static); // Clamp to [FIXZERO(0), 1]? #endif #line 48 "bind-shader-params.h" #else #define HARDCODE_SETTINGS #endif #line 51 "bind-shader-params.h" // Bind option names to shader parameter uniforms or static constants. #ifdef HARDCODE_SETTINGS // Use constants from user-settings.h, and limit ranges appropriately: static const float crt_gamma = max(0.0, crt_gamma_static); static const float lcd_gamma = max(0.0, lcd_gamma_static); static const float levels_contrast = clamp(levels_contrast_static, 0.0, 4.0); static const float halation_weight = clamp(halation_weight_static, 0.0, 1.0); static const float diffusion_weight = clamp(diffusion_weight_static, 0.0, 1.0); static const float bloom_underestimate_levels = max(FIX_ZERO(0.0), bloom_underestimate_levels_static); static const float bloom_excess = clamp(bloom_excess_static, 0.0, 1.0); static const float beam_min_sigma = max(FIX_ZERO(0.0), beam_min_sigma_static); static const float beam_max_sigma = max(beam_min_sigma, beam_max_sigma_static); static const float beam_spot_power = max(beam_spot_power_static, 0.0); static const float beam_min_shape = max(2.0, beam_min_shape_static); static const float beam_max_shape = max(beam_min_shape, beam_max_shape_static); static const float beam_shape_power = max(0.0, beam_shape_power_static); static const float beam_horiz_filter = clamp(beam_horiz_filter_static, 0.0, 2.0); static const float beam_horiz_sigma = max(FIX_ZERO(0.0), beam_horiz_sigma_static); static const float beam_horiz_linear_rgb_weight = clamp(beam_horiz_linear_rgb_weight_static, 0.0, 1.0); // Unpack static vector elements to match scalar uniforms: static const float convergence_offset_x_r = clamp(convergence_offsets_r_static.x, -4.0, 4.0); static const float convergence_offset_x_g = clamp(convergence_offsets_g_static.x, -4.0, 4.0); static const float convergence_offset_x_b = clamp(convergence_offsets_b_static.x, -4.0, 4.0); static const float convergence_offset_y_r = clamp(convergence_offsets_r_static.y, -4.0, 4.0); static const float convergence_offset_y_g = clamp(convergence_offsets_g_static.y, -4.0, 4.0); static const float convergence_offset_y_b = clamp(convergence_offsets_b_static.y, -4.0, 4.0); static const float mask_type = clamp(mask_type_static, 0.0, 2.0); static const float mask_sample_mode_desired = clamp(mask_sample_mode_static, 0.0, 2.0); static const float mask_specify_num_triads = clamp(mask_specify_num_triads_static, 0.0, 1.0); static const float mask_triad_size_desired = clamp(mask_triad_size_desired_static, 1.0, 18.0); static const float mask_num_triads_desired = clamp(mask_num_triads_desired_static, 342.0, 1920.0); static const float aa_subpixel_r_offset_x_runtime = clamp(aa_subpixel_r_offset_static.x, -0.5, 0.5); static const float aa_subpixel_r_offset_y_runtime = clamp(aa_subpixel_r_offset_static.y, -0.5, 0.5); static const float aa_cubic_c = aa_cubic_c_static; // Clamp to [0, 4]? static const float aa_gauss_sigma = max(FIX_ZERO(0.0), aa_gauss_sigma_static); // Clamp to [FIXZERO(0), 1]? static const float geom_mode_runtime = clamp(geom_mode_static, 0.0, 3.0); static const float geom_radius = max(1.0/(2.0*pi), geom_radius_static); // Clamp to [1/(2*pi), 1024]? static const float geom_view_dist = max(0.5, geom_view_dist_static); // Clamp to [0.5, 1024]? static const float geom_tilt_angle_x = clamp(geom_tilt_angle_static.x, -pi, pi); static const float geom_tilt_angle_y = clamp(geom_tilt_angle_static.y, -pi, pi); static const float geom_aspect_ratio_x = geom_aspect_ratio_static; // Force >= 1? static const float geom_aspect_ratio_y = 1.0; static const float geom_overscan_x = max(FIX_ZERO(0.0), geom_overscan_static.x); static const float geom_overscan_y = max(FIX_ZERO(0.0), geom_overscan_static.y); static const float border_size = clamp(border_size_static, 0.0, 0.5); // 0.5 reaches to image center static const float border_darkness = max(0.0, border_darkness_static); static const float border_compress = max(1.0, border_compress_static); // < 1.0 darkens whole image static const float interlace_bff = float(interlace_bff_static); static const float interlace_1080i = float(interlace_1080i_static); #else #pragma parameter crt_gamma "Simulated CRT Gamma" 2.5 1.0 5.0 0.025 #line 103 "bind-shader-params.h" #define crt_gamma global.crt_gamma #pragma parameter lcd_gamma "Your Display Gamma" 2.2 1.0 5.0 0.025 #line 105 "bind-shader-params.h" #define lcd_gamma global.lcd_gamma #pragma parameter levels_contrast "Contrast" 1.0 0.0 4.0 0.015625 #line 107 "bind-shader-params.h" #define levels_contrast global.levels_contrast #pragma parameter halation_weight "Halation Weight" 0.0 0.0 1.0 0.005 #line 109 "bind-shader-params.h" #pragma parameter diffusion_weight "Diffusion Weight" 0.075 0.0 1.0 0.005 #line 110 "bind-shader-params.h" #pragma parameter bloom_underestimate_levels "Bloom - Underestimate Levels" 0.8 0.0 5.0 0.01 #line 111 "bind-shader-params.h" #define bloom_underestimate_levels global.bloom_underestimate_levels #pragma parameter bloom_excess "Bloom - Excess" 0.0 0.0 1.0 0.005 #line 113 "bind-shader-params.h" #pragma parameter beam_min_sigma "Beam - Min Sigma" 0.02 0.005 1.0 0.005 #line 114 "bind-shader-params.h" #define beam_min_sigma global.beam_min_sigma #pragma parameter beam_max_sigma "Beam - Max Sigma" 0.3 0.005 1.0 0.005 #line 116 "bind-shader-params.h" #define beam_max_sigma global.beam_max_sigma #pragma parameter beam_spot_power "Beam - Spot Power" 0.33 0.01 16.0 0.01 #line 118 "bind-shader-params.h" #define beam_spot_power global.beam_spot_power #pragma parameter beam_min_shape "Beam - Min Shape" 2.0 2.0 32.0 0.1 #line 120 "bind-shader-params.h" #define beam_min_shape global.beam_min_shape #pragma parameter beam_max_shape "Beam - Max Shape" 4.0 2.0 32.0 0.1 #line 122 "bind-shader-params.h" #define beam_max_shape global.beam_max_shape #pragma parameter beam_shape_power "Beam - Shape Power" 0.25 0.01 16.0 0.01 #line 124 "bind-shader-params.h" #define beam_shape_power global.beam_shape_power #pragma parameter beam_horiz_filter "Beam - Horiz Filter" 0.0 0.0 2.0 1.0 #line 126 "bind-shader-params.h" #define beam_horiz_filter global.beam_horiz_filter #pragma parameter beam_horiz_sigma "Beam - Horiz Sigma" 0.35 0.0 0.67 0.005 #line 128 "bind-shader-params.h" #define beam_horiz_sigma global.beam_horiz_sigma #pragma parameter beam_horiz_linear_rgb_weight "Beam - Horiz Linear RGB Weight" 1.0 0.0 1.0 0.01 #line 130 "bind-shader-params.h" #pragma parameter convergence_offset_x_r "Convergence - Offset X Red" 0.0 -4.0 4.0 0.05 #line 131 "bind-shader-params.h" #define convergence_offset_x_r global.convergence_offset_x_r #pragma parameter convergence_offset_x_g "Convergence - Offset X Green" 0.0 -4.0 4.0 0.05 #line 133 "bind-shader-params.h" #define convergence_offset_x_g global.convergence_offset_x_g #pragma parameter convergence_offset_x_b "Convergence - Offset X Blue" 0.0 -4.0 4.0 0.05 #line 135 "bind-shader-params.h" #define convergence_offset_x_b global.convergence_offset_x_b #pragma parameter convergence_offset_y_r "Convergence - Offset Y Red" 0.0 -2.0 2.0 0.05 #line 137 "bind-shader-params.h" #define convergence_offset_y_r global.convergence_offset_y_r #pragma parameter convergence_offset_y_g "Convergence - Offset Y Green" 0.0 -2.0 2.0 0.05 #line 139 "bind-shader-params.h" #define convergence_offset_y_g global.convergence_offset_y_g #pragma parameter convergence_offset_y_b "Convergence - Offset Y Blue" 0.0 -2.0 2.0 0.05 #line 141 "bind-shader-params.h" #define convergence_offset_y_b global.convergence_offset_y_b #pragma parameter mask_type "Mask - Type" 1.0 0.0 2.0 1.0 #line 143 "bind-shader-params.h" #define mask_type global.mask_type #pragma parameter mask_sample_mode_desired "Mask - Sample Mode" 0.0 0.0 2.0 1.0 // Consider blocking mode 2. #line 145 "bind-shader-params.h" #define mask_sample_mode_desired global.mask_sample_mode_desired #pragma parameter mask_specify_num_triads "Mask - Specify Number of Triads" 0.0 0.0 1.0 1.0 #line 147 "bind-shader-params.h" #pragma parameter mask_triad_size_desired "Mask - Triad Size Desired" 3.0 1.0 18.0 0.125 #line 148 "bind-shader-params.h" #pragma parameter mask_num_triads_desired "Mask - Number of Triads Desired" 480.0 342.0 1920.0 1.0 #line 149 "bind-shader-params.h" #pragma parameter aa_subpixel_r_offset_x_runtime "AA - Subpixel R Offset X" -0.333333333 -0.333333333 0.333333333 0.333333333 #line 150 "bind-shader-params.h" #define aa_subpixel_r_offset_x_runtime global.aa_subpixel_r_offset_x_runtime #pragma parameter aa_subpixel_r_offset_y_runtime "AA - Subpixel R Offset Y" 0.0 -0.333333333 0.333333333 0.333333333 #line 152 "bind-shader-params.h" #define aa_subpixel_r_offset_y_runtime global.aa_subpixel_r_offset_y_runtime #pragma parameter aa_cubic_c "AA - Cubic Sharpness" 0.5 0.0 4.0 0.015625 #line 154 "bind-shader-params.h" #define aa_cubic_c global.aa_cubic_c #pragma parameter aa_gauss_sigma "AA - Gaussian Sigma" 0.5 0.0625 1.0 0.015625 #line 156 "bind-shader-params.h" #define aa_gauss_sigma global.aa_gauss_sigma #pragma parameter geom_mode_runtime "Geometry - Mode" 0.0 0.0 3.0 1.0 #line 158 "bind-shader-params.h" #define geom_mode_runtime global.geom_mode_runtime #pragma parameter geom_radius "Geometry - Radius" 2.0 0.16 1024.0 0.1 #line 160 "bind-shader-params.h" #define geom_radius global.geom_radius #pragma parameter geom_view_dist "Geometry - View Distance" 2.0 0.5 1024.0 0.25 #line 162 "bind-shader-params.h" #define geom_view_dist global.geom_view_dist #pragma parameter geom_tilt_angle_x "Geometry - Tilt Angle X" 0.0 -3.14159265 3.14159265 0.017453292519943295 #line 164 "bind-shader-params.h" #define geom_tilt_angle_x global.geom_tilt_angle_x #pragma parameter geom_tilt_angle_y "Geometry - Tilt Angle Y" 0.0 -3.14159265 3.14159265 0.017453292519943295 #line 166 "bind-shader-params.h" #define geom_tilt_angle_y global.geom_tilt_angle_y #pragma parameter geom_aspect_ratio_x "Geometry - Aspect Ratio X" 432.0 1.0 512.0 1.0 #line 168 "bind-shader-params.h" #define geom_aspect_ratio_x global.geom_aspect_ratio_x #pragma parameter geom_aspect_ratio_y "Geometry - Aspect Ratio Y" 329.0 1.0 512.0 1.0 #line 170 "bind-shader-params.h" #define geom_aspect_ratio_y global.geom_aspect_ratio_y #pragma parameter geom_overscan_x "Geometry - Overscan X" 1.0 0.00390625 4.0 0.00390625 #line 172 "bind-shader-params.h" #define geom_overscan_x global.geom_overscan_x #pragma parameter geom_overscan_y "Geometry - Overscan Y" 1.0 0.00390625 4.0 0.00390625 #line 174 "bind-shader-params.h" #define geom_overscan_y global.geom_overscan_y #pragma parameter border_size "Border - Size" 0.015 0.0000001 0.5 0.005 #line 176 "bind-shader-params.h" #define border_size global.border_size #pragma parameter border_darkness "Border - Darkness" 2.0 0.0 16.0 0.0625 #line 178 "bind-shader-params.h" #define border_darkness global.border_darkness #pragma parameter border_compress "Border - Compression" 2.5 1.0 64.0 0.0625 #line 180 "bind-shader-params.h" #define border_compress global.border_compress #pragma parameter interlace_bff "Interlacing - Bottom Field First" 0.0 0.0 1.0 1.0 #line 182 "bind-shader-params.h" //#define interlace_bff global.interlace_bff #pragma parameter interlace_1080i "Interlace - Detect 1080i" 0.0 0.0 1.0 1.0 #line 184 "bind-shader-params.h" #define interlace_1080i global.interlace_1080i #endif #line 186 "bind-shader-params.h" // Provide accessors for vector constants that pack scalar uniforms: inline 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; } inline float2 get_geom_overscan_vector() { return float2(geom_overscan_x, geom_overscan_y); } inline float2 get_geom_tilt_angle_vector() { return float2(geom_tilt_angle_x, geom_tilt_angle_y); } inline float3 get_convergence_offsets_x_vector() { return float3(convergence_offset_x_r, convergence_offset_x_g, convergence_offset_x_b); } inline float3 get_convergence_offsets_y_vector() { return float3(convergence_offset_y_r, convergence_offset_y_g, convergence_offset_y_b); } inline float2 get_convergence_offsets_r_vector() { return float2(convergence_offset_x_r, convergence_offset_y_r); } inline float2 get_convergence_offsets_g_vector() { return float2(convergence_offset_x_g, convergence_offset_y_g); } inline float2 get_convergence_offsets_b_vector() { return float2(convergence_offset_x_b, convergence_offset_y_b); } inline float2 get_aa_subpixel_r_offset() { #ifdef RUNTIME_ANTIALIAS_WEIGHTS #ifdef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // WARNING: THIS IS EXTREMELY EXPENSIVE. return float2(aa_subpixel_r_offset_x_runtime, aa_subpixel_r_offset_y_runtime); #else return aa_subpixel_r_offset_static; #endif #line 246 "bind-shader-params.h" #else return aa_subpixel_r_offset_static; #endif #line 249 "bind-shader-params.h" } // Provide accessors settings which still need "cooking:" inline 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; return mask_type < 0.5 ? mask_grille_amplify : mask_type < 1.5 ? mask_slot_amplify : mask_shadow_amplify; } inline float get_mask_sample_mode() { #ifdef RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE return mask_sample_mode_desired; #else return clamp(mask_sample_mode_desired, 1.0, 2.0); #endif #line 270 "bind-shader-params.h" #else #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE return mask_sample_mode_static; #else return clamp(mask_sample_mode_static, 1.0, 2.0); #endif #line 276 "bind-shader-params.h" #endif #line 277 "bind-shader-params.h" } #endif // BIND_SHADER_PARAMS_H #line 280 "bind-shader-params.h" #line 87 "crt-royale-geometry-aa-last-pass.h" #ifndef 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 #line 104 "crt-royale-geometry-aa-last-pass.h" ////////////////////////////////// INCLUDES ////////////////////////////////// #line 1 "gamma-management.h" #ifndef GAMMA_MANAGEMENT_H #define GAMMA_MANAGEMENT_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 provides gamma-aware tex*D*() and encode_output() functions. // Requires: Before #include-ing this file, the including file must #define // the following macros when applicable and follow their rules: // 1.) #define FIRST_PASS if this is the first pass. // 2.) #define LAST_PASS if this is the last pass. // 3.) If sRGB is available, set srgb_framebufferN = "true" for // every pass except the last in your .cgp preset. // 4.) If sRGB isn't available but you want gamma-correctness with // no banding, #define GAMMA_ENCODE_EVERY_FBO each pass. // 5.) #define SIMULATE_CRT_ON_LCD if desired (precedence over 5-7) // 6.) #define SIMULATE_GBA_ON_LCD if desired (precedence over 6-7) // 7.) #define SIMULATE_LCD_ON_CRT if desired (precedence over 7) // 8.) #define SIMULATE_GBA_ON_CRT if desired (precedence over -) // If an option in [5, 8] is #defined in the first or last pass, it // should be #defined for both. It shouldn't make a difference // whether it's #defined for intermediate passes or not. // Optional: The including file (or an earlier included file) may optionally // #define a number of macros indicating it will override certain // macros and associated constants are as follows: // static constants with either static or uniform constants. The // 1.) OVERRIDE_STANDARD_GAMMA: The user must first define: // static const float ntsc_gamma // static const float pal_gamma // static const float crt_reference_gamma_high // static const float crt_reference_gamma_low // static const float lcd_reference_gamma // static const float crt_office_gamma // static const float lcd_office_gamma // 2.) OVERRIDE_DEVICE_GAMMA: The user must first define: // static const float crt_gamma // static const float gba_gamma // static const float lcd_gamma // 3.) OVERRIDE_FINAL_GAMMA: The user must first define: // static const float input_gamma // static const float intermediate_gamma // static const float output_gamma // (intermediate_gamma is for GAMMA_ENCODE_EVERY_FBO.) // 4.) OVERRIDE_ALPHA_ASSUMPTIONS: The user must first define: // static const bool assume_opaque_alpha // The gamma constant overrides must be used in every pass or none, // and OVERRIDE_FINAL_GAMMA bypasses all of the SIMULATE* macros. // OVERRIDE_ALPHA_ASSUMPTIONS may be set on a per-pass basis. // Usage: After setting macros appropriately, ignore gamma correction and // replace all tex*D*() calls with equivalent gamma-aware // tex*D*_linearize calls, except: // 1.) When you read an LUT, use regular tex*D or a gamma-specified // function, depending on its gamma encoding: // tex*D*_linearize_gamma (takes a runtime gamma parameter) // 2.) If you must read pass0's original input in a later pass, use // tex2D_linearize_ntsc_gamma. If you want to read pass0's // input with gamma-corrected bilinear filtering, consider // creating a first linearizing pass and reading from the input // of pass1 later. // Then, return encode_output(color) from every fragment shader. // Finally, use the global gamma_aware_bilinear boolean if you want // to statically branch based on whether bilinear filtering is // gamma-correct or not (e.g. for placing Gaussian blur samples). // // Detailed Policy: // tex*D*_linearize() functions enforce a consistent gamma-management policy // based on the FIRST_PASS and GAMMA_ENCODE_EVERY_FBO settings. They assume // their input texture has the same encoding characteristics as the input for // the current pass (which doesn't apply to the exceptions listed above). // Similarly, encode_output() enforces a policy based on the LAST_PASS and // GAMMA_ENCODE_EVERY_FBO settings. Together, they result in one of the // following two pipelines. // Typical pipeline with intermediate sRGB framebuffers: // linear_color = pow(pass0_encoded_color, input_gamma); // intermediate_output = linear_color; // Automatic sRGB encoding // linear_color = intermediate_output; // Automatic sRGB decoding // final_output = pow(intermediate_output, 1.0/output_gamma); // Typical pipeline without intermediate sRGB framebuffers: // linear_color = pow(pass0_encoded_color, input_gamma); // intermediate_output = pow(linear_color, 1.0/intermediate_gamma); // linear_color = pow(intermediate_output, intermediate_gamma); // final_output = pow(intermediate_output, 1.0/output_gamma); // Using GAMMA_ENCODE_EVERY_FBO is much slower, but it's provided as a way to // easily get gamma-correctness without banding on devices where sRGB isn't // supported. // // Use This Header to Maximize Code Reuse: // The purpose of this header is to provide a consistent interface for texture // reads and output gamma-encoding that localizes and abstracts away all the // annoying details. This greatly reduces the amount of code in each shader // pass that depends on the pass number in the .cgp preset or whether sRGB // FBO's are being used: You can trivially change the gamma behavior of your // whole pass by commenting or uncommenting 1-3 #defines. To reuse the same // code in your first, Nth, and last passes, you can even put it all in another // header file and #include it from skeleton .cg files that #define the // appropriate pass-specific settings. // // Rationale for Using Three Macros: // This file uses GAMMA_ENCODE_EVERY_FBO instead of an opposite macro like // SRGB_PIPELINE to ensure sRGB is assumed by default, which hopefully imposes // a lower maintenance burden on each pass. At first glance it seems we could // accomplish everything with two macros: GAMMA_CORRECT_IN / GAMMA_CORRECT_OUT. // This works for simple use cases where input_gamma == output_gamma, but it // breaks down for more complex scenarios like CRT simulation, where the pass // number determines the gamma encoding of the input and output. /////////////////////////////// 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 #line 153 "gamma-management.h" // 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 #line 159 "gamma-management.h" /////////////////////// 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: #ifdef OVERRIDE_DEVICE_GAMMA // The user promises to globally define the appropriate constants: inline float get_crt_gamma() { return crt_gamma; } inline float get_gba_gamma() { return gba_gamma; } inline float get_lcd_gamma() { return lcd_gamma; } #else inline float get_crt_gamma() { return crt_reference_gamma_high; } inline float get_gba_gamma() { return 3.5; } // Game Boy Advance; in (3.0, 4.0) inline float get_lcd_gamma() { return lcd_office_gamma; } #endif // OVERRIDE_DEVICE_GAMMA #line 179 "gamma-management.h" // 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: inline float get_intermediate_gamma() { return intermediate_gamma; } inline float get_input_gamma() { return input_gamma; } inline 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: inline float get_intermediate_gamma() { return ntsc_gamma; } #ifdef SIMULATE_CRT_ON_LCD inline float get_input_gamma() { return get_crt_gamma(); } inline float get_output_gamma() { return get_lcd_gamma(); } #else #ifdef SIMULATE_GBA_ON_LCD inline float get_input_gamma() { return get_gba_gamma(); } inline float get_output_gamma() { return get_lcd_gamma(); } #else #ifdef SIMULATE_LCD_ON_CRT inline float get_input_gamma() { return get_lcd_gamma(); } inline float get_output_gamma() { return get_crt_gamma(); } #else #ifdef SIMULATE_GBA_ON_CRT inline float get_input_gamma() { return get_gba_gamma(); } inline float get_output_gamma() { return get_crt_gamma(); } #else // Don't simulate anything: inline float get_input_gamma() { return ntsc_gamma; } inline float get_output_gamma() { return ntsc_gamma; } #endif // SIMULATE_GBA_ON_CRT #line 209 "gamma-management.h" #endif // SIMULATE_LCD_ON_CRT #line 210 "gamma-management.h" #endif // SIMULATE_GBA_ON_LCD #line 211 "gamma-management.h" #endif // SIMULATE_CRT_ON_LCD #line 212 "gamma-management.h" #endif // OVERRIDE_FINAL_GAMMA #line 213 "gamma-management.h" // 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; inline float get_pass_input_gamma() { return get_input_gamma(); } #else static const bool linearize_input = false; inline float get_pass_input_gamma() { return 1.0; } #endif #line 225 "gamma-management.h" #ifdef LAST_PASS static const bool gamma_encode_output = true; inline float get_pass_output_gamma() { return get_output_gamma(); } #else static const bool gamma_encode_output = false; inline float get_pass_output_gamma() { return 1.0; } #endif #line 232 "gamma-management.h" #else static const bool linearize_input = true; static const bool gamma_encode_output = true; #ifdef FIRST_PASS inline float get_pass_input_gamma() { return get_input_gamma(); } #else inline float get_pass_input_gamma() { return get_intermediate_gamma(); } #endif #line 240 "gamma-management.h" #ifdef LAST_PASS inline float get_pass_output_gamma() { return get_output_gamma(); } #else inline float get_pass_output_gamma() { return get_intermediate_gamma(); } #endif #line 245 "gamma-management.h" #endif #line 246 "gamma-management.h" // Users might want to know if bilinear filtering will be gamma-correct: static const bool gamma_aware_bilinear = !linearize_input; ////////////////////// COLOR ENCODING/DECODING FUNCTIONS ///////////////////// inline float4 encode_output(const float4 color) { if(gamma_encode_output) { if(assume_opaque_alpha) { return float4(pow(color.rgb, float3(1.0/get_pass_output_gamma())), 1.0); } else { return float4(pow(color.rgb, float3(1.0/get_pass_output_gamma())), color.a); } } else { return color; } } inline float4 decode_input(const float4 color) { if(linearize_input) { if(assume_opaque_alpha) { return float4(pow(color.rgb, float3(get_pass_input_gamma())), 1.0); } else { return float4(pow(color.rgb, float3(get_pass_input_gamma())), color.a); } } else { return color; } } inline float4 decode_gamma_input(const float4 color, const float3 gamma) { if(assume_opaque_alpha) { return float4(pow(color.rgb, gamma), 1.0); } else { return float4(pow(color.rgb, gamma), color.a); } } //TODO/FIXME: I have no idea why replacing the lookup wrappers with this macro fixes the blurs being offset ¯\_(ツ)_/¯ //#define tex2D_linearize(C, D) decode_input(vec4(texture(C, D))) // EDIT: it's the 'const' in front of the coords that's doing it /////////////////////////// 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. /* // tex1D: inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords) { return decode_input(tex1D(tex, tex_coords)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords) { return decode_input(tex1D(tex, tex_coords)); } inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords, const int texel_off) { return decode_input(tex1D(tex, tex_coords, texel_off)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords, const int texel_off) { return decode_input(tex1D(tex, tex_coords, texel_off)); } inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords, const float dx, const float dy) { return decode_input(tex1D(tex, tex_coords, dx, dy)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords, const float dx, const float dy) { return decode_input(tex1D(tex, tex_coords, dx, dy)); } inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords, const float dx, const float dy, const int texel_off) { return decode_input(tex1D(tex, tex_coords, dx, dy, texel_off)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords, const float dx, const float dy, const int texel_off) { return decode_input(tex1D(tex, tex_coords, dx, dy, texel_off)); } // tex1Dbias: inline float4 tex1Dbias_linearize(const sampler1D tex, const float4 tex_coords) { return decode_input(tex1Dbias(tex, tex_coords)); } inline float4 tex1Dbias_linearize(const sampler1D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex1Dbias(tex, tex_coords, texel_off)); } // tex1Dfetch: inline float4 tex1Dfetch_linearize(const sampler1D tex, const int4 tex_coords) { return decode_input(tex1Dfetch(tex, tex_coords)); } inline float4 tex1Dfetch_linearize(const sampler1D tex, const int4 tex_coords, const int texel_off) { return decode_input(tex1Dfetch(tex, tex_coords, texel_off)); } // tex1Dlod: inline float4 tex1Dlod_linearize(const sampler1D tex, const float4 tex_coords) { return decode_input(tex1Dlod(tex, tex_coords)); } inline float4 tex1Dlod_linearize(const sampler1D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex1Dlod(tex, tex_coords, texel_off)); } // tex1Dproj: inline float4 tex1Dproj_linearize(const sampler1D tex, const float2 tex_coords) { return decode_input(tex1Dproj(tex, tex_coords)); } inline float4 tex1Dproj_linearize(const sampler1D tex, const float3 tex_coords) { return decode_input(tex1Dproj(tex, tex_coords)); } inline float4 tex1Dproj_linearize(const sampler1D tex, const float2 tex_coords, const int texel_off) { return decode_input(tex1Dproj(tex, tex_coords, texel_off)); } inline float4 tex1Dproj_linearize(const sampler1D tex, const float3 tex_coords, const int texel_off) { return decode_input(tex1Dproj(tex, tex_coords, texel_off)); } */ // tex2D: inline float4 tex2D_linearize(const sampler2D tex, float2 tex_coords) { return decode_input(texture(tex, tex_coords)); } inline float4 tex2D_linearize(const sampler2D tex, float3 tex_coords) { return decode_input(texture(tex, tex_coords.xy)); } inline float4 tex2D_linearize(const sampler2D tex, float2 tex_coords, int texel_off) { return decode_input(textureLod(tex, tex_coords, texel_off)); } inline float4 tex2D_linearize(const sampler2D tex, float3 tex_coords, int texel_off) { return decode_input(textureLod(tex, tex_coords.xy, texel_off)); } //inline float4 tex2D_linearize(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy) //{ return decode_input(texture(tex, tex_coords, dx, dy)); } //inline float4 tex2D_linearize(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy) //{ return decode_input(texture(tex, tex_coords, dx, dy)); } //inline float4 tex2D_linearize(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy, const int texel_off) //{ return decode_input(texture(tex, tex_coords, dx, dy, texel_off)); } //inline float4 tex2D_linearize(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy, const int texel_off) //{ return decode_input(texture(tex, tex_coords, dx, dy, texel_off)); } // tex2Dbias: //inline float4 tex2Dbias_linearize(const sampler2D tex, const float4 tex_coords) //{ return decode_input(tex2Dbias(tex, tex_coords)); } //inline float4 tex2Dbias_linearize(const sampler2D tex, const float4 tex_coords, const int texel_off) //{ return decode_input(tex2Dbias(tex, tex_coords, texel_off)); } // tex2Dfetch: //inline float4 tex2Dfetch_linearize(const sampler2D tex, const int4 tex_coords) //{ return decode_input(tex2Dfetch(tex, tex_coords)); } //inline float4 tex2Dfetch_linearize(const sampler2D tex, const int4 tex_coords, const int texel_off) //{ return decode_input(tex2Dfetch(tex, tex_coords, texel_off)); } // tex2Dlod: inline float4 tex2Dlod_linearize(const sampler2D tex, float4 tex_coords) { return decode_input(textureLod(tex, tex_coords.xy, 0.0)); } inline float4 tex2Dlod_linearize(const sampler2D tex, float4 tex_coords, int texel_off) { return decode_input(textureLod(tex, tex_coords.xy, texel_off)); } /* // tex2Dproj: inline float4 tex2Dproj_linearize(const sampler2D tex, const float3 tex_coords) { return decode_input(tex2Dproj(tex, tex_coords)); } inline float4 tex2Dproj_linearize(const sampler2D tex, const float4 tex_coords) { return decode_input(tex2Dproj(tex, tex_coords)); } inline float4 tex2Dproj_linearize(const sampler2D tex, const float3 tex_coords, const int texel_off) { return decode_input(tex2Dproj(tex, tex_coords, texel_off)); } inline float4 tex2Dproj_linearize(const sampler2D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex2Dproj(tex, tex_coords, texel_off)); } */ /* // tex3D: inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords) { return decode_input(tex3D(tex, tex_coords)); } inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords, const int texel_off) { return decode_input(tex3D(tex, tex_coords, texel_off)); } inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords, const float3 dx, const float3 dy) { return decode_input(tex3D(tex, tex_coords, dx, dy)); } inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords, const float3 dx, const float3 dy, const int texel_off) { return decode_input(tex3D(tex, tex_coords, dx, dy, texel_off)); } // tex3Dbias: inline float4 tex3Dbias_linearize(const sampler3D tex, const float4 tex_coords) { return decode_input(tex3Dbias(tex, tex_coords)); } inline float4 tex3Dbias_linearize(const sampler3D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex3Dbias(tex, tex_coords, texel_off)); } // tex3Dfetch: inline float4 tex3Dfetch_linearize(const sampler3D tex, const int4 tex_coords) { return decode_input(tex3Dfetch(tex, tex_coords)); } inline float4 tex3Dfetch_linearize(const sampler3D tex, const int4 tex_coords, const int texel_off) { return decode_input(tex3Dfetch(tex, tex_coords, texel_off)); } // tex3Dlod: inline float4 tex3Dlod_linearize(const sampler3D tex, const float4 tex_coords) { return decode_input(tex3Dlod(tex, tex_coords)); } inline float4 tex3Dlod_linearize(const sampler3D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex3Dlod(tex, tex_coords, texel_off)); } // tex3Dproj: inline float4 tex3Dproj_linearize(const sampler3D tex, const float4 tex_coords) { return decode_input(tex3Dproj(tex, tex_coords)); } inline float4 tex3Dproj_linearize(const sampler3D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex3Dproj(tex, tex_coords, texel_off)); } /////////* // NONSTANDARD "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS: // This narrow selection of nonstandard tex2D* functions can be useful: // tex2Dlod0: Automatically fill in the tex2D LOD parameter for mip level 0. //inline float4 tex2Dlod0_linearize(const sampler2D tex, const float2 tex_coords) //{ return decode_input(tex2Dlod(tex, float4(tex_coords, 0.0, 0.0))); } //inline float4 tex2Dlod0_linearize(const sampler2D tex, const float2 tex_coords, const int texel_off) //{ return decode_input(tex2Dlod(tex, float4(tex_coords, 0.0, 0.0), texel_off)); } // MANUALLY LINEARIZING TEXTURE LOOKUP FUNCTIONS: // Provide a narrower selection of tex2D* wrapper functions that decode an // input sample with a specified gamma value. These are useful for reading // LUT's and for reading the input of pass0 in a later pass. // tex2D: inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const float3 gamma) { return decode_gamma_input(texture(tex, tex_coords), gamma); } inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const float3 gamma) { return decode_gamma_input(texture(tex, tex_coords.xy), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, texel_off), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, texel_off), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy, texel_off), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy, texel_off), gamma); } /* // tex2Dbias: inline float4 tex2Dbias_linearize_gamma(const sampler2D tex, const float4 tex_coords, const float3 gamma) { return decode_gamma_input(tex2Dbias(tex, tex_coords), gamma); } inline float4 tex2Dbias_linearize_gamma(const sampler2D tex, const float4 tex_coords, const int texel_off, const float3 gamma) { return decode_gamma_input(tex2Dbias(tex, tex_coords, texel_off), gamma); } // tex2Dfetch: inline float4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const float3 gamma) { return decode_gamma_input(tex2Dfetch(tex, tex_coords), gamma); } inline float4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const int texel_off, const float3 gamma) { return decode_gamma_input(tex2Dfetch(tex, tex_coords, texel_off), gamma); } */ // tex2Dlod: inline float4 tex2Dlod_linearize_gamma(const sampler2D tex, float4 tex_coords, float3 gamma) { return decode_gamma_input(textureLod(tex, tex_coords.xy, 0.0), gamma); } inline float4 tex2Dlod_linearize_gamma(const sampler2D tex, float4 tex_coords, int texel_off, float3 gamma) { return decode_gamma_input(textureLod(tex, tex_coords.xy, texel_off), gamma); } #endif // GAMMA_MANAGEMENT_H #line 547 "gamma-management.h" #line 107 "crt-royale-geometry-aa-last-pass.h" #line 1 "tex2Dantialias.h" #ifndef TEX2DANTIALIAS_H #define TEX2DANTIALIAS_H ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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 //////////////////////////////// // This file provides antialiased and subpixel-aware tex2D lookups. // Requires: All functions share these requirements: // 1.) All requirements of gamma-management.h must be satisfied! // 2.) pixel_to_tex_uv must be a 2x2 matrix that transforms pixe- // space offsets to texture uv offsets. You can get this with: // const float2 duv_dx = ddx(tex_uv); // const float2 duv_dy = ddy(tex_uv); // const float2x2 pixel_to_tex_uv = float2x2( // duv_dx.x, duv_dy.x, // duv_dx.y, duv_dy.y); // This is left to the user in case the current Cg profile // doesn't support ddx()/ddy(). Ideally, the user could find // calculate a distorted tangent-space mapping analytically. // If not, a simple flat mapping can be obtained with: // const float2 xy_to_uv_scale = IN.output_size * // IN.video_size/IN.texture_size; // const float2x2 pixel_to_tex_uv = float2x2( // xy_to_uv_scale.x, 0.0, // 0.0, xy_to_uv_scale.y); // Optional: To set basic AA settings, #define ANTIALIAS_OVERRIDE_BASICS and: // 1.) Set an antialiasing level: // static const float aa_level = {0 (none), // 1 (sample subpixels), 4, 5, 6, 7, 8, 12, 16, 20, 24} // 2.) Set a filter type: // static const float aa_filter = { // 0 (Box, Separable), 1 (Box, Cylindrical), // 2 (Tent, Separable), 3 (Tent, Cylindrical) // 4 (Gaussian, Separable), 5 (Gaussian, Cylindrical) // 6 (Cubic, Separable), 7 (Cubic, Cylindrical) // 8 (Lanczos Sinc, Separable), // 9 (Lanczos Jinc, Cylindrical)} // If the input is unknown, a separable box filter is used. // Note: Lanczos Jinc is terrible for sparse sampling, and // using aa_axis_importance (see below) defeats the purpose. // 3.) Mirror the sample pattern on odd frames? // static const bool aa_temporal = {true, false] // This helps rotational invariance but can look "fluttery." // The user may #define ANTIALIAS_OVERRIDE_PARAMETERS to override // (all of) the following default parameters with static or uniform // constants (or an accessor function for subpixel offsets): // 1.) Cubic parameters: // static const float aa_cubic_c = 0.5; // See http://www.imagemagick.org/Usage/filter/#mitchell // 2.) Gaussian parameters: // static const float aa_gauss_sigma = // 0.5/aa_pixel_diameter; // 3.) Set subpixel offsets. This requires an accessor function // for compatibility with scalar runtime shader params. Return // a float2 pixel offset in [-0.5, 0.5] for the red subpixel: // float2 get_aa_subpixel_r_offset() // The user may also #define ANTIALIAS_OVERRIDE_STATIC_CONSTANTS to // override (all of) the following default static values. However, // the file's structure requires them to be declared static const: // 1.) static const float aa_lanczos_lobes = 3.0; // 2.) static const float aa_gauss_support = 1.0/aa_pixel_diameter; // Note the default tent/Gaussian support radii may appear // arbitrary, but extensive testing found them nearly optimal // for tough cases like strong distortion at low AA levels. // (The Gaussian default is only best for practical gauss_sigma // values; much larger gauss_sigmas ironically prefer slightly // smaller support given sparse sampling, and vice versa.) // 3.) static const float aa_tent_support = 1.0 / aa_pixel_diameter; // 4.) static const float2 aa_xy_axis_importance: // The sparse N-queens sampling grid interacts poorly with // negative-lobed 2D filters. However, if aliasing is much // stronger in one direction (e.g. horizontally with a phosphor // mask), it can be useful to downplay sample offsets along the // other axis. The support radius in each direction scales with // aa_xy_axis_importance down to a minimum of 0.5 (box support), // after which point only the offsets used for calculating // weights continue to scale downward. This works as follows: // If aa_xy_axis_importance = float2(1.0, 1.0/support_radius), // the vertical support radius will drop to 1.0, and we'll just // filter vertical offsets with the first filter lobe, while // horizontal offsets go through the full multi-lobe filter. // If aa_xy_axis_importance = float2(1.0, 0.0), the vertical // support radius will drop to box support, and the vertical // offsets will be ignored entirely (essentially giving us a // box filter vertically). The former is potentially smoother // (but less predictable) and the default behavior of Lanczos // jinc, whereas the latter is sharper and the default behavior // of cubics and Lanczos sinc. // 5.) static const float aa_pixel_diameter: You can expand the // pixel diameter to e.g. sqrt(2.0), which may be a better // support range for cylindrical filters (they don't // currently discard out-of-circle samples though). // Finally, there are two miscellaneous options: // 1.) If you want to antialias a manually tiled texture, you can // #define ANTIALIAS_DISABLE_ANISOTROPIC to use tex2Dlod() to // fix incompatibilities with anisotropic filtering. This is // slower, and the Cg profile must support tex2Dlod(). // 2.) If aa_cubic_c is a runtime uniform, you can #define // RUNTIME_ANTIALIAS_WEIGHTS to evaluate cubic weights once per // fragment instead of at the usage site (which is used by // default, because it enables static evaluation). // Description: // Each antialiased lookup follows these steps: // 1.) Define a sample pattern of pixel offsets in the range of [-0.5, 0.5] // pixels, spanning the diameter of a rectangular box filter. // 2.) Scale these offsets by the support diameter of the user's chosen filter. // 3.) Using these pixel offsets from the pixel center, compute the offsets to // predefined subpixel locations. // 4.) Compute filter weights based on subpixel offsets. // Much of that can often be done at compile-time. At runtime: // 1.) Project pixel-space offsets into uv-space with a matrix multiplication // to get the uv offsets for each sample. Rectangular pixels have a // diameter of 1.0. Circular pixels are not currently supported, but they // might be better with a diameter of sqrt(2.0) to ensure there are no gaps // between them. // 2.) Load, weight, and sum samples. // We use a sparse bilinear sampling grid, so there are two major implications: // 1.) We can directly project the pixel-space support box into uv-space even // if we're upsizing. This wouldn't be the case for nearest neighbor, // where we'd have to expand the uv-space diameter to at least the support // size to ensure sufficient filter support. In our case, this allows us // to treat upsizing the same as downsizing and use static weighting. :) // 2.) For decent results, negative-lobed filters must be computed based on // separable weights, not radial distances, because the sparse sampling // makes no guarantees about radial distributions. Even then, it's much // better to set aa_xy_axis_importance to e.g. float2(1.0, 0.0) to use e.g. // Lanczos2 horizontally and a box filter vertically. This is mainly due // to the sparse N-queens sampling and a statistically enormous positive or // negative covariance between horizontal and vertical weights. // // Design Decision Comments: // "aa_temporal" mirrors the sample pattern on odd frames along the axis that // keeps subpixel weights constant. This helps with rotational invariance, but // it can cause distracting fluctuations, and horizontal and vertical edges // will look the same. Using a different pattern on a shifted grid would // exploit temporal AA better, but it would require a dynamic branch or a lot // of conditional moves, so it's prohibitively slow for the minor benefit. ///////////////////////////// SETTINGS MANAGEMENT //////////////////////////// #ifndef ANTIALIAS_OVERRIDE_BASICS // The following settings must be static constants: static const float aa_level = 12.0; static const float aa_filter = 0.0; static const bool aa_temporal = false; #endif #line 166 "tex2Dantialias.h" #ifndef ANTIALIAS_OVERRIDE_STATIC_CONSTANTS // Users may override these parameters, but the file structure requires // them to be static constants; see the descriptions above. static const float aa_pixel_diameter = 1.0; static const float aa_lanczos_lobes = 3.0; static const float aa_gauss_support = 1.0 / aa_pixel_diameter; static const float aa_tent_support = 1.0 / aa_pixel_diameter; // If we're using a negative-lobed filter, default to using it horizontally // only, and use only the first lobe vertically or a box filter, over a // correspondingly smaller range. This compensates for the sparse sampling // grid's typically large positive/negative x/y covariance. static const float2 aa_xy_axis_importance = aa_filter < 5.5 ? float2(1.0) : // Box, tent, Gaussian aa_filter < 8.5 ? float2(1.0, 0.0) : // Cubic and Lanczos sinc aa_filter < 9.5 ? float2(1.0, 1.0/aa_lanczos_lobes) : // Lanczos jinc float2(1.0); // Default to box #endif #line 185 "tex2Dantialias.h" #ifndef ANTIALIAS_OVERRIDE_PARAMETERS // Users may override these values with their own uniform or static consts. // 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 = 0.5; static const float aa_gauss_sigma = 0.5 / aa_pixel_diameter; // Users may override the subpixel offset accessor function with their own. // A function is used for compatibility with scalar runtime shader params. inline float2 get_aa_subpixel_r_offset() { return float2(0.0, 0.0); } #endif #line 202 "tex2Dantialias.h" ////////////////////////////////// INCLUDES ////////////////////////////////// #line 1 "gamma-management.h" #ifndef GAMMA_MANAGEMENT_H #define GAMMA_MANAGEMENT_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 provides gamma-aware tex*D*() and encode_output() functions. // Requires: Before #include-ing this file, the including file must #define // the following macros when applicable and follow their rules: // 1.) #define FIRST_PASS if this is the first pass. // 2.) #define LAST_PASS if this is the last pass. // 3.) If sRGB is available, set srgb_framebufferN = "true" for // every pass except the last in your .cgp preset. // 4.) If sRGB isn't available but you want gamma-correctness with // no banding, #define GAMMA_ENCODE_EVERY_FBO each pass. // 5.) #define SIMULATE_CRT_ON_LCD if desired (precedence over 5-7) // 6.) #define SIMULATE_GBA_ON_LCD if desired (precedence over 6-7) // 7.) #define SIMULATE_LCD_ON_CRT if desired (precedence over 7) // 8.) #define SIMULATE_GBA_ON_CRT if desired (precedence over -) // If an option in [5, 8] is #defined in the first or last pass, it // should be #defined for both. It shouldn't make a difference // whether it's #defined for intermediate passes or not. // Optional: The including file (or an earlier included file) may optionally // #define a number of macros indicating it will override certain // macros and associated constants are as follows: // static constants with either static or uniform constants. The // 1.) OVERRIDE_STANDARD_GAMMA: The user must first define: // static const float ntsc_gamma // static const float pal_gamma // static const float crt_reference_gamma_high // static const float crt_reference_gamma_low // static const float lcd_reference_gamma // static const float crt_office_gamma // static const float lcd_office_gamma // 2.) OVERRIDE_DEVICE_GAMMA: The user must first define: // static const float crt_gamma // static const float gba_gamma // static const float lcd_gamma // 3.) OVERRIDE_FINAL_GAMMA: The user must first define: // static const float input_gamma // static const float intermediate_gamma // static const float output_gamma // (intermediate_gamma is for GAMMA_ENCODE_EVERY_FBO.) // 4.) OVERRIDE_ALPHA_ASSUMPTIONS: The user must first define: // static const bool assume_opaque_alpha // The gamma constant overrides must be used in every pass or none, // and OVERRIDE_FINAL_GAMMA bypasses all of the SIMULATE* macros. // OVERRIDE_ALPHA_ASSUMPTIONS may be set on a per-pass basis. // Usage: After setting macros appropriately, ignore gamma correction and // replace all tex*D*() calls with equivalent gamma-aware // tex*D*_linearize calls, except: // 1.) When you read an LUT, use regular tex*D or a gamma-specified // function, depending on its gamma encoding: // tex*D*_linearize_gamma (takes a runtime gamma parameter) // 2.) If you must read pass0's original input in a later pass, use // tex2D_linearize_ntsc_gamma. If you want to read pass0's // input with gamma-corrected bilinear filtering, consider // creating a first linearizing pass and reading from the input // of pass1 later. // Then, return encode_output(color) from every fragment shader. // Finally, use the global gamma_aware_bilinear boolean if you want // to statically branch based on whether bilinear filtering is // gamma-correct or not (e.g. for placing Gaussian blur samples). // // Detailed Policy: // tex*D*_linearize() functions enforce a consistent gamma-management policy // based on the FIRST_PASS and GAMMA_ENCODE_EVERY_FBO settings. They assume // their input texture has the same encoding characteristics as the input for // the current pass (which doesn't apply to the exceptions listed above). // Similarly, encode_output() enforces a policy based on the LAST_PASS and // GAMMA_ENCODE_EVERY_FBO settings. Together, they result in one of the // following two pipelines. // Typical pipeline with intermediate sRGB framebuffers: // linear_color = pow(pass0_encoded_color, input_gamma); // intermediate_output = linear_color; // Automatic sRGB encoding // linear_color = intermediate_output; // Automatic sRGB decoding // final_output = pow(intermediate_output, 1.0/output_gamma); // Typical pipeline without intermediate sRGB framebuffers: // linear_color = pow(pass0_encoded_color, input_gamma); // intermediate_output = pow(linear_color, 1.0/intermediate_gamma); // linear_color = pow(intermediate_output, intermediate_gamma); // final_output = pow(intermediate_output, 1.0/output_gamma); // Using GAMMA_ENCODE_EVERY_FBO is much slower, but it's provided as a way to // easily get gamma-correctness without banding on devices where sRGB isn't // supported. // // Use This Header to Maximize Code Reuse: // The purpose of this header is to provide a consistent interface for texture // reads and output gamma-encoding that localizes and abstracts away all the // annoying details. This greatly reduces the amount of code in each shader // pass that depends on the pass number in the .cgp preset or whether sRGB // FBO's are being used: You can trivially change the gamma behavior of your // whole pass by commenting or uncommenting 1-3 #defines. To reuse the same // code in your first, Nth, and last passes, you can even put it all in another // header file and #include it from skeleton .cg files that #define the // appropriate pass-specific settings. // // Rationale for Using Three Macros: // This file uses GAMMA_ENCODE_EVERY_FBO instead of an opposite macro like // SRGB_PIPELINE to ensure sRGB is assumed by default, which hopefully imposes // a lower maintenance burden on each pass. At first glance it seems we could // accomplish everything with two macros: GAMMA_CORRECT_IN / GAMMA_CORRECT_OUT. // This works for simple use cases where input_gamma == output_gamma, but it // breaks down for more complex scenarios like CRT simulation, where the pass // number determines the gamma encoding of the input and output. /////////////////////////////// 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 #line 153 "gamma-management.h" // 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 #line 159 "gamma-management.h" /////////////////////// 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: #ifdef OVERRIDE_DEVICE_GAMMA // The user promises to globally define the appropriate constants: inline float get_crt_gamma() { return crt_gamma; } inline float get_gba_gamma() { return gba_gamma; } inline float get_lcd_gamma() { return lcd_gamma; } #else inline float get_crt_gamma() { return crt_reference_gamma_high; } inline float get_gba_gamma() { return 3.5; } // Game Boy Advance; in (3.0, 4.0) inline float get_lcd_gamma() { return lcd_office_gamma; } #endif // OVERRIDE_DEVICE_GAMMA #line 179 "gamma-management.h" // 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: inline float get_intermediate_gamma() { return intermediate_gamma; } inline float get_input_gamma() { return input_gamma; } inline 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: inline float get_intermediate_gamma() { return ntsc_gamma; } #ifdef SIMULATE_CRT_ON_LCD inline float get_input_gamma() { return get_crt_gamma(); } inline float get_output_gamma() { return get_lcd_gamma(); } #else #ifdef SIMULATE_GBA_ON_LCD inline float get_input_gamma() { return get_gba_gamma(); } inline float get_output_gamma() { return get_lcd_gamma(); } #else #ifdef SIMULATE_LCD_ON_CRT inline float get_input_gamma() { return get_lcd_gamma(); } inline float get_output_gamma() { return get_crt_gamma(); } #else #ifdef SIMULATE_GBA_ON_CRT inline float get_input_gamma() { return get_gba_gamma(); } inline float get_output_gamma() { return get_crt_gamma(); } #else // Don't simulate anything: inline float get_input_gamma() { return ntsc_gamma; } inline float get_output_gamma() { return ntsc_gamma; } #endif // SIMULATE_GBA_ON_CRT #line 209 "gamma-management.h" #endif // SIMULATE_LCD_ON_CRT #line 210 "gamma-management.h" #endif // SIMULATE_GBA_ON_LCD #line 211 "gamma-management.h" #endif // SIMULATE_CRT_ON_LCD #line 212 "gamma-management.h" #endif // OVERRIDE_FINAL_GAMMA #line 213 "gamma-management.h" // 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; inline float get_pass_input_gamma() { return get_input_gamma(); } #else static const bool linearize_input = false; inline float get_pass_input_gamma() { return 1.0; } #endif #line 225 "gamma-management.h" #ifdef LAST_PASS static const bool gamma_encode_output = true; inline float get_pass_output_gamma() { return get_output_gamma(); } #else static const bool gamma_encode_output = false; inline float get_pass_output_gamma() { return 1.0; } #endif #line 232 "gamma-management.h" #else static const bool linearize_input = true; static const bool gamma_encode_output = true; #ifdef FIRST_PASS inline float get_pass_input_gamma() { return get_input_gamma(); } #else inline float get_pass_input_gamma() { return get_intermediate_gamma(); } #endif #line 240 "gamma-management.h" #ifdef LAST_PASS inline float get_pass_output_gamma() { return get_output_gamma(); } #else inline float get_pass_output_gamma() { return get_intermediate_gamma(); } #endif #line 245 "gamma-management.h" #endif #line 246 "gamma-management.h" // Users might want to know if bilinear filtering will be gamma-correct: static const bool gamma_aware_bilinear = !linearize_input; ////////////////////// COLOR ENCODING/DECODING FUNCTIONS ///////////////////// inline float4 encode_output(const float4 color) { if(gamma_encode_output) { if(assume_opaque_alpha) { return float4(pow(color.rgb, float3(1.0/get_pass_output_gamma())), 1.0); } else { return float4(pow(color.rgb, float3(1.0/get_pass_output_gamma())), color.a); } } else { return color; } } inline float4 decode_input(const float4 color) { if(linearize_input) { if(assume_opaque_alpha) { return float4(pow(color.rgb, float3(get_pass_input_gamma())), 1.0); } else { return float4(pow(color.rgb, float3(get_pass_input_gamma())), color.a); } } else { return color; } } inline float4 decode_gamma_input(const float4 color, const float3 gamma) { if(assume_opaque_alpha) { return float4(pow(color.rgb, gamma), 1.0); } else { return float4(pow(color.rgb, gamma), color.a); } } //TODO/FIXME: I have no idea why replacing the lookup wrappers with this macro fixes the blurs being offset ¯\_(ツ)_/¯ //#define tex2D_linearize(C, D) decode_input(vec4(texture(C, D))) // EDIT: it's the 'const' in front of the coords that's doing it /////////////////////////// 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. /* // tex1D: inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords) { return decode_input(tex1D(tex, tex_coords)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords) { return decode_input(tex1D(tex, tex_coords)); } inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords, const int texel_off) { return decode_input(tex1D(tex, tex_coords, texel_off)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords, const int texel_off) { return decode_input(tex1D(tex, tex_coords, texel_off)); } inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords, const float dx, const float dy) { return decode_input(tex1D(tex, tex_coords, dx, dy)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords, const float dx, const float dy) { return decode_input(tex1D(tex, tex_coords, dx, dy)); } inline float4 tex1D_linearize(const sampler1D tex, const float tex_coords, const float dx, const float dy, const int texel_off) { return decode_input(tex1D(tex, tex_coords, dx, dy, texel_off)); } inline float4 tex1D_linearize(const sampler1D tex, const float2 tex_coords, const float dx, const float dy, const int texel_off) { return decode_input(tex1D(tex, tex_coords, dx, dy, texel_off)); } // tex1Dbias: inline float4 tex1Dbias_linearize(const sampler1D tex, const float4 tex_coords) { return decode_input(tex1Dbias(tex, tex_coords)); } inline float4 tex1Dbias_linearize(const sampler1D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex1Dbias(tex, tex_coords, texel_off)); } // tex1Dfetch: inline float4 tex1Dfetch_linearize(const sampler1D tex, const int4 tex_coords) { return decode_input(tex1Dfetch(tex, tex_coords)); } inline float4 tex1Dfetch_linearize(const sampler1D tex, const int4 tex_coords, const int texel_off) { return decode_input(tex1Dfetch(tex, tex_coords, texel_off)); } // tex1Dlod: inline float4 tex1Dlod_linearize(const sampler1D tex, const float4 tex_coords) { return decode_input(tex1Dlod(tex, tex_coords)); } inline float4 tex1Dlod_linearize(const sampler1D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex1Dlod(tex, tex_coords, texel_off)); } // tex1Dproj: inline float4 tex1Dproj_linearize(const sampler1D tex, const float2 tex_coords) { return decode_input(tex1Dproj(tex, tex_coords)); } inline float4 tex1Dproj_linearize(const sampler1D tex, const float3 tex_coords) { return decode_input(tex1Dproj(tex, tex_coords)); } inline float4 tex1Dproj_linearize(const sampler1D tex, const float2 tex_coords, const int texel_off) { return decode_input(tex1Dproj(tex, tex_coords, texel_off)); } inline float4 tex1Dproj_linearize(const sampler1D tex, const float3 tex_coords, const int texel_off) { return decode_input(tex1Dproj(tex, tex_coords, texel_off)); } */ // tex2D: inline float4 tex2D_linearize(const sampler2D tex, float2 tex_coords) { return decode_input(texture(tex, tex_coords)); } inline float4 tex2D_linearize(const sampler2D tex, float3 tex_coords) { return decode_input(texture(tex, tex_coords.xy)); } inline float4 tex2D_linearize(const sampler2D tex, float2 tex_coords, int texel_off) { return decode_input(textureLod(tex, tex_coords, texel_off)); } inline float4 tex2D_linearize(const sampler2D tex, float3 tex_coords, int texel_off) { return decode_input(textureLod(tex, tex_coords.xy, texel_off)); } //inline float4 tex2D_linearize(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy) //{ return decode_input(texture(tex, tex_coords, dx, dy)); } //inline float4 tex2D_linearize(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy) //{ return decode_input(texture(tex, tex_coords, dx, dy)); } //inline float4 tex2D_linearize(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy, const int texel_off) //{ return decode_input(texture(tex, tex_coords, dx, dy, texel_off)); } //inline float4 tex2D_linearize(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy, const int texel_off) //{ return decode_input(texture(tex, tex_coords, dx, dy, texel_off)); } // tex2Dbias: //inline float4 tex2Dbias_linearize(const sampler2D tex, const float4 tex_coords) //{ return decode_input(tex2Dbias(tex, tex_coords)); } //inline float4 tex2Dbias_linearize(const sampler2D tex, const float4 tex_coords, const int texel_off) //{ return decode_input(tex2Dbias(tex, tex_coords, texel_off)); } // tex2Dfetch: //inline float4 tex2Dfetch_linearize(const sampler2D tex, const int4 tex_coords) //{ return decode_input(tex2Dfetch(tex, tex_coords)); } //inline float4 tex2Dfetch_linearize(const sampler2D tex, const int4 tex_coords, const int texel_off) //{ return decode_input(tex2Dfetch(tex, tex_coords, texel_off)); } // tex2Dlod: inline float4 tex2Dlod_linearize(const sampler2D tex, float4 tex_coords) { return decode_input(textureLod(tex, tex_coords.xy, 0.0)); } inline float4 tex2Dlod_linearize(const sampler2D tex, float4 tex_coords, int texel_off) { return decode_input(textureLod(tex, tex_coords.xy, texel_off)); } /* // tex2Dproj: inline float4 tex2Dproj_linearize(const sampler2D tex, const float3 tex_coords) { return decode_input(tex2Dproj(tex, tex_coords)); } inline float4 tex2Dproj_linearize(const sampler2D tex, const float4 tex_coords) { return decode_input(tex2Dproj(tex, tex_coords)); } inline float4 tex2Dproj_linearize(const sampler2D tex, const float3 tex_coords, const int texel_off) { return decode_input(tex2Dproj(tex, tex_coords, texel_off)); } inline float4 tex2Dproj_linearize(const sampler2D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex2Dproj(tex, tex_coords, texel_off)); } */ /* // tex3D: inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords) { return decode_input(tex3D(tex, tex_coords)); } inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords, const int texel_off) { return decode_input(tex3D(tex, tex_coords, texel_off)); } inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords, const float3 dx, const float3 dy) { return decode_input(tex3D(tex, tex_coords, dx, dy)); } inline float4 tex3D_linearize(const sampler3D tex, const float3 tex_coords, const float3 dx, const float3 dy, const int texel_off) { return decode_input(tex3D(tex, tex_coords, dx, dy, texel_off)); } // tex3Dbias: inline float4 tex3Dbias_linearize(const sampler3D tex, const float4 tex_coords) { return decode_input(tex3Dbias(tex, tex_coords)); } inline float4 tex3Dbias_linearize(const sampler3D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex3Dbias(tex, tex_coords, texel_off)); } // tex3Dfetch: inline float4 tex3Dfetch_linearize(const sampler3D tex, const int4 tex_coords) { return decode_input(tex3Dfetch(tex, tex_coords)); } inline float4 tex3Dfetch_linearize(const sampler3D tex, const int4 tex_coords, const int texel_off) { return decode_input(tex3Dfetch(tex, tex_coords, texel_off)); } // tex3Dlod: inline float4 tex3Dlod_linearize(const sampler3D tex, const float4 tex_coords) { return decode_input(tex3Dlod(tex, tex_coords)); } inline float4 tex3Dlod_linearize(const sampler3D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex3Dlod(tex, tex_coords, texel_off)); } // tex3Dproj: inline float4 tex3Dproj_linearize(const sampler3D tex, const float4 tex_coords) { return decode_input(tex3Dproj(tex, tex_coords)); } inline float4 tex3Dproj_linearize(const sampler3D tex, const float4 tex_coords, const int texel_off) { return decode_input(tex3Dproj(tex, tex_coords, texel_off)); } /////////* // NONSTANDARD "SMART" LINEARIZING TEXTURE LOOKUP FUNCTIONS: // This narrow selection of nonstandard tex2D* functions can be useful: // tex2Dlod0: Automatically fill in the tex2D LOD parameter for mip level 0. //inline float4 tex2Dlod0_linearize(const sampler2D tex, const float2 tex_coords) //{ return decode_input(tex2Dlod(tex, float4(tex_coords, 0.0, 0.0))); } //inline float4 tex2Dlod0_linearize(const sampler2D tex, const float2 tex_coords, const int texel_off) //{ return decode_input(tex2Dlod(tex, float4(tex_coords, 0.0, 0.0), texel_off)); } // MANUALLY LINEARIZING TEXTURE LOOKUP FUNCTIONS: // Provide a narrower selection of tex2D* wrapper functions that decode an // input sample with a specified gamma value. These are useful for reading // LUT's and for reading the input of pass0 in a later pass. // tex2D: inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const float3 gamma) { return decode_gamma_input(texture(tex, tex_coords), gamma); } inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const float3 gamma) { return decode_gamma_input(texture(tex, tex_coords.xy), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, texel_off), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, texel_off), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float2 tex_coords, const float2 dx, const float2 dy, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy, texel_off), gamma); } //inline float4 tex2D_linearize_gamma(const sampler2D tex, const float3 tex_coords, const float2 dx, const float2 dy, const int texel_off, const float3 gamma) //{ return decode_gamma_input(texture(tex, tex_coords, dx, dy, texel_off), gamma); } /* // tex2Dbias: inline float4 tex2Dbias_linearize_gamma(const sampler2D tex, const float4 tex_coords, const float3 gamma) { return decode_gamma_input(tex2Dbias(tex, tex_coords), gamma); } inline float4 tex2Dbias_linearize_gamma(const sampler2D tex, const float4 tex_coords, const int texel_off, const float3 gamma) { return decode_gamma_input(tex2Dbias(tex, tex_coords, texel_off), gamma); } // tex2Dfetch: inline float4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const float3 gamma) { return decode_gamma_input(tex2Dfetch(tex, tex_coords), gamma); } inline float4 tex2Dfetch_linearize_gamma(const sampler2D tex, const int4 tex_coords, const int texel_off, const float3 gamma) { return decode_gamma_input(tex2Dfetch(tex, tex_coords, texel_off), gamma); } */ // tex2Dlod: inline float4 tex2Dlod_linearize_gamma(const sampler2D tex, float4 tex_coords, float3 gamma) { return decode_gamma_input(textureLod(tex, tex_coords.xy, 0.0), gamma); } inline float4 tex2Dlod_linearize_gamma(const sampler2D tex, float4 tex_coords, int texel_off, float3 gamma) { return decode_gamma_input(textureLod(tex, tex_coords.xy, texel_off), gamma); } #endif // GAMMA_MANAGEMENT_H #line 547 "gamma-management.h" #line 206 "tex2Dantialias.h" ////////////////////////////////// CONSTANTS ///////////////////////////////// static const float aa_box_support = 0.5; static const float aa_cubic_support = 2.0; //////////////////////////// GLOBAL NON-CONSTANTS //////////////////////////// // We'll want to define these only once per fragment at most. #ifdef RUNTIME_ANTIALIAS_WEIGHTS float aa_cubic_b; float cubic_branch1_x3_coeff; float cubic_branch1_x2_coeff; float cubic_branch1_x0_coeff; float cubic_branch2_x3_coeff; float cubic_branch2_x2_coeff; float cubic_branch2_x1_coeff; float cubic_branch2_x0_coeff; #endif #line 228 "tex2Dantialias.h" /////////////////////////////////// HELPERS ////////////////////////////////// void assign_aa_cubic_constants() { // Compute cubic coefficients on demand at runtime, and save them to global // uniforms. The B parameter is computed from C, because "Keys cubics" // with B = 1 - 2C are considered the highest quality. #ifdef RUNTIME_ANTIALIAS_WEIGHTS if(aa_filter > 5.5 && aa_filter < 7.5) { aa_cubic_b = 1.0 - 2.0*aa_cubic_c; cubic_branch1_x3_coeff = 12.0 - 9.0*aa_cubic_b - 6.0*aa_cubic_c; cubic_branch1_x2_coeff = -18.0 + 12.0*aa_cubic_b + 6.0*aa_cubic_c; cubic_branch1_x0_coeff = 6.0 - 2.0 * aa_cubic_b; cubic_branch2_x3_coeff = -aa_cubic_b - 6.0 * aa_cubic_c; cubic_branch2_x2_coeff = 6.0*aa_cubic_b + 30.0*aa_cubic_c; cubic_branch2_x1_coeff = -12.0*aa_cubic_b - 48.0*aa_cubic_c; cubic_branch2_x0_coeff = 8.0*aa_cubic_b + 24.0*aa_cubic_c; } #endif #line 250 "tex2Dantialias.h" } inline float4 get_subpixel_support_diam_and_final_axis_importance() { // Statically select the base support radius: static const float base_support_radius = aa_filter < 1.5 ? aa_box_support : aa_filter < 3.5 ? aa_tent_support : aa_filter < 5.5 ? aa_gauss_support : aa_filter < 7.5 ? aa_cubic_support : aa_filter < 9.5 ? aa_lanczos_lobes : aa_box_support; // Default to box // Expand the filter support for subpixel filtering. const float2 subpixel_support_radius_raw = float2(base_support_radius) + abs(get_aa_subpixel_r_offset()); if(aa_filter < 1.5) { // Ignore aa_xy_axis_importance for box filtering. const float2 subpixel_support_diam = 2.0 * subpixel_support_radius_raw; const float2 final_axis_importance = float2(1.0); return float4(subpixel_support_diam, final_axis_importance); } else { // Scale the support window by aa_xy_axis_importance, but don't narrow // it further than box support. This allows decent vertical AA without // messing up horizontal weights or using something silly like Lanczos4 // horizontally with a huge vertical average over an 8-pixel radius. const float2 subpixel_support_radius = max(float2(aa_box_support, aa_box_support), subpixel_support_radius_raw * aa_xy_axis_importance); // Adjust aa_xy_axis_importance to compensate for what's already done: const float2 final_axis_importance = aa_xy_axis_importance * subpixel_support_radius_raw/subpixel_support_radius; const float2 subpixel_support_diam = 2.0 * subpixel_support_radius; return float4(subpixel_support_diam, final_axis_importance); } } /////////////////////////// FILTER WEIGHT FUNCTIONS ////////////////////////// inline float eval_box_filter(const float dist) { return float(abs(dist) <= aa_box_support); } inline float eval_separable_box_filter(const float2 offset) { return float(all(bool2((abs(offset.x) <= aa_box_support), (abs(offset.y) <= aa_box_support)))); } inline float eval_tent_filter(const float dist) { return clamp((aa_tent_support - dist)/ aa_tent_support, 0.0, 1.0); } inline float eval_gaussian_filter(const float dist) { return exp(-(dist*dist) / (2.0*aa_gauss_sigma*aa_gauss_sigma)); } inline float eval_cubic_filter(const float dist) { // Compute coefficients like assign_aa_cubic_constants(), but statically. #ifndef RUNTIME_ANTIALIAS_WEIGHTS // When runtime weights are used, these values are instead written to // global uniforms at the beginning of each tex2Daa* call. const float aa_cubic_b = 1.0 - 2.0*aa_cubic_c; const float cubic_branch1_x3_coeff = 12.0 - 9.0*aa_cubic_b - 6.0*aa_cubic_c; const float cubic_branch1_x2_coeff = -18.0 + 12.0*aa_cubic_b + 6.0*aa_cubic_c; const float cubic_branch1_x0_coeff = 6.0 - 2.0 * aa_cubic_b; const float cubic_branch2_x3_coeff = -aa_cubic_b - 6.0 * aa_cubic_c; const float cubic_branch2_x2_coeff = 6.0*aa_cubic_b + 30.0*aa_cubic_c; const float cubic_branch2_x1_coeff = -12.0*aa_cubic_b - 48.0*aa_cubic_c; const float cubic_branch2_x0_coeff = 8.0*aa_cubic_b + 24.0*aa_cubic_c; #endif #line 328 "tex2Dantialias.h" const float abs_dist = abs(dist); // Compute the cubic based on the Horner's method formula in: // http://www.cs.utexas.edu/users/fussell/courses/cs384g/lectures/mitchell/Mitchell.pdf return (abs_dist < 1.0 ? (cubic_branch1_x3_coeff*abs_dist + cubic_branch1_x2_coeff)*abs_dist*abs_dist + cubic_branch1_x0_coeff : abs_dist < 2.0 ? ((cubic_branch2_x3_coeff*abs_dist + cubic_branch2_x2_coeff)*abs_dist + cubic_branch2_x1_coeff)*abs_dist + cubic_branch2_x0_coeff : 0.0)/6.0; } inline float eval_separable_cubic_filter(const float2 offset) { // This is faster than using a specific float2 version: return eval_cubic_filter(offset.x) * eval_cubic_filter(offset.y); } inline float2 eval_sinc_filter(const float2 offset) { // It's faster to let the caller handle the zero case, or at least it // was when I used macros and the shader preset took a full minute to load. const float2 pi_offset = pi * offset; return sin(pi_offset)/pi_offset; } inline float eval_separable_lanczos_sinc_filter(const float2 offset_unsafe) { // Note: For sparse sampling, you really need to pick an axis to use // Lanczos along (e.g. set aa_xy_axis_importance = float2(1.0, 0.0)). const float2 offset = FIX_ZERO(offset_unsafe); const float2 xy_weights = eval_sinc_filter(offset) * eval_sinc_filter(offset/aa_lanczos_lobes); return xy_weights.x * xy_weights.y; } inline float eval_jinc_filter_unorm(const float x) { // This is a Jinc approximation for x in [0, 45). We'll use x in range // [0, 4*pi) or so. There are faster/closer approximations based on // piecewise cubics from [0, 45) and asymptotic approximations beyond that, // but this has a maximum absolute error < 1/512, and it's simpler/faster // for shaders...not that it's all that useful for sparse sampling anyway. const float point3845_x = 0.38448566093564*x; const float exp_term = exp(-(point3845_x*point3845_x)); const float point8154_plus_x = 0.815362332840791 + x; const float cos_term = cos(point8154_plus_x); return ( 0.0264727330997042*min(x, 6.83134964622778) + 0.680823557250528*exp_term + -0.0597255978950933*min(7.41043194481873, x)*cos_term / (point8154_plus_x + 0.0646074538634482*(x*x) + cos(x)*max(exp_term, cos(x) + cos_term)) - 0.180837503591406); } inline float eval_jinc_filter(const float dist) { return eval_jinc_filter_unorm(pi * dist); } inline float eval_lanczos_jinc_filter(const float dist) { return eval_jinc_filter(dist) * eval_jinc_filter(dist/aa_lanczos_lobes); } inline float3 eval_unorm_rgb_weights(const float2 offset, const float2 final_axis_importance) { // Requires: 1.) final_axis_impportance must be computed according to // get_subpixel_support_diam_and_final_axis_importance(). // 2.) aa_filter must be a global constant. // 3.) offset must be an xy pixel offset in the range: // ([-subpixel_support_diameter.x/2, // subpixel_support_diameter.x/2], // [-subpixel_support_diameter.y/2, // subpixel_support_diameter.y/2]) // Returns: Sample weights at R/G/B destination subpixels for the // given xy pixel offset. const float2 offset_g = offset * final_axis_importance; const float2 aa_r_offset = get_aa_subpixel_r_offset(); const float2 offset_r = offset_g - aa_r_offset * final_axis_importance; const float2 offset_b = offset_g + aa_r_offset * final_axis_importance; // Statically select a filter: if(aa_filter < 0.5) { return float3(eval_separable_box_filter(offset_r), eval_separable_box_filter(offset_g), eval_separable_box_filter(offset_b)); } else if(aa_filter < 1.5) { return float3(eval_box_filter(length(offset_r)), eval_box_filter(length(offset_g)), eval_box_filter(length(offset_b))); } else if(aa_filter < 2.5) { return float3( eval_tent_filter(offset_r.x) * eval_tent_filter(offset_r.y), eval_tent_filter(offset_g.x) * eval_tent_filter(offset_g.y), eval_tent_filter(offset_b.x) * eval_tent_filter(offset_b.y)); } else if(aa_filter < 3.5) { return float3(eval_tent_filter(length(offset_r)), eval_tent_filter(length(offset_g)), eval_tent_filter(length(offset_b))); } else if(aa_filter < 4.5) { return float3( eval_gaussian_filter(offset_r.x) * eval_gaussian_filter(offset_r.y), eval_gaussian_filter(offset_g.x) * eval_gaussian_filter(offset_g.y), eval_gaussian_filter(offset_b.x) * eval_gaussian_filter(offset_b.y)); } else if(aa_filter < 5.5) { return float3(eval_gaussian_filter(length(offset_r)), eval_gaussian_filter(length(offset_g)), eval_gaussian_filter(length(offset_b))); } else if(aa_filter < 6.5) { return float3( eval_cubic_filter(offset_r.x) * eval_cubic_filter(offset_r.y), eval_cubic_filter(offset_g.x) * eval_cubic_filter(offset_g.y), eval_cubic_filter(offset_b.x) * eval_cubic_filter(offset_b.y)); } else if(aa_filter < 7.5) { return float3(eval_cubic_filter(length(offset_r)), eval_cubic_filter(length(offset_g)), eval_cubic_filter(length(offset_b))); } else if(aa_filter < 8.5) { return float3(eval_separable_lanczos_sinc_filter(offset_r), eval_separable_lanczos_sinc_filter(offset_g), eval_separable_lanczos_sinc_filter(offset_b)); } else if(aa_filter < 9.5) { return float3(eval_lanczos_jinc_filter(length(offset_r)), eval_lanczos_jinc_filter(length(offset_g)), eval_lanczos_jinc_filter(length(offset_b))); } else { // Default to a box, because Lanczos Jinc is so bad. ;) return float3(eval_separable_box_filter(offset_r), eval_separable_box_filter(offset_g), eval_separable_box_filter(offset_b)); } } ////////////////////////////// HELPER FUNCTIONS ////////////////////////////// inline float4 tex2Daa_tiled_linearize(const sampler2D samp, const float2 s) { // If we're manually tiling a texture, anisotropic filtering can get // confused. This is one workaround: #ifdef ANTIALIAS_DISABLE_ANISOTROPIC // TODO: Use tex2Dlod_linearize with a calculated mip level. return tex2Dlod_linearize(samp, float4(s, 0.0, 0.0)); #else return tex2D_linearize(samp, s); #endif #line 501 "tex2Dantialias.h" } inline float2 get_frame_sign(const float frame) { if(aa_temporal) { // Mirror the sampling pattern for odd frames in a direction that // lets us keep the same subpixel sample weights: const float frame_odd = float(fmod(frame, 2.0) > 0.5); const float2 aa_r_offset = get_aa_subpixel_r_offset(); const float2 mirror = -float2(abs(aa_r_offset.x) < (FIX_ZERO(0.0)), abs(aa_r_offset.y) < (FIX_ZERO(0.0))); return mirror; } else { return float2(1.0, 1.0); } } ///////////////////////// ANTIALIASED TEXTURE LOOKUPS //////////////////////// float3 tex2Daa_subpixel_weights_only(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv) { // This function is unlike the others: Just perform a single independent // lookup for each subpixel. It may be very aliased. const float2 aa_r_offset = get_aa_subpixel_r_offset(); const float2 aa_r_offset_uv_offset = mul(pixel_to_tex_uv, aa_r_offset); const float color_g = tex2D_linearize(tex, tex_uv).g; const float color_r = tex2D_linearize(tex, tex_uv + aa_r_offset_uv_offset).r; const float color_b = tex2D_linearize(tex, tex_uv - aa_r_offset_uv_offset).b; return float3(color_r, color_g, color_b); } // The tex2Daa* functions compile very slowly due to all the macros and // compile-time math, so only include the ones we'll actually use! float3 tex2Daa4x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use an RGMS4 pattern (4-queens): // . . Q . : off =(-1.5, -1.5)/4 + (2.0, 0.0)/4 // Q . . . : off =(-1.5, -1.5)/4 + (0.0, 1.0)/4 // . . . Q : off =(-1.5, -1.5)/4 + (3.0, 2.0)/4 // . Q . . : off =(-1.5, -1.5)/4 + (1.0, 3.0)/4 // Static screenspace sample offsets (compute some implicitly): static const float grid_size = 4.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0,1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5,0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(2.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(0.0, 1.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = w1.bgr; const float3 w3 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0,1.0,1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * (w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3); } float3 tex2Daa5x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 5-queens pattern: // . Q . . . : off =(-2.0, -2.0)/5 + (1.0, 0.0)/5 // . . . . Q : off =(-2.0, -2.0)/5 + (4.0, 1.0)/5 // . . Q . . : off =(-2.0, -2.0)/5 + (2.0, 2.0)/5 // Q . . . . : off =(-2.0, -2.0)/5 + (0.0, 3.0)/5 // . . . Q . : off =(-2.0, -2.0)/5 + (3.0, 4.0)/5 // Static screenspace sample offsets (compute some implicitly): static const float grid_size = 5.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(1.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(4.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(2.0, 2.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = w1.bgr; const float3 w4 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 w_sum_inv = float3(1.0)/(w0 + w1 + w2 + w3 + w4); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * (w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4); } float3 tex2Daa6x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 6-queens pattern with a stronger horizontal // than vertical slant: // . . . . Q . : off =(-2.5, -2.5)/6 + (4.0, 0.0)/6 // . . Q . . . : off =(-2.5, -2.5)/6 + (2.0, 1.0)/6 // Q . . . . . : off =(-2.5, -2.5)/6 + (0.0, 2.0)/6 // . . . . . Q : off =(-2.5, -2.5)/6 + (5.0, 3.0)/6 // . . . Q . . : off =(-2.5, -2.5)/6 + (3.0, 4.0)/6 // . Q . . . . : off =(-2.5, -2.5)/6 + (1.0, 5.0)/6 // Static screenspace sample offsets (compute some implicitly): static const float grid_size = 6.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(4.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(2.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(0.0, 2.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = w2.bgr; const float3 w4 = w1.bgr; const float3 w5 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * (w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5); } float3 tex2Daa7x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 7-queens pattern with a queen in the center: // . Q . . . . . : off =(-3.0, -3.0)/7 + (1.0, 0.0)/7 // . . . . Q . . : off =(-3.0, -3.0)/7 + (4.0, 1.0)/7 // Q . . . . . . : off =(-3.0, -3.0)/7 + (0.0, 2.0)/7 // . . . Q . . . : off =(-3.0, -3.0)/7 + (3.0, 3.0)/7 // . . . . . . Q : off =(-3.0, -3.0)/7 + (6.0, 4.0)/7 // . . Q . . . . : off =(-3.0, -3.0)/7 + (2.0, 5.0)/7 // . . . . . Q . : off =(-3.0, -3.0)/7 + (5.0, 6.0)/7 static const float grid_size = 7.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(1.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(4.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(0.0, 2.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(3.0, 3.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = w2.bgr; const float3 w5 = w1.bgr; const float3 w6 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2; const float3 w_sum = half_sum + half_sum.bgr + w3; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6); } float3 tex2Daa8x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 8-queens pattern. // . . Q . . . . . : off =(-3.5, -3.5)/8 + (2.0, 0.0)/8 // . . . . Q . . . : off =(-3.5, -3.5)/8 + (4.0, 1.0)/8 // . Q . . . . . . : off =(-3.5, -3.5)/8 + (1.0, 2.0)/8 // . . . . . . . Q : off =(-3.5, -3.5)/8 + (7.0, 3.0)/8 // Q . . . . . . . : off =(-3.5, -3.5)/8 + (0.0, 4.0)/8 // . . . . . . Q . : off =(-3.5, -3.5)/8 + (6.0, 5.0)/8 // . . . Q . . . . : off =(-3.5, -3.5)/8 + (3.0, 6.0)/8 // . . . . . Q . . : off =(-3.5, -3.5)/8 + (5.0, 7.0)/8 static const float grid_size = 8.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(2.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(4.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(1.0, 2.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(7.0, 3.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = w3.bgr; const float3 w5 = w2.bgr; const float3 w6 = w1.bgr; const float3 w7 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2 + w3; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, and mirror on odd frames if directed: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); const float2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset3).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset3).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample7 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7); } float3 tex2Daa12x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 12-superqueens pattern where no 3 points are // exactly collinear. // . . . Q . . . . . . . . : off =(-5.5, -5.5)/12 + (3.0, 0.0)/12 // . . . . . . . . . Q . . : off =(-5.5, -5.5)/12 + (9.0, 1.0)/12 // . . . . . . Q . . . . . : off =(-5.5, -5.5)/12 + (6.0, 2.0)/12 // . Q . . . . . . . . . . : off =(-5.5, -5.5)/12 + (1.0, 3.0)/12 // . . . . . . . . . . . Q : off =(-5.5, -5.5)/12 + (11.0, 4.0)/12 // . . . . Q . . . . . . . : off =(-5.5, -5.5)/12 + (4.0, 5.0)/12 // . . . . . . . Q . . . . : off =(-5.5, -5.5)/12 + (7.0, 6.0)/12 // Q . . . . . . . . . . . : off =(-5.5, -5.5)/12 + (0.0, 7.0)/12 // . . . . . . . . . . Q . : off =(-5.5, -5.5)/12 + (10.0, 8.0)/12 // . . . . . Q . . . . . . : off =(-5.5, -5.5)/12 + (5.0, 9.0)/12 // . . Q . . . . . . . . . : off =(-5.5, -5.5)/12 + (2.0, 10.0)/12 // . . . . . . . . Q . . . : off =(-5.5, -5.5)/12 + (8.0, 11.0)/12 static const float grid_size = 12.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(3.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(9.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(6.0, 2.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(1.0, 3.0) * xy_step; const float2 xy_offset4 = xy_start_offset + float2(11.0, 4.0) * xy_step; const float2 xy_offset5 = xy_start_offset + float2(4.0, 5.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); const float3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); const float3 w6 = w5.bgr; const float3 w7 = w4.bgr; const float3 w8 = w3.bgr; const float3 w9 = w2.bgr; const float3 w10 = w1.bgr; const float3 w11 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2 + w3 + w4 + w5; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/w_sum; // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); const float2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); const float2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); const float2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset3).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset4).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset5).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset5).rgb; const float3 sample7 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset4).rgb; const float3 sample8 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset3).rgb; const float3 sample9 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample10 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample11 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11); } float3 tex2Daa16x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 16-superqueens pattern where no 3 points are // exactly collinear. // . . Q . . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (2.0, 0.0)/16 // . . . . . . . . . Q . . . . . . : off =(-7.5, -7.5)/16 + (9.0, 1.0)/16 // . . . . . . . . . . . . Q . . . : off =(-7.5, -7.5)/16 + (12.0, 2.0)/16 // . . . . Q . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (4.0, 3.0)/16 // . . . . . . . . Q . . . . . . . : off =(-7.5, -7.5)/16 + (8.0, 4.0)/16 // . . . . . . . . . . . . . . Q . : off =(-7.5, -7.5)/16 + (14.0, 5.0)/16 // Q . . . . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (0.0, 6.0)/16 // . . . . . . . . . . Q . . . . . : off =(-7.5, -7.5)/16 + (10.0, 7.0)/16 // . . . . . Q . . . . . . . . . . : off =(-7.5, -7.5)/16 + (5.0, 8.0)/16 // . . . . . . . . . . . . . . . Q : off =(-7.5, -7.5)/16 + (15.0, 9.0)/16 // . Q . . . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (1.0, 10.0)/16 // . . . . . . . Q . . . . . . . . : off =(-7.5, -7.5)/16 + (7.0, 11.0)/16 // . . . . . . . . . . . Q . . . . : off =(-7.5, -7.5)/16 + (11.0, 12.0)/16 // . . . Q . . . . . . . . . . . . : off =(-7.5, -7.5)/16 + (3.0, 13.0)/16 // . . . . . . Q . . . . . . . . . : off =(-7.5, -7.5)/16 + (6.0, 14.0)/16 // . . . . . . . . . . . . . Q . . : off =(-7.5, -7.5)/16 + (13.0, 15.0)/16 static const float grid_size = 16.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(2.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(9.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(12.0, 2.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(4.0, 3.0) * xy_step; const float2 xy_offset4 = xy_start_offset + float2(8.0, 4.0) * xy_step; const float2 xy_offset5 = xy_start_offset + float2(14.0, 5.0) * xy_step; const float2 xy_offset6 = xy_start_offset + float2(0.0, 6.0) * xy_step; const float2 xy_offset7 = xy_start_offset + float2(10.0, 7.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); const float3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); const float3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); const float3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); const float3 w8 = w7.bgr; const float3 w9 = w6.bgr; const float3 w10 = w5.bgr; const float3 w11 = w4.bgr; const float3 w12 = w3.bgr; const float3 w13 = w2.bgr; const float3 w14 = w1.bgr; const float3 w15 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); const float2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); const float2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); const float2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); const float2 uv_offset6 = mul(true_pixel_to_tex_uv, xy_offset6 * frame_sign); const float2 uv_offset7 = mul(true_pixel_to_tex_uv, xy_offset7 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset3).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset4).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset5).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset6).rgb; const float3 sample7 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset7).rgb; const float3 sample8 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset7).rgb; const float3 sample9 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset6).rgb; const float3 sample10 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset5).rgb; const float3 sample11 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset4).rgb; const float3 sample12 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset3).rgb; const float3 sample13 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample14 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample15 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15); } float3 tex2Daa20x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 20-superqueens pattern where no 3 points are // exactly collinear and superqueens have a squared attack radius of 13. // . . . . . . . Q . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (7.0, 0.0)/20 // . . . . . . . . . . . . . . . . Q . . . : off =(-9.5, -9.5)/20 + (16.0, 1.0)/20 // . . . . . . . . . . . Q . . . . . . . . : off =(-9.5, -9.5)/20 + (11.0, 2.0)/20 // . Q . . . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (1.0, 3.0)/20 // . . . . . Q . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (5.0, 4.0)/20 // . . . . . . . . . . . . . . . Q . . . . : off =(-9.5, -9.5)/20 + (15.0, 5.0)/20 // . . . . . . . . . . Q . . . . . . . . . : off =(-9.5, -9.5)/20 + (10.0, 6.0)/20 // . . . . . . . . . . . . . . . . . . . Q : off =(-9.5, -9.5)/20 + (19.0, 7.0)/20 // . . Q . . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (2.0, 8.0)/20 // . . . . . . Q . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (6.0, 9.0)/20 // . . . . . . . . . . . . . Q . . . . . . : off =(-9.5, -9.5)/20 + (13.0, 10.0)/20 // . . . . . . . . . . . . . . . . . Q . . : off =(-9.5, -9.5)/20 + (17.0, 11.0)/20 // Q . . . . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (0.0, 12.0)/20 // . . . . . . . . . Q . . . . . . . . . . : off =(-9.5, -9.5)/20 + (9.0, 13.0)/20 // . . . . Q . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (4.0, 14.0)/20 // . . . . . . . . . . . . . . Q . . . . . : off =(-9.5, -9.5)/20 + (14.0, 15.0)/20 // . . . . . . . . . . . . . . . . . . Q . : off =(-9.5, -9.5)/20 + (18.0, 16.0)/20 // . . . . . . . . Q . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (8.0, 17.0)/20 // . . . Q . . . . . . . . . . . . . . . . : off =(-9.5, -9.5)/20 + (3.0, 18.0)/20 // . . . . . . . . . . . . Q . . . . . . . : off =(-9.5, -9.5)/20 + (12.0, 19.0)/20 static const float grid_size = 20.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(7.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(16.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(11.0, 2.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(1.0, 3.0) * xy_step; const float2 xy_offset4 = xy_start_offset + float2(5.0, 4.0) * xy_step; const float2 xy_offset5 = xy_start_offset + float2(15.0, 5.0) * xy_step; const float2 xy_offset6 = xy_start_offset + float2(10.0, 6.0) * xy_step; const float2 xy_offset7 = xy_start_offset + float2(19.0, 7.0) * xy_step; const float2 xy_offset8 = xy_start_offset + float2(2.0, 8.0) * xy_step; const float2 xy_offset9 = xy_start_offset + float2(6.0, 9.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); const float3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); const float3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); const float3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); const float3 w8 = eval_unorm_rgb_weights(xy_offset8, final_axis_importance); const float3 w9 = eval_unorm_rgb_weights(xy_offset9, final_axis_importance); const float3 w10 = w9.bgr; const float3 w11 = w8.bgr; const float3 w12 = w7.bgr; const float3 w13 = w6.bgr; const float3 w14 = w5.bgr; const float3 w15 = w4.bgr; const float3 w16 = w3.bgr; const float3 w17 = w2.bgr; const float3 w18 = w1.bgr; const float3 w19 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); const float2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); const float2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); const float2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); const float2 uv_offset6 = mul(true_pixel_to_tex_uv, xy_offset6 * frame_sign); const float2 uv_offset7 = mul(true_pixel_to_tex_uv, xy_offset7 * frame_sign); const float2 uv_offset8 = mul(true_pixel_to_tex_uv, xy_offset8 * frame_sign); const float2 uv_offset9 = mul(true_pixel_to_tex_uv, xy_offset9 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset3).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset4).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset5).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset6).rgb; const float3 sample7 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset7).rgb; const float3 sample8 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset8).rgb; const float3 sample9 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset9).rgb; const float3 sample10 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset9).rgb; const float3 sample11 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset8).rgb; const float3 sample12 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset7).rgb; const float3 sample13 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset6).rgb; const float3 sample14 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset5).rgb; const float3 sample15 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset4).rgb; const float3 sample16 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset3).rgb; const float3 sample17 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample18 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample19 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15 + w16 * sample16 + w17 * sample17 + w18 * sample18 + w19 * sample19); } float3 tex2Daa24x(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Use a diagonally symmetric 24-superqueens pattern where no 3 points are // exactly collinear and superqueens have a squared attack radius of 13. // . . . . . . Q . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (6.0, 0.0)/24 // . . . . . . . . . . . . . . . . Q . . . . . . . : off =(-11.5, -11.5)/24 + (16.0, 1.0)/24 // . . . . . . . . . . Q . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (10.0, 2.0)/24 // . . . . . . . . . . . . . . . . . . . . . Q . . : off =(-11.5, -11.5)/24 + (21.0, 3.0)/24 // . . . . . Q . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (5.0, 4.0)/24 // . . . . . . . . . . . . . . . Q . . . . . . . . : off =(-11.5, -11.5)/24 + (15.0, 5.0)/24 // . Q . . . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (1.0, 6.0)/24 // . . . . . . . . . . . Q . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (11.0, 7.0)/24 // . . . . . . . . . . . . . . . . . . . Q . . . . : off =(-11.5, -11.5)/24 + (19.0, 8.0)/24 // . . . . . . . . . . . . . . . . . . . . . . . Q : off =(-11.5, -11.5)/24 + (23.0, 9.0)/24 // . . . Q . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (3.0, 10.0)/24 // . . . . . . . . . . . . . . Q . . . . . . . . . : off =(-11.5, -11.5)/24 + (14.0, 11.0)/24 // . . . . . . . . . Q . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (9.0, 12.0)/24 // . . . . . . . . . . . . . . . . . . . . Q . . . : off =(-11.5, -11.5)/24 + (20.0, 13.0)/24 // Q . . . . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (0.0, 14.0)/24 // . . . . Q . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (4.0, 15.0)/24 // . . . . . . . . . . . . Q . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (12.0, 16.0)/24 // . . . . . . . . . . . . . . . . . . . . . . Q . : off =(-11.5, -11.5)/24 + (22.0, 17.0)/24 // . . . . . . . . Q . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (8.0, 18.0)/24 // . . . . . . . . . . . . . . . . . . Q . . . . . : off =(-11.5, -11.5)/24 + (18.0, 19.0)/24 // . . Q . . . . . . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (2.0, 20.0)/24 // . . . . . . . . . . . . . Q . . . . . . . . . . : off =(-11.5, -11.5)/24 + (13.0, 21.0)/24 // . . . . . . . Q . . . . . . . . . . . . . . . . : off =(-11.5, -11.5)/24 + (7.0, 22.0)/24 // . . . . . . . . . . . . . . . . . Q . . . . . . : off =(-11.5, -11.5)/24 + (17.0, 23.0)/24 static const float grid_size = 24.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample. Exploit diagonal symmetry: const float2 xy_offset0 = xy_start_offset + float2(6.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(16.0, 1.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(10.0, 2.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(21.0, 3.0) * xy_step; const float2 xy_offset4 = xy_start_offset + float2(5.0, 4.0) * xy_step; const float2 xy_offset5 = xy_start_offset + float2(15.0, 5.0) * xy_step; const float2 xy_offset6 = xy_start_offset + float2(1.0, 6.0) * xy_step; const float2 xy_offset7 = xy_start_offset + float2(11.0, 7.0) * xy_step; const float2 xy_offset8 = xy_start_offset + float2(19.0, 8.0) * xy_step; const float2 xy_offset9 = xy_start_offset + float2(23.0, 9.0) * xy_step; const float2 xy_offset10 = xy_start_offset + float2(3.0, 10.0) * xy_step; const float2 xy_offset11 = xy_start_offset + float2(14.0, 11.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); const float3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); const float3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); const float3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); const float3 w8 = eval_unorm_rgb_weights(xy_offset8, final_axis_importance); const float3 w9 = eval_unorm_rgb_weights(xy_offset9, final_axis_importance); const float3 w10 = eval_unorm_rgb_weights(xy_offset10, final_axis_importance); const float3 w11 = eval_unorm_rgb_weights(xy_offset11, final_axis_importance); const float3 w12 = w11.bgr; const float3 w13 = w10.bgr; const float3 w14 = w9.bgr; const float3 w15 = w8.bgr; const float3 w16 = w7.bgr; const float3 w17 = w6.bgr; const float3 w18 = w5.bgr; const float3 w19 = w4.bgr; const float3 w20 = w3.bgr; const float3 w21 = w2.bgr; const float3 w22 = w1.bgr; const float3 w23 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7 + w8 + w9 + w10 + w11; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, mirror on odd frames if directed, and exploit // diagonal symmetry: const float2 frame_sign = get_frame_sign(frame); const float2 uv_offset0 = mul(true_pixel_to_tex_uv, xy_offset0 * frame_sign); const float2 uv_offset1 = mul(true_pixel_to_tex_uv, xy_offset1 * frame_sign); const float2 uv_offset2 = mul(true_pixel_to_tex_uv, xy_offset2 * frame_sign); const float2 uv_offset3 = mul(true_pixel_to_tex_uv, xy_offset3 * frame_sign); const float2 uv_offset4 = mul(true_pixel_to_tex_uv, xy_offset4 * frame_sign); const float2 uv_offset5 = mul(true_pixel_to_tex_uv, xy_offset5 * frame_sign); const float2 uv_offset6 = mul(true_pixel_to_tex_uv, xy_offset6 * frame_sign); const float2 uv_offset7 = mul(true_pixel_to_tex_uv, xy_offset7 * frame_sign); const float2 uv_offset8 = mul(true_pixel_to_tex_uv, xy_offset8 * frame_sign); const float2 uv_offset9 = mul(true_pixel_to_tex_uv, xy_offset9 * frame_sign); const float2 uv_offset10 = mul(true_pixel_to_tex_uv, xy_offset10 * frame_sign); const float2 uv_offset11 = mul(true_pixel_to_tex_uv, xy_offset11 * frame_sign); // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset0).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset1).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset2).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset3).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset4).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset5).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset6).rgb; const float3 sample7 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset7).rgb; const float3 sample8 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset8).rgb; const float3 sample9 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset9).rgb; const float3 sample10 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset10).rgb; const float3 sample11 = tex2Daa_tiled_linearize(tex, tex_uv + uv_offset11).rgb; const float3 sample12 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset11).rgb; const float3 sample13 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset10).rgb; const float3 sample14 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset9).rgb; const float3 sample15 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset8).rgb; const float3 sample16 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset7).rgb; const float3 sample17 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset6).rgb; const float3 sample18 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset5).rgb; const float3 sample19 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset4).rgb; const float3 sample20 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset3).rgb; const float3 sample21 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset2).rgb; const float3 sample22 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset1).rgb; const float3 sample23 = tex2Daa_tiled_linearize(tex, tex_uv - uv_offset0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15 + w16 * sample16 + w17 * sample17 + w18 * sample18 + w19 * sample19 + w20 * sample20 + w21 * sample21 + w22 * sample22 + w23 * sample23); } float3 tex2Daa_debug_16x_regular(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Sample on a regular 4x4 grid. This is mainly for testing. static const float grid_size = 4.0; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float2 xy_step = float2(1.0)/grid_size * subpixel_support_diameter; const float2 xy_start_offset = float2(0.5 - grid_size*0.5) * xy_step; // Get the xy offset of each sample: const float2 xy_offset0 = xy_start_offset + float2(0.0, 0.0) * xy_step; const float2 xy_offset1 = xy_start_offset + float2(1.0, 0.0) * xy_step; const float2 xy_offset2 = xy_start_offset + float2(2.0, 0.0) * xy_step; const float2 xy_offset3 = xy_start_offset + float2(3.0, 0.0) * xy_step; const float2 xy_offset4 = xy_start_offset + float2(0.0, 1.0) * xy_step; const float2 xy_offset5 = xy_start_offset + float2(1.0, 1.0) * xy_step; const float2 xy_offset6 = xy_start_offset + float2(2.0, 1.0) * xy_step; const float2 xy_offset7 = xy_start_offset + float2(3.0, 1.0) * xy_step; // Compute subpixel weights, and exploit diagonal symmetry for speed. // (We can't exploit vertical or horizontal symmetry due to uncertain // subpixel offsets. We could fix that by rotating xy offsets with the // subpixel structure, but...no.) const float3 w0 = eval_unorm_rgb_weights(xy_offset0, final_axis_importance); const float3 w1 = eval_unorm_rgb_weights(xy_offset1, final_axis_importance); const float3 w2 = eval_unorm_rgb_weights(xy_offset2, final_axis_importance); const float3 w3 = eval_unorm_rgb_weights(xy_offset3, final_axis_importance); const float3 w4 = eval_unorm_rgb_weights(xy_offset4, final_axis_importance); const float3 w5 = eval_unorm_rgb_weights(xy_offset5, final_axis_importance); const float3 w6 = eval_unorm_rgb_weights(xy_offset6, final_axis_importance); const float3 w7 = eval_unorm_rgb_weights(xy_offset7, final_axis_importance); const float3 w8 = w7.bgr; const float3 w9 = w6.bgr; const float3 w10 = w5.bgr; const float3 w11 = w4.bgr; const float3 w12 = w3.bgr; const float3 w13 = w2.bgr; const float3 w14 = w1.bgr; const float3 w15 = w0.bgr; // Get the weight sum to normalize the total to 1.0 later: const float3 half_sum = w0 + w1 + w2 + w3 + w4 + w5 + w6 + w7; const float3 w_sum = half_sum + half_sum.bgr; const float3 w_sum_inv = float3(1.0)/(w_sum); // Scale the pixel-space to texture offset matrix by the pixel diameter. const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); // Get uv sample offsets, taking advantage of row alignment: const float2 uv_step_x = mul(true_pixel_to_tex_uv, float2(xy_step.x, 0.0)); const float2 uv_step_y = mul(true_pixel_to_tex_uv, float2(0.0, xy_step.y)); const float2 uv_offset0 = -1.5 * (uv_step_x + uv_step_y); const float2 sample0_uv = tex_uv + uv_offset0; const float2 sample4_uv = sample0_uv + uv_step_y; const float2 sample8_uv = sample0_uv + uv_step_y * 2.0; const float2 sample12_uv = sample0_uv + uv_step_y * 3.0; // Load samples, linearizing if necessary, etc.: const float3 sample0 = tex2Daa_tiled_linearize(tex, sample0_uv).rgb; const float3 sample1 = tex2Daa_tiled_linearize(tex, sample0_uv + uv_step_x).rgb; const float3 sample2 = tex2Daa_tiled_linearize(tex, sample0_uv + uv_step_x * 2.0).rgb; const float3 sample3 = tex2Daa_tiled_linearize(tex, sample0_uv + uv_step_x * 3.0).rgb; const float3 sample4 = tex2Daa_tiled_linearize(tex, sample4_uv).rgb; const float3 sample5 = tex2Daa_tiled_linearize(tex, sample4_uv + uv_step_x).rgb; const float3 sample6 = tex2Daa_tiled_linearize(tex, sample4_uv + uv_step_x * 2.0).rgb; const float3 sample7 = tex2Daa_tiled_linearize(tex, sample4_uv + uv_step_x * 3.0).rgb; const float3 sample8 = tex2Daa_tiled_linearize(tex, sample8_uv).rgb; const float3 sample9 = tex2Daa_tiled_linearize(tex, sample8_uv + uv_step_x).rgb; const float3 sample10 = tex2Daa_tiled_linearize(tex, sample8_uv + uv_step_x * 2.0).rgb; const float3 sample11 = tex2Daa_tiled_linearize(tex, sample8_uv + uv_step_x * 3.0).rgb; const float3 sample12 = tex2Daa_tiled_linearize(tex, sample12_uv).rgb; const float3 sample13 = tex2Daa_tiled_linearize(tex, sample12_uv + uv_step_x).rgb; const float3 sample14 = tex2Daa_tiled_linearize(tex, sample12_uv + uv_step_x * 2.0).rgb; const float3 sample15 = tex2Daa_tiled_linearize(tex, sample12_uv + uv_step_x * 3.0).rgb; // Sum weighted samples (weight sum must equal 1.0 for each channel): return w_sum_inv * ( w0 * sample0 + w1 * sample1 + w2 * sample2 + w3 * sample3 + w4 * sample4 + w5 * sample5 + w6 * sample6 + w7 * sample7 + w8 * sample8 + w9 * sample9 + w10 * sample10 + w11 * sample11 + w12 * sample12 + w13 * sample13 + w14 * sample14 + w15 * sample15); } float3 tex2Daa_debug_dynamic(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // This function is for testing only: Use an NxN grid with dynamic weights. static const int grid_size = 8; assign_aa_cubic_constants(); const float4 ssd_fai = get_subpixel_support_diam_and_final_axis_importance(); const float2 subpixel_support_diameter = ssd_fai.xy; const float2 final_axis_importance = ssd_fai.zw; const float grid_radius_in_samples = (float(grid_size) - 1.0)/2.0; const float2 filter_space_offset_step = subpixel_support_diameter/float2(grid_size); const float2 sample0_filter_space_offset = -grid_radius_in_samples * filter_space_offset_step; // Compute xy sample offsets and subpixel weights: float3 weights[grid_size * grid_size]; float3 weight_sum = float3(0.0, 0.0, 0.0); for(int i = 0; i < grid_size; ++i) { for(int j = 0; j < grid_size; ++j) { // Weights based on xy distances: const float2 offset = sample0_filter_space_offset + float2(j, i) * filter_space_offset_step; const float3 weight = eval_unorm_rgb_weights(offset, final_axis_importance); weights[i*grid_size + j] = weight; weight_sum += weight; } } // Get uv offset vectors along x and y directions: const float2x2 true_pixel_to_tex_uv = float2x2(float4(pixel_to_tex_uv * aa_pixel_diameter)); const float2 uv_offset_step_x = mul(true_pixel_to_tex_uv, float2(filter_space_offset_step.x, 0.0)); const float2 uv_offset_step_y = mul(true_pixel_to_tex_uv, float2(0.0, filter_space_offset_step.y)); // Get a starting sample location: const float2 sample0_uv_offset = -grid_radius_in_samples * (uv_offset_step_x + uv_offset_step_y); const float2 sample0_uv = tex_uv + sample0_uv_offset; // Load, weight, and sum [linearized] samples: float3 sum = float3(0.0, 0.0, 0.0); const float3 weight_sum_inv = float3(1.0)/weight_sum; for(int i = 0; i < grid_size; ++i) { const float2 row_i_first_sample_uv = sample0_uv + i * uv_offset_step_y; for(int j = 0; j < grid_size; ++j) { const float2 sample_uv = row_i_first_sample_uv + j * uv_offset_step_x; sum += weights[i*grid_size + j] * tex2Daa_tiled_linearize(tex, sample_uv).rgb; } } return sum * weight_sum_inv; } /////////////////////// ANTIALIASING CODEPATH SELECTION ////////////////////// inline float3 tex2Daa(const sampler2D tex, const float2 tex_uv, const float2x2 pixel_to_tex_uv, const float frame) { // Statically switch between antialiasing modes/levels: return (aa_level < 0.5) ? tex2D_linearize(tex, tex_uv).rgb : (aa_level < 3.5) ? tex2Daa_subpixel_weights_only( tex, tex_uv, pixel_to_tex_uv) : (aa_level < 4.5) ? tex2Daa4x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 5.5) ? tex2Daa5x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 6.5) ? tex2Daa6x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 7.5) ? tex2Daa7x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 11.5) ? tex2Daa8x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 15.5) ? tex2Daa12x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 19.5) ? tex2Daa16x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 23.5) ? tex2Daa20x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 253.5) ? tex2Daa24x(tex, tex_uv, pixel_to_tex_uv, frame) : (aa_level < 254.5) ? tex2Daa_debug_16x_regular( tex, tex_uv, pixel_to_tex_uv, frame) : tex2Daa_debug_dynamic(tex, tex_uv, pixel_to_tex_uv, frame); } #endif // TEX2DANTIALIAS_H #line 1393 "tex2Dantialias.h" #line 108 "crt-royale-geometry-aa-last-pass.h" #line 1 "geometry-functions.h" #ifndef GEOMETRY_FUNCTIONS_H #define GEOMETRY_FUNCTIONS_H ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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 ////////////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 25 "geometry-functions.h" #line 1 "derived-settings-and-constants.h" #ifndef DERIVED_SETTINGS_AND_CONSTANTS_H #define DERIVED_SETTINGS_AND_CONSTANTS_H ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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. ////////////////////////////////// INCLUDES ////////////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 31 "derived-settings-and-constants.h" #line 1 "user-cgp-constants.h" #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_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). //#define PHOSPHOR_MASK_GRILLE14 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 #ifdef 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 #line 55 "user-cgp-constants.h" #endif // USER_CGP_CONSTANTS_H #line 58 "user-cgp-constants.h" #line 32 "derived-settings-and-constants.h" /////////////////////////////// FIXED SETTINGS /////////////////////////////// // Avoid dividing by zero; using a macro overloads for float, float2, etc.: #define FIX_ZERO(c) (max(abs(c), 0.0000152587890625)) // 2^-16 // Ensure the first pass decodes CRT gamma and the last encodes LCD gamma. #ifndef SIMULATE_CRT_ON_LCD #define SIMULATE_CRT_ON_LCD #endif #line 44 "derived-settings-and-constants.h" // 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). #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD // 129.7 FPS, 4x, flat; 101.8 at fullscreen #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE // 128.1 FPS, 4x, flat; 101.5 at fullscreen #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES // 124.4 FPS, 4x, flat; 97.4 at fullscreen // 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. //#define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD ////////////////////////////// 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.) #ifdef INTEGRATED_GRAPHICS_COMPATIBILITY_MODE #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE #undef PHOSPHOR_MASK_MANUALLY_RESIZE #endif #line 79 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 82 "derived-settings-and-constants.h" // 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 = bloom_approx_filter_static > 1.5 ? 0.0 : bloom_approx_filter_static; #else static const float bloom_approx_filter = bloom_approx_filter_static; #endif #line 89 "derived-settings-and-constants.h" // 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. #ifndef RUNTIME_SHADER_PARAMS_ENABLE #ifdef RUNTIME_PHOSPHOR_BLOOM_SIGMA #undef RUNTIME_PHOSPHOR_BLOOM_SIGMA #endif #line 96 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_WEIGHTS #undef RUNTIME_ANTIALIAS_WEIGHTS #endif #line 99 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #undef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #endif #line 102 "derived-settings-and-constants.h" #ifdef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #undef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #endif #line 105 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_TILT #undef RUNTIME_GEOMETRY_TILT #endif #line 108 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 111 "derived-settings-and-constants.h" #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #undef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 114 "derived-settings-and-constants.h" #endif #line 115 "derived-settings-and-constants.h" // Make tex2Dbias a backup for tex2Dlod for wider compatibility. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 120 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 123 "derived-settings-and-constants.h" // Rule out unavailable anisotropic compatibility strategies: #ifndef DRIVERS_ALLOW_DERIVATIVES #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 128 "derived-settings-and-constants.h" #endif #line 129 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #undef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #endif #line 133 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #endif #line 136 "derived-settings-and-constants.h" #ifdef ANTIALIAS_DISABLE_ANISOTROPIC #undef ANTIALIAS_DISABLE_ANISOTROPIC #endif #line 139 "derived-settings-and-constants.h" #endif #line 140 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 144 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 147 "derived-settings-and-constants.h" #endif #line 148 "derived-settings-and-constants.h" // Prioritize anisotropic tiling compatibility strategies by performance and // disable unused strategies. This concentrates all the nesting in one place. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 154 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 157 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 160 "derived-settings-and-constants.h" #else #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 165 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 168 "derived-settings-and-constants.h" #else // ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE is only compatible with // flat texture coords in the same pass, but that's all we use. #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 175 "derived-settings-and-constants.h" #endif #line 176 "derived-settings-and-constants.h" #endif #line 177 "derived-settings-and-constants.h" #endif #line 178 "derived-settings-and-constants.h" // 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: #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 183 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 186 "derived-settings-and-constants.h" // Prioritize anisotropic resampling compatibility strategies the same way: #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 191 "derived-settings-and-constants.h" #endif #line 192 "derived-settings-and-constants.h" /////////////////////// 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. #ifdef DRIVERS_ALLOW_TEX2DLOD #ifdef 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_small_size; #endif #line 206 "derived-settings-and-constants.h" #else static const float2 mask_resize_src_lut_size = mask_texture_small_size; #endif #line 209 "derived-settings-and-constants.h" // 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. #ifdef DRIVERS_ALLOW_DYNAMIC_BRANCHES #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #else #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 231 "derived-settings-and-constants.h" #endif #line 232 "derived-settings-and-constants.h" // 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 #line 247 "derived-settings-and-constants.h" // 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 #line 253 "derived-settings-and-constants.h" // Fixing discontinuities adds 1.0 more to the pixel border: #ifdef 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 #line 259 "derived-settings-and-constants.h" // Convert the pixel border to an integer texel border. Assume same-pass // curvature about triples the texel frequency: #ifdef GEOMETRY_EARLY static const float max_mask_texel_border = ceil(max_tiled_pixel_border * 3.0); #else static const float max_mask_texel_border = ceil(max_tiled_pixel_border); #endif #line 267 "derived-settings-and-constants.h" // 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 #ifdef 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 #line 284 "derived-settings-and-constants.h" #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 #line 288 "derived-settings-and-constants.h" // 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_viewport_scale; //////////////////////// 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; #endif // DERIVED_SETTINGS_AND_CONSTANTS_H #line 315 "derived-settings-and-constants.h" #line 26 "geometry-functions.h" #line 1 "bind-shader-params.h" #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 // // 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 //////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 25 "bind-shader-params.h" #line 1 "derived-settings-and-constants.h" #ifndef DERIVED_SETTINGS_AND_CONSTANTS_H #define DERIVED_SETTINGS_AND_CONSTANTS_H ///////////////////////////// GPL LICENSE NOTICE ///////////////////////////// // crt-royale: A full-featured CRT shader, with cheese. // Copyright (C) 2014 TroggleMonkey // // 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. ////////////////////////////////// INCLUDES ////////////////////////////////// #line 1 "user-settings.h" #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 //#define DRIVERS_ALLOW_DERIVATIVES // 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. #ifdef DRIVERS_ALLOW_DERIVATIVES #define DRIVERS_ALLOW_FINE_DERIVATIVES #endif #line 29 "user-settings.h" // 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 //#define DRIVERS_ALLOW_DYNAMIC_BRANCHES // 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 //#define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS // 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 //#define DRIVERS_ALLOW_TEX2DLOD // 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 //#define DRIVERS_ALLOW_TEX2DBIAS // 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 //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE //////////////////////////// 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. #define RUNTIME_SHADER_PARAMS_ENABLE // 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. #define RUNTIME_PHOSPHOR_BLOOM_SIGMA // Specify antialiasing weight parameters at runtime? (Costs ~20% with cubics) #define RUNTIME_ANTIALIAS_WEIGHTS // Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!) //#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader // parameters? This will require more math or dynamic branching. #define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE // Specify the tilt at runtime? This makes things about 3% slower. //#define RUNTIME_GEOMETRY_TILT // Specify the geometry mode at runtime? //#define RUNTIME_GEOMETRY_MODE // 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. #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT // PHOSPHOR MASK: // 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. #define PHOSPHOR_MASK_MANUALLY_RESIZE // If we sinc-resize the mask, should we Lanczos-window it (slower but better)? #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW // 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 //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS //#define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS // 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] // 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 beam_max_sigma is low. // 1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring, // always uses a static sigma regardless of beam_max_sigma or // mask_num_triads_desired. // 2.) True 4x4 Gaussian resize: Slowest, technically correct. // These options are more pronounced for the fast, unbloomed shader version. #ifndef RADEON_FIX static const float bloom_approx_filter_static = 2.0; #else static const float bloom_approx_filter_static = 1.0; #endif #line 167 "user-settings.h" // 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 beam_min_sigma_static = 0.02; // range (0, 1] static const float 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 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 beam_min_shape_static = 2.0; // range [2, 32] static const float 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 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_bff_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) static const float aa_level = 12.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 static const float aa_filter = 6.0; // range [0, 9] // Flip the sample grid on odd/even frames (static option only for now)? static const bool aa_temporal = false; // 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 = EDP shadow mask static const float mask_type_static = 1.0; // range [0, 2] // 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_specify_num_triads_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_size_desired_static = 24.0 / 8.0; // If mask_specify_num_triads 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_desired_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) #endif // USER_SETTINGS_H #line 363 "user-settings.h" #line 31 "derived-settings-and-constants.h" #line 1 "user-cgp-constants.h" #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_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). //#define PHOSPHOR_MASK_GRILLE14 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 #ifdef 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 #line 55 "user-cgp-constants.h" #endif // USER_CGP_CONSTANTS_H #line 58 "user-cgp-constants.h" #line 32 "derived-settings-and-constants.h" /////////////////////////////// FIXED SETTINGS /////////////////////////////// // Avoid dividing by zero; using a macro overloads for float, float2, etc.: #define FIX_ZERO(c) (max(abs(c), 0.0000152587890625)) // 2^-16 // Ensure the first pass decodes CRT gamma and the last encodes LCD gamma. #ifndef SIMULATE_CRT_ON_LCD #define SIMULATE_CRT_ON_LCD #endif #line 44 "derived-settings-and-constants.h" // 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). #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD // 129.7 FPS, 4x, flat; 101.8 at fullscreen #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE // 128.1 FPS, 4x, flat; 101.5 at fullscreen #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES // 124.4 FPS, 4x, flat; 97.4 at fullscreen // 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. //#define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD ////////////////////////////// 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.) #ifdef INTEGRATED_GRAPHICS_COMPATIBILITY_MODE #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE #undef PHOSPHOR_MASK_MANUALLY_RESIZE #endif #line 79 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 82 "derived-settings-and-constants.h" // 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 = bloom_approx_filter_static > 1.5 ? 0.0 : bloom_approx_filter_static; #else static const float bloom_approx_filter = bloom_approx_filter_static; #endif #line 89 "derived-settings-and-constants.h" // 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. #ifndef RUNTIME_SHADER_PARAMS_ENABLE #ifdef RUNTIME_PHOSPHOR_BLOOM_SIGMA #undef RUNTIME_PHOSPHOR_BLOOM_SIGMA #endif #line 96 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_WEIGHTS #undef RUNTIME_ANTIALIAS_WEIGHTS #endif #line 99 "derived-settings-and-constants.h" #ifdef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #undef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS #endif #line 102 "derived-settings-and-constants.h" #ifdef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #undef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE #endif #line 105 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_TILT #undef RUNTIME_GEOMETRY_TILT #endif #line 108 "derived-settings-and-constants.h" #ifdef RUNTIME_GEOMETRY_MODE #undef RUNTIME_GEOMETRY_MODE #endif #line 111 "derived-settings-and-constants.h" #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #undef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 114 "derived-settings-and-constants.h" #endif #line 115 "derived-settings-and-constants.h" // Make tex2Dbias a backup for tex2Dlod for wider compatibility. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 120 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 123 "derived-settings-and-constants.h" // Rule out unavailable anisotropic compatibility strategies: #ifndef DRIVERS_ALLOW_DERIVATIVES #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 128 "derived-settings-and-constants.h" #endif #line 129 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #undef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #endif #line 133 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #endif #line 136 "derived-settings-and-constants.h" #ifdef ANTIALIAS_DISABLE_ANISOTROPIC #undef ANTIALIAS_DISABLE_ANISOTROPIC #endif #line 139 "derived-settings-and-constants.h" #endif #line 140 "derived-settings-and-constants.h" #ifndef DRIVERS_ALLOW_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 144 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 147 "derived-settings-and-constants.h" #endif #line 148 "derived-settings-and-constants.h" // Prioritize anisotropic tiling compatibility strategies by performance and // disable unused strategies. This concentrates all the nesting in one place. #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #endif #line 154 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 157 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 160 "derived-settings-and-constants.h" #else #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #endif #line 165 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 168 "derived-settings-and-constants.h" #else // ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE is only compatible with // flat texture coords in the same pass, but that's all we use. #ifdef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE #ifdef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES #endif #line 175 "derived-settings-and-constants.h" #endif #line 176 "derived-settings-and-constants.h" #endif #line 177 "derived-settings-and-constants.h" #endif #line 178 "derived-settings-and-constants.h" // 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: #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DLOD #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 183 "derived-settings-and-constants.h" #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY #endif #line 186 "derived-settings-and-constants.h" // Prioritize anisotropic resampling compatibility strategies the same way: #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS #endif #line 191 "derived-settings-and-constants.h" #endif #line 192 "derived-settings-and-constants.h" /////////////////////// 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. #ifdef DRIVERS_ALLOW_TEX2DLOD #ifdef 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_small_size; #endif #line 206 "derived-settings-and-constants.h" #else static const float2 mask_resize_src_lut_size = mask_texture_small_size; #endif #line 209 "derived-settings-and-constants.h" // 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. #ifdef DRIVERS_ALLOW_DYNAMIC_BRANCHES #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #else #ifdef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #define RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #endif #line 231 "derived-settings-and-constants.h" #endif #line 232 "derived-settings-and-constants.h" // 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 #line 247 "derived-settings-and-constants.h" // 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 #line 253 "derived-settings-and-constants.h" // Fixing discontinuities adds 1.0 more to the pixel border: #ifdef 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 #line 259 "derived-settings-and-constants.h" // Convert the pixel border to an integer texel border. Assume same-pass // curvature about triples the texel frequency: #ifdef GEOMETRY_EARLY static const float max_mask_texel_border = ceil(max_tiled_pixel_border * 3.0); #else static const float max_mask_texel_border = ceil(max_tiled_pixel_border); #endif #line 267 "derived-settings-and-constants.h" // 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 #ifdef 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 #line 284 "derived-settings-and-constants.h" #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 #line 288 "derived-settings-and-constants.h" // 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_viewport_scale; //////////////////////// 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; #endif // DERIVED_SETTINGS_AND_CONSTANTS_H #line 315 "derived-settings-and-constants.h" #line 26 "bind-shader-params.h" // Override some parameters for gamma-management.h and tex2Dantialias.h: #define OVERRIDE_DEVICE_GAMMA static const float gba_gamma = 3.5; // Irrelevant but necessary to define. #define ANTIALIAS_OVERRIDE_BASICS #define ANTIALIAS_OVERRIDE_PARAMETERS // Disable runtime shader params if the user doesn't explicitly want them. // Static constants will be defined in place of uniforms of the same name. #ifdef RUNTIME_SHADER_PARAMS_ENABLE #ifndef RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE static const float beam_horiz_filter = clamp(beam_horiz_filter_static, 0.0, 2.0); static const float beam_horiz_linear_rgb_weight = clamp(beam_horiz_linear_rgb_weight_static, 0.0, 1.0); #endif #line 41 "bind-shader-params.h" #ifndef RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT static const float mask_type = clamp(mask_type_static, 0.0, 2.0); #endif #line 44 "bind-shader-params.h" #ifndef RUNTIME_ANTIALIAS_WEIGHTS static const float aa_cubic_c = aa_cubic_c_static; // Clamp to [0, 4]? static const float aa_gauss_sigma = max(FIX_ZERO(0.0), aa_gauss_sigma_static); // Clamp to [FIXZERO(0), 1]? #endif #line 48 "bind-shader-params.h" #else #define HARDCODE_SETTINGS #endif #line 51 "bind-shader-params.h" // Bind option names to shader parameter uniforms or static constants. #ifdef HARDCODE_SETTINGS // Use constants from user-settings.h, and limit ranges appropriately: static const float crt_gamma = max(0.0, crt_gamma_static); static const float lcd_gamma = max(0.0, lcd_gamma_static); static const float levels_contrast = clamp(levels_contrast_static, 0.0, 4.0); static const float halation_weight = clamp(halation_weight_static, 0.0, 1.0); static const float diffusion_weight = clamp(diffusion_weight_static, 0.0, 1.0); static const float bloom_underestimate_levels = max(FIX_ZERO(0.0), bloom_underestimate_levels_static); static const float bloom_excess = clamp(bloom_excess_static, 0.0, 1.0); static const float beam_min_sigma = max(FIX_ZERO(0.0), beam_min_sigma_static); static const float beam_max_sigma = max(beam_min_sigma, beam_max_sigma_static); static const float beam_spot_power = max(beam_spot_power_static, 0.0); static const float beam_min_shape = max(2.0, beam_min_shape_static); static const float beam_max_shape = max(beam_min_shape, beam_max_shape_static); static const float beam_shape_power = max(0.0, beam_shape_power_static); static const float beam_horiz_filter = clamp(beam_horiz_filter_static, 0.0, 2.0); static const float beam_horiz_sigma = max(FIX_ZERO(0.0), beam_horiz_sigma_static); static const float beam_horiz_linear_rgb_weight = clamp(beam_horiz_linear_rgb_weight_static, 0.0, 1.0); // Unpack static vector elements to match scalar uniforms: static const float convergence_offset_x_r = clamp(convergence_offsets_r_static.x, -4.0, 4.0); static const float convergence_offset_x_g = clamp(convergence_offsets_g_static.x, -4.0, 4.0); static const float convergence_offset_x_b = clamp(convergence_offsets_b_static.x, -4.0, 4.0); static const float convergence_offset_y_r = clamp(convergence_offsets_r_static.y, -4.0, 4.0); static const float convergence_offset_y_g = clamp(convergence_offsets_g_static.y, -4.0, 4.0); static const float convergence_offset_y_b = clamp(convergence_offsets_b_static.y, -4.0, 4.0); static const float mask_type = clamp(mask_type_static, 0.0, 2.0); static const float mask_sample_mode_desired = clamp(mask_sample_mode_static, 0.0, 2.0); static const float mask_specify_num_triads = clamp(mask_specify_num_triads_static, 0.0, 1.0); static const float mask_triad_size_desired = clamp(mask_triad_size_desired_static, 1.0, 18.0); static const float mask_num_triads_desired = clamp(mask_num_triads_desired_static, 342.0, 1920.0); static const float aa_subpixel_r_offset_x_runtime = clamp(aa_subpixel_r_offset_static.x, -0.5, 0.5); static const float aa_subpixel_r_offset_y_runtime = clamp(aa_subpixel_r_offset_static.y, -0.5, 0.5); static const float aa_cubic_c = aa_cubic_c_static; // Clamp to [0, 4]? static const float aa_gauss_sigma = max(FIX_ZERO(0.0), aa_gauss_sigma_static); // Clamp to [FIXZERO(0), 1]? static const float geom_mode_runtime = clamp(geom_mode_static, 0.0, 3.0); static const float geom_radius = max(1.0/(2.0*pi), geom_radius_static); // Clamp to [1/(2*pi), 1024]? static const float geom_view_dist = max(0.5, geom_view_dist_static); // Clamp to [0.5, 1024]? static const float geom_tilt_angle_x = clamp(geom_tilt_angle_static.x, -pi, pi); static const float geom_tilt_angle_y = clamp(geom_tilt_angle_static.y, -pi, pi); static const float geom_aspect_ratio_x = geom_aspect_ratio_static; // Force >= 1? static const float geom_aspect_ratio_y = 1.0; static const float geom_overscan_x = max(FIX_ZERO(0.0), geom_overscan_static.x); static const float geom_overscan_y = max(FIX_ZERO(0.0), geom_overscan_static.y); static const float border_size = clamp(border_size_static, 0.0, 0.5); // 0.5 reaches to image center static const float border_darkness = max(0.0, border_darkness_static); static const float border_compress = max(1.0, border_compress_static); // < 1.0 darkens whole image static const float interlace_bff = float(interlace_bff_static); static const float interlace_1080i = float(interlace_1080i_static); #else #pragma parameter crt_gamma "Simulated CRT Gamma" 2.5 1.0 5.0 0.025 #line 103 "bind-shader-params.h" #define crt_gamma global.crt_gamma #pragma parameter lcd_gamma "Your Display Gamma" 2.2 1.0 5.0 0.025 #line 105 "bind-shader-params.h" #define lcd_gamma global.lcd_gamma #pragma parameter levels_contrast "Contrast" 1.0 0.0 4.0 0.015625 #line 107 "bind-shader-params.h" #define levels_contrast global.levels_contrast #pragma parameter halation_weight "Halation Weight" 0.0 0.0 1.0 0.005 #line 109 "bind-shader-params.h" #pragma parameter diffusion_weight "Diffusion Weight" 0.075 0.0 1.0 0.005 #line 110 "bind-shader-params.h" #pragma parameter bloom_underestimate_levels "Bloom - Underestimate Levels" 0.8 0.0 5.0 0.01 #line 111 "bind-shader-params.h" #define bloom_underestimate_levels global.bloom_underestimate_levels #pragma parameter bloom_excess "Bloom - Excess" 0.0 0.0 1.0 0.005 #line 113 "bind-shader-params.h" #pragma parameter beam_min_sigma "Beam - Min Sigma" 0.02 0.005 1.0 0.005 #line 114 "bind-shader-params.h" #define beam_min_sigma global.beam_min_sigma #pragma parameter beam_max_sigma "Beam - Max Sigma" 0.3 0.005 1.0 0.005 #line 116 "bind-shader-params.h" #define beam_max_sigma global.beam_max_sigma #pragma parameter beam_spot_power "Beam - Spot Power" 0.33 0.01 16.0 0.01 #line 118 "bind-shader-params.h" #define beam_spot_power global.beam_spot_power #pragma parameter beam_min_shape "Beam - Min Shape" 2.0 2.0 32.0 0.1 #line 120 "bind-shader-params.h" #define beam_min_shape global.beam_min_shape #pragma parameter beam_max_shape "Beam - Max Shape" 4.0 2.0 32.0 0.1 #line 122 "bind-shader-params.h" #define beam_max_shape global.beam_max_shape #pragma parameter beam_shape_power "Beam - Shape Power" 0.25 0.01 16.0 0.01 #line 124 "bind-shader-params.h" #define beam_shape_power global.beam_shape_power #pragma parameter beam_horiz_filter "Beam - Horiz Filter" 0.0 0.0 2.0 1.0 #line 126 "bind-shader-params.h" #define beam_horiz_filter global.beam_horiz_filter #pragma parameter beam_horiz_sigma "Beam - Horiz Sigma" 0.35 0.0 0.67 0.005 #line 128 "bind-shader-params.h" #define beam_horiz_sigma global.beam_horiz_sigma #pragma parameter beam_horiz_linear_rgb_weight "Beam - Horiz Linear RGB Weight" 1.0 0.0 1.0 0.01 #line 130 "bind-shader-params.h" #pragma parameter convergence_offset_x_r "Convergence - Offset X Red" 0.0 -4.0 4.0 0.05 #line 131 "bind-shader-params.h" #define convergence_offset_x_r global.convergence_offset_x_r #pragma parameter convergence_offset_x_g "Convergence - Offset X Green" 0.0 -4.0 4.0 0.05 #line 133 "bind-shader-params.h" #define convergence_offset_x_g global.convergence_offset_x_g #pragma parameter convergence_offset_x_b "Convergence - Offset X Blue" 0.0 -4.0 4.0 0.05 #line 135 "bind-shader-params.h" #define convergence_offset_x_b global.convergence_offset_x_b #pragma parameter convergence_offset_y_r "Convergence - Offset Y Red" 0.0 -2.0 2.0 0.05 #line 137 "bind-shader-params.h" #define convergence_offset_y_r global.convergence_offset_y_r #pragma parameter convergence_offset_y_g "Convergence - Offset Y Green" 0.0 -2.0 2.0 0.05 #line 139 "bind-shader-params.h" #define convergence_offset_y_g global.convergence_offset_y_g #pragma parameter convergence_offset_y_b "Convergence - Offset Y Blue" 0.0 -2.0 2.0 0.05 #line 141 "bind-shader-params.h" #define convergence_offset_y_b global.convergence_offset_y_b #pragma parameter mask_type "Mask - Type" 1.0 0.0 2.0 1.0 #line 143 "bind-shader-params.h" #define mask_type global.mask_type #pragma parameter mask_sample_mode_desired "Mask - Sample Mode" 0.0 0.0 2.0 1.0 // Consider blocking mode 2. #line 145 "bind-shader-params.h" #define mask_sample_mode_desired global.mask_sample_mode_desired #pragma parameter mask_specify_num_triads "Mask - Specify Number of Triads" 0.0 0.0 1.0 1.0 #line 147 "bind-shader-params.h" #pragma parameter mask_triad_size_desired "Mask - Triad Size Desired" 3.0 1.0 18.0 0.125 #line 148 "bind-shader-params.h" #pragma parameter mask_num_triads_desired "Mask - Number of Triads Desired" 480.0 342.0 1920.0 1.0 #line 149 "bind-shader-params.h" #pragma parameter aa_subpixel_r_offset_x_runtime "AA - Subpixel R Offset X" -0.333333333 -0.333333333 0.333333333 0.333333333 #line 150 "bind-shader-params.h" #define aa_subpixel_r_offset_x_runtime global.aa_subpixel_r_offset_x_runtime #pragma parameter aa_subpixel_r_offset_y_runtime "AA - Subpixel R Offset Y" 0.0 -0.333333333 0.333333333 0.333333333 #line 152 "bind-shader-params.h" #define aa_subpixel_r_offset_y_runtime global.aa_subpixel_r_offset_y_runtime #pragma parameter aa_cubic_c "AA - Cubic Sharpness" 0.5 0.0 4.0 0.015625 #line 154 "bind-shader-params.h" #define aa_cubic_c global.aa_cubic_c #pragma parameter aa_gauss_sigma "AA - Gaussian Sigma" 0.5 0.0625 1.0 0.015625 #line 156 "bind-shader-params.h" #define aa_gauss_sigma global.aa_gauss_sigma #pragma parameter geom_mode_runtime "Geometry - Mode" 0.0 0.0 3.0 1.0 #line 158 "bind-shader-params.h" #define geom_mode_runtime global.geom_mode_runtime #pragma parameter geom_radius "Geometry - Radius" 2.0 0.16 1024.0 0.1 #line 160 "bind-shader-params.h" #define geom_radius global.geom_radius #pragma parameter geom_view_dist "Geometry - View Distance" 2.0 0.5 1024.0 0.25 #line 162 "bind-shader-params.h" #define geom_view_dist global.geom_view_dist #pragma parameter geom_tilt_angle_x "Geometry - Tilt Angle X" 0.0 -3.14159265 3.14159265 0.017453292519943295 #line 164 "bind-shader-params.h" #define geom_tilt_angle_x global.geom_tilt_angle_x #pragma parameter geom_tilt_angle_y "Geometry - Tilt Angle Y" 0.0 -3.14159265 3.14159265 0.017453292519943295 #line 166 "bind-shader-params.h" #define geom_tilt_angle_y global.geom_tilt_angle_y #pragma parameter geom_aspect_ratio_x "Geometry - Aspect Ratio X" 432.0 1.0 512.0 1.0 #line 168 "bind-shader-params.h" #define geom_aspect_ratio_x global.geom_aspect_ratio_x #pragma parameter geom_aspect_ratio_y "Geometry - Aspect Ratio Y" 329.0 1.0 512.0 1.0 #line 170 "bind-shader-params.h" #define geom_aspect_ratio_y global.geom_aspect_ratio_y #pragma parameter geom_overscan_x "Geometry - Overscan X" 1.0 0.00390625 4.0 0.00390625 #line 172 "bind-shader-params.h" #define geom_overscan_x global.geom_overscan_x #pragma parameter geom_overscan_y "Geometry - Overscan Y" 1.0 0.00390625 4.0 0.00390625 #line 174 "bind-shader-params.h" #define geom_overscan_y global.geom_overscan_y #pragma parameter border_size "Border - Size" 0.015 0.0000001 0.5 0.005 #line 176 "bind-shader-params.h" #define border_size global.border_size #pragma parameter border_darkness "Border - Darkness" 2.0 0.0 16.0 0.0625 #line 178 "bind-shader-params.h" #define border_darkness global.border_darkness #pragma parameter border_compress "Border - Compression" 2.5 1.0 64.0 0.0625 #line 180 "bind-shader-params.h" #define border_compress global.border_compress #pragma parameter interlace_bff "Interlacing - Bottom Field First" 0.0 0.0 1.0 1.0 #line 182 "bind-shader-params.h" //#define interlace_bff global.interlace_bff #pragma parameter interlace_1080i "Interlace - Detect 1080i" 0.0 0.0 1.0 1.0 #line 184 "bind-shader-params.h" #define interlace_1080i global.interlace_1080i #endif #line 186 "bind-shader-params.h" // Provide accessors for vector constants that pack scalar uniforms: inline 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; } inline float2 get_geom_overscan_vector() { return float2(geom_overscan_x, geom_overscan_y); } inline float2 get_geom_tilt_angle_vector() { return float2(geom_tilt_angle_x, geom_tilt_angle_y); } inline float3 get_convergence_offsets_x_vector() { return float3(convergence_offset_x_r, convergence_offset_x_g, convergence_offset_x_b); } inline float3 get_convergence_offsets_y_vector() { return float3(convergence_offset_y_r, convergence_offset_y_g, convergence_offset_y_b); } inline float2 get_convergence_offsets_r_vector() { return float2(convergence_offset_x_r, convergence_offset_y_r); } inline float2 get_convergence_offsets_g_vector() { return float2(convergence_offset_x_g, convergence_offset_y_g); } inline float2 get_convergence_offsets_b_vector() { return float2(convergence_offset_x_b, convergence_offset_y_b); } inline float2 get_aa_subpixel_r_offset() { #ifdef RUNTIME_ANTIALIAS_WEIGHTS #ifdef RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS // WARNING: THIS IS EXTREMELY EXPENSIVE. return float2(aa_subpixel_r_offset_x_runtime, aa_subpixel_r_offset_y_runtime); #else return aa_subpixel_r_offset_static; #endif #line 246 "bind-shader-params.h" #else return aa_subpixel_r_offset_static; #endif #line 249 "bind-shader-params.h" } // Provide accessors settings which still need "cooking:" inline 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; return mask_type < 0.5 ? mask_grille_amplify : mask_type < 1.5 ? mask_slot_amplify : mask_shadow_amplify; } inline float get_mask_sample_mode() { #ifdef RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE return mask_sample_mode_desired; #else return clamp(mask_sample_mode_desired, 1.0, 2.0); #endif #line 270 "bind-shader-params.h" #else #ifdef PHOSPHOR_MASK_MANUALLY_RESIZE return mask_sample_mode_static; #else return clamp(mask_sample_mode_static, 1.0, 2.0); #endif #line 276 "bind-shader-params.h" #endif #line 277 "bind-shader-params.h" } #endif // BIND_SHADER_PARAMS_H #line 280 "bind-shader-params.h" #line 27 "geometry-functions.h" //////////////////////////// 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. 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; } 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); } inline 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); } inline 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); } inline 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); } float3 get_ideal_global_eye_pos() { return float3 (1.0, 1.0, 1.0); } 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)) * 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); // 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. #ifdef 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 #line 470 "geometry-functions.h" #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 #line 499 "geometry-functions.h" 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) - video_uv) * geom_aspect; const float2 border_penetration = max(float2(border_size) - edge_dists, float2(0.0)); const float penetration_ratio = length(border_penetration)/border_size; 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 #line 528 "geometry-functions.h" #line 109 "crt-royale-geometry-aa-last-pass.h" /////////////////////////////////// HELPERS ////////////////////////////////// float2x2 mul_scale(float2 scale, float2x2 matrix) { //float2x2 scale_matrix = float2x2(scale.x, 0.0, 0.0, scale.y); //return mul(scale_matrix, matrix); return float2x2(float4(matrix[0][0],matrix[0][1],matrix[1][0],matrix[1][1]) * scale.xxyy); } #line 199 "crt-royale-geometry-aa-last-pass.h" layout(location = 0) in vec2 tex_uv; layout(location = 1) in vec4 video_and_texture_size_inv; layout(location = 2) in vec2 output_size_inv; layout(location = 3) in vec3 eye_pos_local; layout(location = 4) in vec4 geom_aspect_and_overscan; layout(location = 5) in vec3 global_to_local_row0; layout(location = 6) in vec3 global_to_local_row1; layout(location = 7) in vec3 global_to_local_row2; layout(location = 0) out vec4 FragColor; layout(set = 0, binding = 2) uniform sampler2D Source; #define input_texture Source void main() { // Localize some parameters: const float2 geom_aspect = geom_aspect_and_overscan.xy; const float2 geom_overscan = geom_aspect_and_overscan.zw; const float2 video_size_inv = video_and_texture_size_inv.xy; const float2 texture_size_inv = video_and_texture_size_inv.zw; //const float2 output_size_inv = output_size_inv; #ifdef 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 #line 225 "crt-royale-geometry-aa-last-pass.h" #ifdef RUNTIME_GEOMETRY_MODE const float geom_mode = geom_mode_runtime; #else static const float geom_mode = geom_mode_static; #endif #line 230 "crt-royale-geometry-aa-last-pass.h" // 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 = tex_uv * (IN.texture_size * video_size_inv); 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 * (IN.video_size * texture_size_inv); // Get a matrix transforming pixel vectors to tex_uv vectors: const float2x2 pixel_to_tex_uv = mul_scale(IN.video_size * texture_size_inv / geom_aspect_and_overscan.zw, pixel_to_video_uv); // Sample! Skip antialiasing if aa_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()); const bool need_subpixel_aa = abs_aa_r_offset.x + abs_aa_r_offset.y > 0.0; float3 color; /* //TODO/FIXME: This block is what causes the black screen when geom_mode >= 1.0 if(aa_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.): color = tex2Daa(input_texture, tex_uv, pixel_to_tex_uv, float(IN.frame_count)); } else */if(aa_level > 0.5 && need_subpixel_aa) { // Sample at each subpixel location: color = tex2Daa_subpixel_weights_only( input_texture, tex_uv, pixel_to_tex_uv); } else { color = tex2D_linearize(input_texture, tex_uv).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 = color * border_dim_factor; FragColor = encode_output(float4(final_color, 1.0)); } #line 3 "crt-royale-geometry-aa-last-pass.slang"