nzp-team/quakespasm
0
0
Fork 0
mirror of https://github.com/nzp-team/quakespasm.git synced 2024-11-10 06:32:03 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakespasm/source/gl_sky.c

1174 lines
26 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);
}
extern float fog_red, fog_green, fog_blue;
extern vec3_t NULLVEC;
void DrawSkyFogBlend (float skydepth) {
float skyfogblend = 0.6f;
//if (skyfogblend <= 0) return;
float endheight = skydepth * skyfogblend;
float startheight = MIN(skydepth * 0.075f, endheight * 0.3f);
glDisable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glShadeModel(GL_SMOOTH);
glEnable(GL_BLEND);
float r = MIN(1.0f, fog_red * 0.01f);
float g = MIN(1.0f, fog_green * 0.01f);
float b = MIN(1.0f, fog_blue * 0.01f);
for (int i = -2; i < 2; i++) {
for (int j = 0; j < 2; j++) {
const int unclipped_vertex_count = 4;
vec3_t verts[unclipped_vertex_count];
vec3_t angles, forward, right;
angles[PITCH] = 0.f;
angles[YAW] = r_refdef.viewangles[YAW];
angles[ROLL] = 0.f;
AngleVectors(angles, forward, right, NULLVEC);
float forwardamount = skydepth * (0.7f - abs(i*i) * 0.15f);
float forwardamount2 = skydepth * (0.7f - abs((i + 1)*(i + 1)) * 0.15f);
qboolean no_alpha = j > 0;
//unsigned int uppercolor = j > 0 ? fogcol2 : fogcol1;
float bottomheight = j > 0 ? startheight : -1.0f;
float topheight = j > 0 ? endheight : startheight;
bottomheight -= 40.0f;
topheight -= 40.0f;
glBegin(GL_QUADS);
verts[0][0] = r_origin[0] + forward[0] * forwardamount + i * right[0] * skydepth;
verts[0][1] = r_origin[1] + forward[1] * forwardamount + i * right[1] * skydepth;
verts[0][2] = r_origin[2] + forward[2] * forwardamount + i * right[2] * skydepth + bottomheight;
glColor4f(r, g, b, 1.0f);
glVertex3fv(verts[0]);
verts[1][0] = r_origin[0] + forward[0] * forwardamount + i * right[0] * skydepth;
verts[1][1] = r_origin[1] + forward[1] * forwardamount + i * right[1] * skydepth;
verts[1][2] = r_origin[2] + forward[2] * forwardamount + i * right[2] * skydepth + topheight;
if (no_alpha)
glColor4f(r, g, b, 0.0f);
else
glColor4f(r, g, b, 1.0f);
glVertex3fv(verts[1]);
verts[2][0] = r_origin[0] + forward[0] * forwardamount2 + (i + 1) * right[0] * skydepth;
verts[2][1] = r_origin[1] + forward[1] * forwardamount2 + (i + 1) * right[1] * skydepth;
verts[2][2] = r_origin[2] + forward[2] * forwardamount2 + (i + 1) * right[2] * skydepth + topheight;
if (no_alpha)
glColor4f(r, g, b, 0.0f);
else
glColor4f(r, g, b, 1.0f);
glVertex3fv(verts[2]);
verts[3][0] = r_origin[0] + forward[0] * forwardamount2 + (i + 1) * right[0] * skydepth;
verts[3][1] = r_origin[1] + forward[1] * forwardamount2 + (i + 1) * right[1] * skydepth;
verts[3][2] = r_origin[2] + forward[2] * forwardamount2 + (i + 1) * right[2] * skydepth + bottomheight;
glColor4f(r, g, b, 1.0f);
glVertex3fv(verts[3]);
glEnd();
}
}
glEnable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
}
/*
==============
Sky_DrawSkyBox
==============
*/
typedef struct
{
float x, y, z;
float s, t;
float r, g, b;
} glvert_t;
float skynormals[5][3] = {
{ 1.f, 0.f, 0.f },
{ -1.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f },
{ 0.f, -1.f, 0.f },
{ 0.f, 0.f, 1.f }
};
float skyrt[5][3] = {
{ 0.f, -1.f, 0.f },
{ 0.f, 1.f, 0.f },
{ 1.f, 0.f, 0.f },
{ -1.f, 0.f, 0.f },
{ 0.f, -1.f, 0.f }
};
float skyup[5][3] = {
{ 0.f, 0.f, 1.f },
{ 0.f, 0.f, 1.f },
{ 0.f, 0.f, 1.f },
{ 0.f, 0.f, 1.f },
{ -1.f, 0.f, 0.f }
};
void Sky_DrawSkyBox (void)
{
int i, j, k;
vec3_t v;
float s, t;
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
float skydepth = 1000.0f;
for(i = 0; i < 5; i++)
{
const int vertex_count = 4;
glvert_t sky_vertices[vertex_count];
// check if poly needs to be drawn at all
float dot = DotProduct(skynormals[i], vpn);
// < 0 check would work at fov 90 or less, just guess a value that's high enough?
if (dot < -0.25f) continue;
GL_Bind (skybox_textures[skytexorder[i]]);
// if direction is not up, cut "down" vector to zero to only render half cube
//float upnegfact = i == 4 ? 1.0f : 0.0f;
float upnegfact = 1.0f;
float skyboxtexsize = 256.f;
// move ever so slightly less towards forward to make edges overlap a bit, just to not have shimmering pixels between sky edges
float forwardfact = 0.99f;
glBegin(GL_QUADS);
sky_vertices[0].s = 0.5f / skyboxtexsize;
sky_vertices[0].t = (skyboxtexsize - .5f) / skyboxtexsize;
sky_vertices[0].x = r_origin[0] + (forwardfact * skynormals[i][0] - skyrt[i][0] - skyup[i][0] * upnegfact) * skydepth;
sky_vertices[0].y = r_origin[1] + (forwardfact * skynormals[i][1] - skyrt[i][1] - skyup[i][1] * upnegfact) * skydepth;
sky_vertices[0].z = r_origin[2] + (forwardfact * skynormals[i][2] - skyrt[i][2] - skyup[i][2] * upnegfact) * skydepth;
v[0] = sky_vertices[0].x;
v[1] = sky_vertices[0].y;
v[2] = sky_vertices[0].z;
glTexCoord2f (sky_vertices[0].s, sky_vertices[0].t);
glVertex3fv (v);
sky_vertices[1].s = 0.5f / skyboxtexsize;
sky_vertices[1].t = 0.5f / skyboxtexsize;
sky_vertices[1].x = r_origin[0] + (forwardfact * skynormals[i][0] - skyrt[i][0] + skyup[i][0]) * skydepth;
sky_vertices[1].y = r_origin[1] + (forwardfact * skynormals[i][1] - skyrt[i][1] + skyup[i][1]) * skydepth;
sky_vertices[1].z = r_origin[2] + (forwardfact * skynormals[i][2] - skyrt[i][2] + skyup[i][2]) * skydepth;
v[0] = sky_vertices[1].x;
v[1] = sky_vertices[1].y;
v[2] = sky_vertices[1].z;
glTexCoord2f (sky_vertices[1].s, sky_vertices[1].t);
glVertex3fv (v);
sky_vertices[2].s = (skyboxtexsize - .5f) / skyboxtexsize;
sky_vertices[2].t = 0.5f / skyboxtexsize;
sky_vertices[2].x = r_origin[0] + (forwardfact * skynormals[i][0] + skyrt[i][0] + skyup[i][0]) * skydepth;
sky_vertices[2].y = r_origin[1] + (forwardfact * skynormals[i][1] + skyrt[i][1] + skyup[i][1]) * skydepth;
sky_vertices[2].z = r_origin[2] + (forwardfact * skynormals[i][2] + skyrt[i][2] + skyup[i][2]) * skydepth;
v[0] = sky_vertices[2].x;
v[1] = sky_vertices[2].y;
v[2] = sky_vertices[2].z;
glTexCoord2f (sky_vertices[2].s, sky_vertices[2].t);
glVertex3fv (v);
sky_vertices[3].s = (skyboxtexsize - .5f) / skyboxtexsize;
sky_vertices[3].t = (skyboxtexsize - .5f) / skyboxtexsize;
sky_vertices[3].x = r_origin[0] + (forwardfact * skynormals[i][0] + skyrt[i][0] - skyup[i][0] * upnegfact) * skydepth;
sky_vertices[3].y = r_origin[1] + (forwardfact * skynormals[i][1] + skyrt[i][1] - skyup[i][1] * upnegfact) * skydepth;
sky_vertices[3].z = r_origin[2] + (forwardfact * skynormals[i][2] + skyrt[i][2] - skyup[i][2] * upnegfact) * skydepth;
v[0] = sky_vertices[3].x;
v[1] = sky_vertices[3].y;
v[2] = sky_vertices[3].z;
glTexCoord2f (sky_vertices[3].s, sky_vertices[3].t);
glVertex3fv (v);
glEnd();
}
DrawSkyFogBlend(256.0f);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
}
//==============================================================================
//
// 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