X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_rmain.c;h=2883c1be92011cd594a6613395d2ef93cfd6ef7b;hp=bfb11c6037e314af74abfd7093272b13f6d6a7ff;hb=9b45c4242e6f64c354ab7d55366a2cecbfd86a10;hpb=ce7af50b2021e374ca73c8678dc7e320d42df2d9 diff --git a/gl_rmain.c b/gl_rmain.c index bfb11c60..2883c1be 100644 --- a/gl_rmain.c +++ b/gl_rmain.c @@ -61,6 +61,8 @@ cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1", "enables glowing pixels cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0", "casts fake stencil shadows from models onto the world (rtlights are unaffected by this)"}; cvar_t r_shadows_throwdistance = {CVAR_SAVE, "r_shadows_throwdistance", "500", "how far to cast shadows from models"}; cvar_t r_q1bsp_skymasking = {0, "r_q1bsp_skymasking", "1", "allows sky polygons in quake1 maps to obscure other geometry"}; +cvar_t r_polygonoffset_submodel_factor = {0, "r_polygonoffset_submodel_factor", "0", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"}; +cvar_t r_polygonoffset_submodel_offset = {0, "r_polygonoffset_submodel_offset", "2", "biases depth values of world submodels such as doors, to prevent z-fighting artifacts in Quake maps"}; cvar_t gl_fogenable = {0, "gl_fogenable", "0", "nehahra fog enable (for Nehahra compatibility only)"}; cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25", "nehahra fog density (recommend values below 0.1) (for Nehahra compatibility only)"}; @@ -77,6 +79,7 @@ cvar_t r_glsl_offsetmapping = {CVAR_SAVE, "r_glsl_offsetmapping", "0", "offset m cvar_t r_glsl_offsetmapping_reliefmapping = {CVAR_SAVE, "r_glsl_offsetmapping_reliefmapping", "0", "relief mapping effect (higher quality)"}; cvar_t r_glsl_offsetmapping_scale = {CVAR_SAVE, "r_glsl_offsetmapping_scale", "0.04", "how deep the offset mapping effect is"}; cvar_t r_glsl_deluxemapping = {CVAR_SAVE, "r_glsl_deluxemapping", "1", "use per pixel lighting on deluxemap-compiled q3bsp maps (or a value of 2 forces deluxemap shading even without deluxemaps)"}; +cvar_t r_glsl_contrastboost = {CVAR_SAVE, "r_glsl_contrastboost", "1", "by how much to multiply the contrast in dark areas (1 is no change)"}; cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1", "enables animation smoothing on sprites (requires r_lerpmodels 1)"}; cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1", "enables animation smoothing on models"}; @@ -104,6 +107,8 @@ cvar_t gl_lightmaps = {0, "gl_lightmaps", "0", "draws only lightmaps, no texture cvar_t r_test = {0, "r_test", "0", "internal development use only, leave it alone (usually does nothing anyway)"}; cvar_t r_batchmode = {0, "r_batchmode", "1", "selects method of rendering multiple surfaces with one driver call (values are 0, 1, 2, etc...)"}; +extern qboolean v_flipped_state; + typedef struct r_glsl_bloomshader_s { int program; @@ -213,7 +218,7 @@ float FogPoint_World(const vec3_t p) float FogPoint_Model(const vec3_t p) { - int fogmasktableindex = (int)(VectorDistance((p), rsurface_modelorg) * r_refdef.fogmasktabledistmultiplier); + int fogmasktableindex = (int)(VectorDistance((p), rsurface.modelorg) * r_refdef.fogmasktabledistmultiplier); return r_refdef.fogmasktable[min(fogmasktableindex, FOGMASKTABLEWIDTH - 1)]; } @@ -483,6 +488,9 @@ static const char *builtinshaderstring = "\n" "uniform myhalf GlowScale;\n" "uniform myhalf SceneBrightness;\n" +"#ifdef USECONTRASTBOOST\n" +"uniform myhalf ContrastBoostCoeff;\n" +"#endif\n" "\n" "uniform float OffsetMapping_Scale;\n" "uniform float OffsetMapping_Bias;\n" @@ -647,7 +655,11 @@ static const char *builtinshaderstring = " color.rgb = mix(FogColor, color.rgb, myhalf(texture2D(Texture_FogMask, myhvec2(length(EyeVectorModelSpace)*FogRangeRecip, 0.0))));\n" "#endif\n" "\n" +"#ifdef USECONTRASTBOOST\n" +" color.rgb = color.rgb * SceneBrightness / (ContrastBoostCoeff * color.rgb + myhvec3(1, 1, 1));\n" +"#else\n" " color.rgb *= SceneBrightness;\n" +"#endif\n" "\n" " gl_FragColor = vec4(color);\n" "}\n" @@ -666,6 +678,7 @@ const char *permutationinfo[][2] = {"#define USEFOG\n", " fog"}, {"#define USECOLORMAPPING\n", " colormapping"}, {"#define USEDIFFUSE\n", " diffuse"}, + {"#define USECONTRASTBOOST\n", " contrastboost"}, {"#define USESPECULAR\n", " specular"}, {"#define USECUBEFILTER\n", " cubefilter"}, {"#define USEOFFSETMAPPING\n", " offsetmapping"}, @@ -777,6 +790,7 @@ void R_GLSL_CompilePermutation(const char *filename, int permutation) p->loc_DiffuseColor = qglGetUniformLocationARB(p->program, "DiffuseColor"); p->loc_SpecularColor = qglGetUniformLocationARB(p->program, "SpecularColor"); p->loc_LightDir = qglGetUniformLocationARB(p->program, "LightDir"); + p->loc_ContrastBoostCoeff = qglGetUniformLocationARB(p->program, "ContrastBoostCoeff"); // initialize the samplers to refer to the texture units we use if (p->loc_Texture_Normal >= 0) qglUniform1iARB(p->loc_Texture_Normal, 0); if (p->loc_Texture_Color >= 0) qglUniform1iARB(p->loc_Texture_Color, 1); @@ -820,12 +834,12 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl unsigned int permutation = 0; r_glsl_permutation = NULL; // TODO: implement geometry-shader based shadow volumes someday - if (r_shadow_rtlight) + if (rsurface.rtlight) { // light source shaderfilename = "glsl/default.glsl"; permutation = SHADERPERMUTATION_MODE_LIGHTSOURCE | SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER; - if (r_shadow_rtlight->currentcubemap != r_texture_whitecube) + if (rsurface.rtlight->currentcubemap != r_texture_whitecube) permutation |= SHADERPERMUTATION_CUBEFILTER; if (diffusescale > 0) permutation |= SHADERPERMUTATION_DIFFUSE; @@ -833,7 +847,7 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl permutation |= SHADERPERMUTATION_SPECULAR | SHADERPERMUTATION_DIFFUSE; if (r_refdef.fogenabled) permutation |= SHADERPERMUTATION_FOG; - if (rsurface_texture->colormapping) + if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; if (r_glsl_offsetmapping.integer) { @@ -841,17 +855,19 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING; } + if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0) + permutation |= SHADERPERMUTATION_CONTRASTBOOST; } - else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) + else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) { // bright unshaded geometry shaderfilename = "glsl/default.glsl"; permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER; - if (rsurface_texture->currentskinframe->glow) + if (rsurface.texture->currentskinframe->glow) permutation |= SHADERPERMUTATION_GLOW; if (r_refdef.fogenabled) permutation |= SHADERPERMUTATION_FOG; - if (rsurface_texture->colormapping) + if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; if (r_glsl_offsetmapping.integer) { @@ -859,6 +875,8 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING; } + if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0) + permutation |= SHADERPERMUTATION_CONTRASTBOOST; } else if (modellighting) { @@ -866,13 +884,13 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl shaderfilename = "glsl/default.glsl"; permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER; permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTION; - if (rsurface_texture->currentskinframe->glow) + if (rsurface.texture->currentskinframe->glow) permutation |= SHADERPERMUTATION_GLOW; if (specularscale > 0) permutation |= SHADERPERMUTATION_SPECULAR; if (r_refdef.fogenabled) permutation |= SHADERPERMUTATION_FOG; - if (rsurface_texture->colormapping) + if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; if (r_glsl_offsetmapping.integer) { @@ -880,16 +898,18 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING; } + if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0) + permutation |= SHADERPERMUTATION_CONTRASTBOOST; } else { // lightmapped wall shaderfilename = "glsl/default.glsl"; permutation = SHADERPERMUTATION_USES_VERTEXSHADER | SHADERPERMUTATION_USES_FRAGMENTSHADER; - if (r_glsl_deluxemapping.integer >= 1 && rsurface_uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping) + if (r_glsl_deluxemapping.integer >= 1 && rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping) { // deluxemapping (light direction texture) - if (rsurface_uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace) + if (rsurface.uselightmaptexture && r_refdef.worldmodel && r_refdef.worldmodel->brushq3.deluxemapping && r_refdef.worldmodel->brushq3.deluxemapping_modelspace) permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_MODELSPACE; else permutation |= SHADERPERMUTATION_MODE_LIGHTDIRECTIONMAP_TANGENTSPACE; @@ -908,11 +928,11 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl // ordinary lightmapping permutation |= 0; } - if (rsurface_texture->currentskinframe->glow) + if (rsurface.texture->currentskinframe->glow) permutation |= SHADERPERMUTATION_GLOW; if (r_refdef.fogenabled) permutation |= SHADERPERMUTATION_FOG; - if (rsurface_texture->colormapping) + if (rsurface.texture->colormapping) permutation |= SHADERPERMUTATION_COLORMAPPING; if (r_glsl_offsetmapping.integer) { @@ -920,6 +940,8 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl if (r_glsl_offsetmapping_reliefmapping.integer) permutation |= SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING; } + if(r_glsl_contrastboost.value > 1 || r_glsl_contrastboost.value < 0) + permutation |= SHADERPERMUTATION_CONTRASTBOOST; } if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program) { @@ -929,14 +951,14 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl { // remove features until we find a valid permutation unsigned int i; - for (i = SHADERPERMUTATION_MASK;;i>>=1) + for (i = (SHADERPERMUTATION_MAX >> 1);;i>>=1) { if (!i) - return 0; // utterly failed + return 0; // no bit left to clear // reduce i more quickly whenever it would not remove any bits - if (permutation < i) + if (!(permutation & i)) continue; - permutation &= i; + permutation &= ~i; if (!r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].compiled) R_GLSL_CompilePermutation(shaderfilename, permutation); if (r_glsl_permutations[permutation & SHADERPERMUTATION_MASK].program) @@ -947,11 +969,11 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl r_glsl_permutation = r_glsl_permutations + (permutation & SHADERPERMUTATION_MASK); CHECKGLERROR qglUseProgramObjectARB(r_glsl_permutation->program);CHECKGLERROR - R_Mesh_TexMatrix(0, &rsurface_texture->currenttexmatrix); + R_Mesh_TexMatrix(0, &rsurface.texture->currenttexmatrix); if (permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) { - if (r_glsl_permutation->loc_Texture_Cube >= 0 && r_shadow_rtlight) R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap)); - if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, r_shadow_entitylightorigin[0], r_shadow_entitylightorigin[1], r_shadow_entitylightorigin[2]); + if (r_glsl_permutation->loc_Texture_Cube >= 0 && rsurface.rtlight) R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap)); + if (r_glsl_permutation->loc_LightPosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightPosition, rsurface.entitylightorigin[0], rsurface.entitylightorigin[1], rsurface.entitylightorigin[2]); if (permutation & SHADERPERMUTATION_DIFFUSE) { if (r_glsl_permutation->loc_LightColor >= 0) qglUniform3fARB(r_glsl_permutation->loc_LightColor, lightcolorbase[0], lightcolorbase[1], lightcolorbase[2]); @@ -971,13 +993,13 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl else if (permutation & SHADERPERMUTATION_MODE_LIGHTDIRECTION) { if (r_glsl_permutation->loc_AmbientColor >= 0) - qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface_entity->modellight_ambient[0] * ambientscale, rsurface_entity->modellight_ambient[1] * ambientscale, rsurface_entity->modellight_ambient[2] * ambientscale); + qglUniform3fARB(r_glsl_permutation->loc_AmbientColor, rsurface.modellight_ambient[0] * ambientscale, rsurface.modellight_ambient[1] * ambientscale, rsurface.modellight_ambient[2] * ambientscale); if (r_glsl_permutation->loc_DiffuseColor >= 0) - qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface_entity->modellight_diffuse[0] * diffusescale, rsurface_entity->modellight_diffuse[1] * diffusescale, rsurface_entity->modellight_diffuse[2] * diffusescale); + qglUniform3fARB(r_glsl_permutation->loc_DiffuseColor, rsurface.modellight_diffuse[0] * diffusescale, rsurface.modellight_diffuse[1] * diffusescale, rsurface.modellight_diffuse[2] * diffusescale); if (r_glsl_permutation->loc_SpecularColor >= 0) - qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface_entity->modellight_diffuse[0] * specularscale, rsurface_entity->modellight_diffuse[1] * specularscale, rsurface_entity->modellight_diffuse[2] * specularscale); + qglUniform3fARB(r_glsl_permutation->loc_SpecularColor, rsurface.modellight_diffuse[0] * specularscale, rsurface.modellight_diffuse[1] * specularscale, rsurface.modellight_diffuse[2] * specularscale); if (r_glsl_permutation->loc_LightDir >= 0) - qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface_entity->modellight_lightdir[0], rsurface_entity->modellight_lightdir[1], rsurface_entity->modellight_lightdir[2]); + qglUniform3fARB(r_glsl_permutation->loc_LightDir, rsurface.modellight_lightdir[0], rsurface.modellight_lightdir[1], rsurface.modellight_lightdir[2]); } else { @@ -985,44 +1007,59 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl if (r_glsl_permutation->loc_DiffuseScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_DiffuseScale, r_refdef.lightmapintensity * 2.0f); if (r_glsl_permutation->loc_SpecularScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularScale, r_refdef.lightmapintensity * specularscale * 2.0f); } - if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(0, R_GetTexture(rsurface_texture->currentskinframe->nmap)); - if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(1, R_GetTexture(rsurface_texture->basetexture)); - if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(2, R_GetTexture(rsurface_texture->glosstexture)); - //if (r_glsl_permutation->loc_Texture_Cube >= 0 && permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) R_Mesh_TexBindCubeMap(3, R_GetTexture(r_shadow_rtlight->currentcubemap)); + if (r_glsl_permutation->loc_Texture_Normal >= 0) R_Mesh_TexBind(0, R_GetTexture(rsurface.texture->currentskinframe->nmap)); + if (r_glsl_permutation->loc_Texture_Color >= 0) R_Mesh_TexBind(1, R_GetTexture(rsurface.texture->basetexture)); + if (r_glsl_permutation->loc_Texture_Gloss >= 0) R_Mesh_TexBind(2, R_GetTexture(rsurface.texture->glosstexture)); + //if (r_glsl_permutation->loc_Texture_Cube >= 0 && permutation & SHADERPERMUTATION_MODE_LIGHTSOURCE) R_Mesh_TexBindCubeMap(3, R_GetTexture(rsurface.rtlight->currentcubemap)); if (r_glsl_permutation->loc_Texture_Attenuation >= 0) R_Mesh_TexBind(10, R_GetTexture(r_shadow_attenuationgradienttexture)); if (r_glsl_permutation->loc_Texture_FogMask >= 0) R_Mesh_TexBind(4, R_GetTexture(r_texture_fogattenuation)); - if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(5, R_GetTexture(rsurface_texture->currentskinframe->pants)); - if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface_texture->currentskinframe->shirt)); + if (r_glsl_permutation->loc_Texture_Pants >= 0) R_Mesh_TexBind(5, R_GetTexture(rsurface.texture->currentskinframe->pants)); + if (r_glsl_permutation->loc_Texture_Shirt >= 0) R_Mesh_TexBind(6, R_GetTexture(rsurface.texture->currentskinframe->shirt)); //if (r_glsl_permutation->loc_Texture_Lightmap >= 0) R_Mesh_TexBind(7, R_GetTexture(r_texture_white)); //if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap)); - if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(9, R_GetTexture(rsurface_texture->currentskinframe->glow)); + if (r_glsl_permutation->loc_Texture_Glow >= 0) R_Mesh_TexBind(9, R_GetTexture(rsurface.texture->currentskinframe->glow)); if (r_glsl_permutation->loc_GlowScale >= 0) qglUniform1fARB(r_glsl_permutation->loc_GlowScale, r_hdr_glowintensity.value); - if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale); + if (r_glsl_permutation->loc_ContrastBoostCoeff >= 0) + { + // The formula used is actually: + // color.rgb *= SceneBrightness; + // color.rgb *= ContrastBoost / ((ContrastBoost - 1) * color.rgb + 1); + // I simplify that to + // color.rgb *= [[SceneBrightness * ContrastBoost]]; + // color.rgb /= [[(ContrastBoost - 1) / ContrastBoost]] * color.rgb + 1; + // and Black: + // color.rgb = [[SceneBrightness * ContrastBoost]] / ([[(ContrastBoost - 1) * SceneBrightness]] + 1 / color.rgb); + // and do [[calculations]] here in the engine + qglUniform1fARB(r_glsl_permutation->loc_ContrastBoostCoeff, (r_glsl_contrastboost.value - 1) * r_view.colorscale); + if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale * r_glsl_contrastboost.value); + } + else + if (r_glsl_permutation->loc_SceneBrightness >= 0) qglUniform1fARB(r_glsl_permutation->loc_SceneBrightness, r_view.colorscale); if (r_glsl_permutation->loc_FogColor >= 0) { // additive passes are only darkened by fog, not tinted - if (r_shadow_rtlight || (rsurface_texture->currentmaterialflags & MATERIALFLAG_ADD)) + if (rsurface.rtlight || (rsurface.texture->currentmaterialflags & MATERIALFLAG_ADD)) qglUniform3fARB(r_glsl_permutation->loc_FogColor, 0, 0, 0); else qglUniform3fARB(r_glsl_permutation->loc_FogColor, r_refdef.fogcolor[0], r_refdef.fogcolor[1], r_refdef.fogcolor[2]); } - if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface_modelorg[0], rsurface_modelorg[1], rsurface_modelorg[2]); + if (r_glsl_permutation->loc_EyePosition >= 0) qglUniform3fARB(r_glsl_permutation->loc_EyePosition, rsurface.modelorg[0], rsurface.modelorg[1], rsurface.modelorg[2]); if (r_glsl_permutation->loc_Color_Pants >= 0) { - if (rsurface_texture->currentskinframe->pants) - qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface_entity->colormap_pantscolor[0], rsurface_entity->colormap_pantscolor[1], rsurface_entity->colormap_pantscolor[2]); + if (rsurface.texture->currentskinframe->pants) + qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, rsurface.colormap_pantscolor[0], rsurface.colormap_pantscolor[1], rsurface.colormap_pantscolor[2]); else qglUniform3fARB(r_glsl_permutation->loc_Color_Pants, 0, 0, 0); } if (r_glsl_permutation->loc_Color_Shirt >= 0) { - if (rsurface_texture->currentskinframe->shirt) - qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface_entity->colormap_shirtcolor[0], rsurface_entity->colormap_shirtcolor[1], rsurface_entity->colormap_shirtcolor[2]); + if (rsurface.texture->currentskinframe->shirt) + qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, rsurface.colormap_shirtcolor[0], rsurface.colormap_shirtcolor[1], rsurface.colormap_shirtcolor[2]); else qglUniform3fARB(r_glsl_permutation->loc_Color_Shirt, 0, 0, 0); } if (r_glsl_permutation->loc_FogRangeRecip >= 0) qglUniform1fARB(r_glsl_permutation->loc_FogRangeRecip, r_refdef.fograngerecip); - if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface_texture->specularpower); + if (r_glsl_permutation->loc_SpecularPower >= 0) qglUniform1fARB(r_glsl_permutation->loc_SpecularPower, rsurface.texture->specularpower); if (r_glsl_permutation->loc_OffsetMapping_Scale >= 0) qglUniform1fARB(r_glsl_permutation->loc_OffsetMapping_Scale, r_glsl_offsetmapping_scale.value); CHECKGLERROR return permutation; @@ -1491,6 +1528,8 @@ void GL_Main_Init(void) 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); @@ -1509,6 +1548,7 @@ void GL_Main_Init(void) 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); @@ -1887,34 +1927,48 @@ static void R_View_SetFrustum(void) - 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); - VectorNormalize(r_view.frustum[0].normal); - VectorNormalize(r_view.frustum[1].normal); - VectorNormalize(r_view.frustum[2].normal); - VectorNormalize(r_view.frustum[3].normal); - 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; + 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); + + // 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; + } + PlaneClassify(&r_view.frustum[0]); PlaneClassify(&r_view.frustum[1]); PlaneClassify(&r_view.frustum[2]); PlaneClassify(&r_view.frustum[3]); PlaneClassify(&r_view.frustum[4]); - // 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]); - // 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. @@ -1954,7 +2008,9 @@ void R_View_Update(void) void R_SetupView(const matrix4x4_t *matrix) { - if (r_refdef.rtworldshadows || r_refdef.rtdlightshadows) + 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); @@ -1985,7 +2041,7 @@ void R_ResetViewRendering2D(void) GL_DepthTest(false); R_Mesh_Matrix(&identitymatrix); R_Mesh_ResetTextureState(); - qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR + GL_PolygonOffset(0, 0); qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR qglDepthFunc(GL_LEQUAL);CHECKGLERROR qglDisable(GL_STENCIL_TEST);CHECKGLERROR @@ -2018,7 +2074,7 @@ void R_ResetViewRendering3D(void) GL_DepthTest(true); R_Mesh_Matrix(&identitymatrix); R_Mesh_ResetTextureState(); - qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR + GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); qglEnable(GL_POLYGON_OFFSET_FILL);CHECKGLERROR qglDepthFunc(GL_LEQUAL);CHECKGLERROR qglDisable(GL_STENCIL_TEST);CHECKGLERROR @@ -2453,15 +2509,17 @@ void R_UpdateVariables(void) 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_shadow_polygonfactor.value; - r_refdef.shadowpolygonoffset = r_refdef.polygonoffset + r_shadow_shadow_polygonoffset.value; + 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_refdef.rtworld ? r_shadow_realtime_world_dlightshadows.integer : r_shadow_realtime_dlight_shadows.integer) && gl_stencil; + 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) { @@ -2730,6 +2788,7 @@ void R_DrawBBoxMesh(vec3_t mins, vec3_t maxs, float cr, float cg, float cb, floa 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(); @@ -2866,6 +2925,7 @@ void R_DrawNoModel_TransparentCallback(const entity_render_t *ent, const rtlight 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 : GL_FRONT); // quake is backwards, this culls back faces R_Mesh_VertexPointer(nomodelvertex3f, 0, 0); @@ -2903,7 +2963,7 @@ 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, r_shadow_rtlight); + R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_view.origin : org, R_DrawNoModel_TransparentCallback, ent, 0, rsurface.rtlight); //else // R_DrawNoModelCallback(ent, 0); } @@ -2950,8 +3010,19 @@ void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_ R_Mesh_Matrix(&identitymatrix); GL_BlendFunc(blendfunc1, blendfunc2); + + if(v_flipped_state) + { + scalex1 = -scalex1; + scalex2 = -scalex2; + GL_CullFace(GL_BACK); + } + else + GL_CullFace(GL_FRONT); + 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; @@ -3124,10 +3195,46 @@ static void R_Texture_AddLayer(texture_t *t, qboolean depthmask, int blendfunc1, 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 { @@ -3148,7 +3255,7 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t) { // use an alternate animation if the entity's frame is not 0, // and only if the texture has an alternate animation - if (ent->frame != 0 && t->anim_total[1]) + 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]; @@ -3190,13 +3297,63 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t) t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE; if (ent->flags & RENDER_VIEWMODEL) t->currentmaterialflags |= MATERIALFLAG_SHORTDEPTHRANGE; - if (t->currentmaterialflags & MATERIALFLAG_WATER && r_waterscroll.value != 0) - t->currenttexmatrix = r_waterscrollmatrix; - else - t->currenttexmatrix = identitymatrix; 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_white; @@ -3220,6 +3377,18 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t) t->specularscale = r_shadow_gloss2intensity.value; } + t->currentpolygonfactor = r_refdef.polygonfactor; + t->currentpolygonoffset = r_refdef.polygonoffset; + // 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_refdef.polygonfactor + r_polygonoffset_submodel_factor.value; + t->currentpolygonoffset = r_refdef.polygonoffset + r_polygonoffset_submodel_offset.value; + } + + VectorClear(t->dlightcolor); t->currentnumlayers = 0; if (!(t->currentmaterialflags & MATERIALFLAG_NODRAW)) { @@ -3266,6 +3435,8 @@ void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t) 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 @@ -3319,298 +3490,629 @@ void R_UpdateAllTextureInfo(entity_render_t *ent) R_UpdateTextureInfo(ent, ent->model->data_textures + i); } -int rsurface_array_size = 0; -float *rsurface_array_modelvertex3f = NULL; -float *rsurface_array_modelsvector3f = NULL; -float *rsurface_array_modeltvector3f = NULL; -float *rsurface_array_modelnormal3f = NULL; -float *rsurface_array_deformedvertex3f = NULL; -float *rsurface_array_deformedsvector3f = NULL; -float *rsurface_array_deformedtvector3f = NULL; -float *rsurface_array_deformednormal3f = NULL; -float *rsurface_array_color4f = NULL; -float *rsurface_array_texcoord3f = NULL; +rsurfacestate_t rsurface; void R_Mesh_ResizeArrays(int newvertices) { float *base; - if (rsurface_array_size >= newvertices) + 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[31])); - 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; + 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; } -float *rsurface_modelvertex3f; -int rsurface_modelvertex3f_bufferobject; -size_t rsurface_modelvertex3f_bufferoffset; -float *rsurface_modelsvector3f; -int rsurface_modelsvector3f_bufferobject; -size_t rsurface_modelsvector3f_bufferoffset; -float *rsurface_modeltvector3f; -int rsurface_modeltvector3f_bufferobject; -size_t rsurface_modeltvector3f_bufferoffset; -float *rsurface_modelnormal3f; -int rsurface_modelnormal3f_bufferobject; -size_t rsurface_modelnormal3f_bufferoffset; -float *rsurface_vertex3f; -int rsurface_vertex3f_bufferobject; -size_t rsurface_vertex3f_bufferoffset; -float *rsurface_svector3f; -int rsurface_svector3f_bufferobject; -size_t rsurface_svector3f_bufferoffset; -float *rsurface_tvector3f; -int rsurface_tvector3f_bufferobject; -size_t rsurface_tvector3f_bufferoffset; -float *rsurface_normal3f; -int rsurface_normal3f_bufferobject; -size_t rsurface_normal3f_bufferoffset; -float *rsurface_lightmapcolor4f; -int rsurface_lightmapcolor4f_bufferobject; -size_t rsurface_lightmapcolor4f_bufferoffset; -vec3_t rsurface_modelorg; -qboolean rsurface_generatedvertex; -const entity_render_t *rsurface_entity; -const model_t *rsurface_model; -texture_t *rsurface_texture; -qboolean rsurface_uselightmaptexture; -rsurfmode_t rsurface_mode; -int rsurface_lightmode; // 0 = lightmap or fullbright, 1 = color array from q3bsp, 2 = vertex shaded model - void RSurf_CleanUp(void) { CHECKGLERROR - if (rsurface_mode == RSURFMODE_GLSL) + if (rsurface.mode == RSURFMODE_GLSL) { qglUseProgramObjectARB(0);CHECKGLERROR } GL_AlphaTest(false); - rsurface_mode = RSURFMODE_NONE; - rsurface_uselightmaptexture = false; - rsurface_texture = NULL; + rsurface.mode = RSURFMODE_NONE; + rsurface.uselightmaptexture = false; + rsurface.texture = NULL; } void RSurf_ActiveWorldEntity(void) { + model_t *model = r_refdef.worldmodel; RSurf_CleanUp(); - rsurface_entity = r_refdef.worldentity; - rsurface_model = r_refdef.worldmodel; - if (rsurface_array_size < rsurface_model->surfmesh.num_vertices) - R_Mesh_ResizeArrays(rsurface_model->surfmesh.num_vertices); + 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); - rsurface_modelvertex3f = rsurface_model->surfmesh.data_vertex3f; - rsurface_modelvertex3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modelvertex3f_bufferoffset = rsurface_model->surfmesh.vbooffset_vertex3f; - rsurface_modelsvector3f = rsurface_model->surfmesh.data_svector3f; - rsurface_modelsvector3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modelsvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_svector3f; - rsurface_modeltvector3f = rsurface_model->surfmesh.data_tvector3f; - rsurface_modeltvector3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modeltvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_tvector3f; - rsurface_modelnormal3f = rsurface_model->surfmesh.data_normal3f; - rsurface_modelnormal3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modelnormal3f_bufferoffset = rsurface_model->surfmesh.vbooffset_normal3f; - 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; + 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(); - rsurface_entity = ent; - rsurface_model = ent->model; - if (rsurface_array_size < rsurface_model->surfmesh.num_vertices) - R_Mesh_ResizeArrays(rsurface_model->surfmesh.num_vertices); - R_Mesh_Matrix(&ent->matrix); - Matrix4x4_Transform(&ent->inversematrix, r_view.origin, rsurface_modelorg); - if (rsurface_model->surfmesh.isanimated && (rsurface_entity->frameblend[0].lerp != 1 || rsurface_entity->frameblend[0].frame != 0)) + 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(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f); + 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(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, rsurface_array_modelnormal3f, NULL, NULL); + 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(rsurface_model, rsurface_entity->frameblend, rsurface_array_modelvertex3f, NULL, NULL, NULL); + 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; + 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 = rsurface_model->surfmesh.data_vertex3f; - rsurface_modelvertex3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modelvertex3f_bufferoffset = rsurface_model->surfmesh.vbooffset_vertex3f; - rsurface_modelsvector3f = rsurface_model->surfmesh.data_svector3f; - rsurface_modelsvector3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modelsvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_svector3f; - rsurface_modeltvector3f = rsurface_model->surfmesh.data_tvector3f; - rsurface_modeltvector3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modeltvector3f_bufferoffset = rsurface_model->surfmesh.vbooffset_tvector3f; - rsurface_modelnormal3f = rsurface_model->surfmesh.data_normal3f; - rsurface_modelnormal3f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_modelnormal3f_bufferoffset = rsurface_model->surfmesh.vbooffset_normal3f; - 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.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) { - // 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->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) - generatetangents = true; - if (generatetangents) + 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; - if (generatenormals && !rsurface_modelnormal3f) + 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_model->surfmesh.num_vertices, rsurface_model->surfmesh.num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i, rsurface_array_modelnormal3f, r_smoothnormals_areaweighting.integer); + 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) + 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_model->surfmesh.num_vertices, rsurface_model->surfmesh.num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_modelnormal3f, rsurface_model->surfmesh.data_element3i, rsurface_array_modelsvector3f, rsurface_array_modeltvector3f, r_smoothnormals_areaweighting.integer); + 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); } } - // 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_model* array pointers point to (may be static model data or generated data for an animated model) - if (rsurface_texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) - { - int texturesurfaceindex; - float center[3], forward[3], right[3], up[3], v[4][3]; - matrix4x4_t matrix1, imatrix1; - Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.forward, forward); - Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.right, right); - Matrix4x4_Transform(&rsurface_entity->inversematrix, r_view.up, up); - // make deformed versions of only the model vertices used by the specified surfaces - for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) + 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) { - int i, j; - const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - // a single autosprite surface can contain multiple sprites... - for (j = 0;j < surface->num_vertices - 3;j += 4) + 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++) { - VectorClear(center); - for (i = 0;i < 4;i++) - VectorAdd(center, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center); - VectorScale(center, 0.25f, center); - if (rsurface_texture->textureflags & Q3TEXTUREFLAG_AUTOSPRITE2) + const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; + const float *v1, *v2; + vec3_t start, end; + float f, l; + struct { - forward[0] = rsurface_modelorg[0] - center[0]; - forward[1] = rsurface_modelorg[1] - center[1]; - forward[2] = 0; + 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); - right[0] = forward[1]; - right[1] = -forward[0]; - right[2] = 0; - VectorSet(up, 0, 0, 1); + 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); } - // FIXME: calculate vectors from triangle edges instead of using texture vectors as an easy way out? - Matrix4x4_FromVectors(&matrix1, (rsurface_modelnormal3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modelsvector3f + 3 * surface->num_firstvertex) + j*3, (rsurface_modeltvector3f + 3 * surface->num_firstvertex) + j*3, center); - Matrix4x4_Invert_Simple(&imatrix1, &matrix1); - for (i = 0;i < 4;i++) - Matrix4x4_Transform(&imatrix1, (rsurface_modelvertex3f + 3 * surface->num_firstvertex) + (j+i)*3, v[i]); - for (i = 0;i < 4;i++) - VectorMAMAMAM(1, center, v[i][0], forward, v[i][1], right, v[i][2], up, rsurface_array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3); + 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); } - Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_element3i + surface->num_firsttriangle * 3, rsurface_array_deformednormal3f, r_smoothnormals_areaweighting.integer); - Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_modelvertex3f, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_array_deformednormal3f, rsurface_model->surfmesh.data_element3i + 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; } - 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; } - else - { - 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; - } - R_Mesh_VertexPointer(rsurface_vertex3f, rsurface_vertex3f_bufferobject, rsurface_vertex3f_bufferoffset); + // 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) @@ -3626,7 +4128,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel if (texturenumsurfaces == 1) { GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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) { @@ -3639,10 +4141,10 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel j = i + 1; if (surface->num_triangles > MAXBATCHTRIANGLES) { - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3])); + 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; @@ -3651,7 +4153,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel surface2 = texturesurfacelist[j]; if (batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES) break; - memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3])); + 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); @@ -3673,7 +4175,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel 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_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle)); } } else @@ -3682,7 +4184,7 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel { surface = texturesurfacelist[i]; GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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)); } } } @@ -3704,7 +4206,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa if (deluxemaptexunit >= 0) R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture)); GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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) { @@ -3720,10 +4222,10 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa j = i + 1; if (surface->num_triangles > MAXBATCHTRIANGLES) { - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3])); + 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; @@ -3732,7 +4234,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa surface2 = texturesurfacelist[j]; if (surface2->lightmaptexture != surface->lightmaptexture || batchtriangles + surface2->num_triangles > MAXBATCHTRIANGLES) break; - memcpy(batchelements + batchtriangles * 3, rsurface_model->surfmesh.data_element3i + 3 * surface2->num_firsttriangle, surface2->num_triangles * sizeof(int[3])); + 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); @@ -3745,7 +4247,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa else if (r_batchmode.integer == 1) { #if 0 - Con_Printf("%s batch sizes ignoring lightmap:", rsurface_texture->name); + Con_Printf("%s batch sizes ignoring lightmap:", rsurface.texture->name); for (i = 0;i < texturenumsurfaces;i = j) { surface = texturesurfacelist[i]; @@ -3755,7 +4257,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa Con_Printf(" %i", j - i); } Con_Printf("\n"); - Con_Printf("%s batch sizes honoring lightmap:", rsurface_texture->name); + Con_Printf("%s batch sizes honoring lightmap:", rsurface.texture->name); #endif for (i = 0;i < texturenumsurfaces;i = j) { @@ -3773,7 +4275,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa 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_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface.modelelement3i + 3 * surface->num_firsttriangle), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * surface->num_firsttriangle)); } #if 0 Con_Printf("\n"); @@ -3788,7 +4290,7 @@ static void RSurf_DrawBatch_WithLightmapSwitching(int texturenumsurfaces, msurfa if (deluxemaptexunit >= 0) R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture)); GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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)); } } } @@ -3806,7 +4308,7 @@ static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **te { float f = ((j + surface->num_firsttriangle) & 31) * (1.0f / 31.0f) * r_view.colorscale; GL_Color(f, f, f, 1); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, 1, (rsurface_model->surfmesh.data_element3i + 3 * (j + surface->num_firsttriangle)), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * (j + surface->num_firsttriangle))); + R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, 1, (rsurface.modelelement3i + 3 * (j + surface->num_firsttriangle)), rsurface.modelelement3i_bufferobject, (sizeof(int[3]) * (j + surface->num_firsttriangle))); } } } @@ -3818,7 +4320,7 @@ static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **te int k = (int)(((size_t)surface) / sizeof(msurface_t)); GL_Color((k & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 4) & 15) * (1.0f / 16.0f) * r_view.colorscale, ((k >> 8) & 15) * (1.0f / 16.0f) * r_view.colorscale, 1); GL_LockArrays(surface->num_firstvertex, surface->num_vertices); - R_Mesh_Draw(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle)); + 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)); } } } @@ -3829,13 +4331,13 @@ static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **t int i; float f; float *v, *c, *c2; - if (rsurface_lightmapcolor4f) + if (rsurface.lightmapcolor4f) { // generate color arrays for the surfaces in this list for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) { const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4) + for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4) { f = FogPoint_Model(v); c2[0] = c[0] * f; @@ -3850,7 +4352,7 @@ static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **t for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) { const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4) + for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4) { f = FogPoint_Model(v); c2[0] = f; @@ -3860,9 +4362,9 @@ static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **t } } } - rsurface_lightmapcolor4f = rsurface_array_color4f; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = rsurface.array_color4f; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; } static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a) @@ -3870,12 +4372,12 @@ static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t * int texturesurfaceindex; int i; float *c, *c2; - if (!rsurface_lightmapcolor4f) + if (!rsurface.lightmapcolor4f) return; for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) { const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - for (i = 0, c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4) + for (i = 0, c = (rsurface.lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4) { c2[0] = c[0] * r; c2[1] = c[1] * g; @@ -3883,20 +4385,20 @@ static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t * c2[3] = c[3] * a; } } - rsurface_lightmapcolor4f = rsurface_array_color4f; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = rsurface.array_color4f; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; } static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog) { // TODO: optimize - rsurface_lightmapcolor4f = NULL; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = NULL; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist); if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a); - R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset); + R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset); GL_Color(r, g, b, a); RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1); } @@ -3905,12 +4407,12 @@ static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **text { // TODO: optimize applyfog && applycolor case // just apply fog if necessary, and tint the fog color array if necessary - rsurface_lightmapcolor4f = NULL; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = NULL; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist); if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a); - R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset); + R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset); GL_Color(r, g, b, a); RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist); } @@ -3927,11 +4429,11 @@ static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) { const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4) + for (i = 0, c = rsurface.array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4) { if (surface->lightmapinfo->samples) { - const unsigned char *lm = surface->lightmapinfo->samples + (rsurface_model->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i]; + const unsigned char *lm = surface->lightmapinfo->samples + (rsurface.modellightmapoffsets + surface->num_firstvertex)[i]; float scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[0]] * (1.0f / 32768.0f); VectorScale(lm, scale, c); if (surface->lightmapinfo->styles[1] != 255) @@ -3959,19 +4461,19 @@ static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t c[3] = 1; } } - rsurface_lightmapcolor4f = rsurface_array_color4f; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = rsurface.array_color4f; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; } else { - rsurface_lightmapcolor4f = rsurface_model->surfmesh.data_lightmapcolor4f; - rsurface_lightmapcolor4f_bufferobject = rsurface_model->surfmesh.vbo; - rsurface_lightmapcolor4f_bufferoffset = rsurface_model->surfmesh.vbooffset_lightmapcolor4f; + rsurface.lightmapcolor4f = rsurface.modellightmapcolor4f; + rsurface.lightmapcolor4f_bufferobject = rsurface.modellightmapcolor4f_bufferobject; + rsurface.lightmapcolor4f_bufferoffset = rsurface.modellightmapcolor4f_bufferoffset; } if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist); if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a); - R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset); + R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset); GL_Color(r, g, b, a); RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist); } @@ -3987,13 +4489,13 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t vec3_t lightdir; // TODO: optimize // model lighting - VectorCopy(rsurface_entity->modellight_lightdir, lightdir); - ambientcolor[0] = rsurface_entity->modellight_ambient[0] * r * 0.5f; - ambientcolor[1] = rsurface_entity->modellight_ambient[1] * g * 0.5f; - ambientcolor[2] = rsurface_entity->modellight_ambient[2] * b * 0.5f; - diffusecolor[0] = rsurface_entity->modellight_diffuse[0] * r * 0.5f; - diffusecolor[1] = rsurface_entity->modellight_diffuse[1] * g * 0.5f; - diffusecolor[2] = rsurface_entity->modellight_diffuse[2] * b * 0.5f; + VectorCopy(rsurface.modellight_lightdir, lightdir); + ambientcolor[0] = rsurface.modellight_ambient[0] * r * 0.5f; + ambientcolor[1] = rsurface.modellight_ambient[1] * g * 0.5f; + ambientcolor[2] = rsurface.modellight_ambient[2] * b * 0.5f; + diffusecolor[0] = rsurface.modellight_diffuse[0] * r * 0.5f; + diffusecolor[1] = rsurface.modellight_diffuse[1] * g * 0.5f; + diffusecolor[2] = rsurface.modellight_diffuse[2] * b * 0.5f; if (VectorLength2(diffusecolor) > 0) { // generate color arrays for the surfaces in this list @@ -4001,9 +4503,9 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t { const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; int numverts = surface->num_vertices; - v = rsurface_vertex3f + 3 * surface->num_firstvertex; - c2 = rsurface_normal3f + 3 * surface->num_firstvertex; - c = rsurface_array_color4f + 4 * surface->num_firstvertex; + v = rsurface.vertex3f + 3 * surface->num_firstvertex; + c2 = rsurface.normal3f + 3 * surface->num_firstvertex; + c = rsurface.array_color4f + 4 * surface->num_firstvertex; // q3-style directional shading for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4) { @@ -4019,34 +4521,35 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t b = 1; a = 1; applycolor = false; - rsurface_lightmapcolor4f = rsurface_array_color4f; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = rsurface.array_color4f; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; } else { r = ambientcolor[0]; g = ambientcolor[1]; b = ambientcolor[2]; - rsurface_lightmapcolor4f = NULL; - rsurface_lightmapcolor4f_bufferobject = 0; - rsurface_lightmapcolor4f_bufferoffset = 0; + rsurface.lightmapcolor4f = NULL; + rsurface.lightmapcolor4f_bufferobject = 0; + rsurface.lightmapcolor4f_bufferoffset = 0; } if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist); if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a); - R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset); + R_Mesh_ColorPointer(rsurface.lightmapcolor4f, rsurface.lightmapcolor4f_bufferobject, rsurface.lightmapcolor4f_bufferoffset); GL_Color(r, g, b, a); RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist); } static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist) { - GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); - GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); - GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces - if (rsurface_mode != RSURFMODE_SHOWSURFACES) + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset); + GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + if (rsurface.mode != RSURFMODE_SHOWSURFACES) { - rsurface_mode = RSURFMODE_SHOWSURFACES; + rsurface.mode = RSURFMODE_SHOWSURFACES; GL_DepthMask(true); GL_BlendFunc(GL_ONE, GL_ZERO); R_Mesh_ColorPointer(NULL, 0, 0); @@ -4059,26 +4562,27 @@ static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurfa static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist) { // transparent sky would be ridiculous - if ((rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)) + if ((rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)) return; - if (rsurface_mode != RSURFMODE_SKY) + if (rsurface.mode != RSURFMODE_SKY) { - if (rsurface_mode == RSURFMODE_GLSL) + if (rsurface.mode == RSURFMODE_GLSL) { qglUseProgramObjectARB(0);CHECKGLERROR } - rsurface_mode = RSURFMODE_SKY; + rsurface.mode = RSURFMODE_SKY; } if (skyrendernow) { skyrendernow = false; R_Sky(); // restore entity matrix - R_Mesh_Matrix(&rsurface_entity->matrix); + R_Mesh_Matrix(&rsurface.matrix); } - GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); - GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); - GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset); + GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces GL_DepthMask(true); // LordHavoc: HalfLife maps have freaky skypolys so don't use // skymasking on them, and Quake3 never did sky masking (unlike @@ -4086,7 +4590,7 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **te // in Quake3 maps as it causes problems with q3map2 sky tricks, // and skymasking also looks very bad when noclipping outside the // level, so don't use it then either. - if (rsurface_model->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis) + if (r_refdef.worldmodel && r_refdef.worldmodel->type == mod_brushq1 && r_q1bsp_skymasking.integer && !r_viewcache.world_novis) { GL_Color(r_refdef.fogcolor[0] * r_view.colorscale, r_refdef.fogcolor[1] * r_view.colorscale, r_refdef.fogcolor[2] * r_view.colorscale, 1); R_Mesh_ColorPointer(NULL, 0, 0); @@ -4113,34 +4617,35 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **te static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist) { - if (rsurface_mode != RSURFMODE_GLSL) + if (rsurface.mode != RSURFMODE_GLSL) { - rsurface_mode = RSURFMODE_GLSL; + rsurface.mode = RSURFMODE_GLSL; R_Mesh_ResetTextureState(); } - R_SetupSurfaceShader(vec3_origin, rsurface_lightmode == 2, 1, 1, rsurface_texture->specularscale); + R_SetupSurfaceShader(vec3_origin, rsurface.lightmode == 2, 1, 1, rsurface.texture->specularscale); if (!r_glsl_permutation) return; - if (rsurface_lightmode == 2) + if (rsurface.lightmode == 2) RSurf_PrepareVerticesForBatch(true, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist); else RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist); - R_Mesh_TexCoordPointer(0, 2, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_texcoordtexture2f); - R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f, rsurface_svector3f_bufferobject, rsurface_svector3f_bufferoffset); - R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f, rsurface_tvector3f_bufferobject, rsurface_tvector3f_bufferoffset); - R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f, rsurface_normal3f_bufferobject, rsurface_normal3f_bufferoffset); - R_Mesh_TexCoordPointer(4, 2, rsurface_model->surfmesh.data_texcoordlightmap2f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_texcoordlightmap2f); + R_Mesh_TexCoordPointer(0, 2, rsurface.texcoordtexture2f, rsurface.texcoordtexture2f_bufferobject, rsurface.texcoordtexture2f_bufferoffset); + R_Mesh_TexCoordPointer(1, 3, rsurface.svector3f, rsurface.svector3f_bufferobject, rsurface.svector3f_bufferoffset); + R_Mesh_TexCoordPointer(2, 3, rsurface.tvector3f, rsurface.tvector3f_bufferobject, rsurface.tvector3f_bufferoffset); + R_Mesh_TexCoordPointer(3, 3, rsurface.normal3f, rsurface.normal3f_bufferobject, rsurface.normal3f_bufferoffset); + R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset); - if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) + GL_Color(rsurface.texture->currentlayers[0].color[0], rsurface.texture->currentlayers[0].color[1], rsurface.texture->currentlayers[0].color[2], rsurface.texture->currentlayers[0].color[3]); + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) { R_Mesh_TexBind(7, R_GetTexture(r_texture_white)); if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap)); R_Mesh_ColorPointer(NULL, 0, 0); } - else if (rsurface_uselightmaptexture) + else if (rsurface.uselightmaptexture) { R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture)); if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) @@ -4152,14 +4657,14 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **t R_Mesh_TexBind(7, R_GetTexture(r_texture_white)); if (r_glsl_permutation->loc_Texture_Deluxemap >= 0) R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap)); - R_Mesh_ColorPointer(rsurface_model->surfmesh.data_lightmapcolor4f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_lightmapcolor4f); + R_Mesh_ColorPointer(rsurface.modellightmapcolor4f, rsurface.modellightmapcolor4f_bufferobject, rsurface.modellightmapcolor4f_bufferoffset); } - if (rsurface_uselightmaptexture && !(rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) + if (rsurface.uselightmaptexture && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)) RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1); else RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist); - if (rsurface_texture->backgroundnumskinframes && !(rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)) + if (rsurface.texture->backgroundnumskinframes && !(rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED)) { } } @@ -4173,14 +4678,14 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t rmeshstate_t m; int layerindex; const texturelayer_t *layer; - if (rsurface_mode != RSURFMODE_MULTIPASS) - rsurface_mode = RSURFMODE_MULTIPASS; + if (rsurface.mode != RSURFMODE_MULTIPASS) + rsurface.mode = RSURFMODE_MULTIPASS; RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist); - for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++) + for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++) { vec4_t layercolor; int layertexrgbscale; - if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { if (layerindex == 0) GL_AlphaTest(true); @@ -4216,19 +4721,19 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t case TEXTURELAYERTYPE_LITTEXTURE: memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(r_texture_white); - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordlightmap2f; + m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f; + m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset; m.tex[1] = R_GetTexture(layer->texture); m.texmatrix[1] = layer->texmatrix; m.texrgbscale[1] = layertexrgbscale; - m.pointer_texcoord[1] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[1] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[1] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[1] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[1] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[1] = rsurface.texcoordtexture2f_bufferoffset; R_Mesh_TextureState(&m); - if (rsurface_lightmode == 2) + if (rsurface.lightmode == 2) RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); - else if (rsurface_uselightmaptexture) + else if (rsurface.uselightmaptexture) RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); else RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); @@ -4238,9 +4743,9 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t m.tex[0] = R_GetTexture(layer->texture); m.texmatrix[0] = layer->texmatrix; m.texrgbscale[0] = layertexrgbscale; - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; R_Mesh_TextureState(&m); RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); break; @@ -4251,19 +4756,19 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t { m.tex[0] = R_GetTexture(layer->texture); m.texmatrix[0] = layer->texmatrix; - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; } R_Mesh_TextureState(&m); // generate a color array for the fog pass - R_Mesh_ColorPointer(rsurface_array_color4f, 0, 0); + R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0); for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) { int i; float f, *v, *c; const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4) + for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4) { f = 1 - FogPoint_Model(v); c[0] = layercolor[0]; @@ -4280,7 +4785,7 @@ static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **t GL_LockArrays(0, 0); } CHECKGLERROR - if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { qglDepthFunc(GL_LEQUAL);CHECKGLERROR GL_AlphaTest(false); @@ -4295,12 +4800,12 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t rmeshstate_t m; int layerindex; const texturelayer_t *layer; - if (rsurface_mode != RSURFMODE_MULTIPASS) - rsurface_mode = RSURFMODE_MULTIPASS; + if (rsurface.mode != RSURFMODE_MULTIPASS) + rsurface.mode = RSURFMODE_MULTIPASS; RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist); - for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++) + for (layerindex = 0, layer = rsurface.texture->currentlayers;layerindex < rsurface.texture->currentnumlayers;layerindex++, layer++) { - if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { if (layerindex == 0) GL_AlphaTest(true); @@ -4323,13 +4828,13 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t // first the lightmap pass memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(r_texture_white); - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordlightmap2f; + m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f; + m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset; R_Mesh_TextureState(&m); - if (rsurface_lightmode == 2) + if (rsurface.lightmode == 2) RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); - else if (rsurface_uselightmaptexture) + else if (rsurface.uselightmaptexture) RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); else RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); @@ -4339,9 +4844,9 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(layer->texture); m.texmatrix[0] = layer->texmatrix; - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; R_Mesh_TextureState(&m); RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0] * 0.5f, layer->color[1] * 0.5f, layer->color[2] * 0.5f, layer->color[3], layer->color[0] != 2 || layer->color[1] != 2 || layer->color[2] != 2 || layer->color[3] != 1, false); } @@ -4351,11 +4856,11 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(layer->texture); m.texmatrix[0] = layer->texmatrix; - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; R_Mesh_TextureState(&m); - if (rsurface_lightmode == 2) + if (rsurface.lightmode == 2) RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog); else RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog); @@ -4366,23 +4871,23 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(layer->texture); m.texmatrix[0] = layer->texmatrix; - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; R_Mesh_TextureState(&m); RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog); break; case TEXTURELAYERTYPE_FOG: // singletexture fogging - R_Mesh_ColorPointer(rsurface_array_color4f, 0, 0); + R_Mesh_ColorPointer(rsurface.array_color4f, 0, 0); if (layer->texture) { memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(layer->texture); m.texmatrix[0] = layer->texmatrix; - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f; + m.pointer_texcoord[0] = rsurface.texcoordtexture2f; + m.pointer_texcoord_bufferobject[0] = rsurface.texcoordtexture2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.texcoordtexture2f_bufferoffset; R_Mesh_TextureState(&m); } else @@ -4393,7 +4898,7 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t int i; float f, *v, *c; const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; - for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4) + for (i = 0, v = (rsurface.vertex3f + 3 * surface->num_firstvertex), c = (rsurface.array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4) { f = 1 - FogPoint_Model(v); c[0] = layer->color[0]; @@ -4410,7 +4915,7 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t GL_LockArrays(0, 0); } CHECKGLERROR - if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) { qglDepthFunc(GL_LEQUAL);CHECKGLERROR GL_AlphaTest(false); @@ -4419,19 +4924,19 @@ static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **t static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly) { - if (rsurface_texture->currentmaterialflags & MATERIALFLAG_NODRAW) + if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW) return; - r_shadow_rtlight = NULL; + rsurface.rtlight = NULL; CHECKGLERROR if (depthonly) { - if ((rsurface_texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST))) + if ((rsurface.texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST))) return; - if (rsurface_mode != RSURFMODE_MULTIPASS) - rsurface_mode = RSURFMODE_MULTIPASS; + if (rsurface.mode != RSURFMODE_MULTIPASS) + rsurface.mode = RSURFMODE_MULTIPASS; if (r_depthfirst.integer == 3) { - int i = (int)(texturesurfacelist[0] - rsurface_model->data_surfaces); + int i = (int)(texturesurfacelist[0] - rsurface.modelsurfaces); GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1); } else @@ -4439,8 +4944,9 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur GL_ColorMask(0,0,0,0); GL_Color(1,1,1,1); } - GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); - GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset); + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces GL_DepthTest(true); GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthMask(true); @@ -4456,11 +4962,12 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur return; else if (r_showsurfaces.integer) { - if (rsurface_mode != RSURFMODE_MULTIPASS) - rsurface_mode = RSURFMODE_MULTIPASS; - GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + if (rsurface.mode != RSURFMODE_MULTIPASS) + rsurface.mode = RSURFMODE_MULTIPASS; + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset); GL_DepthTest(true); - GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthMask(writedepth); GL_Color(1,1,1,1); @@ -4474,11 +4981,11 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur else if (gl_lightmaps.integer) { rmeshstate_t m; - if (rsurface_mode != RSURFMODE_MULTIPASS) - rsurface_mode = RSURFMODE_MULTIPASS; - GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + if (rsurface.mode != RSURFMODE_MULTIPASS) + rsurface.mode = RSURFMODE_MULTIPASS; + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); GL_DepthTest(true); - GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces GL_BlendFunc(GL_ONE, GL_ZERO); GL_DepthMask(writedepth); GL_Color(1,1,1,1); @@ -4486,38 +4993,38 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur R_Mesh_ColorPointer(NULL, 0, 0); memset(&m, 0, sizeof(m)); m.tex[0] = R_GetTexture(r_texture_white); - m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordlightmap2f; - m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo; - m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordlightmap2f; + m.pointer_texcoord[0] = rsurface.modeltexcoordlightmap2f; + m.pointer_texcoord_bufferobject[0] = rsurface.modeltexcoordlightmap2f_bufferobject; + m.pointer_texcoord_bufferoffset[0] = rsurface.modeltexcoordlightmap2f_bufferoffset; R_Mesh_TextureState(&m); - RSurf_PrepareVerticesForBatch(rsurface_lightmode == 2, false, texturenumsurfaces, texturesurfacelist); - if (rsurface_lightmode == 2) + RSurf_PrepareVerticesForBatch(rsurface.lightmode == 2, false, texturenumsurfaces, texturesurfacelist); + if (rsurface.lightmode == 2) RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); - else if (rsurface_uselightmaptexture) + else if (rsurface.uselightmaptexture) RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); else RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); r_refdef.stats.entities_surfaces += texturenumsurfaces; } - else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY) + else if (rsurface.texture->currentmaterialflags & MATERIALFLAG_SKY) { R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist); r_refdef.stats.entities_surfaces += texturenumsurfaces; } - else if (rsurface_texture->currentnumlayers) + else if (rsurface.texture->currentnumlayers) { // write depth for anything we skipped on the depth-only pass earlier - if (!writedepth && (rsurface_texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST))) + if (!writedepth && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST))) writedepth = true; - GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); - GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); - GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces - GL_BlendFunc(rsurface_texture->currentlayers[0].blendfunc1, rsurface_texture->currentlayers[0].blendfunc2); - GL_DepthMask(writedepth && !(rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED)); - GL_Color(rsurface_entity->colormod[0], rsurface_entity->colormod[1], rsurface_entity->colormod[2], rsurface_texture->currentalpha); - GL_AlphaTest((rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); - // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh - rsurface_lightmode = ((rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2; + GL_DepthRange(0, (rsurface.texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1); + GL_PolygonOffset(rsurface.texture->currentpolygonfactor, rsurface.texture->currentpolygonoffset); + GL_DepthTest(!(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST)); + GL_CullFace((rsurface.texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces + GL_BlendFunc(rsurface.texture->currentlayers[0].blendfunc1, rsurface.texture->currentlayers[0].blendfunc2); + GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)); + GL_AlphaTest((rsurface.texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0); + // use lightmode 0 (fullbright or lightmap) or 2 (model lighting) + rsurface.lightmode = ((rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface.modeltexcoordlightmap2f != NULL) ? 0 : 2; if (r_glsl.integer && gl_support_fragment_shader) R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist); else if (gl_combine.integer && r_textureunits.integer >= 2) @@ -4551,19 +5058,19 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const for (i = 0;i < numsurfaces;i = j) { j = i + 1; - surface = rsurface_model->data_surfaces + surfacelist[i]; + surface = rsurface.modelsurfaces + surfacelist[i]; texture = surface->texture; R_UpdateTextureInfo(ent, texture); - rsurface_texture = texture->currentframe; - rsurface_uselightmaptexture = surface->lightmaptexture != NULL; + rsurface.texture = texture->currentframe; + rsurface.uselightmaptexture = surface->lightmaptexture != NULL; // scan ahead until we find a different texture endsurface = min(i + 1024, numsurfaces); texturenumsurfaces = 0; texturesurfacelist[texturenumsurfaces++] = surface; for (;j < endsurface;j++) { - surface = rsurface_model->data_surfaces + surfacelist[j]; - if (texture != surface->texture || rsurface_uselightmaptexture != (surface->lightmaptexture != NULL)) + surface = rsurface.modelsurfaces + surfacelist[j]; + if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL)) break; texturesurfacelist[texturenumsurfaces++] = surface; } @@ -4574,7 +5081,7 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const RSurf_CleanUp(); } -void R_QueueSurfaceList(int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly) +void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surfacelist, int flagsmask, qboolean writedepth, qboolean depthonly) { int i, j; vec3_t tempcenter, center; @@ -4583,21 +5090,21 @@ void R_QueueSurfaceList(int numsurfaces, msurface_t **surfacelist, int flagsmask for (i = 0;i < numsurfaces;i = j) { j = i + 1; - // texture is the base texture pointer, rsurface_texture is the + // texture is the base texture pointer, rsurface.texture is the // current frame/skin the texture is directing us to use (for example // if a model has 2 skins and it is on skin 1, then skin 0 tells us to // use skin 1 instead) texture = surfacelist[i]->texture; - rsurface_texture = texture->currentframe; - rsurface_uselightmaptexture = surfacelist[i]->lightmaptexture != NULL; - if (!(rsurface_texture->currentmaterialflags & flagsmask)) + rsurface.texture = texture->currentframe; + rsurface.uselightmaptexture = surfacelist[i]->lightmaptexture != NULL; + if (!(rsurface.texture->currentmaterialflags & flagsmask)) { // if this texture is not the kind we want, skip ahead to the next one for (;j < numsurfaces && texture == surfacelist[j]->texture;j++) ; continue; } - if (rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) + if (rsurface.texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED) { // transparent surfaces get pushed off into the transparent queue const msurface_t *surface = surfacelist[i]; @@ -4606,13 +5113,13 @@ void R_QueueSurfaceList(int numsurfaces, msurface_t **surfacelist, int flagsmask tempcenter[0] = (surface->mins[0] + surface->maxs[0]) * 0.5f; tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f; tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f; - Matrix4x4_Transform(&rsurface_entity->matrix, tempcenter, center); - R_MeshQueue_AddTransparent(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, rsurface_entity, surface - rsurface_model->data_surfaces, r_shadow_rtlight); + Matrix4x4_Transform(&rsurface.matrix, tempcenter, center); + R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight); } else { // simply scan ahead until we find a different texture or lightmap state - for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface_uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++) + for (;j < numsurfaces && texture == surfacelist[j]->texture && rsurface.uselightmaptexture == (surfacelist[j]->lightmaptexture != NULL);j++) ; // render the range of surfaces R_DrawTextureSurfaceList(j - i, surfacelist + i, writedepth, depthonly); @@ -4650,6 +5157,7 @@ void R_DrawLoc_Callback(const entity_render_t *ent, const rtlight_t *rtlight, in 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); GL_DepthTest(true); GL_CullFace(GL_NONE); R_Mesh_Matrix(&identitymatrix); @@ -4710,14 +5218,14 @@ void R_DrawCollisionBrushes(entity_render_t *ent) GL_DepthMask(false); GL_DepthRange(0, 1); GL_DepthTest(!r_showdisabledepthtest.integer); - qglPolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value);CHECKGLERROR + GL_PolygonOffset(r_refdef.polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_refdef.polygonoffset + r_showcollisionbrushes_polygonoffset.value); for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) if (brush->colbrushf && brush->colbrushf->numtriangles) R_DrawCollisionBrush(brush->colbrushf); for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) if (surface->num_collisiontriangles) R_DrawCollisionSurface(ent, surface); - qglPolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset);CHECKGLERROR + GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); } void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean drawnormals, int flagsmask) @@ -4730,6 +5238,7 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean CHECKGLERROR GL_DepthRange(0, 1); GL_DepthTest(!r_showdisabledepthtest.integer); + GL_PolygonOffset(r_refdef.polygonfactor, r_refdef.polygonoffset); GL_DepthMask(true); GL_BlendFunc(GL_ONE, GL_ZERO); R_Mesh_ColorPointer(NULL, 0, 0); @@ -4738,13 +5247,13 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean { if (ent == r_refdef.worldentity && !r_viewcache.world_surfacevisible[j]) continue; - rsurface_texture = surface->texture->currentframe; - if ((rsurface_texture->currentmaterialflags & flagsmask) && surface->num_triangles) + rsurface.texture = surface->texture->currentframe; + if ((rsurface.texture->currentmaterialflags & flagsmask) && surface->num_triangles) { RSurf_PrepareVerticesForBatch(true, true, 1, &surface); if (drawtris) { - if (!rsurface_texture->currentlayers->depthmask) + if (!rsurface.texture->currentlayers->depthmask) GL_Color(r_showtris.value * r_view.colorscale, 0, 0, 1); else if (ent == r_refdef.worldentity) GL_Color(r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, r_showtris.value * r_view.colorscale, 1); @@ -4755,7 +5264,7 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean qglBegin(GL_LINES); for (k = 0;k < surface->num_triangles;k++, elements += 3) { -#define GLVERTEXELEMENT(n) qglVertex3f(rsurface_vertex3f[elements[n]*3+0], rsurface_vertex3f[elements[n]*3+1], rsurface_vertex3f[elements[n]*3+2]) +#define GLVERTEXELEMENT(n) qglVertex3f(rsurface.vertex3f[elements[n]*3+0], rsurface.vertex3f[elements[n]*3+1], rsurface.vertex3f[elements[n]*3+2]) GLVERTEXELEMENT(0);GLVERTEXELEMENT(1); GLVERTEXELEMENT(1);GLVERTEXELEMENT(2); GLVERTEXELEMENT(2);GLVERTEXELEMENT(0); @@ -4769,9 +5278,9 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean qglBegin(GL_LINES); for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++) { - VectorCopy(rsurface_vertex3f + l * 3, v); + VectorCopy(rsurface.vertex3f + l * 3, v); qglVertex3f(v[0], v[1], v[2]); - VectorMA(v, 8, rsurface_svector3f + l * 3, v); + VectorMA(v, 8, rsurface.svector3f + l * 3, v); qglVertex3f(v[0], v[1], v[2]); } qglEnd(); @@ -4780,9 +5289,9 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean qglBegin(GL_LINES); for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++) { - VectorCopy(rsurface_vertex3f + l * 3, v); + VectorCopy(rsurface.vertex3f + l * 3, v); qglVertex3f(v[0], v[1], v[2]); - VectorMA(v, 8, rsurface_tvector3f + l * 3, v); + VectorMA(v, 8, rsurface.tvector3f + l * 3, v); qglVertex3f(v[0], v[1], v[2]); } qglEnd(); @@ -4791,9 +5300,9 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean qglBegin(GL_LINES); for (k = 0, l = surface->num_firstvertex;k < surface->num_vertices;k++, l++) { - VectorCopy(rsurface_vertex3f + l * 3, v); + VectorCopy(rsurface.vertex3f + l * 3, v); qglVertex3f(v[0], v[1], v[2]); - VectorMA(v, 8, rsurface_normal3f + l * 3, v); + VectorMA(v, 8, rsurface.normal3f + l * 3, v); qglVertex3f(v[0], v[1], v[2]); } qglEnd(); @@ -4801,7 +5310,7 @@ void R_DrawTrianglesAndNormals(entity_render_t *ent, qboolean drawtris, qboolean } } } - rsurface_texture = NULL; + rsurface.texture = NULL; } extern void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface); @@ -4839,8 +5348,8 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL); f = 0; t = NULL; - rsurface_uselightmaptexture = false; - rsurface_texture = NULL; + rsurface.uselightmaptexture = false; + rsurface.texture = NULL; numsurfacelist = 0; j = model->firstmodelsurface; endj = j + model->nummodelsurfaces; @@ -4865,14 +5374,14 @@ void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean dep counttriangles += surface->num_triangles; if (numsurfacelist >= maxsurfacelist) { - R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); + R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); numsurfacelist = 0; } } } } if (numsurfacelist) - R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); + R_QueueSurfaceList(r_refdef.worldentity, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); r_refdef.stats.entities_triangles += counttriangles; RSurf_CleanUp(); @@ -4925,8 +5434,8 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr flagsmask = skysurfaces ? MATERIALFLAG_SKY : (MATERIALFLAG_WATER | MATERIALFLAG_WALL); f = 0; t = NULL; - rsurface_uselightmaptexture = false; - rsurface_texture = NULL; + rsurface.uselightmaptexture = false; + rsurface.texture = NULL; numsurfacelist = 0; surface = model->data_surfaces + model->firstmodelsurface; endsurface = surface + model->nummodelsurfaces; @@ -4943,13 +5452,13 @@ void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean wr counttriangles += surface->num_triangles; if (numsurfacelist >= maxsurfacelist) { - R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); + R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); numsurfacelist = 0; } } } if (numsurfacelist) - R_QueueSurfaceList(numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); + R_QueueSurfaceList(ent, numsurfacelist, surfacelist, flagsmask, writedepth, depthonly); r_refdef.stats.entities_triangles += counttriangles; RSurf_CleanUp();