Example #1
0
        public GeometryModel3D[] lightModels;  // geo models

        public static DiffuseMaterial GetMipMaterial(Miptex miptex)
        {
            if (miptex == null)
            {
                return(null);
            }

            WriteableBitmap bmp = new WriteableBitmap(miptex.width, miptex.height, 96, 96, PixelFormats.Indexed8, Bsp.colorPalette);

            bmp.WritePixels(new Int32Rect(0, 0, miptex.width, miptex.height), miptex.texture1, miptex.width, 0);
            var brush = new ImageBrush(bmp);

            brush.TileMode      = TileMode.Tile;
            brush.ViewportUnits = BrushMappingMode.Absolute;
            var material = new DiffuseMaterial(brush);

            return(material);
        }
Example #2
0
        public byte[] texture8; // 1/16 size
        public static Miptex Read(BinaryReader br)
        {
            Miptex miptex = new Miptex();
            var    bytes  = br.ReadBytes(16);

            miptex.name     = Encoding.ASCII.GetString(bytes, 0, bytes.ToList().IndexOf(0));
            miptex.width    = (int)br.ReadUInt32();
            miptex.height   = (int)br.ReadUInt32();
            miptex.offset1  = (int)br.ReadUInt32();
            miptex.offset2  = (int)br.ReadUInt32();
            miptex.offset4  = (int)br.ReadUInt32();
            miptex.offset8  = (int)br.ReadUInt32();
            miptex.texture1 = br.ReadBytes((miptex.width * miptex.height));
            miptex.texture2 = br.ReadBytes((miptex.width * miptex.height) / 4);
            miptex.texture4 = br.ReadBytes((miptex.width * miptex.height) / 16);
            miptex.texture8 = br.ReadBytes((miptex.width * miptex.height) / 64);
            return(miptex);
        }
Example #3
0
        public static Bsp Read(byte[] buf)
        {
            using (var ms = new MemoryStream(buf))
                using (var br = new BinaryReader(ms)) {
                    Header header = Header.Read(br);

                    Bsp bsp = new Bsp();

                    bsp.entities = ReadItems(br, header.entities, (b) => Entity.Read(b));
                    bsp.planes   = ReadItems(br, header.planes, (b) => Plane.Read(b));

                    br.BaseStream.Seek(header.miptex.offset, SeekOrigin.Begin);
                    bsp.mipheader = Mipheader.Read(br);
                    bsp.miptexs   = new Miptex[bsp.mipheader.numtex];
                    for (int i = 0; i < bsp.miptexs.Length; i++)
                    {
                        if (bsp.mipheader.offset[i] == -1)
                        {
                            continue;
                        }
                        br.BaseStream.Seek(header.miptex.offset + bsp.mipheader.offset[i], SeekOrigin.Begin);
                        bsp.miptexs[i] = Miptex.Read(br);
                    }

                    bsp.vertices  = ReadItems(br, header.vertices, (b) => new Vector3D(b.ReadSingle(), b.ReadSingle(), b.ReadSingle()));
                    bsp.vislist   = ReadItems(br, header.visilist, (b) => b.ReadByte());
                    bsp.nodes     = ReadItems(br, header.nodes, (b) => Node.Read(b));
                    bsp.texinfo   = ReadItems(br, header.texinfo, (b) => TexInfo.Read(b));
                    bsp.faces     = ReadItems(br, header.faces, (b) => Face.Read(b));
                    bsp.lightmaps = ReadItems(br, header.lightmaps, (b) => b.ReadByte());
                    bsp.clipnodes = ReadItems(br, header.clipnodes, (b) => Clipnode.Read(b));
                    bsp.leafs     = ReadItems(br, header.leafs, (b) => Leaf.Read(b));
                    bsp.lface     = ReadItems(br, header.lface, (b) => b.ReadUInt16());
                    bsp.edges     = ReadItems(br, header.edges, (b) => Edge.Read(b));
                    bsp.ledges    = ReadItems(br, header.ledges, (b) => b.ReadInt32());
                    bsp.models    = ReadItems(br, header.models, (b) => Model.Read(b));

                    bsp.mipMaterials = bsp.miptexs.Select((mip) => GetMipMaterial(mip)).ToArray();
                    bsp.mipModels    = bsp.faces.Select((face) => bsp.GetMipModel(face)).ToArray();
                    bsp.lightModels  = bsp.faces.Select((face) => bsp.GetLightModel(face)).ToArray();

                    return(bsp);
                }
        }