diff options
| -rwxr-xr-x | Config.cs | 2 | ||||
| -rwxr-xr-x | Plugin.cs | 1374 |
2 files changed, 805 insertions, 571 deletions
@@ -88,7 +88,7 @@ namespace WorldTuningTool public struct PatchConfig
{
- public bool TripleShadowResolution { get; set; } = false;
+ public int ShadowResolutionMultiplier { get; set; } = 1;
public bool FullResolutionVolumeBlur { get; set; } = false;
public bool HigherThanHighestVolumeRendering { get; set; } = false;
public bool DisableLODLimits { get; set; } = false;
@@ -16,26 +16,26 @@ using SharpPluginLoader.Core.Memory; using SharpPluginLoader.Core.Entities;
// @TODO:
+// - Shadow resolution param.
+// - Hair clipping while looking down.
+// - Optimized update logic.
+// - Only update non-override values when ui is shown.
+// - Map sky params.
+// - Lights refactor.
// - Descriptions.
// - float format.
// - Min/Max.
-// - Lights refactor.
// - Lights iterop.
// - SPL Patches:
// - No crash on empty config.
// - Style change
-// - Optimized update logic.
-// - Only update non-override values when ui is shown.
-// - Tune parameter settings (step, min/max, format, etc).
-// - PerFrame.
// - Create light hook.
-// - Try to understand shadow distance vs backforward distance vs bias.
// - Shadow distance retuning.
// - Weird shadow area in Rotten Vale.
// - Hotload nukes config?
//
// Known issues to think about:
-// - Volume rendering can look really bad with multiple sources(?) (Guding lands vines).
+// - Volume rendering can look really bad with multiple overlapped sources(?) (Guding lands vines).
// - Screen space reflections often look bad.
// - Facial contact shadows incorrectly move based on camera position.
@@ -72,18 +72,41 @@ namespace WorldTuningTool ((int)MathF.Round(v.W * 255.0f) << 24));
}
+ private static string Vector3ToString(Vector3 v)
+ {
+ return $"{v.X},{v.Y},{v.Z}";
+ }
+
+ private static Vector3 Vector3FromString(string s)
+ {
+ if (String.IsNullOrEmpty(s))
+ {
+ throw new FormatException();
+ }
+ string[] vs = s.Split(',').Select(v => v.Trim()).ToArray();
+ if (vs.Length != 3)
+ {
+ throw new FormatException();
+ }
+ return new Vector3(
+ Convert.ToSingle(vs[0]),
+ Convert.ToSingle(vs[1]),
+ Convert.ToSingle(vs[2]));
+ }
+
public enum ParameterType
{
BOOL,
- BYTE,
FLAG,
+ BYTE,
INT,
HEX,
COLOR,
FLOAT,
VECTOR3,
VECTOR4,
- PATCH_FLOAT
+ PATCH_FLOAT,
+ SHADOW_RESOLUTION
}
static IPlugin? Instance = null;
@@ -95,6 +118,8 @@ namespace WorldTuningTool private const float defaultParamWidth = 0.215f;
+ private static bool ignoreMinMax = false;
+
private const Stage globalStage = Stage.InfinityOfNothingHandler;
private static Stage currentStage => Area.CurrentStage;
private static Stage selectedStage = globalStage;
@@ -102,7 +127,7 @@ namespace WorldTuningTool private static List<Override>? maybeGetStageOverrides(Config config)
{
- return currentStage != 0 ? config.Overrides[currentStage] : null;
+ return (currentStage != 0) ? config.Overrides[currentStage] : null;
}
private static string selectedPreset = "";
@@ -180,8 +205,10 @@ namespace WorldTuningTool private string hiddenName;
public ParameterType Type;
public bool PerFrame;
+ public bool NoOverride;
private nint offset;
+ private int mask;
private nint lastAddr = 0x0;
private bool overrideValue = false;
private bool overrideForStage = false;
@@ -189,28 +216,28 @@ namespace WorldTuningTool protected float stepf, minf, maxf;
protected int step, min, max;
- protected int mask;
private Vector4 valueV = default;
private int valueInt = 0;
- private Vector4 oValueV;
+ private Vector4 oValueV; // Original value.
private int oValueInt;
private bool pendingUpdate = true;
private bool queuedOverride = false;
private bool queuedValue = false;
- private Vector4 qValueV;
+ private Vector4 qValueV; // Queued value.
private int qValueInt;
private bool bValue = false;
- private Vector4 bValueV;
+ private Vector4 bValueV; // B value in A/B.
private int bValueInt;
- public Parameter(string name, nint offset, ParameterType type, bool perFrame)
+ public Parameter(string name, nint offset, int mask, ParameterType type, bool perFrame, bool noOverride)
{
Name = name;
hiddenName = "##" + Name;
this.offset = offset;
+ this.mask = mask;
Type = type;
if (Type == ParameterType.PATCH_FLOAT)
{
@@ -218,6 +245,7 @@ namespace WorldTuningTool pendingUpdate = false;
}
PerFrame = perFrame;
+ NoOverride = noOverride;
}
public bool PendingUpdate()
@@ -245,13 +273,13 @@ namespace WorldTuningTool MemoryUtil.GetRef<byte>(lastAddr + offset) = (byte)valueInt;
break;
case ParameterType.FLAG:
- if (valueInt == 0)
+ if (valueInt != 0)
{
- MemoryUtil.GetRef<int>(lastAddr + offset) &= ~mask;
+ MemoryUtil.GetRef<int>(lastAddr + offset) |= mask;
}
else
{
- MemoryUtil.GetRef<int>(lastAddr + offset) |= mask;
+ MemoryUtil.GetRef<int>(lastAddr + offset) &= ~mask;
}
break;
case ParameterType.INT:
@@ -262,15 +290,15 @@ namespace WorldTuningTool case ParameterType.FLOAT:
MemoryUtil.GetRef<float>(lastAddr + offset) = valueV.X;
break;
+ case ParameterType.PATCH_FLOAT:
+ new Patch(offset, BitConverter.GetBytes(valueV.X)).Enable();
+ break;
case ParameterType.VECTOR3:
MemoryUtil.GetRef<Vector3>(lastAddr + offset) = new Vector3(valueV.X, valueV.Y, valueV.Z);
break;
case ParameterType.VECTOR4:
MemoryUtil.GetRef<Vector4>(lastAddr + offset) = valueV;
break;
- case ParameterType.PATCH_FLOAT:
- new Patch(offset, BitConverter.GetBytes(valueV.X)).Enable();
- break;
}
}
@@ -375,16 +403,16 @@ namespace WorldTuningTool return;
}
- // Trying to track changes to the original value is a
- // "best effort" approach because it can't work if the in-game
- // value and the override value are the same.
+ // Trying to track changes to the original value is a "best effort"
+ // approach because it can't work if the in-game value is updated
+ // to the same value as a current override.
switch (Type)
{
case ParameterType.BOOL:
case ParameterType.BYTE:
{
ref byte b1 = ref MemoryUtil.GetRef<byte>(baseObject + offset);
- if (b1 != (byte)valueInt && b1 != (byte)oValueInt)
+ if (b1 != (byte)valueInt)
{
oValueInt = (byte)b1;
}
@@ -401,25 +429,25 @@ namespace WorldTuningTool case ParameterType.FLAG:
{
ref int i1 = ref MemoryUtil.GetRef<int>(baseObject + offset);
- int f1 = i1 & mask;
- if (f1 != valueInt && f1 != oValueInt)
+ int b1 = ByteFlag((i1 & mask) == mask);
+ if (b1 != valueInt)
{
- oValueInt = f1;
+ oValueInt = b1;
}
if (overrideValue)
{
- if (f1 == 0)
+ if (valueInt != 0)
{
- i1 &= ~mask;
+ i1 |= mask;
}
else
{
- i1 |= mask;
+ i1 &= ~mask;
}
}
else
{
- valueInt = f1;
+ valueInt = b1;
}
break;
}
@@ -428,7 +456,7 @@ namespace WorldTuningTool case ParameterType.COLOR:
{
ref int i1 = ref MemoryUtil.GetRef<int>(baseObject + offset);
- if (i1 != valueInt && i1 != oValueInt)
+ if (i1 != valueInt)
{
oValueInt = i1;
}
@@ -445,7 +473,7 @@ namespace WorldTuningTool case ParameterType.FLOAT:
{
ref float f1 = ref MemoryUtil.GetRef<float>(baseObject + offset);
- if (f1 != valueV.X && f1 != oValueV.X)
+ if (f1 != valueV.X)
{
oValueV.X = f1;
}
@@ -463,11 +491,9 @@ namespace WorldTuningTool {
ref Vector3 v3 = ref MemoryUtil.GetRef<Vector3>(baseObject + offset);
Vector3 valueV3 = new Vector3(valueV.X, valueV.Y, valueV.Z);
- if (v3 != valueV3 && v3 != valueV3)
+ if (v3 != valueV3)
{
- oValueV.X = v3.X;
- oValueV.Y = v3.Y;
- oValueV.Z = v3.Z;
+ oValueV = new Vector4(v3.X, v3.Y, v3.Z, 0.0f);
}
if (overrideValue)
{
@@ -475,16 +501,14 @@ namespace WorldTuningTool }
else
{
- valueV.X = v3.X;
- valueV.Y = v3.Y;
- valueV.Z = v3.Z;
+ valueV = new Vector4(v3.X, v3.Y, v3.Z, 0.0f);
}
break;
}
case ParameterType.VECTOR4:
{
ref Vector4 v4 = ref MemoryUtil.GetRef<Vector4>(baseObject + offset);
- if (v4 != valueV && v4 != oValueV)
+ if (v4 != valueV)
{
oValueV = v4;
}
@@ -529,8 +553,9 @@ namespace WorldTuningTool switch (Type)
{
case ParameterType.BOOL:
+ case ParameterType.FLAG:
{
- bool b = i1 == 0x1;
+ bool b = i1 != 0;
if (ImGui.Checkbox(label, ref b))
{
i1 = ByteFlag(b);
@@ -544,7 +569,6 @@ namespace WorldTuningTool ImGuiInputTextFlags flags = ImGuiInputTextFlags.EnterReturnsTrue;
if (ImGui.InputInt(label, ref i1, step, 0, flags))
{
- i1 = Math.Clamp(i1, min, max);
valueChanged = true;
}
break;
@@ -560,20 +584,6 @@ namespace WorldTuningTool }
if (ImGui.InputInt(label, ref i1, step, 0, flags))
{
- if (max > min)
- {
- i1 = Math.Clamp(i1, min, max);
- }
- valueChanged = true;
- }
- break;
- }
- case ParameterType.FLAG:
- {
- bool b = i1 == mask;
- if (ImGui.Checkbox(label, ref b))
- {
- i1 = b ? mask : 0;
valueChanged = true;
}
break;
@@ -590,13 +600,13 @@ namespace WorldTuningTool break;
}
case ParameterType.FLOAT:
+ case ParameterType.PATCH_FLOAT:
{
ImGui.SetNextItemWidth(width * defaultParamWidth);
float f1 = v4.X;
- // Ideally we want ImGuiInputTextFlags.EnterReturnsTrue behavior here.
- if (ImGui.DragFloat(label, ref f1, stepf, minf, maxf, "%.5f", ImGuiSliderFlags.NoRoundToFormat))
+ if (ImGui.DragFloat(label, ref f1, stepf, 0.0f, 0.0f, "%.6f", ImGuiSliderFlags.NoRoundToFormat))
{
- v4.X = f1;
+ v4 = new Vector4(f1, 0.0f, 0.0f, 0.0f);
valueChanged = true;
}
break;
@@ -605,11 +615,9 @@ namespace WorldTuningTool {
ImGui.SetNextItemWidth(width * defaultParamWidth * 3.0f);
Vector3 v3 = new Vector3(v4.X, v4.Y, v4.Z);
- if (ImGui.DragFloat3(label, ref v3, stepf, minf, maxf, "%.4f", ImGuiSliderFlags.NoRoundToFormat))
+ if (ImGui.DragFloat3(label, ref v3, stepf, 0.0f, 0.0f, "%.4f", ImGuiSliderFlags.NoRoundToFormat))
{
- v4.X = v3.X;
- v4.Y = v3.Y;
- v4.Z = v3.Z;
+ v4 = new Vector4(v3.X, v3.Y, v3.Z, 0.0f);
valueChanged = true;
}
break;
@@ -617,22 +625,34 @@ namespace WorldTuningTool case ParameterType.VECTOR4:
{
ImGui.SetNextItemWidth(width * defaultParamWidth * 4.0f);
- if (ImGui.DragFloat4(label, ref v4, stepf, minf, maxf, "%.4f", ImGuiSliderFlags.NoRoundToFormat))
+ if (ImGui.DragFloat4(label, ref v4, stepf, 0.0f, 0.0f, "%.4f", ImGuiSliderFlags.NoRoundToFormat))
{
valueChanged = true;
}
break;
}
- case ParameterType.PATCH_FLOAT:
+ }
+ if (valueChanged && !ignoreMinMax)
+ {
+ switch (Type)
{
- ImGui.SetNextItemWidth(width * defaultParamWidth);
- float f1 = v4.X;
- if (ImGui.InputFloat(label, ref f1, 0.0f, 0.0f, "%.4f", ImGuiInputTextFlags.EnterReturnsTrue))
- {
- v4.X = f1;
- valueChanged = true;
- }
- break;
+ case ParameterType.BOOL:
+ case ParameterType.FLAG:
+ case ParameterType.BYTE:
+ case ParameterType.INT:
+ case ParameterType.HEX:
+ i1 = Math.Clamp(i1, min, max);
+ break;
+ case ParameterType.FLOAT:
+ case ParameterType.PATCH_FLOAT:
+ case ParameterType.VECTOR3:
+ case ParameterType.VECTOR4:
+ v4 = new Vector4(
+ Math.Clamp(v4.X, minf, maxf),
+ Math.Clamp(v4.Y, minf, maxf),
+ Math.Clamp(v4.Z, minf, maxf),
+ Math.Clamp(v4.W, minf, maxf));
+ break;
}
}
return valueChanged;
@@ -644,24 +664,15 @@ namespace WorldTuningTool switch (Type)
{
case ParameterType.BOOL:
- {
- ImGui.Text($"({name}: {i1 == 0x1})");
+ case ParameterType.FLAG:
+ ImGui.Text($"({name}: {i1 != 0})");
break;
- }
case ParameterType.BYTE:
- {
ImGui.Text($"({name}: {i1})");
break;
- }
- case ParameterType.FLAG:
- {
- ImGui.Text($"({name}: {i1 != 0})");
- break;
- }
case ParameterType.INT:
case ParameterType.HEX:
case ParameterType.COLOR:
- {
if (Type == ParameterType.INT)
{
ImGui.Text($"({name}: {i1})");
@@ -671,23 +682,16 @@ namespace WorldTuningTool ImGui.Text($"({name}: {i1:X})");
}
break;
- }
case ParameterType.FLOAT:
case ParameterType.PATCH_FLOAT:
- {
ImGui.Text($"({name}: {v4.X:0.00000})");
break;
- }
case ParameterType.VECTOR3:
- {
ImGui.Text($"({name}: {v4.X:0.0000}, {v4.Y:0.0000}, {v4.Z:0.0000})");
break;
- }
case ParameterType.VECTOR4:
- {
ImGui.Text($"({name}: {v4.X:0.0000}, {v4.Y:0.0000}, {v4.Z:0.0000}, {v4.W:0.00000})");
break;
- }
}
ImGui.PopStyleVar();
}
@@ -700,7 +704,11 @@ namespace WorldTuningTool public void Draw(ref Vector4 v4, ref int i1, float width, bool assumeOverride)
{
ImGui.PushID(Name);
- if (!assumeOverride)
+ if (NoOverride)
+ {
+ ImGui.SetCursorPos(ImGui.GetCursorPos() + new Vector2(40.0f, 0.0f));
+ }
+ else if (!assumeOverride)
{
if (overrideForStage)
{
@@ -851,33 +859,70 @@ namespace WorldTuningTool public class Parameter<T> : Parameter where T : unmanaged
{
- // @TODO: Defaults are ill-defined. Should have no defaults except for type sizes (byte).
- public Parameter(string name, nint offset, ParameterType type, bool perFrame, T? step = null, T? min = null, T? max = null) : base(name, offset, type, perFrame)
+ public Parameter(string name, nint offset, int mask, ParameterType type, T? min, T? max, T? step, bool perFrame, bool noOverride) : base(name, offset, mask, type, perFrame, noOverride)
{
if (typeof(T) == typeof(float))
{
- this.stepf = step != null ? Convert.ToSingle(step) : 0.01f;
- this.minf = min != null ? Convert.ToSingle(min) : -Single.MaxValue;
- this.maxf = max != null ? Convert.ToSingle(max) : Single.MaxValue;
+ this.stepf = (step != null) ? Convert.ToSingle(step) : 0.1f;
+ this.minf = (min != null) ? Convert.ToSingle(min) : -Single.MaxValue;
+ this.maxf = (max != null) ? Convert.ToSingle(max) : Single.MaxValue;
}
- else if (typeof(T) == typeof(int) || typeof(T) == typeof(byte))
+ else if (typeof(T) == typeof(int) || typeof(T) == typeof(byte) || typeof(T) == typeof(bool))
{
- this.step = step != null ? Convert.ToInt32(step) : 0;
- mask = this.step;
+ this.step = (step != null) ? Convert.ToInt32(step) : 0;
if (typeof(T) == typeof(int))
{
- this.min = min != null ? Convert.ToInt32(min) : Int32.MinValue;
- this.max = max != null ? Convert.ToInt32(max) : Int32.MaxValue;
+ this.min = (min != null) ? Convert.ToInt32(min) : Int32.MinValue;
+ this.max = (max != null) ? Convert.ToInt32(max) : Int32.MaxValue;
}
else if (typeof(T) == typeof(byte))
{
- this.min = min != null ? Convert.ToInt32(min) : 0x0;
- this.max = max != null ? Convert.ToInt32(max) : 0xFF;
+ this.min = (min != null) ? Convert.ToInt32(min) : 0x0;
+ this.max = (max != null) ? Convert.ToInt32(max) : 0xFF;
+ }
+ else if (typeof(T) == typeof(bool))
+ {
+ this.min = 0;
+ this.max = 1;
}
}
}
}
+ public static (float?, float?, float?) pStep(float step) { return (null, null, step); }
+ public static (float?, float?, float?) pMin(float min) { return (min, null, null); }
+ public static (float?, float?, float?) pMax(float max) { return (null, max, null); }
+ public static (float?, float?, float?) pMinStep(float min, float step) { return (min, null, step); }
+ public static (float?, float?, float?) pMaxStep(float max, float step) { return (null, max, step); }
+ public static (float?, float?, float?) pMinMaxStep(float min, float max, float step) { return (min, max, step); }
+ public static (int?, int?, int?) pStep(int step) { return (null, null, step); }
+ public static (int?, int?, int?) pMin(int min) { return (min, null, null); }
+ public static (int?, int?, int?) pMax(int max) { return (null, max, null); }
+ public static (int?, int?, int?) pMinStep(int min, int step) { return (min, null, step); }
+ public static (int?, int?, int?) pMaxStep(int max, int step) { return (null, max, step); }
+ public static (int?, int?, int?) pMinMaxStep(int min, int max, int step) { return (min, max, step); }
+ public static (byte?, byte?, byte?) pStep(byte step) { return (null, null, step); }
+
+ public static Parameter<T> newParameter<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
+ {
+ return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, false, false);
+ }
+
+ public static Parameter<T> newFrameParameter<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
+ {
+ return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, true, false);
+ }
+
+ public static Parameter<T> newParameterView<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
+ {
+ return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, false, true);
+ }
+
+ public static Parameter<T> newFlag<T>(string name, nint offset, ParameterType type, int mask) where T : unmanaged
+ {
+ return new Parameter<T>(name, offset, mask, type, null, null, null, false, false);
+ }
+
private static Parameter? getParameterByName(string name)
{
foreach (Parameter param in allParameters)
@@ -895,14 +940,8 @@ namespace WorldTuningTool public Parameter? Param = null;
public string Name
{
- get
- {
- return Param != null ? Param.Name : "";
- }
- set
- {
- Param = getParameterByName(value);
- }
+ get => (Param != null) ? Param.Name : "";
+ set => Param = getParameterByName(value);
}
public string Value
{
@@ -913,26 +952,23 @@ namespace WorldTuningTool switch (Param.Type)
{
case ParameterType.BOOL:
- return (valueInt == 0x1).ToString();
- case ParameterType.BYTE:
- return valueInt.ToString();
case ParameterType.FLAG:
- return (valueInt != 0).ToString();
+ return (sValueInt != 0).ToString();
+ case ParameterType.BYTE:
+ return sValueInt.ToString();
case ParameterType.INT:
- return valueInt.ToString();
+ return sValueInt.ToString();
case ParameterType.HEX:
case ParameterType.COLOR:
- return valueInt.ToString("X8");
+ return sValueInt.ToString("X8");
case ParameterType.FLOAT:
case ParameterType.PATCH_FLOAT:
- return valueV.X.ToString();
+ return sValueV.X.ToString();
case ParameterType.VECTOR3:
- {
- Vector3 valueV3 = new Vector3(valueV.X, valueV.Y, valueV.Z);
- return valueV3.ToString();
- }
+ Vector3 sValueV3 = new Vector3(sValueV.X, sValueV.Y, sValueV.Z);
+ return Vector3ToString(sValueV3);
case ParameterType.VECTOR4:
- return valueV.ToString();
+ break;
}
}
return "";
@@ -945,14 +981,12 @@ namespace WorldTuningTool switch (Param.Type)
{
case ParameterType.BOOL:
+ case ParameterType.FLAG:
valueInt = ByteFlag(Convert.ToBoolean(value));
break;
case ParameterType.BYTE:
valueInt = Convert.ToInt32(value);
break;
- case ParameterType.FLAG:
- valueInt = Convert.ToBoolean(value) ? Param.GetMask() : 0;
- break;
case ParameterType.INT:
valueInt = Convert.ToInt32(value);
break;
@@ -965,25 +999,29 @@ namespace WorldTuningTool valueV.X = Convert.ToSingle(value);
break;
case ParameterType.VECTOR3:
+ Vector3 valueV3 = Vector3FromString(value);
+ valueV = new Vector4(valueV3.X, valueV3.Y, valueV3.Z, 0.0f);
break;
case ParameterType.VECTOR4:
break;
}
- sValueV = valueV;
- sValueInt = valueInt;
}
catch (FormatException)
{
+ Log.Warn($"Failed to parse value of '{Name}' override.");
}
catch (OverflowException)
{
+ Log.Warn($"Value of '{Name}' override too large.");
}
+ Save();
}
}
+ // This could different from the Parameter's valueV/valueInt if this override is unset.
private Vector4 valueV = default;
private int valueInt = 0;
private bool isSet = false;
- private Vector4 sValueV = default;
+ private Vector4 sValueV = default; // Saved value.
private int sValueInt = 0;
public Override() { }
@@ -1034,12 +1072,13 @@ namespace WorldTuningTool ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true);
}
ImGui.PushItemWidth(width * 0.475f);
- if (ImGui.BeginCombo("##Parameters", Param != null ? Param.Name : ""))
+ if (ImGui.BeginCombo("##Parameters", (Param != null) ? Param.Name : ""))
{
if (currentOverrides != null)
{
foreach (Parameter iterParam in allParameters)
{
+ if (iterParam.NoOverride) continue;
if (overridesContainsParam(currentOverrides, iterParam)) continue;
bool isSelected = Param == iterParam;
if (ImGui.Selectable(iterParam.Name, isSelected))
@@ -1087,9 +1126,12 @@ namespace WorldTuningTool if (Param != null)
{
ImGui.SameLine();
- if (Param.DrawValue(ref valueV, ref valueInt, width, false) && isSet)
+ if (Param.DrawValue(ref valueV, ref valueInt, width, false))
{
- Param.OverrideValue(valueV, valueInt);
+ if (isSet)
+ {
+ Param.OverrideValue(valueV, valueInt);
+ }
}
(Vector4 v4, int i1) = Param.GetValue();
bool valueDiffers = (v4, i1) != (valueV, valueInt);
@@ -1135,125 +1177,231 @@ namespace WorldTuningTool }
}
+ // Start of Parameter Definitions.
+
private delegate void OnAreaChange(nint unknownPtr);
private Hook<OnAreaChange>? onAreaChange;
private static MtObject? sMhScene = null;
- private delegate void UpdateSSAOParams(nint sceneObjectInternal, nint stackOffset);
+
+ private static Parameter hqMode = newParameter<bool>("HQ Mode", 0xE9A3, ParameterType.BOOL);
+
+ private static Parameter[] lodParameters = {
+ newParameter<float>("LOD Bias 1", 0x21C, ParameterType.FLOAT),
+ newParameter<float>("LOD Bias 2", 0x220, ParameterType.FLOAT),
+ newParameter<float>("LOD Caster Bias", 0x1E4, ParameterType.FLOAT),
+ // If platform is PS4/Xbox/PC it appears [2] is PC.
+ newParameter<float>("LOD Length Platform Bias[2]", 0x22C + (4 * 2), ParameterType.FLOAT),
+ newParameter<float>("LOD Pixel Size Platform Bias[2]", 0x244 + (4 * 2), ParameterType.FLOAT),
+ newParameter<int>("LOD Limit", 0xE898, ParameterType.INT, pStep(1)),
+ newParameter<float>("LOD Passthrough Culling Rate", 0x1F0, ParameterType.FLOAT),
+ newParameter<float>("LOD Far Culling Fade Length Max", 0x20C, ParameterType.FLOAT),
+ newParameter<float>("LOD Far Culling Fade Pixel Max", 0x210, ParameterType.FLOAT),
+ newParameter<float>("Speed Tree LOD Billboard Fade Range", 0x214, ParameterType.FLOAT),
+ newParameter<float>("LOD Culling Length Bias", 0x224, ParameterType.FLOAT),
+ newParameter<float>("LOD Culling Pixel Bias", 0x228, ParameterType.FLOAT)
+ };
+
+ private static Parameter[] snowParameters = {
+ newParameter<float>("Snow Field 4 Global LOD Param", 0x5718, ParameterType.FLOAT)
+ };
+
+ private static Parameter[] passthroughParameters = {
+ newParameter<bool>("Passthrough Active", 0xE9A0, ParameterType.BOOL),
+ newParameter<bool>("Passthrough Culling Active", 0xE9A2, ParameterType.BOOL),
+ newParameterView<float>("Passthrough Near", 0xE940, ParameterType.FLOAT),
+ newParameterView<float>("Passthrough Far", 0xE944, ParameterType.FLOAT),
+ newParameter<float>("Passthrough Near Alpha", 0xE948, ParameterType.FLOAT),
+ newParameter<float>("Passthrough Far Alpha", 0xE94C, ParameterType.FLOAT),
+ newParameter<float>("Passthrough Correct", 0xE950, ParameterType.FLOAT)
+ };
+
+ private static Parameter[] shadowCascadeParameters = {
+ newParameter<bool>("Primary Shadow HQ", 0xE5C0, ParameterType.BOOL),
+ newParameter<bool>("Primary Shadow HQ (HQ)", 0xE5C2, ParameterType.BOOL),
+ newParameter<float>("Shadow Cascade 2Way Bias (HQ)", 0x58, ParameterType.FLOAT),
+ newParameter<int>("Primary Shadow Sample Num (HQ)", 0xE5CC, ParameterType.INT, pStep(1))
+ };
+
+ private delegate void EvalSceneParams(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3);
+ private Hook<EvalSceneParams>? evalSceneParams;
+ private static Parameter[] broadAreaShadowParameters = {
+ newParameter<bool>("Broad Area Shadow Enable", 0x5534, ParameterType.BOOL),
+ newParameter<float>("Broad Area Shadow Center", 0x5540 + 0x40, ParameterType.VECTOR3),
+ newParameter<float>("Broad Area Shadow Range", 0x5560 + 0x40, ParameterType.VECTOR3),
+ newParameter<float>("Broad Area Shadow Direction", 0x5550 + 0x40, ParameterType.VECTOR3, pStep(0.001f)),
+ newParameter<float>("Broad Area Shadow Max LOD Level", 0x5524, ParameterType.FLOAT),
+ newParameter<float>("Broad Area Shadow Culling Size", 0x5528, ParameterType.FLOAT),
+ newParameter<int>("Broad Area Shadow Precision", 0x5518, ParameterType.INT, pMinMaxStep(0, 2, 1))
+ };
+
+ private static Parameter[] contactShadowParameters = {
+ newParameter<float>("Fake Light Intensity", 0xEC40, ParameterType.FLOAT),
+ // MonsterHunterWorld.exe+1B18711 - mov [rbx+0000EC44],3F800000 (Other unknown reference).
+ newParameter<float>("Fake Light Intensity (Gameplay)", new IntPtr(0x141B1A19F) + 0x6, ParameterType.PATCH_FLOAT),
+ newParameter<float>("Fake Light Blend", new IntPtr(0x141CDE0CE) + 0x6, ParameterType.PATCH_FLOAT),
+ newParameter<bool>("Force Disable Contact Shadows", 0xB4ED, ParameterType.BOOL),
+ newParameter<bool>("Facial Contact Shadows Enabled", 0xB4EE, ParameterType.BOOL),
+ newParameter<bool>("Facial Contact Shadows Enable Noise", 0xB501, ParameterType.BOOL),
+ newParameter<float>("Contact Shadow Accept Maximum Length", 0xB4F8, ParameterType.FLOAT),
+ newParameter<float>("Contact Shadow Accept Minimum Length", 0xB4FC, ParameterType.FLOAT)
+ };
+
+ private delegate void UpdateCapsuleAOParams(nint sceneObjectInternal);
+ private Hook<UpdateCapsuleAOParams>? updateCapsuleAoParams;
+ private static Parameter[] capsuleLightParameters = {
+ newParameter<bool>("Force Disable Capsule AO", 0xB503, ParameterType.BOOL),
+ newParameter<bool>("Capsule AO Enabled", 0xB502, ParameterType.BOOL),
+ newParameter<float>("Capsule AO Distance Fall Coef", 0xE5B4, ParameterType.FLOAT, pStep(0.0001f)),
+ newParameter<int>("Capsule AO Light Channel Mask", 0xE5BC, ParameterType.INT, pStep(1)),
+ newParameter<float>("Capsule Light Dir XZY", 0xE548, ParameterType.VECTOR3),
+ newParameterView<float>("Capsule Light W Dir", 0xE560, ParameterType.VECTOR3),
+ newParameter<float>("Capsule Light Angle", 0xE5B0, ParameterType.FLOAT),
+ newParameter<float>("Capsule AO Intensity", 0xE5B8, ParameterType.FLOAT)
+ };
+
+ private delegate void UpdateSSAOParams(nint stackOffset);
private Hook<UpdateSSAOParams>? updateSSAOParams;
private static Parameter[] ssaoParameters = {
- new Parameter<float>("SSAO Depth Bias", 0xB4B0, ParameterType.FLOAT, false, 0.00001f),
- new Parameter<float>("SSAO Sloped Depth Bias", 0xB4B4, ParameterType.FLOAT, false, 0.00001f),
- new Parameter<float>("SSAO Max Depth Bias", 0xB4B8, ParameterType.FLOAT, false, 0.00001f),
- new Parameter<float>("SSAO Dispersion", 0xB4BC, ParameterType.FLOAT, false),
- new Parameter<float>("SSAO Effect", 0xB430, ParameterType.FLOAT, false),
- new Parameter<float>("SSAO Effect GI", 0xB434, ParameterType.FLOAT, false),
- new Parameter<float>("SSAO Depth Difference", 0xB4C0, ParameterType.FLOAT, false),
- new Parameter<float>("SSAO Samples Per Pixel", 0xB4C4, ParameterType.FLOAT, false),
- new Parameter<int>("SSAO Max Sample Num", 0xB4C8, ParameterType.INT, false),
- new Parameter<int>("SSAO Max Sample Num (HQ)", 0xB4D0, ParameterType.INT, false),
- new Parameter<float>("SSAO Radius", 0xB4D4, ParameterType.FLOAT, false),
- new Parameter<float>("SSAO Bias", 0xB4D8, ParameterType.FLOAT, false),
- new Parameter<float>("SSAO Intensity", 0xB4E0, ParameterType.FLOAT, false),
- new Parameter<byte>("SSAO Use HiZ", 0xB4E5, ParameterType.BOOL, false),
- new Parameter<float>("SSAO Edge Atten Rate", 0xB4DC, ParameterType.FLOAT, false)
+ newParameter<float>("SSAO Depth Bias", 0xB4B0, ParameterType.FLOAT, pStep(0.00001f)),
+ newParameter<float>("SSAO Sloped Depth Bias", 0xB4B4, ParameterType.FLOAT, pStep(0.00001f)),
+ newParameter<float>("SSAO Max Depth Bias", 0xB4B8, ParameterType.FLOAT, pStep(0.00001f)),
+ newParameter<float>("SSAO Dispersion", 0xB4BC, ParameterType.FLOAT),
+ newParameter<float>("SSAO Effect", 0xB430, ParameterType.FLOAT),
+ newParameter<float>("SSAO Effect GI", 0xB434, ParameterType.FLOAT),
+ newParameter<float>("SSAO Depth Difference", 0xB4C0, ParameterType.FLOAT),
+ newParameter<float>("SSAO Samples Per Pixel", 0xB4C4, ParameterType.FLOAT),
+ newParameter<int>("SSAO Max Sample Num", 0xB4C8, ParameterType.INT, pStep(1)),
+ newParameter<int>("SSAO Max Sample Num (HQ)", 0xB4D0, ParameterType.INT, pStep(1)),
+ newParameter<float>("SSAO Radius", 0xB4D4, ParameterType.FLOAT),
+ newParameter<float>("SSAO Bias", 0xB4D8, ParameterType.FLOAT),
+ newParameter<float>("SSAO Intensity", 0xB4E0, ParameterType.FLOAT),
+ newParameter<bool>("SSAO Use HiZ", 0xB4E5, ParameterType.BOOL),
+ newParameter<float>("SSAO Edge Atten Rate", 0xB4DC, ParameterType.FLOAT)
};
+
private delegate void UpdateSSLRParams(nint stackOffset);
private Hook<UpdateSSLRParams>? updateSSLRParams;
private static Parameter[] sslrParameters = {
- new Parameter<int>("SSLR Loop Count", 0xE628, ParameterType.INT, false),
- new Parameter<float>("SSLR Loop Count Factor for CBR", 0xE62C, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Eliminate Depth", 0xE630, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Accurate Threshold", 0xE644, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Accurate Threshold (HQ)", 0xE64C, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Dither Radius", 0xE634, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Importance Bias", 0xE638, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Mip Scale", 0xE63C, ParameterType.FLOAT, false),
- new Parameter<float>("SSLR Mip Bias", 0xE640, ParameterType.FLOAT, false),
- new Parameter<byte>("SSLR Dither Resolve", 0xB43F, ParameterType.BOOL, false),
- new Parameter<float>("SSLR Edge Atten Rate", 0xB428, ParameterType.FLOAT, false),
- new Parameter<int>("SSLR Mip 0 Count Threshold", 0xB438, ParameterType.INT, false, 1),
- new Parameter<float>("SSLR Depth Eliminate Rate", 0xB42C, ParameterType.FLOAT, false),
- new Parameter<byte>("SSLR Use Mipmap", 0xE650, ParameterType.BOOL, false),
- new Parameter<byte>("SSLR GBuffer Jitter", 0xB440, ParameterType.BOOL, false),
+ newParameter<int>("SSLR Loop Count", 0xE628, ParameterType.INT),
+ newParameter<float>("SSLR Loop Count Factor for CBR", 0xE62C, ParameterType.FLOAT),
+ newParameter<float>("SSLR Eliminate Depth", 0xE630, ParameterType.FLOAT),
+ newParameter<float>("SSLR Accurate Threshold", 0xE644, ParameterType.FLOAT),
+ newParameter<float>("SSLR Accurate Threshold (HQ)", 0xE64C, ParameterType.FLOAT),
+ newParameter<float>("SSLR Dither Radius", 0xE634, ParameterType.FLOAT),
+ newParameter<float>("SSLR Importance Bias", 0xE638, ParameterType.FLOAT),
+ newParameter<float>("SSLR Mip Scale", 0xE63C, ParameterType.FLOAT),
+ newParameter<float>("SSLR Mip Bias", 0xE640, ParameterType.FLOAT),
+ newParameter<bool>("SSLR Dither Resolve", 0xB43F, ParameterType.BOOL),
+ newParameter<float>("SSLR Edge Atten Rate", 0xB428, ParameterType.FLOAT),
+ newParameter<int>("SSLR Mip 0 Count Threshold", 0xB438, ParameterType.INT, pStep(1)),
+ newParameter<float>("SSLR Depth Eliminate Rate", 0xB42C, ParameterType.FLOAT),
+ newParameter<bool>("SSLR Use Mipmap", 0xE650, ParameterType.BOOL),
+ newParameter<bool>("SSLR GBuffer Jitter", 0xB440, ParameterType.BOOL),
+ newParameter<float>("SSLR Intensity", 0xB424, ParameterType.FLOAT)
};
- private static Parameter[] sceneParameters = {
- new Parameter<byte>("HQ Mode", 0xE9A3, ParameterType.BOOL, false),
- new Parameter<float>("Shadow Cascade 2Way Bias (HQ)", 0x58, ParameterType.FLOAT, false),
- new Parameter<int>("Primary Shadow Sample Num", 0xE5C4, ParameterType.INT, false),
- new Parameter<int>("Primary Shadow Sample Num (HQ)", 0xE5CC, ParameterType.INT, false),
- new Parameter<byte>("Primary Shadow HQ", 0xE5C0, ParameterType.BOOL, false),
- new Parameter<byte>("Primary Shadow HQ (HQ)", 0xE5C2, ParameterType.BOOL, false),
- new Parameter<float>("LOD Bias 1", 0x21C, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Bias 2", 0x220, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Caster Bias", 0x1E4, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Length Bias", 0x1F4, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Length Bias (HQ)", 0x1FC, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Pixel Size Bias", 0x200, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Pixel Size Bias (HQ)", 0x208, ParameterType.FLOAT, false),
- new Parameter<int>("LOD Limit", 0xE898, ParameterType.INT, false, 1),
- new Parameter<float>("LOD Passthrough Culling Rate", 0x1F0, ParameterType.FLOAT, false),
- new Parameter<float>("Far Culling Fade Length Max", 0x20C, ParameterType.FLOAT, false),
- new Parameter<float>("Far Culling Fade Pixel Max", 0x210, ParameterType.FLOAT, false),
- new Parameter<float>("Speed Tree LOD Billboard Fade Range", 0x214, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Culling Length Bias", 0x224, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Culling Pixel Bias", 0x228, ParameterType.FLOAT, false),
- new Parameter<byte>("Is Calc LOD Bias Use Boundary", 0x218, ParameterType.BOOL, false),
- new Parameter<int>("Model Detail", 0x190, ParameterType.INT, false, 1),
- new Parameter<byte>("Passthrough Active", 0xE9A0, ParameterType.BOOL, false),
- new Parameter<byte>("Passthrough Culling Active", 0xE9A2, ParameterType.BOOL, false),
- new Parameter<float>("Passthrough Near", 0xE940, ParameterType.FLOAT, false),
- new Parameter<float>("Passthrough Far", 0xE944, ParameterType.FLOAT, false),
- new Parameter<float>("Passthrough Near Alpha", 0xE948, ParameterType.FLOAT, false),
- new Parameter<float>("Passthrough Far Alpha", 0xE94C, ParameterType.FLOAT, false),
- new Parameter<float>("Passthrough Correct", 0xE950, ParameterType.FLOAT, false),
- new Parameter<float>("LOD Length Platform Bias[2]", 0x22C + (4 * 2), ParameterType.FLOAT, false),
- new Parameter<float>("LOD Pixel Size Platform Bias[2]", 0x244 + (4 * 2), ParameterType.FLOAT, false),
- new Parameter<float>("Fake Light Intensity", 0xEC40, ParameterType.FLOAT, false),
- // MonsterHunterWorld.exe+1B18711 - mov [rbx+0000EC44],3F800000 (Other unknown reference).
- new Parameter<float>("Fake Light Intensity (Gameplay)", new IntPtr(0x141B1A19F) + 0x6, ParameterType.PATCH_FLOAT, false),
- new Parameter<float>("Fake Light Blend", new IntPtr(0x141CDE0CE) + 0x6, ParameterType.PATCH_FLOAT, false),
- new Parameter<byte>("Contact Shadows Enabled", 0xB4EC, ParameterType.BOOL, false),
- new Parameter<byte>("Force Disable Contact Shadows", 0xB4ED, ParameterType.BOOL, false),
- new Parameter<byte>("Facial Contact Shadows Enabled", 0xB4EE, ParameterType.BOOL, false),
- new Parameter<byte>("Contact Shadows Enable Noise", 0xB500, ParameterType.BOOL, false),
- new Parameter<byte>("Facial Contact Shadows Enable Noise", 0xB501, ParameterType.BOOL, false),
- new Parameter<float>("Contact Shadow Intensity", 0xB4F0, ParameterType.FLOAT, false),
- new Parameter<float>("Contact Shadow Length", 0xB4F4, ParameterType.FLOAT, false),
- new Parameter<float>("Contact Shadow Accept Maximum Length", 0xB4F8, ParameterType.FLOAT, false),
- new Parameter<float>("Contact Shadow Accept Minimum Length", 0xB4FC, ParameterType.FLOAT, false),
- new Parameter<byte>("Capsule AO Enabled", 0xB502, ParameterType.BOOL, false),
- new Parameter<byte>("Force Disable Capsule AO", 0xB503, ParameterType.BOOL, false),
- new Parameter<float>("Capsule AO Distance Fall Coef", 0xE5B4, ParameterType.FLOAT, false),
- new Parameter<int>("Capsule AO Light Channel Mask", 0xE5BC, ParameterType.INT, false),
- new Parameter<float>("Capsule Light Dir XZY", 0xE548, ParameterType.VECTOR3, false),
- new Parameter<float>("Capsule Light W Dir", 0xE560, ParameterType.FLOAT, false),
- new Parameter<float>("Capsule Light Angle", 0xE5B0, ParameterType.FLOAT, false),
- new Parameter<float>("Capsule AO Intensity", 0xE5B8, ParameterType.FLOAT, false),
- new Parameter<byte>("Accurate Cascade 1 Shadow", 0x44F, ParameterType.BOOL, false),
- new Parameter<byte>("Broad Area Shadow Enable", 0x5534, ParameterType.BOOL, false),
- new Parameter<float>("Broad Area Shadow Center", 0x5540, ParameterType.VECTOR3, false),
- new Parameter<float>("Broad Area Shadow Range", 0x5560, ParameterType.VECTOR3, false),
- new Parameter<float>("Broad Area Shadow Dir", 0x5550, ParameterType.VECTOR4, false),
- new Parameter<float>("Broad Area Shadow Max LOD Level", 0x5524, ParameterType.FLOAT, false),
- new Parameter<float>("Broad Area Shadow Culling Size", 0x5528, ParameterType.FLOAT, false),
- new Parameter<int>("Broad Area Shadow Precision", 0x5518, ParameterType.INT, false, 1, 0, 2), // Maybe 3?
- new Parameter<float>("Shadow Culling Length", 0x5C, ParameterType.FLOAT, false),
- new Parameter<byte>("Light Frustum Cull Enable", 0x552C, ParameterType.BOOL, false),
- new Parameter<float>("Snow Field 4 Global LOD Param", 0x5718, ParameterType.FLOAT, false)
+
+ // This is actually an InfiniteLight object.
+ private delegate void UpdateShadowParams(nint shadowParams, nint stackOffset);
+ private delegate void StaticShadowParams(nint shadowParamsStatic, nint shadowObjectInternal);
+ private Hook<UpdateShadowParams>? updateShadowParams;
+ private Hook<StaticShadowParams>? staticShadowParams;
+ private static Parameter[] shadowParameters1 = {
+ };
+ // Non-PerFrame parameters will be written directly to the light object.
+ private static Parameter[] shadowParameters2 = {
+ newFrameParameter<int>("Sunlight Group", 0x14, ParameterType.INT, pMinMaxStep(1, 255, 1)),
+ newFrameParameter<float>("Sunlight Direction", 0x110, ParameterType.VECTOR3, pStep(0.001f)),
+ newFrameParameter<float>("Sunlight Color", 0xE0, ParameterType.FLOAT),
+ newFrameParameter<float>("Sunlight Intensity", 0xF4, ParameterType.FLOAT),
+ newParameter<float>("Sunlight Min Roughness", 0x58C, ParameterType.FLOAT, pStep(0.0025f)), // +0xFC in params but is never read.
+ newFrameParameter<bool>("Sunlight Do Volumetric", 0x1F, ParameterType.BOOL),
+ newFrameParameter<bool>("Sunlight Is Primary", 0x1D, ParameterType.BOOL),
+ newFrameParameter<bool>("Shadow Cast", 0x23, ParameterType.BOOL),
+ newFrameParameter<int>("Shadow Map Size", 0x30, ParameterType.INT), // Aligned to 128.
+ newFrameParameter<float>("Shadow Near Clip Distance", 0x28, ParameterType.FLOAT),
+ newFrameParameter<int>("Shadow Cascade Mode", 0x174, ParameterType.INT, pMinMaxStep(0, 3, 1)),
+ newFrameParameter<float>("Shadow Cascade 2Way Bias", 0x17C, ParameterType.FLOAT),
+ newFrameParameter<float>("Shadow Distance", 0x6C, ParameterType.FLOAT, pStep(5.0f)),
+ newFrameParameter<float>("Shadow Backforward Distance", 0x7C, ParameterType.FLOAT, pStep(5.0f)),
+ newFrameParameter<bool>("Shadow Is Fixed Fov Mode", 0x1F9, ParameterType.BOOL),
+ newFrameParameter<float>("Shadow Fov", 0x1F4, ParameterType.FLOAT, pStep(0.0001f)),
+ newFrameParameter<bool>("Shadow Is Discretization Fov Mode", 0x205, ParameterType.BOOL),
+ newFrameParameter<float>("Shadow Discretization Angle", 0x200, ParameterType.FLOAT, pStep(0.0001f)),
+ newFrameParameter<float>("Shadow Distribution", 0x74, ParameterType.FLOAT, pStep(0.001f)),
+ newFrameParameter<bool>("Cascade Manual Split", 0x4D, ParameterType.BOOL),
+ newFrameParameter<float>("Cascade Manual Split Distance[0]", 0x54, ParameterType.FLOAT),
+ newFrameParameter<float>("Cascade Manual Split Distance[1]", 0x5C, ParameterType.FLOAT),
+ newFrameParameter<float>("Cascade Manual Split Distance[2]", 0x64, ParameterType.FLOAT),
+ newFrameParameter<float>("Shadow Sloped Depth Bias", 0x40, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Shadow Depth Bias", 0x38, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Shadow Max Depth Bias", 0x48, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<bool>("Cascade Individual Shadow Bias", 0x81, ParameterType.BOOL),
+ newFrameParameter<float>("Cascade Depth Bias[0]", 0x88, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Sloped Depth Bias[0]", 0xA0, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Max Depth Bias[0]", 0xB8, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Depth Bias[1]", 0x90, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Sloped Depth Bias[1]", 0xA8, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Max Depth Bias[1]", 0xC0, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Depth Bias[2]", 0x98, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Sloped Depth Bias[2]", 0xB0, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Cascade Max Depth Bias[2]", 0xC8, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Broad Area Shadow Depth Bias", 0x1C4, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Broad Area Shadow Sloped Depth Bias", 0x1CC, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Broad Area Shadow Max Depth Bias", 0x1D4, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Projection Scale", 0x134, ParameterType.VECTOR3),
+ newFrameParameter<float>("Projection Offset Speed", 0x144, ParameterType.FLOAT),
+ newFrameParameter<float>("Projection Up", 0x160, ParameterType.VECTOR3),
+ newFrameParameter<int>("Primary Shadow Sample Num", 0x1DC, ParameterType.INT, pStep(1)),
+ newFrameParameter<float>("Primary Shadow Radius", 0x1EC, ParameterType.FLOAT, pStep(0.0001f))
};
- private delegate nint CreateFXAAObject();
- private delegate nint CreateFXAAObject2(nint unknownPtr);
- private delegate nint DestroyFXAAObject(nint fxaaObjectInternal, int unknownInt);
- private Hook<CreateFXAAObject>? createFXAAObject;
- private Hook<CreateFXAAObject2>? createFXAAObject2;
- private Hook<DestroyFXAAObject>? destroyFXAAObject;
- private nint fxaaObject = 0x0;
- private static Parameter[] fxaaParameters = {
- new Parameter<float>("FXAA Subpix", 0x178, ParameterType.FLOAT, false, 0.005f, 0.0f, 1.0f),
- new Parameter<float>("FXAA Edge Threshold", 0x17C, ParameterType.FLOAT, false, 0.001f, 0.0f, 1.0f),
- new Parameter<float>("FXAA Edge Threshold Min", 0x180, ParameterType.FLOAT, false, 0.001f, 0.0f, 1.0f)
+ private static MtObject? sLightProbes = null;
+ private static Parameter[] lightProbesParameters = {
+ newParameter<int>("Debug Mode", 0x98, ParameterType.INT, pStep(1))
+ };
+ private delegate nint CreateLightingObject();
+ private delegate nint DestroyLightingObject(nint lightingObjectInternal, int unknownInt);
+ private Hook<CreateLightingObject>? createLightingObject;
+ private Hook<DestroyLightingObject>? destroyLightingObject;
+ private nint lightingObject = 0x0;
+ private delegate void UpdateLightingParameters(nint stackOffset, nint lightingObjectInternal);
+ private Hook<UpdateLightingParameters>? updateLightingParams;
+ private static Parameter[] lightingParameters = {
+ newParameter<int>("Light Tone Map Type", 0x16C, ParameterType.INT, pMinMaxStep(1, 6, 1)),
+ newParameter<byte>("Light Shoulder Strength", 0x168, ParameterType.BYTE, pStep((byte)1)),
+ newParameter<float>("Light Linear Strength", 0x178, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Light Linear Angle", 0x17C, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Light Toe Strength", 0x180, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Light Toe Num", 0x184, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Light White Point", 0x18C, ParameterType.FLOAT, pStep(0.01f)),
+ newParameter<bool>("Light Enable Color Grading", 0x1D8, ParameterType.BOOL),
+ newParameter<float>("Volume Dispersion", 0x19C, ParameterType.FLOAT),
+ newParameter<float>("Volume Edge Sharpness", 0x198, ParameterType.FLOAT, pStep(0.00001f)),
+ newParameter<bool>("Volume Downsample", 0x210, ParameterType.BOOL)
+ };
+
+ private delegate nint CreateBloomObject();
+ private delegate nint CreateBloomObject2(nint unknownPtr);
+ private delegate nint DestroyBloomObject(nint bloomObjectInternal, int unknownInt);
+ private Hook<CreateBloomObject>? createBloomObject;
+ private Hook<CreateBloomObject2>? createBloomObject2;
+ private Hook<DestroyBloomObject>? destroyBloomObject;
+ //private delegate void UpdateBloomParams(nint bloomObjectInternal, nint unknownPtr);
+ //private Hook<UpdateBloomParams>? updateBloomParams;
+ private nint bloomObject = 0x0;
+ private static Parameter[] bloomParameters = {
+ // Disabling 'Draw' is a bad way to disable bloom. It breaks the filter on initial load which
+ // can be seen when returning to title or opening a guild card for the first time. Setting 'Bloom Renormalize'
+ // to 0.0 or 'Bloom Reduction Resolution' to -1 can both effectively disable bloom without that issue.
+ //newFlag<byte>("Bloom Enabled", 0x14, ParameterType.FLAG, (1 << 1)), // Draw
+ newParameter<float>("Bloom Threshold", 0x204, ParameterType.FLOAT),
+ newParameter<float>("Bloom Renormalize", 0x208, ParameterType.FLOAT, pMin(0.0f)),
+ newParameter<int>("Bloom Color", 0x200, ParameterType.COLOR),
+ newParameter<int>("Bloom Downsample Count", 0x168, ParameterType.INT, pMinMaxStep(0, 8, 1)),
+ newParameter<int>("Bloom Reduction Resolution", 0x16C, ParameterType.INT, pStep(1)),
+ newParameter<bool>("Bloom Is SRGB Gamut", 0x214, ParameterType.BOOL),
+ newParameter<bool>("Bloom Compute Luminance", 0x241, ParameterType.BOOL)
};
private delegate nint CreateDofObject();
@@ -1266,25 +1414,25 @@ namespace WorldTuningTool private Hook<UpdateDofParams>? updateDofParams;
private nint dofObject = 0x0;
private static Parameter[] dofParameters = {
- new Parameter<byte>("Dof Enabled", 0x1DD, ParameterType.BOOL, false),
- new Parameter<byte>("New Version", 0x1DC, ParameterType.BOOL, false),
- new Parameter<float>("F Number", 0x1A0, ParameterType.FLOAT, true, 0.001f),
- new Parameter<float>("Sensor Size", 0x1A4, ParameterType.FLOAT, true, 0.001f),
- new Parameter<float>("Focus Distance", 0x1A8, ParameterType.FLOAT, true, 0.2f),
- new Parameter<float>("Near Coef", 0x1CC, ParameterType.FLOAT, false, 0.001f),
- new Parameter<float>("Far Coef", 0x1C8, ParameterType.FLOAT, false, 0.001f),
- new Parameter<byte>("Near Enable", 0x1DE, ParameterType.BOOL, false),
- new Parameter<byte>("Far Enable", 0x1DF, ParameterType.BOOL, false),
- new Parameter<byte>("Debug Draw", 0x1E0, ParameterType.BOOL, false),
- new Parameter<float>("Radius", 0x1D0, ParameterType.FLOAT, false, 0.001f),
- new Parameter<float>("Depth Scale Foreground", 0x1D4, ParameterType.FLOAT, false, 0.0001f),
- new Parameter<float>("Aspect", 0x1D8, ParameterType.FLOAT, false, 0.001f),
- new Parameter<byte>("Vignetting Enabled", 0x200, ParameterType.BOOL, true),
- new Parameter<byte>("Vignetting Ellipse", 0x201, ParameterType.BOOL, true),
- new Parameter<float>("Vignetting Ellipticity", 0x204, ParameterType.FLOAT, true),
- new Parameter<float>("Vignetting Offset", 0x1F8, ParameterType.FLOAT, true),
- new Parameter<float>("Vignetting Pow", 0x1FC, ParameterType.FLOAT, true),
- new Parameter<int>("Vignetting Color", 0x208, ParameterType.COLOR, true),
+ newParameter<bool>("Dof Enabled", 0x1DD, ParameterType.BOOL),
+ newParameter<bool>("Dof New Version", 0x1DC, ParameterType.BOOL),
+ newFrameParameter<float>("Dof F Number", 0x1A0, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
+ newFrameParameter<float>("Dof Sensor Size", 0x1A4, ParameterType.FLOAT, pStep(0.001f)),
+ newFrameParameter<float>("Dof Focus Distance", 0x1A8, ParameterType.FLOAT, pStep(0.2f)),
+ newParameter<float>("Dof Near Coef", 0x1CC, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Dof Far Coef", 0x1C8, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<bool>("Dof Near Enable", 0x1DE, ParameterType.BOOL),
+ newParameter<bool>("Dof Far Enable", 0x1DF, ParameterType.BOOL),
+ newParameter<bool>("Dof Debug Draw", 0x1E0, ParameterType.BOOL),
+ newParameter<float>("Dof Radius", 0x1D0, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Dof Depth Scale Foreground", 0x1D4, ParameterType.FLOAT, pMinStep(0.0f, 0.0001f)),
+ newParameter<float>("Dof Aspect", 0x1D8, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
+ newFrameParameter<bool>("Vignetting Enabled", 0x200, ParameterType.BOOL),
+ newFrameParameter<bool>("Vignetting Ellipse", 0x201, ParameterType.BOOL),
+ newFrameParameter<float>("Vignetting Ellipticity", 0x204, ParameterType.FLOAT),
+ newFrameParameter<float>("Vignetting Offset", 0x1F8, ParameterType.FLOAT),
+ newFrameParameter<float>("Vignetting Pow", 0x1FC, ParameterType.FLOAT),
+ newFrameParameter<int>("Vignetting Color", 0x208, ParameterType.COLOR)
};
private delegate nint CreateMotionBlurObject();
@@ -1297,163 +1445,125 @@ namespace WorldTuningTool private Hook<UpdateMotionBlurParams>? updateMotionBlurParams;
private nint motionBlurObject = 0x0;
private static Parameter[] motionBlurParameters = {
- new Parameter<int>("Type", 0x168, ParameterType.INT, false, 1),
- new Parameter<int>("Sample Num", 0x180, ParameterType.INT, false, 1, 0),
- new Parameter<float>("Shutter Speed", 0x184, ParameterType.FLOAT, true),
- new Parameter<float>("Fur Shutter Speed", 0x188, ParameterType.FLOAT, false),
- new Parameter<float>("Blur Threshold", 0x18C, ParameterType.FLOAT, false)
- };
-
- private delegate nint CreateBloomObject();
- private delegate nint CreateBloomObject2(nint unknownPtr);
- private delegate nint DestroyBloomObject(nint bloomObjectInternal, int unknownInt);
- private Hook<CreateBloomObject>? createBloomObject;
- private Hook<CreateBloomObject2>? createBloomObject2;
- private Hook<DestroyBloomObject>? destroyBloomObject;
- private nint bloomObject = 0x0;
- private static Parameter[] bloomParameters = {
- new Parameter<byte>("Bloom Enabled", 0x14, ParameterType.FLAG, false, (1 << 1)),
- new Parameter<float>("Threshold", 0x204, ParameterType.FLOAT, false),
- new Parameter<float>("Renormalize", 0x208, ParameterType.FLOAT, false),
- new Parameter<float>("Dispersion for CBR", 0x210, ParameterType.FLOAT, false),
- new Parameter<byte>("is SRGB Gamut", 0x214, ParameterType.BOOL, false),
- new Parameter<byte>("Enable Optimize", 0x215, ParameterType.BOOL, false),
- new Parameter<int>("Bloom Color", 0x200, ParameterType.COLOR, false),
- new Parameter<float>("Dirt Color", 0x230, ParameterType.FLOAT, false),
- new Parameter<byte>("Flip Dirt Intensity", 0x240, ParameterType.BOOL, false),
- new Parameter<int>("Downsample Count", 0x168, ParameterType.INT, false),
- new Parameter<int>("Reduction Resolution", 0x16C, ParameterType.INT, false),
- new Parameter<byte>("Compute Luminance", 0x241, ParameterType.BOOL, false)
+ newParameter<int>("Motion Blur Type", 0x168, ParameterType.INT, pStep(1)),
+ newParameter<int>("Motion Blur Sample Num", 0x180, ParameterType.INT, pMinStep(0, 1)),
+ newFrameParameter<float>("Motion Blur Shutter Speed", 0x184, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
+ newParameter<float>("Motion Blur Fur Shutter Speed", 0x188, ParameterType.FLOAT, pStep(0.001f)),
+ newParameter<float>("Motion Blur Threshold", 0x18C, ParameterType.FLOAT, pMinStep(0.0f, 0.01f))
};
- private static MtObject? sLightProbes = null;
- private static Parameter[] lightProbesParameters = {
- new Parameter<int>("Debug Mode", 0x98, ParameterType.INT, false, 1),
- };
- private delegate nint CreateLightingObject();
- private delegate nint DestroyLightingObject(nint lightingObjectInternal, int unknownInt);
- private Hook<CreateLightingObject>? createLightingObject;
- private Hook<DestroyLightingObject>? destroyLightingObject;
- private nint lightingObject = 0x0;
- private static Parameter[] lightingParameters = {
- new Parameter<int>("Tone Map Type", 0x16C, ParameterType.INT, false, 1, 1, 7),
- new Parameter<float>("Shoulder Strength", 0x168, ParameterType.FLOAT, false),
- new Parameter<float>("Linear Strength", 0x178, ParameterType.FLOAT, false),
- new Parameter<float>("Linear Angle", 0x17C, ParameterType.FLOAT, false),
- new Parameter<float>("Toe Strength", 0x180, ParameterType.FLOAT, false),
- new Parameter<float>("Toe Num", 0x184, ParameterType.FLOAT, false),
- new Parameter<float>("White Point", 0x18C, ParameterType.FLOAT, false),
- new Parameter<byte>("Enable Color Grading", 0x1D8, ParameterType.BOOL, false),
- new Parameter<float>("Dispersion", 0x19C, ParameterType.FLOAT, false),
- new Parameter<float>("Edge Sharpness", 0x198, ParameterType.FLOAT, false, 0.00001f),
- new Parameter<byte>("Downsample Volume", 0x210, ParameterType.BOOL, false)
- };
-
- private delegate void UpdateShadowParams(nint shadowObjectInternal, nint stackOffset);
- private Hook<UpdateShadowParams>? updateShadowParams;
- private Hook<UpdateShadowParams>? staticShadowParams;
- private static Parameter[] shadowParameters1 = {
- };
- // This is actually an InfiniteLight object.
- private static Parameter[] shadowParameters2 = {
- new Parameter<float>("Color", 0xE0, ParameterType.FLOAT, true),
- new Parameter<float>("Intensity", 0xF4, ParameterType.FLOAT, true),
- new Parameter<float>("Min Roughness", 0xFC, ParameterType.FLOAT, true),
- new Parameter<float>("Dir", 0x110, ParameterType.VECTOR4, true),
- new Parameter<byte>("Group", 0x14, ParameterType.BYTE, true),
- new Parameter<byte>("Priority", 0x1A, ParameterType.BYTE, true),
- new Parameter<byte>("Primary", 0x1D, ParameterType.BOOL, true),
- new Parameter<byte>("Shadow Cast", 0x23, ParameterType.BOOL, true),
- new Parameter<float>("Near Clip Distance", 0x28, ParameterType.FLOAT, true),
- new Parameter<float>("Shadow Sloped Depth Bias", 0x40, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<int>("Shadow Map Size", 0x30, ParameterType.INT, true), // Aligned to 128.
- new Parameter<float>("Shadow Depth Bias", 0x38, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Shadow Max Depth Bias", 0x48, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<byte>("Do Volumetric", 0x1F, ParameterType.BOOL, true),
- new Parameter<byte>("Draw Mode", 0x21, ParameterType.BYTE, true),
- new Parameter<float>("Shadow Distance", 0x6C, ParameterType.FLOAT, true, 5.0f),
- new Parameter<float>("Shadow Backforward Distance", 0x7C, ParameterType.FLOAT, true, 5.0f),
- new Parameter<float>("Shadow Distribution", 0x74, ParameterType.FLOAT, true, 0.001f),
- new Parameter<byte>("Manual Split", 0x4D, ParameterType.BOOL, true),
- new Parameter<byte>("Individual Shadow Bias", 0x81, ParameterType.BOOL, true),
- new Parameter<float>("Manual Split Distance[0]", 0x54, ParameterType.FLOAT, true),
- new Parameter<float>("Cascade Depth Bias[0]", 0x88, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Cascade Sloped Depth Bias[0]", 0xA0, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Cascade Max Depth Bias[0]", 0xB8, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Manual Split Distance[1]", 0x5C, ParameterType.FLOAT, true),
- new Parameter<float>("Cascade Depth Bias[1]", 0x90, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Cascade Sloped Depth Bias[1]", 0xA8, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Cascade Max Depth Bias[1]", 0xC0, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Manual Split Distance[2]", 0x64, ParameterType.FLOAT, true),
- new Parameter<float>("Cascade Depth Bias[2]", 0x98, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Cascade Sloped Depth Bias[2]", 0xB0, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Cascade Max Depth Bias[2]", 0xC8, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Projection Scale", 0x134, ParameterType.FLOAT, true),
- new Parameter<float>("Projection Offset Speed", 0x144, ParameterType.FLOAT, true),
- new Parameter<float>("Projection Up", 0x160, ParameterType.VECTOR3, true),
- new Parameter<byte>("Shadow Cascade Mode", 0x174, ParameterType.BYTE, true, 1, 0, 3),
- new Parameter<float>("Shadow Cascade 2Way Bias", 0x17C, ParameterType.FLOAT, true),
- new Parameter<float>("Shadow Culling Length[0]", 0x184, ParameterType.FLOAT, true),
- new Parameter<float>("Shadow Culling Length[1]", 0x18C, ParameterType.FLOAT, true),
- new Parameter<float>("Shadow Culling Length[2]", 0x194, ParameterType.FLOAT, true),
- //new Parameter<float>("Broad Area Shadow Range", 0x1B0, ParameterType.VECTOR3, true),
- new Parameter<float>("Broad Area Shadow Depth Bias", 0x1C4, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Broad Area Shadow Sloped Depth Bias", 0x1CC, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Broad Area Shadow Max Depth Bias", 0x1D4, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<int>("Primary Shadow Sample Num", 0x1DC, ParameterType.INT, true),
- new Parameter<float>("Primary Shadow Radius", 0x1EC, ParameterType.FLOAT, true, 0.0001f),
- new Parameter<float>("Fov", 0x1F4, ParameterType.FLOAT, true, 0.0001f),
- new Parameter<byte>("Is Fixed Fov Mode", 0x1F9, ParameterType.BOOL, true),
- new Parameter<float>("Discretization Angle", 0x200, ParameterType.FLOAT, true, 0.0001f),
- new Parameter<byte>("Is Discretization Fov Mode", 0x205, ParameterType.BOOL, true)
+ private delegate nint CreateFXAAObject();
+ private delegate nint CreateFXAAObject2(nint unknownPtr);
+ private delegate nint DestroyFXAAObject(nint fxaaObjectInternal, int unknownInt);
+ private Hook<CreateFXAAObject>? createFXAAObject;
+ private Hook<CreateFXAAObject2>? createFXAAObject2;
+ private Hook<DestroyFXAAObject>? destroyFXAAObject;
+ private nint fxaaObject = 0x0;
+ private static Parameter[] fxaaParameters = {
+ newParameter<float>("FXAA Subpix", 0x178, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.005f)),
+ newParameter<float>("FXAA Edge Threshold", 0x17C, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.001f)),
+ newParameter<float>("FXAA Edge Threshold Min", 0x180, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.001f))
};
private static MtObject? sMain = null;
- private static MtObject? sLightLinker = null;
- private static MtObject? sMhSpeedTree = null;
- private static Parameter[] allParameters = sceneParameters
+ private static Parameter[] allParameters = new Parameter[]{ hqMode }
+ .Concat(lodParameters)
+ .Concat(snowParameters)
+ .Concat(shadowParameters2)
+ .Concat(shadowCascadeParameters)
+ .Concat(broadAreaShadowParameters)
+ .Concat(contactShadowParameters)
+ .Concat(capsuleLightParameters)
.Concat(ssaoParameters)
.Concat(sslrParameters)
- .Concat(fxaaParameters)
+ .Concat(passthroughParameters)
+ .Concat(lightingParameters)
+ .Concat(bloomParameters)
.Concat(dofParameters)
.Concat(motionBlurParameters)
- .Concat(bloomParameters)
- .Concat(lightingParameters)
- .Concat(shadowParameters2).ToArray();
+ .Concat(fxaaParameters).ToArray();
- private bool tripleShadowResolution = false;
- private bool quadrupleShadowResolution = false;
+ private int shadowResMultiplier = 1;
private NativeAction<int> setShadowQuality;
+ private Patch shadowRes1_2x;
private Patch shadowRes1_3x;
private Patch shadowRes1_4x;
+ private Patch shadowRes1_5x;
private Patch shadowRes1_1;
private Patch shadowRes1_2;
private Patch shadowRes1_3;
+ private Patch shadowRes1_4;
private Patch shadowRes2;
private Patch shadowRes3;
- //private Patch shadowRes4_Limit;
- private void tripleShadowResEnable()
+ private void shadowResEnable(int prevMultiplier)
{
- shadowRes1_3x.Enable();
- shadowRes1_1.Enable();
- shadowRes1_2.Enable();
- shadowRes1_3.Enable();
- shadowRes2.Enable();
- shadowRes3.Enable();
- //shadowRes4_Limit.Enable();
+ switch (prevMultiplier)
+ {
+ case 1:
+ shadowRes1_1.Enable();
+ shadowRes1_2.Enable();
+ shadowRes1_3.Enable();
+ shadowRes1_4.Enable();
+ shadowRes2.Enable();
+ shadowRes3.Enable();
+ break;
+ case 2:
+ shadowRes1_2x.Disable();
+ break;
+ case 3:
+ shadowRes1_3x.Disable();
+ break;
+ case 4:
+ shadowRes1_4x.Disable();
+ break;
+ case 5:
+ shadowRes1_5x.Disable();
+ break;
+ }
+ switch (shadowResMultiplier)
+ {
+ case 2:
+ shadowRes1_2x.Enable();
+ break;
+ case 3:
+ shadowRes1_3x.Enable();
+ break;
+ case 4:
+ shadowRes1_4x.Enable();
+ break;
+ case 5:
+ case 6:
+ shadowRes1_5x.Enable();
+ break;
+ }
}
- private void tripleShadowResDisable()
+ private void shadowResDisable(int prevMultiplier)
{
- shadowRes1_3x.Disable();
+ Assert(shadowResMultiplier == 1 && prevMultiplier != 1);
+ switch (prevMultiplier)
+ {
+ case 2:
+ shadowRes1_2x.Disable();
+ break;
+ case 3:
+ shadowRes1_3x.Disable();
+ break;
+ case 4:
+ shadowRes1_4x.Disable();
+ break;
+ case 5:
+ shadowRes1_5x.Disable();
+ break;
+ }
shadowRes1_1.Disable();
shadowRes1_2.Disable();
shadowRes1_3.Disable();
+ shadowRes1_4.Disable();
shadowRes2.Disable();
shadowRes3.Disable();
- //shadowRes4_Limit.Disable();
}
private bool fullResVolumeBlur = false;
@@ -1532,22 +1642,22 @@ namespace WorldTuningTool public nint Object;
public int Type;
public Parameter[] Parameters = {
- new Parameter<int>("Group", 0x13C, ParameterType.INT, false, 1, 1, 3),
- new Parameter<float>("Position", 0x5A0, ParameterType.VECTOR3, true, 0.1f),
- new Parameter<int>("Color", 0x140, ParameterType.COLOR, true),
- new Parameter<float>("Intensity", 0x8A8, ParameterType.FLOAT, true, 0.1f),
- new Parameter<float>("Radius", 0x6A0, ParameterType.FLOAT, true, 0.25f),
- new Parameter<float>("Effective Radius", 0x588, ParameterType.FLOAT, true, 0.25f),
- new Parameter<float>("Min Roughness", 0x58C, ParameterType.FLOAT, true),
- new Parameter<int>("Shadow Cast", 0x138, ParameterType.FLAG, false, (1 << 23)),
- new Parameter<int>("Shadow Map Size", 0x1B8, ParameterType.INT, false), // Aligned to 128.
- new Parameter<float>("Shadow Depth Bias", 0x57C, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Shadow Sloped Depth Bias", 0x580, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<float>("Shadow Max Depth Bias", 0x584, ParameterType.FLOAT, true, 0.00001f),
- new Parameter<byte>("Do Volumetric", 0x590, ParameterType.BOOL, true),
- new Parameter<float>("Near Clip Distance", 0x1B4, ParameterType.FLOAT, true),
- //new Parameter<byte>("Use Umbra", 0x591, ParameterType.BOOL, true),
- //new Parameter<byte>("Enable Camera LOD", 0x592, ParameterType.BOOL, true),
+ newParameter<int>("Group", 0x13C, ParameterType.INT, pMinMaxStep(1, 255, 1)), // 1 = World, (1 << 1) = Player/Palico, (1 << 2) = NPCs
+ newFrameParameter<float>("Position", 0x5A0, ParameterType.VECTOR3, pStep(0.15f)),
+ newFrameParameter<int>("Color", 0x140, ParameterType.COLOR),
+ newFrameParameter<float>("Intensity", 0x8A8, ParameterType.FLOAT),
+ newFrameParameter<float>("Radius", 0x6A0, ParameterType.FLOAT, pStep(0.25f)),
+ newFrameParameter<float>("Effective Radius", 0x588, ParameterType.FLOAT, pStep(0.25f)),
+ newFrameParameter<float>("Min Roughness", 0x58C, ParameterType.FLOAT),
+ newParameter<bool>("Do Volumetric", 0x590, ParameterType.BOOL),
+ newFlag<bool>("Shadow Cast", 0x138, ParameterType.FLAG, (1 << 23)),
+ newParameter<int>("Shadow Map Size", 0x1B8, ParameterType.INT), // Aligned to 128.
+ newParameter<float>("Shadow Near Clip Distance", 0x1B4, ParameterType.FLOAT),
+ newFrameParameter<float>("Shadow Depth Bias", 0x57C, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Shadow Sloped Depth Bias", 0x580, ParameterType.FLOAT, pStep(0.00001f)),
+ newFrameParameter<float>("Shadow Max Depth Bias", 0x584, ParameterType.FLOAT, pStep(0.00001f)),
+ //new Parameter<bool>("Use Umbra", 0x591, ParameterType.BOOL, true),
+ //new Parameter<bool>("Enable Camera LOD", 0x592, ParameterType.BOOL, true),
//new Parameter<float>("Llk Intensity", 0x974, ParameterType.FLOAT, true),
//new Parameter<float>("Llk Radius", 0x978, ParameterType.FLOAT, true),
//new Parameter<float>("Llk Effective Radius", 0x97C, ParameterType.FLOAT, true),
@@ -1584,7 +1694,7 @@ namespace WorldTuningTool {
param.OverrideOn(false);
}
- Parameters[0].OverrideValue(default, 3);
+ Parameters[0].OverrideValue(default, 255);
Parameters[1].OverrideValue(new Vector4(pos.X, pos.Y, pos.Z, 0.0f), 0);
Parameters[3].OverrideValue(new Vector4(10.0f, 0.0f, 0.0f, 0.0f), 0);
foreach (Parameter param in Parameters)
@@ -1616,9 +1726,9 @@ namespace WorldTuningTool private int requestLightType = 2;
private NativeFunction<int, nint> createLight;
- private bool interceptCreateLight = false;
+ //private bool interceptCreateLight = false;
private List<Light> ourLights = new List<Light>();
- private List<Light> sceneLights = new List<Light>();
+ //private List<Light> sceneLights = new List<Light>();
private NativeAction<nint, int, nint, int> addToScene;
private NativeAction<nint> removeFromScene;
//private delegate nint CreateLightObject(int type);
@@ -1676,15 +1786,32 @@ namespace WorldTuningTool {
Instance = this;
+ // Assert no duplicate names.
+ foreach (Parameter param in allParameters)
+ {
+ Assert(Array.FindAll(allParameters, (p => p.Name == param.Name)).Length == 1);
+ }
+
onAreaChange = Hook.Create<OnAreaChange>(0x141AC27D0, OnAreaChangeHook); // nint
+ // Needed for at least "Broad Area Shadow Dir". Otherwise it will flicker during an update on center change.
+ evalSceneParams = Hook.Create<EvalSceneParams>(0x1423C3790, EvalSceneParamsHook); // nint, nint, int, nint
+
+ // Light Dir XZY is updated seperately at 0x1420397F0, we assume this function always happens later, though.
+ updateCapsuleAoParams = Hook.Create<UpdateCapsuleAOParams>(0x141B19E10, UpdateCapsuleAOParamsHook); // nint
+
// These run during cutscenes.
- updateSSAOParams = Hook.Create<UpdateSSAOParams>(0x1416D8B10, UpdateSSAOParamsHook); // nint, nint
+ updateSSAOParams = Hook.Create<UpdateSSAOParams>(0x1416D8B10, UpdateSSAOParamsHook); // nint
updateSSLRParams = Hook.Create<UpdateSSLRParams>(0x1416DA3F0, UpdateSSLRParamsHook); // nint
+ updateLightingParams = Hook.Create<UpdateLightingParameters>(0x1416DAAB0, UpdateLightingParametersHook); // nint, nint
- createFXAAObject = Hook.Create<CreateFXAAObject>(0x142393560, CreateFXAAObjectHook);
- createFXAAObject2 = Hook.Create<CreateFXAAObject2>(0x142393680, CreateFXAAObject2Hook); // nint
- destroyFXAAObject = Hook.Create<DestroyFXAAObject>(0x142393740, DestroyFXAAObjectHook); // nint, int
+ createLightingObject = Hook.Create<CreateLightingObject>(0x1424CDE20, CreateLightingObjectHook);
+ destroyLightingObject = Hook.Create<DestroyLightingObject>(0x1424CE380, DestroyLightingObjectHook); // nint, int
+
+ createBloomObject = Hook.Create<CreateBloomObject>(0x1424CB3C0, CreateBloomObjectHook);
+ createBloomObject2 = Hook.Create<CreateBloomObject2>(0x1424CB5E0, CreateBloomObject2Hook); // nint
+ destroyBloomObject = Hook.Create<DestroyBloomObject>(0x1424CB750, DestroyBloomObjectHook); // nint, int
+ //updateBloomParams = Hook.Create<UpdateBloomParams>(0x1424CD570, UpdateBloomParamsHook); // nint, nint
createDofObject = Hook.Create<CreateDofObject>(0x142421E80, CreateDofObjectHook);
createDofObject2 = Hook.Create<CreateDofObject2>(0x1424220A0, CreateDofObject2Hook); // nint
@@ -1696,29 +1823,31 @@ namespace WorldTuningTool destroyMotionBlurObject = Hook.Create<DestroyMotionBlurObject>(0x1424C97E0, DestroyMotionBlurObjectHook); // nint, int
updateMotionBlurParams = Hook.Create<UpdateMotionBlurParams>(0x1424CADF0, UpdateMotionBlurParamsHook); // nint, nint
- createBloomObject = Hook.Create<CreateBloomObject>(0x1424CB3C0, CreateBloomObjectHook);
- createBloomObject2 = Hook.Create<CreateBloomObject2>(0x1424CB5E0, CreateBloomObject2Hook); // nint
- destroyBloomObject = Hook.Create<DestroyBloomObject>(0x1424CB750, DestroyBloomObjectHook); // nint, int
-
- createLightingObject = Hook.Create<CreateLightingObject>(0x1424CDE20, CreateLightingObjectHook);
- destroyLightingObject = Hook.Create<DestroyLightingObject>(0x1424CE380, DestroyLightingObjectHook); // nint, int
+ createFXAAObject = Hook.Create<CreateFXAAObject>(0x142393560, CreateFXAAObjectHook);
+ createFXAAObject2 = Hook.Create<CreateFXAAObject2>(0x142393680, CreateFXAAObject2Hook); // nint
+ destroyFXAAObject = Hook.Create<DestroyFXAAObject>(0x142393740, DestroyFXAAObjectHook); // nint, int
IntPtr addr = PatternScanner.FindFirst(Pattern.FromString("48 89 5C 24 10 48 89 74 24 18 48 89 7C 24 20 55 41 56 41 57 48 8B EC 48 83 EC 30 48 8B FA 48 8B D9 E8 AA B6 C1 FF 48 8B 47 10 48 8D 57 50"));
Assert(addr == 0x141AB2260); // nint, nint
updateShadowParams = Hook.Create<UpdateShadowParams>(addr, UpdateShadowParamsHook);
- staticShadowParams = Hook.Create<UpdateShadowParams>(0x1416D94F0, StaticShadowParamsHook); // nint, nint
+ staticShadowParams = Hook.Create<StaticShadowParams>(0x1416D94F0, StaticShadowParamsHook); // nint, nint
setShadowQuality = new NativeAction<int>(0x14043FF80);
addr = PatternScanner.FindFirst(Pattern.FromString("48 83 EC 28 F3 0F 10 0D ?? ?? ?? ?? 80 F9 04 75 2F 48 8B 0D ?? ?? ?? ?? E8 D3 8A E4 01 48 8B 0D ?? ?? ?? ?? 33 D2 E8 ?? ?? ?? ??"));
Assert(addr == 0x14043FF80);
+ Assert(MemoryUtil.Read<float>(0x142EE1A90) == 2.0f);
Assert(MemoryUtil.Read<float>(0x142E4FE5C) == 3.0f);
Assert(MemoryUtil.Read<float>(0x142C4A2F0) == 4.0f);
+ Assert(MemoryUtil.Read<float>(0x142F0F260) == 5.0f);
+ shadowRes1_2x = new Patch(addr + 0x8, [0x04, 0x1B, 0xAA, 0x02]); // 2.0.
shadowRes1_3x = new Patch(addr + 0x8, [0xD0, 0xFE, 0xA0, 0x02]); // 3.0.
shadowRes1_4x = new Patch(addr + 0x8, [0x64, 0xA3, 0x80, 0x02]); // 4.0.
+ shadowRes1_5x = new Patch(addr + 0x8, [0xD4, 0xF2, 0xAC, 0x02]); // 5.0.
shadowRes1_1 = new Patch(addr + 0x65, [0x17]); // Always set "Value is not 1.0" flag.
shadowRes1_2 = new Patch(addr + 0x68, [0x59]); // movss -> mulss.
shadowRes1_3 = new Patch(addr + 0x77, [0x59]); // movss -> mulss.
+ shadowRes1_4 = new Patch(new nint(0x142288AAA) + 0x4, [0x9E]); // Limit 4.0 -> 5.0.
// shadowRes2/3 control the detail of the infrequently updated fallback shadows (Broad Area).
addr = PatternScanner.FindFirst(Pattern.FromString("83 FA FF 74 06 89 91 1C 55 00 00 8B 91 30 55 00 00 83 FA FF 7F 06 8B 91 1C 55 00 00 85 D2 74 4B 83 EA 01 74 3B 83 EA 01 74 2B 83 EA 01 74 1B 83 FA 01 74 0B C7 81 20 55 00 00 01 00 00 00 C3 C7 81 20 55 00 00 00 10 00 00"));
@@ -1799,7 +1928,7 @@ namespace WorldTuningTool Assert(addr == 0x141754438);
defaultViewModeLODLimit_2 = new Patch(addr + 0x24, [0x07]);
- // Unknown.
+ // Unknown. @TODO: Figure this out.
defaultViewModeLODLimit_3 = new Patch(new IntPtr(0x14128F1AC) + 0x1, [0x07]);
// Talking to NPC.
@@ -1858,10 +1987,10 @@ namespace WorldTuningTool {
Config config = getConfig();
Config.PatchConfig patches = config.Patches;
- tripleShadowResolution = patches.TripleShadowResolution;
- if (tripleShadowResolution)
+ shadowResMultiplier = patches.ShadowResolutionMultiplier;
+ if (shadowResMultiplier > 1)
{
- tripleShadowResEnable();
+ shadowResEnable(1);
}
fullResVolumeBlur = patches.FullResolutionVolumeBlur;
if (fullResVolumeBlur)
@@ -1895,8 +2024,6 @@ namespace WorldTuningTool sMain = SingletonManager.GetSingleton("sMhMain")!;
sMhScene = SingletonManager.GetSingleton("sMhScene")!;
sLightProbes = SingletonManager.GetSingleton("sLightProbes")!;
- sLightLinker = SingletonManager.GetSingleton("sLightLinker")!;
- sMhSpeedTree = SingletonManager.GetSingleton("sMhSpeedTree")!;
Config config = getConfig();
foreach (Stage area in Enum.GetValues(typeof(Stage)))
{
@@ -1934,89 +2061,103 @@ namespace WorldTuningTool public void OnUpdate(float deltaTime)
{
- if (fxaaObject != 0x0)
+ hqMode.Update(sMhScene!.Instance);
+ foreach (Parameter param in lodParameters)
{
- foreach (Parameter param in fxaaParameters)
- {
- param.Update(fxaaObject);
- }
+ param.Update(sMhScene!.Instance);
}
- if (dofObject != 0x0)
+ foreach (Parameter param in passthroughParameters)
{
- foreach (Parameter param in dofParameters)
- {
- if (!param.PerFrame)
- {
- param.Update(dofObject);
- }
- }
+ param.Update(sMhScene!.Instance);
}
- if (motionBlurObject != 0x0)
+ foreach (Parameter param in shadowCascadeParameters)
{
- foreach (Parameter param in motionBlurParameters)
- {
- if (!param.PerFrame)
- {
- param.Update(motionBlurObject);
- }
- }
+ param.Update(sMhScene!.Instance);
}
- if (bloomObject != 0x0)
+ foreach (Parameter param in contactShadowParameters)
{
- foreach (Parameter param in bloomParameters)
- {
- if (!param.PerFrame)
- {
- param.Update(bloomObject);
- }
- }
+ param.Update(sMhScene!.Instance);
+ }
+ foreach (Parameter param in snowParameters)
+ {
+ param.Update(sMhScene!.Instance);
+ }
+ foreach (Parameter param in ssaoParameters)
+ {
+ param.Update(sMhScene!.Instance);
+ }
+ foreach (Parameter param in sslrParameters)
+ {
+ param.Update(sMhScene!.Instance);
}
if (lightingObject != 0x0)
{
foreach (Parameter param in lightingParameters)
{
- if (!param.PerFrame)
- {
- param.Update(lightingObject);
- }
+ param.Update(lightingObject);
}
}
- if (sLightProbes!.Instance != 0x0)
+ foreach (Parameter param in lightProbesParameters)
{
- foreach (Parameter param in lightProbesParameters)
+ param.Update(sLightProbes!.Instance);
+ }
+ if (bloomObject != 0x0)
+ {
+ foreach (Parameter param in bloomParameters)
{
- param.Update(sLightProbes!.Instance);
+ param.Update(bloomObject);
}
}
- if (sMhScene!.Instance != 0x0)
+ if (dofObject != 0x0)
{
- foreach (Parameter param in ssaoParameters)
+ foreach (Parameter param in dofParameters)
{
if (!param.PerFrame)
{
- param.Update(sMhScene!.Instance);
+ param.Update(dofObject);
}
}
- foreach (Parameter param in sslrParameters)
+ }
+ if (motionBlurObject != 0x0)
+ {
+ foreach (Parameter param in motionBlurParameters)
{
if (!param.PerFrame)
{
- param.Update(sMhScene!.Instance);
+ param.Update(motionBlurObject);
}
}
- foreach (Parameter param in sceneParameters)
+ }
+ if (fxaaObject != 0x0)
+ {
+ foreach (Parameter param in fxaaParameters)
{
- if (!param.PerFrame)
- {
- param.Update(sMhScene!.Instance);
- }
+ param.Update(fxaaObject);
}
}
}
- private void UpdateSSAOParamsHook(nint sceneObjectInternal, nint stackOffset)
+ private void EvalSceneParamsHook(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3)
+ {
+ foreach (Parameter param in broadAreaShadowParameters)
+ {
+ param.Update(sMhScene!.Instance);
+ }
+ evalSceneParams!.Original(unknownPtr, unknownPtr2, unknownInt, unknownPtr3);
+ }
+
+ private void UpdateCapsuleAOParamsHook(nint sceneObjectInternal)
{
- updateSSAOParams!.Original(sceneObjectInternal, stackOffset);
+ updateCapsuleAoParams!.Original(sceneObjectInternal);
+ foreach (Parameter param in capsuleLightParameters)
+ {
+ param.Update(sMhScene!.Instance);
+ }
+ }
+
+ private void UpdateSSAOParamsHook(nint stackOffset)
+ {
+ updateSSAOParams!.Original(stackOffset);
foreach (Parameter param in ssaoParameters)
{
param.Update(sMhScene!.Instance);
@@ -2032,6 +2173,18 @@ namespace WorldTuningTool }
}
+ private void UpdateLightingParametersHook(nint stackOffset, nint lightingObjectInternal)
+ {
+ updateLightingParams!.Original(stackOffset, lightingObjectInternal);
+ if (lightingObject == lightingObjectInternal)
+ {
+ foreach (Parameter param in lightingParameters)
+ {
+ param.Update(lightingObject);
+ }
+ }
+ }
+
private nint CreateFXAAObjectHook()
{
fxaaObject = createFXAAObject!.Original();
@@ -2192,6 +2345,20 @@ namespace WorldTuningTool return destroyBloomObject!.Original(bloomObjectInternal, unknownInt);
}
+ /*
+ private void UpdateBloomParamsHook(nint bloomObjectInternal, nint unknownPtr)
+ {
+ if (bloomObject == bloomObjectInternal)
+ {
+ foreach (Parameter param in bloomParameters)
+ {
+ param.Update(bloomObject);
+ }
+ }
+ updateBloomParams!.Original(bloomObjectInternal, unknownPtr);
+ }
+ */
+
private nint CreateLightingObjectHook()
{
lightingObject = createLightingObject!.Original();
@@ -2216,32 +2383,46 @@ namespace WorldTuningTool return destroyLightingObject!.Original(lightingObjectInternal, unknownInt);
}
- private void UpdateShadowParamsHook(nint shadowObjectInternal, nint stackOffset)
+ private void UpdateShadowParamsHook(nint shadowParams, nint stackOffset)
{
- nint shadowCascadeMode = MemoryUtil.GetRef<nint>(stackOffset + 0x170) >> 32;
- bool firstPass = shadowCascadeMode == 3;
-
- if (!firstPass)
+ bool isPrimary = MemoryUtil.Read<byte>(stackOffset + 0x1D) == 0x1;
+ if (isPrimary)
{
foreach (Parameter param in shadowParameters2)
{
- param.Update(stackOffset);
+ if (param.PerFrame)
+ {
+ param.Update(stackOffset);
+ }
}
}
-
- updateShadowParams!.Original(shadowObjectInternal, stackOffset);
+ updateShadowParams!.Original(shadowParams, stackOffset);
}
- private void StaticShadowParamsHook(nint shadowObjectStatic, nint shadowObjectInternal)
+ private void StaticShadowParamsHook(nint shadowParamsStatic, nint shadowObjectInternal)
{
if (shadowObjectInternal == 0x0)
{
+ // Necessary to apply Broad Area Depth Bias overrides on first update.
+ foreach (Parameter param in shadowParameters2)
+ {
+ if (param.PerFrame)
+ {
+ param.Update(shadowParamsStatic);
+ }
+ }
+ }
+ else
+ {
foreach (Parameter param in shadowParameters2)
{
- param.Update(shadowObjectStatic);
+ if (!param.PerFrame)
+ {
+ param.Update(shadowObjectInternal);
+ }
}
}
- staticShadowParams!.Original(shadowObjectStatic, shadowObjectInternal);
+ staticShadowParams!.Original(shadowParamsStatic, shadowObjectInternal);
}
/*
@@ -2263,6 +2444,7 @@ namespace WorldTuningTool private void DestroyLightObjectHook(nint lightObject, int unknownInt)
{
+ /*
for (int i = 0; i < sceneLights.Count; i++)
{
if (lightObject == sceneLights[i].Object)
@@ -2271,6 +2453,7 @@ namespace WorldTuningTool break;
}
}
+ */
for (int i = 0; i < ourLights.Count; i++)
{
if (lightObject == ourLights[i].Object)
@@ -2285,6 +2468,7 @@ namespace WorldTuningTool private void UpdateLightsHook(nint lightObject)
{
Light? light = null;
+ /*
for (int i = 0; i < sceneLights.Count; i++)
{
if (lightObject == sceneLights[i].Object)
@@ -2293,6 +2477,7 @@ namespace WorldTuningTool break;
}
}
+ */
if (light == null)
{
for (int i = 0; i < ourLights.Count; i++)
@@ -2692,41 +2877,29 @@ namespace WorldTuningTool if (ImGui.CollapsingHeader("Patches"))
{
Config.PatchConfig patches = config.Patches;
- if (ImGui.Checkbox("3x Shadow Resolution", ref tripleShadowResolution))
+ int prevShadowMultiplier = shadowResMultiplier;
+ ImGui.SetNextItemWidth(width * 0.2f);
+ if (ImGui.InputInt("Shadow Resolution Multiplier", ref shadowResMultiplier, 1))
{
- if (tripleShadowResolution)
+ shadowResMultiplier = Math.Clamp(shadowResMultiplier, 1, 5);
+ if (shadowResMultiplier > 1)
{
- tripleShadowResEnable();
+ shadowResEnable(prevShadowMultiplier);
}
else
{
- tripleShadowResDisable();
+ shadowResDisable(prevShadowMultiplier);
}
setShadowQuality.Invoke(MemoryUtil.Read<int>(sMhScene!.Instance + 0x5530) + 1);
- patches.TripleShadowResolution = tripleShadowResolution;
+ patches.ShadowResolutionMultiplier = shadowResMultiplier;
config.Patches = patches;
ConfigManager.SaveConfig<Config>(this);
}
if (ImGui.BeginItemTooltip())
{
- ImGui.Text("In-Game Settings:\n - High: 1.0 -> 3.0\n - Mid: 0.7 -> 2.1\n - Low: 0.5 -> 1.5");
+ ImGui.Text("In-Game Settings:\n - High: 1.0\n - Mid: 0.7\n - Low: 0.5");
ImGui.EndTooltip();
}
- ImGui.SameLine();
- if (ImGui.Checkbox("4x Shadow Resolution", ref quadrupleShadowResolution))
- {
- if (quadrupleShadowResolution)
- {
- shadowRes1_3x.Disable();
- shadowRes1_4x.Enable();
- }
- else
- {
- shadowRes1_4x.Disable();
- shadowRes1_3x.Enable();
- }
- setShadowQuality.Invoke(MemoryUtil.Read<int>(sMhScene!.Instance + 0x5530) + 1);
- }
if (ImGui.Checkbox("Volume Rendering Full Resolution Blur Pass (Requires Area Change)", ref fullResVolumeBlur))
{
@@ -2838,7 +3011,7 @@ namespace WorldTuningTool */
if (ImGui.Button("New"))
{
- interceptCreateLight = true;
+ //interceptCreateLight = true;
nint lightObject = createLight.Invoke(requestLightType);
Vector3 pos = default;
Player? player = Player.MainPlayer;
@@ -2910,29 +3083,39 @@ namespace WorldTuningTool ImGui.PopID();
}
- if (ImGui.CollapsingHeader("Parameters"))
+ bool expanded = ImGui.CollapsingHeader("Parameters");
+ if (ImGui.BeginItemTooltip())
{
- ImGui.Separator();
+ ImGui.Text("(Original: X) may be inaccurate for various reasons, such as\n 1. The game set the parameter to the same value as an override from this mod.\n 2. The game is dynamically updating the parameter in a location unknown to this mod.");
+ ImGui.EndTooltip();
+ }
+ if (expanded)
+ {
+ hqMode.Draw(width);
- if (ImGui.CollapsingHeader("Scene"))
+ ImGui.PushID("LOD");
+ if (ImGui.CollapsingHeader("Level of Detail"))
{
- ImGui.PushID("Scene");
- ImGui.Text($"Address: {sMhScene!.Instance:X}");
- foreach (Parameter param in sceneParameters)
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
+ foreach (Parameter param in lodParameters)
+ {
+ param.Draw(width);
+ }
+ foreach (Parameter param in snowParameters)
{
param.Draw(width);
}
- ImGui.PopID();
}
+ ImGui.PopID();
- if (ImGui.CollapsingHeader("Sun Light/Shadows"))
+ // MonsterHunterWorld.exe+1AB99E0 - mov rax,[MonsterHunterWorld.exe+500E180]
+ nint shadowAddr = MemoryUtil.Read<nint>(0x14500E180);
+ nint shadowObject = MemoryUtil.Read<nint>(shadowAddr + 0x4B0);
+ shadowAddr += 0x5B0;
+ ImGui.PushID("Shadows");
+ if (ImGui.CollapsingHeader("Sunlight and Shadows"))
{
- ImGui.PushID("Shadows");
- // MonsterHunterWorld.exe+1AB99E0 - mov rax,[MonsterHunterWorld.exe+500E180]
- nint shadowAddr = MemoryUtil.Read<nint>(0x14500E180);
- nint shadowObject = MemoryUtil.Read<nint>(shadowAddr + 0x4B0);
- shadowAddr += 0x5B0;
- ImGui.Text($"Address: {shadowAddr:X}, Object: {shadowObject:X}");
+ ImGui.Text($"shadowObject: 0x{shadowAddr:X}, shadowAddr: 0x{shadowObject:X}");
/*
if (ImGui.CollapsingHeader("Pass 1"))
{
@@ -2955,120 +3138,173 @@ namespace WorldTuningTool ImGui.PopID();
}
*/
- ImGui.PopID();
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
+ foreach (Parameter param in shadowCascadeParameters)
+ {
+ param.Draw(width);
+ }
}
+ ImGui.PopID();
+
+ ImGui.PushID("BroadAreaShadows");
+ if (ImGui.CollapsingHeader("Broad Area Shadows"))
+ {
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
+ foreach (Parameter param in broadAreaShadowParameters)
+ {
+ param.Draw(width);
+ }
+ }
+ ImGui.PopID();
+
+ ImGui.PushID("ContactLight");
+ if (ImGui.CollapsingHeader("Contact Light"))
+ {
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
+ foreach (Parameter param in contactShadowParameters)
+ {
+ param.Draw(width);
+ }
+ foreach (Parameter param in capsuleLightParameters)
+ {
+ param.Draw(width);
+ }
+ }
+ ImGui.PopID();
- if (ImGui.CollapsingHeader("Screen-space Ambient Occlusion"))
+ ImGui.PushID("SSAO");
+ if (ImGui.CollapsingHeader("Ambient Occlusion"))
{
- ImGui.PushID("SSAO");
- ImGui.Text($"Address: {sMhScene!.Instance:X}");
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
foreach (Parameter param in ssaoParameters)
{
param.Draw(width);
}
- ImGui.PopID();
}
+ ImGui.PopID();
- if (ImGui.CollapsingHeader("Screen-space Local Reflections"))
+ ImGui.PushID("SSLR");
+ if (ImGui.CollapsingHeader("Reflections"))
{
- ImGui.PushID("SSLR");
- ImGui.Text($"Address: {sMhScene!.Instance:X}");
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
foreach (Parameter param in sslrParameters)
{
param.Draw(width);
}
- ImGui.PopID();
}
+ ImGui.PopID();
+ ImGui.PushID("Passthrough");
+ if (ImGui.CollapsingHeader("Passthrough"))
+ {
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
+ foreach (Parameter param in passthroughParameters)
+ {
+ param.Draw(width);
+ }
+ }
+ ImGui.PopID();
+
+ /*
+ ImGui.PushID("Snow");
+ if (ImGui.CollapsingHeader("Snow"))
+ {
+ ImGui.Text($"Address: 0x{sMhScene!.Instance:X}");
+ foreach (Parameter param in snowParameters)
+ {
+ param.Draw(width);
+ }
+ }
+ ImGui.PopID();
+ */
+
+ ImGui.PushID("Lighting");
+ if (ImGui.CollapsingHeader("Lighting"))
+ {
+ if (lightingObject != 0x0)
+ {
+ ImGui.Text($"Address: 0x{lightingObject:X}");
+ foreach (Parameter param in lightingParameters)
+ {
+ param.Draw(width);
+ }
+ }
+ ImGui.Separator();
+ ImGui.Text($"Address: 0x{sLightProbes!.Instance:X}");
+ foreach (Parameter param in lightProbesParameters)
+ {
+ param.Draw(width);
+ }
+ }
+ ImGui.PopID();
+
+ ImGui.PushID("Bloom");
if (ImGui.CollapsingHeader("Bloom"))
{
- ImGui.PushID("Bloom");
- ImGui.Text($"Address: {bloomObject:X}");
if (bloomObject != 0x0)
{
+ ImGui.Text($"Address: 0x{bloomObject:X}");
foreach (Parameter param in bloomParameters)
{
param.Draw(width);
}
}
}
+ ImGui.PopID();
+ ImGui.PushID("DepthOfField");
if (ImGui.CollapsingHeader("Depth of Field"))
{
- ImGui.PushID("DepthOfField");
- ImGui.Text($"Address: {dofObject:X}");
if (dofObject != 0x0)
{
+ ImGui.Text($"Address: 0x{dofObject:X}");
foreach (Parameter param in dofParameters)
{
param.Draw(width);
}
}
- ImGui.PopID();
}
+ ImGui.PopID();
+ ImGui.PushID("MotionBlur");
if (ImGui.CollapsingHeader("Motion Blur"))
{
- ImGui.PushID("MotionBlur");
- ImGui.Text($"Address: {motionBlurObject:X}");
if (motionBlurObject != 0x0)
{
+ ImGui.Text($"Address: 0x{motionBlurObject:X}");
foreach (Parameter param in motionBlurParameters)
{
param.Draw(width);
}
}
}
+ ImGui.PopID();
+ ImGui.PushID("FXAA");
if (ImGui.CollapsingHeader("FXAA"))
{
- ImGui.PushID("FXAA");
- ImGui.Text($"Address: {fxaaObject:X}");
if (fxaaObject != 0x0)
{
+ ImGui.Text($"Address: 0x{fxaaObject:X}");
foreach (Parameter param in fxaaParameters)
{
param.Draw(width);
}
}
- ImGui.PopID();
- }
-
- if (ImGui.CollapsingHeader("Lighting"))
- {
- ImGui.PushID("Lighting");
- ImGui.Text($"Address: {lightingObject:X}");
- if (lightingObject != 0x0)
- {
- foreach (Parameter param in lightingParameters)
- {
- param.Draw(width);
- }
- }
- ImGui.PopID();
- }
-
- if (ImGui.CollapsingHeader("Light Probes"))
- {
- ImGui.PushID("LightProbes");
- ImGui.Text($"Address: {sLightProbes!.Instance:X}");
- foreach (Parameter param in lightProbesParameters)
- {
- param.Draw(width);
- }
- ImGui.PopID();
}
+ ImGui.PopID();
ImGui.Separator();
}
- if (ImGui.BeginItemTooltip())
- {
- ImGui.Text("\"Original\" values may be inaccurate for multiple reasons, including\n 1. The value was set by the game to the same value as an already applied Override.\n 2. The value is being set per-frame in a location unknown to this mod.");
- ImGui.EndTooltip();
- }
if (ImGui.CollapsingHeader("DEBUG"))
{
+ ImGui.Checkbox("Globally Ignore Parameter Min/Max", ref ignoreMinMax);
+ if (ImGui.BeginItemTooltip())
+ {
+ ImGui.Text("Some min/max values are set to avoid crashes, so be warned.");
+ ImGui.EndTooltip();
+ }
ImGui.PushItemWidth(width * 0.15f);
ImGui.Text($"FPS: {MemoryUtil.GetRef<float>(sMain!.Instance + 0x68)}");
ImGui.Text($"Delta Time: {MemoryUtil.GetRef<float>(sMain!.Instance + 0x94)}");
@@ -3081,8 +3317,6 @@ namespace WorldTuningTool }
ImGui.InputFloat("Max FPS", ref MemoryUtil.GetRef<float>(sMain!.Instance + 0x5C));
ImGui.PopItemWidth();
- ImGui.Text($"sLightLinker: {sLightLinker!.Instance:X}");
- ImGui.Text($"sMhSpeedTree: {sMhSpeedTree!.Instance:X}");
}
}
|