private void OnDrawGizmos()
 {
     if (SpringManager.showColliders &&
         !SpringBone.SelectionContainsSpringBones())
     {
         DrawGizmos((manager != null) ? manager.colliderColor : Color.gray);
     }
 }
Example #2
0
            public ChainInfo(SpringBone rootBone)
            {
                springBones = rootBone.GetComponentsInChildren <SpringBone>(true);
                transforms  = rootBone.GetComponentsInChildren <Transform>(true);
                var bonePosition = rootBone.transform.position;

                baseVector = new Vector2(bonePosition.x, bonePosition.z).normalized;
                sideVector = new Vector2(-baseVector.y, baseVector.x);
            }
        private static void SelectSpringManager(SpringBone bone)
        {
            var manager = bone.gameObject.GetComponentInParent <SpringManager>();

            if (manager != null)
            {
                Selection.objects = new Object[] { manager.gameObject };
            }
        }
        private void ShowActionButtons(SpringBone bone)
        {
            InitializeActionButtons();
            var buttonCount  = actionButtons.Length;
            var buttonHeight = GUILayout.Height(ButtonHeight);

            for (int buttonIndex = 0; buttonIndex < buttonCount; buttonIndex++)
            {
                actionButtons[buttonIndex].Show(bone, buttonHeight);
            }
        }
        private void OnDrawGizmos()
        {
            if (!enabled)
            {
                return;
            }

            DrawPickBox();

            if (SpringManager.showColliders &&
                !SpringBone.SelectionContainsSpringBones())
            {
                DrawGizmos((manager != null) ? manager.colliderColor : Color.gray);
            }
        }
        private static void SelectPivotNode(SpringBone bone)
        {
            var pivotObjects = new List <GameObject>();

            foreach (var gameObject in Selection.gameObjects)
            {
                var springBone = gameObject.GetComponent <SpringBone>();
                if (springBone != null &&
                    springBone.pivotNode != null)
                {
                    pivotObjects.Add(springBone.pivotNode.gameObject);
                }
            }
            Selection.objects = pivotObjects.ToArray();
        }
Example #7
0
        // Copies dynamics properties to the target.
        // Excludes child, boneAxis, target nodes, and private members.
        public void CopyDynamicsPropertiesTo(SpringBone target)
        {
            target.stiffnessForce = stiffnessForce;
            target.dragForce      = dragForce;
            target.springForce    = springForce;

            target.angularStiffness = angularStiffness;
            yAngleLimits.CopyTo(target.yAngleLimits);
            zAngleLimits.CopyTo(target.zAngleLimits);

            target.radius           = radius;
            target.sphereColliders  = (SpringSphereCollider[])sphereColliders.Clone();
            target.capsuleColliders = (SpringCapsuleCollider[])capsuleColliders.Clone();
            target.panelColliders   = (SpringPanelCollider[])capsuleColliders.Clone();
        }
        private void OnDrawGizmos()
        {
            if (!enabled)
            {
                return;
            }

            if (manager == null)
            {
                manager = GetComponentInParent <SpringManager>();
            }

            if (SpringManager.showColliders &&
                !SpringBone.SelectionContainsSpringBones())
            {
                DrawGizmos((manager != null) ? manager.colliderColor : Color.gray);
            }
        }
Example #9
0
        private static bool TryToGetPivotSideDirection
        (
            SpringBone springBone,
            Vector3 lookDirection,
            out Vector3 sideDirection
        )
        {
            sideDirection = Vector3.up;
            var meshNormal            = FindClosestMeshNormalToPoint(springBone.transform.root, springBone.transform.position);
            var upDirection           = Vector3.Cross(meshNormal, lookDirection).normalized;
            var possibleSideDirection = Vector3.Cross(lookDirection, upDirection).normalized;
            var isSideDirectionValid  = IsPivotSideDirectionValid(lookDirection, possibleSideDirection);

            if (isSideDirectionValid)
            {
                sideDirection = possibleSideDirection;
            }
            return(isSideDirectionValid);
        }
Example #10
0
        // 基点ノードを作成
        public static GameObject CreateSpringPivotNode(SpringBone springBone)
        {
            var pivotObject = new GameObject(springBone.name + "_Pivot");

            pivotObject.transform.parent   = springBone.transform.parent;
            pivotObject.transform.rotation = GetPivotRotation(springBone);
            pivotObject.transform.position = springBone.transform.position;
            pivotObject.AddComponent <SpringBonePivot>();

            var oldPivotNode = springBone.pivotNode;

            if (oldPivotNode != null)
            {
                var skinBones = GameObjectUtil.GetAllBones(springBone.transform.root.gameObject);
                if (IsPivotProbablySafeToDestroy(oldPivotNode, skinBones))
                {
                    Object.DestroyImmediate(oldPivotNode.gameObject);
                }
            }

            springBone.pivotNode = pivotObject.transform;

            springBone.yAngleLimits.active = true;
            if (springBone.yAngleLimits.min > -0.5f && springBone.yAngleLimits.max < 0.5f)
            {
                springBone.yAngleLimits.min = -20f;
                springBone.yAngleLimits.max = 20f;
            }

            springBone.zAngleLimits.active = true;
            if (springBone.zAngleLimits.min > -0.5f && springBone.zAngleLimits.max < 0.5f)
            {
                springBone.zAngleLimits.min = 0f;
                springBone.zAngleLimits.max = 20f;
            }

            return(pivotObject);
        }
Example #11
0
        private static Quaternion GetPivotRotation(SpringBone springBone)
        {
            var lookDirection = springBone.ComputeChildPosition() - springBone.transform.position;

            lookDirection.Normalize();

            Vector3 sideDirection;

            if (!TryToGetPivotSideDirection(springBone, lookDirection, out sideDirection))
            {
                sideDirection   = springBone.transform.position;
                sideDirection.y = 0f;
                sideDirection.Normalize();
                if (!IsPivotSideDirectionValid(lookDirection, sideDirection))
                {
                    sideDirection = Vector3.up;
                    if (!IsPivotSideDirectionValid(lookDirection, sideDirection))
                    {
                        sideDirection = Vector3.forward;
                    }
                }
            }

            var flattenedPosition = springBone.transform.position;

            flattenedPosition.y = 0f;
            if (Vector3.Dot(sideDirection, flattenedPosition) < 0f)
            {
                sideDirection = -sideDirection;
            }

            var upDirection  = Vector3.Cross(lookDirection, sideDirection).normalized;
            var lookRotation = Quaternion.LookRotation(lookDirection, upDirection);
            var axisShift    = Quaternion.Euler(180f, 90f, 0f);

            return(lookRotation * axisShift);
        }
 private static SpringBoneBaseSerializer SpringBoneToBaseSerializer(SpringBone sourceBone)
 {
     return(new SpringBoneBaseSerializer
     {
         boneName = sourceBone.name,
         radius = sourceBone.radius,
         stiffness = sourceBone.stiffnessForce,
         drag = sourceBone.dragForce,
         springForce = sourceBone.springForce,
         windInfluence = sourceBone.windInfluence,
         pivotName = (sourceBone.pivotNode != null) ? sourceBone.pivotNode.name : "",
         yAngleLimits = AngleLimitsToSerializer(sourceBone.yAngleLimits),
         zAngleLimits = AngleLimitsToSerializer(sourceBone.zAngleLimits),
         angularStiffness = sourceBone.angularStiffness,
         lengthLimits = sourceBone.lengthLimitTargets
                        .Where(item => item != null)
                        .Select(item => new LengthLimitSerializer
         {
             objectName = item.name,
             ratio = 1.01f
         })
                        .ToArray()
     });
 }