X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=gl_poly.c;h=8750595a38f6ea1fd26264d75e31ef1a92c3e8b9;hb=45982a9894c5bff60ff494a0f82865ec267d52f7;hp=df53f9f05bb395e1760c7587209c3b6e5e8c527b;hpb=8cb574958bd264215ca8bf1b9007d5d98822e6fd;p=xonotic%2Fdarkplaces.git diff --git a/gl_poly.c b/gl_poly.c index df53f9f0..8750595a 100644 --- a/gl_poly.c +++ b/gl_poly.c @@ -1,8 +1,18 @@ #include "quakedef.h" +typedef struct +{ + unsigned short tex; + unsigned short type; + int indices; +} +rendertranspoly_t; + transvert_t *transvert; transpoly_t *transpoly; -unsigned short *transpolyindex; +rendertranspoly_t *rendertranspoly; +int *transpolyindex; +int *transvertindex; wallvert_t *wallvert; wallvertcolor_t *wallvertcolor; wallpoly_t *wallpoly; @@ -16,20 +26,22 @@ int currentwallvert; int currentskypoly; int currentskyvert; + void LoadSky_f(void); -cvar_t r_multitexture = {"r_multitexture", "1"}; -cvar_t r_skyquality = {"r_skyquality", "2", true}; -cvar_t r_mergesky = {"r_mergesky", "0", true}; +cvar_t r_multitexture = {0, "r_multitexture", "1"}; +cvar_t r_skyquality = {CVAR_SAVE, "r_skyquality", "2"}; +cvar_t r_mergesky = {CVAR_SAVE, "r_mergesky", "0"}; +cvar_t gl_transpolytris = {0, "gl_transpolytris", "0"}; -char skyworldname[1024]; -rtexture_t *mergeskytexture; -rtexture_t *solidskytexture; -rtexture_t *alphaskytexture; -qboolean skyavailable_quake; -qboolean skyavailable_box; +static char skyworldname[1024]; +static rtexture_t *mergeskytexture; +static rtexture_t *solidskytexture, *solidskytexture_half; +static rtexture_t *alphaskytexture, *alphaskytexture_half; +static qboolean skyavailable_quake; +static qboolean skyavailable_box; -void R_BuildSky (int scrollupper, int scrolllower); +static void R_BuildSky (int scrollupper, int scrolllower); typedef struct translistitem_s { @@ -47,12 +59,14 @@ float transviewdist; // distance of view origin along the view normal float transreciptable[256]; -void gl_poly_start(void) +static void gl_poly_start(void) { int i; transvert = qmalloc(MAX_TRANSVERTS * sizeof(transvert_t)); transpoly = qmalloc(MAX_TRANSPOLYS * sizeof(transpoly_t)); - transpolyindex = qmalloc(MAX_TRANSPOLYS * sizeof(unsigned short)); + rendertranspoly = qmalloc(MAX_TRANSPOLYS * sizeof(rendertranspoly_t)); + transpolyindex = qmalloc(MAX_TRANSPOLYS * sizeof(int)); + transvertindex = qmalloc(MAX_TRANSVERTS * sizeof(int)); wallvert = qmalloc(MAX_WALLVERTS * sizeof(wallvert_t)); wallvertcolor = qmalloc(MAX_WALLVERTS * sizeof(wallvertcolor_t)); wallpoly = qmalloc(MAX_WALLPOLYS * sizeof(wallpoly_t)); @@ -63,11 +77,13 @@ void gl_poly_start(void) transreciptable[i] = 1.0f / i; } -void gl_poly_shutdown(void) +static void gl_poly_shutdown(void) { qfree(transvert); qfree(transpoly); + qfree(rendertranspoly); qfree(transpolyindex); + qfree(transvertindex); qfree(wallvert); qfree(wallvertcolor); qfree(wallpoly); @@ -75,7 +91,7 @@ void gl_poly_shutdown(void) qfree(skypoly); } -void gl_poly_newmap(void) +static void gl_poly_newmap(void) { skyavailable_box = false; skyavailable_quake = false; @@ -89,6 +105,7 @@ void GL_Poly_Init(void) Cvar_RegisterVariable (&r_multitexture); Cvar_RegisterVariable (&r_skyquality); Cvar_RegisterVariable (&r_mergesky); + Cvar_RegisterVariable (&gl_transpolytris); R_RegisterModule("GL_Poly", gl_poly_start, gl_poly_shutdown, gl_poly_newmap); } @@ -100,42 +117,7 @@ void transpolyclear(void) transviewdist = DotProduct(r_origin, vpn); } -// turned into a #define -/* -void transpolybegin(int texnum, int glowtexnum, int fogtexnum, int transpolytype) -{ - if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS) - return; - transpoly[currenttranspoly].texnum = (unsigned short) texnum; - transpoly[currenttranspoly].glowtexnum = (unsigned short) glowtexnum; - transpoly[currenttranspoly].fogtexnum = (unsigned short) fogtexnum; - transpoly[currenttranspoly].transpolytype = (unsigned short) transpolytype; - transpoly[currenttranspoly].firstvert = currenttransvert; - transpoly[currenttranspoly].verts = 0; -// transpoly[currenttranspoly].ndist = 0; // clear the normal -} -*/ - -// turned into a #define -/* -void transpolyvert(float x, float y, float z, float s, float t, int r, int g, int b, int a) -{ - int i; - if (currenttranspoly >= MAX_TRANSPOLYS || currenttransvert >= MAX_TRANSVERTS) - return; - transvert[currenttransvert].s = s; - transvert[currenttransvert].t = t; - transvert[currenttransvert].r = bound(0, r, 255); - transvert[currenttransvert].g = bound(0, g, 255); - transvert[currenttransvert].b = bound(0, b, 255); - transvert[currenttransvert].a = bound(0, a, 255); - transvert[currenttransvert].v[0] = x; - transvert[currenttransvert].v[1] = y; - transvert[currenttransvert].v[2] = z; - currenttransvert++; - transpoly[currenttranspoly].verts++; -} -*/ +// transpolybegin and transpolyvert are #define macros void transpolyend(void) { @@ -174,207 +156,367 @@ void transpolyend(void) currenttranspoly++; } -int transpolyindices; +void transpolyparticle(vec3_t org, vec3_t right, vec3_t up, vec_t scale, unsigned short texnum, unsigned short transpolytype, int ir, int ig, int ib, float alphaf, float s1, float t1, float s2, float t2) +{ + float center, scale2; + int i; + vec3_t corner; + byte br, bg, bb, ba; + transpoly_t *p; + transvert_t *v; + center = DotProduct(org, vpn) - transviewdist; + if (center < 4.0f || currenttranspoly >= MAX_TRANSPOLYS || (currenttransvert + 4) > MAX_TRANSVERTS) + return; + + p = transpoly + (currenttranspoly++); + v = transvert + currenttransvert; + + if (lighthalf) + { + ir >>= 1; + ig >>= 1; + ib >>= 1; + } + ir = bound(0, ir, 255); + ig = bound(0, ig, 255); + ib = bound(0, ib, 255); + br = (byte) ir; + bg = (byte) ig; + bb = (byte) ib; + +#if SLOWMATH + i = (int) alphaf; + if (i > 255) + i = 255; + ba = (byte) i; + + i = (int) center; +#else + alphaf += 8388608.0f; + i = *((long *)&alphaf) & 0x007FFFFF; + if (i > 255) + i = 255; + ba = (byte) i; + + center += 8388608.0f; + i = *((long *)¢er) & 0x007FFFFF; +#endif + i = bound(0, i, 4095); + currenttranslist->next = translisthash[i]; + currenttranslist->poly = p; + translisthash[i] = currenttranslist++; + + p->texnum = p->fogtexnum = texnum; + p->glowtexnum = 0; + p->transpolytype = transpolytype; + p->firstvert = currenttransvert; + p->verts = 4; + currenttransvert += 4; + + scale2 = scale * -0.5f; + corner[0] = org[0] + (up[0] + right[0]) * scale2; + corner[1] = org[1] + (up[1] + right[1]) * scale2; + corner[2] = org[2] + (up[2] + right[2]) * scale2; + v->s = s1; + v->t = t1; + v->r = br; + v->g = bg; + v->b = bb; + v->a = ba; + v->v[0] = corner[0]; + v->v[1] = corner[1]; + v->v[2] = corner[2]; + v++; + v->s = s1; + v->t = t2; + v->r = br; + v->g = bg; + v->b = bb; + v->a = ba; + v->v[0] = corner[0] + up[0] * scale; + v->v[1] = corner[1] + up[1] * scale; + v->v[2] = corner[2] + up[2] * scale; + v++; + v->s = s2; + v->t = t2; + v->r = br; + v->g = bg; + v->b = bb; + v->a = ba; + v->v[0] = corner[0] + (up[0] + right[0]) * scale; + v->v[1] = corner[1] + (up[1] + right[1]) * scale; + v->v[2] = corner[2] + (up[2] + right[2]) * scale; + v++; + v->s = s2; + v->t = t1; + v->r = br; + v->g = bg; + v->b = bb; + v->a = ba; + v->v[0] = corner[0] + right[0] * scale; + v->v[1] = corner[1] + right[1] * scale; + v->v[2] = corner[2] + right[2] * scale; + v++; +} void transpolyrender(void) { - int i, j, tpolytype, texnum; - transpoly_t *p; + int i, j, k, l, tpolytype, texnum, transvertindices, alpha, currentrendertranspoly; + byte fogr, fogg, fogb; + vec3_t diff; + transpoly_t *p; + rendertranspoly_t *r, *rend; + translistitem *item; + if (!r_render.value) return; if (currenttranspoly < 1) return; -// transpolyrenderminmax(); -// if (transpolyindices < 1) -// return; - // testing -// Con_DPrintf("transpolyrender: %i polys %i infront %i vertices\n", currenttranspoly, transpolyindices, currenttransvert); -// if (transpolyindices >= 2) -// transpolysort(); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glEnable(GL_BLEND); - glShadeModel(GL_SMOOTH); +// glShadeModel(GL_SMOOTH); glDepthMask(0); // disable zbuffer updates - glDisable(GL_ALPHA_TEST); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - tpolytype = TPOLYTYPE_ALPHA; - texnum = -1; - /* - if (gl_vertexarrays.value) + + // set up the vertex array + glInterleavedArrays(GL_T2F_C4UB_V3F, sizeof(transvert[0]), transvert); + + currentrendertranspoly = 0; + transvertindices = 0; + fogr = (byte) bound(0, (int) (fogcolor[0] * 255.0f), 255); + fogg = (byte) bound(0, (int) (fogcolor[1] * 255.0f), 255); + fogb = (byte) bound(0, (int) (fogcolor[2] * 255.0f), 255); + if (gl_transpolytris.value) { - // set up the vertex array - glInterleavedArrays(GL_T2F_C4UB_V3F, 0, transvert); - for (i = 0;i < transpolyindices;i++) + int glowtexnum, fogtexnum; + for (i = 4095;i >= 0;i--) { - p = &transpoly[transpolyindex[i]]; - if (p->texnum != texnum || p->transpolytype != tpolytype) + item = translisthash[i]; + while(item) { - if (p->texnum != texnum) + p = item->poly; + item = item->next; + glowtexnum = p->glowtexnum; + fogtexnum = p->fogtexnum; + +#define POLYTOTRI(pfirstvert, ptexnum, ptranspolytype) \ + l = pfirstvert;\ + r = &rendertranspoly[currentrendertranspoly++];\ + r->tex = ptexnum;\ + r->type = ptranspolytype;\ + if (p->verts == 4)\ + {\ + transvertindex[transvertindices] = l;\ + transvertindex[transvertindices + 1] = l + 1;\ + transvertindex[transvertindices + 2] = l + 2;\ + transvertindex[transvertindices + 3] = l;\ + transvertindex[transvertindices + 4] = l + 2;\ + transvertindex[transvertindices + 5] = l + 3;\ + transvertindices += 6;\ + r->indices = 6;\ + }\ + else if (p->verts == 3)\ + {\ + transvertindex[transvertindices] = l;\ + transvertindex[transvertindices + 1] = l + 1;\ + transvertindex[transvertindices + 2] = l + 2;\ + transvertindices += 3;\ + r->indices = 3;\ + }\ + else\ + {\ + for (j = l + p->verts, k = l + 2;k < j;k++)\ + {\ + transvertindex[transvertindices] = l;\ + transvertindex[transvertindices + 1] = k - 1;\ + transvertindex[transvertindices + 2] = k;\ + transvertindices += 3;\ + }\ + r->indices = (p->verts - 2) * 3;\ + } + + POLYTOTRI(p->firstvert, p->texnum, p->transpolytype) + + if (p->glowtexnum) { - texnum = p->texnum; - glBindTexture(GL_TEXTURE_2D, texnum); + // make another poly for glow effect + if (currenttranspoly < MAX_TRANSPOLYS && currenttransvert + p->verts <= MAX_TRANSVERTS) + { + memcpy(&transvert[currenttransvert], &transvert[p->firstvert], sizeof(transvert_t) * p->verts); + POLYTOTRI(currenttransvert, p->glowtexnum, TPOLYTYPE_ADD) + for (j = 0;j < p->verts;j++) + { + transvert[currenttransvert].r = transvert[currenttransvert].g = transvert[currenttransvert].b = 255; + currenttransvert++; + } + } } - if (p->transpolytype != tpolytype) + + if (fogenabled) { - tpolytype = p->transpolytype; - if (tpolytype == TPOLYTYPE_ADD) // additive - glBlendFunc(GL_SRC_ALPHA, GL_ONE); - else // alpha - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + // make another poly for fog + if (currenttranspoly < MAX_TRANSPOLYS && currenttransvert + p->verts <= MAX_TRANSVERTS) + { + memcpy(&transvert[currenttransvert], &transvert[p->firstvert], sizeof(transvert_t) * p->verts); + POLYTOTRI(currenttransvert, p->fogtexnum, TPOLYTYPE_ALPHA) + for (j = 0, k = p->firstvert;j < p->verts;j++, k++) + { + transvert[currenttransvert].r = fogr; + transvert[currenttransvert].g = fogg; + transvert[currenttransvert].b = fogb; + VectorSubtract(transvert[currenttransvert].v, r_origin, diff); + alpha = transvert[currenttransvert].a * exp(fogdensity / DotProduct(diff, diff)); + transvert[currenttransvert].a = (byte) bound(0, alpha, 255); + currenttransvert++; + } + } } } - glDrawArrays(GL_POLYGON, p->firstvert, p->verts); - if (p->glowtexnum) - { - texnum = p->glowtexnum; // highly unlikely to match next poly, but... - glBindTexture(GL_TEXTURE_2D, texnum); - tpolytype = TPOLYTYPE_ADD; // might match next poly - glBlendFunc(GL_SRC_ALPHA, GL_ONE); - glDrawArrays(GL_POLYGON, p->firstvert, p->verts); - } } - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_COLOR_ARRAY); - glDisableClientState(GL_VERTEX_ARRAY); } else - */ { - int points = -1; - translistitem *item; - transvert_t *vert; for (i = 4095;i >= 0;i--) { item = translisthash[i]; - while (item) + while(item) { p = item->poly; item = item->next; - if (p->texnum != texnum || p->verts != points || p->transpolytype != tpolytype) - { - glEnd(); - if (isG200) - { - // LordHavoc: Matrox G200 cards can't handle per pixel alpha - if (p->fogtexnum) - glEnable(GL_ALPHA_TEST); - else - glDisable(GL_ALPHA_TEST); - } - if (p->texnum != texnum) - { - texnum = p->texnum; - glBindTexture(GL_TEXTURE_2D, texnum); - } - if (p->transpolytype != tpolytype) - { - tpolytype = p->transpolytype; - if (tpolytype == TPOLYTYPE_ADD) // additive - glBlendFunc(GL_SRC_ALPHA, GL_ONE); - else // alpha - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - } - points = p->verts; - switch (points) - { - case 3: - glBegin(GL_TRIANGLES); - break; - case 4: - glBegin(GL_QUADS); - break; - default: - glBegin(GL_POLYGON); - points = -1; // to force a reinit on the next poly - break; - } - } - for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++) - { - // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...) - glTexCoord2f(vert->s, vert->t); - // again, vector version isn't supported I think - glColor4ub(vert->r, vert->g, vert->b, vert->a); - glVertex3fv(vert->v); - } + + l = p->firstvert; + r = &rendertranspoly[currentrendertranspoly++]; + r->tex = p->texnum; + r->type = p->transpolytype; + r->indices = p->verts; + + for (j = l + p->verts, k = l;k < j;k++) + transvertindex[transvertindices++] = k; + if (p->glowtexnum) { - glEnd(); - texnum = p->glowtexnum; // highly unlikely to match next poly, but... - glBindTexture(GL_TEXTURE_2D, texnum); - if (tpolytype != TPOLYTYPE_ADD) - { - tpolytype = TPOLYTYPE_ADD; // might match next poly - glBlendFunc(GL_SRC_ALPHA, GL_ONE); - } - points = -1; - glBegin(GL_POLYGON); - for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++) - { - glColor4ub(255,255,255,vert->a); - // would be 2fv, but windoze Matrox G200 and probably G400 drivers don't support that (dumb...) - glTexCoord2f(vert->s, vert->t); - glVertex3fv(vert->v); - } - glEnd(); - } - if (fogenabled && p->transpolytype == TPOLYTYPE_ALPHA) - { - vec3_t diff; - glEnd(); - points = -1; // to force a reinit on the next poly - if (tpolytype != TPOLYTYPE_ALPHA) + // make another poly for glow effect + if (currentrendertranspoly < MAX_TRANSPOLYS && currenttransvert + p->verts <= MAX_TRANSVERTS) { - tpolytype = TPOLYTYPE_ALPHA; // probably matchs next poly - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - } - if (p->fogtexnum) - { - if (texnum != p->fogtexnum) // highly unlikely to match next poly, but... - { - texnum = p->fogtexnum; - glBindTexture(GL_TEXTURE_2D, texnum); - } - glBegin(GL_POLYGON); - for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++) + l = currenttransvert; + r = &rendertranspoly[currentrendertranspoly++]; + r->tex = p->glowtexnum; + r->type = TPOLYTYPE_ADD; + r->indices = p->verts; + + memcpy(&transvert[currenttransvert], &transvert[p->firstvert], sizeof(transvert_t) * p->verts); + for (j = 0;j < p->verts;j++) { - VectorSubtract(vert->v, r_origin, diff); - glTexCoord2f(vert->s, vert->t); - glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff))); - glVertex3fv(vert->v); + transvert[currenttransvert].r = transvert[currenttransvert].g = transvert[currenttransvert].b = 255; + transvertindex[transvertindices++] = currenttransvert++; } - glEnd (); } - else + } + if (fogenabled) + { + // make another poly for fog + if (currentrendertranspoly < MAX_TRANSPOLYS && currenttransvert + p->verts <= MAX_TRANSVERTS) { - glDisable(GL_TEXTURE_2D); - glBegin(GL_POLYGON); - for (j = 0,vert = &transvert[p->firstvert];j < p->verts;j++, vert++) + l = currenttransvert; + r = &rendertranspoly[currentrendertranspoly++]; + r->tex = p->fogtexnum; + r->type = TPOLYTYPE_ALPHA; + r->indices = p->verts; + + memcpy(&transvert[currenttransvert], &transvert[p->firstvert], sizeof(transvert_t) * p->verts); + for (j = 0;j < p->verts;j++) { - VectorSubtract(vert->v, r_origin, diff); - glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], vert->a*(1.0f/255.0f)*exp(fogdensity/DotProduct(diff,diff))); - glVertex3fv(vert->v); + transvert[currenttransvert].r = fogr; + transvert[currenttransvert].g = fogg; + transvert[currenttransvert].b = fogb; + VectorSubtract(transvert[currenttransvert].v, r_origin, diff); + alpha = transvert[currenttransvert].a * exp(fogdensity / DotProduct(diff, diff)); + transvert[currenttransvert].a = (byte) bound(0, alpha, 255); + transvertindex[transvertindices++] = currenttransvert++; } - glEnd (); - glEnable(GL_TEXTURE_2D); } } } } - glEnd(); } + GL_LockArray(0, currenttransvert); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + tpolytype = TPOLYTYPE_ALPHA; + texnum = -1; + transvertindices = 0; + r = rendertranspoly; + rend = r + currentrendertranspoly; + while(r < rend) + { + if (texnum != r->tex) + { + texnum = r->tex; + glBindTexture(GL_TEXTURE_2D, texnum); + } + if (tpolytype != r->type) + { + tpolytype = r->type; + if (tpolytype == TPOLYTYPE_ADD) // additive + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + else // alpha + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } + k = transvertindices; + if (gl_transpolytris.value) + { + do + transvertindices += r->indices, r++; + while (r < rend && r->tex == texnum && r->type == tpolytype); + glDrawElements(GL_TRIANGLES, transvertindices - k, GL_UNSIGNED_INT, &transvertindex[k]); + } + else + { + if (r->indices == 4) + { + do + transvertindices += 4, r++; + while (r < rend && r->indices == 4 && r->tex == texnum && r->type == tpolytype); + glDrawElements(GL_QUADS, transvertindices - k, GL_UNSIGNED_INT, &transvertindex[k]); + } + else if (r->indices == 3) + { + do + transvertindices += 3, r++; + while (r < rend && r->indices == 3 && r->tex == texnum && r->type == tpolytype); + glDrawElements(GL_TRIANGLES, transvertindices - k, GL_UNSIGNED_INT, &transvertindex[k]); + } + else + { + transvertindices += r->indices, r++; + glDrawElements(GL_POLYGON, transvertindices - k, GL_UNSIGNED_INT, &transvertindex[k]); + } + } + } + + GL_UnlockArray(); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDepthMask(1); // enable zbuffer updates - glDisable(GL_ALPHA_TEST); + glDisable(GL_BLEND); + glColor3f(1,1,1); + + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + } void wallpolyclear(void) { + if (!gl_mtexable) + r_multitexture.value = 0; currentwallpoly = currentwallvert = 0; } -void wallpolyrender(void) +// render walls and fullbrights, but not fog +void wallpolyrender1(void) { int i, j, texnum, lighttexnum; wallpoly_t *p; @@ -387,11 +529,9 @@ void wallpolyrender(void) c_brush_polys += currentwallpoly; // testing //Con_DPrintf("wallpolyrender: %i polys %i vertices\n", currentwallpoly, currentwallvert); - if (!gl_mtexable) - r_multitexture.value = 0; glDisable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - glShadeModel(GL_FLAT); +// glShadeModel(GL_FLAT); // make sure zbuffer is enabled glEnable(GL_DEPTH_TEST); // glDisable(GL_ALPHA_TEST); @@ -401,7 +541,7 @@ void wallpolyrender(void) { glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); texnum = -1; - for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++) + for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++) { if (p->texnum != texnum) { @@ -420,40 +560,87 @@ void wallpolyrender(void) } else if (r_multitexture.value) { - qglSelectTexture(gl_mtex_enum+0); - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); - glEnable(GL_TEXTURE_2D); - qglSelectTexture(gl_mtex_enum+1); - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glEnable(GL_TEXTURE_2D); + if (gl_combine.value) + { + qglActiveTexture(GL_TEXTURE0_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0); + glEnable(GL_TEXTURE_2D); + qglActiveTexture(GL_TEXTURE1_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 4.0); + glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0); + glEnable(GL_TEXTURE_2D); + } + else + { + qglActiveTexture(GL_TEXTURE0_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + glEnable(GL_TEXTURE_2D); + qglActiveTexture(GL_TEXTURE1_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glEnable(GL_TEXTURE_2D); + } texnum = -1; lighttexnum = -1; - for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++) + for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++) { - if (p->texnum != texnum || p->lighttexnum != lighttexnum) + if (p->texnum != texnum) { texnum = p->texnum; - lighttexnum = p->lighttexnum; - qglSelectTexture(gl_mtex_enum+0); + qglActiveTexture(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, texnum); - qglSelectTexture(gl_mtex_enum+1); + qglActiveTexture(GL_TEXTURE1_ARB); + } + if (p->lighttexnum != lighttexnum) + { + lighttexnum = p->lighttexnum; glBindTexture(GL_TEXTURE_2D, lighttexnum); } vert = &wallvert[p->firstvert]; glBegin(GL_POLYGON); for (j=0 ; jnumverts ; j++, vert++) { - qglMTexCoord2f(gl_mtex_enum, vert->vert[3], vert->vert[4]); // texture - qglMTexCoord2f((gl_mtex_enum+1), vert->vert[5], vert->vert[6]); // lightmap + qglMultiTexCoord2f(GL_TEXTURE0_ARB, vert->vert[3], vert->vert[4]); // texture + qglMultiTexCoord2f(GL_TEXTURE1_ARB, vert->vert[5], vert->vert[6]); // lightmap glVertex3fv (vert->vert); } glEnd (); } - qglSelectTexture(gl_mtex_enum+1); + qglActiveTexture(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - qglSelectTexture(gl_mtex_enum+0); + qglActiveTexture(GL_TEXTURE0_ARB); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } else @@ -461,7 +648,7 @@ void wallpolyrender(void) // first do the textures glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); texnum = -1; - for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++) + for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++) { if (p->texnum != texnum) { @@ -502,10 +689,10 @@ void wallpolyrender(void) // switch to additive mode settings glDepthMask(0); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glBlendFunc(GL_SRC_ALPHA, GL_ONE); + glBlendFunc(GL_ONE, GL_ONE); glEnable(GL_BLEND); // glDisable(GL_ALPHA_TEST); - glShadeModel(GL_SMOOTH); +// glShadeModel(GL_SMOOTH); // render vertex lit overlays ontop texnum = -1; for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++) @@ -535,14 +722,13 @@ lit: glEnd(); } // render glow textures - glShadeModel(GL_FLAT); - glBlendFunc(GL_ONE, GL_ONE); +// glShadeModel(GL_FLAT); if (lighthalf) glColor3f(0.5,0.5,0.5); else glColor3f(1,1,1); texnum = -1; - for (i = 0,p = wallpoly;i < currentwallpoly;i++, p++) + for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++) { if (!p->glowtexnum) continue; @@ -562,37 +748,61 @@ lit: } glColor3f(1,1,1); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - glShadeModel(GL_SMOOTH); +// glDisable(GL_ALPHA_TEST); +// glShadeModel(GL_SMOOTH); + glDisable(GL_BLEND); + glDepthMask(1); +} + +// render fog +void wallpolyrender2(void) +{ + if (!r_render.value) + return; + if (currentwallpoly < 1) + return; if (fogenabled) { + int i, j, alpha, fogr, fogg, fogb; + wallpoly_t *p; + wallvert_t *vert; vec3_t diff; + glEnable(GL_DEPTH_TEST); + glDepthMask(0); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_BLEND); +// glShadeModel(GL_SMOOTH); glDisable(GL_TEXTURE_2D); - for (i = 0,p = &wallpoly[0];i < currentwallpoly;i++, p++) + fogr = (byte) bound(0, (int) (fogcolor[0] * 255.0f), 255); + fogg = (byte) bound(0, (int) (fogcolor[1] * 255.0f), 255); + fogb = (byte) bound(0, (int) (fogcolor[2] * 255.0f), 255); + for (i = 0, p = wallpoly;i < currentwallpoly;i++, p++) { vert = &wallvert[p->firstvert]; glBegin(GL_POLYGON); for (j=0 ; jnumverts ; j++, vert++) { VectorSubtract(vert->vert, r_origin, diff); - glColor4f(fogcolor[0], fogcolor[1], fogcolor[2], exp(fogdensity/DotProduct(diff,diff))); + alpha = 255.0f * exp(fogdensity/DotProduct(diff,diff)); + alpha = bound(0, alpha, 255); + glColor4ub(fogr, fogg, fogb, (byte) alpha); glVertex3fv (vert->vert); } glEnd (); } glEnable(GL_TEXTURE_2D); + glColor3f(1,1,1); + glDisable(GL_BLEND); + glDepthMask(1); } - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); -// glDisable(GL_ALPHA_TEST); - glShadeModel(GL_SMOOTH); - glDisable(GL_BLEND); - glDepthMask(1); } -int skyrendersphere; -int skyrenderbox; -int skyrenderglquakepolys; -int skyrendertwolayers; +static int skyrendersphere; +static int skyrenderbox; +static int skyrenderglquakepolys; +static int skyrendertwolayers; +static int skyrendercombine; void skypolyclear(void) { @@ -601,6 +811,7 @@ void skypolyclear(void) skyrenderbox = false; skyrenderglquakepolys = false; skyrendertwolayers = false; + skyrendercombine = false; if (r_skyquality.value >= 1 && !fogenabled) { if (skyavailable_box) @@ -615,6 +826,8 @@ void skypolyclear(void) case 2: skyrenderglquakepolys = true; skyrendertwolayers = true; + if (gl_combine.value) + skyrendercombine = true; break; case 3: skyrendersphere = true; @@ -623,6 +836,8 @@ void skypolyclear(void) case 4: skyrendersphere = true; skyrendertwolayers = true; + if (gl_combine.value) + skyrendercombine = true; break; } } @@ -630,6 +845,7 @@ void skypolyclear(void) if (r_mergesky.value && (skyrenderglquakepolys || skyrendersphere)) { skyrendertwolayers = false; + skyrendercombine = false; // R_BuildSky((int) (cl.time * 8.0), (int) (cl.time * 16.0)); // R_BuildSky((int) (cl.time * -8.0), 0); R_BuildSky(0, (int) (cl.time * 8.0)); @@ -637,6 +853,8 @@ void skypolyclear(void) } +static void R_Sky(void); + void skypolyrender(void) { int i, j; @@ -644,6 +862,7 @@ void skypolyrender(void) skyvert_t *vert; float length, speedscale; vec3_t dir; + float y, number; if (!r_render.value) return; if (currentskypoly < 1) @@ -653,126 +872,183 @@ void skypolyrender(void) // make sure zbuffer is enabled glEnable(GL_DEPTH_TEST); glDepthMask(1); + glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].v[0]); + glEnableClientState(GL_VERTEX_ARRAY); + GL_LockArray(0, currentskyvert); + speedscale = cl.time * (8.0/128.0); + speedscale -= (int)speedscale; + for (vert = skyvert, j = 0;j < currentskyvert;j++, vert++) + { + VectorSubtract (vert->v, r_origin, dir); + // flatten the sphere + dir[2] *= 3; + + // LordHavoc: fast version + number = DotProduct(dir, dir); + *((long *)&y) = 0x5f3759df - ((* (long *) &number) >> 1); + length = 3.0f * (y * (1.5f - (number * 0.5f * y * y))); + // LordHavoc: slow version + //length = 3.0f / sqrt(DotProduct(dir, dir)); + + vert->tex2[0] = speedscale + (vert->tex[0] = speedscale + dir[0] * length); + vert->tex2[1] = speedscale + (vert->tex[1] = speedscale + dir[1] * length); + } + + glDisable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + if (skyrenderglquakepolys) { - if (r_mergesky.value) - glBindTexture(GL_TEXTURE_2D, R_GetTexture(mergeskytexture)); // both layers in one texture - else - glBindTexture(GL_TEXTURE_2D, R_GetTexture(solidskytexture)); // upper clouds glTexCoordPointer(2, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].tex[0]); glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].v[0]); - glEnableClientState(GL_VERTEX_ARRAY); - if(lighthalf) - glColor3f(0.5f, 0.5f, 0.5f); - else - glColor3f(1.0f,1.0f,1.0f); - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glEnable(GL_TEXTURE_2D); - glDisable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - if (r_mergesky.value) - { - speedscale = cl.time * (8.0/128.0); - speedscale -= (int)speedscale; - } - else - { - speedscale = cl.time * (8.0/128.0); - speedscale -= (int)speedscale; - } - for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) + + if (skyrendercombine) { - vert = skyvert + p->firstvert; - for (j = 0;j < p->verts;j++, vert++) - { - VectorSubtract (vert->v, r_origin, dir); - // flatten the sphere - dir[2] *= 3; + // upper clouds + glBindTexture(GL_TEXTURE_2D, R_GetTexture(lighthalf ? solidskytexture_half : solidskytexture)); - length = 3.0f / sqrt(DotProduct(dir, dir)); + // set up the second texcoord array + // switch texcoord array selector to TMU 1 + qglClientActiveTexture(GL_TEXTURE1_ARB); + glTexCoordPointer(2, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].tex2[0]); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); - vert->tex[0] = speedscale + dir[0] * length; - vert->tex[1] = speedscale + dir[1] * length; - } - } - GL_LockArray(0, currentskyvert); - for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) - glDrawArrays(GL_POLYGON, p->firstvert, p->verts); - GL_UnlockArray(); - if (skyrendertwolayers) - { - glEnable(GL_BLEND); - glDepthMask(0); - glBindTexture(GL_TEXTURE_2D, R_GetTexture(alphaskytexture)); // lower clouds - speedscale = cl.time * (16.0 / 128.0); - speedscale -= (int)speedscale; - for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) - { - vert = skyvert + p->firstvert; - for (j = 0;j < p->verts;j++, vert++) - { - VectorSubtract (vert->v, r_origin, dir); - // flatten the sphere - dir[2] *= 3; + // render both layers as one pass using GL_ARB_texture_env_combine + // TMU 0 is already selected, the TMU 0 texcoord array is already + // set up, the texture is bound, and texturing is already enabled, + // so just set up COMBINE - length = 3.0f / sqrt(DotProduct(dir, dir)); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); - vert->tex[0] = speedscale + dir[0] * length; - vert->tex[1] = speedscale + dir[1] * length; - } - } + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA); + + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0); + + // set up TMU 1 + qglActiveTexture(GL_TEXTURE1_ARB); + // lower clouds + glBindTexture(GL_TEXTURE_2D, R_GetTexture(lighthalf ? alphaskytexture_half : alphaskytexture)); + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA); + + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0); + glEnable(GL_TEXTURE_2D); + + // draw it + for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) + glDrawArrays(GL_POLYGON, p->firstvert, p->verts); + + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisable(GL_TEXTURE_2D); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + qglActiveTexture(GL_TEXTURE0_ARB); + // switch texcoord array selector back to TMU 0 + qglClientActiveTexture(GL_TEXTURE0_ARB); + // the TMU 0 texcoord array is disabled by the code below + } + else + { + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + if (r_mergesky.value) + glBindTexture(GL_TEXTURE_2D, R_GetTexture(mergeskytexture)); // both layers in one texture + else + glBindTexture(GL_TEXTURE_2D, R_GetTexture(solidskytexture)); // upper clouds + if(lighthalf) + glColor3f(0.5f, 0.5f, 0.5f); + else + glColor3f(1.0f,1.0f,1.0f); + glEnable(GL_TEXTURE_2D); GL_LockArray(0, currentskyvert); for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) glDrawArrays(GL_POLYGON, p->firstvert, p->verts); GL_UnlockArray(); - glDisable(GL_BLEND); + if (skyrendertwolayers) + { + glEnable(GL_BLEND); + glDepthMask(0); + glBindTexture(GL_TEXTURE_2D, R_GetTexture(alphaskytexture)); // lower clouds + // switch to lower clouds texcoord array + glTexCoordPointer(2, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].tex2[0]); + for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) + glDrawArrays(GL_POLYGON, p->firstvert, p->verts); + glDepthMask(1); + glDisable(GL_BLEND); + } + glColor3f(1,1,1); } - glColor3f(1,1,1); - glDepthMask(1); glDisableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_VERTEX_ARRAY); } else { - glVertexPointer(3, GL_FLOAT, sizeof(skyvert_t), &skyvert[0].v[0]); - glEnableClientState(GL_VERTEX_ARRAY); - glDisable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glDisable(GL_TEXTURE_2D); // note: this color is not seen if skyrendersphere or skyrenderbox is on glColor3fv(fogcolor); - GL_LockArray(0, currentskyvert); for (i = 0, p = &skypoly[0];i < currentskypoly;i++, p++) glDrawArrays(GL_POLYGON, p->firstvert, p->verts); - GL_UnlockArray(); glColor3f(1,1,1); glEnable(GL_TEXTURE_2D); - glDisableClientState(GL_VERTEX_ARRAY); } + GL_UnlockArray(); + glDisableClientState(GL_VERTEX_ARRAY); + + R_Sky(); } -char skyname[256]; +static char skyname[256]; /* ================== R_SetSkyBox ================== */ -char *suf[6] = {"rt", "bk", "lf", "ft", "up", "dn"}; -rtexture_t *skyboxside[6]; -void R_SetSkyBox(char *sky) +static char *suf[6] = {"rt", "bk", "lf", "ft", "up", "dn"}; +static rtexture_t *skyboxside[6]; +int R_SetSkyBox(char *sky) { int i; char name[1024]; byte* image_rgba; if (strcmp(sky, skyname) == 0) // no change - return; + return true; if (strlen(sky) > 1000) { Con_Printf ("sky name too long (%i, max is 1000)\n", strlen(sky)); - return; + return false; } skyboxside[0] = skyboxside[1] = skyboxside[2] = skyboxside[3] = skyboxside[4] = skyboxside[5] = NULL; @@ -780,7 +1056,7 @@ void R_SetSkyBox(char *sky) skyname[0] = 0; if (!sky[0]) - return; + return true; for (i = 0;i < 6;i++) { @@ -790,7 +1066,7 @@ void R_SetSkyBox(char *sky) sprintf (name, "gfx/env/%s%s", sky, suf[i]); if (!(image_rgba = loadimagepixels(name, false, 0, 0))) { - Con_Printf ("Couldn't load %s\n", name); + Con_Printf ("Couldn't load env/%s%s or gfx/env/%s%s\n", sky, suf[i], sky, suf[i]); continue; } } @@ -802,7 +1078,9 @@ void R_SetSkyBox(char *sky) { skyavailable_box = true; strcpy(skyname, sky); + return true; } + return false; } // LordHavoc: added LoadSky console command @@ -814,11 +1092,18 @@ void LoadSky_f (void) if (skyname[0]) Con_Printf("current sky: %s\n", skyname); else - Con_Printf("no skybox has been set\n", skyname); + Con_Printf("no skybox has been set\n"); break; case 2: - R_SetSkyBox(Cmd_Argv(1)); - Con_Printf("skybox set to %s\n", skyname); + if (R_SetSkyBox(Cmd_Argv(1))) + { + if (skyname[0]) + Con_Printf("skybox set to %s\n", skyname); + else + Con_Printf("skybox disabled\n"); + } + else + Con_Printf("failed to load skybox %s\n", Cmd_Argv(1)); break; default: Con_Printf("usage: loadsky skyname\n"); @@ -830,7 +1115,7 @@ void LoadSky_f (void) glTexCoord2f((s) * (254.0f/256.0f) + (1.0f/256.0f), (t) * (254.0f/256.0f) + (1.0f/256.0f));\ glVertex3f((x) * 1024.0 + r_origin[0], (y) * 1024.0 + r_origin[1], (z) * 1024.0 + r_origin[2]); -void R_SkyBox(void) +static void R_SkyBox(void) { glDisable(GL_DEPTH_TEST); glDepthMask(0); @@ -887,10 +1172,9 @@ void R_SkyBox(void) glColor3f (1,1,1); } -float skysphereouter[33*33*5]; -float skysphereinner[33*33*5]; -int skysphereindices[32*32*6]; -void skyspherecalc(float *sphere, float dx, float dy, float dz) +static float skysphere[33*33*5]; +static int skysphereindices[32*32*6]; +static void skyspherecalc(float *sphere, float dx, float dy, float dz) { float a, b, x, ax, ay, v[3], length; int i, j, *index; @@ -929,41 +1213,36 @@ void skyspherecalc(float *sphere, float dx, float dy, float dz) } } -void skysphere(float *source, float s) +static void skyspherearrays(float *vert, float *tex, float *tex2, float *source, float s, float s2) { - float vert[33*33][4], tex[33*33][2], *v, *t; + float *v, *t, *t2; int i; - v = &vert[0][0]; - t = &tex[0][0]; + v = vert; + t = tex; + t2 = tex2; for (i = 0;i < (33*33);i++) { - *t++ = *source++ + s; - *t++ = *source++ + s; - *v++ = *source++ + r_origin[0]; - *v++ = *source++ + r_origin[1]; - *v++ = *source++ + r_origin[2]; + *t++ = source[0] + s; + *t++ = source[1] + s; + *t2++ = source[0] + s2; + *t2++ = source[1] + s2; + *v++ = source[2] + r_origin[0]; + *v++ = source[3] + r_origin[1]; + *v++ = source[4] + r_origin[2]; *v++ = 0; + source += 5; } - glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 2, tex); - glVertexPointer(3, GL_FLOAT, sizeof(float) * 4, vert); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - GL_LockArray(0, 32*32*6); - glDrawElements(GL_TRIANGLES, 32*32*6, GL_UNSIGNED_INT, &skysphereindices[0]); - GL_UnlockArray(); - glDisableClientState(GL_VERTEX_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } -void R_SkySphere(void) +static void R_SkySphere(void) { - float speedscale; + float speedscale, speedscale2; + float vert[33*33*4], tex[33*33*2], tex2[33*33*2]; static qboolean skysphereinitialized = false; if (!skysphereinitialized) { skysphereinitialized = true; - skyspherecalc(skysphereouter, 1024, 1024, 1024 / 3); - skyspherecalc(skysphereinner, 1024, 1024, 1024 / 3); + skyspherecalc(skysphere, 1024, 1024, 1024 / 3); } glDisable(GL_DEPTH_TEST); glDepthMask(0); @@ -974,35 +1253,127 @@ void R_SkySphere(void) glColor3f(0.5,0.5,0.5); else glColor3f(1,1,1); + speedscale = cl.time*8.0/128.0; + speedscale -= (int)speedscale; + speedscale2 = cl.time*16.0/128.0; + speedscale2 -= (int)speedscale2; + skyspherearrays(vert, tex, tex2, skysphere, speedscale, speedscale2); + glVertexPointer(3, GL_FLOAT, sizeof(float) * 4, vert); + glEnableClientState(GL_VERTEX_ARRAY); + // do not lock the texcoord array, because it will be switched + GL_LockArray(0, 32*32*6); + glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 2, tex); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); if (r_mergesky.value) { glBindTexture(GL_TEXTURE_2D, R_GetTexture(mergeskytexture)); // both layers in one texture - speedscale = cl.time*8.0/128.0; - speedscale -= (int)speedscale; - skysphere(skysphereouter, speedscale); + glDrawElements(GL_TRIANGLES, 32*32*6, GL_UNSIGNED_INT, &skysphereindices[0]); } else { - glBindTexture(GL_TEXTURE_2D, R_GetTexture(solidskytexture)); // upper clouds - speedscale = cl.time*8.0/128.0; - speedscale -= (int)speedscale; - skysphere(skysphereouter, speedscale); - if (skyrendertwolayers) + // LordHavoc: note that this combine operation does not use the color, + // so it has to use alternate textures in lighthalf mode + if (skyrendercombine) { - glEnable (GL_BLEND); - glBindTexture(GL_TEXTURE_2D, R_GetTexture(alphaskytexture)); // lower clouds - speedscale = cl.time*16.0/128.0; - speedscale -= (int)speedscale; - skysphere(skysphereinner, speedscale); - glDisable (GL_BLEND); + // upper clouds + glBindTexture(GL_TEXTURE_2D, R_GetTexture(lighthalf ? solidskytexture_half : solidskytexture)); + + // set up the second texcoord array + // switch texcoord array selector to TMU 1 + qglClientActiveTexture(GL_TEXTURE1_ARB); + glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 2, tex2); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + + // render both layers as one pass using GL_ARB_texture_env_combine + // TMU 0 is already selected, the TMU 0 texcoord array is already + // set up, the texture is bound, and texturing is already enabled, + // so just set up COMBINE + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA); + + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0); + + // set up TMU 1 + qglActiveTexture(GL_TEXTURE1_ARB); + // lower clouds + glBindTexture(GL_TEXTURE_2D, R_GetTexture(lighthalf ? alphaskytexture_half : alphaskytexture)); + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA); + + glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_TEXTURE); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA); + glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA); + + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0); + glTexEnvf(GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1.0); + glEnable(GL_TEXTURE_2D); + + // draw it + glDrawElements(GL_TRIANGLES, 32*32*6, GL_UNSIGNED_INT, &skysphereindices[0]); + + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisable(GL_TEXTURE_2D); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + qglActiveTexture(GL_TEXTURE0_ARB); + // switch texcoord array selector back to TMU 0 + qglClientActiveTexture(GL_TEXTURE0_ARB); + // the TMU 0 texcoord array is disabled by the code below + } + else + { + glBindTexture(GL_TEXTURE_2D, R_GetTexture(solidskytexture)); // upper clouds + glDrawElements(GL_TRIANGLES, 32*32*6, GL_UNSIGNED_INT, &skysphereindices[0]); + + if (skyrendertwolayers) + { + glEnable (GL_BLEND); + glBindTexture(GL_TEXTURE_2D, R_GetTexture(alphaskytexture)); // lower clouds + glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 2, tex2); + glDrawElements(GL_TRIANGLES, 32*32*6, GL_UNSIGNED_INT, &skysphereindices[0]); + glDisable (GL_BLEND); + } } } + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + GL_UnlockArray(); + glDisableClientState(GL_VERTEX_ARRAY); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glDepthMask(1); glEnable (GL_DEPTH_TEST); glColor3f (1,1,1); } -void R_Sky(void) +static void R_Sky(void) { if (!r_render.value) return; @@ -1014,11 +1385,11 @@ void R_Sky(void) //=============================================================== -byte skyupperlayerpixels[128*128*4]; -byte skylowerlayerpixels[128*128*4]; -byte skymergedpixels[128*128*4]; +static byte skyupperlayerpixels[128*128*4]; +static byte skylowerlayerpixels[128*128*4]; +static byte skymergedpixels[128*128*4]; -void R_BuildSky (int scrollupper, int scrolllower) +static void R_BuildSky (int scrollupper, int scrolllower) { int x, y, ux, uy, lx, ly; byte *m, *u, *l; @@ -1112,6 +1483,13 @@ void R_InitSky (byte *src, int bytesperpixel) memcpy(skyupperlayerpixels, trans, 128*128*4); solidskytexture = R_LoadTexture ("sky_solidtexture", 128, 128, (byte *) trans, TEXF_RGBA | TEXF_PRECACHE); + for (i = 0;i < 128*128;i++) + { + ((byte *)&trans[i])[0] >>= 1; + ((byte *)&trans[i])[1] >>= 1; + ((byte *)&trans[i])[2] >>= 1; + } + solidskytexture_half = R_LoadTexture ("sky_solidtexture_half", 128, 128, (byte *) trans, TEXF_RGBA | TEXF_PRECACHE); if (bytesperpixel == 4) { @@ -1137,4 +1515,11 @@ void R_InitSky (byte *src, int bytesperpixel) memcpy(skylowerlayerpixels, trans, 128*128*4); alphaskytexture = R_LoadTexture ("sky_alphatexture", 128, 128, (byte *) trans, TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE); + for (i = 0;i < 128*128;i++) + { + ((byte *)&trans[i])[0] >>= 1; + ((byte *)&trans[i])[1] >>= 1; + ((byte *)&trans[i])[2] >>= 1; + } + alphaskytexture_half = R_LoadTexture ("sky_alphatexture_half", 128, 128, (byte *) trans, TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE); }