quick/netradiant-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

apply all of VorteX's changes except deviance (that one sucks :P)

Browse Source 
git-svn-id: svn://svn.icculus.org/netradiant/trunk@237 61c419a2-8eb2-4b30-bcec-8cead039b335
This commit is contained in:
divverent 2009-03-29 18:08:19 +00:00
parent 7e4c830250
commit f560e2703b
27 changed files with 869 additions and 3625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tools/quake3/q3map2/q3map2_fsr_newfiles/game_darkplaces.h → tools/quake3/q3map2/game_darkplaces.h
View File

@ -46,7 +46,7 @@ game_t struct
".darkplaces ", /* unix home sub-dir */
"darkplaces", /* magic path word */
"scripts", /* shader directory */
64, /* max lightmapped surface verts */
999, /* max lightmapped surface verts */
999, /* max surface verts */
6000, /* max surface indexes */
qfalse, /* flares */

0
tools/quake3/q3map2/q3map2_fsr_newfiles/game_dq.h → tools/quake3/q3map2/game_dq.h
View File

8
tools/quake3/q3map2/game_ef.h
View File

@ -115,6 +115,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_etut.h
View File

@ -150,6 +150,14 @@ game_t struct
2.2f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_ja.h
View File

@ -69,6 +69,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"RBSP", /* bsp file prefix */
1, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_jk2.h
View File

@ -66,6 +66,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"RBSP", /* bsp file prefix */
1, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

9
tools/quake3/q3map2/game_nexuiz.h
View File

@ -65,6 +65,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qtrue, /* disable shader lightstyles hack */
qtrue, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */
@ -131,6 +139,7 @@ game_t struct
{ "nodlight", 0, 0, Q_SURF_NODLIGHT, 0, 0, 0 },
{ "dust", 0, 0, Q_SURF_DUST, 0, 0, 0 },
/* null */
{ NULL, 0, 0, 0, 0, 0, 0 }
}

0
tools/quake3/q3map2/q3map2_fsr_newfiles/game_prophecy.h → tools/quake3/q3map2/game_prophecy.h
View File

8
tools/quake3/q3map2/game_qfusion.h
View File

@ -117,6 +117,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"FBSP", /* bsp file prefix */
1, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_quake3.h
View File

@ -114,6 +114,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_quakelive.h
View File

@ -66,6 +66,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
47, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_sof2.h
View File

@ -141,6 +141,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"RBSP", /* bsp file prefix */
1, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_tenebrae.h
View File

@ -114,6 +114,14 @@ game_t struct
2.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qtrue, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qtrue, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_tremulous.h
View File

@ -72,6 +72,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_wolf.h
View File

@ -131,6 +131,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

8
tools/quake3/q3map2/game_wolfet.h
View File

@ -68,6 +68,14 @@ game_t struct
1.0f, /* lightmap gamma */
1.0f, /* lightmap exposure */
1.0f, /* lightmap compensate */
1.0f, /* lightgrid scale */
1.0f, /* lightgrid ambient scale */
qfalse, /* disable shader lightstyles hack */
qfalse, /* keep light entities on bsp */
8, /* default patchMeta subdivisions tolerance */
qfalse, /* patch casting enabled */
qfalse, /* compile deluxemaps */
0, /* deluxemaps default mode */
"IBSP", /* bsp file prefix */
46, /* bsp file version */
qfalse, /* cod-style lump len/ofs order */

159
tools/quake3/q3map2/light.c
View File

@ -313,7 +313,15 @@ void CreateEntityLights( void )
flags |= LIGHT_GRID;
flags &= ~LIGHT_SURFACES;
}
/* vortex: unnormalized? */
if (spawnflags & 32)
flags |= LIGHT_UNNORMALIZED;
/* vortex: distance atten? */
if (spawnflags & 64)
flags |= LIGHT_ATTEN_DISTANCE;
/* store the flags */
light->flags = flags;
@ -385,14 +393,16 @@ void CreateEntityLights( void )
if( _color && _color[ 0 ] )
{
sscanf( _color, "%f %f %f", &light->color[ 0 ], &light->color[ 1 ], &light->color[ 2 ] );
ColorNormalize( light->color, light->color );
if (!(light->flags & LIGHT_UNNORMALIZED))
{
ColorNormalize( light->color, light->color );
}
}
else
light->color[ 0 ] = light->color[ 1 ] = light->color[ 2 ] = 1.0f;
intensity = intensity * pointScale;
light->photons = intensity;
light->type = EMIT_POINT;
/* set falloff threshold */
@ -741,6 +751,7 @@ int LightContributionToSample( trace_t *trace )
/* clear color */
VectorClear( trace->color );
VectorClear( trace->colorNoShadow );
/* ydnar: early out */
if( !(light->flags & LIGHT_SURFACES) || light->envelope <= 0.0f )
@ -766,7 +777,6 @@ int LightContributionToSample( trace_t *trace )
float d;
vec3_t pushedOrigin;
/* project sample point into light plane */
d = DotProduct( trace->origin, light->normal ) - light->dist;
if( d < 3.0f )
@ -881,8 +891,7 @@ int LightContributionToSample( trace_t *trace )
{
float distByNormal, radiusAtDist, sampleRadius;
vec3_t pointAtDist, distToSample;
/* do cone calculation */
distByNormal = -DotProduct( trace->displacement, light->normal );
if( distByNormal < 0.0f )
@ -922,6 +931,9 @@ int LightContributionToSample( trace_t *trace )
add = light->photons * angle;
if( add <= 0.0f )
return 0;
/* VorteX: set noShadow color */
VectorScale(light->color, add, trace->colorNoShadow);
/* setup trace */
trace->testAll = qtrue;
@ -942,6 +954,9 @@ int LightContributionToSample( trace_t *trace )
/* return to sender */
return 1;
}
/* VorteX: set noShadow color */
VectorScale(light->color, add, trace->colorNoShadow);
/* ydnar: changed to a variable number */
if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
@ -1409,7 +1424,7 @@ void TraceGrid( int num )
trace.normal[2]=-1;
}
f = FloodLightForSample(&trace);
f = FloodLightForSample(&trace, floodlightDistance, floodlight_lowquality);
contributions[ numCon ].color[0]=col[0]*f;
contributions[ numCon ].color[1]=col[1]*f;
@ -1470,6 +1485,9 @@ void TraceGrid( int num )
/* ambient light will be at 1/4 the value of directed light */
/* (ydnar: nuke this in favor of more dramatic lighting?) */
/* (PM: how about actually making it work? d=1 when it got here for single lights/sun :P */
// d = 0.25f;
/* (Hobbes: always setting it to .25 is hardly any better) */
d = 0.25f * (1.0f - d);
VectorMA( gp->ambient[ j ], d, contributions[ i ].color, gp->ambient[ j ] );
}
@ -1487,8 +1505,10 @@ void TraceGrid( int num )
for( j = 0; j < 3; j++ )
if( color[ j ] < minGridLight[ j ] )
color[ j ] = minGridLight[ j ];
ColorToBytes( color, bgp->ambient[ i ], 1.0f );
ColorToBytes( gp->directed[ i ], bgp->directed[ i ], 1.0f );
/* vortex: apply gridscale and gridambientscale here */
ColorToBytes( color, bgp->ambient[ i ], gridScale*gridAmbientScale );
ColorToBytes( gp->directed[ i ], bgp->directed[ i ], gridScale );
}
/* debug code */
@ -1711,12 +1731,8 @@ void LightWorld( void )
RunThreadsOnIndividual( numRawLightmaps, qtrue, DirtyRawLightmap );
}
/* floodlight them up */
if( floodlighty )
{
Sys_Printf( "--- FloodlightRawLightmap ---\n" );
RunThreadsOnIndividual( numRawLightmaps, qtrue, FloodLightRawLightmap );
}
/* floodlight pass */
FloodlightRawLightmaps();
/* ydnar: set up light envelopes */
SetupEnvelopes( qfalse, fast );
@ -1832,12 +1848,64 @@ int LightMain( int argc, char **argv )
/* note it */
Sys_Printf( "--- Light ---\n" );
Sys_Printf( "--- ProcessGameSpecific ---\n" );
/* set standard game flags */
wolfLight = game->wolfLight;
if (wolfLight == qtrue)
Sys_Printf( " lightning model: wolf\n" );
else
Sys_Printf( " lightning model: quake3\n" );
lmCustomSize = game->lightmapSize;
Sys_Printf( " lightmap size: %d x %d pixels\n", lmCustomSize, lmCustomSize );
lightmapGamma = game->lightmapGamma;
Sys_Printf( " lightning gamma: %f\n", lightmapGamma );
lightmapCompensate = game->lightmapCompensate;
Sys_Printf( " lightning compensation: %f\n", lightmapCompensate );
lightmapExposure = game->lightmapExposure;
Sys_Printf( " lightning exposure: %f\n", lightmapExposure );
gridScale = game->gridScale;
Sys_Printf( " lightgrid scale: %f\n", gridScale );
gridAmbientScale = game->gridAmbientScale;
Sys_Printf( " lightgrid ambient scale: %f\n", gridAmbientScale );
noStyles = game->noStyles;
if (noStyles == qtrue)
Sys_Printf( " shader lightstyles hack: disabled\n" );
else
Sys_Printf( " shader lightstyles hack: enabled\n" );
keepLights = game->keepLights;
if (keepLights == qtrue)
Sys_Printf( " keep lights: enabled\n" );
else
Sys_Printf( " keep lights: disabled\n" );
patchShadows = game->patchShadows;
if (patchShadows == qtrue)
Sys_Printf( " patch shadows: enabled\n" );
else
Sys_Printf( " patch shadows: disabled\n" );
deluxemap = game->deluxeMap;
deluxemode = game->deluxeMode;
if (deluxemap == qtrue)
{
if (deluxemode)
Sys_Printf( " deluxemapping: enabled with tangentspace deluxemaps\n" );
else
Sys_Printf( " deluxemapping: enabled with modelspace deluxemaps\n" );
}
else
Sys_Printf( " deluxemapping: disabled\n" );
Sys_Printf( "--- ProcessCommandLine ---\n" );
/* process commandline arguments */
for( i = 1; i < (argc - 1); i++ )
@ -1885,6 +1953,22 @@ int LightMain( int argc, char **argv )
Sys_Printf( "All light scaled by %f\n", f );
i++;
}
else if( !strcmp( argv[ i ], "-gridscale" ) )
{
f = atof( argv[ i + 1 ] );
Sys_Printf( "Grid lightning scaled by %f\n", f );
gridScale *= f;
i++;
}
else if( !strcmp( argv[ i ], "-gridambientscale" ) )
{
f = atof( argv[ i + 1 ] );
Sys_Printf( "Grid ambient lightning scaled by %f\n", f );
gridAmbientScale *= f;
i++;
}
else if( !strcmp( argv[ i ], "-gamma" ) )
{
@ -1955,12 +2039,6 @@ int LightMain( int argc, char **argv )
Sys_Printf( "Dark lightmap seams enabled\n" );
}
else if( !strcmp( argv[ i ], "-shadeangle" ) )
{
shadeAngleDegrees = atof( argv[ i + 1 ] );
@ -1993,13 +2071,28 @@ int LightMain( int argc, char **argv )
Sys_Printf( "Approximating lightmaps within a byte tolerance of %d\n", approximateTolerance );
i++;
}
else if( !strcmp( argv[ i ], "-deluxe" ) || !strcmp( argv[ i ], "-deluxemap" ) )
{
deluxemap = qtrue;
Sys_Printf( "Generating deluxemaps for average light direction\n" );
}
else if( !strcmp( argv[ i ], "-deluxemode" ))
{
deluxemode = atoi( argv[ i + 1 ] );
if (deluxemode == 0 || deluxemode > 1 || deluxemode < 0)
{
Sys_Printf( "Generating modelspace deluxemaps\n" );
deluxemode = 0;
}
else
Sys_Printf( "Generating tangentspace deluxemaps\n" );
i++;
}
else if( !strcmp( argv[ i ], "-nodeluxe" ) || !strcmp( argv[ i ], "-nodeluxemap" ) )
{
deluxemap = qfalse;
Sys_Printf( "Disabling generating of deluxemaps for average light direction\n" );
}
else if( !strcmp( argv[ i ], "-external" ) )
{
externalLightmaps = qtrue;
@ -2234,6 +2327,12 @@ int LightMain( int argc, char **argv )
i++;
Sys_Printf( "Minimum lightmap sample size set to %dx%d units\n", minSampleSize, minSampleSize );
}
else if( !strcmp( argv[ i ], "-samplescale" ) )
{
sampleScale = atoi( argv[ i + 1 ] );
i++;
Sys_Printf( "Lightmaps sample scale set to %d\n", sampleScale);
}
else if( !strcmp( argv[ i ], "-novertex" ) )
{
noVertexLighting = qtrue;
@ -2269,6 +2368,16 @@ int LightMain( int argc, char **argv )
noStyles = qtrue;
Sys_Printf( "Disabling lightstyles\n" );
}
else if( !strcmp( argv[ i ], "-style" ) || !strcmp( argv[ i ], "-styles" ) )
{
noStyles = qfalse;
Sys_Printf( "Enabling lightstyles\n" );
}
else if( !strcmp( argv[ i ], "-keeplights" ))
{
keepLights = qtrue;
Sys_Printf( "Leaving light entities on map after compile\n" );
}
else if( !strcmp( argv[ i ], "-cpma" ) )
{
cpmaHack = qtrue;

2
tools/quake3/q3map2/light_trace.c
View File

@ -56,7 +56,7 @@ several games based on the Quake III Arena engine, in the form of "Q3Map2."
#define GROW_TRACE_NODES 16384 //% 16384
#define GROW_NODE_ITEMS 16 //% 256
#define MAX_TW_VERTS 12
#define MAX_TW_VERTS 24 // vortex: increased from 12 to 24 for ability co compile some insane maps with large curve count
#define TRACE_ON_EPSILON 0.1f

518
tools/quake3/q3map2/light_ydnar.c
View File

@ -2107,7 +2107,7 @@ void IlluminateRawLightmap( int rawLightmapNum )
if(DotProduct(normal, trace.direction) > 0) // do not take light from the back side
{
/* color to grayscale (photoshop rgb weighting) */
brightness = trace.color[ 0 ] * 0.3f + trace.color[ 1 ] * 0.59f + trace.color[ 2 ] * 0.11f;
brightness = trace.colorNoShadow[ 0 ] * 0.3f + trace.colorNoShadow[ 1 ] * 0.59f + trace.colorNoShadow[ 2 ] * 0.11f;
brightness *= (1.0 / 255.0);
VectorScale( trace.direction, brightness, trace.direction );
VectorAdd( deluxel, trace.direction, deluxel );
@ -2346,56 +2346,8 @@ void IlluminateRawLightmap( int rawLightmapNum )
/* free light list */
FreeTraceLights( &trace );
/* -----------------------------------------------------------------
floodlight pass
----------------------------------------------------------------- */
if( floodlighty )
{
/* walk lightmaps */
for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
{
/* early out */
if( lm->superLuxels[ lightmapNum ] == NULL )
continue;
/* apply floodlight to each luxel */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get cluster */
cluster = SUPER_CLUSTER( x, y );
if( *cluster < 0 )
continue;
/* get particulars */
luxel = SUPER_LUXEL( lightmapNum, x, y );
floodlight = SUPER_FLOODLIGHT( x, y );
flood[0]=floodlightRGB[0]*floodlightIntensity;
flood[1]=floodlightRGB[1]*floodlightIntensity;
flood[2]=floodlightRGB[2]*floodlightIntensity;
/* scale light value */
VectorScale( flood, *floodlight, flood );
luxel[0]+=flood[0];
luxel[1]+=flood[1];
luxel[2]+=flood[2];
if (luxel[3]==0) luxel[3]=1;
if(deluxemap)
{
brightness = flood[ 0 ] * 0.3f + flood[ 1 ] * 0.59f + flood[ 2 ] * 0.11f;
brightness *= (1.0 / 255.0);
VectorScale( normal, brightness, temp );
VectorAdd( deluxel, temp, deluxel );
}
}
}
}
}
/* floodlight pass */
FloodlightIlluminateLightmap(lm);
if (debugnormals)
{
@ -2404,7 +2356,7 @@ void IlluminateRawLightmap( int rawLightmapNum )
/* early out */
if( lm->superLuxels[ lightmapNum ] == NULL )
continue;
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
@ -2413,11 +2365,11 @@ void IlluminateRawLightmap( int rawLightmapNum )
cluster = SUPER_CLUSTER( x, y );
//% if( *cluster < 0 )
//% continue;
/* get particulars */
luxel = SUPER_LUXEL( lightmapNum, x, y );
normal = SUPER_NORMAL ( x, y );
luxel[0]=(normal[0]*127)+127;
luxel[1]=(normal[1]*127)+127;
luxel[2]=(normal[2]*127)+127;
@ -2425,7 +2377,7 @@ void IlluminateRawLightmap( int rawLightmapNum )
}
}
}
/* -----------------------------------------------------------------
dirt pass
----------------------------------------------------------------- */
@ -3908,137 +3860,13 @@ void SetupFloodLight( void )
VectorNormalize(floodlightRGB,floodlightRGB);
}
//27 - lighttracer style ambient occlusion light hack.
//Kudos to the dirtmapping author for most of this source.
void FloodLightRawLightmap( int rawLightmapNum )
{
int i, x, y, sx, sy, *cluster;
float *origin, *normal, *floodlight, *floodlight2, average, samples;
rawLightmap_t *lm;
surfaceInfo_t *info;
trace_t trace;
/* bail if this number exceeds the number of raw lightmaps */
if( rawLightmapNum >= numRawLightmaps )
return;
/* get lightmap */
lm = &rawLightmaps[ rawLightmapNum ];
memset(&trace,0,sizeof(trace_t));
/* setup trace */
trace.testOcclusion = qtrue;
trace.forceSunlight = qfalse;
trace.twoSided = qtrue;
trace.recvShadows = lm->recvShadows;
trace.numSurfaces = lm->numLightSurfaces;
trace.surfaces = &lightSurfaces[ lm->firstLightSurface ];
trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
trace.testAll = qfalse;
trace.distance = 1024;
/* twosided lighting (may or may not be a good idea for lightmapped stuff) */
//trace.twoSided = qfalse;
for( i = 0; i < trace.numSurfaces; i++ )
{
/* get surface */
info = &surfaceInfos[ trace.surfaces[ i ] ];
/* check twosidedness */
if( info->si->twoSided )
{
trace.twoSided = qtrue;
break;
}
}
/* gather dirt */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get luxel */
cluster = SUPER_CLUSTER( x, y );
origin = SUPER_ORIGIN( x, y );
normal = SUPER_NORMAL( x, y );
floodlight = SUPER_FLOODLIGHT( x, y );
/* set default dirt */
*floodlight = 0.0f;
/* only look at mapped luxels */
if( *cluster < 0 )
continue;
/* copy to trace */
trace.cluster = *cluster;
VectorCopy( origin, trace.origin );
VectorCopy( normal, trace.normal );
/* get dirt */
*floodlight = FloodLightForSample( &trace );
}
}
/* testing no filtering */
return;
/* filter "dirt" */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get luxel */
cluster = SUPER_CLUSTER( x, y );
floodlight = SUPER_FLOODLIGHT( x, y );
/* filter dirt by adjacency to unmapped luxels */
average = *floodlight;
samples = 1.0f;
for( sy = (y - 1); sy <= (y + 1); sy++ )
{
if( sy < 0 || sy >= lm->sh )
continue;
for( sx = (x - 1); sx <= (x + 1); sx++ )
{
if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
continue;
/* get neighboring luxel */
cluster = SUPER_CLUSTER( sx, sy );
floodlight2 = SUPER_FLOODLIGHT( sx, sy );
if( *cluster < 0 || *floodlight2 <= 0.0f )
continue;
/* add it */
average += *floodlight2;
samples += 1.0f;
}
/* bail */
if( samples <= 0.0f )
break;
}
/* bail */
if( samples <= 0.0f )
continue;
/* scale dirt */
*floodlight = average / samples;
}
}
}
/*
FloodLightForSample()
calculates floodlight value for a given sample
once again, kudos to the dirtmapping coder
*/
float FloodLightForSample( trace_t *trace )
float FloodLightForSample( trace_t *trace , float floodLightDistance, qboolean floodLightLowQuality)
{
int i;
float d;
@ -4048,23 +3876,23 @@ float FloodLightForSample( trace_t *trace )
vec3_t normal, worldUp, myUp, myRt, direction, displacement;
float dd;
int vecs = 0;
gatherLight=0;
/* dummy check */
//if( !dirty )
// return 1.0f;
if( trace == NULL || trace->cluster < 0 )
return 0.0f;
/* setup */
dd = floodlightDistance;
dd = floodLightDistance;
VectorCopy( trace->normal, normal );
/* check if the normal is aligned to the world-up */
if( normal[ 0 ] == 0.0f && normal[ 1 ] == 0.0f )
{
if( normal[ 2 ] == 1.0f )
if( normal[ 2 ] == 1.0f )
{
VectorSet( myRt, 1.0f, 0.0f, 0.0f );
VectorSet( myUp, 0.0f, 1.0f, 0.0f );
@ -4084,55 +3912,60 @@ float FloodLightForSample( trace_t *trace )
VectorNormalize( myUp, myUp );
}
/* iterate through ordered vectors */
for( i = 0; i < numFloodVectors; i++ )
{
if (floodlight_lowquality==qtrue)
{
/* vortex: optimise floodLightLowQuality a bit */
if ( floodLightLowQuality == qtrue )
{
/* iterate through ordered vectors */
for( i = 0; i < numFloodVectors; i++ )
if (rand()%10 != 0 ) continue;
}
vecs++;
/* transform vector into tangent space */
direction[ 0 ] = myRt[ 0 ] * floodVectors[ i ][ 0 ] + myUp[ 0 ] * floodVectors[ i ][ 1 ] + normal[ 0 ] * floodVectors[ i ][ 2 ];
direction[ 1 ] = myRt[ 1 ] * floodVectors[ i ][ 0 ] + myUp[ 1 ] * floodVectors[ i ][ 1 ] + normal[ 1 ] * floodVectors[ i ][ 2 ];
direction[ 2 ] = myRt[ 2 ] * floodVectors[ i ][ 0 ] + myUp[ 2 ] * floodVectors[ i ][ 1 ] + normal[ 2 ] * floodVectors[ i ][ 2 ];
/* set endpoint */
VectorMA( trace->origin, dd, direction, trace->end );
//VectorMA( trace->origin, 1, direction, trace->origin );
SetupTrace( trace );
/* trace */
TraceLine( trace );
contribution=1;
if (trace->compileFlags & C_SKY )
{
contribution=1.0f;
}
else if ( trace->opaque )
{
VectorSubtract( trace->hit, trace->origin, displacement );
d=VectorLength( displacement );
// d=trace->distance;
//if (d>256) gatherDirt+=1;
contribution=d/dd;
if (contribution>1) contribution=1.0f;
//gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
}
gatherLight+=contribution;
}
else
{
/* iterate through ordered vectors */
for( i = 0; i < numFloodVectors; i++ )
{
vecs++;
/* transform vector into tangent space */
direction[ 0 ] = myRt[ 0 ] * floodVectors[ i ][ 0 ] + myUp[ 0 ] * floodVectors[ i ][ 1 ] + normal[ 0 ] * floodVectors[ i ][ 2 ];
direction[ 1 ] = myRt[ 1 ] * floodVectors[ i ][ 0 ] + myUp[ 1 ] * floodVectors[ i ][ 1 ] + normal[ 1 ] * floodVectors[ i ][ 2 ];
direction[ 2 ] = myRt[ 2 ] * floodVectors[ i ][ 0 ] + myUp[ 2 ] * floodVectors[ i ][ 1 ] + normal[ 2 ] * floodVectors[ i ][ 2 ];
/* set endpoint */
VectorMA( trace->origin, dd, direction, trace->end );
//VectorMA( trace->origin, 1, direction, trace->origin );
SetupTrace( trace );
/* trace */
TraceLine( trace );
contribution=1;
if (trace->compileFlags & C_SKY )
{
contribution=1.0f;
}
else if ( trace->opaque )
{
VectorSubtract( trace->hit, trace->origin, displacement );
d=VectorLength( displacement );
// d=trace->distance;
//if (d>256) gatherDirt+=1;
contribution=d/dd;
if (contribution>1) contribution=1.0f;
//gatherDirt += 1.0f - ooDepth * VectorLength( displacement );
}
gatherLight+=contribution;
}
}
/* early out */
if( gatherLight <= 0.0f )
return 0.0f;
sub=vecs;
if (sub<1) sub=1;
@ -4141,8 +3974,233 @@ float FloodLightForSample( trace_t *trace )
outLight=gatherLight;
if( outLight > 1.0f )
outLight = 1.0f;
/* return to sender */
return outLight;
}
/*
FloodLightRawLightmap
lighttracer style ambient occlusion light hack.
Kudos to the dirtmapping author for most of this source.
VorteX: modified to floodlight up custom surfaces (q3map_floodLight)
VorteX: fixed problems with deluxemapping
*/
// floodlight pass on a lightmap
void FloodLightRawLightmapPass( rawLightmap_t *lm , vec3_t lmFloodLightRGB, float lmFloodLightIntensity, float lmFloodLightDistance, qboolean lmFloodLightLowQuality, float floodlightDirectionScale)
{
int i, x, y, *cluster;
float *origin, *normal, *floodlight, floodLightAmount;
surfaceInfo_t *info;
trace_t trace;
// int sx, sy;
// float samples, average, *floodlight2;
memset(&trace,0,sizeof(trace_t));
/* setup trace */
trace.testOcclusion = qtrue;
trace.forceSunlight = qfalse;
trace.twoSided = qtrue;
trace.recvShadows = lm->recvShadows;
trace.numSurfaces = lm->numLightSurfaces;
trace.surfaces = &lightSurfaces[ lm->firstLightSurface ];
trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
trace.testAll = qfalse;
trace.distance = 1024;
/* twosided lighting (may or may not be a good idea for lightmapped stuff) */
//trace.twoSided = qfalse;
for( i = 0; i < trace.numSurfaces; i++ )
{
/* get surface */
info = &surfaceInfos[ trace.surfaces[ i ] ];
/* check twosidedness */
if( info->si->twoSided )
{
trace.twoSided = qtrue;
break;
}
}
/* gather floodlight */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get luxel */
cluster = SUPER_CLUSTER( x, y );
origin = SUPER_ORIGIN( x, y );
normal = SUPER_NORMAL( x, y );
floodlight = SUPER_FLOODLIGHT( x, y );
/* set default dirt */
*floodlight = 0.0f;
/* only look at mapped luxels */
if( *cluster < 0 )
continue;
/* copy to trace */
trace.cluster = *cluster;
VectorCopy( origin, trace.origin );
VectorCopy( normal, trace.normal );
/* get floodlight */
floodLightAmount = FloodLightForSample( &trace , lmFloodLightDistance, lmFloodLightLowQuality)*lmFloodLightIntensity;
/* add floodlight */
floodlight[0] += lmFloodLightRGB[0]*floodLightAmount;
floodlight[1] += lmFloodLightRGB[1]*floodLightAmount;
floodlight[2] += lmFloodLightRGB[2]*floodLightAmount;
floodlight[3] += floodlightDirectionScale;
}
}
/* testing no filtering */
return;
#if 0
/* filter "dirt" */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get luxel */
cluster = SUPER_CLUSTER( x, y );
floodlight = SUPER_FLOODLIGHT(x, y );
/* filter dirt by adjacency to unmapped luxels */
average = *floodlight;
samples = 1.0f;
for( sy = (y - 1); sy <= (y + 1); sy++ )
{
if( sy < 0 || sy >= lm->sh )
continue;
for( sx = (x - 1); sx <= (x + 1); sx++ )
{
if( sx < 0 || sx >= lm->sw || (sx == x && sy == y) )
continue;
/* get neighboring luxel */
cluster = SUPER_CLUSTER( sx, sy );
floodlight2 = SUPER_FLOODLIGHT( sx, sy );
if( *cluster < 0 || *floodlight2 <= 0.0f )
continue;
/* add it */
average += *floodlight2;
samples += 1.0f;
}
/* bail */
if( samples <= 0.0f )
break;
}
/* bail */
if( samples <= 0.0f )
continue;
/* scale dirt */
*floodlight = average / samples;
}
}
#endif
}
void FloodLightRawLightmap( int rawLightmapNum )
{
rawLightmap_t *lm;
/* bail if this number exceeds the number of raw lightmaps */
if( rawLightmapNum >= numRawLightmaps )
return;
/* get lightmap */
lm = &rawLightmaps[ rawLightmapNum ];
/* global pass */
if (floodlighty && floodlightIntensity)
FloodLightRawLightmapPass(lm, floodlightRGB, floodlightIntensity, floodlightDistance, floodlight_lowquality, 0);
/* custom pass */
if (lm->floodlightIntensity)
{
FloodLightRawLightmapPass(lm, lm->floodlightRGB, lm->floodlightIntensity, lm->floodlightDistance, qfalse, lm->floodlightDirectionScale);
numSurfacesFloodlighten += 1;
}
}
void FloodlightRawLightmaps()
{
Sys_Printf( "--- FloodlightRawLightmap ---\n" );
numSurfacesFloodlighten = 0;
RunThreadsOnIndividual( numRawLightmaps, qtrue, FloodLightRawLightmap );
Sys_Printf( "%9d custom lightmaps floodlighted\n", numSurfacesFloodlighten );
}
/*
FloodLightIlluminate()
illuminate floodlight into lightmap luxels
*/
void FloodlightIlluminateLightmap( rawLightmap_t *lm )
{
float *luxel, *floodlight, *deluxel, *normal;
int *cluster;
float brightness;
vec3_t lightvector;
int x, y, lightmapNum;
/* walk lightmaps */
for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
{
/* early out */
if( lm->superLuxels[ lightmapNum ] == NULL )
continue;
/* apply floodlight to each luxel */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get floodlight */
floodlight = SUPER_FLOODLIGHT( x, y );
if (!floodlight[0] && !floodlight[1] && !floodlight[2])
continue;
/* get cluster */
cluster = SUPER_CLUSTER( x, y );
/* only process mapped luxels */
if( *cluster < 0 )
continue;
/* get particulars */
luxel = SUPER_LUXEL( lightmapNum, x, y );
deluxel = SUPER_DELUXEL( x, y );
/* add to lightmap */
luxel[0]+=floodlight[0];
luxel[1]+=floodlight[1];
luxel[2]+=floodlight[2];
if (luxel[3]==0) luxel[3]=1;
/* add to deluxemap */
if (deluxemap && floodlight[3] > 0)
{
normal = SUPER_NORMAL( x, y );
brightness = floodlight[ 0 ] * 0.3f + floodlight[ 1 ] * 0.59f + floodlight[ 2 ] * 0.11f;
brightness *= ( 1.0f / 255.0f ) * floodlight[3];
VectorScale( normal, brightness, lightvector );
VectorAdd( deluxel, lightvector, deluxel );
}
}
}
}
}

157
tools/quake3/q3map2/lightmaps_ydnar.c
View File

@ -1111,12 +1111,20 @@ void SetupSurfaceLightmaps( void )
lm->splotchFix = info->si->splotchFix;
lm->firstLightSurface = numLightSurfaces;
lm->numLightSurfaces = 0;
lm->sampleSize = info->sampleSize;
lm->actualSampleSize = info->sampleSize;
/* vortex: multiply lightmap sample size by -samplescale */
if (sampleScale > 0)
lm->sampleSize = info->sampleSize*sampleScale;
else
lm->sampleSize = info->sampleSize;
lm->actualSampleSize = lm->sampleSize;
lm->entityNum = info->entityNum;
lm->recvShadows = info->recvShadows;
lm->brightness = info->si->lmBrightness;
lm->filterRadius = info->si->lmFilterRadius;
VectorCopy(info->si->floodlightRGB, lm->floodlightRGB);
lm->floodlightDistance = info->si->floodlightDistance;
lm->floodlightIntensity = info->si->floodlightIntensity;
lm->floodlightDirectionScale = info->si->floodlightDirectionScale;
VectorCopy( info->axis, lm->axis );
lm->plane = info->plane;
VectorCopy( info->mins, lm->mins );
@ -2295,7 +2303,7 @@ void StoreSurfaceLightmaps( void )
----------------------------------------------------------------- */
/* note it */
Sys_FPrintf( SYS_VRB, "Subsampling..." );
Sys_Printf( "Subsampling..." );
/* walk the list of raw lightmaps */
numUsed = 0;
@ -2631,6 +2639,135 @@ void StoreSurfaceLightmaps( void )
}
}
/* -----------------------------------------------------------------
convert modelspace deluxemaps to tangentspace
----------------------------------------------------------------- */
/* note it */
if( !bouncing )
{
if( deluxemap && deluxemode == 1)
{
vec3_t worldUp, myNormal, myTangent, myBinormal;
float dist;
Sys_Printf( "converting..." );
for( i = 0; i < numRawLightmaps; i++ )
{
/* get lightmap */
lm = &rawLightmaps[ i ];
/* walk lightmap samples */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get normal and deluxel */
normal = SUPER_NORMAL(x, y);
cluster = SUPER_CLUSTER(x, y);
bspDeluxel = BSP_DELUXEL( x, y );
deluxel = SUPER_DELUXEL( x, y );
/* get normal */
VectorSet( myNormal, normal[0], normal[1], normal[2] );
/* get tangent vectors */
if( myNormal[ 0 ] == 0.0f && myNormal[ 1 ] == 0.0f )
{
if( myNormal[ 2 ] == 1.0f )
{
VectorSet( myTangent, 1.0f, 0.0f, 0.0f );
VectorSet( myBinormal, 0.0f, 1.0f, 0.0f );
}
else if( myNormal[ 2 ] == -1.0f )
{
VectorSet( myTangent, -1.0f, 0.0f, 0.0f );
VectorSet( myBinormal, 0.0f, 1.0f, 0.0f );
}
}
else
{
VectorSet( worldUp, 0.0f, 0.0f, 1.0f );
CrossProduct( myNormal, worldUp, myTangent );
VectorNormalize( myTangent, myTangent );
CrossProduct( myTangent, myNormal, myBinormal );
VectorNormalize( myBinormal, myBinormal );
}
/* project onto plane */
dist = -DotProduct(myTangent, myNormal);
VectorMA(myTangent, dist, myNormal, myTangent);
dist = -DotProduct(myBinormal, myNormal);
VectorMA(myBinormal, dist, myNormal, myBinormal);
/* renormalize */
VectorNormalize( myTangent, myTangent );
VectorNormalize( myBinormal, myBinormal );
/* convert modelspace deluxel to tangentspace */
dirSample[0] = bspDeluxel[0];
dirSample[1] = bspDeluxel[1];
dirSample[2] = bspDeluxel[2];
VectorNormalize(dirSample, dirSample);
/* fix tangents to world matrix */
if (myNormal[0] > 0 || myNormal[1] < 0 || myNormal[2] < 0)
VectorNegate(myTangent, myTangent);
/* build tangentspace vectors */
bspDeluxel[0] = DotProduct(dirSample, myTangent);
bspDeluxel[1] = DotProduct(dirSample, myBinormal);
bspDeluxel[2] = DotProduct(dirSample, myNormal);
}
}
}
}
}
/* -----------------------------------------------------------------
blend lightmaps
----------------------------------------------------------------- */
#ifdef sdfsdfwq312323
/* note it */
Sys_Printf( "blending..." );
for( i = 0; i < numRawLightmaps; i++ )
{
vec3_t myColor;
float myBrightness;
/* get lightmap */
lm = &rawLightmaps[ i ];
/* walk individual lightmaps */
for( lightmapNum = 0; lightmapNum < MAX_LIGHTMAPS; lightmapNum++ )
{
/* early outs */
if( lm->superLuxels[ lightmapNum ] == NULL )
continue;
/* walk lightmap samples */
for( y = 0; y < lm->sh; y++ )
{
for( x = 0; x < lm->sw; x++ )
{
/* get luxel */
bspLuxel = BSP_LUXEL( lightmapNum, x, y );
/* get color */
VectorNormalize(bspLuxel, myColor);
myBrightness = VectorLength(bspLuxel);
myBrightness *= (1 / 127.0f);
myBrightness = myBrightness*myBrightness;
myBrightness *= 127.0f;
VectorScale(myColor, myBrightness, bspLuxel);
}
}
}
}
#endif
/* -----------------------------------------------------------------
collapse non-unique lightmaps
----------------------------------------------------------------- */
@ -2638,7 +2775,7 @@ void StoreSurfaceLightmaps( void )
if( noCollapse == qfalse && deluxemap == qfalse )
{
/* note it */
Sys_FPrintf( SYS_VRB, "collapsing..." );
Sys_Printf( "collapsing..." );
/* set all twin refs to null */
for( i = 0; i < numRawLightmaps; i++ )
@ -2706,7 +2843,7 @@ void StoreSurfaceLightmaps( void )
----------------------------------------------------------------- */
/* note it */
Sys_FPrintf( SYS_VRB, "sorting..." );
Sys_Printf( "sorting..." );
/* allocate a new sorted list */
if( sortLightmaps == NULL )
@ -2722,7 +2859,7 @@ void StoreSurfaceLightmaps( void )
----------------------------------------------------------------- */
/* note it */
Sys_FPrintf( SYS_VRB, "allocating..." );
Sys_Printf( "allocating..." );
/* kill all existing output lightmaps */
if( outLightmaps != NULL )
@ -2775,7 +2912,7 @@ void StoreSurfaceLightmaps( void )
----------------------------------------------------------------- */
/* note it */
Sys_FPrintf( SYS_VRB, "storing..." );
Sys_Printf( "storing..." );
/* count the bsp lightmaps and allocate space */
if( bspLightBytes != NULL )
@ -2843,7 +2980,7 @@ void StoreSurfaceLightmaps( void )
}
if( numExtLightmaps > 0 )
Sys_FPrintf( SYS_VRB, "\n" );
Sys_Printf( "\n" );
/* delete unused external lightmaps */
for( i = numExtLightmaps; i; i++ )
@ -2862,7 +2999,7 @@ void StoreSurfaceLightmaps( void )
----------------------------------------------------------------- */
/* note it */
Sys_FPrintf( SYS_VRB, "projecting..." );
Sys_Printf( "projecting..." );
/* walk the list of surfaces */
for( i = 0; i < numBSPDrawSurfaces; i++ )
@ -3134,7 +3271,7 @@ void StoreSurfaceLightmaps( void )
}
/* finish */
Sys_FPrintf( SYS_VRB, "done.\n" );
Sys_Printf( "done.\n" );
/* calc num stored */
numStored = numBSPLightBytes / 3;

6
tools/quake3/q3map2/main.c
View File

@ -795,7 +795,7 @@ int main( int argc, char **argv )
/* set exit call */
atexit( ExitQ3Map );
/* read general options first */
for( i = 1; i < argc; i++ )
{
@ -871,6 +871,10 @@ int main( int argc, char **argv )
/* ydnar: new path initialization */
InitPaths( &argc, argv );
/* set game options */
if (!patchSubdivisions)
patchSubdivisions = game->patchSubdivisions;
/* check if we have enough options left to attempt something */
if( argc < 2 )

71
tools/quake3/q3map2/q3map2.h
View File

@ -237,6 +237,7 @@ constants
#define LIGHT_FAST_TEMP 512
#define LIGHT_FAST_ACTUAL (LIGHT_FAST | LIGHT_FAST_TEMP)
#define LIGHT_NEGATIVE 1024
#define LIGHT_UNNORMALIZED 2048 /* vortex: do not normalize _color */
#define LIGHT_SUN_DEFAULT (LIGHT_ATTEN_ANGLE | LIGHT_GRID | LIGHT_SURFACES)
#define LIGHT_AREA_DEFAULT (LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES) /* q3a and wolf are the same */
@ -270,7 +271,7 @@ constants
#define SUPER_NORMAL_SIZE 4
#define SUPER_DELUXEL_SIZE 3
#define BSP_DELUXEL_SIZE 3
#define SUPER_FLOODLIGHT_SIZE 1
#define SUPER_FLOODLIGHT_SIZE 4
#define VERTEX_LUXEL( s, v ) (vertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE))
#define RAD_VERTEX_LUXEL( s, v )(radVertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE))
@ -550,6 +551,14 @@ typedef struct game_s
float lightmapGamma; /* default lightmap gamma */
float lightmapExposure; /* default lightmap exposure */
float lightmapCompensate; /* default lightmap compensate value */
float gridScale; /* vortex: default lightgrid scale (affects both directional and ambient spectres) */
float gridAmbientScale; /* vortex: default lightgrid ambient spectre scale */
qboolean noStyles; /* use lightstyles hack or not */
qboolean keepLights; /* keep light entities on bsp */
int patchSubdivisions; /* default patch subdivisions tolerance */
qboolean patchShadows; /* patch casting enabled */
qboolean deluxeMap; /* compile deluxemaps */
int deluxeMode; /* deluxemap mode (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
char *bspIdent; /* 4-letter bsp file prefix */
int bspVersion; /* bsp version to use */
qboolean lumpSwap; /* cod-style len/ofs order */
@ -672,6 +681,7 @@ typedef struct shaderInfo_s
char *backShader; /* for surfaces that generate different front and back passes */
char *cloneShader; /* ydnar: for cloning of a surface */
char *remapShader; /* ydnar: remap a shader in final stage */
char *deprecateShader; /* vortex: shader is deprecated and replaced by this on use */
surfaceModel_t *surfaceModel; /* ydnar: for distribution of models */
foliage_t *foliage; /* ydnar/splash damage: wolf et foliage */
@ -747,7 +757,13 @@ typedef struct shaderInfo_s
vec3_t color; /* normalized color */
vec3_t averageColor;
byte lightStyle;
byte lightStyle;
/* vortex: per-surface floodlight */
float floodlightDirectionScale;
vec3_t floodlightRGB;
float floodlightIntensity;
float floodlightDistance;
qb_t lmMergable; /* ydnar */
int lmCustomWidth, lmCustomHeight; /* ydnar */
@ -1023,7 +1039,7 @@ typedef struct mapDrawSurface_s
int maxIterations;
int patchWidth, patchHeight;
vec3_t bounds[ 2 ];
/* ydnar/sd: for foliage */
int numFoliageInstances;
@ -1072,6 +1088,7 @@ typedef struct
int firstBrush, numBrushes; /* only valid during BSP compile */
epair_t *epairs;
vec3_t originbrush_origin;
qboolean forceNormalSmoothing; /* vortex: true if entity has _smoothnormals/_sn/_smooth key */
}
entity_t;
@ -1307,7 +1324,8 @@ typedef struct
/* input and output */
vec3_t color; /* starts out at full color, may be reduced if transparent surfaces are crossed */
vec3_t colorNoShadow; /* result color with no shadow casting */
/* output */
vec3_t hit;
int compileFlags; /* for determining surface compile flags traced through */
@ -1378,6 +1396,13 @@ typedef struct rawLightmap_s
int numLightClusters, *lightClusters;
int sampleSize, actualSampleSize, axisNum;
/* vortex: per-surface floodlight */
float floodlightDirectionScale;
vec3_t floodlightRGB;
float floodlightIntensity;
float floodlightDistance;
int entityNum;
int recvShadows;
vec3_t mins, maxs, axis, origin, *vecs;
@ -1433,8 +1458,6 @@ typedef struct surfaceInfo_s
}
surfaceInfo_t;
/* -------------------------------------------------------------------------------
prototypes
@ -1568,6 +1591,7 @@ void FreeTreePortals_r( node_t *node );
void ParsePatch( qboolean onlyLights );
mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength );
void PatchMapDrawSurfs( entity_t *e );
void TriangulatePatchSurface( entity_t *e , mapDrawSurface_t *ds );
/* tjunction.c */
@ -1622,6 +1646,8 @@ void SubdivideFaceSurfaces( entity_t *e, tree_t *tree );
void AddEntitySurfaceModels( entity_t *e );
int AddSurfaceModels( mapDrawSurface_t *ds );
void FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree );
void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds );
void EmitTriangleSurface( mapDrawSurface_t *ds );
/* surface_fur.c */
@ -1719,7 +1745,9 @@ float DirtForSample( trace_t *trace );
void DirtyRawLightmap( int num );
void SetupFloodLight();
float FloodLightForSample( trace_t *trace );
void FloodlightRawLightmaps();
void FloodlightIlluminateLightmap( rawLightmap_t *lm );
float FloodLightForSample( trace_t *trace , float floodLightDistance, qboolean floodLightLowQuality);
void FloodLightRawLightmap( int num );
void IlluminateRawLightmap( int num );
@ -1871,6 +1899,12 @@ Q_EXTERN game_t games[]
,
#include "game_qfusion.h" /* qfusion game */
,
#include "game_darkplaces.h" /* vortex: darkplaces q1 engine */
,
#include "game_dq.h" /* vortex: deluxe quake game ( darkplaces q1 engine) */
,
#include "game_prophecy.h" /* vortex: prophecy game ( darkplaces q1 engine) */
,
{ NULL } /* null game */
};
#endif
@ -1957,6 +1991,7 @@ Q_EXTERN char outbase[ 32 ];
Q_EXTERN int sampleSize; /* lightmap sample size in units */
Q_EXTERN int minSampleSize; /* minimum sample size to use at all */
Q_EXTERN int sampleScale; /* vortex: lightmap sample scale (ie quality)*/
Q_EXTERN int mapEntityNum Q_ASSIGN( 0 );
@ -2083,6 +2118,7 @@ light global variables
Q_EXTERN qboolean wolfLight Q_ASSIGN( qfalse );
Q_EXTERN qboolean loMem Q_ASSIGN( qfalse );
Q_EXTERN qboolean noStyles Q_ASSIGN( qfalse );
Q_EXTERN qboolean keepLights Q_ASSIGN( qfalse );
Q_EXTERN int sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE );
Q_EXTERN int minSampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_MIN_SAMPLE_SIZE );
@ -2096,6 +2132,7 @@ Q_EXTERN qboolean cpmaHack Q_ASSIGN( qfalse );
Q_EXTERN qboolean deluxemap Q_ASSIGN( qfalse );
Q_EXTERN qboolean debugDeluxemap Q_ASSIGN( qfalse );
Q_EXTERN int deluxemode Q_ASSIGN( 0 ); /* deluxemap format (0 - modelspace, 1 - tangentspace with renormalization, 2 - tangentspace without renormalization) */
Q_EXTERN qboolean fast Q_ASSIGN( qfalse );
Q_EXTERN qboolean faster Q_ASSIGN( qfalse );
@ -2130,12 +2167,13 @@ Q_EXTERN float dirtDepth Q_ASSIGN( 128.0f );
Q_EXTERN float dirtScale Q_ASSIGN( 1.0f );
Q_EXTERN float dirtGain Q_ASSIGN( 1.0f );
Q_EXTERN qboolean debugnormals Q_ASSIGN( qfalse );
Q_EXTERN qboolean floodlighty Q_ASSIGN( qfalse );
Q_EXTERN qboolean floodlight_lowquality Q_ASSIGN( qfalse );
Q_EXTERN vec3_t floodlightRGB;
Q_EXTERN float floodlightIntensity Q_ASSIGN( 512 );
Q_EXTERN float floodlightDistance Q_ASSIGN( 1024 );
/* 27: floodlighting */
Q_EXTERN qboolean debugnormals Q_ASSIGN( qfalse );
Q_EXTERN qboolean floodlighty Q_ASSIGN( qfalse );
Q_EXTERN qboolean floodlight_lowquality Q_ASSIGN( qfalse );
Q_EXTERN vec3_t floodlightRGB;
Q_EXTERN float floodlightIntensity Q_ASSIGN( 512.0f );
Q_EXTERN float floodlightDistance Q_ASSIGN( 1024.0f );
Q_EXTERN qboolean dump Q_ASSIGN( qfalse );
Q_EXTERN qboolean debug Q_ASSIGN( qfalse );
@ -2153,6 +2191,10 @@ Q_EXTERN float pointScale Q_ASSIGN( 7500.0f );
Q_EXTERN float areaScale Q_ASSIGN( 0.25f );
Q_EXTERN float skyScale Q_ASSIGN( 1.0f );
Q_EXTERN float bounceScale Q_ASSIGN( 0.25f );
/* vortex: gridscale and gridambientscale */
Q_EXTERN float gridScale Q_ASSIGN( 1.0f );
Q_EXTERN float gridAmbientScale Q_ASSIGN( 1.0f );
/* ydnar: lightmap gamma/compensation */
Q_EXTERN float lightmapGamma Q_ASSIGN( 1.0f );
@ -2264,6 +2306,9 @@ Q_EXTERN int numBSPLightmaps Q_ASSIGN( 0 );
Q_EXTERN int numExtLightmaps Q_ASSIGN( 0 );
Q_EXTERN outLightmap_t *outLightmaps Q_ASSIGN( NULL );
/* vortex: per surface floodlight statictics */
Q_EXTERN int numSurfacesFloodlighten Q_ASSIGN( 0 );
/* grid points */
Q_EXTERN int numRawGridPoints Q_ASSIGN( 0 );
Q_EXTERN rawGridPoint_t *rawGridPoints Q_ASSIGN( NULL );

3300
tools/quake3/q3map2/q3map2_fsr_newfiles/q3map2_fsr_svn158.patch
View File

File diff suppressed because it is too large Load Diff

61
tools/quake3/q3map2/shaders.c
View File

@ -827,13 +827,15 @@ ShaderInfoForShader()
finds a shaderinfo for a named shader
*/
#define MAX_SHADER_DEPRECATION_DEPTH 16
shaderInfo_t *ShaderInfoForShader( const char *shaderName )
{
int i;
int deprecationDepth;
shaderInfo_t *si;
char shader[ MAX_QPATH ];
/* dummy check */
if( shaderName == NULL || shaderName[ 0 ] == '\0' )
{
@ -846,11 +848,27 @@ shaderInfo_t *ShaderInfoForShader( const char *shaderName )
StripExtension( shader );
/* search for it */
deprecationDepth = 0;
for( i = 0; i < numShaderInfo; i++ )
{
si = &shaderInfo[ i ];
if( !Q_stricmp( shader, si->shader ) )
{
/* check if shader is deprecated */
if (deprecationDepth < MAX_SHADER_DEPRECATION_DEPTH && si->deprecateShader && si->deprecateShader[ 0 ] )
{
/* override name */
strcpy( shader, si->deprecateShader );
StripExtension( shader );
/* increase deprecation depth */
deprecationDepth++;
if (deprecationDepth == MAX_SHADER_DEPRECATION_DEPTH)
Sys_Printf("WARNING: Max deprecation depth of %i is reached on shader '%s'\n", MAX_SHADER_DEPRECATION_DEPTH, shader);
/* search again from beginning */
i = -1;
continue;
}
/* load image if necessary */
if( si->finished == qfalse )
{
@ -1363,7 +1381,6 @@ static void ParseShaderFile( const char *filename )
{
surfaceModel_t *model;
/* allocate new model and attach it */
model = safe_malloc( sizeof( *model ) );
memset( model, 0, sizeof( *model ) );
@ -1488,6 +1505,24 @@ static void ParseShaderFile( const char *filename )
GetTokenAppend( shaderText, qfalse );
si->backsplashDistance = atof( token );
}
/* q3map_floodLight <r> <g> <b> <diste> <intensity> <light_direction_power> */
else if( !Q_stricmp( token, "q3map_floodLight" ) )
{
/* get color */
GetTokenAppend( shaderText, qfalse );
si->floodlightRGB[ 0 ] = atof( token );
GetTokenAppend( shaderText, qfalse );
si->floodlightRGB[ 1 ] = atof( token );
GetTokenAppend( shaderText, qfalse );
si->floodlightRGB[ 2 ] = atof( token );
GetTokenAppend( shaderText, qfalse );
si->floodlightDistance = atof( token );
GetTokenAppend( shaderText, qfalse );
si->floodlightIntensity = atof( token );
GetTokenAppend( shaderText, qfalse );
si->floodlightDirectionScale = atof( token );
}
/* q3map_lightmapSampleSize <value> */
else if( !Q_stricmp( token, "q3map_lightmapSampleSize" ) )
@ -1613,6 +1648,18 @@ static void ParseShaderFile( const char *filename )
strcpy( si->remapShader, token );
}
}
/* q3map_deprecateShader <shader> */
else if( !Q_stricmp( token, "q3map_deprecateShader" ) )
{
GetTokenAppend( shaderText, qfalse );
if( token[ 0 ] != '\0' )
{
si->deprecateShader = safe_malloc( strlen( token ) + 1 );
strcpy( si->deprecateShader, token );
}
}
/* ydnar: q3map_offset <value> */
else if( !Q_stricmp( token, "q3map_offset" ) )
@ -1933,12 +1980,14 @@ static void ParseShaderFile( const char *filename )
si->styleMarker = 2;
/* ydnar: default to searching for q3map_<surfaceparm> */
else
#if 0
else
{
//% Sys_FPrintf( SYS_VRB, "Attempting to match %s with a known surfaceparm\n", token );
Sys_FPrintf( SYS_VRB, "Attempting to match %s with a known surfaceparm\n", token );
if( ApplySurfaceParm( &token[ 6 ], &si->contentFlags, &si->surfaceFlags, &si->compileFlags ) == qfalse )
;//% Sys_Printf( "WARNING: Unknown q3map_* directive \"%s\"\n", token );
Sys_Printf( "WARNING: Unknown q3map_* directive \"%s\"\n", token );
}
#endif
}

38
tools/quake3/q3map2/surface.c
View File

@ -2446,25 +2446,27 @@ void EmitFlareSurface( mapDrawSurface_t *ds )
numSurfacesByType[ ds->type ]++;
}
/*
EmitPatchSurface()
emits a bsp patch drawsurface
*/
void EmitPatchSurface( mapDrawSurface_t *ds )
void EmitPatchSurface( entity_t *e, mapDrawSurface_t *ds )
{
int i, j;
bspDrawSurface_t *out;
int surfaceFlags, contentFlags;
int forcePatchMeta;
/* vortex: _patchMeta support */
forcePatchMeta = IntForKey(e, "_patchMeta" );
if (!forcePatchMeta)
forcePatchMeta = IntForKey(e, "patchMeta" );
/* invert the surface if necessary */
if( ds->backSide || ds->shaderInfo->invert )
{
bspDrawVert_t *dv1, *dv2, temp;
/* walk the verts, flip the normal */
for( i = 0; i < ds->numVerts; i++ )
@ -2486,7 +2488,7 @@ void EmitPatchSurface( mapDrawSurface_t *ds )
/* invert facing */
VectorScale( ds->lightmapVecs[ 2 ], -1.0f, ds->lightmapVecs[ 2 ] );
}
/* allocate a new surface */
if( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS )
Error( "MAX_MAP_DRAW_SURFS" );
@ -2494,12 +2496,12 @@ void EmitPatchSurface( mapDrawSurface_t *ds )
ds->outputNum = numBSPDrawSurfaces;
numBSPDrawSurfaces++;
memset( out, 0, sizeof( *out ) );
/* set it up */
out->surfaceType = MST_PATCH;
if( debugSurfaces )
out->shaderNum = EmitShader( "debugsurfaces", NULL, NULL );
else if( patchMeta )
else if( patchMeta || forcePatchMeta )
{
/* patch meta requires that we have nodraw patches for collision */
surfaceFlags = ds->shaderInfo->surfaceFlags;
@ -2549,8 +2551,6 @@ void EmitPatchSurface( mapDrawSurface_t *ds )
numSurfacesByType[ ds->type ]++;
}
/*
OptimizeTriangleSurface() - ydnar
optimizes the vertex/index data in a triangle surface
@ -2674,12 +2674,11 @@ EmitTriangleSurface()
creates a bsp drawsurface from arbitrary triangle surfaces
*/
static void EmitTriangleSurface( mapDrawSurface_t *ds )
void EmitTriangleSurface( mapDrawSurface_t *ds )
{
int i, temp;
bspDrawSurface_t *out;
/* invert the surface if necessary */
if( ds->backSide || ds->shaderInfo->invert )
{
@ -2690,15 +2689,15 @@ static void EmitTriangleSurface( mapDrawSurface_t *ds )
ds->indexes[ i ] = ds->indexes[ i + 1 ];
ds->indexes[ i + 1 ] = temp;
}
/* walk the verts, flip the normal */
for( i = 0; i < ds->numVerts; i++ )
VectorScale( ds->verts[ i ].normal, -1.0f, ds->verts[ i ].normal );
/* invert facing */
VectorScale( ds->lightmapVecs[ 2 ], -1.0f, ds->lightmapVecs[ 2 ] );
}
/* allocate a new surface */
if( numBSPDrawSurfaces == MAX_MAP_DRAW_SURFS )
Error( "MAX_MAP_DRAW_SURFS" );
@ -2805,15 +2804,14 @@ EmitFaceSurface()
emits a bsp planar winding (brush face) drawsurface
*/
static void EmitFaceSurface( mapDrawSurface_t *ds )
static void EmitFaceSurface(mapDrawSurface_t *ds )
{
/* strip/fan finding was moved elsewhere */
StripFaceSurface( ds );
EmitTriangleSurface( ds );
EmitTriangleSurface(ds);
}
/*
MakeDebugPortalSurfs_r() - ydnar
generates drawsurfaces for passable portals in the bsp
@ -3503,7 +3501,7 @@ void FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree )
if( refs == 0 )
refs = FilterPatchIntoTree( ds, tree );
if( refs > 0 )
EmitPatchSurface( ds );
EmitPatchSurface( e, ds );
break;
/* handle triangle surfaces */

64
tools/quake3/q3map2/surface_meta.c
View File

@ -312,23 +312,41 @@ TriangulatePatchSurface()
creates triangles from a patch
*/
void TriangulatePatchSurface( mapDrawSurface_t *ds )
void TriangulatePatchSurface( entity_t *e , mapDrawSurface_t *ds )
{
int iterations, x, y, pw[ 5 ], r;
mapDrawSurface_t *dsNew;
mesh_t src, *subdivided, *mesh;
int forcePatchMeta;
int patchQuality;
int patchSubdivision;
/* vortex: _patchMeta, _patchQuality, _patchSubdivide support */
forcePatchMeta = IntForKey(e, "_patchMeta" );
if (!forcePatchMeta)
forcePatchMeta = IntForKey(e, "patchMeta" );
patchQuality = IntForKey(e, "_patchQuality" );
if (!patchQuality)
patchQuality = IntForKey(e, "patchQuality" );
if (!patchQuality)
patchQuality = 1.0;
patchSubdivision = IntForKey(e, "_patchSubdivide" );
if (!patchSubdivision)
patchSubdivision = IntForKey(e, "patchSubdivide" );
/* try to early out */
if( ds->numVerts == 0 || ds->type != SURFACE_PATCH || patchMeta == qfalse )
if(ds->numVerts == 0 || ds->type != SURFACE_PATCH || ( patchMeta == qfalse && !forcePatchMeta) )
return;
/* make a mesh from the drawsurf */
src.width = ds->patchWidth;
src.height = ds->patchHeight;
src.verts = ds->verts;
//% subdivided = SubdivideMesh( src, 8, 999 );
iterations = IterationsForCurve( ds->longestCurve, patchSubdivisions );
if (patchSubdivision)
iterations = IterationsForCurve( ds->longestCurve, patchSubdivision );
else
iterations = IterationsForCurve( ds->longestCurve, patchSubdivisions / patchQuality );
subdivided = SubdivideMesh2( src, iterations ); //% ds->maxIterations
/* fit it to the curve and remove colinear verts on rows/columns */
@ -667,12 +685,12 @@ void MakeEntityMetaTriangles( entity_t *e )
break;
case SURFACE_PATCH:
TriangulatePatchSurface( ds );
TriangulatePatchSurface(e, ds );
break;
case SURFACE_TRIANGLES:
break;
case SURFACE_FORCED_META:
case SURFACE_META:
SurfaceToMetaTriangles( ds );
@ -987,7 +1005,7 @@ void SmoothMetaTriangles( void )
vec3_t average, diff;
int indexes[ MAX_SAMPLES ];
vec3_t votes[ MAX_SAMPLES ];
const char *classname;
/* note it */
Sys_FPrintf( SYS_VRB, "--- SmoothMetaTriangles ---\n" );
@ -1009,11 +1027,31 @@ void SmoothMetaTriangles( void )
and set per-vertex smoothing angle */
for( i = 0, tri = &metaTriangles[ i ]; i < numMetaTriangles; i++, tri++ )
{
/* vortex: try get smoothing from entity key */
shadeAngle = FloatForKey(&entities[tri->entityNum], "_smoothnormals");
if (shadeAngle <= 0.0f)
shadeAngle = FloatForKey(&entities[tri->entityNum], "_sn");
if (shadeAngle <= 0.0f)
shadeAngle = FloatForKey(&entities[tri->entityNum], "_smooth");
if (shadeAngle > 0.0f)
{
if (entities[tri->entityNum].forceNormalSmoothing == qfalse)
{
entities[tri->entityNum].forceNormalSmoothing = qtrue;
classname = ValueForKey( &entities[tri->entityNum], "classname" );
Sys_Printf( "Entity %d (%s) has vertex normal smoothing with breaking angle of %3.0f\n", tri->entityNum, classname, shadeAngle );
}
shadeAngle = DEG2RAD( shadeAngle );
}
/* get shader for shade angle */
if( tri->si->shadeAngleDegrees > 0.0f )
shadeAngle = DEG2RAD( tri->si->shadeAngleDegrees );
else
shadeAngle = defaultShadeAngle;
if (shadeAngle <= 0.0f)
{
if( tri->si->shadeAngleDegrees > 0.0f )
shadeAngle = DEG2RAD( tri->si->shadeAngleDegrees );
else
shadeAngle = defaultShadeAngle;
}
if( shadeAngle > maxShadeAngle )
maxShadeAngle = shadeAngle;

11
tools/quake3/q3map2/writebsp.c
View File

@ -280,18 +280,19 @@ sets style keys for entity lights
void SetLightStyles( void )
{
int i, j, style, numStyles;
qboolean keepLights;
const char *t;
entity_t *e;
epair_t *ep, *next;
char value[ 10 ];
char lightTargets[ MAX_SWITCHED_LIGHTS ][ 64 ];
int lightStyles[ MAX_SWITCHED_LIGHTS ];
/* ydnar: determine if we keep lights in the bsp */
t = ValueForKey( &entities[ 0 ], "_keepLights" );
keepLights = (t[ 0 ] == '1') ? qtrue : qfalse;
if (KeyExists(&entities[ 0 ], "_keepLights") == qtrue)
{
t = ValueForKey( &entities[ 0 ], "_keepLights" );
keepLights = (t[ 0 ] == '1') ? qtrue : qfalse;
}
/* any light that is controlled (has a targetname) must have a unique style number generated for it */
numStyles = 0;