示例#1
0
 private static Bitmap Parse(FileInfo file)
 {
     // Sprite file spec taken from the spritegen source in the Half-Life SDK.
     using (var br = new BinaryReader(file.OpenRead()))
     {
         var idst = br.ReadFixedLengthString(Encoding.ASCII, 4);
         if (idst != "IDSP") return null;
         var version = br.ReadInt32();
         if (version != 2) return null;
         var type = br.ReadInt32();
         var texFormat = br.ReadInt32();
         var boundingRadius = br.ReadSingle();
         var width = br.ReadInt32();
         var height = br.ReadInt32();
         var numframes = br.ReadInt32();
         var beamlength = br.ReadSingle();
         var synctype = br.ReadInt32();
         var paletteSize = br.ReadInt16();
         var palette = br.ReadBytes(paletteSize * 3);
         // Only read the first frame.
         var frametype = br.ReadInt32();
         if (frametype != 0)
         {
             var num = br.ReadInt32();
             var intervals = br.ReadSingleArray(num);
         }
         var originX = br.ReadInt32();
         var originY = br.ReadInt32();
         var framewidth = br.ReadInt32();
         var frameheight = br.ReadInt32();
         var pixels = br.ReadBytes(framewidth * frameheight);
         var bitmap = new Bitmap(framewidth, frameheight);
         for (var y = 0; y < frameheight; y++)
         {
             for (var x = 0; x < framewidth; x++)
             {
                 var idx = pixels[framewidth * y + x] * 3;
                 var a = 255;
                 var r = palette[idx + 0];
                 var g = palette[idx + 1];
                 var b = palette[idx + 2];
                 if (b == 255 && r == 0 && g == 0) a = b = 0; // blue pixels are transparent
                 var col = Color.FromArgb(a, r, g, b);
                 bitmap.SetPixel(x, y, col);
             }
         }
         return bitmap;
     }
 }
示例#2
0
        private static Bitmap Parse(IFile file)
        {
            // Sprite file spec taken from the spritegen source in the Half-Life SDK.
            using (var br = new BinaryReader(file.Open()))
            {
                var idst = br.ReadFixedLengthString(Encoding.ASCII, 4);
                if (idst != "IDSP") return null;
                var version = br.ReadInt32();
                if (version != 2) return null;
                var type = (SpriteOrientation) br.ReadInt32();
                var texFormat = (SpriteRenderMode) br.ReadInt32();
                var boundingRadius = br.ReadSingle();
                var width = br.ReadInt32();
                var height = br.ReadInt32();
                var numframes = br.ReadInt32();
                var beamlength = br.ReadSingle();
                var synctype = br.ReadInt32();
                var paletteSize = br.ReadInt16();
                var palette = br.ReadBytes(paletteSize * 3);

                if (paletteSize > 256) paletteSize = 256; // Don't accept anything higher
                var colours = new Color[256];
                for (var i = 0; i < paletteSize; i++)
                {
                    var r = palette[i * 3 + 0];
                    var g = palette[i * 3 + 1];
                    var b = palette[i * 3 + 2];
                    colours[i] = Color.FromArgb(255, r, g, b);
                }

                // Only read the first frame.
                var frametype = br.ReadInt32();
                if (frametype != 0)
                {
                    var num = br.ReadInt32();
                    var intervals = br.ReadSingleArray(num);
                }
                var originX = br.ReadInt32();
                var originY = br.ReadInt32();
                var framewidth = br.ReadInt32();
                var frameheight = br.ReadInt32();
                var pixels = br.ReadBytes(framewidth * frameheight);

                var bitmap = new Bitmap(framewidth, frameheight, PixelFormat.Format8bppIndexed);

                // Pre-process the palette
                var pal = bitmap.Palette;
                var last = colours[255];
                for (var i = 0; i < paletteSize; i++)
                {
                    var c = colours[i];
                    if (texFormat == SpriteRenderMode.Additive)
                    {
                        var a = (int) ((c.R + c.G + c.B) / 3f);
                        c = Color.FromArgb(a, c);
                    }
                    else if (texFormat == SpriteRenderMode.IndexAlpha && i < 255)
                    {
                        var a = (int) ((c.R + c.G + c.B) / 3f);
                        c = Color.FromArgb(a, last);
                    }
                    pal.Entries[i] = c;
                }
                if (texFormat == SpriteRenderMode.AlphaTest)
                {
                    pal.Entries[255] = Color.FromArgb(0, 0, 0, 0);
                }
                bitmap.Palette = pal;

                // Set the pixel data
                var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
                Marshal.Copy(pixels, 0, data.Scan0, data.Width * data.Height);
                bitmap.UnlockBits(data);

                return bitmap;
            }
        }
示例#3
0
        public void LoadFrom(Stream stream)
        {
            BinaryReader reader = new BinaryReader(stream);
            m_ChildPositionArray = reader.ReadVector2Array(reader.ReadInt32());
            m_ChildMagnitudeArray = reader.ReadSingleArray(reader.ReadInt32());
            m_ChildPairVectorArray = reader.ReadVector2Array(reader.ReadInt32());
            m_ChildPairAvgMagInvArray = reader.ReadSingleArray(reader.ReadInt32());

            int numNeighbours = reader.ReadInt32();
            m_ChildNeighborListArray = new MotionNeighborList[numNeighbours];
            for (int i = 0; i < numNeighbours; i++)
            {
                m_ChildNeighborListArray[i] = new MotionNeighborList(stream);
            }
        }
示例#4
0
文件: Mesh.cs 项目: hejob/SB3Utility
 public void LoadFrom(Stream stream)
 {
     BinaryReader reader = new BinaryReader(stream);
     weight = reader.ReadSingleArray(4);
     boneIndex = reader.ReadInt32Array(4);
 }
示例#5
0
 public void LoadFrom(Stream stream)
 {
     BinaryReader reader = new BinaryReader(stream);
     m_ChildThresholdArray = reader.ReadSingleArray(reader.ReadInt32());
 }
示例#6
0
        public void LoadFrom(Stream stream)
        {
            BinaryReader reader = new BinaryReader(stream);

            int numBools = reader.ReadInt32();
            m_BoolValues = new bool[numBools];
            for (int i = 0; i < numBools; i++)
            {
                m_BoolValues[i] = reader.ReadBoolean();
            }
            if ((numBools & 3) > 0)
            {
                reader.ReadBytes(4 - (numBools & 3));
            }

            m_IntValues = reader.ReadInt32Array(reader.ReadInt32());
            m_FloatValues = reader.ReadSingleArray(reader.ReadInt32());
            m_PositionValues = reader.ReadVector4Array(reader.ReadInt32());
            m_QuaternionValues = reader.ReadVector4Array(reader.ReadInt32());
            m_ScaleValues = reader.ReadVector4Array(reader.ReadInt32());
        }
示例#7
0
        private static void ReadSequence(BinaryReader br, int index, ModelData data, DataStructures.Models.Model model, IList<SequenceGroup> groups)
        {
            var startReadIndex = br.BaseStream.Position;
            var name = "";
            var fps = 0f;
            if (data.Version == MDLVersionGoldsource)
            {
                name = br.ReadFixedLengthString(Encoding.ASCII, 32);
                fps = br.ReadSingle();
            }
            else if (data.Version >= MDLVersionSource2006)
            {
                var baseIndex = br.ReadInt32();
                var labelIndex = br.ReadInt32();
                var activityNameIndex = br.ReadInt32();
            }

            var flags = br.ReadInt32();

            var activity = br.ReadInt32();
            var actweight = br.ReadInt32();

            var numevents = br.ReadInt32();
            var eventindex = br.ReadInt32();

            var numframes = 0;

            if (data.Version == MDLVersionGoldsource)
            {
                numframes = br.ReadInt32();
                var numpivots = br.ReadInt32();
                var pivotindex = br.ReadInt32();
                var motiontype = br.ReadInt32();
                var motionbone = br.ReadInt32();
                var linearmovement = br.ReadCoordinateF();
                var automoveposindex = br.ReadInt32();
                var automoveangleindex = br.ReadInt32();
            }

            var bbmin = br.ReadCoordinateF();
            var bbmax = br.ReadCoordinateF();

            var numblends = br.ReadInt32();

            var animindex = br.ReadInt32();

            var groupsize = new int[0];
            if (data.Version >= MDLVersionSource2006)
            {
                var movementindex = br.ReadInt32();
                groupsize = br.ReadIntArray(2);
            }

            var blendtype = br.ReadIntArray(2); // paramindex in source
            var blendstart = br.ReadSingleArray(2); // paramstart
            var blendend = br.ReadSingleArray(2); // paramend
            var blendparent = br.ReadInt32(); // paramparent

            var seqgroup = 0;
            if (data.Version == MDLVersionGoldsource)
            {
                seqgroup = br.ReadInt32();
            }

            if (data.Version >= MDLVersionSource2006)
            {
                var fadeintime = br.ReadSingle();
                var fadeouttime = br.ReadSingle();
            }

            var entrynode = br.ReadInt32();
            var exitnode = br.ReadInt32();
            var nodeflags = br.ReadInt32();

            if (data.Version >= MDLVersionSource2006)
            {
                var entryphase = br.ReadSingle();
                var exitphase = br.ReadSingle();

                var lastframe = br.ReadSingle();
            }

            var nextseq = br.ReadInt32();

            if (data.Version >= MDLVersionSource2006)
            {
                var pose = br.ReadInt32();

                var numikrules = br.ReadInt32();

                var numautolayers = br.ReadInt32();
                var autolayerindex = br.ReadInt32();

                var weightlistindex = br.ReadInt32();

                var wlpos = br.BaseStream.Position;
                br.BaseStream.Position = startReadIndex + weightlistindex;

                var weightList = br.ReadSingleArray(model.Bones.Count);

                br.BaseStream.Position = wlpos;

                var posekeyindex = br.ReadInt32();

                var numiklocks = br.ReadInt32();
                var iklockindex = br.ReadInt32();

                var keyvalueindex = br.ReadInt32();
                var keyvaluesize = br.ReadInt32();

                var cycleposeindex = br.ReadInt32();
                br.ReadIntArray(7); // Unused
            }

            // Load animtion values
            var pos = br.BaseStream.Position;

            if (data.Version == MDLVersionGoldsource)
            {
                if (seqgroup > 0)
                {
                    //TODO: load animations from other files
                    return;
                    // sub out br for another br against the new SG file
                    // br = new BinaryReader(file....etc)
                    // br.BaseStream.Position = animindex;
                }
                br.BaseStream.Position = groups[seqgroup].GroupZeroDataIndex + animindex;
                ReadAnimationGoldsource(br, model, numframes);
            }
            else if (data.Version >= MDLVersionSource2006)
            {
                br.BaseStream.Position = startReadIndex + animindex;
                ReadAnimationSource(br, data, model, groupsize);
            }

            br.BaseStream.Position = pos;
        }
示例#8
0
        private static void LoadSourceMeshData(ModelData modelData, IFile file)
        {
            modelData.Meshes = new List<VTXModel>();
            // In Source the vertices are saved to the VVD file
            // The vertex windings are saved in the VTX file
            var vvd = file.GetRelatedFile("vvd");
            var vtx = file.GetRelatedFile("vtx");
            if (vvd == null) throw new ProviderException("Unable to locate " + file.NameWithoutExtension + ".vvd");
            if (vtx == null) throw new ProviderException("Unable to locate " + file.NameWithoutExtension + ".vtx");

            var vertices = new List<VVDPoint>();

            using (var fs = vvd.Open())
            {
                using (var vbr = new BinaryReader(fs))
                {
                    var magicString = vbr.ReadFixedLengthString(Encoding.UTF8, 4);
                    if (magicString != MagicStringIDSV)
                    {
                        throw new ProviderException("Bad magic number for vertex file. Expected IDSV, got: " + magicString);
                    }

                    var version = vbr.ReadInt32();
                    if (version != VVDVersionSource)
                    {
                        throw new ProviderException("Bad version number for vertex file. Expected 4, got: " + version);
                    }

                    long checksum = vbr.ReadInt32();
                    var numLods = vbr.ReadInt32();
                    var numLodVertices = vbr.ReadIntArray(8);

                    var numFixups = vbr.ReadInt32();
                    var fixupTableStart = vbr.ReadInt32();
                    var vertexDataStart = vbr.ReadInt32();
                    var tangentDataStart = vbr.ReadInt32();

                    vbr.BaseStream.Position = vertexDataStart;

                    // Read all the vertices from LOD 0 (this should contain the vertices for all LODs)
                    for (var i = 0; i < numLodVertices[0]; i++)
                    {
                        var boneWeights = vbr.ReadSingleArray(3);
                        var bones = vbr.ReadBytes(3);
                        var numBones = vbr.ReadByte();
                        var position = vbr.ReadCoordinateF();
                        var normal = vbr.ReadCoordinateF();
                        var textureS = vbr.ReadSingle();
                        var textureT = vbr.ReadSingle();
                        vertices.Add(new VVDPoint(boneWeights, bones, numBones, position, normal, textureS, textureT));
                    }

                    // Apply the fixup table, this re-orders the indices in reverse LOD order for performance reasons
                    if (numFixups > 0)
                    {
                        vbr.BaseStream.Position = fixupTableStart;
                        var newVerts = new List<VVDPoint>();
                        for (var i = 0; i < numFixups; i++)
                        {
                            var fuLod = vbr.ReadInt32();
                            var fuvertid = vbr.ReadInt32();
                            var funumverts = vbr.ReadInt32();
                            newVerts.AddRange(vertices.GetRange(fuvertid, funumverts));
                        }
                        vertices.Clear();
                        vertices.AddRange(newVerts);
                    }

                    modelData.Vertices = vertices;
                }
            }
            using (var fs = vtx.Open())
            {
                using (var vbr = new BinaryReader(fs))
                {
                    var version = vbr.ReadInt32(); // 7
                    if (version != VTXVersionSource)
                    {
                        throw new ProviderException("Bad version number for vertex file. Expected 7, got: " + version);
                    }
                    var vertCacheSize = vbr.ReadInt32();
                    var maxBonesPerStrip = vbr.ReadUInt16();
                    var maxBonesPerTri = vbr.ReadUInt16();
                    var maxBonesPerVert = vbr.ReadInt32();
                    long checksum = vbr.ReadInt32();
                    var numLods = vbr.ReadInt32();
                    var materialReplacementListOffset = vbr.ReadInt32();
                    var numBodyParts = vbr.ReadInt32();
                    var bodyPartOffset = vbr.ReadInt32();

                    // BODY PARTS
                    long posbp = bodyPartOffset;
                    for (var bp = 0; bp < numBodyParts; bp++)
                    {
                        vbr.BaseStream.Position = posbp;

                        var numModels = vbr.ReadInt32();
                        var modelOffset = vbr.ReadInt32();

                        var posmdl = posbp + modelOffset;
                        posbp = vbr.BaseStream.Position;

                        // MODELS
                        for (var mdl = 0; mdl < numModels; mdl++)
                        {
                            vbr.BaseStream.Position = posmdl;

                            var numLod = vbr.ReadInt32();
                            var lodOffset = vbr.ReadInt32();

                            var poslod = posmdl + lodOffset;
                            posmdl = vbr.BaseStream.Position;

                            // LODS
                            for (var lod = 0; lod < numLod; lod++)
                            {
                                vbr.BaseStream.Position = poslod;

                                var meshNum = vbr.ReadInt32();
                                var meshOffset = vbr.ReadInt32();
                                var switchPoint = vbr.ReadSingle();

                                var posmesh = poslod + meshOffset;
                                poslod = vbr.BaseStream.Position;

                                // MESHES
                                for (var msh = 0; msh < meshNum; msh++)
                                {
                                    vbr.BaseStream.Position = posmesh;

                                    var sgNum = vbr.ReadInt32();
                                    var sgOffset = vbr.ReadInt32();
                                    var meshFlags = vbr.ReadByte();

                                    var possg = posmesh + sgOffset;
                                    posmesh = vbr.BaseStream.Position;

                                    var mesh = new VTXModel(bp, mdl, lod, msh);

                                    // STRIP GROUPS
                                    for (var sg = 0; sg < sgNum; sg++)
                                    {
                                        vbr.BaseStream.Position = possg;

                                        var vertNum = vbr.ReadInt32();
                                        var vertOffset = vbr.ReadInt32();
                                        var indexNum = vbr.ReadInt32();
                                        var indexOffset = vbr.ReadInt32();
                                        var stripNum = vbr.ReadInt32();
                                        var stripOffset = vbr.ReadInt32();
                                        var sgFlags = vbr.ReadByte();
                                        // vbr.ReadIntArray(2); //TODO FIXME Newer model format 49's (DOTA2, CSGO) have two extra integers here, (num + offset, purpose unknown)

                                        var posvert = possg + vertOffset;
                                        var posidx = possg + indexOffset;
                                        var posstrip = possg + stripOffset;
                                        possg = vbr.BaseStream.Position;

                                        var vertinfo = new List<VTXPoint>();
                                        vbr.BaseStream.Position = posvert;
                                        for (var vert = 0; vert < vertNum; vert++)
                                        {
                                            var boneWeightIndices = vbr.ReadBytes(3);
                                            var numBones = vbr.ReadByte();
                                            var meshVertex = vbr.ReadInt16();
                                            var boneIDs = vbr.ReadBytes(3);

                                            vertinfo.Add(new VTXPoint(boneWeightIndices, numBones, meshVertex, boneIDs));
                                        }

                                        vbr.BaseStream.Position = posidx;
                                        var indices = vbr.ReadShortArray(indexNum);

                                        // The strips hold info about whether this is a triangle strip or just a list
                                        vbr.BaseStream.Position = posstrip;
                                        for (var st = 0; st < stripNum; st++)
                                        {
                                            var numStIndices = vbr.ReadInt32();
                                            var stIndexOffset = vbr.ReadInt32();
                                            var numStVerts = vbr.ReadInt32();
                                            var stVertOffset = vbr.ReadInt32();
                                            var numStBones = vbr.ReadInt16();
                                            var stFlags = vbr.ReadByte();
                                            var numStBoneStateChanges = vbr.ReadInt32();
                                            var stBoneStateChangeOffset = vbr.ReadInt32();
                                            // vbr.ReadIntArray(2); //TODO FIXME Newer model format 49's (DOTA2, CSGO) have two extra integers here, (num + offset, purpose unknown)

                                            if ((stFlags & VTXStripGroupTriListFlag) > 0)
                                            {
                                                for (var j = stIndexOffset; j < stIndexOffset + numStIndices; j++)
                                                {
                                                    mesh.Mesh.Points.Add(vertinfo[indices[j]]);
                                                    //mesh.Vertices.Add(vertices[vertinfo[indices[j]]]);
                                                }
                                            }
                                            else if ((stFlags & VTXStripGroupTriStripFlag) > 0)
                                            {
                                                for (var j = stIndexOffset; j < stIndexOffset + numStIndices - 2; j++)
                                                {
                                                    var add = j % 2 == 1 ? new[] { j + 1, j, j + 2 } : new[] { j, j + 1, j + 2 };
                                                    foreach (var idx in add)
                                                    {
                                                        mesh.Mesh.Points.Add(vertinfo[indices[idx]]);
                                                        //mesh.Vertices.Add(vertices[vertinfo[indices[idx]]]);
                                                    }
                                                }
                                            }
                                        } // Strips
                                    } // Strip Groups
                                    modelData.Meshes.Add(mesh);
                                } // Meshes
                            } // LODs
                        } // Models
                    } // Body Parts
                } // using (var br)
            } // using (var fs)
        }
示例#9
0
        public sviParser(Stream stream)
        {
            BinaryReader reader = new BinaryReader(stream);

            version = reader.ReadInt32();
            if (version != 100)
            {
                throw new Exception("SVI bad beginning: 0x" + version.ToString("X"));
            }
            meshName = reader.ReadName();
            submeshIdx = reader.ReadInt32();
            int numIndices = reader.ReadInt32();
            indices = reader.ReadUInt16Array(numIndices);

            positionsPresent = reader.ReadByte();
            if (positionsPresent == 1)
            {
                positions = reader.ReadVector3Array(numIndices);
            }

            bonesPresent = reader.ReadByte();
            if (bonesPresent == 1)
            {
                boneWeights3 = new float[numIndices][];
                for (ushort i = 0; i < numIndices; i++)
                {
                    boneWeights3[i] = reader.ReadSingleArray(3);
                }
                boneIndices = new byte[numIndices][];
                for (ushort i = 0; i < numIndices; i++)
                {
                    boneIndices[i] = reader.ReadBytes(4);
                }

                int numBones = reader.ReadInt32();
                bones = new sviBone[numBones];
                for (int i = 0; i < numBones; i++)
                {
                    bones[i] = new sviBone();
                    bones[i].name = reader.ReadName();
                    bones[i].boneIdx = reader.ReadInt32();
                    bones[i].matrix = reader.ReadMatrix();
                }
            }

            normalsPresent = reader.ReadByte();
            if (normalsPresent == 1)
            {
                normals = reader.ReadVector3Array(numIndices);
            }

            uvsPresent = reader.ReadByte();
            if (uvsPresent == 1)
            {
                uvs = reader.ReadVector2Array(numIndices);
            }

            futureSectionPresent = reader.ReadByte();
            if (futureSectionPresent != 0)
            {
                throw new Exception("SVI future section present");
            }
        }