tools/quake2/qdata/tables.c

   1 #include "qdata.h"
   2
   3 /*
   4 =============================================================================
   5
   6 ALPHALIGHT GENERATION
   7
   8 Find alphamap values that best match modulated lightmap values
   9
  10 This isn't used anymore, but I'm keeping it around...
  11 =============================================================================
  12 */
  13
  14 unsigned short  alphamap[32*32*32];
  15 unsigned char   inverse16to8table[65536];
  16
  17 /*
  18 static int FindNearestColor( unsigned int color )
  19 {
  20         int i;
  21         int closest_so_far = 0;
  22         float closest_distance_so_far = 100000000;
  23         float d;
  24         float r[2], g[2], b[2];
  25
  26         // incoming color is assumed to be in 0xRRGGBB format
  27         r[0] = ( color & 31 ) << 3;
  28         g[0] = ( ( color >> 5 ) & 63 ) << 2;
  29         b[0] = ( ( color >> 11 ) & 31 ) << 3;
  30
  31         for ( i = 0; i < 256; i++ )
  32         {
  33                 r[1] = ( d_8to24table[i] >> 0 ) & 0xFF;
  34                 g[1] = ( d_8to24table[i] >> 8 ) & 0xFF;
  35                 b[1] = ( d_8to24table[i] >> 16 ) & 0xFF;
  36
  37                 d = ( r[1] - r[0] ) * ( r[1] - r[0] ) +
  38                         ( g[1] - g[0] ) * ( g[1] - g[0] ) +
  39                         ( b[1] - b[0] ) * ( b[1] - b[0] );
  40
  41                 if ( d < closest_distance_so_far )
  42                 {
  43                         closest_distance_so_far = d;
  44                         closest_so_far = i;
  45                 }
  46         }
  47
  48         return closest_so_far;
  49 }
  50 */
  51
  52 extern byte BestColor( int, int, int, int, int );
  53
  54 void Inverse16_BuildTable( void )
  55 {
  56         int i;
  57
  58         /*
  59         ** create the 16-to-8 table
  60         */
  61         for ( i = 0; i < 65536; i++ )
  62         {
  63                 int r = i & 31;
  64                 int g = ( i >> 5 ) & 63;
  65                 int b = ( i >> 11 ) & 31;
  66
  67                 r <<= 3;
  68                 g <<= 2;
  69                 b <<= 3;
  70
  71                 inverse16to8table[i] = BestColor( r, g, b, 0, 255 );
  72         }
  73 }
  74
  75 void Alphalight_Thread (int i)
  76 {
  77         int             j;
  78         float   r, g, b;
  79         float   mr, mg, mb, ma;
  80         float   distortion, bestdistortion;
  81         float   v;
  82
  83         r = (i>>10) * (1.0/16);
  84         g = ((i>>5)&31)  * (1.0/16);
  85         b = (i&31) * (1.0/16);
  86
  87         bestdistortion = 999999;
  88         for (j=0 ; j<16*16*16*16 ; j++)
  89         {
  90                 mr = (j>>12) * (1.0/16);
  91                 mg = ((j>>8)&15) * (1.0/16);
  92                 mb = ((j>>4)&15) * (1.0/16);
  93                 ma = (j&15) * (1.0/16);
  94
  95                 v = r * 0.5 - (mr*ma + 0.5*(1.0-ma));
  96                 distortion = v*v;
  97                 v = g * 0.5 - (mg*ma + 0.5*(1.0-ma));
  98                 distortion += v*v;
  99                 v = b * 0.5 - (mb*ma + 0.5*(1.0-ma));
 100                 distortion += v*v;
 101
 102                 distortion *= 1.0 + ma*4;
 103
 104                 if (distortion < bestdistortion)
 105                 {
 106                         bestdistortion = distortion;
 107                         alphamap[i] = j;
 108                 }
 109         }
 110 }
 111
 112 void Cmd_Alphalight (void)
 113 {
 114         char    savename[1024];
 115
 116         GetToken (false);
 117
 118         if (g_release)
 119         {
 120                 ReleaseFile (token);
 121                 return;
 122         }
 123
 124         sprintf (savename, "%s%s", gamedir, token);
 125         printf ("Building alphalight table...\n");
 126
 127         RunThreadsOnIndividual (32*32*32, true, Alphalight_Thread);
 128
 129         SaveFile (savename, (byte *)alphamap, sizeof(alphamap));
 130 }
 131
 132
 133 void Cmd_Inverse16Table( void )
 134 {
 135         char savename[1024];
 136
 137         if ( g_release )
 138         {
 139                 sprintf (savename, "pics/16to8.dat");
 140                 ReleaseFile( savename );
 141                 return;
 142         }
 143
 144         sprintf (savename, "%spics/16to8.dat", gamedir);
 145         printf ("Building inverse 16-to-8 table...\n");
 146
 147         Inverse16_BuildTable();
 148
 149         SaveFile( savename, (byte *) inverse16to8table, sizeof( inverse16to8table ) );
 150 }