コード例 #1
0
 /// <summary>
 /// Initialize a new empty instance of <see cref="LandTableSA2"/> with default values.
 /// </summary>
 public LandTableSA2()
 {
     Field04   = 0;     // constant
     Field06   = -1;    // constant
     Field08   = 1;     // constant
     CullRange = 3000f; // almost always this value
     Models    = new List <LandModelSA2>();
     Textures  = new TextureReferenceList();
 }
コード例 #2
0
        private void Read(EndianBinaryReader reader)
        {
            var modelCount = reader.ReadInt16();
            var animCount  = reader.ReadInt16();

            Field04   = reader.ReadInt32();
            CullRange = reader.ReadSingle();
            reader.ReadOffset(() =>
            {
                for (int i = 0; i < modelCount; i++)
                {
                    Models.Add(reader.ReadObject <LandModelSA1>());
                }
            });
            var animListOffset = reader.ReadInt32();

            TexturePakFileName = reader.ReadStringOffset();
            Textures           = reader.ReadObjectOffset <TextureReferenceList>();
        }
コード例 #3
0
        private void Read(EndianBinaryReader reader)
        {
            var modelCount        = reader.ReadInt16();
            var visibleModelCount = reader.ReadInt16(); // can be -1, see objLandTable0000

            Field04   = reader.ReadInt16();
            Field06   = reader.ReadInt16();
            Field08   = reader.ReadInt32();
            CullRange = reader.ReadSingle();
            reader.ReadOffset(() =>
            {
                Models = new List <LandModelSA2>(modelCount);
                for (int i = 0; i < modelCount; i++)
                {
                    Models.Add(reader.ReadObject <LandModelSA2>());
                }

                var actualVisibleModelCount = Models.Count(x => !x.Flags.HasFlag(SurfaceFlags.Collidable));
                if (visibleModelCount != -1 && !(visibleModelCount > modelCount))     // 1 land table is bugged
                {
                    Debug.Assert(visibleModelCount == actualVisibleModelCount);
                }
            });
            reader.ReadOffset(() => throw new NotImplementedException());

            // Hack(TGE): strings are stored in the rdata segment, and thus the base offset is different.
            // Maybe solve this with an address resolver function in the reader.
            var baseOffset  = reader.BaseOffset;
            var baseOffset2 = baseOffset;

            if (baseOffset == -0x10002000)
            {
                baseOffset2 = -0x10001200;
            }

            reader.BaseOffset  = baseOffset2;
            TexturePakFileName = reader.ReadStringOffset();
            reader.BaseOffset  = baseOffset;

            Textures = reader.ReadObjectOffset <TextureReferenceList>(baseOffset2);
        }
コード例 #4
0
 public void Export(Node rootNode, string filePath, TextureReferenceList textureNames)
 {
     TextureNames = textureNames.Select(x => x.Name).ToList();
     Export(rootNode, filePath);
 }
コード例 #5
0
        private static (List <MaterialBuildInfo> MaterialBuildInfos, TextureReferenceList TextureReferences) ConvertMaterialsAndTextures(string baseDirectory, List <Assimp.Material> aiMaterials, string texturePakPath)
        {
            var textureArchive       = new GvmArchive();
            var textureArchiveStream = new MemoryStream();
            var textureArchiveWriter = ( GvmArchiveWriter )textureArchive.Create(textureArchiveStream);
            var textureIdLookup      = new Dictionary <string, int>(StringComparer.InvariantCultureIgnoreCase);
            var textureReferences    = new TextureReferenceList();
            var dontConvert          = false;
            var alphaTextureIds      = new HashSet <int>();

            if (texturePakPath != null && File.Exists(texturePakPath))
            {
                var extension  = Path.GetExtension(texturePakPath);
                var fileStream = ( Stream )File.OpenRead(texturePakPath);
                if (extension.Equals(".prs", StringComparison.InvariantCultureIgnoreCase))
                {
                    try
                    {
                        var decompressedFileStream = new MemoryStream();
                        Prs.Decompress(fileStream, decompressedFileStream);
                        fileStream.Dispose();
                        fileStream = decompressedFileStream;
                    }
                    catch (Exception)
                    {
                        // Not compressed
                    }

                    fileStream.Position = 0;
                }

                var existingTextureArchive       = new GvmArchive();
                var existingTextureArchiveReader = ( GvmArchiveReader )existingTextureArchive.Open(fileStream);
                for (var i = 0; i < existingTextureArchiveReader.Entries.Count; i++)
                {
                    var entry = existingTextureArchiveReader.Entries[i];

                    // Make copy of entry stream
                    var entryStreamCopy = new MemoryStream();
                    entry.Open().CopyTo(entryStreamCopy);
                    entryStreamCopy.Position = 0;

                    var texture = new VrSharp.GvrTexture.GvrTexture(entryStreamCopy);
                    Console.WriteLine(texture.GlobalIndex);
                    entryStreamCopy.Position = 0;

                    // Clean entry name from the added extension
                    var entryName = Path.ChangeExtension(entry.Name, null);

                    textureArchiveWriter.CreateEntry(entryStreamCopy, entryName);
                    textureIdLookup[entryName] = i;
                }
            }

            var materials = new List <MaterialBuildInfo>();

            foreach (var aiMaterial in aiMaterials)
            {
                var texturePath = aiMaterial.TextureDiffuse.FilePath ?? string.Empty;
                var textureName = Path.GetFileNameWithoutExtension(texturePath).ToLowerInvariant();

                if (!textureIdLookup.TryGetValue(textureName, out var textureId))
                {
                    textureReferences.Add(new TextureReference(textureName));
                    textureId = textureIdLookup[textureName] = textureIdLookup.Count;

                    var textureFullPath = Path.GetFullPath(Path.Combine(baseDirectory, texturePath));
                    if (!dontConvert && File.Exists(textureFullPath))
                    {
                        // Convert texture
                        var texture = new GvrTexture {
                            GlobalIndex = ( uint )(1 + textureId)
                        };

                        var textureStream         = new MemoryStream();
                        var textureOriginalBitmap = new Bitmap(textureFullPath);
                        var textureBitmap         = new Bitmap(textureOriginalBitmap,
                                                               new Size(textureOriginalBitmap.Width / 2, textureOriginalBitmap.Height / 2));
                        //var textureBitmap = new Bitmap( 32, 32 );
                        texture.Write(textureBitmap, textureStream);
                        textureStream.Position = 0;

                        // Add it
                        textureArchiveWriter.CreateEntry(textureStream, textureName);

                        //if ( HasTransparency( textureBitmap ) )
                        //{
                        //    alphaTextureIds.Add( textureId );
                        //}
                    }
                }

                var material = new MaterialBuildInfo
                {
                    Ambient          = AssimpHelper.FromAssimp(aiMaterial.ColorAmbient),
                    Diffuse          = AssimpHelper.FromAssimp(aiMaterial.ColorDiffuse),
                    Specular         = AssimpHelper.FromAssimp(aiMaterial.ColorSpecular),
                    ClampU           = aiMaterial.TextureDiffuse.WrapModeU == Assimp.TextureWrapMode.Clamp,
                    ClampV           = aiMaterial.TextureDiffuse.WrapModeV == Assimp.TextureWrapMode.Clamp,
                    FlipU            = aiMaterial.TextureDiffuse.WrapModeU == Assimp.TextureWrapMode.Mirror,
                    FlipV            = aiMaterial.TextureDiffuse.WrapModeV == Assimp.TextureWrapMode.Mirror,
                    DestinationAlpha = DstAlphaOp.InverseDst,
                    Exponent         = 0,
                    FilterMode       = FilterMode.Trilinear,
                    MipMapDAdjust    = MipMapDAdjust.D050,
                    SourceAlpha      = SrcAlphaOp.Src,
                    SuperSample      = false,
                    TextureId        = ( short )textureId,
                    UseAlpha         = alphaTextureIds.Contains(textureId)
                };

                materials.Add(material);
            }

            if (!dontConvert)
            {
                // Write texture archive to file
                textureArchiveWriter.Flush();
                textureArchiveStream.Position = 0;

                if (texturePakPath != null)
                {
                    // Compress it.
                    var textureArchivePrsStream = new MemoryStream();
                    Prs.Compress(textureArchiveStream, textureArchivePrsStream);

                    // Save compressed file.
                    textureArchivePrsStream.Position = 0;
                    using (var outFile = File.Create(texturePakPath))
                        textureArchivePrsStream.CopyTo(outFile);
                }
            }

            return(materials, textureReferences);
        }