mh's zfail skypheres port to normal quake

[revelator]

not sure they are correct they do work tho one function in particualr had me up the walls the code for clipping sky see below maybe if mh drops by he can spread some light as to what actually needs to be there, as of right now i just render two passes ontop.

Code: Select all

/*
=================
R_DrawSkyArrays
=================
*/
void R_DrawSkyArrays (int texnum, float bigscale, float smallscale, float rotatefactor)
{
   // go to a new matrix
   glPushMatrix ();
   
   // center it on the players position, scale it, orient so the poles are unobtrusive,
   // make it not always at right angles to the player, and rotate it around the poles
   glTranslatef (r_origin[0], r_origin[1], r_origin[2]);
   glTranslatef (0, 0, -500);
   glScalef (bigscale, bigscale, smallscale);
   glRotatef (-90, 1, 0, 0);
   glRotatef (-22, 0, 1, 0);
   glRotatef (rotatefactor, 0, 0, 1);
   
   // bind the correct texture
   GL_Bind (texnum);
   
   // draw the sphere
   // (if this barfs on your implementation, just unroll the single call into 10 batches of 22)
   glCallList (r_skysphere);
   
   // restore the previous matrix
   glPopMatrix ();
}

/*
=================
R_ClipSky

eh not sure this was the intention ?
=================
*/
void R_ClipSky (msurface_t *fa)
{
   // disable texturing and writes to the color buffer
   glDisable (GL_TEXTURE_2D);
   glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
   
   for (fa = skychain; fa; fa = fa->texturechain)
   {
      EmitFlatPoly (fa);
   }
   skychain = NULL;
   skychain_tail = &skychain;

   // revert
   glEnable (GL_TEXTURE_2D);
   glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
   
   // need to reset primary colour to full as well
   // as colormask can set it to black on some implementations
   glColor3f (1, 1, 1);
}


/*
=================
R_DrawSkyChain
=================
*/
void R_DrawSkyChain (void)
{
   // sky scaling
   float fullscale = r_farclip.value / 4096;
   float halfscale = r_farclip.value / 8192;
   float reducedfull = (r_farclip.value / 4096) * 0.9;
   float reducedhalf = (r_farclip.value / 8192) * 0.9;

   // rotation
   float rotateBack = anglemod (realtime * 6);      // JT022605 - changed from 12 to slow sky
   float rotateFore = anglemod (realtime * 10);   // JT022605 - changed from 20 to slow sky

   if (!skychain) return;

   // turn on fogging.  fog looks good on the skies - it gives them a more
   // "airy" far-away look, and has the knock-on effect of preventing the
   // old "texture distortion at the poles" problem.
   glFogi (GL_FOG_MODE, GL_LINEAR);
   glFogfv (GL_FOG_COLOR, r_skyfog);
   glFogf (GL_FOG_START, -r_farclip.value);         // changed from 5

   // must tweak the fog end too!!!
   glFogf (GL_FOG_END, r_farclip.value * 0.60);      // changed from 0.75
   glEnable (GL_FOG);

   // write the regular sky polys into the depth buffer to get a baseline
   R_ClipSky (skychain);
   
   // switch the depth func so that the regular polys will prevent sphere polys outside their area reaching the framebuffer
   glDepthFunc (GL_GEQUAL);
   glDepthMask (GL_FALSE);

   // sky texture scaling
   // previous releases made a tiled version of the sky texture.  here i just shrink it using the
   // texture matrix, for much the same effect
   glMatrixMode (GL_TEXTURE);
   glLoadIdentity ();
   glScalef (2, 1, 1);
   glMatrixMode (GL_MODELVIEW);

   // background
   // ==========
   // go to a new matrix
   R_DrawSkyArrays (solidskytexture, reducedfull, reducedhalf, -rotateBack);

   // enable blending for the alpha sky
   glEnable (GL_BLEND);
   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   // foreground
   // ==========
   // go to a new matrix
   R_DrawSkyArrays (alphaskytexture, fullscale, halfscale, -rotateFore);

   // back to normal mode
   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glDisable (GL_BLEND);

   // turn off fog
   glDisable (GL_FOG);

   // revert the texture matrix
   glMatrixMode (GL_TEXTURE);
   glLoadIdentity ();
   glMatrixMode (GL_MODELVIEW);

   // revert the depth func
   glDepthFunc (GL_LEQUAL);
   glDepthMask (GL_TRUE);

   // now write the regular polys one more time to clip world geometry
   R_ClipSky (skychain);
}

/*
==============
R_DrawSphere

Draw a sphere!!!  The verts and texcoords are precalculated for extra efficiency.  The sphere is put into
a display list to reduce overhead even further.
==============
*/
float skytexes[440];
float skyverts[660];

void R_DrawSphere (void)
{
   if (r_skysphere == -1)
   {
      int i;
      int j;

      int vertspos = 0;
      int texespos = 0;

      // build the sphere display list
      r_skysphere = glGenLists (1);

      glNewList (r_skysphere, GL_COMPILE);

      for (i = 0; i < 10; i++)
      {
         glBegin (GL_TRIANGLE_STRIP);

         for (j = 0; j <= 10; j++)
         {
            glTexCoord2fv (&skytexes[texespos]);
            glVertex3fv (&skyverts[vertspos]);

            texespos += 2;
            vertspos += 3;

            glTexCoord2fv (&skytexes[texespos]);
            glVertex3fv (&skyverts[vertspos]);

            texespos += 2;
            vertspos += 3;
         }
         glEnd ();
      }
      glEndList ();
   }
}


/*
==============
R_InitSkyChain

Initialize the sky chain arrays
==============
*/
void R_InitSkyChain (void)
{
   float drho = 0.3141592653589;
   float dtheta = 0.6283185307180;

   float ds = 0.1;
   float dt = 0.1;

   float t = 1.0f;
   float s = 0.0f;

   int i;
   int j;

   int vertspos = 0;
   int texespos = 0;

   for (i = 0; i < 10; i++)
   {
      float rho = (float) i * drho;
      float srho = (float) (sin (rho));
      float crho = (float) (cos (rho));
      float srhodrho = (float) (sin (rho + drho));
      float crhodrho = (float) (cos (rho + drho));

      s = 0.0f;

      for (j = 0; j <= 10; j++)
      {
         float theta = (j == 10) ? 0.0f : j * dtheta;
         float stheta = (float) (-sin( theta));
         float ctheta = (float) (cos (theta));

         skytexes[texespos++] = s * 2;
         skytexes[texespos++] = t * 2;

         skyverts[vertspos++] = stheta * srho * 4096.0;
         skyverts[vertspos++] = ctheta * srho * 4096.0;
         skyverts[vertspos++] = crho * 4096.0;

         skytexes[texespos++] = s * 2;
         skytexes[texespos++] = (t - dt) * 2;

         skyverts[vertspos++] = stheta * srhodrho * 4096.0;
         skyverts[vertspos++] = ctheta * srhodrho * 4096.0;
         skyverts[vertspos++] = crhodrho * 4096.0;

         s += ds;
      }
      t -= dt;
   }
}


/*
=============
R_InitSky

A sky texture is 256*128, with the right side being a masked overlay
==============
*/
void R_InitSky (miptex_t *mt)
{
   int         i, j, p;
   byte      *src;
   unsigned   transpix;
   int         r, g, b;
   unsigned   *rgba;
   unsigned   topalpha;
   int         div;
   unsigned   *trans;

   // initialize our pointers
   trans = malloc (128 * 128 * 4);

   // -----------------
   // solid sky texture
   // -----------------
   src = (byte *)mt + mt->offsets[0];

   // make an average value for the back to avoid
   // a fringe on the top level
   r = g = b = 0;

   for (i=0 ; i<128 ; i++)
   {
      for (j=0 ; j<128 ; j++)
      {
         p = src[i*256 + j + 128];
         rgba = &d_8to24table[p];
         trans[(i*128) + j] = *rgba;

         r += ((byte *)rgba)[0];
         g += ((byte *)rgba)[1];
         b += ((byte *)rgba)[2];
      }
   }

   ((byte *)&transpix)[0] = r/(128*128);
   ((byte *)&transpix)[1] = g/(128*128);
   ((byte *)&transpix)[2] = b/(128*128);
   ((byte *)&transpix)[3] = 0;

   if (!solidskytexture) solidskytexture = texture_extension_number++;

   GL_Bind (solidskytexture);

   glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 128, 128, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans);
   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

   // -----------------
   // alpha sky texture
   // -----------------
   // get another average cos the bottom layer average can be too dark
   div = r = g = b = 0;

   for (i=0 ; i<128 ; i++)
   {
      for (j=0 ; j<128 ; j++)
      {
         p = src[i*256 + j];

         if (p == 0)
         {
            topalpha = transpix;
         }
         else
         {
            rgba = &d_8to24table[p];

            r += ((byte *)rgba)[0];
            g += ((byte *)rgba)[1];
            b += ((byte *)rgba)[2];

            div++;

            topalpha = d_8to24table[p];
         }

         ((byte *)&topalpha)[3] = ((byte *)&topalpha)[3] / 2;

         trans[(i*128) + j] = topalpha;
      }
   }

   if (!alphaskytexture) alphaskytexture = texture_extension_number++;

   GL_Bind (alphaskytexture);

   glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, 128, 128, 0, GL_RGBA, GL_UNSIGNED_BYTE, trans);
   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

   // get fog colours for the sky - we halve these
   r_skyfog[0] = ((float)r / (float)div) / 512.0;
   r_skyfog[1] = ((float)g / (float)div) / 512.0;
   r_skyfog[2] = ((float)b / (float)div) / 512.0;
   r_skyfog[3] = 0.1;

   // free the used memory
   free (trans);

   // recalc the sphere display list - delete the original one first!!!
   if (r_skysphere != -1)
   {
      glDeleteLists (r_skysphere, 1);
   }
   r_skysphere = -1;

   R_InitSkyChain ();
   R_DrawSphere ();
}


[mh]

That looks right.

[revelator]

it is cool
was starting to wonder if you moved to qukedev thank you for confirming the code

[MeTcHsteekle]

hmm this sounds intresting, if i only knew where to out it :S

[r00k]

I ported this into Qrack when MH posted the tut back on QSG.
If you want to see the end result you can try R_SKYSCROLL 1 in Qrack or MHQUAKE.
The new z-fail method speeds the rendering 10x so it is VERY useful on less powerful machines, like my silly DELL desktop at work that has an integrated Intel (brookdale) card.

EDIT:
Oops! I just re-read your message to conclude u meant PUT it. I thought for a minute meant check it OUT.

The bulk of the code goes in gl_warp.c



______________________________________________
random MH quote: Hot damn Jethro, this sho' is purdy!!!

[mh]

Yup, it's all in gl_warp.c - have a look at the Qrack source, it's probably easier to work from than mine

[revelator]

the above is correct when i first posted this it wasnt actually in the tutorial section cause i wasnt sure it was right so some code is missing like the EmitFlatPoly code "part of fuhquake qrack joequake etc" can get it from there if its missing in your gl_warp.c

rest is pretty much straight forward