Merge commit 'ddee6cbe7c5fcbba52e7881a411f310809b867f9' into master-merge

[xonotic/netradiant.git] / tools / quake3 / q3map2 / light_bounce.c

diff --git a/tools/quake3/q3map2/light_bounce.c b/tools/quake3/q3map2/light_bounce.c
index 18d1f0a4c236650d2de4e718fe58ca581efdde24..8cd6deadd281a8a395b0a158b7959d2ee3995aef 100644 (file)
--- a/tools/quake3/q3map2/light_bounce.c
+++ b/tools/quake3/q3map2/light_bounce.c
@@ -185,10 +185,10 @@ static void RadClipWindingEpsilon( radWinding_t *in, vec3_t normal, vec_t dist,
        }
 
        /* error check */
-       if ( front->numVerts > maxPoints || front->numVerts > maxPoints ) {
+       if ( front->numVerts > maxPoints ) {
                Error( "RadClipWindingEpsilon: points exceeded estimate" );
        }
-       if ( front->numVerts > MAX_POINTS_ON_WINDING || front->numVerts > MAX_POINTS_ON_WINDING ) {
+       if ( front->numVerts > MAX_POINTS_ON_WINDING ) {
                Error( "RadClipWindingEpsilon: MAX_POINTS_ON_WINDING" );
        }
 }
@@ -295,7 +295,7 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
                        /* 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[ 4 ] = 255.0f;
+                               textureColor[ 3 ] = 255.0f;
                        }
                        avgcolor = ( textureColor[ 0 ] + textureColor[ 1 ] + textureColor[ 2 ] ) / 3;
                        for ( i = 0; i < 3; i++ )
@@ -381,7 +381,7 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
                                                /* multiply by texture color */
                                                if ( !RadSampleImage( si->lightImage->pixels, si->lightImage->width, si->lightImage->height, st, textureColor ) ) {
                                                        VectorCopy( si->averageColor, textureColor );
-                                                       textureColor[ 4 ] = 255;
+                                                       textureColor[ 3 ] = 255;
                                                }
                                                avgcolor = ( textureColor[ 0 ] + textureColor[ 1 ] + textureColor[ 2 ] ) / 3;
                                                for ( l = 0; l < 3; l++ ){
@@ -435,13 +435,15 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
 #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 ){
+                                                                         float scale, float subdivide, 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;
+       winding_t       *w, *splash_w;
 
 
        /* dummy check */
@@ -470,8 +472,8 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
                        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 );
+                       RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &front, cw );
+                       RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &back, cw );
                        return;
                }
        }
@@ -497,7 +499,7 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
                /* 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 );
+                       RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, ( subdivide / 2.0f ), rw, cw );
                        return;
                }
        }
@@ -586,27 +588,77 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
                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 ) {
+#if 0
+               /* optionally create a point backsplash light */
+               if ( si->backsplashFraction > 0 ) {
+
                        /* allocate a new point light */
                        splash = safe_malloc0( 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++;
                }
+#endif
+
+#if 1
+               /* optionally create area backsplash light */
+               //if ( original && si->backsplashFraction > 0 ) {
+               if ( si->backsplashFraction > 0 && !( si->compileFlags & C_SKY ) ) {
+                       /* allocate a new area light */
+                       splash = safe_malloc( sizeof( *splash ) );
+                       memset( splash, 0, sizeof( *splash ) );
+                       ThreadLock();
+                       splash->next = lights;
+                       lights = splash;
+                       ThreadUnlock();
+
+                       /* set it up */
+                       splash->flags = LIGHT_AREA_DEFAULT;
+                       splash->type = EMIT_AREA;
+                       splash->photons = light->photons * 7.0f * si->backsplashFraction;
+                       splash->add = light->add * 7.0f * si->backsplashFraction;
+                       splash->fade = 1.0f;
+                       splash->si = si;
+                       VectorCopy( si->color, splash->color );
+                       VectorScale( splash->color, splash->add, splash->emitColor );
+                       splash->falloffTolerance = falloffTolerance;
+                       splash->style = noStyles ? LS_NORMAL : si->lightStyle;
+                       if ( splash->style < LS_NORMAL || splash->style >= LS_NONE ) {
+                               splash->style = LS_NORMAL;
+                       }
+
+                       /* create a regular winding */
+                       splash_w = AllocWinding( rw->numVerts );
+                       splash_w->numpoints = rw->numVerts;
+                       for ( i = 0; i < rw->numVerts; i++ )
+                               VectorMA( rw->verts[rw->numVerts - 1 - i].xyz, si->backsplashDistance, normal, splash_w->p[ i ] );
+                       splash->w = splash_w;
+
+                       VectorMA( light->origin, si->backsplashDistance, normal, splash->origin );
+                       VectorNegate( normal, splash->normal );
+            splash->dist = DotProduct( splash->origin, splash->normal );
+
+//                     splash->flags |= LIGHT_TWOSIDED;
+               }
+#endif
+
        }
        else
        {
@@ -645,7 +697,6 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
 }
 
 
-
 /*
    RadLightForTriangles()
    creates unbounced diffuse lights for triangle soup (misc_models, etc)
@@ -684,7 +735,7 @@ void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderIn
                }
 
                /* subdivide into area lights */
-               RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
+               RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw );
        }
 }
 
@@ -793,7 +844,7 @@ void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t
                                }
 
                                /* subdivide into area lights */
-                               RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
+                               RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw );
                        }
 
                        /* generate 2 tris */
@@ -822,7 +873,7 @@ void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t
                                        }
 
                                        /* subdivide into area lights */
-                                       RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw );
+                                       RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw );
                                }
                        }
                }