qcsrc/server/radarmap.qc

   1 // ===============================================
   2 //      Generates radar map images for use in the HUD
   3 // ===============================================
   4
   5 entity radarmapper;
   6
   7 float RADAR_WIDTH_MAX = 512;
   8 float RADAR_HEIGHT_MAX = 512;
   9 float sharpen_buffer[RADAR_WIDTH_MAX * 3];
  10 string doublehex = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFFFF";
  11 // FF is contained twice, to map 256 to FF too
  12 // removes the need to bound()
  13
  14 float FullTraceFraction(vector a, vector mi, vector ma, vector b)
  15 {
  16         vector c;
  17         float white, black;
  18
  19         white = 0.001;
  20         black = 0.001;
  21
  22         c = a;
  23
  24         float n, m;
  25         n = m = 0;
  26
  27         while(vlen(c - b) > 1)
  28         {
  29                 ++m;
  30
  31                 tracebox(c, mi, ma, b, MOVE_WORLDONLY, world);
  32                 ++n;
  33
  34                 if(!trace_startsolid)
  35                 {
  36                         black += vlen(trace_endpos - c);
  37                         c = trace_endpos;
  38                 }
  39
  40                 n += tracebox_inverted(c, mi, ma, b, MOVE_WORLDONLY, world);
  41
  42                 white += vlen(trace_endpos - c);
  43                 c = trace_endpos;
  44         }
  45
  46         if(n > 200)
  47                 dprint("HOLY SHIT! FullTraceFraction: ", ftos(n), " total traces, ", ftos(m), " iterations\n");
  48
  49         return white / (black + white);
  50 }
  51 float RadarMapAtPoint_Trace(float x, float y, float w, float h, float zmin, float zsize, float q)
  52 {
  53         vector a, b, mi, ma;
  54
  55         mi = '0 0 0';
  56         ma = '1 0 0' * w + '0 1 0' * h;
  57         a = '1 0 0' * x + '0 1 0' * y + '0 0 1' * zmin;
  58         b = '1 0 0' * x + '0 1 0' * y + '0 0 1' * (zsize + zmin);
  59
  60         return FullTraceFraction(a, mi, ma, b);
  61 }
  62 float RadarMapAtPoint_LineBlock(float x, float y, float w, float h, float zmin, float zsize, float q)
  63 {
  64         vector o, mi, ma;
  65         float i, r;
  66         vector dz;
  67
  68         q = 256 * q - 1;
  69         // 256q-1 is the ideal sample count to map equal amount of sample values to one pixel value
  70
  71         mi = '0 0 0';
  72         dz = (zsize / q) * '0 0 1';
  73         ma = '1 0 0' * w + '0 1 0' * h + dz;
  74         o = '1 0 0' * x + '0 1 0' * y + '0 0 1' * zmin;
  75
  76         if(x < world.absmin_x - w)
  77                 return 0;
  78         if(y < world.absmin_y - h)
  79                 return 0;
  80         if(x > world.absmax_x)
  81                 return 0;
  82         if(y > world.absmax_y)
  83                 return 0;
  84
  85         r = 0;
  86         for(i = 0; i < q; ++i)
  87         {
  88                 vector v1, v2;
  89                 v1 = v2 = o + dz * i + mi;
  90                 v1_x += random() * (ma_x - mi_x);
  91                 v1_y += random() * (ma_y - mi_y);
  92                 v1_z += random() * (ma_z - mi_z);
  93                 v2_x += random() * (ma_x - mi_x);
  94                 v2_y += random() * (ma_y - mi_y);
  95                 v2_z += random() * (ma_z - mi_z);
  96                 traceline(v1, v2, MOVE_WORLDONLY, world);
  97                 if(trace_startsolid || trace_fraction < 1)
  98                         ++r;
  99         }
 100         return r / q;
 101 }
 102 float RadarMapAtPoint_Block(float x, float y, float w, float h, float zmin, float zsize, float q)
 103 {
 104         vector o, mi, ma;
 105         float i, r;
 106         vector dz;
 107
 108         q = 256 * q - 1;
 109         // 256q-1 is the ideal sample count to map equal amount of sample values to one pixel value
 110
 111         mi = '0 0 0';
 112         dz = (zsize / q) * '0 0 1';
 113         ma = '1 0 0' * w + '0 1 0' * h + dz;
 114         o = '1 0 0' * x + '0 1 0' * y + '0 0 1' * zmin;
 115
 116         if(x < world.absmin_x - w)
 117                 return 0;
 118         if(y < world.absmin_y - h)
 119                 return 0;
 120         if(x > world.absmax_x)
 121                 return 0;
 122         if(y > world.absmax_y)
 123                 return 0;
 124
 125         r = 0;
 126         for(i = 0; i < q; ++i)
 127         {
 128                 tracebox(o + dz * i, mi, ma, o + dz * i, MOVE_WORLDONLY, world);
 129                 if(trace_startsolid)
 130                         ++r;
 131         }
 132         return r / q;
 133 }
 134 float RadarMapAtPoint_Sample(float x, float y, float w, float h, float zmin, float zsize, float q)
 135 {
 136         vector a, b, mi, ma;
 137
 138         q *= 4; // choose q so it matches the regular algorithm in speed
 139
 140         q = 256 * q - 1;
 141         // 256q-1 is the ideal sample count to map equal amount of sample values to one pixel value
 142
 143         mi = '0 0 0';
 144         ma = '1 0 0' * w + '0 1 0' * h;
 145         a = '1 0 0' * x + '0 1 0' * y + '0 0 1' * zmin;
 146         b = '1 0 0' * w + '0 1 0' * h + '0 0 1' * zsize;
 147
 148         float c, i;
 149         c = 0;
 150
 151         for(i = 0; i < q; ++i)
 152         {
 153                 vector v;
 154                 v_x = a_x + random() * b_x;
 155                 v_y = a_y + random() * b_y;
 156                 v_z = a_z + random() * b_z;
 157                 traceline(v, v, MOVE_WORLDONLY, world);
 158                 if(trace_startsolid)
 159                         ++c;
 160         }
 161
 162         return c / q;
 163 }
 164 void sharpen_set(float x, float v)
 165 {
 166         sharpen_buffer[x + 2 * RADAR_WIDTH_MAX] = v;
 167 }
 168 float sharpen_getpixel(float x, float y)
 169 {
 170         if(x < 0)
 171                 return 0;
 172         if(x >= RADAR_WIDTH_MAX)
 173                 return 0;
 174         if(y < 0)
 175                 return 0;
 176         if(y > 2)
 177                 return 0;
 178         return sharpen_buffer[x + y * RADAR_WIDTH_MAX];
 179 }
 180 float sharpen_get(float x, float a)
 181 {
 182         float sum;
 183         sum = sharpen_getpixel(x, 1);
 184         if(a == 0)
 185                 return sum;
 186         sum *= (8 + 1/a);
 187         sum -= sharpen_getpixel(x - 1, 0);
 188         sum -= sharpen_getpixel(x - 1, 1);
 189         sum -= sharpen_getpixel(x - 1, 2);
 190         sum -= sharpen_getpixel(x + 1, 0);
 191         sum -= sharpen_getpixel(x + 1, 1);
 192         sum -= sharpen_getpixel(x + 1, 2);
 193         sum -= sharpen_getpixel(x, 0);
 194         sum -= sharpen_getpixel(x, 2);
 195         return bound(0, sum * a, 1);
 196 }
 197 void sharpen_shift(float w)
 198 {
 199         float i;
 200         for(i = 0; i < w; ++i)
 201         {
 202                 sharpen_buffer[i] = sharpen_buffer[i + RADAR_WIDTH_MAX];
 203                 sharpen_buffer[i + RADAR_WIDTH_MAX] = sharpen_buffer[i + 2 * RADAR_WIDTH_MAX];
 204                 sharpen_buffer[i + 2 * RADAR_WIDTH_MAX] = 0;
 205         }
 206 }
 207 void sharpen_init(float w)
 208 {
 209         float i;
 210         for(i = 0; i < w; ++i)
 211         {
 212                 sharpen_buffer[i] = 0;
 213                 sharpen_buffer[i + RADAR_WIDTH_MAX] = 0;
 214                 sharpen_buffer[i + 2 * RADAR_WIDTH_MAX] = 0;
 215         }
 216 }
 217 void RadarMap_Next()
 218 {
 219         if(radarmapper.count & 4)
 220         {
 221                 localcmd("quit\n");
 222         }
 223         else if(radarmapper.count & 2)
 224         {
 225                 localcmd(strcat("defer 1 \"sv_cmd radarmap --flags ", ftos(radarmapper.count), strcat(" --res ", ftos(radarmapper.size_x), " ", ftos(radarmapper.size_y), " --sharpen ", ftos(radarmapper.ltime), " --qual ", ftos(radarmapper.size_z)), "\"\n"));
 226                 GotoNextMap();
 227         }
 228         remove(radarmapper);
 229         radarmapper = world;
 230 }
 231 void RadarMap_Think()
 232 {
 233         // rough map entity
 234         //   cnt: current line
 235         //   size: pixel width/height
 236         //   maxs: cell width/height
 237         //   frame: counter
 238
 239         float i, x, l;
 240         string si;
 241
 242         if(self.frame == 0)
 243         {
 244                 // initialize
 245                 get_mi_min_max_texcoords(1);
 246                 self.mins = mi_picmin;
 247                 self.maxs_x = (mi_picmax_x - mi_picmin_x) / self.size_x;
 248                 self.maxs_y = (mi_picmax_y - mi_picmin_y) / self.size_y;
 249                 self.maxs_z = mi_max_z - mi_min_z;
 250                 print("Picture mins/maxs: ", ftos(self.maxs_x), " and ", ftos(self.maxs_y), " should match\n");
 251                 self.netname = strzone(strcat("gfx/", mi_shortname, "_radar.xpm"));
 252                 if(!(self.count & 1))
 253                 {
 254                         self.cnt = fopen(self.netname, FILE_READ);
 255                         if(self.cnt < 0)
 256                                 self.cnt = fopen(strcat("gfx/", mi_shortname, "_radar.tga"), FILE_READ);
 257                         if(self.cnt < 0)
 258                                 self.cnt = fopen(strcat("gfx/", mi_shortname, "_radar.png"), FILE_READ);
 259                         if(self.cnt < 0)
 260                                 self.cnt = fopen(strcat("gfx/", mi_shortname, "_radar.jpg"), FILE_READ);
 261                         if(self.cnt < 0)
 262                                 self.cnt = fopen(strcat("gfx/", mi_shortname, "_mini.tga"), FILE_READ);
 263                         if(self.cnt < 0)
 264                                 self.cnt = fopen(strcat("gfx/", mi_shortname, "_mini.png"), FILE_READ);
 265                         if(self.cnt < 0)
 266                                 self.cnt = fopen(strcat("gfx/", mi_shortname, "_mini.jpg"), FILE_READ);
 267                         if(self.cnt >= 0)
 268                         {
 269                                 fclose(self.cnt);
 270
 271                                 print(self.netname, " already exists, aborting (you may want to specify --force)\n");
 272                                 RadarMap_Next();
 273                                 return;
 274                         }
 275                 }
 276                 self.cnt = fopen(self.netname, FILE_WRITE);
 277                 if(self.cnt < 0)
 278                 {
 279                         print("Error writing ", self.netname, "\n");
 280                         remove(self);
 281                         radarmapper = world;
 282                         return;
 283                 }
 284                 print("Writing to ", self.netname, "...\n");
 285                 fputs(self.cnt, "/* XPM */\n");
 286                 fputs(self.cnt, "static char *RadarMap[] = {\n");
 287                 fputs(self.cnt, "/* columns rows colors chars-per-pixel */\n");
 288                 fputs(self.cnt, strcat("\"", ftos(self.size_x), " ", ftos(self.size_y), " 256 2\",\n"));
 289                 for(i = 0; i < 256; ++i)
 290                 {
 291                         si = substring(doublehex, i*2, 2);
 292                         fputs(self.cnt, strcat("\"", si, " c #", si, si, si, "\",\n"));
 293                 }
 294                 self.frame += 1;
 295                 self.nextthink = time;
 296                 sharpen_init(self.size_x);
 297         }
 298         else if(self.frame <= self.size_y)
 299         {
 300                 // fill the sharpen buffer with this line
 301                 sharpen_shift(self.size_x);
 302                 i = self.count & 24;
 303
 304                 switch(i)
 305                 {
 306                         case 0:
 307                         default:
 308                                 for(x = 0; x < self.size_x; ++x)
 309                                 {
 310                                         l = RadarMapAtPoint_Block(self.mins_x + x * self.maxs_x, self.mins_y + (self.size_y - self.frame) * self.maxs_y, self.maxs_x, self.maxs_y, self.mins_z, self.maxs_z, self.size_z);
 311                                         sharpen_set(x, l);
 312                                 }
 313                                 break;
 314                         case 8:
 315                                 for(x = 0; x < self.size_x; ++x)
 316                                 {
 317                                         l = RadarMapAtPoint_Trace(self.mins_x + x * self.maxs_x, self.mins_y + (self.size_y - self.frame) * self.maxs_y, self.maxs_x, self.maxs_y, self.mins_z, self.maxs_z, self.size_z);
 318                                         sharpen_set(x, l);
 319                                 }
 320                                 break;
 321                         case 16:
 322                                 for(x = 0; x < self.size_x; ++x)
 323                                 {
 324                                         l = RadarMapAtPoint_Sample(self.mins_x + x * self.maxs_x, self.mins_y + (self.size_y - self.frame) * self.maxs_y, self.maxs_x, self.maxs_y, self.mins_z, self.maxs_z, self.size_z);
 325                                         sharpen_set(x, l);
 326                                 }
 327                                 break;
 328                         case 24:
 329                                 for(x = 0; x < self.size_x; ++x)
 330                                 {
 331                                         l = RadarMapAtPoint_LineBlock(self.mins_x + x * self.maxs_x, self.mins_y + (self.size_y - self.frame) * self.maxs_y, self.maxs_x, self.maxs_y, self.mins_z, self.maxs_z, self.size_z);
 332                                         sharpen_set(x, l);
 333                                 }
 334                                 break;
 335                 }
 336
 337                 // do we have enough lines?
 338                 if(self.frame >= 2)
 339                 {
 340                         // write a pixel line
 341                         fputs(self.cnt, "\"");
 342                         for(x = 0; x < self.size_x; ++x)
 343                         {
 344                                 l = sharpen_get(x, self.ltime);
 345                                 fputs(self.cnt, substring(doublehex, 2 * floor(l * 256.0), 2));
 346                         }
 347                         if(self.frame == self.size_y)
 348                                 fputs(self.cnt, "\"\n");
 349                         else
 350                         {
 351                                 fputs(self.cnt, "\",\n");
 352                                 print(ftos(self.size_y - self.frame), " lines left\n");
 353                         }
 354                 }
 355
 356                 // is this the last line? then write back the missing line
 357                 if(self.frame == self.size_y)
 358                 {
 359                         sharpen_shift(self.size_x);
 360                         // write a pixel line
 361                         fputs(self.cnt, "\"");
 362                         for(x = 0; x < self.size_x; ++x)
 363                         {
 364                                 l = sharpen_get(x, self.ltime);
 365                                 fputs(self.cnt, substring(doublehex, 2 * floor(l * 256.0), 2));
 366                         }
 367                         if(self.frame == self.size_y)
 368                                 fputs(self.cnt, "\"\n");
 369                         else
 370                         {
 371                                 fputs(self.cnt, "\",\n");
 372                                 print(ftos(self.size_y - self.frame), " lines left\n");
 373                         }
 374                 }
 375
 376                 self.frame += 1;
 377                 self.nextthink = time;
 378         }
 379         else
 380         {
 381                 // close the file
 382                 fputs(self.cnt, "};\n");
 383                 fclose(self.cnt);
 384                 print("Finished. Please edit data/", self.netname, " with an image editing application and place it in the TGA format in the gfx folder.\n");
 385                 RadarMap_Next();
 386         }
 387 }
 388
 389 float RadarMap_Make(float argc)
 390 {
 391         float i;
 392
 393         if(!radarmapper)
 394         {
 395                 radarmapper = spawn();
 396                 radarmapper.classname = "radarmapper";
 397                 radarmapper.think = RadarMap_Think;
 398                 radarmapper.nextthink = time;
 399                 radarmapper.count = 8; // default to the --trace method, as it is faster now
 400                 radarmapper.ltime = 1;
 401                 radarmapper.size = '512 512 1';
 402                 for(i = 1; i < argc; ++i)
 403                 {
 404                         switch(argv(i))
 405                         {
 406                                 case "--force": { radarmapper.count |= 1; break; }
 407                                 case "--loop": { radarmapper.count |= 2; break; }
 408                                 case "--quit": { radarmapper.count |= 4; break; }
 409                                 case "--block": { radarmapper.count &~= 24; break; }
 410                                 case "--trace": { radarmapper.count &~= 24; radarmapper.count |= 8; break; }
 411                                 case "--sample": { radarmapper.count &~= 24; radarmapper.count |= 16; break; }
 412                                 case "--lineblock": { radarmapper.count |= 24; break; }
 413                                 case "--flags": { ++i; radarmapper.count = stof(argv(i)); break; } // for the recursive call
 414                                 case "--sharpen": { ++i; radarmapper.ltime = stof(argv(i)); break; } // for the recursive call
 415                                 case "--res": // minor alias
 416                                 case "--resolution": { ++i; radarmapper.size_x = stof(argv(i)); ++i; radarmapper.size_y = stof(argv(i)); break; }
 417                                 case "--qual": // minor alias
 418                                 case "--quality": { ++i; radarmapper.size_z = stof(argv(i)); break; }
 419
 420                                 default:
 421                                         i = argc;
 422                                         remove(radarmapper);
 423                                         radarmapper = world;
 424                                         break;
 425                         }
 426                 }
 427
 428                 if(radarmapper) // after doing the arguments, see if we successfully went forward.
 429                 {
 430                         print("Radarmap entity spawned.\n");
 431                         return TRUE; // if so, don't print usage.
 432                 }
 433         }
 434
 435         return FALSE;
 436 }