/*
===============
Cmd_Skin
Skins aren't actually stored in the file, only a reference
is saved out to the header file.
===============
*/
static void process_skin(char *name, char *savename)
{
byte *palette;
byte *pixels;
int width, height;
byte *cropped;
int y;
// load the image
printf ("loading %s\n", name);
Load256Image (name, &pixels, &palette, &width, &height);
RemapZero (pixels, palette, width, height);
// crop it to the proper size
cropped = malloc (model.skinwidth*model.skinheight);
for (y=0 ; y<model.skinheight ; y++)
{
memcpy (cropped+y*model.skinwidth,
pixels+y*width, model.skinwidth);
}
// save off the new image
printf ("saving %s\n", savename);
CreatePath (savename);
WritePCXfile (savename, cropped, model.skinwidth,
model.skinheight, palette);
free (pixels);
free (palette);
free (cropped);
}
/*
==================
SCR_ScreenShot_f
==================
*/
void SCR_ScreenShot_f (void)
{
int i;
char pcxname[80];
char checkname[MAX_OSPATH];
//
// find a file name to save it to
//
#if defined (__APPLE__) || defined (MACOSX)
qboolean success = false;
strcpy(pcxname,"quake00.png");
#else
strcpy(pcxname,"quake00.pcx");
#endif /* __APPLE__ || MACOSX */
for (i=0 ; i<=99 ; i++)
{
pcxname[5] = i/10 + '0';
pcxname[6] = i%10 + '0';
#if defined (__APPLE__) || defined (MACOSX)
snprintf (checkname, MAX_OSPATH, "%s/%s", com_gamedir, pcxname);
#else
sprintf (checkname, "%s/%s", com_gamedir, pcxname);
#endif /* __APPLE__ || MACOSX */
if (Sys_FileTime(checkname) == -1)
break; // file doesn't exist
}
if (i==100)
{
#if defined (__APPLE__) || defined (MACOSX)
Con_Printf ("SCR_ScreenShot_f: Couldn't create a PNG file\n");
#else
Con_Printf ("SCR_ScreenShot_f: Couldn't create a PCX file\n");
#endif /* __APPLE__ || MACOSX */
return;
}
//
// save the pcx file
//
D_EnableBackBufferAccess (); // enable direct drawing of console to back
// buffer
#if defined (__APPLE__) || defined (MACOSX)
success = WritePNGFile (checkname, vid.buffer, vid.width, vid.height, vid.rowbytes, host_basepal);
D_DisableBackBufferAccess (); // for adapters that can't stay mapped in
// for linear writes all the time
if (success == true)
{
Con_Printf ("Wrote %s\n", pcxname);
}
#else
WritePCXfile (pcxname, vid.buffer, vid.width, vid.height, vid.rowbytes, host_basepal);
D_DisableBackBufferAccess (); // for adapters that can't stay mapped in
// for linear writes all the time
Con_Printf ("Wrote %s\n", pcxname);
#endif /* __APPLE__ ||ÊMACOSX */
}
//
// M_ScreenShot
//
void M_ScreenShot (void)
{
int i;
byte* linear;
char lbmname[12];
// munge planar buffer to linear
linear = screens[2];
I_ReadScreen (linear);
// find a file name to save it to
strcpy(lbmname,"DOOM00.pcx");
for (i=0 ; i<=99 ; i++)
{
lbmname[4] = i/10 + '0';
lbmname[5] = i%10 + '0';
if (access(lbmname,0) == -1)
break; // file doesn't exist
}
if (i==100)
I_Error ("M_ScreenShot: Couldn't create a PCX");
// save the pcx file
WritePCXfile (lbmname, linear,
SCREENWIDTH, SCREENHEIGHT,
(byte*)W_CacheLumpName ("PLAYPAL",PU_CACHE));
players[consoleplayer].message = "screen shot";
}
void M_ScreenShot (void)
{
int i;
byte *linear;
char lbmname[12];
byte *pal;
#ifdef _WATCOMC_
extern byte *pcscreen;
#endif
//
// munge planar buffer to linear
//
#ifdef _WATCOMC_
linear = pcscreen;
#else
linear = screen;
#endif
//
// find a file name to save it to
//
strcpy(lbmname,"HEXEN00.pcx");
for (i=0 ; i<=99 ; i++)
{
lbmname[5] = i/10 + '0';
lbmname[6] = i%10 + '0';
if (access(lbmname,0) == -1)
break; // file doesn't exist
}
if (i==100)
I_Error ("M_ScreenShot: Couldn't create a PCX");
//
// save the pcx file
//
#ifdef __WATCOMC__
pal = (byte *)Z_Malloc(768, PU_STATIC, NULL);
outp(0x3c7, 0);
for(i = 0; i < 768; i++)
{
*(pal+i) = inp(0x3c9)<<2;
}
#else
pal = (byte *)W_CacheLumpName("PLAYPAL", PU_CACHE);
#endif
WritePCXfile (lbmname, linear, SCREENWIDTH, SCREENHEIGHT
, pal);
P_SetMessage(&players[consoleplayer], "SCREEN SHOT", false);
#ifdef __WATCOMC__
Z_Free(pal);
#endif
}
/*
==============
Cmd_Grab
$grab filename x y width height
==============
*/
void Cmd_Grab( void ){
int xl,yl,w,h,y;
byte *cropped;
char savename[1024];
char dest[1024];
GetToken( qfalse );
if ( token[0] == '/' || token[0] == '\\' ) {
sprintf( savename, "%s%s.pcx", writedir, token + 1 );
}
else{
sprintf( savename, "%spics/%s.pcx", writedir, token );
}
if ( g_release ) {
if ( token[0] == '/' || token[0] == '\\' ) {
sprintf( dest, "%s.pcx", token + 1 );
}
else{
sprintf( dest, "pics/%s.pcx", token );
}
ReleaseFile( dest );
return;
}
GetToken( qfalse );
xl = atoi( token );
GetToken( qfalse );
yl = atoi( token );
GetToken( qfalse );
w = atoi( token );
GetToken( qfalse );
h = atoi( token );
if ( xl < 0 || yl < 0 || w < 0 || h < 0 || xl + w > byteimagewidth || yl + h > byteimageheight ) {
Error( "GrabPic: Bad size: %i, %i, %i, %i",xl,yl,w,h );
}
// crop it to the proper size
cropped = malloc( w * h );
for ( y = 0 ; y < h ; y++ )
{
memcpy( cropped + y * w, byteimage + ( y + yl ) * byteimagewidth + xl, w );
}
// save off the new image
printf( "saving %s\n", savename );
CreatePath( savename );
WritePCXfile( savename, cropped, w, h, lbmpalette );
free( cropped );
}
/*
==================
R_ScreenShot_f
==================
*/
void R_ScreenShot_f (void)
{
int i;
char pcxname[80];
char checkname[MAX_OSPATH];
FILE *f;
byte palette[768];
// create the scrnshots directory if it doesn't exist
Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot", ri.FS_Gamedir());
Sys_Mkdir (checkname);
//
// find a file name to save it to
//
strcpy(pcxname,"quake00.pcx");
for (i=0 ; i<=99 ; i++)
{
pcxname[5] = i/10 + '0';
pcxname[6] = i%10 + '0';
Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot/%s", ri.FS_Gamedir(), pcxname);
f = fopen (checkname, "r");
if (!f)
break; // file doesn't exist
fclose (f);
}
if (i==100)
{
ri.Con_Printf (PRINT_ALL, "R_ScreenShot_f: Couldn't create a PCX");
return;
}
// turn the current 32 bit palette into a 24 bit palette
for (i=0 ; i<256 ; i++)
{
palette[i*3+0] = sw_state.currentpalette[i*4+0];
palette[i*3+1] = sw_state.currentpalette[i*4+1];
palette[i*3+2] = sw_state.currentpalette[i*4+2];
}
//
// save the pcx file
//
WritePCXfile (checkname, vid.buffer, vid.width, vid.height, vid.rowbytes,
palette);
ri.Con_Printf (PRINT_ALL, "Wrote %s\n", checkname);
}
/*
=================
Cmd_Environment
=================
*/
void Cmd_Environment( void ){
char name[1024];
int i, x, y;
byte image[256 * 256];
byte *tga;
GetToken( qfalse );
if ( g_release ) {
for ( i = 0 ; i < 6 ; i++ )
{
sprintf( name, "env/%s%s.pcx", token, suf[i] );
ReleaseFile( name );
sprintf( name, "env/%s%s.tga", token, suf[i] );
ReleaseFile( name );
}
return;
}
// get the palette
BuildPalmap();
sprintf( name, "%senv/", gamedir );
CreatePath( name );
// convert the images
for ( i = 0 ; i < 6 ; i++ )
{
sprintf( name, "%senv/%s%s.tga", gamedir, token, suf[i] );
printf( "loading %s...\n", name );
LoadTGA( name, &tga, NULL, NULL );
for ( y = 0 ; y < 256 ; y++ )
{
for ( x = 0 ; x < 256 ; x++ )
{
image[y * 256 + x] = FindColor( tga[( y * 256 + x ) * 4 + 0],tga[( y * 256 + x ) * 4 + 1],tga[( y * 256 + x ) * 4 + 2] );
}
}
free( tga );
sprintf( name, "%senv/%s%s.pcx", writedir, token, suf[i] );
if ( FileTime( name ) != -1 ) {
printf( "%s already exists, not overwriting.\n", name );
}
else{
WritePCXfile( name, image, 256, 256, colormap_palette );
}
}
}
/*
==============
Save256Image
Will save either an lbm or pcx, depending on extension.
==============
*/
void Save256Image(const char *name, byte * pixels, byte * palette, int width, int height)
{
char ext[128];
ExtractFileExtension(name, ext);
if(!Q_stricmp(ext, "lbm"))
{
WriteLBMfile(name, pixels, width, height, palette);
}
else if(!Q_stricmp(ext, "pcx"))
{
WritePCXfile(name, pixels, width, height, palette);
}
else
Error("%s doesn't have a known image extension", name);
}
/*
==================
SCR_ScreenShot_f
==================
*/
void SCR_ScreenShot_f (void)
{
int i;
char pcxname[80];
char checkname[MAX_OSPATH];
sprintf (checkname, "%s/shots", com_gamedir);
Sys_mkdir (checkname);
//
// find a file name to save it to
//
strcpy(pcxname,"shots/hexen00.pcx");
for (i=0 ; i<=99 ; i++)
{
pcxname[11] = i/10 + '0';
pcxname[12] = i%10 + '0';
sprintf (checkname, "%s/%s", com_gamedir, pcxname);
if (Sys_FileTime(checkname) == -1)
break; // file doesn't exist
}
if (i==100)
{
Con_Printf ("SCR_ScreenShot_f: Couldn't create a PCX file\n");
return;
}
//
// save the pcx file
//
D_EnableBackBufferAccess (); // enable direct drawing of console to back
// buffer
WritePCXfile (pcxname, vid.buffer, vid.width, vid.height, vid.rowbytes,
host_basepal);
D_DisableBackBufferAccess (); // for adapters that can't stay mapped in
// for linear writes all the time
Con_Printf ("Wrote %s\n", pcxname);
}
/*
SCR_ScreenShot_f
*/
void
SCR_ScreenShot_f (void)
{
char pcxname[MAX_OSPATH];
// find a file name to save it to
if (!COM_NextFilename (pcxname, "qf", ".pcx")) {
Con_Printf ("SCR_ScreenShot_f: Couldn't create a PCX");
return;
}
// enable direct drawing of console to back buffer
D_EnableBackBufferAccess ();
// save the pcx file
WritePCXfile (pcxname, vid.buffer, vid.width, vid.height, vid.rowbytes,
host_basepal, false, false);
// for adapters that can't stay mapped in for linear writes all the time
D_DisableBackBufferAccess ();
Con_Printf ("Wrote %s\n", pcxname);
}
//-----------------------------------------------------------------------------
//
// M_ScreenShot
//
void M_ScreenShot (void)
{
int i;
byte* linear;
char pcxname [6];
char lbmname [80];
// munge planar buffer to linear
linear = screens[2];
I_ReadScreen (linear);
// I only want the first four characters as I now use a four digit index...
memcpy (pcxname, screenshot_messages[SC_FILENAME], 4);
pcxname [4] = 0;
// find a file name to save it to
i=~0;
do
{
i++;
sprintf (lbmname, "%s"DIRSEP"%s%04u"EXTSEP"pcx", basedefaultdir, pcxname, i);
} while (access(lbmname,0) != -1); // file doesn't exist
// save the pcx file
WritePCXfile (lbmname, linear,
SCREENWIDTH, SCREENHEIGHT,
W_CacheLumpName ("PLAYPAL",PU_CACHE));
#ifdef __riscos
set_riscos_filetype (lbmname, 0x697);
#endif
players[consoleplayer].message = HU_printf ("%s - %s", screenshot_messages[SC_MESSAGE], lbmname);
#ifdef NORMALUNIX
printf ("%s\n", players[consoleplayer].message);
#endif
}
/*
SCR_RSShot_f
*/
void
SCR_RSShot_f (void)
{
int x, y;
unsigned char *src, *dest;
char pcxname[80];
unsigned char *newbuf;
int w, h;
int dx, dy, dex, dey, nx;
int r, b, g;
int count;
float fracw, frach;
char st[80];
time_t now;
if (CL_IsUploading ())
return; // already one pending
if (cls.state < ca_onserver)
return; // gotta be connected
Con_Printf ("Remote screen shot requested.\n");
snprintf (pcxname, sizeof (pcxname), "rss.pcx");
//
// save the pcx file
//
D_EnableBackBufferAccess (); // enable direct drawing of console
// to back
// buffer
w = (vid.width < RSSHOT_WIDTH) ? vid.width : RSSHOT_WIDTH;
h = (vid.height < RSSHOT_HEIGHT) ? vid.height : RSSHOT_HEIGHT;
fracw = (float) vid.width / (float) w;
frach = (float) vid.height / (float) h;
newbuf = calloc (1, w * h);
for (y = 0; y < h; y++) {
dest = newbuf + (w * y);
for (x = 0; x < w; x++) {
r = g = b = 0;
dx = x * fracw;
dex = (x + 1) * fracw;
if (dex == dx)
dex++; // at least one
dy = y * frach;
dey = (y + 1) * frach;
if (dey == dy)
dey++; // at least one
count = 0;
for ( /* */ ; dy < dey; dy++) {
src = vid.buffer + (vid.rowbytes * dy) + dx;
for (nx = dx; nx < dex; nx++) {
r += host_basepal[*src * 3];
g += host_basepal[*src * 3 + 1];
b += host_basepal[*src * 3 + 2];
src++;
count++;
}
}
r /= count;
g /= count;
b /= count;
*dest++ = MipColor (r, g, b);
}
}
time (&now);
strcpy (st, ctime (&now));
st[strlen (st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen (st) * 8, 0, w);
strncpy (st, cls.servername, sizeof (st));
st[sizeof (st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen (st) * 8, 10, w);
strncpy (st, name->string, sizeof (st));
st[sizeof (st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen (st) * 8, 20, w);
WritePCXfile (pcxname, newbuf, w, h, w, host_basepal, true, false);
free (newbuf);
D_DisableBackBufferAccess (); // for adapters that can't stay
// mapped in
// for linear writes all the time
Con_Printf ("Wrote %s\n", pcxname);
Con_Printf ("Sending shot to server...\n");
}
/*
SCR_RSShot_f
*/
void
SCR_RSShot_f (void)
{
int x, y;
unsigned char *src, *dest;
char pcxname[80];
unsigned char *newbuf;
int w, h;
int dx, dy, dex, dey, nx;
int r, b, g;
int count;
float fracw, frach;
char st[80];
time_t now;
if (CL_IsUploading ())
return; // already one pending
if (cls.state < ca_onserver)
return; // gotta be connected
Con_Printf ("Remote screen shot requested.\n");
snprintf (pcxname, sizeof (pcxname), "rss.pcx");
//
// save the pcx file
//
newbuf = malloc (glheight * glwidth * 3);
glReadPixels (glx, gly, glwidth, glheight, GL_RGB, GL_UNSIGNED_BYTE,
newbuf);
w = (vid.width < RSSHOT_WIDTH) ? glwidth : RSSHOT_WIDTH;
h = (vid.height < RSSHOT_HEIGHT) ? glheight : RSSHOT_HEIGHT;
fracw = (float) glwidth / (float) w;
frach = (float) glheight / (float) h;
for (y = 0; y < h; y++) {
dest = newbuf + (w * 3 * y);
for (x = 0; x < w; x++) {
r = g = b = 0;
dx = x * fracw;
dex = (x + 1) * fracw;
if (dex == dx)
dex++; // at least one
dy = y * frach;
dey = (y + 1) * frach;
if (dey == dy)
dey++; // at least one
count = 0;
for ( /* */ ; dy < dey; dy++) {
src = newbuf + (glwidth * 3 * dy) + dx * 3;
for (nx = dx; nx < dex; nx++) {
r += *src++;
g += *src++;
b += *src++;
count++;
}
}
r /= count;
g /= count;
b /= count;
*dest++ = r;
*dest++ = b;
*dest++ = g;
}
}
// convert to eight bit
for (y = 0; y < h; y++) {
src = newbuf + (w * 3 * y);
dest = newbuf + (w * y);
for (x = 0; x < w; x++) {
*dest++ = MipColor (src[0], src[1], src[2]);
src += 3;
}
}
time (&now);
strcpy (st, ctime (&now));
st[strlen (st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen (st) * 8, h - 1, w);
strncpy (st, cls.servername, sizeof (st));
st[sizeof (st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen (st) * 8, h - 11, w);
strncpy (st, name->string, sizeof (st));
st[sizeof (st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - strlen (st) * 8, h - 21, w);
WritePCXfile (pcxname, newbuf, w, h, w, host_basepal, true, true);
free (newbuf);
Con_Printf ("Wrote %s\n", pcxname);
Con_Printf ("Sending shot to server...\n");
}
/*
===============
Cmd_SpriteFrame
===============
*/
void Cmd_SpriteFrame( void ){
int y,xl,yl,xh,yh,w,h;
dsprframe_t *pframe;
int ox, oy;
byte *cropped;
char savename[1024];
GetToken( false );
xl = atoi( token );
GetToken( false );
yl = atoi( token );
GetToken( false );
w = atoi( token );
GetToken( false );
h = atoi( token );
// origin offset is optional
if ( TokenAvailable() ) {
GetToken( false );
ox = atoi( token );
GetToken( false );
oy = atoi( token );
}
else
{
ox = w / 2;
oy = h / 2;
}
if ( ( xl & 0x07 ) || ( yl & 0x07 ) || ( w & 0x07 ) || ( h & 0x07 ) ) {
Error( "Sprite dimensions not multiples of 8\n" );
}
if ( ( w > 256 ) || ( h > 256 ) ) {
Error( "Sprite has a dimension longer than 256" );
}
xh = xl + w;
yh = yl + h;
if ( sprite.numframes >= MAX_SPRFRAMES ) {
Error( "Too many frames; increase MAX_SPRFRAMES\n" );
}
pframe = &frames[sprite.numframes];
pframe->width = w;
pframe->height = h;
pframe->origin_x = ox;
pframe->origin_y = oy;
sprintf( pframe->name, "%s_%i.pcx", spritename, sprite.numframes );
sprintf( savename, "%s%s_%i.pcx", gamedir, spritename, sprite.numframes );
sprite.numframes++;
if ( g_release ) {
ReleaseFile( pframe->name );
return;
}
// crop it to the proper size
cropped = malloc( w * h );
for ( y = 0 ; y < h ; y++ )
{
memcpy( cropped + y * w, byteimage + ( y + yl ) * byteimagewidth + xl, w );
}
// save off the new image
printf( "saving %s\n", savename );
CreatePath( savename );
WritePCXfile( savename, cropped, w, h, lbmpalette );
free( cropped );
}
/*
==============
Cmd_Colormap
$colormap filename
the brightes colormap is first in the table (FIXME: reverse this now?)
64 rows of 256 : lightmaps
256 rows of 256 : translucency table
==============
*/
void Cmd_Colormap( void ){
int levels, brights;
int l, c;
float frac, red, green, blue;
float range;
byte *cropped, *lump_p;
char savename[1024];
char dest[1024];
colormap_issued = qtrue;
if ( !g_release ) {
memcpy( colormap_palette, lbmpalette, 768 );
}
if ( !TokenAvailable() ) { // just setting colormap_issued
return;
}
GetToken( qfalse );
sprintf( savename, "%spics/%s.pcx", writedir, token );
if ( g_release ) {
sprintf( dest, "pics/%s.pcx", token );
ReleaseFile( dest );
return;
}
range = 2;
levels = 64;
brights = 1; // ignore 255 (transparent)
cropped = malloc( ( levels + 256 ) * 256 );
lump_p = cropped;
// shaded levels
for ( l = 0; l < levels; l++ )
{
frac = range - range * (float)l / ( levels - 1 );
for ( c = 0 ; c < 256 - brights ; c++ )
{
red = lbmpalette[c * 3];
green = lbmpalette[c * 3 + 1];
blue = lbmpalette[c * 3 + 2];
red = (int)( red * frac + 0.5 );
green = (int)( green * frac + 0.5 );
blue = (int)( blue * frac + 0.5 );
//
// note: 254 instead of 255 because 255 is the transparent color, and we
// don't want anything remapping to that
// don't use color 0, because NT can't remap that (or 255)
//
*lump_p++ = BestColor( red,green,blue, 1, 254 );
}
// fullbrights allways stay the same
for ( ; c < 256 ; c++ )
*lump_p++ = c;
}
// 66% transparancy table
for ( l = 0; l < 255; l++ )
{
for ( c = 0 ; c < 255 ; c++ )
{
red = lbmpalette[c * 3] * 0.33 + lbmpalette[l * 3] * 0.66;
green = lbmpalette[c * 3 + 1] * 0.33 + lbmpalette[l * 3 + 1] * 0.66;
blue = lbmpalette[c * 3 + 2] * 0.33 + lbmpalette[l * 3 + 2] * 0.66;
*lump_p++ = BestColor( red,green,blue, 1, 254 );
}
*lump_p++ = 255;
}
for ( c = 0 ; c < 256 ; c++ )
*lump_p++ = 255;
// save off the new image
printf( "saving %s\n", savename );
CreatePath( savename );
WritePCXfile( savename, cropped, 256, levels + 256, lbmpalette );
free( cropped );
}
void M_ScreenShot (const char *filename)
{
FILE *file;
FString autoname;
bool writepcx = (stricmp (screenshot_type, "pcx") == 0); // PNG is the default
// find a file name to save it to
if (filename == NULL || filename[0] == '\0')
{
#if !defined(unix) && !defined(__APPLE__)
if (Args->CheckParm ("-cdrom"))
{
autoname = CDROM_DIR "\\";
}
else
#endif
{
size_t dirlen;
autoname = Args->CheckValue("-shotdir");
if (autoname.IsEmpty())
{
autoname = screenshot_dir;
}
dirlen = autoname.Len();
if (dirlen == 0)
{
#ifdef unix
autoname = "~/" GAME_DIR "/screenshots/";
#elif defined(__APPLE__)
char cpath[PATH_MAX];
FSRef folder;
if (noErr == FSFindFolder(kUserDomain, kDocumentsFolderType, kCreateFolder, &folder) &&
noErr == FSRefMakePath(&folder, (UInt8*)cpath, PATH_MAX))
{
autoname << cpath << "/" GAME_DIR "/Screenshots/";
}
else
{
autoname = "~";
}
#else
autoname = progdir;
#endif
}
else if (dirlen > 0)
{
if (autoname[dirlen-1] != '/' && autoname[dirlen-1] != '\\')
{
autoname += '/';
}
}
}
autoname = NicePath(autoname);
CreatePath(autoname);
if (!FindFreeName (autoname, writepcx ? "pcx" : "png"))
{
Printf ("M_ScreenShot: Delete some screenshots\n");
return;
}
}
else
{
autoname = filename;
DefaultExtension (autoname, writepcx ? ".pcx" : ".png");
}
// save the screenshot
const BYTE *buffer;
int pitch;
ESSType color_type;
screen->GetScreenshotBuffer(buffer, pitch, color_type);
if (buffer != NULL)
{
PalEntry palette[256];
if (color_type == SS_PAL)
{
screen->GetFlashedPalette(palette);
}
file = fopen (autoname, "wb");
if (file == NULL)
{
Printf ("Could not open %s\n", autoname.GetChars());
screen->ReleaseScreenshotBuffer();
return;
}
if (writepcx)
{
WritePCXfile(file, buffer, palette, color_type,
screen->GetWidth(), screen->GetHeight(), pitch);
}
else
{
WritePNGfile(file, buffer, palette, color_type,
screen->GetWidth(), screen->GetHeight(), pitch);
}
fclose(file);
screen->ReleaseScreenshotBuffer();
if (!screenshot_quiet)
{
int slash = -1;
if (!longsavemessages) slash = autoname.LastIndexOfAny(":/\\");
Printf ("Captured %s\n", autoname.GetChars()+slash+1);
}
}
else
{
if (!screenshot_quiet)
{
Printf ("Could not create screenshot.\n");
}
}
}
void M_ScreenShot (const char *filename)
{
FileWriter *file;
FString autoname;
bool writepcx = (stricmp (screenshot_type, "pcx") == 0); // PNG is the default
// find a file name to save it to
if (filename == NULL || filename[0] == '\0')
{
size_t dirlen;
autoname = Args->CheckValue("-shotdir");
if (autoname.IsEmpty())
{
autoname = screenshot_dir;
}
dirlen = autoname.Len();
if (dirlen == 0)
{
autoname = M_GetScreenshotsPath();
dirlen = autoname.Len();
}
if (dirlen > 0)
{
if (autoname[dirlen-1] != '/' && autoname[dirlen-1] != '\\')
{
autoname += '/';
}
}
autoname = NicePath(autoname);
CreatePath(autoname);
if (!FindFreeName (autoname, writepcx ? "pcx" : "png"))
{
Printf ("M_ScreenShot: Delete some screenshots\n");
return;
}
}
else
{
autoname = filename;
DefaultExtension (autoname, writepcx ? ".pcx" : ".png");
}
// save the screenshot
const BYTE *buffer;
int pitch;
ESSType color_type;
screen->GetScreenshotBuffer(buffer, pitch, color_type);
if (buffer != NULL)
{
PalEntry palette[256];
if (color_type == SS_PAL)
{
screen->GetFlashedPalette(palette);
}
file = FileWriter::Open(autoname);
if (file == NULL)
{
Printf ("Could not open %s\n", autoname.GetChars());
screen->ReleaseScreenshotBuffer();
return;
}
if (writepcx)
{
WritePCXfile(file, buffer, palette, color_type,
screen->GetWidth(), screen->GetHeight(), pitch);
}
else
{
WritePNGfile(file, buffer, palette, color_type,
screen->GetWidth(), screen->GetHeight(), pitch);
}
delete file;
screen->ReleaseScreenshotBuffer();
if (!screenshot_quiet)
{
int slash = -1;
if (!longsavemessages) slash = autoname.LastIndexOfAny(":/\\");
Printf ("Captured %s\n", autoname.GetChars()+slash+1);
}
}
else
{
if (!screenshot_quiet)
{
Printf ("Could not create screenshot.\n");
}
}
}
/*
==================
SCR_RSShot_f
==================
*/
void SCR_RSShot_f (void)
{
int x, y;
unsigned char *src, *dest;
char pcxname[80];
#if 0
int i;
char checkname[MAX_OSPATH];
#endif
unsigned char *newbuf; //, *srcbuf;
// int srcrowbytes;
int w, h;
int dx, dy, dex, dey, nx;
int r, b, g;
int count;
float fracw, frach;
char st[80];
time_t now;
if (CL_IsUploading())
return; // already one pending
if (cls.state < ca_onserver)
return; // gotta be connected
if (!scr_allowsnap.value) {
MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
SZ_Print (&cls.netchan.message, "snap\n");
Con_Printf("Refusing remote screen shot request.\n");
return;
}
Con_Printf("Remote screen shot requested.\n");
#if 0
//
// find a file name to save it to
//
strcpy(pcxname,"mquake00.pcx");
for (i=0 ; i<=99 ; i++)
{
pcxname[6] = i/10 + '0';
pcxname[7] = i%10 + '0';
#if defined (__APPLE__) || defined (MACOSX)
snprintf (checkname, MAX_OSPATH, "%s/%s", com_gamedir, pcxname);
#else
sprintf (checkname, "%s/%s", com_gamedir, pcxname);
#endif /* __APPLE__ || MACOSX */
if (Sys_FileTime(checkname) == -1)
break; // file doesn't exist
}
if (i==100)
{
Con_Printf ("SCR_ScreenShot_f: Couldn't create a PCX");
return;
}
#endif
//
// save the pcx file
//
D_EnableBackBufferAccess (); // enable direct drawing of console to back
// buffer
w = (vid.width < RSSHOT_WIDTH) ? vid.width : RSSHOT_WIDTH;
h = (vid.height < RSSHOT_HEIGHT) ? vid.height : RSSHOT_HEIGHT;
fracw = (float)vid.width / (float)w;
frach = (float)vid.height / (float)h;
newbuf = malloc(w*h);
for (y = 0; y < h; y++) {
dest = newbuf + (w * y);
for (x = 0; x < w; x++) {
r = g = b = 0;
dx = x * fracw;
dex = (x + 1) * fracw;
if (dex == dx) dex++; // at least one
dy = y * frach;
dey = (y + 1) * frach;
if (dey == dy) dey++; // at least one
count = 0;
for (/* */; dy < dey; dy++) {
src = vid.buffer + (vid.rowbytes * dy) + dx;
for (nx = dx; nx < dex; nx++) {
r += host_basepal[*src * 3];
g += host_basepal[*src * 3+1];
b += host_basepal[*src * 3+2];
src++;
count++;
}
}
r /= count;
g /= count;
b /= count;
*dest++ = MipColor(r, g, b);
}
}
time(&now);
strcpy(st, ctime(&now));
st[strlen(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - ((int) strlen(st))*8, 0, w);
strncpy(st, cls.servername, sizeof(st));
st[sizeof(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - ((int) strlen(st))*8, 10, w);
strncpy(st, name.string, sizeof(st));
st[sizeof(st) - 1] = 0;
SCR_DrawStringToSnap (st, newbuf, w - ((int) strlen(st))*8, 20, w);
WritePCXfile (pcxname, newbuf, w, h, w, host_basepal, true);
free(newbuf);
D_DisableBackBufferAccess (); // for adapters that can't stay mapped in
// for linear writes all the time
// Con_Printf ("Wrote %s\n", pcxname);
Con_Printf ("Sending shot to server...\n");
}
/*
===============
Cmd_Skin
Skins aren't actually stored in the file, only a reference
is saved out to the header file.
===============
*/
void Cmd_Skin (void)
{
byte *palette;
byte *pixels;
int width, height;
byte *cropped;
int y;
char name[1024], savename[1024];
GetScriptToken (false);
if (model.num_skins == MAX_MD2SKINS)
Error ("model.num_skins == MAX_MD2SKINS");
if (g_skipmodel)
return;
#if 1
sprintf (name, "%s/%s.pcx", cddir, token);
sprintf (savename, "%s/!%s.pcx", g_outputDir, token);
sprintf (g_skins[model.num_skins], "%s/!%s.pcx", cdpartial, token);
#else
sprintf (name, "%s/%s.lbm", cdarchive, token);
strcpy (name, ExpandPathAndArchive( name ) );
// sprintf (name, "%s/%s.lbm", cddir, token);
if (ScriptTokenAvailable())
{
GetScriptToken (false);
sprintf (g_skins[model.num_skins], "%s.pcx", token);
sprintf (savename, "%s%s.pcx", g_outputDir, g_skins[model.num_skins]);
}
else
{
sprintf (savename, "%s/%s.pcx", g_outputDir, token);
sprintf (g_skins[model.num_skins], "%s/%s.pcx", cdpartial, token);
}
#endif
model.num_skins++;
if (g_skipmodel || g_release || g_archive)
return;
// load the image
printf ("loading %s\n", name);
Load256Image (name, &pixels, &palette, &width, &height);
// RemapZero (pixels, palette, width, height);
// crop it to the proper size
cropped = (byte *) SafeMalloc (model.skinwidth*model.skinheight, "Cmd_Skin");
for (y=0 ; y<model.skinheight ; y++)
{
memcpy (cropped+y*model.skinwidth,
pixels+y*width, model.skinwidth);
}
// save off the new image
printf ("saving %s\n", savename);
CreatePath (savename);
WritePCXfile (savename, cropped, model.skinwidth,
model.skinheight, palette);
free (pixels);
free (palette);
free (cropped);
}
/*
==================
R_ScreenShot_f
==================
*/
void R_ScreenShot_f (void)
{
int i;
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Allocating in big stack. Stack in this device is pretty small:
//char pcxname[80];
//char checkname[MAX_OSPATH];
//FILE *f;
//byte palette[768];
FILE *f;
char* pcxname = Sys_BigStackAlloc(80, "R_ScreenShot_f");
char* checkname = Sys_BigStackAlloc(MAX_OSPATH, "R_ScreenShot_f");
byte* palette = Sys_BigStackAlloc(768, "R_ScreenShot_f");
// <<< FIX
// create the scrnshots directory if it doesn't exist
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Adjusting for previous fix:
//Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot", ri.FS_Gamedir());
Com_sprintf (checkname, MAX_OSPATH, "%s/scrnshot", ri.FS_Gamedir());
// <<< FIX
Sys_Mkdir (checkname);
//
// find a file name to save it to
//
strcpy(pcxname,"quake00.pcx");
for (i=0 ; i<=99 ; i++)
{
pcxname[5] = i/10 + '0';
pcxname[6] = i%10 + '0';
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Adjusting for previous fix:
//Com_sprintf (checkname, sizeof(checkname), "%s/scrnshot/%s", ri.FS_Gamedir(), pcxname);
Com_sprintf (checkname, MAX_OSPATH, "%s/scrnshot/%s", ri.FS_Gamedir(), pcxname);
// <<< FIX
f = fopen (checkname, "r");
if (!f)
break; // file doesn't exist
fclose (f);
}
if (i==100)
{
ri.Con_Printf (PRINT_ALL, "R_ScreenShot_f: Couldn't create a PCX");
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Deallocating from previous fix:
Sys_BigStackFree(80 + MAX_OSPATH + 768, "R_ScreenShot_f");
// <<< FIX
return;
}
// turn the current 32 bit palette into a 24 bit palette
for (i=0 ; i<256 ; i++)
{
palette[i*3+0] = sw_state.currentpalette[i*4+0];
palette[i*3+1] = sw_state.currentpalette[i*4+1];
palette[i*3+2] = sw_state.currentpalette[i*4+2];
}
//
// save the pcx file
//
WritePCXfile (checkname, vid.buffer, vid.width, vid.height, vid.rowbytes,
palette);
ri.Con_Printf (PRINT_ALL, "Wrote %s\n", checkname);
// >>> FIX: For Nintendo Wii using devkitPPC / libogc
// Deallocating from previous fix:
Sys_BigStackFree(80 + MAX_OSPATH + 768, "R_ScreenShot_f");
// <<< FIX
}
