Merge branch 'NateEag-master-patch-12920' into 'master'

[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 c818121215d6f3a87bf1b728b73ee550a80a13bf..b0b838b8ccea11094e34b50f3dc1745e0dc64384 100644 (file)
--- a/tools/quake3/q3map2/light_bounce.c
+++ b/tools/quake3/q3map2/light_bounce.c
@@ -195,6 +195,23 @@ static void RadClipWindingEpsilon( radWinding_t *in, vec3_t normal, vec_t dist,
 
 
 
+/*
+   Modulo1IfNegative()
+   Previously the bias computation was doing:
+
+      while ( f < 0.0f ) {
+         f += 1.0f;
+      }
+
+   That may end in infinite loop in some case.
+   It may also be slower because of useless loops.
+   I don't know what that computation is for.
+   -- illwieckz
+*/
+float Modulo1IfNegative( float f ){
+       return f < 0.0f ? f - floor( f ) : f;
+}
+
 
 
 /*
@@ -204,10 +221,8 @@ static void RadClipWindingEpsilon( radWinding_t *in, vec3_t normal, vec_t dist,
  */
 
 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;
 
@@ -216,18 +231,10 @@ qboolean RadSampleImage( byte *pixels, int width, int height, float st[ 2 ], flo
                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 = ( (float) width * Modulo1IfNegative( st[ 0 ] ) ) + 0.5f;
        x %= width;
-       y = ( (float) height * sto[ 1 ] )  + 0.5f;
+       y = ( (float) height * Modulo1IfNegative( st[ 1 ] ) ) + 0.5f;
        y %= height;
 
        /* get pixel */
@@ -256,7 +263,7 @@ qboolean RadSampleImage( byte *pixels, int width, int height, float st[ 2 ], flo
 #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, avgcolor;
+       int i, j, k, l, v, x, y, samples, avgcolor, f_superSample;
        vec3_t color, mins, maxs;
        vec4_t textureColor;
        float alpha, alphaI, bf;
@@ -309,6 +316,7 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
        /* sample lightmap */
        else
        {
+               f_superSample = (float)superSample;
                /* fracture the winding into a fan (including degenerate tris) */
                for ( v = 1; v < ( rw->numVerts - 1 ) && samples < MAX_SAMPLES; v++ )
                {
@@ -328,7 +336,7 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
                                                blend[ 0 ] = i;
                                                blend[ 1 ] = j;
                                                blend[ 2 ] = k;
-                                               bf = ( 1.0 / ( blend[ 0 ] + blend[ 1 ] + blend[ 2 ] ) );
+                                               bf = ( 1.0f / ( blend[ 0 ] + blend[ 1 ] + blend[ 2 ] ) );
                                                VectorScale( blend, bf, blend );
 
                                                /* create a blended sample */
@@ -345,8 +353,10 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
                                                }
 
                                                /* get lightmap xy coords */
-                                               x = lightmap[ 0 ] / (float) superSample;
-                                               y = lightmap[ 1 ] / (float) superSample;
+                                               /* xy = clamp(lightmap/superSample, 0, lm - 1)*/
+                                               x = lightmap[ 0 ] / f_superSample;
+                                               y = lightmap[ 1 ] / f_superSample;
+
                                                if ( x < 0 ) {
                                                        x = 0;
                                                }
@@ -377,8 +387,15 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
                                                        textureColor[ 3 ] = 255;
                                                }
                                                avgcolor = ( textureColor[ 0 ] + textureColor[ 1 ] + textureColor[ 2 ] ) / 3;
-                                               for ( l = 0; l < 3; l++ ){
+                                               for ( i = 0; i < 3; i++ ){
+                                                       color[ i ] = ( ( textureColor[ i ] * bounceColorRatio + ( avgcolor * ( 1 - bounceColorRatio ) ) ) / 255 ) * ( radLuxel[ i ] / 255 );
+                                               /*
+                                                  Workaround for https://gitlab.com/xonotic/netradiant/-/issues/182
+                                                  This loop normally uses the l iterator instead of i:
+                                                  for ( l = 0; l < 3; l++ ){
                                                        color[ l ] = ( ( textureColor[ l ] * bounceColorRatio + ( avgcolor * ( 1 - bounceColorRatio ) ) ) / 255 ) * ( radLuxel[ l ] / 255 );
+                                                       }
+                                               */
                                                //Sys_Printf( "%i %i %i %i %i \n", (int) textureColor[ 0 ], (int) textureColor[ 1 ], (int) textureColor[ 2 ], (int) avgcolor, (int) color[ i ] );
                                                }
                                                AddPointToBounds( color, mins, maxs );
@@ -538,8 +555,7 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
        }
 
        /* create a light */
-       light = safe_malloc( sizeof( *light ) );
-       memset( light, 0, sizeof( *light ) );
+       light = safe_malloc0( sizeof( *light ) );
 
        /* attach it */
        ThreadLock();
@@ -587,8 +603,7 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
                if ( si->backsplashFraction > 0 ) {
 
                        /* allocate a new point light */
-                       splash = safe_malloc( sizeof( *splash ) );
-                       memset( splash, 0, sizeof( *splash ) );
+                       splash = safe_malloc0( sizeof( *splash ) );
 
                        splash->next = lights;
                        lights = splash;