mirror of
https://github.com/TTimo/GtkRadiant.git
synced 2024-11-14 17:01:22 +00:00
954 lines
26 KiB
C
954 lines
26 KiB
C
/* -------------------------------------------------------------------------------
|
|
|
|
Copyright (C) 1999-2007 id Software, Inc. and contributors.
|
|
For a list of contributors, see the accompanying CONTRIBUTORS file.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
GtkRadiant is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
----------------------------------------------------------------------------------
|
|
|
|
This code has been altered significantly from its original form, to support
|
|
several games based on the Quake III Arena engine, in the form of "Q3Map2."
|
|
|
|
------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/* marker */
|
|
#define LIGHT_BOUNCE_C
|
|
|
|
|
|
|
|
/* dependencies */
|
|
#include "q3map2.h"
|
|
|
|
|
|
|
|
/* functions */
|
|
|
|
/*
|
|
RadFreeLights()
|
|
deletes any existing lights, freeing up memory for the next bounce
|
|
*/
|
|
|
|
void RadFreeLights( void ){
|
|
light_t *light, *next;
|
|
|
|
|
|
/* delete lights */
|
|
for ( light = lights; light; light = next )
|
|
{
|
|
next = light->next;
|
|
if ( light->w != NULL ) {
|
|
FreeWinding( light->w );
|
|
}
|
|
free( light );
|
|
}
|
|
numLights = 0;
|
|
lights = NULL;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
RadClipWindingEpsilon()
|
|
clips a rad winding by a plane
|
|
based off the regular clip winding code
|
|
*/
|
|
|
|
static void RadClipWindingEpsilon( radWinding_t *in, vec3_t normal, vec_t dist,
|
|
vec_t epsilon, radWinding_t *front, radWinding_t *back, clipWork_t *cw ){
|
|
vec_t *dists;
|
|
int *sides;
|
|
int counts[ 3 ];
|
|
vec_t dot; /* ydnar: changed from static b/c of threading */ /* VC 4.2 optimizer bug if not static? */
|
|
int i, j, k;
|
|
radVert_t *v1, *v2, mid;
|
|
int maxPoints;
|
|
|
|
|
|
/* crutch */
|
|
dists = cw->dists;
|
|
sides = cw->sides;
|
|
|
|
/* clear counts */
|
|
counts[ 0 ] = counts[ 1 ] = counts[ 2 ] = 0;
|
|
|
|
/* determine sides for each point */
|
|
for ( i = 0; i < in->numVerts; i++ )
|
|
{
|
|
dot = DotProduct( in->verts[ i ].xyz, normal );
|
|
dot -= dist;
|
|
dists[ i ] = dot;
|
|
if ( dot > epsilon ) {
|
|
sides[ i ] = SIDE_FRONT;
|
|
}
|
|
else if ( dot < -epsilon ) {
|
|
sides[ i ] = SIDE_BACK;
|
|
}
|
|
else{
|
|
sides[ i ] = SIDE_ON;
|
|
}
|
|
counts[ sides[ i ] ]++;
|
|
}
|
|
sides[ i ] = sides[ 0 ];
|
|
dists[ i ] = dists[ 0 ];
|
|
|
|
/* clear front and back */
|
|
front->numVerts = back->numVerts = 0;
|
|
|
|
/* handle all on one side cases */
|
|
if ( counts[ 0 ] == 0 ) {
|
|
memcpy( back, in, sizeof( radWinding_t ) );
|
|
return;
|
|
}
|
|
if ( counts[ 1 ] == 0 ) {
|
|
memcpy( front, in, sizeof( radWinding_t ) );
|
|
return;
|
|
}
|
|
|
|
/* setup windings */
|
|
maxPoints = in->numVerts + 4;
|
|
|
|
/* do individual verts */
|
|
for ( i = 0; i < in->numVerts; i++ )
|
|
{
|
|
/* do simple vertex copies first */
|
|
v1 = &in->verts[ i ];
|
|
|
|
if ( sides[ i ] == SIDE_ON ) {
|
|
memcpy( &front->verts[ front->numVerts++ ], v1, sizeof( radVert_t ) );
|
|
memcpy( &back->verts[ back->numVerts++ ], v1, sizeof( radVert_t ) );
|
|
continue;
|
|
}
|
|
|
|
if ( sides[ i ] == SIDE_FRONT ) {
|
|
memcpy( &front->verts[ front->numVerts++ ], v1, sizeof( radVert_t ) );
|
|
}
|
|
|
|
if ( sides[ i ] == SIDE_BACK ) {
|
|
memcpy( &back->verts[ back->numVerts++ ], v1, sizeof( radVert_t ) );
|
|
}
|
|
|
|
if ( sides[ i + 1 ] == SIDE_ON || sides[ i + 1 ] == sides[ i ] ) {
|
|
continue;
|
|
}
|
|
|
|
/* generate a split vertex */
|
|
v2 = &in->verts[ ( i + 1 ) % in->numVerts ];
|
|
|
|
dot = dists[ i ] / ( dists[ i ] - dists[ i + 1 ] );
|
|
|
|
/* average vertex values */
|
|
for ( j = 0; j < 4; j++ )
|
|
{
|
|
/* color */
|
|
if ( j < 4 ) {
|
|
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
|
|
mid.color[ k ][ j ] = v1->color[ k ][ j ] + dot * ( v2->color[ k ][ j ] - v1->color[ k ][ j ] );
|
|
}
|
|
|
|
/* xyz, normal */
|
|
if ( j < 3 ) {
|
|
mid.xyz[ j ] = v1->xyz[ j ] + dot * ( v2->xyz[ j ] - v1->xyz[ j ] );
|
|
mid.normal[ j ] = v1->normal[ j ] + dot * ( v2->normal[ j ] - v1->normal[ j ] );
|
|
}
|
|
|
|
/* st, lightmap */
|
|
if ( j < 2 ) {
|
|
mid.st[ j ] = v1->st[ j ] + dot * ( v2->st[ j ] - v1->st[ j ] );
|
|
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
|
|
mid.lightmap[ k ][ j ] = v1->lightmap[ k ][ j ] + dot * ( v2->lightmap[ k ][ j ] - v1->lightmap[ k ][ j ] );
|
|
}
|
|
}
|
|
|
|
/* normalize the averaged normal */
|
|
VectorNormalize( mid.normal, mid.normal );
|
|
|
|
/* copy the midpoint to both windings */
|
|
memcpy( &front->verts[ front->numVerts++ ], &mid, sizeof( radVert_t ) );
|
|
memcpy( &back->verts[ back->numVerts++ ], &mid, sizeof( radVert_t ) );
|
|
}
|
|
|
|
/* error check */
|
|
if ( front->numVerts > maxPoints ) {
|
|
Error( "RadClipWindingEpsilon: points exceeded estimate" );
|
|
}
|
|
if ( front->numVerts > MAX_POINTS_ON_WINDING ) {
|
|
Error( "RadClipWindingEpsilon: MAX_POINTS_ON_WINDING" );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
RadSampleImage()
|
|
samples a texture image for a given color
|
|
returns qfalse if pixels are bad
|
|
*/
|
|
|
|
qboolean RadSampleImage( byte *pixels, int width, int height, float st[ 2 ], float color[ 4 ] ){
|
|
float sto[ 2 ];
|
|
int x, y;
|
|
|
|
|
|
/* clear color first */
|
|
color[ 0 ] = color[ 1 ] = color[ 2 ] = color[ 3 ] = 255;
|
|
|
|
/* dummy check */
|
|
if ( pixels == NULL || width < 1 || height < 1 ) {
|
|
return qfalse;
|
|
}
|
|
|
|
/* bias st */
|
|
sto[ 0 ] = st[ 0 ];
|
|
while ( sto[ 0 ] < 0.0f )
|
|
sto[ 0 ] += 1.0f;
|
|
sto[ 1 ] = st[ 1 ];
|
|
while ( sto[ 1 ] < 0.0f )
|
|
sto[ 1 ] += 1.0f;
|
|
|
|
/* get offsets */
|
|
x = ( (float) width * sto[ 0 ] ) + 0.5f;
|
|
x %= width;
|
|
y = ( (float) height * sto[ 1 ] ) + 0.5f;
|
|
y %= height;
|
|
|
|
/* get pixel */
|
|
pixels += ( y * width * 4 ) + ( x * 4 );
|
|
VectorCopy( pixels, color );
|
|
color[ 3 ] = pixels[ 3 ];
|
|
return qtrue;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
RadSample()
|
|
samples a fragment's lightmap or vertex color and returns an
|
|
average color and a color gradient for the sample
|
|
*/
|
|
|
|
#define MAX_SAMPLES 150
|
|
#define SAMPLE_GRANULARITY 6
|
|
|
|
static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si, radWinding_t *rw, vec3_t average, vec3_t gradient, int *style ){
|
|
int i, j, k, l, v, x, y, samples;
|
|
vec3_t color, mins, maxs;
|
|
vec4_t textureColor;
|
|
float alpha, alphaI, bf;
|
|
vec3_t blend;
|
|
float st[ 2 ], lightmap[ 2 ], *radLuxel;
|
|
radVert_t *rv[ 3 ];
|
|
|
|
/* initial setup */
|
|
ClearBounds( mins, maxs );
|
|
VectorClear( average );
|
|
VectorClear( gradient );
|
|
alpha = 0;
|
|
|
|
/* dummy check */
|
|
if ( rw == NULL || rw->numVerts < 3 ) {
|
|
return;
|
|
}
|
|
|
|
/* start sampling */
|
|
samples = 0;
|
|
|
|
/* sample vertex colors if no lightmap or this is the initial pass */
|
|
if ( lm == NULL || lm->radLuxels[ lightmapNum ] == NULL || bouncing == qfalse ) {
|
|
for ( samples = 0; samples < rw->numVerts; samples++ )
|
|
{
|
|
/* multiply by texture color */
|
|
if ( !RadSampleImage( si->lightImage->pixels, si->lightImage->width, si->lightImage->height, rw->verts[ samples ].st, textureColor ) ) {
|
|
VectorCopy( si->averageColor, textureColor );
|
|
textureColor[ 3 ] = 255.0f;
|
|
}
|
|
for ( i = 0; i < 3; i++ )
|
|
color[ i ] = ( textureColor[ i ] / 255 ) * ( rw->verts[ samples ].color[ lightmapNum ][ i ] / 255.0f );
|
|
|
|
AddPointToBounds( color, mins, maxs );
|
|
VectorAdd( average, color, average );
|
|
|
|
/* get alpha */
|
|
alpha += ( textureColor[ 3 ] / 255.0f ) * ( rw->verts[ samples ].color[ lightmapNum ][ 3 ] / 255.0f );
|
|
}
|
|
|
|
/* set style */
|
|
*style = ds->vertexStyles[ lightmapNum ];
|
|
}
|
|
|
|
/* sample lightmap */
|
|
else
|
|
{
|
|
/* fracture the winding into a fan (including degenerate tris) */
|
|
for ( v = 1; v < ( rw->numVerts - 1 ) && samples < MAX_SAMPLES; v++ )
|
|
{
|
|
/* get a triangle */
|
|
rv[ 0 ] = &rw->verts[ 0 ];
|
|
rv[ 1 ] = &rw->verts[ v ];
|
|
rv[ 2 ] = &rw->verts[ v + 1 ];
|
|
|
|
/* this code is embarassing (really should just rasterize the triangle) */
|
|
for ( i = 1; i < SAMPLE_GRANULARITY && samples < MAX_SAMPLES; i++ )
|
|
{
|
|
for ( j = 1; j < SAMPLE_GRANULARITY && samples < MAX_SAMPLES; j++ )
|
|
{
|
|
for ( k = 1; k < SAMPLE_GRANULARITY && samples < MAX_SAMPLES; k++ )
|
|
{
|
|
/* create a blend vector (barycentric coordinates) */
|
|
blend[ 0 ] = i;
|
|
blend[ 1 ] = j;
|
|
blend[ 2 ] = k;
|
|
bf = ( 1.0 / ( blend[ 0 ] + blend[ 1 ] + blend[ 2 ] ) );
|
|
VectorScale( blend, bf, blend );
|
|
|
|
/* create a blended sample */
|
|
st[ 0 ] = st[ 1 ] = 0.0f;
|
|
lightmap[ 0 ] = lightmap[ 1 ] = 0.0f;
|
|
alphaI = 0.0f;
|
|
for ( l = 0; l < 3; l++ )
|
|
{
|
|
st[ 0 ] += ( rv[ l ]->st[ 0 ] * blend[ l ] );
|
|
st[ 1 ] += ( rv[ l ]->st[ 1 ] * blend[ l ] );
|
|
lightmap[ 0 ] += ( rv[ l ]->lightmap[ lightmapNum ][ 0 ] * blend[ l ] );
|
|
lightmap[ 1 ] += ( rv[ l ]->lightmap[ lightmapNum ][ 1 ] * blend[ l ] );
|
|
alphaI += ( rv[ l ]->color[ lightmapNum ][ 3 ] * blend[ l ] );
|
|
}
|
|
|
|
/* get lightmap xy coords */
|
|
x = lightmap[ 0 ] / (float) superSample;
|
|
y = lightmap[ 1 ] / (float) superSample;
|
|
if ( x < 0 ) {
|
|
x = 0;
|
|
}
|
|
else if ( x >= lm->w ) {
|
|
x = lm->w - 1;
|
|
}
|
|
if ( y < 0 ) {
|
|
y = 0;
|
|
}
|
|
else if ( y >= lm->h ) {
|
|
y = lm->h - 1;
|
|
}
|
|
|
|
/* get radiosity luxel */
|
|
radLuxel = RAD_LUXEL( lightmapNum, x, y );
|
|
|
|
/* ignore unlit/unused luxels */
|
|
if ( radLuxel[ 0 ] < 0.0f ) {
|
|
continue;
|
|
}
|
|
|
|
/* inc samples */
|
|
samples++;
|
|
|
|
/* multiply by texture color */
|
|
if ( !RadSampleImage( si->lightImage->pixels, si->lightImage->width, si->lightImage->height, st, textureColor ) ) {
|
|
VectorCopy( si->averageColor, textureColor );
|
|
textureColor[ 3 ] = 255;
|
|
}
|
|
for ( i = 0; i < 3; i++ )
|
|
color[ i ] = ( textureColor[ i ] / 255 ) * ( radLuxel[ i ] / 255 );
|
|
|
|
AddPointToBounds( color, mins, maxs );
|
|
VectorAdd( average, color, average );
|
|
|
|
/* get alpha */
|
|
alpha += ( textureColor[ 3 ] / 255 ) * ( alphaI / 255 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* set style */
|
|
*style = ds->lightmapStyles[ lightmapNum ];
|
|
}
|
|
|
|
/* any samples? */
|
|
if ( samples <= 0 ) {
|
|
return;
|
|
}
|
|
|
|
/* average the color */
|
|
VectorScale( average, ( 1.0 / samples ), average );
|
|
|
|
/* create the color gradient */
|
|
//% VectorSubtract( maxs, mins, delta );
|
|
|
|
/* new: color gradient will always be 0-1.0, expressed as the range of light relative to overall light */
|
|
//% gradient[ 0 ] = maxs[ 0 ] > 0.0f ? (maxs[ 0 ] - mins[ 0 ]) / maxs[ 0 ] : 0.0f;
|
|
//% gradient[ 1 ] = maxs[ 1 ] > 0.0f ? (maxs[ 1 ] - mins[ 1 ]) / maxs[ 1 ] : 0.0f;
|
|
//% gradient[ 2 ] = maxs[ 2 ] > 0.0f ? (maxs[ 2 ] - mins[ 2 ]) / maxs[ 2 ] : 0.0f;
|
|
|
|
/* newer: another contrast function */
|
|
for ( i = 0; i < 3; i++ )
|
|
gradient[ i ] = ( maxs[ i ] - mins[ i ] ) * maxs[ i ];
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
RadSubdivideDiffuseLight()
|
|
subdivides a radiosity winding until it is smaller than subdivide, then generates an area light
|
|
*/
|
|
|
|
#define RADIOSITY_MAX_GRADIENT 0.75f //% 0.25f
|
|
#define RADIOSITY_VALUE 500.0f
|
|
#define RADIOSITY_MIN 0.0001f
|
|
#define RADIOSITY_CLIP_EPSILON 0.125f
|
|
|
|
static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si,
|
|
float scale, float subdivide, qboolean original, radWinding_t *rw, clipWork_t *cw ){
|
|
int i, style = 0;
|
|
float dist, area, value;
|
|
vec3_t mins, maxs, normal, d1, d2, cross, color, gradient;
|
|
light_t *light, *splash;
|
|
winding_t *w;
|
|
|
|
|
|
/* dummy check */
|
|
if ( rw == NULL || rw->numVerts < 3 ) {
|
|
return;
|
|
}
|
|
|
|
/* get bounds for winding */
|
|
ClearBounds( mins, maxs );
|
|
for ( i = 0; i < rw->numVerts; i++ )
|
|
AddPointToBounds( rw->verts[ i ].xyz, mins, maxs );
|
|
|
|
/* subdivide if necessary */
|
|
for ( i = 0; i < 3; i++ )
|
|
{
|
|
if ( maxs[ i ] - mins[ i ] > subdivide ) {
|
|
radWinding_t front, back;
|
|
|
|
|
|
/* make axial plane */
|
|
VectorClear( normal );
|
|
normal[ i ] = 1;
|
|
dist = ( maxs[ i ] + mins[ i ] ) * 0.5f;
|
|
|
|
/* clip the winding */
|
|
RadClipWindingEpsilon( rw, normal, dist, RADIOSITY_CLIP_EPSILON, &front, &back, cw );
|
|
|
|
/* recurse */
|
|
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &front, cw );
|
|
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &back, cw );
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* check area */
|
|
area = 0.0f;
|
|
for ( i = 2; i < rw->numVerts; i++ )
|
|
{
|
|
VectorSubtract( rw->verts[ i - 1 ].xyz, rw->verts[ 0 ].xyz, d1 );
|
|
VectorSubtract( rw->verts[ i ].xyz, rw->verts[ 0 ].xyz, d2 );
|
|
CrossProduct( d1, d2, cross );
|
|
area += 0.5f * VectorLength( cross );
|
|
}
|
|
if ( area < 1.0f || area > 20000000.0f ) {
|
|
return;
|
|
}
|
|
|
|
/* more subdivision may be necessary */
|
|
if ( bouncing ) {
|
|
/* get color sample for the surface fragment */
|
|
RadSample( lightmapNum, ds, lm, si, rw, color, gradient, &style );
|
|
|
|
/* if color gradient is too high, subdivide again */
|
|
if ( subdivide > minDiffuseSubdivide &&
|
|
( gradient[ 0 ] > RADIOSITY_MAX_GRADIENT || gradient[ 1 ] > RADIOSITY_MAX_GRADIENT || gradient[ 2 ] > RADIOSITY_MAX_GRADIENT ) ) {
|
|
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, ( subdivide / 2.0f ), qfalse, rw, cw );
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* create a regular winding and an average normal */
|
|
w = AllocWinding( rw->numVerts );
|
|
w->numpoints = rw->numVerts;
|
|
VectorClear( normal );
|
|
for ( i = 0; i < rw->numVerts; i++ )
|
|
{
|
|
VectorCopy( rw->verts[ i ].xyz, w->p[ i ] );
|
|
VectorAdd( normal, rw->verts[ i ].normal, normal );
|
|
}
|
|
VectorScale( normal, ( 1.0f / rw->numVerts ), normal );
|
|
if ( VectorNormalize( normal, normal ) == 0.0f ) {
|
|
return;
|
|
}
|
|
|
|
/* early out? */
|
|
if ( bouncing && VectorLength( color ) < RADIOSITY_MIN ) {
|
|
return;
|
|
}
|
|
|
|
/* debug code */
|
|
//% Sys_Printf( "Size: %d %d %d\n", (int) (maxs[ 0 ] - mins[ 0 ]), (int) (maxs[ 1 ] - mins[ 1 ]), (int) (maxs[ 2 ] - mins[ 2 ]) );
|
|
//% Sys_Printf( "Grad: %f %f %f\n", gradient[ 0 ], gradient[ 1 ], gradient[ 2 ] );
|
|
|
|
/* increment counts */
|
|
numDiffuseLights++;
|
|
switch ( ds->surfaceType )
|
|
{
|
|
case MST_PLANAR:
|
|
numBrushDiffuseLights++;
|
|
break;
|
|
|
|
case MST_TRIANGLE_SOUP:
|
|
numTriangleDiffuseLights++;
|
|
break;
|
|
|
|
case MST_PATCH:
|
|
numPatchDiffuseLights++;
|
|
break;
|
|
}
|
|
|
|
/* create a light */
|
|
light = safe_malloc( sizeof( *light ) );
|
|
memset( light, 0, sizeof( *light ) );
|
|
|
|
/* attach it */
|
|
ThreadLock();
|
|
light->next = lights;
|
|
lights = light;
|
|
ThreadUnlock();
|
|
|
|
/* initialize the light */
|
|
light->flags = LIGHT_AREA_DEFAULT;
|
|
light->type = EMIT_AREA;
|
|
light->si = si;
|
|
light->fade = 1.0f;
|
|
light->w = w;
|
|
|
|
/* set falloff threshold */
|
|
light->falloffTolerance = falloffTolerance;
|
|
|
|
/* bouncing light? */
|
|
if ( !bouncing ) {
|
|
/* This is weird. This actually handles surfacelight and not
|
|
* bounces. */
|
|
|
|
/* handle first-pass lights in normal q3a style */
|
|
value = si->value;
|
|
light->photons = value * area * areaScale;
|
|
light->add = value * formFactorValueScale * areaScale;
|
|
VectorCopy( si->color, light->color );
|
|
VectorScale( light->color, light->add, light->emitColor );
|
|
light->style = noStyles ? LS_NORMAL : si->lightStyle;
|
|
if ( light->style < LS_NORMAL || light->style >= LS_NONE ) {
|
|
light->style = LS_NORMAL;
|
|
}
|
|
|
|
/* set origin */
|
|
VectorAdd( mins, maxs, light->origin );
|
|
VectorScale( light->origin, 0.5f, light->origin );
|
|
|
|
/* nudge it off the plane a bit */
|
|
VectorCopy( normal, light->normal );
|
|
VectorMA( light->origin, 1.0f, light->normal, light->origin );
|
|
light->dist = DotProduct( light->origin, normal );
|
|
|
|
/* optionally create a point splashsplash light for first pass */
|
|
if ( original && si->backsplashFraction > 0 ) {
|
|
/* allocate a new point light */
|
|
splash = safe_malloc( sizeof( *splash ) );
|
|
memset( splash, 0, sizeof( *splash ) );
|
|
splash->next = lights;
|
|
lights = splash;
|
|
|
|
/* set it up */
|
|
splash->flags = LIGHT_Q3A_DEFAULT;
|
|
splash->type = EMIT_POINT;
|
|
splash->photons = light->photons * si->backsplashFraction;
|
|
splash->fade = 1.0f;
|
|
splash->si = si;
|
|
VectorMA( light->origin, si->backsplashDistance, normal, splash->origin );
|
|
VectorCopy( si->color, splash->color );
|
|
splash->falloffTolerance = falloffTolerance;
|
|
splash->style = noStyles ? LS_NORMAL : light->style;
|
|
|
|
/* add to counts */
|
|
numPointLights++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* handle bounced light (radiosity) a little differently */
|
|
value = RADIOSITY_VALUE * si->bounceScale * 0.375f;
|
|
light->photons = value * area * bounceScale;
|
|
light->add = value * formFactorValueScale * bounceScale;
|
|
VectorCopy( color, light->color );
|
|
VectorScale( light->color, light->add, light->emitColor );
|
|
light->style = noStyles ? LS_NORMAL : style;
|
|
if ( light->style < LS_NORMAL || light->style >= LS_NONE ) {
|
|
light->style = LS_NORMAL;
|
|
}
|
|
|
|
/* set origin */
|
|
WindingCenter( w, light->origin );
|
|
|
|
/* nudge it off the plane a bit */
|
|
VectorCopy( normal, light->normal );
|
|
VectorMA( light->origin, 1.0f, light->normal, light->origin );
|
|
light->dist = DotProduct( light->origin, normal );
|
|
}
|
|
|
|
/* emit light from both sides? */
|
|
if ( si->compileFlags & C_FOG || si->twoSided ) {
|
|
light->flags |= LIGHT_TWOSIDED;
|
|
}
|
|
|
|
//% Sys_Printf( "\nAL: C: (%6f, %6f, %6f) [%6f] N: (%6f, %6f, %6f) %s\n",
|
|
//% light->color[ 0 ], light->color[ 1 ], light->color[ 2 ], light->add,
|
|
//% light->normal[ 0 ], light->normal[ 1 ], light->normal[ 2 ],
|
|
//% light->si->shader );
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
RadLightForTriangles()
|
|
creates unbounced diffuse lights for triangle soup (misc_models, etc)
|
|
*/
|
|
|
|
void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ){
|
|
int i, j, k, v;
|
|
bspDrawSurface_t *ds;
|
|
surfaceInfo_t *info;
|
|
float *radVertexLuxel;
|
|
radWinding_t rw;
|
|
|
|
|
|
/* get surface */
|
|
ds = &bspDrawSurfaces[ num ];
|
|
info = &surfaceInfos[ num ];
|
|
|
|
/* each triangle is a potential emitter */
|
|
rw.numVerts = 3;
|
|
for ( i = 0; i < ds->numIndexes; i += 3 )
|
|
{
|
|
/* copy each vert */
|
|
for ( j = 0; j < 3; j++ )
|
|
{
|
|
/* get vertex index and rad vertex luxel */
|
|
v = ds->firstVert + bspDrawIndexes[ ds->firstIndex + i + j ];
|
|
|
|
/* get most everything */
|
|
memcpy( &rw.verts[ j ], &yDrawVerts[ v ], sizeof( bspDrawVert_t ) );
|
|
|
|
/* fix colors */
|
|
for ( k = 0; k < MAX_LIGHTMAPS; k++ )
|
|
{
|
|
radVertexLuxel = RAD_VERTEX_LUXEL( k, ds->firstVert + bspDrawIndexes[ ds->firstIndex + i + j ] );
|
|
VectorCopy( radVertexLuxel, rw.verts[ j ].color[ k ] );
|
|
rw.verts[ j ].color[ k ][ 3 ] = yDrawVerts[ v ].color[ k ][ 3 ];
|
|
}
|
|
}
|
|
|
|
/* subdivide into area lights */
|
|
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
RadLightForPatch()
|
|
creates unbounced diffuse lights for patches
|
|
*/
|
|
|
|
#define PLANAR_EPSILON 0.1f
|
|
|
|
void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ){
|
|
int i, x, y, v, t, pw[ 5 ], r;
|
|
bspDrawSurface_t *ds;
|
|
surfaceInfo_t *info;
|
|
bspDrawVert_t *bogus;
|
|
bspDrawVert_t *dv[ 4 ];
|
|
mesh_t src, *subdivided, *mesh;
|
|
float *radVertexLuxel;
|
|
float dist;
|
|
vec4_t plane;
|
|
qboolean planar;
|
|
radWinding_t rw;
|
|
|
|
|
|
/* get surface */
|
|
ds = &bspDrawSurfaces[ num ];
|
|
info = &surfaceInfos[ num ];
|
|
|
|
/* construct a bogus vert list with color index stuffed into color[ 0 ] */
|
|
bogus = safe_malloc( ds->numVerts * sizeof( bspDrawVert_t ) );
|
|
memcpy( bogus, &yDrawVerts[ ds->firstVert ], ds->numVerts * sizeof( bspDrawVert_t ) );
|
|
for ( i = 0; i < ds->numVerts; i++ )
|
|
bogus[ i ].color[ 0 ][ 0 ] = i;
|
|
|
|
/* build a subdivided mesh identical to shadow facets for this patch */
|
|
/* this MUST MATCH FacetsForPatch() identically! */
|
|
src.width = ds->patchWidth;
|
|
src.height = ds->patchHeight;
|
|
src.verts = bogus;
|
|
//% subdivided = SubdivideMesh( src, 8, 512 );
|
|
subdivided = SubdivideMesh2( src, info->patchIterations );
|
|
PutMeshOnCurve( *subdivided );
|
|
//% MakeMeshNormals( *subdivided );
|
|
mesh = RemoveLinearMeshColumnsRows( subdivided );
|
|
FreeMesh( subdivided );
|
|
free( bogus );
|
|
|
|
/* FIXME: build interpolation table into color[ 1 ] */
|
|
|
|
/* fix up color indexes */
|
|
for ( i = 0; i < ( mesh->width * mesh->height ); i++ )
|
|
{
|
|
dv[ 0 ] = &mesh->verts[ i ];
|
|
if ( dv[ 0 ]->color[ 0 ][ 0 ] >= ds->numVerts ) {
|
|
dv[ 0 ]->color[ 0 ][ 0 ] = ds->numVerts - 1;
|
|
}
|
|
}
|
|
|
|
/* iterate through the mesh quads */
|
|
for ( y = 0; y < ( mesh->height - 1 ); y++ )
|
|
{
|
|
for ( x = 0; x < ( mesh->width - 1 ); x++ )
|
|
{
|
|
/* set indexes */
|
|
pw[ 0 ] = x + ( y * mesh->width );
|
|
pw[ 1 ] = x + ( ( y + 1 ) * mesh->width );
|
|
pw[ 2 ] = x + 1 + ( ( y + 1 ) * mesh->width );
|
|
pw[ 3 ] = x + 1 + ( y * mesh->width );
|
|
pw[ 4 ] = x + ( y * mesh->width ); /* same as pw[ 0 ] */
|
|
|
|
/* set radix */
|
|
r = ( x + y ) & 1;
|
|
|
|
/* get drawverts */
|
|
dv[ 0 ] = &mesh->verts[ pw[ r + 0 ] ];
|
|
dv[ 1 ] = &mesh->verts[ pw[ r + 1 ] ];
|
|
dv[ 2 ] = &mesh->verts[ pw[ r + 2 ] ];
|
|
dv[ 3 ] = &mesh->verts[ pw[ r + 3 ] ];
|
|
|
|
/* planar? */
|
|
planar = PlaneFromPoints( plane, dv[ 0 ]->xyz, dv[ 1 ]->xyz, dv[ 2 ]->xyz );
|
|
if ( planar ) {
|
|
dist = DotProduct( dv[ 1 ]->xyz, plane ) - plane[ 3 ];
|
|
if ( fabs( dist ) > PLANAR_EPSILON ) {
|
|
planar = qfalse;
|
|
}
|
|
}
|
|
|
|
/* generate a quad */
|
|
if ( planar ) {
|
|
rw.numVerts = 4;
|
|
for ( v = 0; v < 4; v++ )
|
|
{
|
|
/* get most everything */
|
|
memcpy( &rw.verts[ v ], dv[ v ], sizeof( bspDrawVert_t ) );
|
|
|
|
/* fix colors */
|
|
for ( i = 0; i < MAX_LIGHTMAPS; i++ )
|
|
{
|
|
radVertexLuxel = RAD_VERTEX_LUXEL( i, ds->firstVert + dv[ v ]->color[ 0 ][ 0 ] );
|
|
VectorCopy( radVertexLuxel, rw.verts[ v ].color[ i ] );
|
|
rw.verts[ v ].color[ i ][ 3 ] = dv[ v ]->color[ i ][ 3 ];
|
|
}
|
|
}
|
|
|
|
/* subdivide into area lights */
|
|
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
|
|
}
|
|
|
|
/* generate 2 tris */
|
|
else
|
|
{
|
|
rw.numVerts = 3;
|
|
for ( t = 0; t < 2; t++ )
|
|
{
|
|
for ( v = 0; v < 3 + t; v++ )
|
|
{
|
|
/* get "other" triangle (stupid hacky logic, but whatevah) */
|
|
if ( v == 1 && t == 1 ) {
|
|
v++;
|
|
}
|
|
|
|
/* get most everything */
|
|
memcpy( &rw.verts[ v ], dv[ v ], sizeof( bspDrawVert_t ) );
|
|
|
|
/* fix colors */
|
|
for ( i = 0; i < MAX_LIGHTMAPS; i++ )
|
|
{
|
|
radVertexLuxel = RAD_VERTEX_LUXEL( i, ds->firstVert + dv[ v ]->color[ 0 ][ 0 ] );
|
|
VectorCopy( radVertexLuxel, rw.verts[ v ].color[ i ] );
|
|
rw.verts[ v ].color[ i ][ 3 ] = dv[ v ]->color[ i ][ 3 ];
|
|
}
|
|
}
|
|
|
|
/* subdivide into area lights */
|
|
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* free the mesh */
|
|
FreeMesh( mesh );
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
RadLight()
|
|
creates unbounced diffuse lights for a given surface
|
|
*/
|
|
|
|
void RadLight( int num ){
|
|
int lightmapNum;
|
|
float scale, subdivide;
|
|
int contentFlags, surfaceFlags, compileFlags;
|
|
bspDrawSurface_t *ds;
|
|
surfaceInfo_t *info;
|
|
rawLightmap_t *lm;
|
|
shaderInfo_t *si;
|
|
clipWork_t cw;
|
|
|
|
|
|
/* get drawsurface, lightmap, and shader info */
|
|
ds = &bspDrawSurfaces[ num ];
|
|
info = &surfaceInfos[ num ];
|
|
lm = info->lm;
|
|
si = info->si;
|
|
scale = si->bounceScale;
|
|
|
|
/* find nodraw bit */
|
|
contentFlags = surfaceFlags = compileFlags = 0;
|
|
ApplySurfaceParm( "nodraw", &contentFlags, &surfaceFlags, &compileFlags );
|
|
|
|
/* early outs? */
|
|
if ( scale <= 0.0f || ( si->compileFlags & C_SKY ) || si->autosprite ||
|
|
( bspShaders[ ds->shaderNum ].contentFlags & contentFlags ) || ( bspShaders[ ds->shaderNum ].surfaceFlags & surfaceFlags ) ||
|
|
( si->compileFlags & compileFlags ) ) {
|
|
return;
|
|
}
|
|
|
|
/* determine how much we need to chop up the surface */
|
|
if ( si->lightSubdivide ) {
|
|
subdivide = si->lightSubdivide;
|
|
}
|
|
else{
|
|
subdivide = diffuseSubdivide;
|
|
}
|
|
|
|
/* inc counts */
|
|
numDiffuseSurfaces++;
|
|
|
|
/* iterate through styles (this could be more efficient, yes) */
|
|
for ( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
|
|
{
|
|
/* switch on type */
|
|
if ( ds->lightmapStyles[ lightmapNum ] != LS_NONE && ds->lightmapStyles[ lightmapNum ] != LS_UNUSED ) {
|
|
switch ( ds->surfaceType )
|
|
{
|
|
case MST_PLANAR:
|
|
case MST_TRIANGLE_SOUP:
|
|
RadLightForTriangles( num, lightmapNum, lm, si, scale, subdivide, &cw );
|
|
break;
|
|
|
|
case MST_PATCH:
|
|
RadLightForPatch( num, lightmapNum, lm, si, scale, subdivide, &cw );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
RadCreateDiffuseLights()
|
|
creates lights for unbounced light on surfaces in the bsp
|
|
*/
|
|
|
|
int iterations = 0;
|
|
|
|
void RadCreateDiffuseLights( void ){
|
|
/* startup */
|
|
Sys_FPrintf( SYS_VRB, "--- RadCreateDiffuseLights ---\n" );
|
|
numDiffuseSurfaces = 0;
|
|
numDiffuseLights = 0;
|
|
numBrushDiffuseLights = 0;
|
|
numTriangleDiffuseLights = 0;
|
|
numPatchDiffuseLights = 0;
|
|
numAreaLights = 0;
|
|
|
|
/* hit every surface (threaded) */
|
|
RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, RadLight );
|
|
|
|
/* dump the lights generated to a file */
|
|
if ( dump ) {
|
|
char dumpName[ 1024 ], ext[ 64 ];
|
|
FILE *file;
|
|
light_t *light;
|
|
|
|
strcpy( dumpName, source );
|
|
StripExtension( dumpName );
|
|
sprintf( ext, "_bounce_%03d.map", iterations );
|
|
strcat( dumpName, ext );
|
|
file = fopen( dumpName, "wb" );
|
|
Sys_Printf( "Writing %s...\n", dumpName );
|
|
if ( file ) {
|
|
for ( light = lights; light; light = light->next )
|
|
{
|
|
fprintf( file,
|
|
"{\n"
|
|
"\"classname\" \"light\"\n"
|
|
"\"light\" \"%d\"\n"
|
|
"\"origin\" \"%.0f %.0f %.0f\"\n"
|
|
"\"_color\" \"%.3f %.3f %.3f\"\n"
|
|
"}\n",
|
|
|
|
(int) light->add,
|
|
|
|
light->origin[ 0 ],
|
|
light->origin[ 1 ],
|
|
light->origin[ 2 ],
|
|
|
|
light->color[ 0 ],
|
|
light->color[ 1 ],
|
|
light->color[ 2 ] );
|
|
}
|
|
fclose( file );
|
|
}
|
|
}
|
|
|
|
/* increment */
|
|
iterations++;
|
|
|
|
/* print counts */
|
|
Sys_Printf( "%8d diffuse surfaces\n", numDiffuseSurfaces );
|
|
Sys_FPrintf( SYS_VRB, "%8d total diffuse lights\n", numDiffuseLights );
|
|
Sys_FPrintf( SYS_VRB, "%8d brush diffuse lights\n", numBrushDiffuseLights );
|
|
Sys_FPrintf( SYS_VRB, "%8d patch diffuse lights\n", numPatchDiffuseLights );
|
|
Sys_FPrintf( SYS_VRB, "%8d triangle diffuse lights\n", numTriangleDiffuseLights );
|
|
}
|