mirror of
https://github.com/blendogames/quadrilateralcowboy.git
synced 2024-11-22 04:01:08 +00:00
2219 lines
61 KiB
C++
2219 lines
61 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"
|
|
|
|
/*
|
|
PROBLEM: compressed textures may break the zero clamp rule!
|
|
*/
|
|
|
|
static bool FormatIsDXT( int internalFormat ) {
|
|
if ( internalFormat < GL_COMPRESSED_RGB_S3TC_DXT1_EXT
|
|
|| internalFormat > GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int MakePowerOfTwo( int num ) {
|
|
int pot;
|
|
for (pot = 1 ; pot < num ; pot<<=1) {
|
|
}
|
|
return pot;
|
|
}
|
|
|
|
/*
|
|
================
|
|
BitsForInternalFormat
|
|
|
|
Used for determining memory utilization
|
|
================
|
|
*/
|
|
int idImage::BitsForInternalFormat( int internalFormat ) const {
|
|
switch ( internalFormat ) {
|
|
case GL_INTENSITY8:
|
|
case 1:
|
|
return 8;
|
|
case 2:
|
|
case GL_LUMINANCE8_ALPHA8:
|
|
return 16;
|
|
case 3:
|
|
return 32; // on some future hardware, this may actually be 24, but be conservative
|
|
case 4:
|
|
return 32;
|
|
case GL_LUMINANCE8:
|
|
return 8;
|
|
case GL_ALPHA8:
|
|
return 8;
|
|
case GL_RGBA8:
|
|
return 32;
|
|
case GL_RGB8:
|
|
return 32; // on some future hardware, this may actually be 24, but be conservative
|
|
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
|
|
return 4;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
|
|
return 4;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
|
|
return 8;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
|
|
return 8;
|
|
case GL_RGBA4:
|
|
return 16;
|
|
case GL_RGB5:
|
|
return 16;
|
|
case GL_COLOR_INDEX8_EXT:
|
|
return 8;
|
|
case GL_COLOR_INDEX:
|
|
return 8;
|
|
case GL_COMPRESSED_RGB_ARB:
|
|
return 4; // not sure
|
|
case GL_COMPRESSED_RGBA_ARB:
|
|
return 8; // not sure
|
|
default:
|
|
common->Error( "R_BitsForInternalFormat: BAD FORMAT:%i", internalFormat );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
UploadCompressedNormalMap
|
|
|
|
Create a 256 color palette to be used by compressed normal maps
|
|
==================
|
|
*/
|
|
void idImage::UploadCompressedNormalMap( int width, int height, const byte *rgba, int mipLevel ) {
|
|
byte *normals;
|
|
const byte *in;
|
|
byte *out;
|
|
int i, j;
|
|
int x, y, z;
|
|
int row;
|
|
|
|
// OpenGL's pixel packing rule
|
|
row = width < 4 ? 4 : width;
|
|
|
|
normals = (byte *)_alloca( row * height );
|
|
if ( !normals ) {
|
|
common->Error( "R_UploadCompressedNormalMap: _alloca failed" );
|
|
}
|
|
|
|
in = rgba;
|
|
out = normals;
|
|
for ( i = 0 ; i < height ; i++, out += row, in += width * 4 ) {
|
|
for ( j = 0 ; j < width ; j++ ) {
|
|
x = in[ j * 4 + 0 ];
|
|
y = in[ j * 4 + 1 ];
|
|
z = in[ j * 4 + 2 ];
|
|
|
|
int c;
|
|
if ( x == 128 && y == 128 && z == 128 ) {
|
|
// the "nullnormal" color
|
|
c = 255;
|
|
} else {
|
|
c = ( globalImages->originalToCompressed[x] << 4 ) | globalImages->originalToCompressed[y];
|
|
if ( c == 255 ) {
|
|
c = 254; // don't use the nullnormal color
|
|
}
|
|
}
|
|
out[j] = c;
|
|
}
|
|
}
|
|
|
|
if ( mipLevel == 0 ) {
|
|
// Optionally write out the paletized normal map to a .tga
|
|
if ( globalImages->image_writeNormalTGAPalletized.GetBool() ) {
|
|
char filename[MAX_IMAGE_NAME];
|
|
ImageProgramStringToCompressedFileName( imgName, filename );
|
|
char *ext = strrchr(filename, '.');
|
|
if ( ext ) {
|
|
strcpy(ext, "_pal.tga");
|
|
R_WritePalTGA( filename, normals, globalImages->compressedPalette, width, height);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( glConfig.sharedTexturePaletteAvailable ) {
|
|
qglTexImage2D( GL_TEXTURE_2D,
|
|
mipLevel,
|
|
GL_COLOR_INDEX8_EXT,
|
|
width,
|
|
height,
|
|
0,
|
|
GL_COLOR_INDEX,
|
|
GL_UNSIGNED_BYTE,
|
|
normals );
|
|
}
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
|
|
|
|
static byte mipBlendColors[16][4] = {
|
|
{0,0,0,0},
|
|
{255,0,0,128},
|
|
{0,255,0,128},
|
|
{0,0,255,128},
|
|
{255,0,0,128},
|
|
{0,255,0,128},
|
|
{0,0,255,128},
|
|
{255,0,0,128},
|
|
{0,255,0,128},
|
|
{0,0,255,128},
|
|
{255,0,0,128},
|
|
{0,255,0,128},
|
|
{0,0,255,128},
|
|
{255,0,0,128},
|
|
{0,255,0,128},
|
|
{0,0,255,128},
|
|
};
|
|
|
|
/*
|
|
===============
|
|
SelectInternalFormat
|
|
|
|
This may need to scan six cube map images
|
|
===============
|
|
*/
|
|
GLenum idImage::SelectInternalFormat( const byte **dataPtrs, int numDataPtrs, int width, int height,
|
|
textureDepth_t minimumDepth, bool *monochromeResult ) const {
|
|
int i, c;
|
|
const byte *scan;
|
|
int rgbOr, rgbAnd, aOr, aAnd;
|
|
int rgbDiffer, rgbaDiffer;
|
|
|
|
// determine if the rgb channels are all the same
|
|
// and if either all rgb or all alpha are 255
|
|
c = width*height;
|
|
rgbDiffer = 0;
|
|
rgbaDiffer = 0;
|
|
rgbOr = 0;
|
|
rgbAnd = -1;
|
|
aOr = 0;
|
|
aAnd = -1;
|
|
|
|
*monochromeResult = true; // until shown otherwise
|
|
|
|
for ( int side = 0 ; side < numDataPtrs ; side++ ) {
|
|
scan = dataPtrs[side];
|
|
for ( i = 0; i < c; i++, scan += 4 ) {
|
|
int cor, cand;
|
|
|
|
aOr |= scan[3];
|
|
aAnd &= scan[3];
|
|
|
|
cor = scan[0] | scan[1] | scan[2];
|
|
cand = scan[0] & scan[1] & scan[2];
|
|
|
|
// if rgb are all the same, the or and and will match
|
|
rgbDiffer |= ( cor ^ cand );
|
|
|
|
// our "isMonochrome" test is more lax than rgbDiffer,
|
|
// allowing the values to be off by several units and
|
|
// still use the NV20 mono path
|
|
if ( *monochromeResult ) {
|
|
if ( abs( scan[0] - scan[1] ) > 16
|
|
|| abs( scan[0] - scan[2] ) > 16 ) {
|
|
*monochromeResult = false;
|
|
}
|
|
}
|
|
|
|
rgbOr |= cor;
|
|
rgbAnd &= cand;
|
|
|
|
cor |= scan[3];
|
|
cand &= scan[3];
|
|
|
|
rgbaDiffer |= ( cor ^ cand );
|
|
}
|
|
}
|
|
|
|
// we assume that all 0 implies that the alpha channel isn't needed,
|
|
// because some tools will spit out 32 bit images with a 0 alpha instead
|
|
// of 255 alpha, but if the alpha actually is referenced, there will be
|
|
// different behavior in the compressed vs uncompressed states.
|
|
bool needAlpha;
|
|
if ( aAnd == 255 || aOr == 0 ) {
|
|
needAlpha = false;
|
|
} else {
|
|
needAlpha = true;
|
|
}
|
|
|
|
// catch normal maps first
|
|
if ( minimumDepth == TD_BUMP ) {
|
|
if ( globalImages->image_useCompression.GetBool() && globalImages->image_useNormalCompression.GetInteger() == 1 && glConfig.sharedTexturePaletteAvailable ) {
|
|
// image_useNormalCompression should only be set to 1 on nv_10 and nv_20 paths
|
|
return GL_COLOR_INDEX8_EXT;
|
|
} else if ( globalImages->image_useCompression.GetBool() && globalImages->image_useNormalCompression.GetInteger() && glConfig.textureCompressionAvailable ) {
|
|
// image_useNormalCompression == 2 uses rxgb format which produces really good quality for medium settings
|
|
return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
|
|
} else {
|
|
// we always need the alpha channel for bump maps for swizzling
|
|
return GL_RGBA8;
|
|
}
|
|
}
|
|
|
|
// allow a complete override of image compression with a cvar
|
|
if ( !globalImages->image_useCompression.GetBool() ) {
|
|
minimumDepth = TD_HIGH_QUALITY;
|
|
}
|
|
|
|
if ( minimumDepth == TD_SPECULAR ) {
|
|
// we are assuming that any alpha channel is unintentional
|
|
if ( glConfig.textureCompressionAvailable ) {
|
|
return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
|
|
} else {
|
|
return GL_RGB5;
|
|
}
|
|
}
|
|
if ( minimumDepth == TD_DIFFUSE ) {
|
|
// we might intentionally have an alpha channel for alpha tested textures
|
|
if ( glConfig.textureCompressionAvailable ) {
|
|
if ( !needAlpha ) {
|
|
return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
|
|
} else {
|
|
return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
|
|
}
|
|
} else if ( ( aAnd == 255 || aOr == 0 ) ) {
|
|
return GL_RGB5;
|
|
} else {
|
|
return GL_RGBA4;
|
|
}
|
|
}
|
|
|
|
// there will probably be some drivers that don't
|
|
// correctly handle the intensity/alpha/luminance/luminance+alpha
|
|
// formats, so provide a fallback that only uses the rgb/rgba formats
|
|
if ( !globalImages->image_useAllFormats.GetBool() ) {
|
|
// pretend rgb is varying and inconsistant, which
|
|
// prevents any of the more compact forms
|
|
rgbDiffer = 1;
|
|
rgbaDiffer = 1;
|
|
rgbAnd = 0;
|
|
}
|
|
|
|
// cases without alpha
|
|
if ( !needAlpha ) {
|
|
if ( minimumDepth == TD_HIGH_QUALITY ) {
|
|
return GL_RGB8; // four bytes
|
|
}
|
|
if ( glConfig.textureCompressionAvailable ) {
|
|
return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; // half byte
|
|
}
|
|
return GL_RGB5; // two bytes
|
|
}
|
|
|
|
// cases with alpha
|
|
if ( !rgbaDiffer ) {
|
|
if ( minimumDepth != TD_HIGH_QUALITY && glConfig.textureCompressionAvailable ) {
|
|
return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; // one byte
|
|
}
|
|
return GL_INTENSITY8; // single byte for all channels
|
|
}
|
|
|
|
#if 0
|
|
// we don't support alpha textures any more, because there
|
|
// is a discrepancy in the definition of TEX_ENV_COMBINE that
|
|
// causes them to be treated as 0 0 0 A, instead of 1 1 1 A as
|
|
// normal texture modulation treats them
|
|
if ( rgbAnd == 255 ) {
|
|
return GL_ALPHA8; // single byte, only alpha
|
|
}
|
|
#endif
|
|
|
|
if ( minimumDepth == TD_HIGH_QUALITY ) {
|
|
return GL_RGBA8; // four bytes
|
|
}
|
|
if ( glConfig.textureCompressionAvailable ) {
|
|
return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; // one byte
|
|
}
|
|
if ( !rgbDiffer ) {
|
|
return GL_LUMINANCE8_ALPHA8; // two bytes, max quality
|
|
}
|
|
return GL_RGBA4; // two bytes
|
|
}
|
|
|
|
/*
|
|
==================
|
|
SetImageFilterAndRepeat
|
|
==================
|
|
*/
|
|
void idImage::SetImageFilterAndRepeat() const {
|
|
// set the minimize / maximize filtering
|
|
switch( filter ) {
|
|
case TF_DEFAULT:
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, globalImages->textureMinFilter );
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, globalImages->textureMaxFilter );
|
|
break;
|
|
case TF_LINEAR:
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
break;
|
|
case TF_NEAREST:
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
|
|
break;
|
|
default:
|
|
common->FatalError( "R_CreateImage: bad texture filter" );
|
|
}
|
|
|
|
if ( glConfig.anisotropicAvailable ) {
|
|
// only do aniso filtering on mip mapped images
|
|
if ( filter == TF_DEFAULT ) {
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, globalImages->textureAnisotropy );
|
|
} else {
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1 );
|
|
}
|
|
}
|
|
if ( glConfig.textureLODBiasAvailable ) {
|
|
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS_EXT, globalImages->textureLODBias );
|
|
}
|
|
|
|
// set the wrap/clamp modes
|
|
switch( repeat ) {
|
|
case TR_REPEAT:
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
|
|
break;
|
|
case TR_CLAMP_TO_BORDER:
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER );
|
|
break;
|
|
case TR_CLAMP_TO_ZERO:
|
|
case TR_CLAMP_TO_ZERO_ALPHA:
|
|
case TR_CLAMP:
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
break;
|
|
default:
|
|
common->FatalError( "R_CreateImage: bad texture repeat" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idImage::Downsize
|
|
helper function that takes the current width/height and might make them smaller
|
|
================
|
|
*/
|
|
void idImage::GetDownsize( int &scaled_width, int &scaled_height ) const {
|
|
int size = 0;
|
|
|
|
// perform optional picmip operation to save texture memory
|
|
if ( depth == TD_SPECULAR && globalImages->image_downSizeSpecular.GetInteger() ) {
|
|
size = globalImages->image_downSizeSpecularLimit.GetInteger();
|
|
if ( size == 0 ) {
|
|
size = 64;
|
|
}
|
|
} else if ( depth == TD_BUMP && globalImages->image_downSizeBump.GetInteger() ) {
|
|
size = globalImages->image_downSizeBumpLimit.GetInteger();
|
|
if ( size == 0 ) {
|
|
size = 64;
|
|
}
|
|
} else if ( ( allowDownSize || globalImages->image_forceDownSize.GetBool() ) && globalImages->image_downSize.GetInteger() ) {
|
|
size = globalImages->image_downSizeLimit.GetInteger();
|
|
if ( size == 0 ) {
|
|
size = 256;
|
|
}
|
|
}
|
|
|
|
if ( size > 0 ) {
|
|
while ( scaled_width > size || scaled_height > size ) {
|
|
if ( scaled_width > 1 ) {
|
|
scaled_width >>= 1;
|
|
}
|
|
if ( scaled_height > 1 ) {
|
|
scaled_height >>= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// clamp to minimum size
|
|
if ( scaled_width < 1 ) {
|
|
scaled_width = 1;
|
|
}
|
|
if ( scaled_height < 1 ) {
|
|
scaled_height = 1;
|
|
}
|
|
|
|
// clamp size to the hardware specific upper limit
|
|
// scale both axis down equally so we don't have to
|
|
// deal with a half mip resampling
|
|
// This causes a 512*256 texture to sample down to
|
|
// 256*128 on a voodoo3, even though it could be 256*256
|
|
while ( scaled_width > glConfig.maxTextureSize
|
|
|| scaled_height > glConfig.maxTextureSize ) {
|
|
scaled_width >>= 1;
|
|
scaled_height >>= 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
GenerateImage
|
|
|
|
The alpha channel bytes should be 255 if you don't
|
|
want the channel.
|
|
|
|
We need a material characteristic to ask for specific texture modes.
|
|
|
|
Designed limitations of flexibility:
|
|
|
|
No support for texture borders.
|
|
|
|
No support for texture border color.
|
|
|
|
No support for texture environment colors or GL_BLEND or GL_DECAL
|
|
texture environments, because the automatic optimization to single
|
|
or dual component textures makes those modes potentially undefined.
|
|
|
|
No non-power-of-two images.
|
|
|
|
No palettized textures.
|
|
|
|
There is no way to specify separate wrap/clamp values for S and T
|
|
|
|
There is no way to specify explicit mip map levels
|
|
|
|
================
|
|
*/
|
|
void idImage::GenerateImage( const byte *pic, int width, int height,
|
|
textureFilter_t filterParm, bool allowDownSizeParm,
|
|
textureRepeat_t repeatParm, textureDepth_t depthParm ) {
|
|
bool preserveBorder;
|
|
byte *scaledBuffer;
|
|
int scaled_width, scaled_height;
|
|
byte *shrunk;
|
|
|
|
PurgeImage();
|
|
|
|
filter = filterParm;
|
|
allowDownSize = allowDownSizeParm;
|
|
repeat = repeatParm;
|
|
depth = depthParm;
|
|
|
|
// if we don't have a rendering context, just return after we
|
|
// have filled in the parms. We must have the values set, or
|
|
// an image match from a shader before OpenGL starts would miss
|
|
// the generated texture
|
|
if ( !glConfig.isInitialized ) {
|
|
return;
|
|
}
|
|
|
|
// don't let mip mapping smear the texture into the clamped border
|
|
if ( repeat == TR_CLAMP_TO_ZERO ) {
|
|
preserveBorder = true;
|
|
} else {
|
|
preserveBorder = false;
|
|
}
|
|
|
|
// make sure it is a power of 2
|
|
scaled_width = MakePowerOfTwo( width );
|
|
scaled_height = MakePowerOfTwo( height );
|
|
|
|
if ( scaled_width != width || scaled_height != height ) {
|
|
common->Error( "R_CreateImage: not a power of 2 image" );
|
|
}
|
|
|
|
// Optionally modify our width/height based on options/hardware
|
|
GetDownsize( scaled_width, scaled_height );
|
|
|
|
scaledBuffer = NULL;
|
|
|
|
// generate the texture number
|
|
qglGenTextures( 1, &texnum );
|
|
|
|
// select proper internal format before we resample
|
|
internalFormat = SelectInternalFormat( &pic, 1, width, height, depth, &isMonochrome );
|
|
|
|
// copy or resample data as appropriate for first MIP level
|
|
if ( ( scaled_width == width ) && ( scaled_height == height ) ) {
|
|
// we must copy even if unchanged, because the border zeroing
|
|
// would otherwise modify const data
|
|
scaledBuffer = (byte *)R_StaticAlloc( sizeof( unsigned ) * scaled_width * scaled_height );
|
|
memcpy (scaledBuffer, pic, width*height*4);
|
|
} else {
|
|
// resample down as needed (FIXME: this doesn't seem like it resamples anymore!)
|
|
// scaledBuffer = R_ResampleTexture( pic, width, height, width >>= 1, height >>= 1 );
|
|
scaledBuffer = R_MipMap( pic, width, height, preserveBorder );
|
|
width >>= 1;
|
|
height >>= 1;
|
|
if ( width < 1 ) {
|
|
width = 1;
|
|
}
|
|
if ( height < 1 ) {
|
|
height = 1;
|
|
}
|
|
|
|
while ( width > scaled_width || height > scaled_height ) {
|
|
shrunk = R_MipMap( scaledBuffer, width, height, preserveBorder );
|
|
R_StaticFree( scaledBuffer );
|
|
scaledBuffer = shrunk;
|
|
|
|
width >>= 1;
|
|
height >>= 1;
|
|
if ( width < 1 ) {
|
|
width = 1;
|
|
}
|
|
if ( height < 1 ) {
|
|
height = 1;
|
|
}
|
|
}
|
|
|
|
// one might have shrunk down below the target size
|
|
scaled_width = width;
|
|
scaled_height = height;
|
|
}
|
|
|
|
uploadHeight = scaled_height;
|
|
uploadWidth = scaled_width;
|
|
type = TT_2D;
|
|
|
|
// zero the border if desired, allowing clamped projection textures
|
|
// even after picmip resampling or careless artists.
|
|
if ( repeat == TR_CLAMP_TO_ZERO ) {
|
|
byte rgba[4];
|
|
|
|
rgba[0] = rgba[1] = rgba[2] = 0;
|
|
rgba[3] = 255;
|
|
R_SetBorderTexels( (byte *)scaledBuffer, width, height, rgba );
|
|
}
|
|
if ( repeat == TR_CLAMP_TO_ZERO_ALPHA ) {
|
|
byte rgba[4];
|
|
|
|
rgba[0] = rgba[1] = rgba[2] = 255;
|
|
rgba[3] = 0;
|
|
R_SetBorderTexels( (byte *)scaledBuffer, width, height, rgba );
|
|
}
|
|
|
|
if ( generatorFunction == NULL && ( depth == TD_BUMP && globalImages->image_writeNormalTGA.GetBool() || depth != TD_BUMP && globalImages->image_writeTGA.GetBool() ) ) {
|
|
// Optionally write out the texture to a .tga
|
|
char filename[MAX_IMAGE_NAME];
|
|
ImageProgramStringToCompressedFileName( imgName, filename );
|
|
char *ext = strrchr(filename, '.');
|
|
if ( ext ) {
|
|
strcpy( ext, ".tga" );
|
|
// swap the red/alpha for the write
|
|
/*
|
|
if ( depth == TD_BUMP ) {
|
|
for ( int i = 0; i < scaled_width * scaled_height * 4; i += 4 ) {
|
|
scaledBuffer[ i ] = scaledBuffer[ i + 3 ];
|
|
scaledBuffer[ i + 3 ] = 0;
|
|
}
|
|
}
|
|
*/
|
|
R_WriteTGA( filename, scaledBuffer, scaled_width, scaled_height, false );
|
|
|
|
// put it back
|
|
/*
|
|
if ( depth == TD_BUMP ) {
|
|
for ( int i = 0; i < scaled_width * scaled_height * 4; i += 4 ) {
|
|
scaledBuffer[ i + 3 ] = scaledBuffer[ i ];
|
|
scaledBuffer[ i ] = 0;
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
// swap the red and alpha for rxgb support
|
|
// do this even on tga normal maps so we only have to use
|
|
// one fragment program
|
|
// if the image is precompressed ( either in palletized mode or true rxgb mode )
|
|
// then it is loaded above and the swap never happens here
|
|
if ( depth == TD_BUMP && globalImages->image_useNormalCompression.GetInteger() != 1 ) {
|
|
for ( int i = 0; i < scaled_width * scaled_height * 4; i += 4 ) {
|
|
scaledBuffer[ i + 3 ] = scaledBuffer[ i ];
|
|
scaledBuffer[ i ] = 0;
|
|
}
|
|
}
|
|
// upload the main image level
|
|
Bind();
|
|
|
|
|
|
if ( internalFormat == GL_COLOR_INDEX8_EXT ) {
|
|
/*
|
|
if ( depth == TD_BUMP ) {
|
|
for ( int i = 0; i < scaled_width * scaled_height * 4; i += 4 ) {
|
|
scaledBuffer[ i ] = scaledBuffer[ i + 3 ];
|
|
scaledBuffer[ i + 3 ] = 0;
|
|
}
|
|
}
|
|
*/
|
|
UploadCompressedNormalMap( scaled_width, scaled_height, scaledBuffer, 0 );
|
|
} else {
|
|
qglTexImage2D( GL_TEXTURE_2D, 0, internalFormat, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaledBuffer );
|
|
}
|
|
|
|
// create and upload the mip map levels, which we do in all cases, even if we don't think they are needed
|
|
int miplevel;
|
|
|
|
miplevel = 0;
|
|
while ( scaled_width > 1 || scaled_height > 1 ) {
|
|
// preserve the border after mip map unless repeating
|
|
shrunk = R_MipMap( scaledBuffer, scaled_width, scaled_height, preserveBorder );
|
|
R_StaticFree( scaledBuffer );
|
|
scaledBuffer = shrunk;
|
|
|
|
scaled_width >>= 1;
|
|
scaled_height >>= 1;
|
|
if ( scaled_width < 1 ) {
|
|
scaled_width = 1;
|
|
}
|
|
if ( scaled_height < 1 ) {
|
|
scaled_height = 1;
|
|
}
|
|
miplevel++;
|
|
|
|
// this is a visualization tool that shades each mip map
|
|
// level with a different color so you can see the
|
|
// rasterizer's texture level selection algorithm
|
|
// Changing the color doesn't help with lumminance/alpha/intensity formats...
|
|
if ( depth == TD_DIFFUSE && globalImages->image_colorMipLevels.GetBool() ) {
|
|
R_BlendOverTexture( (byte *)scaledBuffer, scaled_width * scaled_height, mipBlendColors[miplevel] );
|
|
}
|
|
|
|
// upload the mip map
|
|
if ( internalFormat == GL_COLOR_INDEX8_EXT ) {
|
|
UploadCompressedNormalMap( scaled_width, scaled_height, scaledBuffer, miplevel );
|
|
} else {
|
|
qglTexImage2D( GL_TEXTURE_2D, miplevel, internalFormat, scaled_width, scaled_height,
|
|
0, GL_RGBA, GL_UNSIGNED_BYTE, scaledBuffer );
|
|
}
|
|
}
|
|
|
|
if ( scaledBuffer != 0 ) {
|
|
R_StaticFree( scaledBuffer );
|
|
}
|
|
|
|
SetImageFilterAndRepeat();
|
|
|
|
// see if we messed anything up
|
|
GL_CheckErrors();
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
Generate3DImage
|
|
==================
|
|
*/
|
|
void idImage::Generate3DImage( const byte *pic, int width, int height, int picDepth,
|
|
textureFilter_t filterParm, bool allowDownSizeParm,
|
|
textureRepeat_t repeatParm, textureDepth_t minDepthParm ) {
|
|
int scaled_width, scaled_height, scaled_depth;
|
|
|
|
PurgeImage();
|
|
|
|
filter = filterParm;
|
|
allowDownSize = allowDownSizeParm;
|
|
repeat = repeatParm;
|
|
depth = minDepthParm;
|
|
|
|
// if we don't have a rendering context, just return after we
|
|
// have filled in the parms. We must have the values set, or
|
|
// an image match from a shader before OpenGL starts would miss
|
|
// the generated texture
|
|
if ( !glConfig.isInitialized ) {
|
|
return;
|
|
}
|
|
|
|
// make sure it is a power of 2
|
|
scaled_width = MakePowerOfTwo( width );
|
|
scaled_height = MakePowerOfTwo( height );
|
|
scaled_depth = MakePowerOfTwo( picDepth );
|
|
if ( scaled_width != width || scaled_height != height || scaled_depth != picDepth ) {
|
|
common->Error( "R_Create3DImage: not a power of 2 image" );
|
|
}
|
|
|
|
// FIXME: allow picmip here
|
|
|
|
// generate the texture number
|
|
qglGenTextures( 1, &texnum );
|
|
|
|
// select proper internal format before we resample
|
|
// this function doesn't need to know it is 3D, so just make it very "tall"
|
|
internalFormat = SelectInternalFormat( &pic, 1, width, height * picDepth, minDepthParm, &isMonochrome );
|
|
|
|
uploadHeight = scaled_height;
|
|
uploadWidth = scaled_width;
|
|
uploadDepth = scaled_depth;
|
|
|
|
|
|
type = TT_3D;
|
|
|
|
// upload the main image level
|
|
Bind();
|
|
|
|
qglTexImage3D(GL_TEXTURE_3D, 0, internalFormat, scaled_width, scaled_height, scaled_depth,
|
|
0, GL_RGBA, GL_UNSIGNED_BYTE, pic );
|
|
|
|
// create and upload the mip map levels
|
|
int miplevel;
|
|
byte *scaledBuffer, *shrunk;
|
|
|
|
scaledBuffer = (byte *)R_StaticAlloc( scaled_width * scaled_height * scaled_depth * 4 );
|
|
memcpy( scaledBuffer, pic, scaled_width * scaled_height * scaled_depth * 4 );
|
|
miplevel = 0;
|
|
while ( scaled_width > 1 || scaled_height > 1 || scaled_depth > 1 ) {
|
|
// preserve the border after mip map unless repeating
|
|
shrunk = R_MipMap3D( scaledBuffer, scaled_width, scaled_height, scaled_depth,
|
|
(bool)(repeat != TR_REPEAT) );
|
|
R_StaticFree( scaledBuffer );
|
|
scaledBuffer = shrunk;
|
|
|
|
scaled_width >>= 1;
|
|
scaled_height >>= 1;
|
|
scaled_depth >>= 1;
|
|
if ( scaled_width < 1 ) {
|
|
scaled_width = 1;
|
|
}
|
|
if ( scaled_height < 1 ) {
|
|
scaled_height = 1;
|
|
}
|
|
if ( scaled_depth < 1 ) {
|
|
scaled_depth = 1;
|
|
}
|
|
miplevel++;
|
|
|
|
// upload the mip map
|
|
qglTexImage3D(GL_TEXTURE_3D, miplevel, internalFormat, scaled_width, scaled_height, scaled_depth,
|
|
0, GL_RGBA, GL_UNSIGNED_BYTE, scaledBuffer );
|
|
}
|
|
R_StaticFree( scaledBuffer );
|
|
|
|
// set the minimize / maximize filtering
|
|
switch( filter ) {
|
|
case TF_DEFAULT:
|
|
qglTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, globalImages->textureMinFilter );
|
|
qglTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, globalImages->textureMaxFilter );
|
|
break;
|
|
case TF_LINEAR:
|
|
qglTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
qglTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
break;
|
|
case TF_NEAREST:
|
|
qglTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
|
|
qglTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
|
|
break;
|
|
default:
|
|
common->FatalError( "R_CreateImage: bad texture filter" );
|
|
}
|
|
|
|
// set the wrap/clamp modes
|
|
switch( repeat ) {
|
|
case TR_REPEAT:
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT );
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT );
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT );
|
|
break;
|
|
case TR_CLAMP_TO_BORDER:
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER );
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER );
|
|
break;
|
|
case TR_CLAMP_TO_ZERO:
|
|
case TR_CLAMP_TO_ZERO_ALPHA:
|
|
case TR_CLAMP:
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
qglTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
|
|
break;
|
|
default:
|
|
common->FatalError( "R_CreateImage: bad texture repeat" );
|
|
}
|
|
|
|
// see if we messed anything up
|
|
GL_CheckErrors();
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
GenerateCubeImage
|
|
|
|
Non-square cube sides are not allowed
|
|
====================
|
|
*/
|
|
void idImage::GenerateCubeImage( const byte *pic[6], int size,
|
|
textureFilter_t filterParm, bool allowDownSizeParm,
|
|
textureDepth_t depthParm ) {
|
|
int scaled_width, scaled_height;
|
|
int width, height;
|
|
int i;
|
|
|
|
PurgeImage();
|
|
|
|
filter = filterParm;
|
|
allowDownSize = allowDownSizeParm;
|
|
depth = depthParm;
|
|
|
|
type = TT_CUBIC;
|
|
|
|
// if we don't have a rendering context, just return after we
|
|
// have filled in the parms. We must have the values set, or
|
|
// an image match from a shader before OpenGL starts would miss
|
|
// the generated texture
|
|
if ( !glConfig.isInitialized ) {
|
|
return;
|
|
}
|
|
|
|
if ( ! glConfig.cubeMapAvailable ) {
|
|
return;
|
|
}
|
|
|
|
width = height = size;
|
|
|
|
// generate the texture number
|
|
qglGenTextures( 1, &texnum );
|
|
|
|
// select proper internal format before we resample
|
|
internalFormat = SelectInternalFormat( pic, 6, width, height, depth, &isMonochrome );
|
|
|
|
// don't bother with downsample for now
|
|
scaled_width = width;
|
|
scaled_height = height;
|
|
|
|
uploadHeight = scaled_height;
|
|
uploadWidth = scaled_width;
|
|
|
|
Bind();
|
|
|
|
// no other clamp mode makes sense
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
// set the minimize / maximize filtering
|
|
switch( filter ) {
|
|
case TF_DEFAULT:
|
|
qglTexParameterf(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MIN_FILTER, globalImages->textureMinFilter );
|
|
qglTexParameterf(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, globalImages->textureMaxFilter );
|
|
break;
|
|
case TF_LINEAR:
|
|
qglTexParameterf(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
qglTexParameterf(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
break;
|
|
case TF_NEAREST:
|
|
qglTexParameterf(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
|
|
qglTexParameterf(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
|
|
break;
|
|
default:
|
|
common->FatalError( "R_CreateImage: bad texture filter" );
|
|
}
|
|
|
|
// upload the base level
|
|
// FIXME: support GL_COLOR_INDEX8_EXT?
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
qglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT+i, 0, internalFormat, scaled_width, scaled_height, 0,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, pic[i] );
|
|
}
|
|
|
|
|
|
// create and upload the mip map levels
|
|
int miplevel;
|
|
byte *shrunk[6];
|
|
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
shrunk[i] = R_MipMap( pic[i], scaled_width, scaled_height, false );
|
|
}
|
|
|
|
miplevel = 1;
|
|
while ( scaled_width > 1 ) {
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
byte *shrunken;
|
|
|
|
qglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT+i, miplevel, internalFormat,
|
|
scaled_width / 2, scaled_height / 2, 0,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, shrunk[i] );
|
|
|
|
if ( scaled_width > 2 ) {
|
|
shrunken = R_MipMap( shrunk[i], scaled_width/2, scaled_height/2, false );
|
|
} else {
|
|
shrunken = NULL;
|
|
}
|
|
|
|
R_StaticFree( shrunk[i] );
|
|
shrunk[i] = shrunken;
|
|
}
|
|
|
|
scaled_width >>= 1;
|
|
scaled_height >>= 1;
|
|
miplevel++;
|
|
}
|
|
|
|
// see if we messed anything up
|
|
GL_CheckErrors();
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
ImageProgramStringToFileCompressedFileName
|
|
================
|
|
*/
|
|
void idImage::ImageProgramStringToCompressedFileName( const char *imageProg, char *fileName ) const {
|
|
const char *s;
|
|
char *f;
|
|
|
|
strcpy( fileName, "dds/" );
|
|
f = fileName + strlen( fileName );
|
|
|
|
int depth = 0;
|
|
|
|
// convert all illegal characters to underscores
|
|
// this could conceivably produce a duplicated mapping, but we aren't going to worry about it
|
|
for ( s = imageProg ; *s ; s++ ) {
|
|
if ( *s == '/' || *s == '\\' || *s == '(') {
|
|
if ( depth < 4 ) {
|
|
*f = '/';
|
|
depth ++;
|
|
} else {
|
|
*f = ' ';
|
|
}
|
|
f++;
|
|
} else if ( *s == '<' || *s == '>' || *s == ':' || *s == '|' || *s == '"' || *s == '.' ) {
|
|
*f = '_';
|
|
f++;
|
|
} else if ( *s == ' ' && *(f-1) == '/' ) { // ignore a space right after a slash
|
|
} else if ( *s == ')' || *s == ',' ) { // always ignore these
|
|
} else {
|
|
*f = *s;
|
|
f++;
|
|
}
|
|
}
|
|
*f++ = 0;
|
|
strcat( fileName, ".dds" );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
NumLevelsForImageSize
|
|
==================
|
|
*/
|
|
int idImage::NumLevelsForImageSize( int width, int height ) const {
|
|
int numLevels = 1;
|
|
|
|
while ( width > 1 || height > 1 ) {
|
|
numLevels++;
|
|
width >>= 1;
|
|
height >>= 1;
|
|
}
|
|
|
|
return numLevels;
|
|
}
|
|
|
|
/*
|
|
================
|
|
WritePrecompressedImage
|
|
|
|
When we are happy with our source data, we can write out precompressed
|
|
versions of everything to speed future load times.
|
|
================
|
|
*/
|
|
void idImage::WritePrecompressedImage() {
|
|
|
|
// Always write the precompressed image if we're making a build
|
|
if ( !com_makingBuild.GetBool() ) {
|
|
if ( !globalImages->image_writePrecompressedTextures.GetBool() || !globalImages->image_usePrecompressedTextures.GetBool() ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( !glConfig.isInitialized ) {
|
|
return;
|
|
}
|
|
|
|
char filename[MAX_IMAGE_NAME];
|
|
ImageProgramStringToCompressedFileName( imgName, filename );
|
|
|
|
|
|
|
|
int numLevels = NumLevelsForImageSize( uploadWidth, uploadHeight );
|
|
if ( numLevels > MAX_TEXTURE_LEVELS ) {
|
|
common->Warning( "R_WritePrecompressedImage: level > MAX_TEXTURE_LEVELS for image %s", filename );
|
|
return;
|
|
}
|
|
|
|
// glGetTexImage only supports a small subset of all the available internal formats
|
|
// We have to use BGRA because DDS is a windows based format
|
|
int altInternalFormat = 0;
|
|
int bitSize = 0;
|
|
switch ( internalFormat ) {
|
|
case GL_COLOR_INDEX8_EXT:
|
|
case GL_COLOR_INDEX:
|
|
// this will not work with dds viewers but we need it in this format to save disk
|
|
// load speed ( i.e. size )
|
|
altInternalFormat = GL_COLOR_INDEX;
|
|
bitSize = 24;
|
|
break;
|
|
case 1:
|
|
case GL_INTENSITY8:
|
|
case GL_LUMINANCE8:
|
|
case 3:
|
|
case GL_RGB8:
|
|
altInternalFormat = GL_BGR_EXT;
|
|
bitSize = 24;
|
|
break;
|
|
case GL_LUMINANCE8_ALPHA8:
|
|
case 4:
|
|
case GL_RGBA8:
|
|
altInternalFormat = GL_BGRA_EXT;
|
|
bitSize = 32;
|
|
break;
|
|
case GL_ALPHA8:
|
|
altInternalFormat = GL_ALPHA;
|
|
bitSize = 8;
|
|
break;
|
|
default:
|
|
if ( FormatIsDXT( internalFormat ) ) {
|
|
altInternalFormat = internalFormat;
|
|
} else {
|
|
common->Warning("Unknown or unsupported format for %s", filename);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( globalImages->image_useOffLineCompression.GetBool() && FormatIsDXT( altInternalFormat ) ) {
|
|
idStr outFile = fileSystem->RelativePathToOSPath( filename, "fs_basepath" );
|
|
idStr inFile = outFile;
|
|
inFile.StripFileExtension();
|
|
inFile.SetFileExtension( "tga" );
|
|
idStr format;
|
|
if ( depth == TD_BUMP ) {
|
|
format = "RXGB +red 0.0 +green 0.5 +blue 0.5";
|
|
} else {
|
|
switch ( altInternalFormat ) {
|
|
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
|
|
format = "DXT1";
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
|
|
format = "DXT1 -alpha_threshold";
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
|
|
format = "DXT3";
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
|
|
format = "DXT5";
|
|
break;
|
|
}
|
|
}
|
|
globalImages->AddDDSCommand( va( "z:/d3xp/compressonator/thecompressonator -convert \"%s\" \"%s\" %s -mipmaps\n", inFile.c_str(), outFile.c_str(), format.c_str() ) );
|
|
return;
|
|
}
|
|
|
|
|
|
ddsFileHeader_t header;
|
|
memset( &header, 0, sizeof(header) );
|
|
header.dwSize = sizeof(header);
|
|
header.dwFlags = DDSF_CAPS | DDSF_PIXELFORMAT | DDSF_WIDTH | DDSF_HEIGHT;
|
|
header.dwHeight = uploadHeight;
|
|
header.dwWidth = uploadWidth;
|
|
|
|
// hack in our monochrome flag for the NV20 optimization
|
|
if ( isMonochrome ) {
|
|
header.dwFlags |= DDSF_ID_MONOCHROME;
|
|
}
|
|
|
|
if ( FormatIsDXT( altInternalFormat ) ) {
|
|
// size (in bytes) of the compressed base image
|
|
header.dwFlags |= DDSF_LINEARSIZE;
|
|
header.dwPitchOrLinearSize = ( ( uploadWidth + 3 ) / 4 ) * ( ( uploadHeight + 3 ) / 4 )*
|
|
(altInternalFormat <= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ? 8 : 16);
|
|
}
|
|
else {
|
|
// 4 Byte aligned line width (from nv_dds)
|
|
header.dwFlags |= DDSF_PITCH;
|
|
header.dwPitchOrLinearSize = ( ( uploadWidth * bitSize + 31 ) & -32 ) >> 3;
|
|
}
|
|
|
|
header.dwCaps1 = DDSF_TEXTURE;
|
|
|
|
if ( numLevels > 1 ) {
|
|
header.dwMipMapCount = numLevels;
|
|
header.dwFlags |= DDSF_MIPMAPCOUNT;
|
|
header.dwCaps1 |= DDSF_MIPMAP | DDSF_COMPLEX;
|
|
}
|
|
|
|
header.ddspf.dwSize = sizeof(header.ddspf);
|
|
if ( FormatIsDXT( altInternalFormat ) ) {
|
|
header.ddspf.dwFlags = DDSF_FOURCC;
|
|
switch ( altInternalFormat ) {
|
|
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
|
|
header.ddspf.dwFourCC = DDS_MAKEFOURCC('D','X','T','1');
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
|
|
header.ddspf.dwFlags |= DDSF_ALPHAPIXELS;
|
|
header.ddspf.dwFourCC = DDS_MAKEFOURCC('D','X','T','1');
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
|
|
header.ddspf.dwFourCC = DDS_MAKEFOURCC('D','X','T','3');
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
|
|
header.ddspf.dwFourCC = DDS_MAKEFOURCC('D','X','T','5');
|
|
break;
|
|
}
|
|
} else {
|
|
header.ddspf.dwFlags = ( internalFormat == GL_COLOR_INDEX8_EXT ) ? DDSF_RGB | DDSF_ID_INDEXCOLOR : DDSF_RGB;
|
|
header.ddspf.dwRGBBitCount = bitSize;
|
|
switch ( altInternalFormat ) {
|
|
case GL_BGRA_EXT:
|
|
case GL_LUMINANCE_ALPHA:
|
|
header.ddspf.dwFlags |= DDSF_ALPHAPIXELS;
|
|
header.ddspf.dwABitMask = 0xFF000000;
|
|
// Fall through
|
|
case GL_BGR_EXT:
|
|
case GL_LUMINANCE:
|
|
case GL_COLOR_INDEX:
|
|
header.ddspf.dwRBitMask = 0x00FF0000;
|
|
header.ddspf.dwGBitMask = 0x0000FF00;
|
|
header.ddspf.dwBBitMask = 0x000000FF;
|
|
break;
|
|
case GL_ALPHA:
|
|
header.ddspf.dwFlags = DDSF_ALPHAPIXELS;
|
|
header.ddspf.dwABitMask = 0xFF000000;
|
|
break;
|
|
default:
|
|
common->Warning( "Unknown or unsupported format for %s", filename );
|
|
return;
|
|
}
|
|
}
|
|
|
|
idFile *f = fileSystem->OpenFileWrite( filename );
|
|
if ( f == NULL ) {
|
|
common->Warning( "Could not open %s trying to write precompressed image", filename );
|
|
return;
|
|
}
|
|
common->Printf( "Writing precompressed image: %s\n", filename );
|
|
|
|
f->Write( "DDS ", 4 );
|
|
f->Write( &header, sizeof(header) );
|
|
|
|
// bind to the image so we can read back the contents
|
|
Bind();
|
|
|
|
qglPixelStorei( GL_PACK_ALIGNMENT, 1 ); // otherwise small rows get padded to 32 bits
|
|
|
|
int uw = uploadWidth;
|
|
int uh = uploadHeight;
|
|
|
|
// Will be allocated first time through the loop
|
|
byte *data = NULL;
|
|
|
|
for ( int level = 0 ; level < numLevels ; level++ ) {
|
|
|
|
int size = 0;
|
|
if ( FormatIsDXT( altInternalFormat ) ) {
|
|
size = ( ( uw + 3 ) / 4 ) * ( ( uh + 3 ) / 4 ) *
|
|
(altInternalFormat <= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ? 8 : 16);
|
|
} else {
|
|
size = uw * uh * (bitSize / 8);
|
|
}
|
|
|
|
if (data == NULL) {
|
|
data = (byte *)R_StaticAlloc( size );
|
|
}
|
|
|
|
if ( FormatIsDXT( altInternalFormat ) ) {
|
|
qglGetCompressedTexImageARB( GL_TEXTURE_2D, level, data );
|
|
} else {
|
|
qglGetTexImage( GL_TEXTURE_2D, level, altInternalFormat, GL_UNSIGNED_BYTE, data );
|
|
}
|
|
|
|
f->Write( data, size );
|
|
|
|
uw /= 2;
|
|
uh /= 2;
|
|
if (uw < 1) {
|
|
uw = 1;
|
|
}
|
|
if (uh < 1) {
|
|
uh = 1;
|
|
}
|
|
}
|
|
|
|
if (data != NULL) {
|
|
R_StaticFree( data );
|
|
}
|
|
|
|
fileSystem->CloseFile( f );
|
|
}
|
|
|
|
/*
|
|
================
|
|
ShouldImageBePartialCached
|
|
|
|
Returns true if there is a precompressed image, and it is large enough
|
|
to be worth caching
|
|
================
|
|
*/
|
|
bool idImage::ShouldImageBePartialCached() {
|
|
if ( !glConfig.textureCompressionAvailable ) {
|
|
return false;
|
|
}
|
|
|
|
if ( !globalImages->image_useCache.GetBool() ) {
|
|
return false;
|
|
}
|
|
|
|
// the allowDownSize flag does double-duty as don't-partial-load
|
|
if ( !allowDownSize ) {
|
|
return false;
|
|
}
|
|
|
|
if ( globalImages->image_cacheMinK.GetInteger() <= 0 ) {
|
|
return false;
|
|
}
|
|
|
|
// if we are doing a copyFiles, make sure the original images are referenced
|
|
if ( fileSystem->PerformingCopyFiles() ) {
|
|
return false;
|
|
}
|
|
|
|
char filename[MAX_IMAGE_NAME];
|
|
ImageProgramStringToCompressedFileName( imgName, filename );
|
|
|
|
// get the file timestamp
|
|
fileSystem->ReadFile( filename, NULL, ×tamp );
|
|
|
|
if ( timestamp == FILE_NOT_FOUND_TIMESTAMP ) {
|
|
return false;
|
|
}
|
|
|
|
// open it and get the file size
|
|
idFile *f;
|
|
|
|
f = fileSystem->OpenFileRead( filename );
|
|
if ( !f ) {
|
|
return false;
|
|
}
|
|
|
|
int len = f->Length();
|
|
fileSystem->CloseFile( f );
|
|
|
|
if ( len <= globalImages->image_cacheMinK.GetInteger() * 1024 ) {
|
|
return false;
|
|
}
|
|
|
|
// we do want to do a partial load
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
CheckPrecompressedImage
|
|
|
|
If fullLoad is false, only the small mip levels of the image will be loaded
|
|
================
|
|
*/
|
|
bool idImage::CheckPrecompressedImage( bool fullLoad ) {
|
|
if ( !glConfig.isInitialized || !glConfig.textureCompressionAvailable ) {
|
|
return false;
|
|
}
|
|
|
|
#if 1 // ( _D3XP had disabled ) - Allow grabbing of DDS's from original Doom pak files
|
|
// if we are doing a copyFiles, make sure the original images are referenced
|
|
if ( fileSystem->PerformingCopyFiles() ) {
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
if ( depth == TD_BUMP && globalImages->image_useNormalCompression.GetInteger() != 2 ) {
|
|
return false;
|
|
}
|
|
|
|
// god i love last minute hacks :-)
|
|
if ( com_machineSpec.GetInteger() >= 1 && com_videoRam.GetInteger() >= 128 && imgName.Icmpn( "lights/", 7 ) == 0 ) {
|
|
return false;
|
|
}
|
|
|
|
char filename[MAX_IMAGE_NAME];
|
|
ImageProgramStringToCompressedFileName( imgName, filename );
|
|
|
|
// get the file timestamp
|
|
ID_TIME_T precompTimestamp;
|
|
fileSystem->ReadFile( filename, NULL, &precompTimestamp );
|
|
|
|
|
|
if ( precompTimestamp == FILE_NOT_FOUND_TIMESTAMP ) {
|
|
return false;
|
|
}
|
|
|
|
if ( !generatorFunction && timestamp != FILE_NOT_FOUND_TIMESTAMP ) {
|
|
if ( precompTimestamp < timestamp ) {
|
|
// The image has changed after being precompressed
|
|
return false;
|
|
}
|
|
}
|
|
|
|
timestamp = precompTimestamp;
|
|
|
|
// open it and just read the header
|
|
idFile *f;
|
|
|
|
f = fileSystem->OpenFileRead( filename );
|
|
if ( !f ) {
|
|
return false;
|
|
}
|
|
|
|
int len = f->Length();
|
|
if ( len < sizeof( ddsFileHeader_t ) ) {
|
|
fileSystem->CloseFile( f );
|
|
return false;
|
|
}
|
|
|
|
if ( !fullLoad && len > globalImages->image_cacheMinK.GetInteger() * 1024 ) {
|
|
len = globalImages->image_cacheMinK.GetInteger() * 1024;
|
|
}
|
|
|
|
byte *data = (byte *)R_StaticAlloc( len );
|
|
|
|
f->Read( data, len );
|
|
|
|
fileSystem->CloseFile( f );
|
|
|
|
// flibit: 64 bit fix, changed long to int
|
|
unsigned int magic = LittleLong( *(unsigned int *)data );
|
|
// flibit end
|
|
ddsFileHeader_t *_header = (ddsFileHeader_t *)(data + 4);
|
|
int ddspf_dwFlags = LittleLong( _header->ddspf.dwFlags );
|
|
|
|
if ( magic != DDS_MAKEFOURCC('D', 'D', 'S', ' ')) {
|
|
common->Printf( "CheckPrecompressedImage( %s ): magic != 'DDS '\n", imgName.c_str() );
|
|
R_StaticFree( data );
|
|
return false;
|
|
}
|
|
|
|
// if we don't support color index textures, we must load the full image
|
|
// should we just expand the 256 color image to 32 bit for upload?
|
|
if ( ddspf_dwFlags & DDSF_ID_INDEXCOLOR && !glConfig.sharedTexturePaletteAvailable ) {
|
|
R_StaticFree( data );
|
|
return false;
|
|
}
|
|
|
|
// upload all the levels
|
|
UploadPrecompressedImage( data, len );
|
|
|
|
R_StaticFree( data );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
UploadPrecompressedImage
|
|
|
|
This can be called by the front end during nromal loading,
|
|
or by the backend after a background read of the file
|
|
has completed
|
|
===================
|
|
*/
|
|
void idImage::UploadPrecompressedImage( byte *data, int len ) {
|
|
ddsFileHeader_t *header = (ddsFileHeader_t *)(data + 4);
|
|
|
|
// ( not byte swapping dwReserved1 dwReserved2 )
|
|
header->dwSize = LittleLong( header->dwSize );
|
|
header->dwFlags = LittleLong( header->dwFlags );
|
|
header->dwHeight = LittleLong( header->dwHeight );
|
|
header->dwWidth = LittleLong( header->dwWidth );
|
|
header->dwPitchOrLinearSize = LittleLong( header->dwPitchOrLinearSize );
|
|
header->dwDepth = LittleLong( header->dwDepth );
|
|
header->dwMipMapCount = LittleLong( header->dwMipMapCount );
|
|
header->dwCaps1 = LittleLong( header->dwCaps1 );
|
|
header->dwCaps2 = LittleLong( header->dwCaps2 );
|
|
|
|
header->ddspf.dwSize = LittleLong( header->ddspf.dwSize );
|
|
header->ddspf.dwFlags = LittleLong( header->ddspf.dwFlags );
|
|
header->ddspf.dwFourCC = LittleLong( header->ddspf.dwFourCC );
|
|
header->ddspf.dwRGBBitCount = LittleLong( header->ddspf.dwRGBBitCount );
|
|
header->ddspf.dwRBitMask = LittleLong( header->ddspf.dwRBitMask );
|
|
header->ddspf.dwGBitMask = LittleLong( header->ddspf.dwGBitMask );
|
|
header->ddspf.dwBBitMask = LittleLong( header->ddspf.dwBBitMask );
|
|
header->ddspf.dwABitMask = LittleLong( header->ddspf.dwABitMask );
|
|
|
|
// generate the texture number
|
|
qglGenTextures( 1, &texnum );
|
|
|
|
int externalFormat = 0;
|
|
|
|
precompressedFile = true;
|
|
|
|
uploadWidth = header->dwWidth;
|
|
uploadHeight = header->dwHeight;
|
|
if ( header->ddspf.dwFlags & DDSF_FOURCC ) {
|
|
switch ( header->ddspf.dwFourCC ) {
|
|
case DDS_MAKEFOURCC( 'D', 'X', 'T', '1' ):
|
|
if ( header->ddspf.dwFlags & DDSF_ALPHAPIXELS ) {
|
|
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
|
|
} else {
|
|
internalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
|
|
}
|
|
break;
|
|
case DDS_MAKEFOURCC( 'D', 'X', 'T', '3' ):
|
|
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
|
|
break;
|
|
case DDS_MAKEFOURCC( 'D', 'X', 'T', '5' ):
|
|
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
|
|
break;
|
|
case DDS_MAKEFOURCC( 'R', 'X', 'G', 'B' ):
|
|
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
|
|
break;
|
|
default:
|
|
common->Warning( "Invalid compressed internal format\n" );
|
|
return;
|
|
}
|
|
} else if ( ( header->ddspf.dwFlags & DDSF_RGBA ) && header->ddspf.dwRGBBitCount == 32 ) {
|
|
externalFormat = GL_BGRA_EXT;
|
|
internalFormat = GL_RGBA8;
|
|
} else if ( ( header->ddspf.dwFlags & DDSF_RGB ) && header->ddspf.dwRGBBitCount == 32 ) {
|
|
externalFormat = GL_BGRA_EXT;
|
|
internalFormat = GL_RGBA8;
|
|
} else if ( ( header->ddspf.dwFlags & DDSF_RGB ) && header->ddspf.dwRGBBitCount == 24 ) {
|
|
if ( header->ddspf.dwFlags & DDSF_ID_INDEXCOLOR ) {
|
|
externalFormat = GL_COLOR_INDEX;
|
|
internalFormat = GL_COLOR_INDEX8_EXT;
|
|
} else {
|
|
externalFormat = GL_BGR_EXT;
|
|
internalFormat = GL_RGB8;
|
|
}
|
|
} else if ( header->ddspf.dwRGBBitCount == 8 ) {
|
|
externalFormat = GL_ALPHA;
|
|
internalFormat = GL_ALPHA8;
|
|
} else {
|
|
common->Warning( "Invalid uncompressed internal format\n" );
|
|
return;
|
|
}
|
|
|
|
// we need the monochrome flag for the NV20 optimized path
|
|
if ( header->dwFlags & DDSF_ID_MONOCHROME ) {
|
|
isMonochrome = true;
|
|
}
|
|
|
|
type = TT_2D; // FIXME: we may want to support pre-compressed cube maps in the future
|
|
|
|
Bind();
|
|
|
|
int numMipmaps = 1;
|
|
if ( header->dwFlags & DDSF_MIPMAPCOUNT ) {
|
|
numMipmaps = header->dwMipMapCount;
|
|
}
|
|
|
|
int uw = uploadWidth;
|
|
int uh = uploadHeight;
|
|
|
|
// We may skip some mip maps if we are downsizing
|
|
int skipMip = 0;
|
|
GetDownsize( uploadWidth, uploadHeight );
|
|
|
|
byte *imagedata = data + sizeof(ddsFileHeader_t) + 4;
|
|
|
|
for ( int i = 0 ; i < numMipmaps; i++ ) {
|
|
int size = 0;
|
|
if ( FormatIsDXT( internalFormat ) ) {
|
|
size = ( ( uw + 3 ) / 4 ) * ( ( uh + 3 ) / 4 ) *
|
|
(internalFormat <= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ? 8 : 16);
|
|
} else {
|
|
size = uw * uh * (header->ddspf.dwRGBBitCount / 8);
|
|
}
|
|
|
|
if ( uw > uploadWidth || uh > uploadHeight ) {
|
|
skipMip++;
|
|
} else {
|
|
if ( FormatIsDXT( internalFormat ) ) {
|
|
qglCompressedTexImage2DARB( GL_TEXTURE_2D, i - skipMip, internalFormat, uw, uh, 0, size, imagedata );
|
|
} else {
|
|
qglTexImage2D( GL_TEXTURE_2D, i - skipMip, internalFormat, uw, uh, 0, externalFormat, GL_UNSIGNED_BYTE, imagedata );
|
|
}
|
|
}
|
|
|
|
imagedata += size;
|
|
uw /= 2;
|
|
uh /= 2;
|
|
if (uw < 1) {
|
|
uw = 1;
|
|
}
|
|
if (uh < 1) {
|
|
uh = 1;
|
|
}
|
|
}
|
|
|
|
SetImageFilterAndRepeat();
|
|
}
|
|
|
|
/*
|
|
===============
|
|
ActuallyLoadImage
|
|
|
|
Absolutely every image goes through this path
|
|
On exit, the idImage will have a valid OpenGL texture number that can be bound
|
|
===============
|
|
*/
|
|
void idImage::ActuallyLoadImage( bool checkForPrecompressed, bool fromBackEnd ) {
|
|
int width, height;
|
|
byte *pic;
|
|
|
|
// this is the ONLY place generatorFunction will ever be called
|
|
if ( generatorFunction ) {
|
|
generatorFunction( this );
|
|
return;
|
|
}
|
|
|
|
// if we are a partial image, we are only going to load from a compressed file
|
|
if ( isPartialImage ) {
|
|
if ( CheckPrecompressedImage( false ) ) {
|
|
return;
|
|
}
|
|
// this is an error -- the partial image failed to load
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// load the image from disk
|
|
//
|
|
if ( cubeFiles != CF_2D ) {
|
|
byte *pics[6];
|
|
|
|
// we don't check for pre-compressed cube images currently
|
|
R_LoadCubeImages( imgName, cubeFiles, pics, &width, ×tamp );
|
|
|
|
if ( pics[0] == NULL ) {
|
|
common->Warning( "Couldn't load cube image: %s", imgName.c_str() );
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
|
|
GenerateCubeImage( (const byte **)pics, width, filter, allowDownSize, depth );
|
|
precompressedFile = false;
|
|
|
|
for ( int i = 0 ; i < 6 ; i++ ) {
|
|
if ( pics[i] ) {
|
|
R_StaticFree( pics[i] );
|
|
}
|
|
}
|
|
} else {
|
|
// see if we have a pre-generated image file that is
|
|
// already image processed and compressed
|
|
if ( checkForPrecompressed && globalImages->image_usePrecompressedTextures.GetBool() ) {
|
|
if ( CheckPrecompressedImage( true ) ) {
|
|
// we got the precompressed image
|
|
return;
|
|
}
|
|
// fall through to load the normal image
|
|
}
|
|
|
|
R_LoadImageProgram( imgName, &pic, &width, &height, ×tamp, &depth );
|
|
|
|
if ( pic == NULL ) {
|
|
common->Warning( "Couldn't load image: %s", imgName.c_str() );
|
|
MakeDefault();
|
|
return;
|
|
}
|
|
/*
|
|
// swap the red and alpha for rxgb support
|
|
// do this even on tga normal maps so we only have to use
|
|
// one fragment program
|
|
// if the image is precompressed ( either in palletized mode or true rxgb mode )
|
|
// then it is loaded above and the swap never happens here
|
|
if ( depth == TD_BUMP && globalImages->image_useNormalCompression.GetInteger() != 1 ) {
|
|
for ( int i = 0; i < width * height * 4; i += 4 ) {
|
|
pic[ i + 3 ] = pic[ i ];
|
|
pic[ i ] = 0;
|
|
}
|
|
}
|
|
*/
|
|
// build a hash for checking duplicate image files
|
|
// NOTE: takes about 10% of image load times (SD)
|
|
// may not be strictly necessary, but some code uses it, so let's leave it in
|
|
imageHash = MD4_BlockChecksum( pic, width * height * 4 );
|
|
|
|
GenerateImage( pic, width, height, filter, allowDownSize, repeat, depth );
|
|
timestamp = timestamp;
|
|
precompressedFile = false;
|
|
|
|
R_StaticFree( pic );
|
|
|
|
// write out the precompressed version of this file if needed
|
|
WritePrecompressedImage();
|
|
}
|
|
}
|
|
|
|
//=========================================================================================================
|
|
|
|
/*
|
|
===============
|
|
PurgeImage
|
|
===============
|
|
*/
|
|
void idImage::PurgeImage() {
|
|
if ( texnum != TEXTURE_NOT_LOADED ) {
|
|
// sometimes is NULL when exiting with an error
|
|
if ( qglDeleteTextures ) {
|
|
qglDeleteTextures( 1, &texnum ); // this should be the ONLY place it is ever called!
|
|
}
|
|
texnum = TEXTURE_NOT_LOADED;
|
|
}
|
|
|
|
// clear all the current binding caches, so the next bind will do a real one
|
|
for ( int i = 0 ; i < MAX_MULTITEXTURE_UNITS ; i++ ) {
|
|
backEnd.glState.tmu[i].current2DMap = -1;
|
|
backEnd.glState.tmu[i].current3DMap = -1;
|
|
backEnd.glState.tmu[i].currentCubeMap = -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Bind
|
|
|
|
Automatically enables 2D mapping, cube mapping, or 3D texturing if needed
|
|
==============
|
|
*/
|
|
void idImage::Bind() {
|
|
if ( tr.logFile ) {
|
|
RB_LogComment( "idImage::Bind( %s )\n", imgName.c_str() );
|
|
}
|
|
|
|
// if this is an image that we are caching, move it to the front of the LRU chain
|
|
if ( partialImage ) {
|
|
if ( cacheUsageNext ) {
|
|
// unlink from old position
|
|
cacheUsageNext->cacheUsagePrev = cacheUsagePrev;
|
|
cacheUsagePrev->cacheUsageNext = cacheUsageNext;
|
|
}
|
|
// link in at the head of the list
|
|
cacheUsageNext = globalImages->cacheLRU.cacheUsageNext;
|
|
cacheUsagePrev = &globalImages->cacheLRU;
|
|
|
|
cacheUsageNext->cacheUsagePrev = this;
|
|
cacheUsagePrev->cacheUsageNext = this;
|
|
}
|
|
|
|
// load the image if necessary (FIXME: not SMP safe!)
|
|
if ( texnum == TEXTURE_NOT_LOADED ) {
|
|
if ( partialImage ) {
|
|
// if we have a partial image, go ahead and use that
|
|
this->partialImage->Bind();
|
|
|
|
// start a background load of the full thing if it isn't already in the queue
|
|
if ( !backgroundLoadInProgress ) {
|
|
StartBackgroundImageLoad();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// load the image on demand here, which isn't our normal game operating mode
|
|
ActuallyLoadImage( true, true ); // check for precompressed, load is from back end
|
|
}
|
|
|
|
|
|
// bump our statistic counters
|
|
frameUsed = backEnd.frameCount;
|
|
bindCount++;
|
|
|
|
tmu_t *tmu = &backEnd.glState.tmu[backEnd.glState.currenttmu];
|
|
|
|
// enable or disable apropriate texture modes
|
|
if ( tmu->textureType != type && ( backEnd.glState.currenttmu < glConfig.maxTextureUnits ) ) {
|
|
if ( tmu->textureType == TT_CUBIC ) {
|
|
qglDisable( GL_TEXTURE_CUBE_MAP_EXT );
|
|
} else if ( tmu->textureType == TT_3D ) {
|
|
qglDisable( GL_TEXTURE_3D );
|
|
} else if ( tmu->textureType == TT_2D ) {
|
|
qglDisable( GL_TEXTURE_2D );
|
|
}
|
|
|
|
if ( type == TT_CUBIC ) {
|
|
qglEnable( GL_TEXTURE_CUBE_MAP_EXT );
|
|
} else if ( type == TT_3D ) {
|
|
qglEnable( GL_TEXTURE_3D );
|
|
} else if ( type == TT_2D ) {
|
|
qglEnable( GL_TEXTURE_2D );
|
|
}
|
|
tmu->textureType = type;
|
|
}
|
|
|
|
// bind the texture
|
|
if ( type == TT_2D ) {
|
|
if ( tmu->current2DMap != texnum ) {
|
|
tmu->current2DMap = texnum;
|
|
qglBindTexture( GL_TEXTURE_2D, texnum );
|
|
}
|
|
} else if ( type == TT_CUBIC ) {
|
|
if ( tmu->currentCubeMap != texnum ) {
|
|
tmu->currentCubeMap = texnum;
|
|
qglBindTexture( GL_TEXTURE_CUBE_MAP_EXT, texnum );
|
|
}
|
|
} else if ( type == TT_3D ) {
|
|
if ( tmu->current3DMap != texnum ) {
|
|
tmu->current3DMap = texnum;
|
|
qglBindTexture( GL_TEXTURE_3D, texnum );
|
|
}
|
|
}
|
|
|
|
if ( com_purgeAll.GetBool() ) {
|
|
GLclampf priority = 1.0f;
|
|
qglPrioritizeTextures( 1, &texnum, &priority );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============
|
|
BindFragment
|
|
|
|
Fragment programs explicitly say which type of map they want, so we don't need to
|
|
do any enable / disable changes
|
|
==============
|
|
*/
|
|
void idImage::BindFragment() {
|
|
if ( tr.logFile ) {
|
|
RB_LogComment( "idImage::BindFragment %s )\n", imgName.c_str() );
|
|
}
|
|
|
|
// if this is an image that we are caching, move it to the front of the LRU chain
|
|
if ( partialImage ) {
|
|
if ( cacheUsageNext ) {
|
|
// unlink from old position
|
|
cacheUsageNext->cacheUsagePrev = cacheUsagePrev;
|
|
cacheUsagePrev->cacheUsageNext = cacheUsageNext;
|
|
}
|
|
// link in at the head of the list
|
|
cacheUsageNext = globalImages->cacheLRU.cacheUsageNext;
|
|
cacheUsagePrev = &globalImages->cacheLRU;
|
|
|
|
cacheUsageNext->cacheUsagePrev = this;
|
|
cacheUsagePrev->cacheUsageNext = this;
|
|
}
|
|
|
|
// load the image if necessary (FIXME: not SMP safe!)
|
|
if ( texnum == TEXTURE_NOT_LOADED ) {
|
|
if ( partialImage ) {
|
|
// if we have a partial image, go ahead and use that
|
|
this->partialImage->BindFragment();
|
|
|
|
// start a background load of the full thing if it isn't already in the queue
|
|
if ( !backgroundLoadInProgress ) {
|
|
StartBackgroundImageLoad();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// load the image on demand here, which isn't our normal game operating mode
|
|
ActuallyLoadImage( true, true ); // check for precompressed, load is from back end
|
|
}
|
|
|
|
|
|
// bump our statistic counters
|
|
frameUsed = backEnd.frameCount;
|
|
bindCount++;
|
|
|
|
// bind the texture
|
|
if ( type == TT_2D ) {
|
|
qglBindTexture( GL_TEXTURE_2D, texnum );
|
|
} else if ( type == TT_RECT ) {
|
|
qglBindTexture( GL_TEXTURE_RECTANGLE_NV, texnum );
|
|
} else if ( type == TT_CUBIC ) {
|
|
qglBindTexture( GL_TEXTURE_CUBE_MAP_EXT, texnum );
|
|
} else if ( type == TT_3D ) {
|
|
qglBindTexture( GL_TEXTURE_3D, texnum );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
CopyFramebuffer
|
|
====================
|
|
*/
|
|
void idImage::CopyFramebuffer( int x, int y, int imageWidth, int imageHeight, bool useOversizedBuffer ) {
|
|
Bind();
|
|
|
|
if ( cvarSystem->GetCVarBool( "g_lowresFullscreenFX" ) ) {
|
|
imageWidth = 512;
|
|
imageHeight = 512;
|
|
}
|
|
|
|
// if the size isn't a power of 2, the image must be increased in size
|
|
int potWidth, potHeight;
|
|
|
|
potWidth = MakePowerOfTwo( imageWidth );
|
|
potHeight = MakePowerOfTwo( imageHeight );
|
|
|
|
GetDownsize( imageWidth, imageHeight );
|
|
GetDownsize( potWidth, potHeight );
|
|
|
|
if (backEnd.offscreenBBSet) {
|
|
qglReadBuffer( GL_COLOR_ATTACHMENT0_EXT );
|
|
}
|
|
else {
|
|
qglReadBuffer( GL_BACK );
|
|
}
|
|
|
|
// only resize if the current dimensions can't hold it at all,
|
|
// otherwise subview renderings could thrash this
|
|
if ( ( useOversizedBuffer && ( uploadWidth < potWidth || uploadHeight < potHeight ) )
|
|
|| ( !useOversizedBuffer && ( uploadWidth != potWidth || uploadHeight != potHeight ) ) ) {
|
|
uploadWidth = potWidth;
|
|
uploadHeight = potHeight;
|
|
if ( potWidth == imageWidth && potHeight == imageHeight ) {
|
|
qglCopyTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, x, y, imageWidth, imageHeight, 0 );
|
|
} else {
|
|
byte *junk;
|
|
// we need to create a dummy image with power of two dimensions,
|
|
// then do a qglCopyTexSubImage2D of the data we want
|
|
// this might be a 16+ meg allocation, which could fail on _alloca
|
|
junk = (byte *)Mem_Alloc( potWidth * potHeight * 4 );
|
|
memset( junk, 0, potWidth * potHeight * 4 ); //!@#
|
|
#if 0 // Disabling because it's unnecessary and introduces a green strip on edge of _currentRender
|
|
for ( int i = 0 ; i < potWidth * potHeight * 4 ; i+=4 ) {
|
|
junk[i+1] = 255;
|
|
}
|
|
#endif
|
|
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, potWidth, potHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, junk );
|
|
Mem_Free( junk );
|
|
|
|
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, x, y, imageWidth, imageHeight );
|
|
}
|
|
} else {
|
|
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
|
|
// it and don't try and do a texture compression or some other silliness
|
|
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, x, y, imageWidth, imageHeight );
|
|
}
|
|
|
|
// if the image isn't a full power of two, duplicate an extra row and/or column to fix bilerps
|
|
if ( imageWidth != potWidth ) {
|
|
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, imageWidth, 0, x+imageWidth-1, y, 1, imageHeight );
|
|
}
|
|
if ( imageHeight != potHeight ) {
|
|
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, imageHeight, x, y+imageHeight-1, imageWidth, 1 );
|
|
}
|
|
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
|
|
backEnd.c_copyFrameBuffer++;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CopyDepthbuffer
|
|
|
|
This should just be part of copyFramebuffer once we have a proper image type field
|
|
====================
|
|
*/
|
|
void idImage::CopyDepthbuffer( int x, int y, int imageWidth, int imageHeight ) {
|
|
Bind();
|
|
|
|
// if the size isn't a power of 2, the image must be increased in size
|
|
int potWidth, potHeight;
|
|
|
|
potWidth = MakePowerOfTwo( imageWidth );
|
|
potHeight = MakePowerOfTwo( imageHeight );
|
|
|
|
if ( uploadWidth != potWidth || uploadHeight != potHeight ) {
|
|
uploadWidth = potWidth;
|
|
uploadHeight = potHeight;
|
|
if ( potWidth == imageWidth && potHeight == imageHeight ) {
|
|
qglCopyTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, x, y, imageWidth, imageHeight, 0 );
|
|
} else {
|
|
// we need to create a dummy image with power of two dimensions,
|
|
// then do a qglCopyTexSubImage2D of the data we want
|
|
qglTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, potWidth, potHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
|
|
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, x, y, imageWidth, imageHeight );
|
|
}
|
|
} else {
|
|
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
|
|
// it and don't try and do a texture compression or some other silliness
|
|
qglCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, x, y, imageWidth, imageHeight );
|
|
}
|
|
|
|
// qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
|
|
// qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
|
|
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
}
|
|
|
|
/*
|
|
=============
|
|
RB_UploadScratchImage
|
|
|
|
if rows = cols * 6, assume it is a cube map animation
|
|
=============
|
|
*/
|
|
void idImage::UploadScratch( const byte *data, int cols, int rows ) {
|
|
int i;
|
|
|
|
// if rows = cols * 6, assume it is a cube map animation
|
|
if ( rows == cols * 6 ) {
|
|
if ( type != TT_CUBIC ) {
|
|
type = TT_CUBIC;
|
|
uploadWidth = -1; // for a non-sub upload
|
|
}
|
|
|
|
Bind();
|
|
|
|
rows /= 6;
|
|
// if the scratchImage isn't in the format we want, specify it as a new texture
|
|
if ( cols != uploadWidth || rows != uploadHeight ) {
|
|
uploadWidth = cols;
|
|
uploadHeight = rows;
|
|
|
|
// upload the base level
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
qglTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT+i, 0, GL_RGB8, cols, rows, 0,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, data + cols*rows*4*i );
|
|
}
|
|
} else {
|
|
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
|
|
// it and don't try and do a texture compression
|
|
for ( i = 0 ; i < 6 ; i++ ) {
|
|
qglTexSubImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT+i, 0, 0, 0, cols, rows,
|
|
GL_RGBA, GL_UNSIGNED_BYTE, data + cols*rows*4*i );
|
|
}
|
|
}
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
// no other clamp mode makes sense
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
} else {
|
|
// otherwise, it is a 2D image
|
|
if ( type != TT_2D ) {
|
|
type = TT_2D;
|
|
uploadWidth = -1; // for a non-sub upload
|
|
}
|
|
|
|
Bind();
|
|
|
|
// if the scratchImage isn't in the format we want, specify it as a new texture
|
|
if ( cols != uploadWidth || rows != uploadHeight ) {
|
|
uploadWidth = cols;
|
|
uploadHeight = rows;
|
|
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
|
|
} else {
|
|
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
|
|
// it and don't try and do a texture compression
|
|
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
|
|
}
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
// these probably should be clamp, but we have a lot of issues with editor
|
|
// geometry coming out with texcoords slightly off one side, resulting in
|
|
// a smear across the entire polygon
|
|
#if 1
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
|
|
#else
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
void idImage::SetClassification( int tag ) {
|
|
classification = tag;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
StorageSize
|
|
==================
|
|
*/
|
|
int idImage::StorageSize() const {
|
|
int baseSize;
|
|
|
|
if ( texnum == TEXTURE_NOT_LOADED ) {
|
|
return 0;
|
|
}
|
|
|
|
switch ( type ) {
|
|
default:
|
|
case TT_2D:
|
|
baseSize = uploadWidth*uploadHeight;
|
|
break;
|
|
case TT_3D:
|
|
baseSize = uploadWidth*uploadHeight*uploadDepth;
|
|
break;
|
|
case TT_CUBIC:
|
|
baseSize = 6 * uploadWidth*uploadHeight;
|
|
break;
|
|
}
|
|
|
|
baseSize *= BitsForInternalFormat( internalFormat );
|
|
|
|
baseSize /= 8;
|
|
|
|
// account for mip mapping
|
|
baseSize = baseSize * 4 / 3;
|
|
|
|
return baseSize;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Print
|
|
==================
|
|
*/
|
|
void idImage::Print() const {
|
|
if ( precompressedFile ) {
|
|
common->Printf( "P" );
|
|
} else if ( generatorFunction ) {
|
|
common->Printf( "F" );
|
|
} else {
|
|
common->Printf( " " );
|
|
}
|
|
|
|
switch ( type ) {
|
|
case TT_2D:
|
|
common->Printf( " " );
|
|
break;
|
|
case TT_3D:
|
|
common->Printf( "3" );
|
|
break;
|
|
case TT_CUBIC:
|
|
common->Printf( "C" );
|
|
break;
|
|
case TT_RECT:
|
|
common->Printf( "R" );
|
|
break;
|
|
default:
|
|
common->Printf( "<BAD TYPE:%i>", type );
|
|
break;
|
|
}
|
|
|
|
common->Printf( "%4i %4i ", uploadWidth, uploadHeight );
|
|
|
|
switch( filter ) {
|
|
case TF_DEFAULT:
|
|
common->Printf( "dflt " );
|
|
break;
|
|
case TF_LINEAR:
|
|
common->Printf( "linr " );
|
|
break;
|
|
case TF_NEAREST:
|
|
common->Printf( "nrst " );
|
|
break;
|
|
default:
|
|
common->Printf( "<BAD FILTER:%i>", filter );
|
|
break;
|
|
}
|
|
|
|
switch ( internalFormat ) {
|
|
case GL_INTENSITY8:
|
|
case 1:
|
|
common->Printf( "I " );
|
|
break;
|
|
case 2:
|
|
case GL_LUMINANCE8_ALPHA8:
|
|
common->Printf( "LA " );
|
|
break;
|
|
case 3:
|
|
common->Printf( "RGB " );
|
|
break;
|
|
case 4:
|
|
common->Printf( "RGBA " );
|
|
break;
|
|
case GL_LUMINANCE8:
|
|
common->Printf( "L " );
|
|
break;
|
|
case GL_ALPHA8:
|
|
common->Printf( "A " );
|
|
break;
|
|
case GL_RGBA8:
|
|
common->Printf( "RGBA8 " );
|
|
break;
|
|
case GL_RGB8:
|
|
common->Printf( "RGB8 " );
|
|
break;
|
|
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
|
|
common->Printf( "DXT1 " );
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
|
|
common->Printf( "DXT1A " );
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
|
|
common->Printf( "DXT3 " );
|
|
break;
|
|
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
|
|
common->Printf( "DXT5 " );
|
|
break;
|
|
case GL_RGBA4:
|
|
common->Printf( "RGBA4 " );
|
|
break;
|
|
case GL_RGB5:
|
|
common->Printf( "RGB5 " );
|
|
break;
|
|
case GL_COLOR_INDEX8_EXT:
|
|
common->Printf( "CI8 " );
|
|
break;
|
|
case GL_COLOR_INDEX:
|
|
common->Printf( "CI " );
|
|
break;
|
|
case GL_COMPRESSED_RGB_ARB:
|
|
common->Printf( "RGBC " );
|
|
break;
|
|
case GL_COMPRESSED_RGBA_ARB:
|
|
common->Printf( "RGBAC " );
|
|
break;
|
|
case 0:
|
|
common->Printf( " " );
|
|
break;
|
|
default:
|
|
common->Printf( "<BAD FORMAT:%i>", internalFormat );
|
|
break;
|
|
}
|
|
|
|
switch ( repeat ) {
|
|
case TR_REPEAT:
|
|
common->Printf( "rept " );
|
|
break;
|
|
case TR_CLAMP_TO_ZERO:
|
|
common->Printf( "zero " );
|
|
break;
|
|
case TR_CLAMP_TO_ZERO_ALPHA:
|
|
common->Printf( "azro " );
|
|
break;
|
|
case TR_CLAMP:
|
|
common->Printf( "clmp " );
|
|
break;
|
|
default:
|
|
common->Printf( "<BAD REPEAT:%i>", repeat );
|
|
break;
|
|
}
|
|
|
|
common->Printf( "%4ik ", StorageSize() / 1024 );
|
|
|
|
common->Printf( " %s\n", imgName.c_str() );
|
|
}
|