mirror of
https://github.com/italicsjenga/slang-shaders.git
synced 2024-11-29 02:41:32 +11:00
803 lines
46 KiB
PHP
803 lines
46 KiB
PHP
/*
|
|
Mega Bezel - Creates a graphic treatment for the game play area to give a retro feel
|
|
Copyright (C) 2019-2021 HyperspaceMadness - HyperspaceMadness@outlook.com
|
|
|
|
Incorporates much great feedback from the libretro forum, and thanks
|
|
to Hunterk who helped me get started
|
|
|
|
See more at the libretro forum
|
|
https://forums.libretro.com/t/hsm-mega-bezel-reflection-shader-feedback-and-updates
|
|
|
|
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 3 of the License, or
|
|
(at your option) 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, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
// Screen Scale Required Parameters
|
|
#pragma parameter HSM_MEGA_BEZEL_TITLE "[ --- HSM MEGA BEZEL V 1.0.001 2022-06-24 Rev 1 --- ]" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_RESOLUTION_DEBUG_ON " Show Resolution Info" 0 0 1 1
|
|
float HSM_RESOLUTION_DEBUG_ON = global.HSM_RESOLUTION_DEBUG_ON;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// CRT Layer
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_CRT_TITLE "[ CRT BRIGHTNESS & GAMMA ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter GAMMA_INPUT " Gamma In (Game Embedded Gamma) Def 2.4" 2.4 0.1 5 0.05
|
|
#define GAMMA_INPUT global.GAMMA_INPUT
|
|
|
|
#pragma parameter gamma_out " Gamma Out (Electron Gun Gamma) Def 2.4" 2.4 0.1 5 0.05
|
|
#define HSM_GAMMA_OUT_CRT global.gamma_out
|
|
|
|
#pragma parameter post_br " Post CRT Brightness" 1 0.01 5 0.01
|
|
#define HSM_POST_CRT_BRIGHTNESS global.post_br
|
|
|
|
#pragma parameter post_br_affect_black_level " Post CRT Brightness Affects Grade Black Level" 100 0 100 10
|
|
#define HSM_POST_CRT_BRIGHTNESS_AFFECT_BLACK_LEVEL global.post_br_affect_black_level / 100
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Global Graphics Caching
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_GLOBAL_GRAPHICS_CACHE_TITLE "[ GRAPHICS CACHE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_CACHE_GRAPHICS_ON " Cache Graphics: OFF | ON" 1 0 1 1
|
|
float HSM_CACHE_GRAPHICS_ON = global.HSM_CACHE_GRAPHICS_ON;
|
|
|
|
#pragma parameter HSM_CACHE_UPDATE_INDICATOR_MODE " Cache Update Indicator: OFF | ON | ONLY WHEN CACHE OFF" 2 0 2 1
|
|
float HSM_CACHE_UPDATE_INDICATOR_MODE = global.HSM_CACHE_UPDATE_INDICATOR_MODE;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Global Graphics Brightness
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_GLOBAL_GRAPHICS_BRIGHTNESS_TITLE "[ GRAPHICS GLOBAL BRIGHTNESS ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_GLOBAL_GRAPHICS_BRIGHTNESS " Graphics Brightness" 100 0 500 1
|
|
float HSM_GLOBAL_GRAPHICS_BRIGHTNESS = global.HSM_GLOBAL_GRAPHICS_BRIGHTNESS / 100;
|
|
|
|
#pragma parameter HSM_STATIC_LAYERS_GAMMA " Graphics Gamma Adjust" 1 0.01 5 0.01
|
|
float HSM_STATIC_LAYERS_GAMMA = global.HSM_STATIC_LAYERS_GAMMA;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// NIGHT LIGHTING
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_TITLE "[ AMBIENT LIGHTING ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_OPACITY " Opacity" 0 0 100 1
|
|
float HSM_AMBIENT_LIGHTING_OPACITY = global.HSM_AMBIENT_LIGHTING_OPACITY / 100;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_HUE " Hue" 0 -180 180 1
|
|
float HSM_AMBIENT_LIGHTING_HUE = global.HSM_AMBIENT_LIGHTING_HUE / 360;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_SATURATION " Saturation" 100 0 300 1
|
|
float HSM_AMBIENT_LIGHTING_SATURATION = global.HSM_AMBIENT_LIGHTING_SATURATION / 100;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_VALUE " Value" 100 0 400 1
|
|
float HSM_AMBIENT_LIGHTING_VALUE = global.HSM_AMBIENT_LIGHTING_VALUE / 100;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_SCALE_MODE " Scale Mode - VIEW WITH ZOOM | FULL" 1 0 1 1
|
|
float HSM_AMBIENT_LIGHTING_SCALE_MODE = global.HSM_AMBIENT_LIGHTING_SCALE_MODE;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_SCALE " Scale Offset" 100 10 1000 1
|
|
float HSM_AMBIENT_LIGHTING_SCALE = global.HSM_AMBIENT_LIGHTING_SCALE / 100;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_ROTATE " Rotate" 0 0 1 1
|
|
float HSM_AMBIENT_LIGHTING_ROTATE = global.HSM_AMBIENT_LIGHTING_ROTATE;
|
|
|
|
#pragma parameter HSM_AMBIENT_LIGHTING_MIRROR_HORZ " Mirror Horizontal" 0 0 1 1
|
|
float HSM_AMBIENT_LIGHTING_MIRROR_HORZ = global.HSM_AMBIENT_LIGHTING_MIRROR_HORZ;
|
|
|
|
// Commented out because I don't think anyone is using this
|
|
// #pragma parameter HSM_AMBIENT_LIGHTING_DITHERING_SAMPLES " Dithering Noise Samples (Reduces Banding)" 0 0 10 1
|
|
// float HSM_AMBIENT_LIGHTING_DITHERING_SAMPLES = global.HSM_AMBIENT_LIGHTING_DITHERING_SAMPLES;
|
|
float HSM_AMBIENT_LIGHTING_DITHERING_SAMPLES = 0;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Zoom & Pan
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_VIEWPORT_ZOOM_TITLE "[ VIEWPORT ZOOM ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_VIEWPORT_ZOOM " Viewport Zoom" 100 10 500 0.2
|
|
float HSM_VIEWPORT_ZOOM = global.HSM_VIEWPORT_ZOOM / 100;
|
|
|
|
#pragma parameter HSM_VIEWPORT_ZOOM_MASK " Zoom CRT Mask" 0 0 1 1
|
|
float HSM_VIEWPORT_ZOOM_MASK = global.HSM_VIEWPORT_ZOOM_MASK;
|
|
|
|
#pragma parameter HSM_VIEWPORT_POSITION_X " Viewport Position X" 0 -500 500 1
|
|
float HSM_VIEWPORT_POSITION_X = -1 * global.HSM_VIEWPORT_POSITION_X / 1000;
|
|
|
|
#pragma parameter HSM_VIEWPORT_POSITION_Y " Viewport Position Y" 0 -500 500 1
|
|
float HSM_VIEWPORT_POSITION_Y = -1 * global.HSM_VIEWPORT_POSITION_Y / 1000;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// FLIP & ROTATE
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_FLIP_ROTATE_TITLE "[ FLIP & ROTATE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_FLIP_VIEWPORT_VERTICAL " Flip Viewport Vertical" 0 0 1 1
|
|
float HSM_FLIP_VIEWPORT_VERTICAL = -(global.HSM_FLIP_VIEWPORT_VERTICAL * 2 - 1);
|
|
|
|
#pragma parameter HSM_FLIP_VIEWPORT_HORIZONTAL " Flip Viewport Horizontal" 0 0 1 1
|
|
float HSM_FLIP_VIEWPORT_HORIZONTAL = -(global.HSM_FLIP_VIEWPORT_HORIZONTAL * 2 - 1);
|
|
|
|
#pragma parameter HSM_FLIP_CORE_VERTICAL " Flip Core Image Vertical" 0 0 1 1
|
|
// float HSM_FLIP_CORE_VERTICAL = global.HSM_FLIP_CORE_VERTICAL;
|
|
float HSM_FLIP_CORE_VERTICAL = -(global.HSM_FLIP_CORE_VERTICAL * 2 - 1);
|
|
|
|
#pragma parameter HSM_FLIP_CORE_HORIZONTAL " Flip Core Image Horizontal" 0 0 1 1
|
|
// float HSM_FLIP_CORE_HORIZONTAL = global.HSM_FLIP_CORE_HORIZONTAL;
|
|
float HSM_FLIP_CORE_HORIZONTAL = -(global.HSM_FLIP_CORE_HORIZONTAL * 2 - 1);
|
|
|
|
#pragma parameter HSM_ROTATE_CORE_IMAGE " Rotate CRT Tube" 0 0 1 1
|
|
float HSM_ROTATE_CORE_IMAGE = global.HSM_ROTATE_CORE_IMAGE;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// ASPECT RATIO
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_ASPECT_RATIO_TITLE "[ ASPECT RATIO ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_ASPECT_RATIO_ORIENTATION " Orientation - Auto | Horizontal | Vertical" 0 0 2 1
|
|
float HSM_ASPECT_RATIO_ORIENTATION = global.HSM_ASPECT_RATIO_ORIENTATION;
|
|
|
|
#pragma parameter HSM_ASPECT_RATIO_MODE " Type - Auto | Explicit | 4:3 | 3:2 | 16:9 | PAR | Full" 0 0 6 1
|
|
float HSM_ASPECT_RATIO_MODE = global.HSM_ASPECT_RATIO_MODE;
|
|
|
|
#pragma parameter HSM_ASPECT_RATIO_EXPLICIT " Explicit Aspect Ratio (Also Auto Ratio Fallback)" 1.3333 0 8 0.002
|
|
float HSM_ASPECT_RATIO_EXPLICIT = global.HSM_ASPECT_RATIO_EXPLICIT;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// SCALING
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SCALING_TITLE "[ CRT SCREEN SCALING GENERAL ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_INT_SCALE_MODE " Integer Scale Mode - OFF | ShortAxis | BothAxes" 0 0 2 1
|
|
#define HSM_INT_SCALE_MODE global.HSM_INT_SCALE_MODE
|
|
|
|
#pragma parameter HSM_VERTICAL_PRESET " Preset is for Monitor Portrait Mode (Smaller CRT Screen)" 0 0 1 1
|
|
float HSM_VERTICAL_PRESET = global.HSM_VERTICAL_PRESET;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Integer Scale
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
#pragma parameter HSM_INTEGER_SCALE_TITLE "[ INTEGER SCALE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_INT_SCALE_MAX_HEIGHT " Base Integer Scale Max Height %" 89 60 140 0.5
|
|
float HSM_INT_SCALE_MAX_HEIGHT = global.HSM_INT_SCALE_MAX_HEIGHT / 100;
|
|
|
|
#pragma parameter HSM_INT_SCALE_MULTIPLE_OFFSET " Integer Scale Multiple Offset" 0 -20 20 1
|
|
#define HSM_INT_SCALE_MULTIPLE_OFFSET global.HSM_INT_SCALE_MULTIPLE_OFFSET
|
|
|
|
#pragma parameter HSM_INT_SCALE_MULTIPLE_OFFSET_LONG " Integer Scale Multiple Offset on Long Axis" 0 -20 20 1
|
|
#define HSM_INT_SCALE_MULTIPLE_OFFSET_LONG global.HSM_INT_SCALE_MULTIPLE_OFFSET_LONG
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Non-Integer Scale
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
#pragma parameter HSM_NON_INTEGER_SCALE_PERCENT_TITLE "[ NON-INTEGER SCALE PERCENT ]:" 0 0 0.01 0.01
|
|
|
|
// Non integer scale is set to 82.97 so that cores which output 224px will have integer scale by default
|
|
// This is 8x integer scale at 3840x2160 and 6x integer scale at 1920x1080
|
|
#pragma parameter HSM_NON_INTEGER_SCALE " Non-Integer Scale %" 82.97 1 200 0.2
|
|
float HSM_NON_INTEGER_SCALE = global.HSM_NON_INTEGER_SCALE / 100;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Physical Size
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
#pragma parameter HSM_PHYSICAL_SIZE_TITLE "[ NON-INTEGER - PHYSICAL SIZES ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_USE_PHYSICAL_SIZE_FOR_NON_INTEGER " Use Physical Monitor and Tube Sizes for Non-Integer" 0 0 1 1
|
|
float HSM_USE_PHYSICAL_SIZE_FOR_NON_INTEGER = global.HSM_USE_PHYSICAL_SIZE_FOR_NON_INTEGER;
|
|
|
|
#pragma parameter HSM_PHYSICAL_MONITOR_ASPECT_RATIO " Your Monitor's Aspect Ratio" 1.77 0.25 5 0.01
|
|
float HSM_PHYSICAL_MONITOR_ASPECT_RATIO = global.HSM_PHYSICAL_MONITOR_ASPECT_RATIO;
|
|
|
|
#pragma parameter HSM_PHYSICAL_MONITOR_DIAGONAL_SIZE " Your Monitor's Size (Diagonal)" 27 1 100 0.1
|
|
float HSM_PHYSICAL_MONITOR_DIAGONAL_SIZE = global.HSM_PHYSICAL_MONITOR_DIAGONAL_SIZE;
|
|
|
|
#pragma parameter HSM_PHYSICAL_SIM_TUBE_DIAGONAL_SIZE " Simulated Tube Size (Diagonal)" 18.1 1 100 0.1
|
|
float HSM_PHYSICAL_SIM_TUBE_DIAGONAL_SIZE = global.HSM_PHYSICAL_SIM_TUBE_DIAGONAL_SIZE;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Automatic Scale & Position
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_AUTOMATIC_SCREEN_SCALE_TITLE "[ NON-INTEGER - AUTOMATIC SCREEN SCALE & PLACEMENT ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_USE_IMAGE_FOR_PLACEMENT " Use Image For Automatic Placement (Scale and Y Pos)" 0 0 1 1
|
|
float HSM_USE_IMAGE_FOR_PLACEMENT = global.HSM_USE_IMAGE_FOR_PLACEMENT;
|
|
|
|
#pragma parameter HSM_PLACEMENT_IMAGE_USE_HORIZONTAL " Auto Place Horizontal (X Pos)" 0 0 1 1
|
|
float HSM_PLACEMENT_IMAGE_USE_HORIZONTAL = global.HSM_PLACEMENT_IMAGE_USE_HORIZONTAL;
|
|
|
|
#pragma parameter HSM_PLACEMENT_IMAGE_MODE " Placement Image Mode: TRANSPARENCY : WHITE ON BLACK" 0 0 1 1
|
|
float HSM_PLACEMENT_IMAGE_MODE = global.HSM_PLACEMENT_IMAGE_MODE;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Non Integer Scale Offset
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_NONINTEGER_SCALE_OFFSET_TITLE "[ NON-INTEGER SCALE OFFSET ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_NON_INTEGER_SCALE_OFFSET " Non-Integer Scale Offset" 100 5 400 0.1
|
|
float HSM_NON_INTEGER_SCALE_OFFSET = global.HSM_NON_INTEGER_SCALE_OFFSET / 100;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Snap to Integer Scale
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
#pragma parameter HSM_SNAP_NONINTEGER_TITLE "[ SNAP NON-INTEGER TO CLOSEST INTEGER SCALE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_USE_SNAP_TO_CLOSEST_INT_SCALE " Snap to Closest Integer Scale: OFF | ON" 0 0 1 1
|
|
float HSM_USE_SNAP_TO_CLOSEST_INT_SCALE = global.HSM_USE_SNAP_TO_CLOSEST_INT_SCALE;
|
|
|
|
#pragma parameter HSM_SNAP_TO_CLOSEST_INT_SCALE_TOLERANCE " Snap To Closest Integer Scale Tolerance" 20 0 300 1
|
|
float HSM_SNAP_TO_CLOSEST_INT_SCALE_TOLERANCE = HSM_USE_SNAP_TO_CLOSEST_INT_SCALE > 0.5 ? global.HSM_SNAP_TO_CLOSEST_INT_SCALE_TOLERANCE / 100 : 0;
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Position
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SCREEN_POSITION_TITLE "[ POSITION OFFSET ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_SCREEN_POSITION_X " Position X" 0 -1000 1000 1
|
|
float HSM_SCREEN_POSITION_X = global.HSM_SCREEN_POSITION_X / 1000;
|
|
|
|
#pragma parameter HSM_SCREEN_POSITION_Y " Position Y" 0 -1000 1000 1
|
|
float HSM_SCREEN_POSITION_Y = -1 * global.HSM_SCREEN_POSITION_Y / 1000;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// CROPPING
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_CROPPING_TITLE "[ CROPPING CORE IMAGE ]:" 0 0 0.01 0.01
|
|
#pragma parameter HSM_CROP_FYI "!!! FYI !!! Negative Crop is currently Disabled :(" 2 0 2 1
|
|
|
|
#pragma parameter HSM_CROP_MODE " Crop Mode - OFF | CROP BLACK ONLY | CROP ANY" 2 0 2 1
|
|
float HSM_CROP_MODE = global.HSM_CROP_MODE;
|
|
|
|
#pragma parameter HSM_CROP_PERCENT_ZOOM " Crop Zoom %" 0 -50 100 0.1
|
|
float HSM_CROP_PERCENT_ZOOM = global.HSM_CROP_PERCENT_ZOOM / 100;
|
|
|
|
#pragma parameter HSM_CROP_PERCENT_TOP " Crop Top %" 0 -50 100 0.1
|
|
float HSM_CROP_PERCENT_TOP = global.HSM_CROP_PERCENT_TOP / 100;
|
|
|
|
#pragma parameter HSM_CROP_PERCENT_BOTTOM " Crop Bottom %" 0 -50 100 0.1
|
|
float HSM_CROP_PERCENT_BOTTOM = global.HSM_CROP_PERCENT_BOTTOM / 100;
|
|
|
|
#pragma parameter HSM_CROP_PERCENT_LEFT " Crop Left %" 0 -50 100 0.1
|
|
float HSM_CROP_PERCENT_LEFT = global.HSM_CROP_PERCENT_LEFT / 100;
|
|
|
|
#pragma parameter HSM_CROP_PERCENT_RIGHT " Crop Right %" 0 -50 100 0.1
|
|
float HSM_CROP_PERCENT_RIGHT = global.HSM_CROP_PERCENT_RIGHT / 100;
|
|
|
|
#pragma parameter HSM_CROP_BLACK_THRESHOLD " Black Threshold for 'CROP BLACK ONLY'" 0 0 100 1
|
|
float HSM_CROP_BLACK_THRESHOLD = global.HSM_CROP_BLACK_THRESHOLD / 100;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// SHADERFX
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SCALEFX_TITLE "[ --- SMOOTHING - SCALEFX - SMOOTH-ADV Presets Only ---- ]:" 0 0 0.01 0.01
|
|
#pragma parameter HSM_SCALEFX_ON " ScaleFx ON - Must Increase Core Res Sampling" 0 0 1 1
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// SCANLINES
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SCANLINE_TITLE "[ SCANLINE DIRECTION ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_SCANLINE_DIRECTION " Scanline Direction - Auto | Horiz | Vert" 0 0 2 1
|
|
float HSM_SCANLINE_DIRECTION = global.HSM_SCANLINE_DIRECTION;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// CORE RES SAMPLING
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SAMPLING_TITLE "[ CORE RES SAMPLING]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_CORE_RES_SAMPLING_MULT_SCANLINE_DIR " Scanline Dir Multiplier (X-Prescale for H Scanline)" 100 25 1600 25
|
|
float HSM_CORE_RES_SAMPLING_MULT_SCANLINE_DIR = global.HSM_CORE_RES_SAMPLING_MULT_SCANLINE_DIR / 100;
|
|
|
|
#pragma parameter HSM_DOWNSAMPLE_BLUR_SCANLINE_DIR " Scanline Dir Downsample Blur" 0 0 200 1
|
|
float HSM_DOWNSAMPLE_BLUR_SCANLINE_DIR = global.HSM_DOWNSAMPLE_BLUR_SCANLINE_DIR / 100;
|
|
|
|
#pragma parameter HSM_CORE_RES_SAMPLING_MULT_OPPOSITE_DIR " Opposite Dir Multiplier (Y Downsample for H Scanline)" 100 25 1600 25
|
|
float HSM_CORE_RES_SAMPLING_MULT_OPPOSITE_DIR = global.HSM_CORE_RES_SAMPLING_MULT_OPPOSITE_DIR / 100;
|
|
|
|
#pragma parameter HSM_DOWNSAMPLE_BLUR_OPPOSITE_DIR " Opposite Dir Downsample Blur" 0 0 200 1
|
|
float HSM_DOWNSAMPLE_BLUR_OPPOSITE_DIR = global.HSM_DOWNSAMPLE_BLUR_OPPOSITE_DIR / 100;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// INTERLACING
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_INTERLACE_TITLE "[ INTERLACING From Guest.r :) ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_INTERLACE_TRIGGER_RES " Interlacing and Fake Scanlines Trigger Res" 600 100 2000 25
|
|
#define HSM_INTERLACE_TRIGGER_RES global.HSM_INTERLACE_TRIGGER_RES
|
|
|
|
#pragma parameter HSM_INTERLACE_MODE " Interlacing Mode: OFF | Normal 1-3 | Interpolation 4-5" 4 0.0 5.0 1.0
|
|
#define HSM_INTERLACE_MODE global.HSM_INTERLACE_MODE
|
|
|
|
#pragma parameter HSM_INTERLACE_EFFECT_SMOOTHNESS_INTERS " Interlacing Effect Smoothness" 0 0 100 10
|
|
#define HSM_INTERLACE_EFFECT_SMOOTHNESS_INTERS global.HSM_INTERLACE_EFFECT_SMOOTHNESS_INTERS / 200
|
|
|
|
#pragma parameter HSM_INTERLACE_SCANLINE_EFFECT " Interlacing Scanline Effect" 20 0 100 5
|
|
#define HSM_INTERLACE_SCANLINE_EFFECT global.HSM_INTERLACE_SCANLINE_EFFECT / 100
|
|
|
|
#pragma parameter iscans " Interlacing (Scanline) Saturation" 0.25 0 1 0.05
|
|
#define iscans global.iscans
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// FAKE SCANLINES
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_FAKE_SCANLINE_TITLE "[ FAKE SCANLINES ]" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_MODE " Show Fake Scanlines - OFF | ON | USE TRIGGER RES" 2 0 2 1
|
|
#define HSM_FAKE_SCANLINE_MODE global.HSM_FAKE_SCANLINE_MODE
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_OPACITY " Opacity - Def 70" 0 0 100 5
|
|
#define HSM_FAKE_SCANLINE_OPACITY global.HSM_FAKE_SCANLINE_OPACITY / 100
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_RES_MODE " Scan Resolution Mode: AUTO (CORE RES) : EXPLICIT" 1 0 1 1
|
|
#define HSM_FAKE_SCANLINE_RES_MODE global.HSM_FAKE_SCANLINE_RES_MODE
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_RES " Explicit Scan Resolution" 240 0 480 8
|
|
#define HSM_FAKE_SCANLINE_RES global.HSM_FAKE_SCANLINE_RES
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_INT_SCALE " Int Scale Scanlines" 1 0 1 1
|
|
#define HSM_FAKE_SCANLINE_INT_SCALE global.HSM_FAKE_SCANLINE_INT_SCALE
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_ROLL " Rolling Scanline" 0 -100 100 1
|
|
#define HSM_FAKE_SCANLINE_ROLL global.HSM_FAKE_SCANLINE_ROLL / 100
|
|
|
|
#pragma parameter HSM_FAKE_SCANLINE_CURVATURE " Scanline Curvature" 0 0 100 1
|
|
#define HSM_FAKE_SCANLINE_CURVATURE global.HSM_FAKE_SCANLINE_CURVATURE / 100
|
|
|
|
// #pragma parameter HSM_FAKE_SCANLINE_BRIGHTNESS_CUTOFF "[ SCREEN FX ] Fake 240p Scanline Brightness Cutoff - Def 3" 3 0 10 0.05
|
|
#ifndef HSM_FAKE_SCANLINE_BRIGHTNESS_CUTOFF
|
|
#define HSM_FAKE_SCANLINE_BRIGHTNESS_CUTOFF 3
|
|
#endif
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// CURVATURE
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_CURVATURE_TITLE "[ CURVATURE ]:" 0 0 0.01 0.01
|
|
|
|
// #pragma parameter HSM_USE_GEOM " Use Geom Curvature" 0 -1 3 1
|
|
// float HSM_USE_GEOM = global.HSM_USE_GEOM;
|
|
float HSM_USE_GEOM = 0;
|
|
|
|
#pragma parameter HSM_CURVATURE_MODE " Curvature Mode OFF | 2D | 2D-CYL | 3D-1 | 3D-2 | 3D CYL" 1 0 5 1
|
|
float HSM_CURVATURE_MODE = global.HSM_CURVATURE_MODE;
|
|
|
|
#pragma parameter HSM_CURVATURE_2D_SCALE_LONG_AXIS " 2D Curvature on Long Axis" 100 5 400 5
|
|
#define HSM_CURVATURE_2D_SCALE_LONG_AXIS global.HSM_CURVATURE_2D_SCALE_LONG_AXIS / 100
|
|
|
|
#pragma parameter HSM_CURVATURE_2D_SCALE_SHORT_AXIS " 2D Curvature on Short Axis" 100 5 400 5
|
|
#define HSM_CURVATURE_2D_SCALE_SHORT_AXIS global.HSM_CURVATURE_2D_SCALE_SHORT_AXIS / 100
|
|
|
|
// #pragma parameter HSM_CURVATURE_2D_SHAPE " 2D Curvature Shape" 0.25 0.05 0.60 0.05
|
|
// #define HSM_CURVATURE_2D_SHAPE global.HSM_CURVATURE_2D_SHAPE
|
|
|
|
#pragma parameter HSM_CURVATURE_3D_RADIUS " 3D Radius" 200 16 102400 1
|
|
float HSM_CURVATURE_3D_RADIUS = global.HSM_CURVATURE_3D_RADIUS / 100;
|
|
|
|
#pragma parameter HSM_CURVATURE_3D_VIEW_DIST " 3D View Distance - Def 150" 150 50 102400 5
|
|
float HSM_CURVATURE_3D_VIEW_DIST = global.HSM_CURVATURE_3D_VIEW_DIST / 100;
|
|
|
|
#pragma parameter HSM_CURVATURE_3D_TILT_ANGLE_X " 3D Tilt Angle X" 0 -120 120 1
|
|
float HSM_CURVATURE_3D_TILT_ANGLE_X = global.HSM_CURVATURE_3D_TILT_ANGLE_X / 100;
|
|
|
|
#pragma parameter HSM_CURVATURE_3D_TILT_ANGLE_Y " 3D Tilt Angle Y" 0 -120 120 1
|
|
float HSM_CURVATURE_3D_TILT_ANGLE_Y = global.HSM_CURVATURE_3D_TILT_ANGLE_Y / 100;
|
|
|
|
#pragma parameter HSM_CRT_CURVATURE_SCALE " CRT Curvature Scale Multiplier: 0 = Less Moire Artifacts" 100 0 100 1
|
|
float HSM_CRT_CURVATURE_SCALE = global.HSM_CRT_CURVATURE_SCALE / 100;
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// ANTI-FLICKER
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_ANTI_FLICKER_TITLE "[ ANTI-FLICKER ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_ANTI_FLICKER_ON " Anti-Flicker ON" 0 0 1 1
|
|
#define HSM_ANTI_FLICKER_ON global.HSM_ANTI_FLICKER_ON
|
|
|
|
#pragma parameter HSM_ANTI_FLICKER_THRESHOLD " Luma Difference Threshold" 25 0 100 5
|
|
#define HSM_ANTI_FLICKER_THRESHOLD global.HSM_ANTI_FLICKER_THRESHOLD / 100
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// CRT vs ORIGINAL A/B TESTING
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_CRT_AB_COMPARE_TITLE "[ A/B SPLITSCREEN COMPARE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_AB_COMPARE_SHOW_MODE " Show: CRT SHADER | ORIGINAL" 0 0 1 1
|
|
float HSM_AB_COMPARE_SHOW_MODE = global.HSM_AB_COMPARE_SHOW_MODE;
|
|
|
|
#pragma parameter HSM_AB_COMPARE_AREA " Compare Area: LEFT | RIGHT | TOP | BOTTOM" 0 0 3 1
|
|
float HSM_AB_COMPARE_AREA = global.HSM_AB_COMPARE_AREA;
|
|
|
|
#pragma parameter HSM_AB_COMPARE_SPLIT_POSITION " Splitscreen Position" 50 0 100 0.2
|
|
float HSM_AB_COMPARE_SPLIT_POSITION = global.HSM_AB_COMPARE_SPLIT_POSITION / 100;
|
|
|
|
#pragma parameter HSM_AB_COMPARE_FREEZE_CRT_TUBE " Freeze CRT Tube (Freeze Left, New changes on Right)" 0 0 1 1
|
|
float HSM_AB_COMPARE_FREEZE_CRT_TUBE = global.HSM_AB_COMPARE_FREEZE_CRT_TUBE;
|
|
|
|
#pragma parameter HSM_AB_COMPARE_FREEZE_GRAPHICS " Freeze Graphics (Freeze Left, New changes on Right)" 0 0 1 1
|
|
float HSM_AB_COMPARE_FREEZE_GRAPHICS = global.HSM_AB_COMPARE_FREEZE_GRAPHICS;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Screen Vignette
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SCREEN_VIGNETTE_TITLE "[ SCREEN VIGNETTE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_SCREEN_VIGNETTE_ON " Use Vignette" 1 0 1 1
|
|
#define HSM_SCREEN_VIGNETTE_ON global.HSM_SCREEN_VIGNETTE_ON
|
|
|
|
#pragma parameter HSM_SCREEN_VIGNETTE_DUALSCREEN_VIS_MODE " Dual Screen Visibility - BOTH | SCREEN 1 | SCREEN 2" 0 0 2 1
|
|
float HSM_SCREEN_VIGNETTE_DUALSCREEN_VIS_MODE = global.HSM_SCREEN_VIGNETTE_DUALSCREEN_VIS_MODE;
|
|
|
|
#pragma parameter HSM_SCREEN_VIGNETTE_STRENGTH " Amount (Strength)" 40 0 98 2
|
|
#define HSM_SCREEN_VIGNETTE_STRENGTH (1 - global.HSM_SCREEN_VIGNETTE_STRENGTH / 100) * 50
|
|
|
|
#pragma parameter HSM_SCREEN_VIGNETTE_POWER " Corner Amount (Power)" 26 0 200 2
|
|
#define HSM_SCREEN_VIGNETTE_POWER global.HSM_SCREEN_VIGNETTE_POWER / 100
|
|
|
|
#pragma parameter HSM_SCREEN_VIGNETTE_IN_REFLECTION " Amount of Vignette in Reflection" 100 0 100 1
|
|
#define HSM_SCREEN_VIGNETTE_IN_REFLECTION global.HSM_SCREEN_VIGNETTE_IN_REFLECTION / 100
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Monochrome
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_MONOCHROME_TITLE "[ MONOCHROME ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_MONOCHROME_MODE " Monochrome Color: OFF | BW | AMBER | GREEN" 0.0 0.0 3.0 1.0
|
|
#define HSM_MONOCHROME_MODE global.HSM_MONOCHROME_MODE
|
|
|
|
#pragma parameter HSM_MONOCHROME_BRIGHTNESS " Monochrome Brightness" 100 1 500 1
|
|
#define HSM_MONOCHROME_BRIGHTNESS global.HSM_MONOCHROME_BRIGHTNESS / 100
|
|
|
|
#pragma parameter HSM_MONOCHROME_GAMMA " Monochrome Gamma" 1.0 0.1 5 0.1
|
|
#define HSM_MONOCHROME_GAMMA global.HSM_MONOCHROME_GAMMA
|
|
|
|
#pragma parameter HSM_MONOCHROME_HUE_OFFSET " Monochrome Hue Offset" 0 -180 180 1
|
|
#define HSM_MONOCHROME_HUE_OFFSET (global.HSM_MONOCHROME_HUE_OFFSET / 360)
|
|
|
|
#pragma parameter HSM_MONOCHROME_SATURATION " Monochrome Saturation" 100 -100 200 1
|
|
#define HSM_MONOCHROME_SATURATION (global.HSM_MONOCHROME_SATURATION / 100)
|
|
|
|
#pragma parameter HSM_MONOCHROME_DUALSCREEN_VIS_MODE " Dual Screen Visibility - BOTH | SCREEN 1 | SCREEN 2" 0 0 2 1
|
|
float HSM_MONOCHROME_DUALSCREEN_VIS_MODE = global.HSM_MONOCHROME_DUALSCREEN_VIS_MODE;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// CRT Blend Over Diffuse
|
|
//---------------------------------------------------------------------------------------------------
|
|
|
|
#pragma parameter HSM_CRT_BLEND_TITLE "[ CRT ON TUBE DIFFUSE BLENDING ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_CRT_BLEND_MODE " CRT On Tube Diffuse Blend Mode: OFF | ADD | MULTIPLY" 1 0 2 1
|
|
#define HSM_CRT_BLEND_MODE global.HSM_CRT_BLEND_MODE
|
|
|
|
#pragma parameter HSM_CRT_BLEND_AMOUNT " CRT On Tube Diffuse Blend Amount" 100 0 100 1
|
|
#define HSM_CRT_BLEND_AMOUNT global.HSM_CRT_BLEND_AMOUNT / 100
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// TUBE DIFFUSE COLOR
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_TITLE "[ TUBE DIFFUSE IMAGE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_MODE " Tube Diffuse Color - BLACK | IMAGE | TRANSPARENT" 0 0 2 1
|
|
float HSM_TUBE_DIFFUSE_MODE = global.HSM_TUBE_DIFFUSE_MODE;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_OPACITY " Opacity" 100 0 100 0.1
|
|
float HSM_TUBE_DIFFUSE_OPACITY = global.HSM_TUBE_DIFFUSE_OPACITY / 100;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_DUALSCREEN_VIS_MODE " Dual Screen Visibility - BOTH | SCREEN 1 | SCREEN 2" 0 0 2 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_DUALSCREEN_VIS_MODE = global.HSM_TUBE_DIFFUSE_IMAGE_DUALSCREEN_VIS_MODE;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_COLORIZE_ON " Colorize On" 0 0 1 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_COLORIZE_ON = global.HSM_TUBE_DIFFUSE_IMAGE_COLORIZE_ON;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_HUE " Hue Offset" 0 0 360 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_HUE = global.HSM_TUBE_DIFFUSE_IMAGE_HUE / 360;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_SATURATION " Saturation" 100 0 200 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_SATURATION = global.HSM_TUBE_DIFFUSE_IMAGE_SATURATION / 100;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_BRIGHTNESS " Brightness" 20 0 500 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_BRIGHTNESS = global.HSM_TUBE_DIFFUSE_IMAGE_BRIGHTNESS / 100;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_GAMMA " Gamma Adjust" 1 0 5 0.01
|
|
float HSM_TUBE_DIFFUSE_IMAGE_GAMMA = global.HSM_TUBE_DIFFUSE_IMAGE_GAMMA;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_AMBIENT_LIGHTING " Ambient Lighting Multiplier" 100 0 100 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_AMBIENT_LIGHTING = global.HSM_TUBE_DIFFUSE_IMAGE_AMBIENT_LIGHTING / 100;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_SCALE " Scale" 100 0 1000 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_SCALE = global.HSM_TUBE_DIFFUSE_IMAGE_SCALE / 100;
|
|
|
|
#pragma parameter HSM_TUBE_DIFFUSE_IMAGE_SCALE_X " Scale X" 100 0 1000 1
|
|
float HSM_TUBE_DIFFUSE_IMAGE_SCALE_X = global.HSM_TUBE_DIFFUSE_IMAGE_SCALE_X / 100;
|
|
|
|
#pragma parameter HSM_TUBE_EMPTY_THICKNESS " Empty Tube Thickness" 0 0 6000 5
|
|
#define HSM_TUBE_EMPTY_THICKNESS (0.7 * global.HSM_TUBE_EMPTY_THICKNESS / 100)
|
|
|
|
#pragma parameter HSM_TUBE_EMPTY_THICKNESS_X_SCALE " Empty Tube Thicknes X Scale" 100 0 3000 1
|
|
#define HSM_TUBE_EMPTY_THICKNESS_X_SCALE (global.HSM_TUBE_EMPTY_THICKNESS_X_SCALE / 100)
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// TUBE SHADOW IMAGE
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_TITLE "[ TUBE SHADOW IMAGE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_ON " Tube Shadow Image - OFF | ON" 1 0 1 1
|
|
float HSM_TUBE_SHADOW_IMAGE_ON = global.HSM_TUBE_SHADOW_IMAGE_ON;
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_OPACITY " Opacity" 60 0 100 2
|
|
float HSM_TUBE_SHADOW_IMAGE_OPACITY = global.HSM_TUBE_SHADOW_IMAGE_OPACITY / 100;
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_POS_X " Position X" 0 -500 500 0.1
|
|
float HSM_TUBE_SHADOW_IMAGE_POS_X = global.HSM_TUBE_SHADOW_IMAGE_POS_X / 100;
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_POS_Y " Position Y" 9 -500 500 0.1
|
|
float HSM_TUBE_SHADOW_IMAGE_POS_Y = global.HSM_TUBE_SHADOW_IMAGE_POS_Y / 100;
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_SCALE_X " Scale X" 122 0 1000 0.1
|
|
float HSM_TUBE_SHADOW_IMAGE_SCALE_X = global.HSM_TUBE_SHADOW_IMAGE_SCALE_X / 100;
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_IMAGE_SCALE_Y " Scale Y" 130 0 1000 0.1
|
|
float HSM_TUBE_SHADOW_IMAGE_SCALE_Y = global.HSM_TUBE_SHADOW_IMAGE_SCALE_Y / 100;
|
|
|
|
#pragma parameter HSM_TUBE_SHADOW_CURVATURE_SCALE " Curvature Scale" 300 0 2000 1
|
|
float HSM_TUBE_SHADOW_CURVATURE_SCALE = global.HSM_TUBE_SHADOW_CURVATURE_SCALE / 100;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// TUBE STATIC REFLECTION
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_TITLE "[ TUBE STATIC REFLECTION IMAGE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_ON " Use Tube Static Reflection Image - OFF | ON" 0 0 1 1
|
|
float HSM_TUBE_STATIC_REFLECTION_IMAGE_ON = global.HSM_TUBE_STATIC_REFLECTION_IMAGE_ON;
|
|
|
|
#pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_DUALSCREEN_VIS_MODE " Dual Screen Visibility - BOTH | SCREEN 1 | SCREEN 2" 0 0 2 1
|
|
float HSM_TUBE_STATIC_REFLECTION_IMAGE_DUALSCREEN_VIS_MODE = global.HSM_TUBE_STATIC_REFLECTION_IMAGE_DUALSCREEN_VIS_MODE;
|
|
|
|
#pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_OPACITY " Opacity" 10 0 100 0.1
|
|
float HSM_TUBE_STATIC_REFLECTION_IMAGE_OPACITY = global.HSM_TUBE_STATIC_REFLECTION_IMAGE_OPACITY / 100;
|
|
|
|
#pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_AMBIENT_LIGHTING " Ambient Lighting Multiplier" 100 0 100 1
|
|
float HSM_TUBE_STATIC_REFLECTION_IMAGE_AMBIENT_LIGHTING = global.HSM_TUBE_STATIC_REFLECTION_IMAGE_AMBIENT_LIGHTING / 100;
|
|
|
|
#pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_SCALE " Scale" 110 0 1000 1
|
|
float HSM_TUBE_STATIC_REFLECTION_IMAGE_SCALE = global.HSM_TUBE_STATIC_REFLECTION_IMAGE_SCALE / 100;
|
|
|
|
// #pragma parameter HSM_TUBE_STATIC_REFLECTION_IMAGE_DITHERING_SAMPLES "[ TUBE IMAGES ] Tube Static Reflection Noise Samples (Reduces Banding)" 0 0 10 1
|
|
// float HSM_TUBE_STATIC_REFLECTION_IMAGE_DITHERING_SAMPLES = global.HSM_TUBE_STATIC_REFLECTION_IMAGE_DITHERING_SAMPLES;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// TUBE COLORED GEL
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_TUBE_IMAGES_TITLE "[ TUBE COLORED GEL IMAGE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_ON " Use Tube Colored Gel - OFF | ON" 0 0 1 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_ON = global.HSM_TUBE_COLORED_GEL_IMAGE_ON;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_DUALSCREEN_VIS_MODE " Dual Screen Visibility - BOTH | SCREEN 1 | SCREEN 2" 0 0 2 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_DUALSCREEN_VIS_MODE = global.HSM_TUBE_COLORED_GEL_IMAGE_DUALSCREEN_VIS_MODE;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_MULTIPLY_AMOUNT " Multiply Blend Amount" 90 0 100 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_MULTIPLY_AMOUNT = global.HSM_TUBE_COLORED_GEL_IMAGE_MULTIPLY_AMOUNT / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_ADDITIVE_AMOUNT " Additive Blend Amount" 0 0 100 0.05
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_ADDITIVE_AMOUNT = global.HSM_TUBE_COLORED_GEL_IMAGE_ADDITIVE_AMOUNT / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_NORMAL_AMOUNT " Normal Blend Amount" 15 0 100 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_NORMAL_AMOUNT = global.HSM_TUBE_COLORED_GEL_IMAGE_NORMAL_AMOUNT / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_NORMAL_BRIGHTNESS " Normal Blend Brightness" 100 0 200 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_NORMAL_BRIGHTNESS = global.HSM_TUBE_COLORED_GEL_IMAGE_NORMAL_BRIGHTNESS / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_TRANSPARENCY_THRESHOLD " Normal Blend Transparency Threshold" 23 0 100 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_TRANSPARENCY_THRESHOLD = global.HSM_TUBE_COLORED_GEL_IMAGE_TRANSPARENCY_THRESHOLD / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_AMBIENT_LIGHTING " Ambient Lighting Multiplier" 100 0 100 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_AMBIENT_LIGHTING = global.HSM_TUBE_COLORED_GEL_IMAGE_AMBIENT_LIGHTING / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_SCALE " Scale" 100 0 1000 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_SCALE = global.HSM_TUBE_COLORED_GEL_IMAGE_SCALE / 100;
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_FLIP_HORIZONTAL " Flip Horizontal" 0 0 1 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_FLIP_HORIZONTAL = -(global.HSM_TUBE_COLORED_GEL_IMAGE_FLIP_HORIZONTAL * 2 - 1);
|
|
|
|
#pragma parameter HSM_TUBE_COLORED_GEL_IMAGE_FLIP_VERTICAL " Flip Vertical" 0 0 1 1
|
|
float HSM_TUBE_COLORED_GEL_IMAGE_FLIP_VERTICAL = -(global.HSM_TUBE_COLORED_GEL_IMAGE_FLIP_VERTICAL * 2 - 1);
|
|
|
|
#pragma parameter HSM_SHOW_CRT_ON_TOP_OF_COLORED_GEL " Show CRT on Top of Colored Gel Normal" 0 0 1 1
|
|
float HSM_SHOW_CRT_ON_TOP_OF_COLORED_GEL = global.HSM_SHOW_CRT_ON_TOP_OF_COLORED_GEL;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// SCREEN BLACK EDGE
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_SCREEN_EDGE_TITLE "[ SCREEN BLACK EDGE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_TUBE_BLACK_EDGE_LAYERING_MODE " Show Black Edge: OFF | OVER DIFFUSE & GEL" 1 0 1 1
|
|
float HSM_TUBE_BLACK_EDGE_LAYERING_MODE = global.HSM_TUBE_BLACK_EDGE_LAYERING_MODE;
|
|
|
|
#pragma parameter HSM_GLOBAL_CORNER_RADIUS " Global Corner Radius - Def 10" 10 4 500 2
|
|
#define HSM_GLOBAL_CORNER_RADIUS global.HSM_GLOBAL_CORNER_RADIUS
|
|
|
|
#pragma parameter HSM_TUBE_BLACK_EDGE_CORNER_RADIUS_SCALE " Black Edge Corner Radius Scale" 100 100 8000 10
|
|
#define HSM_TUBE_BLACK_EDGE_CORNER_RADIUS_SCALE global.HSM_TUBE_BLACK_EDGE_CORNER_RADIUS_SCALE / 100
|
|
|
|
#pragma parameter HSM_TUBE_BLACK_EDGE_SHARPNESS " Black Edge Sharpness - Def 70" 70 0 90 1
|
|
#define HSM_TUBE_BLACK_EDGE_SHARPNESS global.HSM_TUBE_BLACK_EDGE_SHARPNESS / 100
|
|
|
|
#pragma parameter HSM_TUBE_BLACK_EDGE_CURVATURE_SCALE " Black Edge Curvature Scale Multiplier" 100 100 8000 10
|
|
#define HSM_TUBE_BLACK_EDGE_CURVATURE_SCALE global.HSM_TUBE_BLACK_EDGE_CURVATURE_SCALE / 100
|
|
|
|
#pragma parameter HSM_TUBE_BLACK_EDGE_THICKNESS " Black Edge Thickness" 100 -800 6000 5
|
|
#define HSM_TUBE_BLACK_EDGE_THICKNESS (0.7 * global.HSM_TUBE_BLACK_EDGE_THICKNESS / 100)
|
|
|
|
#pragma parameter HSM_TUBE_BLACK_EDGE_THICKNESS_X_SCALE " Black Edge Thickness X Scale" 100 0 3000 10
|
|
#define HSM_TUBE_BLACK_EDGE_THICKNESS_X_SCALE (global.HSM_TUBE_BLACK_EDGE_THICKNESS_X_SCALE / 100)
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// DUAL SCREEN
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_DUALSCREEN_TITLE "[ DUAL SCREEN ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_DUALSCREEN_MODE " Dual Screen Mode - OFF | VERTICAL | HORIZONTAL" 0 0 2 1
|
|
float HSM_DUALSCREEN_MODE = global.HSM_DUALSCREEN_MODE;
|
|
|
|
#pragma parameter HSM_DUALSCREEN_CORE_IMAGE_SPLIT_MODE " Core Image Split Mode - AUTO | VERTICAL | HORIZONTAL" 1 0 2 1
|
|
float HSM_DUALSCREEN_CORE_IMAGE_SPLIT_MODE = global.HSM_DUALSCREEN_CORE_IMAGE_SPLIT_MODE;
|
|
|
|
#pragma parameter HSM_DUALSCREEN_CORE_IMAGE_SWAP_SCREENS " Core Image Swap Screen Content" 0 0 1 1
|
|
float HSM_DUALSCREEN_CORE_IMAGE_SWAP_SCREENS = global.HSM_DUALSCREEN_CORE_IMAGE_SWAP_SCREENS;
|
|
|
|
#pragma parameter HSM_DUALSCREEN_CORE_IMAGE_SPLIT_OFFSET " Core Image Split Offset" 0 -100 100 1
|
|
float HSM_DUALSCREEN_CORE_IMAGE_SPLIT_OFFSET = global.HSM_DUALSCREEN_CORE_IMAGE_SPLIT_OFFSET / 1000;
|
|
|
|
// #pragma parameter HSM_2ND_SCREEN_SIDES_CROP " Crop % from Edges of 2nd Screen" 0 0 100 0.1
|
|
// float HSM_2ND_SCREEN_SIDES_CROP = global.HSM_2ND_SCREEN_SIDES_CROP / 100;
|
|
|
|
#pragma parameter HSM_DUALSCREEN_VIEWPORT_SPLIT_LOCATION " Viewport Split Offset" 0 -500 500 1
|
|
float HSM_DUALSCREEN_VIEWPORT_SPLIT_LOCATION = global.HSM_DUALSCREEN_VIEWPORT_SPLIT_LOCATION / 1000;
|
|
|
|
#pragma parameter HSM_DUALSCREEN_SHIFT_POSITION_WITH_SCALE " Scale Screens from Center of Split" 1 0 1 1
|
|
float HSM_DUALSCREEN_SHIFT_POSITION_WITH_SCALE = global.HSM_DUALSCREEN_SHIFT_POSITION_WITH_SCALE;
|
|
|
|
#pragma parameter HSM_DUALSCREEN_POSITION_OFFSET_BETWEEN_SCREENS " Position Offset Between Screens" 0 -250 250 0.2
|
|
float HSM_DUALSCREEN_POSITION_OFFSET_BETWEEN_SCREENS = global.HSM_DUALSCREEN_POSITION_OFFSET_BETWEEN_SCREENS / 1000;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_ASPECT_RATIO_MODE " 2nd Screen Aspect Ratio Mode - Same as 1st Screen | PAR" 0 0 1 1
|
|
float HSM_2ND_SCREEN_ASPECT_RATIO_MODE = global.HSM_2ND_SCREEN_ASPECT_RATIO_MODE;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_INDEPENDENT_SCALE " 2nd Screen Use Independent Scale" 0 0 1 1
|
|
float HSM_2ND_SCREEN_INDEPENDENT_SCALE = global.HSM_2ND_SCREEN_INDEPENDENT_SCALE;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_SCALE_OFFSET " 2nd Screen Scale Offset" 100 1 500 0.5
|
|
float HSM_2ND_SCREEN_SCALE_OFFSET = global.HSM_2ND_SCREEN_SCALE_OFFSET / 100;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_POS_X " 2nd Screen Pos X" 0 -500 500 1
|
|
float HSM_2ND_SCREEN_POS_X = global.HSM_2ND_SCREEN_POS_X / 1000;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_POS_Y " 2nd Screen Pos Y" 0 -500 500 1
|
|
float HSM_2ND_SCREEN_POS_Y = global.HSM_2ND_SCREEN_POS_Y / 1000;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_CROP_PERCENT_ZOOM " 2nd Screen Crop Zoom %" 0 -10 100 0.1
|
|
float HSM_2ND_SCREEN_CROP_PERCENT_ZOOM = global.HSM_2ND_SCREEN_CROP_PERCENT_ZOOM / 100;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_CROP_PERCENT_TOP " 2nd Screen Crop Top %" 0 -10 100 0.1
|
|
float HSM_2ND_SCREEN_CROP_PERCENT_TOP = global.HSM_2ND_SCREEN_CROP_PERCENT_TOP / 100;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_CROP_PERCENT_BOTTOM " 2nd Screen Crop Bottom %" 0 -10 100 0.1
|
|
float HSM_2ND_SCREEN_CROP_PERCENT_BOTTOM = global.HSM_2ND_SCREEN_CROP_PERCENT_BOTTOM / 100;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_CROP_PERCENT_LEFT " 2nd Screen Crop Left %" 0 -10 100 0.1
|
|
float HSM_2ND_SCREEN_CROP_PERCENT_LEFT = global.HSM_2ND_SCREEN_CROP_PERCENT_LEFT / 100;
|
|
|
|
#pragma parameter HSM_2ND_SCREEN_CROP_PERCENT_RIGHT " 2nd Screen Crop Right %" 0 -10 100 0.1
|
|
float HSM_2ND_SCREEN_CROP_PERCENT_RIGHT = global.HSM_2ND_SCREEN_CROP_PERCENT_RIGHT / 100;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// Reflection Transform
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_REFLECTIONAPPEARANCE_TITLE "[ REFLECTION POSITION & SCALE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_SCREEN_REFLECTION_SCALE " Screen Reflection Scale" 100 1 300 1
|
|
float HSM_SCREEN_REFLECTION_SCALE = global.HSM_SCREEN_REFLECTION_SCALE / 100;
|
|
|
|
#pragma parameter HSM_SCREEN_REFLECTION_POS_X " Screen Reflection Pos X" 0 -100 100 1
|
|
float HSM_SCREEN_REFLECTION_POS_X = global.HSM_SCREEN_REFLECTION_POS_X / 600;
|
|
|
|
#pragma parameter HSM_SCREEN_REFLECTION_POS_Y " Screen Reflection Pos Y" 0 -100 100 1
|
|
float HSM_SCREEN_REFLECTION_POS_Y = global.HSM_SCREEN_REFLECTION_POS_Y / 600;
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// BEZEL INDEPENDENT SCALE
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_BEZEL_INDEPENDENT_TITLE "[ BEZEL INDEPENDENT SCALE & CURVATURE ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_BZL_USE_INDEPENDENT_SCALE " Use Independent Scale" 0 0 1 1
|
|
#define HSM_BZL_USE_INDEPENDENT_SCALE global.HSM_BZL_USE_INDEPENDENT_SCALE
|
|
|
|
#pragma parameter HSM_BZL_INDEPENDENT_SCALE " Independent Scale (When scale from image is not used)" 82.97 1 200 0.1
|
|
#define HSM_BZL_INDEPENDENT_SCALE global.HSM_BZL_INDEPENDENT_SCALE / 100
|
|
|
|
#pragma parameter HSM_BZL_USE_INDEPENDENT_CURVATURE " Use Independent Curvature" 0 0 1 1
|
|
#define HSM_BZL_USE_INDEPENDENT_CURVATURE global.HSM_BZL_USE_INDEPENDENT_CURVATURE
|
|
|
|
#pragma parameter HSM_BZL_INDEPENDENT_CURVATURE_SCALE_LONG_AXIS " Independent Curvature X" 100 0 400 5
|
|
#define HSM_BZL_INDEPENDENT_CURVATURE_SCALE_LONG_AXIS global.HSM_BZL_INDEPENDENT_CURVATURE_SCALE_LONG_AXIS / 100
|
|
|
|
#pragma parameter HSM_BZL_INDEPENDENT_CURVATURE_SCALE_SHORT_AXIS " Independent Curvature Y" 100 0 400 5
|
|
#define HSM_BZL_INDEPENDENT_CURVATURE_SCALE_SHORT_AXIS global.HSM_BZL_INDEPENDENT_CURVATURE_SCALE_SHORT_AXIS / 100
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------
|
|
// BEZEL GENERAL
|
|
//---------------------------------------------------------------------------------------------------
|
|
#pragma parameter HSM_BEZEL_GENERAL_TITLE "[ BEZEL GENERAL ]:" 0 0 0.01 0.01
|
|
|
|
#pragma parameter HSM_BZL_OPACITY " Opacity" 100 0 100 5
|
|
float HSM_BZL_OPACITY = global.HSM_BZL_OPACITY / 100;
|
|
|
|
#pragma parameter HSM_BZL_BLEND_MODE " Blend Mode - Off | Normal | Add | Mult" 1 0 3 1
|
|
float HSM_BZL_BLEND_MODE = global.HSM_BZL_BLEND_MODE;
|
|
|
|
#pragma parameter HSM_BZL_WIDTH " Width - Def 125" 125 -250 5000 1
|
|
float HSM_BZL_WIDTH = global.HSM_BZL_WIDTH * 0.0008624;
|
|
|
|
#pragma parameter HSM_BZL_HEIGHT " Height" 100 -250 5000 1
|
|
float HSM_BZL_HEIGHT = global.HSM_BZL_HEIGHT * 0.0008732;
|
|
|
|
#pragma parameter HSM_BZL_SCALE_OFFSET " Scale Offset" 100 1 200 0.1
|
|
#define HSM_BZL_SCALE_OFFSET global.HSM_BZL_SCALE_OFFSET / 100
|
|
|
|
#pragma parameter HSM_BZL_INNER_CURVATURE_SCALE " Inner Curvature Scale Multiplier" 100 0 8000 10
|
|
#define HSM_BZL_INNER_CURVATURE_SCALE global.HSM_BZL_INNER_CURVATURE_SCALE / 100
|
|
|
|
#pragma parameter HSM_BZL_INNER_CORNER_RADIUS_SCALE " Inner Corner Radius Scale - Def 80" 80 0 8000 1
|
|
float HSM_BZL_INNER_CORNER_RADIUS_SCALE = global.HSM_BZL_INNER_CORNER_RADIUS_SCALE / 100;
|