641 lines
16 KiB
C
641 lines
16 KiB
C
//=======================================================================
|
|
// Copyright XashXT Group 2007 ©
|
|
// sprlib.c - sprite generator
|
|
//=======================================================================
|
|
|
|
#include "utils.h"
|
|
#include "sprite.h"
|
|
#include "byteorder.h"
|
|
#include "mathlib.h"
|
|
|
|
#define MAX_FRAMES 256
|
|
#define MAX_FRAME_DIM 512
|
|
#define MIN_INTERVAL 0.001f
|
|
#define MAX_INTERVAL 64.0f
|
|
|
|
dsprite_t sprite;
|
|
byte *spritepool;
|
|
byte *sprite_pal;
|
|
rgbdata_t *frame = NULL;
|
|
script_t *spriteqc = NULL;
|
|
string spriteoutname;
|
|
float frameinterval;
|
|
int framecount;
|
|
int origin_x;
|
|
int origin_y;
|
|
qboolean need_resample;
|
|
qboolean ignore_resample;
|
|
int resample_w;
|
|
int resample_h;
|
|
|
|
struct
|
|
{
|
|
frametype_t type; // single frame or group of frames
|
|
void *pdata; // either a dspriteframe_t or group info
|
|
float interval; // only used for frames in groups
|
|
int numgroupframes; // only used by group headers
|
|
} frames[MAX_FRAMES];
|
|
|
|
/*
|
|
============
|
|
WriteFrame
|
|
============
|
|
*/
|
|
void WriteFrame( file_t *f, int framenum )
|
|
{
|
|
dspriteframe_t *pframe;
|
|
|
|
pframe = (dspriteframe_t *)frames[framenum].pdata;
|
|
pframe->origin[0] = LittleLong( pframe->origin[0] );
|
|
pframe->origin[1] = LittleLong( pframe->origin[1] );
|
|
pframe->width = LittleLong (pframe->width);
|
|
pframe->height = LittleLong (pframe->height);
|
|
|
|
// write frame as 32-bit indexed image
|
|
FS_Write(f, pframe, sizeof(*pframe));
|
|
FS_Write(f, (byte *)(pframe + 1), pframe->height * pframe->width );
|
|
}
|
|
|
|
/*
|
|
============
|
|
WriteSprite
|
|
============
|
|
*/
|
|
void WriteSprite( file_t *f )
|
|
{
|
|
int i;
|
|
short cnt = 256;
|
|
int curframe = 0;
|
|
int groupframe = 0;
|
|
|
|
// calculate bounding radius
|
|
sprite.boundingradius = sqrt(((sprite.bounds[0]>>1) * (sprite.bounds[0]>>1))
|
|
+ ((sprite.bounds[1]>>1) * (sprite.bounds[1]>>1)));
|
|
|
|
// write out the sprite header
|
|
SwapBlock((int *)&sprite, sizeof(dsprite_t));
|
|
FS_Write( f, &sprite, sizeof(sprite));
|
|
|
|
// write out palette (768 bytes)
|
|
FS_Write( f, (void *)&cnt, sizeof(cnt));
|
|
FS_Write( f, sprite_pal, cnt * 3 );
|
|
|
|
for (i = 0; i < sprite.numframes; i++)
|
|
{
|
|
FS_Write( f, &frames[curframe].type, sizeof(frames[curframe].type));
|
|
if( frames[curframe].type == FRAME_SINGLE )
|
|
{
|
|
// single (non-grouped) frame
|
|
WriteFrame( f, curframe );
|
|
curframe++;
|
|
}
|
|
else // angled or sequence
|
|
{
|
|
int j, numframes;
|
|
dspritegroup_t dsgroup;
|
|
float totinterval;
|
|
|
|
groupframe = curframe;
|
|
curframe++;
|
|
numframes = frames[groupframe].numgroupframes;
|
|
|
|
// set and write the group header
|
|
dsgroup.numframes = LittleLong( numframes );
|
|
FS_Write( f, &dsgroup, sizeof(dsgroup));
|
|
totinterval = 0.0f; // write the interval array
|
|
|
|
for( j = 0; j < numframes; j++ )
|
|
{
|
|
dspriteinterval_t temp;
|
|
|
|
totinterval += frames[groupframe+1+j].interval;
|
|
temp.interval = LittleFloat( totinterval );
|
|
FS_Write( f, &temp, sizeof( temp ));
|
|
}
|
|
for( j = 0; j < numframes; j++ )
|
|
{
|
|
WriteFrame( f, curframe );
|
|
curframe++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============
|
|
WriteSPRFile
|
|
==============
|
|
*/
|
|
qboolean WriteSPRFile( void )
|
|
{
|
|
file_t *f;
|
|
uint i, groups = 0, grpframes = 0, sngframes = framecount;
|
|
|
|
Com_CloseScript( spriteqc );
|
|
if( sprite.numframes == 0 )
|
|
{
|
|
MsgDev(D_WARN, "WriteSPRFile: ignoring blank sprite %s\n", spriteoutname );
|
|
return false;
|
|
}
|
|
|
|
f = FS_Open( spriteoutname, "wb" );
|
|
Msg( "writing %s\n", spriteoutname );
|
|
WriteSprite( f );
|
|
FS_Close( f );
|
|
|
|
// release framebuffer
|
|
for( i = 0; i < framecount; i++)
|
|
{
|
|
if( frames[i].pdata ) Mem_Free( frames[i].pdata );
|
|
if( frames[i].numgroupframes )
|
|
{
|
|
groups++;
|
|
sngframes -= frames[i].numgroupframes;
|
|
grpframes += frames[i].numgroupframes;
|
|
}
|
|
}
|
|
|
|
// display info about current sprite
|
|
if( groups )
|
|
{
|
|
Msg("%d group%s,", groups, groups > 1 ? "s":"" );
|
|
Msg(" contain %d frame%s\n", grpframes, grpframes > 1 ? "s":"" );
|
|
}
|
|
if( sngframes - groups )
|
|
Msg("%d ungrouped frame%s\n", sngframes - groups, (sngframes - groups) > 1 ? "s" : "" );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Type
|
|
|
|
syntax: "$type preset"
|
|
===============
|
|
*/
|
|
void Cmd_Type( void )
|
|
{
|
|
token_t token;
|
|
|
|
Com_ReadToken( spriteqc, 0, &token );
|
|
|
|
if( !com.stricmp( token.string, "vp_parallel_upright" )) sprite.type = SPR_FWD_PARALLEL_UPRIGHT;
|
|
else if( !com.stricmp( token.string, "facing_upright" )) sprite.type = SPR_FACING_UPRIGHT;
|
|
else if( !com.stricmp( token.string, "vp_parallel" )) sprite.type = SPR_FWD_PARALLEL;
|
|
else if( !com.stricmp( token.string, "oriented" )) sprite.type = SPR_ORIENTED;
|
|
else if( !com.stricmp( token.string, "vp_parallel_oriented")) sprite.type = SPR_FWD_PARALLEL_ORIENTED;
|
|
else sprite.type = SPR_FWD_PARALLEL; // default
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_RenderMode
|
|
|
|
syntax: "$rendermode preset"
|
|
===============
|
|
*/
|
|
void Cmd_RenderMode( void )
|
|
{
|
|
token_t token;
|
|
|
|
Com_ReadToken( spriteqc, 0, &token );
|
|
|
|
if( !com.stricmp( token.string, "additive")) sprite.texFormat = SPR_ADDITIVE;
|
|
else if( !com.stricmp( token.string, "normal")) sprite.texFormat = SPR_NORMAL;
|
|
else if( !com.stricmp( token.string, "indexalpha")) sprite.texFormat = SPR_INDEXALPHA;
|
|
else if( !com.stricmp( token.string, "alphatest")) sprite.texFormat = SPR_ALPHTEST;
|
|
else if( !com.stricmp( token.string, "glow")) sprite.texFormat = SPR_ADDGLOW;
|
|
else sprite.texFormat = SPR_ADDITIVE; // default
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Cmd_FaceType
|
|
|
|
syntax: "$facetype"
|
|
==============
|
|
*/
|
|
void Cmd_FaceType( void )
|
|
{
|
|
token_t token;
|
|
|
|
Com_ReadToken( spriteqc, 0, &token );
|
|
|
|
if( !com.stricmp( token.string, "normal" )) sprite.facetype = SPR_CULL_FRONT;
|
|
else if( !com.stricmp( token.string, "twoside" )) sprite.facetype = SPR_CULL_NONE;
|
|
else sprite.facetype = SPR_CULL_FRONT; // default
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
Cmd_Framerate
|
|
|
|
syntax: "$framerate value"
|
|
===============
|
|
*/
|
|
void Cmd_Framerate( void )
|
|
{
|
|
float framerate;
|
|
|
|
Com_ReadFloat( spriteqc, false, &framerate );
|
|
if( framerate <= 0.0f ) return; // negative framerate not allowed
|
|
frameinterval = bound( MIN_INTERVAL, (1.0f/framerate), MAX_INTERVAL );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Resample
|
|
|
|
syntax: "$resample <w h>"
|
|
===============
|
|
*/
|
|
void Cmd_Resample( void )
|
|
{
|
|
if(Com_ReadUlong( spriteqc, false, &resample_w ))
|
|
Com_ReadUlong( spriteqc, false, &resample_h );
|
|
else resample_w = resample_h = 0; // Image_Resample will be found nearest pow2
|
|
if( !ignore_resample ) need_resample = true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_NoResample
|
|
|
|
syntax: "$noresample"
|
|
===============
|
|
*/
|
|
void Cmd_NoResample( void )
|
|
{
|
|
ignore_resample = true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Load
|
|
|
|
syntax "$load fire01.bmp"
|
|
===============
|
|
*/
|
|
void Cmd_Load( void )
|
|
{
|
|
string framename;
|
|
static byte base_pal[256*3];
|
|
int flags = 0;
|
|
token_t token;
|
|
|
|
Com_ReadString( spriteqc, SC_PARSE_GENERIC, framename );
|
|
|
|
if( frame ) FS_FreeImage( frame );
|
|
frame = FS_LoadImage( framename, error_bmp, error_bmp_size );
|
|
if( !frame ) Sys_Break( "unable to load %s\n", framename ); // no error.bmp, missing frame...
|
|
if( frame->type != PF_INDEXED_24 && frame->type != PF_INDEXED_32 )
|
|
Sys_Break( "%s it's a not indexed image!\n", framename );
|
|
Image_Process( &frame, 0, 0, IMAGE_PALTO24 );
|
|
if( sprite.numframes == 0 ) Mem_Copy( base_pal, frame->palette, sizeof( base_pal ));
|
|
else if( memcmp( base_pal, frame->palette, sizeof( base_pal )))
|
|
MsgDev( D_WARN, "Cmd_Load: %s doesn't share a pallette with the previous frame\n", framename );
|
|
sprite_pal = (byte *)(&base_pal[0]);
|
|
|
|
Msg( "grabbing %s\n", framename );
|
|
while( Com_ReadToken( spriteqc, 0, &token ))
|
|
{
|
|
if( !com.stricmp(token.string, "flip_diagonal")) flags |= IMAGE_ROT_90;
|
|
else if( !com.stricmp( token.string, "flip_y" )) flags |= IMAGE_FLIP_Y;
|
|
else if( !com.stricmp( token.string, "flip_x" )) flags |= IMAGE_FLIP_X;
|
|
}
|
|
|
|
// apply changes
|
|
Image_Process( &frame, 0, 0, flags );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Frame
|
|
|
|
syntax "$frame xoffset yoffset width height <interval> <origin x> <origin y>"
|
|
===============
|
|
*/
|
|
void Cmd_Frame( void )
|
|
{
|
|
int x, y, xl, yl, xh, yh, w, h;
|
|
int org_x, org_y;
|
|
int pixels, linedelta;
|
|
qboolean resampled = false;
|
|
dspriteframe_t *pframe;
|
|
byte *fin, *plump;
|
|
|
|
if( !frame || !frame->buffer ) Sys_Break( "frame not loaded\n" );
|
|
if( framecount >= MAX_FRAMES ) Sys_Break( "too many frames in package\n" );
|
|
pixels = frame->width * frame->height;
|
|
|
|
Com_ReadLong( spriteqc, false, &xl );
|
|
Com_ReadLong( spriteqc, false, &yl );
|
|
Com_ReadLong( spriteqc, false, &w );
|
|
Com_ReadLong( spriteqc, false, &h );
|
|
|
|
// merge bounds
|
|
if( xl <= 0 || xl > frame->width ) xl = 0;
|
|
if( yl <= 0 || yl > frame->width ) yl = 0;
|
|
if( w <= 0 || w > frame->width ) w = frame->width;
|
|
if( h <= 0 || h > frame->height ) h = frame->height;
|
|
|
|
if(( xl & 0x07 ) || ( yl & 0x07 ) || ( w & 0x07 ) || ( h & 0x07 ))
|
|
{
|
|
if( need_resample )
|
|
resampled = Image_Process( &frame, resample_w, resample_h, IMAGE_RESAMPLE );
|
|
if( !resampled ) MsgDev( D_NOTE, "frame dimensions not multiples of 8\n" );
|
|
}
|
|
if(( w > MAX_FRAME_DIM ) || ( h > MAX_FRAME_DIM ))
|
|
Sys_Break( "sprite has a dimension longer than %d\n", MAX_FRAME_DIM );
|
|
|
|
// get interval
|
|
if( Com_ReadFloat( spriteqc, false, &frames[framecount].interval ))
|
|
{
|
|
frames[framecount].interval = bound( MIN_INTERVAL, frames[framecount].interval, MAX_INTERVAL );
|
|
|
|
}
|
|
else if( frameinterval != 0 )
|
|
{
|
|
frames[framecount].interval = frameinterval;
|
|
}
|
|
else
|
|
{
|
|
// use default interval
|
|
frames[framecount].interval = (float)0.05f;
|
|
}
|
|
|
|
if(Com_ReadLong( spriteqc, false, &org_x ))
|
|
{
|
|
org_x = -org_x; // inverse x coord
|
|
Com_ReadLong( spriteqc, false, &org_y );
|
|
}
|
|
else if((origin_x != 0) && (origin_y != 0))
|
|
{
|
|
// write shared origin
|
|
org_x = -origin_x;
|
|
org_y = origin_y;
|
|
}
|
|
else
|
|
{
|
|
// use center of image
|
|
org_x = -(w>>1);
|
|
org_y = h>>1;
|
|
}
|
|
|
|
// merge all sprite info
|
|
if( need_resample && resampled )
|
|
{
|
|
// check for org[n] == size[n] and org[n] == size[n]/2
|
|
// another cases will be not changed
|
|
if( org_x == -w ) org_x = -frame->width;
|
|
else if( org_x == -(w>>1)) org_x = -frame->width>>1;
|
|
if( org_y == h ) org_y = frame->height;
|
|
else if( org_y == (h>>1)) org_y = frame->height>>1;
|
|
w = frame->width;
|
|
h = frame->height;
|
|
}
|
|
|
|
xh = xl + w;
|
|
yh = yl + h;
|
|
|
|
plump = (byte *)Mem_Alloc( spritepool, sizeof(dspriteframe_t) + (w * h));
|
|
pframe = (dspriteframe_t *)plump;
|
|
frames[framecount].pdata = plump;
|
|
frames[framecount].type = FRAME_SINGLE;
|
|
|
|
pframe->origin[0] = org_x;
|
|
pframe->origin[1] = org_y;
|
|
pframe->width = w;
|
|
pframe->height = h;
|
|
|
|
// adjust maxsize
|
|
if(w > sprite.bounds[0]) sprite.bounds[0] = w;
|
|
if(h > sprite.bounds[1]) sprite.bounds[1] = h;
|
|
|
|
plump = (byte *)(pframe + 1); // move pointer
|
|
fin = frame->buffer + yl * frame->width + xl;
|
|
linedelta = frame->width - w;
|
|
|
|
// apply scissor to source
|
|
for( y = yl; y < yh; y++ )
|
|
{
|
|
for( x = xl; x < xh; x++ )
|
|
*plump++ = *fin++;
|
|
fin += linedelta;
|
|
}
|
|
framecount++;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Cmd_SpriteUnknown
|
|
|
|
syntax: "blabla"
|
|
==============
|
|
*/
|
|
void Cmd_SpriteUnknown( const char *token )
|
|
{
|
|
MsgDev( D_WARN, "Cmd_SpriteUnknown: bad command %s\n", token );
|
|
Com_SkipRestOfLine( spriteqc );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Group
|
|
|
|
syntax:
|
|
$group or $angled
|
|
{
|
|
$load fire01.bmp
|
|
$frame xoffset yoffset width height <interval> <origin x> <origin y>
|
|
$load fire02.bmp
|
|
$frame xoffset yoffset width height <interval> <origin x> <origin y>"
|
|
$load fire03.bmp
|
|
$frame xoffset yoffset width height <interval> <origin x> <origin y>
|
|
}
|
|
===============
|
|
*/
|
|
void Cmd_Group( qboolean angled )
|
|
{
|
|
int groupframe;
|
|
int is_started = 0;
|
|
token_t token;
|
|
|
|
groupframe = framecount++;
|
|
|
|
frames[groupframe].type = angled ? FRAME_ANGLED : FRAME_GROUP;
|
|
need_resample = resample_w = resample_h = 0; // invalidate resample for group
|
|
frames[groupframe].numgroupframes = 0;
|
|
|
|
while( 1 )
|
|
{
|
|
if( !Com_ReadToken( spriteqc, SC_ALLOW_NEWLINES|SC_PARSE_GENERIC, &token ))
|
|
{
|
|
if( is_started ) Sys_Break( "missing }\n" );
|
|
break;
|
|
}
|
|
|
|
if( !com.stricmp( token.string, "{" )) is_started = 1;
|
|
else if( !com.stricmp( token.string, "groupstart" )) is_started = 1;
|
|
else if( !com.stricmp( token.string, "groupend" )) break; // end of group
|
|
else if( !com.stricmp( token.string, "}" )) break; // end of group
|
|
else if( !com.stricmp( token.string, "$framerate" )) Cmd_Framerate();
|
|
else if( !com.stricmp( token.string, "$resample" )) Cmd_Resample();
|
|
else if( !com.stricmp( token.string, "$frame" ))
|
|
{
|
|
Cmd_Frame();
|
|
frames[groupframe].numgroupframes++;
|
|
}
|
|
else if( !com.stricmp( token.string, "$load" )) Cmd_Load();
|
|
else if( is_started ) Sys_Break( "missing }\n" );
|
|
else Cmd_SpriteUnknown( token.string ); // skip unknown commands
|
|
}
|
|
if( frames[groupframe].numgroupframes == 0 )
|
|
{
|
|
// don't create blank groups, rewind frames
|
|
framecount--, sprite.numframes--;
|
|
MsgDev( D_WARN, "Cmd_Group: remove blank group\n" );
|
|
}
|
|
else if( angled && frames[groupframe].numgroupframes != 8 )
|
|
{
|
|
// don't create blank groups, rewind frames
|
|
framecount--, sprite.numframes--;
|
|
MsgDev(D_WARN, "Cmd_Group: Remove angled group with invalid framecount\n" );
|
|
}
|
|
|
|
// back to single frames, invalidate resample
|
|
need_resample = resample_w = resample_h = 0;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
Cmd_Origin
|
|
|
|
syntax: $origin "x_pos y_pos"
|
|
===============
|
|
*/
|
|
static void Cmd_Origin( void )
|
|
{
|
|
Com_ReadLong( spriteqc, false, &origin_x );
|
|
Com_ReadLong( spriteqc, false, &origin_y );
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
Cmd_Rand
|
|
|
|
syntax: $rand
|
|
===============
|
|
*/
|
|
static void Cmd_Rand( void )
|
|
{
|
|
sprite.synctype = ST_RAND;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Cmd_Spritename
|
|
|
|
syntax: "$spritename outname"
|
|
==============
|
|
*/
|
|
void Cmd_Spritename( void )
|
|
{
|
|
Com_ReadString( spriteqc, false, spriteoutname );
|
|
FS_DefaultExtension( spriteoutname, ".spr" );
|
|
}
|
|
|
|
void ResetSpriteInfo( void )
|
|
{
|
|
// set default sprite parms
|
|
spriteoutname[0] = 0;
|
|
FS_FileBase( gs_filename, spriteoutname );
|
|
FS_DefaultExtension( spriteoutname, ".spr" );
|
|
|
|
Mem_Set( &sprite, 0, sizeof( sprite ));
|
|
Mem_Set( frames, 0, sizeof( frames ));
|
|
framecount = origin_x = origin_y = 0;
|
|
frameinterval = 0.0f;
|
|
|
|
sprite.bounds[0] = -9999;
|
|
sprite.bounds[1] = -9999;
|
|
sprite.ident = IDSPRITEHEADER;
|
|
sprite.version = SPRITE_VERSION;
|
|
sprite.type = SPR_FWD_PARALLEL;
|
|
sprite.facetype = SPR_CULL_FRONT;
|
|
sprite.synctype = ST_SYNC;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
ParseScript
|
|
===============
|
|
*/
|
|
qboolean ParseSpriteScript( void )
|
|
{
|
|
token_t token;
|
|
|
|
ResetSpriteInfo();
|
|
|
|
while( 1 )
|
|
{
|
|
if( !Com_ReadToken( spriteqc, SC_ALLOW_NEWLINES|SC_PARSE_GENERIC, &token )) break;
|
|
if( !com.stricmp( token.string, "$spritename" )) Cmd_Spritename();
|
|
else if( !com.stricmp( token.string, "$noresample" )) Cmd_NoResample();
|
|
else if( !com.stricmp( token.string, "$resample" )) Cmd_Resample();
|
|
else if( !com.stricmp( token.string, "$texture" )) Cmd_RenderMode();
|
|
else if( !com.stricmp( token.string, "$facetype" )) Cmd_FaceType();
|
|
else if( !com.stricmp( token.string, "$origin" )) Cmd_Origin();
|
|
else if( !com.stricmp( token.string, "$rand" )) Cmd_Rand();
|
|
else if( !com.stricmp( token.string, "$load" )) Cmd_Load();
|
|
else if( !com.stricmp( token.string, "$type" )) Cmd_Type();
|
|
else if( !com.stricmp( token.string, "$frame" ))
|
|
{
|
|
Cmd_Frame();
|
|
sprite.numframes++;
|
|
}
|
|
else if( !com.stricmp( token.string, "$group" ))
|
|
{
|
|
Cmd_Group( false );
|
|
sprite.numframes++;
|
|
}
|
|
else if( !com.stricmp( token.string, "$angled" ))
|
|
{
|
|
Cmd_Group( true );
|
|
sprite.numframes++;
|
|
}
|
|
else if( !Com_ValidScript( token.string, QC_SPRITEGEN )) return false;
|
|
else Cmd_SpriteUnknown( token.string );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
qboolean CompileCurrentSprite( const char *name )
|
|
{
|
|
if( name ) com.strcpy( gs_filename, name );
|
|
FS_DefaultExtension( gs_filename, ".qc" );
|
|
spriteqc = Com_OpenScript( gs_filename, NULL, 0 );
|
|
|
|
if( spriteqc )
|
|
{
|
|
if(!ParseSpriteScript())
|
|
return false;
|
|
return WriteSPRFile();
|
|
}
|
|
|
|
Msg( "%s not found\n", gs_filename );
|
|
return false;
|
|
}
|
|
|
|
qboolean CompileSpriteModel( byte *mempool, const char *name, byte parms )
|
|
{
|
|
if( mempool ) spritepool = mempool;
|
|
else
|
|
{
|
|
MsgDev( D_ERROR, "can't allocate memory pool.\nAbort compilation\n");
|
|
return false;
|
|
}
|
|
return CompileCurrentSprite( name );
|
|
} |