nzp-team/quakespasm
0
0
Fork 0
mirror of https://github.com/nzp-team/quakespasm.git synced 2024-11-25 21:31:40 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakespasm/source/gl_sky.c
cypress e6827d3140 NX/VITA: Proper fog implementation
2023-09-02 22:01:12 -04:00

1032 lines
21 KiB
C
Raw Blame History

/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2007-2008 Kristian Duske
Copyright (C) 2010-2014 QuakeSpasm developers
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//gl_sky.c
#include "quakedef.h"
#define MAX_CLIP_VERTS 64
float Fog_GetDensity(void);
float *Fog_GetColor(void);
extern qmodel_t *loadmodel;
extern int rs_skypolys; //for r_speeds readout
extern int rs_skypasses; //for r_speeds readout
float skyflatcolor[3];
float skymins[2][6], skymaxs[2][6];
char skybox_name[32] = ""; //name of current skybox, or "" if no skybox
gltexture_t *skybox_textures[6];
gltexture_t *solidskytexture, *alphaskytexture;
extern cvar_t gl_farclip;
cvar_t r_fastsky = {"r_fastsky", "0", CVAR_NONE};
cvar_t r_sky_quality = {"r_sky_quality", "12", CVAR_NONE};
cvar_t r_skyalpha = {"r_skyalpha", "1", CVAR_NONE};
cvar_t r_skyfog = {"r_skyfog","0.5",CVAR_NONE};
int skytexorder[6] = {0,2,1,3,4,5}; //for skybox
vec3_t skyclip[6] = {
{1,1,0},
{1,-1,0},
{0,-1,1},
{0,1,1},
{1,0,1},
{-1,0,1}
};
int st_to_vec[6][3] =
{
{3,-1,2},
{-3,1,2},
{1,3,2},
{-1,-3,2},
{-2,-1,3}, // straight up
{2,-1,-3} // straight down
};
int vec_to_st[6][3] =
{
{-2,3,1},
{2,3,-1},
{1,3,2},
{-1,3,-2},
{-2,-1,3},
{-2,1,-3}
};
float skyfog; // ericw
//==============================================================================
//
// INIT
//
//==============================================================================
/*
=============
Sky_LoadTexture
A sky texture is 256*128, with the left side being a masked overlay
==============
*/
void Sky_LoadTexture (texture_t *mt)
{
char texturename[64];
int i, j, p, r, g, b, count;
byte *src;
static byte front_data[128*128]; //FIXME: Hunk_Alloc
static byte back_data[128*128]; //FIXME: Hunk_Alloc
unsigned *rgba;
src = (byte *)mt + mt->offsets[0];
// extract back layer and upload
for (i=0 ; i<128 ; i++)
for (j=0 ; j<128 ; j++)
back_data[(i*128) + j] = src[i*256 + j + 128];
q_snprintf(texturename, sizeof(texturename), "%s:%s_back", loadmodel->name, mt->name);
solidskytexture = TexMgr_LoadImage (loadmodel, texturename, 128, 128, SRC_INDEXED, back_data, "", (src_offset_t)back_data, TEXPREF_NONE);
// extract front layer and upload
for (i=0 ; i<128 ; i++)
for (j=0 ; j<128 ; j++)
{
front_data[(i*128) + j] = src[i*256 + j];
if (front_data[(i*128) + j] == 0)
front_data[(i*128) + j] = 255;
}
q_snprintf(texturename, sizeof(texturename), "%s:%s_front", loadmodel->name, mt->name);
alphaskytexture = TexMgr_LoadImage (loadmodel, texturename, 128, 128, SRC_INDEXED, front_data, "", (src_offset_t)front_data, TEXPREF_ALPHA);
// calculate r_fastsky color based on average of all opaque foreground colors
r = g = b = count = 0;
for (i=0 ; i<128 ; i++)
for (j=0 ; j<128 ; j++)
{
p = src[i*256 + j];
if (p != 0)
{
rgba = &d_8to24table[p];
r += ((byte *)rgba)[0];
g += ((byte *)rgba)[1];
b += ((byte *)rgba)[2];
count++;
}
}
skyflatcolor[0] = (float)r/(count*255);
skyflatcolor[1] = (float)g/(count*255);
skyflatcolor[2] = (float)b/(count*255);
}
/*
==================
Sky_LoadSkyBox
==================
*/
const char *suf[6] = {"rt", "bk", "lf", "ft", "up", "dn"};
void Sky_LoadSkyBox (const char *name)
{
int i, mark, width, height;
char filename[MAX_OSPATH];
byte *data;
qboolean nonefound = true;
if (strcmp(skybox_name, name) == 0)
return; //no change
//purge old textures
for (i=0; i<6; i++)
{
if (skybox_textures[i] && skybox_textures[i] != notexture)
TexMgr_FreeTexture (skybox_textures[i]);
skybox_textures[i] = NULL;
}
//turn off skybox if sky is set to ""
if (name[0] == 0)
{
skybox_name[0] = 0;
return;
}
//load textures
for (i=0; i<6; i++)
{
mark = Hunk_LowMark ();
q_snprintf (filename, sizeof(filename), "gfx/env/%s%s", name, suf[i]);
data = Image_LoadImage (filename, &width, &height);
if (data)
{
skybox_textures[i] = TexMgr_LoadImage (cl.worldmodel, filename, width, height, SRC_RGBA, data, filename, 0, TEXPREF_NONE);
nonefound = false;
}
else
{
Con_Printf ("Couldn't load %s\n", filename);
skybox_textures[i] = notexture;
}
Hunk_FreeToLowMark (mark);
}
if (nonefound) // go back to scrolling sky if skybox is totally missing
{
for (i=0; i<6; i++)
{
if (skybox_textures[i] && skybox_textures[i] != notexture)
TexMgr_FreeTexture (skybox_textures[i]);
skybox_textures[i] = NULL;
}
skybox_name[0] = 0;
return;
}
strcpy(skybox_name, name);
}
/*
=================
Sky_NewMap
=================
*/
void Sky_NewMap (void)
{
char key[128], value[4096];
const char *data;
int i;
//
// initially no sky
//
skybox_name[0] = 0;
for (i=0; i<6; i++)
skybox_textures[i] = NULL;
//skyfog = r_skyfog.value;
//
// read worldspawn (this is so ugly, and shouldn't it be done on the server?)
//
data = cl.worldmodel->entities;
if (!data)
Sys_Error("Could not init Sky_NewMap"); //FIXME: how could this possibly ever happen? -- if there's no
// worldspawn then the sever wouldn't send the loadmap message to the client
data = COM_Parse(data);
if (!data) //should never happen
return; // error
if (com_token[0] != '{') //should never happen
return; // error
while (1)
{
data = COM_Parse(data);
if (!data)
return; // error
if (com_token[0] == '}')
break; // end of worldspawn
if (com_token[0] == '_')
strcpy(key, com_token + 1);
else
strcpy(key, com_token);
while (key[strlen(key)-1] == ' ') // remove trailing spaces
key[strlen(key)-1] = 0;
data = COM_Parse(data);
if (!data)
return; // error
strcpy(value, com_token);
if (!strcmp("sky", key))
Sky_LoadSkyBox(value);
//if (!strcmp("skyfog", key))
//skyfog = atof(value);
#if 1 //also accept non-standard keys
else if (!strcmp("skyname", key)) //half-life
Sky_LoadSkyBox(value);
else if (!strcmp("qlsky", key)) //quake lives
Sky_LoadSkyBox(value);
#endif
}
}
/*
=================
Sky_SkyCommand_f
=================
*/
void Sky_SkyCommand_f (void)
{
switch (Cmd_Argc())
{
case 1:
Con_Printf("\"sky\" is \"%s\"\n", skybox_name);
break;
case 2:
Sky_LoadSkyBox(Cmd_Argv(1));
break;
default:
Con_Printf("usage: sky <skyname>\n");
}
}
/*
====================
R_SetSkyfog_f -- ericw
====================
*/
static void R_SetSkyfog_f (cvar_t *var)
{
// clear any skyfog setting from worldspawn
skyfog = var->value;
}
/*
=============
Sky_Init
=============
*/
void Sky_Init (void)
{
int i;
Cvar_RegisterVariable (&r_fastsky);
Cvar_RegisterVariable (&r_sky_quality);
Cvar_RegisterVariable (&r_skyalpha);
Cvar_RegisterVariable (&r_skyfog);
Cvar_SetCallback (&r_skyfog, R_SetSkyfog_f);
Cmd_AddCommand ("sky",Sky_SkyCommand_f);
for (i=0; i<6; i++)
skybox_textures[i] = NULL;
}
//==============================================================================
//
// PROCESS SKY SURFS
//
//==============================================================================
/*
=================
Sky_ProjectPoly
update sky bounds
=================
*/
void Sky_ProjectPoly (int nump, vec3_t vecs)
{
int i,j;
vec3_t v, av;
float s, t, dv;
int axis;
float *vp;
// decide which face it maps to
VectorCopy (vec3_origin, v);
for (i=0, vp=vecs ; i<nump ; i++, vp+=3)
{
VectorAdd (vp, v, v);
}
av[0] = fabs(v[0]);
av[1] = fabs(v[1]);
av[2] = fabs(v[2]);
if (av[0] > av[1] && av[0] > av[2])
{
if (v[0] < 0)
axis = 1;
else
axis = 0;
}
else if (av[1] > av[2] && av[1] > av[0])
{
if (v[1] < 0)
axis = 3;
else
axis = 2;
}
else
{
if (v[2] < 0)
axis = 5;
else
axis = 4;
}
// project new texture coords
for (i=0 ; i<nump ; i++, vecs+=3)
{
j = vec_to_st[axis][2];
if (j > 0)
dv = vecs[j - 1];
else
dv = -vecs[-j - 1];
j = vec_to_st[axis][0];
if (j < 0)
s = -vecs[-j -1] / dv;
else
s = vecs[j-1] / dv;
j = vec_to_st[axis][1];
if (j < 0)
t = -vecs[-j -1] / dv;
else
t = vecs[j-1] / dv;
if (s < skymins[0][axis])
skymins[0][axis] = s;
if (t < skymins[1][axis])
skymins[1][axis] = t;
if (s > skymaxs[0][axis])
skymaxs[0][axis] = s;
if (t > skymaxs[1][axis])
skymaxs[1][axis] = t;
}
}
/*
=================
Sky_ClipPoly
=================
*/
void Sky_ClipPoly (int nump, vec3_t vecs, int stage)
{
float *norm;
float *v;
qboolean front, back;
float d, e;
float dists[MAX_CLIP_VERTS];
int sides[MAX_CLIP_VERTS];
vec3_t newv[2][MAX_CLIP_VERTS];
int newc[2];
int i, j;
if (nump > MAX_CLIP_VERTS-2)
Sys_Error ("Sky_ClipPoly: MAX_CLIP_VERTS");
if (stage == 6) // fully clipped
{
Sky_ProjectPoly (nump, vecs);
return;
}
front = back = false;
norm = skyclip[stage];
for (i=0, v = vecs ; i<nump ; i++, v+=3)
{
d = DotProduct (v, norm);
if (d > ON_EPSILON)
{
front = true;
sides[i] = SIDE_FRONT;
}
else if (d < ON_EPSILON)
{
back = true;
sides[i] = SIDE_BACK;
}
else
sides[i] = SIDE_ON;
dists[i] = d;
}
if (!front || !back)
{ // not clipped
Sky_ClipPoly (nump, vecs, stage+1);
return;
}
// clip it
sides[i] = sides[0];
dists[i] = dists[0];
VectorCopy (vecs, (vecs+(i*3)) );
newc[0] = newc[1] = 0;
for (i=0, v = vecs ; i<nump ; i++, v+=3)
{
switch (sides[i])
{
case SIDE_FRONT:
VectorCopy (v, newv[0][newc[0]]);
newc[0]++;
break;
case SIDE_BACK:
VectorCopy (v, newv[1][newc[1]]);
newc[1]++;
break;
case SIDE_ON:
VectorCopy (v, newv[0][newc[0]]);
newc[0]++;
VectorCopy (v, newv[1][newc[1]]);
newc[1]++;
break;
}
if (sides[i] == SIDE_ON || sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
continue;
d = dists[i] / (dists[i] - dists[i+1]);
for (j=0 ; j<3 ; j++)
{
e = v[j] + d*(v[j+3] - v[j]);
newv[0][newc[0]][j] = e;
newv[1][newc[1]][j] = e;
}
newc[0]++;
newc[1]++;
}
// continue
Sky_ClipPoly (newc[0], newv[0][0], stage+1);
Sky_ClipPoly (newc[1], newv[1][0], stage+1);
}
/*
================
Sky_ProcessPoly
================
*/
void Sky_ProcessPoly (glpoly_t *p)
{
int i;
vec3_t verts[MAX_CLIP_VERTS];
//draw it
DrawGLPoly(p);
rs_brushpasses++;
//update sky bounds
if (!r_fastsky.value)
{
for (i=0 ; i<p->numverts ; i++)
VectorSubtract (p->verts[i], r_origin, verts[i]);
Sky_ClipPoly (p->numverts, verts[0], 0);
}
}
/*
================
Sky_ProcessTextureChains -- handles sky polys in world model
================
*/
void Sky_ProcessTextureChains (void)
{
int i;
msurface_t *s;
texture_t *t;
if (!r_drawworld_cheatsafe)
return;
for (i=0 ; i<cl.worldmodel->numtextures ; i++)
{
t = cl.worldmodel->textures[i];
if (!t || !t->texturechains[chain_world] || !(t->texturechains[chain_world]->flags & SURF_DRAWSKY))
continue;
for (s = t->texturechains[chain_world]; s; s = s->texturechain)
if (!s->culled)
Sky_ProcessPoly (s->polys);
}
}
/*
================
Sky_ProcessEntities -- handles sky polys on brush models
================
*/
void Sky_ProcessEntities (void)
{
entity_t *e;
msurface_t *s;
glpoly_t *p;
int i,j,k,mark;
float dot;
qboolean rotated;
vec3_t temp, forward, right, up;
if (!r_drawentities.value)
return;
for (i=0 ; i<cl_numvisedicts ; i++)
{
e = cl_visedicts[i];
if (e->model->type != mod_brush)
continue;
if (R_CullModelForEntity(e))
continue;
if (e->alpha == ENTALPHA_ZERO)
continue;
VectorSubtract (r_refdef.vieworg, e->origin, modelorg);
if (e->angles[0] || e->angles[1] || e->angles[2])
{
rotated = true;
AngleVectors (e->angles, forward, right, up);
VectorCopy (modelorg, temp);
modelorg[0] = DotProduct (temp, forward);
modelorg[1] = -DotProduct (temp, right);
modelorg[2] = DotProduct (temp, up);
}
else
rotated = false;
s = &e->model->surfaces[e->model->firstmodelsurface];
for (j=0 ; j<e->model->nummodelsurfaces ; j++, s++)
{
if (s->flags & SURF_DRAWSKY)
{
dot = DotProduct (modelorg, s->plane->normal) - s->plane->dist;
if (((s->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
(!(s->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
{
//copy the polygon and translate manually, since Sky_ProcessPoly needs it to be in world space
mark = Hunk_LowMark();
p = (glpoly_t *) Hunk_Alloc (sizeof(*s->polys)); //FIXME: don't allocate for each poly
p->numverts = s->polys->numverts;
for (k=0; k<p->numverts; k++)
{
if (rotated)
{
p->verts[k][0] = e->origin[0] + s->polys->verts[k][0] * forward[0]
- s->polys->verts[k][1] * right[0]
+ s->polys->verts[k][2] * up[0];
p->verts[k][1] = e->origin[1] + s->polys->verts[k][0] * forward[1]
- s->polys->verts[k][1] * right[1]
+ s->polys->verts[k][2] * up[1];
p->verts[k][2] = e->origin[2] + s->polys->verts[k][0] * forward[2]
- s->polys->verts[k][1] * right[2]
+ s->polys->verts[k][2] * up[2];
}
else
VectorAdd(s->polys->verts[k], e->origin, p->verts[k]);
}
Sky_ProcessPoly (p);
Hunk_FreeToLowMark (mark);
}
}
}
}
}
//==============================================================================
//
// RENDER SKYBOX
//
//==============================================================================
/*
==============
Sky_EmitSkyBoxVertex
==============
*/
void Sky_EmitSkyBoxVertex (float s, float t, int axis)
{
vec3_t v, b;
int j, k;
float w, h;
b[0] = s * gl_farclip.value / sqrt(3.0);
b[1] = t * gl_farclip.value / sqrt(3.0);
b[2] = gl_farclip.value / sqrt(3.0);
for (j=0 ; j<3 ; j++)
{
k = st_to_vec[axis][j];
if (k < 0)
v[j] = -b[-k - 1];
else
v[j] = b[k - 1];
v[j] += r_origin[j];
}
// convert from range [-1,1] to [0,1]
s = (s+1)*0.5;
t = (t+1)*0.5;
// avoid bilerp seam
w = skybox_textures[skytexorder[axis]]->width;
h = skybox_textures[skytexorder[axis]]->height;
s = s * (w-1)/w + 0.5/w;
t = t * (h-1)/h + 0.5/h;
t = 1.0 - t;
glTexCoord2f (s, t);
glVertex3fv (v);
}
/*
==============
Sky_DrawSkyBox
FIXME: eliminate cracks by adding an extra vert on tjuncs
==============
*/
void Sky_DrawSkyBox (void)
{
int i;
for (i=0 ; i<6 ; i++)
{
if (skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i])
continue;
GL_Bind (skybox_textures[skytexorder[i]]);
#if 1 //FIXME: this is to avoid tjunctions until i can do it the right way
skymins[0][i] = -1;
skymins[1][i] = -1;
skymaxs[0][i] = 1;
skymaxs[1][i] = 1;
#endif
glBegin (GL_QUADS);
Sky_EmitSkyBoxVertex (skymins[0][i], skymins[1][i], i);
Sky_EmitSkyBoxVertex (skymins[0][i], skymaxs[1][i], i);
Sky_EmitSkyBoxVertex (skymaxs[0][i], skymaxs[1][i], i);
Sky_EmitSkyBoxVertex (skymaxs[0][i], skymins[1][i], i);
glEnd ();
rs_skypolys++;
rs_skypasses++;
/*if (Fog_GetDensity() > 0 && skyfog > 0)
{
float *c;
c = Fog_GetColor();
glEnable (GL_BLEND);
glDisable (GL_TEXTURE_2D);
glColor4f (c[0],c[1],c[2], CLAMP(0.0,skyfog,1.0));
glBegin (GL_QUADS);
Sky_EmitSkyBoxVertex (skymins[0][i], skymins[1][i], i);
Sky_EmitSkyBoxVertex (skymins[0][i], skymaxs[1][i], i);
Sky_EmitSkyBoxVertex (skymaxs[0][i], skymaxs[1][i], i);
Sky_EmitSkyBoxVertex (skymaxs[0][i], skymins[1][i], i);
glEnd ();
glColor3f (1, 1, 1);
glEnable (GL_TEXTURE_2D);
glDisable (GL_BLEND);
rs_skypasses++;
}*/
}
}
//==============================================================================
//
// RENDER CLOUDS
//
//==============================================================================
/*
==============
Sky_SetBoxVert
==============
*/
void Sky_SetBoxVert (float s, float t, int axis, vec3_t v)
{
vec3_t b;
int j, k;
b[0] = s * gl_farclip.value / sqrt(3.0);
b[1] = t * gl_farclip.value / sqrt(3.0);
b[2] = gl_farclip.value / sqrt(3.0);
for (j=0 ; j<3 ; j++)
{
k = st_to_vec[axis][j];
if (k < 0)
v[j] = -b[-k - 1];
else
v[j] = b[k - 1];
v[j] += r_origin[j];
}
}
/*
=============
Sky_GetTexCoord
=============
*/
void Sky_GetTexCoord (vec3_t v, float speed, float *s, float *t)
{
vec3_t dir;
float length, scroll;
VectorSubtract (v, r_origin, dir);
dir[2] *= 3; // flatten the sphere
length = dir[0]*dir[0] + dir[1]*dir[1] + dir[2]*dir[2];
length = sqrt (length);
length = 6*63/length;
scroll = cl.time*speed;
scroll -= (int)scroll & ~127;
*s = (scroll + dir[0] * length) * (1.0/128);
*t = (scroll + dir[1] * length) * (1.0/128);
}
/*
===============
Sky_DrawFaceQuad
===============
*/
void Sky_DrawFaceQuad (glpoly_t *p)
{
float s, t;
float *v;
int i;
if (gl_mtexable) // && r_skyalpha.value >= 1.0
{
GL_Bind (solidskytexture);
GL_EnableMultitexture();
GL_Bind (alphaskytexture);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glBegin (GL_QUADS);
for (i=0, v=p->verts[0] ; i<4 ; i++, v+=VERTEXSIZE)
{
Sky_GetTexCoord (v, 8, &s, &t);
GL_MTexCoord2fFunc (GL_TEXTURE0_ARB, s, t);
Sky_GetTexCoord (v, 16, &s, &t);
GL_MTexCoord2fFunc (GL_TEXTURE1_ARB, s, t);
glVertex3fv (v);
}
glEnd ();
GL_DisableMultitexture();
rs_skypolys++;
rs_skypasses++;
}
else
{
GL_Bind (solidskytexture);
//if (r_skyalpha.value < 1.0)
//glColor3f (1, 1, 1);
glBegin (GL_QUADS);
for (i=0, v=p->verts[0] ; i<4 ; i++, v+=VERTEXSIZE)
{
Sky_GetTexCoord (v, 8, &s, &t);
glTexCoord2f (s, t);
glVertex3fv (v);
}
glEnd ();
GL_Bind (alphaskytexture);
glEnable (GL_BLEND);
//if (r_skyalpha.value < 1.0)
//glColor4f (1, 1, 1, r_skyalpha.value);
glBegin (GL_QUADS);
for (i=0, v=p->verts[0] ; i<4 ; i++, v+=VERTEXSIZE)
{
Sky_GetTexCoord (v, 16, &s, &t);
glTexCoord2f (s, t);
glVertex3fv (v);
}
glEnd ();
glDisable (GL_BLEND);
rs_skypolys++;
rs_skypasses += 2;
}
/*if (Fog_GetDensity() > 0 && skyfog > 0)
{
float *c;
c = Fog_GetColor();
glEnable (GL_BLEND);
glDisable (GL_TEXTURE_2D);
glColor4f (c[0],c[1],c[2], CLAMP(0.0,skyfog,1.0));
glBegin (GL_QUADS);
for (i=0, v=p->verts[0] ; i<4 ; i++, v+=VERTEXSIZE)
glVertex3fv (v);
glEnd ();
glColor3f (1, 1, 1);
glEnable (GL_TEXTURE_2D);
glDisable (GL_BLEND);
rs_skypasses++;
}*/
}
/*
==============
Sky_DrawFace
==============
*/
void Sky_DrawFace (int axis)
{
glpoly_t *p;
vec3_t verts[4];
int i, j, start;
float di,qi,dj,qj;
vec3_t vup, vright, temp, temp2;
Sky_SetBoxVert(-1.0, -1.0, axis, verts[0]);
Sky_SetBoxVert(-1.0, 1.0, axis, verts[1]);
Sky_SetBoxVert(1.0, 1.0, axis, verts[2]);
Sky_SetBoxVert(1.0, -1.0, axis, verts[3]);
start = Hunk_LowMark ();
p = (glpoly_t *) Hunk_Alloc(sizeof(glpoly_t));
VectorSubtract(verts[2],verts[3],vup);
VectorSubtract(verts[2],verts[1],vright);
di = q_max((int)r_sky_quality.value, 1);
qi = 1.0 / di;
dj = (axis < 4) ? di*2 : di; //subdivide vertically more than horizontally on skybox sides
qj = 1.0 / dj;
for (i=0; i<di; i++)
{
for (j=0; j<dj; j++)
{
if (i*qi < skymins[0][axis]/2+0.5 - qi || i*qi > skymaxs[0][axis]/2+0.5 ||
j*qj < skymins[1][axis]/2+0.5 - qj || j*qj > skymaxs[1][axis]/2+0.5)
continue;
//if (i&1 ^ j&1) continue; //checkerboard test
VectorScale (vright, qi*i, temp);
VectorScale (vup, qj*j, temp2);
VectorAdd(temp,temp2,temp);
VectorAdd(verts[0],temp,p->verts[0]);
VectorScale (vup, qj, temp);
VectorAdd (p->verts[0],temp,p->verts[1]);
VectorScale (vright, qi, temp);
VectorAdd (p->verts[1],temp,p->verts[2]);
VectorAdd (p->verts[0],temp,p->verts[3]);
Sky_DrawFaceQuad (p);
}
}
Hunk_FreeToLowMark (start);
}
/*
==============
Sky_DrawSkyLayers
draws the old-style scrolling cloud layers
==============
*/
void Sky_DrawSkyLayers (void)
{
int i;
if (r_skyalpha.value < 1.0)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
for (i=0 ; i<6 ; i++)
if (skymins[0][i] < skymaxs[0][i] && skymins[1][i] < skymaxs[1][i])
Sky_DrawFace (i);
if (r_skyalpha.value < 1.0)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
/*
==============
Sky_DrawSky
called once per frame before drawing anything else
==============
*/
void Sky_DrawSky (void)
{
int i;
//in these special render modes, the sky faces are handled in the normal world/brush renderer
if (r_drawflat_cheatsafe || r_lightmap_cheatsafe )
return;
//
// reset sky bounds
//
for (i=0 ; i<6 ; i++)
{
skymins[0][i] = skymins[1][i] = 9999;
skymaxs[0][i] = skymaxs[1][i] = -9999;
}
//
// process world and bmodels: draw flat-shaded sky surfs, and update skybounds
//
Fog_DisableGFog ();
glDisable (GL_TEXTURE_2D);
/*if (Fog_GetDensity() > 0)
glColor3fv (Fog_GetColor());
else*/
//glColor3fv (skyflatcolor);
//glColor3fv (Fog_GetColor());
Sky_ProcessTextureChains ();
Sky_ProcessEntities ();
//glColor3f (1, 1, 1);
glEnable (GL_TEXTURE_2D);
//
// render slow sky: cloud layers or skybox
//
if (!r_fastsky.value)
{
glDepthFunc(GL_GEQUAL);
glDepthMask(0);
if (skybox_name[0])
Sky_DrawSkyBox ();
else
Sky_DrawSkyLayers();
glDepthMask(1);
glDepthFunc(GL_LEQUAL);
}
Fog_EnableGFog ();
}
Reference in a new issue View git blame Copy permalink