slow down non-fast operation but make it more accurate by not using falloff tolerance...

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

diff --git a/tools/quake3/q3map2/light_ydnar.c b/tools/quake3/q3map2/light_ydnar.c
index bf5bc36c34b90a72d785696daa837368e45f7918..12742f707cc439df86a172e6476d18979990c7d8 100644 (file)
--- a/tools/quake3/q3map2/light_ydnar.c
+++ b/tools/quake3/q3map2/light_ydnar.c
@@ -74,7 +74,7 @@ void ColorToBytes( const float *color, byte *colorBytes, float scale )
                sample[ i ] = pow( sample[ i ] / 255.0f, gamma ) * 255.0f;
        }
 
-       if (lightmapExposure == 1)
+       if (lightmapExposure == 0)
        {
                /* clamp with color normalization */
                max = sample[ 0 ];
@@ -87,10 +87,6 @@ void ColorToBytes( const float *color, byte *colorBytes, float scale )
        }
        else
        {
-               if (lightmapExposure==0)
-               {
-                       lightmapExposure=1.0f;
-               }
                inv=1.f/lightmapExposure;
                //Exposure
 
@@ -3193,8 +3189,6 @@ void SetupBrushesFlags( int mask_any, int test_any, int mask_all, int test_all )
                        allCompileFlags &= si->compileFlags;
                }
 
-       Sys_FPrintf( SYS_VRB, "flags: %d (all: %d)\n", compileFlags, allCompileFlags );
-               
                /* determine if this brush is opaque to light */
                if( (compileFlags & mask_any) == test_any && (allCompileFlags & mask_all) == test_all )
                {
@@ -3638,23 +3632,29 @@ void SetupEnvelopes( qboolean forGrid, qboolean fastFlag )
                                /* handle area lights */
                                if( exactPointToPolygon && light->type == EMIT_AREA && light->w != NULL )
                                {
-                                       /* ugly hack to calculate extent for area lights, but only done once */
-                                       VectorScale( light->normal, -1.0f, dir );
-                                       for( radius = 100.0f; radius < 130000.0f && light->envelope == 0; radius += 10.0f )
+                                       light->envelope = MAX_WORLD_COORD * 8.0f;
+
+                                       /* check for fast mode */
+                                       if( (light->flags & LIGHT_FAST) || (light->flags & LIGHT_FAST_TEMP) )
                                        {
-                                               float   factor;
-                                               
-                                               VectorMA( light->origin, radius, light->normal, origin );
-                                               factor = PointToPolygonFormFactor( origin, dir, light->w );
-                                               if( factor < 0.0f )
-                                                       factor *= -1.0f;
-                                               if( (factor * light->add) <= light->falloffTolerance )
-                                                       light->envelope = radius;
+                                               /* ugly hack to calculate extent for area lights, but only done once */
+                                               VectorScale( light->normal, -1.0f, dir );
+                                               for( radius = 100.0f; radius < MAX_WORLD_COORD * 8.0f; radius += 10.0f )
+                                               {
+                                                       float   factor;
+                                                       
+                                                       VectorMA( light->origin, radius, light->normal, origin );
+                                                       factor = PointToPolygonFormFactor( origin, dir, light->w );
+                                                       if( factor < 0.0f )
+                                                               factor *= -1.0f;
+                                                       if( (factor * light->add) <= light->falloffTolerance )
+                                                       {
+                                                               light->envelope = radius;
+                                                               break;
+                                                       }
+                                               }
                                        }
                                        
-                                       /* check for fast mode */
-                                       if( !(light->flags & LIGHT_FAST) && !(light->flags & LIGHT_FAST_TEMP) )
-                                               light->envelope = MAX_WORLD_COORD * 8.0f;
                                        intensity = light->photons; /* hopefully not used */
                                }
                                else
@@ -3669,30 +3669,42 @@ void SetupEnvelopes( qboolean forGrid, qboolean fastFlag )
                                        /* solve distance for non-distance lights */
                                        if( !(light->flags & LIGHT_ATTEN_DISTANCE) )
                                                light->envelope = MAX_WORLD_COORD * 8.0f;
-                                       
-                                       /* solve distance for linear lights */
-                                       else if( (light->flags & LIGHT_ATTEN_LINEAR ) )
-                                               //% light->envelope = ((intensity / light->falloffTolerance) * linearScale - 1 + radius) / light->fade;
-                                               light->envelope = ((intensity * linearScale) - light->falloffTolerance) / light->fade;
-
-                                               /*
-                                               add = angle * light->photons * linearScale - (dist * light->fade);
-                                               T = (light->photons * linearScale) - (dist * light->fade);
-                                               T + (dist * light->fade) = (light->photons * linearScale);
-                                               dist * light->fade = (light->photons * linearScale) - T;
-                                               dist = ((light->photons * linearScale) - T) / light->fade;
-                                               */
-                                       
-                                       /* solve for inverse square falloff */
+                                               
+                                       else if( (light->flags & LIGHT_FAST) || (light->flags & LIGHT_FAST_TEMP) )
+                                       {
+                                               /* solve distance for linear lights */
+                                               if( (light->flags & LIGHT_ATTEN_LINEAR ) )
+                                                       light->envelope = ((intensity * linearScale) - light->falloffTolerance) / light->fade;
+
+                                                       /*
+                                                       add = angle * light->photons * linearScale - (dist * light->fade);
+                                                       T = (light->photons * linearScale) - (dist * light->fade);
+                                                       T + (dist * light->fade) = (light->photons * linearScale);
+                                                       dist * light->fade = (light->photons * linearScale) - T;
+                                                       dist = ((light->photons * linearScale) - T) / light->fade;
+                                                       */
+                                               
+                                               /* solve for inverse square falloff */
+                                               else
+                                                       light->envelope = sqrt( intensity / light->falloffTolerance ) + radius;
+                                                       
+                                                       /*
+                                                       add = light->photons / (dist * dist);
+                                                       T = light->photons / (dist * dist);
+                                                       T * (dist * dist) = light->photons;
+                                                       dist = sqrt( light->photons / T );
+                                                       */
+                                       }
                                        else
-                                               light->envelope = sqrt( intensity / light->falloffTolerance ) + radius;
+                                       {
+                                               /* solve distance for linear lights */
+                                               if( (light->flags & LIGHT_ATTEN_LINEAR ) )
+                                                       light->envelope = (intensity * linearScale) / light->fade;
                                                
-                                               /*
-                                               add = light->photons / (dist * dist);
-                                               T = light->photons / (dist * dist);
-                                               T * (dist * dist) = light->photons;
-                                               dist = sqrt( light->photons / T );
-                                               */
+                                               /* can't cull these */
+                                               else
+                                                       light->envelope = MAX_WORLD_COORD * 8.0f;
+                                       }
                                }
                                
                                /* chop radius against pvs */
@@ -4077,7 +4089,7 @@ void SetupFloodLight( void )
 
                if (VectorLength(floodlightRGB)==0)
                {
-                       VectorSet(floodlightRGB,240,240,255);
+                       VectorSet(floodlightRGB,0.94,0.94,1.0);
                }
 
                if (v4<1) v4=1024;
@@ -4093,11 +4105,15 @@ void SetupFloodLight( void )
        }
        else
        {
-               VectorSet(floodlightRGB,240,240,255);
-               //floodlighty = qtrue;
-               //Sys_Printf( "FloodLighting enabled via worldspawn _floodlight key.\n" );
+               VectorSet(floodlightRGB,0.94,0.94,1.0);
+       }
+       if(colorsRGB)
+       {
+               floodlightRGB[0] = Image_LinearFloatFromsRGBFloat(floodlightRGB[0]);
+               floodlightRGB[1] = Image_LinearFloatFromsRGBFloat(floodlightRGB[1]);
+               floodlightRGB[2] = Image_LinearFloatFromsRGBFloat(floodlightRGB[2]);
        }
-       VectorNormalize(floodlightRGB,floodlightRGB);
+       ColorNormalize(floodlightRGB,floodlightRGB);
 }
 
 /*