diff options
| author | 2026-11-11 21:16:07 -0500 | |
|---|---|---|
| committer | 2026-11-11 21:21:50 -0500 | |
| commit | 72083036f686f8d6e5b7def5db4b401e3f351aba (patch) | |
| tree | 5da70c56cd15b28254aea89b6aa13016f593f636 | |
| download | PlayerPoser-master.tar.gz PlayerPoser-master.tar.bz2 PlayerPoser-master.zip | |
Signed-off-by: Andrew Opalach <andrew@akon.city>
| -rw-r--r-- | Animal.cs | 178 | ||||
| -rw-r--r-- | Armor.cs | 3111 | ||||
| -rw-r--r-- | Models.cs | 568 | ||||
| -rw-r--r-- | PlayerPoser.csproj | 26 | ||||
| -rw-r--r-- | PlayerPoser.sln | 22 | ||||
| -rw-r--r-- | Plugin.cs | 722 | ||||
| -rw-r--r-- | README.txt | 3 | ||||
| -rw-r--r-- | Utility.cs | 214 | ||||
| -rw-r--r-- | Zone.cs | 343 |
9 files changed, 5187 insertions, 0 deletions
diff --git a/Animal.cs b/Animal.cs new file mode 100644 index 0000000..f15da23 --- /dev/null +++ b/Animal.cs @@ -0,0 +1,178 @@ +using SharpPluginLoader.Core.Memory; + +namespace SharpPluginLoader.Core.Entities +{ + public class Animal : Entity + { + /// <summary> + /// Gets a list of all animals in the game + /// </summary> + /// <returns></returns> + public static Animal[] GetAllAnimals() + { + lock (_animals) return _animals.ToArray(); + } + + /// <summary> + /// Constructs a new Animal from a native pointer + /// </summary> + /// <param name="instance">The native pointer</param> + public Animal(nint instance) : base(instance) { } + + // @TODO: Map to names. + public int Id => Get<int>(0x1AF8); // +0x294 + public int OtherId => Get<int>(0x1AF0); + + private static nint uGmAnimalCtorHook(nint unknownPtr, int unknownInt) + { + nint animalObject = _uGmAnimalCtor.Original(unknownPtr, unknownInt); + lock (_animals) _animals.Add(new(animalObject)); + return animalObject; + } + + private static nint uGmAnimalDestructorHook(nint animalObject) + { + lock(_animals) + { + for (int i = 0; i < _animals.Count; i++) + { + if (_animals[i].Instance == animalObject) + { + _animals.RemoveAt(i); + break; + } + } + } + return _uGmAnimalDestructor.Original(animalObject); + } + + internal static void Initialize() + { + _uGmAnimalCtor = Hook.Create<uGmAnimalCtor>(0x141D285C0, uGmAnimalCtorHook); + _uGmAnimalDestructor = Hook.Create<uGmAnimalDestructor>(0x141D289D0, uGmAnimalDestructorHook); + } + + private delegate nint uGmAnimalCtor(nint unknownPtr, int unknownInt); + private delegate nint uGmAnimalDestructor(nint animalObject); + private static Hook<uGmAnimalCtor> _uGmAnimalCtor = null!; + private static Hook<uGmAnimalDestructor> _uGmAnimalDestructor = null!; + private static readonly List<Animal> _animals = []; + } + + /// <summary> + /// Represents an animal id + /// </summary> + public enum AnimalType : uint + { + /* + Shepherd Hare = 1, + Pilot Hare = 1, + Woodland Pteryx = 2, + Forest Pteryx = 2, + Cobalt Flutterfly = 3, + Phantom Flutterfly = 3, + Climbing Joyperch = 4, + Forest Gekko = 5, + Wildspire Gekko = 5, + Gloom Gekko = 5, + Moonlight Gekko = 5, + Vaporonid = 6, + Scavantula = 6, + Revolture = 7, + Blissbill = 7, + Stonebill = 7, + Omenfly = 8, + Augurfly = 8, + Scalebat = 9, + Gold Scalebat = 9, + Dung Beetle = 10, + Bomb Beetle = 10, + Rime Beetle = 10, + Pink Parexus = 11, + Great Pink Parexus = 11, + Burst Arowana = 12, + Bomb Arowana = 12, + Great Burst Arowana = 12, + Great Bomb Arowana = 12, + Elegant Coralbird = 13, + Dapper Coralbird = 13, + Andangler = 14, + Downy Crake = 15, + Bristly Crake = 15, + Hopguppy = 16, + Petricanths = 17, + Paratoad = 18, + Sleeptoad = 18, + Nitrotoad = 18, + Wiggler = 19, + Wiggler Queen = 19, + Vigorwasp = 20, + Giant Vigorwasp = 20, + Flying Meduso = 21, + Carrier Ant = 22, + Hercudrome = 23, + Gold Hercudrome = 23, + Prism Hercudrome = 23, + Emperor Hopper = 24, + Tyrant Hopper = 24, + Flashfly = 25, + 羽虫 = 26, + ハエ = 27, + ハチ = 28, + 蛍 = 29, + Grandfather Mantagrell = 30, + Iron Helmcrab = 31, + Soldier Helmcrab = 31, + Emerald Helmcrab = 31, + Gold Helmcrab = 31, + Shiny Gold Helmcrab = 31, + 苦蟲 = 32, + 光蟲 = 32, + 不死蟲 = 32, + 雷光蟲 = 32, + 佳餚蟲 = 32, + Whetfish = 33, + Great Whetfish = 33, + Gastronome Tuna = 34, + Great Gastronome Tuna = 34, + King Marlin = 35, + Great King Marlin = 35, + 楔虫 = 36, + Goldenfish = 37, + Platinumfish = 37, + Great Goldenfish = 37, + Great Platinumfish = 37, + Goldenfry = 38, + Great Goldenfry = 38, + Sushifish = 39, + Great Sushifish = 39, + Gunpowderfish = 40, + Great Gunpowderfish = 40, + Copper Calappa = 41, + Gold Calappa = 41, + Tsuchinoko = 42, + Cactuar = 43, + Cactuar Cutting = 43, + Flowering Cactuar Cutting = 43, + Nekker = 44, + Pearlspring Macaque = 50, + Goldspring Macaque = 50, + Crowned Prawn = 51, + Moon Slug = 52, + Duffel Penguin = 53, + Arrowhead Gekko = 54, + Blue Diva = 55, + Sealord's Crestfish = 56, + Glass Parexus = 57, + Great Glass Parexus = 57, + Wintermoon Nettle = 58, + Moly = 59, + Mossy Moly = 59, + Rocky Moly = 59, + Fluffy Moly = 59, + Spiny Moly = 59, + Rowdy Moly = 59, + Frosty Moly = 59 + */ + } +} diff --git a/Armor.cs b/Armor.cs new file mode 100644 index 0000000..3fef15f --- /dev/null +++ b/Armor.cs @@ -0,0 +1,3111 @@ +//#define QUARANTINED_FEATURES +//#define HOOK_ORDER_ASSERTS +//#define ALT_TEXTURE_LOAD + +using System.Numerics; +using System.Text.Json; + +using ImGuiNET; +using SharpPluginLoader.Core; +using SharpPluginLoader.Core.MtTypes; +using SharpPluginLoader.Core.Entities; +using SharpPluginLoader.Core.Memory; +using SharpPluginLoader.Core.Rendering; +using SharpPluginLoader.Core.Resources; +#if ALT_TEXTURE_LOAD +using SharpPluginLoader.Core.IO; +#endif +using WorldTuningTool; + +namespace PlayerPoser +{ + using static Utility; + using static WorldTuningTool.PFuncs; + + internal static unsafe class Armor + { + private const string posePath = "nativePC/plugins/CSharp/Poses"; + + private class BaseMaterial + { + public int Index = -1; + public nint Address = 0x0; + public List<Parameter> Parameters = new(); + public virtual string Name => "Material"; + public virtual int Order => -1; + + public BaseMaterial() { } + + public void Update(nint paramsAddr) + { + Address = paramsAddr; + foreach (Parameter param in Parameters) + { + param.Update(paramsAddr); + } + } + + public void Draw(float width) + { + if (Address != 0x0) + { + ImGui.PushID(this.GetHashCode()); + if (ImGui.CollapsingHeader(Name)) + { + ImGui.Text($"Address: 0x{Address:X} (index: {Index})"); + foreach (Parameter param in Parameters) + { + int overrideSet = param.Draw(width); + // Depends on parameters being set exclusively from the UI. + activeMaterialOverrides += overrideSet; + } + } + ImGui.PopID(); + } + } + } + + private class MhMaterialCommon : BaseMaterial + { + public override string Name => "MhMaterialCommon"; + public override int Order => 0; + + public MhMaterialCommon() : base() + { + Parameters.AddRange(new Parameter[]{ + P<bool>("Bypass", 0x0, ParameterType.BOOL), + P<bool>("Decal Mask", 0x4, ParameterType.BOOL), + P<bool>("Emissive", 0x8, ParameterType.BOOL), + P<byte>("GBuffer ID", 0xC, ParameterType.BYTE, pStep((byte)1)), + P<byte>("Outline ID", 0x10, ParameterType.BYTE, pStep((byte)1)), + }); + } + } + + private class BasePLMaterial : BaseMaterial + { + public override string Name => "PLMaterial"; + public override int Order => 1; + + public BasePLMaterial() : base() + { + Parameters.AddRange(new Parameter[]{ + P<float>("Base Map Factor", 0x0, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Emissive Factor", 0x10, ParameterType.VECTOR3), + P<float>("Metalic", 0x1C, ParameterType.FLOAT, pStep(0.001f)), + P<float>("Roughness", 0x20, ParameterType.FLOAT, pStep(0.001f)), + P<float>("Specular", 0x24, ParameterType.FLOAT, pStep(0.001f)), + P<float>("Sub Surface Blend", 0x28, ParameterType.FLOAT, pStep(0.001f)), + P<int>("Sub Surface Profile", 0x2C, ParameterType.INT, pStep(1)), + P<float>("Translucency", 0x30, ParameterType.FLOAT, pStep(0.001f)), + P<bool>("Base Color Emissive", 0x34, ParameterType.BOOL), + P<bool>("Back Face Normal Flip", 0x38, ParameterType.BOOL), + P<float>("Anim Emit Min", 0x3C, ParameterType.FLOAT), + P<float>("Anim Emit Speed", 0x40, ParameterType.FLOAT), + }); + } + } + + private class MhMaterialPLLocal : BasePLMaterial + { + public override string Name => "MhMaterialPLLocal"; + public override int Order => 2; + + public MhMaterialPLLocal() : base() + { + Parameters.AddRange(new Parameter[]{ + P<bool>("Use CMM", 0x44, ParameterType.BOOL), + P<float>("Add Color A", 0x50, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Add Color B", 0x60, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Add Color C", 0x70, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Add Color D", 0x80, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Fur Param", 0x90, ParameterType.VECTOR4), + P<float>("Fur Tile", 0xA0, ParameterType.FLOAT), + P<float>("Snow Control", 0xB0, ParameterType.VECTOR4), + P<float>("Material Snow Blend A", 0xC0, ParameterType.FLOAT), + P<float>("Material Snow Blend B", 0xC4, ParameterType.FLOAT), + P<float>("Snow Tile", 0xC8, ParameterType.FLOAT), + P<float>("Snow Color", 0xD0, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Snow Mat Control", 0xE0, ParameterType.VECTOR4), + P<float>("Snow UV Offset", 0xF0, ParameterType.VECTOR2), + P<float>("Anim Emit Wave", 0xF8, ParameterType.FLOAT), + P<bool>("Use Emit Wave", 0xFC, ParameterType.BOOL), + P<float>("Film Thickness", 0x100, ParameterType.FLOAT), + P<float>("Film Blend", 0x104, ParameterType.FLOAT), + P<float>("Film IOR", 0x108, ParameterType.FLOAT), + P<float>("Refract Blend", 0x10C, ParameterType.FLOAT), + P<float>("Refraction", 0x110, ParameterType.FLOAT), + P<float>("Panorama Tile", 0x114, ParameterType.FLOAT), + P<float>("Emissive Blend Color", 0x120, ParameterType.VECTOR3, pStep(0.001f)), + P<float>("Emissive Blend Color Blend", 0x12C, ParameterType.FLOAT), + P<float>("Emissive Blend Rim Param", 0x130, ParameterType.VECTOR3), + P<float>("Detail Normal Blend", 0x13C, ParameterType.FLOAT), + P<float>("UV Transform Detail Normal", 0x140, ParameterType.VECTOR4) + }); + } + } + + private class MhMaterialPLSkinLocal : BasePLMaterial + { + public override string Name => "MhMaterialPLSkinLocal"; + public override int Order => 3; + + public MhMaterialPLSkinLocal() : base() + { + Parameters.AddRange(new Parameter[]{ + P<float>("Add Color UV", 0x44, ParameterType.VECTOR2, pStep(0.001f)), + P<bool>("Use CMM", 0x4C, ParameterType.BOOL), + P<float>("Add Color A", 0x50, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Add Color B", 0x60, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Detail Normal Blend", 0x70, ParameterType.FLOAT), + P<float>("UV Transform Detail Normal", 0x80, ParameterType.VECTOR4) + }); + } + } + + private class MhMaterialPLHairLocal : BasePLMaterial + { + public override string Name => "MhMaterialPLHairLocal"; + public override int Order => 4; + + public MhMaterialPLHairLocal() : base() + { + Parameters.AddRange(new Parameter[]{ + P<float>("Primary Color", 0x50, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Secondary Color", 0x60, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Primary Expo", 0x70, ParameterType.FLOAT), + P<float>("Secondary Expo", 0x74, ParameterType.FLOAT), + P<float>("Primary Shift", 0x78, ParameterType.FLOAT), + P<float>("Secondary Shift", 0x7C, ParameterType.FLOAT), + P<float>("Shininess", 0x80, ParameterType.FLOAT), + P<float>("Fake Light Direction", 0x84, ParameterType.VECTOR3), + P<float>("Fur Height", 0x90, ParameterType.FLOAT), + P<float>("Fur Param", 0x94, ParameterType.VECTOR4), + P<float>("Fur Tile", 0xA4, ParameterType.FLOAT), + P<float>("Vertex AO", 0xA8, ParameterType.VECTOR4), + P<float>("V Color Normal Blend", 0xB8, ParameterType.FLOAT), + P<float>("Rim Width", 0xBC, ParameterType.FLOAT), + P<float>("Rim Normal Blend", 0xC0, ParameterType.FLOAT), + P<bool>("Use Rim Translucency", 0xC4, ParameterType.BOOL), + P<bool>("Use Offset", 0xC8, ParameterType.BOOL), + P<float>("Inner Offset Scale", 0xCC, ParameterType.FLOAT), + P<float>("Detail Normal Blend", 0xD0, ParameterType.FLOAT), + P<float>("UV Transform Detail Normal", 0xD4, ParameterType.VECTOR4) + }); + } + } + + private class MhMaterialPLEditFaceLocal : BasePLMaterial + { + public override string Name => "MhMaterialPLEditFaceLocal"; + public override int Order => 5; + + public MhMaterialPLEditFaceLocal() : base() + { + Parameters.AddRange(new Parameter[]{ + P<float>("Add Color UV", 0x44, ParameterType.VECTOR2, pStep(0.001f)), + P<float>("Add Normal Mask A", 0x50, ParameterType.VECTOR4), + P<float>("Add Normal Mask B", 0x60, ParameterType.VECTOR4), + P<float>("Add Normal Mask C", 0x70, ParameterType.VECTOR4), + P<float>("Add Normal Mask D", 0x80, ParameterType.VECTOR4), + P<float>("Paint Map RC", 0x90, ParameterType.VECTOR2), + P<float>("Paint Map Num", 0x98, ParameterType.FLOAT), + P<float>("Paint Map Offset", 0xA0, ParameterType.VECTOR4), + P<float>("Paint Color", 0xB0, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Paint Roughness", 0xC0, ParameterType.FLOAT), + P<float>("Paint Metal", 0xC4, ParameterType.FLOAT), + P<float>("Paint Map Num B", 0xC8, ParameterType.FLOAT), + P<float>("Paint Map Offset B", 0xD0, ParameterType.VECTOR4), + P<float>("Paint Color B", 0xE0, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Paint Roughness B", 0xF0, ParameterType.FLOAT), + P<float>("Paint Metal B", 0xF4, ParameterType.FLOAT), + P<float>("Paint Map Num C", 0xF8, ParameterType.FLOAT), + P<float>("Paint Map Offset C", 0x100, ParameterType.VECTOR4), + P<float>("Paint Color C", 0x110, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<float>("Paint Roughness C", 0x120, ParameterType.FLOAT), + P<float>("Paint Metal C", 0x124, ParameterType.FLOAT), + P<float>("Face Normal Blend", 0x128, ParameterType.VECTOR2), + P<float>("Mayu Map Num", 0x130, ParameterType.FLOAT), + P<float>("Mayu Map Offset", 0x134, ParameterType.VECTOR2), + P<float>("Mayu Map RC", 0x140, ParameterType.VECTOR2), + P<float>("Mayu Color", 0x150, ParameterType.COLOR_FACTOR, pStep(0.001f)), + P<bool>("Paint Emit", 0x160, ParameterType.BOOL), + P<bool>("Paint Emit B", 0x164, ParameterType.BOOL), + P<bool>("Paint Emit C", 0x168, ParameterType.BOOL), + P<float>("Paint Emit Intensity", 0x170, ParameterType.VECTOR3), + P<float>("Paint Emit Intensity Multiply", 0x17C, ParameterType.FLOAT), + P<bool>("Paint Normal", 0x180, ParameterType.BOOL), + P<bool>("Paint Shade", 0x184, ParameterType.BOOL), + P<bool>("Paint Normal B", 0x188, ParameterType.BOOL), + P<bool>("Paint Shade B", 0x18C, ParameterType.BOOL), + P<bool>("Paint Normal C", 0x190, ParameterType.BOOL), + P<bool>("Paint Shade C", 0x194, ParameterType.BOOL), + P<float>("Fake Light Blend", 0x198, ParameterType.FLOAT), + P<float>("Fake Light Intensity", 0x19C, ParameterType.FLOAT), + P<float>("Fake Face Light Direction", 0x1A0, ParameterType.VECTOR3), + P<float>("Fake Shadow Intensity", 0x1AC, ParameterType.FLOAT), + P<float>("Fake Shadow Length", 0x1B0, ParameterType.FLOAT), + P<float>("Detail Normal Blend", 0x1B4, ParameterType.FLOAT), + P<float>("UV Transform Detail Normal", 0x1C0, ParameterType.VECTOR4) + }); + } + } + + private static class Part + { + internal const byte Helmet = 0; + internal const byte Body = 1; + internal const byte Arms = 2; + internal const byte Waist = 3; + internal const byte Legs = 4; + internal const byte Slinger = 5; + internal const byte Hair = 6; + internal const byte Face = 7; + internal const byte EyeLens = 8; + } + + private static class Joint + { + public const byte Root = 0x0; + public const byte Root2 = 0xD; + public const byte LowerBack = 0x1; + public const byte UpperBack = 0x2; + public const byte LowerNeck = 0x3; + public const byte LowerNeckNull = 0xFE; + public const byte UpperNeck = 0x4; + public const byte LeftCollarbone = 0x5; + public const byte LeftShoulderNull = 0x46; + public const byte LeftShoulder = 0x6; + public const byte LeftElbow = 0x7; + public const byte LeftWrist = 0x8; + public const byte LeftWristNull = 0x1E; + public const byte LeftThumbLow = 0x1F; + public const byte LeftThumbMid = 0x20; + public const byte LeftThumbHigh = 0x21; + public const byte LeftIndexLow = 0x22; + public const byte LeftIndexMid = 0x23; + public const byte LeftIndexHigh = 0x24; + public const byte LeftMiddleLow = 0x25; + public const byte LeftMiddleMid = 0x26; + public const byte LeftMiddleHigh = 0x27; + public const byte LeftPalm = 0x28; + public const byte LeftRingLow = 0x29; + public const byte LeftRingMid = 0x2A; + public const byte LeftRingHigh = 0x2B; + public const byte LeftPinkyLow = 0x2C; + public const byte LeftPinkyMid = 0x2D; + public const byte LeftPinkyHigh = 0x2E; + public const byte LeftArmUnk1 = 0x51; + public const byte LeftArmUnk2 = 0x65; + public const byte LeftArmUnk3 = 0x66; + public const byte LeftArmUnk4 = 0x67; + public const byte LeftArmUnk5 = 0x68; + public const byte LeftArmUnk6 = 0x47; + public const byte LeftArmUnk7 = 0x50; + public const byte RightCollarbone = 0x9; + public const byte RightShoulder = 0xA; + public const byte RightElbow = 0xB; + public const byte RightWrist = 0xC; + public const byte RightWristNull = 0x2F; + public const byte RightThumbLow = 0x30; + public const byte RightThumbMid = 0x31; + public const byte RightThumbHigh = 0x32; + public const byte RightIndexLow = 0x33; + public const byte RightIndexMid = 0x34; + public const byte RightIndexHigh = 0x35; + public const byte RightMiddleLow = 0x36; + public const byte RightMiddleMid = 0x37; + public const byte RightMiddleHigh = 0x38; + public const byte RightPalm = 0x39; + public const byte RightRingLow = 0x3A; + public const byte RightRingMid = 0x3B; + public const byte RightRingHigh = 0x3C; + public const byte RightPinkyLow = 0x3D; + public const byte RightPinkyMid = 0x3E; + public const byte RightPinkyHigh = 0x3F; + public const byte RightArmUnk1 = 0x53; + public const byte RightArmUnk2 = 0x49; + public const byte RightArmUnk3 = 0x52; + public const byte RightArmUnk4 = 0x48; + public const byte Unknown1 = 0xF7; + public const byte Unknown2 = 0xF8; + public const byte LeftHip = 0xE; + public const byte LeftKnee = 0xF; + public const byte LeftAnkle = 0x10; + public const byte LeftToes = 0x11; + public const byte LeftAnkleNull = 0x54; + public const byte LeftKneeNull = 0x4B; + public const byte LeftHipNull = 0x4A; + public const byte Unknown3 = 0x40; + public const byte Unknown4 = 0x42; + public const byte RightHip = 0x12; + public const byte RightKnee = 0x13; + public const byte RightAnkle = 0x14; + public const byte RightToes = 0x15; + public const byte RightAnkleNull = 0x55; + public const byte RightKneeNull = 0x4D; + public const byte RightHipNull = 0x4C; + public const byte Unknown5 = 0x43; + public const byte Unknown6 = 0x45; + public const byte Unknown7 = 0xF9; + public const byte Unknown8 = 0xFA; + public const byte Unknown9 = 0xFB; + public const byte Unknown10 = 0xFC; + public const byte Unknown11 = 0xFD; + } + + private static class FaceJoint + { + public const byte LeftCheek1 = 0x6C; + public const byte LeftCheek2 = 0x99; + public const byte RightCheek1 = 0x71; + public const byte RightCheek2 = 0x9E; + public const byte RightCheek3 = 0x70; + public const byte LeftCheek3 = 0x6B; + public const byte RightCheek4 = 0x6F; + public const byte LeftCheek4 = 0x6A; + public const byte RightCheek5 = 0x72; + public const byte LeftCheek5 = 0x6D; + public const byte LeftCheek = 0x6E; + public const byte RightCheek = 0x73; + public const byte LeftEye = 0x3A; + public const byte LeftEye1 = 0x3B; + public const byte LeftEye2 = 0x43; + public const byte LeftEye3 = 0x42; + public const byte LeftEye4 = 0x41; + public const byte LeftEye5 = 0x40; + public const byte LeftEye6 = 0x3F; + public const byte LeftEye7 = 0x46; + public const byte LeftEye8 = 0x45; + public const byte LeftEye9 = 0x44; + public const byte LeftEye10 = 0x3C; + public const byte LeftEye11 = 0x3E; + public const byte LeftEye12 = 0x3D; + public const byte LeftEye13 = 0x68; + public const byte RightEye = 0x47; + public const byte RightEye1 = 0x48; + public const byte RightEye2 = 0x50; + public const byte RightEye3 = 0x4F; + public const byte RightEye4 = 0x4E; + public const byte RightEye5 = 0x4D; + public const byte RightEye6 = 0x4C; + public const byte RightEye7 = 0x51; + public const byte RightEye8 = 0x52; + public const byte RightEye9 = 0x53; + public const byte RightEye10 = 0x4A; + public const byte RightEye11 = 0x4B; + public const byte RightEye12 = 0x49; + public const byte RightEye13 = 0x69; + public const byte Nose = 0x54; + public const byte Nose1 = 0x55; + public const byte Nose2 = 0x56; + public const byte Nose3 = 0x58; + public const byte Nose4 = 0x64; + public const byte Nose5 = 0x5E; + public const byte Nose6 = 0x5F; + public const byte Nose7 = 0x65; + public const byte Nose8 = 0x5C; + public const byte Nose9 = 0x62; + public const byte Nose10 = 0x5D; + public const byte Nose11 = 0x63; + public const byte Nose12 = 0x5B; + public const byte Nose13 = 0x61; + public const byte Nose14 = 0x5A; + public const byte Nose15 = 0x60; + public const byte Nose16 = 0x57; + public const byte Nose17 = 0x59; + public const byte Nose18 = 0x66; + public const byte Nose19 = 0x67; + public const byte Mouth = 0x75; + public const byte Mouth1 = 0x80; + public const byte Mouth2 = 0x81; + public const byte Mouth3 = 0x86; + public const byte Mouth4 = 0x85; + public const byte Mouth5 = 0x84; + public const byte Mouth6 = 0x83; + public const byte Mouth7 = 0x82; + public const byte Mouth8 = 0x8B; + public const byte Mouth9 = 0x8A; + public const byte Mouth10 = 0x89; + public const byte Mouth11 = 0x88; + public const byte Mouth12 = 0x87; + public const byte Mouth13 = 0x8F; + public const byte Mouth14 = 0x8E; + public const byte Mouth15 = 0x90; + public const byte Mouth16 = 0x8D; + public const byte Mouth17 = 0x91; + public const byte Mouth18 = 0x8C; + public const byte Mouth19 = 0x92; + public const byte Mouth20 = 0x76; + public const byte Mouth21 = 0x77; + public const byte Mouth22 = 0x78; + public const byte Mouth23 = 0x79; + public const byte Mouth24 = 0x7A; + public const byte Mouth25 = 0x7F; + public const byte Mouth26 = 0x7E; + public const byte Mouth27 = 0x7D; + public const byte Mouth28 = 0x7C; + public const byte Mouth29 = 0x7B; + public const byte Mouth30 = 0x74; + public const byte ChinMiddle = 0x94; + public const byte ChinRight = 0x9C; + public const byte ChinLeft = 0x9B; + public const byte ChinRightBack = 0x9D; + public const byte ChinLeftBack = 0x9A; + public const byte NeckMiddle = 0xA0; + public const byte Jaw = 0x97; + public const byte Jaw1 = 0xEA; + public const byte Jaw2 = 0xEB; + public const byte JawLeft = 0x98; + public const byte JawRight = 0x96; + public const byte JawUpLeft = 0x93; + public const byte JawUpRight = 0x95; + public const byte NeckLeft = 0x9F; + public const byte NeckRight = 0xA1; + public const byte EyeAgainLeft = 0xF4; + public const byte EyeAgainLeft1 = 0xF5; + public const byte NoseAgain = 0xF6; + public const byte MouthAgain = 0xF7; + public const byte Forehead0 = 0xF8; + public const byte Forehead = 0xA2; + public const byte Forehead1 = 0x36; + public const byte Forehead2 = 0x37; + public const byte Forehead3 = 0x38; + public const byte Forehead4 = 0x35; + public const byte Forehead5 = 0x34; + public const byte Forehead6 = 0x33; + public const byte Forehead7 = 0x32; + public const byte Forehead8 = 0x2E; + public const byte Forehead9 = 0x2D; + public const byte Forehead10 = 0x2F; + public const byte Forehead11 = 0x2C; + public const byte Forehead12 = 0x30; + public const byte Forehead13 = 0x31; + public const byte Forehead14 = 0x39; + public const byte Base1 = 0xFB; + public const byte Base2 = 0xFC; + public const byte Base3 = 0xFD; + } + + private static nint[] playerArmor = new nint[9]; + private static nint lastBodyArmor = 0x0; + private static List<nint> playerWeapon = new(); + private static nint[] bodyJointMap = new nint[0xFF]; + private static nint[] faceJointMap = new nint[0xFF]; + + private static bool retryArmorRefresh = false; + private static bool retryWeaponRefresh = false; + + private delegate void UpdatePlayerArmor(nint cpPlCombineArmorCtrl, int index, int armorId); + private static Hook<UpdatePlayerArmor>? updatePlayerArmor; + + private delegate void ChangeWeapon(nint playerAddr, WeaponType weaponType, int weaponId); + private static Hook<ChangeWeapon>? changeWeaponHook; + + private delegate void UpdateModel(nint model); + private static Hook<UpdateModel>? updateModelHook; + private static Hook<UpdateModel>? updateJointRotationHook; + private static Hook<UpdateModel>? updateHairJoints; + + private static List<nint> bodyJoints = new(); + private static Dictionary<nint, Vector4> bodyRotations = new(); + private static Dictionary<nint, Vector3> bodyPositions = new(); + private static Dictionary<nint, Vector3> bodyOffsets = new(); + + private static List<nint> faceJoints = new(); + private static Dictionary<nint, Vector4> faceRotations = new(); + private static Dictionary<nint, Vector3> facePositions = new(); + private static Dictionary<nint, Vector3> faceOffsets = new(); + + private static List<nint> hairJoints = new(); + private static Dictionary<nint, Vector4> hairRotations = new(); + private static Dictionary<nint, Vector3> hairOffsets = new(); + + private static Dictionary<nint, List<nint>> jiggleBones = new(); + + private static bool ikForcedOff = false; + private static Patch forceDisableIK; +#if QUARANTINED_FEATURES + private delegate void UpdateIKPosition(nint ikObject, nint joint, nint obj); + private static Hook<UpdateIKPosition>? updateIKPositionHook; + private static List<nint> ikJoints = new(); + private static Dictionary<nint, List<Vector3>> ikOffsets = new(); +#endif + + private static NativeFunction<nint, int, nint> getMaterialParams1; + private static NativeFunction<nint, uint, nint> getMaterialParams2; + private static int activeMaterialOverrides = 0; + private static List<BaseMaterial> helmetMaterials = new(); + private static List<BaseMaterial> bodyMaterials = new(); + private static List<BaseMaterial> armsMaterials = new(); + private static List<BaseMaterial> waistMaterials = new(); + private static List<BaseMaterial> legsMaterials = new(); + private static List<BaseMaterial> slingerMaterials = new(); + private static List<BaseMaterial> faceMaterials = new(); + private static List<BaseMaterial> hairMaterials = new(); + private static List<List<BaseMaterial>> allMaterialLists = new() + { + helmetMaterials, + bodyMaterials, + armsMaterials, + waistMaterials, + legsMaterials, + slingerMaterials, + faceMaterials, + hairMaterials + }; + + private static bool skinToneSet = false; + private static Vector2 currentSkinTone = new(); + private static Texture? skinAddTexture = null; + private static TextureHandle skinAddTextureHandle = TextureHandle.Invalid; + + private static bool ignoreFullArmorFace = false; + private static Patch jmpOverExtFace; + private static Patch jmpOverExtHair; + + private static bool ignoreHideSlinger = false; + private static Patch jmpOverHideSlinger; + + internal static void Initialize() + { + updatePlayerArmor = Hook.Create<UpdatePlayerArmor>(0x1412F0D40, UpdatePlayerArmorHook); + + changeWeaponHook = Hook.Create<ChangeWeapon>(0x141F5A410, ChangeWeaponHook); + + forceDisableIK = new Patch(0x14031FD40, [0xC6, 0x81, 0x81, 0x01, 0x00, 0x00, 0x00, 0xC3]); + + updateModelHook = Hook.Create<UpdateModel>(0x141FBCCD0, UpdateModelHook); + updateJointRotationHook = Hook.Create<UpdateModel>(0x14223BA30, UpdateJointRotationHook); + updateHairJoints = Hook.Create<UpdateModel>(0x1420499A0, UpdateHairJointsHook); +#if QUARANTINED_FEATURES + updateIKPositionHook = Hook.Create<UpdateIKPosition>(0x142472C00, UpdateIKPositionHook); +#endif + + getMaterialParams1 = new NativeFunction<nint, int, nint>(0x14222F910); + getMaterialParams2 = new NativeFunction<nint, uint, nint>(0x14235E400); + + jmpOverExtFace = new Patch(0x141258654, [0xEB]); + jmpOverExtHair = new Patch(0x1412586C2, [0xEB]); + + jmpOverHideSlinger = new Patch(0x1412EE1D7, [0xEB]); + } + +#if HOOK_ORDER_ASSERTS + private static int hookOrder = 1; +#endif + + internal static void OnUpdate() + { +#if HOOK_ORDER_ASSERTS + hookOrder = 0; +#endif + + Player? player = getPlayer(); + if (player != null) + { + if (retryArmorRefresh) + { + refreshArmorState(player); + } + + if (retryWeaponRefresh) + { + refreshWeaponState(player); + } + } + } + + internal static void OnPlayerChange() + { + Player? player = getPlayer(); + if (player != null) + { + retryArmorRefresh = true; + refreshArmorState(player); + retryWeaponRefresh = true; + refreshWeaponState(player); + } + } + + private static void UpdatePlayerArmorHook(nint cpPlCombineArmorCtrl, int index, int armorId) + { + updatePlayerArmor!.Original(cpPlCombineArmorCtrl, index, armorId); + + Player? player = null; + if (index == Part.Legs && (player = getPlayer()) != null) + { + retryArmorRefresh = true; + refreshArmorState(player); + } + } + + private static void ChangeWeaponHook(nint playerAddr, WeaponType weaponType, int weaponId) + { + changeWeaponHook!.Original(playerAddr, weaponType, weaponId); + Player? player = getPlayer(); + if (player != null && player.Instance == playerAddr) + { + retryWeaponRefresh = true; + refreshWeaponState(player); + } + } + + private static void dropArmorState() + { + Array.Clear(playerArmor, 0, playerArmor.Length); + Array.Clear(bodyJointMap, 0, bodyJointMap.Length); + Array.Clear(faceJointMap, 0, faceJointMap.Length); + bodyJoints.Clear(); + faceJoints.Clear(); + hairJoints.Clear(); + jiggleBones.Clear(); +#if QUARANTINED_FEATURES + ikJoints.Clear(); +#endif + } + + private static void dropWeaponState() + { + playerWeapon.Clear(); + } + + private static void dropJointOffsets() + { + bodyRotations.Clear(); + bodyPositions.Clear(); + bodyOffsets.Clear(); + faceRotations.Clear(); + facePositions.Clear(); + faceOffsets.Clear(); + hairRotations.Clear(); + hairOffsets.Clear(); +#if QUARANTINED_FEATURES + ikOffsets.Clear(); +#endif + } + + private static void resetMaterials() + { + foreach (List<BaseMaterial> partMaterials in allMaterialLists) + { + foreach (BaseMaterial material in partMaterials) + { + material.Update(0x0); + } + } + } + + private static void probeMaterial<T>(nint partAddr, nint paramsAddr, int index, uint code, List<BaseMaterial> partMaterials) where T : BaseMaterial, new() + { + nint paramsAddr2 = getMaterialParams2.Invoke(paramsAddr, code); + if (paramsAddr2 != 0x0) + { + foreach (BaseMaterial material in partMaterials) + { + if (material is T && material.Index == index) + { + material.Update(paramsAddr2); + return; + } + } + T newMaterial = new(); + partMaterials.Add(newMaterial); + newMaterial.Index = index; + newMaterial.Update(paramsAddr2); + } + } + + private static void probePartForMaterials(nint partAddr, List<BaseMaterial> partMaterials) + { + if (partAddr == 0x0) + { + return; + } + nint paramsAddr; + for (int i = 0; ;i++) + { + paramsAddr = getMaterialParams1.Invoke(partAddr, i); + if (paramsAddr == 0x0) break; + // Makeup: [2E0]DCDC0 [BFC8B]000 + probeMaterial<MhMaterialCommon>(partAddr, paramsAddr, i, 0xB2732092, partMaterials); + probeMaterial<MhMaterialPLLocal>(partAddr, paramsAddr, i, 0x120B83B2, partMaterials); + probeMaterial<MhMaterialPLSkinLocal>(partAddr, paramsAddr, i, 0xBFC8B2E0, partMaterials); + probeMaterial<MhMaterialPLHairLocal>(partAddr, paramsAddr, i, 0xCE0DE378, partMaterials); + probeMaterial<MhMaterialPLEditFaceLocal>(partAddr, paramsAddr, i, 0xCA04A371, partMaterials); + } + partMaterials.Sort(delegate(BaseMaterial x, BaseMaterial y) + { + if (y.Order == x.Order) + { + if (y.Address != 0x0 && x.Address == 0x0) return 1; + else if (x.Address != 0x0 && y.Address == 0x0) return -1; + return 0; + } + return y.Order - x.Order; + }); + } + + private static void probeAllPartsForMaterials() + { + resetMaterials(); + probePartForMaterials(playerArmor[Part.Helmet], helmetMaterials); + probePartForMaterials(playerArmor[Part.Body], bodyMaterials); + probePartForMaterials(playerArmor[Part.Arms], armsMaterials); + probePartForMaterials(playerArmor[Part.Waist], waistMaterials); + probePartForMaterials(playerArmor[Part.Legs], legsMaterials); + probePartForMaterials(playerArmor[Part.Slinger], slingerMaterials); + probePartForMaterials(playerArmor[Part.Face], faceMaterials); + probePartForMaterials(playerArmor[Part.Hair], hairMaterials); + if (skinToneSet) + { + setSkinToneOverride(); + } + } + + private static void refreshArmorState(Player player) + { + dropArmorState(); + if (collectArmorAndJoints(player)) + { + probeAllPartsForMaterials(); + } + else + { + dropJointOffsets(); + } + } + + private static void refreshWeaponState(Player player) + { + dropWeaponState(); + collectWeaponParts(player); + } + + private static void collectArmorParts(nint modelAddr, nint resourceAddr) + { + int part; + string fullString = new(GetPtrInline<sbyte>(resourceAddr, 0xC)); + string partName = Models.extractPartName(fullString); + if (partName == "body") part = Part.Body; + else if (partName == "helm") part = Part.Helmet; + else if (partName == "arm") part = Part.Arms; + else if (partName == "wst") part = Part.Waist; + else if (partName == "leg") part = Part.Legs; + else if (partName.StartsWith("slg")) part = Part.Slinger; + else if (partName.StartsWith("hair")) part = Part.Hair; + else if (partName.StartsWith("face")) part = partName.EndsWith("_eyelens") ? Part.EyeLens : Part.Face; + else if (fullString.StartsWith("wp\\")) + { + if (!playerWeapon.Contains(modelAddr)) + { + playerWeapon.Add(modelAddr); + } + return; + } + else return; + playerArmor[part] = modelAddr; + + int jointCount = Get<int>(modelAddr, 0x4A0); + nint jointAddr = Get<nint>(modelAddr, 0x4A8); + for (int i = 0; i < jointCount; i++) + { + nint childAddr = Get<nint>(jointAddr, 0x8); + if (childAddr != 0x0 && Get<nint>(childAddr) == 0x142F21A90) + { + childAddr = Get<nint>(childAddr, 0x8); + if (childAddr != 0x0) + { + nint childVtable = Get<nint>(childAddr); + if (childVtable == 0x143524BD8) + { + childAddr = Get<nint>(childAddr, 0x188); + if (childAddr != 0x0 && Get<nint>(childAddr) == 0x143519530) + { + nint jiggleData = Get<nint>(Get<nint>(childAddr, 0xA0)); + if (Get<nint>(jiggleData) == 0x143519508) + { + if (!jiggleBones.ContainsKey(jiggleData)) + { + int jiggleIndex = jiggleBones.Count(); + jiggleBones[jiggleData] = new(); + } + jiggleBones[jiggleData].Add(jointAddr); + } + } + } +#if QUARANTINED_FEATURES + else if (childVtable == 0x143249170) + { + childAddr = Get<nint>(childAddr, 0x188); + if (childAddr != 0x0 && Get<nint>(childAddr) == 0x1432492F0) + { + ikJoints.Add(jointAddr); + } + } +#endif + } + } + switch (part) + { + case Part.Body: + bodyJoints.Add(jointAddr); + break; + case Part.Face: + faceJoints.Add(jointAddr); + break; + case Part.Hair: + hairJoints.Add(jointAddr); + break; + } + jointAddr += 0xC0; + } + + if (part == Part.Body) + { + for (int i = 0; i < bodyJoints.Count; i++) + { + jointAddr = bodyJoints[i]; + byte id = Get<byte>(jointAddr, 0xA0); + Assert(bodyJointMap[id] == 0x0); + bodyJointMap[id] = jointAddr; + } + foreach ((nint joint, _) in bodyRotations.Where((e) => !bodyJoints.Contains(e.Key))) bodyRotations.Remove(joint); + foreach ((nint joint, _) in bodyPositions.Where((e) => !bodyJoints.Contains(e.Key))) bodyPositions.Remove(joint); + foreach ((nint joint, _) in bodyOffsets.Where((e) => !bodyJoints.Contains(e.Key))) bodyOffsets.Remove(joint); +#if QUARANTINED_FEATURES + foreach ((nint joint, _) in ikOffsets.Where((e) => !bodyJoints.Contains(e.Key))) ikOffsets.Remove(joint); +#endif + } + else if (part == Part.Face) + { + for (int i = 0; i < faceJoints.Count; i++) + { + jointAddr = faceJoints[i]; + byte id = Get<byte>(jointAddr, 0xA0); + Assert(faceJointMap[id] == 0x0); + faceJointMap[id] = jointAddr; + } + foreach ((nint joint, _) in faceRotations.Where((e) => !faceJoints.Contains(e.Key))) faceRotations.Remove(joint); + foreach ((nint joint, _) in facePositions.Where((e) => !faceJoints.Contains(e.Key))) facePositions.Remove(joint); + foreach ((nint joint, _) in faceOffsets.Where((e) => !faceJoints.Contains(e.Key))) faceOffsets.Remove(joint); + } + else if (part == Part.Hair) + { + foreach ((nint joint, _) in hairRotations.Where((e) => !hairJoints.Contains(e.Key))) hairRotations.Remove(joint); + foreach ((nint joint, _) in hairOffsets.Where((e) => !hairJoints.Contains(e.Key))) hairOffsets.Remove(joint); + } + } + + private static void collectWeaponParts(Player player) + { + nint weaponAddr = player.Get<nint>(0x76B0); + if (weaponAddr == 0x0) + { + return; + } + nint resourceAddr = Get<nint>(weaponAddr, 0x2A0); + if (resourceAddr == 0x0) + { + return; + } + retryWeaponRefresh = false; + collectArmorParts(weaponAddr, resourceAddr); + nint subAddr = Get<nint>(weaponAddr, 0x2208); + if (subAddr != 0x0) + { + resourceAddr = Get<nint>(subAddr, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(subAddr, resourceAddr); + } + } + nint weaponParts = Get<nint>(weaponAddr, 0x9C8); + if (weaponParts == 0x0) + { + weaponParts = Get<nint>(weaponAddr, 0x21D8); + } + nint next = weaponParts; + nint head = next; + nint prev = 0x0; + if (weaponParts != 0x0) + { + prev = Get<nint>(weaponParts, 0x38); + } + for (;next != 0x0;) + { + weaponParts = next; + // If we search backwards (+0x38), we will pick up to-be-freed resources. + next = Get<nint>(weaponParts, 0x30); + nint vTable = Get<nint>(weaponParts); + if (vTable == 0x1434D1D58) // uWeaponEmblem + { + if (Get<nint>(weaponParts, 0x590) != player.Instance) + { + continue; + } + nint parentAddr = Get<nint>(weaponParts, 0x5A8); + if (parentAddr != 0x0) + { + vTable = Get<nint>(parentAddr); + if (vTable == 0x1434D7C88 || vTable == 0x1434D7928) // uWpSubGeneral || uWpQuiver + { + if (Get<nint>(parentAddr, 0x9B0) != player.Instance) + { + continue; + } + resourceAddr = Get<nint>(parentAddr, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(parentAddr, resourceAddr); + } + } + } + } + else if (vTable == 0x1434D7C88) // uWpSubGeneral + { + if (Get<nint>(weaponParts, 0x9B0) != player.Instance) + { + continue; + } + } + else if (vTable == 0x1434D2400) // uWeaponParts + { + if (Get<nint>(weaponParts, 0x990) != player.Instance) + { + continue; + } + } + else + { + continue; + } + resourceAddr = Get<nint>(weaponParts, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(weaponParts, resourceAddr); + } + } + } + + private static bool collectArmorAndJoints(Player player) + { + // MonsterHunterWorld.exe+203E8A2 - mov rax,[rbx+000126C8] + // cpPlCombineArmorCtrl + 0x50 + (partIndex * 0x80) + nint cpPlCombineArmorCtrl = player.Get<nint>(0x126C8); + nint bodyArmorResource = player.Get<nint>(0x2A0); + nint slingerAddr = player.Get<nint>(0x8918); + if (cpPlCombineArmorCtrl == 0x0 || bodyArmorResource == 0x0 || slingerAddr == 0x0) + { + return false; + } + retryArmorRefresh = false; + if (bodyArmorResource != lastBodyArmor) + { + dropJointOffsets(); + lastBodyArmor = bodyArmorResource; + } + collectArmorParts(player.Instance, bodyArmorResource); + nint next, resourceAddr; + resourceAddr = Get<nint>(slingerAddr, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(slingerAddr, resourceAddr); + } + cpPlCombineArmorCtrl = Get<nint>(cpPlCombineArmorCtrl, 0x70); + next = cpPlCombineArmorCtrl; + for (;next != 0x0;) + { + nint armorAddr = next; + next = Get<nint>(armorAddr, 0x30); + nint vTable = Get<nint>(armorAddr); + if (vTable == 0x1434A7560) // uPlCombineArmor + { + nint parentAddr = Get<nint>(armorAddr, 0x548); + if (parentAddr != 0x0) + { + if (Get<nint>(parentAddr) == 0x143451520) // Face. + { + if (Get<nint>(parentAddr, 0x998) != player.Instance) + { + continue; + } + if (playerArmor[Part.Face] == 0x0) + { + resourceAddr = Get<nint>(parentAddr, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(parentAddr, resourceAddr); + } + nint childAddr = Get<nint>(parentAddr, 0x9C8); + if (childAddr != 0x0 && Get<nint>(childAddr) == 0x143505E98) // Eye lens. + { + resourceAddr = Get<nint>(childAddr, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(childAddr, resourceAddr); + } + } + } + } + else if (parentAddr != player.Instance) + { + continue; + } + } + } + else + { + continue; + } + resourceAddr = Get<nint>(armorAddr, 0x2A0); + if (resourceAddr != 0x0) + { + collectArmorParts(armorAddr, resourceAddr); + } + if (!playerArmor.Where((p) => p == 0x0).Any()) + { + break; + } + } + return true; + } + + private static void assertFirstHook(nint model) + { +#if HOOK_ORDER_ASSERTS + Player? player = getPlayer(); + if (player != null && model == player.Instance) + { + if (Monitor.TryEnter(playerArmor)) Monitor.Exit(playerArmor); + else Assert(false); + Assert(hookOrder == 0); + hookOrder = 1; + } +#endif + } + + private static void assertModelHook(nint model) + { +#if HOOK_ORDER_ASSERTS + Player? player = getPlayer(); + if (player != null && model == player.Instance) + { + if (Monitor.TryEnter(playerArmor)) Monitor.Exit(playerArmor); + else Assert(false); + Assert(hookOrder == 1); + } +#endif + } + + private static void UpdateModelHook(nint model) + { + assertFirstHook(model); + + bool updateBody = bodyPositions.Count() > 0 || bodyOffsets.Count() > 0; + bool updateFace = facePositions.Count() > 0 || faceOffsets.Count() > 0; + bool processUpdate = updateBody || updateFace || activeMaterialOverrides > 0 || skinToneSet; + + updateModelHook!.Original(model); + + Player? player = null; + if (processUpdate && (player = getPlayer()) != null) + { + getDirectionVectors(player.Rotation, out Vector3 rootForward, out Vector3 rootRight, out Vector3 rootUp); + + if (model == player.Instance) + { + if (updateBody) + { + foreach ((nint addr, Vector3 position) in bodyPositions) + { + GetRef<Vector3>(addr, 0x50) = player.Position + ((rootForward * position.X) + (rootUp * position.Y) + (rootRight * position.Z)); + } + + foreach ((nint addr, Vector3 offset) in bodyOffsets) + { + GetRef<Vector3>(addr, 0x50) += (rootForward * offset.X) + (rootUp * offset.Y) + (rootRight * offset.Z); + } + } + + foreach (BaseMaterial material in helmetMaterials) + { + material.Update(material.Address); + } + + foreach (BaseMaterial material in bodyMaterials) + { + material.Update(material.Address); + } + + foreach (BaseMaterial material in armsMaterials) + { + material.Update(material.Address); + } + + foreach (BaseMaterial material in waistMaterials) + { + material.Update(material.Address); + } + + foreach (BaseMaterial material in legsMaterials) + { + material.Update(material.Address); + } + + foreach (BaseMaterial material in slingerMaterials) + { + material.Update(material.Address); + } + } + + if (model == playerArmor[Part.Face]) + { + if (updateFace) + { + foreach ((nint addr, Vector3 position) in facePositions) + { + GetRef<Vector3>(addr, 0x50) = player.Position + ((rootForward * position.X) + (rootUp * position.Y) + (rootRight * position.Z)); + } + + foreach ((nint addr, Vector3 offset) in faceOffsets) + { + GetRef<Vector3>(addr, 0x50) += (rootForward * offset.X) + (rootUp * offset.Y) + (rootRight * offset.Z); + } + } + + foreach (BaseMaterial material in faceMaterials) + { + material.Update(material.Address); + } + } + } + } + + private static void UpdateJointRotationHook(nint model) + { + assertModelHook(model); + + bool updateBody = bodyRotations.Count() > 0; + bool updateFace = faceRotations.Count() > 0; + bool processUpdate = updateBody || updateFace; + + Player? player = null; + if (processUpdate && (player = getPlayer()) != null) + { + if (updateBody && model == player.Instance) + { + foreach ((nint addr, Vector4 rotation) in bodyRotations) + { + GetRef<Quaternion>(addr, 0x70) = new(rotation.X, rotation.Y, rotation.Z, rotation.W); + } + } + + if (updateFace && model == playerArmor[Part.Face]) + { + foreach ((nint addr, Vector4 rotation) in faceRotations) + { + GetRef<Quaternion>(addr, 0x70) = new(rotation.X, rotation.Y, rotation.Z, rotation.W); + } + } + } + + updateJointRotationHook!.Original(model); + } + + private static void UpdateHairJointsHook(nint model) + { + assertModelHook(model); + + bool updateRotation = hairRotations.Count() > 0; + bool updatePosition = hairOffsets.Count() > 0; + bool processUpdate = updateRotation || updatePosition || activeMaterialOverrides > 0; + + updateHairJoints!.Original(model); + + Player? player = null; + if (processUpdate && (player = getPlayer()) != null) + { + if (model != playerArmor[Part.Hair]) + { + return; + } + + if (updateRotation) + { + foreach ((nint addr, Vector4 rotation) in hairRotations) + { + GetRef<Quaternion>(addr, 0x70) = new(rotation.X, rotation.Y, rotation.Z, rotation.W); + } + } + + if (updatePosition) + { + getDirectionVectors(player.Rotation, out Vector3 rootForward, out Vector3 rootRight, out Vector3 rootUp); + foreach ((nint addr, Vector3 offset) in hairOffsets) + { + GetRef<Vector3>(addr, 0x50) += (rootForward * offset.X) + (rootUp * offset.Y) + (rootRight * offset.Z); + } + } + + foreach (BaseMaterial material in hairMaterials) + { + material.Update(material.Address); + } + } + } + +#if QUARANTINED_FEATURES + private static void UpdateIKPositionHook(nint ikObject, nint joint, nint obj) + { + if (ikOffsets.ContainsKey(joint)) + { + Vector3 offset = ikOffsets[joint][0]; + GetRef<Vector3>(ikObject, 0x1380) += offset; + } + + updateIKPositionHook!.Original(ikObject, joint, obj); + } +#endif + + private static void drawJoint(nint jointAddr, Dictionary<nint, Vector4> rotations, Dictionary<nint, Vector3> offsets) + { + if (jointAddr == 0x0) return; + ImGui.PushID(jointAddr); + bool hasRotation = rotations.ContainsKey(jointAddr); + bool hasOffset = offsets.ContainsKey(jointAddr); +#if QUARANTINED_FEATURES + bool hasIkOffset = ikOffsets.ContainsKey(jointAddr); +#endif + ref Vector3 position = ref GetRef<Vector3>(jointAddr, 0x50); + ref Vector4 rotation = ref GetRef<Vector4>(jointAddr, 0x70); + ImGui.DragFloat4("Rotation", ref rotation, 0.005f); + if (hasRotation) + { + ImGui.PushID("Rotation"); + bool doRemove = ImGui.Button("X"); + ImGui.SameLine(); + if (Models.drawRotate("##Rotate", rotations[jointAddr], out Vector4 result)) + { + rotations[jointAddr] = result; + } + if (doRemove) rotations.Remove(jointAddr); + ImGui.PopID(); + } + ImGui.DragFloat3("Position", ref position, 0.005f); + if (hasOffset) + { + ImGui.PushID("Position"); + bool doRemove = ImGui.Button("X"); + ImGui.SameLine(); + if (ImGui.Button("Reset")) + { + offsets[jointAddr] = default; + } + ImGui.SameLine(); + Vector3 v = offsets[jointAddr]; + if (ImGui.DragFloat3($"##Offset", ref v, 0.005f)) + { + offsets[jointAddr] = v; + } + if (doRemove) offsets.Remove(jointAddr); + ImGui.PopID(); + } +#if QUARANTINED_FEATURES + if (hasIkOffset) + { + ImGui.PushID("IK"); + bool doRemove = ImGui.Button("X"); + ImGui.SameLine(); + if (ImGui.Button("Reset")) + { + ikOffsets[jointAddr][0] = default; + ikOffsets[jointAddr][1] = default; + } + ImGui.SameLine(); + Vector3 v = ikOffsets[jointAddr][0]; + if (ImGui.DragFloat3($"##IK Offset", ref v, 0.025f)) + { + ikOffsets[jointAddr][0] = v; + } + if (doRemove) ikOffsets.Remove(jointAddr); + ImGui.PopID(); + } +#endif + if (!hasRotation) + { + if (ImGui.Button("Add Rotation")) + { + rotations.Add(jointAddr, rotation); + } + } + if (!hasOffset) + { + if (!hasRotation) + { + ImGui.SameLine(); + } + if (ImGui.Button("Add Offset")) + { + offsets.Add(jointAddr, new Vector3()); + } + } +#if QUARANTINED_FEATURES + if (ikJoints.Contains(jointAddr) && !hasIkOffset) + { + if (!hasOffset) + { + ImGui.SameLine(); + } + if (ImGui.Button("Add IK Offset")) + { + ikOffsets.Add(jointAddr, new List<Vector3>(){ default, default }); + } + } +#endif + ImGui.PopID(); + } + + private static void drawBodyJoint(nint jointAddr) + { + drawJoint(jointAddr, bodyRotations, bodyOffsets); + } + + private static void drawFaceJoint(nint jointAddr) + { + drawJoint(jointAddr, faceRotations, faceOffsets); + } + + private static void drawJointLeaf(ref List<nint> joints, int i, Dictionary<nint, Vector4> rotations, Dictionary<nint, Vector3> offsets) + { + if (i >= joints.Count) return; + nint jointAddr = joints[i]; + byte id = Get<byte>(jointAddr, 0xA0); + ImGui.PushID(jointAddr); + if (ImGui.CollapsingHeader($"Joint #{i} (0x{jointAddr:X}, id: 0x{id:X})")) + { + drawJoint(jointAddr, rotations, offsets); + } + ImGui.PopID(); + drawJointLeaf(ref joints, i + 1, rotations, offsets); + } + + internal static void drawArmorParts(Player player, float width) + { + if (ImGui.Checkbox("Ignore Full Armor Sets Face/Hair", ref ignoreFullArmorFace)) + { + if (ignoreFullArmorFace) + { + jmpOverExtFace.Enable(); + jmpOverExtHair.Enable(); + } + else + { + jmpOverExtFace.Disable(); + jmpOverExtHair.Disable(); + } + } + + if (ImGui.Checkbox("Disable Full Armor Sets Hides Slinger", ref ignoreHideSlinger)) + { + if (ignoreHideSlinger) + { + jmpOverHideSlinger.Enable(); + } + else + { + jmpOverHideSlinger.Disable(); + } + } + + bool expand = ImGui.CollapsingHeader("Helmet"); + ImGui.SameLine(); + int layered = player.Get<int>(0x13754); + ImGui.Text($"(id: {player.Get<int>(0x1373C):X}" + ((layered != -1) ? $", layered: {layered:X})" : ")")); + if (expand) + { + Models.drawModelParts(playerArmor[Part.Helmet]); + foreach (BaseMaterial material in helmetMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + ImGui.PushID("Body"); + expand = ImGui.CollapsingHeader("Body"); + ImGui.SameLine(); + layered = player.Get<int>(0x13758); + ImGui.Text($"(id: {player.Get<int>(0x13740):X}" + ((layered != -1) ? $", layered: {layered:X})" : ")")); + if (expand) + { + Models.drawModelParts(playerArmor[Part.Body]); + foreach (BaseMaterial material in bodyMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + ImGui.PopID(); + ImGui.PushID("Arms"); + expand = ImGui.CollapsingHeader("Arms"); + ImGui.SameLine(); + layered = player.Get<int>(0x1375C); + ImGui.Text($"(id: {player.Get<int>(0x13744):X}" + ((layered != -1) ? $", layered: {layered:X})" : ")")); + if (expand) + { + Models.drawModelParts(playerArmor[Part.Arms]); + foreach (BaseMaterial material in armsMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + ImGui.PopID(); + expand = ImGui.CollapsingHeader("Waist"); + ImGui.SameLine(); + layered = player.Get<int>(0x13760); + ImGui.Text($"(id: {player.Get<int>(0x13748):X}" + ((layered != -1) ? $", layered: {layered:X})" : ")")); + if (expand) + { + Models.drawModelParts(playerArmor[Part.Waist]); + foreach (BaseMaterial material in waistMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + ImGui.PushID("Legs"); + expand = ImGui.CollapsingHeader("Legs"); + ImGui.SameLine(); + layered = player.Get<int>(0x13764); + ImGui.Text($"(id: {player.Get<int>(0x1374C):X}" + ((layered != -1) ? $", layered: {layered:X})" : ")")); + if (expand) + { + Models.drawModelParts(playerArmor[Part.Legs]); + foreach (BaseMaterial material in legsMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + ImGui.PopID(); + expand = ImGui.CollapsingHeader("Slinger"); + ImGui.SameLine(); + ImGui.Text($"(id: {player.Get<int>(0x13D8C):X}_{player.Get<int>(0x13D90):X})"); + if (expand) + { + Models.drawModelParts(playerArmor[Part.Slinger]); + foreach (BaseMaterial material in slingerMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + expand = ImGui.CollapsingHeader("Weapon"); + if (expand) + { + foreach (nint weaponPart in playerWeapon) + { + Models.drawModelParts(weaponPart); + ImGui.Separator(); + } + } + if (ImGui.CollapsingHeader("Hair")) + { + Models.drawModelParts(playerArmor[Part.Hair]); + foreach (BaseMaterial material in hairMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + if (ImGui.CollapsingHeader("Face")) + { + Models.drawModelParts(playerArmor[Part.Face]); + foreach (BaseMaterial material in faceMaterials) + { + material.Draw(width); + } + ImGui.Separator(); + } + if (ImGui.CollapsingHeader("Eye Lens")) + { + Models.drawModelParts(playerArmor[Part.EyeLens]); + } + } + + private static void setSkinToneOverride() + { + skinToneSet = true; + foreach (List<BaseMaterial> partMaterials in allMaterialLists) + { + foreach (BaseMaterial material in partMaterials) + { + if (material is MhMaterialPLEditFaceLocal || material is MhMaterialPLSkinLocal) + { + material.Parameters[12].ForceOverrideOn(true); + material.Parameters[12].SetOverrideValue(new Vector4(currentSkinTone.X, currentSkinTone.Y, 0.0f, 0.0f), 0); + } + } + } + } + + private static void unsetSkinToneOverride() + { + skinToneSet = false; + foreach (List<BaseMaterial> partMaterials in allMaterialLists) + { + foreach (BaseMaterial material in partMaterials) + { + if (material is MhMaterialPLEditFaceLocal || material is MhMaterialPLSkinLocal) + { + material.Parameters[12].ForceOverrideOff(); + } + } + } + } + + internal static void drawSkinTone(Player player, NativeWrapper playerSettings, float width) + { + // @TODO: This could be a ColorButton with a popup. + if (!skinToneSet) + { + currentSkinTone = new Vector2( + playerSettings.GetRef<byte>(0x166) / 255.0f, + playerSettings.GetRef<byte>(0x167) / 255.0f); + } + if (skinAddTextureHandle == TextureHandle.Invalid) + { + if (skinAddTexture != null) + { + skinAddTextureHandle = skinAddTexture.GetTextureHandle(); + } + else + { +#if ALT_TEXTURE_LOAD + string path = "native:\\Assets\\default_tex\\skin_BM.tex"; + MtFileStream? file = MtFileStream.FromPath(path, OpenMode.Read, false); + if (file != null) + { + skinAddTexture = MtDti.Find("rTexture")!.CreateInstance<Texture>(); + if (skinAddTexture.LoadFrom(file)) + { + MemoryUtil.WriteBytes(skinAddTexture.Instance + 0xC, StringToCStr(path.Replace("native:\\", "").Replace(".tex", ""))); + } + else + { + skinAddTexture = null; + } + file.Close(); + } +#else + skinAddTexture = ResourceManager.GetResource<Texture>("Assets\\default_tex\\skin_BM", MtDti.Find("rTexture")!); + if (skinAddTexture != null) + { + skinAddTextureHandle = skinAddTexture.GetTextureHandle(); + } +#endif + } + } + bool skinToneChanged = false; + if (skinAddTextureHandle != TextureHandle.Invalid) + { + ImGui.PushItemFlag(ImGuiItemFlags.NoNav, true); + string fullString = new(GetPtrInline<sbyte>(skinAddTexture!.Instance, 0xC)); + ImGui.Text($"{fullString} @ {skinAddTexture.Instance:X}"); + Vector2 cursorPos = ImGui.GetCursorPos(); + Vector2 mousePos = ImGui.GetMousePos(); + Vector2 windowPos = ImGui.GetWindowPos(); + windowPos += cursorPos - new Vector2(ImGui.GetScrollX(), ImGui.GetScrollY()); + Vector2 size = new Vector2(skinAddTexture.Width, skinAddTexture.Height); + ImGui.Image(skinAddTextureHandle, size); + ImGui.SetCursorPos(cursorPos); + ImGui.InvisibleButton("picker", size); + if (ImGui.IsItemActive()) + { + currentSkinTone = new Vector2( + Math.Clamp((mousePos.X - windowPos.X) / size.X, 0.0f, 1.0f), + Math.Clamp((mousePos.Y - windowPos.Y) / size.Y, 0.0f, 1.0f)); + skinToneChanged = true; + } + cursorPos = currentSkinTone; + cursorPos *= size; + cursorPos += windowPos; + ImDrawListPtr drawList = ImGui.GetWindowDrawList(); + drawList.AddRect(cursorPos - new Vector2(3.0f, 3.0f), cursorPos + new Vector2(3.0f, 3.0f), (uint)0xFFFFFFFF); + ImGui.PopItemFlag(); + } + ImGui.SetNextItemWidth(width * 0.25f); + if (ImGui.DragFloat2("##Skin Tone", ref currentSkinTone, 0.001f, 0.0f, 1.0f) || skinToneChanged) + { + setSkinToneOverride(); + } + ImGui.SameLine(); + if (ImGui.Button("Reset")) + { + unsetSkinToneOverride(); + } + ImGui.SameLine(); + if (ImGui.Button("Save")) + { + byte skinToneX = (byte)Math.Round(currentSkinTone.X * 255.0f); + byte skinToneY = (byte)Math.Round(currentSkinTone.Y * 255.0f); + player.GetRef<byte>(0x13716) = skinToneX; + player.GetRef<byte>(0x13717) = skinToneY; + playerSettings.GetRef<byte>(0x166) = skinToneX; + playerSettings.GetRef<byte>(0x167) = skinToneY; + } + if (ImGui.Button("Unload Texture")) + { + skinAddTexture = null; + skinAddTextureHandle = TextureHandle.Invalid; + } + } + + private static bool poseRotationOnly = false; + private static string typedPoseName = ""; + private static string selectedPoseName = ""; + private static bool poseConfirmDelete = false; + private static string[] poseList = []; + private static bool poseSelectionStarted = false; + + public static bool overlayJoints = false; + + private static void savePose(Player player) + { + string name = typedPoseName; + if (name == "") + { + return; + } + if (!Directory.Exists(posePath)) + { + try + { + Directory.CreateDirectory(posePath); + } + catch (Exception e) + { + Log.Error($"Failed create directory: {posePath} ({e.Message})"); + return; + } + } + string path = Path.Join(posePath, name + ".json"); + FileStream stream; + try + { + stream = File.Open(path, FileMode.Create); + } + catch (Exception e) + { + Log.Error($"Failed to open: {path} ({e.Message})"); + return; + } + using (Utf8JsonWriter writer = new Utf8JsonWriter(stream, new JsonWriterOptions { Indented = true })) + { + Vector3 rootPosition = player.Position; + getDirectionVectors(player.Rotation, out Vector3 rootForward, out Vector3 rootRight, out Vector3 rootUp); + writer.WriteStartObject(); + writer.WriteStartObject("body"); + foreach (nint jointAddr in bodyJoints) + { + byte id = Get<byte>(jointAddr, 0xA0); + writer.WritePropertyName($"{id}"); + writer.WriteStartArray(); + writer.WriteStringValue(Vector4ToString(Get<Vector4>(jointAddr, 0x70))); + Vector3 positionOffset = default; + Vector3 position = Get<Vector3>(jointAddr, 0x50); + Vector3 diff = position - rootPosition; + positionOffset.Y = diff.Y; + diff.Y = 0.0f; + positionOffset.X = Vector3.Dot(rootForward, diff); + positionOffset.Z = Vector3.Dot(rootRight, diff); + writer.WriteStringValue(Vector3ToString(positionOffset)); + if (bodyOffsets.ContainsKey(jointAddr)) + { + writer.WriteStringValue(Vector3ToString(bodyOffsets[jointAddr])); + } + writer.WriteEndArray(); + } + writer.WriteEndObject(); + writer.WriteStartObject("face"); + foreach (nint jointAddr in faceJoints) + { + byte id = Get<byte>(jointAddr, 0xA0); + writer.WritePropertyName($"{id}"); + writer.WriteStartArray(); + writer.WriteStringValue(Vector4ToString(Get<Vector4>(jointAddr, 0x70))); + Vector3 positionOffset = default; + Vector3 position = Get<Vector3>(jointAddr, 0x50); + Vector3 diff = position - rootPosition; + positionOffset.Y = diff.Y; + diff.Y = 0.0f; + positionOffset.X = Vector3.Dot(rootForward, diff); + positionOffset.Z = Vector3.Dot(rootRight, diff); + writer.WriteStringValue(Vector3ToString(positionOffset)); + if (faceOffsets.ContainsKey(jointAddr)) + { + writer.WriteStringValue(Vector3ToString(faceOffsets[jointAddr])); + } + writer.WriteEndArray(); + } + writer.WriteEndObject(); + writer.WriteEndObject(); + writer.Flush(); + } + stream.Close(); + } + + private static void setPose(string filePath, string fileName) + { + dropJointOffsets(); + Utf8JsonReader reader; + try + { + reader = new Utf8JsonReader(File.ReadAllBytes(filePath)); + } + catch (Exception e) + { + Log.Error($"Failed to open: {filePath} ({e.Message})"); + return; + } + selectedPoseName = fileName; + bool isFace = false; + byte currentId = 0xFF; + int arrayIndex = 0; + while (reader.Read()) + { + switch (reader.TokenType) + { + case JsonTokenType.PropertyName: + string property = reader.GetString()!; + if (property == "body") + { + isFace = false; + } + else if (property == "face") + { + isFace = true; + } + else + { + try + { + currentId = Convert.ToByte(property); + } + catch (FormatException) + { + currentId = 0xFF; + } + catch (OverflowException) + { + currentId = 0xFF; + } + } + break; + case JsonTokenType.StartArray: + arrayIndex = 0; + break; + case JsonTokenType.String: + if (currentId == 0xFF) break; + if (arrayIndex == 0) + { + if (isFace) + { + faceRotations[faceJointMap[currentId]] = StringToVector4(reader.GetString()!); + } + else + { + bodyRotations[bodyJointMap[currentId]] = StringToVector4(reader.GetString()!); + } + } + else if (arrayIndex == 1 && !poseRotationOnly) + { + if (isFace) + { + facePositions[faceJointMap[currentId]] = StringToVector3(reader.GetString()!); + } + else + { + bodyPositions[bodyJointMap[currentId]] = StringToVector3(reader.GetString()!); + } + } + arrayIndex++; + break; + } + } + } + + internal static void drawPoser(Player player, float width) + { + ImGui.PushID("Poser"); + ImGui.Text("Poses"); + ImGui.PushItemWidth(width * 0.3f); + ImGui.InputText("##Pose Name", ref typedPoseName, 99); + ImGui.SameLine(); + if (ImGui.Button("Save")) + { + savePose(player); + } + ImGui.SameLine(); + if (ImGui.BeginCombo("##Poses", selectedPoseName, ImGuiComboFlags.HeightLarge)) + { + if (!poseSelectionStarted) + { + try + { + poseList = Directory.GetFiles(posePath); + } + catch (Exception e) + { + Log.Error($"Failed read directory: {posePath} ({e.Message})"); + } + poseSelectionStarted = true; + poseConfirmDelete = false; + } + if (ImGui.Selectable("(None)")) + { + if (selectedPoseName != "") + { + dropJointOffsets(); + } + selectedPoseName = ""; + } + foreach (string filePath in poseList) + { + if (Path.GetExtension(filePath) != ".json") + { + continue; + } + string fileName = Path.GetFileNameWithoutExtension(filePath); + bool isSelected = fileName == selectedPoseName; + if (ImGui.Selectable(fileName, isSelected)) + { + setPose(filePath, fileName); + } + if (isSelected) ImGui.SetItemDefaultFocus(); + } + ImGui.EndCombo(); + } + else + { + poseSelectionStarted = false; + } + ImGui.SameLine(); + if (poseConfirmDelete) + { + ImGui.AlignTextToFramePadding(); + ImGui.Text("Are you sure?"); + ImGui.SameLine(); + if (ImGui.Button("No")) + { + poseConfirmDelete = false; + } + ImGui.SameLine(); + if (ImGui.Button("Yes")) + { + string path = Path.Join(posePath, selectedPoseName + ".json"); + try + { + File.Delete(path); + } + catch (Exception e) + { + Log.Error($"Failed to delete: {path} ({e.Message})"); + } + selectedPoseName = ""; + poseConfirmDelete = false; + } + } + else if (ImGui.Button("Delete")) + { + if (selectedPoseName != "") + { + poseConfirmDelete = true; + } + } + ImGui.PopItemWidth(); + + ImGui.AlignTextToFramePadding(); +#if QUARANTINED_FEATURES + ImGui.Text($"Rotations: {bodyRotations.Count + faceRotations.Count}, Positions: {bodyPositions.Count + facePositions.Count}, Offsets: {bodyOffsets.Count + faceOffsets.Count + ikOffsets.Count}"); +#else + ImGui.Text($"Rotations: {bodyRotations.Count + faceRotations.Count}, Positions: {bodyPositions.Count + facePositions.Count}, Offsets: {bodyOffsets.Count + faceOffsets.Count}"); +#endif + ImGui.SameLine(); + if (ImGui.Button("Clear")) + { + dropJointOffsets(); + } + ImGui.SameLine(); + ImGui.Checkbox("Overlay Joints", ref overlayJoints); + + if (overlayJoints) + { + //Renderer.RequestMouseCapture(); + } + + ImGui.Checkbox("Apply Rotations Only", ref poseRotationOnly); + ImGui.SameLine(); + /* + ref byte ikDisabledB = ref GetRef<byte>(player.Get<nint>(0x990), 0x5C); + bool ikDisabled = ikDisabledB == 0x0; + if (ImGui.Checkbox("Disable IK", ref ikDisabled)) + { + ikDisabledB = ByteFlag(!ikDisabled); + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Mostly disable inverse kinematics on your player. To rotate ankles, you need to use Force Disable IK."); + ImGui.EndTooltip(); + } + ImGui.SameLine(); + */ + if (ImGui.Checkbox("Disable IK", ref ikForcedOff)) + { + if (ikForcedOff) + { + forceDisableIK.Enable(); + } + else + { + forceDisableIK.Disable(); + } + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Forcefully disable inverse kinematics."); + ImGui.EndTooltip(); + } + ImGui.SameLine(); + ref byte lookAtDisabledB = ref GetRef<byte>(player.Get<nint>(0x9C0), 0x5C); + bool lookAtDisabled = lookAtDisabledB == 0x0; + if (ImGui.Checkbox("Disable Look At", ref lookAtDisabled)) + { + lookAtDisabledB = ByteFlag(!lookAtDisabled); + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Stop your character from looking at people, animals, and objects they pass."); + ImGui.EndTooltip(); + } + + if (ImGui.CollapsingHeader("Joints")) + { + ImGui.PushItemWidth(width * 0.75f); + + if (ImGui.TreeNodeEx("Body", ImGuiTreeNodeFlags.Framed)) + { + drawBodyJoints(); + ImGui.TreePop(); + } + + if (ImGui.TreeNodeEx("Face", ImGuiTreeNodeFlags.Framed)) + { + drawFaceJoints(); + ImGui.TreePop(); + } + + if (ImGui.CollapsingHeader("Jiggle Bones")) + { + for (int i = 0; i < jiggleBones.Count; i++) + { + nint jiggleData = jiggleBones.Keys.ElementAt(i); + ImGui.PushID(jiggleData); + List<nint> jointAddrs = jiggleBones[jiggleData]; + string ids = ""; + for (int j = 0; j < jointAddrs.Count; j++) + { + byte id = Get<byte>(jointAddrs[j], 0xA0); + ids += $"0x{id:X}" + ((j != jointAddrs.Count - 1) ? ", " : ""); + } + if (ImGui.CollapsingHeader($"Jiggle Bone #{i} (0x{jiggleData:X}, joint_ids: {ids})")) + { + ImGui.DragFloat3("Position", ref GetRef<Vector3>(jiggleData, 0xD0), 0.05f); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Drag position around to influence the bone."); + ImGui.EndTooltip(); + } + } + ImGui.PopID(); + } + } + + ImGui.Separator(); + + if (ImGui.CollapsingHeader("All Body Joints")) + { + drawJointLeaf(ref bodyJoints, 0, bodyRotations, bodyOffsets); + } + + if (ImGui.CollapsingHeader("All Face Joints")) + { + drawJointLeaf(ref faceJoints, 0, faceRotations, faceOffsets); + } + + if (ImGui.CollapsingHeader("All Hair Joints")) + { + drawJointLeaf(ref hairJoints, 0, hairRotations, hairOffsets); + } + + ImGui.PopItemWidth(); + } + + ImGui.PopID(); + } + + private static void drawBodyJoints() + { + ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags.Framed; + bool expand; + if (ImGui.TreeNodeEx("Root", flags)) + { + drawBodyJoint(bodyJointMap[Joint.Root2]); + ImGui.TreePop(); + } + ImGui.PushID("Neck"); + if (ImGui.TreeNodeEx("Neck", flags)) + { + if (ImGui.TreeNodeEx("Upper", flags)) + { + drawBodyJoint(bodyJointMap[Joint.UpperNeck]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Lower", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LowerNeck]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Neck. + ImGui.PushID("Back"); + if (ImGui.TreeNodeEx("Back", flags)) + { + if (ImGui.TreeNodeEx("Upper", flags)) + { + drawBodyJoint(bodyJointMap[Joint.UpperBack]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Lower", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LowerBack]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Back. + ImGui.PushID("Right Arm"); + if (ImGui.TreeNodeEx("Right Arm", flags)) + { + if (ImGui.TreeNodeEx("Collarbone", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightCollarbone]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Shoulder", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightShoulder]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Elbow", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightElbow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Wrist", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightWrist]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Right Arm. + ImGui.PushID("Right Hand"); + if (ImGui.TreeNodeEx("Right Hand", flags)) + { + ImGui.PushID("Thumb"); + if (ImGui.TreeNodeEx("Thumb", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightThumbLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightThumbMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightThumbHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Index"); + if (ImGui.TreeNodeEx("Index", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightIndexLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightIndexMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightIndexHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Middle"); + if (ImGui.TreeNodeEx("Middle", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightMiddleLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightMiddleMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightMiddleHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Ring"); + if (ImGui.TreeNodeEx("Ring", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightRingLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightRingMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightRingHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Pinky"); + if (ImGui.TreeNodeEx("Pinky", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightPinkyLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightPinkyMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightPinkyHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + expand = ImGui.TreeNodeEx("Palm", flags); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Outer Palm/Pinky+Ring"); + ImGui.EndTooltip(); + } + if (expand) + { + drawBodyJoint(bodyJointMap[Joint.RightPalm]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Right Hand. + ImGui.PushID("Right Leg"); + if (ImGui.TreeNodeEx("Right Leg", flags)) + { + if (ImGui.TreeNodeEx("Hip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightHip]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Knee", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightKnee]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Ankle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightAnkle]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Toes", flags)) + { + drawBodyJoint(bodyJointMap[Joint.RightToes]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Right Leg. + ImGui.PushID("Left Arm"); + if (ImGui.TreeNodeEx("Left Arm", flags)) + { + if (ImGui.TreeNodeEx("Collarbone", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftCollarbone]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Shoulder", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftShoulder]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Elbow", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftElbow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Wrist", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftWrist]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Left Arm. + ImGui.PushID("Left Hand"); + if (ImGui.TreeNodeEx("Left Hand", flags)) + { + ImGui.PushID("Thumb"); + if (ImGui.TreeNodeEx("Thumb", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftThumbLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftThumbMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftThumbHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Index"); + if (ImGui.TreeNodeEx("Index", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftIndexLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftIndexMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftIndexHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Middle"); + if (ImGui.TreeNodeEx("Middle", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftMiddleLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftMiddleMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftMiddleHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Ring"); + if (ImGui.TreeNodeEx("Ring", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftRingLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftRingMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftRingHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + ImGui.PushID("Pinky"); + if (ImGui.TreeNodeEx("Pinky", flags)) + { + if (ImGui.TreeNodeEx("Base", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftPinkyLow]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftPinkyMid]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Tip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftPinkyHigh]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); + expand = ImGui.TreeNodeEx("Palm", flags); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Outer Palm/Pinky+Ring"); + ImGui.EndTooltip(); + } + if (expand) + { + drawBodyJoint(bodyJointMap[Joint.LeftPalm]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Left Hand. + ImGui.PushID("Left Leg"); + if (ImGui.TreeNodeEx("Left Leg", flags)) + { + if (ImGui.TreeNodeEx("Hip", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftHip]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Knee", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftKnee]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Ankle", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftAnkle]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Toes", flags)) + { + drawBodyJoint(bodyJointMap[Joint.LeftToes]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Left Leg. + } + + private static void drawFaceJoints() + { + ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags.Framed; + ImGui.PushID("Lips"); + if (ImGui.TreeNodeEx("Lips", flags)) + { + if (ImGui.TreeNodeEx("Right Edge", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Lower 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Lower 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Upper 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth29]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Upper 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth28]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Edge", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Lower 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth7]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Lower 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth6]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Upper 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth25]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Upper 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth26]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle Lower", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth5]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle Upper", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth27]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Lips. + ImGui.PushID("Mouth"); + if (ImGui.TreeNodeEx("Mouth", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth]); + if (ImGui.TreeNodeEx("Bottom Teeth", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth30]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Lower 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth12]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Lower 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth11]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Upper 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth24]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Upper 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth23]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Lower 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth8]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Lower 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth9]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Upper 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth20]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Upper 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth21]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle Lower", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth10]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle Upper", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth22]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Under", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth15]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Under", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth14]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Middle Under", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth13]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth17]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth19]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth16]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Mouth18]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Mouth. + ImGui.PushID("Cheeks"); + if (ImGui.TreeNodeEx("Cheeks", flags)) + { + if (ImGui.TreeNodeEx("Right Cheek", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightCheek]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightCheek1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightCheek2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightCheek3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 4", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightCheek4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Right Cheek 5", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightCheek5]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftCheek]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftCheek1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftCheek2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftCheek3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 4", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftCheek4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Left Cheek 5", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftCheek5]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Cheeks. + ImGui.PushID("Right Eye"); + if (ImGui.TreeNodeEx("Right Eye", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye]); + if (ImGui.TreeNodeEx("Eyeball", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Outer", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye5]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Inner", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye6]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Lower 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye7]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Lower 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye8]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Lower 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye9]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Top 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye10]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Top 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye11]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Top 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye12]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Under Eye", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.RightEye13]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Right Eye. + ImGui.PushID("Left Eye"); + if (ImGui.TreeNodeEx("Left Eye", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye]); + if (ImGui.TreeNodeEx("Eyeball", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Outer", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye5]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Inner", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye6]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Lower 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye7]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Lower 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye8]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Lower 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye9]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Top 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye10]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Top 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye11]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Eyelid Top 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye12]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Under Eye", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.LeftEye13]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Left Eye. + ImGui.PushID("Chin"); + if (ImGui.TreeNodeEx("Chin", flags)) + { + if (ImGui.TreeNodeEx("Chin Right", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.ChinRight]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Chin Right Back", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.ChinRightBack]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Chin Middle", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.ChinMiddle]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Chin Left", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.ChinLeft]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Chin Left Back", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.ChinLeftBack]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Neck Right", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.NeckRight]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Neck Middle", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.NeckMiddle]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Neck Left", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.NeckLeft]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Jaw", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Jaw]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Jaw Right", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.JawRight]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Jaw Up Right", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.JawUpRight]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Jaw Left", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.JawLeft]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Jaw Up Left", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.JawUpLeft]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Chin. + ImGui.PushID("Brow"); + if (ImGui.TreeNodeEx("Brow", flags)) + { + if (ImGui.TreeNodeEx("Brow 0", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead0]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 4", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 5", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead5]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 6", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead6]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 7", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead7]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 8", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead8]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 9", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead9]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 10", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead10]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 11", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead11]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 12", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead12]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 13", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead13]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Brow 14", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Forehead14]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Brow. + ImGui.PushID("Nose"); + if (ImGui.TreeNodeEx("Nose", flags)) + { + if (ImGui.TreeNodeEx("Nose", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 1", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose1]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 2", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose2]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 3", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose3]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 4", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose4]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 5", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose5]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 6", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose6]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 7", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose7]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 8", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose8]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 9", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose9]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 10", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose10]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 11", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose11]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 12", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose12]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 13", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose13]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 14", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose14]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 15", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose15]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 16", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose16]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 17", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose17]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 18", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose18]); + ImGui.TreePop(); + } + if (ImGui.TreeNodeEx("Nose 19", flags)) + { + drawFaceJoint(faceJointMap[FaceJoint.Nose19]); + ImGui.TreePop(); + } + ImGui.TreePop(); + } + ImGui.PopID(); // Nose. + } + + internal static void OnRender() + { + if (overlayJoints) + { + for (int i = 0; i < bodyJoints.Count; i++) + { + Primitives.RenderSphere(Get<Vector3>(bodyJoints[i], 0x50), 0.1f, new MtColor(255, 0, 0, 255)); + } + + for (int i = 0; i < faceJoints.Count; i++) + { + Primitives.RenderSphere(Get<Vector3>(faceJoints[i], 0x50), 0.1f, new MtColor(255, 0, 0, 255)); + } + + for (int i = 0; i < hairJoints.Count; i++) + { + Primitives.RenderSphere(Get<Vector3>(hairJoints[i], 0x50), 0.1f, new MtColor(255, 0, 0, 255)); + } + } + } + } +} diff --git a/Models.cs b/Models.cs new file mode 100644 index 0000000..4073716 --- /dev/null +++ b/Models.cs @@ -0,0 +1,568 @@ +using System.Numerics; +using System.Text.RegularExpressions; + +using ImGuiNET; +using SharpPluginLoader.Core.Entities; +using SharpPluginLoader.Core.Actions; +using SharpPluginLoader.Core.Components; + +namespace PlayerPoser +{ + using static Utility; + + internal static unsafe class Models + { + private static string modelFilter = ""; + private static bool modelFilterIsRegex = false; + private static Regex? modelRegex = null; + internal static bool modelOnlyAddressLod0 = false; + + private static string objectFilter = ""; + private static bool sortObjectsByDistanceToPlayer = false; + + private static int inputLmt = -1; + private static int inputAnimationId = -1; + private static int inputSet = -1; + private static int inputActionId = -1; + + internal static Vector4 rotateVector4(Vector4 rotation, Vector3 offset) + { + Quaternion rotationQ = new(rotation.X, rotation.Y, rotation.Z, rotation.W); + rotationQ *= Quaternion.CreateFromYawPitchRoll(offset.X, offset.Y, offset.Z); + return new(rotationQ.X, rotationQ.Y, rotationQ.Z, rotationQ.W); + } + + internal static bool drawRotate(string label, Vector4 rotation, out Vector4 result) + { + Vector3 offset = default; + if (ImGui.DragFloat3(label, ref offset, 0.0025f)) + { + result = rotateVector4(rotation, offset); + return true; + } + result = new(-1.0f); + return false; + } + + internal static string extractPartName(string fullString) + { + string partName = ""; + if (fullString.StartsWith("pl\\f_equip") || fullString.StartsWith("pl\\m_equip")) + { + partName = fullString.Split('\\')[3]; + } + else if (fullString.StartsWith("wp\\")) + { + string[] split = fullString.Split('\\'); + partName = (split[4] == "mod") ? split[5] : split[4]; + } + else if (fullString.StartsWith("pl\\hair")) + { + partName = fullString.Split('\\')[2]; + } + else if (fullString.StartsWith("pl\\f_face") || fullString.StartsWith("pl\\m_face")) + { + partName = fullString.Split('\\')[4].Substring(2); + } + return partName; + } + + internal static void drawModelParts(nint armorAddr, nint resourceAddr = 0x0, bool hideAll = false, bool showAll = false) + { + if (resourceAddr == 0x0) + { + if (armorAddr == 0x0 || (resourceAddr = Get<nint>(armorAddr, 0x2A0)) == 0x0) + { + return; + } + } + ImGui.PushID(resourceAddr); + string fullString = new(GetPtrInline<sbyte>(resourceAddr, 0xC)); + if (armorAddr != 0x0) + { + string partName = extractPartName(fullString); + ImGui.Text($"{partName} (0x{armorAddr:X}, {fullString} @ 0x{resourceAddr:X}):"); + } + else + { + ImGui.Text($"{fullString} @ 0x{resourceAddr:X}:"); + } + // MonsterHunterWorld.exe+222E651 - mov rax,[r8+000000C8] + nint baseLod = Get<nint>(resourceAddr, 0xC8); + nint baseOffset = Get<nint>(resourceAddr, 0x408 + (0x8 * 0x1)); + int numParts = Get<int>(resourceAddr, 0x548 + (0x4 * 0x1)); + // Setting lodCount to 0 is probably the best way to completely hide a model. + int lodCount = Get<int>(resourceAddr, 0xD0); + const int lodStructSize = 0x50; + const int partsPerLine = 10; + bool allOn = ImGui.Button("Show All") || showAll; + ImGui.SameLine(); + bool allOff = ImGui.Button("Hide All") || hideAll; + for (int i = 0; i < numParts; i++) + { + int lodOffset = Get<int>(baseOffset, i * 0x4); + nint lod0 = baseLod + (lodOffset * lodStructSize); + ushort lod0Visible = Get<ushort>(lod0); + bool isVisible = lod0Visible != 0; + bool togglePart = ImGui.Checkbox($"##Part #{i}", ref isVisible); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text($"Part #{i} (0x{lod0:X})"); + ImGui.EndTooltip(); + } + int lastLod = (i < numParts - 1) ? Get<int>(baseOffset, (i + 1) * 0x4) : lodCount; + int partLodCount = lastLod - lodOffset; + // This is not a "proper" way to hide a part. It abuses the fact that if the lower + // 16 bits (lodVisible) of these 4 bytes are 0, a check to skip rendering it will + // always pass. Also that +0xA appears to be unused/padding. + // MonsterHunterWorld.exe+222FCE3 - mov eax,[r8] + for (int j = 0; j < partLodCount; j++) + { + if (togglePart || (lod0Visible != 0 && allOff) || (lod0Visible == 0 && allOn)) + { + nint lod = lod0 + (j * lodStructSize); + ref ushort lodVisible = ref GetRef<ushort>(lod); + ref ushort padSub = ref GetRef<ushort>(lod, 0xA); + if (lod0Visible != 0) Assert(padSub == 0); + // Check against LOD0 to prevent an inconsistent state. + if ((lodVisible != 0) == (lod0Visible != 0)) + { + (lodVisible, padSub) = (padSub, lodVisible); + } + } + if (modelOnlyAddressLod0) break; + } + if (i != numParts - 1 && i % partsPerLine != partsPerLine - 1) + { + ImGui.SameLine(); + } + } + ImGui.PopID(); + } + + internal static void runAction(ActionController actionController, int actionSet, int actionId) + { + actionController.DoAction(actionSet, actionId); + /* + actionController.GetRef<int>(0xC0) = actionId; + actionController.GetRef<int>(0xBC) = actionSet; + */ + } + + internal static void drawAnimationInfo(Entity entity, float width, bool debug) + { + ActionController actionController = entity.ActionController; + ActionInfo currentActionInfo = actionController.CurrentAction; + SharpPluginLoader.Core.Actions.Action? currentAction = null; + if (currentActionInfo.ActionSet >= 0 && currentActionInfo.ActionSet <= 3) + { + ActionList actionList = actionController.GetActionList(currentActionInfo.ActionSet); + if (currentActionInfo.ActionId >= 0 && currentActionInfo.ActionId < actionList.Count) + { + currentAction = actionList[currentActionInfo.ActionId]; + } + } + if (debug) + { + ImGui.Text($"ActionController: 0x{actionController.Instance:X}"); + ImGui.Text($" Current: {currentAction} {currentActionInfo}"); + if (currentAction != null) + { + + ImGui.Text($" Active Time: {currentAction.ActiveTime}"); + ImGui.Text($" Delta Sec: {currentAction.DeltaSec}"); + } + } + AnimationId currentAnimation = entity.CurrentAnimation; + AnimationLayerComponent? animationLayer = entity.AnimationLayer; + if (animationLayer != null) + { + ImGui.Text(debug ? $"AnimationLayer: 0x{animationLayer.Instance:X}" : "Animation"); + + if (debug) + { + ImGui.Text($" Current: {currentAnimation}"); + ImGui.Text($" Frame: {animationLayer.CurrentFrame:0.000}/{animationLayer.MaxFrame:0.000}"); + } + else + { + ImGui.Text($" Current: {currentAnimation.Lmt}.{currentAnimation.Id}, {(currentAction != null ? currentAction.Name : "None")} ({currentActionInfo.ActionSet}.{currentActionInfo.ActionId})"); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("{Lmt}.{Id}, {Action} ({Set}.{Id})"); + ImGui.EndTooltip(); + } + ImGui.SetNextItemWidth(width * 0.85f); + ImGui.SliderFloat("Frame", ref animationLayer.CurrentFrame, 0.0f, animationLayer.MaxFrame, "%.3f"); + bool animationPaused = animationLayer.Paused; + if (ImGui.Checkbox("Paused", ref animationPaused)) + { + animationLayer.Paused = animationPaused; + } + ImGui.SameLine(); + float? lockedSpeed = animationLayer.LockedSpeed; + float speed = lockedSpeed ?? animationLayer.Speed; + bool animationLocked = lockedSpeed != null; + if (ImGui.Checkbox("Set", ref animationLocked)) + { + if (animationLocked) + { + animationLayer.LockSpeed(speed); + } + else + { + animationLayer.UnlockSpeed(); + } + } + ImGui.SameLine(); + ImGui.SetNextItemWidth(width * 0.2f); + if (ImGui.DragFloat($"Speed", ref speed, 0.01f, 0.0f, 0.0f, "%.3f")) + { + if (animationLocked) animationLayer.LockSpeed(speed); + } + } + + if (debug) + { + ImGui.PushItemWidth(width * 0.075f); + ImGui.PushID("Animation"); + bool animationValid = inputLmt >= 0 && inputAnimationId >= 0; + if (!animationValid) + { + ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * 0.5f); + } + bool doAnimation = ImGui.Button("Do"); + if (!animationValid) + { + ImGui.PopStyleVar(); + ImGui.PopItemFlag(); + } + ImGui.SameLine(); + ImGui.InputInt("Lmt", ref inputLmt, 0); + ImGui.SameLine(); + ImGui.InputInt("Animation Id", ref inputAnimationId, 0); + ImGui.PopID(); + ImGui.PushID("Action"); + bool actionValid = inputSet >= 0 && inputActionId >= 0; + if (!actionValid) + { + ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * 0.5f); + } + bool doAction = ImGui.Button("Do"); + if (!actionValid) + { + ImGui.PopStyleVar(); + ImGui.PopItemFlag(); + } + ImGui.SameLine(); + ImGui.InputInt("Set", ref inputSet, 0); + ImGui.SameLine(); + float widthDiff = ImGui.CalcTextSize("Lmt").X - ImGui.CalcTextSize("Set").X; + ImGui.SetCursorPos(ImGui.GetCursorPos() + new Vector2(widthDiff, 0.0f)); + ImGui.InputInt("Action Id", ref inputActionId, 0); + ImGui.PopID(); + if (!(animationValid && actionValid)) + { + ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * 0.5f); + } + if (ImGui.Button("Do Both")) + { + doAnimation = true; + doAction = true; + } + if (!(animationValid && actionValid)) + { + ImGui.PopStyleVar(); + ImGui.PopItemFlag(); + } + if (doAction) + { + runAction(actionController, inputSet, inputActionId); + } + if (doAnimation) + { + animationLayer.DoAnimation(new AnimationId((uint)inputLmt, (uint)inputAnimationId)); + } + ImGui.PopItemWidth(); + } + } + } + + private static void iterList(nint baseAddr, Action<nint> func) + { + nint next = baseAddr; + nint head = next; + nint prev = Get<nint>(next, 0x10); + for (;next != 0x0;) + { + func(next + 0x40); + if (head == prev) + { + next = Get<nint>(next, 0x10); + } + else + { + next = Get<nint>(next, 0x18); + if (next == 0x0) + { + head = prev; + next = prev; + } + } + } + } + + internal static void drawModelList(float width, nint baseObject) + { + ImGui.PushID("Models"); + ImGui.Text("Filter"); + bool updateRegex = false; + bool invalidRegex = modelFilterIsRegex && modelFilter != "" && modelRegex == null; + if (invalidRegex) + { + ImGui.PushStyleColor(ImGuiCol.Text, 0xFF0000FF); + } + ImGui.SetNextItemWidth(width * 0.55f); + if (ImGui.InputText("##Filter", ref modelFilter, 256)) + { + if (modelFilterIsRegex) + { + updateRegex = true; + } + } + if (invalidRegex) + { + ImGui.PopStyleColor(); + } + ImGui.SameLine(); + if (ImGui.Button("Clear")) + { + modelFilter = ""; + if (modelFilterIsRegex) + { + updateRegex = true; + } + } + ImGui.SameLine(); + if (ImGui.Checkbox("Regex", ref modelFilterIsRegex)) + { + if (modelFilterIsRegex) + { + updateRegex = true; + } + } + if (updateRegex) + { + if (String.IsNullOrEmpty(modelFilter)) + { + modelRegex = null; + } + else + { + try + { + modelRegex = new Regex(modelFilter); + } + catch (ArgumentException) + { + modelRegex = null; + } + } + } + bool hideEverything = ImGui.Button("Hide Everything"); + ImGui.SameLine(); + bool showEverything = ImGui.Button("Show Everything"); + nint baseObjectResource = Get<nint>(baseObject, 0x2A0); + if (baseObjectResource != 0x0) + { + iterList(baseObjectResource - 0x40, (partAddr) => + { + ImGui.PushID(partAddr); + nint vTable = Get<nint>(partAddr); + if (vTable == 0x143507A18) + { + string fullString = new(GetPtrInline<sbyte>(partAddr, 0xC)); + bool filterMatch = false; + if (modelFilterIsRegex) + { + filterMatch = modelRegex == null || modelRegex.Match(fullString).Success; + } + else + { + filterMatch = String.IsNullOrEmpty(modelFilter) || fullString.StartsWith(modelFilter); + } + if (filterMatch) + { + drawModelParts(0x0, partAddr, hideEverything, showEverything); + } + } + ImGui.PopID(); + }); + } + ImGui.PopID(); + } + + private static void searchUnitList(long addr, List<nint> objects) + { + nint baseAddr = Get<nint>(addr); + if (baseAddr == 0x0) return; + baseAddr = Get<nint>(baseAddr, 0xB8); + if (baseAddr == 0x0) return; + iterList(baseAddr + 0x40, (objectAddr) => + { + nint vTable = Get<nint>(objectAddr); + if (vTable == 0x14341F728 || vTable == 0x1434A9720) // Instanced Model || uScrMotionModel + { + objects.Add(objectAddr); + } + }); + } + + internal static void drawObjectList(float width, Player player) + { + List<nint> objects = new(); + searchUnitList(0x1450ECA20, objects); + searchUnitList(0x1450EC980, objects); + ImGui.PushID("Objects"); + ImGui.Text("Filter"); + ImGui.SetNextItemWidth(width * 0.55f); + ImGui.InputText("##Filter", ref objectFilter, 256); + ImGui.Checkbox("Sort By Distance To Player", ref sortObjectsByDistanceToPlayer); + IEnumerable<nint> enumerator = objects; + if (sortObjectsByDistanceToPlayer) + { + enumerator = Enumerable.OrderBy(objects, (x) => x, Comparer<nint>.Create((x, y) => + { + Vector3 pos = player.Position; + Vector3 xPos = default, yPos = default; + nint vTableX = Get<nint>(x); + nint vTableY = Get<nint>(y); + if (vTableX == 0x1434A9720) + { + xPos = Get<Vector3>(x, 0x160); + } + else if (vTableX == 0x14341F728) + { + bool instanced = (Get<byte>(x, 0x2C8) & 0x10) != 0x10; + if (instanced) + { + xPos = Get<Vector3>(x, 0x500); + } + else + { + xPos = Get<Vector3>(x, 0x160); + } + } + if (vTableY == 0x1434A9720) + { + yPos = Get<Vector3>(y, 0x160); + } + else if (vTableY == 0x14341F728) + { + bool instanced = (Get<byte>(y, 0x2C8) & 0x10) != 0x10; + if (instanced) + { + yPos = Get<Vector3>(y, 0x500); + } + else + { + yPos = Get<Vector3>(y, 0x160); + } + } + float distX = Vector3.Distance(pos, xPos); + float distY = Vector3.Distance(pos, yPos); + if (distX < distY) return -1; + else if (distX > distY) return 1; + return 0; + })); + } + foreach (nint objectAddr in enumerator) + { + nint resourceAddr = Get<nint>(objectAddr, 0x2A0); + string fullString = new(GetPtrInline<sbyte>(resourceAddr, 0xC)); + bool filterMatch = string.IsNullOrEmpty(objectFilter) || (!string.IsNullOrEmpty(fullString) && fullString.StartsWith(objectFilter)); + if (!filterMatch) + { + continue; + } + ImGui.PushID(objectAddr); + if (ImGui.CollapsingHeader($"{fullString} @ 0x{objectAddr:X}")) + { + nint vTable = Get<nint>(objectAddr); + if (vTable == 0x1434A9720) + { + ImGui.DragFloat3("Position", ref GetRef<Vector3>(objectAddr, 0x160), 0.5f); + } + else + { + bool update = GetRef<byte>(objectAddr, 0x540) == 0x1; + if (ImGui.Checkbox("Update", ref update)) + { + GetRef<byte>(objectAddr, 0x540) = ByteFlag(update); + } + ImGui.SameLine(); + bool instanced = (GetRef<byte>(objectAddr, 0x2C8) & 0x10) == 0x10; + if (ImGui.Checkbox("Instanced", ref instanced)) + { + if (instanced) + { + GetRef<byte>(objectAddr, 0x2C8) |= 0x10; + } + else + { + GetRef<byte>(objectAddr, 0x2C8) &= 0xF; + GetRef<Vector3>(objectAddr, 0x160) = GetRef<Vector3>(objectAddr, 0x500); + } + } + if (instanced) + { + ImGui.DragFloat3("Position", ref GetRef<Vector3>(objectAddr, 0x500), 0.5f); + int instanceCount = Get<int>(objectAddr, 0x4C0); + nint instances = Get<nint>(objectAddr, 0x4B8); + ImGui.Text($"Instances: {instanceCount} (0x{instances:X})"); + for (int i = 0; i < instanceCount; i++) + { + ImGui.PushID(instances); + ref Vector3 position = ref GetRef<Vector3>(instances, 0xF0); + ref Vector4 rotation = ref GetRef<Vector4>(instances, 0x100); + ref Vector3 scale = ref GetRef<Vector3>(instances, 0x110); + ImGui.DragFloat3("Position", ref position, 0.5f); + ImGui.SliderFloat4("Rotation", ref rotation, -1.0f, 1.0f); + if (drawRotate("Rotate", rotation, out Vector4 result)) + { + rotation = result; + } + ImGui.DragFloat3("Scale", ref scale, 0.025f); + ImGui.Separator(); + ImGui.PopID(); + instances += 0x1D0; + } + } + else + { + ref Vector3 position = ref GetRef<Vector3>(objectAddr, 0x160); + ref Vector4 rotation = ref GetRef<Vector4>(objectAddr, 0x170); + ref Vector3 scale = ref GetRef<Vector3>(objectAddr, 0x180); + ImGui.DragFloat3("Position", ref position, 0.5f); + if (ImGui.Button("Move to Player")) + { + position = new(player.Position.X, player.Position.Y - 150.0f, player.Position.Z); + } + ImGui.SliderFloat4("Rotation", ref rotation, -1.0f, 1.0f); + if (drawRotate("Rotate", rotation, out Vector4 result)) + { + rotation = result; + } + ImGui.DragFloat3("Scale", ref scale, 0.025f); + } + } + } + ImGui.PopID(); + } + ImGui.PopID(); + } + } +} diff --git a/PlayerPoser.csproj b/PlayerPoser.csproj new file mode 100644 index 0000000..0ad9e76 --- /dev/null +++ b/PlayerPoser.csproj @@ -0,0 +1,26 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net8.0</TargetFramework> + <ImplicitUsings>enable</ImplicitUsings> + <Nullable>enable</Nullable> + <AllowUnsafeBlocks>True</AllowUnsafeBlocks> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="SharpPluginLoader.ImGui" Version="1.90.2.3" /> + </ItemGroup> + + <ItemGroup> + <Reference Include="SharpPluginLoader.Bootstrapper"> + <HintPath>..\SharpPluginLoader-fork\SharpPluginLoader.Bootstrapper\bin\Release\net8.0\SharpPluginLoader.Bootstrapper.dll</HintPath> + </Reference> + <Reference Include="SharpPluginLoader.Core"> + <HintPath>..\SharpPluginLoader-fork\SharpPluginLoader.Core\bin\Release\net8.0\SharpPluginLoader.Core.dll</HintPath> + </Reference> + <Reference Include="WorldTuningTool"> + <HintPath>..\WorldTuningTool\bin\Release\net8.0\WorldTuningTool.dll</HintPath> + </Reference> + </ItemGroup> + +</Project> diff --git a/PlayerPoser.sln b/PlayerPoser.sln new file mode 100644 index 0000000..e6cbbb9 --- /dev/null +++ b/PlayerPoser.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.12.35514.174 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{44C7FB79-D2FA-4610-89FE-8511C1A6BA7C}") = "PlayerPoser", "PlayerPoser.csproj", "{E9DE1105-BC7A-4753-9181-E7DA03727E54}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E9DE1105-BC7A-4753-9181-E7DA03727E54}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E9DE1105-BC7A-4753-9181-E7DA03727E54}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E9DE1105-BC7A-4753-9181-E7DA03727E54}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E9DE1105-BC7A-4753-9181-E7DA03727E54}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Plugin.cs b/Plugin.cs new file mode 100644 index 0000000..2173bae --- /dev/null +++ b/Plugin.cs @@ -0,0 +1,722 @@ +using System.Numerics; + +using ImGuiNET; +using SharpPluginLoader.Core; +using SharpPluginLoader.Core.Memory; +using SharpPluginLoader.Core.View; +using SharpPluginLoader.Core.Entities; +using SharpPluginLoader.Core.Rendering; + +namespace PlayerPoser +{ + using static Utility; + + public unsafe class Plugin : IPlugin + { + public string Name => "Player Poser"; + public string Author => "Akon City Software"; + + private const string fontPath = "nativePC/plugins/CSharp/Fonts/Catrinity.otf"; + private bool tryCustomFont = false; + + internal static readonly MtObject sMhArea = SingletonManager.GetSingleton("sMhArea")!; + + internal static readonly MtObject sPlayer = SingletonManager.GetSingleton("sPlayer")!; + internal static readonly MtObject sOtomo = SingletonManager.GetSingleton("sOtomo")!; + + internal static readonly MtObject sUserData = SingletonManager.GetSingleton("sUserData")!; + + private bool hideWeapon = false; + private NativeAction<nint, int> hideWeaponFunc; + private bool hideKnife = false; + private bool hideSlinger = false; + private bool updateHideSlinger = false; + + private static bool overridePlayerWetness = false; + private static float headWetness = 0.0f; + private static float bodyWetness = 0.0f; + private static float waistWetness = 0.0f; + private static float legsWetness = 0.0f; + private Patch noopPlayerWetnessUpdate; + private Patch jmpOverChangeEquipmentWetnessUpdate_1; + private Patch jmpOverChangeEquipmentWetnessUpdate_2; + + private void overridePlayerWetnessEnable() + { + noopPlayerWetnessUpdate.Enable(); + jmpOverChangeEquipmentWetnessUpdate_1.Enable(); + jmpOverChangeEquipmentWetnessUpdate_2.Enable(); + } + + private void overridePlayerWetnessDisable() + { + noopPlayerWetnessUpdate.Disable(); + jmpOverChangeEquipmentWetnessUpdate_1.Disable(); + jmpOverChangeEquipmentWetnessUpdate_2.Disable(); + } + + private float playerOpacityOverride = 1.0f; + private float palicoOpacityOverride = 1.0f; + private delegate void UpdateCharacterParams(nint characterObject, nint unknownPtr); + private Hook<UpdateCharacterParams>? updateCharacterParams; + private delegate void UpdatePalicoFade(nint palicoObject); + private Hook<UpdatePalicoFade>? updatePalicoFade; + + private bool disableCollision = false; + private bool disableExtraCollision = false; + private bool disableGravity = false; + private bool disableExtraGravity = false; + private Patch disableXCollision; + private Patch disableYCollision; + private Patch disableSecondaryYCollision; + private Patch disableZCollision; + private Patch disableExtraYCollision; + private Patch disableGravityYUpdate; + private Patch disableGravityXZUpdate; + private Patch disableGravityEval; + + private void disableCollisionEnable() + { + disableXCollision.Enable(); + disableYCollision.Enable(); + disableSecondaryYCollision.Enable(); + disableZCollision.Enable(); + } + + private void disableCollisionDisable() + { + disableXCollision.Disable(); + disableYCollision.Disable(); + disableSecondaryYCollision.Disable(); + disableZCollision.Disable(); + } + + private void disableExtraCollisionEnable() + { + disableExtraYCollision.Enable(); + } + + private void disableExtraCollisionDisable() + { + disableExtraYCollision.Disable(); + } + + private void disableGravityEnable() + { + disableGravityYUpdate.Enable(); + } + + private void disableGravityDisable() + { + disableGravityYUpdate.Disable(); + } + + private void disableExtraGravityEnable() + { + disableGravityEval.Enable(); + } + + private void disableExtraGravityDisable() + { + disableGravityEval.Disable(); + } + + private bool sortMonsters; + private bool sortAnimals; + + public PluginData Initialize() + { + PluginData data = new PluginData(); + + if (File.Exists(fontPath)) + { + Renderer.RegisterFont("Catrinity", fontPath, 21.0f, GlyphRangeFactory.CreateGlyphRanges([ + (0x0020, 0x00FF), (0x2640, 0x2642) // Gender symbols. + ])); + tryCustomFont = true; + } + + Utility.Initialize(); + Zone.Initialize(); + Armor.Initialize(); + + hideWeaponFunc = new NativeAction<nint, int>(0x141789AB0); + + updateCharacterParams = Hook.Create<UpdateCharacterParams>(0x141F605F0, UpdateCharacterParamsHook); + updatePalicoFade = Hook.Create<UpdatePalicoFade>(0x14201D130, UpdatePalicoFadeHook); + + noopPlayerWetnessUpdate = new Patch(0x14203E893, [0x90, 0x90, 0x90, 0x90, 0x90]); + jmpOverChangeEquipmentWetnessUpdate_1 = new Patch(0x14203E310, [0xEB]); // je -> jmp. + jmpOverChangeEquipmentWetnessUpdate_2 = new Patch(0x14203E397, [0xE9, 0xB9, 0x00, 0x00, 0x00, 0x90]); // je -> jmp. + + // Noop collision checks. + nint addr = PatternScanner.FindFirst(Pattern.FromString("F3 0F 11 06 F3 0F 10 48 04 F3 0F 58 4E 04 F3 0F 11 4E 04 F3 0F 10 40 08 F3 0F 58 46 08 F3 0F 11 46 08 44 8B AF E0 0B 00 00")); + Assert(addr == 0x141C001B5); + disableXCollision = new Patch(addr, [0x90, 0x90, 0x90, 0x90]); + Assert(addr + 0xE == 0x141C001C3); + disableYCollision = new Patch(addr + 0xE, [0x90, 0x90, 0x90, 0x90, 0x90]); + Assert(addr + 0x1D == 0x141C001D2); + disableZCollision = new Patch(addr + 0x1D, [0x90, 0x90, 0x90, 0x90, 0x90]); + + addr = PatternScanner.FindFirst(Pattern.FromString("F3 0F 11 46 04 F3 0F 10 46 08 F3 0F 5C C2 F3 0F 11 46 08 ?? ?? F3 0F")); + Assert(addr == 0x141C000D2); + disableSecondaryYCollision = new Patch(addr, [0x90, 0x90, 0x90, 0x90, 0x90]); + + addr = PatternScanner.FindFirst(Pattern.FromString("F3 0F 11 46 04 F3 0F 10 58 08 F3 0F 58 5E 08 F3 0F 11 5E 08 44 8B 87 D0 0B 00 00 41 F6 C0 03")); + Assert(addr == 0x141BFFF90); + disableExtraYCollision = new Patch(addr, [0x90, 0x90, 0x90, 0x90, 0x90]); + + addr = PatternScanner.FindFirst(Pattern.FromString("F3 0F 11 83 80 00 00 00 F3 0F 11 8B 84 00 00 00 F3 0F 11 93 88 00 00 00 89 B3 8C 00 00 00 8B 83 A4 01 00 00 C1 E8 05 44 0F 29 A4 24 D0 01 00 00 44 0F 29 B4 24 B0 01 00 00 A8 01")); + Assert(addr + 0x8 == 0x1413259ED); + disableGravityYUpdate = new Patch(addr + 0x8, [ + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + ]); + disableGravityXZUpdate = new Patch(addr, [ + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // Will already be applied. + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 + ]); + + addr = PatternScanner.FindFirst(Pattern.FromString("F3 0F 11 97 54 15 00 00 F3 0F 11 8F 58 15 00 00 F3 0F 10 47 68 F3 0F 5E D8 44 89 B7 6C 15 00 00 F3 0F 5E D0 F3 0F 5E C8 F3 0F 11 9F 60 15 00 00 F3 0F 11 97 64 15 00 00 F3 0F 11 8F 68 15 00 00")); + Assert(addr + 0x40 == 0x141BFFF75); + disableGravityEval = new Patch(addr + 0x40, [0x90, 0x90, 0x90, 0x90, 0x90]); // call MonsterHunterWorld.exe+1325810. + + return data; + } + + private void perFrameHideEquipment(Player player) + { + if (hideWeapon) + { + hideWeaponFunc.Invoke(player.Instance, 0); + /* + // MonsterHunterWorld.exe+1789ABA - mov rdi,[rcx+000076B0] + nint weapon = player.Get<nint>(0x76B0); + if (weapon != 0x0) + { + GetRef<byte>(weapon, 0x1A98) = 0x1; + int weaponParts = Get<int>(weapon, 0x2250); + for (int i = 0; i < weaponParts; i++) + { + nint part = Get<nint>(weapon, (i + 0x16B) * 24); + if (part != 0x0) + { + GetRef<byte>(part, 0x1A98) = 0x1; + } + } + } + */ + } + + if (hideKnife) + { + // Emulate what Carving and Flourish emote do at + // MonsterHunterWorld.exe+1F68832 - bts eax,06 + // if set, skips + // MonsterHunterWorld.exe+203A0D2 - bts ecx,01 + player.GetRef<int>(0x8938) |= (1 << 6); + player.GetRef<int>(0x8968) |= (1 << 6); + /* + if (playerArmor[Armor.Waist] != 0x0) + { + if (hideKnife) + { + GetRef<byte>(playerArmor[Armor.Waist], 0x2D0) &= 0xFD; + } + else + { + GetRef<byte>(playerArmor[Armor.Waist], 0x2D0) |= 0x2; + } + } + */ + } + + if (hideSlinger || updateHideSlinger) + { + nint slinger = player.Get<nint>(0x8918); + if (slinger != 0) + { + // MonsterHunterWorld.exe+AD9CC6 - cmp [rdi+000019E7],bl + // MonsterHunterWorld.exe+AD8A10 - and [rbx+000002D0],FFFFFE1E + GetRef<byte>(slinger, 0x19E7) = ByteFlag(hideSlinger); + updateHideSlinger = false; + } + } + } + + internal static void OnPlayerChange() + { + Armor.OnPlayerChange(); + } + + public void OnUpdate(float deltaTime) + { + Utility.OnUpdate(); + Armor.OnUpdate(); + + Player? player = getPlayer(); + if (player != null) + { + perFrameHideEquipment(player); + } + } + + internal static void OnZoneChange(nint player) + { + if (overridePlayerWetness) + { + nint wetnessAddr = player + 0x13BD0; + GetRef<float>(wetnessAddr) = headWetness; + GetRef<float>(wetnessAddr, 0x28) = bodyWetness; + GetRef<float>(wetnessAddr, 0x50) = waistWetness; + GetRef<float>(wetnessAddr, 0x78) = legsWetness; + } + } + + private void UpdateCharacterParamsHook(nint characterObject, nint unknownPtr) + { + updateCharacterParams!.Original(characterObject, unknownPtr); + + if (playerOpacityOverride != 1.0f) + { + Player? player = getPlayer(); + if (player != null && characterObject == player.Instance) + { + player.GetRef<float>(0x78E0) = playerOpacityOverride; + } + } + } + + public void UpdatePalicoFadeHook(nint palicoObject) + { + updatePalicoFade!.Original(palicoObject); + + if (palicoOpacityOverride != 1.0f) + { + NativeWrapper palico = getPalico(); + if (palico != 0x0 && palicoObject == palico) + { + palico.GetRef<float>(0x314) = palicoOpacityOverride; + } + } + } + + private void drawPlayerName(NativeWrapper playerSettings, bool isFemale) + { + string playerName = new(playerSettings.GetPtrInline<sbyte>(0x50)); + string genderSymbol; + if (tryCustomFont) + { + ImGui.PushFont(Renderer.GetFont("Catrinity")); + genderSymbol = isFemale ? "♀" : "♂"; + } + else + { + genderSymbol = isFemale ? "(F)" : "(M)"; + } + ImGui.Text($"{playerName}"); + ImGui.SameLine(); + if (isFemale) + { + ImGui.PushStyleColor(ImGuiCol.Text, (uint)ColorVectorToInt(ImGui.GetStyle().Colors[(int)ImGuiCol.PlotHistogram])); + } + else + { + ImGui.PushStyleColor(ImGuiCol.Text, (uint)ColorVectorToInt(ImGui.GetStyle().Colors[(int)ImGuiCol.PlotLinesHovered])); + } + ImGui.SetCursorPos(ImGui.GetCursorPos() - new Vector2(4.0f, (tryCustomFont && isFemale) ? -1.0f : 0.0f)); + ImGui.Text($"{genderSymbol}"); + ImGui.PopStyleColor(); + if (tryCustomFont) + { + ImGui.PopFont(); + } + ImGui.SetCursorPos(ImGui.GetCursorPos() + new Vector2(0.0f, 2.0f)); + } + + public void OnRender() + { + Armor.OnRender(); + } + + public void OnImGuiRender() + { + float width = ImGui.GetWindowWidth(); + width /= width / 600.0f; + + Player? player = getPlayer(); + NativeWrapper playerSettings = new(0x0); + if (player == null) + { + ImGui.Text("Player not found"); + goto debug; + } + playerSettings = getPlayerSettings(); + + bool isFemale = player.Get<byte>(0x1371C) == 1; + drawPlayerName(playerSettings, isFemale); + + ImGui.Checkbox("Hide Weapon", ref hideWeapon); + ImGui.SameLine(); + ImGui.Checkbox("Hide Knife", ref hideKnife); + ImGui.SameLine(); + if (ImGui.Checkbox("Hide Slinger", ref hideSlinger)) + { + updateHideSlinger = true; + } + + ImGui.AlignTextToFramePadding(); + ImGui.Text("Head Armor Display"); + // MonsterHunterWorld.exe+11A2967 - cmp byte ptr [rax+001403E1],01 + ref byte showHeadArmor = ref playerSettings.GetRef<byte>(0x1403E1); + int showHeadArmorInt = showHeadArmor; + ImGui.SameLine(); + if (ImGui.RadioButton("Show", ref showHeadArmorInt, 0)) + { + showHeadArmor = (byte)showHeadArmorInt; + } + ImGui.SameLine(); + if (ImGui.RadioButton("Hide", ref showHeadArmorInt, 1)) + { + showHeadArmor = (byte)showHeadArmorInt; + } + ImGui.SameLine(); + if (ImGui.RadioButton("Hide in Cutscenes", ref showHeadArmorInt, 2)) + { + showHeadArmor = (byte)showHeadArmorInt; + } + + if (ImGui.CollapsingHeader("Armor Parts")) + { + Armor.drawArmorParts(player, width); + } + + ImGui.PushID("Opacity"); + ref float playerOpacity = ref player.GetRef<float>(0x78E0); + if (ImGui.Button("Reset")) + { + playerOpacity = 1.0f; + playerOpacityOverride = 1.0f; + } + ImGui.SameLine(); + ImGui.SetNextItemWidth(width * 0.3f); + if (ImGui.DragFloat("Opacity", ref playerOpacity, 0.01f, 0.0f, Single.MaxValue)) + { + playerOpacityOverride = playerOpacity; + } + NativeWrapper palico = getPalico(); + if (palico != 0x0) + { + ImGui.PushID("Palico"); + ref float palicoOpacity = ref palico.GetRef<float>(0x314); + if (ImGui.Button("Reset")) + { + palicoOpacity = 1.0f; + palicoOpacityOverride = 1.0f; + } + ImGui.SameLine(); + ImGui.SetNextItemWidth(width * 0.3f); + if (ImGui.DragFloat("Palico Opacity", ref palicoOpacity, 0.01f, 0.0f, Single.MaxValue)) + { + palicoOpacityOverride = palicoOpacity; + } + ImGui.PopID(); + } + ImGui.PopID(); + + ImGui.PushID("Wetness"); + if (ImGui.CollapsingHeader("Wetness")) + { + nint wetnessAddr = player.Instance + 0x13BD0; + ref float head = ref GetRef<float>(wetnessAddr); + ref float body = ref GetRef<float>(wetnessAddr, 0x28); + ref float waist = ref GetRef<float>(wetnessAddr, 0x50); + ref float legs = ref GetRef<float>(wetnessAddr, 0x78); + ImGui.PushItemWidth(width * 0.2f); + if (ImGui.DragFloat("Head", ref headWetness, 0.005f)) + { + head = headWetness; + } + ImGui.SameLine(); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + ImGui.Text($"(Current: {head})"); + ImGui.PopStyleVar(); + if (ImGui.DragFloat("Body", ref bodyWetness, 0.005f)) + { + body = bodyWetness; + } + ImGui.SameLine(); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + ImGui.Text($"(Current: {body})"); + ImGui.PopStyleVar(); + if (ImGui.DragFloat("Waist", ref waistWetness, 0.005f)) + { + waist = waistWetness; + } + ImGui.SameLine(); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + ImGui.Text($"(Current: {waist})"); + ImGui.PopStyleVar(); + if (ImGui.DragFloat("Legs", ref legsWetness, 0.005f)) + { + legs = legsWetness; + } + ImGui.SameLine(); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + ImGui.Text($"(Current: {legs})"); + ImGui.PopStyleVar(); + ImGui.PopItemWidth(); + if (ImGui.Button("Reset")) + { + head = headWetness = 0.0f; + body = bodyWetness = 0.0f; + waist = waistWetness = 0.0f; + legs = legsWetness = 0.0f; + } + ImGui.SameLine(); + if (ImGui.Checkbox("Override Player Wetness", ref overridePlayerWetness)) + { + if (overridePlayerWetness) + { + overridePlayerWetnessEnable(); + head = headWetness; + body = bodyWetness; + waist = waistWetness; + legs = legsWetness; + } + else + { + overridePlayerWetnessDisable(); + } + } + } + ImGui.PopID(); + + if (ImGui.CollapsingHeader("Skin Tone")) + { + Armor.drawSkinTone(player, playerSettings, width); + } + + ImGui.PushID("Position"); + ImGui.PushItemWidth(width * 0.75f); + ImGui.DragFloat3("Position", ref player.Position, 0.5f); + Vector3 forward = new(player.Forward.X, player.Forward.Y, player.Forward.Z); + ImGui.DragFloat3("Forward", ref forward, 0.0f); + Vector4 rotation = new(player.Rotation.X, player.Rotation.Y, player.Rotation.Z, player.Rotation.W); + ImGui.SliderFloat4("Rotation", ref rotation, -1.0f, 1.0f); + if (Models.drawRotate("Rotate", rotation, out Vector4 result)) + { + player.Rotation = new(result.X, result.Y, result.Z, result.W); + } + ImGui.PopItemWidth(); + if (ImGui.Button("Reset")) + { + player.Rotation.X = 0.0f; + player.Rotation.Z = 0.0f; + } + ImGui.PopID(); + + if (ImGui.Checkbox("Disable Some Collision", ref disableCollision)) + { + if (disableCollision) + { + disableCollisionEnable(); + } + else + { + disableCollisionDisable(); + } + } + ImGui.SameLine(); + if (ImGui.Checkbox("Disable Another Y Collision", ref disableExtraCollision)) + { + if (disableExtraCollision) + { + disableExtraCollisionEnable(); + } + else + { + disableExtraCollisionDisable(); + } + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("This will make your legs goofy, but is needed to get on top of some things."); + ImGui.EndTooltip(); + } + + if (ImGui.Checkbox("Disable Height Check", ref disableGravity)) + { + if (disableGravity) + { + if (!disableExtraGravity) + { + disableExtraGravityEnable(); + disableExtraGravity = true; + } + disableGravityEnable(); + } + else + { + disableGravityDisable(); + } + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Avoid falling when going too high."); + ImGui.EndTooltip(); + } + ImGui.SameLine(); + float widthDiff = ImGui.CalcTextSize("Disable Some Collision").X - ImGui.CalcTextSize("Disable Height Check").X; + ImGui.SetCursorPos(ImGui.GetCursorPos() + new Vector2(widthDiff, 0.0f)); + if (ImGui.Checkbox("Disable Gravity", ref disableExtraGravity)) + { + if (disableExtraGravity) + { + disableExtraGravityEnable(); + } + else + { + disableExtraGravityDisable(); + } + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Avoid falling when going out of bounds or rotating."); + ImGui.EndTooltip(); + } + + Zone.drawUI(player, getSaveSlotIndex() >= 0, width); + + Models.drawAnimationInfo(player, width, false); + + Armor.drawPoser(player, width); + + debug: + if (ImGui.CollapsingHeader("DEBUG")) + { + drawDebugMenu(player, playerSettings, width); + } + } + + private void drawDebugMenu(Player? player, NativeWrapper playerSettings, float width) + { + ImGui.PushID("Player"); + ImGui.Text("Player"); + ImGui.Text($"sPlayer: 0x{sPlayer.Instance:X}"); + if (player != null) + { + ImGui.Text($"Address: 0x{player.Instance:X}"); + ImGui.Text($"Settings: 0x{playerSettings.Instance:X}"); + + Models.drawAnimationInfo(player, width, true); + + ImGui.Separator(); + } + ImGui.PopID(); + + ImGui.PushID("Palico"); + ImGui.Text("Palico/Otomo"); + ImGui.Text($"sOtomo: 0x{sOtomo.Instance:X}"); + ImGui.PopID(); + + if (ImGui.CollapsingHeader("Monsters")) + { + Monster[] monsters = Monster.GetAllMonsters(); + ImGui.Text($"Count: {monsters.Length}"); + ImGui.Checkbox("Sort by distance from camera", ref sortMonsters); + Viewport vp = CameraSystem.GetViewport(0); + if (sortMonsters && vp.Camera != null) + { + Array.Sort(monsters, delegate(Monster x, Monster y) + { + float distX = Vector3.Distance(vp.Camera.Position, x.Position); + float distY = Vector3.Distance(vp.Camera.Position, y.Position); + if (distX < distY) return 1; + else if (distX > distY) return -1; + return 0; + }); + } + for (int i = monsters.Length - 1; i >= 0; i--) + { + Monster monster = monsters[i]; + ImGui.PushID(monster.Instance); + ImGui.Text($"{monster.Name}:"); + ImGui.Text($" Address: 0x{monster.Instance:X}"); + ImGui.DragFloat3("Position", ref monster.Position, 0.5f); + Vector4 rotation = new(monster.Rotation.X, monster.Rotation.Y, monster.Rotation.Z, monster.Rotation.W); + ImGui.SliderFloat4("Rotation", ref rotation, -1.0f, 1.0f); + if (Models.drawRotate("Rotate", rotation, out Vector4 result)) + { + monster.Rotation = new(result.X, result.Y, result.Z, result.W); + } + Models.drawAnimationInfo(monster, width, true); + ImGui.PopID(); + ImGui.Separator(); + } + } + + if (ImGui.CollapsingHeader("Animals")) + { + Animal[] animals = Animal.GetAllAnimals(); + ImGui.Text($"Count: {animals.Length}"); + ImGui.Checkbox("Sort by distance from camera", ref sortAnimals); + Viewport vp = CameraSystem.GetViewport(0); + if (sortAnimals && vp.Camera != null) + { + Array.Sort(animals, delegate(Animal x, Animal y) + { + float distX = Vector3.Distance(vp.Camera.Position, x.Position); + float distY = Vector3.Distance(vp.Camera.Position, y.Position); + if (distX < distY) return 1; + else if (distX > distY) return -1; + return 0; + }); + } + for (int i = animals.Length - 1; i >= 0; i--) + { + Animal animal = animals[i]; + ImGui.PushID(animal.Instance); + ImGui.Text($"{animal.Id:X} ({animal.OtherId:X}):"); + ImGui.Text($" Address: 0x{animal.Instance:X}"); + ImGui.DragFloat3("Position", ref animal.Position, 0.5f); + Vector4 rotation = new(animal.Rotation.X, animal.Rotation.Y, animal.Rotation.Z, animal.Rotation.W); + ImGui.SliderFloat4("Rotation", ref rotation, -1.0f, 1.0f); + if (Models.drawRotate("Rotate", rotation, out Vector4 result)) + { + animal.Rotation = new(result.X, result.Y, result.Z, result.W); + } + if (ImGui.Button("Remove")) + { + MemoryUtil.GetRef<uint>(animal.Instance + 0x928) = 0xFFFFFFFF; + } + ImGui.PopID(); + ImGui.Separator(); + } + } + + ImGui.Checkbox("Only Toggle LOD 0", ref Models.modelOnlyAddressLod0); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text($"This can be used to check if a given model is showing LOD 0 or not.\nApplies when a part is toggled, meaning you should probably toggle all parts on before enabling this."); + ImGui.EndTooltip(); + } + bool expand = ImGui.CollapsingHeader("Loaded Models"); + if (expand && player != null) + { + Models.drawModelList(width, player.Instance); + } + + expand = ImGui.CollapsingHeader("Objects"); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("This reads from the list of objects to be updated.\nTherefore, at any given moment it could be empty."); + ImGui.EndTooltip(); + } + if (expand && player != null) + { + Models.drawObjectList(width, player); + } + } + } +} diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..2f7d6da --- /dev/null +++ b/README.txt @@ -0,0 +1,3 @@ +== Player Poser + +// vim: set syntax=asciidoc: diff --git a/Utility.cs b/Utility.cs new file mode 100644 index 0000000..6ea08f1 --- /dev/null +++ b/Utility.cs @@ -0,0 +1,214 @@ +#define ENABLE_ASSERTS + +using System.Numerics; +using System.Text; +using System.Globalization; +#if ENABLE_ASSERTS +using System.Diagnostics; +using System.Runtime.CompilerServices; +#endif + +using SharpPluginLoader.Core; +using SharpPluginLoader.Core.MtTypes; +using SharpPluginLoader.Core.Memory; +using SharpPluginLoader.Core.Entities; + +namespace PlayerPoser +{ + using static Plugin; + + internal static unsafe class Utility + { + internal const float disableAlphaFactor = 0.6f; + + private static bool loggedAssertFailed = false; + internal static void Assert(bool condition, [CallerLineNumber] int line = 0) + { + if (!condition && !loggedAssertFailed) + { + Log.Error($"Assert failed on line {line}, further asserts won't be logged."); + loggedAssertFailed = true; + } +#if ENABLE_ASSERTS + Trace.Assert(condition); +#endif + } + + internal static byte ByteFlag(bool f) { return f ? (byte)0x1 : (byte)0x0; } + + internal static T Get<T>(nint addr, nint offset = 0x0) where T : unmanaged + { + return MemoryUtil.Read<T>(addr + offset); + } + + internal static T Get<T>(long addr, nint offset = 0x0) where T : unmanaged + { + return MemoryUtil.Read<T>((nint)addr + offset); + } + + internal static T *GetPtrInline<T>(nint addr, nint offset = 0x0) where T : unmanaged + { + return (T *)(addr + offset); + } + + internal static ref T GetRef<T>(nint addr, nint offset = 0x0) where T : unmanaged + { + return ref MemoryUtil.GetRef<T>(addr + offset); + } + + internal static int ColorVectorToInt(Vector4 v) + { + return ((int)MathF.Round(v.X * 255.0f) | + ((int)MathF.Round(v.Y * 255.0f) << 8) | + ((int)MathF.Round(v.Z * 255.0f) << 16) | + ((int)MathF.Round(v.W * 255.0f) << 24)); + } + + internal static byte[] StringToCStr(string s) + { + return Encoding.ASCII.GetBytes(s + '\0'); + } + + internal static float StringToSingle(string s) { return Convert.ToSingle(s, CultureInfo.InvariantCulture); } + + internal static Vector3 StringToVector3(string s, char delim = ',') + { + if (string.IsNullOrEmpty(s)) throw new FormatException(); + string[] sp = s.Split(delim).Select((v) => v.Trim()).ToArray(); + if (sp.Length != 3) throw new FormatException(); + return new Vector3(StringToSingle(sp[0]), StringToSingle(sp[1]), StringToSingle(sp[2])); + } + + internal static Vector4 StringToVector4(string s, char delim = ',') + { + if (string.IsNullOrEmpty(s)) throw new FormatException(); + string[] sp = s.Split(delim).Select((v) => v.Trim()).ToArray(); + if (sp.Length != 4) throw new FormatException(); + return new Vector4(StringToSingle(sp[0]), StringToSingle(sp[1]), StringToSingle(sp[2]), StringToSingle(sp[3])); + } + + internal static string Vector3ToString(Vector3 v) + { + return string.Format(CultureInfo.InvariantCulture, "{0},{1},{2}", v.X, v.Y, v.Z); + } + + internal static string Vector4ToString(Vector4 v) + { + return string.Format(CultureInfo.InvariantCulture, "{0},{1},{2},{3}", v.X, v.Y, v.Z, v.W); + } + + internal static void getDirectionVectors(MtQuaternion rotation, out Vector3 forward, out Vector3 right, out Vector3 up) + { + Quaternion qRotation = new(rotation.X, rotation.Y, rotation.Z, rotation.W); + forward = Vector3.Transform(new(0.0f, 0.0f, 1.0f), qRotation); + right = Vector3.Transform(new(1.0f, 0.0f, 0.0f), qRotation); + up = Vector3.Transform(new(0.0f, 1.0f, 0.0f), qRotation); + } + + private static Player? lastPlayer = null; + private static int lastSaveSlotIndex = -1; + + private delegate nint DestroyPlayerObject(nint playerObjectInternal, int unknownInt); + private static Hook<DestroyPlayerObject>? destroyPlayerObjectHook; + + private static NativeFunction<nint, nint> getSaveSlotGuiAddr; + private static NativeFunction<nint, nint> getPlayerSettingsAddr; + + private static NativeFunction<nint, int, nint> getPalicoFunc; + + internal static void OnUpdate() + { + (lastPlayer, lastSaveSlotIndex) = getPlayerWithSaveSlot(); + } + + internal static Player? getPlayer() + { + return lastPlayer; + } + + internal static int getSaveSlotIndex() + { + return lastSaveSlotIndex; + } + + internal static NativeWrapper getPlayerSettings() + { + Assert(lastPlayer != null); + if (lastSaveSlotIndex >= 0) + { + // MonsterHunterWorld.exe+ADC442 - imul rdx,rcx,0026CC00 + nint rax = lastSaveSlotIndex * 0x26CC00; + rax += sUserData.Get<nint>(0xA8); + return new(rax); + } + // MonsterHunterWorld.exe+1B8DBB0 - movsxd rax,dword ptr [rcx+000000A0] + return new(getPlayerSettingsAddr.Invoke(sUserData.Instance)); + } + + internal static NativeWrapper getPalico() + { + return new(getPalicoFunc.Invoke(sOtomo!.Instance, 0)); + } + + private static (Player?, int) getPlayerFromSaveSlot() + { + nint guiAddr = getSaveSlotGuiAddr.Invoke(sMhArea.Instance); + if (guiAddr != 0x0) + { + // MonsterHunterWorld.exe+ADC42F - movsxd rcx,dword ptr [rax+00000334] + int saveSlotIndex = Get<int>(guiAddr, 0x334); + if (saveSlotIndex != -1) + { + // MonsterHunterWorld.exe+1B42047 - add r8,00000740 + nint offset = (sPlayer!.Instance + 0x40) + (0x740 * saveSlotIndex); + if (offset != 0x0 && Get<nint>(offset) == 0x1433FE588) + { + nint playerAddr = Get<nint>(offset, 0x18); + if (playerAddr != 0x0) + { + return (new Player(playerAddr), saveSlotIndex); + } + } + } + } + return (null, -1); + } + + private static (Player?, int) getPlayerWithSaveSlot() + { + Player? player = Player.MainPlayer; + int saveSlotIndex = -1; + if (player == null) + { + (player, saveSlotIndex) = getPlayerFromSaveSlot(); + } + if (player != lastPlayer) + { + lastPlayer = player; + lastSaveSlotIndex = saveSlotIndex; + OnPlayerChange(); + } + return (player, saveSlotIndex); + } + + private static nint DestroyPlayerObjectHook(nint playerObjectInternal, int unknownInt) + { + if (playerObjectInternal == lastPlayer) + { + lastPlayer = null; + lastSaveSlotIndex = -1; + } + return destroyPlayerObjectHook!.Original(playerObjectInternal, unknownInt); + } + + internal static void Initialize() + { + destroyPlayerObjectHook = Hook.Create<DestroyPlayerObject>(0x142033500, DestroyPlayerObjectHook); + + getSaveSlotGuiAddr = new NativeFunction<nint, nint>(0x141AC0B60); + getPlayerSettingsAddr = new NativeFunction<nint, nint>(0x141B8DBB0); + + getPalicoFunc = new NativeFunction<nint, int, nint>(0x141B32E00); + } + } +} @@ -0,0 +1,343 @@ +#define QUARANTINED_FEATURES + +using System.Numerics; +using System.Runtime.InteropServices; + +using ImGuiNET; +using SharpPluginLoader.Core; +using SharpPluginLoader.Core.Memory; +using SharpPluginLoader.Core.Entities; + +namespace PlayerPoser +{ + using static Utility; + + internal static unsafe class Zone + { + internal enum ZoneState + { + Unknown = 0, + Hub = 1, + Combat = 2 + } + +#if QUARANTINED_FEATURES + private static ZoneState forceZoneState = ZoneState.Unknown; + private static ZoneState lastZoneState = ZoneState.Combat; // Save select default. + private static NativeAction<nint, int> setZoneStateFunc; + private static bool zoneStateManualInvoke = false; + + private static NativeAction<nint> setPlayerController1; + private static NativeAction<nint> setPlayerController5; + + private static bool forcePassiveInCombatZone = false; + private static Patch zoneStateForcePassive1; + private static Patch zoneStateForcePassive2; + + private static bool forceCombatInPassiveZone = false; + private static Patch zoneStateForceCombat1; + private static Patch zoneStateForceCombat2; +#endif + private delegate void ZoneStateDelegate(nint player, int flags); + private static Hook<ZoneStateDelegate>? setZoneState; + + private static bool enableCrawl = false; + private static nint psuedoObject1; + private static nint psuedoObject2; + private static NativeAction<nint, nint> procEnvironmentCollision; + private delegate void CollisionCheckDelegate(nint unknownPtr1, nint unknownPtr2); + private static Hook<CollisionCheckDelegate>? collisionCheck; + + private static bool allowHotSpringsAnywhere = false; + private static Patch jmpOverHotSpringsEval; + + private static bool disableHotSpringsSteam = false; + private static Patch jmpOverHotSpringsSteam; + + internal static void Initialize() + { +#if QUARANTINED_FEATURES + // MonsterHunterWorld.exe+20354F7 - call MonsterHunterWorld.exe+1F73850 + setZoneStateFunc = new NativeAction<nint, int>(0x142035020); + + setPlayerController1 = new NativeAction<nint>(0x141F73850); + setPlayerController5 = new NativeAction<nint>(0x14118DDC0); + + zoneStateForcePassive1 = new Patch(0x140256A3F + 0x6, [0x1]); + zoneStateForcePassive2 = new Patch(0x141AC2865 + 0x6, [0x1]); + + zoneStateForceCombat1 = new Patch(0x141AC2938 + 0x6, [0x0]); + zoneStateForceCombat2 = new Patch(0x141AC28EC + 0x6, [0x0]); +#endif + setZoneState = Hook.Create<ZoneStateDelegate>(0x142035020, SetZoneStateHook); + + psuedoObject1 = (nint)NativeMemory.AllocZeroed(0x7C); + GetRef<byte>(psuedoObject1, 0x30) = 0x03; + psuedoObject2 = (nint)NativeMemory.AllocZeroed(0x7C); + GetRef<byte>(psuedoObject2, 0x30) = 0x08; + procEnvironmentCollision = new NativeAction<nint, nint>(0x141F737D0); + collisionCheck = Hook.Create<CollisionCheckDelegate>(0x1411C4E50, CollisionCheckHook); + + // Player + ECCC = How far underwater is the player. + jmpOverHotSpringsEval = new Patch(0x1417C1B03, [0xEB]); + jmpOverHotSpringsSteam = new Patch(0x14203A494, [0xE9, 0x8D, 0x00, 0x00, 0x00, 0x90]); + } + + private static void SetZoneStateHook(nint player, int flags) + { +#if QUARANTINED_FEATURES + ref byte zoneState = ref GetRef<byte>(Get<nint>(0x1451C42B8), 0xD2EA); + if (zoneStateManualInvoke) + { + zoneStateManualInvoke = false; + } + else + { + lastZoneState = (zoneState == 0x1) ? ZoneState.Hub : ZoneState.Combat; + } + ZoneState overrideZoneState = (forceZoneState == ZoneState.Unknown) ? lastZoneState : forceZoneState; + if (overrideZoneState != ZoneState.Unknown) + { + zoneState = ByteFlag(overrideZoneState == ZoneState.Hub); + } +#endif + + setZoneState!.Original(player, flags); + + Plugin.OnZoneChange(player); + } + + private static void CollisionCheckHook(nint unknownPtr1, nint unknownPtr2) + { + Player? player = null; + if (enableCrawl && (player = getPlayer()) != null) + { + nint controlsAddr = player.Get<nint>(0x12608); + bool combatControls = controlsAddr != 0x0 && Get<byte>(controlsAddr, 0xB18) == 0x80; + if (combatControls) + { + procEnvironmentCollision.Invoke(player.Instance, psuedoObject1); + procEnvironmentCollision.Invoke(player.Instance, psuedoObject2); + } + else + { + enableCrawl = false; + } + } + + collisionCheck!.Original(unknownPtr1, unknownPtr2); + } + + private static Quaternion getRight(Quaternion q) + { + return q * Quaternion.CreateFromYawPitchRoll(MathF.PI, 0.0f, 0.0f); + } + + internal static void drawUI(Player player, bool saveSlotFallback, float width) + { + ZoneState zoneState = ZoneState.Unknown; + nint zoneStateAddr = Get<nint>(0x1451C42B8); + if (zoneStateAddr == 0x0) + { + return; + } + bool expand = ImGui.CollapsingHeader("Zone State"); + ImGui.SameLine(); + ImGui.Text($"(Current: {((GetRef<byte>(zoneStateAddr, 0xD2EA) == 0x1) ? "Hub" : "Combat")})"); + if (expand) + { + ref byte passiveFlag1 = ref player.GetRef<byte>(0x7626); + ref byte passiveFlag2 = ref GetRef<byte>(player.Get<nint>(0x7D20), 0x9B8); + bool passive = passiveFlag1 == 0x1 && passiveFlag2 == 0x1; + if (saveSlotFallback) + { + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + } + if (ImGui.Checkbox("Passive", ref passive)) + { + passiveFlag1 = ByteFlag(passive); + passiveFlag2 = ByteFlag(passive); + } + if (saveSlotFallback) + { + ImGui.PopStyleVar(); + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Passive: Calm camera and your hunter looks neutral/smiles.\nCombat: Intense camera and your hunter looks angry.\nIf you have Passive set and Combat Controls on, or vice versa, expect glitchy behavior."); + ImGui.EndTooltip(); + } + nint controlsAddr = player.Get<nint>(0x12608); + if (controlsAddr == 0x0) return; + bool combatControls = Get<byte>(controlsAddr, 0xB18) == 0x80; + zoneState = combatControls ? ZoneState.Combat : ZoneState.Hub; +#if QUARANTINED_FEATURES + if (ImGui.Checkbox("Combat Controls", ref combatControls)) + { + passiveFlag1 = ByteFlag(!combatControls); + passiveFlag2 = ByteFlag(!combatControls); + setPlayerController1.Invoke(player.Instance); + setPlayerController5.Invoke(controlsAddr); + } + int zoneStateInt = (int)forceZoneState; + ImGui.AlignTextToFramePadding(); + ImGui.Text($"Force:"); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("This will apply when moving to a different area."); + ImGui.EndTooltip(); + } + ImGui.SameLine(); + ImGui.RadioButton("Off", ref zoneStateInt, 0); + ImGui.SameLine(); + ImGui.RadioButton("Hub", ref zoneStateInt, 1); + ImGui.SameLine(); + ImGui.RadioButton("Combat", ref zoneStateInt, 2); + forceZoneState = (ZoneState)zoneStateInt; + if (ImGui.Button("Run Change Zone State")) + { + zoneStateManualInvoke = true; + setZoneStateFunc.Invoke(player.Instance, 0x000106C0); // or 0x00010780. + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("You can use this to apply the value of Force Zone State.\nIf you're out in a map and Force Zone State is set to Off or Combat, this will send you back to camp."); + ImGui.EndTooltip(); + } + if (ImGui.Checkbox("Force Passive in Combat Zones", ref forcePassiveInCombatZone)) + { + if (forcePassiveInCombatZone) + { + zoneStateForcePassive1.Enable(); + zoneStateForcePassive2.Enable(); + } + else + { + zoneStateForcePassive1.Disable(); + zoneStateForcePassive2.Disable(); + } + } + if (ImGui.Checkbox("Force Combat in Passive Zones", ref forceCombatInPassiveZone)) + { + if (forceCombatInPassiveZone) + { + zoneStateForceCombat1.Enable(); + zoneStateForceCombat2.Enable(); + } + else + { + zoneStateForceCombat1.Disable(); + zoneStateForceCombat2.Disable(); + } + } +#endif + if (zoneState != ZoneState.Combat) + { + ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + } + if (ImGui.Checkbox("Force Crawl", ref enableCrawl)) + { + if (enableCrawl) + { + GetRef<float>(psuedoObject2, 0x70) = player.Position.X + player.Forward.X; + GetRef<float>(psuedoObject2, 0x74) = player.Position.Y + player.Forward.Y; + GetRef<float>(psuedoObject2, 0x78) = player.Position.Z + player.Forward.Z; + + Quaternion playerRotation = new(player.Forward.X, player.Forward.Y, player.Forward.Z, 0.0f); + Quaternion objectRotation = getRight(playerRotation); + + GetRef<float>(psuedoObject2, 0x40) = objectRotation.X; + GetRef<float>(psuedoObject2, 0x44) = objectRotation.Y; + GetRef<float>(psuedoObject2, 0x48) = objectRotation.Z; + GetRef<float>(psuedoObject2, 0x4C) = objectRotation.W; + + GetRef<float>(psuedoObject2, 0x50) = 0.0f; + GetRef<float>(psuedoObject2, 0x54) = 1.0f; + GetRef<float>(psuedoObject2, 0x58) = 0.0f; + GetRef<float>(psuedoObject2, 0x5C) = 0.0f; + + GetRef<float>(psuedoObject2, 0x60) = playerRotation.X; + GetRef<float>(psuedoObject2, 0x64) = playerRotation.Y; + GetRef<float>(psuedoObject2, 0x68) = playerRotation.Z; + GetRef<float>(psuedoObject2, 0x6C) = playerRotation.W; + } + } + if (zoneState != ZoneState.Combat) + { + ImGui.PopStyleVar(); + ImGui.PopItemFlag(); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("You have to be out in a map to use this."); + ImGui.EndTooltip(); + } + } + else + { + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Simulate crawling under an object in the direction your character was facing when enabled."); + ImGui.EndTooltip(); + } + } + + if (zoneState != ZoneState.Hub) + { + ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true); + ImGui.PushStyleVar(ImGuiStyleVar.Alpha, ImGui.GetStyle().Alpha * disableAlphaFactor); + } + if (ImGui.Button("Sit in Hot Springs")) + { + // Run sit in hot springs action (top of function). + // MonsterHunterWorld.exe+17601F0 - mov [rsp+08],rbx + Models.runAction(player.ActionController, 0x1, 0x65); + } + if (zoneState != ZoneState.Hub) + { + ImGui.PopStyleVar(); + ImGui.PopItemFlag(); + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("You have to be in a hub area to use this."); + ImGui.EndTooltip(); + } + } + + if (ImGui.Checkbox("Allow Hot Springs Anywhere", ref allowHotSpringsAnywhere)) + { + if (allowHotSpringsAnywhere) + { + jmpOverHotSpringsEval.Enable(); + } + else + { + jmpOverHotSpringsEval.Disable(); + } + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("Disable check for being about halfway submerged in water to stay sitting."); + ImGui.EndTooltip(); + } + + if (ImGui.Checkbox("Disable Hot Springs Steam", ref disableHotSpringsSteam)) + { + if (disableHotSpringsSteam) + { + jmpOverHotSpringsSteam.Enable(); + } + else + { + jmpOverHotSpringsSteam.Disable(); + } + } + if (ImGui.BeginItemTooltip()) + { + ImGui.Text("It will take a couple of seconds to fade away."); + ImGui.EndTooltip(); + } + } + } + } +} |