YGGverse
/
xash3d-fwgs
mirror of https://github.com/YGGverse/xash3d-fwgs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

engine: common: mod_bmodel: Tidied texture loading procedure

pull/2/head
Jonathan Poncelet 2 years ago committed by Alibek Omarov
parent
f2c671d809
commit
78555ab125
1 changed files with 419 additions and 232 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 651
      engine/common/mod_bmodel.c

651
engine/common/mod_bmodel.c
Unescape View File

@ -24,6 +24,9 @@ GNU General Public License for more details. @@ -24,6 +24,9 @@ GNU General Public License for more details.
#include "client.h"
#include "server.h" // LUMP_ error codes
#include "ref_common.h"
#define MIPTEX_CUSTOM_PALETTE_SIZE_BYTES 770
typedef struct wadlist_s
{
char wadnames[MAX_MAP_WADS][32];
@ -207,6 +210,151 @@ static mlumpinfo_t extlumps[EXTRA_LUMPS] = @@ -207,6 +210,151 @@ static mlumpinfo_t extlumps[EXTRA_LUMPS] =
{ LUMP_SHADOWMAP, 0, MAX_MAP_LIGHTING / 3, sizeof( byte ), -1, "shadowmap", USE_EXTRAHEADER, (const void **)&srcmodel.shadowdata, &srcmodel.shadowdatasize },
};
/*
===============================================================================
Static helper functions
===============================================================================
*/
static mip_t* Mod_GetMipTexForTexture( dbspmodel_t* bmod, int textureIndex )
{
if( textureIndex < 0 ||
textureIndex >= bmod->textures->nummiptex ||
bmod->textures->dataofs[textureIndex] == -1 )
{
return NULL;
}
return (mip_t*)((byte*)bmod->textures + bmod->textures->dataofs[textureIndex]);
}
// Returns index of WAD that texture was found in, or -1 if not found.
static int Mod_FindTextureInWadList(
wadlist_t* list,
const char* textureName,
char* foundPathBuffer,
size_t foundPathBufferLength )
{
char pathInWad[MAX_VA_STRING];
int wadIndex;
if( !list || !textureName || !(*textureName) )
{
return -1;
}
// check wads in reverse order
for( wadIndex = list->count - 1; wadIndex >= 0; --wadIndex )
{
Q_snprintf( pathInWad, sizeof(pathInWad), "%s.wad/%s.mip", list->wadnames[wadIndex], textureName );
if( FS_FileExists( pathInWad, false ) )
{
if( foundPathBuffer && foundPathBufferLength > 0 )
{
Q_strncpy( foundPathBuffer, pathInWad, foundPathBufferLength );
}
return wadIndex;
}
}
return -1;
}
static size_t Mod_CalculateMipTexSize( mip_t* mipTex, qboolean customPalette )
{
if( !mipTex )
{
return 0;
}
return sizeof(*mipTex) +
(( mipTex->width * mipTex->height * 85) >> 6) +
(customPalette ? MIPTEX_CUSTOM_PALETTE_SIZE_BYTES : 0);
}
static qboolean Mod_CalcMipTexUsesCustomPalette( dbspmodel_t* bmod, int textureIndex )
{
int size = 0;
int nextTextureIndex = 0;
mip_t* mipTex = NULL;
mipTex = Mod_GetMipTexForTexture( bmod, textureIndex );
if( !mipTex || mipTex->offsets[0] <= 0 )
{
return false;
}
// Calculate the size assuming we are not using a custom palette.
size = (int)Mod_CalculateMipTexSize( mipTex, false );
// Compute next data offset to determine allocated miptex space
for( nextTextureIndex = textureIndex + 1; nextTextureIndex < loadmodel->numtextures; ++nextTextureIndex )
{
int nextOffset = bmod->textures->dataofs[nextTextureIndex];
if( nextOffset != -1 )
{
int remainingBytes = nextOffset - (bmod->textures->dataofs[textureIndex] + size);
return remainingBytes >= MIPTEX_CUSTOM_PALETTE_SIZE_BYTES;
}
}
// There was no other miptex after this one.
// See if there is enough space between the end and our offset.
return bmod->texdatasize - (bmod->textures->dataofs[textureIndex] + size) >= MIPTEX_CUSTOM_PALETTE_SIZE_BYTES;
}
static qboolean Mod_NameImpliesTextureIsAnimated( texture_t* tex )
{
if( !tex )
{
return false;
}
if( tex->name[0] != '-' && tex->name[0] != '+' )
{
// Not an animated texture name
return false;
}
// Name implies texture is animated - check second character is valid.
if( !(tex->name[1] >= '0' && tex->name[1] <= '9') &&
!(tex->name[1] >= 'a' && tex->name[1] <= 'j') )
{
Con_Printf( S_ERROR "Mod_NameImpliesTextureIsAnimated: animating texture \"%s\" has invalid name\n", tex->name );
return false;
}
return true;
}
static void Mod_CreateDefaultTexture(texture_t** texture)
{
// Pointer must be valid, and value pointed to must be null.
if( !texture || *texture != NULL )
{
return;
}
*texture = Mem_Calloc( loadmodel->mempool, sizeof(texture_t) );
Q_strncpy( (*texture)->name, REF_DEFAULT_TEXTURE, sizeof((*texture)->name) );
#if !XASH_DEDICATED
if( !Host_IsDedicated() )
{
(*texture)->gl_texturenum = R_GetBuiltinTexture( REF_DEFAULT_TEXTURE );
(*texture)->width = 16;
(*texture)->height = 16;
}
#endif // XASH_DEDICATED
}
/*
===============================================================================
@ -1881,313 +2029,352 @@ static void Mod_LoadMarkSurfaces( dbspmodel_t *bmod ) @@ -1881,313 +2029,352 @@ static void Mod_LoadMarkSurfaces( dbspmodel_t *bmod )
}
}
/*
=================
Mod_LoadTextures
=================
*/
static void Mod_LoadTextures( dbspmodel_t *bmod )
{
dmiptexlump_t *in;
texture_t *tx, *tx2;
texture_t *anims[10];
texture_t *altanims[10];
int num, max, altmax;
qboolean custom_palette;
char texname[64];
mip_t *mt;
int i, j;
static void Mod_LoadTextureData( dbspmodel_t* bmod, int textureIndex )
{
#if !XASH_DEDICATED
texture_t* texture = NULL;
mip_t* mipTex = NULL;
qboolean usesCustomPalette = false;
uint32_t txFlags = 0;
if( bmod->isworld )
if( Host_IsDedicated() )
{
#if !XASH_DEDICATED
// release old sky layers first
if( !Host_IsDedicated() )
{
ref.dllFuncs.GL_FreeTexture( R_GetBuiltinTexture( REF_ALPHASKY_TEXTURE ));
ref.dllFuncs.GL_FreeTexture( R_GetBuiltinTexture( REF_SOLIDSKY_TEXTURE ));
}
#endif
// Don't load texture data on dedicated server, as there is no renderer.
return;
}
if( !bmod->texdatasize )
texture = loadmodel->textures[textureIndex];
mipTex = Mod_GetMipTexForTexture( bmod, textureIndex );
if( FBitSet( host.features, ENGINE_IMPROVED_LINETRACE ) && mipTex->name[0] == '{' )
{
// no textures
loadmodel->textures = NULL;
return;
SetBits( txFlags, TF_KEEP_SOURCE ); // Paranoia2 texture alpha-tracing
}
in = bmod->textures;
loadmodel->textures = (texture_t **)Mem_Calloc( loadmodel->mempool, in->nummiptex * sizeof( texture_t* ));
loadmodel->numtextures = in->nummiptex;
usesCustomPalette = Mod_CalcMipTexUsesCustomPalette( bmod, textureIndex );
for( i = 0; i < loadmodel->numtextures; i++ )
// check for multi-layered sky texture (quake1 specific)
if( bmod->isworld && Q_strncmp( mipTex->name, "sky", 3 ) == 0 && (mipTex->width / mipTex->height) == 2 )
{
int txFlags = 0;
ref.dllFuncs.R_InitSkyClouds( mipTex, texture, usesCustomPalette ); // load quake sky
if( in->dataofs[i] == -1 )
if( R_GetBuiltinTexture( REF_SOLIDSKY_TEXTURE ) && R_GetBuiltinTexture( REF_ALPHASKY_TEXTURE ) )
{
// create default texture (some mods requires this)
tx = Mem_Calloc( loadmodel->mempool, sizeof( *tx ));
loadmodel->textures[i] = tx;
Q_strncpy( tx->name, "*default", sizeof( tx->name ));
#if !XASH_DEDICATED
if( !Host_IsDedicated() )
{
tx->gl_texturenum = R_GetBuiltinTexture( REF_DEFAULT_TEXTURE );
tx->width = tx->height = 16;
}
#endif
continue; // missed
SetBits( world.flags, FWORLD_SKYSPHERE );
}
mt = (mip_t *)((byte *)in + in->dataofs[i] );
// No texture to load in this case, so just exit.
return;
}
if( !mt->name[0] )
Q_snprintf( mt->name, sizeof( mt->name ), "miptex_%i", i );
tx = Mem_Calloc( loadmodel->mempool, sizeof( *tx ));
loadmodel->textures[i] = tx;
// Texture loading order:
// 1. From WAD
// 2. Internal from map
// convert to lowercase
Q_strncpy( tx->name, mt->name, sizeof( tx->name ));
Q_strnlwr( tx->name, tx->name, sizeof( tx->name ));
custom_palette = false;
// Try WAD texture (force while r_wadtextures is 1)
if( (r_wadtextures->value && bmod->wadlist.count > 0) || mipTex->offsets[0] <= 0 )
{
char texpath[MAX_VA_STRING];
int wadIndex = Mod_FindTextureInWadList( &bmod->wadlist, mipTex->name, texpath, sizeof(texpath) );
tx->width = mt->width;
tx->height = mt->height;
if( wadIndex >= 0 )
{
texture->gl_texturenum = ref.dllFuncs.GL_LoadTexture( texpath, NULL, 0, txFlags );
bmod->wadlist.wadusage[wadIndex]++;
}
}
if( FBitSet( host.features, ENGINE_IMPROVED_LINETRACE ) && mt->name[0] == '{' )
SetBits( txFlags, TF_KEEP_SOURCE ); // Paranoia2 texture alpha-tracing
// WAD failed, so use internal texture (if present)
if( mipTex->offsets[0] > 0 && texture->gl_texturenum == 0 )
{
char texName[64];
const size_t size = Mod_CalculateMipTexSize( mipTex, usesCustomPalette );
if( mt->offsets[0] > 0 )
{
int size = (int)sizeof( mip_t ) + ((mt->width * mt->height * 85)>>6);
int next_dataofs = 0, remaining;
Q_snprintf( texName, sizeof(texName), "#%s:%s.mip", loadstat.name, mipTex->name );
texture->gl_texturenum = ref.dllFuncs.GL_LoadTexture( texName, (byte*)mipTex, size, txFlags );
}
// compute next dataofset to determine allocated miptex space
for( j = i + 1; j < loadmodel->numtextures; j++ )
{
next_dataofs = in->dataofs[j];
if( next_dataofs != -1 ) break;
}
// If texture is completely missed:
if( texture->gl_texturenum == 0 )
{
Con_DPrintf( S_ERROR "Unable to find %s.mip\n", mipTex->name );
texture->gl_texturenum = R_GetBuiltinTexture( REF_DEFAULT_TEXTURE );
}
if( j == loadmodel->numtextures )
next_dataofs = bmod->texdatasize;
// Check for luma texture
if( FBitSet( REF_GET_PARM( PARM_TEX_FLAGS, texture->gl_texturenum ), TF_HAS_LUMA ) )
{
char texName[64];
Q_snprintf( texName, sizeof(texName), "#%s:%s_luma.mip", loadstat.name, mipTex->name );
// NOTE: imagelib detect miptex version by size
// 770 additional bytes is indicated custom palette
remaining = next_dataofs - (in->dataofs[i] + size);
if( remaining >= 770 ) custom_palette = true;
if( mipTex->offsets[0] > 0 )
{
const size_t size = Mod_CalculateMipTexSize( mipTex, usesCustomPalette );
texture->fb_texturenum = ref.dllFuncs.GL_LoadTexture( texName, (byte*)mipTex, size, TF_MAKELUMA );
}
#if !XASH_DEDICATED
if( !Host_IsDedicated() )
else
{
// check for multi-layered sky texture (quake1 specific)
if( bmod->isworld && !Q_strncmp( mt->name, "sky", 3 ) && (( mt->width / mt->height ) == 2 ) )
{
ref.dllFuncs.R_InitSkyClouds( mt, tx, custom_palette ); // load quake sky
char texpath[MAX_VA_STRING];
int wadIndex = -1;
fs_offset_t srcSize = 0;
byte* src = NULL;
if( R_GetBuiltinTexture( REF_SOLIDSKY_TEXTURE ) &&
R_GetBuiltinTexture( REF_ALPHASKY_TEXTURE ) )
SetBits( world.flags, FWORLD_SKYSPHERE );
continue;
// NOTE: We can't load the _luma texture from the WAD as normal because it
// doesn't exist there. The original texture is already loaded, but cannot be modified.
// Instead, load the original texture again and convert it to luma.
wadIndex = Mod_FindTextureInWadList( &bmod->wadlist, texture->name, texpath, sizeof(texpath) );
if( wadIndex >= 0 )
{
src = FS_LoadFile( texpath, &srcSize, false );
bmod->wadlist.wadusage[wadIndex]++;
}
// texture loading order:
// 1. from wad
// 2. internal from map
// OK, loading it from wad or hi-res version
texture->fb_texturenum = ref.dllFuncs.GL_LoadTexture( texName, src, srcSize, TF_MAKELUMA );
// trying wad texture (force while r_wadtextures is 1)
if(( r_wadtextures->value && bmod->wadlist.count > 0 ) || ( mt->offsets[0] <= 0 ))
if( src )
{
Q_snprintf( texname, sizeof( texname ), "%s.mip", mt->name );
Mem_Free( src );
}
}
}
#endif // !XASH_DEDICATED
}
// check wads in reverse order
for( j = bmod->wadlist.count - 1; j >= 0; j-- )
{
char texpath[MAX_VA_STRING];
static void Mod_LoadTexture( dbspmodel_t* bmod, int textureIndex )
{
texture_t* texture = NULL;
mip_t* mipTex = NULL;
Q_snprintf( texpath, sizeof( texpath ), "%s.wad/%s", bmod->wadlist.wadnames[j], texname );
if( textureIndex < 0 || textureIndex >= loadmodel->numtextures )
{
return;
}
if( FS_FileExists( texpath, false ))
{
tx->gl_texturenum = ref.dllFuncs.GL_LoadTexture( texpath, NULL, 0, txFlags );
bmod->wadlist.wadusage[j]++; // this wad are really used
break;
}
}
}
mipTex = Mod_GetMipTexForTexture( bmod, textureIndex );
// wad failed, so use internal texture (if present)
if( mt->offsets[0] > 0 && !tx->gl_texturenum )
{
// NOTE: imagelib detect miptex version by size
// 770 additional bytes is indicated custom palette
int size = (int)sizeof( mip_t ) + ((mt->width * mt->height * 85)>>6);
if( !mipTex )
{
// No data for this texture.
// Create default texture (some mods require this).
Mod_CreateDefaultTexture( &loadmodel->textures[textureIndex] );
return;
}
if( custom_palette ) size += sizeof( short ) + 768;
Q_snprintf( texname, sizeof( texname ), "#%s:%s.mip", loadstat.name, mt->name );
tx->gl_texturenum = ref.dllFuncs.GL_LoadTexture( texname, (byte *)mt, size, txFlags );
}
if( mipTex->name[0] == '\0' )
{
Q_snprintf( mipTex->name, sizeof(mipTex->name), "miptex_%i", textureIndex );
}
// if texture is completely missed
if( !tx->gl_texturenum )
{
Con_DPrintf( S_ERROR "unable to find %s.mip\n", mt->name );
tx->gl_texturenum = R_GetBuiltinTexture( REF_DEFAULT_TEXTURE );
}
texture = (texture_t*)Mem_Calloc( loadmodel->mempool, sizeof(texture_t) );
loadmodel->textures[textureIndex] = texture;
// check for luma texture
if( FBitSet( REF_GET_PARM( PARM_TEX_FLAGS, tx->gl_texturenum ), TF_HAS_LUMA ))
{
Q_snprintf( texname, sizeof( texname ), "#%s:%s_luma.mip", loadstat.name, mt->name );
// Ensure texture name is lowercase.
Q_strncpy( texture->name, mipTex->name, sizeof(texture->name) );
Q_strnlwr( texture->name, texture->name, sizeof(texture->name) );
if( mt->offsets[0] > 0 )
{
// NOTE: imagelib detect miptex version by size
// 770 additional bytes is indicated custom palette
int size = (int)sizeof( mip_t ) + ((mt->width * mt->height * 85)>>6);
texture->width = mipTex->width;
texture->height = mipTex->height;
if( custom_palette ) size += sizeof( short ) + 768;
tx->fb_texturenum = ref.dllFuncs.GL_LoadTexture( texname, (byte *)mt, size, TF_MAKELUMA );
}
else
{
fs_offset_t srcSize = 0;
byte *src = NULL;
Mod_LoadTextureData( bmod, textureIndex );
}
// NOTE: we can't loading it from wad as normal because _luma texture doesn't exist
// and not be loaded. But original texture is already loaded and can't be modified
// So load original texture manually and convert it to luma
static void Mod_LoadAllTextures( dbspmodel_t* bmod )
{
for( int index = 0; index < loadmodel->numtextures; ++index )
{
Mod_LoadTexture( bmod, index );
}
}
// check wads in reverse order
for( j = bmod->wadlist.count - 1; j >= 0; j-- )
{
char texpath[MAX_VA_STRING];
static void Mod_SequenceAnimatedTexture( int baseTextureIndex )
{
texture_t* anims[10];
texture_t* altanims[10];
texture_t* baseTexture = NULL;
int max = 0;
int altmax = 0;
int candidateIndex = 0;
Q_snprintf( texpath, sizeof( texpath ), "%s.wad/%s.mip", bmod->wadlist.wadnames[j], tx->name );
if( baseTextureIndex < 0 || baseTextureIndex >= loadmodel->numtextures )
{
return;
}
if( FS_FileExists( texpath, false ))
{
src = FS_LoadFile( texpath, &srcSize, false );
bmod->wadlist.wadusage[j]++; // this wad are really used
break;
}
}
baseTexture = loadmodel->textures[baseTextureIndex];
// okay, loading it from wad or hi-res version
tx->fb_texturenum = ref.dllFuncs.GL_LoadTexture( texname, src, srcSize, TF_MAKELUMA );
if( src ) Mem_Free( src );
}
}
}
#endif
if( !Mod_NameImpliesTextureIsAnimated( baseTexture ) )
{
return;
}
// sequence the animations and detail textures
for( i = 0; i < loadmodel->numtextures; i++ )
if( baseTexture->anim_next )
{
tx = loadmodel->textures[i];
// Already sequenced
return;
}
if( !tx || ( tx->name[0] != '-' && tx->name[0] != '+' ))
continue;
// find the number of frames in the animation
memset( anims, 0, sizeof(anims) );
memset( altanims, 0, sizeof(altanims) );
if( tx->anim_next )
continue; // already sequenced
if( baseTexture->name[1] >= '0' && baseTexture->name[1] <= '9' )
{
// This texture is a standard animation frame.
int frameIndex = (int)baseTexture->name[1] - (int)'0';
// find the number of frames in the animation
memset( anims, 0, sizeof( anims ));
memset( altanims, 0, sizeof( altanims ));
anims[frameIndex] = baseTexture;
max = frameIndex + 1;
}
else
{
// This texture is an alternate animation frame.
int frameIndex = (int)baseTexture->name[1] - (int)'a';
max = tx->name[1];
altmax = 0;
altanims[frameIndex] = baseTexture;
altmax = frameIndex + 1;
}
if( max >= '0' && max <= '9' )
// Now search the rest of the textures to find all other frames.
for( candidateIndex = baseTextureIndex + 1; candidateIndex < loadmodel->numtextures; ++candidateIndex )
{
texture_t* altTexture = loadmodel->textures[candidateIndex];
if( !Mod_NameImpliesTextureIsAnimated( altTexture ) )
{
max -= '0';
altmax = 0;
anims[max] = tx;
max++;
continue;
}
else if( max >= 'a' && max <= 'j' )
// This texture is animated, but is it part of the same group as
// the original texture we encountered? Check that the rest of
// the name matches the original (both will be valid for at least
// string index 2).
if( Q_strcmp( altTexture->name + 2, baseTexture->name + 2 ) != 0)
{
altmax = max - 'a';
max = 0;
altanims[altmax] = tx;
altmax++;
continue;
}
else Con_Printf( S_ERROR "Mod_LoadTextures: bad animating texture %s\n", tx->name );
for( j = i + 1; j < loadmodel->numtextures; j++ )
if( altTexture->name[1] >= '0' && altTexture->name[1] <= '9' )
{
tx2 = loadmodel->textures[j];
if( !tx2 || ( tx2->name[0] != '-' && tx2->name[0] != '+' ))
continue;
// This texture is a standard frame.
int frameIndex = (int)altTexture->name[1] - (int)'0';
anims[frameIndex] = altTexture;
if( Q_strcmp( tx2->name + 2, tx->name + 2 ))
continue;
num = tx2->name[1];
if( num >= '0' && num <= '9' )
if( frameIndex >= max )
{
num -= '0';
anims[num] = tx2;
if( num + 1 > max )
max = num + 1;
max = frameIndex + 1;
}
else if( num >= 'a' && num <= 'j' )
}
else
{
// This texture is an alternate frame.
int frameIndex = (int)altTexture->name[1] - (int)'a';
altanims[frameIndex] = altTexture;
if( frameIndex >= altmax )
{
num = num - 'a';
altanims[num] = tx2;
if( num + 1 > altmax )
altmax = num + 1;
altmax = frameIndex + 1;
}
else Con_Printf( S_ERROR "Mod_LoadTextures: bad animating texture %s\n", tx->name );
}
}
// link them all together
for( j = 0; j < max; j++ )
// Link all standard animated frames together.
for( candidateIndex = 0; candidateIndex < max; ++candidateIndex )
{
texture_t* tex = anims[candidateIndex];
if( !tex )
{
tx2 = anims[j];
Con_Printf( S_ERROR "Mod_SequenceAnimatedTexture: missing frame %i of animated texture \"%s\"\n",
candidateIndex,
baseTexture->name );
if( !tx2 )
{
Con_Printf( S_ERROR "Mod_LoadTextures: missing frame %i of %s\n", j, tx->name );
tx->anim_total = 0;
break;
}
baseTexture->anim_total = 0;
break;
}
tx2->anim_total = max * ANIM_CYCLE;
tx2->anim_min = j * ANIM_CYCLE;
tx2->anim_max = (j + 1) * ANIM_CYCLE;
tx2->anim_next = anims[(j + 1) % max];
if( altmax ) tx2->alternate_anims = altanims[0];
tex->anim_total = max * ANIM_CYCLE;
tex->anim_min = candidateIndex * ANIM_CYCLE;
tex->anim_max = (candidateIndex + 1) * ANIM_CYCLE;
tex->anim_next = anims[(candidateIndex + 1) % max];
if( altmax > 0 )
{
tex->alternate_anims = altanims[0];
}
}
// Link all alternate animated frames together.
for( candidateIndex = 0; candidateIndex < altmax; ++candidateIndex )
{
texture_t* tex = altanims[candidateIndex];
for( j = 0; j < altmax; j++ )
if( !tex )
{
tx2 = altanims[j];
Con_Printf( S_ERROR "Mod_SequenceAnimatedTexture: missing alternate frame %i of animated texture \"%s\"\n",
candidateIndex,
baseTexture->name );
if( !tx2 )
{
Con_Printf( S_ERROR "Mod_LoadTextures: missing frame %i of %s\n", j, tx->name );
tx->anim_total = 0;
break;
}
baseTexture->anim_total = 0;
break;
}
tx2->anim_total = altmax * ANIM_CYCLE;
tx2->anim_min = j * ANIM_CYCLE;
tx2->anim_max = (j+1) * ANIM_CYCLE;
tx2->anim_next = altanims[(j + 1) % altmax];
if( max ) tx2->alternate_anims = anims[0];
tex->anim_total = altmax * ANIM_CYCLE;
tex->anim_min = candidateIndex * ANIM_CYCLE;
tex->anim_max = (candidateIndex + 1) * ANIM_CYCLE;
tex->anim_next = altanims[(candidateIndex + 1) % altmax];
if( max > 0 )
{
tex->alternate_anims = anims[0];
}
}
}
static void Mod_SequenceAllAnimatedTextures(void)
{
for( int index = 0; index < loadmodel->numtextures; ++index )
{
Mod_SequenceAnimatedTexture( index );
}
}
/*
=================
Mod_LoadTextures
=================
*/
static void Mod_LoadTextures( dbspmodel_t* bmod )
{
dmiptexlump_t* lump = NULL;
#if !XASH_DEDICATED
// release old sky layers first
if( !Host_IsDedicated() && bmod->isworld )
{
ref.dllFuncs.GL_FreeTexture( R_GetBuiltinTexture( REF_ALPHASKY_TEXTURE ) );
ref.dllFuncs.GL_FreeTexture( R_GetBuiltinTexture( REF_SOLIDSKY_TEXTURE ) );
}
#endif
lump = bmod->textures;
if( bmod->texdatasize < 1 || !lump || lump->nummiptex < 1 )
{
// no textures
loadmodel->textures = NULL;
return;
}
loadmodel->textures = (texture_t**)Mem_Calloc( loadmodel->mempool, lump->nummiptex * sizeof(texture_t*) );
loadmodel->numtextures = loadmodel->textures ? lump->nummiptex : 0;
Mod_LoadAllTextures( bmod );
Mod_SequenceAllAnimatedTextures();
}
/*
=================
Mod_LoadTexInfo

Write Preview
Loading…
Cancel
Save