コード例 #1
0
        /// <summary>
        /// Converts the given texture dictionary to a field texture archive, and returns a new texture dictionary filled with dummy textures for each texture in the given texture dictionary.
        /// </summary>
        /// <param name="textureDictionary"></param>
        /// <param name="archiveFilePath"></param>
        /// <returns></returns>
        public static TextureDictionary ConvertToFieldTextureArchive(TextureDictionary textureDictionary, string archiveFilePath, bool usePS4Format = false)
        {
            var archiveBuilder = new ArchiveBuilder();

            // Create bgTexArcData00.txt
            var fieldTextureArchiveDataInfoStream = new MemoryStream();

            using (var streamWriter = new StreamWriter(fieldTextureArchiveDataInfoStream, Encoding.Default, 4096, true))
            {
                streamWriter.WriteLine("1,");
                streamWriter.WriteLine($"{textureDictionary.Count},");
            }

            archiveBuilder.AddFile("bgTexArcData00.txt", fieldTextureArchiveDataInfoStream);

            // Convert textures
            foreach (var texture in textureDictionary.Textures)
            {
                var textureInfo      = TextureInfo.GetTextureInfo(texture);
                var texturePixelData = TextureUtilities.GetRawPixelData(texture);

                // Create field texture & save it
                Stream textureStream = new MemoryStream();
                if (!usePS4Format)
                {
                    var fieldTexture = new FieldTexturePS3(textureInfo.PixelFormat, ( byte )textureInfo.MipMapCount, ( short )textureInfo.Width,
                                                           ( short )textureInfo.Height, texturePixelData);
                    fieldTexture.Save(textureStream);
                }
                else
                {
                    var fieldTexture = new GNFTexture(textureInfo.PixelFormat, ( byte )textureInfo.MipMapCount, ( short )textureInfo.Width,
                                                      ( short )textureInfo.Height, texturePixelData);
                    fieldTexture.Save(textureStream);
                }

                archiveBuilder.AddFile(texture.Name, textureStream);
            }

            // Finally build archive file
            archiveBuilder.BuildFile(archiveFilePath);

            // Dummy out textures in texture dictionary
            var newTextureDictionary = new TextureDictionary(textureDictionary.Version);

            foreach (var texture in textureDictionary.Textures)
            {
                newTextureDictionary.Add(Texture.CreateDefaultTexture(texture.Name));
            }

            return(newTextureDictionary);
        }
コード例 #2
0
        private static Material ConvertMaterialAndTextures(Ai.Material aiMaterial, ModelConverterOptions options, string baseDirectoryPath, TextureDictionary textureDictionary)
        {
            // Convert all textures
            TextureInfo diffuseTexture = null;

            if (aiMaterial.HasTextureDiffuse)
            {
                diffuseTexture = ConvertTexture(aiMaterial.TextureDiffuse, baseDirectoryPath);
            }

            TextureInfo lightmapTexture = null;

            if (aiMaterial.HasTextureLightMap)
            {
                lightmapTexture = ConvertTexture(aiMaterial.TextureLightMap, baseDirectoryPath);
            }

            TextureInfo displacementTexture = null;

            if (aiMaterial.HasTextureDisplacement)
            {
                displacementTexture = ConvertTexture(aiMaterial.TextureDisplacement, baseDirectoryPath);
            }

            TextureInfo opacityTexture = null;

            if (aiMaterial.HasTextureOpacity)
            {
                opacityTexture = ConvertTexture(aiMaterial.TextureOpacity, baseDirectoryPath);
            }

            TextureInfo normalTexture = null;

            if (aiMaterial.HasTextureNormal)
            {
                normalTexture = ConvertTexture(aiMaterial.TextureNormal, baseDirectoryPath);
            }

            TextureInfo heightTexture = null;

            if (aiMaterial.HasTextureHeight)
            {
                heightTexture = ConvertTexture(aiMaterial.TextureHeight, baseDirectoryPath);
            }

            TextureInfo emissiveTexture = null;

            if (aiMaterial.HasTextureEmissive)
            {
                emissiveTexture = ConvertTexture(aiMaterial.TextureEmissive, baseDirectoryPath);
            }

            TextureInfo ambientTexture = null;

            if (aiMaterial.HasTextureAmbient)
            {
                ambientTexture = ConvertTexture(aiMaterial.TextureAmbient, baseDirectoryPath);
            }

            TextureInfo specularTexture = null;

            if (aiMaterial.HasTextureSpecular)
            {
                specularTexture = ConvertTexture(aiMaterial.TextureSpecular, baseDirectoryPath);
            }

            TextureInfo reflectionTexture = null;

            if (aiMaterial.HasTextureReflection)
            {
                reflectionTexture = ConvertTexture(aiMaterial.TextureReflection, baseDirectoryPath);
            }

            // Convert material
            Material material     = null;
            string   materialName = AssimpConverterCommon.UnescapeName(aiMaterial.Name);

            switch (options.MaterialPreset)
            {
            case MaterialPreset.FieldTerrain:
            {
                if (diffuseTexture != null)
                {
                    textureDictionary.Add(diffuseTexture.Texture);
                    material = MaterialFactory.CreateFieldTerrainMaterial(materialName, diffuseTexture.Name, HasAlpha(diffuseTexture.PixelFormat));
                }
            }
            break;

            case MaterialPreset.FieldTerrainCastShadow:
            {
                if (diffuseTexture != null)
                {
                    textureDictionary.Add(diffuseTexture.Texture);
                    material = MaterialFactory.CreateFieldTerrainCastShadowMaterial(materialName, diffuseTexture.Name, HasAlpha(diffuseTexture.PixelFormat));
                }
            }
            break;

            case MaterialPreset.CharacterSkinP5:
            {
                if (diffuseTexture != null)
                {
                    textureDictionary.Add(diffuseTexture.Texture);
                    string shadowTextureName = diffuseTexture.Name;

                    if (ambientTexture != null)
                    {
                        textureDictionary.Add(ambientTexture.Texture);
                        shadowTextureName = ambientTexture.Name;
                    }

                    // TODO: transparency
                    material = MaterialFactory.CreateCharacterSkinP5Material(materialName, diffuseTexture.Name, shadowTextureName, HasAlpha(diffuseTexture.PixelFormat));
                }
            }
            break;

            case MaterialPreset.CharacterClothP4D:
            {
                if (diffuseTexture != null)
                {
                    textureDictionary.Add(diffuseTexture.Texture);
                    material = MaterialFactory.CreateCharacterClothP4DMaterial(materialName, diffuseTexture.Name,
                                                                               HasAlpha(diffuseTexture.PixelFormat));
                }
            }
            break;
            }

            // Create dummy material if none was created
            if (material == null)
            {
                material = new Material(materialName);
            }

            return(material);
        }