Update netRadiant source

[voretournament/voretournament.git] / misc / source / netradiant-src / tools / quake3 / q3map2 / shaders.c

diff --git a/misc/source/netradiant-src/tools/quake3/q3map2/shaders.c b/misc/source/netradiant-src/tools/quake3/q3map2/shaders.c
index dcbf79d2c99b088129cf7ed3ee5ed3f48179a1f9..11b9d6183a68169852196ad40f686152ab9257d8 100644 (file)
--- a/misc/source/netradiant-src/tools/quake3/q3map2/shaders.c
+++ b/misc/source/netradiant-src/tools/quake3/q3map2/shaders.c
@@ -827,6 +827,13 @@ finds a shaderinfo for a named shader
 
 #define MAX_SHADER_DEPRECATION_DEPTH 16
 
+shaderInfo_t *ShaderInfoForShaderNull( const char *shaderName )
+{
+       if(!strcmp(shaderName, "noshader"))
+               return NULL;
+       return ShaderInfoForShader(shaderName);
+}
+
 shaderInfo_t *ShaderInfoForShader( const char *shaderName )
 {
        int                             i;
@@ -1293,9 +1300,16 @@ static void ParseShaderFile( const char *filename )
                                sun->color[ 1 ] = atof( token );
                                GetTokenAppend( shaderText, qfalse );
                                sun->color[ 2 ] = atof( token );
+
+                               if(colorsRGB)
+                               {
+                                       sun->color[0] = Image_LinearFloatFromsRGBFloat(sun->color[0]);
+                                       sun->color[1] = Image_LinearFloatFromsRGBFloat(sun->color[1]);
+                                       sun->color[2] = Image_LinearFloatFromsRGBFloat(sun->color[2]);
+                               }
                                
                                /* normalize it */
-                               VectorNormalize( sun->color, sun->color );
+                               ColorNormalize( sun->color, sun->color );
                                
                                /* scale color by brightness */
                                GetTokenAppend( shaderText, qfalse );
@@ -1485,6 +1499,12 @@ static void ParseShaderFile( const char *filename )
                                        si->color[ 1 ] = atof( token );
                                        GetTokenAppend( shaderText, qfalse );
                                        si->color[ 2 ] = atof( token );
+                                       if(colorsRGB)
+                                       {
+                                               si->color[0] = Image_LinearFloatFromsRGBFloat(si->color[0]);
+                                               si->color[1] = Image_LinearFloatFromsRGBFloat(si->color[1]);
+                                               si->color[2] = Image_LinearFloatFromsRGBFloat(si->color[2]);
+                                       }
                                        ColorNormalize( si->color, si->color );
                                }
                                
@@ -1520,6 +1540,13 @@ static void ParseShaderFile( const char *filename )
                                        si->floodlightIntensity = atof( token ); 
                                        GetTokenAppend( shaderText, qfalse );
                                        si->floodlightDirectionScale = atof( token ); 
+                                       if(colorsRGB)
+                                       {
+                                               si->floodlightRGB[0] = Image_LinearFloatFromsRGBFloat(si->floodlightRGB[0]);
+                                               si->floodlightRGB[1] = Image_LinearFloatFromsRGBFloat(si->floodlightRGB[1]);
+                                               si->floodlightRGB[2] = Image_LinearFloatFromsRGBFloat(si->floodlightRGB[2]);
+                                       }
+                                       ColorNormalize(si->floodlightRGB, si->floodlightRGB);
                                }
 
                                /* jal: q3map_nodirty : skip dirty */
@@ -1799,6 +1826,12 @@ static void ParseShaderFile( const char *filename )
                                        {
                                                cm->type = CM_COLOR_SET;
                                                Parse1DMatrixAppend( shaderText, 3, cm->data );
+                                               if(colorsRGB)
+                                               {
+                                                       cm->data[0] = Image_LinearFloatFromsRGBFloat(cm->data[0]);
+                                                       cm->data[1] = Image_LinearFloatFromsRGBFloat(cm->data[1]);
+                                                       cm->data[2] = Image_LinearFloatFromsRGBFloat(cm->data[2]);
+                                               }
                                        }
                                        
                                        /* alpha scale A */