/* 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" #include "vr.h" void R_RenderBrushPoly (msurface_t *fa); #define PROJECTION_DISTANCE 200 #define MAX_STENCIL_ENTS 128 extern int gl_stencilbits; //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 = CVARFD("gl_affinemodels","0", CVAR_ARCHIVE, "Use affine texture sampling for models. This replicates software rendering's distortions."); 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 r_portaldrawplanes; extern cvar_t r_portalonly; extern cvar_t scr_fov; static shader_t *scenepp_rescaled; static shader_t *scenepp_antialias; static shader_t *scenepp_waterwarp; static shader_t *scenepp_gamma; // post processing stuff static texid_t sceneblur_texture; static texid_t scenepp_texture_warp; static texid_t scenepp_texture_edge; texid_t scenepp_postproc_cube; static int scenepp_postproc_cube_size; static fbostate_t fbo_vr; static fbostate_t fbo_gameview; static fbostate_t fbo_postproc; static 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 static 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_vr); 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_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, 1, 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) { float em[16]; float vm[16]; if (e->flags & RF_WEAPONMODELNOBOB) { vm[0] = r_refdef.weaponmatrix[0][0]; vm[1] = r_refdef.weaponmatrix[0][1]; vm[2] = r_refdef.weaponmatrix[0][2]; vm[3] = 0; vm[4] = r_refdef.weaponmatrix[1][0]; vm[5] = r_refdef.weaponmatrix[1][1]; vm[6] = r_refdef.weaponmatrix[1][2]; vm[7] = 0; vm[8] = r_refdef.weaponmatrix[2][0]; vm[9] = r_refdef.weaponmatrix[2][1]; vm[10] = r_refdef.weaponmatrix[2][2]; vm[11] = 0; vm[12] = r_refdef.weaponmatrix[3][0]; vm[13] = r_refdef.weaponmatrix[3][1]; vm[14] = r_refdef.weaponmatrix[3][2]; vm[15] = 1; } else { vm[0] = r_refdef.weaponmatrix_bob[0][0]; vm[1] = r_refdef.weaponmatrix_bob[0][1]; vm[2] = r_refdef.weaponmatrix_bob[0][2]; vm[3] = 0; vm[4] = r_refdef.weaponmatrix_bob[1][0]; vm[5] = r_refdef.weaponmatrix_bob[1][1]; vm[6] = r_refdef.weaponmatrix_bob[1][2]; vm[7] = 0; vm[8] = r_refdef.weaponmatrix_bob[2][0]; vm[9] = r_refdef.weaponmatrix_bob[2][1]; vm[10] = r_refdef.weaponmatrix_bob[2][2]; vm[11] = 0; vm[12] = r_refdef.weaponmatrix_bob[3][0]; vm[13] = r_refdef.weaponmatrix_bob[3][1]; vm[14] = r_refdef.weaponmatrix_bob[3][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); } //================================================================================== /* ============= R_SetupGL ============= */ static void R_SetupGL (const float eyematrix[12]/*can be null*/, const vec4_t fovoverrides/*can be null*/, const float projmatrix[16]/*can be null*/, const pxrect_t *viewport/*can be null*/, texid_t fbo/*can be null*/) { int x, x2, y2, y, w, h; vec3_t newa; float fov_x, fov_y, fov_l, fov_r, fov_d, fov_u; float fovv_x, fovv_y; TRACE(("dbg: calling R_SetupGL\n")); 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 (eyematrix) { extern cvar_t in_vraim; matrix3x4 basematrix; matrix3x4 viewmatrix; if (r_refdef.base_known) { //mod is specifying its own base ang+org. Matrix3x4_RM_FromAngles(r_refdef.base_angles, r_refdef.base_origin, basematrix[0]); Matrix3x4_Multiply(eyematrix, basematrix[0], viewmatrix[0]); Matrix3x4_RM_ToVectors(viewmatrix[0], vpn, vright, vup, r_origin); VectorNegate(vright, vright); } else { //mod provides no info. //client will fiddle with input_angles newa[0] = newa[2] = 0; //ignore player pitch+roll. sorry. apply the eye's transform on top. if (in_vraim.ival) newa[1] -= SHORT2ANGLE(r_refdef.playerview->vrdev[VRDEV_HEAD].angles[YAW]); Matrix3x4_RM_FromAngles(newa, r_refdef.vieworg, basematrix[0]); Matrix3x4_Multiply(eyematrix, basematrix[0], viewmatrix[0]); Matrix3x4_RM_ToVectors(viewmatrix[0], vpn, vright, vup, r_origin); VectorNegate(vright, vright); } } else { AngleVectors (newa, vpn, vright, vup); VectorCopy(r_refdef.vieworg, r_origin); } VectorAdd(r_origin, r_refdef.eyeoffset, r_origin); //used for vr screenshots // // set up viewpoint // if (viewport) { r_refdef.pxrect = *viewport; } else if (fbo) { //with VR fbo postprocessing, we disable all viewport. r_refdef.pxrect.x = 0; r_refdef.pxrect.y = 0; r_refdef.pxrect.width = fbo->width; r_refdef.pxrect.height = fbo->height; r_refdef.pxrect.maxheight = fbo->height; } else 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) { 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; } if (projmatrix) { memcpy(r_refdef.m_projection_std, projmatrix, sizeof(r_refdef.m_projection_std)); memcpy(r_refdef.m_projection_view, projmatrix, sizeof(r_refdef.m_projection_view)); r_refdef.flipcull = 0; } else { if (fovoverrides) { fov_l = fovoverrides[0]; fov_r = fovoverrides[1]; fov_d = fovoverrides[2]; fov_u = fovoverrides[3]; fov_x = fov_r-fov_l; fov_y = fov_u-fov_d; fovv_x = fov_x; fovv_y = fov_y; r_refdef.flipcull = ((fov_u < fov_d)^(fov_r < fov_l))?SHADER_CULL_FLIP:0; } else { 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); } fov_l = -fov_x / 2; fov_r = fov_x / 2; fov_d = -fov_y / 2; fov_u = fov_y / 2; } if (r_xflip.ival) { float t = fov_l; fov_l = fov_r; fov_r = t; r_refdef.flipcull ^= SHADER_CULL_FLIP; fovv_x *= -1; } if (r_refdef.useperspective) { float maxdist = r_refdef.maxdist; if (sh_config.stencilbits && Sh_StencilShadowsActive()) maxdist = 0; //if we're using stencil shadows then force the maxdist to infinite to ensure the shadow volume is sealed. Matrix4x4_CM_Projection_Offset(r_refdef.m_projection_std, fov_l, fov_r, fov_d, fov_u, r_refdef.mindist, maxdist, false); Matrix4x4_CM_Projection_Offset(r_refdef.m_projection_view, -fovv_x/2, fovv_x/2, -fovv_y/2, fovv_y/2, r_refdef.mindist, maxdist, false); r_refdef.m_projection_std[8] += r_refdef.projectionoffset[0]; r_refdef.m_projection_std[9] += r_refdef.projectionoffset[1]; r_refdef.m_projection_view[8] += r_refdef.projectionoffset[0]; r_refdef.m_projection_view[9] += r_refdef.projectionoffset[1]; } 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); //bias the viewmodel depth range to a third: -1 through -0.333 (instead of -1 to 1) 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; GL_ViewportUpdate(); } 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 ================ */ static void R_RenderScene_Internal(void) { extern qboolean depthcleared; int tmpvisents = cl_numvisedicts; 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; depthcleared = false; //whatever is in the depth buffer is no longer useful. if (vrui.enabled) { vec3_t uifwd, uiright, uiup; vec3_t diff; float d; vec3_t ctrlang, ctrlorg, aimdir; extern cvar_t cl_vrui_lock; if (cl_vrui_lock.ival) VRUI_SnapAngle(); // extern usercmd_t cl_pendingcmd[MAX_SPLITS]; AngleVectors(vrui.angles, uifwd, uiright, uiup); VectorAngles(uiright, uifwd, r_worldentity.angles, false); AngleVectors(r_worldentity.angles, r_worldentity.axis[0], r_worldentity.axis[1], r_worldentity.axis[2]); VectorNegate(r_worldentity.axis[1], r_worldentity.axis[1]); r_worldentity.scale = 1;//0.2; VectorMA(r_refdef.vieworg, Cvar_Get("2dz", "256", 0, "")->value*r_worldentity.scale, r_worldentity.axis[2], r_worldentity.origin); VectorMA(r_worldentity.origin, -(int)(vid.width/2)*r_worldentity.scale, r_worldentity.axis[0], r_worldentity.origin); VectorMA(r_worldentity.origin, -(int)(vid.height/2)*r_worldentity.scale, r_worldentity.axis[1], r_worldentity.origin); GL_SetShaderState2D(true); VectorCopy(r_refdef.viewangles, ctrlang); if (r_refdef.playerview->vrdev[VRDEV_RIGHT].status&VRSTATUS_ANG) { ctrlang[0] = SHORT2ANGLE(r_refdef.playerview->vrdev[VRDEV_RIGHT].angles[0]); ctrlang[1] = SHORT2ANGLE(r_refdef.playerview->vrdev[VRDEV_RIGHT].angles[1]); ctrlang[2] = SHORT2ANGLE(r_refdef.playerview->vrdev[VRDEV_RIGHT].angles[2]); } else VectorCopy(r_refdef.viewangles, ctrlang); if (r_refdef.playerview->vrdev[VRDEV_RIGHT].status&VRSTATUS_ORG) VectorCopy(r_refdef.playerview->vrdev[VRDEV_RIGHT].origin, ctrlorg); else VectorCopy(r_refdef.vieworg, ctrlorg); AngleVectors(ctrlang, aimdir, NULL, NULL); VectorSubtract(r_worldentity.origin, ctrlorg, diff); //d = DotProduct(diff, vpn); //figure out how far we need to move it to get an impact. d = DotProduct(diff, r_worldentity.axis[2]); d /= DotProduct(aimdir, r_worldentity.axis[2]); //compensate for the length. VectorMA(ctrlorg, d, aimdir, diff); //calc the impact point... VectorSubtract(diff, r_worldentity.origin, diff); mousecursor_x = DotProduct(diff, r_worldentity.axis[0]); mousecursor_y = DotProduct(diff, r_worldentity.axis[1]); mousecursor_x = bound(0, mousecursor_x, vid.width-1); mousecursor_y = bound(0, mousecursor_y, vid.height-1); #ifdef PLUGINS Plug_SBar (r_refdef.playerview); #else if (Sbar_ShouldDraw(r_refdef.playerview)) { SCR_TileClear (sb_lines); Sbar_Draw (r_refdef.playerview); Sbar_DrawScoreboard (r_refdef.playerview); } else SCR_TileClear (0); #endif SCR_DrawTwoDimensional(true); VectorClear(r_worldentity.origin); VectorClear(r_worldentity.angles); VectorSet(r_worldentity.axis[0], 1,0,0); VectorSet(r_worldentity.axis[1], 0,1,0); VectorSet(r_worldentity.axis[2], 0,0,1); r_worldentity.scale = 1; GL_SetShaderState2D(false); } } static void R_RenderEyeScene (texid_t rendertarget, const pxrect_t *viewport, const vec4_t fovoverride, const float projmatrix[16], const float eyematrix[12]) { extern qboolean depthcleared; refdef_t refdef = r_refdef; int pw = vid.fbpwidth; int ph = vid.fbpheight; int r = 0; extern void CL_ClampPitch (int pnum, float frametime); /*the vr code tends to be somewhat laggy with its head angles, leaving it to the last minute, so redo this to reduce latency*/ if ((size_t)(refdef.playerview-cl.playerview) < MAX_SPLITS) CL_ClampPitch (refdef.playerview-cl.playerview, 0); vrui.enabled = true; if (rendertarget) { r = GLBE_FBO_Update(&fbo_vr, FBO_RB_DEPTH, &rendertarget, 1, r_nulltex, rendertarget->width, rendertarget->height, 0); GL_ForceDepthWritable(); qglClear (GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT); depthcleared = true; vid.fbpwidth = rendertarget->width; vid.fbpheight = rendertarget->height; } R_SetupGL (eyematrix, fovoverride, projmatrix, viewport, rendertarget); R_RenderScene_Internal(); if (rendertarget) { GLBE_FBO_Pop(r); if (gl_finish.ival) qglFinish(); } r_refdef = refdef; vid.fbpwidth = pw; vid.fbpheight = ph; } static void R_RenderScene (void) { float stereooffset[2]; int stereoframes = 1; int stereomode; int i; int cull = r_refdef.flipcull; unsigned int colourmask = r_refdef.colourmask; vec3_t eyeangorg[2]; float eyematrix[12]; extern qboolean depthcleared; r_refdef.colourmask = 0u; 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||r_stereo_convergence.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; } if (vid.vr && !r_refdef.recurse && vid.vr->Render(R_RenderEyeScene)) ; //we drew something VR-ey else if (stereomode == STEREO_OFF) { GL_ForceDepthWritable(); qglClear (GL_DEPTH_BUFFER_BIT); R_SetupGL (NULL, NULL, NULL, NULL, NULL); R_RenderScene_Internal(); } else for (i = 0; i < stereoframes; i++) { r_refdef.colourmask = 0u; 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) r_refdef.colourmask = (SBITS_MASK_GREEN|SBITS_MASK_BLUE); else r_refdef.colourmask = SBITS_MASK_RED; break; case STEREO_RED_BLUE: //red/blue if (stereooffset[i] < 0) r_refdef.colourmask = (SBITS_MASK_GREEN|SBITS_MASK_BLUE); else r_refdef.colourmask = (SBITS_MASK_RED|SBITS_MASK_GREEN); break; case STEREO_RED_GREEN: //red/green if (stereooffset[i] < 0) r_refdef.colourmask = (SBITS_MASK_GREEN|SBITS_MASK_BLUE); else r_refdef.colourmask = (SBITS_MASK_RED|SBITS_MASK_BLUE); break; 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 (!depthcleared) { GL_ForceDepthWritable(); qglClear (GL_DEPTH_BUFFER_BIT); depthcleared = true; } eyeangorg[0][0] = 0; eyeangorg[0][1] = r_stereo_convergence.value * (i?0.5:-0.5); eyeangorg[0][2] = 0; VectorSet(eyeangorg[1], 0, stereooffset[i], 0); Matrix3x4_RM_FromAngles(eyeangorg[0], eyeangorg[1], eyematrix); R_SetupGL (eyematrix, NULL, NULL, NULL, NULL); R_RenderScene_Internal (); } 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: break; case 5: break; } r_refdef.flipcull = cull; r_refdef.colourmask = colourmask; } /*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) { 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); } } else return; //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 = false; r_refdef.forcedvis = NULL; newvis.buffer = alloca(newvis.buffersize=cl.worldmodel->pvsbytes); for (i = batch->firstmesh; i < batch->meshes; i++) { mesh = batch->mesh[i]; if (!mesh->xyz_array) continue; r_refdef.forcevis = true; 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 ============= */ int gldepthfunc = GL_LEQUAL; qboolean depthcleared; void R_Clear (qboolean fbo) { /*tbh, this entire function should be in the backend*/ { 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) { qglClearColor(0, 0, 0, 1); 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) 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_TEXTYPE_CUBE|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< 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, texid_t sourcedepth, 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, sourcedepth); sourcetex = R2D_RT_Configure(restexname, w, h, TF_RGBA32, RT_IMAGEFLAGS); GLBE_FBO_Update(&fbo_postproc, 0, &sourcetex, 1, r_nulltex, w, h, 0); qglViewport(0,0,w,h); R2D_ScalePic(0, 0, vid.fbvwidth, vid.fbvheight, 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, sourcedepth); 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; texid_t sourcedepth = r_nulltex; shader_t *custompostproc = NULL; float renderscale; //extreme, but whatever int oldfbo = 0; qboolean forcedfb = false; qboolean fbdepth = 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 || !cl.worldmodel) r_refdef.flags |= RDF_NOWORLDMODEL; else if (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[FOGTYPE_WATER].density)?FOGTYPE_WATER:FOGTYPE_AIR; 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(NULL, 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 (custompostproc) { int i; for (i = 0; i < custompostproc->numpasses; i++) if (custompostproc->passes[i].texgen == T_GEN_SOURCEDEPTH) { fbdepth = true; break; } } 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; unsigned int fboflags = 0; 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) { //cvar change handler will set ival negative if it matches a known format name, doesn't mean its supported. fmt = -r_hdr_framebuffer.ival; if (fmt >= PTI_FIRSTCOMPRESSED || !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_B10G11R11F]) fmt = PTI_B10G11R11F; else 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); if (fbdepth) { if (sh_config.texfmt[PTI_DEPTH24_8] && !r_shadow_shadowmapping.ival) fmt = PTI_DEPTH24_8; else if (sh_config.texfmt[PTI_DEPTH32]) fmt = PTI_DEPTH32; else fmt = PTI_DEPTH16; } else fmt = PTI_INVALID; sourcedepth = (fmt != PTI_INVALID)?R2D_RT_Configure("rt/$lastgameviewdepth", vid.fbpwidth, vid.fbpheight, fmt, rtflags):r_nulltex; if (sourcedepth) fboflags = FBO_TEX_DEPTH; else fboflags = FBO_RB_DEPTH; oldfbo = GLBE_FBO_Update(&fbo_gameview, fboflags, &sourcetex, 1, sourcedepth, 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, sourcedepth); 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, sourcedepth, RDF_SCENEGAMMA, scenepp_gamma, "rt/$gammaed"); R2D_ImageColours (1, 1, 1, 1); } sourcetex = R_RenderPostProcess (sourcetex, sourcedepth, RDF_WATERWARP, scenepp_waterwarp, "rt/$waterwarped"); sourcetex = R_RenderPostProcess (sourcetex, sourcedepth, RDF_CUSTOMPOSTPROC, custompostproc, "rt/$postproced"); sourcetex = R_RenderPostProcess (sourcetex, sourcedepth, 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