X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rmain.c;h=8aa50492a10cabecaa78d0b22bbfe8e6f882c90d;hb=d96c20b1d768d30f4bd7a5cebe468f9d0e5c5e34;hp=3c23d277e6e24f7d98e02ff796c7c74a7ddfce3a;hpb=97cdef0adb81c4401dcb9cfa292a3eb386214dac;p=xonotic%2Fdarkplaces.git diff --git a/gl_rmain.c b/gl_rmain.c index 3c23d277..8aa50492 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"}; @@ -485,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" @@ -649,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" @@ -668,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"}, @@ -779,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); @@ -843,6 +855,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 (rsurface.texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) { @@ -861,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) { @@ -882,6 +898,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 { @@ -922,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) { @@ -931,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) @@ -999,7 +1019,22 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl //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_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 @@ -1493,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); @@ -1511,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); @@ -1987,7 +2025,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 @@ -2020,7 +2058,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 @@ -2734,6 +2772,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(); @@ -2870,6 +2909,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); @@ -2966,6 +3006,7 @@ void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_ 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; @@ -3320,6 +3361,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)) { @@ -3366,6 +3419,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 @@ -3758,13 +3813,16 @@ void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generateta { const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; const float *v1, *v2; + vec3_t start, end; float f, l; struct { float length2; - int quadedge; + 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) { @@ -3772,43 +3830,74 @@ void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generateta for (i = 0;i < 4;i++) VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center); VectorScale(center, 0.25f, center); - shortest[0].quadedge = shortest[1].quadedge = 0; - shortest[0].length2 = shortest[1].length2 = 0; // 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].quadedge = i; + shortest[0].v1 = v1; + shortest[0].v2 = v2; } else if (shortest[1].length2 > l || i == 1) { shortest[1].length2 = l; - shortest[1].quadedge = i; + shortest[1].v1 = v1; + shortest[1].v2 = v2; } } - // this calculates the midpoints *2 (not bothering to average) of the two shortest edges, and subtracts one from the other to get the up vector - for (i = 0;i < 3;i++) - { - right[i] = rsurface.vertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][1]) + i] - + rsurface.vertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][0]) + i]; - up[i] = rsurface.vertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][0]) + i] - + rsurface.vertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][1]) + i] - - rsurface.vertex3f[3 * (surface->num_firstvertex + quadedges[shortest[0].quadedge][0]) + i] - - rsurface.vertex3f[3 * (surface->num_firstvertex + quadedges[shortest[0].quadedge][1]) + i]; - } + 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); + //VectorSubtract(rsurface.modelorg, center, forward); + Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, forward); + VectorNegate(forward, forward); + VectorReflect(forward, 0, up, forward); + VectorNormalize(forward); CrossProduct(up, forward, newright); - // normalize the vectors involved - VectorNormalize(right); 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 @@ -3819,12 +3908,12 @@ void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generateta // displacement from the center, which we do with a // DotProduct, the subtraction/addition of center is also // optimized into DotProducts here - l = DotProduct(newright, center) - DotProduct(right, center); + l = DotProduct(right, center); for (i = 0;i < 4;i++) { v1 = rsurface.vertex3f + 3 * (surface->num_firstvertex + j + i); - f = DotProduct(right, v1) - DotProduct(newright, v1) + l; - VectorMA(v1, f, newright, rsurface.array_deformedvertex3f + (surface->num_firstvertex+i+j) * 3); + 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); @@ -4439,6 +4528,7 @@ static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist) { 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) @@ -4474,6 +4564,7 @@ static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **te R_Mesh_Matrix(&rsurface.matrix); } 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); @@ -4838,6 +4929,7 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur GL_Color(1,1,1,1); } 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); @@ -4857,6 +4949,7 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur 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_BlendFunc(GL_ONE, GL_ZERO); @@ -4908,6 +5001,7 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur if (!writedepth && (rsurface.texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST))) writedepth = true; 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); @@ -5047,6 +5141,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); @@ -5107,14 +5202,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) @@ -5127,6 +5222,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);