gl_rsurf.c File Reference

#include <assert.h>
#include "gl_local.h"
#include <ctype.h>

Go to the source code of this file.

Classes
struct	gllightmapstate_t

Macros
#define	DYNAMIC_LIGHT_WIDTH   128
#define	DYNAMIC_LIGHT_HEIGHT   128
#define	LIGHTMAP_BYTES   4
#define	BLOCK_WIDTH   128
#define	BLOCK_HEIGHT   128
#define	MAX_LIGHTMAPS   128
#define	GL_LIGHTMAP_FORMAT   GL_RGBA

Functions
static void	LM_InitBlock (void)
static void	LM_UploadBlock (qboolean dynamic)
static qboolean	LM_AllocBlock (int w, int h, int *x, int *y)
void	R_SetCacheState (msurface_t *surf)
void	R_BuildLightMap (msurface_t *surf, byte *dest, int stride)
image_t *	R_TextureAnimation (mtexinfo_t *tex)
void	DrawGLPoly (glpoly_t *p)
void	DrawGLFlowingPoly (msurface_t *fa)
void	R_DrawTriangleOutlines (void)
void	DrawGLPolyChain (glpoly_t *p, float soffset, float toffset)
void	R_BlendLightmaps (void)
void	R_RenderBrushPoly (msurface_t *fa)
void	R_DrawAlphaSurfaces (void)
void	DrawTextureChains (void)
static void	GL_RenderLightmappedPoly (msurface_t *surf)
void	R_DrawInlineBModel (void)
void	R_DrawBrushModel (entity_t *e)
void	R_RecursiveWorldNode (mnode_t *node)
void	R_DrawWorld (void)
void	R_MarkLeaves (void)
void	GL_BuildPolygonFromSurface (msurface_t *fa)
void	GL_CreateSurfaceLightmap (msurface_t *surf)
void	GL_BeginBuildingLightmaps (model_t *m)
void	GL_EndBuildingLightmaps (void)

Variables
static vec3_t	modelorg
msurface_t *	r_alpha_surfaces
int	c_visible_lightmaps
int	c_visible_textures
static gllightmapstate_t	gl_lms

Macro Definition Documentation

BLOCK_HEIGHT

#define BLOCK_HEIGHT   128

Definition at line 36 of file gl_rsurf.c.

BLOCK_WIDTH

#define BLOCK_WIDTH   128

Definition at line 35 of file gl_rsurf.c.

DYNAMIC_LIGHT_HEIGHT

#define DYNAMIC_LIGHT_HEIGHT   128

Definition at line 31 of file gl_rsurf.c.

DYNAMIC_LIGHT_WIDTH

#define DYNAMIC_LIGHT_WIDTH   128

Definition at line 30 of file gl_rsurf.c.

GL_LIGHTMAP_FORMAT

#define GL_LIGHTMAP_FORMAT   GL_RGBA

Definition at line 43 of file gl_rsurf.c.

LIGHTMAP_BYTES

#define LIGHTMAP_BYTES   4

Definition at line 33 of file gl_rsurf.c.

MAX_LIGHTMAPS

#define MAX_LIGHTMAPS   128

Definition at line 38 of file gl_rsurf.c.

Function Documentation

DrawGLFlowingPoly()

void DrawGLFlowingPoly

(

msurface_t *

fa

)

Definition at line 203 of file gl_rsurf.c.

{
    int     i;
    float   *v;
    glpoly_t *p;
    float   scroll;
 
    p = fa->polys;
 
    scroll = -64 * ( (r_newrefdef.time / 40.0) - (int)(r_newrefdef.time / 40.0) );
    if(scroll == 0.0)
        scroll = -64.0;
 
    qglBegin (GL_POLYGON);
    v = p->verts[0];
    for (i=0 ; i<p->numverts ; i++, v+= VERTEXSIZE)
    {
        qglTexCoord2f ((v[3] + scroll), v[4]);
        qglVertex3fv (v);
    }
    qglEnd ();
}

Referenced by R_DrawAlphaSurfaces(), and R_RenderBrushPoly().

DrawGLPoly()

void DrawGLPoly

(

glpoly_t *

p

)

Definition at line 181 of file gl_rsurf.c.

{
    int     i;
    float   *v;
 
    qglBegin (GL_POLYGON);
    v = p->verts[0];
    for (i=0 ; i<p->numverts ; i++, v+= VERTEXSIZE)
    {
        qglTexCoord2f (v[3], v[4]);
        qglVertex3fv (v);
    }
    qglEnd ();
}

Referenced by R_DrawAlphaSurfaces(), and R_RenderBrushPoly().

DrawGLPolyChain()

void DrawGLPolyChain	(	glpoly_t *	p,
		float	soffset,
		float	toffset
	)

Definition at line 272 of file gl_rsurf.c.

{
    if ( soffset == 0 && toffset == 0 )
    {
        for ( ; p != 0; p = p->chain )
        {
            float *v;
            int j;
 
            qglBegin (GL_POLYGON);
            v = p->verts[0];
            for (j=0 ; j<p->numverts ; j++, v+= VERTEXSIZE)
            {
                qglTexCoord2f (v[5], v[6] );
                qglVertex3fv (v);
            }
            qglEnd ();
        }
    }
    else
    {
        for ( ; p != 0; p = p->chain )
        {
            float *v;
            int j;
 
            qglBegin (GL_POLYGON);
            v = p->verts[0];
            for (j=0 ; j<p->numverts ; j++, v+= VERTEXSIZE)
            {
                qglTexCoord2f (v[5] - soffset, v[6] - toffset );
                qglVertex3fv (v);
            }
            qglEnd ();
        }
    }
}

Referenced by R_BlendLightmaps().

DrawTextureChains()

void DrawTextureChains

(

void

)

Definition at line 635 of file gl_rsurf.c.

{
    int     i;
    msurface_t  *s;
    image_t     *image;
 
    c_visible_textures = 0;
 
//  GL_TexEnv( GL_REPLACE );
 
    if ( !qglSelectTextureSGIS && !qglActiveTextureARB )
    {
        for ( i = 0, image=gltextures ; i<numgltextures ; i++,image++)
        {
            if (!image->registration_sequence)
                continue;
            s = image->texturechain;
            if (!s)
                continue;
            c_visible_textures++;
 
            for ( ; s ; s=s->texturechain)
                R_RenderBrushPoly (s);
 
            image->texturechain = NULL;
        }
    }
    else
    {
        for ( i = 0, image=gltextures ; i<numgltextures ; i++,image++)
        {
            if (!image->registration_sequence)
                continue;
            if (!image->texturechain)
                continue;
            c_visible_textures++;
 
            for ( s = image->texturechain; s ; s=s->texturechain)
            {
                if ( !( s->flags & SURF_DRAWTURB ) )
                    R_RenderBrushPoly (s);
            }
        }
 
        GL_EnableMultitexture( false );
        for ( i = 0, image=gltextures ; i<numgltextures ; i++,image++)
        {
            if (!image->registration_sequence)
                continue;
            s = image->texturechain;
            if (!s)
                continue;
 
            for ( ; s ; s=s->texturechain)
            {
                if ( s->flags & SURF_DRAWTURB )
                    R_RenderBrushPoly (s);
            }
 
            image->texturechain = NULL;
        }
//      GL_EnableMultitexture( true );
    }
 
    GL_TexEnv( GL_REPLACE );
}

Referenced by R_DrawWorld().

GL_BeginBuildingLightmaps()

void GL_BeginBuildingLightmaps

(

model_t *

m

)

Definition at line 1565 of file gl_rsurf.c.

{
    static lightstyle_t lightstyles[MAX_LIGHTSTYLES];
    int             i;
    unsigned        dummy[128*128];
 
    memset( gl_lms.allocated, 0, sizeof(gl_lms.allocated) );
 
    r_framecount = 1;       // no dlightcache
 
    GL_EnableMultitexture( true );
    GL_SelectTexture( gl_texture1);
 
    /*
    ** setup the base lightstyles so the lightmaps won't have to be regenerated
    ** the first time they're seen
    */
    for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
    {
        lightstyles[i].rgb[0] = 1;
        lightstyles[i].rgb[1] = 1;
        lightstyles[i].rgb[2] = 1;
        lightstyles[i].white = 3;
    }
    r_newrefdef.lightstyles = lightstyles;
 
    if (!gl_state.lightmap_textures)
    {
        gl_state.lightmap_textures  = TEXNUM_LIGHTMAPS;
//      gl_state.lightmap_textures  = gl_state.texture_extension_number;
//      gl_state.texture_extension_number = gl_state.lightmap_textures + MAX_LIGHTMAPS;
    }
 
    gl_lms.current_lightmap_texture = 1;
 
    /*
    ** if mono lightmaps are enabled and we want to use alpha
    ** blending (a,1-a) then we're likely running on a 3DLabs
    ** Permedia2.  In a perfect world we'd use a GL_ALPHA lightmap
    ** in order to conserve space and maximize bandwidth, however 
    ** this isn't a perfect world.
    **
    ** So we have to use alpha lightmaps, but stored in GL_RGBA format,
    ** which means we only get 1/16th the color resolution we should when
    ** using alpha lightmaps.  If we find another board that supports
    ** only alpha lightmaps but that can at least support the GL_ALPHA
    ** format then we should change this code to use real alpha maps.
    */
    if ( toupper( gl_monolightmap->string[0] ) == 'A' )
    {
        gl_lms.internal_format = gl_tex_alpha_format;
    }
    /*
    ** try to do hacked colored lighting with a blended texture
    */
    else if ( toupper( gl_monolightmap->string[0] ) == 'C' )
    {
        gl_lms.internal_format = gl_tex_alpha_format;
    }
    else if ( toupper( gl_monolightmap->string[0] ) == 'I' )
    {
        gl_lms.internal_format = GL_INTENSITY8;
    }
    else if ( toupper( gl_monolightmap->string[0] ) == 'L' ) 
    {
        gl_lms.internal_format = GL_LUMINANCE8;
    }
    else
    {
        gl_lms.internal_format = gl_tex_solid_format;
    }
 
    /*
    ** initialize the dynamic lightmap texture
    */
    GL_Bind( gl_state.lightmap_textures + 0 );
    qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    qglTexImage2D( GL_TEXTURE_2D, 
                   0, 
                   gl_lms.internal_format,
                   BLOCK_WIDTH, BLOCK_HEIGHT, 
                   0, 
                   GL_LIGHTMAP_FORMAT, 
                   GL_UNSIGNED_BYTE, 
                   dummy );
}

Referenced by Mod_LoadFaces().

GL_BuildPolygonFromSurface()

void GL_BuildPolygonFromSurface

(

msurface_t *

fa

)

Definition at line 1450 of file gl_rsurf.c.

{
    int         i, lindex, lnumverts;
    medge_t     *pedges, *r_pedge;
    int         vertpage;
    float       *vec;
    float       s, t;
    glpoly_t    *poly;
    vec3_t      total;
 
// reconstruct the polygon
    pedges = currentmodel->edges;
    lnumverts = fa->numedges;
    vertpage = 0;
 
    VectorClear (total);
    //
    // draw texture
    //
    poly = Hunk_Alloc (sizeof(glpoly_t) + (lnumverts-4) * VERTEXSIZE*sizeof(float));
    poly->next = fa->polys;
    poly->flags = fa->flags;
    fa->polys = poly;
    poly->numverts = lnumverts;
 
    for (i=0 ; i<lnumverts ; i++)
    {
        lindex = currentmodel->surfedges[fa->firstedge + i];
 
        if (lindex > 0)
        {
            r_pedge = &pedges[lindex];
            vec = currentmodel->vertexes[r_pedge->v[0]].position;
        }
        else
        {
            r_pedge = &pedges[-lindex];
            vec = currentmodel->vertexes[r_pedge->v[1]].position;
        }
        s = DotProduct (vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
        s /= fa->texinfo->image->width;
 
        t = DotProduct (vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
        t /= fa->texinfo->image->height;
 
        VectorAdd (total, vec, total);
        VectorCopy (vec, poly->verts[i]);
        poly->verts[i][3] = s;
        poly->verts[i][4] = t;
 
        //
        // lightmap texture coordinates
        //
        s = DotProduct (vec, fa->texinfo->vecs[0]) + fa->texinfo->vecs[0][3];
        s -= fa->texturemins[0];
        s += fa->light_s*16;
        s += 8;
        s /= BLOCK_WIDTH*16; //fa->texinfo->texture->width;
 
        t = DotProduct (vec, fa->texinfo->vecs[1]) + fa->texinfo->vecs[1][3];
        t -= fa->texturemins[1];
        t += fa->light_t*16;
        t += 8;
        t /= BLOCK_HEIGHT*16; //fa->texinfo->texture->height;
 
        poly->verts[i][5] = s;
        poly->verts[i][6] = t;
    }
 
    poly->numverts = lnumverts;
 
}

Referenced by Mod_LoadFaces().

GL_CreateSurfaceLightmap()

void GL_CreateSurfaceLightmap

(

msurface_t *

surf

)

Definition at line 1528 of file gl_rsurf.c.

{
    int     smax, tmax;
    byte    *base;
 
    if (surf->flags & (SURF_DRAWSKY|SURF_DRAWTURB))
        return;
 
    smax = (surf->extents[0]>>4)+1;
    tmax = (surf->extents[1]>>4)+1;
 
    if ( !LM_AllocBlock( smax, tmax, &surf->light_s, &surf->light_t ) )
    {
        LM_UploadBlock( false );
        LM_InitBlock();
        if ( !LM_AllocBlock( smax, tmax, &surf->light_s, &surf->light_t ) )
        {
            ri.Sys_Error( ERR_FATAL, "Consecutive calls to LM_AllocBlock(%d,%d) failed\n", smax, tmax );
        }
    }
 
    surf->lightmaptexturenum = gl_lms.current_lightmap_texture;
 
    base = gl_lms.lightmap_buffer;
    base += (surf->light_t * BLOCK_WIDTH + surf->light_s) * LIGHTMAP_BYTES;
 
    R_SetCacheState( surf );
    R_BuildLightMap (surf, base, BLOCK_WIDTH*LIGHTMAP_BYTES);
}

Referenced by Mod_LoadFaces().

GL_EndBuildingLightmaps()

void GL_EndBuildingLightmaps

(

void

)

Definition at line 1658 of file gl_rsurf.c.

{
    LM_UploadBlock( false );
    GL_EnableMultitexture( false );
}

Referenced by Mod_LoadFaces().

GL_RenderLightmappedPoly()

static void GL_RenderLightmappedPoly ( msurface_t *  surf )

static

Definition at line 703 of file gl_rsurf.c.

{
    int     i, nv = surf->polys->numverts;
    int     map;
    float   *v;
    image_t *image = R_TextureAnimation( surf->texinfo );
    qboolean is_dynamic = false;
    unsigned lmtex = surf->lightmaptexturenum;
    glpoly_t *p;
 
    for ( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != 255; map++ )
    {
        if ( r_newrefdef.lightstyles[surf->styles[map]].white != surf->cached_light[map] )
            goto dynamic;
    }
 
    // dynamic this frame or dynamic previously
    if ( ( surf->dlightframe == r_framecount ) )
    {
dynamic:
        if ( gl_dynamic->value )
        {
            if ( !(surf->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP ) ) )
            {
                is_dynamic = true;
            }
        }
    }
 
    if ( is_dynamic )
    {
        unsigned    temp[128*128];
        int         smax, tmax;
 
        if ( ( surf->styles[map] >= 32 || surf->styles[map] == 0 ) && ( surf->dlightframe != r_framecount ) )
        {
            smax = (surf->extents[0]>>4)+1;
            tmax = (surf->extents[1]>>4)+1;
 
            R_BuildLightMap( surf, (void *)temp, smax*4 );
            R_SetCacheState( surf );
 
            GL_MBind( gl_texture1, gl_state.lightmap_textures + surf->lightmaptexturenum );
 
            lmtex = surf->lightmaptexturenum;
 
            qglTexSubImage2D( GL_TEXTURE_2D, 0,
                              surf->light_s, surf->light_t, 
                              smax, tmax, 
                              GL_LIGHTMAP_FORMAT, 
                              GL_UNSIGNED_BYTE, temp );
 
        }
        else
        {
            smax = (surf->extents[0]>>4)+1;
            tmax = (surf->extents[1]>>4)+1;
 
            R_BuildLightMap( surf, (void *)temp, smax*4 );
 
            GL_MBind( gl_texture1, gl_state.lightmap_textures + 0 );
 
            lmtex = 0;
 
            qglTexSubImage2D( GL_TEXTURE_2D, 0,
                              surf->light_s, surf->light_t, 
                              smax, tmax, 
                              GL_LIGHTMAP_FORMAT, 
                              GL_UNSIGNED_BYTE, temp );
 
        }
 
        c_brush_polys++;
 
        GL_MBind( gl_texture0, image->texnum );
        GL_MBind( gl_texture1, gl_state.lightmap_textures + lmtex );
 
//==========
//PGM
        if (surf->texinfo->flags & SURF_FLOWING)
        {
            float scroll;
        
            scroll = -64 * ( (r_newrefdef.time / 40.0) - (int)(r_newrefdef.time / 40.0) );
            if(scroll == 0.0)
                scroll = -64.0;
 
            for ( p = surf->polys; p; p = p->chain )
            {
                v = p->verts[0];
                qglBegin (GL_POLYGON);
                for (i=0 ; i< nv; i++, v+= VERTEXSIZE)
                {
                    qglMTexCoord2fSGIS( gl_texture0, (v[3]+scroll), v[4]);
                    qglMTexCoord2fSGIS( gl_texture1, v[5], v[6]);
                    qglVertex3fv (v);
                }
                qglEnd ();
            }
        }
        else
        {
            for ( p = surf->polys; p; p = p->chain )
            {
                v = p->verts[0];
                qglBegin (GL_POLYGON);
                for (i=0 ; i< nv; i++, v+= VERTEXSIZE)
                {
                    qglMTexCoord2fSGIS( gl_texture0, v[3], v[4]);
                    qglMTexCoord2fSGIS( gl_texture1, v[5], v[6]);
                    qglVertex3fv (v);
                }
                qglEnd ();
            }
        }
//PGM
//==========
    }
    else
    {
        c_brush_polys++;
 
        GL_MBind( gl_texture0, image->texnum );
        GL_MBind( gl_texture1, gl_state.lightmap_textures + lmtex );
 
//==========
//PGM
        if (surf->texinfo->flags & SURF_FLOWING)
        {
            float scroll;
        
            scroll = -64 * ( (r_newrefdef.time / 40.0) - (int)(r_newrefdef.time / 40.0) );
            if(scroll == 0.0)
                scroll = -64.0;
 
            for ( p = surf->polys; p; p = p->chain )
            {
                v = p->verts[0];
                qglBegin (GL_POLYGON);
                for (i=0 ; i< nv; i++, v+= VERTEXSIZE)
                {
                    qglMTexCoord2fSGIS( gl_texture0, (v[3]+scroll), v[4]);
                    qglMTexCoord2fSGIS( gl_texture1, v[5], v[6]);
                    qglVertex3fv (v);
                }
                qglEnd ();
            }
        }
        else
        {
//PGM
//==========
            for ( p = surf->polys; p; p = p->chain )
            {
                v = p->verts[0];
                qglBegin (GL_POLYGON);
                for (i=0 ; i< nv; i++, v+= VERTEXSIZE)
                {
                    qglMTexCoord2fSGIS( gl_texture0, v[3], v[4]);
                    qglMTexCoord2fSGIS( gl_texture1, v[5], v[6]);
                    qglVertex3fv (v);
                }
                qglEnd ();
            }
//==========
//PGM
        }
//PGM
//==========
    }
}

Referenced by R_DrawInlineBModel(), and R_RecursiveWorldNode().

LM_AllocBlock()

static qboolean LM_AllocBlock ( int  w, int  h, int *  x, int *  y  )

static

Definition at line 1411 of file gl_rsurf.c.

{
    int     i, j;
    int     best, best2;
 
    best = BLOCK_HEIGHT;
 
    for (i=0 ; i<BLOCK_WIDTH-w ; i++)
    {
        best2 = 0;
 
        for (j=0 ; j<w ; j++)
        {
            if (gl_lms.allocated[i+j] >= best)
                break;
            if (gl_lms.allocated[i+j] > best2)
                best2 = gl_lms.allocated[i+j];
        }
        if (j == w)
        {   // this is a valid spot
            *x = i;
            *y = best = best2;
        }
    }
 
    if (best + h > BLOCK_HEIGHT)
        return false;
 
    for (i=0 ; i<w ; i++)
        gl_lms.allocated[*x + i] = best + h;
 
    return true;
}

Referenced by GL_CreateSurfaceLightmap(), and R_BlendLightmaps().

LM_InitBlock()

static void LM_InitBlock ( void  )

static

Definition at line 1354 of file gl_rsurf.c.

{
    memset( gl_lms.allocated, 0, sizeof( gl_lms.allocated ) );
}

Referenced by GL_CreateSurfaceLightmap(), and R_BlendLightmaps().

LM_UploadBlock()

static void LM_UploadBlock ( qboolean  dynamic )

static

Definition at line 1359 of file gl_rsurf.c.

{
    int texture;
    int height = 0;
 
    if ( dynamic )
    {
        texture = 0;
    }
    else
    {
        texture = gl_lms.current_lightmap_texture;
    }
 
    GL_Bind( gl_state.lightmap_textures + texture );
    qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
    if ( dynamic )
    {
        int i;
 
        for ( i = 0; i < BLOCK_WIDTH; i++ )
        {
            if ( gl_lms.allocated[i] > height )
                height = gl_lms.allocated[i];
        }
 
        qglTexSubImage2D( GL_TEXTURE_2D, 
                          0,
                          0, 0,
                          BLOCK_WIDTH, height,
                          GL_LIGHTMAP_FORMAT,
                          GL_UNSIGNED_BYTE,
                          gl_lms.lightmap_buffer );
    }
    else
    {
        qglTexImage2D( GL_TEXTURE_2D, 
                       0, 
                       gl_lms.internal_format,
                       BLOCK_WIDTH, BLOCK_HEIGHT, 
                       0, 
                       GL_LIGHTMAP_FORMAT, 
                       GL_UNSIGNED_BYTE, 
                       gl_lms.lightmap_buffer );
        if ( ++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS )
            ri.Sys_Error( ERR_DROP, "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n" );
    }
}

Referenced by GL_CreateSurfaceLightmap(), GL_EndBuildingLightmaps(), and R_BlendLightmaps().

R_BlendLightmaps()

void R_BlendLightmaps

(

void

)

Definition at line 316 of file gl_rsurf.c.

{
    int         i;
    msurface_t  *surf, *newdrawsurf = 0;
 
    // don't bother if we're set to fullbright
    if (r_fullbright->value)
        return;
    if (!r_worldmodel->lightdata)
        return;
 
    // don't bother writing Z
    qglDepthMask( 0 );
 
    /*
    ** set the appropriate blending mode unless we're only looking at the
    ** lightmaps.
    */
    if (!gl_lightmap->value)
    {
        qglEnable (GL_BLEND);
 
        if ( gl_saturatelighting->value )
        {
            qglBlendFunc( GL_ONE, GL_ONE );
        }
        else
        {
            if ( gl_monolightmap->string[0] != '0' )
            {
                switch ( toupper( gl_monolightmap->string[0] ) )
                {
                case 'I':
                    qglBlendFunc (GL_ZERO, GL_SRC_COLOR );
                    break;
                case 'L':
                    qglBlendFunc (GL_ZERO, GL_SRC_COLOR );
                    break;
                case 'A':
                default:
                    qglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
                    break;
                }
            }
            else
            {
                qglBlendFunc (GL_ZERO, GL_SRC_COLOR );
            }
        }
    }
 
    if ( currentmodel == r_worldmodel )
        c_visible_lightmaps = 0;
 
    /*
    ** render static lightmaps first
    */
    for ( i = 1; i < MAX_LIGHTMAPS; i++ )
    {
        if ( gl_lms.lightmap_surfaces[i] )
        {
            if (currentmodel == r_worldmodel)
                c_visible_lightmaps++;
            GL_Bind( gl_state.lightmap_textures + i);
 
            for ( surf = gl_lms.lightmap_surfaces[i]; surf != 0; surf = surf->lightmapchain )
            {
                if ( surf->polys )
                    DrawGLPolyChain( surf->polys, 0, 0 );
            }
        }
    }
 
    /*
    ** render dynamic lightmaps
    */
    if ( gl_dynamic->value )
    {
        LM_InitBlock();
 
        GL_Bind( gl_state.lightmap_textures+0 );
 
        if (currentmodel == r_worldmodel)
            c_visible_lightmaps++;
 
        newdrawsurf = gl_lms.lightmap_surfaces[0];
 
        for ( surf = gl_lms.lightmap_surfaces[0]; surf != 0; surf = surf->lightmapchain )
        {
            int     smax, tmax;
            byte    *base;
 
            smax = (surf->extents[0]>>4)+1;
            tmax = (surf->extents[1]>>4)+1;
 
            if ( LM_AllocBlock( smax, tmax, &surf->dlight_s, &surf->dlight_t ) )
            {
                base = gl_lms.lightmap_buffer;
                base += ( surf->dlight_t * BLOCK_WIDTH + surf->dlight_s ) * LIGHTMAP_BYTES;
 
                R_BuildLightMap (surf, base, BLOCK_WIDTH*LIGHTMAP_BYTES);
            }
            else
            {
                msurface_t *drawsurf;
 
                // upload what we have so far
                LM_UploadBlock( true );
 
                // draw all surfaces that use this lightmap
                for ( drawsurf = newdrawsurf; drawsurf != surf; drawsurf = drawsurf->lightmapchain )
                {
                    if ( drawsurf->polys )
                        DrawGLPolyChain( drawsurf->polys, 
                                          ( drawsurf->light_s - drawsurf->dlight_s ) * ( 1.0 / 128.0 ), 
                                        ( drawsurf->light_t - drawsurf->dlight_t ) * ( 1.0 / 128.0 ) );
                }
 
                newdrawsurf = drawsurf;
 
                // clear the block
                LM_InitBlock();
 
                // try uploading the block now
                if ( !LM_AllocBlock( smax, tmax, &surf->dlight_s, &surf->dlight_t ) )
                {
                    ri.Sys_Error( ERR_FATAL, "Consecutive calls to LM_AllocBlock(%d,%d) failed (dynamic)\n", smax, tmax );
                }
 
                base = gl_lms.lightmap_buffer;
                base += ( surf->dlight_t * BLOCK_WIDTH + surf->dlight_s ) * LIGHTMAP_BYTES;
 
                R_BuildLightMap (surf, base, BLOCK_WIDTH*LIGHTMAP_BYTES);
            }
        }
 
        /*
        ** draw remainder of dynamic lightmaps that haven't been uploaded yet
        */
        if ( newdrawsurf )
            LM_UploadBlock( true );
 
        for ( surf = newdrawsurf; surf != 0; surf = surf->lightmapchain )
        {
            if ( surf->polys )
                DrawGLPolyChain( surf->polys, ( surf->light_s - surf->dlight_s ) * ( 1.0 / 128.0 ), ( surf->light_t - surf->dlight_t ) * ( 1.0 / 128.0 ) );
        }
    }
 
    /*
    ** restore state
    */
    qglDisable (GL_BLEND);
    qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    qglDepthMask( 1 );
}

Referenced by R_DrawInlineBModel(), and R_DrawWorld().

R_BuildLightMap()

void R_BuildLightMap	(	msurface_t *	surf,
		byte *	dest,
		int	stride
	)

Definition at line 455 of file gl_light.c.

{
    int         smax, tmax;
    int         r, g, b, a, max;
    int         i, j, size;
    byte        *lightmap;
    float       scale[4];
    int         nummaps;
    float       *bl;
    lightstyle_t    *style;
    int monolightmap;
 
    if ( surf->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP) )
        ri.Sys_Error (ERR_DROP, "R_BuildLightMap called for non-lit surface");
 
    smax = (surf->extents[0]>>4)+1;
    tmax = (surf->extents[1]>>4)+1;
    size = smax*tmax;
    if (size > (sizeof(s_blocklights)>>4) )
        ri.Sys_Error (ERR_DROP, "Bad s_blocklights size");
 
// set to full bright if no light data
    if (!surf->samples)
    {
        int maps;
 
        for (i=0 ; i<size*3 ; i++)
            s_blocklights[i] = 255;
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            style = &r_newrefdef.lightstyles[surf->styles[maps]];
        }
        goto store;
    }
 
    // count the # of maps
    for ( nummaps = 0 ; nummaps < MAXLIGHTMAPS && surf->styles[nummaps] != 255 ;
         nummaps++)
        ;
 
    lightmap = surf->samples;
 
    // add all the lightmaps
    if ( nummaps == 1 )
    {
        int maps;
 
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            bl = s_blocklights;
 
            for (i=0 ; i<3 ; i++)
                scale[i] = gl_modulate->value*r_newrefdef.lightstyles[surf->styles[maps]].rgb[i];
 
            if ( scale[0] == 1.0F &&
                 scale[1] == 1.0F &&
                 scale[2] == 1.0F )
            {
                for (i=0 ; i<size ; i++, bl+=3)
                {
                    bl[0] = lightmap[i*3+0];
                    bl[1] = lightmap[i*3+1];
                    bl[2] = lightmap[i*3+2];
                }
            }
            else
            {
                for (i=0 ; i<size ; i++, bl+=3)
                {
                    bl[0] = lightmap[i*3+0] * scale[0];
                    bl[1] = lightmap[i*3+1] * scale[1];
                    bl[2] = lightmap[i*3+2] * scale[2];
                }
            }
            lightmap += size*3;     // skip to next lightmap
        }
    }
    else
    {
        int maps;
 
        memset( s_blocklights, 0, sizeof( s_blocklights[0] ) * size * 3 );
 
        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
             maps++)
        {
            bl = s_blocklights;
 
            for (i=0 ; i<3 ; i++)
                scale[i] = gl_modulate->value*r_newrefdef.lightstyles[surf->styles[maps]].rgb[i];
 
            if ( scale[0] == 1.0F &&
                 scale[1] == 1.0F &&
                 scale[2] == 1.0F )
            {
                for (i=0 ; i<size ; i++, bl+=3 )
                {
                    bl[0] += lightmap[i*3+0];
                    bl[1] += lightmap[i*3+1];
                    bl[2] += lightmap[i*3+2];
                }
            }
            else
            {
                for (i=0 ; i<size ; i++, bl+=3)
                {
                    bl[0] += lightmap[i*3+0] * scale[0];
                    bl[1] += lightmap[i*3+1] * scale[1];
                    bl[2] += lightmap[i*3+2] * scale[2];
                }
            }
            lightmap += size*3;     // skip to next lightmap
        }
    }
 
// add all the dynamic lights
    if (surf->dlightframe == r_framecount)
        R_AddDynamicLights (surf);
 
// put into texture format
store:
    stride -= (smax<<2);
    bl = s_blocklights;
 
    monolightmap = gl_monolightmap->string[0];
 
    if ( monolightmap == '0' )
    {
        for (i=0 ; i<tmax ; i++, dest += stride)
        {
            for (j=0 ; j<smax ; j++)
            {
                
                r = Q_ftol( bl[0] );
                g = Q_ftol( bl[1] );
                b = Q_ftol( bl[2] );
 
                // catch negative lights
                if (r < 0)
                    r = 0;
                if (g < 0)
                    g = 0;
                if (b < 0)
                    b = 0;
 
                /*
                ** determine the brightest of the three color components
                */
                if (r > g)
                    max = r;
                else
                    max = g;
                if (b > max)
                    max = b;
 
                /*
                ** alpha is ONLY used for the mono lightmap case.  For this reason
                ** we set it to the brightest of the color components so that 
                ** things don't get too dim.
                */
                a = max;
 
                /*
                ** rescale all the color components if the intensity of the greatest
                ** channel exceeds 1.0
                */
                if (max > 255)
                {
                    float t = 255.0F / max;
 
                    r = r*t;
                    g = g*t;
                    b = b*t;
                    a = a*t;
                }
 
                dest[0] = r;
                dest[1] = g;
                dest[2] = b;
                dest[3] = a;
 
                bl += 3;
                dest += 4;
            }
        }
    }
    else
    {
        for (i=0 ; i<tmax ; i++, dest += stride)
        {
            for (j=0 ; j<smax ; j++)
            {
                
                r = Q_ftol( bl[0] );
                g = Q_ftol( bl[1] );
                b = Q_ftol( bl[2] );
 
                // catch negative lights
                if (r < 0)
                    r = 0;
                if (g < 0)
                    g = 0;
                if (b < 0)
                    b = 0;
 
                /*
                ** determine the brightest of the three color components
                */
                if (r > g)
                    max = r;
                else
                    max = g;
                if (b > max)
                    max = b;
 
                /*
                ** alpha is ONLY used for the mono lightmap case.  For this reason
                ** we set it to the brightest of the color components so that 
                ** things don't get too dim.
                */
                a = max;
 
                /*
                ** rescale all the color components if the intensity of the greatest
                ** channel exceeds 1.0
                */
                if (max > 255)
                {
                    float t = 255.0F / max;
 
                    r = r*t;
                    g = g*t;
                    b = b*t;
                    a = a*t;
                }
 
                /*
                ** So if we are doing alpha lightmaps we need to set the R, G, and B
                ** components to 0 and we need to set alpha to 1-alpha.
                */
                switch ( monolightmap )
                {
                case 'L':
                case 'I':
                    r = a;
                    g = b = 0;
                    break;
                case 'C':
                    // try faking colored lighting
                    a = 255 - ((r+g+b)/3);
                    r *= a/255.0;
                    g *= a/255.0;
                    b *= a/255.0;
                    break;
                case 'A':
                default:
                    r = g = b = 0;
                    a = 255 - a;
                    break;
                }
 
                dest[0] = r;
                dest[1] = g;
                dest[2] = b;
                dest[3] = a;
 
                bl += 3;
                dest += 4;
            }
        }
    }
}

Referenced by GL_CreateSurfaceLightmap(), GL_RenderLightmappedPoly(), R_BlendLightmaps(), and R_RenderBrushPoly().

R_DrawAlphaSurfaces()

void R_DrawAlphaSurfaces

(

void

)

Definition at line 588 of file gl_rsurf.c.

{
    msurface_t  *s;
    float       intens;
 
    //
    // go back to the world matrix
    //
    qglLoadMatrixf (r_world_matrix);
 
    qglEnable (GL_BLEND);
    GL_TexEnv( GL_MODULATE );
 
    // the textures are prescaled up for a better lighting range,
    // so scale it back down
    intens = gl_state.inverse_intensity;
 
    for (s=r_alpha_surfaces ; s ; s=s->texturechain)
    {
        GL_Bind(s->texinfo->image->texnum);
        c_brush_polys++;
        if (s->texinfo->flags & SURF_TRANS33)
            qglColor4f (intens,intens,intens,0.33);
        else if (s->texinfo->flags & SURF_TRANS66)
            qglColor4f (intens,intens,intens,0.66);
        else
            qglColor4f (intens,intens,intens,1);
        if (s->flags & SURF_DRAWTURB)
            EmitWaterPolys (s);
        else if(s->texinfo->flags & SURF_FLOWING)           // PGM  9/16/98
            DrawGLFlowingPoly (s);                          // PGM
        else
            DrawGLPoly (s->polys);
    }
 
    GL_TexEnv( GL_REPLACE );
    qglColor4f (1,1,1,1);
    qglDisable (GL_BLEND);
 
    r_alpha_surfaces = NULL;
}

R_DrawBrushModel()

void R_DrawBrushModel

(

entity_t *

e

)

Definition at line 957 of file gl_rsurf.c.

{
    vec3_t      mins, maxs;
    int         i;
    qboolean    rotated;
 
    if (currentmodel->nummodelsurfaces == 0)
        return;
 
    currententity = e;
    gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
 
    if (e->angles[0] || e->angles[1] || e->angles[2])
    {
        rotated = true;
        for (i=0 ; i<3 ; i++)
        {
            mins[i] = e->origin[i] - currentmodel->radius;
            maxs[i] = e->origin[i] + currentmodel->radius;
        }
    }
    else
    {
        rotated = false;
        VectorAdd (e->origin, currentmodel->mins, mins);
        VectorAdd (e->origin, currentmodel->maxs, maxs);
    }
 
    if (R_CullBox (mins, maxs))
        return;
 
    qglColor3f (1,1,1);
    memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
 
    VectorSubtract (r_newrefdef.vieworg, e->origin, modelorg);
    if (rotated)
    {
        vec3_t  temp;
        vec3_t  forward, right, up;
 
        VectorCopy (modelorg, temp);
        AngleVectors (e->angles, forward, right, up);
        modelorg[0] = DotProduct (temp, forward);
        modelorg[1] = -DotProduct (temp, right);
        modelorg[2] = DotProduct (temp, up);
    }
 
    qglPushMatrix ();
e->angles[0] = -e->angles[0];   // stupid quake bug
e->angles[2] = -e->angles[2];   // stupid quake bug
    R_RotateForEntity (e);
e->angles[0] = -e->angles[0];   // stupid quake bug
e->angles[2] = -e->angles[2];   // stupid quake bug
 
    GL_EnableMultitexture( true );
    GL_SelectTexture( gl_texture0);
    GL_TexEnv( GL_REPLACE );
    GL_SelectTexture( gl_texture1);
    GL_TexEnv( GL_MODULATE );
 
    R_DrawInlineBModel ();
    GL_EnableMultitexture( false );
 
    qglPopMatrix ();
}

R_DrawInlineBModel()

void R_DrawInlineBModel

(

void

)

Definition at line 880 of file gl_rsurf.c.

{
    int         i, k;
    cplane_t    *pplane;
    float       dot;
    msurface_t  *psurf;
    dlight_t    *lt;
 
    // calculate dynamic lighting for bmodel
    if ( !gl_flashblend->value )
    {
        lt = r_newrefdef.dlights;
        for (k=0 ; k<r_newrefdef.num_dlights ; k++, lt++)
        {
            R_MarkLights (lt, 1<<k, currentmodel->nodes + currentmodel->firstnode);
        }
    }
 
    psurf = &currentmodel->surfaces[currentmodel->firstmodelsurface];
 
    if ( currententity->flags & RF_TRANSLUCENT )
    {
        qglEnable (GL_BLEND);
        qglColor4f (1,1,1,0.25);
        GL_TexEnv( GL_MODULATE );
    }
 
    //
    // draw texture
    //
    for (i=0 ; i<currentmodel->nummodelsurfaces ; i++, psurf++)
    {
    // find which side of the node we are on
        pplane = psurf->plane;
 
        dot = DotProduct (modelorg, pplane->normal) - pplane->dist;
 
    // draw the polygon
        if (((psurf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
            (!(psurf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
        {
            if (psurf->texinfo->flags & (SURF_TRANS33|SURF_TRANS66) )
            {   // add to the translucent chain
                psurf->texturechain = r_alpha_surfaces;
                r_alpha_surfaces = psurf;
            }
            else if ( qglMTexCoord2fSGIS && !( psurf->flags & SURF_DRAWTURB ) )
            {
                GL_RenderLightmappedPoly( psurf );
            }
            else
            {
                GL_EnableMultitexture( false );
                R_RenderBrushPoly( psurf );
                GL_EnableMultitexture( true );
            }
        }
    }
 
    if ( !(currententity->flags & RF_TRANSLUCENT) )
    {
        if ( !qglMTexCoord2fSGIS )
            R_BlendLightmaps ();
    }
    else
    {
        qglDisable (GL_BLEND);
        qglColor4f (1,1,1,1);
        GL_TexEnv( GL_REPLACE );
    }
}

Referenced by R_DrawBrushModel().

R_DrawTriangleOutlines()

void R_DrawTriangleOutlines

(

void

)

Definition at line 231 of file gl_rsurf.c.

{
    int         i, j;
    glpoly_t    *p;
 
    if (!gl_showtris->value)
        return;
 
    qglDisable (GL_TEXTURE_2D);
    qglDisable (GL_DEPTH_TEST);
    qglColor4f (1,1,1,1);
 
    for (i=0 ; i<MAX_LIGHTMAPS ; i++)
    {
        msurface_t *surf;
 
        for ( surf = gl_lms.lightmap_surfaces[i]; surf != 0; surf = surf->lightmapchain )
        {
            p = surf->polys;
            for ( ; p ; p=p->chain)
            {
                for (j=2 ; j<p->numverts ; j++ )
                {
                    qglBegin (GL_LINE_STRIP);
                    qglVertex3fv (p->verts[0]);
                    qglVertex3fv (p->verts[j-1]);
                    qglVertex3fv (p->verts[j]);
                    qglVertex3fv (p->verts[0]);
                    qglEnd ();
                }
            }
        }
    }
 
    qglEnable (GL_DEPTH_TEST);
    qglEnable (GL_TEXTURE_2D);
}

Referenced by R_DrawWorld().

R_DrawWorld()

void R_DrawWorld

(

void

)

Definition at line 1197 of file gl_rsurf.c.

{
    entity_t    ent;
 
    if (!r_drawworld->value)
        return;
 
    if ( r_newrefdef.rdflags & RDF_NOWORLDMODEL )
        return;
 
    currentmodel = r_worldmodel;
 
    VectorCopy (r_newrefdef.vieworg, modelorg);
 
    // auto cycle the world frame for texture animation
    memset (&ent, 0, sizeof(ent));
    ent.frame = (int)(r_newrefdef.time*2);
    currententity = &ent;
 
    gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1;
 
    qglColor3f (1,1,1);
    memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces));
    R_ClearSkyBox ();
 
    if ( qglMTexCoord2fSGIS )
    {
        GL_EnableMultitexture( true );
 
        GL_SelectTexture( gl_texture0);
        GL_TexEnv( GL_REPLACE );
        GL_SelectTexture( gl_texture1);
 
        if ( gl_lightmap->value )
            GL_TexEnv( GL_REPLACE );
        else 
            GL_TexEnv( GL_MODULATE );
 
        R_RecursiveWorldNode (r_worldmodel->nodes);
 
        GL_EnableMultitexture( false );
    }
    else
    {
        R_RecursiveWorldNode (r_worldmodel->nodes);
    }
 
    /*
    ** theoretically nothing should happen in the next two functions
    ** if multitexture is enabled
    */
    DrawTextureChains ();
    R_BlendLightmaps ();
    
    R_DrawSkyBox ();
 
    R_DrawTriangleOutlines ();
}

R_MarkLeaves()

void R_MarkLeaves

(

void

)

Definition at line 1265 of file gl_rsurf.c.

{
    byte    *vis;
    byte    fatvis[MAX_MAP_LEAFS/8];
    mnode_t *node;
    int     i, c;
    mleaf_t *leaf;
    int     cluster;
 
    if (r_oldviewcluster == r_viewcluster && r_oldviewcluster2 == r_viewcluster2 && !r_novis->value && r_viewcluster != -1)
        return;
 
    // development aid to let you run around and see exactly where
    // the pvs ends
    if (gl_lockpvs->value)
        return;
 
    r_visframecount++;
    r_oldviewcluster = r_viewcluster;
    r_oldviewcluster2 = r_viewcluster2;
 
    if (r_novis->value || r_viewcluster == -1 || !r_worldmodel->vis)
    {
        // mark everything
        for (i=0 ; i<r_worldmodel->numleafs ; i++)
            r_worldmodel->leafs[i].visframe = r_visframecount;
        for (i=0 ; i<r_worldmodel->numnodes ; i++)
            r_worldmodel->nodes[i].visframe = r_visframecount;
        return;
    }
 
    vis = Mod_ClusterPVS (r_viewcluster, r_worldmodel);
    // may have to combine two clusters because of solid water boundaries
    if (r_viewcluster2 != r_viewcluster)
    {
        memcpy (fatvis, vis, (r_worldmodel->numleafs+7)/8);
        vis = Mod_ClusterPVS (r_viewcluster2, r_worldmodel);
        c = (r_worldmodel->numleafs+31)/32;
        for (i=0 ; i<c ; i++)
            ((int *)fatvis)[i] |= ((int *)vis)[i];
        vis = fatvis;
    }
    
    for (i=0,leaf=r_worldmodel->leafs ; i<r_worldmodel->numleafs ; i++, leaf++)
    {
        cluster = leaf->cluster;
        if (cluster == -1)
            continue;
        if (vis[cluster>>3] & (1<<(cluster&7)))
        {
            node = (mnode_t *)leaf;
            do
            {
                if (node->visframe == r_visframecount)
                    break;
                node->visframe = r_visframecount;
                node = node->parent;
            } while (node);
        }
    }
 
#if 0
    for (i=0 ; i<r_worldmodel->vis->numclusters ; i++)
    {
        if (vis[i>>3] & (1<<(i&7)))
        {
            node = (mnode_t *)&r_worldmodel->leafs[i];  // FIXME: cluster
            do
            {
                if (node->visframe == r_visframecount)
                    break;
                node->visframe = r_visframecount;
                node = node->parent;
            } while (node);
        }
    }
#endif
}

R_RecursiveWorldNode()

void R_RecursiveWorldNode

(

mnode_t *

node

)

Definition at line 1036 of file gl_rsurf.c.

{
    int         c, side, sidebit;
    cplane_t    *plane;
    msurface_t  *surf, **mark;
    mleaf_t     *pleaf;
    float       dot;
    image_t     *image;
 
    if (node->contents == CONTENTS_SOLID)
        return;     // solid
 
    if (node->visframe != r_visframecount)
        return;
    if (R_CullBox (node->minmaxs, node->minmaxs+3))
        return;
    
// if a leaf node, draw stuff
    if (node->contents != -1)
    {
        pleaf = (mleaf_t *)node;
 
        // check for door connected areas
        if (r_newrefdef.areabits)
        {
            if (! (r_newrefdef.areabits[pleaf->area>>3] & (1<<(pleaf->area&7)) ) )
                return;     // not visible
        }
 
        mark = pleaf->firstmarksurface;
        c = pleaf->nummarksurfaces;
 
        if (c)
        {
            do
            {
                (*mark)->visframe = r_framecount;
                mark++;
            } while (--c);
        }
 
        return;
    }
 
// node is just a decision point, so go down the apropriate sides
 
// find which side of the node we are on
    plane = node->plane;
 
    switch (plane->type)
    {
    case PLANE_X:
        dot = modelorg[0] - plane->dist;
        break;
    case PLANE_Y:
        dot = modelorg[1] - plane->dist;
        break;
    case PLANE_Z:
        dot = modelorg[2] - plane->dist;
        break;
    default:
        dot = DotProduct (modelorg, plane->normal) - plane->dist;
        break;
    }
 
    if (dot >= 0)
    {
        side = 0;
        sidebit = 0;
    }
    else
    {
        side = 1;
        sidebit = SURF_PLANEBACK;
    }
 
// recurse down the children, front side first
    R_RecursiveWorldNode (node->children[side]);
 
    // draw stuff
    for ( c = node->numsurfaces, surf = r_worldmodel->surfaces + node->firstsurface; c ; c--, surf++)
    {
        if (surf->visframe != r_framecount)
            continue;
 
        if ( (surf->flags & SURF_PLANEBACK) != sidebit )
            continue;       // wrong side
 
        if (surf->texinfo->flags & SURF_SKY)
        {   // just adds to visible sky bounds
            R_AddSkySurface (surf);
        }
        else if (surf->texinfo->flags & (SURF_TRANS33|SURF_TRANS66))
        {   // add to the translucent chain
            surf->texturechain = r_alpha_surfaces;
            r_alpha_surfaces = surf;
        }
        else
        {
            if ( qglMTexCoord2fSGIS && !( surf->flags & SURF_DRAWTURB ) )
            {
                GL_RenderLightmappedPoly( surf );
            }
            else
            {
                // the polygon is visible, so add it to the texture
                // sorted chain
                // FIXME: this is a hack for animation
                image = R_TextureAnimation (surf->texinfo);
                surf->texturechain = image->texturechain;
                image->texturechain = surf;
            }
        }
    }
 
    // recurse down the back side
    R_RecursiveWorldNode (node->children[!side]);
/*
    for ( ; c ; c--, surf++)
    {
        if (surf->visframe != r_framecount)
            continue;
 
        if ( (surf->flags & SURF_PLANEBACK) != sidebit )
            continue;       // wrong side
 
        if (surf->texinfo->flags & SURF_SKY)
        {   // just adds to visible sky bounds
            R_AddSkySurface (surf);
        }
        else if (surf->texinfo->flags & (SURF_TRANS33|SURF_TRANS66))
        {   // add to the translucent chain
//          surf->texturechain = alpha_surfaces;
//          alpha_surfaces = surf;
        }
        else
        {
            if ( qglMTexCoord2fSGIS && !( surf->flags & SURF_DRAWTURB ) )
            {
                GL_RenderLightmappedPoly( surf );
            }
            else
            {
                // the polygon is visible, so add it to the texture
                // sorted chain
                // FIXME: this is a hack for animation
                image = R_TextureAnimation (surf->texinfo);
                surf->texturechain = image->texturechain;
                image->texturechain = surf;
            }
        }
    }
*/
}

Referenced by R_DrawWorld().

R_RenderBrushPoly()

void R_RenderBrushPoly

(

msurface_t *

fa

)

Definition at line 478 of file gl_rsurf.c.

{
    int         maps;
    image_t     *image;
    qboolean is_dynamic = false;
 
    c_brush_polys++;
 
    image = R_TextureAnimation (fa->texinfo);
 
    if (fa->flags & SURF_DRAWTURB)
    {   
        GL_Bind( image->texnum );
 
        // warp texture, no lightmaps
        GL_TexEnv( GL_MODULATE );
        qglColor4f( gl_state.inverse_intensity, 
                    gl_state.inverse_intensity,
                    gl_state.inverse_intensity,
                    1.0F );
        EmitWaterPolys (fa);
        GL_TexEnv( GL_REPLACE );
 
        return;
    }
    else
    {
        GL_Bind( image->texnum );
 
        GL_TexEnv( GL_REPLACE );
    }
 
//======
//PGM
    if(fa->texinfo->flags & SURF_FLOWING)
        DrawGLFlowingPoly (fa);
    else
        DrawGLPoly (fa->polys);
//PGM
//======
 
    /*
    ** check for lightmap modification
    */
    for ( maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++ )
    {
        if ( r_newrefdef.lightstyles[fa->styles[maps]].white != fa->cached_light[maps] )
            goto dynamic;
    }
 
    // dynamic this frame or dynamic previously
    if ( ( fa->dlightframe == r_framecount ) )
    {
dynamic:
        if ( gl_dynamic->value )
        {
            if (!( fa->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP ) ) )
            {
                is_dynamic = true;
            }
        }
    }
 
    if ( is_dynamic )
    {
        if ( ( fa->styles[maps] >= 32 || fa->styles[maps] == 0 ) && ( fa->dlightframe != r_framecount ) )
        {
            unsigned    temp[34*34];
            int         smax, tmax;
 
            smax = (fa->extents[0]>>4)+1;
            tmax = (fa->extents[1]>>4)+1;
 
            R_BuildLightMap( fa, (void *)temp, smax*4 );
            R_SetCacheState( fa );
 
            GL_Bind( gl_state.lightmap_textures + fa->lightmaptexturenum );
 
            qglTexSubImage2D( GL_TEXTURE_2D, 0,
                              fa->light_s, fa->light_t, 
                              smax, tmax, 
                              GL_LIGHTMAP_FORMAT, 
                              GL_UNSIGNED_BYTE, temp );
 
            fa->lightmapchain = gl_lms.lightmap_surfaces[fa->lightmaptexturenum];
            gl_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa;
        }
        else
        {
            fa->lightmapchain = gl_lms.lightmap_surfaces[0];
            gl_lms.lightmap_surfaces[0] = fa;
        }
    }
    else
    {
        fa->lightmapchain = gl_lms.lightmap_surfaces[fa->lightmaptexturenum];
        gl_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa;
    }
}

Referenced by DrawTextureChains(), and R_DrawInlineBModel().

R_SetCacheState()

void R_SetCacheState

(

msurface_t *

surf

)

Definition at line 437 of file gl_light.c.

{
    int maps;
 
    for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
         maps++)
    {
        surf->cached_light[maps] = r_newrefdef.lightstyles[surf->styles[maps]].white;
    }
}

Referenced by GL_CreateSurfaceLightmap(), GL_RenderLightmappedPoly(), and R_RenderBrushPoly().

R_TextureAnimation()

image_t* R_TextureAnimation

(

mtexinfo_t *

tex

)

Definition at line 84 of file gl_rsurf.c.

{
    int     c;
 
    if (!tex->next)
        return tex->image;
 
    c = currententity->frame % tex->numframes;
    while (c)
    {
        tex = tex->next;
        c--;
    }
 
    return tex->image;
}

Referenced by GL_RenderLightmappedPoly(), R_RecursiveWorldNode(), and R_RenderBrushPoly().

Variable Documentation

c_visible_lightmaps

int c_visible_lightmaps

Definition at line 40 of file gl_rsurf.c.

Referenced by R_BlendLightmaps().

c_visible_textures

int c_visible_textures

Definition at line 41 of file gl_rsurf.c.

Referenced by DrawTextureChains().

gl_lms

gllightmapstate_t gl_lms

static

Definition at line 59 of file gl_rsurf.c.

Referenced by GL_BeginBuildingLightmaps(), GL_CreateSurfaceLightmap(), LM_AllocBlock(), LM_InitBlock(), LM_UploadBlock(), R_BlendLightmaps(), R_DrawBrushModel(), R_DrawTriangleOutlines(), R_DrawWorld(), and R_RenderBrushPoly().

modelorg

vec3_t modelorg

static

Definition at line 26 of file gl_rsurf.c.

Referenced by R_DrawBrushModel(), R_DrawInlineBModel(), R_DrawWorld(), and R_RecursiveWorldNode().

r_alpha_surfaces

msurface_t* r_alpha_surfaces

Definition at line 28 of file gl_rsurf.c.

Referenced by R_DrawAlphaSurfaces(), R_DrawInlineBModel(), and R_RecursiveWorldNode().