public static void R_DrawSpriteModel(entity_t e)
{
// don't even bother culling, because it's just a single
// polygon without a surface cache
mspriteframe_t frame = R_GetSpriteFrame(e);
msprite_t psprite = (msprite_t)e.model.cache.data;
Vector3 v_forward, right, up;
if (psprite.type == q_shared.SPR_ORIENTED)
{
// bullet marks on walls
Mathlib.AngleVectors(ref e.angles, out v_forward, out right, out up); // Uze: changed from _CurrentEntity to e
}
else
{ // normal sprite
up = vup; // vup;
right = vright; // vright;
}
GL.Color3(1f, 1, 1);
GL_DisableMultitexture();
GL_Bind(frame.gl_texturenum);
GL.Enable(EnableCap.AlphaTest);
GL.Begin(BeginMode.Quads);
GL.TexCoord2(0f, 1);
Vector3 point = e.origin + up * frame.down + right * frame.left;
GL.Vertex3(point);
GL.TexCoord2(0f, 0);
point = e.origin + up * frame.up + right * frame.left;
GL.Vertex3(point);
GL.TexCoord2(1f, 0);
point = e.origin + up * frame.up + right * frame.right;
GL.Vertex3(point);
GL.TexCoord2(1f, 1);
point = e.origin + up * frame.down + right * frame.right;
GL.Vertex3(point);
GL.End();
GL.Disable(EnableCap.AlphaTest);
}
public static mspriteframe_t R_GetSpriteFrame(entity_t currententity)
{
msprite_t psprite = (msprite_t)currententity.model.cache.data;
int frame = currententity.frame;
if ((frame >= psprite.numframes) || (frame < 0))
{
Con_Printf("R_DrawSprite: no such frame {0}\n", frame);
frame = 0;
}
mspriteframe_t pspriteframe;
if (psprite.frames[frame].type == spriteframetype_t.SPR_SINGLE)
{
pspriteframe = (mspriteframe_t)psprite.frames[frame].frameptr;
}
else
{
mspritegroup_t pspritegroup = (mspritegroup_t)psprite.frames[frame].frameptr;
float[] pintervals = pspritegroup.intervals;
int numframes = pspritegroup.numframes;
float fullinterval = pintervals[numframes - 1];
float time = (float)cl.time + currententity.syncbase;
// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
// are positive, so we don't have to worry about division by 0
float targettime = time - ((int)(time / fullinterval)) * fullinterval;
int i;
for (i = 0; i < (numframes - 1); i++)
{
if (pintervals[i] > targettime)
{
break;
}
}
pspriteframe = pspritegroup.frames[i];
}
return(pspriteframe);
}
/*
=================
Mod_LoadSpriteModel
=================
*/
static void Mod_LoadSpriteModel(model_t mod, byte[] buffer)
{
int i;
int version;
dsprite_t pin;
msprite_t psprite;
int numframes;
dspriteframetype_t pframetype;
bspfile.ByteBuffer aux = new bspfile.ByteBuffer(buffer, 0);
pin = (dsprite_t)buffer;
version = pin.version;
if (version != SPRITE_VERSION)
sys_linux.Sys_Error (mod.name + " has wrong version number (" + version + " should be " + SPRITE_VERSION + ")");
numframes = pin.numframes;
psprite = new msprite_t();
psprite.frames = new mspriteframedesc_t[numframes];
for(int kk = 0; kk < numframes; kk++)
psprite.frames[kk] = new mspriteframedesc_t();
mod.cache = psprite;
psprite.type = pin.type;
psprite.maxwidth = pin.width;
psprite.maxheight = pin.height;
psprite.beamlength = pin.beamlength;
mod.synctype = pin.synctype;
psprite.numframes = numframes;
mod.mins[0] = mod.mins[1] = -psprite.maxwidth/2;
mod.maxs[0] = mod.maxs[1] = psprite.maxwidth/2;
mod.mins[2] = -psprite.maxheight/2;
mod.maxs[2] = psprite.maxheight/2;
//
// load the frames
//
if (numframes < 1)
sys_linux.Sys_Error ("Mod_LoadSpriteModel: Invalid # of frames: " + numframes + "\n");
mod.numframes = numframes;
mod.flags = 0;
aux.ofs += sizeof_dsprite_t;
for (i=0 ; i<numframes ; i++)
{
spriteframetype_t frametype;
pframetype = (dspriteframetype_t)aux;
frametype = pframetype.type;
psprite.frames[i].type = frametype;
if (frametype == spriteframetype_t.SPR_SINGLE)
{
aux.ofs += sizeof_dspriteframetype_t;
Mod_LoadSpriteFrame(aux, ref psprite.frames[i].frameptr);
}
else
{
aux.ofs += sizeof_dspriteframetype_t;
Mod_LoadSpriteGroup(aux, ref psprite.frames[i].frameptr);
}
}
mod.type = modtype_t.mod_sprite;
}
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;
}
