示例#1
0
        protected override void Initialize()
        {
            RegisterExportHandler <Model>(filePath =>
            {
                var configuration = ConfigurationList.Instance.CurrentConfiguration;

                var objectDatabase  = configuration?.ObjectDatabase;
                var textureDatabase = configuration?.TextureDatabase;
                var boneDatabase    = configuration?.BoneDatabase;

                Data.Save(filePath, objectDatabase, textureDatabase, boneDatabase);
            });
            RegisterExportHandler <Scene>(filePath => Exporter.ConvertAiSceneFromModel(Data, filePath));
            RegisterReplaceHandler <Model>(filePath =>
            {
                var configuration = ConfigurationList.Instance.CurrentConfiguration;

                var objectDatabase  = configuration?.ObjectDatabase;
                var textureDatabase = configuration?.TextureDatabase;

                var model = new Model();
                model.Load(filePath, objectDatabase, textureDatabase);
                return(model);
            });
            RegisterReplaceHandler <Scene>(filePath =>
            {
                if (Data.Meshes.Count > 1)
                {
                    return(Importer.ConvertModelFromAiScene(filePath));
                }

                return(Importer.ConvertModelFromAiSceneWithSingleMesh(filePath));
            });
            RegisterCustomHandler("Rename all shaders to...", () =>
            {
                using (var inputDialog = new InputDialog {
                    WindowTitle = "Rename all shaders", Input = "BLINN"
                })
                {
                    if (inputDialog.ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }

                    foreach (var material in Data.Meshes.SelectMany(x => x.Materials))
                    {
                        material.Shader = inputDialog.Input;
                    }
                }

                IsDirty = true;
            });
            RegisterCustomHandler("Convert triangles to triangle strips", () =>
            {
                foreach (var indexTable in Data.Meshes.SelectMany(x => x.SubMeshes).SelectMany(x => x.IndexTables))
                {
                    if (indexTable.PrimitiveType == PrimitiveType.Triangles)
                    {
                        ushort[] triangleStrip = Stripifier.Stripify(indexTable.Indices);
                        if (triangleStrip != null)
                        {
                            indexTable.PrimitiveType = PrimitiveType.TriangleStrip;
                            indexTable.Indices       = triangleStrip;
                        }
                    }
                }

                IsDirty = true;
            });
            RegisterCustomHandler("Combine all meshes into one", () =>
            {
                if (Data.Meshes.Count <= 1)
                {
                    return;
                }

                var combinedMesh = new Mesh {
                    Name = "Combined mesh"
                };
                var indexMap = new Dictionary <int, int>();

                foreach (var mesh in Data.Meshes)
                {
                    if (mesh.Skin != null)
                    {
                        if (combinedMesh.Skin == null)
                        {
                            combinedMesh.Skin = new Skin();
                            combinedMesh.Skin.Bones.AddRange(mesh.Skin.Bones);
                        }
                        else
                        {
                            for (int i = 0; i < mesh.Skin.Bones.Count; i++)
                            {
                                var bone      = mesh.Skin.Bones[i];
                                var boneIndex = combinedMesh.Skin.Bones
                                                .FindIndex(x => x.Name.Equals(bone.Name, StringComparison.OrdinalIgnoreCase));

                                if (boneIndex == -1)
                                {
                                    indexMap[i] = combinedMesh.Skin.Bones.Count;
                                    combinedMesh.Skin.Bones.Add(bone);
                                }
                                else
                                {
                                    indexMap[i] = boneIndex;
                                }
                            }

                            foreach (var indexTable in mesh.SubMeshes.SelectMany(x => x.IndexTables))
                            {
                                if (indexTable.BoneIndices?.Length >= 1)
                                {
                                    for (int i = 0; i < indexTable.BoneIndices.Length; i++)
                                    {
                                        indexTable.BoneIndices[i] = ( ushort )indexMap[indexTable.BoneIndices[i]];
                                    }
                                }
                            }
                        }
                    }

                    foreach (var indexTable in mesh.SubMeshes.SelectMany(x => x.IndexTables))
                    {
                        indexTable.MaterialIndex += combinedMesh.Materials.Count;
                    }

                    combinedMesh.SubMeshes.AddRange(mesh.SubMeshes);
                    combinedMesh.Materials.AddRange(mesh.Materials);
                }

                Data.Meshes.Clear();
                Data.Meshes.Add(combinedMesh);

                if (IsPopulated)
                {
                    IsPopulated = false;
                    Populate();
                }

                IsDirty = true;
            });

            base.Initialize();
        }