mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-12-11 21:40:49 +00:00
79ad905e05
Excluding 3rd party files.
911 lines
25 KiB
C++
911 lines
25 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
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
|
|
}
|