Example #1
0
        /// <summary>
        /// Anchors the mount point to the specified bone, essencially making
        /// this mount point a child of the bone.
        /// </summary>
        /// <param name="rBoneName">Bone name to anchor to or empty string to anchor to the root</param>
        public void AnchorTo(HumanBodyBones rHumanBodyBoneID)
        {
            if (rHumanBodyBoneID < 0)
            {
                return;
            }
            if (rHumanBodyBoneID > HumanBodyBones.LastBone)
            {
                return;
            }

            _BoneName = "";
            Transform lParentTransform = _Owner.transform;

            if (_Anchor == null)
            {
                _Anchor = new GameObject();
            }

            Animator lAnimator = _Owner.GetComponent <Animator>();

            if (lAnimator != null)
            {
                lParentTransform = lAnimator.GetBoneTransform(rHumanBodyBoneID);
                if (lParentTransform != null)
                {
                    _BoneName = MountPoints.GetHumanBodyBoneName(rHumanBodyBoneID);
                }
            }

            // Parent the mount point to this new transform. We don't
            // change it's position or rotation since we may need an offset.
            _Anchor.transform.parent = lParentTransform;
        }
Example #2
0
        /// <summary>
        /// Grab the closest mount point to any of the mount points in this list.
        /// </summary>
        /// <param name="rSourceMountPoints"></param>
        /// <returns></returns>
        public static MountPoint GetClosestMountPoint(MountPoints rSourceMountPoints)
        {
            MountPoint lMountPoint = null;
            float      lDistance   = float.MaxValue;

            for (int i = 0; i < rSourceMountPoints.Points.Count; i++)
            {
                MountPoint lSourceMountPoint    = rSourceMountPoints.Points[i];
                Vector3    lSourceMountPosition = lSourceMountPoint._Anchor.transform.position;

                MountPoint lTestMountPoint = GetClosestMountPoint(lSourceMountPosition, null, rSourceMountPoints);
                if (lTestMountPoint != null)
                {
                    Vector3 lTestPosition = lTestMountPoint._Anchor.transform.position;
                    float   lTestDistance = Vector3.Distance(lSourceMountPosition, lTestPosition);
                    if (lTestDistance < lDistance)
                    {
                        lDistance   = lTestDistance;
                        lMountPoint = lTestMountPoint;
                    }
                }
            }

            return(lMountPoint);
        }
Example #3
0
        /// <summary>
        /// Conntects the child mount point to the parent
        /// </summary>
        /// <param name="rParent">String representing the parents mount point name</param>
        /// <param name="rChildItemPath">Resource path to the object we'll instanciate</param>
        /// <param name="rChildPointName">String representing the child's mount point name</param>
        /// <returns>GameObject that is the child that is instanciated</returns>
        public GameObject ConnectMountPoints(string rParentPoint, string rChildItemPath, string rChildPointName)
        {
            if (rChildItemPath.Length == 0)
            {
                return(null);
            }

            MountPoint lParentMP = GetMountPoint(rParentPoint);

            if (lParentMP == null)
            {
                return(null);
            }

            GameObject lChild = (GameObject)Instantiate(Resources.Load(rChildItemPath));

            if (lChild == null)
            {
                return(null);
            }

            lChild.name = "Instanciated" + lChild.GetInstanceID();

            MountPoint  lChildMP     = null;
            MountPoints lChildMPList = lChild.GetComponent <MountPoints>();

            if (lChildMPList != null)
            {
                lChildMP = lChildMPList.GetMountPoint(rChildPointName);
                lChildMP.OwnerResourcePath = rChildItemPath;
            }
            else
            {
                Mount lChildMount = lChild.GetComponent <Mount>();
                if (lChildMount != null)
                {
                    lChildMP = lChildMount.Point;
                    lChildMP.OwnerResourcePath = rChildItemPath;
                }
            }

            // If there is no mount point, get out
            if (lChildMP == null)
            {
                GameObject.DestroyObject(lChild);
                return(null);
            }

            // Finally, connect the objects
            ConnectMountPoints(lParentMP, lChildMP);

            // Return the newly created child
            return(lChild);
        }
    /// <summary>
    /// Called when the script object is loaded
    /// </summary>
    void OnEnable()
    {
        LoadBoneNames();

        // Grab the serialized objects
        mTarget = (MountPoints)target;
        mTargetSO = new SerializedObject(target);

        InstanciatePointList();
        InstanciateItemList();

        // Runs through all other objects and loads the mount point
        LoadOtherMountPoints();
    }
Example #5
0
        /// <summary>
        /// Creates a mount point at run-time. This won't persist unless you
        /// serialize the data yourself during run-time.
        /// </summary>
        /// <param name="rName">Name of the mount point</param>
        /// <param name="rBoneName">Bone name to attach it to or empty string to attach to root</param>
        /// <param name="rIgnoreParentScale">Determines if we should ignore the parent object's scale value</param>
        /// <returns></returns>
        public MountPoint CreateMountPoint(string rName, string rBoneName, bool rIgnoreParentScale)
        {
            // Create the mount point
            MountPoint lPoint = new MountPoint();

            lPoint.Owner    = gameObject;
            lPoint.Name     = rName;
            lPoint.BoneName = rBoneName;

            // Attach it to the right bone
            Transform lParentTransform = gameObject.transform;

            lPoint.Anchor      = new GameObject();
            lPoint.Anchor.name = "MP_" + lPoint.Anchor.GetInstanceID();

            if (lPoint.BoneName.Length > 0)
            {
                Animator lAnimator = gameObject.GetComponent <Animator>();
                if (lAnimator != null)
                {
                    int lBoneIndex = MountPoints.GetHumanBodyBoneID(lPoint.BoneName);
                    if (lBoneIndex >= 0 && lBoneIndex <= (int)HumanBodyBones.LastBone)
                    {
                        lParentTransform = lAnimator.GetBoneTransform((HumanBodyBones)lBoneIndex);
                    }
                    else
                    {
                        Transform lBoneTransform = MountPoints.FindBone(transform, lPoint.BoneName);
                        if (lBoneTransform != null)
                        {
                            lParentTransform = lBoneTransform;
                        }
                    }
                }
            }

            lPoint.Anchor.transform.position = lParentTransform.position;
            lPoint.Anchor.transform.rotation = lParentTransform.rotation;
            lPoint.Anchor.transform.parent   = lParentTransform;

            // Initialize by ignoring the scale
            lPoint.IgnoreParentScale = rIgnoreParentScale;

            // Add to the list of mount points
            Points.Add(lPoint);

            // Return the point
            return(lPoint);
        }
Example #6
0
        /// <summary>
        /// Conntects the child mount point to the parent
        /// </summary>
        /// <param name="rParent">String representing the parents mount point name</param>
        /// <param name="rChildItemPath">Resource path to the object we'll instanciate</param>
        /// <param name="rChildPointName">String representing the child's mount point name</param>
        /// <returns>GameObject that is the child that is instanciated</returns>
        public bool ConnectMountPoints(GameObject rParent, string rParentPoint)
        {
            if (rParent == null)
            {
                return(false);
            }

            MountPoints lParentMPs = rParent.GetComponent <MountPoints>();

            if (lParentMPs == null)
            {
                return(false);
            }

            return(lParentMPs.ConnectMountPoints(rParentPoint, Point));
        }
Example #7
0
        /// <summary>
        /// Conntects the child mount point to the parent
        /// </summary>
        /// <param name="rParent">String representing the parents mount point name</param>
        /// <param name="rChildItemPath">Resource path to the object we'll instanciate</param>
        /// <param name="rChildPointName">String representing the child's mount point name</param>
        /// <returns>GameObject that is the child that is instanciated</returns>
        public bool ConnectMountPoints(string rParentName, string rParentPoint)
        {
            GameObject lParent = GameObject.Find(rParentName);

            if (lParent == null)
            {
                return(false);
            }

            MountPoints lParentMPs = lParent.GetComponent <MountPoints>();

            if (lParentMPs == null)
            {
                return(false);
            }

            return(lParentMPs.ConnectMountPoints(rParentPoint, Point));
        }
Example #8
0
        /// <summary>
        /// Conntects the child mount point to the parent
        /// </summary>
        /// <param name="rParentPoint">String representing the parents mount point name</param>
        /// <param name="rChild">GameObject representing the child</param>
        /// <param name="rChildPointName">String representing the child mount point name</param>
        /// <returns>Boolean used to determine if the connection was made</returns>
        public bool ConnectMountPoints(string rParentPoint, GameObject rChild, string rChildPointName)
        {
            if (rChild == null)
            {
                return(false);
            }

            MountPoint lParentMP = GetMountPoint(rParentPoint);

            if (lParentMP == null)
            {
                return(false);
            }

            MountPoint  lChildMP     = null;
            MountPoints lChildMPList = rChild.GetComponent <MountPoints>();

            if (lChildMPList != null)
            {
                lChildMP = lChildMPList.GetMountPoint(rChildPointName);
            }
            else
            {
                Mount lParentMount = rChild.GetComponent <Mount>();
                if (lParentMount != null)
                {
                    lChildMP = lParentMount.Point;
                }
            }

            // If there is no child, get out
            if (lChildMP == null)
            {
                return(false);
            }

            // Finally, connect the objects
            return(ConnectMountPoints(lParentMP, lChildMP));
        }
Example #9
0
        /// <summary>
        /// Anchors the mount point to the specified bone, essencially making
        /// this mount point a child of the bone.
        /// </summary>
        /// <param name="rBoneName">Bone name to anchor to or empty string to anchor to the root</param>
        public void AnchorTo(string rBoneName)
        {
            Transform lParentTransform = _Owner.transform;

            if (_Anchor == null)
            {
                _Anchor      = new GameObject();
                _Anchor.name = "MP_" + _Anchor.GetInstanceID();
            }

            _BoneName = rBoneName;
            if (_BoneName.Length > 0)
            {
                Animator lAnimator = _Owner.GetComponent <Animator>();
                if (lAnimator != null)
                {
                    int lBoneIndex = MountPoints.GetHumanBodyBoneID(_BoneName);
                    if (lBoneIndex >= 0 && lBoneIndex < (int)HumanBodyBones.LastBone)
                    {
                        lParentTransform = lAnimator.GetBoneTransform((HumanBodyBones)lBoneIndex);
                    }
                    else
                    {
                        Transform lBoneTransform = MountPoints.FindBone(_Owner.transform, _BoneName);
                        if (lBoneTransform != null)
                        {
                            lParentTransform = lBoneTransform;
                        }
                    }
                }
            }

            // Parent the mount point to this new transform. We don't
            // change it's position or rotation since we may need an offset.
            _Anchor.transform.parent = lParentTransform;
        }
Example #10
0
    /// <summary>
    /// Raised when the object becomes active. Initialization can happen here.
    /// </summary>
    void Awake()
    {
        mMountPoints = GameObject.Find("DefaultMale").GetComponent<MountPoints>();

    }
 /// <summary>
 /// Determine if we're dealing with an actual prefab or an instance
 /// </summary>
 /// <param name="rMountPoints"></param>
 /// <returns></returns>
 private bool IsAddMountPointEnabled(MountPoints rMountPoints)
 {
     PrefabType lType = PrefabUtility.GetPrefabType(rMountPoints);
     return lType != PrefabType.Prefab;
 }
Example #12
0
        /// <summary>
        /// Given the position, find the closest mount point. However, we don't want that mount point to be part of the
        /// current Mount or MountPoints component.
        /// </summary>
        /// <param name="rPosition"></param>
        /// <param name="rSourceMount"></param>
        /// <param name="rSourceMountPoints"></param>
        /// <returns></returns>
        public static MountPoint GetClosestMountPoint(Vector3 rPosition, Mount rSourceMount, MountPoints rSourceMountPoints)
        {
            MountPoint lMountPoint = null;
            float      lDistance   = float.MaxValue;

            MountPoints[] lMountPoints = Component.FindObjectsOfType <MountPoints>();
            for (int i = 0; i < lMountPoints.Length; i++)
            {
                if (lMountPoints[i] == rSourceMountPoints)
                {
                    continue;
                }

                for (int j = 0; j < lMountPoints[i].Points.Count; j++)
                {
                    Vector3 lTestPosition = lMountPoints[i].Points[j]._Anchor.transform.position;
                    float   lTestDistance = Vector3.Distance(rPosition, lTestPosition);
                    if (lTestDistance < lDistance)
                    {
                        lDistance   = lTestDistance;
                        lMountPoint = lMountPoints[i].Points[j];
                    }
                }
            }

            Mount[] lMounts = Component.FindObjectsOfType <Mount>();
            for (int i = 0; i < lMounts.Length; i++)
            {
                if (lMounts[i] == rSourceMount)
                {
                    continue;
                }

                Vector3 lTestPosition = lMounts[i].Point._Anchor.transform.position;
                float   lTestDistance = Vector3.Distance(rPosition, lTestPosition);
                if (lTestDistance < lDistance)
                {
                    lDistance   = lTestDistance;
                    lMountPoint = lMounts[i].Point;
                }
            }

            return(lMountPoint);
        }
Example #13
0
        /// <summary>
        /// Creates an instance of the prefab at the resource path
        /// </summary>
        /// <param name="rParent">MountPoints that will be the parent of the instance</param>
        /// <returns>Instance that was created</returns>
        public GameObject CreateInstance(MountPoints rParent)
        {
            if (_ResourcePath.Length == 0)
            {
                return(null);
            }

            // Extract out the parent's skinned mesh renderer. This should be a high level
            // renderer that contains all the bones we'll need.
            SkinnedMeshRenderer lParentSMR = rParent._Renderer;

            if (lParentSMR == null)
            {
                lParentSMR = rParent.gameObject.GetComponent <SkinnedMeshRenderer>();
            }
            if (lParentSMR == null)
            {
                lParentSMR = rParent.gameObject.GetComponentInChildren <SkinnedMeshRenderer>();
            }
            if (lParentSMR == null)
            {
                return(null);
            }

            // Create the child
            UnityEngine.Object lResource = Resources.Load(_ResourcePath);

#if UNITY_EDITOR
            if (lResource == null)
            {
                lResource = UnityEditor.AssetDatabase.LoadAssetAtPath <GameObject>("Assets\\" + _ResourcePath);
            }
            if (lResource == null)
            {
                lResource = UnityEditor.AssetDatabase.LoadAssetAtPath <GameObject>("Assets\\" + _ResourcePath + ".prefab");
            }
            if (lResource == null)
            {
                lResource = UnityEditor.AssetDatabase.LoadAssetAtPath <GameObject>("Assets\\" + _ResourcePath + ".fbx");
            }
#endif

            if (lResource == null)
            {
                return(null);
            }

            _GameObject = (GameObject)GameObject.Instantiate(lResource);
            if (_GameObject == null)
            {
                return(null);
            }


            //NetworkServer.Spawn(_GameObject);

            // Don't show the child in the hierarchy
            //lChild.hideFlags = HideFlags.HideInHierarchy;

            // Extract out the Skinned Mesh Renderers
            SkinnedMeshRenderer[] lChildSMRs = _GameObject.GetComponents <SkinnedMeshRenderer>();
            if (lChildSMRs == null || lChildSMRs.Length == 0)
            {
                lChildSMRs = _GameObject.GetComponentsInChildren <SkinnedMeshRenderer>();
            }

            // If there's no skinned mesh renderer, we can't really continue
            if (lChildSMRs == null || lChildSMRs.Length == 0)
            {
                DestroyInstance();
                return(null);
            }

            // For each of the renderers, we need to set the bones
            List <Transform> lOldRootBones = new List <Transform>();

            for (int i = 0; i < lChildSMRs.Length; i++)
            {
                SkinnedMeshRenderer lChildSMR = lChildSMRs[i];

                Cloth lChildSMRCloth = lChildSMR.gameObject.GetComponent <Cloth>();

                // Parent it to the parent
                _GameObject.transform.parent        = rParent.gameObject.transform;
                _GameObject.transform.localPosition = Vector3.zero;
                _GameObject.transform.localRotation = Quaternion.identity;
                _GameObject.transform.localScale    = Vector3.one;

                // Go through the bones of the new SM and try to find matching
                // bones from the parent
                List <Transform> lChildBones  = new List <Transform>();
                List <Transform> lTargetBones = new List <Transform>();

                for (int j = 0; j < lChildSMR.bones.Length; j++)
                {
                    Transform lChildBone  = lChildSMR.bones[j];
                    Transform lTargetBone = null;

                    for (int k = 0; k < lParentSMR.bones.Length; k++)
                    {
                        if (MountPoints.CompareBoneNames(lParentSMR.bones[k].name, lChildBone.name))
                        {
                            lTargetBone = lParentSMR.bones[k];
                            break;
                        }
                    }

                    if (lTargetBone == null)
                    {
                        lTargetBone = MountPoints.FindBone(rParent.gameObject.transform, lChildBone.name);
                    }

                    if (lTargetBone != null)
                    {
                        lChildBones.Add(lChildBone);
                        lTargetBones.Add(lTargetBone);
                    }
                }

                lChildSMR.bones = lTargetBones.ToArray();

                // We want to grab the parent's bone that corresponds to our root. We don't
                // just take the parent's root bone since it could be different (ie for boots).
                if (!lOldRootBones.Contains(lChildSMR.rootBone))
                {
                    lOldRootBones.Add(lChildSMR.rootBone);
                }
                lChildSMR.rootBone = MountPoints.FindBone(rParent.gameObject.transform, lChildSMR.rootBone.name);

                // If we're dealing with clothe we need to reassign the colliders
                // Handle clothing if it exists. We may need to move colliders
                if (lChildSMRCloth != null && lChildSMRCloth.capsuleColliders != null)
                {
                    List <CapsuleCollider> lTargetColliders = new List <CapsuleCollider>();

                    for (int j = 0; j < lChildSMRCloth.capsuleColliders.Length; j++)
                    {
                        if (lChildSMRCloth.capsuleColliders[j] == null)
                        {
                            lTargetColliders.Add(null); continue;
                        }

                        int lIndex = lChildBones.IndexOf(lChildSMRCloth.capsuleColliders[j].transform);

                        // If the clothing bone has a collider, our real skeleton may need one too
                        CapsuleCollider lChildCollider = lChildSMRCloth.capsuleColliders[j];
                        if (lChildCollider != null)
                        {
                            // If there's not one, create it
                            CapsuleCollider lParentCollider = lTargetBones[lIndex].GetComponent <CapsuleCollider>();
                            if (lParentCollider == null)
                            {
                                lParentCollider = lTargetBones[lIndex].gameObject.AddComponent <CapsuleCollider>();
                                lParentCollider.GetCopyOf(lChildCollider);
                            }

                            // Change the collider in the clothing
                            for (int k = 0; k < lChildSMRCloth.capsuleColliders.Length; k++)
                            {
                                if (lChildSMRCloth.capsuleColliders[k] == lChildCollider)
                                {
                                    lTargetColliders.Add(lParentCollider);
                                }
                            }
                        }
                    }

                    lChildSMRCloth.capsuleColliders = lTargetColliders.ToArray();
                }

                // Set the update flag per request
                if (_UpdateWhenOffScreen)
                {
                    lChildSMR.updateWhenOffscreen = _UpdateWhenOffScreen;
                }
            }

            // Destroy any old root bones
            for (int i = lOldRootBones.Count - 1; i >= 0; i--)
            {
                if (Application.isPlaying)
                {
                    UnityEngine.GameObject.Destroy(lOldRootBones[i].gameObject);
                }
                else
                {
                    UnityEngine.GameObject.DestroyImmediate(lOldRootBones[i].gameObject);
                }
            }

            // Destroy any old animators
            Animator[] lOldAnimators = _GameObject.GetComponents <Animator>();
            if (lOldAnimators == null || lOldAnimators.Length == 0)
            {
                _GameObject.GetComponentsInChildren <Animator>();
            }

            for (int i = lOldAnimators.Length - 1; i >= 0; i--)
            {
                if (Application.isPlaying)
                {
                    UnityEngine.Component.Destroy(lOldAnimators[i]);
                }
                else
                {
                    UnityEngine.Component.DestroyImmediate(lOldAnimators[i]);
                }
            }

            // Disable visibility if we need to
            if (!_IsVisible)
            {
                Renderer lRenderer = _GameObject.GetComponent <Renderer>();
                if (lRenderer == null)
                {
                    lRenderer = _GameObject.GetComponentInChildren <Renderer>();
                }
                if (lRenderer != null)
                {
                    lRenderer.enabled = false;
                }
            }

            // Return the new game object
            return(_GameObject);
        }