Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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<s ; i+=4)
  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<scaled_height ; i++, out2 += scaled_width)
  323.                 {
  324.                         inrow = original + inwidth*(i*inheight/scaled_height);
  325.                         frac = fracstep >> 1;
  326.                         for (j=0 ; j<scaled_width ; j+=4)
  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<scaled_height ; i++, out += scaled_width)
  349.         {
  350.                 inrow = original + inwidth*(i*inheight/scaled_height);
  351.                 frac = fracstep >> 1;
  352.                 for (j=0 ; j<scaled_width ; j+=4)
  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<cl.worldmodel->numleafs ; 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<cl.worldmodel->numtextures ; 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.  
  456.