Add Dummy NPC

Add ast_interior_base
2025-05-09 20:46:30 +02:00 · 2025-05-07 23:08:19 +02:00
185 changed files with 1880 additions and 4423 deletions
--- a/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt05/ast_rock_mt05_asteroid.3db
+++ b/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt05/ast_rock_mt05_asteroid.3db
--- a/DATA/EQUIPMENT/misc_good.ini
+++ b/DATA/EQUIPMENT/misc_good.ini
@@ -90,7 +90,7 @@ ids_info = 264748
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01 
+nickname = mod_s_tractor_01 
 equipment = ge_s_tractor_01
 category = equipment
 price = 10
@@ -101,7 +101,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_red
+nickname = mod_s_tractor_01_red
 equipment = ge_s_tractor_01_red
 category = equipment
 price = 10
@@ -112,7 +112,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_yellow
+nickname = mod_s_tractor_01_yellow
 equipment = ge_s_tractor_01_yellow
 category = equipment
 price = 10
@@ -123,7 +123,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_blue
+nickname = mod_s_tractor_01_blue
 equipment = ge_s_tractor_01_blue
 category = equipment
 price = 10
@@ -134,7 +134,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_cyan
+nickname = mod_s_tractor_01_cyan
 equipment = ge_s_tractor_01_cyan
 category = equipment
 price = 10
@@ -145,7 +145,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_purple
+nickname = mod_s_tractor_01_purple
 equipment = ge_s_tractor_01_purple
 category = equipment
 price = 10
@@ -156,7 +156,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_pink
+nickname = mod_s_tractor_01_pink
 equipment = ge_s_tractor_01_pink
 category = equipment
 price = 10
@@ -167,7 +167,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_green
+nickname = mod_s_tractor_01_green
 equipment = ge_s_tractor_01_green
 category = equipment
 price = 10
@@ -178,7 +178,7 @@ ids_info = 264744
 shop_archetype = equipment\models\commodities\crates\crate_grey.3db

 [Good]
-nickname = ge_s_tractor_01_orange
+nickname = mod_s_tractor_01_orange
 equipment = ge_s_tractor_01_orange
 category = equipment
 price = 10
--- a/DATA/EQUIPMENT/select_equip.ini
+++ b/DATA/EQUIPMENT/select_equip.ini
@@ -2928,33 +2928,6 @@ explosion_arch = explosion_oxygen_bw09
 debris_type = debris_vanish


-; Track Guide
-
-[CargoPod]
-nickname = track_guide_red01
-LODranges = 0
-DA_archetype = solar\TRACK_MISC\track_guide_red.3db
-material_library = solar\TRACK_MISC\track_guide_red.3db
-hit_pts = 1e36
-mass = 1e10
-HP_child = HpConnect
-parent_impulse = 0.010000
-child_impulse = 0.010000
-debris_type = debris_vanish
-
-[CargoPod]
-nickname = track_guide_red02
-LODranges = 0
-DA_archetype = solar\TRACK_MISC\track_guide_red02.3db
-material_library = solar\TRACK_MISC\track_guide_red02.3db
-hit_pts = 1e36
-mass = 1e10
-HP_child = HpConnect
-parent_impulse = 0.010000
-child_impulse = 0.010000
-debris_type = debris_vanish
-
-



--- a/DATA/FONTS/rich_fonts.ini
+++ b/DATA/FONTS/rich_fonts.ini
@@ -130,10 +130,3 @@ italic = false
 underline = false
 color = 0, 255, 0

-[Style]
-name = STYLE_EXTERNAL
-font = 0
-bold = false
-italic = false
-underline = false
-color = 255, 255, 255
--- a/DATA/INTERFACE/keylist.ini
+++ b/DATA/INTERFACE/keylist.ini
@@ -300,6 +300,10 @@ id = USER_ASSIGN_WEAPON_GROUP5
 [key]
 id = USER_ASSIGN_WEAPON_GROUP6

+[Group]
+group_num = 2
+name = 1504
+
 [key]
 id = USER_CHAT

@@ -315,8 +319,3 @@ id = USER_GROUP_INVITE
 [key]
 id = USER_TRADE_REQUEST

-[Group]
-group_num = 2
-name = 1504
-
-
--- a/DATA/SCRIPTS/BASES/li_08_deck_hardpoint_01_asteroid.thn
+++ b/DATA/SCRIPTS/BASES/li_08_deck_hardpoint_01_asteroid.thn
--- a/DATA/SCRIPTS/BASES/npc_test.thn
+++ b/DATA/SCRIPTS/BASES/npc_test.thn
--- a/DATA/SCRIPTS/HELPERS/convert.lua
+++ b/DATA/SCRIPTS/HELPERS/convert.lua
@@ -1,63 +0,0 @@
-Convert = {}
-Convert["QuatToMatrix"] = function(quat)
-
-	local x = quat[1]
-	local y = quat[2]
-	local z = quat[3]
-	local w = quat[4]
-
-	local x2 = x + x
-	local y2 = y + y
-	local z2 = z + z
-
-	local xx = x * x2
-	local yx = y * x2
-	local yy = y * y2
-	local zx = z * x2
-	local zy = z * y2
-	local zz = z * z2
-	local wx = w * x2
-	local wy = w * y2
-	local wz = w * z2
-
-	local result = {
-		{ 1 - yy - zz, yx + wz, zx - wy },
-		{ yx - wz, 1 - xx - zz, zy + wx },
-		{ zx + wy, zy - wx, 1 - xx - yy }
-	}
-
-	return result
-end
-
-Convert["EulerToQuat"] = function (x, y, z)
-
-    local b = y * 0.5;
-    local c = x * 0.5;
-    local d = z * 0.5;
-    
-    local sp = sin(b)
-    local cp = cos(b)
-    local sy = sin(c)
-    local cy = cos(c)
-    local sr = sin(d) 
-    local cr = cos(d)
-    local a0 = sp * cy * cr
-    local b0 = cp * sy * sr
-    local a1 = cp * sy * cr
-    local b1 = sp * cy * sr
-    local a2 = cp * cy * sr
-    local b2 = sp * sy * cr
-    local a3 = cp * cy * cr
-    local b3 = sp * sy * sr
-     
-    local result = { Math.round(a0 + b0, 5), Math.round(a1 - b1, 5), Math.round(a2 + b2, 5), Math.round(a3 - b3, 5) }
-    return result
-end
-
-- Should be called in place of orient like this: orient  =  Convert.EulerToMatrix(x, y, z),
-
-Convert["EulerToMatrix"] = function (x, y, z)
-	local q = Convert.EulerToQuat(y, x, z)
-	local m = Convert.QuatToMatrix(q)
-	return m
-end
--- a/DATA/SCRIPTS/HELPERS/math.lua
+++ b/DATA/SCRIPTS/HELPERS/math.lua
@@ -1,47 +0,0 @@
-Math = {}
-Math["round"] = function (num, numDecimalPlaces)
-    local mult = 10^(numDecimalPlaces or 0)
-    return floor(num * mult + 0.5) / mult
-end
-
-function sphereCollision(a, b)
-    local ax = a.center[1]
-    local ay = a.center[2]
-    local az = a.center[3]
-
-    local bx = b.center[1]
-    local by = b.center[2]
-    local bz = b.center[2]
-
-    local threshold = (a.radius + b.radius) * (a.radius + b.radius)
-
-    local dx = bx - ax
-    local dy = by - ay
-    local dz = bz - az
-  
-    local distSq = dx * dx + dy * dy + dz * dz
-
-    return distSq < threshold
-end
-
-- Default functions
-Math["abs"] = abs
-Math["asin"] = asin
-Math["atan"] = atan
-Math["atan2"] = atan2
-Math["ceil"] = ceil
-Math["cos"] = cos
-Math["sin"] = sin
-Math["tan"] = tan
-Math["deg"] = deg
-Math["floor"] = floor
-Math["log"] = log
-Math["log10"] = log10
-Math["max"] = max
-Math["min"] = min
-Math["mod"] = mod
-Math["sqrt"] = sqrt
-Math["frexp"] = frexp
-Math["ldexp"] = ldexp
-Math["random"] = random
-Math["randomseed"] = randomseed
--- a/DATA/SCRIPTS/HELPERS/utils.lua
+++ b/DATA/SCRIPTS/HELPERS/utils.lua
@@ -1,14 +0,0 @@
-Utils = {}
-Utils["writeVariables"] = function()
-    filename = "lua.variables.log"
-    remove(filename)
-	local LogVars
-    LogVars = function(x, y)
-        local file = appendto(filename)
-        write(file, tostring(x).." ( "..tostring(y).." )\n")
-        flush(file)
-        closefile(file)
-    end
-    foreachvar(LogVars)
-	filename = nil
-end
--- a/DATA/SCRIPTS/helpers.lua
+++ b/DATA/SCRIPTS/helpers.lua
@@ -1,3 +0,0 @@
-dofile('..\\DATA\\SCRIPTS\\HELPERS\\math.lua')
-dofile('..\\DATA\\SCRIPTS\\HELPERS\\convert.lua')
-dofile('..\\DATA\\SCRIPTS\\HELPERS\\utils.lua')
--- a/DATA/SHIPS/loadouts.ini
+++ b/DATA/SHIPS/loadouts.ini
@@ -10632,17 +10632,4 @@ equip = armor_scale_9
 equip = nomad_gun01_mark03, HpWeapon01
 equip = nomad_gun01_mark03, HpWeapon02
 equip = nomad_gun01_mark03, HpWeapon03
-cargo = commodity_halloween, 1
-
-[Loadout]
-nickname = SECRET_ou_bw_elite2_st01
-archetype = bw_elite2
-equip = special_gun04, HpWeapon01
-equip = special_gun05, HpWeapon02
-equip = mine02_mark05, HpMine01
-cargo = mine02_mark05_ammo, 5
-cargo = ge_s_battery_01, 10
-cargo = ge_s_repair_01, 10
-cargo = commodity_nomad_prototyp_schematic, 1
-cargo = commodity_tractor_beam_schematic, 2
-cargo = nomad_torpedo01_player, 1
+cargo = commodity_halloween, 1
--- a/DATA/SOLAR/ASTEROIDS/MODELS/ast_ring/ast_rock_ring.3db
+++ b/DATA/SOLAR/ASTEROIDS/MODELS/ast_ring/ast_rock_ring.3db
--- a/DATA/SOLAR/ASTEROIDS/MODELS/ast_ring/ast_rock_ring.sur
+++ b/DATA/SOLAR/ASTEROIDS/MODELS/ast_ring/ast_rock_ring.sur
--- a/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt04/ast_rock_mt04_asteroid.3db
+++ b/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt04/ast_rock_mt04_asteroid.3db
--- a/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt04/ast_rock_mt04_asteroid.sur
+++ b/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt04/ast_rock_mt04_asteroid.sur
--- a/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt05/ast_rock_mt05_asteroid.sur
+++ b/DATA/SOLAR/ASTEROIDS/MODELS/mining_tunnel/ast_rock_mt05/ast_rock_mt05_asteroid.sur
--- a/DATA/SOLAR/TRACK_MISC/track_curve_guide.3db
+++ b/DATA/SOLAR/TRACK_MISC/track_curve_guide.3db
--- a/DATA/SOLAR/TRACK_MISC/track_curve_guide.sur
+++ b/DATA/SOLAR/TRACK_MISC/track_curve_guide.sur
--- a/DATA/SOLAR/TRACK_MISC/track_guide_red.3db
+++ b/DATA/SOLAR/TRACK_MISC/track_guide_red.3db
--- a/DATA/SOLAR/TRACK_MISC/track_guide_red02.3db
+++ b/DATA/SOLAR/TRACK_MISC/track_guide_red02.3db
--- a/DATA/SOLAR/TRACK_MISC/track_spiral_guide.3db
+++ b/DATA/SOLAR/TRACK_MISC/track_spiral_guide.3db
--- a/DATA/SOLAR/TRACK_MISC/track_spiral_guide.sur
+++ b/DATA/SOLAR/TRACK_MISC/track_spiral_guide.sur
--- a/DATA/SOLAR/TRACK_MISC/track_straight_guide.3db
+++ b/DATA/SOLAR/TRACK_MISC/track_straight_guide.3db
--- a/DATA/SOLAR/TRACK_MISC/track_straight_guide.sur
+++ b/DATA/SOLAR/TRACK_MISC/track_straight_guide.sur
--- a/DATA/SOLAR/loadouts.ini
+++ b/DATA/SOLAR/loadouts.ini
@@ -7533,11 +7533,6 @@ equip = ast_nomad01_mt03_asteroid33, HpAsteroid01
 equip = ast_nomad01_mt03_asteroid34, HpAsteroid01
 equip = ast_nomad01_mt03_asteroid35, HpAsteroid01

-[Loadout]
-nickname = alien_structure01_load
-cargo = commodity_alien_artifacts, 25
-cargo = nomad_torpedo01_player, 1
-cargo = commodity_nomad_prototyp_schematic, 2

 [Loadout]
 nickname = alien_structure02_load
@@ -7545,7 +7540,6 @@ cargo = commodity_alien_artifacts, 25
 cargo = nomad_torpedo01_player, 1
 cargo = special_nomad_gun03, 2

-
 [Loadout]
 nickname = ast_rock_mt02_asteroid_crystal_load
 equip = ast_rock_mt02_asteroid01, HpAsteroid01
@@ -13116,12 +13110,3 @@ equip = first_level_display_denied, HpPanel01
 nickname = first_level_display_granted_load
 equip = first_level_display_granted, HpPanel01

-
-
-[Loadout]
-nickname = ast_rock_mt05_track_guide_red
-equip = track_guide_red01, HpTrackGuide
-
-[Loadout]
-nickname = ast_rock_mt05_track_guide_red02
-equip = track_guide_red02, HpTrackGuide
--- a/DATA/SOLAR/solararch.ini
+++ b/DATA/SOLAR/solararch.ini
@@ -7642,7 +7642,6 @@ shape_name = NNM_SM_COMMUNICATIONS
 nickname = alien_structure01
 LODranges = 0, 6000, 10000
 type = NON_TARGETABLE
-loadout = alien_structure01_load
 DA_archetype = solar\asteroids\models\alien_structure\alien_structure01.3db
 material_library = solar\asteroids\models\alien_structure\alien_structure01.3db
 mass = 1e10
@@ -8534,28 +8533,6 @@ hit_pts = 1e36
 solar_radius = 20000
 shape_name = NNM_SM_COMMUNICATIONS

-[Solar]
-nickname = ast_rock_mt04_asteroid
-LODranges = 0, 20000, 40000
-type = NON_TARGETABLE
-DA_archetype = solar\asteroids\models\mining_tunnel\ast_rock_mt04\ast_rock_mt04_asteroid.3db
-material_library = solar\asteroids\models\mining_tunnel\ast_rock_mt04\ast_rock_mt04_asteroid.3db
-mass = 1e10
-hit_pts = 1e36
-solar_radius = 20000
-shape_name = NNM_SM_COMMUNICATIONS
-
-[Solar]
-nickname = ast_rock_mt05_asteroid
-LODranges = 0, 20000, 40000
-type = NON_TARGETABLE
-DA_archetype = solar\asteroids\models\mining_tunnel\ast_rock_mt05\ast_rock_mt05_asteroid.3db
-material_library = solar\asteroids\models\mining_tunnel\ast_rock_mt05\ast_rock_mt05_asteroid.3db
-mass = 1e10
-hit_pts = 1e36
-solar_radius = 20000
-shape_name = NNM_SM_COMMUNICATIONS
-
 [Solar]
 nickname = ast_ice_block_mt01_base
 LODranges = 0, 20000
@@ -8568,71 +8545,6 @@ loadout = ast_ice_block_mt01_base_load
 solar_radius = 20000
 shape_name = NNM_SM_COMMUNICATIONS

-; Race Track Miscs
-
-[Solar]
-type = NON_TARGETABLE
-nickname = track_guide_red
-LODranges = 0
-DA_archetype = solar\TRACK_MISC\track_guide_red.3db
-material_library = solar\TRACK_MISC\track_guide_red.3db
-surface_hit_effects = 0, small_hull_hit
-mass = 100000
-solar_radius = 80000
-shape_name = NAV_surpriseX
-hit_pts = 1000000
-destructible = false
-
-[Solar]
-type = NON_TARGETABLE
-nickname = track_straight_guide
-LODranges = 0
-DA_archetype = solar\TRACK_MISC\track_straight_guide.3db
-material_library = solar\TRACK_MISC\track_straight_guide.3db
-surface_hit_effects = 0, small_hull_hit
-mass = 100000
-solar_radius = 80000
-shape_name = NAV_surpriseX
-hit_pts = 1000000
-destructible = false
-
-[Solar]
-type = NON_TARGETABLE
-nickname = track_curve_guide
-LODranges = 0
-DA_archetype = solar\TRACK_MISC\track_curve_guide.3db
-material_library = solar\TRACK_MISC\track_curve_guide.3db
-surface_hit_effects = 0, small_hull_hit
-mass = 100000
-solar_radius = 80000
-shape_name = NAV_surpriseX
-hit_pts = 1000000
-destructible = false
-
-[Solar]
-type = NON_TARGETABLE
-nickname = track_spiral_guide
-LODranges = 0
-DA_archetype = solar\TRACK_MISC\track_spiral_guide.3db
-material_library = solar\TRACK_MISC\track_spiral_guide.3db
-surface_hit_effects = 0, small_hull_hit
-mass = 100000
-solar_radius = 80000
-shape_name = NAV_surpriseX
-hit_pts = 1000000
-destructible = false
-
-[Solar]
-nickname = ast_rock_ring
-LODranges = 0, 20000, 40000
-type = NON_TARGETABLE
-DA_archetype = solar\asteroids\models\ast_ring\ast_rock_ring.3db
-material_library = solar\asteroids\models\ast_ring\ast_rock_ring.3db
-mass = 1e10
-hit_pts = 1e36
-solar_radius = 20000
-shape_name = NNM_SM_COMMUNICATIONS
-
 ; Billboards

 [Solar]
--- a/DATA/UNIVERSE/SYSTEMS/BW11/bw11.ini
+++ b/DATA/UNIVERSE/SYSTEMS/BW11/bw11.ini
@@ -1,419 +0,0 @@
-[SystemInfo]
-space_color = 0, 0, 0
-local_faction = li_p_grp
-
-[Ambient]
-color = 60, 80, 100
-
-[Background]
-basic_stars = solar\starsphere\starsphere_stars_basic.cmp
-complex_stars = solar\starsphere\starsphere_li01_stars.cmp
-nebulae = solar\starsphere\starsphere_li01.cmp
-
-[LightSource]
-nickname = Bw11_system_light
-pos = -31, 0, -48
-color = 120, 250, 255
-range = 50000
-type = DIRECTIONAL
-atten_curve = DYNAMIC_DIRECTION
-
-[Object]
-nickname = Bw11_Sun1
-ids_name = 261037
-pos = 0, 0, 0
-ambient_color = 255, 255, 255
-Archetype = sun_1000
-star = Bw11_Sun1
-atmosphere_range = 5000
-ids_info = 66151
-
-[Object]
-nickname = Bw11_to_Li05_hole
-ids_name = 260857
-;pos = 21917, 0, 12508
-pos = -33400, 110, -21000
-rotate = 0, 90, 0
-Archetype = jumphole_light
-msg_id_prefix = gcs_refer_system_Bw11
-ids_info = 66146
-jump_effect = jump_effect_hole
-visit = 0
-goto = Li05, Li05_to_Bw11_hole, gate_tunnel_bretonia
-
-[Object]
-nickname = Bw06_02
-ids_name = 196706
-pos = 22374, 0, 10000
-archetype = depot
-ids_info = 65829
-base = Bw06_02_Base
-dock_with = Bw06_02_Base
-reputation = co_hsp_grp
-behavior = NOTHING
-visit = 0
-voice = atc_leg_f01
-space_costume = pl_female5_head, sc_female1_body
-difficulty_level = 13
-loadout = depot_co_03
-pilot = pilot_solar_hardest
-
-
-;Please leave this the code alone and do not delete it!!! :D
-
-;[Object]
-;nickname = dmkv_temple
-;pos = 20000, -8350, 1000
-;rotate = 0, 25, 0
-;Archetype = dmkv_temple
-;loadout = dmkv_temple_load
-
-;[Object]
-;nickname = nomadbase_dmkv01
-;ids_name = 198012
-;pos = 20000, -8350, 1000
-;Archetype = nomadbase_dmkv
-
-; [Object]
-; nickname = Bw05_01
-; ids_name = 196702
-; pos = -4675, 100, -12092
-; Archetype = space_police01
-; ids_info = 65823
-; dock_with = Bw05_01_Base
-; base = Bw05_01_Base
-; reputation = gd_gm_grp
-; behavior = NOTHING
-; voice = atc_leg_m01
-; space_costume = pl_male8_head, li_rockford_body
-; difficulty_level = 12
-; loadout = space_police01_co_01
-; pilot = pilot_solar_hard
-
-; [Object]
-; nickname = Bw05_02
-; ids_name = 196703
-; pos = -9537, 0, 19442
-; rotate = 0, -90, 0
-; Archetype = space_mining01
-; ids_info = 65825
-; dock_with = Bw05_02_Base
-; base = Bw05_02_Base
-; reputation = co_alg_grp
-; behavior = NOTHING
-; voice = atc_leg_f01
-; space_costume = rh_newscaster_head, rh_greunwald_body
-; difficulty_level = 11
-; loadout = space_mining01_co_02
-; pilot = pilot_solar_easy
-
-; Race Track
-
-[Object]
-nickname = ast_rock_mt04_asteroid01
-pos = -36920, 120, -21400
-rotate = 0, 135, 0
-Archetype = ast_rock_mt04_asteroid
-
-[Object]
-nickname = ast_rock_mt05_asteroid01
-pos = -37400, 110, -21000
-rotate = 0, 135, 0
-Archetype = ast_rock_mt05_asteroid
-loadout = ast_rock_mt05_track_guide_red02
-
-;[Object]
-;nickname = track_guide_red01
-;pos = -37400, 110, -20910
-;rotate = 90, 75, 00
-;Archetype = track_guide_red
-
-[Object]
-nickname = track_straight_guide01
-pos = -37020, 115, -21310
-rotate = -45, 0, -90
-Archetype = track_straight_guide
-
-[Object]
-nickname = track_ring00
-pos = -37710, 135, -21220
-rotate = 0, -48, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring01
-pos = -37920, 135, -21400
-rotate = 0, -48, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_straight_guide02
-pos = -38340, 135, -21800
-rotate = 43, 0, -90
-Archetype = track_straight_guide
-
-[Object]
-nickname = track_ring02
-pos = -38785, 135, -22230
-rotate = 0, -48, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring03
-pos = -38985, 135, -22450
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide01
-pos = -39300, 135, -22840
-rotate = 43, 0, -90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring04
-pos = -39020, 135, -23350
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_straight_guide03
-pos = -38500, 135, -23850
-rotate = 135, 0, -90
-Archetype = track_straight_guide
-
-[Object]
-nickname = track_ring05
-pos = -38040, 135, -24300
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring06
-pos = -37710, 135, -24580
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide02
-pos = -37286, 135, -24892
-rotate = 135, 0, -90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring07
-pos = -36820, 135, -24650
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring08
-pos = -36580, 135, -24400
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring09
-pos = -36080, 135, -23900
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring10
-pos = -36300, 135, -24125
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide03
-pos = -35765, 175, -23595
-rotate = 90, -135, 0
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_curve_guide04
-pos = -35685, 775, -23515
-rotate = 0, -45, 180
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring11
-pos = -36080, 950, -23900
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring12
-pos = -36285, 950, -24125
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide05
-pos = -36625, 950, -24385
-rotate = 137, 0, 90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring13
-pos = -37115, 950, -24125
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring14
-pos = -37300, 950, -23950
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = ast_rock_ring01
-pos = -37550,950, -23720
-rotate = 0, 45, 0
-Archetype = ast_rock_ring
-spin = 0.05, 0.05, 0
-
-[Object]
-nickname = track_ring15
-pos = -37830, 950, -23455
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring16
-pos = -38045, 950, -23250
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide06
-pos = -38400, 950, -22830
-rotate = -137, 0, 90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring17
-pos = -38150, 950, -22300
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring18
-pos = -37950, 950, -22050
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = ast_rock_ring02
-pos = -37700, 950, -21775
-rotate = 0, 135, 0
-Archetype = ast_rock_ring
-spin = 0.05, 0.05, 0
-
-[Object]
-nickname = track_ring19
-pos = -37450, 950, -21450
-rotate = 0, -25, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_sprial_guide01
-pos = -37900, 350, -21150
-rotate = 270, 0, 0
-Archetype = track_spiral_guide
-
-[Object]
-nickname = track_ring20
-pos = -37655, 300, -20700
-rotate = -5, -25, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring21
-pos = -37325, 275, -20400
-rotate = -5, -65, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring22
-pos = -36765, 200, -20400
-rotate = -5, -110, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring23
-pos = -36150,120, -20500
-rotate = 0, -130, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring24
-pos = -35725,120, -20850
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring25
-pos = -35375,120, -21275
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide07
-pos = -34900,120, -21760
-rotate = 37, 0, 90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_curve_guide08
-pos = -35150,120, -22400
-rotate = 47, 0, -90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_curve_guide09
-pos = -34800,120, -22900
-rotate = 135, 0, -90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_curve_guide10
-pos = -34200,120, -22600
-rotate = 315, 0, 90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_curve_guide11
-pos = -33690,120, -22960
-rotate = 45, 0, 90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring26
-pos = -33950, 120, -23425
-rotate = 0, -45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_curve_guide12
-pos = -34320,120, -23690
-rotate = 135, 0, 90
-Archetype = track_curve_guide
-
-[Object]
-nickname = track_ring27
-pos = -34850,120, -23400
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring28
-pos = -35060,120, -23200
-rotate = 0, 45, 180
-Archetype = track_ring
-
-[Object]
-nickname = track_ring29
-pos = -35260,120, -23000
-rotate = 0, 45, 180
-Archetype = track_ring
--- a/DATA/UNIVERSE/SYSTEMS/LI01/BASES/ROOMS/li01_06_deck.ini
+++ b/DATA/UNIVERSE/SYSTEMS/LI01/BASES/ROOMS/li01_06_deck.ini
@@ -1,5 +1,7 @@
 [Room_Info]
-set_script = Scripts\Bases\Li_08_Deck_hardpoint_01.thn
+; set_script = Scripts\Bases\Li_08_Deck_hardpoint_01.thn
+set_script = Scripts\Bases\li_08_deck_hardpoint_01_asteroid.thn
+scene = all, ambient, Scripts\Bases\npc_test.thn
 scene = all, ambient, Scripts\Bases\Li_08_Deck_ambi_int_01.thn
 animation = Sc_loop

--- a/DATA/UNIVERSE/SYSTEMS/LI05/li05.ini
+++ b/DATA/UNIVERSE/SYSTEMS/LI05/li05.ini
@@ -59,20 +59,6 @@ reputation = fc_uk_grp
 behavior = NOTHING
 goto = Li01, Li01_to_Li05, gate_tunnel_bretonia

-; New System JH
-
-[Object]
-nickname = Li05_to_Bw11_hole
-ids_name = 260857
-pos = 65917, 0,32508
-rotate = 0, 90, 0
-Archetype = jumphole_light
-msg_id_prefix = gcs_refer_system_Li01
-ids_info = 66146
-jump_effect = jump_effect_hole
-visit = 0
-goto = Bw11, Bw11_to_Li05_hole, gate_tunnel_bretonia
-
 [zone]
 nickname = Zone_Li05_nebula
 pos = 0, 0, 0
--- a/DATA/UNIVERSE/universe.ini
+++ b/DATA/UNIVERSE/universe.ini
@@ -2060,16 +2060,6 @@ strid_name = 196642
 ids_info = 66124
 NavMapScale = 2

-[system]
-nickname = Bw11
-file = systems\Bw11\Bw11.ini
-pos = 11, 6
-msg_id_prefix = gcs_refer_system_Bw11
-visit = 0
-strid_name = 196637
-ids_info = 66118
-NavMapScale = 2
-
 [system]
 nickname = Ew01
 file = systems\Ew01\Ew01.ini
--- a/DATA/petaldb.ini
+++ b/DATA/petaldb.ini
@@ -158,6 +158,7 @@ room = bw_02_equipment, bases\pirate\hi_havana_equip.cmp
 room = hi_01_madrid_cityscape, bases\pirate\hi_01_madrid_cityscape.cmp
 prop = hi_01_madrid_background, bases\pirate\hi_01_madrid_background.3db
 room = hi_02_cadiz_cityscape, bases\pirate\hi_02_cadiz_cityscape.cmp
+room = ast_interior_base, bases\generic\ast_interior_base.3db
 room = st_01_dig_site, bases\generic\cv_dig_site.cmp
 room = st_02_dig_site, bases\generic\cv_dig_site_spruage.cmp
 room = st_02_lab, bases\generic\cv_lab.cmp
--- a/EXE/D3D8.dll
+++ b/EXE/D3D8.dll
--- a/EXE/FLAR.dll
+++ b/EXE/FLAR.dll
--- a/EXE/FLHook.dll
+++ b/EXE/FLHook.dll
--- a/EXE/FLHook.ini
+++ b/EXE/FLHook.ini
@@ -0,0 +1,396 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; general settings
+; AntiDockKill:     anti-dockkilling time in ms, starts when player has completely undocked and is able to fly freely.
+;                   while being dockkill-protected, the player can't be damaged by other players and can't damage 
+;                   other players himself
+; AntiF1:           anti-f1 time in ms. f1 pushing will be delayed for this amount of time if player is in space. 
+;                   the client won't see what happens while delaying. (set to 0 to disable)
+; DisconnectDelay:  similar to anti-f1, applies when player disconnects while being in space. the player's ship will
+;                   remain in space for this amount of time when he disconnects. within this period he can't 
+;                   reconnect to the server("your account is already in use" will be displayed)
+; EnableDieMsg:     suppress the "Player das died: XXX" messages and replace with improved FLHook death messages
+; DisableCharfileEncryption: disables charfile-encryption(will be saved in plain ascii-text). this may lead to some
+;                            problems with programs like ioncross!
+; ChangeCruiseDisruptorBehaviour:
+;                   set it to yes and cruise disruptors will no longer affect the engine kill
+; DisableNPCSpawns: disables all npc-spawns while the serverload is bigger than this value. this does not affect
+;                   mission npcs! it allows you to dynamically adjust the number of npcs (set to 0 to disable)
+;	ReservedSlots:		sets the number of reserved slots
+;	TorpMissileBaseDamageMultiplier:	sets the damage multiplier when a player missile/torpedo hits a base
+; MaxGroupSize:     change the maximum group size(default is 8)
+[General]
+AntiDockKill=4000
+AntiF1=0
+DisconnectDelay=10000
+EnableDieMsg=yes
+DisableCharfileEncryption=yes
+ChangeCruiseDisruptorBehaviour=yes
+DisableNPCSpawns=0
+ReservedSlots=0
+TorpMissileBaseDamageMultiplier=1.0
+MaxGroupSize=8
+PersistGroup=no
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; Plugins settings
+; LoadAllPlugins:		Load all plugins on starup (ignoring the list below)
+; plugin:			A list of plugins which should be loaded on startup if LoadAllPlugins is set to no. One line per plugin.
+
+[Plugins]
+LoadAllPlugins=yes
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; log settings
+; Debug:				general debug logging, creates timestamped debug logs "flhook_logs/debug/"
+; DebugMaxSize:			max size of debug log files (in MB)
+; LogAdminCommands:		log all admin commands
+; LogAdminCommands:		log all user commands
+; LogConnects:			log all connects
+; LogPerformanceTimers:	log all performance timers
+; TimerThreshold:		sets the reporting threshold for the performance timers, time in ms
+[Log]
+Debug=yes
+DebugMaxSize=100
+LogAdminCommands=yes
+LogSocketCommands=yes
+LogLocalSocketCommands=yes
+LogUserCommands=yes
+LogConnects=yes
+LogPerformanceTimers=yes
+TimerThreshold=100
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; kick settings
+; AntiBaseIdle:        time in seconds after which a player will be kicked for idling on a base/planet, no matter
+;                      if he's active or not (set to 0 to disable)
+; AntiCharMenuIdle:    time in seconds after which a player will be kicked for idling in charmenu (set to 0 to disable)
+; PingKick:            maximum average ping in ms, higher ping results in kick (set to 0 to disable)
+; PingKickFrame:       time-frame in seconds in which the average ping is calculated (f.e. PingKickFrame=30 -> calculate 
+;                      average ping by the pingdata of the last 30 seconds)
+; FluctKick:           maximum average ping fluctuation, higher fluctuation results in kick (set to 0 to disable)
+; LossKick:            maximum average loss, higher loss results in kick (set to 0 to disable)
+; LossKickFrame:       time-frame in seconds in which the average loss is calculated.
+; LagKick:             maximum average lag, higher lag results in kick (set to 0 to disable)
+; LagDetectionFrame:   frame in position updates in which the average lag is calculated.
+; LagDetectionMinimum: minimum difference in % after which lag is detected, the higher this setting the less lag will be detected
+; KickThreshold:       the server load must exceed this number before players are kicked for have high lag/loss/ping
+[Kick]
+AntiBaseIdle=0
+AntiCharMenuIdle=0
+PingKick=0
+PingKickFrame=120
+FluctKick=0
+LossKick=0
+LossKickFrame=120
+LagKick=0
+LagDetectionFrame=50
+LagDetectionMinimum=50
+KickThreshold=0
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; style settings, these settings affect appearance of text messages sent to a client
+; DeathMsgStyle:    style of death msgs occuring in foreign systems, this is the "data" value of a TRA xml-node
+;                   (explanation in readme.txt)
+; DeathMsgStyleSys: style of death msgs occuring in the system the player is currently in
+; DeathMsgTextPlayerKill:
+;                   text to be displayed when a player killed another one. %victim will be replaced by the name
+;                   of the victim etc. set it to nothing to disable the message.
+; DeathMsgTextSelfKill:
+;                   text to be displayed when a player killed him-/herself
+; DeathMsgTextNPC:  text to be displayed when a player was killed by an npc
+; DeathMsgTextSuicide:
+;                   text to be displayed when a player committed suicide
+; DeathMsgTextAdminKill:
+;                   text to be displayed when an admin kills a player with the "kill" command
+; KickMsg:          this is the xml-string of the text to be displayed when a player is kicked for a certain reason.
+;                   %reason will be replaced by the reason.
+; KickMsgPeriod:    this is the time period in ms during which the reason is shown before the player gets disconnected
+; UserCmdStyle:     style of the user-command replies
+; AdminCmdStyle:    style of the admin-command replies
+[Style]
+DeathMsgStyle=0x19198C01
+DeathMsgStyleSys=0x1919BD01
+DeathMsgTextPlayerKill=Death: %victim was killed by %killer (%type)
+DeathMsgTextSelfKill=Death: %victim killed himself (%type)
+DeathMsgTextNPC=Death: %victim was killed by an NPC
+DeathMsgTextSuicide=Death: %victim committed suicide
+DeathMsgTextAdminKill=Death: %victim was killed by an admin
+KickMsg=<TRA data="0x0000FF10" mask="-1"/><TEXT>You will be kicked. Reason: %reason</TEXT>
+KickMsgPeriod=5000
+UserCmdStyle=0x00FF0001
+AdminCmdStyle=0x00FF0001
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; socket settings
+; Activated:  must be set in order to enable socket listening
+; Port:       port that FLHook should listen to (ascii)
+; WPort:      port that FLHook should listen to (unicode), you will also need to send your commands in unicode
+; EPort:      port that FLHook should listen to (ascii,encrypted), you will also need to send your commands encrypted
+; EWPort:     port that FLHook should listen to (unicode,encrypted), you will also need to send your commands encrypted and in unicode
+; Key:        key to use for the blowfish encryption
+; PassX:      password
+; RightsX:    rights for that password (see the rights section in readme.txt)
+; you can have multiple passwords with their distinctive right settings
+; they must be numbered serially with passX/rightX
+[Socket]
+Activated=yes
+Port=1919
+WPort=1920
+EPort=1921
+EWPort=1922
+Key=SomeRandomKey000
+Pass0=test
+Rights0=superadmin
+Pass1=low
+Rights1=cash,beam
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; user commands (yes = enabled)
+; SetDieMsg:     enable/disable "/set diemsg"
+; SetDieMsgSize: enable/disable "/set diemsgsize"
+; SetChatFont:   enable/disable "/set chatfont"
+; Ignore:        enable/disble ignore commands
+; MaxIgnoreListEntries: maximum number of ignorelist-entries allowed for a player
+; Autobuy:       enable/disable "/autobuy"
+; Ping:					 enable/disable "/ping" and "/pingtarget"
+; Help:					 enable/disable "/help"
+; DefaultLocalChat: if enabled forces messages sent in system chat to be local unless explicitly overridden.
+[UserCommands]
+SetDieMsg=yes
+SetDieMsgSize=yes
+SetChatFont=yes
+Ignore=yes
+MaxIgnoreListEntries=30
+AutoBuy=no
+Ping=yes
+Help=no
+DefaultLocalChat=no
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; chat settings
+; SuppressX:        chat-text entered by players starting with this string will be suppressed but still shown in
+;                   in the eventmode. this simplifies coding a custom ingame-dialogsystem.
+[Chat]
+;Suppress0=/chat
+;Suppress1=/etc
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; nopvp settings
+; SystemX: disable pvp in this system(players can't damage other players)
+[NoPVP]
+; Causes "WARNING: get_system(FP7_system) failed" messages in server log
+System0=FP7_system
+System1=start
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; MultiKillMessages will be displayed whenever a player has made a certain amount of kills in a row
+; Activated:               enable/disable MultiKillMessages
+; Style:                   style of MultiKillMessages
+; <KillsInARow>=<message>: message will be displayed in the system and only to players which have diemsg set to
+;                          system/all.
+[MultiKillMessages]
+Activated=yes
+Style=0x1919BD01
+5=%player is on a rampage
+10=%player runs amok
+15=%player is godlike
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; you can enter ip/host bans here(a message will be printed to flhook_kicks.log when a ban matches)
+; BanAccountOnMatch: player's account will be banned if set to yes and one of the bans below matches(this setting must
+;                    be in the first line of [Bans]!)
+; simply append ip or hostname bans in this section(without the ';' at the beginning!). you may use wildcards(?,*). 
+[Bans]
+BanAccountOnMatch=No
+;13.37.*.*
+;*.lamer-isp.net
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; names settings
+; this is used by the "beam" command and allows you to specify shortcuts
+[Names]
+London = br01_01_base
+Southampton = br01_02_base
+Suffolk = br01_03_base
+Waterloo = br01_04_base
+Canterbury = br01_05_base
+Thames = br01_06_base
+Kensington = br01_07_base
+Trafalgar = br01_08_base
+Newgate = br02_01_base
+Birmingham = br02_02_base
+Sheffield = br02_03_base
+Liverpool = br02_04_base
+Kingston = br02_05_base
+Cambridge = br03_01_base
+Cambridge Research = br03_02_base
+Norfolk = br03_03_base
+Cardiff = br03_04_base
+Leeds = br04_01_base
+Stokes = br04_02_base
+York = br04_03_base
+Glasgow = br04_04_base
+LD-14 = br04_05_base
+Durham = br04_06_base
+Maghera = br04_07_base
+Hood = br05_01_base
+Glorious = br05_02_base
+Graves = br05_03_base
+Essex = br05_04_base
+Arranmore = br05_05_base
+Shetland = br06_01_base
+Aberdeen = br06_02_base
+Islay = br06_03_base
+Perth = br06_04_base
+Castlehill = br06_05_base
+Scapa Flow = br06_06_base
+Sprague = bw01_01_base
+Freeport 1 = bw01_02_base
+Rugen = bw01_03_base
+Douglas = bw01_04_base
+Baxter = bw01_05_base
+Cadiz = bw02_01_base
+Ronneburg = bw02_02_base
+Freistadt = bw03_01_base
+Breisen = bw03_02_base
+Elbich = bw03_03_base
+Solarius = bw04_01_base
+Freital = bw04_02_base
+Naha = bw05_01_base
+Helgoland = bw05_02_base
+Yanagi = bw05_03_base
+Kurile = bw06_01_base
+Atka = bw06_02_base
+Hawaii = bw07_01_base
+Ogashawa = bw07_02_base
+Cali = bw08_01_base
+Tau-31 Gate = bw08_02_base
+Java = bw08_03_base
+Nago = bw09_01_base
+Shinkaku = bw09_02_base
+Freeport 6 = bw09_03_base
+Harris = bw10_01_base
+Holman = bw10_02_base
+Freeport 10 = ew01_01_base
+Falkland = ew01_02_base
+Ruiz = ew02_01_base
+Leon = ew03_01_base
+Freeport 5 = ew03_02_base
+Freeport 9 = ew04_01_base
+Primus = ew06_01_base
+Gammu = ew06_02_base
+Malta = hi01_01_base
+Crete = hi02_01_base
+Tripoli = hi02_02_base
+Pacifica = iw01_01_base
+Freeport 2 = iw01_02_base
+Barrow = iw02_01_base
+Dawson = iw02_02_base
+Freeport 4 = iw03_01_base
+Mactan = iw03_02_base
+Curacao = iw04_01_base
+Montezuma = iw04_02_base
+Ames = iw05_01_base
+Nome = iw05_02_base
+Leiden = iw06_01_base
+Padua = iw06_02_base
+Tokyo = ku01_01_base
+Narita = ku01_02_base
+Yokohama = ku01_03_base
+Roppongi = ku01_04_base
+Shinagawa = ku01_05_base
+Shinjuku = ku01_06_base
+Kabukicho = ku01_07_base
+Fuchu = ku02_01_base
+Myoko = ku02_02_base
+Deshima = ku02_03_base
+Junyo = ku02_04_base
+Ohashi = ku02_05_base
+Kyushu = ku03_01_base
+Tsushima = ku03_02_base
+Nagumo = ku03_03_base
+Nansei = ku03_04_base
+Kagoshima = ku03_05_base
+Honshu = ku04_01_base
+Osaka = ku04_02_base
+Yukawa = ku04_03_base
+Kansai = ku04_04_base
+Aomori = ku04_05_base
+Akita = ku04_06_base
+Matsumoto = ku05_01_base
+Ainu = ku05_02_base
+Chugoku Gate = ku05_03_base
+Sapporo = ku05_04_base
+Kyoto = ku06_01_base
+Ryuku = ku07_01_base
+Heavens = ku07_02_base
+Manhattan = li01_01_base
+Pittsburgh = li01_02_base
+Missouri = li01_03_base
+Benford = li01_04_base
+Ithaca = li01_05_base
+Trenton = li01_06_base
+Norfolk Shipyard = li01_07_base
+Newark = li01_08_base
+West Point = li01_09_base
+Detroit = li01_10_base
+Fort Bush = li01_11_base
+Buffalo = li01_12_base
+Rochester = li01_13_base
+Baltimore = li01_14_base
+Los Angeles = li02_01_base
+California Minor = li02_02_base
+Yukon = li02_03_base
+Willard = li02_04_base
+San Diego = li02_05_base
+Alcatraz = li02_06_base
+Denver = li03_01_base
+RioGrande = li03_02_base
+Ouray = li03_03_base
+Pueblo = li03_04_base
+Houston = li04_01_base
+Huntsville = li04_02_base
+Mississippi = li04_03_base
+Beaumont = li04_04_base
+Sugarland = li04_05_base
+Mitchell = li05_01_base
+Anchorage = li05_02_base
+Anchorage Research = li05_03_base
+Juneau = li05_04_base
+Berlin = rh01_01_base
+Oder = rh01_02_base
+Ring = rh01_03_base
+Bonn = rh01_04_base
+Dortmund = rh01_05_base
+Essen = rh01_06_base
+Brandenburg = rh01_07_base
+Kreuzberg = rh01_08_base
+Hamburg = rh02_01_base
+Westfalen = rh02_02_base
+Vierlande = rh02_03_base
+Alster = rh02_04_base
+Altona = rh02_05_base
+Lübeck = rh02_06_base
+Stuttgart = rh03_01_base
+Baden-Baden = rh03_02_base
+Freiburg = rh03_03_base
+Ulm = rh03_04_base
+Konstanz = rh03_05_base
+Darmstadt = rh03_06_base
+Holstein = rh04_01_base
+Mainz = rh04_02_base
+Mannheim = rh04_03_base
+Fulda = rh04_04_base
+Bruchsal = rh04_05_base
+Wilhelmshaven = rh04_06_base
+Wiesbaden = rh04_07_base
+Jena = rh04_08_base
+Leipzig = rh05_01_base
+Bautzen = rh05_02_base
+Pirna = rh05_03_base
+Vogtland = rh05_04_base
+Bremen = rh05_05_base
+Toledo = st01_01_base
+Osiris = st01_02_base
--- a/EXE/FLSharp.dll
+++ b/EXE/FLSharp.dll
--- a/EXE/FLSharp.ini
+++ b/EXE/FLSharp.ini
@@ -1,36 +0,0 @@
-; This ini files specifies for each FLSharp feature whether or not it will be enabled.
-; For more information, see https://github.com/BC46/FLSharp/blob/main/README.md
-[FLSharp]
-; Ensures client-server updates occur more smoothly to prevent players with high/inconsistent framerates from jittering.
-; Also fixes a bug where the client doesn't send the right engine state to the server.
-better_updates = true
-; Prevents waypoints from being cleared when the player reaches the coordinates in a different system.
-; Also makes it so that the player ship cannot be selected as a waypoint target on the nav map.
-waypoint_fixes = true
-; Fixes a bug where multi-barrel launchers do not play their one-shot sound.
-projectiles_sound_fix = true
-; Fixes a bug on the client and server where multi-barrel launchers do not decrement the correct amount of ammo.
-projectiles_server_fix = true
-; Allows for up to 127 resolutions in the display options menu which are based on the main monitor's resolution.
-; Also fixes some resolution-related issues.
-better_resolutions = true
-; Adds support for playing ui_interface_test and ui_ambiance_test in the options menu.
-more_test_sounds = true
-; Fixes a bug where the lights of a trade lane never turn back on after the trade lane gets disrupted.
-trade_lane_lights_fix = true
-; Allows the Ctrl + C key to copy text from any in-game input box to the clipboard.
-; Also allows for the Ctrl + V key to copy text from the clipboard to any in-game input box.
-copy_paste_feature = true
-; Fixes a minor bug where in some Multiplayer menus the slide-out animation of the buttons happened incorrectly.
-slide_ui_anim_fix = true
-; Fixes a bug that causes weapon animations to not work; i.e. enables weapon animations.
-; Also allows a weapon animation to be played on the parent of the weapon.
-weapon_anim_fix = true
-; Fixes a bug that makes a weapon's flash particle effect only play on the first barrel. This fix makes it play on all barrels.
-flash_particle_fix = true
-; Allows the reputation requirement to be printed when the "You must be on friendlier terms to purchase this." string gets displayed in the dealer menus.
-print_rep_requirements = true
-; Fixes a bug that causes the Freelancer process to not always terminate after exiting the game.
-post_game_deadlock_fix = true
-; Makes sure auto level and rotation lock are set to the default value when launching to space to prevent issues related to the flight controls.
-flight_controls_fix = true
--- a/EXE/Freelancer.exe
+++ b/EXE/Freelancer.exe
--- a/EXE/MinHook.x86.dll
+++ b/EXE/MinHook.x86.dll
--- a/EXE/REM-Client.dll
+++ b/EXE/REM-Client.dll
--- a/EXE/REM/Avatars/characters.cfg
+++ b/EXE/REM/Avatars/characters.cfg
@@ -1 +1 @@
-trent
+1
--- a/EXE/REM/Avatars/characters.txt
+++ b/EXE/REM/Avatars/characters.txt
@@ -1 +0,0 @@
-1
--- a/EXE/REM/FPV-Zones/Li01_01_Base_Bar.ini
+++ b/EXE/REM/FPV-Zones/Li01_01_Base_Bar.ini
@@ -1,278 +0,0 @@
-[Init]
-target_z = 1.6             ; Feste Z-Position der Kamera (Höhe)
-start_x = 3.703124         ; Start-X-Position
-start_y = -6.287891        ; Start-Y-Position
-start_blickrichtung = 90.0 ; Start-Blickrichtung (Yaw-Winkel in Grad)
-
-[Zone1]
-; Hauptbereich
-min_x = -5.000000
-min_y = -12.500000
-min_z = -48.0       ; Etwas unter target_z=2.0, da Z fixiert ist
-max_x = 5.250000
-max_y = 12.500000
-max_z = 52.0        ; Etwas über target_z=2.0
-
-[Object1]
-; Pillar1
-name = Pillar1
-min_x = 4.000000
-min_y = -7.400000
-min_z = -10.0
-max_x = 5.250000
-max_y = -5.900000
-max_z = 10.0
-
-[Object2]
-; Pillar2
-name = Pillar2
-min_x = -1.750000
-min_y = -7.400000
-min_z = -10.0
-max_x = 2.950000
-max_y = -5.900000
-max_z = 10.0
-
-[Object3]
-; Table1
-name = Table1
-min_x = 2.850000
-min_y = -4.400000
-min_z = -10.0
-max_x = 4.250000
-max_y = -3.000000
-max_z = 10.0
-
-[Object4]
-; Table2
-name = Table2
-min_x = 2.850000
-min_y = -2.400000
-min_z = -10.0
-max_x = 4.250000
-max_y = -1.00000
-max_z = 10.0
-
-[Object5]
-; Table3
-name = Table3
-min_x = 2.850000
-min_y = -0.650000
-min_z = -10.0
-max_x = 4.250000
-max_y = 0.750000
-max_z = 10.0
-
-[Object6]
-; Table4
-name = Table4
-min_x = 2.850000
-min_y = 1.000000
-min_z = -10.0
-max_x = 4.250000
-max_y = 2.400000
-max_z = 10.0
-
-[Object6]
-; Table5
-name = Table5
-min_x = 2.850000
-min_y = 2.900000
-min_z = -10.0
-max_x = 4.250000
-max_y = 4.300000
-max_z = 10.0
-
-[Object7]
-; Chair1
-name = Chair1
-min_x = 0.500000
-min_y = -3.000000
-min_z = -10.0
-max_x = 1.000000
-max_y = -2.500000
-max_z = 10.0
-
-[Object7]
-; Chair2
-name = Chair2
-min_x = -0.200000
-min_y = -1.600000
-min_z = -10.0
-max_x = 0.300000
-max_y = -1.100000
-max_z = 10.0
-
-[Object8]
-; Chair3
-name = Chair3
-min_x = -0.400000
-min_y = -0.300000
-min_z = -10.0
-max_x = 0.100000
-max_y = 0.200000
-max_z = 10.0
-
-[Object9]
-; Chair4
-name = Chair4
-min_x = 0.000000
-min_y = 1.100000
-min_z = -10.0
-max_x = 0.500000
-max_y = 1.600000
-max_z = 10.0
-
-[Object11]
-; Bar_Element1
-name = Bar_Element1
-min_x = -2.500000
-min_y = -8.000000
-min_z = -10.0
-max_x = -0.300000
-max_y = 8.000000
-max_z = 10.0
-
-[Object12]
-; Bar_Element2_Left
-name = Bar_Element2_Left
-min_x = -2.500000
-min_y = -3.900000
-min_z = -10.0
-max_x = 1.000000
-max_y = -1.500000
-max_z = 10.0
-
-[Object13]
-; Bar_Element3_Left
-name = Bar_Element3_Left
-min_x = -2.000000
-min_y = -4.200000
-min_z = -10.0
-max_x = 0.700000
-max_y = -3.500000
-max_z = 10.0
-
-[Object15]
-; Bar_Element2_Right + Chair5
-name = Bar_Element2_Right
-min_x = -2.500000
-min_y = 2.500000
-min_z = -10.0
-max_x = 1.000000
-max_y = 3.900000
-max_z = 10.0
-
-[Object16]
-; Bar_Element3_Right
-name = Bar_Element3_Right
-min_x = -2.000000
-min_y = 3.500000
-min_z = -10.0
-max_x = 0.700000
-max_y = 4.200000
-max_z = 10.0
-
-[Object17]
-; Bar_Element4_Right
-name = Bar_Element3_Right
-min_x = -2.000000
-min_y = 1.700000
-min_z = -10.0
-max_x = 0.180000
-max_y = 3.000000
-max_z = 10.0
-
-[Object18]
-; Bar_Element5_Right
-name = Bar_Element5_Right
-min_x = -2.500000
-min_y = 1.100000
-min_z = -10.0
-max_x = 0.050000
-max_y = 2.900000
-max_z = 10.0
-
-[Object19]
-; Wall_Bar_Left
-name = Wall_Bar_Right
-min_x = 0.500000
-min_y = -8.000000
-min_z = -10.0
-max_x = 2.200000
-max_y = -5.400000
-max_z = 10.0
-
-[Object20]
-; Wall_Bar_Right1
-name = Wall_Bar_Right1
-min_x = -0.500000
-min_y = 5.500000
-min_z = -10.0
-max_x = 0.500000
-max_y = 8.000000
-max_z = 10.0
-
-[Object21]
-; Wall_Bar_Right
-name = Wall_Bar_Right2
-min_x = 0.500000
-min_y = 5.400000
-min_z = -10.0
-max_x = 2.200000
-max_y = 8.000000
-max_z = 10.0
-
-[Object22]
-; Pillar3
-name = Pillar1
-min_x = 4.000000
-min_y = 5.900000
-min_z = -10.0
-max_x = 5.250000
-max_y = 7.400000
-max_z = 10.0
-
-[Object23]
-; Pillar4
-name = Pillar2
-min_x = -1.750000
-min_y = 5.900000
-min_z = -10.0
-max_x = 2.950000
-max_y = 7.400000
-max_z = 10.0
-
-[Object24]
-; Wall_Left
-name = Wall_Left1
-min_x = 0.000000
-min_y = -13.500000
-min_z = -10.0
-max_x = 2.500000
-max_y = -7.500000
-max_z = 10.0
-
-[Object24]
-; Wall_Right1
-name = Wall_Right1
-min_x = 0.000000
-min_y = 7.500000
-min_z = -10.0
-max_x = 2.500000
-max_y = 13.500000
-max_z = 10.0
-
-;[InteractiveObject1]
-;name = Func_Button1
-;min_x = 0.374799
-;min_y = 12.056148
-;min_z = -4.0
-;max_x = 2.078362
-;max_y = 13.280120
-;max_z = 4.0
-;action = control_panel.lua
-;in_range = 3.0
-;facing = 90.0 ; Vorderseite in positive Y-Richtung
-;collision_offset = 1.0
-
--- a/EXE/REM/FPV-Zones/Li01_06_Base_Deck.ini
+++ b/EXE/REM/FPV-Zones/Li01_06_Base_Deck.ini
@@ -1,58 +0,0 @@
-; Zonen- und Objektdefinition für Trenton Outpost (Li01_06_Base_Deck)
-; Koordinaten sind in Metern, relativ zum Ursprung der Szene
-; Y-Achse ist Vorwärtsrichtung, Z ist Höhe, X ist seitwärts
-
-[Init]
-target_z = 2.0           ; Feste Z-Position der Kamera (Höhe)
-start_x = 29.403124      ; Start-X-Position
-start_y = 17.587891      ; Start-Y-Position
-start_blickrichtung = 30.0 ; Start-Blickrichtung (Yaw-Winkel in Grad)
-
-[Zone1]
-; Hauptbereich
-min_x = -20.596876
-min_y = -32.412109
-min_z = -48.0       ; Etwas unter target_z=2.0, da Z fixiert ist
-max_x = 79.403124
-max_y = 67.587891
-max_z = 52.0        ; Etwas über target_z=2.0
-
-[Zone2]
-; Angrenzender Korridor
-min_x = 60.0
-min_y = -32.412109
-min_z = -48.0
-max_x = 100.0
-max_y = 67.587891
-max_z = 52.0
-
-[Zone3]
-; Ausbuchtung (Alkoven)
-min_x = 20.0
-min_y = -32.412109
-min_z = -48.0
-max_x = 40.0
-max_y = 67.587891
-max_z = 52.0
-
-[Object1]
-; Kiste im Hauptbereich
-name = Crate
-min_x = 5.0
-min_y = 5.0
-min_z = -10.0
-max_x = 10.0
-max_y = 10.0
-max_z = 10.0
-
-[InteractiveObject1]
-name = ControlPanel
-min_x = 2.0
-min_y = 3.0
-min_z = -1.0
-max_x = 3.0
-max_y = 4.0
-max_z = 1.0
-action = control_panel.lua
-in_range = 3.0
-facing = 0.0 ; Vorderseite in positive Y-Richtung
--- a/EXE/REM/Fonts/AGENCYB.TTF
+++ b/EXE/REM/Fonts/AGENCYB.TTF
--- a/EXE/REM/Fonts/AGENCYR.TTF
+++ b/EXE/REM/Fonts/AGENCYR.TTF
--- a/EXE/REM/Fonts/AGENCYR_CR.TTF
+++ b/EXE/REM/Fonts/AGENCYR_CR.TTF
--- a/EXE/REM/LOGS/ClientLogFolder.txt
+++ b/EXE/REM/LOGS/ClientLogFolder.txt
--- a/EXE/REM/Lua/CreateNewCharacter.lua
+++ b/EXE/REM/Lua/CreateNewCharacter.lua
--- a/EXE/REM/Lua/CreateNewCharacter_After.lua
+++ b/EXE/REM/Lua/CreateNewCharacter_After.lua
--- a/EXE/REM/Lua/DYNAMIC/day.cfg
+++ b/EXE/REM/Lua/DYNAMIC/day.cfg
@@ -1 +0,0 @@
-14
--- a/EXE/REM/Lua/DYNAMIC/gcs_state.cfg
+++ b/EXE/REM/Lua/DYNAMIC/gcs_state.cfg
@@ -1 +0,0 @@
-off
--- a/EXE/REM/Lua/DYNAMIC/manhattan.cfg
+++ b/EXE/REM/Lua/DYNAMIC/manhattan.cfg
@@ -1 +0,0 @@
-origin
--- a/EXE/REM/Lua/DYNAMIC/months.cfg
+++ b/EXE/REM/Lua/DYNAMIC/months.cfg
@@ -1 +0,0 @@
-May
--- a/EXE/REM/Lua/DYNAMIC/rochester.cfg
+++ b/EXE/REM/Lua/DYNAMIC/rochester.cfg
@@ -1 +0,0 @@
-origin
--- a/EXE/REM/Lua/DYNAMIC/toledo.cfg
+++ b/EXE/REM/Lua/DYNAMIC/toledo.cfg
@@ -1 +0,0 @@
-origin
--- a/EXE/REM/Lua/Dock.lua
+++ b/EXE/REM/Lua/Dock.lua
--- a/EXE/REM/Lua/Dock_After.lua
+++ b/EXE/REM/Lua/Dock_After.lua
--- a/EXE/REM/Lua/LocationEnter.lua
+++ b/EXE/REM/Lua/LocationEnter.lua
--- a/EXE/REM/Lua/LocationEnter_After.lua
+++ b/EXE/REM/Lua/LocationEnter_After.lua
--- a/EXE/REM/Lua/LocationExit.lua
+++ b/EXE/REM/Lua/LocationExit.lua
--- a/EXE/REM/Lua/LocationExit_After.lua
+++ b/EXE/REM/Lua/LocationExit_After.lua
--- a/EXE/REM/Lua/luastart.lua
+++ b/EXE/REM/Lua/luastart.lua
@@ -1,10 +1,10 @@
 print("Lua started!")

 -- Open the console after a delay
-- rem.StartTimer(2000, function()
--    rem.ShowNNMessage(9000)
--     print("Console open after 2 seconds.")
-- end)
+rem.StartTimer(2000, function()
+     rem.ShowNNMessage(9000)
+     print("Console open after 2 seconds.")
+end)

 -- Add Infocard
 rem.AddInfoCard(9000, "TestSpam")
--- a/EXE/REM/Lua/testwindow-nnmessage.lua
+++ b/EXE/REM/Lua/testwindow-nnmessage.lua
@@ -1,7 +0,0 @@
-- Start a timer for 3 seconds
-rem.StartTimer(3000, function()
-    rem.ShowNNMessage(1699)
-    print("Message displayed after 3 seconds!")
-end)
-
-print("This happens immediately while the timer runs.")
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_bluecrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_bluecrystal.png
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_cyancrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_cyancrystal.png
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_greencrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_greencrystal.png
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_orangecrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_orangecrystal.png
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_purplecrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_purplecrystal.png
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_redcrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_redcrystal.png
--- a/EXE/REM/UI/COMMODITIES/Crystal/commod_yellowcrystal.png
+++ b/EXE/REM/UI/COMMODITIES/Crystal/commod_yellowcrystal.png
--- a/EXE/REM/UI/COMMODITIES/commod_Azurite.png
+++ b/EXE/REM/UI/COMMODITIES/commod_Azurite.png
--- a/EXE/REM/UI/COMMODITIES/commod_Citrine.png
+++ b/EXE/REM/UI/COMMODITIES/commod_Citrine.png
--- a/EXE/REM/UI/COMMODITIES/commod_Morganite.png
+++ b/EXE/REM/UI/COMMODITIES/commod_Morganite.png
--- a/EXE/REM/UI/COMMODITIES/commod_Obsidian.png
+++ b/EXE/REM/UI/COMMODITIES/commod_Obsidian.png
--- a/EXE/REM/UI/COMMODITIES/commod_Pyrope.png
+++ b/EXE/REM/UI/COMMODITIES/commod_Pyrope.png
--- a/EXE/REM/UI/COMMODITIES/commod_Viridian.png
+++ b/EXE/REM/UI/COMMODITIES/commod_Viridian.png
--- a/EXE/REM/UI/COMMODITIES/commod_diamonds.png
+++ b/EXE/REM/UI/COMMODITIES/commod_diamonds.png
--- a/EXE/REM/UI/HUD/mousecursor.png
+++ b/EXE/REM/UI/HUD/mousecursor.png
--- a/EXE/REM/UI/ICON/icon_player_cam_switch.png
+++ b/EXE/REM/UI/ICON/icon_player_cam_switch.png
--- a/EXE/ReShade.ini
+++ b/EXE/ReShade.ini
@@ -1,4 +1,4 @@
-[APP]
+[APP]
 Force10BitFormat=0
 ForceFullscreen=0
 ForceResolution=0,0
@@ -30,10 +30,10 @@ KeyReload=0,0,0,0
 KeyScreenshot=44,0,0,0

 [OVERLAY]
-AutoSavePreset=1
 ClockFormat=0
 FPSPosition=1
 NoFontScaling=0
+SavePresetOnModification=1
 SaveWindowState=0
 ShowClock=0
 ShowForceLoadEffectsButton=1
@@ -75,5 +75,3 @@ ScrollbarRounding=0.000000
 StyleIndex=2
 TabRounding=4.000000
 WindowRounding=0.000000
-
-
--- a/EXE/ReShade.log
+++ b/EXE/ReShade.log
@@ -0,0 +1,15 @@
+
+If you are reading this after launching the game at least once, it likely means ReShade was not loaded by the game.
+
+In that event here are some steps you can try to resolve this:
+
+1) Make sure this file and the related DLL are really in the same directory as the game executable.
+   If that is the case and it does not work regardless, check if there is a 'bin' directory, move them there and try again.
+
+2) Try running the game with elevated user permissions by doing a right click on its executable and choosing 'Run as administrator'.
+
+3) If the game crashes, try disabling all game overlays (like Origin), recording software (like Fraps), FPS displaying software,
+   GPU overclocking and tweaking software and other proxy DLLs (like ENB, Helix or Umod).
+
+4) If none of the above helps, you can get support on the forums at https://reshade.me/forum. But search for your problem before
+   creating a new topic, as somebody else may have already found a solution.
--- a/EXE/dacom.ini
+++ b/EXE/dacom.ini
@@ -46,6 +46,7 @@ shipclass.dll

 ;REM
 REM-Client.dll
+MinHook.x86.dll

 ;;EMAURER now include any DLLs used only in development.
@include FL_DevOnlyLibs.ini
@@ -123,15 +124,23 @@ FORCE_FREQ_CONTROL_TO_SW = false
 max3DPan = 15

 [Alchemy]
+;EMAURER added this line to fix problem with runtime alchemy running out of vertex buffer
+;maxVertices and maxIndices are now determined by alchemy based on the particle pools
+;Alchemy.maxVertices ~= 11100
+;Alchemy.maxIndices ~= 28200 
+
 Alchemy.useMaterialBatcher = false
-FxBasicAppearance.poolSize    = 50000
-FxRectAppearance.poolSize     = 20000
-FxPerpAppearance.poolSize     = 12500
-FxOrientedAppearance.poolSize = 0
-FLBeamAppearance.poolSize     = 30000
-FLDustAppearance.poolSize     = 12500
-FxMeshAppearance.poolSize     = 20000
-FxParticleAppearance.poolSize = 5000
+											; (note: 1000 is default poolsize)
+FxBasicAppearance.poolSize    = 10000		; each particle can generate: 4 verts 6, indices 
+FxRectAppearance.poolSize     = 4000		; each particle can generate: 4 verts 6, indices 
+FxPerpAppearance.poolSize     = 2500		; each particle can generate: 4 verts 6, indices 
+FxOrientedAppearance.poolSize = 1000		; each particle can generate: 4 verts 6, indices 
+FLBeamAppearance.poolSize     = 6800		; custom app from flalchemy.dll: each particle can generate: 5 verts 24 indices
+FLDustAppearance.poolSize     = 2500		; custom app from flalchemy.dll: each particle can generate: 4 verts 6 indices
+;---------------------- total = 26000 -------; 
+;
+FxMeshAppearance.poolSize  = 5000			; generates meshes not particles; need enough of these for all tradelane rings in a system.
+FxParticleAppearance.poolSize = 1000		; generates effects not particles

 [BatchedMaterials]
 Type = .*OcOt
--- a/EXE/dgVoodoo.conf
+++ b/EXE/dgVoodoo.conf
@@ -0,0 +1,349 @@
+;==========================================================================
+; === Text based config file for dgVoodoo2
+; === Use this file if you are a game modder/hacker or an experted user and
+;     want to modify some advanced properties not available via the CPL.
+;==========================================================================
+
+Version                              = 0x282
+
+;--------------------------------------------------------------------------
+
+[General]
+
+;       OutputAPI: "d3d11warp", "d3d11_fl10_0", "d3d11_fl10_1", "d3d11_fl11_0",
+;                  "d3d12_fl11_0", "d3d12_fl12_0", "bestavailable"
+;        Adapters: "all", or the ordinal of the adapter (1, ...)
+;FullScreenOutput: "default", or the ordinal of the output on the adapter (1, ...)
+;     ScalingMode: "unspecified", "centered", "stretched", "centered_ar", "stretched_ar", "stretched_ar_crt",
+;                  "stretched_4_3", "stretched_4_3_crt", "stretched_4_3_c64"
+;
+;InheritColorProfileInFullScreenMode:
+;                  Enabled by default and can only be disabled only when a D3D11 output API
+;                  is explicitly selected. Disabled case is intended for avoiding extra
+;                  rendering resources on old hardware for better performance, if required.
+
+OutputAPI                            = bestavailable
+Adapters                             = all
+FullScreenOutput                     = default
+FullScreenMode                       = true
+ScalingMode                          = unspecified
+ProgressiveScanlineOrder             = false
+EnumerateRefreshRates                = false
+
+Brightness                           = 100
+Color                                = 100
+Contrast                             = 100
+InheritColorProfileInFullScreenMode  = true
+
+KeepWindowAspectRatio                = true
+CaptureMouse                         = true
+CenterAppWindow                      = false
+
+;--------------------------------------------------------------------------
+
+[GeneralExt]
+
+;      DesktopResolution: Desktop (native) resolution can be forced for dgVoodoo's internal calculations.
+;                         Useful for rare applications that pre-set the desktop to other than the native
+;                         resolution before dgVoodoo gets in action. Only the compact format can be used here,
+;                         and applies to all outputs of the desktop.
+;        DesktopBitDepth: You can define what screen bit depth should be reported through dgVoodoo
+;                         (8, 16, 32)
+;           DeframerSize: When resolution is forced to other than the app default then
+;                         a black frame is drawn around the output image coming from a wrapped API
+;                         to remove scaling artifacts -
+;                         frame thickness can be defined in pixels (max 16, 0 = disable)
+;       ImageScaleFactor: Integer factor for scaling the output image coming from a wrapped API
+;                         Always done by nearest point filtering, independent on scaling mode
+;                         (0 = max available)
+;                         Separate factors can be defined for horizontal and vertical scaling
+;                         by subproperties, e.g.
+;                         ImageScaleFactor = x:3, y:2
+;      CursorScaleFactor: Integer factor for scaling the emulated hardware mouse (max 16)
+;                         (0 = automatic, 1 = no scale, 2 = double scale, ...)
+;             DisplayROI: Display region of interest
+;                         If scaling is done by the dgVoodoo then you can define a subrect of the
+;                         output image, coming from a wrapped API, to be displayed. The defined subrect
+;                         is mapped to the display output according to the current scaling mode
+;                         It can be useful for applications rendering a widescreen subimage into a 4:3
+;                         resolution; in this case you can scale up that subimage to (nearly) fill the
+;                         whole screen on a widescreen monitor.
+;                         DisplayROI empty value means the whole image.
+;                         DisplayROI value can be a proportion in form of %d_%d or a pixel size (%d|%d)
+;                         Pos subproperty is not mandatory and can be 'centered' or a pixel position (%d|%d)
+;                         Examples: DisplayROI = 16_9, pos:centered
+;                                   DisplayROI = (320|200), pos:(10|10)
+;             Resampling: When scaling is done by the dgVoodoo for the given scaling mode,
+;                         you can choose which filter is to be used for resampling the output image
+;                         Available filters are: "pointsampled", "bilinear", "bicubic", "lanczos-2", "lanczos-3"
+;      PresentationModel: Low-level swapchain swap effect: if you know what you are doing then it can be
+;                         overridden here. Flip models are better suited for modern OS features like auto HDR,
+;                         while plain legacy models provide the best presentation performance under ideal conditions
+;                         Not all model + output API + OS version combinations are supported.
+;                         "auto", "discard", "seq", "flip_discard", "flip_seq"
+;             ColorSpace: Color space of the swap chain:
+;						  "appdriven"           - an application can choose argb2101010 through D3D9, but it means
+;                                                 the legacy argb8888_srgb in any other case
+;                         "argb8888_srgb"       - Legacy 32 bit output for SDR displays
+;                         "argb2101010_sdr"     - 32 bit extended precision for SDR displays
+;                         "argb2101010_sdr_wcg" - Wide Color Gamut format for SDR displays (available from Windows 11 22H2)
+;                         "argb16161616_hdr"    - Float16 HDR output (available from Windows 10 1709)
+;              FreeMouse: If true then physical mouse is free to move inside the game window
+;                         when using emulated scaling and/or application and forced resolution
+;                         differs; can be useful when a game relies on the physical window size
+;     WindowedAttributes: You can define attributes for forced windowed appearance (separated by commas):
+;                          "borderless"     - forces the app window not have any border
+;                          "alwaysontop"    - forces the app window into the top-most band
+;                          "fullscreensize" - forces the app window to be full screen size with image scaling inside
+;   FullscreenAttributes: You can define attributes for fullscreen appearance (separated by commas):
+;                          "fake"           - forces fake fullscreen mode with a screen-size window
+;               FPSLimit: An integer or rational (fractional) value, 0 = unlimited
+;            Environment: Software environment in which dgVoodoo is running: can be left unspecified (native)
+;                         or can be set to 'DosBox' or 'QEmu'.
+;        SystemHookFlags: You can define which part of the system should be hooked (x86-DX only):
+;                          "gdi"            - for showing graphical contents rendered through GDI
+;                                             (like movie playback through the ancient Windows Multimedia AVI player library)
+;                          "cursor"         - for suppressing double-cursor symptoms when the cursor is emulated
+
+DesktopResolution                    = 
+DesktopBitDepth                      = 
+DeframerSize                         = 1
+ImageScaleFactor                     = 1
+CursorScaleFactor                    = 0
+DisplayROI                           = 
+Resampling                           = bilinear
+PresentationModel                    = auto
+ColorSpace                           = appdriven
+FreeMouse                            = false
+WindowedAttributes                   = 
+FullscreenAttributes                 = 
+FPSLimit                             = 0
+Environment                          = 
+SystemHookFlags                      = 
+
+;--------------------------------------------------------------------------
+
+[Glide]
+
+;  VideoCard:      "voodoo_graphics", "voodoo_rush", "voodoo_2", "voodoo_banshee", "other_greater"
+; OnboardRAM:      in MBs
+; MemorySizeOfTMU: in kBs
+;    TMUFiltering: "appdriven", "pointsampled", "bilinear"
+;
+; Resolution: either "unforced", "max", "max_isf", "max_fhd", "max_fhd_isf", "max_qhd", "max_qhd_isf", "desktop", "%dx",
+;                                "max_%dx", "max_isf_%dx", "max_fhd_%dx", "max_fhd_isf_%d"x, "max_qhd_%dx", "max_qhd_isf_%dx", "desktop_%dx"
+;             or subproperties: h: horizontal, v: vertical
+;             + optional subproperty refrate: refresh rate in Hz
+;             e.g. Resolution = max, refrate:60
+;                  Resolution = 2x, refrate:59
+;                  Resolution = h:1280, v:1024, refrate:75
+;                  Resolution = max_2x
+;             or just use the compact form like "1024x768@60" or "512x384"
+;
+;Antialiasing: "off", "appdriven", "2x", "4x", "8x", "16x" (your GPU must support the chosen one)
+
+VideoCard                           = voodoo_2
+OnboardRAM                          = 12
+MemorySizeOfTMU                     = 4096
+NumberOfTMUs                        = 2
+TMUFiltering                        = bilinear
+DisableMipmapping                   = false
+Resolution                          = unforced
+Antialiasing                        = 8x
+
+EnableGlideGammaRamp                = true
+ForceVerticalSync                   = false
+ForceEmulatingTruePCIAccess         = false
+16BitDepthBuffer                    = false
+3DfxWatermark                       = false
+3DfxSplashScreen                    = false
+PointcastPalette                    = false
+EnableInactiveAppState              = false
+
+
+;--------------------------------------------------------------------------
+
+[GlideExt]
+
+;               DitheringEffect: "pure32bit", "dither2x2", "dither4x4"
+;                     Dithering: "disabled", "appdriven", "forcealways"
+;  DitherOrderedMatrixSizeScale: integer scale value for dither matrix size
+;                                1 = normal, 2 = double size, etc.
+;                                0 = automatic (the aim is to have some retro feel&look)
+
+DitheringEffect                     = pure32bit
+Dithering                           = forcealways
+DitherOrderedMatrixSizeScale        = 0
+
+;--------------------------------------------------------------------------
+
+[DirectX]
+
+;  VideoCard: "svga", "internal3D", "geforce_ti_4800", "ati_radeon_8500",
+;             "matrox_parhelia-512", "geforce_fx_5700_ultra", "geforce_9800_gt"
+;       VRAM: in MBs (default) or in GBs (e.g. VRAM = 2GB)
+;  Filtering: "appdriven", "pointsampled", "bilinear", "pointmip", "linearmip", "trilinear"
+;             or the integer value of an anisotropic filtering level (1-16)
+; Mipmapping: "appdriven", "disabled", "autogen_point", "autogen_bilinear"
+;  KeepFilterIfPointSampled: if enabled then forced filtering affects only non-point sampled textures
+;      Bilinear2DOperations: if enabled then DirectDraw Blit and CPU-written data is transferred with bilinear scaling
+
+DisableAndPassThru                  = false
+
+VideoCard                           = internal3D
+VRAM                                = 4096
+Filtering                           = 16
+Mipmapping                          = autogen_bilinear
+KeepFilterIfPointSampled            = false
+Resolution                          = unforced
+Antialiasing                        = 8x
+
+AppControlledScreenMode             = true
+DisableAltEnterToToggleScreenMode   = true
+
+Bilinear2DOperations                = false
+PhongShadingWhenPossible            = false
+ForceVerticalSync                   = false
+dgVoodooWatermark                   = false
+FastVideoMemoryAccess               = false
+
+;--------------------------------------------------------------------------
+
+[DirectXExt]
+
+;                 AdapterIDType: "nvidia", "amd", "intel" or leave it undefined
+;                                You can define what type of driver version and vendor id's the wrapper should report to
+;                                the application; Some games rely on that information so it can be useful for them
+;                                Can be defined only for SVGA and Internal3D card types; the others have their own wired
+;                                information
+
+; VendorID, DeviceID, SubsystemID, RevisionID:
+;                                Can be defined only for SVGA and Internal3D card types
+;                                You can overwrite these properties even if a non-default AdapterIDType is defined;
+;                                say, you defined an nvidia id type but would like to refine the vendor id
+
+;  DefaultEnumeratedResolutions: you can define what resolutions should be enumerated to the application by default
+;                                "all", "classics", "none"
+
+;    ExtraEnumeratedResolutions: you can add extra resolutions (separated by commas, max 16) that will get
+;                                enumerated to the application as display adapter supported ones -
+;                                can be useful if an app supports rendering at arbitrary resolutions
+;                                and you have a particular favorite resolution that are not
+;                                enumerated to the application by default
+;                                you can either use the compact resolution format here, or
+;                                "max", "max@refrate" meaning your desktop resolution with a potential refresh rate, or
+;                                "max_4_3", "max_4_3@refrate", "max_16_9", "max_16_9@refrate"
+;                                meaning the maximum resolution with the given aspect ratio calculated from
+;                                the desktop resolution with the given refresh rate, e.g. "max_4_3@60", "max_16_9"
+
+; EnumeratedResolutionBitdepths: you can filter what bitdepths are included in the resolution enumeration
+;                                any subset of {"8", "16", "32"}, or "all"
+
+;               DitheringEffect: "high_quality", "ordered2x2", "ordered4x4"
+;                     Dithering: "disabled", "appdriven", "forceon16bit", "forcealways"
+;  DitherOrderedMatrixSizeScale: integer scale value for dither matrix size
+;                                1 = normal, 2 = double size, etc.
+;                                0 = automatic
+;          DepthBuffersBitDepth: internal bit depth of depth/stencil buffers for 3D rendering (32 bit is not recommended)
+;                                "appdriven", "forcemin24bit", "force32bit"
+;         Default3DRenderFormat: default format of 3D rendering
+;                                "auto", "argb8888", "argb2101010", "argb16161616"
+;                                auto corresponds to the selected color space
+;                                argb2101010 has the benefit that it is still 32 bit but it can corrupt the rendering
+;                                because of the lowered alpha bits, not recommended
+
+;           MaxVSConstRegisters: Max number of vertex shader constant registers (DX8/9 only)
+;                                Can be defined only for SVGA and Internal3D card types
+;                                Valid values are 256 (default), 512 or 1024
+
+;        NPatchTesselationLevel: Force N-Patch tesselation level (D3D8/9)
+;                                0 = app driven
+;                                1 = disable
+;                                2 to 8 = a forced tesselation level
+;                                Altough tesselation works with all vertex shader versions, you can force level higher than 1
+;                                only for the fixed function or vs.1.x vertex pipeline because of performance and practical reasons
+;                                (forced tesselation also disables adaptive mode (D3D9), but forcing is not recommended at all, anyway)
+
+;       DisplayOutputEnableMask: Each bit in this 32 bit value corresponds to a display output. Display outputs of the adapters are numbered
+;                                sequentially. If Adapter0 has n display outputs and Adapter1 has m display outputs attached then the lowest
+;                                n bits match Adapter0 display outputs, the next m bits match Adapter1 outputs, and so on. The lowest bit
+;                                in a group corresponds to Output0. If a bit value is 0 then the display output is disabled for the device
+;                                enumeration, in other words, it is invisible to the application. It can be useful for D3D9 multihead-
+;                                or very special applications where you want to enable only individual displays on your monitor wall.
+
+;              MSD3DDeviceNames: if true then original Microsoft D3D device names are exposed
+;                                (some applications check for them and they fail)
+
+;   RTTexturesForceScaleAndMSAA: if true then forced resolution scaling and MSAA is
+;                                applied also to rendertarget textures
+;                                Set it to false for games requiring pixel-precise rendering
+;                                but be careful it can EASILY break certain things, not recommended
+
+;         SmoothedDepthSampling: if true then extra smoothing is added to depth textures
+;                                when they are sampled
+
+;      DeferredScreenModeSwitch: If true the switching to full screen is deferred after the application initialized
+;                                the DirectX device; can be useful for games that don't expect rendering window changes
+;                                during initialization and crash
+
+;   PrimarySurfaceBatchedUpdate: If true then direct changes of the primary surface are batched together for presenting them
+;                                If false then each change is instantly presented (debug-like mode)
+
+;          SuppressAMDBlacklist: Some AMD GPU models are blacklisted to workaround the solid-color-textures driver issue
+;                                You can suppress it to check out if the problem is fixed in your current driver
+
+AdapterIDType                       = 
+VendorID                            = 
+DeviceID                            = 
+SubsystemID                         = 
+RevisionID                          = 
+
+DefaultEnumeratedResolutions        = all
+ExtraEnumeratedResolutions          = 
+EnumeratedResolutionBitdepths       = all
+
+DitheringEffect                     = high_quality
+Dithering                           = forcealways
+DitherOrderedMatrixSizeScale        = 0
+DepthBuffersBitDepth                = appdriven
+Default3DRenderFormat               = auto
+
+MaxVSConstRegisters                 = 256
+
+NPatchTesselationLevel              = 0
+
+DisplayOutputEnableMask             = 0xffffffff
+
+MSD3DDeviceNames                    = false
+RTTexturesForceScaleAndMSAA         = true
+SmoothedDepthSampling               = true
+DeferredScreenModeSwitch            = false
+PrimarySurfaceBatchedUpdate         = false
+SuppressAMDBlacklist                = false
+
+;--------------------------------------------------------------------------
+
+[Debug]
+
+; This section affects only debug/spec release builds
+;
+; Info, Warning, Error
+;                "Disable"      - disables all messages and debugger break
+;                "Enable"       - enables messages and disables debugger break
+;                "EnableBreak"  - enables both messages and breaking into debugger
+;
+; MaxTraceLevel: Maximum level of tracing API calls
+;                0 - Disable
+;                1 - API Functions and methods
+;                2 - Additional trace info for internals
+;
+; LogToFile: if false or debugger is detected then output goes to the debug output
+;            if true and no debugger detected then output goes to 'dgVoodoo.log'
+;            (not implemented yet, always the default debug output is used)
+
+Info                                = enable
+Warning                             = enable
+Error                               = enable
+MaxTraceLevel                       = 0
+
+;LogToFile                           = false
--- a/EXE/dgVoodooCpl.exe
+++ b/EXE/dgVoodooCpl.exe
--- a/EXE/dgVoodooReadme.url
+++ b/EXE/dgVoodooReadme.url
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=http://dege.fw.hu/dgVoodoo2/ReadmeGeneral/
--- a/EXE/dgVoodooReadmeDirectX.url
+++ b/EXE/dgVoodooReadmeDirectX.url
@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=http://dege.fw.hu/dgVoodoo2/ReadmeDirectX/
--- a/EXE/dxgi.dll
+++ b/EXE/dxgi.dll
--- a/EXE/flhook_plugins/rem_server.dll
+++ b/EXE/flhook_plugins/rem_server.dll
--- a/EXE/libmysql.dll
+++ b/EXE/libmysql.dll
--- a/EXE/lua.dll
+++ b/EXE/lua.dll
--- a/EXE/opengl32.dll
+++ b/EXE/opengl32.dll
--- a/EXE/reshade-shaders/Shaders/Blending.fxh
+++ b/EXE/reshade-shaders/Shaders/Blending.fxh
@@ -1,589 +0,0 @@
-/*------------------.
-| :: Description :: |
-'-------------------/
-
-    Blending Header (version 0.8)
-
-    Blending Algorithm Sources:
-    https://www.khronos.org/registry/OpenGL/extensions/NV/NV_blend_equation_advanced.txt
-
-    http://www.nathanm.com/photoshop-blending-math/
-    (Alt) https://github.com/cplotts/WPFSLBlendModeFx/blob/master/PhotoshopMathFP.hlsl
-
-    Header Authors: originalnicodr, prod80, uchu suzume, Marot Satil
-
-    About:
-    Provides a variety of blending methods for you to use as you wish. Just include this header.
-
-    History:
-    (*) Feature (+) Improvement (x) Bugfix (-) Information (!) Compatibility
-    
-    Version 0.1 by Marot Satil & uchu suzume
-    * Added and improved upon multiple blending modes thanks to the work of uchu suzume, prod80, and originalnicodr.
-
-    Version 0.2 by uchu suzume & Marot Satil
-    * Added Addition, Subtract, Divide blending modes and improved code readability.
-
-    Version 0.3 by uchu suzume & Marot Satil
-    * Sorted blending modes in a more logical fashion, grouping by type.
-
-    Version 0.4 by uchu suzume
-    x Corrected Color Dodge blending behavior.
-
-    Version 0.5 by Marot Satil & uchu suzume
-    * Added preprocessor macros for uniform variable combo UI element & lerp.
-
-    Version 0.6 by Marot Satil & uchu suzume
-    * Added Divide (Alternative) and Divide (Photoshop) blending modes.
-
-    Version 0.7 by prod80
-    - Added original sources for blending algorithms.
-    x Corrected average luminosity values.
-
-    Version 0.8 by Marot Satil
-    * Added a new funciton to output blended data.
-    + Moved all code into the BlendingH namespace, which is part of the ComHeaders common namespace meant to be used by other headers.
-    ! Removed old preprocessor macro blending output.
-
-.------------------.
-| :: How To Use :: |
-'------------------/
-
-    Blending two variables using this header in your own shaders is very straightforward.
-    Very basic example code using the "Darken" blending mode follows:
-
-    // First, include the header.
-    #include "Blending.fxh"
-
-    // You can use this preprocessor macro to generate an attractive and functional uniform int UI combo element containing the list of blending techniques:
-    // BLENDING_COMBO(variable_name, label, tooltip, category, category_closed, spacing, default_value)
-    BLENDING_COMBO(_BlendMode, "Blending Mode", "Select the blending mode applied to the layer.", "Blending Options", false, 0, 0)
-
-    // Inside of your function you can call this function to apply the blending option specified by an int (variable) to your float3 (input) via
-    // a lerp between your float3 (input), float3 (output), and a float (blending) for the alpha channel.
-    // ComHeaders::Blending::Blend(int variable, float3 input, float3 output, float blending)
-    outColor.rgb = ComHeaders::Blending::Blend(_BlendMode, inColor, outColor, outColor.a);
-*/
-
-
-// -------------------------------------
-// Preprocessor Macros
-// -------------------------------------
-
-#undef BLENDING_COMBO
-#define BLENDING_COMBO(variable, name_label, description, group, grp_closed, space, default_value) \
-uniform int variable \
-< \
-    ui_category = group; \
-    ui_category_closed = grp_closed; \
-    ui_items = \
-           "Normal\0" \
-/* "Darken" */ \
-           "Darken\0" \
-           "  Multiply\0" \
-           "  Color Burn\0" \
-           "  Linear Burn\0" \
-/* "Lighten" */	\
-           "Lighten\0" \
-           "  Screen\0" \
-           "  Color Dodge\0" \
-           "  Linear Dodge\0" \
-           "  Addition\0" \
-           "  Glow\0" \
-/* "Contrast" */ \
-           "Overlay\0" \
-           "  Soft Light\0" \
-           "  Hard Light\0" \
-           "  Vivid Light\0" \
-           "  Linear Light\0" \
-           "  Pin Light\0" \
-           "  Hard Mix\0" \
-/* "Inversion" */ \
-           "Difference\0" \
-           "  Exclusion\0" \
-/* "Cancelation" */	\
-           "Subtract\0" \
-           "  Divide\0" \
-           "  Divide (Alternative)\0" \
-           "  Divide (Photoshop)\0" \
-           "  Reflect\0" \
-           "  Grain Extract\0" \
-           "  Grain Merge\0" \
-/* "Component" */ \
-           "Hue\0" \
-           "  Saturation\0" \
-           "  Color\0" \
-           "  Luminosity\0"; \
-    ui_label = name_label; \
-    ui_tooltip = description; \
-    ui_type = "combo"; \
-    ui_spacing = space; \
-> = default_value;
-
-namespace ComHeaders
-{
-    namespace Blending
-    {
-
-// -------------------------------------
-// Helper Functions
-// -------------------------------------
-
-        float3 Aux(float3 a)
-        {
-            if (a.r <= 0.25 && a.g <= 0.25 && a.b <= 0.25)
-                return ((16.0 * a - 12.0) * a + 4) * a;
-            else
-                return sqrt(a);
-        }
-
-        float Lum(float3 a)
-        {
-            return (0.33333 * a.r + 0.33334 * a.g + 0.33333 * a.b);
-        }
-
-        float3 SetLum (float3 a, float b){
-            const float c = b - Lum(a);
-            return float3(a.r + c, a.g + c, a.b + c);
-        }
-
-        float min3 (float a, float b, float c)
-        {
-            return min(a, (min(b, c)));
-        }
-
-        float max3 (float a, float b, float c)
-        {
-            return max(a, max(b, c));
-        }
-
-        float3 SetSat(float3 a, float b){
-            float ar = a.r;
-            float ag = a.g;
-            float ab = a.b;
-            if (ar == max3(ar, ag, ab) && ab == min3(ar, ag, ab))
-            {
-                //caso r->max g->mid b->min
-                if (ar > ab)
-                {
-                    ag = (((ag - ab) * b) / (ar - ab));
-                    ar = b;
-                }
-                else
-                {
-                    ag = 0.0;
-                    ar = 0.0;
-                }
-                ab = 0.0;
-            }
-            else
-            {
-                if (ar == max3(ar, ag, ab) && ag == min3(ar, ag, ab))
-                {
-                    //caso r->max b->mid g->min
-                    if (ar > ag)
-                    {
-                        ab = (((ab - ag) * b) / (ar - ag));
-                        ar = b;
-                    }
-                    else
-                    {
-                        ab = 0.0;
-                        ar = 0.0;
-                    }
-                    ag = 0.0;
-                }
-                else
-                {
-                    if (ag == max3(ar, ag, ab) && ab == min3(ar, ag, ab))
-                    {
-                        //caso g->max r->mid b->min
-                        if (ag > ab)
-                        {
-                            ar = (((ar - ab) * b) / (ag - ab));
-                            ag = b;
-                        }
-                        else
-                        {
-                            ar = 0.0;
-                            ag = 0.0;
-                        }
-                        ab = 0.0;
-                    }
-                    else
-                    {
-                        if (ag == max3(ar, ag, ab) && ar == min3(ar, ag, ab))
-                        {
-                            //caso g->max b->mid r->min
-                            if (ag > ar)
-                            {
-                                ab = (((ab - ar) * b) / (ag - ar));
-                                ag = b;
-                            }
-                            else
-                            {
-                                ab = 0.0;
-                                ag = 0.0;
-                            }
-                            ar = 0.0;
-                        }
-                        else
-                        {
-                            if (ab == max3(ar, ag, ab) && ag == min3(ar, ag, ab))
-                            {
-                                //caso b->max r->mid g->min
-                                if (ab > ag)
-                                {
-                                    ar = (((ar - ag) * b) / (ab - ag));
-                                    ab = b;
-                                }
-                                else
-                                {
-                                    ar = 0.0;
-                                    ab = 0.0;
-                                }
-                                ag = 0.0;
-                            }
-                            else
-                            {
-                                if (ab == max3(ar, ag, ab) && ar == min3(ar, ag, ab))
-                                {
-                                    //caso b->max g->mid r->min
-                                    if (ab > ar)
-                                    {
-                                        ag = (((ag - ar) * b) / (ab - ar));
-                                        ab = b;
-                                    }
-                                    else
-                                    {
-                                        ag = 0.0;
-                                        ab = 0.0;
-                                    }
-                                    ar = 0.0;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return float3(ar, ag, ab);
-        }
-
-        float Sat(float3 a)
-        {
-            return max3(a.r, a.g, a.b) - min3(a.r, a.g, a.b);
-        }
-
-
-// -------------------------------------
-// Blending Modes
-// -------------------------------------
-
-        // Darken
-        float3 Darken(float3 a, float3 b)
-        {
-            return min(a, b);
-        }
-
-        // Multiply
-        float3 Multiply(float3 a, float3 b)
-        {
-            return a * b;
-        }
-
-        // Color Burn
-        float3 ColorBurn(float3 a, float3 b)
-        {
-            if (b.r > 0 && b.g > 0 && b.b > 0)
-                return 1.0 - min(1.0, (0.5 - a) / b);
-            else
-                return 0.0;
-        }
-
-        // Linear Burn
-        float3 LinearBurn(float3 a, float3 b)
-        {
-            return max(a + b - 1.0f, 0.0f);
-        }
-
-        // Lighten
-        float3 Lighten(float3 a, float3 b)
-        {
-            return max(a, b);
-        }
-
-        // Screen
-        float3 Screen(float3 a, float3 b)
-        {
-            return 1.0 - (1.0 - a) * (1.0 - b);
-        }
-
-        // Color Dodge
-        float3 ColorDodge(float3 a, float3 b)
-        {
-            if (b.r < 1 && b.g < 1 && b.b < 1)
-                return min(1.0, a / (1.0 - b));
-            else
-                return 1.0;
-        }
-
-        // Linear Dodge
-        float3 LinearDodge(float3 a, float3 b)
-        {
-            return min(a + b, 1.0f);
-        }
-
-        // Addition
-        float3 Addition(float3 a, float3 b)
-        {
-            return min((a + b), 1);
-        }
-
-        // Reflect
-        float3 Reflect(float3 a, float3 b)
-        {
-            if (b.r >= 0.999999 || b.g >= 0.999999 || b.b >= 0.999999)
-                return b;
-            else
-                return saturate(a * a / (1.0f - b));
-        }
-
-        // Glow
-        float3 Glow(float3 a, float3 b)
-        {
-            return Reflect(b, a);
-        }
-
-        // Overlay
-        float3 Overlay(float3 a, float3 b)
-        {
-            return lerp(2 * a * b, 1.0 - 2 * (1.0 - a) * (1.0 - b), step(0.5, a));
-        }
-
-        // Soft Light
-        float3 SoftLight(float3 a, float3 b)
-        {
-            if (b.r <= 0.5 && b.g <= 0.5 && b.b <= 0.5)
-                return clamp(a - (1.0 - 2 * b) * a * (1 - a), 0,1);
-            else
-                return clamp(a + (2 * b - 1.0) * (Aux(a) - a), 0, 1);
-        }
-
-        // Hard Light
-        float3 HardLight(float3 a, float3 b)
-        {
-            return lerp(2 * a * b, 1.0 - 2 * (1.0 - b) * (1.0 - a), step(0.5, b));
-        }
-
-        // Vivid Light
-        float3 VividLight(float3 a, float3 b)
-        {
-            return lerp(2 * a * b, b / (2 * (1.01 - a)), step(0.50, a));
-        }
-
-        // Linear Light
-        float3 LinearLight(float3 a, float3 b)
-        {
-            if (b.r < 0.5 || b.g < 0.5 || b.b < 0.5)
-                return LinearBurn(a, (2.0 * b));
-            else
-                return LinearDodge(a, (2.0 * (b - 0.5)));
-        }
-
-        // Pin Light
-        float3 PinLight(float3 a, float3 b)
-        {
-            if (b.r < 0.5 || b.g < 0.5 || b.b < 0.5)
-                return Darken(a, (2.0 * b));
-            else
-                return Lighten(a, (2.0 * (b - 0.5)));
-        }
-
-        // Hard Mix
-        float3 HardMix(float3 a, float3 b)
-        {
-            const float3 vl = VividLight(a, b);
-            if (vl.r < 0.5 || vl.g < 0.5 || vl.b < 0.5)
-                return 0.0;
-            else
-                return 1.0;
-        }
-
-        // Difference
-        float3 Difference(float3 a, float3 b)
-        {
-            return max(a - b, b - a);
-        }
-
-        // Exclusion
-        float3 Exclusion(float3 a, float3 b)
-        {
-            return a + b - 2 * a * b;
-        }
-
-        // Subtract
-        float3 Subtract(float3 a, float3 b)
-        {
-            return max((a - b), 0);
-        }
-
-        // Divide
-        float3 Divide(float3 a, float3 b)
-        {
-            return (saturate(a / (b + 0.01)));
-        }
-
-        // Divide (Alternative)
-        float3 DivideAlt(float3 a, float3 b)
-        {
-            return (saturate(1.0 / (a / b)));
-        }
-
-        // Divide (Photoshop)
-        float3 DividePS(float3 a, float3 b)
-        {
-            return (saturate(a / b));
-        }
-
-        // Grain Merge
-        float3 GrainMerge(float3 a, float3 b)
-        {
-            return saturate(b + a - 0.5);
-        }
-
-        // Grain Extract
-        float3 GrainExtract(float3 a, float3 b)
-        {
-            return saturate(a - b + 0.5);
-        }
-
-        // Hue
-        float3 Hue(float3 a, float3 b)
-        {
-            return SetLum(SetSat(b, Sat(a)), Lum(a));
-        }
-
-        // Saturation
-        float3 Saturation(float3 a, float3 b)
-        {
-            return SetLum(SetSat(a, Sat(b)), Lum(a));
-        }
-
-        // Color
-        float3 ColorB(float3 a, float3 b)
-        {
-            return SetLum(b, Lum(a));
-        }
-
-        // Luminousity
-        float3 Luminosity(float3 a, float3 b)
-        {
-            return SetLum(a, Lum(b));
-        }
-
-
-// -------------------------------------
-// Output Functions
-// -------------------------------------
-
-        float3 Blend(int mode, float3 input, float3 output, float blending)
-        {
-            switch (mode)
-            {
-                // Normal
-                default:
-                    return lerp(input.rgb, output.rgb, blending);
-                // Darken
-                case 1:
-                    return lerp(input.rgb, Darken(input.rgb, output.rgb), blending);
-                // Multiply
-                case 2:
-                    return lerp(input.rgb, Multiply(input.rgb, output.rgb), blending);
-                // Color Burn
-                case 3:
-                    return lerp(input.rgb, ColorBurn(input.rgb, output.rgb), blending);
-                // Linear Burn
-                case 4:
-                    return lerp(input.rgb, LinearBurn(input.rgb, output.rgb), blending);
-                // Lighten
-                case 5:
-                    return lerp(input.rgb, Lighten(input.rgb, output.rgb), blending);
-                // Screen
-                case 6:
-                    return lerp(input.rgb, Screen(input.rgb, output.rgb), blending);
-                // Color Dodge
-                case 7:
-                    return lerp(input.rgb, ColorDodge(input.rgb, output.rgb), blending);
-                // Linear Dodge
-                case 8:
-                    return lerp(input.rgb, LinearDodge(input.rgb, output.rgb), blending);
-                // Addition
-                case 9:
-                    return lerp(input.rgb, Addition(input.rgb, output.rgb), blending);
-                // Glow
-                case 10:
-                    return lerp(input.rgb, Glow(input.rgb, output.rgb), blending);
-                // Overlay
-                case 11:
-                    return lerp(input.rgb, Overlay(input.rgb, output.rgb), blending);
-                // Soft Light
-                case 12:
-                    return lerp(input.rgb, SoftLight(input.rgb, output.rgb), blending);
-                // Hard Light
-                case 13:
-                    return lerp(input.rgb, HardLight(input.rgb, output.rgb), blending);
-                // Vivid Light
-                case 14:
-                    return lerp(input.rgb, VividLight(input.rgb, output.rgb), blending);
-                // Linear Light
-                case 15:
-                    return lerp(input.rgb, LinearLight(input.rgb, output.rgb), blending);
-                // Pin Light
-                case 16:
-                    return lerp(input.rgb, PinLight(input.rgb, output.rgb), blending);
-                // Hard Mix
-                case 17:
-                    return lerp(input.rgb, HardMix(input.rgb, output.rgb), blending);
-                // Difference
-                case 18:
-                    return lerp(input.rgb, Difference(input.rgb, output.rgb), blending);
-                // Exclusion
-                case 19:
-                    return lerp(input.rgb, Exclusion(input.rgb, output.rgb), blending);
-                // Subtract
-                case 20:
-                    return lerp(input.rgb, Subtract(input.rgb, output.rgb), blending);
-                // Divide
-                case 21:
-                    return lerp(input.rgb, Divide(input.rgb, output.rgb), blending);
-                // Divide (Alternative)
-                case 22:
-                    return lerp(input.rgb, DivideAlt(input.rgb, output.rgb), blending);
-                // Divide (Photoshop)
-                case 23:
-                    return lerp(input.rgb, DividePS(input.rgb, output.rgb), blending);
-                // Reflect
-                case 24:
-                    return lerp(input.rgb, Reflect(input.rgb, output.rgb), blending);
-                // Grain Merge
-                case 25:
-                    return lerp(input.rgb, GrainMerge(input.rgb, output.rgb), blending);
-                // Grain Extract
-                case 26:
-                    return lerp(input.rgb, GrainExtract(input.rgb, output.rgb), blending);
-                // Hue
-                case 27:
-                    return lerp(input.rgb, Hue(input.rgb, output.rgb), blending);
-                // Saturation
-                case 28:
-                    return lerp(input.rgb, Saturation(input.rgb, output.rgb), blending);
-                // Color
-                case 29:
-                    return lerp(input.rgb, ColorB(input.rgb, output.rgb), blending);
-                // Luminosity
-                case 30:
-                    return lerp(input.rgb, Luminosity(input.rgb, output.rgb), blending);
-            }
-        }
-    }
-}
--- a/EXE/reshade-shaders/Shaders/CAS.fx
+++ b/EXE/reshade-shaders/Shaders/CAS.fx
@@ -0,0 +1,182 @@
+// LICENSE
+// =======
+// Copyright (c) 2017-2019 Advanced Micro Devices, Inc. All rights reserved.
+// -------
+// 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
+
+//Initial port to ReShade: SLSNe	https://gist.github.com/SLSNe/bbaf2d77db0b2a2a0755df581b3cf00c
+
+//Optimizations by Marty McFly:
+//	vectorized math, even with scalar gcn hardware this should work
+//	out the same, order of operations has not changed
+//	For some reason, it went from 64 to 48 instructions, a lot of MOV gone
+//	Also modified the way the final window is calculated
+//	  
+//	reordered min() and max() operations, from 11 down to 9 registers	
+//
+//	restructured final weighting, 49 -> 48 instructions
+//
+//	delayed RCP to replace SQRT with RSQRT
+//
+//	removed the saturate() from the control var as it is clamped
+//	by UI manager already, 48 -> 47 instructions
+//
+//	replaced tex2D with tex2Doffset intrinsic (address offset by immediate integer)
+//	47 -> 43 instructions
+//	9 -> 8 registers
+
+//Further modified by OopyDoopy and Lord of Lunacy:
+//	Changed wording in the UI for the existing variable and added a new variable and relevant code to adjust sharpening strength.
+
+//Fix by Lord of Lunacy:
+//	Made the shader use a linear colorspace rather than sRGB, as recommended by the original AMD documentation from FidelityFX.
+
+//Modified by CeeJay.dk:
+//	Included a label and tooltip description. I followed AMDs official naming guidelines for FidelityFX.
+//
+//	Used gather trick to reduce the number of texture operations by one (9 -> 8). It's now 42 -> 51 instructions but still faster
+//	because of the texture operation that was optimized away.
+
+//Fix by CeeJay.dk
+//	Fixed precision issues with the gather at super high resolutions
+//	Also tried to refactor the samples so more work can be done while they are being sampled, but it's not so easy and the gains
+//	I'm seeing are so small they might be statistical noise. So it MIGHT be faster - no promises.
+
+//Fix by BC46
+//	Removed the "0.5 * pixel" expressions in the DX10 or higher check.
+// 	With the use of dgVoodoo at least, the previous code caused the entire image to be blurry and slightly mispositioned.
+
+uniform float Contrast <
+	ui_type = "drag";
+	ui_label = "Contrast Adaptation";
+	ui_tooltip = "Adjusts the range the shader adapts to high contrast (0 is not all the way off).  Higher values = more high contrast sharpening.";
+	ui_min = 0.0; ui_max = 1.0;
+> = 0.0;
+
+uniform float Sharpening <
+	ui_type = "drag";
+	ui_label = "Sharpening intensity";
+	ui_tooltip = "Adjusts sharpening intensity by averaging the original pixels to the sharpened result.  1.0 is the unmodified default.";
+	ui_min = 0.0; ui_max = 1.0;
+> = 1.0;
+
+#include "ReShade.fxh"
+#define pixel float2(BUFFER_RCP_WIDTH, BUFFER_RCP_HEIGHT)
+
+texture TexColor : COLOR;
+sampler sTexColor {Texture = TexColor; SRGBTexture = true;};
+
+float3 CASPass(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
+{	
+	// fetch a 3x3 neighborhood around the pixel 'e',
+	//  a b c
+	//  d(e)f
+	//  g h i
+	
+
+	float3 b = tex2Doffset(sTexColor, texcoord, int2(0, -1)).rgb;
+	float3 d = tex2Doffset(sTexColor, texcoord, int2(-1, 0)).rgb;
+	
+ 
+#if __RENDERER__ >= 0xa000 // If DX10 or higher
+	float4 red_efhi = tex2DgatherR(sTexColor, texcoord);
+	
+	float3 e = float3( red_efhi.w, red_efhi.w, red_efhi.w);
+	float3 f = float3( red_efhi.z, red_efhi.z, red_efhi.z);
+	float3 h = float3( red_efhi.x, red_efhi.x, red_efhi.x);
+	float3 i = float3( red_efhi.y, red_efhi.y, red_efhi.y);
+	
+	float4 green_efhi = tex2DgatherG(sTexColor, texcoord);
+	
+	e.g = green_efhi.w;
+	f.g = green_efhi.z;
+	h.g = green_efhi.x;
+	i.g = green_efhi.y;
+	
+	float4 blue_efhi = tex2DgatherB(sTexColor, texcoord);
+	
+	e.b = blue_efhi.w;
+	f.b = blue_efhi.z;
+	h.b = blue_efhi.x;
+	i.b = blue_efhi.y;
+
+
+#else // If DX9
+	float3 e = tex2D(sTexColor, texcoord).rgb;
+	float3 f = tex2Doffset(sTexColor, texcoord, int2(1, 0)).rgb;
+
+	float3 h = tex2Doffset(sTexColor, texcoord, int2(0, 1)).rgb;
+	float3 i = tex2Doffset(sTexColor, texcoord, int2(1, 1)).rgb;
+
+#endif
+
+	float3 g = tex2Doffset(sTexColor, texcoord, int2(-1, 1)).rgb; 
+	float3 a = tex2Doffset(sTexColor, texcoord, int2(-1, -1)).rgb;
+	float3 c = tex2Doffset(sTexColor, texcoord, int2(1, -1)).rgb;
+   
+
+	// Soft min and max.
+	//  a b c			 b
+	//  d e f * 0.5  +  d e f * 0.5
+	//  g h i			 h
+	// These are 2.0x bigger (factored out the extra multiply).
+	float3 mnRGB = min(min(min(d, e), min(f, b)), h);
+	float3 mnRGB2 = min(mnRGB, min(min(a, c), min(g, i)));
+	mnRGB += mnRGB2;
+
+	float3 mxRGB = max(max(max(d, e), max(f, b)), h);
+	float3 mxRGB2 = max(mxRGB, max(max(a, c), max(g, i)));
+	mxRGB += mxRGB2;
+
+	// Smooth minimum distance to signal limit divided by smooth max.
+	float3 rcpMRGB = rcp(mxRGB);
+	float3 ampRGB = saturate(min(mnRGB, 2.0 - mxRGB) * rcpMRGB);	
+	
+	// Shaping amount of sharpening.
+	ampRGB = rsqrt(ampRGB);
+	
+	float peak = -3.0 * Contrast + 8.0;
+	float3 wRGB = -rcp(ampRGB * peak);
+
+	float3 rcpWeightRGB = rcp(4.0 * wRGB + 1.0);
+
+	//						  0 w 0
+	//  Filter shape:		   w 1 w
+	//						  0 w 0  
+	float3 window = (b + d) + (f + h);
+	float3 outColor = saturate((window * wRGB + e) * rcpWeightRGB);
+	
+	return lerp(e, outColor, Sharpening);
+}
+
+technique ContrastAdaptiveSharpen
+	<
+	ui_label = "AMD FidelityFX Contrast Adaptive Sharpening";
+	ui_tooltip = 
+	"CAS is a low overhead adaptive sharpening algorithm that AMD includes with their drivers.\n"
+	"This port to ReShade works with all cards from all vendors,\n"
+	"but cannot do the optional scaling that CAS is normally also capable of when activated in the AMD drivers.\n"
+	"\n"
+	"The algorithm adjusts the amount of sharpening per pixel to target an even level of sharpness across the image.\n"
+	"Areas of the input image that are already sharp are sharpened less, while areas that lack detail are sharpened more.\n"
+	"This allows for higher overall natural visual sharpness with fewer artifacts.";
+	>
+{
+	pass
+	{
+		VertexShader = PostProcessVS;
+		PixelShader = CASPass;
+		SRGBWriteEnable = true;
+	}
+}
--- a/EXE/reshade-shaders/Shaders/Colourfulness.fx
+++ b/EXE/reshade-shaders/Shaders/Colourfulness.fx
@@ -0,0 +1,140 @@
+// Copyright (c) 2016-2018, bacondither
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer
+//    in this position and unchanged.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Colourfulness - version 2018-11-12
+// EXPECTS FULL RANGE GAMMA LIGHT
+
+#include "ReShadeUI.fxh"
+
+uniform float colourfulness < __UNIFORM_SLIDER_FLOAT1
+	ui_min = -1.0; ui_max = 2.0;
+	ui_tooltip = "Degree of colourfulness, 0 = neutral";
+	ui_step = 0.01;
+> = 0.4;
+
+uniform float lim_luma < __UNIFORM_SLIDER_FLOAT1
+	ui_min = 0.1; ui_max = 1.0;
+	ui_tooltip = "Lower values allows for more change near clipping";
+	ui_step = 0.01;
+> = 0.7;
+
+uniform bool enable_dither <
+	ui_tooltip = "Enables dithering, avoids introducing banding in gradients";
+	ui_category = "Dither";
+> = false;
+
+uniform bool col_noise <
+	ui_tooltip = "Coloured dither noise, lower subjective noise level";
+	ui_category = "Dither";
+> = true;
+
+uniform float backbuffer_bits <
+	ui_min = 1.0; ui_max = 32.0;
+	ui_tooltip = "Backbuffer bith depth, most likely 8 or 10 bits";
+	ui_category = "Dither";
+> = 8.0;
+
+//-------------------------------------------------------------------------------------------------
+#ifndef fast_luma
+	#define fast_luma 1 // Rapid approx of sRGB gamma, small difference in quality
+#endif
+
+#ifndef temporal_dither
+	#define temporal_dither 0 // Dither changes with every frame
+#endif
+//-------------------------------------------------------------------------------------------------
+
+#include "ReShade.fxh"
+
+#if (temporal_dither == 1)
+	uniform int rnd < source = "random"; min = 0; max = 1000; >;
+#endif
+
+// Sigmoid function, sign(v)*pow(pow(abs(v), -2) + pow(s, -2), 1.0/-2)
+#define soft_lim(v,s)  ( (v*s)*rcp(sqrt(s*s + v*v)) )
+
+// Weighted power mean, p = 0.5
+#define wpmean(a,b,w)  ( pow(abs(w)*sqrt(abs(a)) + abs(1-w)*sqrt(abs(b)), 2) )
+
+// Max/Min RGB components
+#define maxRGB(c)      ( max((c).r, max((c).g, (c).b)) )
+#define minRGB(c)      ( min((c).r, min((c).g, (c).b)) )
+
+// Mean of Rec. 709 & 601 luma coefficients
+#define lumacoeff        float3(0.2558, 0.6511, 0.0931)
+
+float3 Colourfulness(float4 vpos : SV_Position, float2 tex : TEXCOORD) : SV_Target
+{
+	#if (fast_luma == 1)
+		float3 c0  = tex2D(ReShade::BackBuffer, tex).rgb;
+		float luma = sqrt(dot(saturate(c0*abs(c0)), lumacoeff));
+		c0 = saturate(c0);
+	#else // Better approx of sRGB gamma
+		float3 c0  = saturate(tex2D(ReShade::BackBuffer, tex).rgb);
+		float luma = pow(dot(pow(c0 + 0.06, 2.4), lumacoeff), 1.0/2.4) - 0.06;
+	#endif
+
+	// Calc colour saturation change
+	float3 diff_luma = c0 - luma;
+	float3 c_diff = diff_luma*(colourfulness + 1) - diff_luma;
+
+	if (colourfulness > 0.0)
+	{
+		// 120% of c_diff clamped to max visible range + overshoot
+		float3 rlc_diff = clamp((c_diff*1.2) + c0, -0.0001, 1.0001) - c0;
+
+		// Calc max saturation-increase without altering RGB ratios
+		float poslim = (1.0002 - luma)/(abs(maxRGB(diff_luma)) + 0.0001);
+		float neglim = (luma + 0.0002)/(abs(minRGB(diff_luma)) + 0.0001);
+
+		float3 diffmax = diff_luma*min(min(poslim, neglim), 32) - diff_luma;
+
+		// Soft limit diff
+		c_diff = soft_lim( c_diff, max(wpmean(diffmax, rlc_diff, lim_luma), 1e-7) );
+	}
+
+	if (enable_dither == true)
+	{
+		// Interleaved gradient noise by Jorge Jimenez
+		const float3 magic = float3(0.06711056, 0.00583715, 52.9829189);
+		#if (temporal_dither == 1)
+			float xy_magic = (vpos.x + rnd)*magic.x + (vpos.y + rnd)*magic.y;
+		#else
+			float xy_magic = vpos.x*magic.x + vpos.y*magic.y;
+		#endif
+		float noise = (frac(magic.z*frac(xy_magic)) - 0.5)/(exp2(backbuffer_bits) - 1);
+		c_diff += col_noise == true ? float3(-noise, noise, -noise) : noise;
+	}
+
+	return saturate(c0 + c_diff);
+}
+
+technique Colourfulness
+{
+	pass
+	{
+		VertexShader = PostProcessVS;
+		PixelShader  = Colourfulness;
+	}
+}
--- a/EXE/reshade-shaders/Shaders/Daltonize.fx
+++ b/EXE/reshade-shaders/Shaders/Daltonize.fx
@@ -1,73 +0,0 @@
-/**
- * Daltonization algorithm by daltonize.org
- * http://www.daltonize.org/2010/05/lms-daltonization-algorithm.html
- * Originally ported to ReShade by IDDQD, modified for ReShade 3.0 by crosire
- */
-
-uniform int Type <
-	ui_type = "combo";
-	ui_items = "Protanopia\0Deuteranopia\0Tritanopia\0";
-> = 0;
-
-#include "ReShade.fxh"
-
-float3 PS_DaltonizeFXmain(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
-{
-	float3 input = tex2D(ReShade::BackBuffer, texcoord).rgb;
-
-	// RGB to LMS matrix conversion
-	float OnizeL = (17.8824f * input.r) + (43.5161f * input.g) + (4.11935f * input.b);
-	float OnizeM = (3.45565f * input.r) + (27.1554f * input.g) + (3.86714f * input.b);
-	float OnizeS = (0.0299566f * input.r) + (0.184309f * input.g) + (1.46709f * input.b);
-	
-	// Simulate color blindness
-	float Daltl, Daltm, Dalts;
-
-	if (Type == 0) // Protanopia - reds are greatly reduced (1% men)
-	{
-		Daltl = 0.0f * OnizeL + 2.02344f * OnizeM + -2.52581f * OnizeS;
-		Daltm = 0.0f * OnizeL + 1.0f * OnizeM + 0.0f * OnizeS;
-		Dalts = 0.0f * OnizeL + 0.0f * OnizeM + 1.0f * OnizeS;
-	}
-	else if (Type == 1) // Deuteranopia - greens are greatly reduced (1% men)
-	{
-		Daltl = 1.0f * OnizeL + 0.0f * OnizeM + 0.0f * OnizeS;
-		Daltm = 0.494207f * OnizeL + 0.0f * OnizeM + 1.24827f * OnizeS;
-		Dalts = 0.0f * OnizeL + 0.0f * OnizeM + 1.0f * OnizeS;
-	}
-	else if (Type == 2) // Tritanopia - blues are greatly reduced (0.003% population)
-	{
-		Daltl = 1.0f * OnizeL + 0.0f * OnizeM + 0.0f * OnizeS;
-		Daltm = 0.0f * OnizeL + 1.0f * OnizeM + 0.0f * OnizeS;
-		Dalts = -0.395913f * OnizeL + 0.801109f * OnizeM + 0.0f * OnizeS;
-	}
-	
-	// LMS to RGB matrix conversion
-	float3 error;
-	error.r = (0.0809444479f * Daltl) + (-0.130504409f * Daltm) + (0.116721066f * Dalts);
-	error.g = (-0.0102485335f * Daltl) + (0.0540193266f * Daltm) + (-0.113614708f * Dalts);
-	error.b = (-0.000365296938f * Daltl) + (-0.00412161469f * Daltm) + (0.693511405f * Dalts);
-	
-	// Isolate invisible colors to color vision deficiency (calculate error matrix)
-	error = (input - error);
-	
-	// Shift colors towards visible spectrum (apply error modifications)
-	float3 correction;
-	correction.r = 0; // (error.r * 0.0) + (error.g * 0.0) + (error.b * 0.0);
-	correction.g = (error.r * 0.7) + (error.g * 1.0); // + (error.b * 0.0);
-	correction.b = (error.r * 0.7) + (error.b * 1.0); // + (error.g * 0.0);
-	
-	// Add compensation to original values
-	correction = input + correction;
-	
-	return correction;
-}
-
-technique Daltonize
-{
-	pass
-	{
-		VertexShader = PostProcessVS;
-		PixelShader = PS_DaltonizeFXmain;
-	}
-}
--- a/EXE/reshade-shaders/Shaders/Deband.fx
+++ b/EXE/reshade-shaders/Shaders/Deband.fx
@@ -1,252 +0,0 @@
-/**
- * Deband shader by haasn
- * https://github.com/haasn/gentoo-conf/blob/xor/home/nand/.mpv/shaders/deband-pre.glsl
- *
- * Copyright (c) 2015 Niklas Haas
- *
- * 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.
- *
- * Modified and optimized for ReShade by JPulowski
- * https://reshade.me/forum/shader-presentation/768-deband
- *
- * Do not distribute without giving credit to the original author(s).
- *
- * 1.0  - Initial release
- * 1.1  - Replaced the algorithm with the one from MPV
- * 1.1a - Minor optimizations
- *      - Removed unnecessary lines and replaced them with ReShadeFX intrinsic counterparts
- * 2.0  - Replaced "grain" with CeeJay.dk's ordered dithering algorithm and enabled it by default
- *      - The configuration is now more simpler and straightforward
- *      - Some minor code changes and optimizations
- *      - Improved the algorithm and made it more robust by adding some of the madshi's
- *        improvements to flash3kyuu_deband which should cause an increase in quality. Higher
- *        iterations/ranges should now yield higher quality debanding without too much decrease
- *        in quality.
- *      - Changed licensing text and original source code URL
- * 3.0  - Replaced the entire banding detection algorithm with modified standard deviation and
- *        Weber ratio analyses which give more accurate and error-free results compared to the
- *        previous algorithm
- *      - Added banding map debug view
- *      - Added and redefined UI categories
- *      - Added depth detection (credits to spiro) which should be useful when banding only
- *        occurs in the sky texture for example
- *      - Fixed a bug in random number generation which was causing artifacts on the upper left
- *        side of the screen
- *      - Dithering is now applied only when debanding a pixel as it should be which should
- *        reduce the overall noise in the final texture
- *      - Minor code optimizations
- * 3.1  - Switched to chroma-based analysis from luma-based analysis which was causing artifacts
- *        under some scenarios
- *      - Changed parts of the code which was causing compatibility issues on some renderers
- */
-
-#include "ReShadeUI.fxh"
-#include "ReShade.fxh"
-
-uniform bool enable_weber <
-    ui_category = "Banding analysis";
-    ui_label = "Weber ratio";
-    ui_tooltip = "Weber ratio analysis that calculates the ratio of the each local pixel's intensity to average background intensity of all the local pixels.";
-    ui_type = "radio";
-> = true;
-
-uniform bool enable_sdeviation <
-    ui_category = "Banding analysis";
-    ui_label = "Standard deviation";
-    ui_tooltip = "Modified standard deviation analysis that calculates nearby pixels' intensity deviation from the current pixel instead of the mean.";
-    ui_type = "radio";
-> = true;
-
-uniform bool enable_depthbuffer <
-    ui_category = "Banding analysis";
-    ui_label = "Depth detection";
-    ui_tooltip = "Allows depth information to be used when analysing banding, pixels will only be analysed if they are in a certain depth. (e.g. debanding only the sky)";
-    ui_type = "radio";
-> = false;
-
-uniform float t1 <
-    ui_category = "Banding analysis";
-    ui_label = "Standard deviation threshold";
-    ui_max = 0.5;
-    ui_min = 0.0;
-    ui_step = 0.001;
-    ui_tooltip = "Standard deviations lower than this threshold will be flagged as flat regions with potential banding.";
-    ui_type = "slider";
-> = 0.007;
-
-uniform float t2 <
-    ui_category = "Banding analysis";
-    ui_label = "Weber ratio threshold";
-    ui_max = 2.0;
-    ui_min = 0.0;
-    ui_step = 0.01;
-    ui_tooltip = "Weber ratios lower than this threshold will be flagged as flat regions with potential banding.";
-    ui_type = "slider";
-> = 0.04;
-
-uniform float banding_depth <
-    ui_category = "Banding analysis";
-    ui_label = "Banding depth";
-    ui_max = 1.0;
-    ui_min = 0.0;
-    ui_step = 0.001;
-    ui_tooltip = "Pixels under this depth threshold will not be processed and returned as they are.";
-    ui_type = "slider";
-> = 1.0;
-
-uniform float range <
-    ui_category = "Banding detection & removal";
-    ui_label = "Radius";
-    ui_max = 32.0;
-    ui_min = 1.0;
-    ui_step = 1.0;
-    ui_tooltip = "The radius increases linearly for each iteration. A higher radius will find more gradients, but a lower radius will smooth more aggressively.";
-    ui_type = "slider";
-> = 24.0;
-
-uniform int iterations <
-    ui_category = "Banding detection & removal";
-    ui_label = "Iterations";
-    ui_max = 4;
-    ui_min = 1;
-    ui_tooltip = "The number of debanding steps to perform per sample. Each step reduces a bit more banding, but takes time to compute.";
-    ui_type = "slider";
-> = 1;
-
-uniform int debug_output <
-    ui_category = "Debug";
-    ui_items = "None\0Blurred (LPF) image\0Banding map\0";
-    ui_label = "Debug view";
-    ui_tooltip = "Blurred (LPF) image: Useful when tweaking radius and iterations to make sure all banding regions are blurred enough.\nBanding map: Useful when tweaking analysis parameters, continuous green regions indicate flat (i.e. banding) regions.";
-    ui_type = "combo";
-> = 0;
-
-// Reshade uses C rand for random, max cannot be larger than 2^15-1
-uniform int drandom < source = "random"; min = 0; max = 32767; >;
-
-float rand(float x)
-{
-    return frac(x / 41.0);
-}
-
-float permute(float x)
-{
-    return ((34.0 * x + 1.0) * x) % 289.0;
-}
-
-float3 PS_Deband(float4 vpos : SV_Position, float2 texcoord : TexCoord) : SV_Target
-{
-    float3 ori = tex2Dlod(ReShade::BackBuffer, float4(texcoord, 0.0, 0.0)).rgb;
-
-    if (enable_depthbuffer && (ReShade::GetLinearizedDepth(texcoord) < banding_depth))
-        return ori;
-
-    // Initialize the PRNG by hashing the position + a random uniform
-    float3 m = float3(texcoord + 1.0, (drandom / 32767.0) + 1.0);
-    float h = permute(permute(permute(m.x) + m.y) + m.z);
-
-    // Compute a random angle
-    float dir  = rand(permute(h)) * 6.2831853;
-    float2 o;
-    sincos(dir, o.y, o.x);
-    
-    // Distance calculations
-    float2 pt;
-    float dist;
-
-    for (int i = 1; i <= iterations; ++i) {
-        dist = rand(h) * range * i;
-        pt = dist * BUFFER_PIXEL_SIZE;
-    
-        h = permute(h);
-    }
-    
-    // Sample at quarter-turn intervals around the source pixel
-    float3 ref[4] = {
-        tex2Dlod(ReShade::BackBuffer, float4(mad(pt,                  o, texcoord), 0.0, 0.0)).rgb, // SE
-        tex2Dlod(ReShade::BackBuffer, float4(mad(pt,                 -o, texcoord), 0.0, 0.0)).rgb, // NW
-        tex2Dlod(ReShade::BackBuffer, float4(mad(pt, float2(-o.y,  o.x), texcoord), 0.0, 0.0)).rgb, // NE
-        tex2Dlod(ReShade::BackBuffer, float4(mad(pt, float2( o.y, -o.x), texcoord), 0.0, 0.0)).rgb  // SW
-    };
-
-    // Calculate weber ratio
-    float3 mean = (ori + ref[0] + ref[1] + ref[2] + ref[3]) * 0.2;
-    float3 k = abs(ori - mean);
-    for (int j = 0; j < 4; ++j) {
-        k += abs(ref[j] - mean);
-    }
-
-    k = k * 0.2 / mean;
-
-    // Calculate std. deviation
-    float3 sd = 0.0;
-
-    for (int j = 0; j < 4; ++j) {
-        sd += pow(ref[j] - ori, 2);
-    }
-
-    sd = sqrt(sd * 0.25);
-
-    // Generate final output
-    float3 output;
-
-    if (debug_output == 2)
-        output = float3(0.0, 1.0, 0.0);
-    else
-        output = (ref[0] + ref[1] + ref[2] + ref[3]) * 0.25;
-
-    // Generate a binary banding map
-    bool3 banding_map = true;
-
-    if (debug_output != 1) {
-        if (enable_weber)
-            banding_map = banding_map && k <= t2 * iterations;
-
-        if (enable_sdeviation)
-            banding_map = banding_map && sd <= t1 * iterations;
-    }
-
-	/*------------------------.
-	| :: Ordered Dithering :: |
-	'------------------------*/
-	//Calculate grid position
-	float grid_position = frac(dot(texcoord, (BUFFER_SCREEN_SIZE * float2(1.0 / 16.0, 10.0 / 36.0)) + 0.25));
-
-	//Calculate how big the shift should be
-	float dither_shift = 0.25 * (1.0 / (pow(2, BUFFER_COLOR_BIT_DEPTH) - 1.0));
-
-	//Shift the individual colors differently, thus making it even harder to see the dithering pattern
-	float3 dither_shift_RGB = float3(dither_shift, -dither_shift, dither_shift); //subpixel dithering
-
-	//modify shift acording to grid position.
-	dither_shift_RGB = lerp(2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position); //shift acording to grid position.
-    
-    return banding_map ? output + dither_shift_RGB : ori;
-}
-
-technique Deband <
-ui_tooltip = "Alleviates color banding by trying to approximate original color values.";
->
-{
-    pass
-    {
-        VertexShader = PostProcessVS;
-        PixelShader = PS_Deband;
-    }
-}
--- a/EXE/reshade-shaders/Shaders/DisplayDepth.fx
+++ b/EXE/reshade-shaders/Shaders/DisplayDepth.fx
@@ -1,427 +0,0 @@
-/*
-  DisplayDepth by CeeJay.dk (with many updates and additions by the Reshade community)
-
-  Visualizes the depth buffer. The distance of pixels determine their brightness.
-  Close objects are dark. Far away objects are bright.
-  Use this to configure the depth input preprocessor definitions (RESHADE_DEPTH_INPUT_*).
-*/
-
-#include "ReShade.fxh"
-
-// -- Basic options --
-#if RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN
-#define TEXT_UPSIDE_DOWN "1"
-#define TEXT_UPSIDE_DOWN_ALTER "0"
-#else
-#define TEXT_UPSIDE_DOWN "0"
-#define TEXT_UPSIDE_DOWN_ALTER "1"
-#endif
-#if RESHADE_DEPTH_INPUT_IS_REVERSED
-#define TEXT_REVERSED "1"
-#define TEXT_REVERSED_ALTER "0"
-#else
-#define TEXT_REVERSED "0"
-#define TEXT_REVERSED_ALTER "1"
-#endif
-#if RESHADE_DEPTH_INPUT_IS_LOGARITHMIC
-#define TEXT_LOGARITHMIC "1"
-#define TEXT_LOGARITHMIC_ALTER "0"
-#else
-#define TEXT_LOGARITHMIC "0"
-#define TEXT_LOGARITHMIC_ALTER "1"
-#endif
-
-// "ui_text" was introduced in ReShade 4.5, so cannot show instructions in older versions
-
-uniform int iUIPresentType <
-    ui_label = "Present type";
-    ui_label_ja_jp = "画面効果";
-    ui_type = "combo";
-    ui_items = "Depth map\0Normal map\0Show both (Vertical 50/50)\0";
-    ui_items_ja_jp = "深度マップ\0法線マップ\0両方を表示 (左右分割)\0";
-#if __RESHADE__ < 40500
-    ui_tooltip =
-#else
-    ui_text =
-#endif
-        "The right settings need to be set in the dialog that opens after clicking the \"Edit global preprocessor definitions\" button above.\n"
-        "\n"
-        "RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN is currently set to " TEXT_UPSIDE_DOWN ".\n"
-        "If the Depth map is shown upside down set it to " TEXT_UPSIDE_DOWN_ALTER ".\n"
-        "\n"
-        "RESHADE_DEPTH_INPUT_IS_REVERSED is currently set to " TEXT_REVERSED ".\n"
-        "If close objects in the Depth map are bright and far ones are dark set it to " TEXT_REVERSED_ALTER ".\n"
-        "Also try this if you can see the normals, but the depth view is all black.\n"
-        "\n"
-        "RESHADE_DEPTH_INPUT_IS_LOGARITHMIC is currently set to " TEXT_LOGARITHMIC ".\n"
-        "If the Normal map has banding artifacts (extra stripes) set it to " TEXT_LOGARITHMIC_ALTER ".";
-    ui_text_ja_jp =
-#if ADDON_ADJUST_DEPTH
-        "Adjust Depthアドオンのインストールを検出しました。\n"
-        "'設定に保存して反映する'ボタンをクリックすると、このエフェクトで調節した全ての変数が共通設定に反映されます。\n"
-        "または、上の'プリプロセッサの定義を編集'ボタンをクリックした後に開くダイアログで直接編集する事もできます。";
-#else
-        "調節が終わったら、上の'プリプロセッサの定義を編集'ボタンをクリックした後に開くダイアログに入力する必要があります。\n"
-        "\n"
-        "RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWNは現在" TEXT_UPSIDE_DOWN "に設定されています。\n"
-        "深度マップが上下逆さまに表示されている場合は" TEXT_UPSIDE_DOWN_ALTER "に変更して下さい。\n"
-        "\n"
-        "RESHADE_DEPTH_INPUT_IS_REVERSEDは現在" TEXT_REVERSED "に設定されています。\n"
-        "画面効果が深度マップのとき、近くの形状がより白く、遠くの形状がより黒い場合は" TEXT_REVERSED_ALTER "に変更して下さい。\n"
-        "また、法線マップで形が判別出来るが、深度マップが真っ暗に見えるという場合も、この設定の変更を試して下さい。\n"
-        "\n"
-        "RESHADE_DEPTH_INPUT_IS_LOGARITHMICは現在" TEXT_LOGARITHMIC "に設定されています。\n"
-        "画面効果に実際のレンダリングと合致しない縞模様がある場合は" TEXT_LOGARITHMIC_ALTER "に変更して下さい。";
-#endif
-    ui_tooltip_ja_jp =
-        "'深度マップ'は、形状の遠近を白黒で表現します。正しい見え方では、近くの形状ほど黒く、遠くの形状ほど白くなります。\n"
-        "'法線マップ'は、形状を滑らかに表現します。正しい見え方では、全体的に青緑風で、地平線を見たときに地面が緑掛かった色合いになります。\n"
-        "'両方を表示 (左右分割)'が選択された場合は、左に法線マップ、右に深度マップを表示します。";
-> = 2;
-
-uniform bool bUIShowOffset <
-    ui_label = "Blend Depth map into the image (to help with finding the right offset)";
-    ui_label_ja_jp = "透かし比較";
-    ui_tooltip_ja_jp = "補正作業を支援するために、画面効果を半透過で適用します。";
-> = false;
-
-uniform bool bUIUseLivePreview <
-    ui_category = "Preview settings";
-    ui_category_ja_jp = "基本的な補正";
-#if __RESHADE__ <= 50902
-    ui_category_closed = true;
-#elif !ADDON_ADJUST_DEPTH
-    ui_category_toggle = true;
-#endif
-    ui_label = "Show live preview and ignore preprocessor definitions";
-    ui_label_ja_jp = "プリプロセッサの定義を無視 (補正プレビューをオン)";
-    ui_tooltip = "Enable this to preview with the current preset settings instead of the global preprocessor settings.";
-    ui_tooltip_ja_jp =
-        "共通設定に保存されたプリプロセッサの定義ではなく、これより下のプレビュー設定を使用するには、これを有効にします。\n"
-#if ADDON_ADJUST_DEPTH
-        "設定の準備が出来たら、'設定に保存して反映する'ボタンをクリックしてから、このチェックボックスをオフにして下さい。"
-#else
-        "設定の準備が出来たら、上の'プリプロセッサの定義を編集'ボタンをクリックした後に開くダイアログに入力して下さい。"
-#endif
-        "\n\n"
-        "プレビューをオンにした場合と比較して画面効果がまったく同じになれば、正しく設定が反映されています。";
-> = false;
-
-#if __RESHADE__ <= 50902
-uniform int iUIUpsideDown <
-#else
-uniform bool iUIUpsideDown <
-#endif
-    ui_category = "Preview settings";
-    ui_label = "Upside Down";
-    ui_label_ja_jp = "深度バッファの上下反転を修正";
-#if __RESHADE__ <= 50902
-    ui_type = "combo";
-    ui_items = "Off\0On\0";
-#endif
-    ui_text_ja_jp =
-        "\n"
-#if ADDON_ADJUST_DEPTH
-        "項目にカーソルを合わせると、設定が必要な状況の説明が表示されます。"
-#else
-        "項目にカーソルを合わせると、設定が必要な状況の説明と、プリプロセッサの定義が表示されます。"
-#endif
-    ;
-    ui_tooltip_ja_jp =
-        "深度マップが上下逆さまに表示されている場合は変更して下さい。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN=値\n"
-        "定義値は次の通りです。オンの場合は1、オフの場合は0を指定して下さい。\n"
-        "RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN=1\n"
-        "RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN=0"
-#endif
-        ;
-> = RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN;
-
-#if __RESHADE__ <= 50902
-uniform int iUIReversed <
-#else
-uniform bool iUIReversed <
-#endif
-    ui_category = "Preview settings";
-    ui_label = "Reversed";
-    ui_label_ja_jp = "深度バッファの奥行反転を修正";
-#if __RESHADE__ <= 50902
-    ui_type = "combo";
-    ui_items = "Off\0On\0";
-#endif
-    ui_tooltip_ja_jp =
-        "画面効果が深度マップのとき、近くの形状が明るく、遠くの形状が暗い場合は変更して下さい。\n"
-        "また、法線マップで形が判別出来るが、深度マップが真っ暗に見えるという場合も、この設定の変更を試して下さい。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_INPUT_IS_REVERSED=値\n"
-        "定義値は次の通りです。オンの場合は1、オフの場合は0を指定して下さい。\n"
-        "RESHADE_DEPTH_INPUT_IS_REVERSED=1\n"
-        "RESHADE_DEPTH_INPUT_IS_REVERSED=0"
-#endif
-        ;
-> = RESHADE_DEPTH_INPUT_IS_REVERSED;
-
-#if __RESHADE__ <= 50902
-uniform int iUILogarithmic <
-#else
-uniform bool iUILogarithmic <
-#endif
-    ui_category = "Preview settings";
-    ui_label = "Logarithmic";
-    ui_label_ja_jp = "深度バッファを対数分布として扱うように修正";
-#if __RESHADE__ <= 50902
-    ui_type = "combo";
-    ui_items = "Off\0On\0";
-#endif
-    ui_tooltip = "Change this setting if the displayed surface normals have stripes in them.";
-    ui_tooltip_ja_jp =
-        "画面効果に実際のゲーム画面と合致しない縞模様がある場合は変更して下さい。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_INPUT_IS_LOGARITHMIC=値\n"
-        "定義値は次の通りです。オンの場合は1、オフの場合は0を指定して下さい。\n"
-        "RESHADE_DEPTH_INPUT_IS_LOGARITHMIC=1\n"
-        "RESHADE_DEPTH_INPUT_IS_LOGARITHMIC=0"
-#endif
-        ;
-> = RESHADE_DEPTH_INPUT_IS_LOGARITHMIC;
-
-// -- Advanced options --
-
-uniform float2 fUIScale <
-    ui_category = "Preview settings";
-    ui_label = "Scale";
-    ui_label_ja_jp = "拡大率";
-    ui_type = "drag";
-    ui_text =
-        "\n"
-        " * Advanced options\n"
-        "\n"
-        "The following settings also need to be set using \"Edit global preprocessor definitions\" above in order to take effect.\n"
-        "You can preview how they will affect the Depth map using the controls below.\n"
-        "\n"
-        "It is rarely necessary to change these though, as their defaults fit almost all games.\n\n";
-    ui_text_ja_jp =
-        "\n"
-        " * その他の補正 (不定形またはその他)\n"
-        "\n"
-        "これより下は、深度バッファが不定形など、特別なケース向けの設定です。\n"
-        "通常はこれより上の'基本的な補正'のみでほとんどのゲームに適合します。\n"
-        "また、これらの設定は画質の向上にはまったく役に立ちません。\n\n";
-    ui_tooltip =
-        "Best use 'Present type'->'Depth map' and enable 'Offset' in the options below to set the scale.\n"
-        "Use these values for:\nRESHADE_DEPTH_INPUT_X_SCALE=<left value>\nRESHADE_DEPTH_INPUT_Y_SCALE=<right value>\n"
-        "\n"
-        "If you know the right resolution of the games depth buffer then this scale value is simply the ratio\n"
-        "between the correct resolution and the resolution Reshade thinks it is.\n"
-        "For example:\n"
-        "If it thinks the resolution is 1920 x 1080, but it's really 1280 x 720 then the right scale is (1.5 , 1.5)\n"
-        "because 1920 / 1280 is 1.5 and 1080 / 720 is also 1.5, so 1.5 is the right scale for both the x and the y";
-    ui_tooltip_ja_jp =
-        "深度バッファの解像度がクライアント解像度と異なる場合に変更して下さい。\n"
-        "このスケール値は、深度バッファの解像度とクライアント解像度との単純な比率になります。\n"
-        "深度バッファの解像度が1280×720でクライアント解像度が1920×1080の場合、横の比率が1920÷1280、縦の比率が1080÷720となります。\n"
-        "計算した結果を設定すると、値はそれぞれX_SCALE=1.5、Y_SCALE=1.5となります。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_INPUT_X_SCALE=横の値\n"
-        "RESHADE_DEPTH_INPUT_Y_SCALE=縦の値\n"
-        "定義値は次の通りです。横の値はX_SCALE、縦の値はY_SCALEに指定して下さい。\n"
-        "RESHADE_DEPTH_INPUT_X_SCALE=1.0\n"
-        "RESHADE_DEPTH_INPUT_Y_SCALE=1.0"
-#endif
-        ;
-    ui_min = 0.0; ui_max = 2.0;
-    ui_step = 0.001;
-> = float2(RESHADE_DEPTH_INPUT_X_SCALE, RESHADE_DEPTH_INPUT_Y_SCALE);
-
-uniform int2 iUIOffset <
-    ui_category = "Preview settings";
-    ui_label = "Offset";
-    ui_label_ja_jp = "位置オフセット";
-    ui_type = "slider";
-    ui_tooltip =
-        "Best use 'Present type'->'Depth map' and enable 'Offset' in the options below to set the offset in pixels.\n"
-        "Use these values for:\nRESHADE_DEPTH_INPUT_X_PIXEL_OFFSET=<left value>\nRESHADE_DEPTH_INPUT_Y_PIXEL_OFFSET=<right value>";
-    ui_tooltip_ja_jp =
-        "深度バッファにレンダリングされた物体の形状が画面効果と重なり合っていない場合に変更して下さい。\n"
-        "この値は、ピクセル単位で指定します。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_INPUT_X_PIXEL_OFFSET=横の値\n"
-        "RESHADE_DEPTH_INPUT_Y_PIXEL_OFFSET=縦の値\n"
-        "定義値は次の通りです。横の値はX_PIXEL_OFFSET、縦の値はY_PIXEL_OFFSETに指定して下さい。\n"
-        "RESHADE_DEPTH_INPUT_X_PIXEL_OFFSET=0.0\n"
-        "RESHADE_DEPTH_INPUT_Y_PIXEL_OFFSET=0.0"
-#endif
-        ;
-    ui_min = -BUFFER_SCREEN_SIZE;
-    ui_max = BUFFER_SCREEN_SIZE;
-    ui_step = 1;
-> = int2(RESHADE_DEPTH_INPUT_X_PIXEL_OFFSET, RESHADE_DEPTH_INPUT_Y_PIXEL_OFFSET);
-
-uniform float fUIFarPlane <
-    ui_category = "Preview settings";
-    ui_label = "Far Plane";
-    ui_label_ja_jp = "遠点距離";
-    ui_type = "drag";
-    ui_tooltip = 
-        "RESHADE_DEPTH_LINEARIZATION_FAR_PLANE=<value>\n"
-        "Changing this value is not necessary in most cases.";
-    ui_tooltip_ja_jp =
-        "深度マップの色合いが距離感と合致しない、法線マップの表面が平面に見える、などの場合に変更して下さい。\n"
-        "遠点距離を1000に設定すると、ゲームの描画距離が1000メートルであると見なします。\n\n"
-        "このプレビュー画面はあくまでプレビューであり、ほとんどの場合、深度バッファは深度マップの色数より遥かに高い精度で表現されています。\n"
-        "例えば、10m前後の距離の形状が純粋な黒に見えるからという理由で値を変更しないで下さい。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_LINEARIZATION_FAR_PLANE=値\n"
-        "定義値は次の通りです。\n"
-        "RESHADE_DEPTH_LINEARIZATION_FAR_PLANE=1000.0"
-#endif
-        ;
-    ui_min = 0.0; ui_max = 1000.0;
-    ui_step = 0.1;
-> = RESHADE_DEPTH_LINEARIZATION_FAR_PLANE;
-
-uniform float fUIDepthMultiplier <
-    ui_category = "Preview settings";
-    ui_label = "Multiplier";
-    ui_label_ja_jp = "深度乗数";
-    ui_type = "drag";
-    ui_tooltip = "RESHADE_DEPTH_MULTIPLIER=<value>";
-    ui_tooltip_ja_jp =
-        "特定のエミュレータソフトウェアにおける深度バッファを修正するため、特別に追加された変数です。\n"
-        "この値は僅かな変更でも計算式を破壊するため、設定すべき値を知らない場合は変更しないで下さい。"
-#if !ADDON_ADJUST_DEPTH
-        "\n\n"
-        "定義名は次の通りです。文字は完全に一致する必要があり、半角大文字の英字とアンダーバーを用いなければなりません。\n"
-        "RESHADE_DEPTH_MULTIPLIER=値\n"
-        "定義値は次の通りです。\n"
-        "RESHADE_DEPTH_MULTIPLIER=1.0"
-#endif
-        ;
-    ui_min = 0.0; ui_max = 1000.0;
-    ui_step = 0.001;
-> = RESHADE_DEPTH_MULTIPLIER;
-
-float GetLinearizedDepth(float2 texcoord)
-{
-    if (!bUIUseLivePreview)
-    {
-        return ReShade::GetLinearizedDepth(texcoord);
-    }
-    else
-    {
-        if (iUIUpsideDown) // RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN
-            texcoord.y = 1.0 - texcoord.y;
-
-        texcoord.x /= fUIScale.x; // RESHADE_DEPTH_INPUT_X_SCALE
-        texcoord.y /= fUIScale.y; // RESHADE_DEPTH_INPUT_Y_SCALE
-        texcoord.x -= iUIOffset.x * BUFFER_RCP_WIDTH; // RESHADE_DEPTH_INPUT_X_PIXEL_OFFSET
-        texcoord.y += iUIOffset.y * BUFFER_RCP_HEIGHT; // RESHADE_DEPTH_INPUT_Y_PIXEL_OFFSET
-
-        float depth = tex2Dlod(ReShade::DepthBuffer, float4(texcoord, 0, 0)).x * fUIDepthMultiplier;
-
-        const float C = 0.01;
-        if (iUILogarithmic) // RESHADE_DEPTH_INPUT_IS_LOGARITHMIC
-            depth = (exp(depth * log(C + 1.0)) - 1.0) / C;
-
-        if (iUIReversed) // RESHADE_DEPTH_INPUT_IS_REVERSED
-            depth = 1.0 - depth;
-
-        const float N = 1.0;
-        depth /= fUIFarPlane - depth * (fUIFarPlane - N);
-
-        return depth;
-    }
-}
-
-float3 GetScreenSpaceNormal(float2 texcoord)
-{
-    float3 offset = float3(BUFFER_PIXEL_SIZE, 0.0);
-    float2 posCenter = texcoord.xy;
-    float2 posNorth  = posCenter - offset.zy;
-    float2 posEast   = posCenter + offset.xz;
-
-    float3 vertCenter = float3(posCenter - 0.5, 1) * GetLinearizedDepth(posCenter);
-    float3 vertNorth  = float3(posNorth - 0.5,  1) * GetLinearizedDepth(posNorth);
-    float3 vertEast   = float3(posEast - 0.5,   1) * GetLinearizedDepth(posEast);
-
-    return normalize(cross(vertCenter - vertNorth, vertCenter - vertEast)) * 0.5 + 0.5;
-}
-
-void PS_DisplayDepth(in float4 position : SV_Position, in float2 texcoord : TEXCOORD, out float3 color : SV_Target)
-{
-    float3 depth = GetLinearizedDepth(texcoord).xxx;
-    float3 normal = GetScreenSpaceNormal(texcoord);
-
-    // Ordered dithering
-#if 1
-    const float dither_bit = 8.0; // Number of bits per channel. Should be 8 for most monitors.
-    // Calculate grid position
-    float grid_position = frac(dot(texcoord, (BUFFER_SCREEN_SIZE * float2(1.0 / 16.0, 10.0 / 36.0)) + 0.25));
-    // Calculate how big the shift should be
-    float dither_shift = 0.25 * (1.0 / (pow(2, dither_bit) - 1.0));
-    // Shift the individual colors differently, thus making it even harder to see the dithering pattern
-    float3 dither_shift_RGB = float3(dither_shift, -dither_shift, dither_shift); // Subpixel dithering
-    // Modify shift acording to grid position.
-    dither_shift_RGB = lerp(2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position);
-    depth += dither_shift_RGB;
-#endif
-
-    color = depth;
-    if (iUIPresentType == 1)
-        color = normal;
-    if (iUIPresentType == 2)
-        color = lerp(normal, depth, step(BUFFER_WIDTH * 0.5, position.x));
-
-    if (bUIShowOffset)
-    {
-        float3 color_orig = tex2D(ReShade::BackBuffer, texcoord).rgb;
-
-        // Blend depth and back buffer color with 'overlay' so the offset is more noticeable
-        color = lerp(2 * color * color_orig, 1.0 - 2.0 * (1.0 - color) * (1.0 - color_orig), max(color.r, max(color.g, color.b)) < 0.5 ? 0.0 : 1.0);
-    }
-}
-
-technique DisplayDepth <
-    ui_tooltip =
-        "This shader helps you set the right preprocessor settings for depth input.\n"
-        "To set the settings click on 'Edit global preprocessor definitions' and set them there - not in this shader.\n"
-        "The settings will then take effect for all shaders, including this one.\n"  
-        "\n"
-        "By default calculated normals and depth are shown side by side.\n"
-        "Normals (on the left) should look smooth and the ground should be greenish when looking at the horizon.\n"
-        "Depth (on the right) should show close objects as dark and use gradually brighter shades the further away objects are.\n";
-    ui_tooltip_ja_jp =
-        "これは、深度バッファの入力をReShade側の計算式に合わせる調節をするための、設定作業の支援に特化した特殊な扱いのエフェクトです。\n"
-        "初期状態では「両方を表示」が選択されており、左に法線マップ、右に深度マップが表示されます。\n"
-        "\n"
-        "法線マップ(左側)は、形状を滑らかに表現します。正しい設定では、全体的に青緑風で、地平線を見たときに地面が緑を帯びた色になります。\n"
-        "深度マップ(右側)は、形状の遠近を白黒で表現します。正しい設定では、近くの形状ほど黒く、遠くの形状ほど白くなります。\n"
-        "\n"
-#if ADDON_ADJUST_DEPTH
-        "設定を完了するには、DisplayDepth.fxエフェクトの変数の一覧にある'設定に保存して反映する'ボタンをクリックして下さい。\n"
-#else
-        "設定を完了するには、エフェクト変数の編集画面にある'プリプロセッサの定義を編集'ボタンをクリックした後に開くダイアログに入力して下さい。\n"
-#endif
-        "すると、インストール先のゲームに対して共通の設定として保存され、他のプリセットでも正しく表示されるようになります。";
->
-
-{
-    pass
-    {
-        VertexShader = PostProcessVS;
-        PixelShader = PS_DisplayDepth;
-    }
-}
--- a/EXE/reshade-shaders/Shaders/DrawText.fxh
+++ b/EXE/reshade-shaders/Shaders/DrawText.fxh
@@ -1,228 +0,0 @@
-#ifndef _DRAWTEXT_H_
-#define _DRAWTEXT_H_
-
-#define _DRAWTEXT_GRID_X 14.0
-#define _DRAWTEXT_GRID_Y 7.0
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                                                                                   //
-//  DrawText.fxh by kingreic1992   ( update: Sep.28.2019 )                                           //
-//                                                                                                   //
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
-//                                                                                                   //
-//  Available functions:                                                                             //
-//      DrawText_String( offset, text size, xy ratio, input coord, string array, array size, output) //
-//          float2 offset       = top left corner of string, screen hight pixel unit.                //
-//          float  text size    = text size, screen hight pixel unit.                                //
-//          float  xy ratio     = xy ratio of text.                                                  //
-//          float2 input coord  = current texture coord.                                             //
-//          int    string array = string data in float2 array format, ex: "Demo Text"                //
-//              int String0[9] = { __D, __e, __m, __o, __Space, __T, __e, __x, __t};                 //
-//          int    string size  = size of the string array.                                          //
-//          float  output       = output.                                                            //
-//                                                                                                   //
-//      DrawText_Digit( offset, text size, xy ratio, input coord, precision after dot, data, output) //
-//          float2 offset       = same as DrawText_String.                                           //
-//          float  text size    = same as DrawText_String.                                           //
-//          float  xy ratio     = same as DrawText_String.                                           //
-//          float2 input coord  = same as DrawText_String.                                           //
-//          int    precision    = digits after dot.                                                  //
-//          float  data         = input float.                                                       //
-//          float  output       = output.                                                            //
-//                                                                                                   //
-//      float2 DrawText_Shift(offset, shift, text size, xy ratio)                                    //
-//          float2 offset       = same as DrawText_String.                                           //
-//          float2 shift        = shift line(y) and column.                                          //
-//          float text size     = same as DrawText_String.                                           //
-//          float xy ratio      = same as DrawText_String.                                           //
-//                                                                                                   //
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-//Sample Usage
-
-/*
-
-#include "DrawText.fxh"
-
-float4 main_fragment( float4 position : POSITION,
-                      float2 txcoord  : TEXCOORD) : COLOR {
-    float res = 0.0;
-
-    int line0[9]  = { __D, __e, __m, __o, __Space, __T, __e, __x, __t };   //Demo Text
-    int line1[15] = { __b, __y, __Space, __k, __i, __n, __g, __e, __r, __i, __c, __1, __9, __9, __2 }; //by kingeric1992
-    int line2[6]  = { __S, __i, __z, __e, __Colon, __Space }; // Size: %d.
-
-    DrawText_String(float2(100.0 , 100.0), 32, 1, txcoord,  line0, 9, res);
-    DrawText_String(float2(100.0 , 134.0), textSize, 1, txcoord,  line1, 15, res);
-    DrawText_String(DrawText_Shift(float2(100.0 , 134.0), int2(0, 1), textSize, 1), 18, 1, txcoord,  line2, 6, res);
-    DrawText_Digit(DrawText_Shift(DrawText_Shift(float2(100.0 , 134.0), int2(0, 1), textSize, 1), int2(8, 0), 18, 1),
-                    18, 1, txcoord,  0, textSize, res);
-    return res;
-}
-*/
-
-//Text display
-//Character indexing
-#define __Space       0 //  (space)
-#define __Exclam      1 //  !
-#define __Quote       2 //  "
-#define __Pound       3 //  #
-#define __Dollar      4 //  $
-#define __Percent     5 //  %
-#define __And         6 //  &
-#define __sQuote      7 //  '
-#define __rBrac_O     8 //  (
-#define __rBrac_C     9 //  )
-#define __Asterisk   10 //  *
-#define __Plus       11 //  +
-#define __Comma      12 //  ,
-#define __Minus      13 //  -
-
-#define __Dot        14 //  .
-#define __Slash      15 //  /
-#define __0          16 //  0
-#define __1          17 //  1
-#define __2          18 //  2
-#define __3          19 //  3
-#define __4          20 //  4
-#define __5          21 //  5
-#define __6          22 //  6
-#define __7          23 //  7
-#define __8          24 //  8
-#define __9          25 //  9
-#define __Colon      26 //  :
-#define __sColon     27 //  ;
-
-#define __Less       28 //  <
-#define __Equals     29 //  =
-#define __Greater    30 //  >
-#define __Question   31 //  ?
-#define __at         32 //  @
-#define __A          33 //  A
-#define __B          34 //  B
-#define __C          35 //  C
-#define __D          36 //  D
-#define __E          37 //  E
-#define __F          38 //  F
-#define __G          39 //  G
-#define __H          40 //  H
-#define __I          41 //  I
-
-#define __J          42 //  J
-#define __K          43 //  K
-#define __L          44 //  L
-#define __M          45 //  M
-#define __N          46 //  N
-#define __O          47 //  O
-#define __P          48 //  P
-#define __Q          49 //  Q
-#define __R          50 //  R
-#define __S          51 //  S
-#define __T          52 //  T
-#define __U          53 //  U
-#define __V          54 //  V
-#define __W          55 //  W
-
-#define __X          56 //  X
-#define __Y          57 //  Y
-#define __Z          58 //  Z
-#define __sBrac_O    59 //  [
-#define __Backslash  60 //  \..
-#define __sBrac_C    61 //  ]
-#define __Caret      62 //  ^
-#define __Underscore 63 //  _
-#define __Punc       64 //  `
-#define __a          65 //  a
-#define __b          66 //  b
-#define __c          67 //  c
-#define __d          68 //  d
-#define __e          69 //  e
-
-#define __f          70 //  f
-#define __g          71 //  g
-#define __h          72 //  h
-#define __i          73 //  i
-#define __j          74 //  j
-#define __k          75 //  k
-#define __l          76 //  l
-#define __m          77 //  m
-#define __n          78 //  n
-#define __o          79 //  o
-#define __p          80 //  p
-#define __q          81 //  q
-#define __r          82 //  r
-#define __s          83 //  s
-
-#define __t          84 //  t
-#define __u          85 //  u
-#define __v          86 //  v
-#define __w          87 //  w
-#define __x          88 //  x
-#define __y          89 //  y
-#define __z          90 //  z
-#define __cBrac_O    91 //  {
-#define __vBar       92 //  |
-#define __cBrac_C    93 //  }
-#define __Tilde      94 //  ~
-#define __tridot     95 // (...)
-#define __empty0     96 // (null)
-#define __empty1     97 // (null)
-//Character indexing ends
-
-texture Texttex < source = "FontAtlas.png"; > {
-    Width  = 512;
-    Height = 512;
-};
-
-sampler samplerText {
-    Texture = Texttex;
-};
-
-//accomodate for undef array size.
-#define DrawText_String(  pos, size, ratio, tex, array, arrSize, output ) \
-    {   float  text = 0.0; \
-        float2 uv = (tex * float2(BUFFER_WIDTH, BUFFER_HEIGHT) - pos) / size; \
-        uv.y      = saturate(uv.y); \
-        uv.x     *= ratio * 2.0; \
-        float  id = array[int(trunc(uv.x))]; \
-        if(uv.x  <= arrSize && uv.x >= 0.0) \
-            text  = tex2D(samplerText, (frac(uv) + float2( id % 14.0, trunc(id / 14.0))) \
-            / float2( _DRAWTEXT_GRID_X, _DRAWTEXT_GRID_Y) ).x; \
-        output += text;  }
-
-float2 DrawText_Shift( float2 pos, int2 shift, float size, float ratio ) {
-    return pos + size * shift * float2(0.5, 1.0) / ratio;
-}
-
-void DrawText_Digit( float2 pos, float size, float ratio, float2 tex, int digit, float data, inout float res) {
-    int digits[13] = {
-        __0, __1, __2, __3, __4, __5, __6, __7, __8, __9, __Minus, __Space, __Dot
-    };
-
-    float2 uv = (tex * float2(BUFFER_WIDTH, BUFFER_HEIGHT) - pos) / size;
-    uv.y      = saturate(uv.y);
-    uv.x     *= ratio * 2.0;
-
-    float  t  = abs(data);
-    int radix = floor(t)? ceil(log2(t)/3.32192809):0;
-
-    //early exit:
-    if(uv.x > digit+1 || -uv.x > radix+1) return;
-
-    float index = t;
-    if(floor(uv.x) > 0)
-        for(int i = ceil(-uv.x); i<0; i++) index *= 10.;
-    else
-        for(int i = ceil(uv.x); i<0; i++) index /= 10.;
-
-    index = (uv.x >= -radix-!radix)? index%10 : (10+step(0, data)); //adding sign
-    index = (uv.x > 0 && uv.x < 1)? 12:index; //adding dot
-    index = digits[(uint)index];
-
-    res  += tex2D(samplerText, (frac(uv) + float2( index % 14.0, trunc(index / 14.0))) /
-                float2( _DRAWTEXT_GRID_X, _DRAWTEXT_GRID_Y)).x;
-}
-
-#endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
D4rkl1ght3r	a1ecaa00e7	Add Dummy NPC	2025-05-09 20:46:30 +02:00
D4rkl1ght3r	b191862aeb	Add ast_interior_base	2025-05-07 23:08:19 +02:00