home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / q1source_amy / qw / client / gl_rmisc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-21  |  11.5 KB  |  474 lines
  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. extern void R_InitBubble();
  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.  
  110.     glDrawBuffer  (GL_FRONT);
  111.     glReadBuffer  (GL_FRONT);
  112.     envmap = true;
  113.  
  114.     r_refdef.vrect.x = 0;
  115.     r_refdef.vrect.y = 0;
  116.     r_refdef.vrect.width = 256;
  117.     r_refdef.vrect.height = 256;
  118.  
  119.     r_refdef.viewangles[0] = 0;
  120.     r_refdef.viewangles[1] = 0;
  121.     r_refdef.viewangles[2] = 0;
  122.     GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
  123.     R_RenderView ();
  124.     glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
  125.     COM_WriteFile ("env0.rgb", buffer, sizeof(buffer));        
  126.  
  127.     r_refdef.viewangles[1] = 90;
  128.     GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
  129.     R_RenderView ();
  130.     glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
  131.     COM_WriteFile ("env1.rgb", buffer, sizeof(buffer));        
  132.  
  133.     r_refdef.viewangles[1] = 180;
  134.     GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
  135.     R_RenderView ();
  136.     glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
  137.     COM_WriteFile ("env2.rgb", buffer, sizeof(buffer));        
  138.  
  139.     r_refdef.viewangles[1] = 270;
  140.     GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
  141.     R_RenderView ();
  142.     glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
  143.     COM_WriteFile ("env3.rgb", buffer, sizeof(buffer));        
  144.  
  145.     r_refdef.viewangles[0] = -90;
  146.     r_refdef.viewangles[1] = 0;
  147.     GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
  148.     R_RenderView ();
  149.     glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
  150.     COM_WriteFile ("env4.rgb", buffer, sizeof(buffer));        
  151.  
  152.     r_refdef.viewangles[0] = 90;
  153.     r_refdef.viewangles[1] = 0;
  154.     GL_BeginRendering (&glx, &gly, &glwidth, &glheight);
  155.     R_RenderView ();
  156.     glReadPixels (0, 0, 256, 256, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
  157.     COM_WriteFile ("env5.rgb", buffer, sizeof(buffer));        
  158.  
  159.     envmap = false;
  160.     glDrawBuffer  (GL_BACK);
  161.     glReadBuffer  (GL_BACK);
  162.     GL_EndRendering ();
  163. }
  164.  
  165. /*
  166. ===============
  167. R_Init
  168. ===============
  169. */
  170. void R_Init (void)
  171. {    
  172.     Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);    
  173.     Cmd_AddCommand ("envmap", R_Envmap_f);    
  174.     Cmd_AddCommand ("pointfile", R_ReadPointFile_f);    
  175.  
  176.     Cvar_RegisterVariable (&r_norefresh);
  177.     Cvar_RegisterVariable (&r_lightmap);
  178.     Cvar_RegisterVariable (&r_fullbright);
  179.     Cvar_RegisterVariable (&r_drawentities);
  180.     Cvar_RegisterVariable (&r_drawviewmodel);
  181.     Cvar_RegisterVariable (&r_shadows);
  182.     Cvar_RegisterVariable (&r_mirroralpha);
  183.     Cvar_RegisterVariable (&r_wateralpha);
  184.     Cvar_RegisterVariable (&r_dynamic);
  185.     Cvar_RegisterVariable (&r_novis);
  186.     Cvar_RegisterVariable (&r_speeds);
  187.     Cvar_RegisterVariable (&r_netgraph);
  188.  
  189.     Cvar_RegisterVariable (&gl_clear);
  190.     Cvar_RegisterVariable (&gl_texsort);
  191.  
  192.      if (gl_mtexable)
  193.         Cvar_SetValue ("gl_texsort", 0.0);
  194.  
  195.     Cvar_RegisterVariable (&gl_cull);
  196.     Cvar_RegisterVariable (&gl_smoothmodels);
  197.     Cvar_RegisterVariable (&gl_affinemodels);
  198.     Cvar_RegisterVariable (&gl_polyblend);
  199.     Cvar_RegisterVariable (&gl_flashblend);
  200.     Cvar_RegisterVariable (&gl_playermip);
  201.     Cvar_RegisterVariable (&gl_nocolors);
  202.     Cvar_RegisterVariable (&gl_finish);
  203.  
  204.     Cvar_RegisterVariable (&gl_keeptjunctions);
  205.     Cvar_RegisterVariable (&gl_reporttjunctions);
  206.  
  207.     R_InitBubble();
  208.     
  209.     R_InitParticles ();
  210.     R_InitParticleTexture ();
  211.  
  212. #ifdef GLTEST
  213.     Test_Init ();
  214. #endif
  215.  
  216.     netgraphtexture = texture_extension_number;
  217.     texture_extension_number++;
  218.  
  219.     playertextures = texture_extension_number;
  220.     texture_extension_number += MAX_CLIENTS;
  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;
  236.     byte    *original;
  237.     unsigned    pixels[512*256], *out;
  238.     unsigned    scaled_width, scaled_height;
  239.     int            inwidth, inheight;
  240.     int            tinwidth, tinheight;
  241.     byte        *inrow;
  242.     unsigned    frac, fracstep;
  243.     player_info_t *player;
  244.     extern    byte        player_8bit_texels[320*200];
  245.     char s[512];
  246.  
  247.     GL_DisableMultitexture();
  248.  
  249.     player = &cl.players[playernum];
  250.     if (!player->name[0])
  251.         return;
  252.  
  253.     strcpy(s, Info_ValueForKey(player->userinfo, "skin"));
  254.     COM_StripExtension(s, s);
  255.     if (player->skin && !stricmp(s, player->skin->name))
  256.         player->skin = NULL;
  257.  
  258.     if (player->_topcolor != player->topcolor ||
  259.         player->_bottomcolor != player->bottomcolor || !player->skin) {
  260.         player->_topcolor = player->topcolor;
  261.         player->_bottomcolor = player->bottomcolor;
  262.  
  263.         top = player->topcolor;
  264.         bottom = player->bottomcolor;
  265.         top = (top < 0) ? 0 : ((top > 13) ? 13 : top);
  266.         bottom = (bottom < 0) ? 0 : ((bottom > 13) ? 13 : bottom);
  267.         top *= 16;
  268.         bottom *= 16;
  269.  
  270.         for (i=0 ; i<256 ; i++)
  271.             translate[i] = i;
  272.  
  273.         for (i=0 ; i<16 ; i++)
  274.         {
  275.             if (top < 128)    // the artists made some backwards ranges.  sigh.
  276.                 translate[TOP_RANGE+i] = top+i;
  277.             else
  278.                 translate[TOP_RANGE+i] = top+15-i;
  279.                     
  280.             if (bottom < 128)
  281.                 translate[BOTTOM_RANGE+i] = bottom+i;
  282.             else
  283.                 translate[BOTTOM_RANGE+i] = bottom+15-i;
  284.         }
  285.  
  286.         //
  287.         // locate the original skin pixels
  288.         //
  289.         // real model width
  290.         tinwidth = 296;
  291.         tinheight = 194;
  292.  
  293.         if (!player->skin)
  294.             Skin_Find(player);
  295.         if ((original = Skin_Cache(player->skin)) != NULL) {
  296.             //skin data width
  297.             inwidth = 320;
  298.             inheight = 200;
  299.         } else {
  300.             original = player_8bit_texels;
  301.             inwidth = 296;
  302.             inheight = 194;
  303.         }
  304.  
  305.  
  306.         // because this happens during gameplay, do it fast
  307.         // instead of sending it through gl_upload 8
  308.         GL_Bind(playertextures + playernum);
  309.  
  310.     #if 0
  311.         s = 320*200;
  312.         byte    translated[320*200];
  313.  
  314.         for (i=0 ; i<s ; i+=4)
  315.         {
  316.             translated[i] = translate[original[i]];
  317.             translated[i+1] = translate[original[i+1]];
  318.             translated[i+2] = translate[original[i+2]];
  319.             translated[i+3] = translate[original[i+3]];
  320.         }
  321.  
  322.  
  323.         // don't mipmap these, because it takes too long
  324.         GL_Upload8 (translated, paliashdr->skinwidth, paliashdr->skinheight, 
  325.             false, false, true);
  326.     #endif
  327.  
  328.         scaled_width = gl_max_size.value < 512 ? gl_max_size.value : 512;
  329.         scaled_height = gl_max_size.value < 256 ? gl_max_size.value : 256;
  330.         // allow users to crunch sizes down even more if they want
  331.         scaled_width >>= (int)gl_playermip.value;
  332.         scaled_height >>= (int)gl_playermip.value;
  333.  
  334.         if (VID_Is8bit()) { // 8bit texture upload
  335.             byte *out2;
  336.  
  337.             out2 = (byte *)pixels;
  338.             memset(pixels, 0, sizeof(pixels));
  339.             fracstep = tinwidth*0x10000/scaled_width;
  340.             for (i=0 ; i<scaled_height ; i++, out2 += scaled_width)
  341.             {
  342.                 inrow = original + inwidth*(i*tinheight/scaled_height);
  343.                 frac = fracstep >> 1;
  344.                 for (j=0 ; j<scaled_width ; j+=4)
  345.                 {
  346.                     out2[j] = translate[inrow[frac>>16]];
  347.                     frac += fracstep;
  348.                     out2[j+1] = translate[inrow[frac>>16]];
  349.                     frac += fracstep;
  350.                     out2[j+2] = translate[inrow[frac>>16]];
  351.                     frac += fracstep;
  352.                     out2[j+3] = translate[inrow[frac>>16]];
  353.                     frac += fracstep;
  354.                 }
  355.             }
  356.  
  357.             GL_Upload8_EXT ((byte *)pixels, scaled_width, scaled_height, false, false);
  358.             return;
  359.         }
  360.  
  361.         for (i=0 ; i<256 ; i++)
  362.             translate32[i] = d_8to24table[translate[i]];
  363.  
  364.         out = pixels;
  365.         memset(pixels, 0, sizeof(pixels));
  366.         fracstep = tinwidth*0x10000/scaled_width;
  367.         for (i=0 ; i<scaled_height ; i++, out += scaled_width)
  368.         {
  369.             inrow = original + inwidth*(i*tinheight/scaled_height);
  370.             frac = fracstep >> 1;
  371.             for (j=0 ; j<scaled_width ; j+=4)
  372.             {
  373.                 out[j] = translate32[inrow[frac>>16]];
  374.                 frac += fracstep;
  375.                 out[j+1] = translate32[inrow[frac>>16]];
  376.                 frac += fracstep;
  377.                 out[j+2] = translate32[inrow[frac>>16]];
  378.                 frac += fracstep;
  379.                 out[j+3] = translate32[inrow[frac>>16]];
  380.                 frac += fracstep;
  381.             }
  382.         }
  383.  
  384.         glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, 
  385.             scaled_width, scaled_height, 0, GL_RGBA, 
  386.             GL_UNSIGNED_BYTE, pixels);
  387.  
  388.         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  389.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  390.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  391.     }
  392. }
  393.  
  394. /*
  395. ===============
  396. R_NewMap
  397. ===============
  398. */
  399. void R_NewMap (void)
  400. {
  401.     int        i;
  402.     
  403.     for (i=0 ; i<256 ; i++)
  404.         d_lightstylevalue[i] = 264;        // normal light value
  405.  
  406.     memset (&r_worldentity, 0, sizeof(r_worldentity));
  407.     r_worldentity.model = cl.worldmodel;
  408.  
  409. // clear out efrags in case the level hasn't been reloaded
  410. // FIXME: is this one short?
  411.     for (i=0 ; i<cl.worldmodel->numleafs ; i++)
  412.         cl.worldmodel->leafs[i].efrags = NULL;
  413.              
  414.     r_viewleaf = NULL;
  415.     R_ClearParticles ();
  416.  
  417.     GL_BuildLightmaps ();
  418.  
  419.     // identify sky texture
  420.     skytexturenum = -1;
  421.     mirrortexturenum = -1;
  422.     for (i=0 ; i<cl.worldmodel->numtextures ; i++)
  423.     {
  424.         if (!cl.worldmodel->textures[i])
  425.             continue;
  426.         if (!Q_strncmp(cl.worldmodel->textures[i]->name,"sky",3) )
  427.             skytexturenum = i;
  428.         if (!Q_strncmp(cl.worldmodel->textures[i]->name,"window02_1",10) )
  429.             mirrortexturenum = i;
  430.          cl.worldmodel->textures[i]->texturechain = NULL;
  431.     }
  432. #ifdef QUAKE2
  433.     R_LoadSkys ();
  434. #endif
  435. }
  436.  
  437.  
  438. /*
  439. ====================
  440. R_TimeRefresh_f
  441.  
  442. For program optimization
  443. ====================
  444. */
  445. void R_TimeRefresh_f (void)
  446. {
  447.     int            i;
  448.     float        start, stop, time;
  449.  
  450.     glDrawBuffer  (GL_FRONT);
  451.     glFinish ();
  452.  
  453.     start = Sys_DoubleTime ();
  454.     for (i=0 ; i<128 ; i++)
  455.     {
  456.         r_refdef.viewangles[1] = i/128.0*360.0;
  457.         R_RenderView ();
  458.     }
  459.  
  460.     glFinish ();
  461.     stop = Sys_DoubleTime ();
  462.     time = stop-start;
  463.     Con_Printf ("%f seconds (%f fps)\n", time, 128/time);
  464.  
  465.     glDrawBuffer  (GL_BACK);
  466.     GL_EndRendering ();
  467. }
  468.  
  469. void D_FlushCaches (void)
  470. {
  471. }
  472.  
  473.  
  474.