Merge remote branch 'icculus/master'
authorRudolf Polzer <divverent@alientrap.org>
Sun, 25 Jul 2010 15:13:35 +0000 (17:13 +0200)
committerRudolf Polzer <divverent@alientrap.org>
Sun, 25 Jul 2010 15:13:35 +0000 (17:13 +0200)
1  2 
tools/quake3/q3map2/light.c

index aaaa224762580ef5772e475bad0fc17198fe1737,dee882eed1402ed1248a80250719d7d610aa83c9..977fa32f28fbbe4dae12893fec306c30fd81dacf
@@@ -749,8 -749,8 +749,8 @@@ int LightContributionToSample( trace_t 
        float                   angle;
        float                   add;
        float                   dist;
 -      float                   addDeluxe = 0.0f, addDeluxeBounceScale = 0.25f;\r
 -      qboolean                angledDeluxe = qfalse;\r
 +      float                   addDeluxe = 0.0f, addDeluxeBounceScale = 0.25f;
 +      qboolean                angledDeluxe = qfalse;
        float                   colorBrightness;
        
        /* get light */
        /* clear color */
        VectorClear( trace->color );
        VectorClear( trace->colorNoShadow );
 -      VectorClear( trace->directionContribution );\r
 -\r
 +      VectorClear( trace->directionContribution );
 +
        colorBrightness = RGBTOGRAY( light->color ) * ( 1.0f/255.0f );
        
        /* ydnar: early out */
  
                        add = light->photons / (dist * dist) * angle;
  
 -                      if( deluxemap )\r
 -                      {\r
 -                              if( angledDeluxe )\r
 -                                      addDeluxe = light->photons / (dist * dist) * angle;\r
 -                              else\r
 -                                      addDeluxe = light->photons / (dist * dist);\r
 +                      if( deluxemap )
 +                      {
 +                              if( angledDeluxe )
 +                                      addDeluxe = light->photons / (dist * dist) * angle;
 +                              else
 +                                      addDeluxe = light->photons / (dist * dist);
                        }
                }
                else
                        /* ydnar: moved to here */
                        add = factor * light->add;
  
 -                      if( deluxemap )\r
 +                      if( deluxemap )
                                addDeluxe = add;
                }
        }
                        if( add < 0.0f )
                                add = 0.0f;
  
 -                      if( deluxemap )\r
 -                      {\r
 -                              if( angledDeluxe )\r
 -                                      addDeluxe = angle * light->photons * linearScale - (dist * light->fade);\r
 -                              else\r
 -                                      addDeluxe = light->photons * linearScale - (dist * light->fade);\r
 -\r
 -                              if( addDeluxe < 0.0f )\r
 -                                      addDeluxe = 0.0f;\r
 +                      if( deluxemap )
 +                      {
 +                              if( angledDeluxe )
 +                                      addDeluxe = angle * light->photons * linearScale - (dist * light->fade);
 +                              else
 +                                      addDeluxe = light->photons * linearScale - (dist * light->fade);
 +
 +                              if( addDeluxe < 0.0f )
 +                                      addDeluxe = 0.0f;
                        }
                }
                else
                {
                        add = (light->photons / (dist * dist)) * angle;
 -                      if( add < 0.0f )\r
 -                              add = 0.0f;\r
 -\r
 -                      if( deluxemap )\r
 -                      {\r
 -                              if( angledDeluxe )\r
 -                                      addDeluxe = (light->photons / (dist * dist)) * angle;\r
 -                              else\r
 -                                      addDeluxe = (light->photons / (dist * dist));\r
 -                      }\r
 -\r
 -                      if( addDeluxe < 0.0f )\r
 +                      if( add < 0.0f )
 +                              add = 0.0f;
 +
 +                      if( deluxemap )
 +                      {
 +                              if( angledDeluxe )
 +                                      addDeluxe = (light->photons / (dist * dist)) * angle;
 +                              else
 +                                      addDeluxe = (light->photons / (dist * dist));
 +                      }
 +
 +                      if( addDeluxe < 0.0f )
                                addDeluxe = 0.0f;
                }
                
                        if( sampleRadius > (radiusAtDist - 32.0f) )
                        {
                                add *= ((radiusAtDist - sampleRadius) / 32.0f);
 -                              if( add < 0.0f )\r
 -                                      add = 0.0f;\r
 -\r
 -                              addDeluxe *= ((radiusAtDist - sampleRadius) / 32.0f);\r
 -\r
 -                              if( addDeluxe < 0.0f )\r
 +                              if( add < 0.0f )
 +                                      add = 0.0f;
 +
 +                              addDeluxe *= ((radiusAtDist - sampleRadius) / 32.0f);
 +
 +                              if( addDeluxe < 0.0f )
                                        addDeluxe = 0.0f;
                        }
                }
                /* attenuate */
                add = light->photons * angle;
  
 -              if( deluxemap )\r
 -              {\r
 -                      if( angledDeluxe )\r
 -                              addDeluxe = light->photons * angle;\r
 -                      else\r
 -                              addDeluxe = light->photons;\r
 -\r
 -                      if( addDeluxe < 0.0f )\r
 -                              addDeluxe = 0.0f;\r
 +              if( deluxemap )
 +              {
 +                      if( angledDeluxe )
 +                              addDeluxe = light->photons * angle;
 +                      else
 +                              addDeluxe = light->photons;
 +
 +                      if( addDeluxe < 0.0f )
 +                              addDeluxe = 0.0f;
                }
  
                if( add <= 0.0f )
                /* VorteX: set noShadow color */
                VectorScale(light->color, add, trace->colorNoShadow);
  
 -              addDeluxe *= colorBrightness;\r
 -\r
 -              if( bouncing )\r
 -              {\r
 -                      addDeluxe *= addDeluxeBounceScale;\r
 -                      if( addDeluxe < 0.00390625f )\r
 -                              addDeluxe = 0.00390625f;\r
 -              }\r
 -\r
 +              addDeluxe *= colorBrightness;
 +
 +              if( bouncing )
 +              {
 +                      addDeluxe *= addDeluxeBounceScale;
 +                      if( addDeluxe < 0.00390625f )
 +                              addDeluxe = 0.00390625f;
 +              }
 +
                VectorScale( trace->direction, addDeluxe, trace->directionContribution );
                
                /* setup trace */
        if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
                return 0;
  
 -      addDeluxe *= colorBrightness;\r
 -\r
 -      /* hack land: scale down the radiosity contribution to light directionality.\r
 -      Deluxemaps fusion many light directions into one. In a rtl process all lights\r
 -      would contribute individually to the bump map, so several light sources together\r
 -      would make it more directional (example: a yellow and red lights received from\r
 -      opposing sides would light one side in red and the other in blue, adding\r
 -      the effect of 2 directions applied. In the deluxemapping case, this 2 lights would\r
 -      neutralize each other making it look like having no direction.\r
 -      Same thing happens with radiosity. In deluxemapping case the radiosity contribution\r
 -      is modifying the direction applied from directional lights, making it go closer and closer\r
 -      to the surface normal the bigger is the amount of radiosity received.\r
 -      So, for preserving the directional lights contributions, we scale down the radiosity\r
 -      contribution. It's a hack, but there's a reason behind it */\r
 -      if( bouncing )\r
 -      {\r
 -              addDeluxe *= addDeluxeBounceScale;\r
 -              if( addDeluxe < 0.00390625f )\r
 -                      addDeluxe = 0.00390625f;\r
 -      }\r
 -\r
 +      addDeluxe *= colorBrightness;
 +
 +      /* hack land: scale down the radiosity contribution to light directionality.
 +      Deluxemaps fusion many light directions into one. In a rtl process all lights
 +      would contribute individually to the bump map, so several light sources together
 +      would make it more directional (example: a yellow and red lights received from
 +      opposing sides would light one side in red and the other in blue, adding
 +      the effect of 2 directions applied. In the deluxemapping case, this 2 lights would
 +      neutralize each other making it look like having no direction.
 +      Same thing happens with radiosity. In deluxemapping case the radiosity contribution
 +      is modifying the direction applied from directional lights, making it go closer and closer
 +      to the surface normal the bigger is the amount of radiosity received.
 +      So, for preserving the directional lights contributions, we scale down the radiosity
 +      contribution. It's a hack, but there's a reason behind it */
 +      if( bouncing )
 +      {
 +              addDeluxe *= addDeluxeBounceScale;
 +              if( addDeluxe < 0.00390625f )
 +                      addDeluxe = 0.00390625f;
 +      }
 +
        VectorScale( trace->direction, addDeluxe, trace->directionContribution );
        
        /* setup trace */
        if( trace->passSolid || trace->opaque )
        {
                VectorClear( trace->color );
 -              VectorClear( trace->directionContribution );\r
 +              VectorClear( trace->directionContribution );
  
                return -1;
        }
@@@ -1421,6 -1421,7 +1421,7 @@@ typedef struc
  {
        vec3_t          dir;
        vec3_t          color;
+       vec3_t          ambient;
        int                     style;
  }
  contribution_t;
@@@ -1514,6 -1515,7 +1515,7 @@@ void TraceGrid( int num 
                /* add a contribution */
                VectorCopy( trace.color, contributions[ numCon ].color );
                VectorCopy( trace.direction, contributions[ numCon ].dir );
+               VectorClear( contributions[ numCon ].ambient );
                contributions[ numCon ].style = trace.light->style;
                numCon++;
                
        
        /////// Floodlighting for point //////////////////
        //do our floodlight ambient occlusion loop, and add a single contribution based on the brightest dir
-       if (floodlighty)
-       {
-               int q;
-               float addSize,f;
-               vec3_t col,dir;
-               col[0]=col[1]=col[2]=floodlightIntensity;
-               dir[0]=dir[1]=0;
-               dir[2]=1;
-               trace.testOcclusion = qtrue;
-               trace.forceSunlight = qfalse;
-               trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;
-               trace.testAll = qtrue;
-               for (q=0;q<2;q++)
-               {
-                       if (q==0) //upper hemisphere
-                       {
-                               trace.normal[0]=0;
-                               trace.normal[1]=0;
-                               trace.normal[2]=1;
-                       }
-                       else //lower hemisphere
-                       {
-                               trace.normal[0]=0;
-                               trace.normal[1]=0;
-                               trace.normal[2]=-1;
-                       }
-                       f = FloodLightForSample(&trace, floodlightDistance, floodlight_lowquality);
-                       contributions[ numCon ].color[0]=col[0]*f;
-                       contributions[ numCon ].color[1]=col[1]*f;
-                       contributions[ numCon ].color[2]=col[2]*f;
-                       contributions[ numCon ].dir[0]=dir[0];
-                       contributions[ numCon ].dir[1]=dir[1];
-                       contributions[ numCon ].dir[2]=dir[2];
-                       contributions[ numCon ].style = 0;
-                       numCon++;
-                       /* push average direction around */
-                       addSize = VectorLength( col );
-                       VectorMA( gp->dir, addSize, dir, gp->dir );
-               }
+       if( floodlighty )\r
+       {\r
+               int k;\r
+               float addSize, f;\r
+               vec3_t dir = { 0, 0, 1 };\r
+               float ambientFrac = 0.25f;\r
\r
+               trace.testOcclusion = qtrue;\r
+               trace.forceSunlight = qfalse;\r
+               trace.inhibitRadius = DEFAULT_INHIBIT_RADIUS;\r
+               trace.testAll = qtrue;\r
\r
+               for( k = 0; k < 2; k++ )\r
+               {\r
+                       if( k == 0 ) // upper hemisphere\r
+                       {\r
+                               trace.normal[0] = 0;\r
+                               trace.normal[1] = 0;\r
+                               trace.normal[2] = 1;\r
+                       }\r
+                       else //lower hemisphere\r
+                       {\r
+                               trace.normal[0] = 0;\r
+                               trace.normal[1] = 0;\r
+                               trace.normal[2] = -1;\r
+                       }\r
\r
+                       f = FloodLightForSample( &trace, floodlightDistance, floodlight_lowquality );\r
\r
+                       /* add a fraction as pure ambient, half as top-down direction */\r
+                       contributions[ numCon ].color[0]= floodlightRGB[0] * floodlightIntensity * f * ( 1.0f - ambientFrac );\r
+                       contributions[ numCon ].color[1]= floodlightRGB[1] * floodlightIntensity * f * ( 1.0f - ambientFrac );\r
+                       contributions[ numCon ].color[2]= floodlightRGB[2] * floodlightIntensity * f * ( 1.0f - ambientFrac );\r
\r
+                       contributions[ numCon ].ambient[0]= floodlightRGB[0] * floodlightIntensity * f * ambientFrac;\r
+                       contributions[ numCon ].ambient[1]= floodlightRGB[1] * floodlightIntensity * f * ambientFrac;\r
+                       contributions[ numCon ].ambient[2]= floodlightRGB[2] * floodlightIntensity * f * ambientFrac;\r
\r
+                       contributions[ numCon ].dir[0] = dir[0];\r
+                       contributions[ numCon ].dir[1] = dir[1];\r
+                       contributions[ numCon ].dir[2] = dir[2];\r
\r
+                       contributions[ numCon ].style = 0;\r
\r
+                       /* push average direction around */\r
+                       addSize = VectorLength( contributions[ numCon ].color );\r
+                       VectorMA( gp->dir, addSize, dir, gp->dir );\r
\r
+                       numCon++;\r
+               }\r
        }
        /////////////////////
  
                d = 0.25f * (1.0f - d);
                VectorMA( gp->ambient[ j ], d, contributions[ i ].color, gp->ambient[ j ] );
  
+               VectorAdd( gp->ambient[ j ], contributions[ i ].ambient, gp->ambient[ j ] );
  /*
   * div0:
   * the total light average = ambient value + 0.25 * sum of all directional values