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