Exemple #1
0
        protected virtual void buildTopology()
        {
            using (new ProfilerSample("Build Topology")) {
                var topology = MeshCache.GetTopology(_generation.graphic.mesh);

                int vertOffset = _generation.verts.Count;
                for (int i = 0; i < topology.tris.Length; i++)
                {
                    _generation.tris.Add(topology.tris[i] + vertOffset);
                }

                if (_doesRequireNormals)
                {
                    var normals = MeshCache.GetNormals(_generation.graphic.mesh);
                    for (int i = 0; i < topology.verts.Length; i++)
                    {
                        Vector3 meshVert;
                        Vector3 meshNormal;
                        graphicVertNormalToMeshVertNormal(topology.verts[i], normals[i], out meshVert, out meshNormal);

                        _generation.verts.Add(meshVert);
                        _generation.normals.Add(meshNormal);
                    }
                }
                else
                {
                    for (int i = 0; i < topology.verts.Length; i++)
                    {
                        _generation.verts.Add(graphicVertToMeshVert(topology.verts[i]));
                    }
                }
            }
        }
            public override void RebuildEditorPickingMesh()
            {
                base.RebuildEditorPickingMesh();

                Assert.IsNotNull(_meshGraphic);

                _meshGraphic.RefreshMeshData();

                List <Vector3> pickingVerts = new List <Vector3>();
                List <int>     pickingTris  = new List <int>();

                pickingVerts.Clear();
                pickingTris.Clear();

                if (pickingMesh == null)
                {
                    pickingMesh = new Mesh();
                    pickingMesh.MarkDynamic();
                    pickingMesh.hideFlags = HideFlags.HideAndDontSave;
                    pickingMesh.name      = "Graphic Picking Mesh";
                }
                pickingMesh.Clear();

                if (_meshGraphic.mesh == null)
                {
                    return;
                }

                var topology = MeshCache.GetTopology(_meshGraphic.mesh);

                for (int i = 0; i < topology.tris.Length; i++)
                {
                    pickingTris.Add(topology.tris[i] + pickingVerts.Count);
                }

                ITransformer transformer = null;

                if (_meshGraphic.anchor != null)
                {
                    transformer = _meshGraphic.anchor.transformer;
                }

                for (int i = 0; i < topology.verts.Length; i++)
                {
                    Vector3 localRectVert = _meshGraphic.attachedGroup.renderer.transform.InverseTransformPoint(_meshGraphic.transform.TransformPoint(topology.verts[i]));

                    if (transformer != null)
                    {
                        localRectVert = transformer.TransformPoint(localRectVert);
                    }

                    localRectVert = _meshGraphic.attachedGroup.renderer.transform.TransformPoint(localRectVert);

                    pickingVerts.Add(localRectVert);
                }

                pickingMesh.SetVertices(pickingVerts);
                pickingMesh.SetTriangles(pickingTris, 0, calculateBounds: true);
                pickingMesh.RecalculateNormals();
            }