Duckstation/data/resources/shaders/reshade/Shaders/crt-royale/lib/derived-settings-and-constants.fxh

#ifndef _DERIVED_SETTINGS_AND_CONSTANTS_H
#define _DERIVED_SETTINGS_AND_CONSTANTS_H

#include "helper-functions-and-macros.fxh"
#include "user-settings.fxh"

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

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


/////////////////////////////////  DESCRIPTION  ////////////////////////////////

//  These macros and constants can be used across the whole codebase.
//  Unlike the values in user-settings.cgh, end users shouldn't modify these.


///////////////////////////////  BEGIN INCLUDES  ///////////////////////////////

//#include "../user-settings.h"

//#include "user-cgp-constants.h"

/////////////////////////   BEGIN USER-CGP-CONSTANTS   /////////////////////////

#ifndef _USER_CGP_CONSTANTS_H
#define _USER_CGP_CONSTANTS_H

//  IMPORTANT:
//  These constants MUST be set appropriately for the settings in crt-royale.cgp
//  (or whatever related .cgp file you're using).  If they aren't, you're likely
//  to get artifacts, the wrong phosphor mask size, etc.  I wish these could be
//  set directly in the .cgp file to make things easier, but...they can't.

//  PASS SCALES AND RELATED CONSTANTS:
//  Copy the absolute scale_x for BLOOM_APPROX.  There are two major versions of
//  this shader: One does a viewport-scale bloom, and the other skips it.  The
//  latter benefits from a higher bloom_approx_scale_x, so save both separately:
static const float bloom_approx_scale_x = 4.0 / 3.0;
static const float max_viewport_size_x = 1080.0*1024.0*(4.0/3.0);
static const float bloom_diff_thresh_ = 1.0/256.0;

static const float bloom_approx_size_x = 320.0;
static const float bloom_approx_size_x_for_fake = 400.0;
//  Copy the viewport-relative scales of the phosphor mask resize passes
//  (MASK_RESIZE and the pass immediately preceding it):
static const float2 mask_resize_viewport_scale = float2(0.0625, 0.0625);
//  Copy the geom_max_aspect_ratio used to calculate the MASK_RESIZE scales, etc.:
static const float geom_max_aspect_ratio = 4.0/3.0;

//  PHOSPHOR MASK TEXTURE CONSTANTS:
//  Set the following constants to reflect the properties of the phosphor mask
//  texture named in crt-royale.cgp.  The shader optionally resizes a mask tile
//  based on user settings, then repeats a single tile until filling the screen.
//  The shader must know the input texture size (default 64x64), and to manually
//  resize, it must also know the horizontal triads per tile (default 8).
static const float2 mask_texture_small_size = float2(64.0, 64.0);
static const float2 mask_texture_large_size = float2(512.0, 512.0);
static const float mask_triads_per_tile = 8.0;
//  We need the average brightness of the phosphor mask to compensate for the
//  dimming it causes.  The following four values are roughly correct for the
//  masks included with the shader.  Update the value for any LUT texture you
//  change.  [Un]comment "#define PHOSPHOR_MASK_GRILLE14" depending on whether
//  the loaded aperture grille uses 14-pixel or 15-pixel stripes (default 15).
// #ifndef PHOSPHOR_MASK_GRILLE14
//     #define PHOSPHOR_MASK_GRILLE14 0
// #endif
static const float mask_grille14_avg_color = 50.6666666/255.0;
    //  TileableLinearApertureGrille14Wide7d33Spacing*.png
    //  TileableLinearApertureGrille14Wide10And6Spacing*.png
static const float mask_grille15_avg_color = 53.0/255.0;
    //  TileableLinearApertureGrille15Wide6d33Spacing*.png
    //  TileableLinearApertureGrille15Wide8And5d5Spacing*.png
static const float mask_slot_avg_color = 46.0/255.0;
    //  TileableLinearSlotMask15Wide9And4d5Horizontal8VerticalSpacing*.png
    //  TileableLinearSlotMaskTall15Wide9And4d5Horizontal9d14VerticalSpacing*.png
static const float mask_shadow_avg_color = 41.0/255.0;
    //  TileableLinearShadowMask*.png
    //  TileableLinearShadowMaskEDP*.png

// #if PHOSPHOR_MASK_GRILLE14
//     static const float mask_grille_avg_color = mask_grille14_avg_color;
// #else
    static const float mask_grille_avg_color = mask_grille15_avg_color;
// #endif


#endif  //  _USER_CGP_CONSTANTS_H

//////////////////////////   END USER-CGP-CONSTANTS   //////////////////////////

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

///////////////////////////////  FIXED SETTINGS  ///////////////////////////////



#define _SIMULATE_CRT_ON_LCD 1
#define _SIMULATE_GBA_ON_LCD 2
#define _SIMULATE_LCD_ON_CRT 3
#define _SIMULATE_GBA_ON_CRT 4

//  Ensure the first pass decodes CRT gamma and the last encodes LCD gamma.
#define GAMMA_SIMULATION_MODE _SIMULATE_CRT_ON_LCD

//  Manually tiling a manually resized texture creates texture coord derivative
//  discontinuities and confuses anisotropic filtering, causing discolored tile
//  seams in the phosphor mask.  Workarounds:
//  a.) Using tex2Dlod disables anisotropic filtering for tiled masks.  It's
//      downgraded to tex2Dbias without _DRIVERS_ALLOW_TEX2DLOD #defined and
//      disabled without _DRIVERS_ALLOW_TEX2DBIAS #defined either.
//  b.) "Tile flat twice" requires drawing two full tiles without border padding
//      to the resized mask FBO, and it's incompatible with same-pass curvature.
//      (Same-pass curvature isn't used but could be in the future...maybe.)
//  c.) "Fix discontinuities" requires derivatives and drawing one tile with
//      border padding to the resized mask FBO, but it works with same-pass
//      curvature.  It's disabled without _DRIVERS_ALLOW_DERIVATIVES #defined.
//  Precedence: a, then, b, then c (if multiple strategies are #defined).
// #ifndef ANISOTROPIC_TILING_COMPAT_TEX2DLOD
//     #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD 1              //  129.7 FPS, 4x, flat; 101.8 at fullscreen
// #endif
// #ifndef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
//     #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE 1       //  128.1 FPS, 4x, flat; 101.5 at fullscreen
// #endif
// #ifndef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//     #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 1   //  124.4 FPS, 4x, flat; 97.4 at fullscreen
// #endif
//  Also, manually resampling the phosphor mask is slightly blurrier with
//  anisotropic filtering.  (Resampling with mipmapping is even worse: It
//  creates artifacts, but only with the fully bloomed shader.)  The difference
//  is subtle with small triads, but you can fix it for a small cost.
// #ifndef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
//     #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD 0
// #endif


//////////////////////////////  DERIVED SETTINGS  //////////////////////////////

//  Intel HD 4000 GPU's can't handle manual mask resizing (for now), setting the
//  geometry mode at runtime, or a 4x4 true Gaussian resize.  Disable
//  incompatible settings ASAP.  (_INTEGRATED_GRAPHICS_COMPATIBILITY_MODE may be
//  #defined by either user-settings.h or a wrapper .cg that #includes the
//  current .cg pass.)
#if _INTEGRATED_GRAPHICS_COMPATIBILITY_MODE
    #if _PHOSPHOR_MASK_MANUALLY_RESIZE
        #undef _PHOSPHOR_MASK_MANUALLY_RESIZE
        #define _PHOSPHOR_MASK_MANUALLY_RESIZE 0
    #endif
    #if _RUNTIME_GEOMETRY_MODE
        #undef _RUNTIME_GEOMETRY_MODE
        #define _RUNTIME_GEOMETRY_MODE 0
    #endif
    //  Mode 2 (4x4 Gaussian resize) won't work, and mode 1 (3x3 blur) is
    //  inferior in most cases, so replace 2.0 with 0.0:
    static const float bloom_approx_filter = macro_cond(
        bloom_approx_filter_static > 1.5,
        0.0,
        bloom_approx_filter_static
    );
#else
    static const float bloom_approx_filter = bloom_approx_filter_static;
#endif

//  Disable slow runtime paths if static parameters are used.  Most of these
//  won't be a problem anyway once the params are disabled, but some will.
#if !_RUNTIME_SHADER_PARAMS_ENABLE
    #if _RUNTIME_PHOSPHOR_BLOOM_SIGMA
        #undef _RUNTIME_PHOSPHOR_BLOOM_SIGMA
        #define _RUNTIME_PHOSPHOR_BLOOM_SIGMA 0
    #endif
    #if _RUNTIME_ANTIALIAS_WEIGHTS
        #undef _RUNTIME_ANTIALIAS_WEIGHTS
        #define _RUNTIME_ANTIALIAS_WEIGHTS 0
    #endif
    #if _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
        #undef _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
        #define _RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS 0
    #endif
    #if _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
        #undef _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
        #define _RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE 0
    #endif
    #if _RUNTIME_GEOMETRY_TILT
        #undef _RUNTIME_GEOMETRY_TILT
        #define _RUNTIME_GEOMETRY_TILT 0
    #endif
    #if _RUNTIME_GEOMETRY_MODE
        #undef _RUNTIME_GEOMETRY_MODE
        #define _RUNTIME_GEOMETRY_MODE 0
    #endif
    // #if FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
    //     #undef FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
    //     #define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT 0
    // #endif
#endif

//  Make tex2Dbias a backup for tex2Dlod for wider compatibility.
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
//     #define ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
// #endif
// #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
//     #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
// #endif
//  Rule out unavailable anisotropic compatibility strategies:
#if !_DRIVERS_ALLOW_DERIVATIVES
    // #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
    //     #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
    //     #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
    // #endif
#endif
// #if !_DRIVERS_ALLOW_TEX2DLOD
    // #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
    //     #undef ANISOTROPIC_TILING_COMPAT_TEX2DLOD
    //     #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD 0
    // #endif
    // #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
    //     #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
    //     #define ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD 0
    // #endif
    // #ifdef ANTIALIAS_DISABLE_ANISOTROPIC
    //     #undef ANTIALIAS_DISABLE_ANISOTROPIC
    // #endif
// #endif
// #if !_DRIVERS_ALLOW_TEX2DBIAS
    // #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
    //     #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
    // #endif
    // #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
    //     #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
    // #endif
// #endif
//  Prioritize anisotropic tiling compatibility strategies by performance and
//  disable unused strategies.  This concentrates all the nesting in one place.
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
//     #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
//         #undef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
//     #endif
//     #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
//         #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
//         #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE 0
//     #endif
//     #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//         #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//         #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
//     #endif
//     #else
//     #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
//         #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
//             #undef ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
//             #define ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE 0
//         #endif
//         #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//             #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//             #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
//         #endif
//     #else
//         //  ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE is only compatible with
//         //  flat texture coords in the same pass, but that's all we use.
//         #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
//             #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//                 #undef ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//                 #define ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES 0
//             #endif
//         #endif
//     #endif
// #endif
//  The tex2Dlod and tex2Dbias strategies share a lot in common, and we can
//  reduce some #ifdef nesting in the next section by essentially OR'ing them:
// #if ANISOTROPIC_TILING_COMPAT_TEX2DLOD
//     #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY
// #endif
// #ifdef ANISOTROPIC_TILING_COMPAT_TEX2DBIAS
//     #define ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY
// #endif
//  Prioritize anisotropic resampling compatibility strategies the same way:
// #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
//     #ifdef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
//         #undef ANISOTROPIC_RESAMPLING_COMPAT_TEX2DBIAS
//     #endif
// #endif


///////////////////////  DERIVED PHOSPHOR MASK CONSTANTS  //////////////////////

//  If we can use the large mipmapped LUT without mipmapping artifacts, we
//  should: It gives us more options for using fewer samples.
// #if USE_LARGE_PHOSPHOR_MASK
    // #if ANISOTROPIC_RESAMPLING_COMPAT_TEX2DLOD
    //     //  TODO: Take advantage of this!
    //     #define PHOSPHOR_MASK_RESIZE_MIPMAPPED_LUT
    //     static const float2 mask_resize_src_lut_size = mask_texture_large_size;
    // #else
static const float2 mask_resize_src_lut_size = mask_texture_large_size;
    // #endif
// #else
//     static const float2 mask_resize_src_lut_size = mask_texture_small_size;
// #endif

static const float tile_aspect_inv = mask_resize_src_lut_size.y/mask_resize_src_lut_size.x;


//  tex2D's sampler2D parameter MUST be a uniform global, a uniform input to
//  main_fragment, or a static alias of one of the above.  This makes it hard
//  to select the phosphor mask at runtime: We can't even assign to a uniform
//  global in the vertex shader or select a sampler2D in the vertex shader and
//  pass it to the fragment shader (even with explicit TEXUNIT# bindings),
//  because it just gives us the input texture or a black screen.  However, we
//  can get around these limitations by calling tex2D three times with different
//  uniform samplers (or resizing the phosphor mask three times altogether).
//  With dynamic branches, we can process only one of these branches on top of
//  quickly discarding fragments we don't need (cgc seems able to overcome
//  limigations around dependent texture fetches inside of branches).  Without
//  dynamic branches, we have to process every branch for every fragment...which
//  is slower.  Runtime sampling mode selection is slower without dynamic
//  branches as well.  Let the user's static #defines decide if it's worth it.
#if _DRIVERS_ALLOW_DYNAMIC_BRANCHES
    #define _RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
// #else
    // #if FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
    //     #define _RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT
    // #endif
#endif

//  We need to render some minimum number of tiles in the resize passes.
//  We need at least 1.0 just to repeat a single tile, and we need extra
//  padding beyond that for anisotropic filtering, discontinuitity fixing,
//  antialiasing, same-pass curvature (not currently used), etc.  First
//  determine how many border texels and tiles we need, based on how the result
//  will be sampled:
#ifdef GEOMETRY_EARLY
    static const float max_subpixel_offset = aa_subpixel_r_offset_static.x;
    //  Most antialiasing filters have a base radius of 4.0 pixels:
    static const float max_aa_base_pixel_border = 4.0 +
        max_subpixel_offset;
#else
    static const float max_aa_base_pixel_border = 0.0;
#endif
//  Anisotropic filtering adds about 0.5 to the pixel border:
// #ifndef ANISOTROPIC_TILING_COMPAT_TEX2DLOD_FAMILY
static const float max_aniso_pixel_border = max_aa_base_pixel_border + 0.5;
// #else
//     static const float max_aniso_pixel_border = max_aa_base_pixel_border;
// #endif
//  Fixing discontinuities adds 1.0 more to the pixel border:
// #if ANISOTROPIC_TILING_COMPAT_FIX_DISCONTINUITIES
//     static const float max_tiled_pixel_border = max_aniso_pixel_border + 1.0;
// #else
    static const float max_tiled_pixel_border = max_aniso_pixel_border;
// #endif
//  Convert the pixel border to an integer texel border.  Assume same-pass
//  curvature about triples the texel frequency:
#ifdef GEOMETRY_EARLY
    #define max_mask_texel_border macro_ceil(max_tiled_pixel_border * 3.0f)
#else
    #define max_mask_texel_border macro_ceil(max_tiled_pixel_border)
#endif
//  Convert the texel border to a tile border using worst-case assumptions:
static const float max_mask_tile_border = max_mask_texel_border/
(mask_min_allowed_triad_size * mask_triads_per_tile);

//  Finally, set the number of resized tiles to render to MASK_RESIZE, and set
//  the starting texel (inside borders) for sampling it.
#ifndef GEOMETRY_EARLY
    // #if ANISOTROPIC_TILING_COMPAT_TILE_FLAT_TWICE
        //  Special case: Render two tiles without borders.  Anisotropic
        //  filtering doesn't seem to be a problem here.
        // static const float mask_resize_num_tiles = 1.0 + 1.0;
        // static const float mask_start_texels = 0.0;
    // #else
    static const float mask_resize_num_tiles = 1.0 + 2.0 * max_mask_tile_border;
    static const float mask_start_texels = max_mask_texel_border;
    // #endif
#else
    static const float mask_resize_num_tiles = 1.0 + 2.0*max_mask_tile_border;
    static const float mask_start_texels = max_mask_texel_border;
#endif

//  We have to fit mask_resize_num_tiles into an FBO with a viewport scale of
//  mask_resize_viewport_scale.  This limits the maximum final triad size.
//  Estimate the minimum number of triads we can split the screen into in each
//  dimension (we'll be as correct as mask_resize_viewport_scale is):
static const float mask_resize_num_triads = mask_resize_num_tiles * mask_triads_per_tile;
static const float2 min_allowed_viewport_triads =
float2(mask_resize_num_triads, mask_resize_num_triads) / mask_resize_viewport_scale;



#endif  //  _DERIVED_SETTINGS_AND_CONSTANTS_H