mirror of
https://github.com/nzp-team/fteqw.git
synced 2024-11-26 05:41:52 +00:00
8197e0875f
Fix up r_ignoreentpvs 0 to check areas properly. checkpvs builtin can no longer mess up area checks elsewhere. Write out foo.db files for release builds, in the hopes of at least getting function names from release-build crashes. Implement _skyroom worldspawn field, still needs a few tweaks though. Try to fix android surface-related crashes, AGAIN. Separate parsing of connect requests, in preparation for formal logins (and removal of the old ranking code). A few tweaks to try to improve compatibility with q3 mods. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5484 fc73d0e0-1445-4013-8a0c-d673dee63da5
2182 lines
60 KiB
C
2182 lines
60 KiB
C
/*
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
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.
|
|
|
|
*/
|
|
// r_main.c
|
|
|
|
#include "quakedef.h"
|
|
|
|
#ifdef GLQUAKE
|
|
#include "glquake.h"
|
|
#include "renderque.h"
|
|
#include "shader.h"
|
|
|
|
void R_RenderBrushPoly (msurface_t *fa);
|
|
|
|
#define PROJECTION_DISTANCE 200
|
|
#define MAX_STENCIL_ENTS 128
|
|
|
|
extern int gl_stencilbits;
|
|
|
|
extern int r_visframecount; // bumped when going to a new PVS
|
|
extern int r_framecount; // used for dlight push checking
|
|
|
|
//mplane_t frustum[4];
|
|
|
|
//
|
|
// view origin
|
|
//
|
|
//vec3_t vup;
|
|
//vec3_t vpn;
|
|
//vec3_t vright;
|
|
//vec3_t r_origin;
|
|
|
|
extern cvar_t gl_part_flame;
|
|
extern cvar_t r_bloom;
|
|
extern cvar_t r_wireframe, r_wireframe_smooth;
|
|
extern cvar_t r_outline;
|
|
|
|
cvar_t gl_affinemodels = CVAR("gl_affinemodels","0");
|
|
cvar_t gl_finish = CVAR("gl_finish","0");
|
|
cvar_t gl_dither = CVAR("gl_dither", "1");
|
|
extern cvar_t r_stereo_separation;
|
|
extern cvar_t r_stereo_convergence;
|
|
extern cvar_t r_stereo_method;
|
|
extern cvar_t r_postprocshader, r_fxaa, r_graphics;
|
|
extern cvar_t r_hdr_framebuffer;
|
|
|
|
extern cvar_t gl_screenangle;
|
|
|
|
extern cvar_t gl_mindist;
|
|
extern cvar_t vid_srgb;
|
|
|
|
extern cvar_t ffov;
|
|
|
|
extern cvar_t gl_motionblur;
|
|
extern cvar_t gl_motionblurscale;
|
|
|
|
extern cvar_t r_tessellation;
|
|
extern cvar_t gl_ati_truform_type;
|
|
extern cvar_t r_tessellation_level;
|
|
|
|
extern cvar_t gl_blendsprites;
|
|
extern cvar_t r_portaldrawplanes;
|
|
extern cvar_t r_portalonly;
|
|
|
|
#ifdef R_XFLIP
|
|
cvar_t r_xflip = CVAR("leftisright", "0");
|
|
#endif
|
|
|
|
extern cvar_t scr_fov;
|
|
|
|
shader_t *scenepp_rescaled;
|
|
shader_t *scenepp_antialias;
|
|
shader_t *scenepp_waterwarp;
|
|
shader_t *scenepp_gamma;
|
|
|
|
// post processing stuff
|
|
texid_t sceneblur_texture;
|
|
texid_t scenepp_texture_warp;
|
|
texid_t scenepp_texture_edge;
|
|
|
|
texid_t scenepp_postproc_cube;
|
|
int scenepp_postproc_cube_size;
|
|
|
|
fbostate_t fbo_gameview;
|
|
fbostate_t fbo_postproc;
|
|
fbostate_t fbo_postproc_cube;
|
|
|
|
// KrimZon - init post processing - called in GL_CheckExtensions, when they're called
|
|
// I put it here so that only this file need be changed when messing with the post
|
|
// processing shaders
|
|
void GL_InitSceneProcessingShaders_WaterWarp (void)
|
|
{
|
|
scenepp_waterwarp = NULL;
|
|
if (gl_config.arb_shader_objects)
|
|
{
|
|
scenepp_waterwarp = R_RegisterShader("waterwarp", SUF_NONE,
|
|
"{\n"
|
|
"program underwaterwarp\n"
|
|
"{\n"
|
|
"map $sourcecolour\n"
|
|
"}\n"
|
|
"{\n"
|
|
"map $upperoverlay\n"
|
|
"}\n"
|
|
"{\n"
|
|
"map $loweroverlay\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
scenepp_waterwarp->defaulttextures->upperoverlay = scenepp_texture_warp;
|
|
scenepp_waterwarp->defaulttextures->loweroverlay = scenepp_texture_edge;
|
|
}
|
|
}
|
|
|
|
void GL_ShutdownPostProcessing(void)
|
|
{
|
|
GLBE_FBO_Destroy(&fbo_gameview);
|
|
GLBE_FBO_Destroy(&fbo_postproc);
|
|
GLBE_FBO_Destroy(&fbo_postproc_cube);
|
|
R_BloomShutdown();
|
|
}
|
|
|
|
void GL_InitSceneProcessingShaders (void)
|
|
{
|
|
if (gl_config.arb_shader_objects)
|
|
{
|
|
GL_InitSceneProcessingShaders_WaterWarp();
|
|
}
|
|
|
|
scenepp_gamma = R_RegisterShader("fte_scenegamma", 0,
|
|
"{\n"
|
|
"program defaultgammacb\n"
|
|
"affine\n"
|
|
"{\n"
|
|
"map $sourcecolour\n"
|
|
"nodepthtest\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
scenepp_rescaled = R_RegisterShader("fte_rescaler", 0,
|
|
"{\n"
|
|
"program default2d\n"
|
|
"affine\n"
|
|
"{\n"
|
|
"map $sourcecolour\n"
|
|
"nodepthtest\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
scenepp_antialias = R_RegisterShader("fte_ppantialias", 0,
|
|
"{\n"
|
|
"program fxaa\n"
|
|
"affine\n"
|
|
"{\n"
|
|
"map $sourcecolour\n"
|
|
"nodepthtest\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
r_wireframe_smooth.modified = true;
|
|
gl_dither.modified = true; //fixme: bad place for this, but hey
|
|
vid_srgb.modified = true;
|
|
}
|
|
|
|
#define PP_WARP_TEX_SIZE 64
|
|
#define PP_AMP_TEX_SIZE 64
|
|
#define PP_AMP_TEX_BORDER 4
|
|
void GL_SetupSceneProcessingTextures (void)
|
|
{
|
|
int i, x, y;
|
|
unsigned char pp_warp_tex[PP_WARP_TEX_SIZE*PP_WARP_TEX_SIZE*4];
|
|
unsigned char pp_edge_tex[PP_AMP_TEX_SIZE*PP_AMP_TEX_SIZE*4];
|
|
|
|
scenepp_postproc_cube = r_nulltex;
|
|
|
|
TEXASSIGN(sceneblur_texture, Image_CreateTexture("***postprocess_blur***", NULL, 0));
|
|
|
|
if (!gl_config.arb_shader_objects)
|
|
return;
|
|
|
|
TEXASSIGN(scenepp_texture_warp, Image_CreateTexture("***postprocess_warp***", NULL, IF_NOMIPMAP|IF_NOGAMMA|IF_LINEAR));
|
|
TEXASSIGN(scenepp_texture_edge, Image_CreateTexture("***postprocess_edge***", NULL, IF_NOMIPMAP|IF_NOGAMMA|IF_LINEAR));
|
|
|
|
// init warp texture - this specifies offset in
|
|
for (y=0; y<PP_WARP_TEX_SIZE; y++)
|
|
{
|
|
for (x=0; x<PP_WARP_TEX_SIZE; x++)
|
|
{
|
|
float fx, fy;
|
|
|
|
i = (x + y*PP_WARP_TEX_SIZE) * 4;
|
|
|
|
fx = sin(((double)y / PP_WARP_TEX_SIZE) * M_PI * 2);
|
|
fy = cos(((double)x / PP_WARP_TEX_SIZE) * M_PI * 2);
|
|
|
|
pp_warp_tex[i ] = (fx+1.0f)*127.0f;
|
|
pp_warp_tex[i+1] = (fy+1.0f)*127.0f;
|
|
pp_warp_tex[i+2] = 0;
|
|
pp_warp_tex[i+3] = 0xff;
|
|
}
|
|
}
|
|
|
|
Image_Upload(scenepp_texture_warp, TF_RGBX32, pp_warp_tex, NULL, PP_WARP_TEX_SIZE, PP_WARP_TEX_SIZE, IF_LINEAR|IF_NOMIPMAP|IF_NOGAMMA);
|
|
|
|
// TODO: init edge texture - this is ampscale * 2, with ampscale calculated
|
|
// init warp texture - this specifies offset in
|
|
for (y=0; y<PP_AMP_TEX_SIZE; y++)
|
|
{
|
|
for (x=0; x<PP_AMP_TEX_SIZE; x++)
|
|
{
|
|
float fx = 1, fy = 1;
|
|
|
|
i = (x + y*PP_AMP_TEX_SIZE) * 4;
|
|
|
|
if (x < PP_AMP_TEX_BORDER)
|
|
{
|
|
fx = (float)x / PP_AMP_TEX_BORDER;
|
|
}
|
|
if (x > PP_AMP_TEX_SIZE - PP_AMP_TEX_BORDER)
|
|
{
|
|
fx = (PP_AMP_TEX_SIZE - (float)x) / PP_AMP_TEX_BORDER;
|
|
}
|
|
|
|
if (y < PP_AMP_TEX_BORDER)
|
|
{
|
|
fy = (float)y / PP_AMP_TEX_BORDER;
|
|
}
|
|
if (y > PP_AMP_TEX_SIZE - PP_AMP_TEX_BORDER)
|
|
{
|
|
fy = (PP_AMP_TEX_SIZE - (float)y) / PP_AMP_TEX_BORDER;
|
|
}
|
|
|
|
//avoid any sudden changes.
|
|
fx=sin(fx*M_PI*0.5);
|
|
fy=sin(fy*M_PI*0.5);
|
|
|
|
//lame
|
|
fx = fy = min(fx, fy);
|
|
|
|
pp_edge_tex[i ] = fx * 255;
|
|
pp_edge_tex[i+1] = fy * 255;
|
|
pp_edge_tex[i+2] = 0;
|
|
pp_edge_tex[i+3] = 0xff;
|
|
}
|
|
}
|
|
|
|
Image_Upload(scenepp_texture_edge, TF_RGBX32, pp_edge_tex, NULL, PP_AMP_TEX_SIZE, PP_AMP_TEX_SIZE, IF_LINEAR|IF_NOMIPMAP|IF_NOGAMMA);
|
|
}
|
|
|
|
void R_RotateForEntity (float *m, float *modelview, const entity_t *e, const model_t *mod)
|
|
{
|
|
if ((e->flags & RF_WEAPONMODEL) && r_refdef.playerview->viewentity > 0)
|
|
{
|
|
float em[16];
|
|
float vm[16];
|
|
|
|
if (e->flags & RF_WEAPONMODELNOBOB)
|
|
{
|
|
vm[0] = vpn[0];
|
|
vm[1] = vpn[1];
|
|
vm[2] = vpn[2];
|
|
vm[3] = 0;
|
|
|
|
vm[4] = -vright[0];
|
|
vm[5] = -vright[1];
|
|
vm[6] = -vright[2];
|
|
vm[7] = 0;
|
|
|
|
vm[8] = vup[0];
|
|
vm[9] = vup[1];
|
|
vm[10] = vup[2];
|
|
vm[11] = 0;
|
|
|
|
vm[12] = r_refdef.vieworg[0];
|
|
vm[13] = r_refdef.vieworg[1];
|
|
vm[14] = r_refdef.vieworg[2];
|
|
vm[15] = 1;
|
|
}
|
|
else
|
|
{
|
|
vm[0] = r_refdef.playerview->vw_axis[0][0];
|
|
vm[1] = r_refdef.playerview->vw_axis[0][1];
|
|
vm[2] = r_refdef.playerview->vw_axis[0][2];
|
|
vm[3] = 0;
|
|
|
|
vm[4] = r_refdef.playerview->vw_axis[1][0];
|
|
vm[5] = r_refdef.playerview->vw_axis[1][1];
|
|
vm[6] = r_refdef.playerview->vw_axis[1][2];
|
|
vm[7] = 0;
|
|
|
|
vm[8] = r_refdef.playerview->vw_axis[2][0];
|
|
vm[9] = r_refdef.playerview->vw_axis[2][1];
|
|
vm[10] = r_refdef.playerview->vw_axis[2][2];
|
|
vm[11] = 0;
|
|
|
|
vm[12] = r_refdef.playerview->vw_origin[0];
|
|
vm[13] = r_refdef.playerview->vw_origin[1];
|
|
vm[14] = r_refdef.playerview->vw_origin[2];
|
|
vm[15] = 1;
|
|
}
|
|
|
|
em[0] = e->axis[0][0];
|
|
em[1] = e->axis[0][1];
|
|
em[2] = e->axis[0][2];
|
|
em[3] = 0;
|
|
|
|
em[4] = e->axis[1][0];
|
|
em[5] = e->axis[1][1];
|
|
em[6] = e->axis[1][2];
|
|
em[7] = 0;
|
|
|
|
em[8] = e->axis[2][0];
|
|
em[9] = e->axis[2][1];
|
|
em[10] = e->axis[2][2];
|
|
em[11] = 0;
|
|
|
|
em[12] = e->origin[0];
|
|
em[13] = e->origin[1];
|
|
em[14] = e->origin[2];
|
|
em[15] = 1;
|
|
|
|
Matrix4_Multiply(vm, em, m);
|
|
}
|
|
else
|
|
{
|
|
m[0] = e->axis[0][0];
|
|
m[1] = e->axis[0][1];
|
|
m[2] = e->axis[0][2];
|
|
m[3] = 0;
|
|
|
|
m[4] = e->axis[1][0];
|
|
m[5] = e->axis[1][1];
|
|
m[6] = e->axis[1][2];
|
|
m[7] = 0;
|
|
|
|
m[8] = e->axis[2][0];
|
|
m[9] = e->axis[2][1];
|
|
m[10] = e->axis[2][2];
|
|
m[11] = 0;
|
|
|
|
m[12] = e->origin[0];
|
|
m[13] = e->origin[1];
|
|
m[14] = e->origin[2];
|
|
m[15] = 1;
|
|
}
|
|
|
|
if (e->scale != 1 && e->scale != 0) //hexen 2 stuff
|
|
{
|
|
#ifdef HEXEN2
|
|
float z;
|
|
float escale;
|
|
escale = e->scale;
|
|
switch(e->drawflags&SCALE_TYPE_MASK)
|
|
{
|
|
default:
|
|
case SCALE_TYPE_UNIFORM:
|
|
VectorScale((m+0), escale, (m+0));
|
|
VectorScale((m+4), escale, (m+4));
|
|
VectorScale((m+8), escale, (m+8));
|
|
break;
|
|
case SCALE_TYPE_XYONLY:
|
|
VectorScale((m+0), escale, (m+0));
|
|
VectorScale((m+4), escale, (m+4));
|
|
break;
|
|
case SCALE_TYPE_ZONLY:
|
|
VectorScale((m+8), escale, (m+8));
|
|
break;
|
|
}
|
|
if (mod && (e->drawflags&SCALE_TYPE_MASK) != SCALE_TYPE_XYONLY)
|
|
{
|
|
switch(e->drawflags&SCALE_ORIGIN_MASK)
|
|
{
|
|
case SCALE_ORIGIN_CENTER:
|
|
z = ((mod->maxs[2] + mod->mins[2]) * (1-escale))/2;
|
|
VectorMA((m+12), z, e->axis[2], (m+12));
|
|
break;
|
|
case SCALE_ORIGIN_BOTTOM:
|
|
VectorMA((m+12), mod->mins[2]*(1-escale), e->axis[2], (m+12));
|
|
break;
|
|
case SCALE_ORIGIN_TOP:
|
|
VectorMA((m+12), -mod->maxs[2], e->axis[2], (m+12));
|
|
break;
|
|
}
|
|
}
|
|
#else
|
|
VectorScale((m+0), e->scale, (m+0));
|
|
VectorScale((m+4), e->scale, (m+4));
|
|
VectorScale((m+8), e->scale, (m+8));
|
|
#endif
|
|
}
|
|
else if (mod && !strcmp(mod->name, "progs/eyes.mdl"))
|
|
{
|
|
/*resize eyes, to make them easier to see*/
|
|
m[14] -= (22 + 8);
|
|
VectorScale((m+0), 2, (m+0));
|
|
VectorScale((m+4), 2, (m+4));
|
|
VectorScale((m+8), 2, (m+8));
|
|
}
|
|
if (mod && !ruleset_allow_larger_models.ival && mod->clampscale != 1 && mod->type == mod_alias)
|
|
{ //possibly this should be on a per-frame basis, but that's a real pain to do
|
|
Con_DPrintf("Rescaling %s by %f\n", mod->name, mod->clampscale);
|
|
VectorScale((m+0), mod->clampscale, (m+0));
|
|
VectorScale((m+4), mod->clampscale, (m+4));
|
|
VectorScale((m+8), mod->clampscale, (m+8));
|
|
}
|
|
|
|
Matrix4_Multiply(r_refdef.m_view, m, modelview);
|
|
}
|
|
|
|
//==================================================================================
|
|
|
|
qboolean R_GameRectIsFullscreen(void);
|
|
/*
|
|
=============
|
|
R_SetupGL
|
|
=============
|
|
*/
|
|
void R_SetupGL (float stereooffset, int i)
|
|
{
|
|
int x, x2, y2, y, w, h;
|
|
vec3_t newa;
|
|
|
|
float fov_x, fov_y;
|
|
float fovv_x, fovv_y;
|
|
|
|
if (!r_refdef.recurse)
|
|
{
|
|
newa[0] = r_refdef.viewangles[0];
|
|
newa[1] = r_refdef.viewangles[1];
|
|
newa[2] = r_refdef.viewangles[2] + gl_screenangle.value;
|
|
if (r_refdef.stereomethod)
|
|
newa[1] += r_stereo_convergence.value * (i?0.5:-0.5); //can we get away with this cheapness? rip 6dof
|
|
if (0)
|
|
{
|
|
vec3_t paxis[3];
|
|
AngleVectors (newa, paxis[0], paxis[1], paxis[2]);
|
|
|
|
//R_ConcatRotations(r_refdef.headaxis, paxis, vpn);
|
|
|
|
VectorMA(vec3_origin, r_refdef.headaxis[0][0], paxis[0], vpn);
|
|
VectorMA(vpn, r_refdef.headaxis[0][1], paxis[1], vpn);
|
|
VectorMA(vpn, r_refdef.headaxis[0][2], paxis[2], vpn);
|
|
|
|
VectorMA(vec3_origin, r_refdef.headaxis[1][0], paxis[0], vright);
|
|
VectorMA(vright, r_refdef.headaxis[1][1], paxis[1], vright);
|
|
VectorMA(vright, r_refdef.headaxis[1][2], paxis[2], vright);
|
|
|
|
VectorMA(vec3_origin, r_refdef.headaxis[2][0], paxis[0], vup);
|
|
VectorMA(vup, r_refdef.headaxis[2][1], paxis[1], vup);
|
|
VectorMA(vup, r_refdef.headaxis[2][2], paxis[2], vup);
|
|
}
|
|
else
|
|
AngleVectors (newa, vpn, vright, vup);
|
|
|
|
VectorMA(r_refdef.vieworg, stereooffset, vright, r_origin);
|
|
VectorAdd(r_origin, r_refdef.eyeoffset, r_origin);
|
|
|
|
//
|
|
// set up viewpoint
|
|
//
|
|
if (r_refdef.flags & (RDF_ALLPOSTPROC|RDF_RENDERSCALE))
|
|
{
|
|
//with fbo postprocessing, we disable all viewport.
|
|
r_refdef.pxrect.x = 0;
|
|
r_refdef.pxrect.y = 0;
|
|
r_refdef.pxrect.width = vid.fbpwidth;
|
|
r_refdef.pxrect.height = vid.fbpheight;
|
|
r_refdef.pxrect.maxheight = vid.fbpheight;
|
|
}
|
|
else if (*r_refdef.rt_destcolour[0].texname)
|
|
{
|
|
//with fbo rendering, we disable all virtual scaling.
|
|
x = r_refdef.vrect.x;
|
|
x2 = r_refdef.vrect.x + r_refdef.vrect.width;
|
|
y = r_refdef.vrect.y;
|
|
y2 = r_refdef.vrect.y + r_refdef.vrect.height;
|
|
|
|
w = x2 - x;
|
|
h = y2 - y;
|
|
|
|
r_refdef.pxrect.x = x;
|
|
r_refdef.pxrect.y = y;
|
|
r_refdef.pxrect.width = w;
|
|
r_refdef.pxrect.height = h;
|
|
r_refdef.pxrect.maxheight = vid.fbpheight;
|
|
}
|
|
else
|
|
{
|
|
x = floor(r_refdef.vrect.x * (float)vid.fbpwidth/(float)vid.width);
|
|
x2 = ceil((r_refdef.vrect.x + r_refdef.vrect.width) * (float)vid.fbpwidth/(float)vid.width);
|
|
y = floor(r_refdef.vrect.y * (float)vid.fbpheight/(float)vid.height);
|
|
y2 = ceil((r_refdef.vrect.y + r_refdef.vrect.height) * (float)vid.fbpheight/(float)vid.height);
|
|
|
|
|
|
// fudge around because of frac screen scale
|
|
/* if (x > 0)
|
|
x--;
|
|
if (x2 < vid.fbpwidth)
|
|
x2++;
|
|
if (y2 < vid.fbpheight)
|
|
y2++;
|
|
if (y > 0)
|
|
y--;
|
|
*/
|
|
w = x2 - x;
|
|
h = y2 - y;
|
|
|
|
if (r_refdef.stereomethod == STEREO_CROSSEYED
|
|
#ifdef FTE_TARGET_WEB
|
|
|| r_refdef.stereomethod == STEREO_WEBVR
|
|
#endif
|
|
)
|
|
{
|
|
w /= 2;
|
|
if (i)
|
|
x += vid.fbpwidth/2;
|
|
}
|
|
|
|
r_refdef.pxrect.x = x;
|
|
r_refdef.pxrect.y = y;
|
|
r_refdef.pxrect.width = w;
|
|
r_refdef.pxrect.height = h;
|
|
r_refdef.pxrect.maxheight = vid.fbpheight;
|
|
}
|
|
fov_x = r_refdef.fov_x;
|
|
fov_y = r_refdef.fov_y;
|
|
fovv_x = r_refdef.fovv_x;
|
|
fovv_y = r_refdef.fovv_y;
|
|
|
|
if ((*r_refdef.rt_destcolour[0].texname || *r_refdef.rt_depth.texname) && strcmp(r_refdef.rt_destcolour[0].texname, "megascreeny"))
|
|
{
|
|
r_refdef.pxrect.y = r_refdef.pxrect.maxheight - (r_refdef.pxrect.height+r_refdef.pxrect.y);
|
|
fov_y *= -1;
|
|
fovv_y *= -1;
|
|
r_refdef.flipcull ^= SHADER_CULL_FLIP;
|
|
}
|
|
else if ((r_refdef.flags & RDF_UNDERWATER) && !(r_refdef.flags & RDF_WATERWARP))
|
|
{
|
|
fov_x *= 1 + (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
|
|
fov_y *= 1 + (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
|
|
|
|
fovv_x *= 1 + (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
|
|
fovv_y *= 1 + (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
|
|
}
|
|
|
|
GL_ViewportUpdate();
|
|
|
|
#ifdef FTE_TARGET_WEB
|
|
if (r_refdef.stereomethod == STEREO_WEBVR)
|
|
{
|
|
float vm[16], em[16];
|
|
emscriptenfte_getvreyedata(i, r_refdef.m_projection_std, em);
|
|
memcpy(r_refdef.m_projection_view, r_refdef.m_projection_std, sizeof(r_refdef.m_projection_view));
|
|
Matrix4x4_Identity(em);
|
|
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vm, vpn, vright, vup, r_origin);
|
|
Matrix4_Multiply(vm, em, r_refdef.m_view);
|
|
//fixme: read the axis+org back out...
|
|
|
|
// Matrix4x4_CM_ModelViewMatrixFromAxis(r_refdef.m_view, vpn, vright, vup, r_origin);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if (r_refdef.useperspective)
|
|
{
|
|
int stencilshadows = Sh_StencilShadowsActive();
|
|
|
|
if ((!stencilshadows || !gl_stencilbits) && r_refdef.maxdist)//gl_nv_range_clamp)
|
|
{
|
|
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*180/M_PI;
|
|
// yfov = (2.0 * tan (scr_fov.value/360*M_PI)) / screenaspect;
|
|
// yfov = 2*atan((float)r_refdef.vrect.height/r_refdef.vrect.width)*(scr_fov.value*2)/M_PI;
|
|
// MYgluPerspective (yfov, screenaspect, 4, 4096);
|
|
|
|
Matrix4x4_CM_Projection_Far(r_refdef.m_projection_std, fov_x, fov_y, r_refdef.mindist, r_refdef.maxdist, false);
|
|
Matrix4x4_CM_Projection_Far(r_refdef.m_projection_view, fovv_x, fovv_y, r_refdef.mindist, r_refdef.maxdist, false);
|
|
}
|
|
else
|
|
{
|
|
Matrix4x4_CM_Projection_Inf(r_refdef.m_projection_std, fov_x, fov_y, r_refdef.mindist, false);
|
|
Matrix4x4_CM_Projection_Inf(r_refdef.m_projection_view, fovv_x, fovv_y, r_refdef.mindist, false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Matrix4x4_CM_Orthographic(r_refdef.m_projection_std, -fov_x/2, fov_x/2, -fov_y/2, fov_y/2, r_refdef.mindist, r_refdef.maxdist?r_refdef.maxdist:9999);
|
|
memcpy(r_refdef.m_projection_view, r_refdef.m_projection_std, sizeof(r_refdef.m_projection_view));
|
|
}
|
|
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(r_refdef.m_view, vpn, vright, vup, r_origin);
|
|
|
|
r_refdef.m_projection_view[2+4*0] *= 0.333;
|
|
r_refdef.m_projection_view[2+4*1] *= 0.333;
|
|
r_refdef.m_projection_view[2+4*2] *= 0.333;
|
|
r_refdef.m_projection_view[2+4*3] *= 0.333;
|
|
r_refdef.m_projection_view[14] -= 0.666;
|
|
//FIXME: bias, so that we use -1 to -.333 range instead of -.333 to 0.333
|
|
}
|
|
}
|
|
|
|
if (qglLoadMatrixf)
|
|
{
|
|
qglMatrixMode(GL_PROJECTION);
|
|
qglLoadMatrixf(r_refdef.m_projection_std);
|
|
|
|
qglMatrixMode(GL_MODELVIEW);
|
|
qglLoadMatrixf(r_refdef.m_view);
|
|
}
|
|
|
|
#ifdef GL_LINE_SMOOTH
|
|
if (!gl_config.gles && r_wireframe_smooth.modified)
|
|
{
|
|
r_wireframe_smooth.modified = false;
|
|
if (r_wireframe_smooth.ival || (r_outline.ival && !r_wireframe.ival))
|
|
{
|
|
qglEnable(GL_LINE_SMOOTH);
|
|
if (qglHint)
|
|
qglHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
|
|
}
|
|
else
|
|
{
|
|
qglDisable(GL_LINE_SMOOTH);
|
|
if (qglHint)
|
|
qglHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
|
|
}
|
|
}
|
|
#endif
|
|
if (!gl_config.gles && gl_dither.modified)
|
|
{
|
|
gl_dither.modified = false;
|
|
if (gl_dither.ival)
|
|
{
|
|
qglEnable(GL_DITHER);
|
|
}
|
|
else
|
|
{
|
|
qglDisable(GL_DITHER);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Surf_SetupFrame(void);
|
|
|
|
/*
|
|
================
|
|
R_RenderScene
|
|
|
|
r_refdef must be set before the first call
|
|
================
|
|
*/
|
|
void R_RenderScene (void)
|
|
{
|
|
float stereooffset[2];
|
|
int stereoframes = 1;
|
|
int stereomode;
|
|
int i;
|
|
int tmpvisents = cl_numvisedicts; /*world rendering is allowed to add additional ents, but we don't want to keep them for recursive views*/
|
|
int cull = r_refdef.flipcull;
|
|
|
|
stereomode = r_refdef.stereomethod;
|
|
if (stereomode == STEREO_QUAD)
|
|
{
|
|
#ifdef GL_STEREO
|
|
GLint glb;
|
|
qglGetIntegerv(GL_STEREO, &glb);
|
|
if (!glb || !qglDrawBuffer)
|
|
#endif
|
|
stereomode = STEREO_OFF; //we are not a stereo context, so no stereoscopic rendering (this encourages it to otherwise be left enabled, which means the user is more likely to spot that they asked it to give a slower context.
|
|
}
|
|
|
|
|
|
if (r_refdef.recurse || !stereomode || !r_stereo_separation.value)
|
|
{
|
|
stereooffset[0] = 0;
|
|
stereoframes = 1;
|
|
stereomode = STEREO_OFF;
|
|
}
|
|
else
|
|
{
|
|
stereooffset[0] = -0.5*r_stereo_separation.value;
|
|
stereooffset[1] = +0.5*r_stereo_separation.value;
|
|
stereoframes = 2;
|
|
}
|
|
|
|
for (i = 0; i < stereoframes; i++)
|
|
{
|
|
switch (stereomode)
|
|
{
|
|
default:
|
|
case STEREO_OFF: //off
|
|
if (i)
|
|
return;
|
|
break;
|
|
#ifdef GL_STEREO
|
|
case STEREO_QUAD: //proper gl stereo rendering
|
|
if (stereooffset[i] < 0)
|
|
qglDrawBuffer(GL_BACK_LEFT);
|
|
else
|
|
qglDrawBuffer(GL_BACK_RIGHT);
|
|
break;
|
|
#endif
|
|
case STEREO_RED_CYAN: //red/cyan(green+blue)
|
|
if (stereooffset[i] < 0)
|
|
qglColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
|
|
else
|
|
qglColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
break;
|
|
case STEREO_RED_BLUE: //red/blue
|
|
if (stereooffset[i] < 0)
|
|
qglColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
|
|
else
|
|
qglColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);
|
|
break;
|
|
case STEREO_RED_GREEN: //red/green
|
|
if (stereooffset[i] < 0)
|
|
qglColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
|
|
else
|
|
qglColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
|
|
break;
|
|
#ifdef FTE_TARGET_WEB
|
|
case STEREO_WEBVR:
|
|
stereooffset[i] = 0; //webgl overrides our separation.
|
|
break;
|
|
#endif
|
|
case STEREO_CROSSEYED: //eyestrain
|
|
break;
|
|
case STEREO_LEFTONLY:
|
|
if (i != 0)
|
|
continue;
|
|
break;
|
|
case STEREO_RIGHTONLY:
|
|
if (i != 1)
|
|
continue;
|
|
//fixme: depth buffer doesn't need clearing
|
|
break;
|
|
}
|
|
if (i)
|
|
{
|
|
GL_ForceDepthWritable();
|
|
qglClear (GL_DEPTH_BUFFER_BIT);
|
|
r_framecount++;
|
|
}
|
|
|
|
TRACE(("dbg: calling R_SetupGL\n"));
|
|
R_SetupGL (stereooffset[i], i);
|
|
|
|
TRACE(("dbg: calling R_SetFrustrum\n"));
|
|
if (!r_refdef.recurse)
|
|
R_SetFrustum (r_refdef.m_projection_std, r_refdef.m_view);
|
|
|
|
RQ_BeginFrame();
|
|
|
|
TRACE(("dbg: calling Surf_DrawWorld\n"));
|
|
Surf_DrawWorld (); // adds static entities to the list
|
|
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
|
|
// R_DrawDecals();
|
|
|
|
TRACE(("dbg: calling R_RenderDlights\n"));
|
|
R_RenderDlights ();
|
|
|
|
if (r_refdef.recurse)
|
|
RQ_RenderBatch();
|
|
else
|
|
RQ_RenderBatchClear();
|
|
|
|
cl_numvisedicts = tmpvisents;
|
|
}
|
|
|
|
switch (stereomode)
|
|
{
|
|
default:
|
|
case STEREO_OFF:
|
|
case STEREO_LEFTONLY:
|
|
case STEREO_RIGHTONLY:
|
|
break;
|
|
case STEREO_QUAD:
|
|
qglDrawBuffer(GL_BACK);
|
|
break;
|
|
case STEREO_RED_BLUE: //green should have already been cleared.
|
|
case STEREO_RED_GREEN: //blue should have already been cleared.
|
|
case STEREO_RED_CYAN:
|
|
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
break;
|
|
case 5:
|
|
break;
|
|
}
|
|
|
|
r_refdef.flipcull = cull;
|
|
}
|
|
/*generates a new modelview matrix, as well as vpn vectors*/
|
|
static void R_MirrorMatrix(plane_t *plane)
|
|
{
|
|
float mirror[16];
|
|
float view[16];
|
|
float result[16];
|
|
|
|
vec3_t pnorm;
|
|
VectorNegate(plane->normal, pnorm);
|
|
|
|
mirror[0] = 1-2*pnorm[0]*pnorm[0];
|
|
mirror[1] = -2*pnorm[0]*pnorm[1];
|
|
mirror[2] = -2*pnorm[0]*pnorm[2];
|
|
mirror[3] = 0;
|
|
|
|
mirror[4] = -2*pnorm[1]*pnorm[0];
|
|
mirror[5] = 1-2*pnorm[1]*pnorm[1];
|
|
mirror[6] = -2*pnorm[1]*pnorm[2] ;
|
|
mirror[7] = 0;
|
|
|
|
mirror[8] = -2*pnorm[2]*pnorm[0];
|
|
mirror[9] = -2*pnorm[2]*pnorm[1];
|
|
mirror[10] = 1-2*pnorm[2]*pnorm[2];
|
|
mirror[11] = 0;
|
|
|
|
mirror[12] = -2*pnorm[0]*plane->dist;
|
|
mirror[13] = -2*pnorm[1]*plane->dist;
|
|
mirror[14] = -2*pnorm[2]*plane->dist;
|
|
mirror[15] = 1;
|
|
|
|
view[0] = vpn[0];
|
|
view[1] = vpn[1];
|
|
view[2] = vpn[2];
|
|
view[3] = 0;
|
|
|
|
view[4] = -vright[0];
|
|
view[5] = -vright[1];
|
|
view[6] = -vright[2];
|
|
view[7] = 0;
|
|
|
|
view[8] = vup[0];
|
|
view[9] = vup[1];
|
|
view[10] = vup[2];
|
|
view[11] = 0;
|
|
|
|
view[12] = r_refdef.vieworg[0];
|
|
view[13] = r_refdef.vieworg[1];
|
|
view[14] = r_refdef.vieworg[2];
|
|
view[15] = 1;
|
|
|
|
VectorMA(r_refdef.vieworg, 0.25, plane->normal, r_refdef.pvsorigin);
|
|
|
|
Matrix4_Multiply(mirror, view, result);
|
|
|
|
vpn[0] = result[0];
|
|
vpn[1] = result[1];
|
|
vpn[2] = result[2];
|
|
|
|
vright[0] = -result[4];
|
|
vright[1] = -result[5];
|
|
vright[2] = -result[6];
|
|
|
|
vup[0] = result[8];
|
|
vup[1] = result[9];
|
|
vup[2] = result[10];
|
|
|
|
r_refdef.vieworg[0] = result[12];
|
|
r_refdef.vieworg[1] = result[13];
|
|
r_refdef.vieworg[2] = result[14];
|
|
}
|
|
static entity_t *R_FindPortalCamera(entity_t *rent)
|
|
{
|
|
int i;
|
|
for (i = 0; i < cl_numvisedicts; i++)
|
|
{
|
|
if (cl_visedicts[i].rtype == RT_PORTALCAMERA)
|
|
{
|
|
if (cl_visedicts[i].keynum == rent->keynum )
|
|
return &cl_visedicts[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
static entity_t *R_NearestPortal(plane_t *plane)
|
|
{
|
|
int i;
|
|
entity_t *best = NULL;
|
|
float dist, bestd = 0;
|
|
|
|
//for q3-compat, portals on world scan for a visedict to use for their view.
|
|
for (i = 0; i < cl_numvisedicts; i++)
|
|
{
|
|
if (cl_visedicts[i].rtype == RT_PORTALSURFACE)
|
|
{
|
|
dist = DotProduct(cl_visedicts[i].origin, plane->normal)-plane->dist;
|
|
dist = fabs(dist);
|
|
if (dist < 64 && (!best || dist < bestd))
|
|
best = &cl_visedicts[i];
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
static void TransformCoord(vec3_t in, vec3_t planea[3], vec3_t planeo, vec3_t viewa[3], vec3_t viewo, vec3_t result)
|
|
{
|
|
int i;
|
|
vec3_t local;
|
|
vec3_t transformed;
|
|
float d;
|
|
|
|
local[0] = in[0] - planeo[0];
|
|
local[1] = in[1] - planeo[1];
|
|
local[2] = in[2] - planeo[2];
|
|
|
|
VectorClear(transformed);
|
|
for ( i = 0 ; i < 3 ; i++ )
|
|
{
|
|
d = DotProduct(local, planea[i]);
|
|
VectorMA(transformed, d, viewa[i], transformed);
|
|
}
|
|
|
|
result[0] = transformed[0] + viewo[0];
|
|
result[1] = transformed[1] + viewo[1];
|
|
result[2] = transformed[2] + viewo[2];
|
|
}
|
|
static void TransformDir(vec3_t in, vec3_t planea[3], vec3_t viewa[3], vec3_t result)
|
|
{
|
|
int i;
|
|
float d;
|
|
vec3_t tmp;
|
|
|
|
VectorCopy(in, tmp);
|
|
|
|
VectorClear(result);
|
|
for ( i = 0 ; i < 3 ; i++ )
|
|
{
|
|
d = DotProduct(tmp, planea[i]);
|
|
VectorMA(result, d, viewa[i], result);
|
|
}
|
|
}
|
|
|
|
void R_ObliqueNearClip(float *viewmat, mplane_t *wplane);
|
|
void CL_DrawDebugPlane(float *normal, float dist, float r, float g, float b, qboolean enqueue);
|
|
void GLR_DrawPortal(batch_t *batch, batch_t **blist, batch_t *depthmasklist[2], int portaltype)
|
|
{
|
|
entity_t *view, *surfent;
|
|
// GLdouble glplane[4];
|
|
plane_t plane, oplane;
|
|
float vmat[16];
|
|
refdef_t oldrefdef;
|
|
vec3_t r;
|
|
int i;
|
|
mesh_t *mesh = batch->mesh[batch->firstmesh];
|
|
pvsbuffer_t newvis;
|
|
float ivmat[16], trmat[16];
|
|
|
|
if (!mesh->xyz_array)
|
|
return;
|
|
|
|
if (!mesh->normals_array)
|
|
{
|
|
VectorSet(plane.normal, 0, 0, 1);
|
|
}
|
|
else
|
|
{
|
|
VectorCopy(mesh->normals_array[0], plane.normal);
|
|
}
|
|
|
|
if (batch->ent == &r_worldentity)
|
|
{
|
|
plane.dist = DotProduct(mesh->xyz_array[0], plane.normal);
|
|
}
|
|
else
|
|
{
|
|
vec3_t point;
|
|
VectorCopy(plane.normal, oplane.normal);
|
|
//rotate the surface normal around its entity's matrix
|
|
plane.normal[0] = oplane.normal[0]*batch->ent->axis[0][0] + oplane.normal[1]*batch->ent->axis[1][0] + oplane.normal[2]*batch->ent->axis[2][0];
|
|
plane.normal[1] = oplane.normal[0]*batch->ent->axis[0][1] + oplane.normal[1]*batch->ent->axis[1][1] + oplane.normal[2]*batch->ent->axis[2][1];
|
|
plane.normal[2] = oplane.normal[0]*batch->ent->axis[0][2] + oplane.normal[1]*batch->ent->axis[1][2] + oplane.normal[2]*batch->ent->axis[2][2];
|
|
|
|
//rotate some point on the mesh around its entity's matrix
|
|
point[0] = mesh->xyz_array[0][0]*batch->ent->axis[0][0] + mesh->xyz_array[0][1]*batch->ent->axis[1][0] + mesh->xyz_array[0][2]*batch->ent->axis[2][0] + batch->ent->origin[0];
|
|
point[1] = mesh->xyz_array[0][0]*batch->ent->axis[0][1] + mesh->xyz_array[0][1]*batch->ent->axis[1][1] + mesh->xyz_array[0][2]*batch->ent->axis[2][1] + batch->ent->origin[1];
|
|
point[2] = mesh->xyz_array[0][0]*batch->ent->axis[0][2] + mesh->xyz_array[0][1]*batch->ent->axis[1][2] + mesh->xyz_array[0][2]*batch->ent->axis[2][2] + batch->ent->origin[2];
|
|
|
|
//now we can figure out the plane dist
|
|
plane.dist = DotProduct(point, plane.normal);
|
|
}
|
|
|
|
//if we're too far away from the surface, don't draw anything
|
|
if (batch->shader->flags & SHADER_AGEN_PORTAL)
|
|
{
|
|
/*there's a portal alpha blend on that surface, that fades out after this distance*/
|
|
if (DotProduct(r_refdef.vieworg, plane.normal)-plane.dist > batch->shader->portaldist)
|
|
return;
|
|
}
|
|
//if we're behind it, then also don't draw anything. for our purposes, behind is when the entire near clipplane is behind.
|
|
if (DotProduct(r_refdef.vieworg, plane.normal)-plane.dist < -r_refdef.mindist)
|
|
return;
|
|
|
|
if (r_refdef.recurse >= R_MAX_RECURSE-1)
|
|
{
|
|
GLBE_SelectMode(BEM_DEPTHDARK);
|
|
GLBE_SubmitBatch(batch);
|
|
GLBE_SelectMode(BEM_STANDARD);
|
|
return;
|
|
}
|
|
|
|
|
|
TRACE(("GLR_DrawPortal: portal type %i\n", portaltype));
|
|
|
|
oldrefdef = r_refdef;
|
|
r_refdef.recurse+=1;
|
|
|
|
r_refdef.externalview = true;
|
|
|
|
switch(portaltype)
|
|
{
|
|
case 1: /*fbo explicit mirror (fucked depth, working clip plane)*/
|
|
//fixme: pvs is surely wrong?
|
|
// r_refdef.flipcull ^= SHADER_CULL_FLIP;
|
|
R_MirrorMatrix(&plane);
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
|
|
|
|
VectorCopy(mesh->xyz_array[0], r_refdef.pvsorigin);
|
|
for (i = 1; i < mesh->numvertexes; i++)
|
|
VectorAdd(r_refdef.pvsorigin, mesh->xyz_array[i], r_refdef.pvsorigin);
|
|
VectorScale(r_refdef.pvsorigin, 1.0/mesh->numvertexes, r_refdef.pvsorigin);
|
|
break;
|
|
|
|
case 2: /*fbo refraction (fucked depth, working clip plane)*/
|
|
case 3: /*screen copy refraction (screen depth, fucked clip planes)*/
|
|
/*refraction image (same view, just with things culled*/
|
|
r_refdef.externalview = oldrefdef.externalview;
|
|
VectorNegate(plane.normal, plane.normal);
|
|
plane.dist = -plane.dist;
|
|
|
|
//use the player's origin for r_viewleaf, because there's not much we can do anyway*/
|
|
VectorCopy(r_origin, r_refdef.pvsorigin);
|
|
|
|
if (cl.worldmodel && cl.worldmodel->funcs.ClusterPVS && !r_novis.ival)
|
|
{
|
|
int clust, i, j;
|
|
float d;
|
|
vec3_t point;
|
|
r_refdef.forcevis = true;
|
|
r_refdef.forcedvis = NULL;
|
|
newvis.buffer = alloca(newvis.buffersize=cl.worldmodel->pvsbytes);
|
|
for (i = batch->firstmesh; i < batch->meshes; i++)
|
|
{
|
|
mesh = batch->mesh[i];
|
|
VectorClear(point);
|
|
for (j = 0; j < mesh->numvertexes; j++)
|
|
VectorAdd(point, mesh->xyz_array[j], point);
|
|
VectorScale(point, 1.0f/mesh->numvertexes, point);
|
|
d = DotProduct(point, plane.normal) - plane.dist;
|
|
d += 0.1; //an epsilon on the far side
|
|
VectorMA(point, d, plane.normal, point);
|
|
|
|
clust = cl.worldmodel->funcs.ClusterForPoint(cl.worldmodel, point, NULL);
|
|
if (i == batch->firstmesh)
|
|
r_refdef.forcedvis = cl.worldmodel->funcs.ClusterPVS(cl.worldmodel, clust, &newvis, PVM_REPLACE);
|
|
else
|
|
r_refdef.forcedvis = cl.worldmodel->funcs.ClusterPVS(cl.worldmodel, clust, &newvis, PVM_MERGE);
|
|
}
|
|
// memset(newvis, 0xff, pvsbytes);
|
|
}
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
|
|
break;
|
|
|
|
case 0: /*q3 portal*/
|
|
default:
|
|
#ifdef CSQC_DAT
|
|
if (CSQC_SetupToRenderPortal(batch->ent->keynum))
|
|
{
|
|
oplane = plane;
|
|
|
|
//transform the old surface plane into the new view matrix
|
|
Matrix4_Invert(r_refdef.m_view, ivmat);
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
|
|
Matrix4_Multiply(ivmat, vmat, trmat);
|
|
plane.normal[0] = -(oplane.normal[0] * trmat[0] + oplane.normal[1] * trmat[1] + oplane.normal[2] * trmat[2]);
|
|
plane.normal[1] = -(oplane.normal[0] * trmat[4] + oplane.normal[1] * trmat[5] + oplane.normal[2] * trmat[6]);
|
|
plane.normal[2] = -(oplane.normal[0] * trmat[8] + oplane.normal[1] * trmat[9] + oplane.normal[2] * trmat[10]);
|
|
plane.dist = -oplane.dist + trmat[12]*oplane.normal[0] + trmat[13]*oplane.normal[1] + trmat[14]*oplane.normal[2];
|
|
|
|
if (Cvar_Get("temp_useplaneclip", "1", 0, "temp")->ival)
|
|
portaltype = 1; //make sure the near clipplane is used.
|
|
break;
|
|
}
|
|
#endif
|
|
surfent = batch->ent;
|
|
if (batch->ent->keynum)
|
|
view = R_FindPortalCamera(batch->ent);
|
|
else
|
|
{
|
|
view = R_NearestPortal(&plane);
|
|
if (view)
|
|
{ //for q3bsps where the portal surface is embedded in the bsp itself, we need an extra leyer of indirection.
|
|
entity_t *oc = R_FindPortalCamera(view);
|
|
if(oc)
|
|
{
|
|
surfent = view;
|
|
view = oc;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (view && view->rtype == RT_PORTALCAMERA)
|
|
{ //q1-style portal, where the portal is defined via attachments
|
|
//the portal plane itself is assumed to be facing directly forwards from the entity that we're drawing, and with the same origin.
|
|
oplane = plane;
|
|
|
|
TransformCoord(r_refdef.vieworg, surfent->axis, surfent->origin, view->axis, view->origin, r_refdef.vieworg);
|
|
TransformDir(vpn, surfent->axis, view->axis, vpn);
|
|
TransformDir(vright, surfent->axis, view->axis, vright);
|
|
TransformDir(vup, surfent->axis, view->axis, vup);
|
|
|
|
//transform the old surface plane into the new view matrix
|
|
Matrix4_Invert(r_refdef.m_view, ivmat);
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
|
|
Matrix4_Multiply(ivmat, vmat, trmat);
|
|
plane.normal[0] = -(oplane.normal[0] * trmat[0] + oplane.normal[1] * trmat[1] + oplane.normal[2] * trmat[2]);
|
|
plane.normal[1] = -(oplane.normal[0] * trmat[4] + oplane.normal[1] * trmat[5] + oplane.normal[2] * trmat[6]);
|
|
plane.normal[2] = -(oplane.normal[0] * trmat[8] + oplane.normal[1] * trmat[9] + oplane.normal[2] * trmat[10]);
|
|
plane.dist = -oplane.dist + trmat[12]*oplane.normal[0] + trmat[13]*oplane.normal[1] + trmat[14]*oplane.normal[2];
|
|
|
|
portaltype = 1; //make sure the near clipplane is used.
|
|
break;
|
|
}
|
|
|
|
//portal surfaces with the same origin+oldorigin are explicit mirrors, and skipped in this case.
|
|
if (view && view->rtype == RT_PORTALSURFACE && !VectorCompare(view->origin, view->oldorigin))
|
|
{ //q3-style portal, where a single entity provides orientation+two origins
|
|
float d;
|
|
vec3_t paxis[3], porigin, vaxis[3], vorg;
|
|
|
|
oplane = plane;
|
|
|
|
/*calculate where the surface is meant to be*/
|
|
VectorCopy(mesh->normals_array[0], paxis[0]);
|
|
PerpendicularVector(paxis[1], paxis[0]);
|
|
CrossProduct(paxis[0], paxis[1], paxis[2]);
|
|
d = DotProduct(view->origin, plane.normal) - plane.dist;
|
|
VectorMA(view->origin, -d, paxis[0], porigin);
|
|
|
|
/*grab the camera origin*/
|
|
VectorNegate(view->axis[0], vaxis[0]);
|
|
VectorNegate(view->axis[1], vaxis[1]);
|
|
VectorCopy(view->axis[2], vaxis[2]);
|
|
VectorCopy(view->oldorigin, vorg);
|
|
|
|
VectorCopy(vorg, r_refdef.pvsorigin);
|
|
|
|
/*rotate it a bit*/
|
|
if (view->framestate.g[FS_REG].frame[1]) //oldframe
|
|
{
|
|
if (view->framestate.g[FS_REG].frame[0]) //newframe
|
|
d = realtime * view->framestate.g[FS_REG].frame[0]; //newframe
|
|
else
|
|
d = view->skinnum + sin(realtime)*4;
|
|
}
|
|
else
|
|
d = view->skinnum;
|
|
|
|
if (d)
|
|
{
|
|
vec3_t rdir;
|
|
VectorCopy(vaxis[1], rdir);
|
|
RotatePointAroundVector(vaxis[1], vaxis[0], rdir, d);
|
|
CrossProduct(vaxis[0], vaxis[1], vaxis[2]);
|
|
}
|
|
|
|
TransformCoord(oldrefdef.vieworg, paxis, porigin, vaxis, vorg, r_refdef.vieworg);
|
|
TransformDir(vpn, paxis, vaxis, vpn);
|
|
TransformDir(vright, paxis, vaxis, vright);
|
|
TransformDir(vup, paxis, vaxis, vup);
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
|
|
|
|
//transform the old surface plane into the new view matrix
|
|
if (Matrix4_Invert(r_refdef.m_view, ivmat))
|
|
{
|
|
Matrix4_Multiply(ivmat, vmat, trmat);
|
|
plane.normal[0] = -(oplane.normal[0] * trmat[0] + oplane.normal[1] * trmat[1] + oplane.normal[2] * trmat[2]);
|
|
plane.normal[1] = -(oplane.normal[0] * trmat[4] + oplane.normal[1] * trmat[5] + oplane.normal[2] * trmat[6]);
|
|
plane.normal[2] = -(oplane.normal[0] * trmat[8] + oplane.normal[1] * trmat[9] + oplane.normal[2] * trmat[10]);
|
|
plane.dist = -oplane.dist + trmat[12]*oplane.normal[0] + trmat[13]*oplane.normal[1] + trmat[14]*oplane.normal[2];
|
|
portaltype = 1;
|
|
}
|
|
break;
|
|
}
|
|
//fixme: q3 gamecode has explicit mirrors. we 'should' just ignore the surface if we've not seen it yet.
|
|
|
|
//a portal with no portal entity, or a portal rentity with an origin equal to its oldorigin, is a mirror.
|
|
R_MirrorMatrix(&plane);
|
|
Matrix4x4_CM_ModelViewMatrixFromAxis(vmat, vpn, vright, vup, r_refdef.vieworg);
|
|
|
|
VectorCopy(mesh->xyz_array[0], r_refdef.pvsorigin);
|
|
for (i = 1; i < mesh->numvertexes; i++)
|
|
VectorAdd(r_refdef.pvsorigin, mesh->xyz_array[i], r_refdef.pvsorigin);
|
|
VectorScale(r_refdef.pvsorigin, 1.0/mesh->numvertexes, r_refdef.pvsorigin);
|
|
|
|
portaltype = 1;
|
|
break;
|
|
}
|
|
|
|
/*FIXME: can we get away with stenciling the screen?*/
|
|
/*Add to frustum culling instead of clip planes?*/
|
|
/* if (qglClipPlane && portaltype)
|
|
{
|
|
GLdouble glplane[4];
|
|
glplane[0] = plane.normal[0];
|
|
glplane[1] = plane.normal[1];
|
|
glplane[2] = plane.normal[2];
|
|
glplane[3] = plane.dist;
|
|
qglClipPlane(GL_CLIP_PLANE0, glplane);
|
|
qglEnable(GL_CLIP_PLANE0);
|
|
}
|
|
*/ //fixme: we can probably scissor a smaller frusum
|
|
R_SetFrustum (r_refdef.m_projection_std, vmat);
|
|
if (r_refdef.frustum_numplanes < MAXFRUSTUMPLANES)
|
|
{
|
|
extern int SignbitsForPlane (mplane_t *out);
|
|
mplane_t fp;
|
|
VectorCopy(plane.normal, fp.normal);
|
|
fp.dist = plane.dist;
|
|
|
|
// if (DotProduct(fp.normal, vpn) < 0)
|
|
// {
|
|
// VectorNegate(fp.normal, fp.normal);
|
|
// fp.dist *= -1;
|
|
// }
|
|
|
|
fp.type = PLANE_ANYZ;
|
|
fp.signbits = SignbitsForPlane (&fp);
|
|
|
|
if (portaltype == 1 || portaltype == 2)
|
|
R_ObliqueNearClip(vmat, &fp);
|
|
|
|
//our own culling should be an epsilon forwards so we don't still draw things behind the line due to precision issues.
|
|
fp.dist += 0.01;
|
|
r_refdef.frustum[r_refdef.frustum_numplanes++] = fp;
|
|
}
|
|
#if 1
|
|
if (depthmasklist)
|
|
{
|
|
/*draw already-drawn portals as depth-only, to ensure that their contents are not harmed*/
|
|
/*we can only do this AFTER the oblique perspective matrix is calculated, to avoid depth inconsistancies, while we still have the old view matrix*/
|
|
int i;
|
|
batch_t *dmask = NULL;
|
|
if (qglLoadMatrixf)
|
|
{
|
|
qglMatrixMode(GL_PROJECTION);
|
|
qglLoadMatrixf(r_refdef.m_projection_std);
|
|
qglMatrixMode(GL_MODELVIEW);
|
|
}
|
|
//portals to mask are relative to the old view still.
|
|
currententity = NULL;
|
|
if (gl_config.arb_depth_clamp)
|
|
qglEnable(GL_DEPTH_CLAMP_ARB); //ignore the near clip plane(ish), this means nearer portals can still mask further ones.
|
|
GL_ForceDepthWritable();
|
|
GLBE_SelectMode(BEM_DEPTHONLY);
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
for (dmask = depthmasklist[i]; dmask; dmask = dmask->next)
|
|
{
|
|
if (dmask == batch)
|
|
continue;
|
|
// if (dmask->meshes == dmask->firstmesh)
|
|
// continue;
|
|
GLBE_SubmitBatch(dmask);
|
|
}
|
|
}
|
|
GLBE_SelectMode(BEM_STANDARD);
|
|
if (gl_config.arb_depth_clamp)
|
|
qglDisable(GL_DEPTH_CLAMP_ARB);
|
|
|
|
currententity = NULL;
|
|
}
|
|
#endif
|
|
// r_refdef = oldrefdef;
|
|
// return;
|
|
|
|
//now determine the stuff the backend will use.
|
|
memcpy(r_refdef.m_view, vmat, sizeof(float)*16);
|
|
VectorAngles(vpn, vup, r_refdef.viewangles, false);
|
|
VectorCopy(r_refdef.vieworg, r_origin);
|
|
|
|
//determine r_refdef.flipcull & SHADER_CULL_FLIP based upon whether right is right or not.
|
|
CrossProduct(vpn, vup, r);
|
|
if (DotProduct(r, vright) < 0)
|
|
r_refdef.flipcull |= SHADER_CULL_FLIP;
|
|
else
|
|
r_refdef.flipcull &= ~SHADER_CULL_FLIP;
|
|
if (r_refdef.m_projection_std[5]<0)
|
|
r_refdef.flipcull ^= SHADER_CULL_FLIP;
|
|
|
|
Surf_SetupFrame();
|
|
//FIXME: just call Surf_DrawWorld instead?
|
|
R_RenderScene();
|
|
// if (qglClipPlane)
|
|
// qglDisable(GL_CLIP_PLANE0);
|
|
|
|
if (r_portaldrawplanes.ival)
|
|
{
|
|
//the front of the plane should generally point away from the camera, and will be drawn in bright green. woo
|
|
CL_DrawDebugPlane(plane.normal, plane.dist+0.01, 0.0, 0.5, 0.0, false);
|
|
CL_DrawDebugPlane(plane.normal, plane.dist-0.01, 0.0, 0.5, 0.0, false);
|
|
//the back of the plane points towards the camera, and will be drawn in blue, for the luls
|
|
VectorNegate(plane.normal, plane.normal);
|
|
plane.dist *= -1;
|
|
CL_DrawDebugPlane(plane.normal, plane.dist+0.01, 0.0, 0.0, 0.2, false);
|
|
CL_DrawDebugPlane(plane.normal, plane.dist-0.01, 0.0, 0.0, 0.2, false);
|
|
}
|
|
|
|
|
|
r_refdef = oldrefdef;
|
|
|
|
/*broken stuff*/
|
|
AngleVectors (r_refdef.viewangles, vpn, vright, vup);
|
|
VectorCopy (r_refdef.vieworg, r_origin);
|
|
|
|
GLBE_SelectEntity(&r_worldentity);
|
|
|
|
GL_CullFace(0);//make sure flipcull reversion takes effect
|
|
|
|
TRACE(("GLR_DrawPortal: portal drawn\n"));
|
|
|
|
#ifdef warningmsg
|
|
#pragma warningmsg("warning: there's a bug with rtlights in portals, culling is broken or something. May also be loading the wrong matrix")
|
|
#endif
|
|
currententity = NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
R_Clear
|
|
=============
|
|
*/
|
|
qboolean R_GameRectIsFullscreen(void)
|
|
{
|
|
return r_refdef.grect.x == 0 && r_refdef.grect.y == 0 && (unsigned)r_refdef.grect.width == vid.fbvwidth && (unsigned)r_refdef.grect.height == vid.fbvheight;
|
|
}
|
|
|
|
int gldepthfunc = GL_LEQUAL;
|
|
qboolean depthcleared;
|
|
void R_Clear (qboolean fbo)
|
|
{
|
|
/*tbh, this entire function should be in the backend*/
|
|
{
|
|
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
if (!depthcleared || fbo)
|
|
{
|
|
GL_ForceDepthWritable();
|
|
//we no longer clear colour here. we only ever (need to) do that at the start of the frame, and this point can be called multiple times per frame.
|
|
//for performance, we clear the depth at the same time we clear colour, so we can skip clearing depth here the first time around each frame.
|
|
//but for multiple scenes, we do need to clear depth still.
|
|
//fbos always get cleared depth, just in case (colour fbos may contain junk, but hey).
|
|
if ((fbo && r_clear.ival) || r_refdef.stereomethod==STEREO_RED_BLUE||r_refdef.stereomethod==STEREO_RED_GREEN)
|
|
qglClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
else
|
|
qglClear (GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
if (!fbo)
|
|
depthcleared = false;
|
|
gldepthmin = 0;
|
|
gldepthmax = 1;
|
|
gldepthfunc=GL_LEQUAL;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
void GLR_SetupFog (void)
|
|
{
|
|
if (r_viewleaf)// && r_viewcontents != FTECONTENTS_EMPTY)
|
|
{
|
|
// static fogcolour;
|
|
float fogcol[4]={0};
|
|
float fogperc;
|
|
float fogdist;
|
|
|
|
fogperc=0;
|
|
fogdist=512;
|
|
switch(r_viewcontents)
|
|
{
|
|
case FTECONTENTS_WATER:
|
|
fogcol[0] = 64/255.0;
|
|
fogcol[1] = 128/255.0;
|
|
fogcol[2] = 192/255.0;
|
|
fogperc=0.2;
|
|
fogdist=512;
|
|
break;
|
|
case FTECONTENTS_SLIME:
|
|
fogcol[0] = 32/255.0;
|
|
fogcol[1] = 192/255.0;
|
|
fogcol[2] = 92/255.0;
|
|
fogperc=1;
|
|
fogdist=256;
|
|
break;
|
|
case FTECONTENTS_LAVA:
|
|
fogcol[0] = 192/255.0;
|
|
fogcol[1] = 32/255.0;
|
|
fogcol[2] = 64/255.0;
|
|
fogperc=1;
|
|
fogdist=128;
|
|
break;
|
|
default:
|
|
fogcol[0] = 192/255.0;
|
|
fogcol[1] = 192/255.0;
|
|
fogcol[2] = 192/255.0;
|
|
fogperc=1;
|
|
fogdist=1024;
|
|
break;
|
|
}
|
|
if (fogperc)
|
|
{
|
|
qglFogi(GL_FOG_MODE, GL_LINEAR);
|
|
qglFogfv(GL_FOG_COLOR, fogcol);
|
|
qglFogf(GL_FOG_DENSITY, fogperc);
|
|
qglFogf(GL_FOG_START, 1);
|
|
qglFogf(GL_FOG_END, fogdist);
|
|
qglEnable(GL_FOG);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void R_RenderMotionBlur(void)
|
|
{
|
|
#if !defined(ANDROID) && !defined(NACL)
|
|
int vwidth = 1, vheight = 1;
|
|
float vs, vt, cs, ct;
|
|
shader_t *shader;
|
|
|
|
//figure out the size of our texture.
|
|
if (sh_config.texture_non_power_of_two_pic)
|
|
{ //we can use any size, supposedly
|
|
vwidth = vid.pixelwidth;
|
|
vheight = vid.pixelheight;
|
|
}
|
|
else
|
|
{ //limit the texture size to square and use padding.
|
|
while (vwidth < vid.pixelwidth)
|
|
vwidth *= 2;
|
|
while (vheight < vid.pixelheight)
|
|
vheight *= 2;
|
|
}
|
|
|
|
//blend the last frame onto the scene
|
|
//the maths is because our texture is over-sized (must be power of two)
|
|
cs = vs = (float)vid.pixelwidth / vwidth * 0.5;
|
|
ct = vt = (float)vid.pixelheight / vheight * 0.5;
|
|
vs *= gl_motionblurscale.value;
|
|
vt *= gl_motionblurscale.value;
|
|
|
|
//render using our texture
|
|
shader = R_RegisterShader("postproc_motionblur", SUF_NONE,
|
|
"{\n"
|
|
"program default2d\n"
|
|
"{\n"
|
|
"map $sourcecolour\n"
|
|
"blendfunc blend\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
GLBE_FBO_Sources(sceneblur_texture, r_nulltex);
|
|
R2D_ImageColours(1, 1, 1, gl_motionblur.value);
|
|
R2D_Image(0, 0, vid.width, vid.height, cs-vs, ct+vt, cs+vs, ct-vt, shader);
|
|
GLBE_RenderToTextureUpdate2d(false);
|
|
|
|
//grab the current image so we can feed that back into the next frame.
|
|
GL_MTBind(0, GL_TEXTURE_2D, sceneblur_texture);
|
|
//copy the image into the texture so that we can play with it next frame too!
|
|
qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, vwidth, vheight, 0);
|
|
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
#endif
|
|
}
|
|
|
|
#if 1
|
|
#include "shader.h"
|
|
/*FIXME: we could use geometry shaders to draw to all 6 faces at once*/
|
|
qboolean R_RenderScene_Cubemap(void)
|
|
{
|
|
int cmapsize = 512;
|
|
int i;
|
|
static vec3_t ang[6] =
|
|
{ {0, -90, 0}, {0, 90, 0},
|
|
{90, 0, 0}, {-90, 0, 0},
|
|
{0, 0, 0}, {0, -180, 0} };
|
|
vec3_t saveang;
|
|
vec3_t saveorg;
|
|
|
|
vrect_t vrect;
|
|
pxrect_t prect;
|
|
|
|
shader_t *shader;
|
|
int facemask;
|
|
extern cvar_t r_projection;
|
|
int oldfbo = -1;
|
|
qboolean usefbo = true; //this appears to be a 20% speedup in my tests.
|
|
qboolean fboreset = false;
|
|
int osm = r_refdef.stereomethod;
|
|
|
|
/*needs glsl*/
|
|
if (!gl_config.arb_shader_objects)
|
|
return false;
|
|
|
|
if (!*ffov.string || !strcmp(ffov.string, "0"))
|
|
ffov.value = scr_fov.value;
|
|
|
|
facemask = 0;
|
|
switch(r_projection.ival)
|
|
{
|
|
default: //invalid.
|
|
return false;
|
|
case PROJ_STEREOGRAPHIC:
|
|
shader = R_RegisterShader("postproc_stereographic", SUF_NONE,
|
|
"{\n"
|
|
"program postproc_stereographic\n"
|
|
"{\n"
|
|
"map $sourcecube\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
facemask |= 1<<4; /*front view*/
|
|
if (ffov.value > 70)
|
|
{
|
|
facemask |= (1<<0) | (1<<1); /*side/top*/
|
|
if (ffov.value > 85)
|
|
facemask |= (1<<2) | (1<<3); /*bottom views*/
|
|
if (ffov.value > 300)
|
|
facemask |= 1<<5; /*back view*/
|
|
}
|
|
break;
|
|
case PROJ_FISHEYE:
|
|
shader = R_RegisterShader("postproc_fisheye", SUF_NONE,
|
|
"{\n"
|
|
"program postproc_fisheye\n"
|
|
"{\n"
|
|
"map $sourcecube\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
//fisheye view sees up to a full sphere
|
|
facemask |= 1<<4; /*front view*/
|
|
if (ffov.value > 77)
|
|
facemask |= (1<<0) | (1<<1) | (1<<2) | (1<<3); /*side/top/bottom views*/
|
|
if (ffov.value > 270)
|
|
facemask |= 1<<5; /*back view*/
|
|
break;
|
|
case PROJ_PANORAMA:
|
|
shader = R_RegisterShader("postproc_panorama", SUF_NONE,
|
|
"{\n"
|
|
"program postproc_panorama\n"
|
|
"{\n"
|
|
"map $sourcecube\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
//panoramic view needs at most the four sides
|
|
facemask |= 1<<4; /*front view*/
|
|
if (ffov.value > 90)
|
|
{
|
|
facemask |= (1<<0) | (1<<1); /*side views*/
|
|
if (ffov.value > 270)
|
|
facemask |= 1<<5; /*back view*/
|
|
}
|
|
facemask = 0x3f;
|
|
break;
|
|
case PROJ_LAEA:
|
|
shader = R_RegisterShader("postproc_laea", SUF_NONE,
|
|
"{\n"
|
|
"program postproc_laea\n"
|
|
"{\n"
|
|
"map $sourcecube\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
facemask |= 1<<4; /*front view*/
|
|
if (ffov.value > 90)
|
|
{
|
|
facemask |= (1<<0) | (1<<1) | (1<<2) | (1<<3); /*side/top/bottom views*/
|
|
if (ffov.value > 270)
|
|
facemask |= 1<<5; /*back view*/
|
|
}
|
|
break;
|
|
|
|
case PROJ_EQUIRECTANGULAR:
|
|
shader = R_RegisterShader("postproc_equirectangular", SUF_NONE,
|
|
"{\n"
|
|
"program postproc_equirectangular\n"
|
|
"{\n"
|
|
"map $sourcecube\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
|
|
facemask = 0x3f;
|
|
#if 0
|
|
facemask |= 1<<4; /*front view*/
|
|
if (ffov.value > 90)
|
|
{
|
|
facemask |= (1<<0) | (1<<1) | (1<<2) | (1<<3); /*side/top/bottom views*/
|
|
if (ffov.value > 270)
|
|
facemask |= 1<<5; /*back view*/
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
//FIXME: we should be able to rotate the view
|
|
|
|
vrect = r_refdef.vrect;
|
|
prect = r_refdef.pxrect;
|
|
// prect.x = (vrect.x * vid.pixelwidth)/vid.width;
|
|
// prect.width = (vrect.width * vid.pixelwidth)/vid.width;
|
|
// prect.y = (vrect.y * vid.pixelheight)/vid.height;
|
|
// prect.height = (vrect.height * vid.pixelheight)/vid.height;
|
|
|
|
if (sh_config.texture_non_power_of_two_pic)
|
|
{
|
|
if (usefbo)
|
|
{
|
|
cmapsize = prect.width > prect.height?prect.width:prect.height;
|
|
if (cmapsize > 4096)//sh_config.texture_maxsize)
|
|
cmapsize = 4096;//sh_config.texture_maxsize;
|
|
}
|
|
else
|
|
cmapsize = prect.width < prect.height?prect.width:prect.height;
|
|
}
|
|
else if (!usefbo)
|
|
{
|
|
while (cmapsize > prect.width || cmapsize > prect.height)
|
|
{
|
|
cmapsize /= 2;
|
|
}
|
|
}
|
|
|
|
if (usefbo)
|
|
{
|
|
r_refdef.flags |= RDF_FISHEYE;
|
|
vid.fbpwidth = vid.fbpheight = cmapsize;
|
|
}
|
|
|
|
//FIXME: gl_max_size
|
|
|
|
VectorCopy(r_refdef.vieworg, saveorg);
|
|
VectorCopy(r_refdef.viewangles, saveang);
|
|
saveang[2] = 0;
|
|
|
|
r_refdef.stereomethod = STEREO_OFF;
|
|
|
|
if (!TEXVALID(scenepp_postproc_cube) || cmapsize != scenepp_postproc_cube_size)
|
|
{
|
|
if (!TEXVALID(scenepp_postproc_cube))
|
|
{
|
|
scenepp_postproc_cube = Image_CreateTexture("***fish***", NULL, IF_CUBEMAP|IF_RENDERTARGET|IF_CLAMP|IF_LINEAR);
|
|
qglGenTextures(1, &scenepp_postproc_cube->num);
|
|
}
|
|
else
|
|
{
|
|
qglDeleteTextures(1, &scenepp_postproc_cube->num);
|
|
scenepp_postproc_cube->num = 0;
|
|
GL_MTBind(0, GL_TEXTURE_CUBE_MAP_ARB, scenepp_postproc_cube);
|
|
qglGenTextures(1, &scenepp_postproc_cube->num);
|
|
}
|
|
|
|
GL_MTBind(0, GL_TEXTURE_CUBE_MAP_ARB, scenepp_postproc_cube);
|
|
for (i = 0; i < 6; i++)
|
|
qglCopyTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + i, 0, GL_RGB, 0, 0, cmapsize, cmapsize, 0);
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
qglTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
|
scenepp_postproc_cube_size = cmapsize;
|
|
|
|
fboreset = true;
|
|
}
|
|
|
|
vrect = r_refdef.vrect; //save off the old vrect
|
|
|
|
r_refdef.vrect.width = (cmapsize * vid.fbvwidth) / vid.fbpwidth;
|
|
r_refdef.vrect.height = (cmapsize * vid.fbvheight) / vid.fbpheight;
|
|
r_refdef.vrect.x = 0;
|
|
r_refdef.vrect.y = prect.y;
|
|
|
|
ang[0][0] = -saveang[0];
|
|
ang[0][1] = -90;
|
|
ang[0][2] = -saveang[0];
|
|
|
|
ang[1][0] = -saveang[0];
|
|
ang[1][1] = 90;
|
|
ang[1][2] = saveang[0];
|
|
ang[5][0] = -saveang[0]*2;
|
|
|
|
//in theory, we could use a geometry shader to duplicate the polygons to each face.
|
|
//that would of course require that every bit of glsl had such a geometry shader.
|
|
//it would at least reduce cpu load quite a bit.
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
if (!(facemask & (1<<i)))
|
|
continue;
|
|
|
|
if (usefbo)
|
|
{
|
|
int r = GLBE_FBO_Update(&fbo_postproc_cube, FBO_RB_DEPTH|(fboreset?FBO_RESET:0), &scenepp_postproc_cube, 1, r_nulltex, cmapsize, cmapsize, i);
|
|
fboreset = false;
|
|
if (oldfbo < 0)
|
|
oldfbo = r;
|
|
}
|
|
|
|
r_refdef.fov_x = 90;
|
|
r_refdef.fov_y = 90;
|
|
r_refdef.viewangles[0] = saveang[0]+ang[i][0];
|
|
r_refdef.viewangles[1] = saveang[1]+ang[i][1];
|
|
r_refdef.viewangles[2] = saveang[2]+ang[i][2];
|
|
|
|
R_Clear (usefbo);
|
|
|
|
GL_SetShaderState2D(false);
|
|
|
|
// render normal view
|
|
R_RenderScene ();
|
|
|
|
if (!usefbo)
|
|
{
|
|
GL_MTBind(0, GL_TEXTURE_CUBE_MAP_ARB, scenepp_postproc_cube);
|
|
qglCopyTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + i, 0, 0, 0, 0, vid.fbpheight - (prect.y + cmapsize), cmapsize, cmapsize);
|
|
}
|
|
|
|
r_framecount++;
|
|
}
|
|
|
|
if (usefbo)
|
|
GLBE_FBO_Pop(oldfbo);
|
|
|
|
r_refdef.vrect = vrect;
|
|
r_refdef.pxrect = prect;
|
|
VectorCopy(saveorg, r_refdef.vieworg);
|
|
r_refdef.stereomethod = osm;
|
|
|
|
//GL_ViewportUpdate();
|
|
GL_Set2D(false);
|
|
// go 2d
|
|
/* qglMatrixMode(GL_PROJECTION);
|
|
qglPushMatrix();
|
|
qglLoadIdentity ();
|
|
qglOrtho (0, vid.width, vid.height, 0, -99999, 99999);
|
|
qglMatrixMode(GL_MODELVIEW);
|
|
qglPushMatrix();
|
|
qglLoadIdentity ();
|
|
*/
|
|
// draw it through the shader
|
|
if (r_projection.ival == PROJ_EQUIRECTANGULAR)
|
|
{
|
|
//note vr screenshots have requirements here
|
|
R2D_Image(vrect.x, vrect.y, vrect.width, vrect.height, 0, 1, 1, 0, shader);
|
|
}
|
|
else if (r_projection.ival == PROJ_PANORAMA)
|
|
{
|
|
float saspect = .5;
|
|
float taspect = vrect.height / vrect.width * ffov.value / 90;//(0.5 * vrect.width) / vrect.height;
|
|
R2D_Image(vrect.x, vrect.y, vrect.width, vrect.height, -saspect, taspect, saspect, -taspect, shader);
|
|
}
|
|
else if (vrect.width > vrect.height)
|
|
{
|
|
float aspect = (0.5 * vrect.height) / vrect.width;
|
|
R2D_Image(vrect.x, vrect.y, vrect.width, vrect.height, -0.5, aspect, 0.5, -aspect, shader);
|
|
}
|
|
else
|
|
{
|
|
float aspect = (0.5 * vrect.width) / vrect.height;
|
|
R2D_Image(vrect.x, vrect.y, vrect.width, vrect.height, -aspect, 0.5, aspect, -0.5, shader);
|
|
}
|
|
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
|
|
//revert the matricies
|
|
/* qglMatrixMode(GL_PROJECTION);
|
|
qglPopMatrix();
|
|
qglMatrixMode(GL_MODELVIEW);
|
|
qglPopMatrix();
|
|
*/
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
texid_t R_RenderPostProcess (texid_t sourcetex, int type, shader_t *shader, char *restexname)
|
|
{
|
|
if (r_refdef.flags & type)
|
|
{
|
|
r_refdef.flags &= ~type;
|
|
|
|
if (r_refdef.flags & RDF_ALLPOSTPROC)
|
|
{ //there's other post-processing passes that still need to be applied.
|
|
//thus we need to write this output to a texture.
|
|
int w = (r_refdef.vrect.width * vid.pixelwidth) / vid.width;
|
|
int h = (r_refdef.vrect.height * vid.pixelheight) / vid.height;
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
GLBE_FBO_Sources(sourcetex, r_nulltex);
|
|
sourcetex = R2D_RT_Configure(restexname, w, h, TF_RGBA32, RT_IMAGEFLAGS);
|
|
GLBE_FBO_Update(&fbo_postproc, 0, &sourcetex, 1, r_nulltex, w, h, 0);
|
|
R2D_ScalePic(0, 0, r_refdef.vrect.width, r_refdef.vrect.height, shader);
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
GLBE_RenderToTextureUpdate2d(true);
|
|
}
|
|
else
|
|
{ //yay, dump it to the screen
|
|
//update stuff now that we're not rendering the 3d scene
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
GLBE_FBO_Sources(sourcetex, r_nulltex);
|
|
R2D_ScalePic(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height, shader);
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
}
|
|
}
|
|
|
|
return sourcetex;
|
|
}
|
|
|
|
/*
|
|
================
|
|
R_RenderView
|
|
|
|
r_refdef must be set before the first call
|
|
================
|
|
*/
|
|
void GLR_RenderView (void)
|
|
{
|
|
int dofbo = *r_refdef.rt_destcolour[0].texname || *r_refdef.rt_depth.texname;
|
|
double time1 = 0, time2;
|
|
texid_t sourcetex = r_nulltex;
|
|
shader_t *custompostproc = NULL;
|
|
float renderscale; //extreme, but whatever
|
|
int oldfbo = 0;
|
|
qboolean forcedfb = false;
|
|
|
|
checkglerror();
|
|
|
|
if (r_norefresh.value || !vid.fbpwidth || !vid.fbpwidth)
|
|
return;
|
|
|
|
//when loading/bugged, its possible that the world is still loading.
|
|
//in this case, don't act as a wallhack (unless the world is meant to be hidden anyway)
|
|
if (!(r_refdef.flags & RDF_NOWORLDMODEL))
|
|
{
|
|
//FIXME: fbo stuff
|
|
if (!r_worldentity.model || r_worldentity.model->loadstate != MLS_LOADED || !cl.worldmodel)
|
|
{
|
|
GL_Set2D (false);
|
|
R2D_ImageColours(0, 0, 0, 1);
|
|
R2D_FillBlock(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height);
|
|
R2D_ImageColours(1, 1, 1, 1);
|
|
return;
|
|
}
|
|
// Sys_Error ("R_RenderView: NULL worldmodel");
|
|
}
|
|
|
|
//check if we're underwater (this also limits damage from stereo wallhacks).
|
|
Surf_SetupFrame();
|
|
r_refdef.flags &= ~(RDF_ALLPOSTPROC|RDF_RENDERSCALE);
|
|
|
|
if (dofbo || (r_refdef.flags & RDF_NOWORLDMODEL))
|
|
renderscale = 1;
|
|
else
|
|
{
|
|
renderscale = r_renderscale.value;
|
|
if (R_CanBloom())
|
|
r_refdef.flags |= RDF_BLOOM;
|
|
}
|
|
|
|
//check if we can do underwater warp
|
|
if (cls.protocol != CP_QUAKE2) //quake2 tells us directly
|
|
{
|
|
if (r_viewcontents & FTECONTENTS_FLUID)
|
|
r_refdef.flags |= RDF_UNDERWATER;
|
|
else
|
|
r_refdef.flags &= ~RDF_UNDERWATER;
|
|
}
|
|
if (r_refdef.flags & RDF_UNDERWATER)
|
|
{
|
|
extern cvar_t r_projection;
|
|
if (!r_waterwarp.value || r_projection.ival)
|
|
r_refdef.flags &= ~RDF_UNDERWATER; //no warp at all
|
|
else if (r_waterwarp.value > 0 && scenepp_waterwarp)
|
|
r_refdef.flags |= RDF_WATERWARP; //try fullscreen warp instead if we can
|
|
}
|
|
|
|
if (!r_refdef.globalfog.density)
|
|
{
|
|
int fogtype = ((r_refdef.flags & RDF_UNDERWATER) && cl.fog[1].density)?1:0;
|
|
CL_BlendFog(&r_refdef.globalfog, &cl.oldfog[fogtype], realtime, &cl.fog[fogtype]);
|
|
r_refdef.globalfog.density /= 64; //FIXME
|
|
}
|
|
|
|
if (!(r_refdef.flags & RDF_NOWORLDMODEL))
|
|
{
|
|
if (r_fxaa.ival)
|
|
r_refdef.flags |= RDF_ANTIALIAS;
|
|
if (*r_postprocshader.string)
|
|
custompostproc = R_RegisterCustom(r_postprocshader.string, SUF_NONE, NULL, NULL);
|
|
else if (!r_graphics.ival)
|
|
custompostproc = R_RegisterShader("postproc_ascii", 0,
|
|
"{\n"
|
|
"program postproc_ascii\n"
|
|
"affine\n"
|
|
"{\n"
|
|
"map $sourcecolour\n"
|
|
"nodepthtest\n"
|
|
"}\n"
|
|
"}\n"
|
|
);
|
|
if (custompostproc)
|
|
r_refdef.flags |= RDF_CUSTOMPOSTPROC;
|
|
|
|
if (r_hdr_framebuffer.ival && !(vid.flags & VID_FP16)) //primary use of this cvar is to fix q3shader overbrights (so bright lightmaps can oversaturate then drop below 1 by modulation with the lightmap
|
|
forcedfb = true;
|
|
if (vid_hardwaregamma.ival == 4 && (v_gamma.value != 1 || v_contrast.value != 1 || v_contrastboost.value != 1|| v_brightness.value != 0))
|
|
r_refdef.flags |= RDF_SCENEGAMMA;
|
|
}
|
|
|
|
//disable stuff if its simply not supported.
|
|
if (dofbo || !gl_config.arb_shader_objects || !gl_config.ext_framebuffer_objects || !sh_config.texture_non_power_of_two_pic)
|
|
{
|
|
forcedfb &= !dofbo && gl_config.ext_framebuffer_objects && sh_config.texture_non_power_of_two_pic;
|
|
r_refdef.flags &= ~(RDF_ALLPOSTPROC); //block all of this stuff
|
|
}
|
|
if (dofbo)
|
|
forcedfb = false;
|
|
else if (renderscale != 1)
|
|
forcedfb = gl_config.ext_framebuffer_objects && sh_config.texture_non_power_of_two_pic;
|
|
|
|
BE_Scissor(NULL);
|
|
if (dofbo)
|
|
{
|
|
unsigned int flags = 0;
|
|
texid_t col[R_MAX_RENDERTARGETS], depth = r_nulltex;
|
|
unsigned int cw=0, ch=0, dw=0, dh=0;
|
|
int mrt;
|
|
|
|
if (!gl_config.ext_framebuffer_objects && sh_config.texture_non_power_of_two_pic)
|
|
{
|
|
Con_DPrintf(CON_WARNING"Render targets are not supported on this gpu.\n");
|
|
return; //not supported on this gpu. you'll just get black textures or something.
|
|
}
|
|
|
|
//3d views generally ignore source colour+depth.
|
|
//FIXME: support depth with no colour
|
|
for (mrt = 0; mrt < R_MAX_RENDERTARGETS; mrt++)
|
|
{
|
|
if (*r_refdef.rt_destcolour[mrt].texname)
|
|
{
|
|
col[mrt] = R2D_RT_GetTexture(r_refdef.rt_destcolour[mrt].texname, &cw, &ch);
|
|
if (!TEXVALID(col[mrt]))
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
col[mrt] = r_nulltex;
|
|
break;
|
|
}
|
|
}
|
|
if (*r_refdef.rt_depth.texname)
|
|
depth = R2D_RT_GetTexture(r_refdef.rt_depth.texname, &dw, &dh);
|
|
|
|
if (mrt)
|
|
{ //colour (with or without depth)
|
|
if (*r_refdef.rt_depth.texname && (dw != cw || dh != ch))
|
|
{
|
|
Con_Printf("RT: destcolour and depth render targets are of different sizes\n"); //should check rgb/depth modes too I guess.
|
|
depth = r_nulltex;
|
|
}
|
|
vid.fbvwidth = vid.fbpwidth = cw;
|
|
vid.fbvheight = vid.fbpheight = ch;
|
|
}
|
|
else
|
|
{ //depth, with no colour
|
|
vid.fbvwidth = vid.fbpwidth = dw;
|
|
vid.fbvheight = vid.fbpheight = dh;
|
|
}
|
|
if (TEXVALID(depth))
|
|
flags |= FBO_TEX_DEPTH;
|
|
else
|
|
flags |= FBO_RB_DEPTH;
|
|
oldfbo = GLBE_FBO_Update(&fbo_gameview, flags, col, mrt, depth, vid.fbpwidth, vid.fbpheight, 0);
|
|
}
|
|
else if ((r_refdef.flags & (RDF_ALLPOSTPROC)) || forcedfb)
|
|
{
|
|
unsigned int rtflags = IF_NOMIPMAP|IF_CLAMP|IF_RENDERTARGET|IF_NOSRGB;
|
|
enum uploadfmt fmt;
|
|
|
|
r_refdef.flags |= RDF_RENDERSCALE;
|
|
|
|
//the game needs to be drawn to a texture for post processing
|
|
if (1)//vid.framebuffer)
|
|
{
|
|
vid.fbpwidth = (r_refdef.vrect.width * r_refdef.pxrect.width) / vid.width;
|
|
vid.fbpheight = (r_refdef.vrect.height * r_refdef.pxrect.height) / vid.height;
|
|
}
|
|
else
|
|
{
|
|
vid.fbpwidth = (r_refdef.vrect.width * vid.pixelwidth) / vid.width;
|
|
vid.fbpheight = (r_refdef.vrect.height * vid.pixelheight) / vid.height;
|
|
}
|
|
|
|
if (renderscale < 0)
|
|
{
|
|
renderscale = -renderscale;
|
|
rtflags |= IF_NEAREST;
|
|
vid.fbpwidth *= renderscale;
|
|
vid.fbpheight *= renderscale;
|
|
}
|
|
else
|
|
{
|
|
rtflags |= IF_LINEAR;
|
|
vid.fbpwidth *= renderscale;
|
|
vid.fbpheight *= renderscale;
|
|
}
|
|
|
|
//well... err... meh.
|
|
vid.fbpwidth = bound(1, vid.fbpwidth, sh_config.texture2d_maxsize);
|
|
vid.fbpheight = bound(1, vid.fbpheight, sh_config.texture2d_maxsize);
|
|
|
|
vid.fbvwidth = vid.fbpwidth;
|
|
vid.fbvheight = vid.fbpheight;
|
|
|
|
fmt = PTI_RGBA8;
|
|
if (r_hdr_framebuffer.ival < 0)
|
|
{
|
|
fmt = -r_hdr_framebuffer.ival;
|
|
if (!sh_config.texfmt[fmt])
|
|
fmt = PTI_RGB565;
|
|
}
|
|
else if ((r_refdef.flags&RDF_SCENEGAMMA)||(vid.flags&(VID_SRGBAWARE|VID_FP16))||r_hdr_framebuffer.ival)
|
|
{ //gamma ramps really need higher colour precision, otherwise the entire thing looks terrible.
|
|
if (sh_config.texfmt[PTI_RGBA16F])
|
|
fmt = PTI_RGBA16F;
|
|
else if (sh_config.texfmt[PTI_A2BGR10])
|
|
fmt = PTI_A2BGR10;
|
|
}
|
|
|
|
sourcetex = R2D_RT_Configure("rt/$lastgameview", vid.fbpwidth, vid.fbpheight, fmt, rtflags);
|
|
|
|
oldfbo = GLBE_FBO_Update(&fbo_gameview, FBO_RB_DEPTH, &sourcetex, 1, r_nulltex, vid.fbpwidth, vid.fbpheight, 0);
|
|
dofbo = true;
|
|
}
|
|
else if (vid.framebuffer)
|
|
{
|
|
vid.fbvwidth = vid.width;
|
|
vid.fbvheight = vid.height;
|
|
vid.fbpwidth = vid.framebuffer->width;
|
|
vid.fbpheight = vid.framebuffer->height;
|
|
}
|
|
else
|
|
{
|
|
vid.fbvwidth = vid.width;
|
|
vid.fbvheight = vid.height;
|
|
vid.fbpwidth = vid.pixelwidth;
|
|
vid.fbpheight = vid.pixelheight;
|
|
}
|
|
r_refdef.flipcull = 0;
|
|
|
|
if (qglPNTrianglesiATI)
|
|
{
|
|
if (gl_ati_truform_type.ival)
|
|
{ //linear
|
|
qglPNTrianglesiATI(GL_PN_TRIANGLES_NORMAL_MODE_ATI, GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI);
|
|
qglPNTrianglesiATI(GL_PN_TRIANGLES_POINT_MODE_ATI, GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI);
|
|
}
|
|
else
|
|
{ //quadric
|
|
qglPNTrianglesiATI(GL_PN_TRIANGLES_NORMAL_MODE_ATI, GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI);
|
|
qglPNTrianglesiATI(GL_PN_TRIANGLES_POINT_MODE_ATI, GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI);
|
|
}
|
|
qglPNTrianglesfATI(GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, r_tessellation_level.value);
|
|
}
|
|
|
|
if (gl_finish.ival)
|
|
{
|
|
RSpeedMark();
|
|
qglFinish ();
|
|
RSpeedEnd(RSPEED_SUBMIT);
|
|
}
|
|
|
|
if (r_speeds.ival)
|
|
{
|
|
time1 = Sys_DoubleTime ();
|
|
}
|
|
|
|
if (!(r_refdef.flags & RDF_NOWORLDMODEL) && R_RenderScene_Cubemap())
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
GL_SetShaderState2D(false);
|
|
|
|
R_Clear (dofbo);
|
|
|
|
// GLR_SetupFog ();
|
|
|
|
// render normal view
|
|
R_RenderScene ();
|
|
}
|
|
|
|
// qglDisable(GL_FOG);
|
|
|
|
if (r_speeds.ival)
|
|
{
|
|
// glFinish ();
|
|
time2 = Sys_DoubleTime ();
|
|
|
|
RQuantAdd(RQUANT_MSECS, (int)((time2-time1)*1000000));
|
|
|
|
// Con_Printf ("%3i ms %4i wpoly %4i epoly\n", (int)((time2-time1)*1000), c_brush_polys, c_alias_polys);
|
|
}
|
|
|
|
checkglerror();
|
|
|
|
//update stuff now that we're not rendering the 3d scene
|
|
if (dofbo)
|
|
GLBE_FBO_Pop(oldfbo);
|
|
|
|
GLBE_RenderToTextureUpdate2d(false);
|
|
GL_Set2D (false);
|
|
|
|
// SCENE POST PROCESSING
|
|
|
|
if (forcedfb && !(r_refdef.flags & RDF_ALLPOSTPROC))
|
|
{
|
|
GLBE_FBO_Sources(sourcetex, r_nulltex);
|
|
R2D_Image(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height, 0, 1, 1, 0, scenepp_rescaled);
|
|
}
|
|
else
|
|
{
|
|
if (r_refdef.flags & RDF_SCENEGAMMA)
|
|
{
|
|
R2D_ImageColours (v_gammainverted.ival?v_gamma.value:(1/v_gamma.value), v_contrast.value, v_brightness.value, v_contrastboost.value);
|
|
sourcetex = R_RenderPostProcess (sourcetex, RDF_SCENEGAMMA, scenepp_gamma, "rt/$gammaed");
|
|
R2D_ImageColours (1, 1, 1, 1);
|
|
}
|
|
sourcetex = R_RenderPostProcess (sourcetex, RDF_WATERWARP, scenepp_waterwarp, "rt/$waterwarped");
|
|
sourcetex = R_RenderPostProcess (sourcetex, RDF_CUSTOMPOSTPROC, custompostproc, "rt/$postproced");
|
|
sourcetex = R_RenderPostProcess (sourcetex, RDF_ANTIALIAS, scenepp_antialias, "rt/$antialiased");
|
|
if (r_refdef.flags & RDF_BLOOM)
|
|
R_BloomBlend(sourcetex, r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height);
|
|
}
|
|
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
|
|
GLBE_FBO_Sources(r_nulltex, r_nulltex);
|
|
|
|
if (gl_motionblur.value>0 && gl_motionblur.value < 1 && qglCopyTexImage2D)
|
|
R_RenderMotionBlur();
|
|
|
|
checkglerror();
|
|
}
|
|
|
|
#endif
|