示例#1
0
        public static List <Vector3> ScreenToPlaneArea(Camera camera, Plane plane, bool containsCameraPos)
        {
            List <Vector3> result = new List <Vector3>();

            if (containsCameraPos)
            {
                Vector3 pos = camera.transform.position;
                pos.y = 0;
                result.Add(pos);
            }

            Vector3 v1 = Vector3.zero;
            Vector3 v2 = Vector3.zero; v2.Set(Screen.width, 0, 0);
            Vector3 v3 = Vector3.zero; v3.Set(0, Screen.height, 0);
            Vector3 v4 = Vector3.zero; v4.Set(Screen.width, Screen.height, 0);

            Vector3 p1 = XUtility.ScreenToPlanePoint(camera, plane, v1);
            Vector3 p2 = XUtility.ScreenToPlanePoint(camera, plane, v2);
            Vector3 p3 = XUtility.ScreenToPlanePoint(camera, plane, v3);
            Vector3 p4 = XUtility.ScreenToPlanePoint(camera, plane, v4);

            result.Add(p1);
            result.Add(p2);
            result.Add(p3);
            result.Add(p4);

            return(result);
        }
示例#2
0
        public static Rect ScreenToGroundAreaAlignedAxis(Camera camera)
        {
            Rect rect = new Rect(0, 0, 0, 0);
            var  list = XUtility.ScreenToGroundArea(camera);

            foreach (var p in list)
            {
                if (p.x < rect.xMin)
                {
                    rect.xMin = p.x;
                }
                if (p.x > rect.xMax)
                {
                    rect.xMax = p.x;
                }
                if (p.z < rect.yMin)
                {
                    rect.yMin = p.z;
                }
                if (p.z > rect.yMax)
                {
                    rect.yMax = p.z;
                }
            }
            return(rect);
        }
示例#3
0
        public void Push(string bundleName, GameObject go)
        {
            Dictionary <string, LinkedList <GameObject> > category = null;

            if (!this.mPool.TryGetValue(bundleName, out category))
            {
                category = new Dictionary <string, LinkedList <GameObject> >();
                this.mPool.Add(bundleName, category);
            }

            string prefabName            = XUtility.CutCloneMarkForName(go.name);
            LinkedList <GameObject> slot = null;

            if (!category.TryGetValue(prefabName, out slot))
            {
                slot = new LinkedList <GameObject>();
                category.Add(prefabName, slot);
            }

            if (slot.Count < this.mCountPerGameObject)
            {
                slot.AddLast(go);
            }
            else
            {
                Object.Destroy(go);
            }
        }
示例#4
0
 public static void ForeachGameObjectRecursively(GameObject root, System.Action <GameObject> func)
 {
     if (root == null || func == null)
     {
         return;
     }
     func(root);
     foreach (Transform t in root.transform)
     {
         XUtility.ForeachGameObjectRecursively(t.gameObject, func);
     }
 }
示例#5
0
 public static void ResetRenderQueueRecursively(GameObject root)
 {
     XUtility.ForeachComponentRecursively <Renderer>(root,
                                                     r =>
     {
         foreach (Material m in r.materials)
         {
             if (m == null)
             {
                 continue;
             }
             m.renderQueue = m.shader.renderQueue;
         }
     });
 }
示例#6
0
        public static List <int> Subdivision(Mesh mesh)
        {
            if (mesh == null || mesh.vertices == null || mesh.triangles == null)
            {
                return(null);
            }

            List <Vector3> verts   = new List <Vector3>(mesh.vertices);
            List <int>     faces   = new List <int>(mesh.triangles);
            List <int>     lastLOD = XUtility.Subdivision(verts, faces);

            mesh.vertices  = verts.ToArray();
            mesh.triangles = faces.ToArray();
            return(lastLOD);
        }
示例#7
0
        public GameObject FindUI(Canvas canvas, string uiName)
        {
            string     uiNameClone = XUtility.AddCloneMarkForName(uiName);
            GameObject result      = null;

            this.ForeachUI(canvas, ui =>
            {
                if (ui.name == uiName || ui.name == uiNameClone)
                {
                    result = ui;
                    return(false);
                }
                return(true);
            });
            return(result);
        }
示例#8
0
 public static void ForeachComponentRecursively <T>(GameObject root, System.Action <T> func) where T : Component
 {
     if (root == null || func == null)
     {
         return;
     }
     T[] components = root.GetComponents <T>();
     foreach (var c in components)
     {
         func(c);
     }
     foreach (Transform t in root.transform)
     {
         XUtility.ForeachComponentRecursively(t.gameObject, func);
     }
 }
示例#9
0
        void Generate()
        {
            SkinnedMeshRenderer result = XUtility.FindOrCreateComponent <SkinnedMeshRenderer>(this);

            List <Transform> skeleton = new List <Transform>();

            this.gameObject.GetComponentsInChildren <Transform>(true, skeleton);

            List <SkinnedMeshRenderer> renderers = new List <SkinnedMeshRenderer>();

            foreach (Part p in this.mParts.Values)
            {
                if (p.element == null)
                {
                    continue;
                }

                if (p.method == Method.Dress)
                {
                    SkinnedMeshRenderer[] rs = p.element.GetComponentsInChildren <SkinnedMeshRenderer>(true);
                    renderers.AddRange(rs);
                    if (p.element.transform.parent != this.transform)
                    {
                        p.element.transform.parent = this.transform;
                    }
                }
                else
                {
                    // if p is not changed, dont destroy and attach
                    if (p.changed)
                    {
                        GameObject locator = XUtility.FindGameObjectRecursively(this.gameObject, p.locator);
                        XUtility.DestroyChildren(locator);
                        XUtility.AttachGameObject(locator, p.element);
                        p.element.SetActive(true);
                        //XUtility.SetVisibleRecursively(p.element, true);
                    }
                }
            }

            XUtility.CombineSkinnedMeshRenderer(result, skeleton, renderers);
            result.updateWhenOffscreen = true;
        }
示例#10
0
        public static GameObject FindGameObjectRecursively(GameObject root, int instanceId)
        {
            if (root == null)
            {
                return(null);
            }
            if (root.GetInstanceID() == instanceId)
            {
                return(root);
            }
            GameObject result = null;

            foreach (Transform t in root.transform)
            {
                result = XUtility.FindGameObjectRecursively(t.gameObject, instanceId);
                if (result != null)
                {
                    return(result);
                }
            }
            return(null);
        }
示例#11
0
        public static GameObject FindGameObjectRecursively(GameObject root, string name)
        {
            if (root == null)
            {
                return(null);
            }
            if (root.name == name)
            {
                return(root);
            }
            GameObject result = null;

            foreach (Transform t in root.transform)
            {
                result = XUtility.FindGameObjectRecursively(t.gameObject, name);
                if (result != null)
                {
                    return(result);
                }
            }
            return(null);
        }
示例#12
0
        public static GameObject FindOrCreateGameObject(GameObject parent, string name)
        {
            GameObject result = null;

            if (parent == null)
            {
                result = GameObject.Find(name);
                if (result == null)
                {
                    result = new GameObject(name);
                }
            }
            else
            {
                result = XUtility.FindGameObjectInChildren(parent, name);
                if (result == null)
                {
                    result = new GameObject(name);
                    XUtility.AttachGameObject(parent, result);
                }
            }
            return(result);
        }
示例#13
0
        public static void SetLayerRecursively(GameObject root, string layerName)
        {
            int layer = LayerMask.NameToLayer(layerName);

            XUtility.ForeachGameObjectRecursively(root, go => go.layer = layer);
        }
示例#14
0
        public static void SetLayerRecursively <T>(GameObject root, string layerName) where T : Component
        {
            int layer = LayerMask.NameToLayer(layerName);

            XUtility.ForeachComponentRecursively <T>(root, c => c.gameObject.layer = layer);
        }
示例#15
0
        public static List <Vector3> ScreenToGroundArea(Camera camera)
        {
            Plane ground = new Plane(Vector3.up, Vector3.zero);

            return(XUtility.ScreenToPlaneArea(camera, ground, true));
        }
示例#16
0
 public static void SetColliderEnabledRecursively(GameObject root, bool enabled)
 {
     XUtility.ForeachComponentRecursively <Collider>(root, c => c.enabled = enabled);
 }
示例#17
0
        //      v1
        //       *
        //      / \
        //     /   \
        //  m0*-----*m1
        //   / \   / \
        //  /   \ /   \
        // *-----*-----*
        // v0    m2     v2
        public static List <int> Subdivision(List <Vector3> verts, List <int> faces)
        {
            int iCount = faces.Count;
            int fCount = faces.Count / 3;

            for (int f = 0; f < fCount; f++)
            {
                int     iv0 = faces[f * 3 + 0];
                int     iv1 = faces[f * 3 + 1];
                int     iv2 = faces[f * 3 + 2];
                Vector3 v0  = verts[iv0];
                Vector3 v1  = verts[iv1];
                Vector3 v2  = verts[iv2];

                Vector3 m0 = (v0 + v1) * 0.5f;
                Vector3 m1 = (v1 + v2) * 0.5f;
                Vector3 m2 = (v0 + v2) * 0.5f;

                int vCount = verts.Count;
                int vIndex = 0;

                int im0 = vCount + vIndex;
                var in0 = XUtility.GetNearestVertices(verts, m0, 0.1f);
                if (in0.Count == 0)
                {
                    verts.Add(m0);
                    vIndex++;
                }
                else
                {
                    im0 = in0[0];
                }

                int im1 = vCount + vIndex;
                var in1 = XUtility.GetNearestVertices(verts, m1, 0.1f);
                if (in1.Count == 0)
                {
                    verts.Add(m1);
                    vIndex++;
                }
                else
                {
                    im1 = in1[0];
                }

                int im2 = vCount + vIndex;
                var in2 = XUtility.GetNearestVertices(verts, m2, 0.1f);
                if (in2.Count == 0)
                {
                    verts.Add(m2);
                    vIndex++;
                }
                else
                {
                    im2 = in2[0];
                }

                faces.Add(iv0); faces.Add(im0); faces.Add(im2);
                faces.Add(iv1); faces.Add(im1); faces.Add(im0);
                faces.Add(iv2); faces.Add(im2); faces.Add(im1);
                faces.Add(im0); faces.Add(im1); faces.Add(im2);
            }
            List <int> lastLOD = faces.GetRange(0, iCount);

            faces.RemoveRange(0, iCount);
            return(lastLOD);
        }