a1batross
/
Paranoia2_original
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity
Paranoia2_original/utils/hlsv/sprite_utils.cpp

569 lines
17 KiB
C++
Raw Permalink Blame History

/***
*
* Copyright (c) 1998, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
****/
// updates:
// 1-4-99 fixed file texture load and file read bug
////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gl.h>
#include <GL/glu.h>
#include "SpriteModel.h"
#include "GLWindow.h"
#include "ViewerSettings.h"
#include "stringlib.h"
#include <mx.h>
#include "sprviewer.h"
SpriteModel g_spriteModel;
extern bool bUseWeaponOrigin;
extern bool bUseWeaponLeftHand;
////////////////////////////////////////////////////////////////////////
// Quake1 always has same palette
byte palette_q1[768] =
{
0,0,0,15,15,15,31,31,31,47,47,47,63,63,63,75,75,75,91,91,91,107,107,107,123,123,123,139,139,139,155,155,155,171,
171,171,187,187,187,203,203,203,219,219,219,235,235,235,15,11,7,23,15,11,31,23,11,39,27,15,47,35,19,55,43,23,63,
47,23,75,55,27,83,59,27,91,67,31,99,75,31,107,83,31,115,87,31,123,95,35,131,103,35,143,111,35,11,11,15,19,19,27,
27,27,39,39,39,51,47,47,63,55,55,75,63,63,87,71,71,103,79,79,115,91,91,127,99,99,139,107,107,151,115,115,163,123,
123,175,131,131,187,139,139,203,0,0,0,7,7,0,11,11,0,19,19,0,27,27,0,35,35,0,43,43,7,47,47,7,55,55,7,63,63,7,71,71,
7,75,75,11,83,83,11,91,91,11,99,99,11,107,107,15,7,0,0,15,0,0,23,0,0,31,0,0,39,0,0,47,0,0,55,0,0,63,0,0,71,0,0,79,
0,0,87,0,0,95,0,0,103,0,0,111,0,0,119,0,0,127,0,0,19,19,0,27,27,0,35,35,0,47,43,0,55,47,0,67,55,0,75,59,7,87,67,7,
95,71,7,107,75,11,119,83,15,131,87,19,139,91,19,151,95,27,163,99,31,175,103,35,35,19,7,47,23,11,59,31,15,75,35,19,
87,43,23,99,47,31,115,55,35,127,59,43,143,67,51,159,79,51,175,99,47,191,119,47,207,143,43,223,171,39,239,203,31,255,
243,27,11,7,0,27,19,0,43,35,15,55,43,19,71,51,27,83,55,35,99,63,43,111,71,51,127,83,63,139,95,71,155,107,83,167,123,
95,183,135,107,195,147,123,211,163,139,227,179,151,171,139,163,159,127,151,147,115,135,139,103,123,127,91,111,119,
83,99,107,75,87,95,63,75,87,55,67,75,47,55,67,39,47,55,31,35,43,23,27,35,19,19,23,11,11,15,7,7,187,115,159,175,107,
143,163,95,131,151,87,119,139,79,107,127,75,95,115,67,83,107,59,75,95,51,63,83,43,55,71,35,43,59,31,35,47,23,27,35,
19,19,23,11,11,15,7,7,219,195,187,203,179,167,191,163,155,175,151,139,163,135,123,151,123,111,135,111,95,123,99,83,
107,87,71,95,75,59,83,63,51,67,51,39,55,43,31,39,31,23,27,19,15,15,11,7,111,131,123,103,123,111,95,115,103,87,107,
95,79,99,87,71,91,79,63,83,71,55,75,63,47,67,55,43,59,47,35,51,39,31,43,31,23,35,23,15,27,19,11,19,11,7,11,7,255,
243,27,239,223,23,219,203,19,203,183,15,187,167,15,171,151,11,155,131,7,139,115,7,123,99,7,107,83,0,91,71,0,75,55,
0,59,43,0,43,31,0,27,15,0,11,7,0,0,0,255,11,11,239,19,19,223,27,27,207,35,35,191,43,43,175,47,47,159,47,47,143,47,
47,127,47,47,111,47,47,95,43,43,79,35,35,63,27,27,47,19,19,31,11,11,15,43,0,0,59,0,0,75,7,0,95,7,0,111,15,0,127,23,
7,147,31,7,163,39,11,183,51,15,195,75,27,207,99,43,219,127,59,227,151,79,231,171,95,239,191,119,247,211,139,167,123,
59,183,155,55,199,195,55,231,227,87,127,191,255,171,231,255,215,255,255,103,0,0,139,0,0,179,0,0,215,0,0,255,0,0,255,
243,147,255,247,199,255,255,255,159,91,83
};
////////////////////////////////////////////////////////////////////////
static int g_tex_base = TEXTURE_COUNT;
//Mugsy - upped the maximum texture size to 512. All changes are the replacement of '256'
//with this define, MAX_TEXTURE_DIMS
#define MAX_TEXTURE_DIMS 512
void SpriteModel :: UploadTexture( byte *data, int width, int height, byte *srcpal, int name, int size, bool has_alpha )
{
int row1[MAX_TEXTURE_DIMS], row2[MAX_TEXTURE_DIMS], col1[MAX_TEXTURE_DIMS], col2[MAX_TEXTURE_DIMS];
byte *pix1, *pix2, *pix3, *pix4;
byte *tex, *in, *out, pal[768];
int i, j;
// convert texture to power of 2
int outwidth;
for (outwidth = 1; outwidth < width; outwidth <<= 1);
if (outwidth > MAX_TEXTURE_DIMS)
outwidth = MAX_TEXTURE_DIMS;
int outheight;
for (outheight = 1; outheight < height; outheight <<= 1);
if (outheight > MAX_TEXTURE_DIMS)
outheight = MAX_TEXTURE_DIMS;
in = (byte *)malloc(width * height * 4);
if (!in) return;
if( size == 1024 )
{
// expand pixels to rgba
for (i=0 ; i < width * height; i++)
{
in[i*4+0] = srcpal[data[i]*4+0];
in[i*4+1] = srcpal[data[i]*4+1];
in[i*4+2] = srcpal[data[i]*4+2];
in[i*4+3] = srcpal[data[i]*4+3];
}
}
else
{
memcpy( pal, srcpal, 768 );
// expand pixels to rgba
for (i=0 ; i < width * height; i++)
{
if( data[i] == 255 )
{
has_alpha = true;
in[i*4+0] = 0x00;
in[i*4+1] = 0x00;
in[i*4+2] = 0x00;
in[i*4+3] = 0x00;
}
else
{
in[i*4+0] = pal[data[i]*3+0];
in[i*4+1] = pal[data[i]*3+1];
in[i*4+2] = pal[data[i]*3+2];
in[i*4+3] = 0xFF;
}
}
}
tex = out = (byte *)malloc( outwidth * outheight * 4);
if (!out) return;
for (i = 0; i < outwidth; i++)
{
col1[i] = (int) ((i + 0.25) * (width / (float)outwidth));
col2[i] = (int) ((i + 0.75) * (width / (float)outwidth));
}
for (i = 0; i < outheight; i++)
{
row1[i] = (int) ((i + 0.25) * (height / (float)outheight)) * width;
row2[i] = (int) ((i + 0.75) * (height / (float)outheight)) * width;
}
// scale down and convert to 32bit RGB
for (i=0 ; i<outheight ; i++)
{
for (j=0 ; j<outwidth ; j++, out += 4)
{
pix1 = &in[(row1[i] + col1[j]) * 4];
pix2 = &in[(row1[i] + col2[j]) * 4];
pix3 = &in[(row2[i] + col1[j]) * 4];
pix4 = &in[(row2[i] + col2[j]) * 4];
out[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2;
out[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2;
out[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2;
out[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2;
}
}
GLint outFormat = (has_alpha) ? GL_RGBA : GL_RGB;
glBindTexture( GL_TEXTURE_2D, name );
glHint( GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST );
glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE );
glTexImage2D( GL_TEXTURE_2D, 0, outFormat, outwidth, outheight, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex );
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
const char *extensions = (const char *)glGetString( GL_EXTENSIONS );
// check for anisotropy support
if( Q_strstr( extensions, "GL_EXT_texture_filter_anisotropic" ))
{
float anisotropy = 1.0f;
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &anisotropy );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy );
}
free( tex );
free( in );
}
/*
================
LoadSpriteFrame
================
*/
dframetype_t* SpriteModel :: LoadSpriteFrame( void *pin, mspriteframe_t **ppframe )
{
dspriteframe_t *pinframe;
mspriteframe_t *pspriteframe;
bool has_alpha = false;
// check for alpha-channel
if( m_pspritehdr->texFormat == SPR_ALPHTEST || m_pspritehdr->texFormat == SPR_INDEXALPHA )
has_alpha = true;
pinframe = (dspriteframe_t *)pin;
UploadTexture( (byte *)(pinframe + 1), pinframe->width, pinframe->height, m_palette, g_tex_base + m_loadframe, 1024, has_alpha );
// setup frame description
pspriteframe = (mspriteframe_t *)calloc( 1, sizeof( mspriteframe_t ));
pspriteframe->width = pinframe->width;
pspriteframe->height = pinframe->height;
pspriteframe->up = pinframe->origin[1];
pspriteframe->left = pinframe->origin[0];
pspriteframe->down = pinframe->origin[1] - pinframe->height;
pspriteframe->right = pinframe->width + pinframe->origin[0];
pspriteframe->gl_texturenum = g_tex_base + m_loadframe;
*ppframe = pspriteframe;
m_loadframe++;
return (dframetype_t *)((byte *)(pinframe + 1) + pinframe->width * pinframe->height );
}
/*
================
LoadSpriteGroup
================
*/
dframetype_t* SpriteModel :: LoadSpriteGroup( void *pin, mspriteframe_t **ppframe )
{
dspritegroup_t *pingroup;
mspritegroup_t *pspritegroup;
dspriteinterval_t *pin_intervals;
float *poutintervals;
int i, groupsize, numframes;
void *ptemp;
pingroup = (dspritegroup_t *)pin;
numframes = pingroup->numframes;
groupsize = sizeof( mspritegroup_t ) + (numframes - 1) * sizeof( pspritegroup->frames[0] );
pspritegroup = (mspritegroup_t *)calloc( 1, groupsize );
pspritegroup->numframes = numframes;
*ppframe = (mspriteframe_t *)pspritegroup;
pin_intervals = (dspriteinterval_t *)(pingroup + 1);
poutintervals = (float *)malloc( numframes * sizeof( float ));
pspritegroup->intervals = poutintervals;
for( i = 0; i < numframes; i++ )
{
*poutintervals = pin_intervals->interval;
if( *poutintervals <= 0.0f )
*poutintervals = 1.0f; // set error value
poutintervals++;
pin_intervals++;
}
ptemp = (void *)pin_intervals;
for( i = 0; i < numframes; i++ )
{
ptemp = LoadSpriteFrame( ptemp, &pspritegroup->frames[i] );
}
return (dframetype_t *)ptemp;
}
msprite_t *SpriteModel :: LoadSprite( const char *spritename )
{
FILE *fp;
void *buffer;
if (!spritename)
return 0;
// load the model
if( (fp = fopen( spritename, "rb" )) == NULL)
return 0;
fseek( fp, 0, SEEK_END );
m_iFileSize = ftell( fp );
fseek( fp, 0, SEEK_SET );
buffer = malloc( m_iFileSize );
if (!buffer)
{
m_iFileSize = 0;
fclose (fp);
return 0;
}
fread( buffer, m_iFileSize, 1, fp );
fclose( fp );
dsprite_q1_t *pinq1;
dsprite_hl_t *pinhl;
dsprite_t *pin;
short *numi = NULL;
dframetype_t *pframetype;
msprite_t *psprite;
int i, size;
pin = (dsprite_t *)buffer;
if (strncmp ((const char *) buffer, "IDSP", 4 ))
{
mxMessageBox( g_GlWindow, "Unknown file format.", g_appTitle, MX_MB_OK | MX_MB_ERROR );
m_iFileSize = 0;
free (buffer);
return 0;
}
if( pin->version != SPRITE_VERSION_Q1 && pin->version != SPRITE_VERSION_HL )
{
mxMessageBox( g_GlWindow, "Unsupported sprite version.", g_appTitle, MX_MB_OK | MX_MB_ERROR );
m_iFileSize = 0;
free (buffer);
return 0;
}
if( pin->version == SPRITE_VERSION_Q1 )
{
pinq1 = (dsprite_q1_t *)buffer;
size = sizeof( msprite_t ) + ( pinq1->numframes - 1 ) * sizeof( psprite->frames );
psprite = (msprite_t *)calloc( 1, size );
m_pspritehdr = psprite; // make link to extradata
psprite->type = pinq1->type;
psprite->texFormat = SPR_ALPHTEST;
psprite->numframes = pinq1->numframes;
psprite->facecull = SPR_CULL_FRONT;
psprite->radius = pinq1->boundingradius;
psprite->synctype = pinq1->synctype;
m_spritemins[0] = m_spritemins[1] = -pinq1->bounds[0] * 0.5f;
m_spritemaxs[0] = m_spritemaxs[1] = pinq1->bounds[0] * 0.5f;
m_spritemins[2] = -pinq1->bounds[1] * 0.5f;
m_spritemaxs[2] = pinq1->bounds[1] * 0.5f;
numi = NULL;
}
else if( pin->version == SPRITE_VERSION_HL )
{
pinhl = (dsprite_hl_t *)buffer;
size = sizeof( msprite_t ) + ( pinhl->numframes - 1 ) * sizeof( psprite->frames );
psprite = (msprite_t *)calloc( 1, size );
m_pspritehdr = psprite; // make link to extradata
psprite->type = pinhl->type;
psprite->texFormat = pinhl->texFormat;
psprite->numframes = pinhl->numframes;
psprite->facecull = pinhl->facetype;
psprite->radius = pinhl->boundingradius;
psprite->synctype = pinhl->synctype;
m_spritemins[0] = m_spritemins[1] = -pinhl->bounds[0] * 0.5f;
m_spritemaxs[0] = m_spritemaxs[1] = pinhl->bounds[0] * 0.5f;
m_spritemins[2] = -pinhl->bounds[1] * 0.5f;
m_spritemaxs[2] = pinhl->bounds[1] * 0.5f;
numi = (short *)(pinhl + 1);
}
// last color are transparent
m_palette[255*4+0] = m_palette[255*4+1] = m_palette[255*4+2] = m_palette[255*4+3] = 0;
m_loadframe = 0;
if( numi == NULL )
{
for( i = 0; i < 255; i++ )
{
m_palette[i*4+0] = palette_q1[i*3+0];
m_palette[i*4+1] = palette_q1[i*3+1];
m_palette[i*4+2] = palette_q1[i*3+2];
m_palette[i*4+3] = 0xFF;
}
pframetype = (dframetype_t *)(pinq1 + 1);
}
else if( *numi == 256 )
{
byte *pal = (byte *)(numi+1);
// install palette
switch( psprite->texFormat )
{
case SPR_INDEXALPHA:
for( i = 0; i < 256; i++ )
{
m_palette[i*4+0] = pal[765];
m_palette[i*4+1] = pal[766];
m_palette[i*4+2] = pal[767];
m_palette[i*4+3] = i;
}
break;
case SPR_ALPHTEST:
for( i = 0; i < 255; i++ )
{
m_palette[i*4+0] = pal[i*3+0];
m_palette[i*4+1] = pal[i*3+1];
m_palette[i*4+2] = pal[i*3+2];
m_palette[i*4+3] = 0xFF;
}
break;
default:
for( i = 0; i < 256; i++ )
{
m_palette[i*4+0] = pal[i*3+0];
m_palette[i*4+1] = pal[i*3+1];
m_palette[i*4+2] = pal[i*3+2];
m_palette[i*4+3] = 0xFF;
}
break;
}
pframetype = (dframetype_t *)(pal + 768);
}
else
{
mxMessageBox( g_GlWindow, "sprite has wrong number of palette colors.\n", g_appTitle, MX_MB_OK | MX_MB_ERROR );
free( m_pspritehdr );
m_iFileSize = 0;
free (buffer);
return 0;
}
if( m_pspritehdr->numframes > MAX_SPRITE_FRAMES )
{
mxMessageBox( g_GlWindow, "sprite has too many frames.", g_appTitle, MX_MB_OK | MX_MB_ERROR );
free( m_pspritehdr );
m_iFileSize = 0;
free (buffer);
return 0;
}
Q_strncpy (g_viewerSettings.spriteFile, spritename, sizeof( g_viewerSettings.spriteFile ));
Q_strncpy( g_viewerSettings.spritePath, spritename, sizeof( g_viewerSettings.spritePath ));
for( i = 0; i < m_pspritehdr->numframes; i++ )
{
frametype_t frametype = pframetype->type;
psprite->frames[i].type = frametype;
switch( frametype )
{
case FRAME_SINGLE:
pframetype = LoadSpriteFrame( pframetype + 1, &psprite->frames[i].frameptr );
break;
case FRAME_GROUP:
pframetype = LoadSpriteGroup( pframetype + 1, &psprite->frames[i].frameptr );
break;
case FRAME_ANGLED:
pframetype = LoadSpriteGroup( pframetype + 1, &psprite->frames[i].frameptr );
break;
}
if( pframetype == NULL ) break; // technically an error
}
char basename[64];
COM_FileBase( spritename, basename );
if( !Q_strnicmp( basename, "v_", 2 ))
{
g_SPRViewer->checkboxSet( IDC_OPTIONS_WEAPONORIGIN, true );
bUseWeaponOrigin = true;
}
else
{
g_SPRViewer->checkboxSet( IDC_OPTIONS_WEAPONORIGIN, false );
bUseWeaponOrigin = false;
}
// reset all the changes
g_viewerSettings.numModelChanges = 0;
// free buffer
m_iFileSize = 0;
free (buffer);
return m_pspritehdr;
}
void SpriteModel :: FreeSprite( void )
{
int i;
if( g_viewerSettings.numModelChanges )
{
if( !mxMessageBox( g_GlWindow, "Sprite has changes. Do you wish to save them?", g_appTitle, MX_MB_YESNO | MX_MB_QUESTION ))
{
char *ptr = (char *)mxGetSaveFileName( g_GlWindow , g_viewerSettings.spritePath, "*.spr", g_viewerSettings.spritePath );
if( ptr )
{
char filename[256];
char ext[16];
strcpy( filename, ptr );
strcpy( ext, mx_getextension( filename ));
if( mx_strcasecmp( ext, ".spr" ))
strcat( filename, ".spr" );
if( !SaveSprite( filename ))
mxMessageBox( g_GlWindow, "Error saving sprite.", g_appTitle, MX_MB_OK | MX_MB_ERROR);
}
}
g_viewerSettings.numModelChanges = 0; // all the settings are handled or invalidated
}
if( m_pspritehdr )
{
mspritegroup_t *pgroup;
// deleting textures
int textures[MAX_SPRITE_FRAMES];
for (i = 0; i < m_loadframe; i++)
textures[i] = g_tex_base + i;
for( i = 0; i < m_pspritehdr->numframes; i++ )
{
if( m_pspritehdr->frames[i].type != FRAME_SINGLE )
{
pgroup = (mspritegroup_t *)m_pspritehdr->frames[i].frameptr;
free( pgroup->intervals ); // throw intervals
// throw frames
for( i = 0; i < pgroup->numframes; i++ )
free( pgroup->frames[i] );
free( pgroup ); // throw himself
}
else free( m_pspritehdr->frames[i].frameptr );
}
glDeleteTextures (m_loadframe, (const GLuint *)textures);
m_loadframe = 0;
}
if (m_pspritehdr)
free (m_pspritehdr);
m_frame = 0;
m_pspritehdr = 0;
m_iFileSize = 0;
}
bool SpriteModel :: SaveSprite( const char *spritename )
{
// if (!spritename)
return false;
if (!m_pspritehdr)
return false;
FILE *file;
file = fopen (spritename, "wb");
if (!file)
return false;
fwrite (m_pspritehdr, sizeof (byte), m_iFileSize, file);
fclose (file);
return true;
}
void SpriteModel :: ExtractBbox( vec3_t &mins, vec3_t &maxs )
{
if( !m_pspritehdr )
{
mins = g_vecZero;
maxs = g_vecZero;
return;
}
mins = m_spritemins;
maxs = m_spritemaxs;
}
void SpriteModel:: GetMovement( vec3_t &delta )
{
delta = g_vecZero;
}
Reference in New Issue View Git Blame Copy Permalink