Exemple #1
0
 static void Postfix(PlayerTransforms __instance)
 {
     if (Plugin.IsEnabled)
     {
         Vector3 headPos = __instance.headPseudoLocalPos - ConfigHelper.Config.Offset;
         ReflectionHelper.SetField(__instance, "_headPseudoLocalPos", headPos);
     }
 }
Exemple #2
0
        // Performs all note look rotation from world space
        // Never want to touch this again....
        private static void DoNoteLook(
            float num2,
            Quaternion startRotation,
            Quaternion middleRotation,
            Quaternion endRotation,
            PlayerTransforms playerTransforms,
            Transform rotatedObject,
            Transform baseTransform,
            Quaternion inverseWorldRotation)
        {
            NoodleNoteData?noodleData = (NoodleNoteData?)NoteControllerUpdate.NoodleData;

            if (noodleData != null && noodleData.DisableLook)
            {
                rotatedObject.localRotation = endRotation;
                return;
            }

            Quaternion a;

            if (num2 < 0.125f)
            {
                a = Quaternion.Slerp(baseTransform.rotation * startRotation, baseTransform.rotation * middleRotation, Mathf.Sin(num2 * Mathf.PI * 4f));
            }
            else
            {
                a = Quaternion.Slerp(baseTransform.rotation * middleRotation, baseTransform.rotation * endRotation, Mathf.Sin((num2 - 0.125f) * Mathf.PI * 2f));
            }

            Vector3 vector = playerTransforms.headWorldPos;

            // idk whats happening anymore
            Quaternion worldRot = inverseWorldRotation;

            if (baseTransform.parent != null)
            {
                // Handle parenting
                worldRot *= Quaternion.Inverse(baseTransform.parent.rotation);
            }

            // This line but super complicated so that "y" = "originTransform.up"
            // vector.y = Mathf.Lerp(vector.y, this._localPosition.y, 0.8f);
            Transform  headTransform   = _headTransformAccessor(ref playerTransforms);
            Quaternion inverse         = Quaternion.Inverse(worldRot);
            Vector3    upVector        = inverse * Vector3.up;
            float      baseUpMagnitude = Vector3.Dot(worldRot * baseTransform.position, Vector3.up);
            float      headUpMagnitude = Vector3.Dot(worldRot * headTransform.position, Vector3.up);
            float      mult            = Mathf.Lerp(headUpMagnitude, baseUpMagnitude, 0.8f) - headUpMagnitude;

            vector += upVector * mult;

            // more wtf
            Vector3 normalized = baseTransform.rotation * (worldRot * (baseTransform.position - vector).normalized);

            Quaternion b = Quaternion.LookRotation(normalized, rotatedObject.up);

            rotatedObject.rotation = Quaternion.Lerp(a, b, num2 * 2f);
        }
Exemple #3
0
        IEnumerator WaitForLoad()
        {
            PlayerTransforms playerTransforms = null;
            bool             loaded           = false;

            while (!loaded)
            {
                playerTransforms = Resources.FindObjectsOfTypeAll <PlayerTransforms>().FirstOrDefault();
                pauseMenuManager = Resources.FindObjectsOfTypeAll <PauseMenuManager>().FirstOrDefault();
                if (playerTransforms == null || pauseMenuManager == null)
                {
                    yield return(new WaitForSeconds(0.1f));
                }
                else
                {
                    loaded = true;
                }
            }
            headTransform = playerTransforms.GetPrivateField <Transform>("_headTransform");
            yield return(new WaitForSeconds(0.1f));
        }