diff --git a/IKFixes/HarmonyPatches.cs b/IKFixes/HarmonyPatches.cs index 7c47151..0fdec4d 100644 --- a/IKFixes/HarmonyPatches.cs +++ b/IKFixes/HarmonyPatches.cs @@ -127,28 +127,31 @@ internal static class BodySystemPatches SetPelvisWeight(solver.spine, 0f); } - float maxRootAngle = BodySystem.isCalibratedAsFullBody || IKFixes.EntryUseFakeRootAngle.Value ? (PlayerSetup.Instance._emotePlaying ? 180f : 0f) : (PlayerSetup.Instance._emotePlaying ? 180f : 25f); - solver.spine.maxRootAngle = maxRootAngle; + float maxRootAngle = 25f; + float rootHeadingOffset = 0f; - if (IKFixes.EntryUseFakeRootAngle.Value) + if (BodySystem.isCalibratedAsFullBody || IKFixes.EntryUseFakeRootAngle.Value) + maxRootAngle = 0f; + + if (PlayerSetup.Instance._emotePlaying) + maxRootAngle = 180f; + + if (IKFixes.EntryUseFakeRootAngle.Value && !BodySystem.isCalibratedAsFullBody) { - // Emulate maxRootAngle because CVR doesn't have the player controller set up ideally for VRIK. - // I believe they'd need to change which object vrik.references.root is, as using avatar object is bad! - // This is a small small fix, but makes it so the feet dont point in the direction of the head - // when turning. It also means turning with joystick & turning IRL make feet behave the same and follow behind. float weightedAngleLimit = IKFixes.EntryFakeRootAngleLimit.Value * solver.locomotion.weight; float pivotAngle = MovementSystem.Instance.rotationPivot.eulerAngles.y; float deltaAngleRoot = Mathf.DeltaAngle(pivotAngle, _ikSimulatedRootAngle); float absDeltaAngleRoot = Mathf.Abs(deltaAngleRoot); - if (absDeltaAngleRoot > weightedAngleLimit) - { - deltaAngleRoot = Mathf.Sign(deltaAngleRoot) * weightedAngleLimit; - _ikSimulatedRootAngle = Mathf.MoveTowardsAngle(_ikSimulatedRootAngle, pivotAngle, absDeltaAngleRoot - weightedAngleLimit); - } - solver.spine.rootHeadingOffset = deltaAngleRoot; + deltaAngleRoot = Mathf.Clamp(deltaAngleRoot, -weightedAngleLimit, weightedAngleLimit); + _ikSimulatedRootAngle = Mathf.MoveTowardsAngle(_ikSimulatedRootAngle, pivotAngle, absDeltaAngleRoot - weightedAngleLimit); + + rootHeadingOffset = deltaAngleRoot; } + solver.spine.maxRootAngle = maxRootAngle; + solver.spine.rootHeadingOffset = rootHeadingOffset; + // custom IK settings solver.spine.neckStiffness = IKFixes.EntryNeckStiffness.Value; solver.spine.bodyRotStiffness = IKFixes.EntryBodyRotStiffness.Value; @@ -194,25 +197,24 @@ internal static class BodySystemPatches if (BodySystem.isCalibrating) { IKSystem.Instance.humanPose.bodyRotation = Quaternion.identity; - IKSystem.vrik.solver.spine.maxRootAngle = 0f; // idk, testing + //IKSystem.vrik.solver.spine.maxRootAngle = 0f; // idk, testing } - // makes running animation look better - if (BodySystem.isCalibratedAsFullBody && BodySystem.PlayRunningAnimationInFullBody && BodySystem.TrackingPositionWeight > 0f) + if (BodySystem.isCalibratedAsFullBody && BodySystem.TrackingPositionWeight > 0f) { bool isRunning = MovementSystem.Instance.movementVector.magnitude > 0f; bool isGrounded = MovementSystem.Instance._isGrounded; bool isFlying = MovementSystem.Instance.flying; - if (isRunning || !isGrounded && !isFlying) + bool playRunningAnimation = BodySystem.PlayRunningAnimationInFullBody; + + if ((playRunningAnimation && (isRunning || !isGrounded && !isFlying))) { SetPelvisWeight(IKSystem.vrik.solver.spine, 0f); - // This looks much better when running IKSystem.Instance.applyOriginalHipPosition = true; IKSystem.Instance.applyOriginalHipRotation = true; } else { - // Resetting bodyRotation made running animations look funky IKSystem.Instance.applyOriginalHipPosition = true; IKSystem.Instance.applyOriginalHipRotation = false; IKSystem.Instance.humanPose.bodyRotation = Quaternion.identity; diff --git a/IKFixes/Properties/AssemblyInfo.cs b/IKFixes/Properties/AssemblyInfo.cs index 3170704..28e1c9c 100644 --- a/IKFixes/Properties/AssemblyInfo.cs +++ b/IKFixes/Properties/AssemblyInfo.cs @@ -25,6 +25,6 @@ using System.Reflection; namespace NAK.IKFixes.Properties; internal static class AssemblyInfoParams { - public const string Version = "1.0.4"; + public const string Version = "1.0.5"; public const string Author = "NotAKidoS"; } \ No newline at end of file diff --git a/InteractionTest/ColliderTest/AvatarColliderStruct.cs b/InteractionTest/ColliderTest/AvatarColliderStruct.cs new file mode 100644 index 0000000..86a43cb --- /dev/null +++ b/InteractionTest/ColliderTest/AvatarColliderStruct.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using UnityEngine; + +public struct AvatarTransforms +{ + public Transform root; + public Transform hips; + public Transform spine; + public Transform chest; + public Transform neck; + public Transform head; + public Transform leftShoulder; + public Transform leftUpperArm; + public Transform leftLowerArm; + public Transform leftHand; + public Transform rightShoulder; + public Transform rightUpperArm; + public Transform rightLowerArm; + public Transform rightHand; + public Transform leftUpperLeg; + public Transform leftLowerLeg; + public Transform leftFoot; + public Transform rightUpperLeg; + public Transform rightLowerLeg; + public Transform rightFoot; + + public AvatarTransforms GetAvatarTransforms(Animator animator) + { + AvatarTransforms result = new AvatarTransforms() + { + root = animator.transform, + hips = animator.GetBoneTransform(HumanBodyBones.Hips), + spine = animator.GetBoneTransform(HumanBodyBones.Spine), + chest = animator.GetBoneTransform(HumanBodyBones.Chest), + neck = animator.GetBoneTransform(HumanBodyBones.Neck), + head = animator.GetBoneTransform(HumanBodyBones.Head), + leftShoulder = animator.GetBoneTransform(HumanBodyBones.LeftShoulder), + leftUpperArm = animator.GetBoneTransform(HumanBodyBones.LeftUpperArm), + leftLowerArm = animator.GetBoneTransform(HumanBodyBones.LeftLowerArm), + leftHand = animator.GetBoneTransform(HumanBodyBones.LeftHand), + rightShoulder = animator.GetBoneTransform(HumanBodyBones.RightShoulder), + rightUpperArm = animator.GetBoneTransform(HumanBodyBones.RightUpperArm), + rightLowerArm = animator.GetBoneTransform(HumanBodyBones.RightLowerArm), + rightHand = animator.GetBoneTransform(HumanBodyBones.RightHand), + leftUpperLeg = animator.GetBoneTransform(HumanBodyBones.LeftUpperLeg), + leftLowerLeg = animator.GetBoneTransform(HumanBodyBones.LeftLowerLeg), + leftFoot = animator.GetBoneTransform(HumanBodyBones.LeftFoot), + rightUpperLeg = animator.GetBoneTransform(HumanBodyBones.RightUpperLeg), + rightLowerLeg = animator.GetBoneTransform(HumanBodyBones.RightLowerLeg), + rightFoot = animator.GetBoneTransform(HumanBodyBones.RightFoot), + }; + + return result; + } +} \ No newline at end of file diff --git a/InteractionTest/ColliderTest/AvatarColliders.cs b/InteractionTest/ColliderTest/AvatarColliders.cs new file mode 100644 index 0000000..ccbbd42 --- /dev/null +++ b/InteractionTest/ColliderTest/AvatarColliders.cs @@ -0,0 +1,175 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +public class AvatarColliders : MonoBehaviour +{ + public Animator animator; + public AvatarTransforms m_avatarTransforms; + + void Start() + { + if (animator == null) + animator = GetComponent(); + + m_avatarTransforms = m_avatarTransforms.GetAvatarTransforms(animator); + + CreateColliderTorso(); + CreateColliderLeftArm(); + CreateColliderRightArm(); + } + + void CreateColliderLeftArm() + { + // Calculate the magnitudes for the upper arm, lower arm, and hand. + // This would need to be adjusted based on the specific avatar model being used. + float upperArmMagnitude = CalculateMagnitude(m_avatarTransforms.leftUpperArm.position, m_avatarTransforms.leftLowerArm.position); + //float lowerArmMagnitude = CalculateMagnitude(m_avatarTransforms.leftLowerArm.position, m_avatarTransforms.leftHand.position); + + float handMagnitude = upperArmMagnitude * 0.25f; // Assuming hand is about half the size of the upper arm. + + // Create a collider for the upper arm area + Vector3 upperArmPosition = m_avatarTransforms.leftUpperArm.position; + Vector3 lowerArmPosition = m_avatarTransforms.leftLowerArm.position; + CreateCollider(m_avatarTransforms.leftUpperArm, upperArmPosition, lowerArmPosition, handMagnitude, 0.15f); + + // Create a collider for the lower arm area + Vector3 handPosition = m_avatarTransforms.leftHand.position; + CreateCollider(m_avatarTransforms.leftLowerArm, lowerArmPosition, handPosition, handMagnitude, 0.15f); + + // Create a collider for the hand area + // For simplicity, let's assume the end position is slightly offset from the hand position. + Vector3 handEndPosition = handPosition + (handPosition - lowerArmPosition) * 0.5f; + CreateCollider(m_avatarTransforms.leftHand, handPosition, handEndPosition, handMagnitude, 0.15f); + } + + void CreateColliderRightArm() + { + // Calculate the magnitudes for the upper arm, lower arm, and hand. + // This would need to be adjusted based on the specific avatar model being used. + float upperArmMagnitude = CalculateMagnitude(m_avatarTransforms.rightUpperArm.position, m_avatarTransforms.rightLowerArm.position); + //float lowerArmMagnitude = CalculateMagnitude(m_avatarTransforms.rightLowerArm.position, m_avatarTransforms.rightHand.position); + + float handMagnitude = upperArmMagnitude * 0.25f; // Assuming hand is about half the size of the upper arm. + + // Create a collider for the upper arm area + Vector3 upperArmPosition = m_avatarTransforms.rightUpperArm.position; + Vector3 lowerArmPosition = m_avatarTransforms.rightLowerArm.position; + CreateCollider(m_avatarTransforms.rightUpperArm, upperArmPosition, lowerArmPosition, handMagnitude, 0.15f); + + // Create a collider for the lower arm area + Vector3 handPosition = m_avatarTransforms.rightHand.position; + CreateCollider(m_avatarTransforms.rightLowerArm, lowerArmPosition, handPosition, handMagnitude, 0.15f); + + // Create a collider for the hand area + // For simplicity, let's assume the end position is slightly offset from the hand position. + Vector3 handEndPosition = handPosition + (handPosition - lowerArmPosition) * 0.5f; + CreateCollider(m_avatarTransforms.rightHand, handPosition, handEndPosition, handMagnitude, 0.15f); + } + + void CreateColliderTorso() + { + float legMagnitude = CalculateMagnitude(m_avatarTransforms.rightUpperLeg.position, m_avatarTransforms.leftUpperLeg.position); + + //gets between upperarm and shoulder distances + float armMagnitude = CalculateMagnitude(m_avatarTransforms.rightUpperArm.position, m_avatarTransforms.leftShoulder.position); + + Vector3 hipsPosition = GetHipsPosition(); + + // Create a collider for the hips area + Vector3 spinePosition = m_avatarTransforms.spine.position; + CreateCollider(m_avatarTransforms.hips, hipsPosition, spinePosition, legMagnitude, 0.15f); + + // Create a collider for the chest area + Vector3 chestPosition = m_avatarTransforms.chest.position; + CreateCollider(m_avatarTransforms.spine, spinePosition, chestPosition, (legMagnitude + armMagnitude) / 2, 0.15f); + + // Create a collider for the neck area + Vector3 neckPosition = m_avatarTransforms.neck.position; + CreateCollider(m_avatarTransforms.chest, chestPosition, neckPosition, armMagnitude, 0.15f); + } + + static float CalculateMagnitude(Vector3 position1, Vector3 position2) + { + return (position1 - position2).magnitude; + } + + Vector3 GetHipsPosition() + { + Vector3 hipsPosition = m_avatarTransforms.hips.position; + + if (Vector3.Distance(hipsPosition, m_avatarTransforms.root.position) < Vector3.Distance(m_avatarTransforms.head.position, m_avatarTransforms.root.position) * 0.25f) + { + hipsPosition = Vector3.Lerp(m_avatarTransforms.leftUpperLeg.position, m_avatarTransforms.rightUpperLeg.position, 0.5f); + } + + return hipsPosition; + } + + static void CreateCollider(Transform root, Vector3 start, Vector3 end, float width, float overlap) + { + Vector3 direction = end - start; + float length = direction.magnitude * (1f + overlap); + Vector3 axisVectorToDirection = GetAxisVectorToDirection(root.rotation, direction); + + Vector3 lossyScale = root.lossyScale; + float scaleF = (lossyScale.x + lossyScale.y + lossyScale.z) / 3f; + + CapsuleCollider capsuleCollider = root.gameObject.AddComponent(); + capsuleCollider.height = Mathf.Abs(length / scaleF); + capsuleCollider.radius = Mathf.Abs(width / scaleF); + capsuleCollider.direction = DirectionVector3ToInt(axisVectorToDirection); + capsuleCollider.center = root.InverseTransformPoint(Vector3.Lerp(start, end, 0.5f)); + capsuleCollider.isTrigger = true; + } + + public static Vector3 GetAxisVectorToDirection(Quaternion rotation, Vector3 direction) + { + direction = direction.normalized; + Vector3 result = Vector3.right; + + Vector3 right = rotation * Vector3.right; + Vector3 up = rotation * Vector3.up; + Vector3 forward = rotation * Vector3.forward; + + float dotRight = Mathf.Abs(Vector3.Dot(Vector3.Normalize(right), direction)); + float dotUp = Mathf.Abs(Vector3.Dot(Vector3.Normalize(up), direction)); + float dotForward = Mathf.Abs(Vector3.Dot(Vector3.Normalize(forward), direction)); + + if (dotUp > dotRight) + { + result = Vector3.up; + } + + if (dotForward > dotRight && dotForward > dotUp) + { + result = Vector3.forward; + } + + return result; + } + + public static int DirectionVector3ToInt(Vector3 dir) + { + float dotRight = Vector3.Dot(dir, Vector3.right); + float dotUp = Vector3.Dot(dir, Vector3.up); + float dotForward = Vector3.Dot(dir, Vector3.forward); + + float absDotRight = Mathf.Abs(dotRight); + float absDotUp = Mathf.Abs(dotUp); + float absDotForward = Mathf.Abs(dotForward); + + int result = 0; + + if (absDotUp > absDotRight && absDotUp > absDotForward) + { + result = 1; + } + else if (absDotForward > absDotRight && absDotForward > absDotUp) + { + result = 2; + } + + return result; + } +} diff --git a/InteractionTest/ColliderTest/LineColliderTest.cs b/InteractionTest/ColliderTest/LineColliderTest.cs new file mode 100644 index 0000000..1c2f8ed --- /dev/null +++ b/InteractionTest/ColliderTest/LineColliderTest.cs @@ -0,0 +1,30 @@ +using UnityEngine; + +public static class SphereBetweenLinesHelper +{ + public static bool IsSphereBetweenLines(Vector3 lineStart, Vector3 lineEnd, Vector3 sphereCenter, float sphereRadius) + { + // Calculate the closest point on the line to the sphere's center + Vector3 closestPointOnLine = GetClosestPointOnLine(lineStart, lineEnd, sphereCenter); + + // Calculate the distance between the sphere's center and the closest point on the line + float distanceToLine = Vector3.Distance(sphereCenter, closestPointOnLine); + + // Check if the sphere is between the lines + return distanceToLine < sphereRadius; + } + + // Get the closest point on a line to a given point + private static Vector3 GetClosestPointOnLine(Vector3 lineStart, Vector3 lineEnd, Vector3 point) + { + Vector3 lineDirection = (lineEnd - lineStart).normalized; + float closestPointDistance = Vector3.Dot((point - lineStart), lineDirection); + return lineStart + (closestPointDistance * lineDirection); + } + + public static bool IsPointWithinDistance(Vector3 position, Vector3 point, float distance) + { + float distanceToPosition = Vector3.Distance(position, point); + return distanceToPosition <= distance; + } +} diff --git a/InteractionTest/HarmonyPatches.cs b/InteractionTest/HarmonyPatches.cs index 56480a8..fd7d8c0 100644 --- a/InteractionTest/HarmonyPatches.cs +++ b/InteractionTest/HarmonyPatches.cs @@ -9,7 +9,7 @@ class PuppetMasterPatches [HarmonyPatch(typeof(PuppetMaster), nameof(PuppetMaster.AvatarInstantiated))] static void Postfix_PuppetMaster_SetupAvatar(ref PuppetMaster __instance) { - __instance.avatarObject.AddComponent(); + __instance.avatarObject.AddComponent(); } } @@ -19,6 +19,6 @@ class PlayerSetupPatches [HarmonyPatch(typeof(PlayerSetup), nameof(PlayerSetup.SetupAvatar))] static void Postfix_PlayerSetup_SetupAvatar(ref PlayerSetup __instance) { - + __instance._avatar.AddComponent(); } } \ No newline at end of file diff --git a/NAK_CVR_Mods.sln b/NAK_CVR_Mods.sln index 5f0a3e6..bf256f5 100644 --- a/NAK_CVR_Mods.sln +++ b/NAK_CVR_Mods.sln @@ -57,6 +57,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IKAdjustments", "IKAdjustme EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SmoothRay", "SmoothRay\SmoothRay.csproj", "{1BBC97C5-CC9F-4DA2-B166-F507F825DFAA}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TrackedPointFix", "TrackedPointFix\TrackedPointFix.csproj", "{0A6788A8-89E9-4FC4-B4FE-27FE8B39926C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -171,6 +173,10 @@ Global {1BBC97C5-CC9F-4DA2-B166-F507F825DFAA}.Debug|Any CPU.Build.0 = Debug|Any CPU {1BBC97C5-CC9F-4DA2-B166-F507F825DFAA}.Release|Any CPU.ActiveCfg = Release|Any CPU {1BBC97C5-CC9F-4DA2-B166-F507F825DFAA}.Release|Any CPU.Build.0 = Release|Any CPU + {0A6788A8-89E9-4FC4-B4FE-27FE8B39926C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0A6788A8-89E9-4FC4-B4FE-27FE8B39926C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0A6788A8-89E9-4FC4-B4FE-27FE8B39926C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0A6788A8-89E9-4FC4-B4FE-27FE8B39926C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/SmoothRay/Main.cs b/SmoothRay/Main.cs index 1166bb0..0637bb5 100644 --- a/SmoothRay/Main.cs +++ b/SmoothRay/Main.cs @@ -4,6 +4,7 @@ namespace NAK.SmoothRay; // ChilloutVR adaptation of: // https://github.com/kinsi55/BeatSaber_SmoothedController +// https://github.com/kinsi55/BeatSaber_SmoothedController/blob/master/LICENSE public class SmoothRay : MelonMod { @@ -35,7 +36,7 @@ public class SmoothRay : MelonMod ApplyPatches(typeof(HarmonyPatches.PlayerSetupPatches)); } - private void ApplyPatches(Type type) + void ApplyPatches(Type type) { try { diff --git a/SmoothRay/README.md b/SmoothRay/README.md index 99dd8df..7c670d3 100644 --- a/SmoothRay/README.md +++ b/SmoothRay/README.md @@ -1,11 +1,6 @@ -# SmoothRay (Depricated) -lazy af fix for a small issue +# SmoothRay -Your Left/Right hand controllers will now track faster and while in the Steam overlay. - -This approach to fixing the issue is made lazy to support DesktopVRSwitch. - -(also because im lazy) +Smoothes your controller while using the Quick and Main menus to make it easier to navigate. --- diff --git a/SmoothRay/SmoothRay.cs b/SmoothRay/SmoothRay.cs index f0273b6..4bc610f 100644 --- a/SmoothRay/SmoothRay.cs +++ b/SmoothRay/SmoothRay.cs @@ -1,4 +1,28 @@ -using ABI_RC.Core.InteractionSystem; +/** + MIT License + + Copyright (c) 2021 Kinsi, NotAKidOnSteam + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. +**/ + +using ABI_RC.Core.InteractionSystem; using UnityEngine; using UnityEngine.Events; using Valve.VR; @@ -7,7 +31,7 @@ namespace NAK.SmoothRay; public class SmoothRayer : MonoBehaviour { - internal ControllerRay ray; + public ControllerRay ray; //settings bool isEnabled; @@ -58,16 +82,14 @@ public class SmoothRayer : MonoBehaviour if (pose != null) pose.onTransformUpdatedEvent += OnTransformUpdated; if (tracked != null && newPosesAction != null) - { newPosesAction.enabled = true; - } } void OnDisable() { smoothedPosition = transform.localPosition; smoothedRotation = transform.localRotation; - + // desktopvrswitch support, normal use wont run this if (pose != null) pose.onTransformUpdatedEvent -= OnTransformUpdated; diff --git a/SmoothRay/format.json b/SmoothRay/format.json index 4178936..484a215 100644 --- a/SmoothRay/format.json +++ b/SmoothRay/format.json @@ -6,10 +6,10 @@ "loaderversion": "0.5.7", "modtype": "Mod", "author": "NotAKidoS", - "description": "Allows your controllers to track while the SteamVR overlay is open. This also fixes Quest/Touch controllers feeling slow during fast movements.", + "description": "Smoothes your controller while using the Quick and Main menus to make it easier to navigate.", "searchtags": [ "vr", - "quest", + "ray", "controller", "tracking" ], @@ -19,5 +19,5 @@ "downloadlink": "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/releases/download/r3/SmoothRay.dll", "sourcelink": "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/tree/main/SmoothRay/", "changelog": "Initial Release", - "embedcolor": "3498db" + "embedcolor": "dc8105" } \ No newline at end of file diff --git a/TrackedControllerFix/HarmonyPatches.cs b/TrackedControllerFix/HarmonyPatches.cs index f312b0f..3af71d1 100644 --- a/TrackedControllerFix/HarmonyPatches.cs +++ b/TrackedControllerFix/HarmonyPatches.cs @@ -10,12 +10,11 @@ class PlayerSetupPatches [HarmonyPatch(typeof(PlayerSetup), nameof(PlayerSetup.Start))] static void Post_PlayerSetup_Start(ref PlayerSetup __instance) { - // Add TrackedControllerFix - var vrLeftHandTracker = __instance.vrLeftHandTracker.AddComponent(); - vrLeftHandTracker.inputSource = SteamVR_Input_Sources.LeftHand; - var vrRightHandTracker = __instance.vrRightHandTracker.AddComponent(); - vrRightHandTracker.inputSource = SteamVR_Input_Sources.RightHand; - vrLeftHandTracker.Initialize(); - vrRightHandTracker.Initialize(); + var leftFixer = __instance.vrLeftHandTracker.AddComponent(); + leftFixer.inputSource = SteamVR_Input_Sources.LeftHand; + leftFixer.Initialize(); + var rightFixer = __instance.vrRightHandTracker.AddComponent(); + rightFixer.inputSource = SteamVR_Input_Sources.RightHand; + rightFixer.Initialize(); } } \ No newline at end of file diff --git a/TrackedControllerFix/Main.cs b/TrackedControllerFix/Main.cs index ec78d2d..1990d6f 100644 --- a/TrackedControllerFix/Main.cs +++ b/TrackedControllerFix/Main.cs @@ -9,7 +9,7 @@ public class TrackedControllerFix : MelonMod ApplyPatches(typeof(HarmonyPatches.PlayerSetupPatches)); } - private void ApplyPatches(Type type) + void ApplyPatches(Type type) { try { diff --git a/TrackedControllerFix/Properties/AssemblyInfo.cs b/TrackedControllerFix/Properties/AssemblyInfo.cs index 45b81ed..692e8d4 100644 --- a/TrackedControllerFix/Properties/AssemblyInfo.cs +++ b/TrackedControllerFix/Properties/AssemblyInfo.cs @@ -25,6 +25,6 @@ using System.Reflection; namespace NAK.TrackedControllerFix.Properties; internal static class AssemblyInfoParams { - public const string Version = "1.0.2"; + public const string Version = "1.0.3"; public const string Author = "NotAKidoS"; } \ No newline at end of file diff --git a/TrackedControllerFix/TrackedControllerFix.cs b/TrackedControllerFix/TrackedControllerFix.cs index 30cf2f4..ec0fcbb 100644 --- a/TrackedControllerFix/TrackedControllerFix.cs +++ b/TrackedControllerFix/TrackedControllerFix.cs @@ -6,11 +6,13 @@ namespace NAK.TrackedControllerFix; public class TrackedControllerFixer : MonoBehaviour { public SteamVR_Input_Sources inputSource; - public int deviceIndex; + public int deviceIndex = -1; SteamVR_TrackedObject trackedObject; SteamVR_Behaviour_Pose oldBehaviourPose; SteamVR_Action_Pose actionPose; + + SteamVR_RenderModel renderModel; public void Initialize() { @@ -19,6 +21,8 @@ public class TrackedControllerFixer : MonoBehaviour oldBehaviourPose.broadcastDeviceChanges = false; //this fucks us oldBehaviourPose.enabled = false; + renderModel = gameObject.GetComponentInChildren(); + actionPose = SteamVR_Input.GetAction("Pose", false); if (actionPose != null) CheckDeviceIndex(); } @@ -39,6 +43,14 @@ public class TrackedControllerFixer : MonoBehaviour oldBehaviourPose.enabled = true; } + void Update() + { + if (deviceIndex < 0) + { + CheckDeviceIndex(); + } + } + void OnDeviceConnectedChanged(SteamVR_Action_Pose changedAction, SteamVR_Input_Sources changedSource, bool connected) { if (actionPose != changedAction) actionPose = changedAction; @@ -54,7 +66,8 @@ public class TrackedControllerFixer : MonoBehaviour if (deviceIndex != trackedDeviceIndex) { deviceIndex = trackedDeviceIndex; - trackedObject.SetDeviceIndex(deviceIndex); + trackedObject?.SetDeviceIndex(deviceIndex); + renderModel?.SetDeviceIndex(deviceIndex); } } } diff --git a/TrackedPointFix/HarmonyPatches.cs b/TrackedPointFix/HarmonyPatches.cs new file mode 100644 index 0000000..08bad84 --- /dev/null +++ b/TrackedPointFix/HarmonyPatches.cs @@ -0,0 +1,47 @@ +using ABI_RC.Systems.IK; +using HarmonyLib; +using UnityEngine; +using Valve.VR; + +namespace NAK.TrackedPointFix.HarmonyPatches; + +class IKSystemPatches +{ + [HarmonyPostfix] + [HarmonyPatch(typeof(TrackingPoint), nameof(TrackingPoint.SetVisibility))] + static void Postfix_TrackingPoint_SetVisibility(ref TrackingPoint __instance) + { + GameObject systemTracker = __instance.referenceTransform.Find("DisplayTracker").gameObject; + if (systemTracker != null) + { + systemTracker.SetActive(__instance.displayObject.activeSelf); + __instance.displayObject.SetActive(false); + } + } + + [HarmonyPostfix] + [HarmonyPatch(typeof(TrackingPoint), nameof(TrackingPoint.Initialize))] + static void Postfix_TrackingPoint_Initialize(ref TrackingPoint __instance) + { + GameObject systemTracker = new GameObject(); + systemTracker.name = "DisplayTracker"; + systemTracker.transform.parent = __instance.referenceTransform; + systemTracker.transform.localPosition = Vector3.zero; + systemTracker.transform.localRotation = Quaternion.identity; + systemTracker.transform.localScale = Vector3.one; + systemTracker.SetActive(false); + + SteamVR_RenderModel renderModel = systemTracker.AddComponent(); + renderModel.enabled = true; + renderModel.updateDynamically = false; + renderModel.createComponents = false; + renderModel.SetDeviceIndex(ExtractNumberFromTrackingPoint(__instance.name)); + } + + public static int ExtractNumberFromTrackingPoint(string inputString) + { + string numberString = inputString.Replace("SteamVR_", ""); + int number = int.Parse(numberString); + return number; + } +} \ No newline at end of file diff --git a/TrackedPointFix/Main.cs b/TrackedPointFix/Main.cs new file mode 100644 index 0000000..f927e22 --- /dev/null +++ b/TrackedPointFix/Main.cs @@ -0,0 +1,24 @@ +using MelonLoader; + +namespace NAK.TrackedPointFix; + +public class TrackedPointFix : MelonMod +{ + public override void OnInitializeMelon() + { + ApplyPatches(typeof(HarmonyPatches.IKSystemPatches)); + } + + void ApplyPatches(Type type) + { + try + { + HarmonyInstance.PatchAll(type); + } + catch (Exception e) + { + LoggerInstance.Msg($"Failed while patching {type.Name}!"); + LoggerInstance.Error(e); + } + } +} \ No newline at end of file diff --git a/TrackedPointFix/Properties/AssemblyInfo.cs b/TrackedPointFix/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..013dfe6 --- /dev/null +++ b/TrackedPointFix/Properties/AssemblyInfo.cs @@ -0,0 +1,30 @@ +using MelonLoader; +using NAK.TrackedPointFix.Properties; +using System.Reflection; + +[assembly: AssemblyVersion(AssemblyInfoParams.Version)] +[assembly: AssemblyFileVersion(AssemblyInfoParams.Version)] +[assembly: AssemblyInformationalVersion(AssemblyInfoParams.Version)] +[assembly: AssemblyTitle(nameof(NAK.TrackedPointFix))] +[assembly: AssemblyCompany(AssemblyInfoParams.Author)] +[assembly: AssemblyProduct(nameof(NAK.TrackedPointFix))] + +[assembly: MelonInfo( + typeof(NAK.TrackedPointFix.TrackedPointFix), + nameof(NAK.TrackedPointFix), + AssemblyInfoParams.Version, + AssemblyInfoParams.Author, + downloadLink: "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/tree/main/TrackedPointFix" +)] + +[assembly: MelonGame("Alpha Blend Interactive", "ChilloutVR")] +[assembly: MelonPlatform(MelonPlatformAttribute.CompatiblePlatforms.WINDOWS_X64)] +[assembly: MelonPlatformDomain(MelonPlatformDomainAttribute.CompatibleDomains.MONO)] +[assembly: HarmonyDontPatchAll] + +namespace NAK.TrackedPointFix.Properties; +internal static class AssemblyInfoParams +{ + public const string Version = "1.0.3"; + public const string Author = "NotAKidoS"; +} \ No newline at end of file diff --git a/TrackedPointFix/README.md b/TrackedPointFix/README.md new file mode 100644 index 0000000..14596ae --- /dev/null +++ b/TrackedPointFix/README.md @@ -0,0 +1,19 @@ +# TrackedPointFix (Depricated) +lazy af fix for a small issue + +Your Left/Right hand controllers will now track faster and while in the Steam overlay. + +This approach to fixing the issue is made lazy to support DesktopVRSwitch. + +(also because im lazy) + +--- + +Here is the block of text where I tell you this mod is not affiliated or endorsed by ABI. +https://documentation.abinteractive.net/official/legal/tos/#7-modding-our-games + +> This mod is an independent creation and is not affiliated with, supported by or approved by Alpha Blend Interactive. + +> Use of this mod is done so at the user's own risk and the creator cannot be held responsible for any issues arising from its use. + +> To the best of my knowledge, I have adhered to the Modding Guidelines established by Alpha Blend Interactive. diff --git a/TrackedPointFix/TrackedPointFix.csproj b/TrackedPointFix/TrackedPointFix.csproj new file mode 100644 index 0000000..66a50a8 --- /dev/null +++ b/TrackedPointFix/TrackedPointFix.csproj @@ -0,0 +1,2 @@ + + diff --git a/TrackedPointFix/format.json b/TrackedPointFix/format.json new file mode 100644 index 0000000..e0b9cfb --- /dev/null +++ b/TrackedPointFix/format.json @@ -0,0 +1,23 @@ +{ + "_id": -1, + "name": "TrackedPointFix", + "modversion": "1.0.0", + "gameversion": "2022r170", + "loaderversion": "0.5.7", + "modtype": "Mod", + "author": "NotAKidoS", + "description": "Allows your controllers to track while the SteamVR overlay is open. This also fixes Quest/Touch controllers feeling slow during fast movements.", + "searchtags": [ + "vr", + "quest", + "controller", + "tracking" + ], + "requirements": [ + "None" + ], + "downloadlink": "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/releases/download/r3/TrackedPointFix.dll", + "sourcelink": "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/tree/main/TrackedPointFix/", + "changelog": "Initial Release", + "embedcolor": "3498db" +} \ No newline at end of file