forked from a1batross/Paranoia2_original
757 lines
18 KiB
C++
757 lines
18 KiB
C++
/*
|
|
gl_lightmap.cpp - generate lightmaps and uploading them
|
|
Copyright (C) 2016 Uncle Mike
|
|
|
|
This program 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.
|
|
|
|
This program 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.
|
|
*/
|
|
|
|
#include "hud.h"
|
|
#include "cl_util.h"
|
|
#include "const.h"
|
|
#include "studio.h"
|
|
#include "com_model.h"
|
|
#include "ref_params.h"
|
|
#include "gl_local.h"
|
|
#include <stringlib.h>
|
|
#include "gl_shader.h"
|
|
#include "gl_world.h"
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
LIGHTMAP ALLOCATION
|
|
|
|
=============================================================================
|
|
*/
|
|
static int LM_AllocBlock( unsigned short w, unsigned short h, unsigned short *x, unsigned short *y )
|
|
{
|
|
gl_lightmap_t *lms = &tr.lightmaps[tr.current_lightmap_texture];
|
|
unsigned short i, j, best, best2;
|
|
|
|
best = BLOCK_SIZE;
|
|
|
|
for( i = 0; i < BLOCK_SIZE - w; i++ )
|
|
{
|
|
best2 = 0;
|
|
|
|
for( j = 0; j < w; j++ )
|
|
{
|
|
if( lms->allocated[i+j] >= best )
|
|
break;
|
|
if( lms->allocated[i+j] > best2 )
|
|
best2 = lms->allocated[i+j];
|
|
}
|
|
|
|
if( j == w )
|
|
{
|
|
// this is a valid spot
|
|
*x = i;
|
|
*y = best = best2;
|
|
}
|
|
}
|
|
|
|
if( best + h > BLOCK_SIZE )
|
|
{
|
|
// current lightmap is full
|
|
lms->state = LM_DONE;
|
|
return false;
|
|
}
|
|
|
|
for( i = 0; i < w; i++ )
|
|
lms->allocated[*x + i] = best + h;
|
|
lms->state = LM_USED; // lightmap in use
|
|
|
|
return true;
|
|
}
|
|
|
|
static void LM_InitBlock( void )
|
|
{
|
|
word dummy;
|
|
gl_lightmap_t *lms = &tr.lightmaps[tr.current_lightmap_texture];
|
|
memset( lms->allocated, 0, sizeof( lms->allocated ));
|
|
|
|
// first block at pos 0,0 used as black lightmap for studiomodel
|
|
LM_AllocBlock( 1, 1, &dummy, &dummy );
|
|
}
|
|
|
|
static void LM_UploadPages( bool lightmap, bool deluxmap )
|
|
{
|
|
char lmName[16];
|
|
byte lightBuf[4];
|
|
byte deluxBuf[4];
|
|
int i;
|
|
|
|
lightBuf[0] = 0;
|
|
lightBuf[1] = 0;
|
|
lightBuf[2] = 0;
|
|
lightBuf[3] = 0;
|
|
deluxBuf[0] = 127;
|
|
deluxBuf[1] = 127;
|
|
deluxBuf[2] = 255;
|
|
deluxBuf[3] = 0;
|
|
|
|
for( i = 0; i < MAX_LIGHTMAPS && tr.lightmaps[i].state != LM_FREE; i++ )
|
|
{
|
|
gl_lightmap_t *lms = &tr.lightmaps[i];
|
|
|
|
if( lightmap && !lms->lightmap )
|
|
{
|
|
Q_snprintf( lmName, sizeof( lmName ), "*diffuse%i", i );
|
|
lms->lightmap = CREATE_TEXTURE( lmName, BLOCK_SIZE, BLOCK_SIZE, NULL, TF_LIGHTMAP );
|
|
|
|
// also loading dummy blackpixel
|
|
GL_BindTexture( GL_TEXTURE0, lms->lightmap );
|
|
pglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, lightBuf );
|
|
}
|
|
|
|
if( deluxmap && !lms->deluxmap )
|
|
{
|
|
Q_snprintf( lmName, sizeof( lmName ), "*normals%i", i );
|
|
lms->deluxmap = CREATE_TEXTURE( lmName, BLOCK_SIZE, BLOCK_SIZE, NULL, TF_DELUXMAP );
|
|
|
|
// also loading dummy blackpixel
|
|
GL_BindTexture( GL_TEXTURE0, lms->deluxmap );
|
|
pglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, deluxBuf );
|
|
}
|
|
}
|
|
}
|
|
|
|
static void LM_GoToNextPage( void )
|
|
{
|
|
gl_lightmap_t *lms = &tr.lightmaps[tr.current_lightmap_texture];
|
|
|
|
if( lms->state != LM_DONE ) return; // current atlas not completed
|
|
|
|
if( ++tr.current_lightmap_texture == MAX_LIGHTMAPS )
|
|
HOST_ERROR( "MAX_LIGHTMAPS limit exceded\n" );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
GL_BeginBuildingLightmaps
|
|
|
|
==================
|
|
*/
|
|
void GL_BeginBuildingLightmaps( void )
|
|
{
|
|
int i;
|
|
|
|
// release old lightmaps first
|
|
for( i = 0; i < MAX_LIGHTMAPS && tr.lightmaps[i].state != LM_FREE; i++ )
|
|
{
|
|
FREE_TEXTURE( tr.lightmaps[i].lightmap );
|
|
FREE_TEXTURE( tr.lightmaps[i].deluxmap );
|
|
}
|
|
|
|
memset( tr.lightmaps, 0, sizeof( tr.lightmaps ));
|
|
tr.current_lightmap_texture = 0;
|
|
LM_InitBlock();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
Mod_AllocLightmapForFace
|
|
|
|
NOTE: we don't loading lightmap here.
|
|
just create lmcoords and set lmnum
|
|
=================
|
|
*/
|
|
void GL_AllocLightmapForFace( msurface_t *surf )
|
|
{
|
|
mextrasurf_t *esrf = surf->info;
|
|
word smax, tmax;
|
|
int map;
|
|
|
|
// always reject the tiled faces
|
|
if( FBitSet( surf->flags, SURF_DRAWSKY ))
|
|
return;
|
|
|
|
// no lightdata and no deluxdata
|
|
if( !surf->samples && !esrf->normals )
|
|
return;
|
|
|
|
int sample_size = Mod_SampleSizeForFace( surf );
|
|
smax = ( surf->info->lightextents[0] / sample_size ) + 1;
|
|
tmax = ( surf->info->lightextents[1] / sample_size ) + 1;
|
|
new_page:
|
|
// alloc blocks for all the styles on current page
|
|
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != LS_NONE; map++ )
|
|
{
|
|
if( !LM_AllocBlock( smax, tmax, &esrf->light_s[map], &esrf->light_t[map] ))
|
|
{
|
|
// current page is not enough room for next 1-4 blocks
|
|
LM_GoToNextPage();
|
|
LM_InitBlock();
|
|
goto new_page;
|
|
}
|
|
}
|
|
|
|
// lightmap will be uploaded as far as player can see it
|
|
esrf->lightmaptexturenum = tr.current_lightmap_texture;
|
|
SetBits( surf->flags, SURF_LM_UPDATE|SURF_DM_UPDATE );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
Mod_AllocLightmapForFace
|
|
|
|
NOTE: we don't loading lightmap here.
|
|
just create lmcoords and set lmnum
|
|
=================
|
|
*/
|
|
bool GL_AllocLightmapForFace( mstudiosurface_t *surf )
|
|
{
|
|
word smax, tmax;
|
|
int map;
|
|
|
|
smax = surf->lightextents[0] + 1;
|
|
tmax = surf->lightextents[1] + 1;
|
|
|
|
// alloc blocks for all the styles on current page
|
|
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != LS_NONE; map++ )
|
|
{
|
|
if( !LM_AllocBlock( smax, tmax, &surf->light_s[map], &surf->light_t[map] ))
|
|
{
|
|
// current page is not enough room for next 1-4 blocks
|
|
LM_GoToNextPage();
|
|
LM_InitBlock();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// lightmap will be uploaded as far as player can see it
|
|
surf->lightmaptexturenum = tr.current_lightmap_texture;
|
|
SetBits( surf->flags, SURF_LM_UPDATE|SURF_DM_UPDATE );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=======================
|
|
GL_EndBuildingLightmaps
|
|
=======================
|
|
*/
|
|
void GL_EndBuildingLightmaps( bool lightmap, bool deluxmap )
|
|
{
|
|
LM_UploadPages( lightmap, deluxmap );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_BuildLightMapForStyle
|
|
|
|
write lightmap into page for a given style
|
|
=================
|
|
*/
|
|
static void R_BuildLightMapForStyle( msurface_t *surf, byte *dest, int style )
|
|
{
|
|
mextrasurf_t *esrf = surf->info;
|
|
int stride, size;
|
|
int smax, tmax;
|
|
int s, t;
|
|
color24 *lm;
|
|
byte *sm;
|
|
|
|
ASSERT( style >= 0 && style < MAXLIGHTMAPS );
|
|
|
|
// always reject the sky faces
|
|
if( FBitSet( surf->flags, SURF_DRAWSKY ))
|
|
return;
|
|
|
|
// no lightdata or style missed
|
|
if( !surf->samples || surf->styles[style] == LS_NONE )
|
|
return;
|
|
|
|
int sample_size = Mod_SampleSizeForFace( surf );
|
|
smax = ( surf->info->lightextents[0] / sample_size ) + 1;
|
|
tmax = ( surf->info->lightextents[1] / sample_size ) + 1;
|
|
size = smax * tmax;
|
|
|
|
// jump to specified style
|
|
lm = surf->samples + size * style;
|
|
sm = esrf->shadows + size * style;
|
|
|
|
// put into texture format
|
|
stride = (smax * 4) - (smax << 2);
|
|
|
|
for( t = 0; t < tmax; t++, dest += stride )
|
|
{
|
|
for( s = 0; s < smax; s++ )
|
|
{
|
|
dest[0] = TEXTURE_TO_TEXGAMMA( lm->r );
|
|
dest[1] = TEXTURE_TO_TEXGAMMA( lm->g );
|
|
dest[2] = TEXTURE_TO_TEXGAMMA( lm->b );
|
|
|
|
if( esrf->shadows != NULL )
|
|
dest[3] = *sm++;
|
|
else dest[3] = 255;
|
|
|
|
dest += 4;
|
|
lm++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_BuildLightMapForStyle
|
|
|
|
write lightmap into page for a given style
|
|
=================
|
|
*/
|
|
static void R_BuildLightMapForStyle( mstudiosurface_t *surf, byte *dest, int style )
|
|
{
|
|
int stride, size;
|
|
int smax, tmax;
|
|
int s, t;
|
|
color24 *lm;
|
|
byte *sm;
|
|
|
|
ASSERT( style >= 0 && style < MAXLIGHTMAPS );
|
|
|
|
// no lightdata or style missed
|
|
if( !surf->samples || surf->styles[style] == LS_NONE )
|
|
return;
|
|
|
|
smax = surf->lightextents[0] + 1;
|
|
tmax = surf->lightextents[1] + 1;
|
|
size = smax * tmax;
|
|
|
|
// jump to specified style
|
|
lm = surf->samples + size * style;
|
|
sm = surf->shadows + size * style;
|
|
|
|
// put into texture format
|
|
stride = (smax * 4) - (smax << 2);
|
|
|
|
for( t = 0; t < tmax; t++, dest += stride )
|
|
{
|
|
for( s = 0; s < smax; s++ )
|
|
{
|
|
dest[0] = TEXTURE_TO_TEXGAMMA( lm->r );
|
|
dest[1] = TEXTURE_TO_TEXGAMMA( lm->g );
|
|
dest[2] = TEXTURE_TO_TEXGAMMA( lm->b );
|
|
|
|
if( surf->shadows != NULL )
|
|
dest[3] = *sm++;
|
|
else dest[3] = 255;
|
|
|
|
dest += 4;
|
|
lm++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_BuildDeluxMapForStyle
|
|
|
|
write deluxmap into page for a given style
|
|
=================
|
|
*/
|
|
static void R_BuildDeluxMapForStyle( msurface_t *surf, byte *dest, int style )
|
|
{
|
|
mextrasurf_t *esrf = surf->info;
|
|
int stride, size;
|
|
int smax, tmax;
|
|
int s, t;
|
|
color24 *dm;
|
|
|
|
ASSERT( style >= 0 && style < MAXLIGHTMAPS );
|
|
|
|
// always reject the sky faces
|
|
if( FBitSet( surf->flags, SURF_DRAWSKY ))
|
|
return;
|
|
|
|
// no lightdata or style missed
|
|
if( !esrf->normals || surf->styles[style] == LS_NONE )
|
|
return;
|
|
|
|
int sample_size = Mod_SampleSizeForFace( surf );
|
|
smax = ( surf->info->lightextents[0] / sample_size ) + 1;
|
|
tmax = ( surf->info->lightextents[1] / sample_size ) + 1;
|
|
size = smax * tmax;
|
|
|
|
// jump to specified style
|
|
dm = esrf->normals + size * style;
|
|
|
|
// put into texture format
|
|
stride = (smax * 4) - (smax << 2);
|
|
|
|
for( t = 0; t < tmax; t++, dest += stride )
|
|
{
|
|
for( s = 0; s < smax; s++ )
|
|
{
|
|
dest[0] = dm->r;
|
|
dest[1] = dm->g;
|
|
dest[2] = dm->b;
|
|
dest[3] = 255;
|
|
|
|
dest += 4;
|
|
dm++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_BuildDeluxMapForStyle
|
|
|
|
write deluxmap into page for a given style
|
|
=================
|
|
*/
|
|
static void R_BuildDeluxMapForStyle( mstudiosurface_t *surf, byte *dest, int style )
|
|
{
|
|
int stride, size;
|
|
int smax, tmax;
|
|
int s, t;
|
|
color24 *dm;
|
|
|
|
ASSERT( style >= 0 && style < MAXLIGHTMAPS );
|
|
|
|
// no lightdata or style missed
|
|
if( !surf->normals || surf->styles[style] == LS_NONE )
|
|
return;
|
|
|
|
smax = surf->lightextents[0] + 1;
|
|
tmax = surf->lightextents[1] + 1;
|
|
size = smax * tmax;
|
|
|
|
// jump to specified style
|
|
dm = surf->normals + size * style;
|
|
|
|
// put into texture format
|
|
stride = (smax * 4) - (smax << 2);
|
|
|
|
for( t = 0; t < tmax; t++, dest += stride )
|
|
{
|
|
for( s = 0; s < smax; s++ )
|
|
{
|
|
dest[0] = dm->r;
|
|
dest[1] = dm->g;
|
|
dest[2] = dm->b;
|
|
dest[3] = 255;
|
|
|
|
dest += 4;
|
|
dm++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_UpdateLightMap
|
|
|
|
Combine and scale multiple lightmaps into the floating
|
|
format in r_blocklights
|
|
=================
|
|
*/
|
|
static void R_UpdateLightMap( msurface_t *surf )
|
|
{
|
|
mextrasurf_t *esrf = surf->info;
|
|
static byte buf[132*132*4];
|
|
int map, smax, tmax;
|
|
|
|
// always reject the sky faces
|
|
if( FBitSet( surf->flags, SURF_DRAWSKY ))
|
|
return;
|
|
|
|
int sample_size = Mod_SampleSizeForFace( surf );
|
|
smax = ( surf->info->lightextents[0] / sample_size ) + 1;
|
|
tmax = ( surf->info->lightextents[1] / sample_size ) + 1;
|
|
|
|
// upload the lightmap
|
|
if( surf->samples != NULL && FBitSet( surf->flags, SURF_LM_UPDATE ))
|
|
{
|
|
GL_BindTexture( GL_TEXTURE0, tr.lightmaps[esrf->lightmaptexturenum].lightmap );
|
|
|
|
// write lightmaps into page
|
|
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != LS_NONE; map++ )
|
|
{
|
|
R_BuildLightMapForStyle( surf, buf, map );
|
|
pglTexSubImage2D( GL_TEXTURE_2D, 0, esrf->light_s[map], esrf->light_t[map], smax, tmax, GL_RGBA, GL_UNSIGNED_BYTE, buf );
|
|
}
|
|
}
|
|
|
|
ClearBits( surf->flags, SURF_LM_UPDATE );
|
|
|
|
// upload the deluxemap
|
|
if( esrf->normals != NULL && FBitSet( surf->flags, SURF_DM_UPDATE ))
|
|
{
|
|
GL_BindTexture( GL_TEXTURE0, tr.lightmaps[esrf->lightmaptexturenum].deluxmap );
|
|
|
|
// write lightmaps into page
|
|
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != LS_NONE; map++ )
|
|
{
|
|
R_BuildDeluxMapForStyle( surf, buf, map );
|
|
pglTexSubImage2D( GL_TEXTURE_2D, 0, esrf->light_s[map], esrf->light_t[map], smax, tmax, GL_RGBA, GL_UNSIGNED_BYTE, buf );
|
|
}
|
|
}
|
|
|
|
ClearBits( surf->flags, SURF_DM_UPDATE );
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_UpdateLightMap
|
|
|
|
Combine and scale multiple lightmaps into the floating
|
|
format in r_blocklights
|
|
=================
|
|
*/
|
|
static void R_UpdateLightMap( mstudiosurface_t *surf )
|
|
{
|
|
static byte buf[512*512*4];
|
|
int map, smax, tmax;
|
|
|
|
smax = surf->lightextents[0] + 1;
|
|
tmax = surf->lightextents[1] + 1;
|
|
|
|
// upload the lightmap
|
|
if( surf->samples != NULL && FBitSet( surf->flags, SURF_LM_UPDATE ))
|
|
{
|
|
GL_BindTexture( GL_TEXTURE0, tr.lightmaps[surf->lightmaptexturenum].lightmap );
|
|
|
|
// write lightmaps into page
|
|
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != LS_NONE; map++ )
|
|
{
|
|
R_BuildLightMapForStyle( surf, buf, map );
|
|
pglTexSubImage2D( GL_TEXTURE_2D, 0, surf->light_s[map], surf->light_t[map], smax, tmax, GL_RGBA, GL_UNSIGNED_BYTE, buf );
|
|
}
|
|
}
|
|
|
|
ClearBits( surf->flags, SURF_LM_UPDATE );
|
|
|
|
// upload the deluxemap
|
|
if( surf->normals != NULL && FBitSet( surf->flags, SURF_DM_UPDATE ))
|
|
{
|
|
GL_BindTexture( GL_TEXTURE0, tr.lightmaps[surf->lightmaptexturenum].deluxmap );
|
|
|
|
// write lightmaps into page
|
|
for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != LS_NONE; map++ )
|
|
{
|
|
R_BuildDeluxMapForStyle( surf, buf, map );
|
|
pglTexSubImage2D( GL_TEXTURE_2D, 0, surf->light_s[map], surf->light_t[map], smax, tmax, GL_RGBA, GL_UNSIGNED_BYTE, buf );
|
|
}
|
|
}
|
|
|
|
ClearBits( surf->flags, SURF_DM_UPDATE );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
R_TextureCoords
|
|
|
|
fill vec2_t with texture coords
|
|
========================
|
|
*/
|
|
void R_TextureCoords( msurface_t *surf, const Vector &vec, float *out )
|
|
{
|
|
float s, t;
|
|
|
|
s = DotProduct( vec, surf->texinfo->vecs[0] ) + surf->texinfo->vecs[0][3];
|
|
s /= surf->texinfo->texture->width;
|
|
|
|
t = DotProduct( vec, surf->texinfo->vecs[1] ) + surf->texinfo->vecs[1][3];
|
|
t /= surf->texinfo->texture->height;
|
|
|
|
out[0] = s;
|
|
out[1] = t;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
R_GlobalCoords
|
|
|
|
fill vec2_t with global coords
|
|
========================
|
|
*/
|
|
void R_GlobalCoords( msurface_t *surf, const Vector &point, float *out )
|
|
{
|
|
mfaceinfo_t *land = surf->texinfo->faceinfo;
|
|
terrain_t *terra;
|
|
Vector size;
|
|
indexMap_t *im;
|
|
|
|
if( !land ) return;
|
|
|
|
terra = land->terrain;
|
|
if( !terra ) return;
|
|
|
|
im = &terra->indexmap;
|
|
|
|
for( int i = 0; i < 3; i++ )
|
|
size[i] = land->maxs[i] - land->mins[i];
|
|
|
|
out[2] = ( point[0] - land->mins[0] ) / size[0];
|
|
out[3] = ( land->maxs[1] - point[1] ) / size[1];
|
|
}
|
|
|
|
/*
|
|
========================
|
|
R_GlobalCoords
|
|
|
|
fill vec2_t with global coords
|
|
========================
|
|
*/
|
|
void R_GlobalCoords( msurface_t *surf, const Vector &point, const Vector &absmin, const Vector &absmax, float scale, float *out )
|
|
{
|
|
Vector size;
|
|
|
|
for( int i = 0; i < 3; i++ )
|
|
size[i] = absmax[i] - absmin[i];
|
|
|
|
out[2] = (( point[0] - absmin[0] ) / size[0]) * scale;
|
|
out[3] = (( absmax[1] - point[1] ) / size[1]) * scale;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
R_LightmapCoords
|
|
|
|
fill Vector4D with lightstyle coords (two styles per array)
|
|
========================
|
|
*/
|
|
void R_LightmapCoords( msurface_t *surf, const Vector &vec, float *coords, int style )
|
|
{
|
|
mextrasurf_t *esrf = surf->info;
|
|
float sample_size = Mod_SampleSizeForFace( surf );
|
|
float s, t;
|
|
|
|
for( int i = 0; i < 2; i++ )
|
|
{
|
|
if( surf->styles[style+i] == LS_NONE )
|
|
return; // end of styles
|
|
|
|
s = DotProduct( vec, surf->info->lmvecs[0] ) + surf->info->lmvecs[0][3];
|
|
s -= surf->info->lightmapmins[0];
|
|
s += esrf->light_s[style+i] * sample_size;
|
|
s += sample_size * 0.5f;
|
|
s /= BLOCK_SIZE * sample_size;
|
|
|
|
t = DotProduct( vec, surf->info->lmvecs[1] ) + surf->info->lmvecs[1][3];
|
|
t -= surf->info->lightmapmins[1];
|
|
t += esrf->light_t[style+i] * sample_size;
|
|
t += sample_size * 0.5f;
|
|
t /= BLOCK_SIZE * sample_size;
|
|
|
|
coords[i*2+0] = s;
|
|
coords[i*2+1] = t;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
R_LightmapCoords
|
|
|
|
fill Vector4D with lightstyle coords (two styles per array)
|
|
========================
|
|
*/
|
|
void R_LightmapCoords( mstudiosurface_t *surf, const Vector &vec, const Vector lmvecs[2], float *coords, int style )
|
|
{
|
|
float s, t;
|
|
|
|
for( int i = 0; i < 2; i++ )
|
|
{
|
|
if( surf->styles[style+i] == LS_NONE )
|
|
return; // end of styles
|
|
|
|
s = DotProduct( vec, lmvecs[0] ) + surf->light_s[style+i] + 0.5f;
|
|
t = DotProduct( vec, lmvecs[1] ) + surf->light_t[style+i] + 0.5f;
|
|
s /= (float)BLOCK_SIZE;
|
|
t /= (float)BLOCK_SIZE;
|
|
|
|
coords[i*2+0] = s;
|
|
coords[i*2+1] = t;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_UpdateSurfaceParams
|
|
|
|
update some surface params
|
|
if this was changed
|
|
=================
|
|
*/
|
|
void R_UpdateSurfaceParams( msurface_t *surf )
|
|
{
|
|
mextrasurf_t *esrf = surf->info;
|
|
cl_entity_t *e = RI->currententity;
|
|
model_t *clmodel = e->model;
|
|
|
|
// check for lightmap modification
|
|
if( FBitSet( surf->flags, SURF_LM_UPDATE|SURF_DM_UPDATE ))
|
|
R_UpdateLightMap( surf );
|
|
|
|
if( FBitSet( surf->flags, SURF_MOVIE ))
|
|
R_UpdateCinematic( surf );
|
|
|
|
// handle conveyor movement
|
|
if( FBitSet( clmodel->flags, BIT( 0 )) && FBitSet( surf->flags, SURF_CONVEYOR ))
|
|
{
|
|
float flRate, flAngle;
|
|
float flWidth, flConveyorSpeed;
|
|
float sOffset, sy;
|
|
float tOffset, cy;
|
|
|
|
flConveyorSpeed = (e->curstate.rendercolor.g<<8|e->curstate.rendercolor.b) / 16.0f;
|
|
if( e->curstate.rendercolor.r ) flConveyorSpeed = -flConveyorSpeed;
|
|
flWidth = (float)RENDER_GET_PARM( PARM_TEX_SRC_WIDTH, surf->texinfo->texture->gl_texturenum );
|
|
|
|
if( flWidth != 0.0f )
|
|
{
|
|
flRate = abs( flConveyorSpeed ) / flWidth;
|
|
flAngle = ( flConveyorSpeed >= 0.0f ) ? 180.0f : 0.0f;
|
|
|
|
SinCos( DEG2RAD( flAngle ), &sy, &cy );
|
|
sOffset = tr.time * cy * flRate;
|
|
tOffset = tr.time * sy * flRate;
|
|
|
|
// make sure that we are positive
|
|
if( sOffset < 0.0f ) sOffset += 1.0f + -(int)sOffset;
|
|
if( tOffset < 0.0f ) tOffset += 1.0f + -(int)tOffset;
|
|
|
|
// make sure that we are in a [0,1] range
|
|
sOffset = sOffset - (int)sOffset;
|
|
tOffset = tOffset - (int)tOffset;
|
|
|
|
esrf->texofs[0] = sOffset;
|
|
esrf->texofs[1] = tOffset;
|
|
}
|
|
else
|
|
{
|
|
// no conveyor
|
|
esrf->texofs[0] = 0.0f;
|
|
esrf->texofs[1] = 0.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no conveyor
|
|
esrf->texofs[0] = 0.0f;
|
|
esrf->texofs[1] = 0.0f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_UpdateSurfaceParams
|
|
|
|
update some surface params
|
|
if this was changed
|
|
=================
|
|
*/
|
|
void R_UpdateSurfaceParams( mstudiosurface_t *surf )
|
|
{
|
|
// check for lightmap modification
|
|
if( FBitSet( surf->flags, SURF_LM_UPDATE|SURF_DM_UPDATE ))
|
|
R_UpdateLightMap( surf );
|
|
} |