blendo/quadrilateralcowboy
0
0
Fork 0
mirror of https://github.com/blendogames/quadrilateralcowboy.git synced 2024-11-21 19:51:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
quadrilateralcowboy/renderer/MegaTexture.cpp
brendon 47a1010d23 Initial commit
2020-06-12 14:06:25 -07:00

913 lines
25 KiB
C++
Raw Blame History

/*
===========================================================================
Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "tr_local.h"
idCVar idMegaTexture::r_megaTextureLevel( "r_megaTextureLevel", "0", CVAR_RENDERER | CVAR_INTEGER, "draw only a specific level" );
idCVar idMegaTexture::r_showMegaTexture( "r_showMegaTexture", "0", CVAR_RENDERER | CVAR_BOOL, "display all the level images" );
idCVar idMegaTexture::r_showMegaTextureLabels( "r_showMegaTextureLabels", "0", CVAR_RENDERER | CVAR_BOOL, "draw colored blocks in each tile" );
idCVar idMegaTexture::r_skipMegaTexture( "r_skipMegaTexture", "0", CVAR_RENDERER | CVAR_INTEGER, "only use the lowest level image" );
idCVar idMegaTexture::r_terrainScale( "r_terrainScale", "3", CVAR_RENDERER | CVAR_INTEGER, "vertically scale USGS data" );
/*
allow sparse population of the upper detail tiles
*/
int RoundDownToPowerOfTwo( int num ) {
int pot;
for (pot = 1 ; (pot*2) <= num ; pot<<=1) {
}
return pot;
}
static union {
int intVal;
byte color[4];
} fillColor;
static byte colors[8][4] = {
{ 0, 0, 0, 255 },
{ 255, 0, 0, 255 },
{ 0, 255, 0, 255 },
{ 255, 255, 0, 255 },
{ 0, 0, 255, 255 },
{ 255, 0, 255, 255 },
{ 0, 255, 255, 255 },
{ 255, 255, 255, 255 }
};
static void R_EmptyLevelImage( idImage *image ) {
int c = MAX_LEVEL_WIDTH * MAX_LEVEL_WIDTH;
byte *data = (byte *)_alloca( c*4 );
for ( int i = 0 ; i < c ; i++ ) {
((int *)data)[i] = fillColor.intVal;
}
// FIXME: this won't live past vid mode changes
image->GenerateImage( data, MAX_LEVEL_WIDTH, MAX_LEVEL_WIDTH,
TF_DEFAULT, false, TR_REPEAT, TD_HIGH_QUALITY );
}
/*
====================
InitFromMegaFile
====================
*/
bool idMegaTexture::InitFromMegaFile( const char *fileBase ) {
idStr name = "megaTextures/";
name += fileBase;
name.StripFileExtension();
name += ".mega";
int width, height;
fileHandle = fileSystem->OpenFileRead( name.c_str() );
if ( !fileHandle ) {
common->Printf( "idMegaTexture: failed to open %s\n", name.c_str() );
return false;
}
fileHandle->Read( &header, sizeof( header ) );
if ( header.tileSize < 64 || header.tilesWide < 1 || header.tilesHigh < 1 ) {
common->Printf( "idMegaTexture: bad header on %s\n", name.c_str() );
return false;
}
currentTriMapping = NULL;
numLevels = 0;
width = header.tilesWide;
height = header.tilesHigh;
int tileOffset = 1; // just past the header
memset( levels, 0, sizeof( levels ) );
while( 1 ) {
idTextureLevel *level = &levels[numLevels];
level->mega = this;
level->tileOffset = tileOffset;
level->tilesWide = width;
level->tilesHigh = height;
level->parms[0] = -1; // initially mask everything
level->parms[1] = 0;
level->parms[2] = 0;
level->parms[3] = (float)width / TILE_PER_LEVEL;
level->Invalidate();
tileOffset += level->tilesWide * level->tilesHigh;
char str[1024];
sprintf( str, "MEGA_%s_%i", fileBase, numLevels );
// give each level a default fill color
for (int i = 0 ; i < 4 ; i++ ) {
fillColor.color[i] = colors[numLevels+1][i];
}
levels[numLevels].image = globalImages->ImageFromFunction( str, R_EmptyLevelImage );
numLevels++;
if ( width <= TILE_PER_LEVEL && height <= TILE_PER_LEVEL ) {
break;
}
width = ( width + 1 ) >> 1;
height = ( height + 1 ) >> 1;
}
// force first bind to load everything
currentViewOrigin[0] = -99999999.0f;
currentViewOrigin[1] = -99999999.0f;
currentViewOrigin[2] = -99999999.0f;
return true;
}
/*
====================
SetMappingForSurface
analyzes xyz and st to create a mapping
This is not very robust, but works for rectangular grids
====================
*/
void idMegaTexture::SetMappingForSurface( const srfTriangles_t *tri ) {
if ( tri == currentTriMapping ) {
return;
}
currentTriMapping = tri;
if ( !tri->verts ) {
return;
}
idDrawVert origin, axis[2];
origin.st[0] = 1.0;
origin.st[1] = 1.0;
axis[0].st[0] = 0;
axis[0].st[1] = 1;
axis[1].st[0] = 1;
axis[1].st[1] = 0;
for ( int i = 0 ; i < tri->numVerts ; i++ ) {
idDrawVert *v = &tri->verts[i];
if ( v->st[0] <= origin.st[0] && v->st[1] <= origin.st[1] ) {
origin = *v;
}
if ( v->st[0] >= axis[0].st[0] && v->st[1] <= axis[0].st[1] ) {
axis[0] = *v;
}
if ( v->st[0] <= axis[1].st[0] && v->st[1] >= axis[1].st[1] ) {
axis[1] = *v;
}
}
for ( int i = 0 ; i < 2 ; i++ ) {
idVec3 dir = axis[i].xyz - origin.xyz;
float texLen = axis[i].st[i] - origin.st[i];
float spaceLen = (axis[i].xyz - origin.xyz).Length();
float scale = texLen / (spaceLen*spaceLen);
dir *= scale;
float c = origin.xyz * dir - origin.st[i];
localViewToTextureCenter[i][0] = dir[0];
localViewToTextureCenter[i][1] = dir[1];
localViewToTextureCenter[i][2] = dir[2];
localViewToTextureCenter[i][3] = -c;
}
}
/*
====================
BindForViewOrigin
====================
*/
void idMegaTexture::BindForViewOrigin( const idVec3 viewOrigin ) {
SetViewOrigin( viewOrigin );
// borderClamp image goes in texture 0
GL_SelectTexture( 0 );
globalImages->borderClampImage->Bind();
// level images in higher textures, blurriest first
for ( int i = 0 ; i < 7 ; i++ ) {
GL_SelectTexture( 1+i );
if ( i >= numLevels ) {
globalImages->whiteImage->Bind();
static float parms[4] = { -2, -2, 0, 1 }; // no contribution
qglProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, i, parms );
} else {
idTextureLevel *level = &levels[ numLevels-1-i ];
if ( r_showMegaTexture.GetBool() ) {
if ( i & 1 ) {
globalImages->blackImage->Bind();
} else {
globalImages->whiteImage->Bind();
}
} else {
level->image->Bind();
}
qglProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, i, level->parms );
}
}
float parms[4];
parms[0] = 0;
parms[1] = 0;
parms[2] = 0;
parms[3] = 1;
qglProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, 7, parms );
parms[0] = 1;
parms[1] = 1;
parms[2] = r_terrainScale.GetFloat();
parms[3] = 1;
qglProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, 8, parms );
}
/*
====================
Unbind
This can go away once everything uses fragment programs so the enable states don't
need tracking
====================
*/
void idMegaTexture::Unbind( void ) {
for ( int i = 0 ; i < numLevels ; i++ ) {
GL_SelectTexture( 1+i );
globalImages->BindNull();
}
}
/*
====================
SetViewOrigin
====================
*/
void idMegaTexture::SetViewOrigin( const idVec3 viewOrigin ) {
if ( r_showMegaTextureLabels.IsModified() ) {
r_showMegaTextureLabels.ClearModified();
currentViewOrigin[0] = viewOrigin[0] + 0.1; // force a change
for ( int i = 0 ; i < numLevels ; i++ ) {
levels[i].Invalidate();
}
}
if ( viewOrigin == currentViewOrigin ) {
return;
}
if ( r_skipMegaTexture.GetBool() ) {
return;
}
currentViewOrigin = viewOrigin;
float texCenter[2];
// convert the viewOrigin to a texture center, which will
// be a different conversion for each megaTexture
for ( int i = 0 ; i < 2 ; i++ ) {
texCenter[i] =
viewOrigin[0] * localViewToTextureCenter[i][0] +
viewOrigin[1] * localViewToTextureCenter[i][1] +
viewOrigin[2] * localViewToTextureCenter[i][2] +
localViewToTextureCenter[i][3];
}
for ( int i = 0 ; i < numLevels ; i++ ) {
levels[i].UpdateForCenter( texCenter );
}
}
/*
====================
UpdateTile
A local tile will only be mapped to globalTile[ localTile + X * TILE_PER_LEVEL ] for some x
====================
*/
void idTextureLevel::UpdateTile( int localX, int localY, int globalX, int globalY ) {
idTextureTile *tile = &tileMap[localX][localY];
if ( tile->x == globalX && tile->y == globalY ) {
return;
}
if ( (globalX & (TILE_PER_LEVEL-1)) != localX || (globalY & (TILE_PER_LEVEL-1)) != localY ) {
common->Error( "idTextureLevel::UpdateTile: bad coordinate mod" );
}
tile->x = globalX;
tile->y = globalY;
byte data[ TILE_SIZE * TILE_SIZE * 4 ];
if ( globalX >= tilesWide || globalX < 0 || globalY >= tilesHigh || globalY < 0 ) {
// off the map
memset( data, 0, sizeof( data ) );
} else {
// extract the data from the full image (FIXME: background load from disk)
int tileNum = tileOffset + tile->y * tilesWide + tile->x;
int tileSize = TILE_SIZE * TILE_SIZE * 4;
mega->fileHandle->Seek( tileNum * tileSize, FS_SEEK_SET );
memset( data, 128, sizeof( data ) );
mega->fileHandle->Read( data, tileSize );
}
if ( idMegaTexture::r_showMegaTextureLabels.GetBool() ) {
// put a color marker in it
byte color[4] = { 255 * localX / TILE_PER_LEVEL, 255 * localY / TILE_PER_LEVEL, 0, 0 };
for ( int x = 0 ; x < 8 ; x++ ) {
for ( int y = 0 ; y < 8 ; y++ ) {
*(int *)&data[ ( ( y + TILE_SIZE/2 - 4 ) * TILE_SIZE + x + TILE_SIZE/2 - 4 ) * 4 ] = *(int *)color;
}
}
}
// upload all the mip-map levels
int level = 0;
int size = TILE_SIZE;
while ( 1 ) {
qglTexSubImage2D( GL_TEXTURE_2D, level, localX * size, localY * size, size, size, GL_RGBA, GL_UNSIGNED_BYTE, data );
size >>= 1;
level++;
if ( size == 0 ) {
break;
}
int byteSize = size * 4;
// mip-map in place
for ( int y = 0 ; y < size ; y++ ) {
byte *in, *in2, *out;
in = data + y * size * 16;
in2 = in + size * 8;
out = data + y * size * 4;
for ( int x = 0 ; x < size ; x++ ) {
out[x*4+0] = ( in[x*8+0] + in[x*8+4+0] + in2[x*8+0] + in2[x*8+4+0] ) >> 2;
out[x*4+1] = ( in[x*8+1] + in[x*8+4+1] + in2[x*8+1] + in2[x*8+4+1] ) >> 2;
out[x*4+2] = ( in[x*8+2] + in[x*8+4+2] + in2[x*8+2] + in2[x*8+4+2] ) >> 2;
out[x*4+3] = ( in[x*8+3] + in[x*8+4+3] + in2[x*8+3] + in2[x*8+4+3] ) >> 2;
}
}
}
}
/*
====================
UpdateForCenter
Center is in the 0.0 to 1.0 range
====================
*/
void idTextureLevel::UpdateForCenter( float center[2] ) {
int globalTileCorner[2];
int localTileOffset[2];
if ( tilesWide <= TILE_PER_LEVEL && tilesHigh <= TILE_PER_LEVEL ) {
globalTileCorner[0] = 0;
globalTileCorner[1] = 0;
localTileOffset[0] = 0;
localTileOffset[1] = 0;
// orient the mask so that it doesn't mask anything at all
parms[0] = 0.25;
parms[1] = 0.25;
parms[3] = 0.25;
} else {
for ( int i = 0 ; i < 2 ; i++ ) {
float global[2];
// this value will be outside the 0.0 to 1.0 range unless
// we are in the corner of the megaTexture
global[i] = ( center[i] * parms[3] - 0.5 ) * TILE_PER_LEVEL;
globalTileCorner[i] = (int)( global[i] + 0.5 );
localTileOffset[i] = globalTileCorner[i] & (TILE_PER_LEVEL-1);
// scaling for the mask texture to only allow the proper window
// of tiles to show through
parms[i] = -globalTileCorner[i] / (float)TILE_PER_LEVEL;
}
}
image->Bind();
for ( int x = 0 ; x < TILE_PER_LEVEL ; x++ ) {
for ( int y = 0 ; y < TILE_PER_LEVEL ; y++ ) {
int globalTile[2];
globalTile[0] = globalTileCorner[0] + ( ( x - localTileOffset[0] ) & (TILE_PER_LEVEL-1) );
globalTile[1] = globalTileCorner[1] + ( ( y - localTileOffset[1] ) & (TILE_PER_LEVEL-1) );
UpdateTile( x, y, globalTile[0], globalTile[1] );
}
}
}
/*
=====================
Invalidate
Forces all tiles to be regenerated
=====================
*/
void idTextureLevel::Invalidate() {
for ( int x = 0 ; x < TILE_PER_LEVEL ; x++ ) {
for ( int y = 0 ; y < TILE_PER_LEVEL ; y++ ) {
tileMap[x][y].x =
tileMap[x][y].y = -99999;
}
}
}
//===================================================================================================
typedef struct _TargaHeader {
unsigned char id_length, colormap_type, image_type;
unsigned short colormap_index, colormap_length;
unsigned char colormap_size;
unsigned short x_origin, y_origin, width, height;
unsigned char pixel_size, attributes;
} TargaHeader;
static byte ReadByte( idFile *f ) {
byte b;
f->Read( &b, 1 );
return b;
}
static short ReadShort( idFile *f ) {
byte b[2];
f->Read( &b, 2 );
return b[0] + ( b[1] << 8 );
}
/*
====================
GenerateMegaMipMaps
====================
*/
void idMegaTexture::GenerateMegaMipMaps( megaTextureHeader_t *header, idFile *outFile ) {
outFile->Flush();
// out fileSystem doesn't allow read / write access...
idFile *inFile = fileSystem->OpenFileRead( outFile->GetName() );
int tileOffset = 1;
int width = header->tilesWide;
int height = header->tilesHigh;
int tileSize = header->tileSize * header->tileSize * 4;
byte *oldBlock = (byte *)_alloca( tileSize );
byte *newBlock = (byte *)_alloca( tileSize );
while ( width > 1 || height > 1 ) {
int newHeight = (height+1) >> 1;
if ( newHeight < 1 ) {
newHeight = 1;
}
int newWidth = (width+1) >> 1;
if ( width < 1 ) {
width = 1;
}
common->Printf( "generating %i x %i block mip level\n", newWidth, newHeight );
int tileNum;
for ( int y = 0 ; y < newHeight ; y++ ) {
common->Printf( "row %i\n", y );
session->UpdateScreen();
for ( int x = 0 ; x < newWidth ; x++ ) {
// mip map four original blocks down into a single new block
for ( int yy = 0 ; yy < 2 ; yy++ ) {
for ( int xx = 0 ; xx< 2 ; xx++ ) {
int tx = x*2 + xx;
int ty = y*2 + yy;
if ( tx > width || ty > height ) {
// off edge, zero fill
memset( newBlock, 0, sizeof( newBlock ) );
} else {
tileNum = tileOffset + ty * width + tx;
inFile->Seek( tileNum * tileSize, FS_SEEK_SET );
inFile->Read( oldBlock, tileSize );
}
// mip map the new pixels
for ( int yyy = 0 ; yyy < TILE_SIZE / 2 ; yyy++ ) {
for ( int xxx = 0 ; xxx < TILE_SIZE / 2 ; xxx++ ) {
byte *in = &oldBlock[ ( yyy * 2 * TILE_SIZE + xxx * 2 ) * 4 ];
byte *out = &newBlock[ ( ( ( TILE_SIZE/2 * yy ) + yyy ) * TILE_SIZE + ( TILE_SIZE/2 * xx ) + xxx ) * 4 ];
out[0] = ( in[0] + in[4] + in[0+TILE_SIZE*4] + in[4+TILE_SIZE*4] ) >> 2;
out[1] = ( in[1] + in[5] + in[1+TILE_SIZE*4] + in[5+TILE_SIZE*4] ) >> 2;
out[2] = ( in[2] + in[6] + in[2+TILE_SIZE*4] + in[6+TILE_SIZE*4] ) >> 2;
out[3] = ( in[3] + in[7] + in[3+TILE_SIZE*4] + in[7+TILE_SIZE*4] ) >> 2;
}
}
// write the block out
tileNum = tileOffset + width * height + y * newWidth + x;
outFile->Seek( tileNum * tileSize, FS_SEEK_SET );
outFile->Write( newBlock, tileSize );
}
}
}
}
tileOffset += width * height;
width = newWidth;
height = newHeight;
}
delete inFile;
}
/*
====================
GenerateMegaPreview
Make a 2k x 2k preview image for a mega texture that can be used in modeling programs
====================
*/
void idMegaTexture::GenerateMegaPreview( const char *fileName ) {
idFile *fileHandle = fileSystem->OpenFileRead( fileName );
if ( !fileHandle ) {
common->Printf( "idMegaTexture: failed to open %s\n", fileName );
return;
}
idStr outName = fileName;
outName.StripFileExtension();
outName += "_preview.tga";
common->Printf( "Creating %s.\n", outName.c_str() );
megaTextureHeader_t header;
fileHandle->Read( &header, sizeof( header ) );
if ( header.tileSize < 64 || header.tilesWide < 1 || header.tilesHigh < 1 ) {
common->Printf( "idMegaTexture: bad header on %s\n", fileName );
return;
}
int tileSize = header.tileSize;
int width = header.tilesWide;
int height = header.tilesHigh;
int tileOffset = 1;
int tileBytes = tileSize * tileSize * 4;
// find the level that fits
while ( width * tileSize > 2048 || height * tileSize > 2048 ) {
tileOffset += width * height;
width >>= 1;
if ( width < 1 ) {
width = 1;
}
height >>= 1;
if ( height < 1 ) {
height = 1;
}
}
byte *pic = (byte *)R_StaticAlloc( width * height * tileBytes );
byte *oldBlock = (byte *)_alloca( tileBytes );
for ( int y = 0 ; y < height ; y++ ) {
for ( int x = 0 ; x < width ; x++ ) {
int tileNum = tileOffset + y * width + x;
fileHandle->Seek( tileNum * tileBytes, FS_SEEK_SET );
fileHandle->Read( oldBlock, tileBytes );
for ( int yy = 0 ; yy < tileSize ; yy++ ) {
memcpy( pic + ( ( y * tileSize + yy ) * width * tileSize + x * tileSize ) * 4,
oldBlock + yy * tileSize * 4, tileSize * 4 );
}
}
}
R_WriteTGA( outName.c_str(), pic, width * tileSize, height * tileSize, false );
R_StaticFree( pic );
delete fileHandle;
}
/*
====================
MakeMegaTexture_f
Incrementally load a giant tga file and process into the mega texture block format
====================
*/
void idMegaTexture::MakeMegaTexture_f( const idCmdArgs &args ) {
int columns, rows, fileSize, numBytes;
byte *pixbuf;
int row, column;
TargaHeader targa_header;
if ( args.Argc() != 2 ) {
common->Printf( "USAGE: makeMegaTexture <filebase>\n" );
return;
}
idStr name_s = "megaTextures/";
name_s += args.Argv(1);
name_s.StripFileExtension();
name_s += ".tga";
const char *name = name_s.c_str();
//
// open the file
//
common->Printf( "Opening %s.\n", name );
fileSize = fileSystem->ReadFile( name, NULL, NULL );
idFile *file = fileSystem->OpenFileRead( name );
if ( !file ) {
common->Printf( "Couldn't open %s\n", name );
return;
}
targa_header.id_length = ReadByte( file );
targa_header.colormap_type = ReadByte( file );
targa_header.image_type = ReadByte( file );
targa_header.colormap_index = ReadShort( file );
targa_header.colormap_length = ReadShort( file );
targa_header.colormap_size = ReadByte( file );
targa_header.x_origin = ReadShort( file );
targa_header.y_origin = ReadShort( file );
targa_header.width = ReadShort( file );
targa_header.height = ReadShort( file );
targa_header.pixel_size = ReadByte( file );
targa_header.attributes = ReadByte( file );
if ( targa_header.image_type != 2 && targa_header.image_type != 10 && targa_header.image_type != 3 ) {
common->Error( "LoadTGA( %s ): Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n", name );
}
if ( targa_header.colormap_type != 0 ) {
common->Error( "LoadTGA( %s ): colormaps not supported\n", name );
}
if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 ) {
common->Error( "LoadTGA( %s ): Only 32 or 24 bit images supported (no colormaps)\n", name );
}
if ( targa_header.image_type == 2 || targa_header.image_type == 3 ) {
numBytes = targa_header.width * targa_header.height * ( targa_header.pixel_size >> 3 );
if ( numBytes > fileSize - 18 - targa_header.id_length ) {
common->Error( "LoadTGA( %s ): incomplete file\n", name );
}
}
columns = targa_header.width;
rows = targa_header.height;
// skip TARGA image comment
if ( targa_header.id_length != 0 ) {
file->Seek( targa_header.id_length, FS_SEEK_CUR );
}
megaTextureHeader_t mtHeader;
mtHeader.tileSize = TILE_SIZE;
mtHeader.tilesWide = RoundDownToPowerOfTwo( targa_header.width ) / TILE_SIZE;
mtHeader.tilesHigh = RoundDownToPowerOfTwo( targa_header.height ) / TILE_SIZE;
idStr outName = name;
outName.StripFileExtension();
outName += ".mega";
common->Printf( "Writing %i x %i size %i tiles to %s.\n",
mtHeader.tilesWide, mtHeader.tilesHigh, mtHeader.tileSize, outName.c_str() );
// open the output megatexture file
idFile *out = fileSystem->OpenFileWrite( outName.c_str() );
out->Write( &mtHeader, sizeof( mtHeader ) );
out->Seek( TILE_SIZE * TILE_SIZE * 4, FS_SEEK_SET );
// we will process this one row of tiles at a time, since the entire thing
// won't fit in memory
byte *targa_rgba = (byte *)R_StaticAlloc( TILE_SIZE * targa_header.width * 4 );
int blockRowsRemaining = mtHeader.tilesHigh;
while ( blockRowsRemaining-- ) {
common->Printf( "%i blockRowsRemaining\n", blockRowsRemaining );
session->UpdateScreen();
if ( targa_header.image_type == 2 || targa_header.image_type == 3 ) {
// Uncompressed RGB or gray scale image
for( row = 0 ; row < TILE_SIZE ; row++ ) {
pixbuf = targa_rgba + row*columns*4;
for( column = 0; column < columns; column++) {
unsigned char red,green,blue,alphabyte;
switch( targa_header.pixel_size ) {
case 8:
blue = ReadByte( file );
green = blue;
red = blue;
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = 255;
break;
case 24:
blue = ReadByte( file );
green = ReadByte( file );
red = ReadByte( file );
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = 255;
break;
case 32:
blue = ReadByte( file );
green = ReadByte( file );
red = ReadByte( file );
alphabyte = ReadByte( file );
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = alphabyte;
break;
default:
common->Error( "LoadTGA( %s ): illegal pixel_size '%d'\n", name, targa_header.pixel_size );
break;
}
}
}
} else if ( targa_header.image_type == 10 ) { // Runlength encoded RGB images
unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
red = 0;
green = 0;
blue = 0;
alphabyte = 0xff;
for( row = 0 ; row < TILE_SIZE ; row++ ) {
pixbuf = targa_rgba + row*columns*4;
for( column = 0; column < columns; ) {
packetHeader= ReadByte( file );
packetSize = 1 + (packetHeader & 0x7f);
if ( packetHeader & 0x80 ) { // run-length packet
switch( targa_header.pixel_size ) {
case 24:
blue = ReadByte( file );
green = ReadByte( file );
red = ReadByte( file );
alphabyte = 255;
break;
case 32:
blue = ReadByte( file );
green = ReadByte( file );
red = ReadByte( file );
alphabyte = ReadByte( file );
break;
default:
common->Error( "LoadTGA( %s ): illegal pixel_size '%d'\n", name, targa_header.pixel_size );
break;
}
for( j = 0; j < packetSize; j++ ) {
*pixbuf++=red;
*pixbuf++=green;
*pixbuf++=blue;
*pixbuf++=alphabyte;
column++;
if ( column == columns ) { // run spans across rows
common->Error( "TGA had RLE across columns, probably breaks block" );
column = 0;
if ( row > 0) {
row--;
}
else {
goto breakOut;
}
pixbuf = targa_rgba + row*columns*4;
}
}
} else { // non run-length packet
for( j = 0; j < packetSize; j++ ) {
switch( targa_header.pixel_size ) {
case 24:
blue = ReadByte( file );
green = ReadByte( file );
red = ReadByte( file );
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = 255;
break;
case 32:
blue = ReadByte( file );
green = ReadByte( file );
red = ReadByte( file );
alphabyte = ReadByte( file );
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = alphabyte;
break;
default:
common->Error( "LoadTGA( %s ): illegal pixel_size '%d'\n", name, targa_header.pixel_size );
break;
}
column++;
if ( column == columns ) { // pixel packet run spans across rows
column = 0;
if ( row > 0 ) {
row--;
}
else {
goto breakOut;
}
pixbuf = targa_rgba + row*columns*4;
}
}
}
}
breakOut: ;
}
}
//
// write out individual blocks from the full row block buffer
//
for ( int rowBlock = 0 ; rowBlock < mtHeader.tilesWide ; rowBlock++ ) {
for ( int y = 0 ; y < TILE_SIZE ; y++ ) {
out->Write( targa_rgba + ( y * targa_header.width + rowBlock * TILE_SIZE ) * 4, TILE_SIZE * 4 );
}
}
}
R_StaticFree( targa_rgba );
GenerateMegaMipMaps( &mtHeader, out );
delete out;
delete file;
GenerateMegaPreview( outName.c_str() );
#if 0
if ( (targa_header.attributes & (1<<5)) ) { // image flp bit
R_VerticalFlip( *pic, *width, *height );
}
#endif
}
Reference in a new issue View git blame Copy permalink