+ if (r_svbsp.nodes)
+ Mem_Free(r_svbsp.nodes);
+ memset(&r_svbsp, 0, sizeof (r_svbsp));
+ R_FreeTexturePool(&r_main_texturepool);
+ r_texture_blanknormalmap = NULL;
+ r_texture_white = NULL;
+ r_texture_grey128 = NULL;
+ r_texture_black = NULL;
+ r_texture_whitecube = NULL;
+ r_texture_normalizationcube = NULL;
+ memset(&r_bloomstate, 0, sizeof(r_bloomstate));
+ memset(&r_waterstate, 0, sizeof(r_waterstate));
+ R_GLSL_Restart_f();
+}
+
+extern void CL_ParseEntityLump(char *entitystring);
+void gl_main_newmap(void)
+{
+ // FIXME: move this code to client
+ int l;
+ char *entities, entname[MAX_QPATH];
+ if (cl.worldmodel)
+ {
+ strlcpy(entname, cl.worldmodel->name, sizeof(entname));
+ l = (int)strlen(entname) - 4;
+ if (l >= 0 && !strcmp(entname + l, ".bsp"))
+ {
+ memcpy(entname + l, ".ent", 5);
+ if ((entities = (char *)FS_LoadFile(entname, tempmempool, true, NULL)))
+ {
+ CL_ParseEntityLump(entities);
+ Mem_Free(entities);
+ return;
+ }
+ }
+ if (cl.worldmodel->brush.entities)
+ CL_ParseEntityLump(cl.worldmodel->brush.entities);
+ }
+}
+
+void GL_Main_Init(void)
+{
+ r_main_mempool = Mem_AllocPool("Renderer", 0, NULL);
+
+ Cmd_AddCommand("r_glsl_restart", R_GLSL_Restart_f, "unloads GLSL shaders, they will then be reloaded as needed");
+ Cmd_AddCommand("r_glsl_dumpshader", R_GLSL_DumpShader_f, "dumps the engine internal default.glsl shader into glsl/default.glsl");
+ // FIXME: the client should set up r_refdef.fog stuff including the fogmasktable
+ if (gamemode == GAME_NEHAHRA)
+ {
+ Cvar_RegisterVariable (&gl_fogenable);
+ Cvar_RegisterVariable (&gl_fogdensity);
+ Cvar_RegisterVariable (&gl_fogred);
+ Cvar_RegisterVariable (&gl_foggreen);
+ Cvar_RegisterVariable (&gl_fogblue);
+ Cvar_RegisterVariable (&gl_fogstart);
+ Cvar_RegisterVariable (&gl_fogend);
+ }
+ Cvar_RegisterVariable(&r_depthfirst);
+ Cvar_RegisterVariable(&r_nearclip);
+ Cvar_RegisterVariable(&r_showbboxes);
+ Cvar_RegisterVariable(&r_showsurfaces);
+ Cvar_RegisterVariable(&r_showtris);
+ Cvar_RegisterVariable(&r_shownormals);
+ Cvar_RegisterVariable(&r_showlighting);
+ Cvar_RegisterVariable(&r_showshadowvolumes);
+ Cvar_RegisterVariable(&r_showcollisionbrushes);
+ Cvar_RegisterVariable(&r_showcollisionbrushes_polygonfactor);
+ Cvar_RegisterVariable(&r_showcollisionbrushes_polygonoffset);
+ Cvar_RegisterVariable(&r_showdisabledepthtest);
+ Cvar_RegisterVariable(&r_drawportals);
+ Cvar_RegisterVariable(&r_drawentities);
+ Cvar_RegisterVariable(&r_cullentities_trace);
+ Cvar_RegisterVariable(&r_cullentities_trace_samples);
+ Cvar_RegisterVariable(&r_cullentities_trace_enlarge);
+ Cvar_RegisterVariable(&r_cullentities_trace_delay);
+ Cvar_RegisterVariable(&r_drawviewmodel);
+ Cvar_RegisterVariable(&r_speeds);
+ Cvar_RegisterVariable(&r_fullbrights);
+ Cvar_RegisterVariable(&r_wateralpha);
+ Cvar_RegisterVariable(&r_dynamic);
+ Cvar_RegisterVariable(&r_fullbright);
+ Cvar_RegisterVariable(&r_shadows);
+ Cvar_RegisterVariable(&r_shadows_throwdistance);
+ Cvar_RegisterVariable(&r_q1bsp_skymasking);
+ Cvar_RegisterVariable(&r_polygonoffset_submodel_factor);
+ Cvar_RegisterVariable(&r_polygonoffset_submodel_offset);
+ Cvar_RegisterVariable(&r_textureunits);
+ Cvar_RegisterVariable(&r_glsl);
+ Cvar_RegisterVariable(&r_glsl_offsetmapping);
+ Cvar_RegisterVariable(&r_glsl_offsetmapping_reliefmapping);
+ Cvar_RegisterVariable(&r_glsl_offsetmapping_scale);
+ Cvar_RegisterVariable(&r_glsl_deluxemapping);
+ Cvar_RegisterVariable(&r_water);
+ Cvar_RegisterVariable(&r_water_resolutionmultiplier);
+ Cvar_RegisterVariable(&r_water_clippingplanebias);
+ Cvar_RegisterVariable(&r_water_refractdistort);
+ Cvar_RegisterVariable(&r_water_reflectdistort);
+ Cvar_RegisterVariable(&r_lerpsprites);
+ Cvar_RegisterVariable(&r_lerpmodels);
+ Cvar_RegisterVariable(&r_waterscroll);
+ Cvar_RegisterVariable(&r_bloom);
+ Cvar_RegisterVariable(&r_bloom_colorscale);
+ Cvar_RegisterVariable(&r_bloom_brighten);
+ Cvar_RegisterVariable(&r_bloom_blur);
+ Cvar_RegisterVariable(&r_bloom_resolution);
+ Cvar_RegisterVariable(&r_bloom_colorexponent);
+ Cvar_RegisterVariable(&r_bloom_colorsubtract);
+ Cvar_RegisterVariable(&r_hdr);
+ Cvar_RegisterVariable(&r_hdr_scenebrightness);
+ Cvar_RegisterVariable(&r_glsl_contrastboost);
+ Cvar_RegisterVariable(&r_hdr_glowintensity);
+ Cvar_RegisterVariable(&r_hdr_range);
+ Cvar_RegisterVariable(&r_smoothnormals_areaweighting);
+ Cvar_RegisterVariable(&developer_texturelogging);
+ Cvar_RegisterVariable(&gl_lightmaps);
+ Cvar_RegisterVariable(&r_test);
+ Cvar_RegisterVariable(&r_batchmode);
+ if (gamemode == GAME_NEHAHRA || gamemode == GAME_TENEBRAE)
+ Cvar_SetValue("r_fullbrights", 0);
+ R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
+
+ Cvar_RegisterVariable(&r_track_sprites);
+ Cvar_RegisterVariable(&r_track_sprites_flags);
+ Cvar_RegisterVariable(&r_track_sprites_scalew);
+ Cvar_RegisterVariable(&r_track_sprites_scaleh);
+}
+
+extern void R_Textures_Init(void);
+extern void GL_Draw_Init(void);
+extern void GL_Main_Init(void);
+extern void R_Shadow_Init(void);
+extern void R_Sky_Init(void);
+extern void GL_Surf_Init(void);
+extern void R_Light_Init(void);
+extern void R_Particles_Init(void);
+extern void R_Explosion_Init(void);
+extern void gl_backend_init(void);
+extern void Sbar_Init(void);
+extern void R_LightningBeams_Init(void);
+extern void Mod_RenderInit(void);
+
+void Render_Init(void)
+{
+ gl_backend_init();
+ R_Textures_Init();
+ GL_Main_Init();
+ GL_Draw_Init();
+ R_Shadow_Init();
+ R_Sky_Init();
+ GL_Surf_Init();
+ Sbar_Init();
+ R_Light_Init();
+ R_Particles_Init();
+ R_Explosion_Init();
+ R_LightningBeams_Init();
+ Mod_RenderInit();
+}
+
+/*
+===============
+GL_Init
+===============
+*/
+extern char *ENGINE_EXTENSIONS;
+void GL_Init (void)
+{
+ VID_CheckExtensions();
+
+ // LordHavoc: report supported extensions
+ Con_DPrintf("\nQuakeC extensions for server and client: %s\nQuakeC extensions for menu: %s\n", vm_sv_extensions, vm_m_extensions );
+
+ // clear to black (loading plaque will be seen over this)
+ CHECKGLERROR
+ qglClearColor(0,0,0,1);CHECKGLERROR
+ qglClear(GL_COLOR_BUFFER_BIT);CHECKGLERROR
+}
+
+int R_CullBox(const vec3_t mins, const vec3_t maxs)
+{
+ int i;
+ mplane_t *p;
+ for (i = 0;i < r_view.numfrustumplanes;i++)
+ {
+ // skip nearclip plane, it often culls portals when you are very close, and is almost never useful
+ if (i == 4)
+ continue;
+ p = r_view.frustum + i;
+ switch(p->signbits)
+ {
+ default:
+ case 0:
+ if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 1:
+ if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 2:
+ if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 3:
+ if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 4:
+ if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ case 5:
+ if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ case 6:
+ if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ case 7:
+ if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ }
+ }
+ return false;
+}
+
+int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes)
+{
+ int i;
+ const mplane_t *p;
+ for (i = 0;i < numplanes;i++)
+ {
+ p = planes + i;
+ switch(p->signbits)
+ {
+ default:
+ case 0:
+ if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 1:
+ if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 2:
+ if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 3:
+ if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*maxs[2] < p->dist)
+ return true;
+ break;
+ case 4:
+ if (p->normal[0]*maxs[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ case 5:
+ if (p->normal[0]*mins[0] + p->normal[1]*maxs[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ case 6:
+ if (p->normal[0]*maxs[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ case 7:
+ if (p->normal[0]*mins[0] + p->normal[1]*mins[1] + p->normal[2]*mins[2] < p->dist)
+ return true;
+ break;
+ }
+ }
+ return false;
+}
+
+//==================================================================================
+
+static void R_UpdateEntityLighting(entity_render_t *ent)
+{
+ vec3_t tempdiffusenormal;
+
+ // fetch the lighting from the worldmodel data
+ VectorSet(ent->modellight_ambient, r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f), r_ambient.value * (2.0f / 128.0f));
+ VectorClear(ent->modellight_diffuse);
+ VectorClear(tempdiffusenormal);
+ if ((ent->flags & RENDER_LIGHT) && r_refdef.worldmodel && r_refdef.worldmodel->brush.LightPoint)
+ {
+ vec3_t org;
+ Matrix4x4_OriginFromMatrix(&ent->matrix, org);
+ r_refdef.worldmodel->brush.LightPoint(r_refdef.worldmodel, org, ent->modellight_ambient, ent->modellight_diffuse, tempdiffusenormal);
+ }
+ else // highly rare
+ VectorSet(ent->modellight_ambient, 1, 1, 1);
+
+ // move the light direction into modelspace coordinates for lighting code
+ Matrix4x4_Transform3x3(&ent->inversematrix, tempdiffusenormal, ent->modellight_lightdir);
+ if(VectorLength2(ent->modellight_lightdir) > 0)
+ {
+ VectorNormalize(ent->modellight_lightdir);
+ }
+ else
+ {
+ VectorSet(ent->modellight_lightdir, 0, 0, 1); // have to set SOME valid vector here
+ }
+
+ // scale ambient and directional light contributions according to rendering variables
+ ent->modellight_ambient[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
+ ent->modellight_ambient[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
+ ent->modellight_ambient[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
+ ent->modellight_diffuse[0] *= ent->colormod[0] * r_refdef.lightmapintensity;
+ ent->modellight_diffuse[1] *= ent->colormod[1] * r_refdef.lightmapintensity;
+ ent->modellight_diffuse[2] *= ent->colormod[2] * r_refdef.lightmapintensity;
+}
+
+static void R_View_UpdateEntityVisible (void)
+{
+ int i, renderimask;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return;
+
+ renderimask = r_refdef.envmap ? (RENDER_EXTERIORMODEL | RENDER_VIEWMODEL) : ((chase_active.integer || r_waterstate.renderingscene) ? RENDER_VIEWMODEL : RENDER_EXTERIORMODEL);
+ if (r_refdef.worldmodel && r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs)
+ {
+ // worldmodel can check visibility
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ ent = r_refdef.entities[i];
+ r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs)) && ((ent->effects & EF_NODEPTHTEST) || (ent->flags & RENDER_VIEWMODEL) || r_refdef.worldmodel->brush.BoxTouchingVisibleLeafs(r_refdef.worldmodel, r_viewcache.world_leafvisible, ent->mins, ent->maxs));
+
+ }
+ if(r_cullentities_trace.integer)
+ {
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ ent = r_refdef.entities[i];
+ if(r_viewcache.entityvisible[i] && !(ent->effects & EF_NODEPTHTEST) && !(ent->flags & RENDER_VIEWMODEL) && !(ent->model && (ent->model->name[0] == '*')))
+ {
+ if(Mod_CanSeeBox_Trace(r_cullentities_trace_samples.integer, r_cullentities_trace_enlarge.value, r_refdef.worldmodel, r_view.origin, ent->mins, ent->maxs))
+ ent->last_trace_visibility = realtime;
+ if(ent->last_trace_visibility < realtime - r_cullentities_trace_delay.value)
+ r_viewcache.entityvisible[i] = 0;
+ }
+ }
+ }
+ }
+ else
+ {
+ // no worldmodel or it can't check visibility
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ ent = r_refdef.entities[i];
+ r_viewcache.entityvisible[i] = !(ent->flags & renderimask) && ((ent->model->type == mod_sprite && (ent->model->sprite.sprnum_type == SPR_LABEL || ent->model->sprite.sprnum_type == SPR_LABEL_SCALE)) || !R_CullBox(ent->mins, ent->maxs));
+ }
+ }
+
+ // update entity lighting (even on hidden entities for r_shadows)
+ for (i = 0;i < r_refdef.numentities;i++)
+ R_UpdateEntityLighting(r_refdef.entities[i]);
+}
+
+// only used if skyrendermasked, and normally returns false
+int R_DrawBrushModelsSky (void)
+{
+ int i, sky;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return false;
+
+ sky = false;
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ if (!r_viewcache.entityvisible[i])
+ continue;
+ ent = r_refdef.entities[i];
+ if (!ent->model || !ent->model->DrawSky)
+ continue;
+ ent->model->DrawSky(ent);
+ sky = true;
+ }
+ return sky;
+}
+
+static void R_DrawNoModel(entity_render_t *ent);
+static void R_DrawModels(void)
+{
+ int i;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return;
+
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ if (!r_viewcache.entityvisible[i])
+ continue;
+ ent = r_refdef.entities[i];
+ r_refdef.stats.entities++;
+ if (ent->model && ent->model->Draw != NULL)
+ ent->model->Draw(ent);
+ else
+ R_DrawNoModel(ent);
+ }
+}
+
+static void R_DrawModelsDepth(void)
+{
+ int i;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return;
+
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ if (!r_viewcache.entityvisible[i])
+ continue;
+ ent = r_refdef.entities[i];
+ if (ent->model && ent->model->DrawDepth != NULL)
+ ent->model->DrawDepth(ent);
+ }
+}
+
+static void R_DrawModelsDebug(void)
+{
+ int i;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return;
+
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ if (!r_viewcache.entityvisible[i])
+ continue;
+ ent = r_refdef.entities[i];
+ if (ent->model && ent->model->DrawDebug != NULL)
+ ent->model->DrawDebug(ent);
+ }
+}
+
+static void R_DrawModelsAddWaterPlanes(void)
+{
+ int i;
+ entity_render_t *ent;
+
+ if (!r_drawentities.integer)
+ return;
+
+ for (i = 0;i < r_refdef.numentities;i++)
+ {
+ if (!r_viewcache.entityvisible[i])
+ continue;
+ ent = r_refdef.entities[i];
+ if (ent->model && ent->model->DrawAddWaterPlanes != NULL)
+ ent->model->DrawAddWaterPlanes(ent);
+ }
+}
+
+static void R_View_SetFrustum(void)
+{
+ int i;
+ double slopex, slopey;
+
+ // break apart the view matrix into vectors for various purposes
+ Matrix4x4_ToVectors(&r_view.matrix, r_view.forward, r_view.left, r_view.up, r_view.origin);
+ VectorNegate(r_view.left, r_view.right);
+
+#if 0
+ r_view.frustum[0].normal[0] = 0 - 1.0 / r_view.frustum_x;
+ r_view.frustum[0].normal[1] = 0 - 0;
+ r_view.frustum[0].normal[2] = -1 - 0;
+ r_view.frustum[1].normal[0] = 0 + 1.0 / r_view.frustum_x;
+ r_view.frustum[1].normal[1] = 0 + 0;
+ r_view.frustum[1].normal[2] = -1 + 0;
+ r_view.frustum[2].normal[0] = 0 - 0;
+ r_view.frustum[2].normal[1] = 0 - 1.0 / r_view.frustum_y;
+ r_view.frustum[2].normal[2] = -1 - 0;
+ r_view.frustum[3].normal[0] = 0 + 0;
+ r_view.frustum[3].normal[1] = 0 + 1.0 / r_view.frustum_y;
+ r_view.frustum[3].normal[2] = -1 + 0;
+#endif
+
+#if 0
+ zNear = r_refdef.nearclip;
+ nudge = 1.0 - 1.0 / (1<<23);
+ r_view.frustum[4].normal[0] = 0 - 0;
+ r_view.frustum[4].normal[1] = 0 - 0;
+ r_view.frustum[4].normal[2] = -1 - -nudge;
+ r_view.frustum[4].dist = 0 - -2 * zNear * nudge;
+ r_view.frustum[5].normal[0] = 0 + 0;
+ r_view.frustum[5].normal[1] = 0 + 0;
+ r_view.frustum[5].normal[2] = -1 + -nudge;
+ r_view.frustum[5].dist = 0 + -2 * zNear * nudge;
+#endif
+
+
+
+#if 0
+ r_view.frustum[0].normal[0] = m[3] - m[0];
+ r_view.frustum[0].normal[1] = m[7] - m[4];
+ r_view.frustum[0].normal[2] = m[11] - m[8];
+ r_view.frustum[0].dist = m[15] - m[12];
+
+ r_view.frustum[1].normal[0] = m[3] + m[0];
+ r_view.frustum[1].normal[1] = m[7] + m[4];
+ r_view.frustum[1].normal[2] = m[11] + m[8];
+ r_view.frustum[1].dist = m[15] + m[12];
+
+ r_view.frustum[2].normal[0] = m[3] - m[1];
+ r_view.frustum[2].normal[1] = m[7] - m[5];
+ r_view.frustum[2].normal[2] = m[11] - m[9];
+ r_view.frustum[2].dist = m[15] - m[13];
+
+ r_view.frustum[3].normal[0] = m[3] + m[1];
+ r_view.frustum[3].normal[1] = m[7] + m[5];
+ r_view.frustum[3].normal[2] = m[11] + m[9];
+ r_view.frustum[3].dist = m[15] + m[13];
+
+ r_view.frustum[4].normal[0] = m[3] - m[2];
+ r_view.frustum[4].normal[1] = m[7] - m[6];
+ r_view.frustum[4].normal[2] = m[11] - m[10];
+ r_view.frustum[4].dist = m[15] - m[14];
+
+ r_view.frustum[5].normal[0] = m[3] + m[2];
+ r_view.frustum[5].normal[1] = m[7] + m[6];
+ r_view.frustum[5].normal[2] = m[11] + m[10];
+ r_view.frustum[5].dist = m[15] + m[14];
+#endif
+
+ if (r_view.useperspective)
+ {
+ slopex = 1.0 / r_view.frustum_x;
+ slopey = 1.0 / r_view.frustum_y;
+ VectorMA(r_view.forward, -slopex, r_view.left, r_view.frustum[0].normal);
+ VectorMA(r_view.forward, slopex, r_view.left, r_view.frustum[1].normal);
+ VectorMA(r_view.forward, -slopey, r_view.up , r_view.frustum[2].normal);
+ VectorMA(r_view.forward, slopey, r_view.up , r_view.frustum[3].normal);
+ VectorCopy(r_view.forward, r_view.frustum[4].normal);
+
+ // Leaving those out was a mistake, those were in the old code, and they
+ // fix a reproducable bug in this one: frustum culling got fucked up when viewmatrix was an identity matrix
+ // I couldn't reproduce it after adding those normalizations. --blub
+ VectorNormalize(r_view.frustum[0].normal);
+ VectorNormalize(r_view.frustum[1].normal);
+ VectorNormalize(r_view.frustum[2].normal);
+ VectorNormalize(r_view.frustum[3].normal);
+
+ // calculate frustum corners, which are used to calculate deformed frustum planes for shadow caster culling
+ VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[0]);
+ VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, -1024 * slopey, r_view.up, r_view.frustumcorner[1]);
+ VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, -1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[2]);
+ VectorMAMAMAM(1, r_view.origin, 1024, r_view.forward, 1024 * slopex, r_view.left, 1024 * slopey, r_view.up, r_view.frustumcorner[3]);
+
+ r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal);
+ r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal);
+ r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal);
+ r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal);
+ r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
+ }
+ else
+ {
+ VectorScale(r_view.left, -r_view.ortho_x, r_view.frustum[0].normal);
+ VectorScale(r_view.left, r_view.ortho_x, r_view.frustum[1].normal);
+ VectorScale(r_view.up, -r_view.ortho_y, r_view.frustum[2].normal);
+ VectorScale(r_view.up, r_view.ortho_y, r_view.frustum[3].normal);
+ VectorCopy(r_view.forward, r_view.frustum[4].normal);
+ r_view.frustum[0].dist = DotProduct (r_view.origin, r_view.frustum[0].normal) + r_view.ortho_x;
+ r_view.frustum[1].dist = DotProduct (r_view.origin, r_view.frustum[1].normal) + r_view.ortho_x;
+ r_view.frustum[2].dist = DotProduct (r_view.origin, r_view.frustum[2].normal) + r_view.ortho_y;
+ r_view.frustum[3].dist = DotProduct (r_view.origin, r_view.frustum[3].normal) + r_view.ortho_y;
+ r_view.frustum[4].dist = DotProduct (r_view.origin, r_view.frustum[4].normal) + r_refdef.nearclip;
+ }
+ r_view.numfrustumplanes = 5;
+
+ if (r_view.useclipplane)
+ {
+ r_view.numfrustumplanes = 6;
+ r_view.frustum[5] = r_view.clipplane;
+ }
+
+ for (i = 0;i < r_view.numfrustumplanes;i++)
+ PlaneClassify(r_view.frustum + i);
+
+ // LordHavoc: note to all quake engine coders, Quake had a special case
+ // for 90 degrees which assumed a square view (wrong), so I removed it,
+ // Quake2 has it disabled as well.
+
+ // rotate R_VIEWFORWARD right by FOV_X/2 degrees
+ //RotatePointAroundVector( r_view.frustum[0].normal, r_view.up, r_view.forward, -(90 - r_refdef.fov_x / 2));
+ //r_view.frustum[0].dist = DotProduct (r_view.origin, frustum[0].normal);
+ //PlaneClassify(&frustum[0]);
+
+ // rotate R_VIEWFORWARD left by FOV_X/2 degrees
+ //RotatePointAroundVector( r_view.frustum[1].normal, r_view.up, r_view.forward, (90 - r_refdef.fov_x / 2));
+ //r_view.frustum[1].dist = DotProduct (r_view.origin, frustum[1].normal);
+ //PlaneClassify(&frustum[1]);
+
+ // rotate R_VIEWFORWARD up by FOV_X/2 degrees
+ //RotatePointAroundVector( r_view.frustum[2].normal, r_view.left, r_view.forward, -(90 - r_refdef.fov_y / 2));
+ //r_view.frustum[2].dist = DotProduct (r_view.origin, frustum[2].normal);
+ //PlaneClassify(&frustum[2]);
+
+ // rotate R_VIEWFORWARD down by FOV_X/2 degrees
+ //RotatePointAroundVector( r_view.frustum[3].normal, r_view.left, r_view.forward, (90 - r_refdef.fov_y / 2));
+ //r_view.frustum[3].dist = DotProduct (r_view.origin, frustum[3].normal);
+ //PlaneClassify(&frustum[3]);
+
+ // nearclip plane
+ //VectorCopy(r_view.forward, r_view.frustum[4].normal);
+ //r_view.frustum[4].dist = DotProduct (r_view.origin, frustum[4].normal) + r_nearclip.value;
+ //PlaneClassify(&frustum[4]);
+}
+
+void R_View_Update(void)
+{
+ R_View_SetFrustum();
+ R_View_WorldVisibility(r_view.useclipplane);
+ R_View_UpdateEntityVisible();
+}
+
+void R_SetupView(void)
+{
+ if (!r_view.useperspective)
+ GL_SetupView_Mode_Ortho(-r_view.ortho_x, -r_view.ortho_y, r_view.ortho_x, r_view.ortho_y, -r_refdef.farclip, r_refdef.farclip);
+ else if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows)
+ GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip);
+ else
+ GL_SetupView_Mode_Perspective(r_view.frustum_x, r_view.frustum_y, r_refdef.nearclip, r_refdef.farclip);
+
+ GL_SetupView_Orientation_FromEntity(&r_view.matrix);
+
+ if (r_view.useclipplane)
+ {
+ // LordHavoc: couldn't figure out how to make this approach the
+ vec_t dist = r_view.clipplane.dist - r_water_clippingplanebias.value;
+ vec_t viewdist = DotProduct(r_view.origin, r_view.clipplane.normal);
+ if (viewdist < r_view.clipplane.dist + r_water_clippingplanebias.value)
+ dist = r_view.clipplane.dist;
+ GL_SetupView_ApplyCustomNearClipPlane(r_view.clipplane.normal[0], r_view.clipplane.normal[1], r_view.clipplane.normal[2], dist);
+ }
+}
+
+void R_ResetViewRendering2D(void)
+{
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+
+ DrawQ_Finish();
+
+ // GL is weird because it's bottom to top, r_view.y is top to bottom
+ qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+ GL_SetupView_Mode_Ortho(0, 0, 1, 1, -10, 100);
+ GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
+ GL_Color(1, 1, 1, 1);
+ GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_AlphaTest(false);
+ GL_ScissorTest(false);
+ GL_DepthMask(false);
+ GL_DepthRange(0, 1);
+ GL_DepthTest(false);
+ R_Mesh_Matrix(&identitymatrix);
+ R_Mesh_ResetTextureState();
+ GL_PolygonOffset(0, 0);
+ qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
+ qglDepthFunc(GL_LEQUAL);CHECKGLERROR
+ qglDisable(GL_STENCIL_TEST);CHECKGLERROR
+ qglStencilMask(~0);CHECKGLERROR
+ qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
+ qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
+ GL_CullFace(GL_FRONT); // quake is backwards, this culls back faces
+}
+
+void R_ResetViewRendering3D(void)
+{
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+
+ DrawQ_Finish();
+
+ // GL is weird because it's bottom to top, r_view.y is top to bottom
+ qglViewport(r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+ R_SetupView();
+ GL_Scissor(r_view.x, r_view.y, r_view.width, r_view.height);
+ GL_Color(1, 1, 1, 1);
+ GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_AlphaTest(false);
+ GL_ScissorTest(true);
+ GL_DepthMask(true);
+ GL_DepthRange(0, 1);
+ GL_DepthTest(true);
+ R_Mesh_Matrix(&identitymatrix);
+ R_Mesh_ResetTextureState();
+ GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
+ qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR
+ qglDepthFunc(GL_LEQUAL);CHECKGLERROR
+ qglDisable(GL_STENCIL_TEST);CHECKGLERROR
+ qglStencilMask(~0);CHECKGLERROR
+ qglStencilFunc(GL_ALWAYS, 128, ~0);CHECKGLERROR
+ qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);CHECKGLERROR
+ GL_CullFace(r_view.cullface_back);
+}
+
+/*
+ R_Bloom_SetupShader(
+"// bloom shader\n"
+"// written by Forest 'LordHavoc' Hale\n"
+"\n"
+"// common definitions between vertex shader and fragment shader:\n"
+"\n"
+"#ifdef __GLSL_CG_DATA_TYPES\n"
+"#define myhalf half\n"
+"#define myhvec2 hvec2\n"
+"#define myhvec3 hvec3\n"
+"#define myhvec4 hvec4\n"
+"#else\n"
+"#define myhalf float\n"
+"#define myhvec2 vec2\n"
+"#define myhvec3 vec3\n"
+"#define myhvec4 vec4\n"
+"#endif\n"
+"\n"
+"varying vec2 ScreenTexCoord;\n"
+"varying vec2 BloomTexCoord;\n"
+"\n"
+"\n"
+"\n"
+"\n"
+"// vertex shader specific:\n"
+"#ifdef VERTEX_SHADER\n"
+"\n"
+"void main(void)\n"
+"{\n"
+" ScreenTexCoord = vec2(gl_MultiTexCoord0);\n"
+" BloomTexCoord = vec2(gl_MultiTexCoord1);\n"
+" // transform vertex to camera space, using ftransform to match non-VS\n"
+" // rendering\n"
+" gl_Position = ftransform();\n"
+"}\n"
+"\n"
+"#endif // VERTEX_SHADER\n"
+"\n"
+"\n"
+"\n"
+"\n"
+"// fragment shader specific:\n"
+"#ifdef FRAGMENT_SHADER\n"
+"\n"
+"void main(void)\n"
+"{\n"
+" int x, y;
+" myhvec3 color = myhvec3(texture2D(Texture_Screen, ScreenTexCoord));\n"
+" for (x = -BLUR_X;x <= BLUR_X;x++)
+" color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
+" color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
+" color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
+" color.rgb += myhvec3(texture2D(Texture_Bloom, BloomTexCoord));\n"
+
+" gl_FragColor = vec4(color);\n"
+"}\n"
+"\n"
+"#endif // FRAGMENT_SHADER\n"
+*/
+
+void R_RenderScene(qboolean addwaterplanes);
+
+static void R_Water_StartFrame(void)
+{
+ int i;
+ int waterwidth, waterheight, texturewidth, textureheight;
+ r_waterstate_waterplane_t *p;
+
+ // set waterwidth and waterheight to the water resolution that will be
+ // used (often less than the screen resolution for faster rendering)
+ waterwidth = (int)bound(1, r_view.width * r_water_resolutionmultiplier.value, r_view.width);
+ waterheight = (int)bound(1, r_view.height * r_water_resolutionmultiplier.value, r_view.height);
+
+ // calculate desired texture sizes
+ // can't use water if the card does not support the texture size
+ if (!r_water.integer || !r_glsl.integer || !gl_support_fragment_shader || waterwidth > gl_max_texture_size || waterheight > gl_max_texture_size)
+ texturewidth = textureheight = waterwidth = waterheight = 0;
+ else if (gl_support_arb_texture_non_power_of_two)
+ {
+ texturewidth = waterwidth;
+ textureheight = waterheight;
+ }
+ else
+ {
+ for (texturewidth = 1;texturewidth < waterwidth ;texturewidth *= 2);
+ for (textureheight = 1;textureheight < waterheight;textureheight *= 2);
+ }
+
+ // allocate textures as needed
+ if (r_waterstate.waterwidth != waterwidth || r_waterstate.waterheight != waterheight || r_waterstate.texturewidth != texturewidth || r_waterstate.textureheight != textureheight)
+ {
+ r_waterstate.maxwaterplanes = MAX_WATERPLANES;
+ for (i = 0, p = r_waterstate.waterplanes;i < r_waterstate.maxwaterplanes;i++, p++)
+ {
+ if (p->texture_refraction)
+ R_FreeTexture(p->texture_refraction);
+ p->texture_refraction = NULL;
+ if (p->texture_reflection)
+ R_FreeTexture(p->texture_reflection);
+ p->texture_reflection = NULL;
+ }
+ memset(&r_waterstate, 0, sizeof(r_waterstate));
+ r_waterstate.waterwidth = waterwidth;
+ r_waterstate.waterheight = waterheight;
+ r_waterstate.texturewidth = texturewidth;
+ r_waterstate.textureheight = textureheight;
+ }
+
+ if (r_waterstate.waterwidth)
+ {
+ r_waterstate.enabled = true;
+
+ // set up variables that will be used in shader setup
+ r_waterstate.screenscale[0] = 0.5f * (float)waterwidth / (float)texturewidth;
+ r_waterstate.screenscale[1] = 0.5f * (float)waterheight / (float)textureheight;
+ r_waterstate.screencenter[0] = 0.5f * (float)waterwidth / (float)texturewidth;
+ r_waterstate.screencenter[1] = 0.5f * (float)waterheight / (float)textureheight;
+ }
+
+ r_waterstate.maxwaterplanes = MAX_WATERPLANES;
+ r_waterstate.numwaterplanes = 0;
+}
+
+static void R_Water_AddWaterPlane(msurface_t *surface)
+{
+ int triangleindex, planeindex;
+ const int *e;
+ vec_t f;
+ vec3_t vert[3];
+ vec3_t normal;
+ vec3_t center;
+ r_waterstate_waterplane_t *p;
+ // just use the first triangle with a valid normal for any decisions
+ VectorClear(normal);
+ VectorClear(center);
+ for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles;triangleindex++, e += 3)
+ {
+ Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
+ Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[1]*3, vert[1]);
+ Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[2]*3, vert[2]);
+ TriangleNormal(vert[0], vert[1], vert[2], normal);
+ if (VectorLength2(normal) >= 0.001)
+ break;
+ }
+ // now find the center of this surface
+ for (triangleindex = 0, e = rsurface.modelelement3i + surface->num_firsttriangle * 3;triangleindex < surface->num_triangles*3;triangleindex++, e++)
+ {
+ Matrix4x4_Transform(&rsurface.matrix, rsurface.modelvertex3f + e[0]*3, vert[0]);
+ VectorAdd(center, vert[0], center);
+ }
+ f = 1.0 / surface->num_triangles*3;
+ VectorScale(center, f, center);
+
+ // find a matching plane if there is one
+ for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
+ if (fabs(PlaneDiff(vert[0], &p->plane)) < 1 && fabs(PlaneDiff(vert[1], &p->plane)) < 1 && fabs(PlaneDiff(vert[2], &p->plane)) < 1)
+ break;
+ if (planeindex >= r_waterstate.maxwaterplanes)
+ return; // nothing we can do, out of planes
+
+ // if this triangle does not fit any known plane rendered this frame, add one
+ if (planeindex >= r_waterstate.numwaterplanes)
+ {
+ // store the new plane
+ r_waterstate.numwaterplanes++;
+ VectorCopy(normal, p->plane.normal);
+ VectorNormalize(p->plane.normal);
+ p->plane.dist = DotProduct(vert[0], p->plane.normal);
+ PlaneClassify(&p->plane);
+ // flip the plane if it does not face the viewer
+ if (PlaneDiff(r_view.origin, &p->plane) < 0)
+ {
+ VectorNegate(p->plane.normal, p->plane.normal);
+ p->plane.dist *= -1;
+ PlaneClassify(&p->plane);
+ }
+ // clear materialflags and pvs
+ p->materialflags = 0;
+ p->pvsvalid = false;
+ }
+ // merge this surface's materialflags into the waterplane
+ p->materialflags |= surface->texture->currentframe->currentmaterialflags;
+ // merge this surface's PVS into the waterplane
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION) && r_refdef.worldmodel && r_refdef.worldmodel->brush.FatPVS)
+ {
+ r_refdef.worldmodel->brush.FatPVS(r_refdef.worldmodel, r_view.origin, 2, p->pvsbits, sizeof(p->pvsbits), p->pvsvalid);
+ p->pvsvalid = true;
+ }
+}
+
+static void R_Water_ProcessPlanes(void)
+{
+ r_view_t originalview;
+ int planeindex;
+ r_waterstate_waterplane_t *p;
+
+ originalview = r_view;
+
+ // make sure enough textures are allocated
+ for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
+ {
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
+ {
+ if (!p->texture_refraction)
+ p->texture_refraction = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_refraction", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
+ if (!p->texture_refraction)
+ goto error;
+ }
+
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
+ {
+ if (!p->texture_reflection)
+ p->texture_reflection = R_LoadTexture2D(r_main_texturepool, va("waterplane%i_reflection", planeindex), r_waterstate.texturewidth, r_waterstate.textureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
+ if (!p->texture_reflection)
+ goto error;
+ }
+ }
+
+ // render views
+ for (planeindex = 0, p = r_waterstate.waterplanes;planeindex < r_waterstate.numwaterplanes;planeindex++, p++)
+ {
+ r_view.showdebug = false;
+ r_view.width = r_waterstate.waterwidth;
+ r_view.height = r_waterstate.waterheight;
+ r_view.useclipplane = true;
+ r_waterstate.renderingscene = true;
+
+ // render the normal view scene and copy into texture
+ // (except that a clipping plane should be used to hide everything on one side of the water, and the viewer's weapon model should be omitted)
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION))
+ {
+ r_view.clipplane = p->plane;
+ VectorNegate(r_view.clipplane.normal, r_view.clipplane.normal);
+ r_view.clipplane.dist = -r_view.clipplane.dist;
+ PlaneClassify(&r_view.clipplane);
+
+ R_RenderScene(false);
+
+ // copy view into the screen texture
+ R_Mesh_TexBind(0, R_GetTexture(p->texture_refraction));
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+ }
+
+ if (p->materialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFLECTION))
+ {
+ // render reflected scene and copy into texture
+ Matrix4x4_Reflect(&r_view.matrix, p->plane.normal[0], p->plane.normal[1], p->plane.normal[2], p->plane.dist, -2);
+ r_view.clipplane = p->plane;
+ // reverse the cullface settings for this render
+ r_view.cullface_front = GL_FRONT;
+ r_view.cullface_back = GL_BACK;
+ if (r_refdef.worldmodel && r_refdef.worldmodel->brush.num_pvsclusterbytes)
+ {
+ r_view.usecustompvs = true;
+ if (p->pvsvalid)
+ memcpy(r_viewcache.world_pvsbits, p->pvsbits, r_refdef.worldmodel->brush.num_pvsclusterbytes);
+ else
+ memset(r_viewcache.world_pvsbits, 0xFF, r_refdef.worldmodel->brush.num_pvsclusterbytes);
+ }
+
+ R_ResetViewRendering3D();
+ R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
+
+ R_RenderScene(false);
+
+ R_Mesh_TexBind(0, R_GetTexture(p->texture_reflection));
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+
+ R_ResetViewRendering3D();
+ R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
+ }
+
+ r_view = originalview;
+ r_view.clear = true;
+ r_waterstate.renderingscene = false;
+ }
+ return;
+error:
+ r_view = originalview;
+ r_waterstate.renderingscene = false;
+ Cvar_SetValueQuick(&r_water, 0);
+ Con_Printf("R_Water_ProcessPlanes: Error: texture creation failed! Turned off r_water.\n");
+ return;
+}
+
+void R_Bloom_StartFrame(void)
+{
+ int bloomtexturewidth, bloomtextureheight, screentexturewidth, screentextureheight;
+
+ // set bloomwidth and bloomheight to the bloom resolution that will be
+ // used (often less than the screen resolution for faster rendering)
+ r_bloomstate.bloomwidth = bound(1, r_bloom_resolution.integer, r_view.width);
+ r_bloomstate.bloomheight = r_bloomstate.bloomwidth * r_view.height / r_view.width;
+ r_bloomstate.bloomheight = bound(1, r_bloomstate.bloomheight, r_view.height);
+
+ // calculate desired texture sizes
+ if (gl_support_arb_texture_non_power_of_two)
+ {
+ screentexturewidth = r_view.width;
+ screentextureheight = r_view.height;
+ bloomtexturewidth = r_bloomstate.bloomwidth;
+ bloomtextureheight = r_bloomstate.bloomheight;
+ }
+ else
+ {
+ for (screentexturewidth = 1;screentexturewidth < vid.width ;screentexturewidth *= 2);
+ for (screentextureheight = 1;screentextureheight < vid.height ;screentextureheight *= 2);
+ for (bloomtexturewidth = 1;bloomtexturewidth < r_bloomstate.bloomwidth ;bloomtexturewidth *= 2);
+ for (bloomtextureheight = 1;bloomtextureheight < r_bloomstate.bloomheight;bloomtextureheight *= 2);
+ }
+
+ if (r_hdr.integer)
+ {
+ screentexturewidth = screentextureheight = 0;
+ }
+ else if (r_bloom.integer)
+ {
+ }
+ else
+ {
+ screentexturewidth = screentextureheight = 0;
+ bloomtexturewidth = bloomtextureheight = 0;
+ }
+
+ if ((!bloomtexturewidth && !bloomtextureheight) || r_bloom_resolution.integer < 4 || r_bloom_blur.value < 1 || r_bloom_blur.value >= 512 || screentexturewidth > gl_max_texture_size || screentextureheight > gl_max_texture_size || bloomtexturewidth > gl_max_texture_size || bloomtextureheight > gl_max_texture_size)
+ {
+ // can't use bloom if the parameters are too weird
+ // can't use bloom if the card does not support the texture size
+ if (r_bloomstate.texture_screen)
+ R_FreeTexture(r_bloomstate.texture_screen);
+ if (r_bloomstate.texture_bloom)
+ R_FreeTexture(r_bloomstate.texture_bloom);
+ memset(&r_bloomstate, 0, sizeof(r_bloomstate));
+ return;
+ }
+
+ r_bloomstate.enabled = true;
+ r_bloomstate.hdr = r_hdr.integer != 0;
+
+ // allocate textures as needed
+ if (r_bloomstate.screentexturewidth != screentexturewidth || r_bloomstate.screentextureheight != screentextureheight)
+ {
+ if (r_bloomstate.texture_screen)
+ R_FreeTexture(r_bloomstate.texture_screen);
+ r_bloomstate.texture_screen = NULL;
+ r_bloomstate.screentexturewidth = screentexturewidth;
+ r_bloomstate.screentextureheight = screentextureheight;
+ if (r_bloomstate.screentexturewidth && r_bloomstate.screentextureheight)
+ r_bloomstate.texture_screen = R_LoadTexture2D(r_main_texturepool, "screen", r_bloomstate.screentexturewidth, r_bloomstate.screentextureheight, NULL, TEXTYPE_RGBA, TEXF_FORCENEAREST | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
+ }
+ if (r_bloomstate.bloomtexturewidth != bloomtexturewidth || r_bloomstate.bloomtextureheight != bloomtextureheight)
+ {
+ if (r_bloomstate.texture_bloom)
+ R_FreeTexture(r_bloomstate.texture_bloom);
+ r_bloomstate.texture_bloom = NULL;
+ r_bloomstate.bloomtexturewidth = bloomtexturewidth;
+ r_bloomstate.bloomtextureheight = bloomtextureheight;
+ if (r_bloomstate.bloomtexturewidth && r_bloomstate.bloomtextureheight)
+ r_bloomstate.texture_bloom = R_LoadTexture2D(r_main_texturepool, "bloom", r_bloomstate.bloomtexturewidth, r_bloomstate.bloomtextureheight, NULL, TEXTYPE_RGBA, TEXF_FORCELINEAR | TEXF_CLAMP | TEXF_ALWAYSPRECACHE, NULL);
+ }
+
+ // set up a texcoord array for the full resolution screen image
+ // (we have to keep this around to copy back during final render)
+ r_bloomstate.screentexcoord2f[0] = 0;
+ r_bloomstate.screentexcoord2f[1] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
+ r_bloomstate.screentexcoord2f[2] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
+ r_bloomstate.screentexcoord2f[3] = (float)r_view.height / (float)r_bloomstate.screentextureheight;
+ r_bloomstate.screentexcoord2f[4] = (float)r_view.width / (float)r_bloomstate.screentexturewidth;
+ r_bloomstate.screentexcoord2f[5] = 0;
+ r_bloomstate.screentexcoord2f[6] = 0;
+ r_bloomstate.screentexcoord2f[7] = 0;
+
+ // set up a texcoord array for the reduced resolution bloom image
+ // (which will be additive blended over the screen image)
+ r_bloomstate.bloomtexcoord2f[0] = 0;
+ r_bloomstate.bloomtexcoord2f[1] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
+ r_bloomstate.bloomtexcoord2f[2] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
+ r_bloomstate.bloomtexcoord2f[3] = (float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
+ r_bloomstate.bloomtexcoord2f[4] = (float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
+ r_bloomstate.bloomtexcoord2f[5] = 0;
+ r_bloomstate.bloomtexcoord2f[6] = 0;
+ r_bloomstate.bloomtexcoord2f[7] = 0;
+}
+
+void R_Bloom_CopyScreenTexture(float colorscale)
+{
+ r_refdef.stats.bloom++;
+
+ R_ResetViewRendering2D();
+ R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
+
+ // copy view into the screen texture
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+ r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
+
+ // now scale it down to the bloom texture size
+ CHECKGLERROR
+ qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_Color(colorscale, colorscale, colorscale, 1);
+ // TODO: optimize with multitexture or GLSL
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+
+ // we now have a bloom image in the framebuffer
+ // copy it into the bloom image texture for later processing
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
+ r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+}
+
+void R_Bloom_CopyHDRTexture(void)
+{
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_view.height), r_view.width, r_view.height);CHECKGLERROR
+ r_refdef.stats.bloom_copypixels += r_view.width * r_view.height;
+}
+
+void R_Bloom_MakeTexture(void)
+{
+ int x, range, dir;
+ float xoffset, yoffset, r, brighten;
+
+ r_refdef.stats.bloom++;
+
+ R_ResetViewRendering2D();
+ R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+
+ // we have a bloom image in the framebuffer
+ CHECKGLERROR
+ qglViewport(r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
+
+ for (x = 1;x < min(r_bloom_colorexponent.value, 32);)
+ {
+ x *= 2;
+ r = bound(0, r_bloom_colorexponent.value / x, 1);
+ GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
+ GL_Color(r, r, r, 1);
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+
+ // copy the vertically blurred bloom view to a texture
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
+ r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+ }
+
+ range = r_bloom_blur.integer * r_bloomstate.bloomwidth / 320;
+ brighten = r_bloom_brighten.value;
+ if (r_hdr.integer)
+ brighten *= r_hdr_range.value;
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.offsettexcoord2f, 0, 0);
+
+ for (dir = 0;dir < 2;dir++)
+ {
+ // blend on at multiple vertical offsets to achieve a vertical blur
+ // TODO: do offset blends using GLSL
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ for (x = -range;x <= range;x++)
+ {
+ if (!dir){xoffset = 0;yoffset = x;}
+ else {xoffset = x;yoffset = 0;}
+ xoffset /= (float)r_bloomstate.bloomtexturewidth;
+ yoffset /= (float)r_bloomstate.bloomtextureheight;
+ // compute a texcoord array with the specified x and y offset
+ r_bloomstate.offsettexcoord2f[0] = xoffset+0;
+ r_bloomstate.offsettexcoord2f[1] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
+ r_bloomstate.offsettexcoord2f[2] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
+ r_bloomstate.offsettexcoord2f[3] = yoffset+(float)r_bloomstate.bloomheight / (float)r_bloomstate.bloomtextureheight;
+ r_bloomstate.offsettexcoord2f[4] = xoffset+(float)r_bloomstate.bloomwidth / (float)r_bloomstate.bloomtexturewidth;
+ r_bloomstate.offsettexcoord2f[5] = yoffset+0;
+ r_bloomstate.offsettexcoord2f[6] = xoffset+0;
+ r_bloomstate.offsettexcoord2f[7] = yoffset+0;
+ // this r value looks like a 'dot' particle, fading sharply to
+ // black at the edges
+ // (probably not realistic but looks good enough)
+ //r = ((range*range+1)/((float)(x*x+1)))/(range*2+1);
+ //r = (dir ? 1.0f : brighten)/(range*2+1);
+ r = (dir ? 1.0f : brighten)/(range*2+1)*(1 - x*x/(float)(range*range));
+ GL_Color(r, r, r, 1);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+ GL_BlendFunc(GL_ONE, GL_ONE);
+ }
+
+ // copy the vertically blurred bloom view to a texture
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
+ r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+ }
+
+ // apply subtract last
+ // (just like it would be in a GLSL shader)
+ if (r_bloom_colorsubtract.value > 0 && gl_support_ext_blend_subtract)
+ {
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
+ GL_Color(1, 1, 1, 1);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+
+ GL_BlendFunc(GL_ONE, GL_ONE);
+ qglBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
+ R_Mesh_TexBind(0, R_GetTexture(r_texture_white));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
+ GL_Color(r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, r_bloom_colorsubtract.value, 1);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+ qglBlendEquationEXT(GL_FUNC_ADD_EXT);
+
+ // copy the darkened bloom view to a texture
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ GL_ActiveTexture(0);
+ CHECKGLERROR
+ qglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, r_view.x, vid.height - (r_view.y + r_bloomstate.bloomheight), r_bloomstate.bloomwidth, r_bloomstate.bloomheight);CHECKGLERROR
+ r_refdef.stats.bloom_copypixels += r_bloomstate.bloomwidth * r_bloomstate.bloomheight;
+ }
+}
+
+void R_HDR_RenderBloomTexture(void)
+{
+ int oldwidth, oldheight;
+
+ oldwidth = r_view.width;
+ oldheight = r_view.height;
+ r_view.width = r_bloomstate.bloomwidth;
+ r_view.height = r_bloomstate.bloomheight;
+
+ // TODO: support GL_EXT_framebuffer_object rather than reusing the framebuffer? it might improve SLI performance.
+ // TODO: add exposure compensation features
+ // TODO: add fp16 framebuffer support
+
+ r_view.showdebug = false;
+ r_view.colorscale = r_bloom_colorscale.value * r_hdr_scenebrightness.value;
+ if (r_hdr.integer)
+ r_view.colorscale /= r_hdr_range.value;
+ r_waterstate.numwaterplanes = 0;
+ R_RenderScene(r_waterstate.enabled);
+ r_view.showdebug = true;
+
+ R_ResetViewRendering2D();
+
+ R_Bloom_CopyHDRTexture();
+ R_Bloom_MakeTexture();
+
+ R_ResetViewRendering3D();
+
+ R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
+
+ // restore the view settings
+ r_view.width = oldwidth;
+ r_view.height = oldheight;
+}
+
+static void R_BlendView(void)
+{
+ if (r_bloomstate.enabled && r_bloomstate.hdr)
+ {
+ // render high dynamic range bloom effect
+ // the bloom texture was made earlier this render, so we just need to
+ // blend it onto the screen...
+ R_ResetViewRendering2D();
+ R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ GL_Color(1, 1, 1, 1);
+ GL_BlendFunc(GL_ONE, GL_ONE);
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
+ }
+ else if (r_bloomstate.enabled)
+ {
+ // render simple bloom effect
+ // copy the screen and shrink it and darken it for the bloom process
+ R_Bloom_CopyScreenTexture(r_bloom_colorscale.value);
+ // make the bloom texture
+ R_Bloom_MakeTexture();
+ // put the original screen image back in place and blend the bloom
+ // texture on it
+ R_ResetViewRendering2D();
+ R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ GL_Color(1, 1, 1, 1);
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ // do both in one pass if possible
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_bloom));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.bloomtexcoord2f, 0, 0);
+ if (r_textureunits.integer >= 2 && gl_combine.integer)
+ {
+ R_Mesh_TexCombine(1, GL_ADD, GL_ADD, 1, 1);
+ R_Mesh_TexBind(1, R_GetTexture(r_bloomstate.texture_screen));
+ R_Mesh_TexCoordPointer(1, 2, r_bloomstate.screentexcoord2f, 0, 0);
+ }
+ else
+ {
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
+ // now blend on the bloom texture
+ GL_BlendFunc(GL_ONE, GL_ONE);
+ R_Mesh_TexBind(0, R_GetTexture(r_bloomstate.texture_screen));
+ R_Mesh_TexCoordPointer(0, 2, r_bloomstate.screentexcoord2f, 0, 0);
+ }
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ r_refdef.stats.bloom_drawpixels += r_view.width * r_view.height;
+ }
+ if (r_refdef.viewblend[3] >= (1.0f / 256.0f))
+ {
+ // apply a color tint to the whole view
+ R_ResetViewRendering2D();
+ R_Mesh_VertexPointer(r_screenvertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ }
+}
+
+void R_RenderScene(qboolean addwaterplanes);
+
+matrix4x4_t r_waterscrollmatrix;
+
+void R_UpdateVariables(void)
+{
+ R_Textures_Frame();
+
+ r_refdef.farclip = 4096;
+ if (r_refdef.worldmodel)
+ r_refdef.farclip += VectorDistance(r_refdef.worldmodel->normalmins, r_refdef.worldmodel->normalmaxs);
+ r_refdef.nearclip = bound (0.001f, r_nearclip.value, r_refdef.farclip - 1.0f);
+
+ if (r_shadow_frontsidecasting.integer < 0 || r_shadow_frontsidecasting.integer > 1)
+ Cvar_SetValueQuick(&r_shadow_frontsidecasting, 1);
+ r_refdef.polygonfactor = 0;
+ r_refdef.polygonoffset = 0;
+ r_refdef.shadowpolygonfactor = r_refdef.polygonfactor + r_shadow_polygonfactor.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
+ r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_polygonoffset.value * (r_shadow_frontsidecasting.integer ? 1 : -1);
+
+ r_refdef.rtworld = r_shadow_realtime_world.integer;
+ r_refdef.rtworldshadows = r_shadow_realtime_world_shadows.integer && gl_stencil;
+ r_refdef.rtdlight = (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && !gl_flashblend.integer && r_dynamic.integer;
+ r_refdef.rtdlightshadows = r_refdef.rtdlight && r_shadow_realtime_dlight_shadows.integer && gl_stencil;
+ r_refdef.lightmapintensity = r_refdef.rtworld ? r_shadow_realtime_world_lightmaps.value : 1;
+ if (r_showsurfaces.integer)
+ {
+ r_refdef.rtworld = false;
+ r_refdef.rtworldshadows = false;
+ r_refdef.rtdlight = false;
+ r_refdef.rtdlightshadows = false;
+ r_refdef.lightmapintensity = 0;
+ }
+
+ if (gamemode == GAME_NEHAHRA)
+ {
+ if (gl_fogenable.integer)
+ {
+ r_refdef.oldgl_fogenable = true;
+ r_refdef.fog_density = gl_fogdensity.value;
+ r_refdef.fog_red = gl_fogred.value;
+ r_refdef.fog_green = gl_foggreen.value;
+ r_refdef.fog_blue = gl_fogblue.value;
+ }
+ else if (r_refdef.oldgl_fogenable)
+ {
+ r_refdef.oldgl_fogenable = false;
+ r_refdef.fog_density = 0;
+ r_refdef.fog_red = 0;
+ r_refdef.fog_green = 0;
+ r_refdef.fog_blue = 0;
+ }
+ }
+ if (r_refdef.fog_density)
+ {
+ r_refdef.fogcolor[0] = bound(0.0f, r_refdef.fog_red , 1.0f);
+ r_refdef.fogcolor[1] = bound(0.0f, r_refdef.fog_green, 1.0f);
+ r_refdef.fogcolor[2] = bound(0.0f, r_refdef.fog_blue , 1.0f);
+ }
+ if (r_refdef.fog_density)
+ {
+ r_refdef.fogenabled = true;
+ // this is the point where the fog reaches 0.9986 alpha, which we
+ // consider a good enough cutoff point for the texture
+ // (0.9986 * 256 == 255.6)
+ r_refdef.fogrange = 400 / r_refdef.fog_density;
+ r_refdef.fograngerecip = 1.0f / r_refdef.fogrange;
+ r_refdef.fogmasktabledistmultiplier = FOGMASKTABLEWIDTH * r_refdef.fograngerecip;
+ // fog color was already set
+ }
+ else
+ r_refdef.fogenabled = false;
+}
+
+/*
+================
+R_RenderView
+================
+*/
+void R_RenderView(void)
+{
+ if (!r_refdef.entities/* || !r_refdef.worldmodel*/)
+ return; //Host_Error ("R_RenderView: NULL worldmodel");
+
+ R_Shadow_UpdateWorldLightSelection();
+
+ R_Bloom_StartFrame();
+ R_Water_StartFrame();
+
+ CHECKGLERROR
+ if (r_timereport_active)
+ R_TimeReport("viewsetup");
+
+ R_ResetViewRendering3D();
+
+ if (r_view.clear)
+ {
+ R_ClearScreen();
+ if (r_timereport_active)
+ R_TimeReport("viewclear");
+ }
+ r_view.clear = true;
+
+ r_view.showdebug = true;
+
+ // this produces a bloom texture to be used in R_BlendView() later
+ if (r_hdr.integer)
+ R_HDR_RenderBloomTexture();
+
+ r_view.colorscale = r_hdr_scenebrightness.value;
+ r_waterstate.numwaterplanes = 0;
+ R_RenderScene(r_waterstate.enabled);
+
+ R_BlendView();
+ if (r_timereport_active)
+ R_TimeReport("blendview");
+
+ GL_Scissor(0, 0, vid.width, vid.height);
+ GL_ScissorTest(false);
+ CHECKGLERROR
+}
+
+extern void R_DrawLightningBeams (void);
+extern void VM_CL_AddPolygonsToMeshQueue (void);
+extern void R_DrawPortals (void);
+extern cvar_t cl_locs_show;
+static void R_DrawLocs(void);
+static void R_DrawEntityBBoxes(void);
+void R_RenderScene(qboolean addwaterplanes)
+{
+ if (addwaterplanes)
+ {
+ R_ResetViewRendering3D();
+
+ R_View_Update();
+ if (r_timereport_active)
+ R_TimeReport("watervis");
+
+ if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawAddWaterPlanes)
+ {
+ r_refdef.worldmodel->DrawAddWaterPlanes(r_refdef.worldentity);
+ if (r_timereport_active)
+ R_TimeReport("waterworld");
+ }
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ R_DrawModelsAddWaterPlanes();
+ if (r_timereport_active)
+ R_TimeReport("watermodels");
+
+ R_Water_ProcessPlanes();
+ if (r_timereport_active)
+ R_TimeReport("waterscenes");
+ }
+
+ R_ResetViewRendering3D();
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ R_MeshQueue_BeginScene();
+
+ R_SkyStartFrame();
+
+ R_View_Update();
+ if (r_timereport_active)
+ R_TimeReport("visibility");
+
+ Matrix4x4_CreateTranslate(&r_waterscrollmatrix, sin(r_refdef.time) * 0.025 * r_waterscroll.value, sin(r_refdef.time * 0.8f) * 0.025 * r_waterscroll.value, 0);
+
+ if (cl.csqc_vidvars.drawworld)
+ {
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ if (r_refdef.worldmodel && r_refdef.worldmodel->DrawSky)
+ {
+ r_refdef.worldmodel->DrawSky(r_refdef.worldentity);
+ if (r_timereport_active)
+ R_TimeReport("worldsky");
+ }
+
+ if (R_DrawBrushModelsSky() && r_timereport_active)
+ R_TimeReport("bmodelsky");
+ }
+
+ if (r_depthfirst.integer >= 1 && cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->DrawDepth)
+ {
+ r_refdef.worldmodel->DrawDepth(r_refdef.worldentity);
+ if (r_timereport_active)
+ R_TimeReport("worlddepth");
+ }
+ if (r_depthfirst.integer >= 2)
+ {
+ R_DrawModelsDepth();
+ if (r_timereport_active)
+ R_TimeReport("modeldepth");
+ }
+
+ if (cl.csqc_vidvars.drawworld && r_refdef.worldmodel && r_refdef.worldmodel->Draw)
+ {
+ r_refdef.worldmodel->Draw(r_refdef.worldentity);
+ if (r_timereport_active)
+ R_TimeReport("world");
+ }
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ R_DrawModels();
+ if (r_timereport_active)
+ R_TimeReport("models");
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ if (r_shadows.integer > 0 && r_refdef.lightmapintensity > 0)
+ {
+ R_DrawModelShadows();
+
+ R_ResetViewRendering3D();
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+ }
+
+ R_ShadowVolumeLighting(false);
+ if (r_timereport_active)
+ R_TimeReport("rtlights");
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ if (cl.csqc_vidvars.drawworld)
+ {
+ R_DrawLightningBeams();
+ if (r_timereport_active)
+ R_TimeReport("lightning");
+
+ R_DrawDecals();
+ if (r_timereport_active)
+ R_TimeReport("decals");
+
+ R_DrawParticles();
+ if (r_timereport_active)
+ R_TimeReport("particles");
+
+ R_DrawExplosions();
+ if (r_timereport_active)
+ R_TimeReport("explosions");
+ }
+
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+ VM_CL_AddPolygonsToMeshQueue();
+
+ if (r_view.showdebug)
+ {
+ if (cl_locs_show.integer)
+ {
+ R_DrawLocs();
+ if (r_timereport_active)
+ R_TimeReport("showlocs");
+ }
+
+ if (r_drawportals.integer)
+ {
+ R_DrawPortals();
+ if (r_timereport_active)
+ R_TimeReport("portals");
+ }
+
+ if (r_showbboxes.value > 0)
+ {
+ R_DrawEntityBBoxes();
+ if (r_timereport_active)
+ R_TimeReport("bboxes");
+ }
+ }
+
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+ R_MeshQueue_RenderTransparent();
+ if (r_timereport_active)
+ R_TimeReport("drawtrans");
+
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+
+ if (r_view.showdebug && r_refdef.worldmodel && r_refdef.worldmodel->DrawDebug && (r_showtris.value > 0 || r_shownormals.value > 0 || r_showcollisionbrushes.value > 0))
+ {
+ r_refdef.worldmodel->DrawDebug(r_refdef.worldentity);
+ if (r_timereport_active)
+ R_TimeReport("worlddebug");
+ R_DrawModelsDebug();
+ if (r_timereport_active)
+ R_TimeReport("modeldebug");
+ }
+
+ if (gl_support_fragment_shader)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+
+ if (cl.csqc_vidvars.drawworld)
+ {
+ R_DrawCoronas();
+ if (r_timereport_active)
+ R_TimeReport("coronas");
+ }
+
+ // don't let sound skip if going slow
+ if (r_refdef.extraupdate)
+ S_ExtraUpdate ();
+
+ R_ResetViewRendering2D();
+}
+
+static const int bboxelements[36] =
+{
+ 5, 1, 3, 5, 3, 7,
+ 6, 2, 0, 6, 0, 4,
+ 7, 3, 2, 7, 2, 6,
+ 4, 0, 1, 4, 1, 5,
+ 4, 5, 7, 4, 7, 6,
+ 1, 0, 2, 1, 2, 3,
+};
+
+void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, float ca)
+{
+ int i;
+ float *v, *c, f1, f2, vertex3f[8*3], color4f[8*4];
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
+ GL_DepthRange(0, 1);
+ GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
+ R_Mesh_Matrix(&identitymatrix);
+ R_Mesh_ResetTextureState();
+
+ vertex3f[ 0] = mins[0];vertex3f[ 1] = mins[1];vertex3f[ 2] = mins[2]; //
+ vertex3f[ 3] = maxs[0];vertex3f[ 4] = mins[1];vertex3f[ 5] = mins[2];
+ vertex3f[ 6] = mins[0];vertex3f[ 7] = maxs[1];vertex3f[ 8] = mins[2];
+ vertex3f[ 9] = maxs[0];vertex3f[10] = maxs[1];vertex3f[11] = mins[2];
+ vertex3f[12] = mins[0];vertex3f[13] = mins[1];vertex3f[14] = maxs[2];
+ vertex3f[15] = maxs[0];vertex3f[16] = mins[1];vertex3f[17] = maxs[2];
+ vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
+ vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
+ R_FillColors(color4f, 8, cr, cg, cb, ca);
+ if (r_refdef.fogenabled)
+ {
+ for (i = 0, v = vertex3f, c = color4f;i < 8;i++, v += 3, c += 4)
+ {
+ f1 = FogPoint_World(v);
+ f2 = 1 - f1;
+ c[0] = c[0] * f1 + r_refdef.fogcolor[0] * f2;
+ c[1] = c[1] * f1 + r_refdef.fogcolor[1] * f2;
+ c[2] = c[2] * f1 + r_refdef.fogcolor[2] * f2;
+ }
+ }
+ R_Mesh_VertexPointer(vertex3f, 0, 0);
+ R_Mesh_ColorPointer(color4f, 0, 0);
+ R_Mesh_ResetTextureState();
+ R_Mesh_Draw(0, 8, 12, bboxelements, 0, 0);
+}
+
+static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
+{
+ int i;
+ float color[4];
+ prvm_edict_t *edict;
+ // this function draws bounding boxes of server entities
+ if (!sv.active)
+ return;
+ SV_VM_Begin();
+ for (i = 0;i < numsurfaces;i++)
+ {
+ edict = PRVM_EDICT_NUM(surfacelist[i]);
+ switch ((int)edict->fields.server->solid)
+ {
+ case SOLID_NOT: Vector4Set(color, 1, 1, 1, 0.05);break;
+ case SOLID_TRIGGER: Vector4Set(color, 1, 0, 1, 0.10);break;
+ case SOLID_BBOX: Vector4Set(color, 0, 1, 0, 0.10);break;
+ case SOLID_SLIDEBOX: Vector4Set(color, 1, 0, 0, 0.10);break;
+ case SOLID_BSP: Vector4Set(color, 0, 0, 1, 0.05);break;
+ default: Vector4Set(color, 0, 0, 0, 0.50);break;
+ }
+ color[3] *= r_showbboxes.value;
+ color[3] = bound(0, color[3], 1);
+ GL_DepthTest(!r_showdisabledepthtest.integer);
+ GL_CullFace(r_view.cullface_front);
+ R_DrawBBoxMesh(edict->priv.server->areamins, edict->priv.server->areamaxs, color[0], color[1], color[2], color[3]);
+ }
+ SV_VM_End();
+}
+
+static void R_DrawEntityBBoxes(void)
+{
+ int i;
+ prvm_edict_t *edict;
+ vec3_t center;
+ // this function draws bounding boxes of server entities
+ if (!sv.active)
+ return;
+ SV_VM_Begin();
+ for (i = 0;i < prog->num_edicts;i++)
+ {
+ edict = PRVM_EDICT_NUM(i);
+ if (edict->priv.server->free)
+ continue;
+ VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
+ R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
+ }
+ SV_VM_End();
+}
+
+int nomodelelements[24] =
+{
+ 5, 2, 0,
+ 5, 1, 2,
+ 5, 0, 3,
+ 5, 3, 1,
+ 0, 2, 4,
+ 2, 1, 4,
+ 3, 0, 4,
+ 1, 3, 4
+};
+
+float nomodelvertex3f[6*3] =
+{
+ -16, 0, 0,
+ 16, 0, 0,
+ 0, -16, 0,
+ 0, 16, 0,
+ 0, 0, -16,
+ 0, 0, 16
+};
+
+float nomodelcolor4f[6*4] =
+{
+ 0.0f, 0.0f, 0.5f, 1.0f,
+ 0.0f, 0.0f, 0.5f, 1.0f,
+ 0.0f, 0.5f, 0.0f, 1.0f,
+ 0.0f, 0.5f, 0.0f, 1.0f,
+ 0.5f, 0.0f, 0.0f, 1.0f,
+ 0.5f, 0.0f, 0.0f, 1.0f
+};
+
+void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
+{
+ int i;
+ float f1, f2, *c;
+ float color4f[6*4];
+ // this is only called once per entity so numsurfaces is always 1, and
+ // surfacelist is always {0}, so this code does not handle batches
+ R_Mesh_Matrix(&ent->matrix);
+
+ if (ent->flags & EF_ADDITIVE)
+ {
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+ GL_DepthMask(false);
+ }
+ else if (ent->alpha < 1)
+ {
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
+ }
+ else
+ {
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
+ }
+ GL_DepthRange(0, (ent->flags & RENDER_VIEWMODEL) ? 0.0625 : 1);
+ GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
+ GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
+ GL_CullFace((ent->effects & EF_DOUBLESIDED) ? GL_NONE : r_view.cullface_back);
+ R_Mesh_VertexPointer(nomodelvertex3f, 0, 0);
+ if (r_refdef.fogenabled)
+ {
+ vec3_t org;
+ memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
+ R_Mesh_ColorPointer(color4f, 0, 0);
+ Matrix4x4_OriginFromMatrix(&ent->matrix, org);
+ f1 = FogPoint_World(org);
+ f2 = 1 - f1;
+ for (i = 0, c = color4f;i < 6;i++, c += 4)
+ {
+ c[0] = (c[0] * f1 + r_refdef.fogcolor[0] * f2);
+ c[1] = (c[1] * f1 + r_refdef.fogcolor[1] * f2);
+ c[2] = (c[2] * f1 + r_refdef.fogcolor[2] * f2);
+ c[3] *= ent->alpha;
+ }
+ }
+ else if (ent->alpha != 1)
+ {
+ memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
+ R_Mesh_ColorPointer(color4f, 0, 0);
+ for (i = 0, c = color4f;i < 6;i++, c += 4)
+ c[3] *= ent->alpha;
+ }
+ else
+ R_Mesh_ColorPointer(nomodelcolor4f, 0, 0);
+ R_Mesh_ResetTextureState();
+ R_Mesh_Draw(0, 6, 8, nomodelelements, 0, 0);
+}
+
+void R_DrawNoModel(entity_render_t *ent)
+{
+ vec3_t org;
+ Matrix4x4_OriginFromMatrix(&ent->matrix, org);
+ //if ((ent->effects & EF_ADDITIVE) || (ent->alpha < 1))
+ R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight);
+ //else
+ // R_DrawNoModelCallback(ent, 0);
+}
+
+void R_CalcBeam_Vertex3f (float *vert, const vec3_t org1, const vec3_t org2, float width)
+{
+ vec3_t right1, right2, diff, normal;
+
+ VectorSubtract (org2, org1, normal);
+
+ // calculate 'right' vector for start
+ VectorSubtract (r_view.origin, org1, diff);
+ CrossProduct (normal, diff, right1);
+ VectorNormalize (right1);
+
+ // calculate 'right' vector for end
+ VectorSubtract (r_view.origin, org2, diff);
+ CrossProduct (normal, diff, right2);
+ VectorNormalize (right2);
+
+ vert[ 0] = org1[0] + width * right1[0];
+ vert[ 1] = org1[1] + width * right1[1];
+ vert[ 2] = org1[2] + width * right1[2];
+ vert[ 3] = org1[0] - width * right1[0];
+ vert[ 4] = org1[1] - width * right1[1];
+ vert[ 5] = org1[2] - width * right1[2];
+ vert[ 6] = org2[0] - width * right2[0];
+ vert[ 7] = org2[1] - width * right2[1];
+ vert[ 8] = org2[2] - width * right2[2];
+ vert[ 9] = org2[0] + width * right2[0];
+ vert[10] = org2[1] + width * right2[1];
+ vert[11] = org2[2] + width * right2[2];
+}
+
+float spritetexcoord2f[4*2] = {0, 1, 0, 0, 1, 0, 1, 1};
+
+void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, qboolean depthdisable, qboolean depthshort, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca)
+{
+ float fog = 1.0f;
+ float vertex3f[12];
+
+ if (r_refdef.fogenabled)
+ fog = FogPoint_World(origin);
+
+ R_Mesh_Matrix(&identitymatrix);
+ GL_BlendFunc(blendfunc1, blendfunc2);
+
+ if(v_flipped_state)
+ {
+ scalex1 = -scalex1;
+ scalex2 = -scalex2;
+ GL_CullFace(r_view.cullface_front);
+ }
+ else
+ GL_CullFace(r_view.cullface_back);
+
+ GL_DepthMask(false);
+ GL_DepthRange(0, depthshort ? 0.0625 : 1);
+ GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);
+ GL_DepthTest(!depthdisable);
+
+ vertex3f[ 0] = origin[0] + left[0] * scalex2 + up[0] * scaley1;
+ vertex3f[ 1] = origin[1] + left[1] * scalex2 + up[1] * scaley1;
+ vertex3f[ 2] = origin[2] + left[2] * scalex2 + up[2] * scaley1;
+ vertex3f[ 3] = origin[0] + left[0] * scalex2 + up[0] * scaley2;
+ vertex3f[ 4] = origin[1] + left[1] * scalex2 + up[1] * scaley2;
+ vertex3f[ 5] = origin[2] + left[2] * scalex2 + up[2] * scaley2;
+ vertex3f[ 6] = origin[0] + left[0] * scalex1 + up[0] * scaley2;
+ vertex3f[ 7] = origin[1] + left[1] * scalex1 + up[1] * scaley2;
+ vertex3f[ 8] = origin[2] + left[2] * scalex1 + up[2] * scaley2;
+ vertex3f[ 9] = origin[0] + left[0] * scalex1 + up[0] * scaley1;
+ vertex3f[10] = origin[1] + left[1] * scalex1 + up[1] * scaley1;
+ vertex3f[11] = origin[2] + left[2] * scalex1 + up[2] * scaley1;
+
+ R_Mesh_VertexPointer(vertex3f, 0, 0);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ R_Mesh_ResetTextureState();
+ R_Mesh_TexBind(0, R_GetTexture(texture));
+ R_Mesh_TexCoordPointer(0, 2, spritetexcoord2f, 0, 0);
+ // FIXME: fixed function path can't properly handle r_view.colorscale > 1
+ GL_Color(cr * fog * r_view.colorscale, cg * fog * r_view.colorscale, cb * fog * r_view.colorscale, ca);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+
+ if (blendfunc2 == GL_ONE_MINUS_SRC_ALPHA)
+ {
+ R_Mesh_TexBind(0, R_GetTexture(fogtexture));
+ GL_BlendFunc(blendfunc1, GL_ONE);
+ fog = 1 - fog;
+ GL_Color(r_refdef.fogcolor[0] * fog * r_view.colorscale, r_refdef.fogcolor[1] * fog * r_view.colorscale, r_refdef.fogcolor[2] * fog * r_view.colorscale, ca);
+ R_Mesh_Draw(0, 4, 2, polygonelements, 0, 0);
+ }
+}
+
+int R_Mesh_AddVertex(rmesh_t *mesh, float x, float y, float z)
+{
+ int i;
+ float *vertex3f;
+ float v[3];
+ VectorSet(v, x, y, z);
+ for (i = 0, vertex3f = mesh->vertex3f;i < mesh->numvertices;i++, vertex3f += 3)
+ if (VectorDistance2(v, vertex3f) < mesh->epsilon2)
+ break;
+ if (i == mesh->numvertices)
+ {
+ if (mesh->numvertices < mesh->maxvertices)
+ {
+ VectorCopy(v, vertex3f);
+ mesh->numvertices++;
+ }
+ return mesh->numvertices;
+ }
+ else
+ return i;
+}
+
+void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f)
+{
+ int i;
+ int *e, element[3];
+ element[0] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
+ element[1] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);vertex3f += 3;
+ e = mesh->element3i + mesh->numtriangles * 3;
+ for (i = 0;i < numvertices - 2;i++, vertex3f += 3)
+ {
+ element[2] = R_Mesh_AddVertex(mesh, vertex3f[0], vertex3f[1], vertex3f[2]);
+ if (mesh->numtriangles < mesh->maxtriangles)
+ {
+ *e++ = element[0];
+ *e++ = element[1];
+ *e++ = element[2];
+ mesh->numtriangles++;
+ }
+ element[1] = element[2];
+ }
+}
+
+void R_Mesh_AddPolygon3d(rmesh_t *mesh, int numvertices, double *vertex3d)
+{
+ int i;
+ int *e, element[3];
+ element[0] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
+ element[1] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);vertex3d += 3;
+ e = mesh->element3i + mesh->numtriangles * 3;
+ for (i = 0;i < numvertices - 2;i++, vertex3d += 3)
+ {
+ element[2] = R_Mesh_AddVertex(mesh, vertex3d[0], vertex3d[1], vertex3d[2]);
+ if (mesh->numtriangles < mesh->maxtriangles)
+ {
+ *e++ = element[0];
+ *e++ = element[1];
+ *e++ = element[2];
+ mesh->numtriangles++;
+ }
+ element[1] = element[2];
+ }
+}
+
+#define R_MESH_PLANE_DIST_EPSILON (1.0 / 32.0)
+void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes)
+{
+ int planenum, planenum2;
+ int w;
+ int tempnumpoints;
+ mplane_t *plane, *plane2;
+ double maxdist;
+ double temppoints[2][256*3];
+ // figure out how large a bounding box we need to properly compute this brush
+ maxdist = 0;
+ for (w = 0;w < numplanes;w++)
+ maxdist = max(maxdist, planes[w].dist);
+ // now make it large enough to enclose the entire brush, and round it off to a reasonable multiple of 1024
+ maxdist = floor(maxdist * (4.0 / 1024.0) + 1) * 1024.0;
+ for (planenum = 0, plane = planes;planenum < numplanes;planenum++, plane++)
+ {
+ w = 0;
+ tempnumpoints = 4;
+ PolygonD_QuadForPlane(temppoints[w], plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, maxdist);
+ for (planenum2 = 0, plane2 = planes;planenum2 < numplanes && tempnumpoints >= 3;planenum2++, plane2++)
+ {
+ if (planenum2 == planenum)
+ continue;
+ PolygonD_Divide(tempnumpoints, temppoints[w], plane2->normal[0], plane2->normal[1], plane2->normal[2], plane2->dist, R_MESH_PLANE_DIST_EPSILON, 0, NULL, NULL, 256, temppoints[!w], &tempnumpoints, NULL);
+ w = !w;
+ }
+ if (tempnumpoints < 3)
+ continue;
+ // generate elements forming a triangle fan for this polygon
+ R_Mesh_AddPolygon3d(mesh, tempnumpoints, temppoints[w]);
+ }
+}
+
+static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, int blendfunc2, texturelayertype_t type, rtexture_t *texture, const matrix4x4_t *matrix, float r, float g, float b, float a)
+{
+ texturelayer_t *layer;
+ layer = t->currentlayers + t->currentnumlayers++;
+ layer->type = type;
+ layer->depthmask = depthmask;
+ layer->blendfunc1 = blendfunc1;
+ layer->blendfunc2 = blendfunc2;
+ layer->texture = texture;
+ layer->texmatrix = *matrix;
+ layer->color[0] = r * r_view.colorscale;
+ layer->color[1] = g * r_view.colorscale;
+ layer->color[2] = b * r_view.colorscale;
+ layer->color[3] = a;
+}
+
+static float R_EvaluateQ3WaveFunc(q3wavefunc_t func, const float *parms)
+{
+ double index, f;
+ index = parms[2] + r_refdef.time * parms[3];
+ index -= floor(index);
+ switch (func)
+ {
+ default:
+ case Q3WAVEFUNC_NONE:
+ case Q3WAVEFUNC_NOISE:
+ case Q3WAVEFUNC_COUNT:
+ f = 0;
+ break;
+ case Q3WAVEFUNC_SIN: f = sin(index * M_PI * 2);break;
+ case Q3WAVEFUNC_SQUARE: f = index < 0.5 ? 1 : -1;break;
+ case Q3WAVEFUNC_SAWTOOTH: f = index;break;
+ case Q3WAVEFUNC_INVERSESAWTOOTH: f = 1 - index;break;
+ case Q3WAVEFUNC_TRIANGLE:
+ index *= 4;
+ f = index - floor(index);
+ if (index < 1)
+ f = f;
+ else if (index < 2)
+ f = 1 - f;
+ else if (index < 3)
+ f = -f;
+ else
+ f = -(1 - f);
+ break;
+ }
+ return (float)(parms[0] + parms[1] * f);
+}
+
+void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t)
+{
+ int i;
+ model_t *model = ent->model;
+ float f;
+ float tcmat[12];
+ q3shaderinfo_layer_tcmod_t *tcmod;
+
+ // switch to an alternate material if this is a q1bsp animated material
+ {
+ texture_t *texture = t;
+ int s = ent->skinnum;
+ if ((unsigned int)s >= (unsigned int)model->numskins)
+ s = 0;
+ if (model->skinscenes)
+ {
+ if (model->skinscenes[s].framecount > 1)
+ s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
+ else
+ s = model->skinscenes[s].firstframe;
+ }
+ if (s > 0)
+ t = t + s * model->num_surfaces;
+ if (t->animated)
+ {
+ // use an alternate animation if the entity's frame is not 0,
+ // and only if the texture has an alternate animation
+ if (ent->frame2 != 0 && t->anim_total[1])
+ t = t->anim_frames[1][(t->anim_total[1] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[1]) : 0];
+ else
+ t = t->anim_frames[0][(t->anim_total[0] >= 2) ? ((int)(r_refdef.time * 5.0f) % t->anim_total[0]) : 0];
+ }
+ texture->currentframe = t;
+ }
+
+ // update currentskinframe to be a qw skin or animation frame
+ if ((i = ent->entitynumber - 1) >= 0 && i < cl.maxclients)
+ {
+ if (strcmp(r_qwskincache[i], cl.scores[i].qw_skin))
+ {
+ strlcpy(r_qwskincache[i], cl.scores[i].qw_skin, sizeof(r_qwskincache[i]));
+ Con_DPrintf("loading skins/%s\n", r_qwskincache[i]);
+ r_qwskincache_skinframe[i] = R_SkinFrame_LoadExternal(va("skins/%s", r_qwskincache[i]), TEXF_PRECACHE | (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP | TEXF_COMPRESS, developer.integer > 0);
+ }
+ t->currentskinframe = r_qwskincache_skinframe[i];
+ if (t->currentskinframe == NULL)
+ t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
+ }
+ else if (t->numskinframes >= 2)
+ t->currentskinframe = t->skinframes[(int)(t->skinframerate * (cl.time - ent->frame2time)) % t->numskinframes];
+ if (t->backgroundnumskinframes >= 2)
+ t->backgroundcurrentskinframe = t->backgroundskinframes[(int)(t->backgroundskinframerate * (cl.time - ent->frame2time)) % t->backgroundnumskinframes];
+
+ t->currentmaterialflags = t->basematerialflags;
+ t->currentalpha = ent->alpha;
+ if (t->basematerialflags & MATERIALFLAG_WATERALPHA && (model->brush.supportwateralpha || r_novis.integer))
+ {
+ t->currentalpha *= r_wateralpha.value;
+ /*
+ * FIXME what is this supposed to do?
+ // if rendering refraction/reflection, disable transparency
+ if (r_waterstate.enabled && (t->currentalpha < 1 || (t->currentmaterialflags & MATERIALFLAG_ALPHA)))
+ t->currentmaterialflags |= MATERIALFLAG_WATERSHADER;
+ */
+ }
+ if(!r_waterstate.enabled)
+ t->currentmaterialflags &= ~(MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION);
+ if (!(ent->flags & RENDER_LIGHT))
+ t->currentmaterialflags |= MATERIALFLAG_FULLBRIGHT;
+ else if (rsurface.modeltexcoordlightmap2f == NULL)
+ {
+ // pick a model lighting mode
+ if (VectorLength2(ent->modellight_diffuse) >= (1.0f / 256.0f))
+ t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT | MATERIALFLAG_MODELLIGHT_DIRECTIONAL;
+ else
+ t->currentmaterialflags |= MATERIALFLAG_MODELLIGHT;
+ }
+ if (ent->effects & EF_ADDITIVE)
+ t->currentmaterialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
+ else if (t->currentalpha < 1)
+ t->currentmaterialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
+ if (ent->effects & EF_DOUBLESIDED)
+ t->currentmaterialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_NOCULLFACE;
+ if (ent->effects & EF_NODEPTHTEST)
+ t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
+ if (ent->flags & RENDER_VIEWMODEL)
+ t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE;
+ if (t->backgroundnumskinframes && !(t->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
+ t->currentmaterialflags |= MATERIALFLAG_VERTEXTEXTUREBLEND;
+
+ for (i = 0, tcmod = t->tcmods;i < Q3MAXTCMODS && (tcmod->tcmod || i < 1);i++, tcmod++)
+ {
+ matrix4x4_t matrix;
+ switch(tcmod->tcmod)
+ {
+ case Q3TCMOD_COUNT:
+ case Q3TCMOD_NONE:
+ if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0)
+ matrix = r_waterscrollmatrix;
+ else
+ matrix = identitymatrix;
+ break;
+ case Q3TCMOD_ENTITYTRANSLATE:
+ // this is used in Q3 to allow the gamecode to control texcoord
+ // scrolling on the entity, which is not supported in darkplaces yet.
+ Matrix4x4_CreateTranslate(&matrix, 0, 0, 0);
+ break;
+ case Q3TCMOD_ROTATE:
+ Matrix4x4_CreateTranslate(&matrix, 0.5, 0.5, 0);
+ Matrix4x4_ConcatRotate(&matrix, tcmod->parms[0] * r_refdef.time, 0, 0, 1);
+ Matrix4x4_ConcatTranslate(&matrix, -0.5, -0.5, 0);
+ break;
+ case Q3TCMOD_SCALE:
+ Matrix4x4_CreateScale3(&matrix, tcmod->parms[0], tcmod->parms[1], 1);
+ break;
+ case Q3TCMOD_SCROLL:
+ Matrix4x4_CreateTranslate(&matrix, tcmod->parms[0] * r_refdef.time, tcmod->parms[1] * r_refdef.time, 0);
+ break;
+ case Q3TCMOD_STRETCH:
+ f = 1.0f / R_EvaluateQ3WaveFunc(tcmod->wavefunc, tcmod->waveparms);
+ Matrix4x4_CreateFromQuakeEntity(&matrix, 0.5f * (1 - f), 0.5 * (1 - f), 0, 0, 0, 0, f);
+ break;
+ case Q3TCMOD_TRANSFORM:
+ VectorSet(tcmat + 0, tcmod->parms[0], tcmod->parms[1], 0);
+ VectorSet(tcmat + 3, tcmod->parms[2], tcmod->parms[3], 0);
+ VectorSet(tcmat + 6, 0 , 0 , 1);
+ VectorSet(tcmat + 9, tcmod->parms[4], tcmod->parms[5], 0);
+ Matrix4x4_FromArray12FloatGL(&matrix, tcmat);
+ break;
+ case Q3TCMOD_TURBULENT:
+ // this is handled in the RSurf_PrepareVertices function
+ matrix = identitymatrix;
+ break;
+ }
+ // either replace or concatenate the transformation
+ if (i < 1)
+ t->currenttexmatrix = matrix;
+ else
+ {
+ matrix4x4_t temp = t->currenttexmatrix;
+ Matrix4x4_Concat(&t->currenttexmatrix, &matrix, &temp);
+ }
+ }
+
+ t->colormapping = VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f);
+ t->basetexture = (!t->colormapping && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
+ t->glosstexture = r_texture_black;
+ t->backgroundbasetexture = t->backgroundnumskinframes ? ((!t->colormapping && t->backgroundcurrentskinframe->merged) ? t->backgroundcurrentskinframe->merged : t->backgroundcurrentskinframe->base) : r_texture_white;
+ t->backgroundglosstexture = r_texture_black;
+ t->specularpower = r_shadow_glossexponent.value;
+ // TODO: store reference values for these in the texture?
+ t->specularscale = 0;
+ if (r_shadow_gloss.integer > 0)
+ {
+ if (t->currentskinframe->gloss || (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss))
+ {
+ if (r_shadow_glossintensity.value > 0)
+ {
+ t->glosstexture = t->currentskinframe->gloss ? t->currentskinframe->gloss : r_texture_white;
+ t->backgroundglosstexture = (t->backgroundcurrentskinframe && t->backgroundcurrentskinframe->gloss) ? t->backgroundcurrentskinframe->gloss : r_texture_white;
+ t->specularscale = r_shadow_glossintensity.value;
+ }
+ }
+ else if (r_shadow_gloss.integer >= 2 && r_shadow_gloss2intensity.value > 0)
+ {
+ t->glosstexture = r_texture_white;
+ t->backgroundglosstexture = r_texture_white;
+ t->specularscale = r_shadow_gloss2intensity.value;
+ }
+ }
+
+ // lightmaps mode looks bad with dlights using actual texturing, so turn
+ // off the colormap and glossmap, but leave the normalmap on as it still
+ // accurately represents the shading involved
+ if (gl_lightmaps.integer && !(t->currentmaterialflags & MATERIALFLAG_BLENDED))
+ {
+ t->basetexture = r_texture_white;
+ t->specularscale = 0;
+ }
+
+ t->currentpolygonfactor = r_refdef.polygonfactor + t->basepolygonfactor;
+ t->currentpolygonoffset = r_refdef.polygonoffset + t->basepolygonoffset;
+ // submodels are biased to avoid z-fighting with world surfaces that they
+ // may be exactly overlapping (avoids z-fighting artifacts on certain
+ // doors and things in Quake maps)
+ if (ent->model->brush.submodel)
+ {
+ t->currentpolygonfactor += r_polygonoffset_submodel_factor.value;
+ t->currentpolygonoffset += r_polygonoffset_submodel_offset.value;
+ }
+
+ VectorClear(t->dlightcolor);
+ t->currentnumlayers = 0;
+ if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW))
+ {
+ if (!(t->currentmaterialflags & MATERIALFLAG_SKY))
+ {
+ int blendfunc1, blendfunc2, depthmask;
+ if (t->currentmaterialflags & MATERIALFLAG_ADD)
+ {
+ blendfunc1 = GL_SRC_ALPHA;
+ blendfunc2 = GL_ONE;
+ }
+ else if (t->currentmaterialflags & MATERIALFLAG_ALPHA)
+ {
+ blendfunc1 = GL_SRC_ALPHA;
+ blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+ }
+ else if (t->currentmaterialflags & MATERIALFLAG_CUSTOMBLEND)
+ {
+ blendfunc1 = t->customblendfunc[0];
+ blendfunc2 = t->customblendfunc[1];
+ }
+ else
+ {
+ blendfunc1 = GL_ONE;
+ blendfunc2 = GL_ZERO;
+ }
+ depthmask = !(t->currentmaterialflags & MATERIALFLAG_BLENDED);
+ if (t->currentmaterialflags & (MATERIALFLAG_WATER | MATERIALFLAG_WALL))
+ {
+ rtexture_t *currentbasetexture;
+ int layerflags = 0;
+ if (r_refdef.fogenabled && (t->currentmaterialflags & MATERIALFLAG_BLENDED))
+ layerflags |= TEXTURELAYERFLAG_FOGDARKEN;
+ currentbasetexture = (VectorLength2(ent->colormap_pantscolor) + VectorLength2(ent->colormap_shirtcolor) < (1.0f / 1048576.0f) && t->currentskinframe->merged) ? t->currentskinframe->merged : t->currentskinframe->base;
+ if (t->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
+ {
+ // fullbright is not affected by r_refdef.lightmapintensity
+ R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0], ent->colormod[1], ent->colormod[2], t->currentalpha);
+ if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0], ent->colormap_pantscolor[1] * ent->colormod[1], ent->colormap_pantscolor[2] * ent->colormod[2], t->currentalpha);
+ if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0], ent->colormap_shirtcolor[1] * ent->colormod[1], ent->colormap_shirtcolor[2] * ent->colormod[2], t->currentalpha);
+ }
+ else
+ {
+ float colorscale;
+ // set the color tint used for lights affecting this surface
+ VectorSet(t->dlightcolor, ent->colormod[0] * t->currentalpha, ent->colormod[1] * t->currentalpha, ent->colormod[2] * t->currentalpha);
+ colorscale = 2;
+ // q3bsp has no lightmap updates, so the lightstylevalue that
+ // would normally be baked into the lightmap must be
+ // applied to the color
+ // FIXME: r_glsl 1 rendering doesn't support overbright lightstyles with this (the default light style is not overbright)
+ if (ent->model->type == mod_brushq3)
+ colorscale *= r_refdef.lightstylevalue[0] * (1.0f / 256.0f);
+ colorscale *= r_refdef.lightmapintensity;
+ R_Texture_AddLayer(t, depthmask, blendfunc1, blendfunc2, TEXTURELAYERTYPE_LITTEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * colorscale, ent->colormod[1] * colorscale, ent->colormod[2] * colorscale, t->currentalpha);
+ if (r_ambient.value >= (1.0f/64.0f))
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, currentbasetexture, &t->currenttexmatrix, ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
+ if (VectorLength2(ent->colormap_pantscolor) >= (1.0f / 1048576.0f) && t->currentskinframe->pants)
+ {
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0] * colorscale, ent->colormap_pantscolor[1] * ent->colormod[1] * colorscale, ent->colormap_pantscolor[2] * ent->colormod[2] * colorscale, t->currentalpha);
+ if (r_ambient.value >= (1.0f/64.0f))
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->pants, &t->currenttexmatrix, ent->colormap_pantscolor[0] * ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[1] * ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_pantscolor[2] * ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
+ }
+ if (VectorLength2(ent->colormap_shirtcolor) >= (1.0f / 1048576.0f) && t->currentskinframe->shirt)
+ {
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_LITTEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0] * colorscale, ent->colormap_shirtcolor[1] * ent->colormod[1] * colorscale, ent->colormap_shirtcolor[2] * ent->colormod[2] * colorscale, t->currentalpha);
+ if (r_ambient.value >= (1.0f/64.0f))
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->shirt, &t->currenttexmatrix, ent->colormap_shirtcolor[0] * ent->colormod[0] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[1] * ent->colormod[1] * r_ambient.value * (1.0f / 64.0f), ent->colormap_shirtcolor[2] * ent->colormod[2] * r_ambient.value * (1.0f / 64.0f), t->currentalpha);
+ }
+ }
+ if (t->currentskinframe->glow != NULL)
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, GL_ONE, TEXTURELAYERTYPE_TEXTURE, t->currentskinframe->glow, &t->currenttexmatrix, r_hdr_glowintensity.value, r_hdr_glowintensity.value, r_hdr_glowintensity.value, t->currentalpha);
+ if (r_refdef.fogenabled && !(t->currentmaterialflags & MATERIALFLAG_ADD))
+ {
+ // if this is opaque use alpha blend which will darken the earlier
+ // passes cheaply.
+ //
+ // if this is an alpha blended material, all the earlier passes
+ // were darkened by fog already, so we only need to add the fog
+ // color ontop through the fog mask texture
+ //
+ // if this is an additive blended material, all the earlier passes
+ // were darkened by fog already, and we should not add fog color
+ // (because the background was not darkened, there is no fog color
+ // that was lost behind it).
+ R_Texture_AddLayer(t, false, GL_SRC_ALPHA, (t->currentmaterialflags & MATERIALFLAG_BLENDED) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA, TEXTURELAYERTYPE_FOG, t->currentskinframe->fog, &identitymatrix, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2], t->currentalpha);
+ }
+ }
+ }
+ }
+}
+
+void R_UpdateAllTextureInfo(entity_render_t *ent)
+{
+ int i;
+ if (ent->model)
+ for (i = 0;i < ent->model->num_texturesperskin;i++)
+ R_UpdateTextureInfo(ent, ent->model->data_textures + i);
+}
+
+rsurfacestate_t rsurface;
+
+void R_Mesh_ResizeArrays(int newvertices)
+{
+ float *base;
+ if (rsurface.array_size >= newvertices)
+ return;
+ if (rsurface.array_modelvertex3f)
+ Mem_Free(rsurface.array_modelvertex3f);
+ rsurface.array_size = (newvertices + 1023) & ~1023;
+ base = (float *)Mem_Alloc(r_main_mempool, rsurface.array_size * sizeof(float[33]));
+ rsurface.array_modelvertex3f = base + rsurface.array_size * 0;
+ rsurface.array_modelsvector3f = base + rsurface.array_size * 3;
+ rsurface.array_modeltvector3f = base + rsurface.array_size * 6;
+ rsurface.array_modelnormal3f = base + rsurface.array_size * 9;
+ rsurface.array_deformedvertex3f = base + rsurface.array_size * 12;
+ rsurface.array_deformedsvector3f = base + rsurface.array_size * 15;
+ rsurface.array_deformedtvector3f = base + rsurface.array_size * 18;
+ rsurface.array_deformednormal3f = base + rsurface.array_size * 21;
+ rsurface.array_texcoord3f = base + rsurface.array_size * 24;
+ rsurface.array_color4f = base + rsurface.array_size * 27;
+ rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31;
+}
+
+void RSurf_CleanUp(void)
+{
+ CHECKGLERROR
+ if (rsurface.mode == RSURFMODE_GLSL)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+ GL_AlphaTest(false);
+ rsurface.mode = RSURFMODE_NONE;
+ rsurface.uselightmaptexture = false;
+ rsurface.texture = NULL;
+}
+
+void RSurf_ActiveWorldEntity(void)
+{
+ model_t *model = r_refdef.worldmodel;
+ RSurf_CleanUp();
+ if (rsurface.array_size < model->surfmesh.num_vertices)
+ R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
+ rsurface.matrix = identitymatrix;
+ rsurface.inversematrix = identitymatrix;
+ R_Mesh_Matrix(&identitymatrix);
+ VectorCopy(r_view.origin, rsurface.modelorg);
+ VectorSet(rsurface.modellight_ambient, 0, 0, 0);
+ VectorSet(rsurface.modellight_diffuse, 0, 0, 0);
+ VectorSet(rsurface.modellight_lightdir, 0, 0, 1);
+ VectorSet(rsurface.colormap_pantscolor, 0, 0, 0);
+ VectorSet(rsurface.colormap_shirtcolor, 0, 0, 0);
+ rsurface.frameblend[0].frame = 0;
+ rsurface.frameblend[0].lerp = 1;
+ rsurface.frameblend[1].frame = 0;
+ rsurface.frameblend[1].lerp = 0;
+ rsurface.frameblend[2].frame = 0;
+ rsurface.frameblend[2].lerp = 0;
+ rsurface.frameblend[3].frame = 0;
+ rsurface.frameblend[3].lerp = 0;
+ rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
+ rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
+ rsurface.modelsvector3f = model->surfmesh.data_svector3f;
+ rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
+ rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
+ rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
+ rsurface.modelnormal3f = model->surfmesh.data_normal3f;
+ rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
+ rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
+ rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
+ rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
+ rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
+ rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
+ rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
+ rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
+ rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
+ rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
+ rsurface.modelelement3i = model->surfmesh.data_element3i;
+ rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
+ rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
+ rsurface.modelnum_vertices = model->surfmesh.num_vertices;
+ rsurface.modelnum_triangles = model->surfmesh.num_triangles;
+ rsurface.modelsurfaces = model->data_surfaces;
+ rsurface.generatedvertex = false;
+ rsurface.vertex3f = rsurface.modelvertex3f;
+ rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
+ rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
+ rsurface.svector3f = rsurface.modelsvector3f;
+ rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
+ rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
+ rsurface.tvector3f = rsurface.modeltvector3f;
+ rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
+ rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
+ rsurface.normal3f = rsurface.modelnormal3f;
+ rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
+ rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
+ rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
+}
+
+void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents)
+{
+ model_t *model = ent->model;
+ RSurf_CleanUp();
+ if (rsurface.array_size < model->surfmesh.num_vertices)
+ R_Mesh_ResizeArrays(model->surfmesh.num_vertices);
+ rsurface.matrix = ent->matrix;
+ rsurface.inversematrix = ent->inversematrix;
+ R_Mesh_Matrix(&rsurface.matrix);
+ Matrix4x4_Transform(&rsurface.inversematrix, r_view.origin, rsurface.modelorg);
+ VectorCopy(ent->modellight_ambient, rsurface.modellight_ambient);
+ VectorCopy(ent->modellight_diffuse, rsurface.modellight_diffuse);
+ VectorCopy(ent->modellight_lightdir, rsurface.modellight_lightdir);
+ VectorCopy(ent->colormap_pantscolor, rsurface.colormap_pantscolor);
+ VectorCopy(ent->colormap_shirtcolor, rsurface.colormap_shirtcolor);
+ rsurface.frameblend[0] = ent->frameblend[0];
+ rsurface.frameblend[1] = ent->frameblend[1];
+ rsurface.frameblend[2] = ent->frameblend[2];
+ rsurface.frameblend[3] = ent->frameblend[3];
+ if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0))
+ {
+ if (wanttangents)
+ {
+ rsurface.modelvertex3f = rsurface.array_modelvertex3f;
+ rsurface.modelsvector3f = rsurface.array_modelsvector3f;
+ rsurface.modeltvector3f = rsurface.array_modeltvector3f;
+ rsurface.modelnormal3f = rsurface.array_modelnormal3f;
+ Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f);
+ }
+ else if (wantnormals)
+ {
+ rsurface.modelvertex3f = rsurface.array_modelvertex3f;
+ rsurface.modelsvector3f = NULL;
+ rsurface.modeltvector3f = NULL;
+ rsurface.modelnormal3f = rsurface.array_modelnormal3f;
+ Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL);
+ }
+ else
+ {
+ rsurface.modelvertex3f = rsurface.array_modelvertex3f;
+ rsurface.modelsvector3f = NULL;
+ rsurface.modeltvector3f = NULL;
+ rsurface.modelnormal3f = NULL;
+ Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL);
+ }
+ rsurface.modelvertex3f_bufferobject = 0;
+ rsurface.modelvertex3f_bufferoffset = 0;
+ rsurface.modelsvector3f_bufferobject = 0;
+ rsurface.modelsvector3f_bufferoffset = 0;
+ rsurface.modeltvector3f_bufferobject = 0;
+ rsurface.modeltvector3f_bufferoffset = 0;
+ rsurface.modelnormal3f_bufferobject = 0;
+ rsurface.modelnormal3f_bufferoffset = 0;
+ rsurface.generatedvertex = true;
+ }
+ else
+ {
+ rsurface.modelvertex3f = model->surfmesh.data_vertex3f;
+ rsurface.modelvertex3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modelvertex3f_bufferoffset = model->surfmesh.vbooffset_vertex3f;
+ rsurface.modelsvector3f = model->surfmesh.data_svector3f;
+ rsurface.modelsvector3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modelsvector3f_bufferoffset = model->surfmesh.vbooffset_svector3f;
+ rsurface.modeltvector3f = model->surfmesh.data_tvector3f;
+ rsurface.modeltvector3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modeltvector3f_bufferoffset = model->surfmesh.vbooffset_tvector3f;
+ rsurface.modelnormal3f = model->surfmesh.data_normal3f;
+ rsurface.modelnormal3f_bufferobject = model->surfmesh.vbo;
+ rsurface.modelnormal3f_bufferoffset = model->surfmesh.vbooffset_normal3f;
+ rsurface.generatedvertex = false;
+ }
+ rsurface.modellightmapcolor4f = model->surfmesh.data_lightmapcolor4f;
+ rsurface.modellightmapcolor4f_bufferobject = model->surfmesh.vbo;
+ rsurface.modellightmapcolor4f_bufferoffset = model->surfmesh.vbooffset_lightmapcolor4f;
+ rsurface.modeltexcoordtexture2f = model->surfmesh.data_texcoordtexture2f;
+ rsurface.modeltexcoordtexture2f_bufferobject = model->surfmesh.vbo;
+ rsurface.modeltexcoordtexture2f_bufferoffset = model->surfmesh.vbooffset_texcoordtexture2f;
+ rsurface.modeltexcoordlightmap2f = model->surfmesh.data_texcoordlightmap2f;
+ rsurface.modeltexcoordlightmap2f_bufferobject = model->surfmesh.vbo;
+ rsurface.modeltexcoordlightmap2f_bufferoffset = model->surfmesh.vbooffset_texcoordlightmap2f;
+ rsurface.modelelement3i = model->surfmesh.data_element3i;
+ rsurface.modelelement3i_bufferobject = model->surfmesh.ebo;
+ rsurface.modellightmapoffsets = model->surfmesh.data_lightmapoffsets;
+ rsurface.modelnum_vertices = model->surfmesh.num_vertices;
+ rsurface.modelnum_triangles = model->surfmesh.num_triangles;
+ rsurface.modelsurfaces = model->data_surfaces;
+ rsurface.vertex3f = rsurface.modelvertex3f;
+ rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
+ rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
+ rsurface.svector3f = rsurface.modelsvector3f;
+ rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
+ rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
+ rsurface.tvector3f = rsurface.modeltvector3f;
+ rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
+ rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
+ rsurface.normal3f = rsurface.modelnormal3f;
+ rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
+ rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
+ rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
+}
+
+static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}};
+void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ int deformindex;
+ int texturesurfaceindex;
+ int i, j;
+ float amplitude;
+ float animpos;
+ float scale;
+ const float *v1, *in_tc;
+ float *out_tc;
+ float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3];
+ float waveparms[4];
+ q3shaderinfo_deform_t *deform;
+ // if vertices are dynamic (animated models), generate them into the temporary rsurface.array_model* arrays and point rsurface.model* at them instead of the static data from the model itself
+ if (rsurface.generatedvertex)
+ {
+ if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT)
+ generatenormals = true;
+ for (i = 0;i < Q3MAXDEFORMS;i++)
+ {
+ if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE)
+ {
+ generatetangents = true;
+ generatenormals = true;
+ }
+ if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE)
+ generatenormals = true;
+ }
+ if (generatenormals && !rsurface.modelnormal3f)
+ {
+ rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f;
+ rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0;
+ rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0;
+ Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer);
+ }
+ if (generatetangents && !rsurface.modelsvector3f)
+ {
+ rsurface.svector3f = rsurface.modelsvector3f = rsurface.array_modelsvector3f;
+ rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject = 0;
+ rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset = 0;
+ rsurface.tvector3f = rsurface.modeltvector3f = rsurface.array_modeltvector3f;
+ rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject = 0;
+ rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset = 0;
+ Mod_BuildTextureVectorsFromNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modeltexcoordtexture2f, rsurface.modelnormal3f, rsurface.modelelement3i, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f, r_smoothnormals_areaweighting.integer);
+ }
+ }
+ rsurface.vertex3f = rsurface.modelvertex3f;
+ rsurface.vertex3f_bufferobject = rsurface.modelvertex3f_bufferobject;
+ rsurface.vertex3f_bufferoffset = rsurface.modelvertex3f_bufferoffset;
+ rsurface.svector3f = rsurface.modelsvector3f;
+ rsurface.svector3f_bufferobject = rsurface.modelsvector3f_bufferobject;
+ rsurface.svector3f_bufferoffset = rsurface.modelsvector3f_bufferoffset;
+ rsurface.tvector3f = rsurface.modeltvector3f;
+ rsurface.tvector3f_bufferobject = rsurface.modeltvector3f_bufferobject;
+ rsurface.tvector3f_bufferoffset = rsurface.modeltvector3f_bufferoffset;
+ rsurface.normal3f = rsurface.modelnormal3f;
+ rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject;
+ rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset;
+ // if vertices are deformed (sprite flares and things in maps, possibly
+ // water waves, bulges and other deformations), generate them into
+ // rsurface.deform* arrays from whatever the rsurface.* arrays point to
+ // (may be static model data or generated data for an animated model, or
+ // the previous deform pass)
+ for (deformindex = 0, deform = rsurface.texture->deforms;deformindex < Q3MAXDEFORMS && deform->deform;deformindex++, deform++)
+ {
+ switch (deform->deform)
+ {
+ default:
+ case Q3DEFORM_PROJECTIONSHADOW:
+ case Q3DEFORM_TEXT0:
+ case Q3DEFORM_TEXT1:
+ case Q3DEFORM_TEXT2:
+ case Q3DEFORM_TEXT3:
+ case Q3DEFORM_TEXT4:
+ case Q3DEFORM_TEXT5:
+ case Q3DEFORM_TEXT6:
+ case Q3DEFORM_TEXT7:
+ case Q3DEFORM_NONE:
+ break;
+ case Q3DEFORM_AUTOSPRITE:
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
+ VectorNormalize(newforward);
+ VectorNormalize(newright);
+ VectorNormalize(newup);
+ // make deformed versions of only the model vertices used by the specified surfaces
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ // a single autosprite surface can contain multiple sprites...
+ for (j = 0;j < surface->num_vertices - 3;j += 4)
+ {
+ VectorClear(center);
+ for (i = 0;i < 4;i++)
+ VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
+ VectorScale(center, 0.25f, center);
+ VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, forward);
+ VectorCopy((rsurface.svector3f + 3 * surface->num_firstvertex) + j*3, right);
+ VectorCopy((rsurface.tvector3f + 3 * surface->num_firstvertex) + j*3, up);
+ for (i = 0;i < 4;i++)
+ {
+ VectorSubtract((rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i)*3, center, v);
+ VectorMAMAMAM(1, center, DotProduct(forward, v), newforward, DotProduct(right, v), newright, DotProduct(up, v), newup, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
+ }
+ }
+ Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
+ Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
+ }
+ rsurface.vertex3f = rsurface.array_deformedvertex3f;
+ rsurface.vertex3f_bufferobject = 0;
+ rsurface.vertex3f_bufferoffset = 0;
+ rsurface.svector3f = rsurface.array_deformedsvector3f;
+ rsurface.svector3f_bufferobject = 0;
+ rsurface.svector3f_bufferoffset = 0;
+ rsurface.tvector3f = rsurface.array_deformedtvector3f;
+ rsurface.tvector3f_bufferobject = 0;
+ rsurface.tvector3f_bufferoffset = 0;
+ rsurface.normal3f = rsurface.array_deformednormal3f;
+ rsurface.normal3f_bufferobject = 0;
+ rsurface.normal3f_bufferoffset = 0;
+ break;
+ case Q3DEFORM_AUTOSPRITE2:
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward);
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright);
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup);
+ VectorNormalize(newforward);
+ VectorNormalize(newright);
+ VectorNormalize(newup);
+ // make deformed versions of only the model vertices used by the specified surfaces
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ const float *v1, *v2;
+ vec3_t start, end;
+ float f, l;
+ struct
+ {
+ float length2;
+ const float *v1;
+ const float *v2;
+ }
+ shortest[2];
+ memset(shortest, 0, sizeof(shortest));
+ // a single autosprite surface can contain multiple sprites...
+ for (j = 0;j < surface->num_vertices - 3;j += 4)
+ {
+ VectorClear(center);
+ for (i = 0;i < 4;i++)
+ VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center);
+ VectorScale(center, 0.25f, center);
+ // find the two shortest edges, then use them to define the
+ // axis vectors for rotating around the central axis
+ for (i = 0;i < 6;i++)
+ {
+ v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]);
+ v2 = rsurface.vertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]);
+#if 0
+ Debug_PolygonBegin(NULL, 0, false, 0);
+ Debug_PolygonVertex(v1[0], v1[1], v1[2], 0, 0, 1, 0, 0, 1);
+ Debug_PolygonVertex((v1[0] + v2[0]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, (v1[1] + v2[1]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1], (v1[2] + v2[2]) * 0.5f + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2], 0, 0, 1, 1, 0, 1);
+ Debug_PolygonVertex(v2[0], v2[1], v2[2], 0, 0, 1, 0, 0, 1);
+ Debug_PolygonEnd();
+#endif
+ l = VectorDistance2(v1, v2);
+ // this length bias tries to make sense of square polygons, assuming they are meant to be upright
+ if (v1[2] != v2[2])
+ l += (1.0f / 1024.0f);
+ if (shortest[0].length2 > l || i == 0)
+ {
+ shortest[1] = shortest[0];
+ shortest[0].length2 = l;
+ shortest[0].v1 = v1;
+ shortest[0].v2 = v2;
+ }
+ else if (shortest[1].length2 > l || i == 1)
+ {
+ shortest[1].length2 = l;
+ shortest[1].v1 = v1;
+ shortest[1].v2 = v2;
+ }
+ }
+ VectorLerp(shortest[0].v1, 0.5f, shortest[0].v2, start);
+ VectorLerp(shortest[1].v1, 0.5f, shortest[1].v2, end);
+#if 0
+ Debug_PolygonBegin(NULL, 0, false, 0);
+ Debug_PolygonVertex(start[0], start[1], start[2], 0, 0, 1, 1, 0, 1);
+ Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 4, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 4, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 4, 0, 0, 0, 1, 0, 1);
+ Debug_PolygonVertex(end[0], end[1], end[2], 0, 0, 0, 1, 1, 1);
+ Debug_PolygonEnd();
+#endif
+ // this calculates the right vector from the shortest edge
+ // and the up vector from the edge midpoints
+ VectorSubtract(shortest[0].v1, shortest[0].v2, right);
+ VectorNormalize(right);
+ VectorSubtract(end, start, up);
+ VectorNormalize(up);
+ // calculate a forward vector to use instead of the original plane normal (this is how we get a new right vector)
+ //VectorSubtract(rsurface.modelorg, center, forward);
+ Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward);
+ VectorNegate(forward, forward);
+ VectorReflect(forward, 0, up, forward);
+ VectorNormalize(forward);
+ CrossProduct(up, forward, newright);
+ VectorNormalize(newright);
+#if 0
+ Debug_PolygonBegin(NULL, 0, false, 0);
+ Debug_PolygonVertex(center[0] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+0] * 8, center[1] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+1] * 8, center[2] + rsurface.normal3f[3 * (surface->num_firstvertex + j)+2] * 8, 0, 0, 1, 0, 0, 1);
+ Debug_PolygonVertex(center[0] + right[0] * 8, center[1] + right[1] * 8, center[2] + right[2] * 8, 0, 0, 0, 1, 0, 1);
+ Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
+ Debug_PolygonEnd();
+#endif
+#if 0
+ Debug_PolygonBegin(NULL, 0, false, 0);
+ Debug_PolygonVertex(center[0] + forward [0] * 8, center[1] + forward [1] * 8, center[2] + forward [2] * 8, 0, 0, 1, 0, 0, 1);
+ Debug_PolygonVertex(center[0] + newright[0] * 8, center[1] + newright[1] * 8, center[2] + newright[2] * 8, 0, 0, 0, 1, 0, 1);
+ Debug_PolygonVertex(center[0] + up [0] * 8, center[1] + up [1] * 8, center[2] + up [2] * 8, 0, 0, 0, 0, 1, 1);
+ Debug_PolygonEnd();
+#endif
+ // rotate the quad around the up axis vector, this is made
+ // especially easy by the fact we know the quad is flat,
+ // so we only have to subtract the center position and
+ // measure distance along the right vector, and then
+ // multiply that by the newright vector and add back the
+ // center position
+ // we also need to subtract the old position to undo the
+ // displacement from the center, which we do with a
+ // DotProduct, the subtraction/addition of center is also
+ // optimized into DotProducts here
+ l = DotProduct(right, center);
+ for (i = 0;i < 4;i++)
+ {
+ v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i);
+ f = DotProduct(right, v1) - l;
+ VectorMAMAM(1, v1, -f, right, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3);
+ }
+ }
+ Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer);
+ Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
+ }
+ rsurface.vertex3f = rsurface.array_deformedvertex3f;
+ rsurface.vertex3f_bufferobject = 0;
+ rsurface.vertex3f_bufferoffset = 0;
+ rsurface.svector3f = rsurface.array_deformedsvector3f;
+ rsurface.svector3f_bufferobject = 0;
+ rsurface.svector3f_bufferoffset = 0;
+ rsurface.tvector3f = rsurface.array_deformedtvector3f;
+ rsurface.tvector3f_bufferobject = 0;
+ rsurface.tvector3f_bufferoffset = 0;
+ rsurface.normal3f = rsurface.array_deformednormal3f;
+ rsurface.normal3f_bufferobject = 0;
+ rsurface.normal3f_bufferoffset = 0;
+ break;
+ case Q3DEFORM_NORMAL:
+ // deform the normals to make reflections wavey
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0;j < surface->num_vertices;j++)
+ {
+ float vertex[3];
+ float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3;
+ VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex);
+ VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal);
+ normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
+ normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
+ normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]);
+ VectorNormalize(normal);
+ }
+ Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer);
+ }
+ rsurface.svector3f = rsurface.array_deformedsvector3f;
+ rsurface.svector3f_bufferobject = 0;
+ rsurface.svector3f_bufferoffset = 0;
+ rsurface.tvector3f = rsurface.array_deformedtvector3f;
+ rsurface.tvector3f_bufferobject = 0;
+ rsurface.tvector3f_bufferoffset = 0;
+ rsurface.normal3f = rsurface.array_deformednormal3f;
+ rsurface.normal3f_bufferobject = 0;
+ rsurface.normal3f_bufferoffset = 0;
+ break;
+ case Q3DEFORM_WAVE:
+ // deform vertex array to make wavey water and flags and such
+ waveparms[0] = deform->waveparms[0];
+ waveparms[1] = deform->waveparms[1];
+ waveparms[2] = deform->waveparms[2];
+ waveparms[3] = deform->waveparms[3];
+ // this is how a divisor of vertex influence on deformation
+ animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f;
+ scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0;j < surface->num_vertices;j++)
+ {
+ float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3;
+ VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex);
+ // if the wavefunc depends on time, evaluate it per-vertex
+ if (waveparms[3])
+ {
+ waveparms[2] = deform->waveparms[2] + (vertex[0] + vertex[1] + vertex[2]) * animpos;
+ scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms);
+ }
+ VectorMA(vertex, scale, (rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, vertex);
+ }
+ }
+ rsurface.vertex3f = rsurface.array_deformedvertex3f;
+ rsurface.vertex3f_bufferobject = 0;
+ rsurface.vertex3f_bufferoffset = 0;
+ break;
+ case Q3DEFORM_BULGE:
+ // deform vertex array to make the surface have moving bulges
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0;j < surface->num_vertices;j++)
+ {
+ scale = sin((rsurface.modeltexcoordtexture2f[2 * (surface->num_firstvertex + j)] * deform->parms[0] + r_refdef.time * deform->parms[2])) * deform->parms[1];
+ VectorMA(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), scale, rsurface.normal3f + 3 * (surface->num_firstvertex + j), rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
+ }
+ }
+ rsurface.vertex3f = rsurface.array_deformedvertex3f;
+ rsurface.vertex3f_bufferobject = 0;
+ rsurface.vertex3f_bufferoffset = 0;
+ break;
+ case Q3DEFORM_MOVE:
+ // deform vertex array
+ scale = R_EvaluateQ3WaveFunc(deform->wavefunc, deform->waveparms);
+ VectorScale(deform->parms, scale, waveparms);
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0;j < surface->num_vertices;j++)
+ VectorAdd(rsurface.vertex3f + 3 * (surface->num_firstvertex + j), waveparms, rsurface.array_deformedvertex3f + 3 * (surface->num_firstvertex + j));
+ }
+ rsurface.vertex3f = rsurface.array_deformedvertex3f;
+ rsurface.vertex3f_bufferobject = 0;
+ rsurface.vertex3f_bufferoffset = 0;
+ break;
+ }
+ }
+ // generate texcoords based on the chosen texcoord source
+ switch(rsurface.texture->tcgen.tcgen)
+ {
+ default:
+ case Q3TCGEN_TEXTURE:
+ rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f;
+ rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordtexture2f_bufferobject;
+ rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordtexture2f_bufferoffset;
+ break;
+ case Q3TCGEN_LIGHTMAP:
+ rsurface.texcoordtexture2f = rsurface.modeltexcoordlightmap2f;
+ rsurface.texcoordtexture2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
+ rsurface.texcoordtexture2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
+ break;
+ case Q3TCGEN_VECTOR:
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, out_tc += 2)
+ {
+ out_tc[0] = DotProduct(v1, rsurface.texture->tcgen.parms);
+ out_tc[1] = DotProduct(v1, rsurface.texture->tcgen.parms + 3);
+ }
+ }
+ rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
+ rsurface.texcoordtexture2f_bufferobject = 0;
+ rsurface.texcoordtexture2f_bufferoffset = 0;
+ break;
+ case Q3TCGEN_ENVIRONMENT:
+ // make environment reflections using a spheremap
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ const float *vertex = rsurface.modelvertex3f + 3 * surface->num_firstvertex;
+ const float *normal = rsurface.modelnormal3f + 3 * surface->num_firstvertex;
+ float *out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;
+ for (j = 0;j < surface->num_vertices;j++, vertex += 3, normal += 3, out_tc += 2)
+ {
+ float l, d, eyedir[3];
+ VectorSubtract(rsurface.modelorg, vertex, eyedir);
+ l = 0.5f / VectorLength(eyedir);
+ d = DotProduct(normal, eyedir)*2;
+ out_tc[0] = 0.5f + (normal[1]*d - eyedir[1])*l;
+ out_tc[1] = 0.5f - (normal[2]*d - eyedir[2])*l;
+ }
+ }
+ rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
+ rsurface.texcoordtexture2f_bufferobject = 0;
+ rsurface.texcoordtexture2f_bufferoffset = 0;
+ break;
+ }
+ // the only tcmod that needs software vertex processing is turbulent, so
+ // check for it here and apply the changes if needed
+ // and we only support that as the first one
+ // (handling a mixture of turbulent and other tcmods would be problematic
+ // without punting it entirely to a software path)
+ if (rsurface.texture->tcmods[0].tcmod == Q3TCMOD_TURBULENT)
+ {
+ amplitude = rsurface.texture->tcmods[0].parms[1];
+ animpos = rsurface.texture->tcmods[0].parms[2] + r_refdef.time * rsurface.texture->tcmods[0].parms[3];
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0, v1 = rsurface.modelvertex3f + 3 * surface->num_firstvertex, in_tc = rsurface.texcoordtexture2f + 2 * surface->num_firstvertex, out_tc = rsurface.array_generatedtexcoordtexture2f + 2 * surface->num_firstvertex;j < surface->num_vertices;j++, v1 += 3, in_tc += 2, out_tc += 2)
+ {
+ out_tc[0] = in_tc[0] + amplitude * sin(((v1[0] + v1[2]) * 1.0 / 1024.0f + animpos) * M_PI * 2);
+ out_tc[1] = in_tc[1] + amplitude * sin(((v1[1] ) * 1.0 / 1024.0f + animpos) * M_PI * 2);
+ }
+ }
+ rsurface.texcoordtexture2f = rsurface.array_generatedtexcoordtexture2f;
+ rsurface.texcoordtexture2f_bufferobject = 0;
+ rsurface.texcoordtexture2f_bufferoffset = 0;
+ }
+ rsurface.texcoordlightmap2f = rsurface.modeltexcoordlightmap2f;
+ rsurface.texcoordlightmap2f_bufferobject = rsurface.modeltexcoordlightmap2f_bufferobject;
+ rsurface.texcoordlightmap2f_bufferoffset = rsurface.modeltexcoordlightmap2f_bufferoffset;
+ R_Mesh_VertexPointer(rsurface.vertex3f, rsurface.vertex3f_bufferobject, rsurface.vertex3f_bufferoffset);
+}
+
+void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ int i, j;
+ const msurface_t *surface = texturesurfacelist[0];
+ const msurface_t *surface2;
+ int firstvertex;
+ int endvertex;
+ int numvertices;
+ int numtriangles;
+ // TODO: lock all array ranges before render, rather than on each surface
+ if (texturenumsurfaces == 1)
+ {
+ GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
+ R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
+ }
+ else if (r_batchmode.integer == 2)
+ {
+ #define MAXBATCHTRIANGLES 4096
+ int batchtriangles = 0;
+ int batchelements[MAXBATCHTRIANGLES*3];
+ for (i = 0;i < texturenumsurfaces;i = j)
+ {
+ surface = texturesurfacelist[i];
+ j = i + 1;
+ if (surface->num_triangles > MAXBATCHTRIANGLES)
+ {
+ R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
+ continue;
+ }
+ memcpy(batchelements, rsurface.modelelement3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
+ batchtriangles = surface->num_triangles;
+ firstvertex = surface->num_firstvertex;
+ endvertex = surface->num_firstvertex + surface->num_vertices;
+ for (;j < texturenumsurfaces;j++)
+ {
+ surface2 = texturesurfacelist[j];
+ if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES)
+ break;
+ memcpy(batchelements + batchtriangles * 3, rsurface.modelelement3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3]));
+ batchtriangles += surface2->num_triangles;
+ firstvertex = min(firstvertex, surface2->num_firstvertex);
+ endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
+ }
+ surface2 = texturesurfacelist[j-1];
+ numvertices = endvertex - firstvertex;
+ R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
+ }
+ }
+ else if (r_batchmode.integer == 1)
+ {
+ for (i = 0;i < texturenumsurfaces;i = j)
+ {
+ surface = texturesurfacelist[i];
+ for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
+ if (texturesurfacelist[j] != surface2)
+ break;
+ surface2 = texturesurfacelist[j-1];
+ numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
+ numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
+ GL_LockArrays(surface->num_firstvertex, numvertices);
+ R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
+ }
+ }
+ else
+ {
+ for (i = 0;i < texturenumsurfaces;i++)
+ {
+ surface = texturesurfacelist[i];
+ GL_LockArrays(surface->num_firstvertex, surface->num_vertices);
+ R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle));
+ }
+ }
+}