/// <summary> /// /// </summary> /// <returns>Offset of next data block</returns> private Int32 LoadSpriteFrame(ByteArraySegment pin, out Object ppframe, Int32 framenum, Func <String, ByteArraySegment, Int32, Int32, Int32> onLoadSpriteTexture) { var pinframe = Utilities.BytesToStructure <dspriteframe_t>(pin.Data, pin.StartIndex); var width = EndianHelper.LittleLong(pinframe.width); var height = EndianHelper.LittleLong(pinframe.height); var size = width * height; var pspriteframe = new mspriteframe_t( ); ppframe = pspriteframe; pspriteframe.width = width; pspriteframe.height = height; var orgx = EndianHelper.LittleLong(pinframe.origin[0]); var orgy = EndianHelper.LittleLong(pinframe.origin[1]); pspriteframe.up = orgy; // origin[1]; pspriteframe.down = orgy - height; pspriteframe.left = orgx; // origin[0]; pspriteframe.right = width + orgx; // origin[0]; var name = Name + "_" + framenum.ToString( ); var index = onLoadSpriteTexture(name, new ByteArraySegment(pin.Data, pin.StartIndex + dspriteframe_t.SizeInBytes), width, height); pspriteframe.gl_texturenum = index; return(pin.StartIndex + dspriteframe_t.SizeInBytes + size); }
/// <summary> /// Mod_LoadSpriteGroup /// </summary> private Int32 LoadSpriteGroup(ByteArraySegment pin, out Object ppframe, Int32 framenum, Func <String, ByteArraySegment, Int32, Int32, Int32> onLoadSpriteTexture) { var pingroup = Utilities.BytesToStructure <dspritegroup_t>(pin.Data, pin.StartIndex); var numframes = EndianHelper.LittleLong(pingroup.numframes); var pspritegroup = new mspritegroup_t( ); pspritegroup.numframes = numframes; pspritegroup.frames = new mspriteframe_t[numframes]; ppframe = pspritegroup; var poutintervals = new Single[numframes]; pspritegroup.intervals = poutintervals; var offset = pin.StartIndex + dspritegroup_t.SizeInBytes; for (var i = 0; i < numframes; i++, offset += dspriteinterval_t.SizeInBytes) { var interval = Utilities.BytesToStructure <dspriteinterval_t>(pin.Data, offset); poutintervals[i] = EndianHelper.LittleFloat(interval.interval); if (poutintervals[i] <= 0) { Utilities.Error("Mod_LoadSpriteGroup: interval<=0"); } } for (var i = 0; i < numframes; i++) { Object tmp; offset = LoadSpriteFrame(new ByteArraySegment(pin.Data, offset), out tmp, framenum * 100 + i, onLoadSpriteTexture); pspritegroup.frames[i] = ( mspriteframe_t )tmp; } return(offset); }
private void UpdateScreen() { Host.Screen.vid.maxwarpwidth = WARP_WIDTH; Host.Screen.vid.maxwarpheight = WARP_HEIGHT; Host.Screen.vid.colormap = Host.ColorMap; var v = BitConverter.ToInt32(Host.ColorMap, 2048); Host.Screen.vid.fullbright = 256 - EndianHelper.LittleLong(v); }
public void SwapBytes( ) { this.first_statement = EndianHelper.LittleLong(this.first_statement); this.parm_start = EndianHelper.LittleLong(this.parm_start); this.locals = EndianHelper.LittleLong(this.locals); this.s_name = EndianHelper.LittleLong(this.s_name); this.s_file = EndianHelper.LittleLong(this.s_file); this.numparms = EndianHelper.LittleLong(this.numparms); }
/// <summary> /// CL_WriteDemoMessage /// Dumps the current net message, prefixed by the length and view angles /// </summary> private void WriteDemoMessage( ) { var len = EndianHelper.LittleLong(Host.Network.Message.Length); var writer = ((DisposableWrapper <BinaryWriter>)cls.demofile).Object; writer.Write(len); writer.Write(EndianHelper.LittleFloat(cl.viewangles.X)); writer.Write(EndianHelper.LittleFloat(cl.viewangles.Y)); writer.Write(EndianHelper.LittleFloat(cl.viewangles.Z)); writer.Write(Host.Network.Message.Data, 0, Host.Network.Message.Length); writer.Flush( ); }
public void LoadWadFile(string filename, byte[] buffer) { this._Data = buffer; if (this._Data == null) { Utilities.Error("Wad.LoadWadFile: couldn't load {0}", filename); } if (this._Handle.IsAllocated) { this._Handle.Free( ); } this._Handle = GCHandle.Alloc(this._Data, GCHandleType.Pinned); this._DataPtr = this._Handle.AddrOfPinnedObject( ); var header = Utilities.BytesToStructure <WadInfo>(this._Data, 0); this.Version = Encoding.ASCII.GetString(header.identification); if (this.Version != "WAD2" && this.Version != "WAD3") { Utilities.Error($"Wad file {filename} doesn't have WAD2 or WAD3 id, got {this.Version}\n", filename); } var numlumps = EndianHelper.LittleLong(header.numlumps); var infotableofs = EndianHelper.LittleLong(header.infotableofs); var lumpInfoSize = Marshal.SizeOf(typeof(WadLumpInfo)); this._Lumps = new(numlumps); for (var i = 0; i < numlumps; i++) { var ptr = new IntPtr(this._DataPtr.ToInt64( ) + infotableofs + i * lumpInfoSize); var lump = ( WadLumpInfo )Marshal.PtrToStructure(ptr, typeof(WadLumpInfo)); lump.filepos = EndianHelper.LittleLong(lump.filepos); lump.size = EndianHelper.LittleLong(lump.size); if (lump.type == Wad.TYP_QPIC) { ptr = new(this._DataPtr.ToInt64( ) + lump.filepos); var pic = ( WadPicHeader )Marshal.PtrToStructure(ptr, typeof(WadPicHeader)); EndianHelper.SwapPic(pic); Marshal.StructureToPtr(pic, ptr, true); } this._Lumps.Add(Encoding.ASCII.GetString(lump.name).TrimEnd('\0').ToLower( ), lump); } }
// MSG_ReadFloat (void) public float ReadFloat( ) { if (!this.HasRoom(4)) { return(0); } this._Val.b0 = this._Source.Data[this._Count + 0]; this._Val.b1 = this._Source.Data[this._Count + 1]; this._Val.b2 = this._Source.Data[this._Count + 2]; this._Val.b3 = this._Source.Data[this._Count + 3]; this._Count += 4; this._Val.i0 = EndianHelper.LittleLong(this._Val.i0); return(this._Val.f0); }
public void SwapBytes( ) { this.version = EndianHelper.LittleLong(this.version); this.crc = EndianHelper.LittleLong(this.crc); this.ofs_statements = EndianHelper.LittleLong(this.ofs_statements); this.numstatements = EndianHelper.LittleLong(this.numstatements); this.ofs_globaldefs = EndianHelper.LittleLong(this.ofs_globaldefs); this.numglobaldefs = EndianHelper.LittleLong(this.numglobaldefs); this.ofs_fielddefs = EndianHelper.LittleLong(this.ofs_fielddefs); this.numfielddefs = EndianHelper.LittleLong(this.numfielddefs); this.ofs_functions = EndianHelper.LittleLong(this.ofs_functions); this.numfunctions = EndianHelper.LittleLong(this.numfunctions); this.ofs_strings = EndianHelper.LittleLong(this.ofs_strings); this.numstrings = EndianHelper.LittleLong(this.numstrings); this.ofs_globals = EndianHelper.LittleLong(this.ofs_globals); this.numglobals = EndianHelper.LittleLong(this.numglobals); this.entityfields = EndianHelper.LittleLong(this.entityfields); }
/// <summary> /// Mod_LoadAliasGroup /// </summary> /// <returns>Offset of next data block in source byte array</returns> private int LoadAliasGroup(ByteArraySegment pin, ref maliasframedesc_t frame) { var offset = pin.StartIndex; var pingroup = Utilities.BytesToStructure <daliasgroup_t>(pin.Data, offset); var numframes = EndianHelper.LittleLong(pingroup.numframes); frame.Init( ); frame.firstpose = this.PoseNum; frame.numposes = numframes; for (var i = 0; i < 3; i++) { // these are byte values, so we don't have to worry about endianness frame.bboxmin.v[i] = pingroup.bboxmin.v[i]; frame.bboxmin.v[i] = pingroup.bboxmax.v[i]; } offset += daliasgroup_t.SizeInBytes; var pin_intervals = Utilities.BytesToStructure <daliasinterval_t>(pin.Data, offset); // (daliasinterval_t*)(pingroup + 1); frame.interval = EndianHelper.LittleFloat(pin_intervals.interval); offset += numframes * daliasinterval_t.SizeInBytes; for (var i = 0; i < numframes; i++) { var tris = new trivertx_t[this.Header.numverts]; var offset1 = offset + daliasframe_t.SizeInBytes; for (var j = 0; j < this.Header.numverts; j++, offset1 += trivertx_t.SizeInBytes) { tris[j] = Utilities.BytesToStructure <trivertx_t>(pin.Data, offset1); } this._PoseVerts[this.PoseNum] = tris; this.PoseNum++; offset += daliasframe_t.SizeInBytes + this.Header.numverts * trivertx_t.SizeInBytes; } return(offset); }
/// <summary> /// COM_LoadPackFile /// Takes an explicit (not game tree related) path to a pak file. /// Loads the header and directory, adding the files at the beginning /// of the list so they override previous pack files. /// </summary> public static Pak LoadPackFile(String packfile) { var file = OpenRead(packfile); if (file == null) { return(null); } var header = Utilities.ReadStructure <PakHeader>(file); var id = Encoding.ASCII.GetString(header.id); if (id != "PACK") { Utilities.Error("{0} is not a packfile", packfile); } header.dirofs = EndianHelper.LittleLong(header.dirofs); header.dirlen = EndianHelper.LittleLong(header.dirlen); var numpackfiles = header.dirlen / Marshal.SizeOf(typeof(PakFile)); if (numpackfiles > MAX_FILES_IN_PACK) { Utilities.Error("{0} has {1} files", packfile, numpackfiles); } //if (numpackfiles != PAK0_COUNT) // _IsModified = true; // not the original file file.Seek(header.dirofs, SeekOrigin.Begin); var buf = new Byte[header.dirlen]; if (file.Read(buf, 0, buf.Length) != buf.Length) { Utilities.Error("{0} buffering failed!", packfile); } var info = new List <PakFile>(MAX_FILES_IN_PACK); var handle = GCHandle.Alloc(buf, GCHandleType.Pinned); try { var ptr = handle.AddrOfPinnedObject( ); Int32 count = 0, structSize = Marshal.SizeOf(typeof(PakFile)); while (count < header.dirlen) { var tmp = ( PakFile )Marshal.PtrToStructure(ptr, typeof(PakFile)); info.Add(tmp); ptr = new IntPtr(ptr.ToInt64( ) + structSize); count += structSize; } if (numpackfiles != info.Count) { Utilities.Error("{0} directory reading failed!", packfile); } } finally { handle.Free( ); } // crc the directory to check for modifications //ushort crc; //CRC.Init(out crc); //for (int i = 0; i < buf.Length; i++) // CRC.ProcessByte(ref crc, buf[i]); //if (crc != PAK0_CRC) // _IsModified = true; buf = null; // parse the directory var newfiles = new MemoryPakFile[numpackfiles]; for (var i = 0; i < numpackfiles; i++) { var pf = new MemoryPakFile( ); pf.name = Utilities.GetString(info[i].name); pf.filepos = EndianHelper.LittleLong(info[i].filepos); pf.filelen = EndianHelper.LittleLong(info[i].filelen); newfiles[i] = pf; } var pack = new Pak(packfile, new BinaryReader(file, Encoding.ASCII), newfiles); ConsoleWrapper.Print("Added packfile {0} ({1} files)\n", packfile, numpackfiles); return(pack); }
public void Load(UInt32[] table8to24, String name, Byte[] buffer, Func <String, ByteArraySegment, aliashdr_t, Int32> onLoadSkinTexture, Action <AliasModelData, aliashdr_t> onMakeAliasModelDisplayList) { Name = name; Buffer = buffer; var pinmodel = Utilities.BytesToStructure <mdl_t>(Buffer, 0); var version = EndianHelper.LittleLong(pinmodel.version); if (version != ModelDef.ALIAS_VERSION) { Utilities.Error("{0} has wrong version number ({1} should be {2})", Name, version, ModelDef.ALIAS_VERSION); } // // allocate space for a working header, plus all the data except the frames, // skin and group info // Header = new aliashdr_t( ); Flags = ( EntityFlags )EndianHelper.LittleLong(pinmodel.flags); // // endian-adjust and copy the data, starting with the alias model header // Header.boundingradius = EndianHelper.LittleFloat(pinmodel.boundingradius); Header.numskins = EndianHelper.LittleLong(pinmodel.numskins); Header.skinwidth = EndianHelper.LittleLong(pinmodel.skinwidth); Header.skinheight = EndianHelper.LittleLong(pinmodel.skinheight); if (Header.skinheight > ModelDef.MAX_LBM_HEIGHT) { Utilities.Error("model {0} has a skin taller than {1}", Name, ModelDef.MAX_LBM_HEIGHT); } Header.numverts = EndianHelper.LittleLong(pinmodel.numverts); if (Header.numverts <= 0) { Utilities.Error("model {0} has no vertices", Name); } if (Header.numverts > ModelDef.MAXALIASVERTS) { Utilities.Error("model {0} has too many vertices", Name); } Header.numtris = EndianHelper.LittleLong(pinmodel.numtris); if (Header.numtris <= 0) { Utilities.Error("model {0} has no triangles", Name); } Header.numframes = EndianHelper.LittleLong(pinmodel.numframes); var numframes = Header.numframes; if (numframes < 1) { Utilities.Error("Mod_LoadAliasModel: Invalid # of frames: {0}\n", numframes); } Header.size = EndianHelper.LittleFloat(pinmodel.size) * ModelDef.ALIAS_BASE_SIZE_RATIO; SyncType = ( SyncType )EndianHelper.LittleLong(( Int32 )pinmodel.synctype); FrameCount = Header.numframes; Header.scale = EndianHelper.LittleVector(Utilities.ToVector(ref pinmodel.scale)); Header.scale_origin = EndianHelper.LittleVector(Utilities.ToVector(ref pinmodel.scale_origin)); Header.eyeposition = EndianHelper.LittleVector(Utilities.ToVector(ref pinmodel.eyeposition)); // // load the skins // var offset = LoadAllSkins(table8to24, Header.numskins, new ByteArraySegment(buffer, mdl_t.SizeInBytes), onLoadSkinTexture); // // load base s and t vertices // var stvOffset = offset; // in bytes for (var i = 0; i < Header.numverts; i++, offset += stvert_t.SizeInBytes) { _STVerts[i] = Utilities.BytesToStructure <stvert_t>(buffer, offset); _STVerts[i].onseam = EndianHelper.LittleLong(_STVerts[i].onseam); _STVerts[i].s = EndianHelper.LittleLong(_STVerts[i].s); _STVerts[i].t = EndianHelper.LittleLong(_STVerts[i].t); } // // load triangle lists // var triOffset = stvOffset + Header.numverts * stvert_t.SizeInBytes; offset = triOffset; for (var i = 0; i < Header.numtris; i++, offset += dtriangle_t.SizeInBytes) { _Triangles[i] = Utilities.BytesToStructure <dtriangle_t>(buffer, offset); _Triangles[i].facesfront = EndianHelper.LittleLong(_Triangles[i].facesfront); for (var j = 0; j < 3; j++) { _Triangles[i].vertindex[j] = EndianHelper.LittleLong(_Triangles[i].vertindex[j]); } } // // load the frames // PoseNum = 0; var framesOffset = triOffset + Header.numtris * dtriangle_t.SizeInBytes; Header.frames = new maliasframedesc_t[Header.numframes]; for (var i = 0; i < numframes; i++) { var frametype = ( aliasframetype_t )BitConverter.ToInt32(buffer, framesOffset); framesOffset += 4; if (frametype == aliasframetype_t.ALIAS_SINGLE) { framesOffset = LoadAliasFrame(new ByteArraySegment(buffer, framesOffset), ref Header.frames[i]); } else { framesOffset = LoadAliasGroup(new ByteArraySegment(buffer, framesOffset), ref Header.frames[i]); } } Header.numposes = PoseNum; Type = ModelType.Alias; // FIXME: do this right BoundsMin = -Vector3.One * 16.0f; BoundsMax = -BoundsMin; // // build the draw lists // onMakeAliasModelDisplayList(this, Header); //mesh.MakeAliasModelDisplayLists( mod, Header ); // // move the complete, relocatable alias model to the cache // //cache = Host.Cache.Alloc( aliashdr_t.SizeInBytes * Header.frames.Length * maliasframedesc_t.SizeInBytes, null ); //if ( cache == null ) // return; //cache.data = Header; }
/// <summary> /// Mod_LoadAllSkins /// </summary> /// <returns>Offset of next data block in source byte array</returns> private Int32 LoadAllSkins(UInt32[] table8to24, Int32 numskins, ByteArraySegment data, Func <String, ByteArraySegment, aliashdr_t, Int32> onLoadSkinTexture) { if (numskins < 1 || numskins > ModelDef.MAX_SKINS) { Utilities.Error("Mod_LoadAliasModel: Invalid # of skins: {0}\n", numskins); } var offset = data.StartIndex; var skinOffset = data.StartIndex + daliasskintype_t.SizeInBytes; // skin = (byte*)(pskintype + 1); var s = Header.skinwidth * Header.skinheight; var pskintype = Utilities.BytesToStructure <daliasskintype_t>(data.Data, offset); for (var i = 0; i < numskins; i++) { if (pskintype.type == aliasskintype_t.ALIAS_SKIN_SINGLE) { FloodFillSkin(table8to24, new ByteArraySegment(data.Data, skinOffset), Header.skinwidth, Header.skinheight); // save 8 bit texels for the player model to remap var texels = new Byte[s]; // Hunk_AllocName(s, loadname); Header.texels[i] = texels; // -(byte*)pheader; System.Buffer.BlockCopy(data.Data, offset + daliasskintype_t.SizeInBytes, texels, 0, s); // set offset to pixel data after daliasskintype_t block... offset += daliasskintype_t.SizeInBytes; var name = Name + "_" + i.ToString( ); var index = onLoadSkinTexture(name, new ByteArraySegment(data.Data, offset), Header); Header.gl_texturenum[i, 0] = Header.gl_texturenum[i, 1] = Header.gl_texturenum[i, 2] = Header.gl_texturenum[i, 3] = index; // Host.DrawingContext.LoadTexture( name, Header.skinwidth, //Header.skinheight, new ByteArraySegment( data.Data, offset ), true, false ); // (byte*)(pskintype + 1) // set offset to next daliasskintype_t block... offset += s; pskintype = Utilities.BytesToStructure <daliasskintype_t>(data.Data, offset); } else { // animating skin group. yuck. offset += daliasskintype_t.SizeInBytes; var pinskingroup = Utilities.BytesToStructure <daliasskingroup_t>(data.Data, offset); var groupskins = EndianHelper.LittleLong(pinskingroup.numskins); offset += daliasskingroup_t.SizeInBytes; var pinskinintervals = Utilities.BytesToStructure <daliasskininterval_t>(data.Data, offset); offset += daliasskininterval_t.SizeInBytes * groupskins; pskintype = Utilities.BytesToStructure <daliasskintype_t>(data.Data, offset); Int32 j; for (j = 0; j < groupskins; j++) { FloodFillSkin(table8to24, new ByteArraySegment(data.Data, skinOffset), Header.skinwidth, Header.skinheight); if (j == 0) { var texels = new Byte[s]; // Hunk_AllocName(s, loadname); Header.texels[i] = texels; // -(byte*)pheader; System.Buffer.BlockCopy(data.Data, offset, texels, 0, s); } var name = String.Format("{0}_{1}_{2}", Name, i, j); var index = onLoadSkinTexture(name, new ByteArraySegment(data.Data, offset), Header); Header.gl_texturenum[i, j & 3] = index;// // (byte*)(pskintype) offset += s; pskintype = Utilities.BytesToStructure <daliasskintype_t>(data.Data, offset); } var k = j; for ( ; j < 4; j++) { Header.gl_texturenum[i, j & 3] = Header.gl_texturenum[i, j - k]; } } } return(offset);// (void*)pskintype; }
/// <summary> /// CL_GetMessage /// Handles recording and playback of demos, on top of NET_ code /// </summary> /// <returns></returns> private Int32 GetMessage( ) { if (cls.demoplayback) { // decide if it is time to grab the next message if (cls.signon == ClientDef.SIGNONS) // allways grab until fully connected { if (cls.timedemo) { if (Host.FrameCount == cls.td_lastframe) { return(0); // allready read this frame's message } cls.td_lastframe = Host.FrameCount; // if this is the second frame, grab the real td_starttime // so the bogus time on the first frame doesn't count if (Host.FrameCount == cls.td_startframe + 1) { cls.td_starttime = ( Single )Host.RealTime; } } else if (cl.time <= cl.mtime[0]) { return(0); // don't need another message yet } } // get the next message var reader = ((DisposableWrapper <BinaryReader>)cls.demofile).Object; var size = EndianHelper.LittleLong(reader.ReadInt32( )); if (size > QDef.MAX_MSGLEN) { Utilities.Error("Demo message > MAX_MSGLEN"); } cl.mviewangles[1] = cl.mviewangles[0]; cl.mviewangles[0].X = EndianHelper.LittleFloat(reader.ReadSingle( )); cl.mviewangles[0].Y = EndianHelper.LittleFloat(reader.ReadSingle( )); cl.mviewangles[0].Z = EndianHelper.LittleFloat(reader.ReadSingle( )); Host.Network.Message.FillFrom(reader.BaseStream, size); if (Host.Network.Message.Length < size) { StopPlayback( ); return(0); } return(1); } Int32 r; while (true) { r = Host.Network.GetMessage(cls.netcon); if (r != 1 && r != 2) { return(r); } // discard nop keepalive message if (Host.Network.Message.Length == 1 && Host.Network.Message.Data[0] == ProtocolDef.svc_nop) { Host.Console.Print("<-- server to client keepalive\n"); } else { break; } } if (cls.demorecording) { WriteDemoMessage( ); } return(r); }
public Tuple <byte[], Size, byte[]> GetLumpBuffer(string name) { var lump = this._Lumps .Where(l => Encoding.ASCII.GetString(l.Value.name).Replace("\0", "").ToLower() == name.ToLower( )) .FirstOrDefault( ); if (lump.Value == null) { return(null); } var lumpInfo = lump.Value; if (this.Version == "WAD2" && lumpInfo.type != 0x44) { var offset = this.GetLumpNameOffset(name); var ptr = new IntPtr(this.DataPointer.ToInt64( ) + offset); var picHeader = ( WadPicHeader )Marshal.PtrToStructure(ptr, typeof(WadPicHeader)); offset += Marshal.SizeOf(typeof(WadPicHeader)); return(null); } var mtOffset = lumpInfo.filepos; mtOffset = EndianHelper.LittleLong(mtOffset); if (mtOffset == -1) { return(null); } //var ptr = new IntPtr( DataPointer.ToInt64( ) + offset ); var header = Utilities.BytesToStructure <WadMipTex>(this.Data, mtOffset); //var header = ( WadMipTex ) Marshal.PtrToStructure( ptr, typeof( WadMipTex ) ); var headerSize = WadMipTex.SizeInBytes; var width = EndianHelper.LittleLong(( int )header.width); var height = EndianHelper.LittleLong(( int )header.height); // Dirty code if (name == "conchars") { width = height = 128; } if ((width & 15) != 0 || (height & 15) != 0) { Utilities.Error("Texture {0} is not 16 aligned", name); } if (name == "conchars") { var draw_chars = this.Data; // draw_chars for (var i = 0; i < 256 * 64; i++) { if (draw_chars[mtOffset + i] == 0) { draw_chars[mtOffset + i] = 255; // proper transparent color } } } var pixelCount = ( int )(width * height / 64 * 85); var pixels = new byte[pixelCount]; //offset += WadMipTex.SizeInBytes; byte[] palette = null; var isWad3 = this.Version == "WAD3"; if (isWad3) { var lastOffset = EndianHelper.LittleLong(( int )header.offsets[3]); lastOffset += width / 8 * (height / 8) + 2; var palOffset = mtOffset + lastOffset; palette = new byte[256 * 3]; Buffer.BlockCopy(this.Data, palOffset, palette, 0, palette.Length); } #warning BlockCopy tries to copy data over the bounds of _ModBase if certain mods are loaded. Needs proof fix! if (mtOffset + WadMipTex.SizeInBytes + pixelCount <= this.Data.Length) { Buffer.BlockCopy(this.Data, mtOffset + (isWad3 ? WadMipTex.SizeInBytes : 0), pixels, 0, pixelCount); } else { Buffer.BlockCopy(this.Data, mtOffset + (isWad3 ? WadMipTex.SizeInBytes : 0), pixels, 0, pixelCount); ConsoleWrapper.Print($"Texture info of {name} truncated to fit in bounds of _ModBase\n"); } return(new(pixels, new(width, height), palette)); }
public void Load(String name, Byte[] buffer, Func <String, ByteArraySegment, Int32, Int32, Int32> onLoadSpriteTexture) { Name = name; Buffer = buffer; var pin = Utilities.BytesToStructure <dsprite_t>(buffer, 0); var version = EndianHelper.LittleLong(pin.version); if (version != ModelDef.SPRITE_VERSION) { Utilities.Error("{0} has wrong version number ({1} should be {2})", Name, version, ModelDef.SPRITE_VERSION); } var numframes = EndianHelper.LittleLong(pin.numframes); var psprite = new msprite_t( ); // Uze: sprite models are not cached so cache = new CacheUser( ); cache.data = psprite; psprite.type = ( SpriteType )EndianHelper.LittleLong(pin.type); psprite.maxwidth = EndianHelper.LittleLong(pin.width); psprite.maxheight = EndianHelper.LittleLong(pin.height); psprite.beamlength = EndianHelper.LittleFloat(pin.beamlength); SyncType = ( SyncType )EndianHelper.LittleLong(( Int32 )pin.synctype); psprite.numframes = numframes; var mins = BoundsMin; var maxs = BoundsMax; mins.X = mins.Y = -psprite.maxwidth / 2; maxs.X = maxs.Y = psprite.maxwidth / 2; mins.Z = -psprite.maxheight / 2; maxs.Z = psprite.maxheight / 2; BoundsMin = BoundsMin; // // load the frames // if (numframes < 1) { Utilities.Error("Mod_LoadSpriteModel: Invalid # of frames: {0}\n", numframes); } FrameCount = numframes; var frameOffset = dsprite_t.SizeInBytes; psprite.frames = new mspriteframedesc_t[numframes]; for (var i = 0; i < numframes; i++) { var frametype = ( spriteframetype_t )BitConverter.ToInt32(buffer, frameOffset); frameOffset += 4; psprite.frames[i].type = frametype; if (frametype == spriteframetype_t.SPR_SINGLE) { frameOffset = LoadSpriteFrame(new ByteArraySegment(buffer, frameOffset), out psprite.frames[i].frameptr, i, onLoadSpriteTexture); } else { frameOffset = LoadSpriteGroup(new ByteArraySegment(buffer, frameOffset), out psprite.frames[i].frameptr, i, onLoadSpriteTexture); } } Type = ModelType.Sprite; }
public void SwapBytes( ) { this.type = ( ushort )EndianHelper.LittleShort(( short )this.type); this.ofs = ( ushort )EndianHelper.LittleShort(( short )this.ofs); this.s_name = EndianHelper.LittleLong(this.s_name); }