/// <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);
}
