Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 5131 | clevermous | 1 | /* |
| 2 | Copyright (C) 1996-1997 Id Software, Inc. |
||
| 3 | |||
| 4 | This program is free software; you can redistribute it and/or |
||
| 5 | modify it under the terms of the GNU General Public License |
||
| 6 | as published by the Free Software Foundation; either version 2 |
||
| 7 | of the License, or (at your option) any later version. |
||
| 8 | |||
| 9 | This program is distributed in the hope that it will be useful, |
||
| 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
| 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
||
| 12 | |||
| 13 | See the GNU General Public License for more details. |
||
| 14 | |||
| 15 | You should have received a copy of the GNU General Public License |
||
| 16 | along with this program; if not, write to the Free Software |
||
| 17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
||
| 18 | |||
| 19 | */ |
||
| 20 | // r_misc.c |
||
| 21 | |||
| 22 | #include "quakedef.h" |
||
| 23 | |||
| 24 | |||
| 25 | |||
| 26 | /* |
||
| 27 | ================== |
||
| 28 | R_InitTextures |
||
| 29 | ================== |
||
| 30 | */ |
||
| 31 | void R_InitTextures (void) |
||
| 32 | { |
||
| 33 | int x,y, m; |
||
| 34 | byte *dest; |
||
| 35 | |||
| 36 | // create a simple checkerboard texture for the default |
||
| 37 | r_notexture_mip = Hunk_AllocName (sizeof(texture_t) + 16*16+8*8+4*4+2*2, "notexture"); |
||
| 38 | |||
| 39 | r_notexture_mip->width = r_notexture_mip->height = 16; |
||
| 40 | r_notexture_mip->offsets[0] = sizeof(texture_t); |
||
| 41 | r_notexture_mip->offsets[1] = r_notexture_mip->offsets[0] + 16*16; |
||
| 42 | r_notexture_mip->offsets[2] = r_notexture_mip->offsets[1] + 8*8; |
||
| 43 | r_notexture_mip->offsets[3] = r_notexture_mip->offsets[2] + 4*4; |
||
| 44 | |||
| 45 | for (m=0 ; m<4 ; m++) |
||
| 46 | { |
||
| 47 | dest = (byte *)r_notexture_mip + r_notexture_mip->offsets[m]; |
||
| 48 | for (y=0 ; y< (16>>m) ; y++) |
||
| 49 | for (x=0 ; x< (16>>m) ; x++) |
||
| 50 | { |
||
| 51 | if ( (y< (8>>m) ) ^ (x< (8>>m) ) ) |
||
| 52 | *dest++ = 0; |
||
| 53 | else |
||
| 54 | *dest++ = 0xff; |
||
| 55 | } |
||
| 56 | } |
||
| 57 | } |
||
| 58 | |||
| 59 | byte dottexture[8][8] = |
||
| 60 | { |
||
| 61 | {0,1,1,0,0,0,0,0}, |
||
| 62 | {1,1,1,1,0,0,0,0}, |
||
| 63 | {1,1,1,1,0,0,0,0}, |
||
| 64 | {0,1,1,0,0,0,0,0}, |
||
| 65 | {0,0,0,0,0,0,0,0}, |
||
| 66 | {0,0,0,0,0,0,0,0}, |
||
| 67 | {0,0,0,0,0,0,0,0}, |
||
| 68 | {0,0,0,0,0,0,0,0}, |
||
| 69 | }; |
||
| 70 | void R_InitParticleTexture (void) |
||
| 71 | { |
||
| 72 | int x,y; |
||
| 73 | byte data[8][8][4]; |
||
| 74 | |||
| 75 | // |
||
| 76 | // particle texture |
||
| 77 | // |
||
| 78 | particletexture = texture_extension_number++; |
||
| 79 | GL_Bind(particletexture); |
||
| 80 | |||
| 81 | for (x=0 ; x<8 ; x++) |
||
| 82 | { |
||
| 83 | for (y=0 ; y<8 ; y++) |
||
| 84 | { |
||
| 85 | data[y][x][0] = 255; |
||
| 86 | data[y][x][1] = 255; |
||
| 87 | data[y][x][2] = 255; |
||
| 88 | data[y][x][3] = dottexture[x][y]*255; |
||
| 89 | } |
||
| 90 | } |
||
| 91 | glTexImage2D (GL_TEXTURE_2D, 0, gl_alpha_format, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); |
||
| 92 | |||
| 93 | glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); |
||
| 94 | |||
| 95 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
||
| 96 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
||
| 97 | } |
||
| 98 | |||
| 99 | /* |
||
| 100 | =============== |
||
| 101 | R_Envmap_f |
||
| 102 | |||
| 103 | Grab six views for environment mapping tests |
||
| 104 | =============== |
||
| 105 | */ |
||
| 106 | void R_Envmap_f (void) |
||
| 107 | { |
||
| 108 | byte buffer[256*256*4]; |
||
| 109 | char name[1024]; |
||
| 110 | |||
| 111 | glDrawBuffer (GL_FRONT); |
||
| 112 | glReadBuffer (GL_FRONT); |
||
| 113 | envmap = true; |
||
| 114 | |||
| 115 | r_refdef.vrect.x = 0; |
||
| 116 | r_refdef.vrect.y = 0; |
||
| 117 | r_refdef.vrect.width = 256; |
||
| 118 | r_refdef.vrect.height = 256; |
||
| 119 | |||
| 120 | r_refdef.viewangles[0] = 0; |
||
| 121 | r_refdef.viewangles[1] = 0; |
||
| 122 | r_refdef.viewangles[2] = 0; |
||
| 123 | GL_BeginRendering (&glx, &gly, &glwidth, &glheight); |
||
| 124 | R_RenderView (); |
||
| 125 | glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
||
| 126 | COM_WriteFile ("env0.rgb", buffer, sizeof(buffer)); |
||
| 127 | |||
| 128 | r_refdef.viewangles[1] = 90; |
||
| 129 | GL_BeginRendering (&glx, &gly, &glwidth, &glheight); |
||
| 130 | R_RenderView (); |
||
| 131 | glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
||
| 132 | COM_WriteFile ("env1.rgb", buffer, sizeof(buffer)); |
||
| 133 | |||
| 134 | r_refdef.viewangles[1] = 180; |
||
| 135 | GL_BeginRendering (&glx, &gly, &glwidth, &glheight); |
||
| 136 | R_RenderView (); |
||
| 137 | glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
||
| 138 | COM_WriteFile ("env2.rgb", buffer, sizeof(buffer)); |
||
| 139 | |||
| 140 | r_refdef.viewangles[1] = 270; |
||
| 141 | GL_BeginRendering (&glx, &gly, &glwidth, &glheight); |
||
| 142 | R_RenderView (); |
||
| 143 | glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
||
| 144 | COM_WriteFile ("env3.rgb", buffer, sizeof(buffer)); |
||
| 145 | |||
| 146 | r_refdef.viewangles[0] = -90; |
||
| 147 | r_refdef.viewangles[1] = 0; |
||
| 148 | GL_BeginRendering (&glx, &gly, &glwidth, &glheight); |
||
| 149 | R_RenderView (); |
||
| 150 | glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
||
| 151 | COM_WriteFile ("env4.rgb", buffer, sizeof(buffer)); |
||
| 152 | |||
| 153 | r_refdef.viewangles[0] = 90; |
||
| 154 | r_refdef.viewangles[1] = 0; |
||
| 155 | GL_BeginRendering (&glx, &gly, &glwidth, &glheight); |
||
| 156 | R_RenderView (); |
||
| 157 | glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
||
| 158 | COM_WriteFile ("env5.rgb", buffer, sizeof(buffer)); |
||
| 159 | |||
| 160 | envmap = false; |
||
| 161 | glDrawBuffer (GL_BACK); |
||
| 162 | glReadBuffer (GL_BACK); |
||
| 163 | GL_EndRendering (); |
||
| 164 | } |
||
| 165 | |||
| 166 | /* |
||
| 167 | =============== |
||
| 168 | R_Init |
||
| 169 | =============== |
||
| 170 | */ |
||
| 171 | void R_Init (void) |
||
| 172 | { |
||
| 173 | extern byte *hunk_base; |
||
| 174 | extern cvar_t gl_finish; |
||
| 175 | |||
| 176 | Cmd_AddCommand ("timerefresh", R_TimeRefresh_f); |
||
| 177 | Cmd_AddCommand ("envmap", R_Envmap_f); |
||
| 178 | Cmd_AddCommand ("pointfile", R_ReadPointFile_f); |
||
| 179 | |||
| 180 | Cvar_RegisterVariable (&r_norefresh); |
||
| 181 | Cvar_RegisterVariable (&r_lightmap); |
||
| 182 | Cvar_RegisterVariable (&r_fullbright); |
||
| 183 | Cvar_RegisterVariable (&r_drawentities); |
||
| 184 | Cvar_RegisterVariable (&r_drawviewmodel); |
||
| 185 | Cvar_RegisterVariable (&r_shadows); |
||
| 186 | Cvar_RegisterVariable (&r_mirroralpha); |
||
| 187 | Cvar_RegisterVariable (&r_wateralpha); |
||
| 188 | Cvar_RegisterVariable (&r_dynamic); |
||
| 189 | Cvar_RegisterVariable (&r_novis); |
||
| 190 | Cvar_RegisterVariable (&r_speeds); |
||
| 191 | |||
| 192 | Cvar_RegisterVariable (&gl_finish); |
||
| 193 | Cvar_RegisterVariable (&gl_clear); |
||
| 194 | Cvar_RegisterVariable (&gl_texsort); |
||
| 195 | |||
| 196 | if (gl_mtexable) |
||
| 197 | Cvar_SetValue ("gl_texsort", 0.0); |
||
| 198 | |||
| 199 | Cvar_RegisterVariable (&gl_cull); |
||
| 200 | Cvar_RegisterVariable (&gl_smoothmodels); |
||
| 201 | Cvar_RegisterVariable (&gl_affinemodels); |
||
| 202 | Cvar_RegisterVariable (&gl_polyblend); |
||
| 203 | Cvar_RegisterVariable (&gl_flashblend); |
||
| 204 | Cvar_RegisterVariable (&gl_playermip); |
||
| 205 | Cvar_RegisterVariable (&gl_nocolors); |
||
| 206 | |||
| 207 | Cvar_RegisterVariable (&gl_keeptjunctions); |
||
| 208 | Cvar_RegisterVariable (&gl_reporttjunctions); |
||
| 209 | |||
| 210 | Cvar_RegisterVariable (&gl_doubleeyes); |
||
| 211 | |||
| 212 | R_InitParticles (); |
||
| 213 | R_InitParticleTexture (); |
||
| 214 | |||
| 215 | #ifdef GLTEST |
||
| 216 | Test_Init (); |
||
| 217 | #endif |
||
| 218 | |||
| 219 | playertextures = texture_extension_number; |
||
| 220 | texture_extension_number += 16; |
||
| 221 | } |
||
| 222 | |||
| 223 | /* |
||
| 224 | =============== |
||
| 225 | R_TranslatePlayerSkin |
||
| 226 | |||
| 227 | Translates a skin texture by the per-player color lookup |
||
| 228 | =============== |
||
| 229 | */ |
||
| 230 | void R_TranslatePlayerSkin (int playernum) |
||
| 231 | { |
||
| 232 | int top, bottom; |
||
| 233 | byte translate[256]; |
||
| 234 | unsigned translate32[256]; |
||
| 235 | int i, j, s; |
||
| 236 | model_t *model; |
||
| 237 | aliashdr_t *paliashdr; |
||
| 238 | byte *original; |
||
| 239 | unsigned pixels[512*256], *out; |
||
| 240 | unsigned scaled_width, scaled_height; |
||
| 241 | int inwidth, inheight; |
||
| 242 | byte *inrow; |
||
| 243 | unsigned frac, fracstep; |
||
| 244 | extern byte **player_8bit_texels_tbl; |
||
| 245 | |||
| 246 | GL_DisableMultitexture(); |
||
| 247 | |||
| 248 | top = cl.scores[playernum].colors & 0xf0; |
||
| 249 | bottom = (cl.scores[playernum].colors &15)<<4; |
||
| 250 | |||
| 251 | for (i=0 ; i<256 ; i++) |
||
| 252 | translate[i] = i; |
||
| 253 | |||
| 254 | for (i=0 ; i<16 ; i++) |
||
| 255 | { |
||
| 256 | if (top < 128) // the artists made some backwards ranges. sigh. |
||
| 257 | translate[TOP_RANGE+i] = top+i; |
||
| 258 | else |
||
| 259 | translate[TOP_RANGE+i] = top+15-i; |
||
| 260 | |||
| 261 | if (bottom < 128) |
||
| 262 | translate[BOTTOM_RANGE+i] = bottom+i; |
||
| 263 | else |
||
| 264 | translate[BOTTOM_RANGE+i] = bottom+15-i; |
||
| 265 | } |
||
| 266 | |||
| 267 | // |
||
| 268 | // locate the original skin pixels |
||
| 269 | // |
||
| 270 | currententity = &cl_entities[1+playernum]; |
||
| 271 | model = currententity->model; |
||
| 272 | if (!model) |
||
| 273 | return; // player doesn't have a model yet |
||
| 274 | if (model->type != mod_alias) |
||
| 275 | return; // only translate skins on alias models |
||
| 276 | |||
| 277 | paliashdr = (aliashdr_t *)Mod_Extradata (model); |
||
| 278 | s = paliashdr->skinwidth * paliashdr->skinheight; |
||
| 279 | if (currententity->skinnum < 0 || currententity->skinnum >= paliashdr->numskins) { |
||
| 280 | Con_Printf("(%d): Invalid player skin #%d\n", playernum, currententity->skinnum); |
||
| 281 | original = (byte *)paliashdr + paliashdr->texels[0]; |
||
| 282 | } else |
||
| 283 | original = (byte *)paliashdr + paliashdr->texels[currententity->skinnum]; |
||
| 284 | if (s & 3) |
||
| 285 | Sys_Error ("R_TranslateSkin: s&3"); |
||
| 286 | |||
| 287 | inwidth = paliashdr->skinwidth; |
||
| 288 | inheight = paliashdr->skinheight; |
||
| 289 | |||
| 290 | // because this happens during gameplay, do it fast |
||
| 291 | // instead of sending it through gl_upload 8 |
||
| 292 | GL_Bind(playertextures + playernum); |
||
| 293 | |||
| 294 | #if 0 |
||
| 295 | byte translated[320*200]; |
||
| 296 | |||
| 297 | for (i=0 ; i |
||
| 298 | { |
||
| 299 | translated[i] = translate[original[i]]; |
||
| 300 | translated[i+1] = translate[original[i+1]]; |
||
| 301 | translated[i+2] = translate[original[i+2]]; |
||
| 302 | translated[i+3] = translate[original[i+3]]; |
||
| 303 | } |
||
| 304 | |||
| 305 | |||
| 306 | // don't mipmap these, because it takes too long |
||
| 307 | GL_Upload8 (translated, paliashdr->skinwidth, paliashdr->skinheight, false, false, true); |
||
| 308 | #else |
||
| 309 | scaled_width = gl_max_size.value < 512 ? gl_max_size.value : 512; |
||
| 310 | scaled_height = gl_max_size.value < 256 ? gl_max_size.value : 256; |
||
| 311 | |||
| 312 | // allow users to crunch sizes down even more if they want |
||
| 313 | scaled_width >>= (int)gl_playermip.value; |
||
| 314 | scaled_height >>= (int)gl_playermip.value; |
||
| 315 | |||
| 316 | if (VID_Is8bit()) { // 8bit texture upload |
||
| 317 | byte *out2; |
||
| 318 | |||
| 319 | out2 = (byte *)pixels; |
||
| 320 | memset(pixels, 0, sizeof(pixels)); |
||
| 321 | fracstep = inwidth*0x10000/scaled_width; |
||
| 322 | for (i=0 ; i |
||
| 323 | { |
||
| 324 | inrow = original + inwidth*(i*inheight/scaled_height); |
||
| 325 | frac = fracstep >> 1; |
||
| 326 | for (j=0 ; j |
||
| 327 | { |
||
| 328 | out2[j] = translate[inrow[frac>>16]]; |
||
| 329 | frac += fracstep; |
||
| 330 | out2[j+1] = translate[inrow[frac>>16]]; |
||
| 331 | frac += fracstep; |
||
| 332 | out2[j+2] = translate[inrow[frac>>16]]; |
||
| 333 | frac += fracstep; |
||
| 334 | out2[j+3] = translate[inrow[frac>>16]]; |
||
| 335 | frac += fracstep; |
||
| 336 | } |
||
| 337 | } |
||
| 338 | |||
| 339 | GL_Upload8_EXT ((byte *)pixels, scaled_width, scaled_height, false, false); |
||
| 340 | return; |
||
| 341 | } |
||
| 342 | |||
| 343 | for (i=0 ; i<256 ; i++) |
||
| 344 | translate32[i] = d_8to24table[translate[i]]; |
||
| 345 | |||
| 346 | out = pixels; |
||
| 347 | fracstep = inwidth*0x10000/scaled_width; |
||
| 348 | for (i=0 ; i |
||
| 349 | { |
||
| 350 | inrow = original + inwidth*(i*inheight/scaled_height); |
||
| 351 | frac = fracstep >> 1; |
||
| 352 | for (j=0 ; j |
||
| 353 | { |
||
| 354 | out[j] = translate32[inrow[frac>>16]]; |
||
| 355 | frac += fracstep; |
||
| 356 | out[j+1] = translate32[inrow[frac>>16]]; |
||
| 357 | frac += fracstep; |
||
| 358 | out[j+2] = translate32[inrow[frac>>16]]; |
||
| 359 | frac += fracstep; |
||
| 360 | out[j+3] = translate32[inrow[frac>>16]]; |
||
| 361 | frac += fracstep; |
||
| 362 | } |
||
| 363 | } |
||
| 364 | glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); |
||
| 365 | |||
| 366 | glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); |
||
| 367 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
||
| 368 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
||
| 369 | #endif |
||
| 370 | |||
| 371 | } |
||
| 372 | |||
| 373 | |||
| 374 | /* |
||
| 375 | =============== |
||
| 376 | R_NewMap |
||
| 377 | =============== |
||
| 378 | */ |
||
| 379 | void R_NewMap (void) |
||
| 380 | { |
||
| 381 | int i; |
||
| 382 | |||
| 383 | for (i=0 ; i<256 ; i++) |
||
| 384 | d_lightstylevalue[i] = 264; // normal light value |
||
| 385 | |||
| 386 | memset (&r_worldentity, 0, sizeof(r_worldentity)); |
||
| 387 | r_worldentity.model = cl.worldmodel; |
||
| 388 | |||
| 389 | // clear out efrags in case the level hasn't been reloaded |
||
| 390 | // FIXME: is this one short? |
||
| 391 | for (i=0 ; i |
||
| 392 | cl.worldmodel->leafs[i].efrags = NULL; |
||
| 393 | |||
| 394 | r_viewleaf = NULL; |
||
| 395 | R_ClearParticles (); |
||
| 396 | |||
| 397 | GL_BuildLightmaps (); |
||
| 398 | |||
| 399 | // identify sky texture |
||
| 400 | skytexturenum = -1; |
||
| 401 | mirrortexturenum = -1; |
||
| 402 | for (i=0 ; i |
||
| 403 | { |
||
| 404 | if (!cl.worldmodel->textures[i]) |
||
| 405 | continue; |
||
| 406 | if (!Q_strncmp(cl.worldmodel->textures[i]->name,"sky",3) ) |
||
| 407 | skytexturenum = i; |
||
| 408 | if (!Q_strncmp(cl.worldmodel->textures[i]->name,"window02_1",10) ) |
||
| 409 | mirrortexturenum = i; |
||
| 410 | cl.worldmodel->textures[i]->texturechain = NULL; |
||
| 411 | } |
||
| 412 | #ifdef QUAKE2 |
||
| 413 | R_LoadSkys (); |
||
| 414 | #endif |
||
| 415 | } |
||
| 416 | |||
| 417 | |||
| 418 | /* |
||
| 419 | ==================== |
||
| 420 | R_TimeRefresh_f |
||
| 421 | |||
| 422 | For program optimization |
||
| 423 | ==================== |
||
| 424 | */ |
||
| 425 | void R_TimeRefresh_f (void) |
||
| 426 | { |
||
| 427 | int i; |
||
| 428 | float start, stop, time; |
||
| 429 | int startangle; |
||
| 430 | vrect_t vr; |
||
| 431 | |||
| 432 | glDrawBuffer (GL_FRONT); |
||
| 433 | glFinish (); |
||
| 434 | |||
| 435 | start = Sys_FloatTime (); |
||
| 436 | for (i=0 ; i<128 ; i++) |
||
| 437 | { |
||
| 438 | r_refdef.viewangles[1] = i/128.0*360.0; |
||
| 439 | R_RenderView (); |
||
| 440 | } |
||
| 441 | |||
| 442 | glFinish (); |
||
| 443 | stop = Sys_FloatTime (); |
||
| 444 | time = stop-start; |
||
| 445 | Con_Printf ("%f seconds (%f fps)\n", time, 128/time); |
||
| 446 | |||
| 447 | glDrawBuffer (GL_BACK); |
||
| 448 | GL_EndRendering (); |
||
| 449 | } |
||
| 450 | |||
| 451 | void D_FlushCaches (void) |
||
| 452 | { |
||
| 453 | } |
||
| 454 | |||
| 455 |