ta-forever/tavmod
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

merge into: ta-forever/tavmod:tavmod-4.4
Branches Tags
ta-forever/tavmod:tavmod ta-forever/tavmod:tavmod-4.8 ta-forever/tavmod:tavmod-4.7 ta-forever/tavmod:tavmod-4.4 ta-forever/tavmod:tavmod-4.5 ta-forever/tavmod:tavmod-4.6 ta-forever/tavmod:tavmod-4.3
...
pull from: ta-forever/tavmod:tavmod-4.5
Branches Tags
ta-forever/tavmod:tavmod ta-forever/tavmod:tavmod-4.8 ta-forever/tavmod:tavmod-4.7 ta-forever/tavmod:tavmod-4.4 ta-forever/tavmod:tavmod-4.5 ta-forever/tavmod:tavmod-4.6 ta-forever/tavmod:tavmod-4.3
2 Commits
tavmod-4.4 ... tavmod-4.5
Author SHA1 Message Date
Axle1975 c6653dc1c6 Add 4.5 engine files 2024-03-30 10:42:30 +11:00
Axle1975 cbcbe34c41 tavmod-4.5 2023-04-24 09:44:42 +10:00
48 changed files with 4102 additions and 4 deletions
Expand all files Collapse all files
.gitattributes
+23
View File
@@ -3,3 +3,26 @@ TA_Features_2013.ccx filter=lfs diff=lfs merge=lfs -text
ProTA.gp3 filter=lfs diff=lfs merge=lfs -text
TotalA.exe filter=lfs diff=lfs merge=lfs -text
TADEMO.UFO filter=lfs diff=lfs merge=lfs -text
audiere.dll filter=lfs diff=lfs merge=lfs -text
bassflac.dll filter=lfs diff=lfs merge=lfs -text
bassmix.dll filter=lfs diff=lfs merge=lfs -text
tdraw.dll filter=lfs diff=lfs merge=lfs -text
tplayx.dll filter=lfs diff=lfs merge=lfs -text
Viewer.exe filter=lfs diff=lfs merge=lfs -text
cnc-ddraw[[:space:]]config.exe filter=lfs diff=lfs merge=lfs -text
basscd.dll filter=lfs diff=lfs merge=lfs -text
basswasapi.dll filter=lfs diff=lfs merge=lfs -text
ddraw_custom.dll filter=lfs diff=lfs merge=lfs -text
tmusi.dll filter=lfs diff=lfs merge=lfs -text
wgmus.dll filter=lfs diff=lfs merge=lfs -text
bass.dll filter=lfs diff=lfs merge=lfs -text
Shaders/shader-package.zip filter=lfs diff=lfs merge=lfs -text
TADemo/SERVER.EXE filter=lfs diff=lfs merge=lfs -text
TADemo/bitmaps/ocean.jpg filter=lfs diff=lfs merge=lfs -text
TADemo/3DTA.exe filter=lfs diff=lfs merge=lfs -text
TADemo/HPIUtil.dll filter=lfs diff=lfs merge=lfs -text
TADemo/bagge.fnt filter=lfs diff=lfs merge=lfs -text
TADemo/bitmaps/detailtex.jpg filter=lfs diff=lfs merge=lfs -text
TADemo/bitmaps/gran.bmp filter=lfs diff=lfs merge=lfs -text
TADemo/bitmaps/gran2.bmp filter=lfs diff=lfs merge=lfs -text
TADemo/3DTAConfig.exe filter=lfs diff=lfs merge=lfs -text
ProTA 4.4 changelog.txt
+1 -1
View File
@@ -235,7 +235,7 @@ Arm Maverick:
Arm Shooter:
Reduced health (1250->960)
Reduced turn rate (1216->608)
Reduced torse aiming rate (210->105)
Reduced torso aiming rate (210->105)
Core Sumo:
Increased build time (14268->15365)
ProTA 4.5 changelog.txt
+361
View File
@@ -0,0 +1,361 @@
ProTA 4.5 changelog (test version)
------------------------------------
GUI notes:
- Edited title screen
- Edited build menu side panel
- Fixed campaign build menu glitches
- Re-enabled unit limit slider in battleroom
Gameplay notes:
- Fixed campaign AI not building
- Fixed Core Mission 1, now has 1080p support
- Added missing special damages for seaplanes to Phoenix/Hurricane's laser
- Added missing special damages for seaplanes to Krogoth's rocket
- Fixed Core Adv Kbot Lab yardmap to allow units to leave from the sides better
- Improved Arm Hammer delay before firing
- Added .exe hacks:
- Fix "Necro: Resurrection failed" misspelling
- Prevent reclaiming feature sound from looping until finished (only plays it once)
- Correct the reclaim sound when VTOL starts reclaiming a unit
- Always show all player data at final scoreboard, even if they left
- Allow AI to build and fire nukes/anti nukes
- Prevent AI from infinitely queueing stockpile weapons
- Allow AI to turn off any energy-hungry appliances when energy is low
- Increase number of build units (labs + construction + Commander himself) before AI Commanders go into repair patrol mode, from 5 to 10
Other notes:
- CnC-DDraw 5.1.0.0 by FunkyFr3sh included in install
- WGMUS 0.0.17 by MnHebi included in install
- Moved CTRL+F2 menu to Settings.ini and ChatMacro.ini
Commanders
------------------------------------
Arm Commander:
Increased death explosion AOE (550->580)
Core Commander:
Increased death explosion AOE (550->580)
Buildings
------------------------------------
Arm Metal Storage:
Reduced metal cost (320->256)
Core Metal Storage:
Reduced metal cost (305->244)
Arm Hovercraft Platform:
Reduced energy cost (3166->2111)
Reduced metal cost (1364->1254)
Core Hovercraft Platform:
Reduced energy cost (3252->2168)
Reduced metal cost (1327->1210)
Arm Underwater Metal Extractor:
Reduced energy cost (1037->881)
Reduced metal cost (100->91)
Reduced health (330->280)
Core Underwater Metal Extractor:
Reduced build time (4587->4357)
Reduced energy cost (1059->900)
Reduced metal cost (95->87)
Reduced health (355->275)
Arm Underwater Metal Storage:
Reduced metal cost (360->288)
Core Underwater Metal Storage:
Reduced metal cost (350->280)
Arm Sentinel:
Increased health (1200->1250)
Reduced range (550->500)
Core Gaat Gun:
Increased health (1230->1280)
Reduced range (550->500)
Kbots
------------------------------------
Arm Construction Kbot:
Increased build time (3358->3638)
Core Construction Kbot:
Increased build time (3490->3782)
Arm Rocko:
Removed guidance
Core Storm:
Removed guidance
Vehicles
------------------------------------
Arm Jeffy:
Increased aim speed (90->180)
Core Weasel:
Increased aim speed (90->180)
Aircraft
------------------------------------
Arm Thunder:
Reduced speed (9->8.6)
Increased attack run length (120->160)
Hovercraft
------------------------------------
Arm Construction Hovercraft:
Reduced energy cost (3059->2841)
Reduced metal cost (277->267)
Reduced build time (6977->6296)
Core Construction Hovercraft:
Reduced energy cost (3118->2896)
Reduced metal cost (273->263)
Reduced build time (7333->6617)
Arm Skimmer:
Increased aim speed (150->240)
Core Scrubber:
Increased aim speed (150->240)
Arm Anaconda:
Reduced build time (4463->4058)
Increased aiming speed (170->255)
Core Snapper:
Reduced build time (4710->4282)
Increased aiming speed (150->235)
Arm Swatter:
Reduced build time (3747->3372)
Core Slinger:
Reduced build time (3747->3372)
Arm Wombat:
Reduced build time (5972->5380)
Core Nixer:
Reduced build time (6368->5737)
Seaplanes
------------------------------------
Arm Albatross:
Changed death explosion (BIG_UNITEX -> SMALL_UNITEX) (50 damage, 110 AOE -> 30 damage, 30 AOE)
Core Typhoon:
Changed death explosion (BIG_UNITEX -> SMALL_UNITEX) (50 damage, 110 AOE -> 30 damage, 30 AOE)
Advanced Buildings
------------------------------------
Arm Adv. Aircraft Plant
Increased metal cost (2210->2341)
Core Adv. Aircraft Plant
Increased metal cost (2191->2410)
Arm Moho Mine:
Increased energy cost (2897->4350)
Increased metal cost (502->754)
Increased build time (11905->17875)
Core Moho Mine:
Increased energy cost (3010->4561)
Increased metal cost (483->725)
Increased build time (10823->16250)
Arm Cloakable Fusion Reactor:
Increased energy cost (42058->52573)
Increased metal cost (5420->6775)
Increased build time (105487->131859)
Increased energy production (1000->1250)
Core Cloakable Fusion Reactor:
Increased energy cost (46225->57781)
Increased metal cost (5321->6651)
Increased build time (111874->139843)
Increased energy production (1050->1300)
Arm Big Bertha:
Increased reload time (7.5->8)
Core Intimidator:
Increased accuracy (750->625)
Increased reload time (8->8.5)
Arm Annihilator:
Reduced energy per shot (2000->1500)
Increased health (2820->2960)
Arm Stunner:
Increased area of effect (512->640)
Core Neutron:
Increased area of effect (512->640)
Arm Retaliator:
Increased area of effect (512->640)
Core Silencer:
Increased area of effect (512->640)
Advanced Kbots
------------------------------------
Core Pyro:
Reduced health (1400->1350)
Core Gimp:
Changed AA missile to AA only
Reduced missile reload time (4->2)
Increased missile damage to air (80->90)
Increased weapon velocity (900->1000)
Increased weapon acceleration (300->350)
Reduced turn rate (700->600)
Arm Fido:
Reduced build time (8661->8120)
Increased health (1250->1300)
Converted to triple shot burst weapon
Reduced damage per shot (140->65)
Increased DPS (53.85->75)
Reduced bullet velocity (400->350)
Core Morty:
Reduced damage per shot (80->65)
Reduced reload time (1.6->1.45)
Reduced DPS (50->44.82)
Core Can:
Increased speed (0.8->0.85)
Core Dominator:
Increased build time (10382->11420)
Reduced speed (1.1->1)
Reduced turn rate (700->600)
Reduced health (1550->1500)
Arm Shooter:
Increased energy cost (8976->10309)
Reduced damage per shot (1500->1250)
Reduced reload time (10->9)
Reduced DPS (150->138.88)
Core Sumo:
Increased energy cost (5987->11974)
Increased build time (15365->19206)
Reduced health (5500->5000)
Reduced damage per shot (420->400)
Increased reload time (1.75->2)
Reduced DPS (240->200)
Advanced Vehicles
------------------------------------
Arm Panther:
Reduced range (200->190)
Arm Triton:
Reduced health (2400->2276)
Core Crock:
Reduced health (2288->2174)
Core Diplomat:
Increased rocket weapon velocity (575->600)
Increased rocket weapon acceleration (76->80)
Arm Penetrator:
Increased energy cost (6991->11360)
Core Goliath:
Increased build time (12947->13410)
Increased energy cost (3906->7812)
Increased turn rate (206->270)
Increased aim speed (80->115)
Arm Phalanx:
Increased health (1273->1397)
Core Copperhead:
Increased health (1404->1541)
Advanced Aircraft
------------------------------------
Arm Phoenix:
Increased energy cost (7624->8768)
Increased build time (16064->17670)
Core Hurricane:
Increased energy cost (8050->8855)
Increased build time (16269->17896)
Arm Lancet:
Increased turn rate (420->462)
Increased weapon velocity (150->175)
Reduced reload time (8.5->4.25)
Core Titan:
Increased turn rate (409->450)
Increased weapon velocity (150->175)
Reduced reload time (9->4.5)
Advanced Ships
------------------------------------
Arm Ranger:
Increased radar distance (0->1250)
Increased missile weapon velocity (450->650)
Increased missile start velocity (430->450)
Reduced rocket reload time (12->10)
Increased brake rate (0.032->0.064)
Core Hydra:
Increased missile weapon velocity (450->650)
Increased missile start velocity (400->450)
Reduced rocket reload time (11->9)
Increased brake rate (0.03->0.06)
Arm Archer:
Increased missile weapon velocity (450->650)
Increased missile start velocity (430->450)
Core Shredder:
Increased missile weapon velocity (450->650)
Increased missile start velocity (430->450)
Arm Piranha:
Reduced build time (17767->15102)
Core Shark:
Reduced build time (17529->14900)
ProTA readme.txt
+1
View File
@@ -31,6 +31,7 @@ Switeck - I used many fixes from Switeck's TA Bugfix. Some of the fixes I disagr
ArmouredFish - Helped me a lot with scripting, helped me implement some game changing fixes such as non blocking sea wreckages and offered a lot of general TA knowledge throughout the process
Vohvelieläin - Helped me a lot with his modding knowledge and helped edit some models and scripts
Thaldren - Improved performance in Windows 10 and helped setup the ProTA recorder
FunkyFr3sh - Helped fix bugs with ddraw and spent time making CnC-ddraw work flawlessly with TA
Axle1975 - Helped me fix some issues with the recorder and gave ProTA a platform for competitive play (www.taforever.com)
poosticks - I used his TA guide extensively throughout the modding process to check unit stats and other details
Idec Sdawkminn - I used his TAU forum posts "Complete Unit FBI Guide" and "Comprehensive Weapons Guide" a lot which were massively useful when learning how to mod TA
ProTA.gp3
LFS
BIN
View File
Binary file not shown.
Settings.ini
+278
View File
@@ -0,0 +1,278 @@
; ProTA 4.5 settings
[Settings]
; Use a different order for autoclick queues when the footprint is set to 2
; Construction units will spend ever so slightly less time building lines of Dragon Teeth this way
OptimizeDTEnabled=1
; Creates a full ring queue when the footprints of the structure being queued and the structure you
; are queuing around don't match up
FullRingsEnabled=0
; The code for the key that controls the whiteboard features
WhiteboardKey=220
; The code for the key that toggles the full screen megamap mode
MegaMapKey=115
; The code for the key that controls the autoclick features
BuildLinesRingsKey=88
; The color of the regions outside of the megamap area
; Setting this to anything other than black highlights the edge of the playable area when unmapped
; Set to 95 as default which is a dark grey
MegaMapEmptyRegionColor=95
; The position of the income display box
; This will update itself when moved in game
IncomePosX=1749
IncomePosY=32
; Fully solid background color behind the income display box
IncomeBackgroundEnabled=0
; Change the color of the fully solid background colour behind the income display box
IncomeBackgroundColor=95
; Text only background behind the income display box
IncomeTextBackgroundEnabled=1
; Change the color of the text only background behind the income display box
IncomeTextBackgroundColor=95
------------------------------------------------------------------------------------------------------
; ProTA 4.5 advanced settings
; Windowed mode will disable many TA v3.9.02 features (including some of these) and is not recommended
[Preferences] ; custom settings, if any entry is disabled the "TA v3.9.02 default" values will be used
; Disabled in tdraw.dll
;UseVideoMemory = TRUE;
; Unit limit per player
; Set from 20 - 6553 (setting higher than 1500 may cause instability)
; TA v3.1 default is 250
; TA v3.9.02 default is 1500
; ProTA 4.5 default is 1500
; Broken atm (*playx overwrites this setting forcibly to 1500)
UnitLimit = 1500;
; Pathfinding cycles
; Setting too low (such as TA v3.1 default) ruins pathfinding but setting extremely high lowers fps
; TA v3.1 default is 1333
; TA v3.9.02 default is 66650
; ProTA 4.5 default is 66650
AISearchMapEntries = 66650;
; Special effects limit (smoke, etc.)
; Setting too low (such as TA v3.1 default) will degrade visual quality
; This setting is still experimental, if you experience visual issues set to 400
; TA v3.1 default is 400
; TA v3.9.02 default is 20480
; ProTA 4.5 default is 20480
SfxLimit = 20480;
; Unit model size limit
; Set max width and height for unit model drawing buffer
; TA v3.1 default is 600x600
; TA v3.9.02 default is 1280x1280
; ProTA 4.5 default is 1280x1280
X_CompositeBuf = 1280;
Y_CompositeBuf = 1280;
; Unit ID limit
; Set the maximum number of unique unit IDs
; TA v3.1 default is 512
; TA v3.9.02 default is 16000
; ProTA 4.5 default is 16000
UnitType = 16000;
; Weapon ID limit
; Set the maximum number of unique weapon IDs
; TA v3.1 default is 256
; TA v3.9.02 default is 16000
; ProTA 4.5 default is 16000
WeaponType = 16000;
; Weapon ID multiplayer patch
; Set to TRUE to enable increased Weapon ID limit in multiplayer
; Set to FALSE to allow increased Weapon ID limit only in single player
; TA v3.1 default is FALSE
; TA v3.9.02 default is FALSE (Weapon ID limit increase not yet compatible with Replayer)
; ProTA 4.5 default is FALSE
MultiGameWeapon = FALSE;
; Double-click selection
; Enable or disable the new "double-click to select all units of the same type on screen" feature
; TA v3.1 default is FALSE
; TA v3.9.02 default is TRUE
; ProTA 4.5 default is TRUE
DoubleClick = TRUE;
; Expanded Multiplayer Sharing Menu
; Enable or disable the new expanded multiplayer sharing menu
; TA v3.1 default is FALSE
; TA v3.9.02 default is TRUE
; ProTA 4.5 default is TRUE
ShareDialogExpand = TRUE;
; Main menu resolution adjuster
; Set to FALSE to keep main menu resolution at the default 640x480
; Set to TRUE to match main menu resolution to the in-game resolution set via options menu
; If TRUE, the main menu will not be upscaled to fit increased output resolution
; If resolution is not valid, the game will not start (use resolution overrider below to fix)
; TA v3.1 default is FALSE
; TA v3.9.02 default is FALSE
; ProTA 4.5 default is FALSE
MenuResolution = FALSE;
; Megamap
; Enable or disable the new megamap
; TA v3.1 default is FALSE
; TA v3.9.02 default is TRUE
; ProTA 4.5 default is TRUE
FullScreenMinimap = TRUE;
; Megamap FPS Limit
MegamapFpsLimit = 1000;
; Megamap Icon Configuration File
; Set the location of the megamap's icon configuration file
; TA v3.9.02 default is .\Icon\iconcfg.ini
MegaMapConfig = .\Icon\iconcfg.ini;
; Megamap Configuration Settings
; Use the fields below to customize the megamap
; Megamap Mouse Wheel Zooming
; Enable or disable ability to zoom in and out of the megamap with the mouse wheel
; TA v3.9.02 default is TRUE
; ProTA 4.5 default is TRUE
WheelZoom = TRUE;
; Megamap Mouse Wheel Zoom In Mode
; Set to TRUE to zoom to the cursor location when rolling the wheel up from the megamap
; Set to FALSE to zoom to the previous camera location when rolling the wheel up from the megamap
; TA v3.9.02 default is TRUE
; ProTA 4.5 default is TRUE
WheelMoveMegaMap = TRUE;
; Megamap Double-Click to Zoom Option
; Enable or disable the option to zoom to the cursor location...
; ...when double-clicking terrain on the megamap
; TA v3.9.02 default is FALSE
; ProTA 4.5 default is FALSE
DoubleClickMoveMegamap = FALSE;
; Megamap Unit Icon Flashing When Under Attack
; Enable or disable megamap unit icon flashing when under attack
UnderAttackFlash=TRUE;
; Megamap Minimum Sensor Range Ring Distances
; Set the minimum sensor values required to display range rings on the megamap
; These settings could be helpful if you want to eliminate clutter from short-ranged rings
; TA v3.9.02 default is 0 for all sensors
; ProTA 4.5 default is 0 for all sensors
MegamapRadarMinimum = 0;
MegamapSonarMinimum = 0;
MegamapSonarJamMinimum = 0;
MegamapRadarJamMinimum = 0;
MegamapAntiNukeMinimum = 0;
; Player Icon and Line Marker Colors
; Customize the colors of the player minimap/megamap icons and line markers
; Set from 0 to 255 to select colors from the TA indexed color palette
; These settings are disabled by default (remove the semicolons to enable)
Player1DotColors=252; ;Default is 227 ProTA 4.5 default is 252
Player2DotColors=249; ;Default is 212 ProTA 4.5 default is 249
Player3DotColors=80; ;Default is 80 ProTA 4.5 default is 80
Player4DotColors=250; ;Default is 235 ProTA 4.5 default is 250
Player5DotColors=66; ;Default is 108 ProTA 4.5 default is 66
Player6DotColors=148; ;Default is 219 ProTA 4.5 default is 148
Player7DotColors=208; ;Default is 208 ProTA 4.5 default is 208
Player8DotColors=0; ;Default is 93 ProTA 4.5 default is 0
Player9DotColors=210; ;Default is 130 ProTA 4.5 default is 210
Player10DotColors=33; ;Default is 67 ProTA 4.5 default is 33
; Player Dot Marker Colors
; Customize the colors of player dot markers by setting a custom icon file
; Edit the example smallcircle.pcx file or create a new icon file
; The icon file must contain all 10 player markers from left to right
; The icon width and height settings must match the dimensions of your icons
; These settings are disabled by default (remove the semicolons to enable)
PerPlayerMarkerWidth=10;
PerPlayerMarkerHeight=10;
PlayerMarkerPcx=Icon\smallcircle.pcx;
[REG] ; registry override settings, if any entry is disabled the last value used will be remembered
; Sound mode
; Set to 0 for no sound, 1 for mono sound, and 2 for 3D positional sound
; When set to 3D, the speaker layout is read from the Windows control panel
; All speaker layouts are supported by the 3D sound engine (stereo, 5.1, 7.1, etc.)
; TA v3.1 default is Mono (dword:1)
; TA v3.9.02 default is 3D (dword:2)
; ProTA 4.5 default is 3D (dword:2)
"Sound Mode" = dword:2
; Max number of simultaneous sounds before sounds are cut off
; Set from 2 - 32 for specific limits or 33 or higher for unlimited
; TA v3.1 default is 8 (dword:8)
; TA v3.9.02 default is 128 / unlimited (dword:128)
; ProTA 4.5 default is 128 / unlimited (dword:128)
"MixingBuffers" = dword:128
; Default game speed
; Set from 0 - 20 (corresponding to game speed -10 to +10)
; Use plus and minus keys to adjust while playing
; TA and TA v3.9.02 default is 10 which is equivalent to Normal game speed (dword:10)
; ProTA 4.5 default is 10 which is equivalent to Normal game speed (dword:10)
"GameSpeed" = dword:10
; Group selection hotkey modifier
; Set to 1 to select unit groups with number key and build menus with ALT + number key
; Set to 0 to select build menus with number key and unit groups with ALT + number key
; TA v3.1 default is 0 (dword:0)
; TA v3.9.02 default is 1 (dword:1)
; ProTA 4.5 default is 1 (dword:1)
"SwitchAlt" = dword:1
; Max number of players in skirmish mode
; Set from 2 - 10
; TA v3.1 default is 4 (dword:4)
; TA v3.9.02 default is 10 (dword:10)
; ProTA 4.5 default is 10 (dword:10)
"NumSkirmishPlayers" = dword:10
; Default setting for display of chat messages from other players
; Set to 1 to enable and 0 to disable
; Use "+screenchat" command in-game to toggle setting for the current game
; TA and TA v3.9.02 default is 1
; ProTA 4.5 default is 1
"ScreenChat" = dword:1
; Music playback mode
; Set to 1 for Play All, 2 for Random, 3 for Repeat, and 4 for Custom.
; When set to Custom, the game will attempt to use the dynamic build/battle system...
; ...however this mode is buggy and almost never works correctly on modern systems...
; ...resulting in only a single track being played, either stopping thereafter (CD version)...
; ...or looping forever (MP3 version), therefore Random is best for most people
; TA v3.1 default is Custom (dword:4)
; TA v3.9.02 default is Random (dword:2)
; ProTA 4.5 default is Random (dword:2)
"CDMode" = dword:2
; Resolution overrider (disabled by default)
; Use this to override the resolution set in the options menu (remove semicolons to enable)
; All resolutions and aspect ratios supported by your setup are supported by the game...
; ...as long as they are available in 8-bit color depth (if not, create a custom resolution)
; If you set a resolution not supported by your setup (driver or display) the game will crash
; The override is set at game launch, using options menu will defeat override until next launch
; Example: dword:1920 x dword:1080 (1920x1080)
;"DisplayModeWidth" = dword:1920
;"DisplayModeHeight" = dword:1080
Shaders/crt/crt-lottes-fast-no-warp-bilinear.glsl
+701
View File
@@ -0,0 +1,701 @@
//_____________________________/\_______________________________
//==============================================================
//
//
// [CRTS] PUBLIC DOMAIN CRT-STYLED SCALAR - 20180120b
//
// by Timothy Lottes
// https://www.shadertoy.com/view/MtSfRK
// adapted for RetroArch by hunterk
//
//
//==============================================================
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//_____________________________/\_______________________________
//==============================================================
//
// WHAT'S NEW
//
//--------------------------------------------------------------
// Evolution of prior shadertoy example
//--------------------------------------------------------------
// This one is semi-optimized
// - Less texture fetches
// - Didn't get to instruction level optimization
// - Could likely use texture fetch to generate phosphor mask
//--------------------------------------------------------------
// Added options to disable unused features
//--------------------------------------------------------------
// Added in exposure matching
// - Given scan-line effect and mask always darkens image
// - Uses generalized tonemapper to boost mid-level
// - Note this can compress highlights
// - And won't get back peak brightness
// - But best option if one doesn't want as much darkening
//--------------------------------------------------------------
// Includes option saturation and contrast controls
//--------------------------------------------------------------
// Added in subtractive aperture grille
// - This is a bit brighter than prior
//--------------------------------------------------------------
// Make sure input to this filter is already low-resolution
// - This is not designed to work on titles doing the following
// - Rendering to hi-res with nearest sampling
//--------------------------------------------------------------
// Added a fast and more pixely option for 2 tap/pixel
//--------------------------------------------------------------
// Improved the vignette when WARP is enabled
//--------------------------------------------------------------
// Didn't test HLSL or CPU options
// - Will incorportate patches if they are broken
// - But out of time to try them myself
//==============================================================
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//_____________________________/\_______________________________
//==============================================================
//
// LICENSE = UNLICENSE (aka PUBLIC DOMAIN)
//
//--------------------------------------------------------------
// This is free and unencumbered software released into the
// public domain.
//--------------------------------------------------------------
// Anyone is free to copy, modify, publish, use, compile, sell,
// or distribute this software, either in source code form or as
// a compiled binary, for any purpose, commercial or
// non-commercial, and by any means.
//--------------------------------------------------------------
// In jurisdictions that recognize copyright laws, the author or
// authors of this software dedicate any and all copyright
// interest in the software to the public domain. We make this
// dedication for the benefit of the public at large and to the
// detriment of our heirs and successors. We intend this
// dedication to be an overt act of relinquishment in perpetuity
// of all present and future rights to this software under
// copyright law.
//--------------------------------------------------------------
// 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 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.
//--------------------------------------------------------------
// For more information, please refer to
// <http://unlicense.org/>
//==============================================================
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
#pragma parameter MASK "Mask Type" 1.0 0.0 3.0 1.0
#pragma parameter MASK_INTENSITY "Mask Intensity" 0.5 0.0 1.0 0.05
#pragma parameter SCANLINE_THINNESS "Scanline Intensity" 0.5 0.0 1.0 0.1
#pragma parameter SCAN_BLUR "Sharpness" 2.5 1.0 3.0 0.1
#pragma parameter CURVATURE "Curvature" 0.02 0.0 0.25 0.01
#pragma parameter TRINITRON_CURVE "Trinitron-style Curve" 0.0 0.0 1.0 1.0
#pragma parameter CORNER "Corner Round" 3.0 0.0 11.0 1.0
#pragma parameter CRT_GAMMA "CRT Gamma" 2.4 0.0 51.0 0.1
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
// compatibility #defines
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
void main()
{
gl_Position = MVPMatrix * VertexCoord;
TEX0.xy = TexCoord.xy;
}
#elif defined(FRAGMENT)
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out COMPAT_PRECISION vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
#ifdef PARAMETER_UNIFORM
uniform COMPAT_PRECISION float CRT_GAMMA;
uniform COMPAT_PRECISION float SCANLINE_THINNESS;
uniform COMPAT_PRECISION float SCAN_BLUR;
uniform COMPAT_PRECISION float MASK_INTENSITY;
uniform COMPAT_PRECISION float CURVATURE;
uniform COMPAT_PRECISION float CORNER;
uniform COMPAT_PRECISION float MASK;
uniform COMPAT_PRECISION float TRINITRON_CURVE;
#else
#define CRT_GAMMA 2.4
#define SCANLINE_THINNESS 0.5
#define SCAN_BLUR 2.5
#define MASK_INTENSITY 0.54
#define CURVATURE 0.00
#define CORNER 3.0
#define MASK 1.0
#define TRINITRON_CURVE 0.0
#endif
//_____________________________/\_______________________________
//==============================================================
//
// GAMMA FUNCTIONS
//
//--------------------------------------------------------------
//--------------------------------------------------------------
// Since shadertoy doesn't have sRGB textures
// And we need linear input into shader
// Don't do this in your code
float FromSrgb1(float c){
return (c<=0.04045)?c*(1.0/12.92):
pow(c*(1.0/1.055)+(0.055/1.055),CRT_GAMMA);}
//--------------------------------------------------------------
vec3 FromSrgb(vec3 c){return vec3(
FromSrgb1(c.r),FromSrgb1(c.g),FromSrgb1(c.b));}
// Convert from linear to sRGB
// Since shader toy output is not linear
float ToSrgb1(float c){
return(c<0.0031308?c*12.92:1.055*pow(c,0.41666)-0.055);}
//--------------------------------------------------------------
vec3 ToSrgb(vec3 c){return vec3(
ToSrgb1(c.r),ToSrgb1(c.g),ToSrgb1(c.b));}
//--------------------------------------------------------------
//_____________________________/\_______________________________
//==============================================================
//
// DEFINES
//
//--------------------------------------------------------------
// CRTS_CPU - CPU code
// CRTS_GPU - GPU code
//--------------------------------------------------------------
// CRTS_GLSL - GLSL
// CRTS_HLSL - HLSL (not tested yet)
//--------------------------------------------------------------
// CRTS_DEBUG - Define to see on/off split screen
//--------------------------------------------------------------
// CRTS_WARP - Apply screen warp
//--------------------------------------------------------------
// CRTS_2_TAP - Faster very pixely 2-tap filter (off is 8)
//--------------------------------------------------------------
// CRTS_MASK_GRILLE - Aperture grille (aka Trinitron)
// CRTS_MASK_GRILLE_LITE - Brighter (subtractive channels)
// CRTS_MASK_NONE - No mask
// CRTS_MASK_SHADOW - Horizontally stretched shadow mask
//--------------------------------------------------------------
// CRTS_TONE - Normalize mid-level and process color
// CRTS_CONTRAST - Process color - enable contrast control
// CRTS_SATURATION - Process color - enable saturation control
//--------------------------------------------------------------
#define CRTS_STATIC
#define CrtsPow
#define CRTS_RESTRICT
//==============================================================
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//==============================================================
// SETUP FOR CRTS
//--------------------------------------------------------------
//==============================================================
//#define CRTS_DEBUG 1
#define CRTS_GPU 1
#define CRTS_GLSL 1
//--------------------------------------------------------------
//#define CRTS_2_TAP 1
//--------------------------------------------------------------
#define CRTS_TONE 1
#define CRTS_CONTRAST 0
#define CRTS_SATURATION 0
//--------------------------------------------------------------
#define CRTS_WARP 1
//--------------------------------------------------------------
// Try different masks -> moved to runtime parameters
//#define CRTS_MASK_GRILLE 1
//#define CRTS_MASK_GRILLE_LITE 1
//#define CRTS_MASK_NONE 1
//#define CRTS_MASK_SHADOW 1
//--------------------------------------------------------------
// Scanline thinness
// 0.50 = fused scanlines
// 0.70 = recommended default
// 1.00 = thinner scanlines (too thin)
#define INPUT_THIN 0.5 + (0.5 * SCANLINE_THINNESS)
//--------------------------------------------------------------
// Horizonal scan blur
// -3.0 = pixely
// -2.5 = default
// -2.0 = smooth
// -1.0 = too blurry
#define INPUT_BLUR -1.0 * SCAN_BLUR
//--------------------------------------------------------------
// Shadow mask effect, ranges from,
// 0.25 = large amount of mask (not recommended, too dark)
// 0.50 = recommended default
// 1.00 = no shadow mask
#define INPUT_MASK 1.0 - MASK_INTENSITY
//--------------------------------------------------------------
#define INPUT_X InputSize.x
#define INPUT_Y InputSize.y
//--------------------------------------------------------------
// Setup the function which returns input image color
vec3 CrtsFetch(vec2 uv){
// For shadertoy, scale to get native texels in the image
uv*=vec2(INPUT_X,INPUT_Y)/TextureSize.xy;
// Move towards intersting parts
// uv+=vec2(0.5,0.5);
// Non-shadertoy case would not have the color conversion
return FromSrgb(COMPAT_TEXTURE(Texture,uv.xy,-16.0).rgb);}
#endif
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//_____________________________/\_______________________________
//==============================================================
//
// GPU CODE
//
//==============================================================
#ifdef CRTS_GPU
//_____________________________/\_______________________________
//==============================================================
// PORTABILITY
//==============================================================
#ifdef CRTS_GLSL
#define CrtsF1 float
#define CrtsF2 vec2
#define CrtsF3 vec3
#define CrtsF4 vec4
#define CrtsFractF1 fract
#define CrtsRcpF1(x) (1.0/(x))
#define CrtsSatF1(x) clamp((x),0.0,1.0)
//--------------------------------------------------------------
CrtsF1 CrtsMax3F1(CrtsF1 a,CrtsF1 b,CrtsF1 c){
return max(a,max(b,c));}
#endif
//==============================================================
#ifdef CRTS_HLSL
#define CrtsF1 float
#define CrtsF2 float2
#define CrtsF3 float3
#define CrtsF4 float4
#define CrtsFractF1 frac
#define CrtsRcpF1(x) (1.0/(x))
#define CrtsSatF1(x) saturate(x)
//--------------------------------------------------------------
CrtsF1 CrtsMax3F1(CrtsF1 a,CrtsF1 b,CrtsF1 c){
return max(a,max(b,c));}
#endif
//_____________________________/\_______________________________
//==============================================================
// TONAL CONTROL CONSTANT GENERATION
//--------------------------------------------------------------
// This is in here for rapid prototyping
// Please use the CPU code and pass in as constants
//==============================================================
CrtsF4 CrtsTone(
CrtsF1 contrast,
CrtsF1 saturation,
CrtsF1 thin,
CrtsF1 mask){
//--------------------------------------------------------------
if(MASK == 0.0) mask=1.0;
//--------------------------------------------------------------
if(MASK == 1.0){
// Normal R mask is {1.0,mask,mask}
// LITE R mask is {mask,1.0,1.0}
mask=0.5+mask*0.5;
}
//--------------------------------------------------------------
CrtsF4 ret;
CrtsF1 midOut=0.18/((1.5-thin)*(0.5*mask+0.5));
CrtsF1 pMidIn=pow(0.18,contrast);
ret.x=contrast;
ret.y=((-pMidIn)+midOut)/((1.0-pMidIn)*midOut);
ret.z=((-pMidIn)*midOut+pMidIn)/(midOut*(-pMidIn)+midOut);
ret.w=contrast+saturation;
return ret;}
//_____________________________/\_______________________________
//==============================================================
// MASK
//--------------------------------------------------------------
// Letting LCD/OLED pixel elements function like CRT phosphors
// So "phosphor" resolution scales with display resolution
//--------------------------------------------------------------
// Not applying any warp to the mask (want high frequency)
// Real aperture grille has a mask which gets wider on ends
// Not attempting to be "real" but instead look the best
//--------------------------------------------------------------
// Shadow mask is stretched horizontally
// RRGGBB
// GBBRRG
// RRGGBB
// This tends to look better on LCDs than vertical
// Also 2 pixel width is required to get triad centered
//--------------------------------------------------------------
// The LITE version of the Aperture Grille is brighter
// Uses {dark,1.0,1.0} for R channel
// Non LITE version uses {1.0,dark,dark}
//--------------------------------------------------------------
// 'pos' - This is 'fragCoord.xy'
// Pixel {0,0} should be {0.5,0.5}
// Pixel {1,1} should be {1.5,1.5}
//--------------------------------------------------------------
// 'dark' - Exposure of of masked channel
// 0.0=fully off, 1.0=no effect
//==============================================================
CrtsF3 CrtsMask(CrtsF2 pos,CrtsF1 dark){
if(MASK == 2.0){
CrtsF3 m=CrtsF3(dark,dark,dark);
CrtsF1 x=CrtsFractF1(pos.x*(1.0/3.0));
if(x<(1.0/3.0))m.r=1.0;
else if(x<(2.0/3.0))m.g=1.0;
else m.b=1.0;
return m;
}
//--------------------------------------------------------------
if(MASK == 1.0){
CrtsF3 m=CrtsF3(1.0,1.0,1.0);
CrtsF1 x=CrtsFractF1(pos.x*(1.0/3.0));
if(x<(1.0/3.0))m.r=dark;
else if(x<(2.0/3.0))m.g=dark;
else m.b=dark;
return m;
}
//--------------------------------------------------------------
if(MASK == 0.0){
return CrtsF3(1.0,1.0,1.0);
}
//--------------------------------------------------------------
if(MASK == 3.0){
pos.x+=pos.y*2.9999;
CrtsF3 m=CrtsF3(dark,dark,dark);
CrtsF1 x=CrtsFractF1(pos.x*(1.0/6.0));
if(x<(1.0/3.0))m.r=1.0;
else if(x<(2.0/3.0))m.g=1.0;
else m.b=1.0;
return m;
}
}
//_____________________________/\_______________________________
//==============================================================
// FILTER ENTRY
//--------------------------------------------------------------
// Input must be linear
// Output color is linear
//--------------------------------------------------------------
// Must have fetch function setup: CrtsF3 CrtsFetch(CrtsF2 uv)
// - The 'uv' range is {0.0 to 1.0} for input texture
// - Output of this must be linear color
//--------------------------------------------------------------
// SCANLINE MATH & AUTO-EXPOSURE NOTES
// ===================================
// Each output line has contribution from at most 2 scanlines
// Scanlines are shaped by a windowed cosine function
// This shape blends together well with only 2 lines of overlap
//--------------------------------------------------------------
// Base scanline intensity is as follows
// which leaves output intensity range from {0 to 1.0}
// --------
// thin := range {thick 0.5 to thin 1.0}
// off := range {0.0 to <1.0},
// sub-pixel offset between two scanlines
// --------
// a0=cos(min(0.5, off *thin)*2pi)*0.5+0.5;
// a1=cos(min(0.5,(1.0-off)*thin)*2pi)*0.5+0.5;
//--------------------------------------------------------------
// This leads to a image darkening factor of roughly:
// {(1.5-thin)/1.0}
// This is further reduced by the mask:
// {1.0/2.0+mask*1.0/2.0}
// Reciprocal of combined effect is used for auto-exposure
// to scale up the mid-level in the tonemapper
//==============================================================
CrtsF3 CrtsFilter(
//--------------------------------------------------------------
// SV_POSITION, fragCoord.xy
CrtsF2 ipos,
//--------------------------------------------------------------
// inputSize / outputSize (in pixels)
CrtsF2 inputSizeDivOutputSize,
//--------------------------------------------------------------
// 0.5 * inputSize (in pixels)
CrtsF2 halfInputSize,
//--------------------------------------------------------------
// 1.0 / inputSize (in pixels)
CrtsF2 rcpInputSize,
//--------------------------------------------------------------
// 1.0 / outputSize (in pixels)
CrtsF2 rcpOutputSize,
//--------------------------------------------------------------
// 2.0 / outputSize (in pixels)
CrtsF2 twoDivOutputSize,
//--------------------------------------------------------------
// inputSize.y
CrtsF1 inputHeight,
//--------------------------------------------------------------
// Warp scanlines but not phosphor mask
// 0.0 = no warp
// 1.0/64.0 = light warping
// 1.0/32.0 = more warping
// Want x and y warping to be different (based on aspect)
CrtsF2 warp,
//--------------------------------------------------------------
// Scanline thinness
// 0.50 = fused scanlines
// 0.70 = recommended default
// 1.00 = thinner scanlines (too thin)
// Shared with CrtsTone() function
CrtsF1 thin,
//--------------------------------------------------------------
// Horizonal scan blur
// -3.0 = pixely
// -2.5 = default
// -2.0 = smooth
// -1.0 = too blurry
CrtsF1 blur,
//--------------------------------------------------------------
// Shadow mask effect, ranges from,
// 0.25 = large amount of mask (not recommended, too dark)
// 0.50 = recommended default
// 1.00 = no shadow mask
// Shared with CrtsTone() function
CrtsF1 mask,
//--------------------------------------------------------------
// Tonal curve parameters generated by CrtsTone()
CrtsF4 tone
//--------------------------------------------------------------
){
//--------------------------------------------------------------
#ifdef CRTS_DEBUG
CrtsF2 uv=ipos*rcpOutputSize;
// Show second half processed, and first half un-processed
if(uv.x<0.5){
// Force nearest to get squares
uv*=1.0/rcpInputSize;
uv=floor(uv)+CrtsF2(0.5,0.5);
uv*=rcpInputSize;
CrtsF3 color=CrtsFetch(uv);
return color;}
#endif
//--------------------------------------------------------------
// Optional apply warp
CrtsF2 pos;
#ifdef CRTS_WARP
// Convert to {-1 to 1} range
pos=ipos*twoDivOutputSize-CrtsF2(1.0,1.0);
// Distort pushes image outside {-1 to 1} range
pos*=CrtsF2(
1.0+(pos.y*pos.y)*warp.x,
1.0+(pos.x*pos.x)*warp.y);
// TODO: Vignette needs optimization
CrtsF1 vin=(1.0-(
(1.0-CrtsSatF1(pos.x*pos.x))*(1.0-CrtsSatF1(pos.y*pos.y)))) * (0.998 + (0.001 * CORNER));
vin=CrtsSatF1((-vin)*inputHeight+inputHeight);
// Leave in {0 to inputSize}
pos=pos*halfInputSize+halfInputSize;
#else
pos=ipos*inputSizeDivOutputSize;
#endif
//--------------------------------------------------------------
// Snap to center of first scanline
CrtsF1 y0=floor(pos.y-0.5)+0.5;
#ifdef CRTS_2_TAP
// Using Inigo's "Improved Texture Interpolation"
// http://iquilezles.org/www/articles/texture/texture.htm
pos.x+=0.5;
CrtsF1 xi=floor(pos.x);
CrtsF1 xf=pos.x-xi;
xf=xf*xf*xf*(xf*(xf*6.0-15.0)+10.0);
CrtsF1 x0=xi+xf-0.5;
CrtsF2 p=CrtsF2(x0*rcpInputSize.x,y0*rcpInputSize.y);
// Coordinate adjusted bilinear fetch from 2 nearest scanlines
CrtsF3 colA=CrtsFetch(p);
p.y+=rcpInputSize.y;
CrtsF3 colB=CrtsFetch(p);
#else
// Snap to center of one of four pixels
CrtsF1 x0=floor(pos.x-1.5)+0.5;
// Inital UV position
CrtsF2 p=CrtsF2(x0*rcpInputSize.x,y0*rcpInputSize.y);
// Fetch 4 nearest texels from 2 nearest scanlines
CrtsF3 colA0=CrtsFetch(p);
p.x+=rcpInputSize.x;
CrtsF3 colA1=CrtsFetch(p);
p.x+=rcpInputSize.x;
CrtsF3 colA2=CrtsFetch(p);
p.x+=rcpInputSize.x;
CrtsF3 colA3=CrtsFetch(p);
p.y+=rcpInputSize.y;
CrtsF3 colB3=CrtsFetch(p);
p.x-=rcpInputSize.x;
CrtsF3 colB2=CrtsFetch(p);
p.x-=rcpInputSize.x;
CrtsF3 colB1=CrtsFetch(p);
p.x-=rcpInputSize.x;
CrtsF3 colB0=CrtsFetch(p);
#endif
//--------------------------------------------------------------
// Vertical filter
// Scanline intensity is using sine wave
// Easy filter window and integral used later in exposure
CrtsF1 off=pos.y-y0;
CrtsF1 pi2=6.28318530717958;
CrtsF1 hlf=0.5;
CrtsF1 scanA=cos(min(0.5, off *thin )*pi2)*hlf+hlf;
CrtsF1 scanB=cos(min(0.5,(-off)*thin+thin)*pi2)*hlf+hlf;
//--------------------------------------------------------------
#ifdef CRTS_2_TAP
#ifdef CRTS_WARP
// Get rid of wrong pixels on edge
scanA*=vin;
scanB*=vin;
#endif
// Apply vertical filter
CrtsF3 color=(colA*scanA)+(colB*scanB);
#else
// Horizontal kernel is simple gaussian filter
CrtsF1 off0=pos.x-x0;
CrtsF1 off1=off0-1.0;
CrtsF1 off2=off0-2.0;
CrtsF1 off3=off0-3.0;
CrtsF1 pix0=exp2(blur*off0*off0);
CrtsF1 pix1=exp2(blur*off1*off1);
CrtsF1 pix2=exp2(blur*off2*off2);
CrtsF1 pix3=exp2(blur*off3*off3);
CrtsF1 pixT=CrtsRcpF1(pix0+pix1+pix2+pix3);
#ifdef CRTS_WARP
// Get rid of wrong pixels on edge
pixT*=vin;
#endif
scanA*=pixT;
scanB*=pixT;
// Apply horizontal and vertical filters
CrtsF3 color=
(colA0*pix0+colA1*pix1+colA2*pix2+colA3*pix3)*scanA +
(colB0*pix0+colB1*pix1+colB2*pix2+colB3*pix3)*scanB;
#endif
//--------------------------------------------------------------
// Apply phosphor mask
color*=CrtsMask(ipos,mask);
//--------------------------------------------------------------
// Optional color processing
#ifdef CRTS_TONE
// Tonal control, start by protecting from /0
CrtsF1 peak=max(1.0/(256.0*65536.0),
CrtsMax3F1(color.r,color.g,color.b));
// Compute the ratios of {R,G,B}
CrtsF3 ratio=color*CrtsRcpF1(peak);
// Apply tonal curve to peak value
#ifdef CRTS_CONTRAST
peak=pow(peak,tone.x);
#endif
peak=peak*CrtsRcpF1(peak*tone.y+tone.z);
// Apply saturation
#ifdef CRTS_SATURATION
ratio=pow(ratio,CrtsF3(tone.w,tone.w,tone.w));
#endif
// Reconstruct color
return ratio*peak;
#else
return color;
#endif
//--------------------------------------------------------------
}
void main()
{
vec2 warp_factor;
warp_factor.x = CURVATURE;
warp_factor.y = (3.0 / 4.0) * warp_factor.x; // assume 4:3 aspect
warp_factor.x *= (1.0 - TRINITRON_CURVE);
FragColor.rgb = CrtsFilter(vTexCoord.xy * OutputSize.xy*(TextureSize.xy / InputSize.xy),
InputSize.xy / OutputSize.xy,
InputSize.xy * vec2(0.5,0.5),
1.0/InputSize.xy,
1.0/OutputSize.xy,
2.0/OutputSize.xy,
InputSize.y,
warp_factor,
INPUT_THIN,
INPUT_BLUR,
INPUT_MASK,
CrtsTone(1.0,0.0,INPUT_THIN,INPUT_MASK));
// Shadertoy outputs non-linear color
FragColor.rgb=ToSrgb(FragColor.rgb);
}
#endif
Shaders/cubic/catmull-rom-bilinear.glsl
+150
View File
@@ -0,0 +1,150 @@
/*
Bicubic Catmull-Rom 9 taps (Fast) - ported by Hyllian - 2020
The following code is licensed under the MIT license: https://gist.github.com/TheRealMJP/bc503b0b87b643d3505d41eab8b332ae
Ported from code: https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
Samples a texture with Catmull-Rom filtering, using 9 texture fetches instead of 16.
See http://vec3.ca/bicubic-filtering-in-fewer-taps/ for more details
ATENTION: This code only work using LINEAR filter sampling set on Retroarch!
*/
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
precision COMPAT_PRECISION float;
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
void main()
{
gl_Position = MVPMatrix * VertexCoord;
COL0 = COLOR;
TEX0.xy = TexCoord.xy;
}
#elif defined(FRAGMENT)
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out mediump vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define outsize vec4(OutputSize, 1.0 / OutputSize)
#define mul(c,d) (d*c)
void main()
{
// We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
// down the sample location to get the exact center of our "starting" texel. The starting texel will be at
// location [1, 1] in the grid, where [0, 0] is the top left corner.
vec2 samplePos = vTexCoord * SourceSize.xy;
vec2 texPos1 = floor(samplePos - 0.5) + 0.5;
// Compute the fractional offset from our starting texel to our original sample location, which we'll
// feed into the Catmull-Rom spline function to get our filter weights.
vec2 f = samplePos - texPos1;
// Compute the Catmull-Rom weights using the fractional offset that we calculated earlier.
// These equations are pre-expanded based on our knowledge of where the texels will be located,
// which lets us avoid having to evaluate a piece-wise function.
vec2 w0 = f * (-0.5 + f * (1.0 - 0.5 * f));
vec2 w1 = 1.0 + f * f * (-2.5 + 1.5 * f);
vec2 w2 = f * (0.5 + f * (2.0 - 1.5 * f));
vec2 w3 = f * f * (-0.5 + 0.5 * f);
// vec2 w3 = 1.0 - w0 - w1 - w2;
// Work out weighting factors and sampling offsets that will let us use bilinear filtering to
// simultaneously evaluate the middle 2 samples from the 4x4 grid.
vec2 w12 = w1 + w2;
vec2 offset12 = w2 / (w1 + w2);
// Compute the final UV coordinates we'll use for sampling the texture
vec2 texPos0 = texPos1 - 1.;
vec2 texPos3 = texPos1 + 2.;
vec2 texPos12 = texPos1 + offset12;
texPos0 *= SourceSize.zw;
texPos3 *= SourceSize.zw;
texPos12 *= SourceSize.zw;
vec4 c00 = COMPAT_TEXTURE(Source, vec2(texPos0.x, texPos0.y));
vec4 c10 = COMPAT_TEXTURE(Source, vec2(texPos12.x, texPos0.y));
vec4 c20 = COMPAT_TEXTURE(Source, vec2(texPos3.x, texPos0.y));
vec4 c01 = COMPAT_TEXTURE(Source, vec2(texPos0.x, texPos12.y));
vec4 c11 = COMPAT_TEXTURE(Source, vec2(texPos12.x, texPos12.y));
vec4 c21 = COMPAT_TEXTURE(Source, vec2(texPos3.x, texPos12.y));
vec4 c02 = COMPAT_TEXTURE(Source, vec2(texPos0.x, texPos3.y));
vec4 c12 = COMPAT_TEXTURE(Source, vec2(texPos12.x, texPos3.y));
vec4 c22 = COMPAT_TEXTURE(Source, vec2(texPos3.x, texPos3.y));
// initialize some variables
vec4 c1, c2, c3, wx, wy = vec4(0.,0.,0.,0.);
// junk vec4 used only to round out the non-square 3x4 matrices
vec4 dummy = vec4(0.,0.,0.,1.);
wx = vec4(w0.x, w12.x, w3.x, 1.0);
wy = vec4(w0.y, w12.y, w3.y, 1.0);
c1 = vec4(mul(wx, mat4(c00, c10, c20, dummy)));
c2 = vec4(mul(wx, mat4(c01, c11, c21, dummy)));
c3 = vec4(mul(wx, mat4(c02, c12, c22, dummy)));
FragColor = mul(wy, mat4(c1, c2, c3, dummy));
}
#endif
Shaders/interpolation/bilinear.glsl
+73
View File
@@ -0,0 +1,73 @@
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
void main()
{
gl_Position = VertexCoord.x * MVPMatrix[0] + VertexCoord.y * MVPMatrix[1] + VertexCoord.z * MVPMatrix[2] + VertexCoord.w * MVPMatrix[3];
TEX0.xy = TexCoord.xy;
}
#elif defined(FRAGMENT)
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
void main()
{
FragColor = COMPAT_TEXTURE(Texture, TEX0.xy);
}
#endif
Shaders/nearest-neighbor.glsl
+73
View File
@@ -0,0 +1,73 @@
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
void main()
{
gl_Position = VertexCoord.x * MVPMatrix[0] + VertexCoord.y * MVPMatrix[1] + VertexCoord.z * MVPMatrix[2] + VertexCoord.w * MVPMatrix[3];
TEX0.xy = TexCoord.xy;
}
#elif defined(FRAGMENT)
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
void main()
{
FragColor = COMPAT_TEXTURE(Texture, TEX0.xy);
}
#endif
Shaders/readme.txt
+7
View File
@@ -0,0 +1,7 @@
This is a package of pixel shaders intended for old school emulators.
Copyrights are held by the respective authors.
https://github.com/libretro/glsl-shaders
Note: Filename must end with "bilinear.glsl" to enable bilinear hardware filtering (GL_LINEAR)
Shaders/scanlines/scanline.glsl
+106
View File
@@ -0,0 +1,106 @@
// Parameter lines go here:
#pragma parameter SCANLINE_BASE_BRIGHTNESS "Scanline Base Brightness" 0.95 0.0 1.0 0.01
#pragma parameter SCANLINE_SINE_COMP_A "Scanline Sine Comp A" 0.0 0.0 0.10 0.01
#pragma parameter SCANLINE_SINE_COMP_B "Scanline Sine Comp B" 0.15 0.0 1.0 0.05
#define pi 3.141592654
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
COMPAT_VARYING vec2 omega;
vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
void main()
{
gl_Position = MVPMatrix * VertexCoord;
COL0 = COLOR;
TEX0.xy = TexCoord.xy;
omega = vec2(pi * OutputSize.x, 2.0 * pi * TextureSize.y);
}
#elif defined(FRAGMENT)
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
COMPAT_VARYING vec2 omega;
// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutputSize vec4(OutputSize, 1.0 / OutputSize)
#ifdef PARAMETER_UNIFORM
// All parameter floats need to have COMPAT_PRECISION in front of them
uniform COMPAT_PRECISION float SCANLINE_BASE_BRIGHTNESS;
uniform COMPAT_PRECISION float SCANLINE_SINE_COMP_A;
uniform COMPAT_PRECISION float SCANLINE_SINE_COMP_B;
#else
#define SCANLINE_BASE_BRIGHTNESS 0.95
#define SCANLINE_SINE_COMP_A 0.0
#define SCANLINE_SINE_COMP_B 0.15
#endif
void main()
{
vec2 sine_comp = vec2(SCANLINE_SINE_COMP_A, SCANLINE_SINE_COMP_B);
vec3 res = COMPAT_TEXTURE(Source, vTexCoord).xyz;
vec3 scanline = res * (SCANLINE_BASE_BRIGHTNESS + dot(sine_comp * sin(vTexCoord * omega), vec2(1.0, 1.0)));
FragColor = vec4(scanline.x, scanline.y, scanline.z, 1.0);
}
#endif
Shaders/shader-package.zip
LFS
BIN
View File
Binary file not shown.
Shaders/sharpen/fast-sharpen.glsl
+148
View File
@@ -0,0 +1,148 @@
/*
Fast Sharpen Shader
Copyright (C) 2005 - 2019 guest(r) - guest.r@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 (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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#pragma parameter SHARPEN "Sharpen strength" 1.00 0.0 2.00 0.05
#pragma parameter CONTR "Ammount of sharpening" 0.07 0.0 0.25 0.01
#pragma parameter DETAILS "Details sharpened " 1.00 0.0 1.00 0.05
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 TEX0;
vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
COMPAT_VARYING vec2 g10;
COMPAT_VARYING vec2 g01;
COMPAT_VARYING vec2 g12;
COMPAT_VARYING vec2 g21;
// compatibility #defines
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
void main()
{
gl_Position = MVPMatrix * VertexCoord;
TEX0.xy = TexCoord.xy * 1.00001;
g10 = vec2( 0.3333,-1.0)*SourceSize.zw;
g01 = vec2(-1.0,-0.3333)*SourceSize.zw;
g12 = vec2(-0.3333, 1.0)*SourceSize.zw;
g21 = vec2( 1.0, 0.3333)*SourceSize.zw;
}
#elif defined(FRAGMENT)
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out COMPAT_PRECISION vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
COMPAT_VARYING vec2 g10;
COMPAT_VARYING vec2 g01;
COMPAT_VARYING vec2 g12;
COMPAT_VARYING vec2 g21;
// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
#ifdef PARAMETER_UNIFORM
uniform COMPAT_PRECISION float SHARPEN;
uniform COMPAT_PRECISION float CONTR;
uniform COMPAT_PRECISION float DETAILS;
#else
#define SHARPEN 1.2
#define CONTR 0.08
#define DETAILS 1.0
#endif
void main()
{
vec3 c10 = COMPAT_TEXTURE(Source, vTexCoord + g10).rgb;
vec3 c01 = COMPAT_TEXTURE(Source, vTexCoord + g01).rgb;
vec3 c21 = COMPAT_TEXTURE(Source, vTexCoord + g21).rgb;
vec3 c12 = COMPAT_TEXTURE(Source, vTexCoord + g12).rgb;
vec3 c11 = COMPAT_TEXTURE(Source, vTexCoord ).rgb;
vec3 b11 = (c10+c01+c12+c21)*0.25;
float contrast = max(max(c11.r,c11.g),c11.b);
contrast = mix(2.0*CONTR, CONTR, contrast);
vec3 mn1 = min(min(c10,c01),min(c12,c21)); mn1 = min(mn1,c11*(1.0-contrast));
vec3 mx1 = max(max(c10,c01),max(c12,c21)); mx1 = max(mx1,c11*(1.0+contrast));
vec3 dif = pow(mx1-mn1+0.0001, vec3(0.75,0.75,0.75));
vec3 sharpen = mix(vec3(SHARPEN*DETAILS), vec3(SHARPEN), dif);
c11 = clamp(mix(c11,b11,-sharpen), mn1,mx1);
FragColor = vec4(c11,1.0);
}
#endif
Shaders/smooth-chessboard-gray/smooth-chessboard-gray.glsl
+74
View File
@@ -0,0 +1,74 @@
#if defined(VERTEX)
attribute vec4 VertexCoord;
attribute vec4 COLOR;
attribute vec4 TexCoord;
varying vec4 COL0;
varying vec4 TEX0;
vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform int FrameDirection;
uniform int FrameCount;
uniform vec2 OutputSize;
uniform vec2 TextureSize;
uniform vec2 InputSize;
void main()
{
vec4 _oColor;
vec2 _otexCoord;
gl_Position = VertexCoord.x * MVPMatrix[0] + VertexCoord.y * MVPMatrix[1] + VertexCoord.z * MVPMatrix[2] + VertexCoord.w * MVPMatrix[3];
_oPosition1 = gl_Position;
_oColor = COLOR;
_otexCoord = TexCoord.xy;
COL0 = COLOR;
TEX0.xy = TexCoord.xy;
}
#elif defined(FRAGMENT)
#define BRIGHTNESS 0.5
struct output_dummy {
vec4 _color;
};
uniform int FrameDirection;
uniform int FrameCount;
uniform vec2 OutputSize;
uniform vec2 TextureSize;
uniform vec2 InputSize;
uniform sampler2D Texture;
varying vec4 TEX0;
//standard texture sample looks like this: texture2D(Texture, TEX0.xy);
void main()
{
vec4 myColor = texture2D(Texture, TEX0.xy);
mat4 neighbours = mat4(
texture2D(Texture, vec2(TEX0.x+1./TextureSize.x, TEX0.y)),
texture2D(Texture, vec2(TEX0.x-1./TextureSize.x, TEX0.y)),
texture2D(Texture, vec2(TEX0.x, TEX0.y+1./TextureSize.y)),
texture2D(Texture, vec2(TEX0.x, TEX0.y-1./TextureSize.y))
);
mat4 zero = mat4(
0.,0.,0.,0.,
0.,0.,0.,0.,
0.,0.,0.,0.,
0.,0.,0.,0.
);
if(length(myColor) == 0. && neighbours != zero){
myColor = ((neighbours[0] + neighbours[1] + neighbours[2] + neighbours[3]) / 4.) * BRIGHTNESS;
} else if (length(myColor) != 0. && neighbours == zero) {
myColor = myColor * BRIGHTNESS;
}
gl_FragColor = myColor;
return;
}
#endif
Shaders/windowed/lanczos2-sharp.glsl
+205
View File
@@ -0,0 +1,205 @@
/*
Hyllian's jinc windowed-jinc 2-lobe sharper with anti-ringing Shader
Copyright (C) 2011-2016 Hyllian/Jararaca - sergiogdb@gmail.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#define JINC2_WINDOW_SINC 0.5
#define JINC2_SINC 1.0
#define JINC2_AR_STRENGTH 0.8
#define texCoord TEX0
#if defined(VERTEX)
#if __VERSION__ >= 130
#define OUT out
#define IN in
#define tex2D texture
#else
#define OUT varying
#define IN attribute
#define tex2D texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
IN vec4 VertexCoord;
IN vec4 Color;
IN vec2 TexCoord;
OUT vec4 color;
OUT vec2 texCoord;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
void main()
{
gl_Position = MVPMatrix * VertexCoord;
color = Color;
texCoord = TexCoord;
}
#elif defined(FRAGMENT)
#if __VERSION__ >= 130
#define IN in
#define tex2D texture
out vec4 FragColor;
#else
#define IN varying
#define FragColor gl_FragColor
#define tex2D texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D s_p;
IN vec2 texCoord;
const float halfpi = 1.5707963267948966192313216916398;
const float pi = 3.1415926535897932384626433832795;
const float wa = JINC2_WINDOW_SINC*pi;
const float wb = JINC2_SINC*pi;
// Calculates the distance between two points
float d(vec2 pt1, vec2 pt2)
{
vec2 v = pt2 - pt1;
return sqrt(dot(v,v));
}
vec3 min4(vec3 a, vec3 b, vec3 c, vec3 d)
{
return min(a, min(b, min(c, d)));
}
vec3 max4(vec3 a, vec3 b, vec3 c, vec3 d)
{
return max(a, max(b, max(c, d)));
}
vec4 resampler(vec4 x)
{
vec4 res;
res.x = (x.x==0.0) ? wa*wb : sin(x.x*wa)*sin(x.x*wb)/(x.x*x.x);
res.y = (x.y==0.0) ? wa*wb : sin(x.y*wa)*sin(x.y*wb)/(x.y*x.y);
res.z = (x.z==0.0) ? wa*wb : sin(x.z*wa)*sin(x.z*wb)/(x.z*x.z);
res.w = (x.w==0.0) ? wa*wb : sin(x.w*wa)*sin(x.w*wb)/(x.w*x.w);
return res;
}
void main()
{
vec3 color;
vec4 weights[4];
vec2 dx = vec2(1.0, 0.0);
vec2 dy = vec2(0.0, 1.0);
vec2 pc = texCoord*TextureSize;
vec2 tc = (floor(pc-vec2(0.5,0.5))+vec2(0.5,0.5));
weights[0] = resampler(vec4(d(pc, tc -dx -dy), d(pc, tc -dy), d(pc, tc +dx -dy), d(pc, tc+2.0*dx -dy)));
weights[1] = resampler(vec4(d(pc, tc -dx ), d(pc, tc ), d(pc, tc +dx ), d(pc, tc+2.0*dx )));
weights[2] = resampler(vec4(d(pc, tc -dx +dy), d(pc, tc +dy), d(pc, tc +dx +dy), d(pc, tc+2.0*dx +dy)));
weights[3] = resampler(vec4(d(pc, tc -dx+2.0*dy), d(pc, tc +2.0*dy), d(pc, tc +dx+2.0*dy), d(pc, tc+2.0*dx+2.0*dy)));
dx = dx/TextureSize;
dy = dy/TextureSize;
tc = tc/TextureSize;
vec3 c00 = tex2D(s_p, tc -dx -dy).xyz;
vec3 c10 = tex2D(s_p, tc -dy).xyz;
vec3 c20 = tex2D(s_p, tc +dx -dy).xyz;
vec3 c30 = tex2D(s_p, tc+2.0*dx -dy).xyz;
vec3 c01 = tex2D(s_p, tc -dx ).xyz;
vec3 c11 = tex2D(s_p, tc ).xyz;
vec3 c21 = tex2D(s_p, tc +dx ).xyz;
vec3 c31 = tex2D(s_p, tc+2.0*dx ).xyz;
vec3 c02 = tex2D(s_p, tc -dx +dy).xyz;
vec3 c12 = tex2D(s_p, tc +dy).xyz;
vec3 c22 = tex2D(s_p, tc +dx +dy).xyz;
vec3 c32 = tex2D(s_p, tc+2.0*dx +dy).xyz;
vec3 c03 = tex2D(s_p, tc -dx+2.0*dy).xyz;
vec3 c13 = tex2D(s_p, tc +2.0*dy).xyz;
vec3 c23 = tex2D(s_p, tc +dx+2.0*dy).xyz;
vec3 c33 = tex2D(s_p, tc+2.0*dx+2.0*dy).xyz;
color = tex2D(s_p, texCoord).xyz;
// Get min/max samples
vec3 min_sample = min4(c11, c21, c12, c22);
vec3 max_sample = max4(c11, c21, c12, c22);
/*
color = mat4x3(c00, c10, c20, c30) * weights[0];
color+= mat4x3(c01, c11, c21, c31) * weights[1];
color+= mat4x3(c02, c12, c22, c32) * weights[2];
color+= mat4x3(c03, c13, c23, c33) * weights[3];
mat4 wgts = mat4(weights[0], weights[1], weights[2], weights[3]);
vec4 wsum = wgts * vec4(1.0,1.0,1.0,1.0);
color = color/(dot(wsum, vec4(1.0,1.0,1.0,1.0)));
*/
color = vec3(dot(weights[0], vec4(c00.x, c10.x, c20.x, c30.x)), dot(weights[0], vec4(c00.y, c10.y, c20.y, c30.y)), dot(weights[0], vec4(c00.z, c10.z, c20.z, c30.z)));
color+= vec3(dot(weights[1], vec4(c01.x, c11.x, c21.x, c31.x)), dot(weights[1], vec4(c01.y, c11.y, c21.y, c31.y)), dot(weights[1], vec4(c01.z, c11.z, c21.z, c31.z)));
color+= vec3(dot(weights[2], vec4(c02.x, c12.x, c22.x, c32.x)), dot(weights[2], vec4(c02.y, c12.y, c22.y, c32.y)), dot(weights[2], vec4(c02.z, c12.z, c22.z, c32.z)));
color+= vec3(dot(weights[3], vec4(c03.x, c13.x, c23.x, c33.x)), dot(weights[3], vec4(c03.y, c13.y, c23.y, c33.y)), dot(weights[3], vec4(c03.z, c13.z, c23.z, c33.z)));
color = color/(dot(weights[0], vec4(1,1,1,1)) + dot(weights[1], vec4(1,1,1,1)) + dot(weights[2], vec4(1,1,1,1)) + dot(weights[3], vec4(1,1,1,1)));
// Anti-ringing
vec3 aux = color;
color = clamp(color, min_sample, max_sample);
color = mix(aux, color, JINC2_AR_STRENGTH);
// final sum and weight normalization
FragColor.xyz = color;
}
#endif
Shaders/xbr/xbr-lv2-noblend.glsl
+300
View File
@@ -0,0 +1,300 @@
#version 130
/*
Hyllian's xBR-lv2-noblend Shader
Copyright (C) 2011-2016 Hyllian - sergiogdb@gmail.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Incorporates some of the ideas from SABR shader. Thanks to Joshua Street.
*/
#pragma parameter XBR_EQ_THRESHOLD "Eq Threshold" 0.6 0.0 2.0 0.1
#pragma parameter XBR_LV2_COEFFICIENT "Lv2 Coefficient" 2.0 1.0 3.0 0.1
#define mul(a,b) (b*a)
// Uncomment just one of the three params below to choose the corner detection
#define CORNER_A
//#define CORNER_B
//#define CORNER_C
//#define CORNER_D
#define lv2_cf XBR_LV2_COEFFICIENT
#define texCoord TEX0
#define t1 TEX1
#define t2 TEX2
#define t3 TEX3
#define t4 TEX4
#define t5 TEX5
#define t6 TEX6
#define t7 TEX7
#if defined(VERTEX)
#if __VERSION__ >= 130
#define OUT out
#define IN in
#define tex2D texture
#else
#define OUT varying
#define IN attribute
#define tex2D texture2D
#endif
#ifdef GL_ES
#define PRECISION mediump
#else
#define PRECISION
#endif
IN vec4 VertexCoord;
IN vec4 Color;
IN vec2 TexCoord;
OUT vec4 color;
OUT vec2 texCoord;
OUT vec4 t1;
OUT vec4 t2;
OUT vec4 t3;
OUT vec4 t4;
OUT vec4 t5;
OUT vec4 t6;
OUT vec4 t7;
uniform mat4 MVPMatrix;
uniform PRECISION int FrameDirection;
uniform PRECISION int FrameCount;
uniform PRECISION vec2 OutputSize;
uniform PRECISION vec2 TextureSize;
uniform PRECISION vec2 InputSize;
void main()
{
gl_Position = MVPMatrix * VertexCoord;
color = Color;
float dx = (1.0/TextureSize.x);
float dy = (1.0/TextureSize.y);
texCoord = TexCoord;
texCoord.x *= 1.00000001;
t1 = TexCoord.xxxy + vec4( -dx, 0, dx,-2.0*dy); // A1 B1 C1
t2 = TexCoord.xxxy + vec4( -dx, 0, dx, -dy); // A B C
t3 = TexCoord.xxxy + vec4( -dx, 0, dx, 0); // D E F
t4 = TexCoord.xxxy + vec4( -dx, 0, dx, dy); // G H I
t5 = TexCoord.xxxy + vec4( -dx, 0, dx, 2.0*dy); // G5 H5 I5
t6 = TexCoord.xyyy + vec4(-2.0*dx,-dy, 0, dy); // A0 D0 G0
t7 = TexCoord.xyyy + vec4( 2.0*dx,-dy, 0, dy); // C4 F4 I4
}
#elif defined(FRAGMENT)
#if __VERSION__ >= 130
#define IN in
#define tex2D texture
out vec4 FragColor;
#else
#define IN varying
#define FragColor gl_FragColor
#define tex2D texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define PRECISION mediump
#else
#define PRECISION
#endif
uniform PRECISION int FrameDirection;
uniform PRECISION int FrameCount;
uniform PRECISION vec2 OutputSize;
uniform PRECISION vec2 TextureSize;
uniform PRECISION vec2 InputSize;
uniform sampler2D decal;
IN vec2 texCoord;
IN vec4 t1;
IN vec4 t2;
IN vec4 t3;
IN vec4 t4;
IN vec4 t5;
IN vec4 t6;
IN vec4 t7;
#ifdef PARAMETER_UNIFORM
uniform PRECISION float XBR_EQ_THRESHOLD;
uniform PRECISION float XBR_LV2_COEFFICIENT;
#else
#define XBR_EQ_THRESHOLD 0.6
#define XBR_LV2_COEFFICIENT 2.0
#endif
// END PARAMETERS //
const vec3 Y = vec3(0.2126, 0.7152, 0.0722);
// Difference between vector components.
vec4 df(vec4 A, vec4 B)
{
return vec4(abs(A-B));
}
// Compare two vectors and return their components are different.
vec4 diff(vec4 A, vec4 B)
{
return vec4(notEqual(A, B));
}
// Determine if two vector components are equal based on a threshold.
vec4 eq(vec4 A, vec4 B)
{
return (step(df(A, B), vec4(XBR_EQ_THRESHOLD)));
}
// Determine if two vector components are NOT equal based on a threshold.
vec4 neq(vec4 A, vec4 B)
{
return (vec4(1.0, 1.0, 1.0, 1.0) - eq(A, B));
}
// Weighted distance.
vec4 wd(vec4 a, vec4 b, vec4 c, vec4 d, vec4 e, vec4 f, vec4 g, vec4 h)
{
return (df(a,b) + df(a,c) + df(d,e) + df(d,f) + 4.0*df(g,h));
}
vec4 weighted_distance(vec4 a, vec4 b, vec4 c, vec4 d, vec4 e, vec4 f, vec4 g, vec4 h, vec4 i, vec4 j, vec4 k, vec4 l)
{
return (df(a,b) + df(a,c) + df(d,e) + df(d,f) + df(i,j) + df(k,l) + 2.0*df(g,h));
}
float c_df(vec3 c1, vec3 c2)
{
vec3 df = abs(c1 - c2);
return df.r + df.g + df.b;
}
void main()
{
vec4 edri, edr, edr_l, edr_u; // px = pixel, edr = edge detection rule
vec4 irlv1, irlv2l, irlv2u, block_3d;
bvec4 nc, px;
vec4 fx, fx_l, fx_u; // inequations of straight lines.
vec2 fp = fract(texCoord*TextureSize);
vec3 A1 = tex2D(decal, t1.xw ).xyz;
vec3 B1 = tex2D(decal, t1.yw ).xyz;
vec3 C1 = tex2D(decal, t1.zw ).xyz;
vec3 A = tex2D(decal, t2.xw ).xyz;
vec3 B = tex2D(decal, t2.yw ).xyz;
vec3 C = tex2D(decal, t2.zw ).xyz;
vec3 D = tex2D(decal, t3.xw ).xyz;
vec3 E = tex2D(decal, t3.yw ).xyz;
vec3 F = tex2D(decal, t3.zw ).xyz;
vec3 G = tex2D(decal, t4.xw ).xyz;
vec3 H = tex2D(decal, t4.yw ).xyz;
vec3 I = tex2D(decal, t4.zw ).xyz;
vec3 G5 = tex2D(decal, t5.xw ).xyz;
vec3 H5 = tex2D(decal, t5.yw ).xyz;
vec3 I5 = tex2D(decal, t5.zw ).xyz;
vec3 A0 = tex2D(decal, t6.xy ).xyz;
vec3 D0 = tex2D(decal, t6.xz ).xyz;
vec3 G0 = tex2D(decal, t6.xw ).xyz;
vec3 C4 = tex2D(decal, t7.xy ).xyz;
vec3 F4 = tex2D(decal, t7.xz ).xyz;
vec3 I4 = tex2D(decal, t7.xw ).xyz;
vec4 b = mul( mat4x3(B, D, H, F), Y );
vec4 c = mul( mat4x3(C, A, G, I), Y );
vec4 e = mul( mat4x3(E, E, E, E), Y );
vec4 d = b.yzwx;
vec4 f = b.wxyz;
vec4 g = c.zwxy;
vec4 h = b.zwxy;
vec4 i = c.wxyz;
vec4 i4 = mul( mat4x3(I4, C1, A0, G5), Y );
vec4 i5 = mul( mat4x3(I5, C4, A1, G0), Y );
vec4 h5 = mul( mat4x3(H5, F4, B1, D0), Y );
vec4 f4 = h5.yzwx;
vec4 Ao = vec4( 1.0, -1.0, -1.0, 1.0 );
vec4 Bo = vec4( 1.0, 1.0, -1.0,-1.0 );
vec4 Co = vec4( 1.5, 0.5, -0.5, 0.5 );
vec4 Ax = vec4( 1.0, -1.0, -1.0, 1.0 );
vec4 Bx = vec4( 0.5, 2.0, -0.5,-2.0 );
vec4 Cx = vec4( 1.0, 1.0, -0.5, 0.0 );
vec4 Ay = vec4( 1.0, -1.0, -1.0, 1.0 );
vec4 By = vec4( 2.0, 0.5, -2.0,-0.5 );
vec4 Cy = vec4( 2.0, 0.0, -1.0, 0.5 );
// These inequations define the line below which interpolation occurs.
fx = vec4(greaterThan(Ao*fp.y+Bo*fp.x, Co));
fx_l = vec4(greaterThan(Ax*fp.y+Bx*fp.x, Cx));
fx_u = vec4(greaterThan(Ay*fp.y+By*fp.x, Cy));
#ifdef CORNER_A
irlv1 = diff(e,f) * diff(e,h);
#endif
#ifdef CORNER_B
irlv1 = (neq(f,b) * neq(h,d) + eq(e,i) * neq(f,i4) * neq(h,i5) + eq(e,g) + eq(e,c));
#endif
#ifdef CORNER_D
vec4 c1 = i4.yzwx;
vec4 g0 = i5.wxyz;
irlv1 = (neq(f,b) * neq(h,d) + eq(e,i) * neq(f,i4) * neq(h,i5) + eq(e,g) + eq(e,c) ) * (diff(f,f4) * diff(f,i) + diff(h,h5) * diff(h,i) + diff(h,g) + diff(f,c) + eq(b,c1) * eq(d,g0));
#endif
#ifdef CORNER_C
irlv1 = (neq(f,b) * neq(f,c) + neq(h,d) * neq(h,g) + eq(e,i) * (neq(f,f4) * neq(f,i4) + neq(h,h5) * neq(h,i5)) + eq(e,g) + eq(e,c));
#endif
irlv2l = diff(e,g) * diff(d,g);
irlv2u = diff(e,c) * diff(b,c);
vec4 wd1 = wd( e, c, g, i, h5, f4, h, f);
vec4 wd2 = wd( h, d, i5, f, i4, b, e, i);
edri = step(wd1, wd2) * irlv1;
edr = step(wd1 + vec4(0.1, 0.1, 0.1, 0.1), wd2) * step(vec4(0.5, 0.5, 0.5, 0.5), irlv1);
edr_l = step( lv2_cf*df(f,g), df(h,c) ) * irlv2l * edr;
edr_u = step( lv2_cf*df(h,c), df(f,g) ) * irlv2u * edr;
nc = bvec4( edr * ( fx + edr_l * (fx_l)) + edr_u * fx_u);
px = lessThanEqual(df(e, f), df(e, h));
vec3 res1 = nc.x ? px.x ? F : H : nc.y ? px.y ? B : F : nc.z ? px.z ? D : B : E;
vec3 res2 = nc.w ? px.w ? H : D : nc.z ? px.z ? D : B : nc.y ? px.y ? B : F : E;
vec2 df12 = abs( mul( mat2x3(res1, res2), Y ) - e.xy);
vec3 res = mix(res1, res2, step(df12.x, df12.y));
FragColor.xyz = res;
}
#endif
Shaders/xbrz/xbrz-freescale.glsl
+375
View File
@@ -0,0 +1,375 @@
/*
Hyllian's xBR-vertex code and texel mapping
Copyright (C) 2011/2016 Hyllian - sergiogdb@gmail.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
// This shader also uses code and/or concepts from xBRZ as it appears
// in the Desmume source code. The license for which is as follows:
// ****************************************************************************
// * This file is part of the HqMAME project. It is distributed under *
// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0 *
// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved *
// * *
// * Additionally and as a special exception, the author gives permission *
// * to link the code of this program with the MAME library (or with modified *
// * versions of MAME that use the same license as MAME), and distribute *
// * linked combinations including the two. You must obey the GNU General *
// * Public License in all respects for all of the code used other than MAME. *
// * If you modify this file, you may extend this exception to your version *
// * of the file, but you are not obligated to do so. If you do not wish to *
// * do so, delete this exception statement from your version. *
// ****************************************************************************
#if defined(VERTEX)
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
// compatibility #defines
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
#ifdef PARAMETER_UNIFORM
uniform COMPAT_PRECISION float WHATEVER;
#else
#define WHATEVER 0.0
#endif
void main()
{
gl_Position = MVPMatrix * VertexCoord;
TEX0.xy = TexCoord.xy * 1.0001;
}
#elif defined(FRAGMENT)
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out COMPAT_PRECISION vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
COMPAT_VARYING vec4 TEX0;
// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)
#define BLEND_NONE 0
#define BLEND_NORMAL 1
#define BLEND_DOMINANT 2
#define LUMINANCE_WEIGHT 1.0
#define EQUAL_COLOR_TOLERANCE 30.0/255.0
#define STEEP_DIRECTION_THRESHOLD 2.2
#define DOMINANT_DIRECTION_THRESHOLD 3.6
float DistYCbCr(vec3 pixA, vec3 pixB)
{
const vec3 w = vec3(0.2627, 0.6780, 0.0593);
const float scaleB = 0.5 / (1.0 - w.b);
const float scaleR = 0.5 / (1.0 - w.r);
vec3 diff = pixA - pixB;
float Y = dot(diff.rgb, w);
float Cb = scaleB * (diff.b - Y);
float Cr = scaleR * (diff.r - Y);
return sqrt(((LUMINANCE_WEIGHT * Y) * (LUMINANCE_WEIGHT * Y)) + (Cb * Cb) + (Cr * Cr));
}
bool IsPixEqual(const vec3 pixA, const vec3 pixB)
{
return (DistYCbCr(pixA, pixB) < EQUAL_COLOR_TOLERANCE);
}
float get_left_ratio(vec2 center, vec2 origin, vec2 direction, vec2 scale)
{
vec2 P0 = center - origin;
vec2 proj = direction * (dot(P0, direction) / dot(direction, direction));
vec2 distv = P0 - proj;
vec2 orth = vec2(-direction.y, direction.x);
float side = sign(dot(P0, orth));
float v = side * length(distv * scale);
// return step(0, v);
return smoothstep(-sqrt(2.0)/2.0, sqrt(2.0)/2.0, v);
}
#define eq(a,b) (a == b)
#define neq(a,b) (a != b)
#define P(x,y) COMPAT_TEXTURE(Source, coord + SourceSize.zw * vec2(x, y)).rgb
void main()
{
//---------------------------------------
// Input Pixel Mapping: -|x|x|x|-
// x|A|B|C|x
// x|D|E|F|x
// x|G|H|I|x
// -|x|x|x|-
vec2 scale = OutputSize.xy * SourceSize.zw;
vec2 pos = fract(vTexCoord * SourceSize.xy) - vec2(0.5, 0.5);
vec2 coord = vTexCoord - pos * SourceSize.zw;
vec3 A = P(-1.,-1.);
vec3 B = P( 0.,-1.);
vec3 C = P( 1.,-1.);
vec3 D = P(-1., 0.);
vec3 E = P( 0., 0.);
vec3 F = P( 1., 0.);
vec3 G = P(-1., 1.);
vec3 H = P( 0., 1.);
vec3 I = P( 1., 1.);
// blendResult Mapping: x|y|
// w|z|
ivec4 blendResult = ivec4(BLEND_NONE,BLEND_NONE,BLEND_NONE,BLEND_NONE);
// Preprocess corners
// Pixel Tap Mapping: -|-|-|-|-
// -|-|B|C|-
// -|D|E|F|x
// -|G|H|I|x
// -|-|x|x|-
if (!((eq(E,F) && eq(H,I)) || (eq(E,H) && eq(F,I))))
{
float dist_H_F = DistYCbCr(G, E) + DistYCbCr(E, C) + DistYCbCr(P(0,2), I) + DistYCbCr(I, P(2.,0.)) + (4.0 * DistYCbCr(H, F));
float dist_E_I = DistYCbCr(D, H) + DistYCbCr(H, P(1,2)) + DistYCbCr(B, F) + DistYCbCr(F, P(2.,1.)) + (4.0 * DistYCbCr(E, I));
bool dominantGradient = (DOMINANT_DIRECTION_THRESHOLD * dist_H_F) < dist_E_I;
blendResult.z = ((dist_H_F < dist_E_I) && neq(E,F) && neq(E,H)) ? ((dominantGradient) ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
}
// Pixel Tap Mapping: -|-|-|-|-
// -|A|B|-|-
// x|D|E|F|-
// x|G|H|I|-
// -|x|x|-|-
if (!((eq(D,E) && eq(G,H)) || (eq(D,G) && eq(E,H))))
{
float dist_G_E = DistYCbCr(P(-2.,1.) , D) + DistYCbCr(D, B) + DistYCbCr(P(-1.,2.), H) + DistYCbCr(H, F) + (4.0 * DistYCbCr(G, E));
float dist_D_H = DistYCbCr(P(-2.,0.) , G) + DistYCbCr(G, P(0.,2.)) + DistYCbCr(A, E) + DistYCbCr(E, I) + (4.0 * DistYCbCr(D, H));
bool dominantGradient = (DOMINANT_DIRECTION_THRESHOLD * dist_D_H) < dist_G_E;
blendResult.w = ((dist_G_E > dist_D_H) && neq(E,D) && neq(E,H)) ? ((dominantGradient) ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
}
// Pixel Tap Mapping: -|-|x|x|-
// -|A|B|C|x
// -|D|E|F|x
// -|-|H|I|-
// -|-|-|-|-
if (!((eq(B,C) && eq(E,F)) || (eq(B,E) && eq(C,F))))
{
float dist_E_C = DistYCbCr(D, B) + DistYCbCr(B, P(1.,-2.)) + DistYCbCr(H, F) + DistYCbCr(F, P(2.,-1.)) + (4.0 * DistYCbCr(E, C));
float dist_B_F = DistYCbCr(A, E) + DistYCbCr(E, I) + DistYCbCr(P(0.,-2.), C) + DistYCbCr(C, P(2.,0.)) + (4.0 * DistYCbCr(B, F));
bool dominantGradient = (DOMINANT_DIRECTION_THRESHOLD * dist_B_F) < dist_E_C;
blendResult.y = ((dist_E_C > dist_B_F) && neq(E,B) && neq(E,F)) ? ((dominantGradient) ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
}
// Pixel Tap Mapping: -|x|x|-|-
// x|A|B|C|-
// x|D|E|F|-
// -|G|H|-|-
// -|-|-|-|-
if (!((eq(A,B) && eq(D,E)) || (eq(A,D) && eq(B,E))))
{
float dist_D_B = DistYCbCr(P(-2.,0.), A) + DistYCbCr(A, P(0.,-2.)) + DistYCbCr(G, E) + DistYCbCr(E, C) + (4.0 * DistYCbCr(D, B));
float dist_A_E = DistYCbCr(P(-2.,-1.), D) + DistYCbCr(D, H) + DistYCbCr(P(-1.,-2.), B) + DistYCbCr(B, F) + (4.0 * DistYCbCr(A, E));
bool dominantGradient = (DOMINANT_DIRECTION_THRESHOLD * dist_D_B) < dist_A_E;
blendResult.x = ((dist_D_B < dist_A_E) && neq(E,D) && neq(E,B)) ? ((dominantGradient) ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
}
vec3 res = E;
// Pixel Tap Mapping: -|-|-|-|-
// -|-|B|C|-
// -|D|E|F|x
// -|G|H|I|x
// -|-|x|x|-
if(blendResult.z != BLEND_NONE)
{
float dist_F_G = DistYCbCr(F, G);
float dist_H_C = DistYCbCr(H, C);
bool doLineBlend = (blendResult.z == BLEND_DOMINANT ||
!((blendResult.y != BLEND_NONE && !IsPixEqual(E, G)) || (blendResult.w != BLEND_NONE && !IsPixEqual(E, C)) ||
(IsPixEqual(G, H) && IsPixEqual(H, I) && IsPixEqual(I, F) && IsPixEqual(F, C) && !IsPixEqual(E, I))));
vec2 origin = vec2(0.0, 1.0 / sqrt(2.0));
vec2 direction = vec2(1.0, -1.0);
if(doLineBlend)
{
bool haveShallowLine = (STEEP_DIRECTION_THRESHOLD * dist_F_G <= dist_H_C) && neq(E,G) && neq(D,G);
bool haveSteepLine = (STEEP_DIRECTION_THRESHOLD * dist_H_C <= dist_F_G) && neq(E,C) && neq(B,C);
origin = haveShallowLine? vec2(0.0, 0.25) : vec2(0.0, 0.5);
direction.x += haveShallowLine? 1.0: 0.0;
direction.y -= haveSteepLine? 1.0: 0.0;
}
vec3 blendPix = mix(H,F, step(DistYCbCr(E, F), DistYCbCr(E, H)));
res = mix(res, blendPix, get_left_ratio(pos, origin, direction, scale));
}
// Pixel Tap Mapping: -|-|-|-|-
// -|A|B|-|-
// x|D|E|F|-
// x|G|H|I|-
// -|x|x|-|-
if(blendResult.w != BLEND_NONE)
{
float dist_H_A = DistYCbCr(H, A);
float dist_D_I = DistYCbCr(D, I);
bool doLineBlend = (blendResult.w == BLEND_DOMINANT ||
!((blendResult.z != BLEND_NONE && !IsPixEqual(E, A)) || (blendResult.x != BLEND_NONE && !IsPixEqual(E, I)) ||
(IsPixEqual(A, D) && IsPixEqual(D, G) && IsPixEqual(G, H) && IsPixEqual(H, I) && !IsPixEqual(E, G))));
vec2 origin = vec2(-1.0 / sqrt(2.0), 0.0);
vec2 direction = vec2(1.0, 1.0);
if(doLineBlend)
{
bool haveShallowLine = (STEEP_DIRECTION_THRESHOLD * dist_H_A <= dist_D_I) && neq(E,A) && neq(B,A);
bool haveSteepLine = (STEEP_DIRECTION_THRESHOLD * dist_D_I <= dist_H_A) && neq(E,I) && neq(F,I);
origin = haveShallowLine? vec2(-0.25, 0.0) : vec2(-0.5, 0.0);
direction.y += haveShallowLine? 1.0: 0.0;
direction.x += haveSteepLine? 1.0: 0.0;
}
origin = origin;
direction = direction;
vec3 blendPix = mix(H,D, step(DistYCbCr(E, D), DistYCbCr(E, H)));
res = mix(res, blendPix, get_left_ratio(pos, origin, direction, scale));
}
// Pixel Tap Mapping: -|-|x|x|-
// -|A|B|C|x
// -|D|E|F|x
// -|-|H|I|-
// -|-|-|-|-
if(blendResult.y != BLEND_NONE)
{
float dist_B_I = DistYCbCr(B, I);
float dist_F_A = DistYCbCr(F, A);
bool doLineBlend = (blendResult.y == BLEND_DOMINANT ||
!((blendResult.x != BLEND_NONE && !IsPixEqual(E, I)) || (blendResult.z != BLEND_NONE && !IsPixEqual(E, A)) ||
(IsPixEqual(I, F) && IsPixEqual(F, C) && IsPixEqual(C, B) && IsPixEqual(B, A) && !IsPixEqual(E, C))));
vec2 origin = vec2(1.0 / sqrt(2.0), 0.0);
vec2 direction = vec2(-1.0, -1.0);
if(doLineBlend)
{
bool haveShallowLine = (STEEP_DIRECTION_THRESHOLD * dist_B_I <= dist_F_A) && neq(E,I) && neq(H,I);
bool haveSteepLine = (STEEP_DIRECTION_THRESHOLD * dist_F_A <= dist_B_I) && neq(E,A) && neq(D,A);
origin = haveShallowLine? vec2(0.25, 0.0) : vec2(0.5, 0.0);
direction.y -= haveShallowLine? 1.0: 0.0;
direction.x -= haveSteepLine? 1.0: 0.0;
}
vec3 blendPix = mix(F,B, step(DistYCbCr(E, B), DistYCbCr(E, F)));
res = mix(res, blendPix, get_left_ratio(pos, origin, direction, scale));
}
// Pixel Tap Mapping: -|x|x|-|-
// x|A|B|C|-
// x|D|E|F|-
// -|G|H|-|-
// -|-|-|-|-
if(blendResult.x != BLEND_NONE)
{
float dist_D_C = DistYCbCr(D, C);
float dist_B_G = DistYCbCr(B, G);
bool doLineBlend = (blendResult.x == BLEND_DOMINANT ||
!((blendResult.w != BLEND_NONE && !IsPixEqual(E, C)) || (blendResult.y != BLEND_NONE && !IsPixEqual(E, G)) ||
(IsPixEqual(C, B) && IsPixEqual(B, A) && IsPixEqual(A, D) && IsPixEqual(D, G) && !IsPixEqual(E, A))));
vec2 origin = vec2(0.0, -1.0 / sqrt(2.0));
vec2 direction = vec2(-1.0, 1.0);
if(doLineBlend)
{
bool haveShallowLine = (STEEP_DIRECTION_THRESHOLD * dist_D_C <= dist_B_G) && neq(E,C) && neq(F,C);
bool haveSteepLine = (STEEP_DIRECTION_THRESHOLD * dist_B_G <= dist_D_C) && neq(E,G) && neq(H,G);
origin = haveShallowLine? vec2(0.0, -0.25) : vec2(0.0, -0.5);
direction.x -= haveShallowLine? 1.0: 0.0;
direction.y += haveSteepLine? 1.0: 0.0;
}
vec3 blendPix = mix(D,B, step(DistYCbCr(E, B), DistYCbCr(E, D)));
res = mix(res, blendPix, get_left_ratio(pos, origin, direction, scale));
}
FragColor = vec4(res, 1.0);
}
#endif
TADemo/3DTA.exe
LFS
BIN
View File
Binary file not shown.
TADemo/3DTAConfig.exe
LFS
BIN
View File
Binary file not shown.
TADemo/HPIUtil.dll
LFS
BIN
View File
Binary file not shown.
TADemo/MAPS.TXT
+139
View File
@@ -0,0 +1,139 @@
;
; Default list of maps that the Random Map Selector (tm) will chose from, with weightings.
; Thanks to Xeno for making the list of mapnames!
;
; Structure of this file (quite simple)
;
; +Group_name
; <weight> <mapname>
; <weight> <mapname>
; ...
; +Group_name
; ...
;
; NOTE: If you want to disable a group, just remove the + since all lines that doesn't start with either an
; integer or a + will be considered as groups to ignore. (and no +10 won't count as an integer). If you want
; to disable a specific map, just delete the line or perhaps set the weight to 0.
;
; About the weightings: They are an INTEGER, and the chance for getting a certain map is proportional to
; <map_weighting> / <sum_of_all>.
+ORIGINAL TA MAPS
100 Anteer Strait
100 Ashap Plateau
100 Caldera's Rim
100 Coast to Coast
100 Dark Side
100 Etorrep Glacier
100 Evad River Confluence
100 Fox Holes
100 Full Moon
100 Gods of War
100 Great Divide
100 Greenhaven
100 Hundred Isles
100 Kill the Middle
100 King of the Hill
100 Lava & Two Hills
100 Lava Alley
100 Lava Highground
100 Lava Mania
100 Lava Run
100 Metal Heck
100 Over Crude Water
100 Painted Desert
100 Pincushion
100 Red Hot Lava
100 Red Planet
100 Red Triangle
100 Ring Atoll
100 Rock Alley
100 Seven Islands
100 Sherwood
100 Shore to Shore
100 The Cold Place
100 The Desert Triad
100 The Pass
100 Two Continents
100 Yerrot Mountains
+CORE CONTINGENCY MAPS
100 Acid Foursome
100 Acid Pools
100 Acid Trip
100 Assault on Suburbia
100 Biggie Biggs
100 Block Wars
100 Brain Coral
100 Cavedog Links CC
100 Checker Ponds
100 Cluster Freak
100 Comet Catcher
100 Core Prime Industrial Area
100 Crater Islands
100 Crystal Cracked
100 Crystal Isles
100 Crystal Maze
100 Crystal Treasure Island
100 Dire Straits
100 East Indeez
100 Eastside Westside
100 Expanded Confluence
100 Flooded Glaciers
100 Gasbag Forests
100 Gasplant Plain
100 Higher Ground
100 Ice Scream
100 Icy Bergs
100 John's Pass
100 Lake Shore
100 Lusch Puppy
100 Luschaven
100 Metal Isles
100 Moon Quartet
100 Ooooweeee
100 Pillopeens
100 Plains and Passes
100 Polar Range
100 Polyp Fields
100 Red River North
100 Red River
100 Ror Shock
100 Sail Away
100 Sector 410b
100 Show Down
100 Slate Gordon
100 Slated Fate
100 Steel Jungle
100 Surface Meltdown
100 Temblorian Mist
100 The Barrier Reef
100 The Bayou
100 Town & Country
100 Trout Farm
+BATTLE TACTICS MAPS
100 Aqua Verdigris
100 Brilliant Cut Lake
100 Canal Crossing
100 Coremageddon
100 Metal Gridlock
100 Wretched Ridges
+ONLINE CAVEDOG MAPS
100 Ancient Issaquah
100 Evad River Delta
100 Luschie
100 Luschinfloggen
100 Mounds of Mars
100 ThundurLok Rok
100 Tropical Paradise
TADemo/PALETTE.PAL
BIN
View File
Binary file not shown.
TADemo/SERVER.EXE
LFS
BIN
View File
Binary file not shown.
TADemo/bagge.fnt
LFS
BIN
View File
Binary file not shown.
TADemo/bitmaps/detailtex.jpg
LFS
BIN
View File
Binary file not shown.
TADemo/bitmaps/gran.bmp
LFS
BIN
View File
Binary file not shown.
TADemo/bitmaps/gran2.bmp
LFS
BIN
View File
Binary file not shown.
TADemo/bitmaps/ocean.jpg
LFS
BIN
View File
Binary file not shown.
TADemo/uikeys.txt
+24
View File
@@ -0,0 +1,24 @@
bind 'p' Pause
bind pause Pause
bind 't' Chat
bind enter Chat
bind 'b' Debug
bind up moveforward
bind down moveback
bind right moveright
bind left moveleft
bind ctrl movefast
bind shift moveslow
bind esc quit
bind pageup increaseViewRadius
bind pagedown decreaseViewRadius
bind f6 DrawTrees
bind f7 dynamicSky
bind f11 screenshot
bind numpad+ speedup
bind numpad- speeddown
bind 'k' drawkills
bind 'n' drawnames
bind 'h' drawhealth
bind 'r' DrawResources
bind 'm' DrawMap
TADemo/unitid.txt
+99
View File
@@ -0,0 +1,99 @@
;
; TA Demo Recoder 0.90ß.
;
; This file describes different groups of units.
; You can therefore add 3rd party units etc to this list if you feel like.
;
; The hex-number <unitid> is the same number that is saved in a unit restrictions file. Don't know
; how that is related to the unit, or if it can be found in the unit's file somewhere. So if
; you know, feel free to enlighten me.
;
; If you add stuff to the file, you could always send it to me so that future releases of TA Demo can
; recognize what 3rd-party units was used. (If there should happen to be a nice easy way to get the unit
; names from those id numbers, this file might become obsolete)
;
; Edited by Fnordia 990220
; 991027
; 000219
; 010318
;
;
; Syntax: (very simple)
;
; = <group name / unit name>
; <unitid>
; <unitid>
; <...>
;
; = <group name>
;
; etc..
;
; update: only units in one of the +-groups will show. with the group furthest down takes presedence.
; however, the units before the first +-group will be tested for all groups
; I just added one unit to CC cuz I'm lazy. Btw, it's inclusive, so if any unit in the groups list were
; enabled in the game, this group's name will be listed under used units.
=BAI
6da73737
=Queller
; albatross
62cc5579
=Counterstrike
; fluxor
9a34465c
+regular ta
=Core Contingency
; it's the nixter btw. :)
848ebee6
=ARM Flea
371d264a
=ARM Scarab
6b81b8be
=CORE Hedgehog
763476f4
=CORE Immolator
3fcf5935
=ARM Fast Attack-Repair Kbot
d6d867f3
=CORE Necro
f4c81832
+uberhack 1.0
=UberHack 1.0 TAEC
; The anemone
b9f36d39
+uberhack 1.1
=Uberhack 1.1
; the gimp
16b40f07
=TAEC units
; the thumper hehe
a89cec32
+uberhack 3.0
=Uberhack 3.0
;centurion
3b978743
+xta 0.8
=XTA 0.8
f804eafe
+xta betas
=XTA pre1.0
; fortwall
6d197dcf
TotalA.exe
LFS
BIN
View File
Binary file not shown.
Viewer.exe
LFS
BIN
View File
Binary file not shown.
audiere.dll
LFS
BIN
View File
Binary file not shown.
bass.dll
LFS
BIN
View File
Binary file not shown.
basscd.dll
LFS
BIN
View File
Binary file not shown.
bassflac.dll
LFS
BIN
View File
Binary file not shown.
bassmix.dll
LFS
BIN
View File
Binary file not shown.
basswasapi.dll
LFS
BIN
View File
Binary file not shown.
cnc-ddraw config.exe
LFS
BIN
View File
Binary file not shown.
ddraw.ini
+849
View File
@@ -0,0 +1,849 @@
; cnc-ddraw - https://github.com/FunkyFr3sh/cnc-ddraw
[ddraw]
; ### Optional settings ###
; Use the following settings to adjust the look and feel to your liking
; Stretch to custom resolution, 0 = defaults to the size game requests
width=0
height=0
; Override the width/height settings shown above and always stretch to fullscreen
; Note: Can be combined with 'windowed=true' to get windowed-fullscreen aka borderless mode
fullscreen=true
; Run in windowed mode rather than going fullscreen
windowed=true
; Maintain aspect ratio
maintas=false
; Windowboxing / Integer Scaling
boxing=false
; Real rendering rate, -1 = screen rate, 0 = unlimited, n = cap
; Note: Does not have an impact on the game speed, to limit your game speed use 'maxgameticks='
maxfps=-1
; Vertical synchronization, enable if you get tearing - (Requires 'renderer=auto/opengl/direct3d9')
; Note: vsync=true can fix tearing but it will cause input lag
vsync=true
; Automatic mouse sensitivity scaling
; Note: Only works if stretching is enabled. Sensitivity will be adjusted according to the size of the window
adjmouse=false
; Preliminary libretro shader support - (Requires 'renderer=opengl') https://github.com/libretro/glsl-shaders
; 2x scaling example: https://imgur.com/a/kxsM1oY - 4x scaling example: https://imgur.com/a/wjrhpFV
shader=Shaders\cubic\catmull-rom-bilinear.glsl
; Window position, -32000 = center to screen
posX=-32000
posY=-32000
; Renderer, possible values: auto, opengl, gdi, direct3d9 (auto = try direct3d9/opengl, fallback = gdi)
renderer=opengl
; Developer mode (don't lock the cursor)
devmode=false
; Show window borders in windowed mode
border=true
; Save window position/size/state on game exit and restore it automatically on next game start
; Possible values: 0 = disabled, 1 = save to global 'ddraw' section, 2 = save to game specific section
savesettings=1
; Should the window be resizable by the user in windowed mode?
resizable=true
; Enable linear (D3DTEXF_LINEAR) upscaling filter for the direct3d9 renderer
d3d9linear=true
; Enable upscale hack for high resolution patches (Supports C&C1, Red Alert 1 and KKND Xtreme)
vhack=false
; cnc-ddraw config program language, possible values: auto, english, chinese, german, spanish, russian, hungarian, french
configlang=auto
; Where should screenshots be saved
screenshotdir=.\Screenshots\
; ### Compatibility settings ###
; Use the following settings in case there are any issues with the game
; Hide WM_ACTIVATEAPP and WM_NCACTIVATE messages to prevent problems on alt+tab
noactivateapp=false
; Max game ticks per second, possible values: -1 = disabled, -2 = refresh rate, 0 = emulate 60hz vblank, 1-1000 = custom game speed
; Note: Can be used to slow down a too fast running game, fix flickering or too fast animations
; Note: Usually one of the following values will work: 60 / 30 / 25 / 20 / 15 (lower value = slower game speed)
maxgameticks=0
; Windows API Hooking, Possible values: 0 = disabled, 1 = IAT Hooking, 2 = Microsoft Detours, 3 = IAT+Detours Hooking (All Modules), 4 = IAT Hooking (All Modules)
; Note: Change this value if windowed mode or upscaling isn't working properly
; Note: 'hook=2' will usually work for problematic games, but 'hook=2' should be combined with renderer=gdi
hook=4
; Force minimum FPS, possible values: 0 = disabled, -1 = use 'maxfps=' value, -2 = same as -1 but force full redraw, 1-1000 = custom FPS
; Note: Set this to a low value such as 5 or 10 if some parts of the game are not being displayed (e.g. menus or loading screens)
minfps=0
; Disable fullscreen-exclusive mode for the direct3d9/opengl renderers
; Note: Can be used in case some GUI elements like buttons/textboxes/videos/etc.. are invisible
nonexclusive=false
; Force CPU0 affinity, avoids crashes/freezing, *might* have a performance impact
singlecpu=false
; Available resolutions, possible values: 0 = Small list, 1 = Very small list, 2 = Full list
; Note: Set this to 2 if your chosen resolution is not working, set to 1 if the game is crashing
resolutions=0
; Child window handling, possible values: 0 = Disabled, 1 = Display top left, 2 = Display top left + repaint, 3 = Hide
; Note: Disables upscaling if a child window was detected
fixchilds=2
; Set the precision for Direct3D9 floating-point calculations to the precision used by the calling thread
; Note: Enable this if there are desyncs in online games
fpupreserve=false
; Undocumented settings
d3d9_adapter=0
opengl_core=false
d3d9on12=false
guard_lines=200
max_resolutions=0
limit_bltfast=false
game_handles_close=true
accuratetimers=false
fixpitch=true
fixwndprochook=true
novidmem=false
fixnotresponding=false
locktopleft=false
lock_surfaces=true
releasealt=false
gdilinear=false
allow_wmactivate=false
dinputhook=false
flipclear=false
fixmousehook=false
bpp=0
rgb555=false
hook_peekmessage=false
; ### Hotkeys ###
; Use the following settings to configure your hotkeys, 0x00 = disabled
; Virtual-Key Codes: https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
; Switch between windowed and fullscreen mode = [Alt] + ???
keytogglefullscreen=0x0D
; Maximize window without frame = [Alt] + ???
keytogglemaximize=0x22
; Unlock cursor 1 = [Ctrl] + ???
keyunlockcursor1=0x09
; Unlock cursor 2 = [Right Alt] + ???
keyunlockcursor2=0xA3
; Screenshot
keyscreenshot=0x2C
; ### Game specific settings ###
; The following settings override all settings shown above, section name = executable name
; Atrox
[Atrox]
renderer=gdi
hook=2
fixchilds=0
allow_wmactivate=true
; Atomic Bomberman
[BM]
maxgameticks=60
; Age of Empires
[empires]
renderer=opengl
nonexclusive=true
adjmouse=true
resolutions=2
; Age of Empires: The Rise of Rome
[empiresx]
renderer=opengl
nonexclusive=true
adjmouse=true
resolutions=2
; Age of Empires II
[EMPIRES2]
renderer=opengl
nonexclusive=true
adjmouse=true
; Age of Empires II: The Conquerors
[age2_x1]
renderer=opengl
nonexclusive=true
adjmouse=true
; American Conquest / Cossacks
[DMCR]
resolutions=2
guard_lines=300
minfps=-2
; Age of Wonders
[AoWSM]
windowed=true
fullscreen=false
renderer=gdi
hook=2
; Age of Wonders 2
[AoW2]
windowed=true
fullscreen=false
renderer=gdi
hook=2
; Anstoss 3
[anstoss3]
renderer=gdi
adjmouse=true
; Anno 1602
[1602]
adjmouse=true
; Alien Nations
[AN]
adjmouse=true
; Amerzone
[AMERZONE]
renderer=opengl
; Atlantis
[ATLANTIS]
renderer=opengl
maxgameticks=60
; Airline Tycoon Deluxe
[AT]
fixchilds=0
; Baldur's Gate II
; Note: 'Use 3D Acceleration' must be disabled and 'Full Screen' must be enabled in BGConfig.exe
[BGMain]
resolutions=2
; Blade & Sword
[comeon]
maxgameticks=62
fixchilds=3
; Blood II - The Chosen / Shogo - Mobile Armor Division
[Client]
checkfile=.\SOUND.REZ
noactivateapp=true
; Carmageddon
[CARMA95]
renderer=opengl
noactivateapp=true
flipclear=true
; Carmageddon
[CARM95]
renderer=opengl
noactivateapp=true
flipclear=true
; Carmageddon 2
[Carma2_SW]
renderer=opengl
noactivateapp=true
; Captain Claw
[claw]
noactivateapp=true
; Command & Conquer: Sole Survivor
[SOLE]
maxgameticks=120
maxfps=60
minfps=-1
; Command & Conquer Gold - CnCNet
[cnc95]
maxfps=125
; Command & Conquer Gold
[C&C95]
maxgameticks=120
maxfps=60
minfps=-1
; Command & Conquer: Red Alert - CnCNet
[ra95-spawn]
maxfps=125
; Command & Conquer: Red Alert
[ra95]
maxgameticks=120
maxfps=60
minfps=-1
; Command & Conquer: Red Alert
[ra95_Mod-Launcher]
maxgameticks=120
maxfps=60
minfps=-1
; Command & Conquer: Red Alert
[ra95p]
maxfps=60
minfps=-1
; Command & Conquer: Tiberian Sun / Command & Conquer: Red Alert 2
[game]
checkfile=.\blowfish.dll
tshack=true
noactivateapp=true
adjmouse=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Tiberian Sun Demo
[SUN]
noactivateapp=true
tshack=true
adjmouse=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Tiberian Sun - CnCNet
[ts-spawn]
noactivateapp=true
tshack=true
adjmouse=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Red Alert 2 - XWIS
[ra2]
noactivateapp=true
tshack=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Red Alert 2 - XWIS
[Red Alert 2]
noactivateapp=true
tshack=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Red Alert 2: Yuri's Revenge
[gamemd]
noactivateapp=true
tshack=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Red Alert 2: Yuri's Revenge - ?ModExe?
[ra2md]
noactivateapp=true
tshack=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Red Alert 2: Yuri's Revenge - CnCNet
[gamemd-spawn]
noactivateapp=true
tshack=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Command & Conquer: Red Alert 2: Yuri's Revenge - XWIS
[Yuri's Revenge]
noactivateapp=true
tshack=true
maxfps=60
minfps=-1
maintas=false
boxing=false
; Caesar III
[c3]
renderer=opengl
nonexclusive=true
adjmouse=true
; Chris Sawyer's Locomotion
[LOCO]
adjmouse=true
; Cultures 2
[Cultures2]
adjmouse=true
; Cultures 2 MP
[Cultures2MP]
adjmouse=true
; Close Combat 2: A Bridge Too Far
[cc2]
adjmouse=true
renderer=opengl
nonexclusive=true
; Close Combat 3: The Russian Front
[cc3]
adjmouse=true
renderer=opengl
nonexclusive=true
; Close Combat 4: The Battle of the Bulge
[cc4]
adjmouse=true
renderer=opengl
nonexclusive=true
; Close Combat 5: Invasion: Normandy
[cc5]
adjmouse=true
renderer=opengl
nonexclusive=true
; Call To Power 2
[ctp2]
maintas=false
boxing=false
; Corsairs Gold
[corsairs]
adjmouse=true
renderer=gdi
hook=2
; Divine Divinity
[div]
resolutions=2
singlecpu=false
; Dune 2000
[dune2000]
fpupreserve=true
; Dune 2000 - CnCNet
[dune2000-spawn]
fpupreserve=true
; Dragon Throne: Battle of Red Cliffs
[AdSanguo]
maxgameticks=60
noactivateapp=true
limit_bltfast=true
; Dark Reign: The Future of War
[DKReign]
renderer=opengl
maxgameticks=60
; Dungeon Keeper 2
[DKII]
maxgameticks=60
noactivateapp=true
; Deadlock 2
[DEADLOCK]
fixchilds=0
adjmouse=false
maintas=false
boxing=false
; Escape Velocity Nova
[EV Nova]
renderer=opengl
devmode=true
hook_peekmessage=true
rgb555=true
keytogglefullscreen=0x46
adjmouse=true
; Economic War
[EcoW]
maxgameticks=60
fixnotresponding=true
; Fallout
[falloutw]
dinputhook=true
; Fallout 2
[FALLOUT2]
dinputhook=true
; Fairy Tale About Father Frost, Ivan and Nastya
[mrazik]
guard_lines=0
; Future Cop - L.A.P.D.
[FCopLAPD]
renderer=opengl
nonexclusive=true
adjmouse=true
; G-Police
[GPOLICE]
maxgameticks=60
; Gangsters: Organized Crime
[gangsters]
adjmouse=true
renderer=opengl
nonexclusive=true
; Grand Theft Auto
[Grand Theft Auto]
fixwndprochook=true
singlecpu=false
; Grand Theft Auto: London 1969
[gta_uk]
fixwndprochook=true
singlecpu=false
; Grand Theft Auto: London 1961
[Gta_61]
fixwndprochook=true
singlecpu=false
; Heroes of Might and Magic II: The Succession Wars
[HEROES2W]
adjmouse=true
; Hard Truck: Road to Victory
[htruck]
maxgameticks=25
renderer=opengl
noactivateapp=true
; Invictus
[Invictus]
adjmouse=true
fixwndprochook=true
renderer=opengl
; Interstate 76
[i76]
adjmouse=true
renderer=opengl
; Infantry Online
[infantry]
devmode=true
resolutions=2
infantryhack=true
max_resolutions=90
; Jagged Alliance 2
[ja2]
singlecpu=false
fixmousehook=true
noactivateapp=true
releasealt=true
novidmem=true
; Jagged Alliance 2: Wildfire
[WF6]
singlecpu=false
fixmousehook=true
noactivateapp=true
releasealt=true
novidmem=true
; Jagged Alliance 2 - UC mod
[JA2_UC]
singlecpu=false
fixmousehook=true
noactivateapp=true
releasealt=true
novidmem=true
; Jagged Alliance 2 - Vengeance Reloaded mod
[JA2_Vengeance]
singlecpu=false
fixmousehook=true
noactivateapp=true
releasealt=true
novidmem=true
; Kings Quest 8
[Mask]
renderer=opengl
; Konung
[konung]
fixchilds=0
; Konung 2
[Konung2]
fixchilds=0
; KKND Xtreme (With high resolution patch)
[KKNDgame]
vhack=true
; KKND2: Krossfire
[KKND2]
noactivateapp=true
renderer=gdi
hook=2
; Lionheart
[Lionheart]
locktopleft=true
; Majesty Gold
[Majesty]
minfps=-2
; Majesty Gold HD
[MajestyHD]
adjmouse=true
; Majesty Gold HD
[MajestyHD - Old]
adjmouse=true
; Mech Warrior 3
[Mech3]
renderer=opengl
nonexclusive=true
; Moorhuhn
[Moorhuhn]
dinputhook=true
; Moorhuhn 2
[Moorhuhn2]
dinputhook=true
releasealt=true
; New Robinson
[ROBY]
adjmouse=true
hook_peekmessage=true
; Outlaws
[olwin]
noactivateapp=true
maxgameticks=60
adjmouse=true
renderer=gdi
; Pharaoh
[Pharaoh]
adjmouse=true
; Pax Imperia
[Pax Imperia]
renderer=opengl
nonexclusive=true
; Railroad Tycoon II
[RT2]
adjmouse=true
; ROAD RASH
[RoadRash]
adjmouse=true
fixchilds=1
; Septerra Core
[septerra]
hook=2
; Sim Copter
[SimCopter]
renderer=opengl
nonexclusive=true
; Settlers 3
[s3]
renderer=opengl
nonexclusive=true
; Star Trek - Armada
[Armada]
armadahack=true
renderer=opengl
nonexclusive=true
adjmouse=true
maintas=false
boxing=false
; Star Wars: Galactic Battlegrounds
[battlegrounds]
renderer=opengl
nonexclusive=true
adjmouse=true
; Star Wars: Galactic Battlegrounds: Clone Campaigns
[battlegrounds_x1]
renderer=opengl
nonexclusive=true
adjmouse=true
; Starcraft
[StarCraft]
game_handles_close=true
; Stronghold Crusader HD
[Stronghold Crusader]
adjmouse=true
; Space Rangers
[Rangers]
locktopleft=true
; Stronghold Crusader Extreme HD
[Stronghold_Crusader_Extreme]
adjmouse=true
; Stronghold HD
[Stronghold]
adjmouse=true
; Sim City 3000
[SC3]
renderer=opengl
minfps=-2
; Shadow Watch
[sw]
adjmouse=true
; Shadow Flare
[ShadowFlare]
renderer=opengl
nonexclusive=true
adjmouse=true
maintas=false
boxing=false
; Theme Park World
[TP]
fixwndprochook=true
; Total Annihilation (Unofficial Beta Patch v3.9.02)
[TotalA]
lock_surfaces=true
singlecpu=false
fixwndprochook=true
; Total Annihilation Replay Viewer (Unofficial Beta Patch v3.9.02)
[Viewer]
lock_surfaces=true
singlecpu=false
fixwndprochook=true
; Three Kingdoms: Fate of the Dragon
[sanguo]
maxgameticks=60
noactivateapp=true
limit_bltfast=true
; Twisted Metal
[TWISTED]
renderer=opengl
nonexclusive=true
maxgameticks=25
minfps=5
; Twisted Metal 2
[Tm2]
renderer=opengl
nonexclusive=true
maxgameticks=60
adjmouse=true
fixchilds=1
maintas=false
boxing=false
; Tzar: The Burden of the Crown
; Note: Must set 'DIRECTXDEVICE=0' in 'Tzar.ini'
[Tzar]
adjmouse=true
; Uprising
[uprising]
adjmouse=true
; Uprising 2
[Uprising 2]
renderer=opengl
adjmouse=true
; Wizardry 8
[Wiz8]
fixmousehook=true
noactivateapp=true
releasealt=true
novidmem=true
; Worms Armageddon
[WA]
adjmouse=true
width=0
height=0
resizable=false
; Wizards and Warriors
[deep6]
renderer=gdi
hook=2
; War Wind
[WW]
renderer=opengl
; Zeus and Poseidon
[Zeus]
adjmouse=true
ddraw_custom.dll
LFS
BIN
View File
Binary file not shown.
tdraw.dll
LFS
BIN
View File
Binary file not shown.
tmusi.dll
LFS
BIN
View File
Binary file not shown.
tplayx.dll
LFS
BIN
View File
Binary file not shown.
wgmus readme.MD
+30
View File
@@ -0,0 +1,30 @@
/***************************************************************************/
WGMUS.DLL (WARGAME MUSIC DLL) IS DESIGNED FOR USE WITH TOTAL ANNIHILATION TO ENABLE MUSIC PLAYBACK FROM FILES ON HARD DRIVE, OR FROM CD AS OF NOW, PLAYBACK IS SUPPORTED VIA BASS ( https://www.un4seen.com/ ) AND ADDON BASS CD PLANS FOR SUPPORTING AUDIERE, OPENAL, WINMM, AND DIRECTSHOW. PARTIALLY BASED ON OGG-WINMM https://github.com/hifi-unmaintained/ogg-winmm
PLACE INTO TOTAL ANNIHILATION DIRECTORY, AND REGEDIT TOTALA.EXE REPLACE MENTION OF WINMM.DLL, or WIN32.DLL DEPENDING ON RELEASE WITH WGMUS.DLL
DEFAULT MUSIC FOLDER NAME IS tamus IT IS ADVISED TO NAME TRACKS IN A MANNER THAT IS CONSISTENT FOR EXAMPLE, 00.mp3, 01.mp3, AND SO FORTH NOT 1.mp3 to 9.mp3, THEN 10 to 16 MP3 AS THEY WILL BE LOADED IN THE "WRONG" ORDER.
SETTINGS ARE CONTROLLED VIA wgmus.ini
SPECIAL THANKS:
THALDREN,
KEVIN HAKE,
ARMOURED FISH
COPYRIGHT MENTIONS:
ogg-winmm
Copyright (c) 2012 Toni Spets <toni.spets@iki.fi>
BASS 2.4
Copyright (c) 1999-2022 Un4seen Developments Ltd. All rights reserved.
BASSCD 2.4
Copyright (c) 2003-2022 Un4seen Developments Ltd. All rights reserved.
BASSFLAC 2.4
Copyright (c) 2004-2023 Un4seen Developments Ltd. All rights reserved.
BASSmix 2.4
Copyright (c) 2005-2022 Un4seen Developments Ltd. All rights reserved.
BASSWASAPI 2.4
Copyright (c) 2009-2020 Un4seen Developments Ltd. All rights reserved.
/***************************************************************************/
wgmus.dll
LFS
BIN
View File
Binary file not shown.
wgmus.ini
+13
View File
@@ -0,0 +1,13 @@
[Settings]
;Accepted file formats
;0 wav
;1 mp3
;2 ogg
;3 flac
;4 aiff
FileFormat=1
;Accepted music playback modes
;0 CD
;1 Folder
PlaybackMode=1
MusicFolder=music