Main Page | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals
code / renderer

tr_flares.c File Reference

#include "tr_local.h"

Include dependency graph for tr_flares.c:

Include dependency graph

Go to the source code of this file.

Data Structures

struct  flare_s

Defines

#define MAX_FLARES   128

Typedefs

typedef flare_s flare_t

Functions

void R_ClearFlares (void)
void RB_AddDlightFlares (void)
void RB_AddFlare (void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal)
void RB_RenderFlare (flare_t *f)
void RB_RenderFlares (void)
void RB_TestFlare (flare_t *f)

Variables

flare_t * r_activeFlares
flare_t r_flareStructs [MAX_FLARES]
flare_t * r_inactiveFlares

Define Documentation

#define MAX_FLARES   128
 

Definition at line 81 of file tr_flares.c.

Typedef Documentation

typedef struct flare_s flare_t
 

Referenced by RB_AddFlare(), RB_RenderFlare(), RB_RenderFlares(), and RB_TestFlare().

Function Documentation

void R_ClearFlares (  void   ) 
 

Definition at line 91 of file tr_flares.c.

References Com_Memset(), i, flare_s::next, r_activeFlares, r_flareStructs, and r_inactiveFlares.

Referenced by RE_BeginRegistration().

00091                            {
00092     int     i;
00093 
00094     Com_Memset( r_flareStructs, 0, sizeof( r_flareStructs ) );
00095     r_activeFlares = NULL;
00096     r_inactiveFlares = NULL;
00097 
00098     for ( i = 0 ; i < MAX_FLARES ; i++ ) {
00099         r_flareStructs[i].next = r_inactiveFlares;
00100         r_inactiveFlares = &r_flareStructs[i];
00101     }
00102 }

Here is the call graph for this function:

void RB_AddDlightFlares (  void   ) 
 

Definition at line 197 of file tr_flares.c.

References backEnd, fog_t::bounds, dlight_s::color, dlight_t, trRefdef_t::dlights, world_t::fogs, i, cvar_s::integer, j, k, l, NULL, trRefdef_t::num_dlights, world_t::numfogs, dlight_s::origin, r_flares, RB_AddFlare(), backEndState_t::refdef, tr, and trGlobals_t::world.

00197                                 {
00198     dlight_t        *l;
00199     int             i, j, k;
00200     fog_t           *fog;
00201 
00202     if ( !r_flares->integer ) {
00203         return;
00204     }
00205 
00206     l = backEnd.refdef.dlights;
00207     fog = tr.world->fogs;
00208     for (i=0 ; i<backEnd.refdef.num_dlights ; i++, l++) {
00209 
00210         // find which fog volume the light is in 
00211         for ( j = 1 ; j < tr.world->numfogs ; j++ ) {
00212             fog = &tr.world->fogs[j];
00213             for ( k = 0 ; k < 3 ; k++ ) {
00214                 if ( l->origin[k] < fog->bounds[0][k] || l->origin[k] > fog->bounds[1][k] ) {
00215                     break;
00216                 }
00217             }
00218             if ( k == 3 ) {
00219                 break;
00220             }
00221         }
00222         if ( j == tr.world->numfogs ) {
00223             j = 0;
00224         }
00225 
00226         RB_AddFlare( (void *)l, j, l->origin, l->color, NULL );
00227     }
00228 }

Here is the call graph for this function:

void RB_AddFlare (  void *  surface,
int  fogNum,
vec3_t  point,
vec3_t  color,
vec3_t  normal
) 
 

Definition at line 112 of file tr_flares.c.

References flare_s::addedFrame, backEnd, backEndCounters_t::c_flareAdds, flare_s::color, d, DotProduct, flare_s::eyeZ, f, flare_s::fadeTime, flare_t, flare_s::fogNum, viewParms_t::frameCount, flare_s::frameSceneNum, viewParms_t::frameSceneNum, i, flare_s::inPortal, viewParms_t::isPortal, orientationr_t::modelMatrix, flare_s::next, backEndState_t::or, viewParms_t::or, orientationr_t::origin, backEndState_t::pc, point, viewParms_t::projectionMatrix, r_activeFlares, r_inactiveFlares, R_TransformClipToWindow(), R_TransformModelToClip(), backEndState_t::refdef, flare_s::surface, trRefdef_t::time, vec3_t, VectorCopy, VectorNormalizeFast(), VectorScale, VectorSubtract, backEndState_t::viewParms, viewParms_t::viewportHeight, viewParms_t::viewportWidth, viewParms_t::viewportX, viewParms_t::viewportY, flare_s::visible, flare_s::windowX, and flare_s::windowY.

Referenced by RB_AddDlightFlares().

00112                                                                                          {
00113     int             i;
00114     flare_t         *f, *oldest;
00115     vec3_t          local;
00116     float           d;
00117     vec4_t          eye, clip, normalized, window;
00118 
00119     backEnd.pc.c_flareAdds++;
00120 
00121     // if the point is off the screen, don't bother adding it
00122     // calculate screen coordinates and depth
00123     R_TransformModelToClip( point, backEnd.or.modelMatrix, 
00124         backEnd.viewParms.projectionMatrix, eye, clip );
00125 
00126     // check to see if the point is completely off screen
00127     for ( i = 0 ; i < 3 ; i++ ) {
00128         if ( clip[i] >= clip[3] || clip[i] <= -clip[3] ) {
00129             return;
00130         }
00131     }
00132 
00133     R_TransformClipToWindow( clip, &backEnd.viewParms, normalized, window );
00134 
00135     if ( window[0] < 0 || window[0] >= backEnd.viewParms.viewportWidth
00136         || window[1] < 0 || window[1] >= backEnd.viewParms.viewportHeight ) {
00137         return; // shouldn't happen, since we check the clip[] above, except for FP rounding
00138     }
00139 
00140     // see if a flare with a matching surface, scene, and view exists
00141     oldest = r_flareStructs;
00142     for ( f = r_activeFlares ; f ; f = f->next ) {
00143         if ( f->surface == surface && f->frameSceneNum == backEnd.viewParms.frameSceneNum
00144             && f->inPortal == backEnd.viewParms.isPortal ) {
00145             break;
00146         }
00147     }
00148 
00149     // allocate a new one
00150     if (!f ) {
00151         if ( !r_inactiveFlares ) {
00152             // the list is completely full
00153             return;
00154         }
00155         f = r_inactiveFlares;
00156         r_inactiveFlares = r_inactiveFlares->next;
00157         f->next = r_activeFlares;
00158         r_activeFlares = f;
00159 
00160         f->surface = surface;
00161         f->frameSceneNum = backEnd.viewParms.frameSceneNum;
00162         f->inPortal = backEnd.viewParms.isPortal;
00163         f->addedFrame = -1;
00164     }
00165 
00166     if ( f->addedFrame != backEnd.viewParms.frameCount - 1 ) {
00167         f->visible = qfalse;
00168         f->fadeTime = backEnd.refdef.time - 2000;
00169     }
00170 
00171     f->addedFrame = backEnd.viewParms.frameCount;
00172     f->fogNum = fogNum;
00173 
00174     VectorCopy( color, f->color );
00175 
00176     // fade the intensity of the flare down as the
00177     // light surface turns away from the viewer
00178     if ( normal ) {
00179         VectorSubtract( backEnd.viewParms.or.origin, point, local );
00180         VectorNormalizeFast( local );
00181         d = DotProduct( local, normal );
00182         VectorScale( f->color, d, f->color ); 
00183     }
00184 
00185     // save info needed to test
00186     f->windowX = backEnd.viewParms.viewportX + window[0];
00187     f->windowY = backEnd.viewParms.viewportY + window[1];
00188 
00189     f->eyeZ = eye[2];
00190 }

Here is the call graph for this function:

void RB_RenderFlare (  flare_t *  f  ) 
 

Definition at line 293 of file tr_flares.c.

References backEnd, backEndCounters_t::c_flareRenders, flare_s::color, flare_s::drawIntensity, flare_s::eyeZ, f, flare_t, trGlobals_t::flareShader, flare_s::fogNum, trGlobals_t::identityLight, shaderCommands_s::indexes, shaderCommands_s::numIndexes, shaderCommands_s::numVertexes, backEndState_t::pc, r_flareSize, RB_BeginSurface(), RB_EndSurface(), tess, shaderCommands_s::texCoords, tr, cvar_s::value, vec3_t, VectorScale, shaderCommands_s::vertexColors, backEndState_t::viewParms, viewParms_t::viewportWidth, flare_s::windowX, flare_s::windowY, and shaderCommands_s::xyz.

Referenced by RB_RenderFlares().

00293                                   {
00294     float           size;
00295     vec3_t          color;
00296     int             iColor[3];
00297 
00298     backEnd.pc.c_flareRenders++;
00299 
00300     VectorScale( f->color, f->drawIntensity*tr.identityLight, color );
00301     iColor[0] = color[0] * 255;
00302     iColor[1] = color[1] * 255;
00303     iColor[2] = color[2] * 255;
00304 
00305     size = backEnd.viewParms.viewportWidth * ( r_flareSize->value/640.0f + 8 / -f->eyeZ );
00306 
00307     RB_BeginSurface( tr.flareShader, f->fogNum );
00308 
00309     // FIXME: use quadstamp?
00310     tess.xyz[tess.numVertexes][0] = f->windowX - size;
00311     tess.xyz[tess.numVertexes][1] = f->windowY - size;
00312     tess.texCoords[tess.numVertexes][0][0] = 0;
00313     tess.texCoords[tess.numVertexes][0][1] = 0;
00314     tess.vertexColors[tess.numVertexes][0] = iColor[0];
00315     tess.vertexColors[tess.numVertexes][1] = iColor[1];
00316     tess.vertexColors[tess.numVertexes][2] = iColor[2];
00317     tess.vertexColors[tess.numVertexes][3] = 255;
00318     tess.numVertexes++;
00319 
00320     tess.xyz[tess.numVertexes][0] = f->windowX - size;
00321     tess.xyz[tess.numVertexes][1] = f->windowY + size;
00322     tess.texCoords[tess.numVertexes][0][0] = 0;
00323     tess.texCoords[tess.numVertexes][0][1] = 1;
00324     tess.vertexColors[tess.numVertexes][0] = iColor[0];
00325     tess.vertexColors[tess.numVertexes][1] = iColor[1];
00326     tess.vertexColors[tess.numVertexes][2] = iColor[2];
00327     tess.vertexColors[tess.numVertexes][3] = 255;
00328     tess.numVertexes++;
00329 
00330     tess.xyz[tess.numVertexes][0] = f->windowX + size;
00331     tess.xyz[tess.numVertexes][1] = f->windowY + size;
00332     tess.texCoords[tess.numVertexes][0][0] = 1;
00333     tess.texCoords[tess.numVertexes][0][1] = 1;
00334     tess.vertexColors[tess.numVertexes][0] = iColor[0];
00335     tess.vertexColors[tess.numVertexes][1] = iColor[1];
00336     tess.vertexColors[tess.numVertexes][2] = iColor[2];
00337     tess.vertexColors[tess.numVertexes][3] = 255;
00338     tess.numVertexes++;
00339 
00340     tess.xyz[tess.numVertexes][0] = f->windowX + size;
00341     tess.xyz[tess.numVertexes][1] = f->windowY - size;
00342     tess.texCoords[tess.numVertexes][0][0] = 1;
00343     tess.texCoords[tess.numVertexes][0][1] = 0;
00344     tess.vertexColors[tess.numVertexes][0] = iColor[0];
00345     tess.vertexColors[tess.numVertexes][1] = iColor[1];
00346     tess.vertexColors[tess.numVertexes][2] = iColor[2];
00347     tess.vertexColors[tess.numVertexes][3] = 255;
00348     tess.numVertexes++;
00349 
00350     tess.indexes[tess.numIndexes++] = 0;
00351     tess.indexes[tess.numIndexes++] = 1;
00352     tess.indexes[tess.numIndexes++] = 2;
00353     tess.indexes[tess.numIndexes++] = 0;
00354     tess.indexes[tess.numIndexes++] = 2;
00355     tess.indexes[tess.numIndexes++] = 3;
00356 
00357     RB_EndSurface();
00358 }

Here is the call graph for this function:

void RB_RenderFlares (  void   ) 
 

Definition at line 376 of file tr_flares.c.

References flare_s::addedFrame, backEnd, flare_s::drawIntensity, f, flare_t, viewParms_t::frameCount, flare_s::frameSceneNum, viewParms_t::frameSceneNum, flare_s::inPortal, cvar_s::integer, viewParms_t::isPortal, flare_s::next, qboolean, qglDisable, qglLoadIdentity, qglMatrixMode, qglOrtho, qglPopMatrix, qglPushMatrix, r_flares, r_inactiveFlares, RB_RenderFlare(), RB_TestFlare(), backEndState_t::viewParms, viewParms_t::viewportHeight, viewParms_t::viewportWidth, viewParms_t::viewportX, and viewParms_t::viewportY.

Referenced by RB_RenderDrawSurfList().

00376                             {
00377     flare_t     *f;
00378     flare_t     **prev;
00379     qboolean    draw;
00380 
00381     if ( !r_flares->integer ) {
00382         return;
00383     }
00384 
00385 //  RB_AddDlightFlares();
00386 
00387     // perform z buffer readback on each flare in this view
00388     draw = qfalse;
00389     prev = &r_activeFlares;
00390     while ( ( f = *prev ) != NULL ) {
00391         // throw out any flares that weren't added last frame
00392         if ( f->addedFrame < backEnd.viewParms.frameCount - 1 ) {
00393             *prev = f->next;
00394             f->next = r_inactiveFlares;
00395             r_inactiveFlares = f;
00396             continue;
00397         }
00398 
00399         // don't draw any here that aren't from this scene / portal
00400         f->drawIntensity = 0;
00401         if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
00402             && f->inPortal == backEnd.viewParms.isPortal ) {
00403             RB_TestFlare( f );
00404             if ( f->drawIntensity ) {
00405                 draw = qtrue;
00406             } else {
00407                 // this flare has completely faded out, so remove it from the chain
00408                 *prev = f->next;
00409                 f->next = r_inactiveFlares;
00410                 r_inactiveFlares = f;
00411                 continue;
00412             }
00413         }
00414 
00415         prev = &f->next;
00416     }
00417 
00418     if ( !draw ) {
00419         return;     // none visible
00420     }
00421 
00422     if ( backEnd.viewParms.isPortal ) {
00423         qglDisable (GL_CLIP_PLANE0);
00424     }
00425 
00426     qglPushMatrix();
00427     qglLoadIdentity();
00428     qglMatrixMode( GL_PROJECTION );
00429     qglPushMatrix();
00430     qglLoadIdentity();
00431     qglOrtho( backEnd.viewParms.viewportX, backEnd.viewParms.viewportX + backEnd.viewParms.viewportWidth,
00432               backEnd.viewParms.viewportY, backEnd.viewParms.viewportY + backEnd.viewParms.viewportHeight,
00433               -99999, 99999 );
00434 
00435     for ( f = r_activeFlares ; f ; f = f->next ) {
00436         if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
00437             && f->inPortal == backEnd.viewParms.isPortal
00438             && f->drawIntensity ) {
00439             RB_RenderFlare( f );
00440         }
00441     }
00442 
00443     qglPopMatrix();
00444     qglMatrixMode( GL_MODELVIEW );
00445     qglPopMatrix();
00446 }

Here is the call graph for this function:

void RB_TestFlare (  flare_t *  f  ) 
 

Definition at line 243 of file tr_flares.c.

References backEnd, backEndCounters_t::c_flareTests, flare_s::drawIntensity, flare_s::eyeZ, f, flare_s::fadeTime, glstate_t::finishCalled, flare_t, glState, backEndState_t::pc, viewParms_t::projectionMatrix, qboolean, qglReadPixels, r_flareFade, backEndState_t::refdef, trRefdef_t::time, cvar_s::value, backEndState_t::viewParms, flare_s::visible, flare_s::windowX, and flare_s::windowY.

Referenced by RB_RenderFlares().

00243                                 {
00244     float           depth;
00245     qboolean        visible;
00246     float           fade;
00247     float           screenZ;
00248 
00249     backEnd.pc.c_flareTests++;
00250 
00251     // doing a readpixels is as good as doing a glFinish(), so
00252     // don't bother with another sync
00253     glState.finishCalled = qfalse;
00254 
00255     // read back the z buffer contents
00256     qglReadPixels( f->windowX, f->windowY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth );
00257 
00258     screenZ = backEnd.viewParms.projectionMatrix[14] / 
00259         ( ( 2*depth - 1 ) * backEnd.viewParms.projectionMatrix[11] - backEnd.viewParms.projectionMatrix[10] );
00260 
00261     visible = ( -f->eyeZ - -screenZ ) < 24;
00262 
00263     if ( visible ) {
00264         if ( !f->visible ) {
00265             f->visible = qtrue;
00266             f->fadeTime = backEnd.refdef.time - 1;
00267         }
00268         fade = ( ( backEnd.refdef.time - f->fadeTime ) /1000.0f ) * r_flareFade->value;
00269     } else {
00270         if ( f->visible ) {
00271             f->visible = qfalse;
00272             f->fadeTime = backEnd.refdef.time - 1;
00273         }
00274         fade = 1.0f - ( ( backEnd.refdef.time - f->fadeTime ) / 1000.0f ) * r_flareFade->value;
00275     }
00276 
00277     if ( fade < 0 ) {
00278         fade = 0;
00279     }
00280     if ( fade > 1 ) {
00281         fade = 1;
00282     }
00283 
00284     f->drawIntensity = fade;
00285 }

Variable Documentation

flare_t* r_activeFlares
 

Definition at line 84 of file tr_flares.c.

Referenced by R_ClearFlares(), and RB_AddFlare().

flare_t r_flareStructs[MAX_FLARES]
 

Definition at line 83 of file tr_flares.c.

Referenced by R_ClearFlares().

flare_t * r_inactiveFlares
 

Definition at line 84 of file tr_flares.c.

Referenced by R_ClearFlares(), RB_AddFlare(), and RB_RenderFlares().

Generated on Thu Aug 25 15:02:53 2005 for Quake III Arena by  doxygen 1.3.9.1