public Assimp.Scene ConvertToScene(Model model, Config config)
        {
            // Start building scene
            var aiScene = AssimpHelper.CreateDefaultScene();

            // Convert materials
            for (var i = 0; i < model.Materials.Count; i++)
            {
                var material   = model.Materials[i];
                var aiMaterial = new Assimp.Material {
                    Name = FormatMaterialName(material, i)
                };

                if (material.TextureId != null)
                {
                    aiMaterial.TextureDiffuse = new Assimp.TextureSlot
                    {
                        TextureType = Assimp.TextureType.Diffuse,
                        FilePath    = Path.Combine("textures", FormatTextureName(material.TextureId.Value))
                    };
                }

                aiScene.Materials.Add(aiMaterial);
            }

            // Convert nodes
            var aiNodeLookup = new Dictionary <Node, Assimp.Node>();

            for (var i = 0; i < model.Nodes.Count; i++)
            {
                var node   = model.Nodes[i];
                var aiNode = new Assimp.Node(FormatNodeName(node, i), node.Parent != null ? aiNodeLookup[node.Parent] : aiScene.RootNode);
                aiNodeLookup[node] = aiNode;
                aiNode.Transform   = node.Transform.ToAssimp();

                if (node.Geometry != null)
                {
                    ConvertMeshList(node.Geometry.Meshes, node, i, model.Nodes, aiScene, aiNode);

                    if (node.Geometry.TranslucentMeshes != null)
                    {
                        ConvertMeshList(node.Geometry.TranslucentMeshes, node, i, model.Nodes, aiScene, aiNode);
                    }
                }

                aiNode.Parent.Children.Add(aiNode);
            }

            return(aiScene);
        }
예제 #2
0
        public void ExportCollada(string filepath)
        {
            var aiScene = AssimpHelper.CreateDefaultScene();

            foreach (var geometry in Geometries)
            {
                for (var meshIndex = 0; meshIndex < geometry.Meshes.Count; meshIndex++)
                {
                    var aiMeshNode = new Assimp.Node(geometry.Meshes.Count > 1 ? $"{geometry.Name}_mesh_{meshIndex}" : geometry.Name,
                                                     aiScene.RootNode);
                    aiScene.RootNode.Children.Add(aiMeshNode);

                    var mesh   = geometry.Meshes[meshIndex];
                    var aiMesh = new Assimp.Mesh();

                    var aiMaterial = new Assimp.Material
                    {
                        Name = mesh.Material.Name,
                        //ColorDiffuse      = AssimpHelper.ToAssimp( mesh.Material.Diffuse ),
                        //ColorSpecular     = AssimpHelper.ToAssimp( mesh.Material.Specular ),
                        //ColorAmbient      = AssimpHelper.ToAssimp( mesh.Material.Ambient ),
                        Shininess         = 0,
                        ShininessStrength = 0,
                        Reflectivity      = 0,
                        TextureDiffuse    = new Assimp.TextureSlot
                        {
                            TextureType = Assimp.TextureType.Diffuse,
                            FilePath    = mesh.Material.TextureName,
                            WrapModeU   = Assimp.TextureWrapMode.Wrap,
                            WrapModeV   = Assimp.TextureWrapMode.Wrap,
                        }
                    };

                    aiMesh.MaterialIndex = aiScene.MaterialCount;
                    aiScene.Materials.Add(aiMaterial);

                    foreach (var vertex in mesh.Vertices)
                    {
                        aiMesh.Vertices.Add(AssimpHelper.ToAssimp(vertex.Position));
                        aiMesh.Normals.Add(AssimpHelper.ToAssimp(vertex.Normal));
                        aiMesh.VertexColorChannels[0].Add(AssimpHelper.ToAssimp(vertex.Color));
                        aiMesh.TextureCoordinateChannels[0].Add(AssimpHelper.ToAssimp(vertex.UV));
                    }

                    for (int i = 0; i < mesh.Indices.Length; i += 3)
                    {
                        var aiFace = new Assimp.Face();
                        for (int j = 0; j < 3; j++)
                        {
                            aiFace.Indices.Add(mesh.Indices[i + j]);
                        }

                        aiMesh.Faces.Add(aiFace);
                    }

                    aiMeshNode.MeshIndices.Add(aiScene.MeshCount);
                    aiScene.Meshes.Add(aiMesh);
                }
            }

            AssimpHelper.ExportCollada(aiScene, filepath);
        }