Beispiel #1
0
        public void RemoveObject(int id)
        {
            GenericMonos.RemoveAt(id);
            Parser.Param = GenericMonos;

            Changed = true;
        }
Beispiel #2
0
        public void InsertObject(int id)
        {
            GenericMono genMono = new GenericMono();

            genMono.ObjectName = "Click to rename";
            GenericMonos.Insert(id >= 0 ? id : GenericMonos.Count, genMono);
            Parser.Param = GenericMonos;

            Changed = true;
        }
Beispiel #3
0
        public void ComputeMinMaxNormals(object[] nmlMeshIds, AnimatorEditor dstAnimatorEditor, NmlMonoBehaviourEditor srcNmlEditor, int srcNmlMeshId, AnimatorEditor srcAnimatorEditor, object[] adjacentAnimatorEditorMeshIdPairs, double adjacentSquaredDistance, bool worldCoordinates)
        {
            foreach (double id in nmlMeshIds)
            {
                int dstMeshRId = dstAnimatorEditor.GetMeshRendererId(GenericMonos[(int)id].ObjectName);
                SkinnedMeshRenderer       dstSMesh    = (SkinnedMeshRenderer)dstAnimatorEditor.Meshes[dstMeshRId];
                Operations.vMesh          dstVMesh    = new Operations.vMesh(dstSMesh, false, false);
                List <Operations.vVertex> dstVertList = dstVMesh.submeshes[0].vertexList;
                for (int i = 1; i < dstVMesh.submeshes.Count; i++)
                {
                    dstVertList.AddRange(dstVMesh.submeshes[i].vertexList);
                }
                Transform meshTransform       = dstSMesh.m_GameObject.instance.FindLinkedComponent(typeof(Transform));
                Matrix    meshTransformMatrix = Transform.WorldTransform(meshTransform);
                foreach (var vert in dstVertList)
                {
                    vert.position = Vector3.TransformCoordinate(vert.position, meshTransformMatrix);
                }

                int srcMeshRId = srcAnimatorEditor.GetMeshRendererId(srcNmlMeshId < 0 ? dstSMesh.m_GameObject.instance.m_Name : srcNmlEditor.GenericMonos[srcNmlMeshId].ObjectName);
                SkinnedMeshRenderer       srcSMesh    = (SkinnedMeshRenderer)srcAnimatorEditor.Meshes[srcMeshRId];
                Operations.vMesh          srcVMesh    = new Operations.vMesh(srcSMesh, false, false);
                List <Operations.vVertex> srcVertList = srcVMesh.submeshes[0].vertexList;
                for (int i = 1; i < srcVMesh.submeshes.Count; i++)
                {
                    srcVertList.AddRange(srcVMesh.submeshes[i].vertexList);
                }
                meshTransform       = srcSMesh.m_GameObject.instance.FindLinkedComponent(typeof(Transform));
                meshTransformMatrix = Transform.WorldTransform(meshTransform);
                foreach (var vert in srcVertList)
                {
                    vert.position = Vector3.TransformCoordinate(vert.position, meshTransformMatrix);
                }

                GenericMono dstGenMono = GenericMonos.Find
                                         (
                    delegate(GenericMono m)
                {
                    return(m.ObjectName == dstSMesh.m_GameObject.instance.m_Name);
                }
                                         );
                if (dstGenMono == null)
                {
                    dstGenMono            = new GenericMono();
                    dstGenMono.ObjectName = dstSMesh.m_GameObject.instance.m_Name;
                    GenericMonos.Add(dstGenMono);
                }
                else
                {
                    dstGenMono.NormalMin.Clear();
                    dstGenMono.NormalMax.Clear();
                }

                GenericMono srcGenMono = srcNmlMeshId < 0
                                        ? srcNmlEditor.GenericMonos.Find
                                         (
                    delegate(GenericMono m)
                {
                    return(m.ObjectName == dstSMesh.m_GameObject.instance.m_Name);
                }
                                         )
                                        : srcNmlEditor.GenericMonos[srcNmlMeshId];
                if (srcGenMono == null)
                {
                    throw new Exception("Source GenericMono for " + dstSMesh.m_GameObject.instance.m_Name + " not found");
                }
                if (srcGenMono.NormalMin.Count != srcVertList.Count)
                {
                    throw new Exception("Source GenericMono for " + dstSMesh.m_GameObject.instance.m_Name + " has " + srcGenMono.NormalMin.Count + " normals, but the source mesh has " + srcVertList.Count + " vertices.");
                }

                for (int i = 0; i < dstVertList.Count; i++)
                {
                    var   vert       = dstVertList[i];
                    int   vertIdx    = -1;
                    float minDistPos = float.MaxValue;
                    float minDistUV  = float.MaxValue;
                    for (int j = 0; j < srcVertList.Count; j++)
                    {
                        var   srcVert    = srcVertList[j];
                        float distSquare = (vert.position - srcVert.position).LengthSquared();
                        if (distSquare < minDistPos)
                        {
                            vertIdx = j;
                            if ((minDistPos = distSquare) == 0)
                            {
                                distSquare = (new Vector2(vert.uv[0], vert.uv[1]) - new Vector2(srcVert.uv[0], srcVert.uv[1])).LengthSquared();
                                if (distSquare < minDistUV)
                                {
                                    if ((minDistUV = distSquare) == 0)
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                        else if (distSquare == minDistPos)
                        {
                            distSquare = (new Vector2(vert.uv[0], vert.uv[1]) - new Vector2(srcVert.uv[0], srcVert.uv[1])).LengthSquared();
                            if (distSquare < minDistUV)
                            {
                                vertIdx = j;
                                if ((minDistUV = distSquare) == 0)
                                {
                                    break;
                                }
                            }
                        }
                    }
                    dstGenMono.NormalMin.Add(vert.normal + srcGenMono.NormalMin[vertIdx] - srcGenMono.NormalMax[vertIdx]);
                    dstGenMono.NormalMax.Add(vert.normal);
                }

                if (adjacentAnimatorEditorMeshIdPairs != null)
                {
                    HashSet <int>      dstVertIndices = new HashSet <int>();
                    Operations.vMesh[] adjVMeshes     = new Operations.vMesh[adjacentAnimatorEditorMeshIdPairs.Length / 2];
                    for (int i = 0; i < adjacentAnimatorEditorMeshIdPairs.Length / 2; i++)
                    {
                        MeshRenderer adjMeshR = (MeshRenderer)((AnimatorEditor)adjacentAnimatorEditorMeshIdPairs[i * 2]).Meshes[(int)(double)adjacentAnimatorEditorMeshIdPairs[i * 2 + 1]];
                        Matrix       worldTransform;
                        if (worldCoordinates)
                        {
                            meshTransform  = adjMeshR.m_GameObject.instance.FindLinkedComponent(typeof(Transform));
                            worldTransform = Transform.WorldTransform(meshTransform);
                        }
                        else
                        {
                            worldTransform = Matrix.Identity;
                        }
                        Operations.vMesh adjVMesh = new Operations.vMesh(adjMeshR, false, false);
                        int adjVertsAdapted       = 0;
                        foreach (var adjSubmesh in adjVMesh.submeshes)
                        {
                            foreach (var adjVert in adjSubmesh.vertexList)
                            {
                                Vector3 adjPos = worldCoordinates
                                                                        ? Vector3.TransformCoordinate(adjVert.position, worldTransform)
                                                                        : adjVert.position;
                                for (int j = 0; j < dstVertList.Count; j++)
                                {
                                    var dstVert = dstVertList[j];
                                    if ((adjPos - dstVert.position).LengthSquared() < adjacentSquaredDistance)
                                    {
                                        if (dstVertIndices.Add(j))
                                        {
                                            dstGenMono.NormalMin[j] = dstGenMono.NormalMax[j] = (dstGenMono.NormalMin[j] + dstGenMono.NormalMax[j]) / 2;
                                        }
                                        adjVert.normal = dstGenMono.NormalMin[j];
                                        adjVertsAdapted++;
                                        break;
                                    }
                                }
                            }
                        }
                        if (adjVertsAdapted > 0)
                        {
                            adjVMeshes[i] = adjVMesh;
                            Report.ReportLog("Adjacent MeshRenderer " + adjMeshR.m_GameObject.instance.m_Name + " has " + adjVertsAdapted + " verts smaller squared distance than " + ((float)adjacentSquaredDistance).ToFloatString());
                        }
                    }

                    for (int i = 0; i < adjVMeshes.Length; i++)
                    {
                        var adjVMesh = adjVMeshes[i];
                        if (adjVMesh != null)
                        {
                            adjVMesh.Flush();
                            ((AnimatorEditor)adjacentAnimatorEditorMeshIdPairs[i * 2]).Changed = true;
                        }
                    }
                }
            }

            Parser.Param = GenericMonos;

            Changed = true;
        }