X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rmain.c;h=8aa50492a10cabecaa78d0b22bbfe8e6f882c90d;hb=f6ba1415824df19d9d6b38066dc93912fb2ce789;hp=31594e2e30e72e652008d2a58f16c7e54097295e;hpb=302711d37e168e57a9e2c8003084a22a3285c555;p=xonotic%2Fdarkplaces.git diff --git a/gl_rmain.c b/gl_rmain.c index 31594e2e..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); @@ -822,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; @@ -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) @@ -952,8 +972,8 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl 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]); @@ -990,7 +1010,7 @@ int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, fl 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_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)); @@ -999,11 +1019,26 @@ 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 - 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]); @@ -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); @@ -2907,7 +2947,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); } @@ -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; @@ -3138,10 +3179,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 { @@ -3204,13 +3281,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; @@ -3234,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)) { @@ -3280,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 @@ -3343,7 +3484,7 @@ void R_Mesh_ResizeArrays(int newvertices) 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])); + 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; @@ -3354,6 +3495,7 @@ void R_Mesh_ResizeArrays(int newvertices) rsurface.array_deformednormal3f = base + rsurface.array_size * 21; rsurface.array_texcoord3f = base + rsurface.array_size * 24; rsurface.array_color4f = base + rsurface.array_size * 27; + rsurface.array_generatedtexcoordtexture2f = base + rsurface.array_size * 31; } void RSurf_CleanUp(void) @@ -3371,10 +3513,10 @@ void RSurf_CleanUp(void) void RSurf_ActiveWorldEntity(void) { + model_t *model = r_refdef.worldmodel; RSurf_CleanUp(); - 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); @@ -3392,18 +3534,33 @@ void RSurf_ActiveWorldEntity(void) rsurface.frameblend[2].lerp = 0; rsurface.frameblend[3].frame = 0; rsurface.frameblend[3].lerp = 0; - 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.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; @@ -3417,14 +3574,15 @@ void RSurf_ActiveWorldEntity(void) 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.model = ent->model; - 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 = ent->matrix; rsurface.inversematrix = ent->inversematrix; R_Mesh_Matrix(&rsurface.matrix); @@ -3438,7 +3596,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.frameblend[1] = ent->frameblend[1]; rsurface.frameblend[2] = ent->frameblend[2]; rsurface.frameblend[3] = ent->frameblend[3]; - if (rsurface.model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0)) + if (model->surfmesh.isanimated && (rsurface.frameblend[0].lerp != 1 || rsurface.frameblend[0].frame != 0)) { if (wanttangents) { @@ -3446,7 +3604,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.modelsvector3f = rsurface.array_modelsvector3f; rsurface.modeltvector3f = rsurface.array_modeltvector3f; rsurface.modelnormal3f = rsurface.array_modelnormal3f; - Mod_Alias_GetMesh_Vertices(rsurface.model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f); + Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, rsurface.array_modelsvector3f, rsurface.array_modeltvector3f); } else if (wantnormals) { @@ -3454,7 +3612,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.modelsvector3f = NULL; rsurface.modeltvector3f = NULL; rsurface.modelnormal3f = rsurface.array_modelnormal3f; - Mod_Alias_GetMesh_Vertices(rsurface.model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL); + Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, rsurface.array_modelnormal3f, NULL, NULL); } else { @@ -3462,7 +3620,7 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.modelsvector3f = NULL; rsurface.modeltvector3f = NULL; rsurface.modelnormal3f = NULL; - Mod_Alias_GetMesh_Vertices(rsurface.model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL); + Mod_Alias_GetMesh_Vertices(model, rsurface.frameblend, rsurface.array_modelvertex3f, NULL, NULL, NULL); } rsurface.modelvertex3f_bufferobject = 0; rsurface.modelvertex3f_bufferoffset = 0; @@ -3476,20 +3634,35 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q } 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.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; @@ -3502,24 +3675,44 @@ void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, q rsurface.normal3f = rsurface.modelnormal3f; rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject; rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset; + rsurface.texcoordtexture2f = rsurface.modeltexcoordtexture2f; } static const int quadedges[6][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 2}, {1, 3}, {2, 3}}; void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist) { + int deformindex; + int texturesurfaceindex; + int i, j; + float amplitude; + float animpos; + float scale; + const float *v1, *in_tc; + float *out_tc; + float center[3], forward[3], right[3], up[3], v[3], newforward[3], newright[3], newup[3]; + float waveparms[4]; + q3shaderinfo_deform_t *deform; // if vertices are dynamic (animated models), generate them into the temporary rsurface.array_model* arrays and point rsurface.model* at them instead of the static data from the model itself if (rsurface.generatedvertex) { - if (rsurface.texture->textureflags & (Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) - generatetangents = true; - if (generatetangents) + if (rsurface.texture->tcgen.tcgen == Q3TCGEN_ENVIRONMENT) generatenormals = true; + for (i = 0;i < Q3MAXDEFORMS;i++) + { + if (rsurface.texture->deforms[i].deform == Q3DEFORM_AUTOSPRITE) + { + generatetangents = true; + generatenormals = true; + } + if (rsurface.texture->deforms[i].deform != Q3DEFORM_NONE) + generatenormals = true; + } if (generatenormals && !rsurface.modelnormal3f) { rsurface.normal3f = rsurface.modelnormal3f = rsurface.array_modelnormal3f; rsurface.normal3f_bufferobject = rsurface.modelnormal3f_bufferobject = 0; rsurface.normal3f_bufferoffset = rsurface.modelnormal3f_bufferoffset = 0; - Mod_BuildNormals(0, rsurface.model->surfmesh.num_vertices, rsurface.model->surfmesh.num_triangles, rsurface.modelvertex3f, rsurface.model->surfmesh.data_element3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer); + Mod_BuildNormals(0, rsurface.modelnum_vertices, rsurface.modelnum_triangles, rsurface.modelvertex3f, rsurface.modelelement3i, rsurface.array_modelnormal3f, r_smoothnormals_areaweighting.integer); } if (generatetangents && !rsurface.modelsvector3f) { @@ -3529,79 +3722,182 @@ void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generateta 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); + 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[3], newforward[3], newright[3], newup[3]; - 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++) + 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++) { - 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]; + // a single autosprite surface can contain multiple sprites... + for (j = 0;j < surface->num_vertices - 3;j += 4) { - const float *v1, *v2; - float f, l; - struct + 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++) { - float length2; - int quadedge; + 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); } - shortest[2]; - shortest[0].quadedge = shortest[1].quadedge = 0; - shortest[0].length2 = shortest[1].length2 = 0; + } + Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformednormal3f, r_smoothnormals_areaweighting.integer); + Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer); + } + rsurface.vertex3f = rsurface.array_deformedvertex3f; + rsurface.vertex3f_bufferobject = 0; + rsurface.vertex3f_bufferoffset = 0; + rsurface.svector3f = rsurface.array_deformedsvector3f; + rsurface.svector3f_bufferobject = 0; + rsurface.svector3f_bufferoffset = 0; + rsurface.tvector3f = rsurface.array_deformedtvector3f; + rsurface.tvector3f_bufferobject = 0; + rsurface.tvector3f_bufferoffset = 0; + rsurface.normal3f = rsurface.array_deformednormal3f; + rsurface.normal3f_bufferobject = 0; + rsurface.normal3f_bufferoffset = 0; + break; + case Q3DEFORM_AUTOSPRITE2: + Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.forward, newforward); + Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.right, newright); + Matrix4x4_Transform3x3(&rsurface.inversematrix, r_view.up, newup); + VectorNormalize(newforward); + VectorNormalize(newright); + VectorNormalize(newup); + // make deformed versions of only the model vertices used by the specified surfaces + for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) + { + const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; + const float *v1, *v2; + vec3_t start, end; + float f, l; + struct + { + float length2; + const float *v1; + const float *v2; + } + shortest[2]; + memset(shortest, 0, sizeof(shortest)); + // a single autosprite surface can contain multiple sprites... + for (j = 0;j < surface->num_vertices - 3;j += 4) + { + VectorClear(center); + for (i = 0;i < 4;i++) + VectorAdd(center, (rsurface.vertex3f + 3 * surface->num_firstvertex) + (j+i) * 3, center); + VectorScale(center, 0.25f, center); // find the two shortest edges, then use them to define the // axis vectors for rotating around the central axis for (i = 0;i < 6;i++) { - v1 = rsurface.modelvertex3f + 3 * (surface->num_firstvertex + quadedges[i][0]); - v2 = rsurface.modelvertex3f + 3 * (surface->num_firstvertex + quadedges[i][1]); + 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.modelvertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][1]) + i] - + rsurface.modelvertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][0]) + i]; - up[i] = rsurface.modelvertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][0]) + i] - + rsurface.modelvertex3f[3 * (surface->num_firstvertex + quadedges[shortest[1].quadedge][1]) + i] - - rsurface.modelvertex3f[3 * (surface->num_firstvertex + quadedges[shortest[0].quadedge][0]) + i] - - rsurface.modelvertex3f[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 @@ -3612,57 +3908,194 @@ 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.modelvertex3f + 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); + 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); } } - else + 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++) { - VectorCopy((rsurface.modelnormal3f + 3 * surface->num_firstvertex) + j*3, forward); - VectorCopy((rsurface.modelsvector3f + 3 * surface->num_firstvertex) + j*3, right); - VectorCopy((rsurface.modeltvector3f + 3 * surface->num_firstvertex) + j*3, up); - for (i = 0;i < 4;i++) + float vertex[3]; + float *normal = (rsurface.array_deformednormal3f + 3 * surface->num_firstvertex) + j*3; + VectorScale((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, 0.98f, vertex); + VectorCopy((rsurface.normal3f + 3 * surface->num_firstvertex) + j*3, normal); + normal[0] += deform->parms[0] * noise4f( vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]); + normal[1] += deform->parms[0] * noise4f( 98 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]); + normal[2] += deform->parms[0] * noise4f(196 + vertex[0], vertex[1], vertex[2], r_refdef.time * deform->parms[1]); + VectorNormalize(normal); + } + Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface.vertex3f, rsurface.modeltexcoordtexture2f, rsurface.array_deformednormal3f, rsurface.modelelement3i + surface->num_firsttriangle * 3, rsurface.array_deformedsvector3f, rsurface.array_deformedtvector3f, r_smoothnormals_areaweighting.integer); + } + rsurface.svector3f = rsurface.array_deformedsvector3f; + rsurface.svector3f_bufferobject = 0; + rsurface.svector3f_bufferoffset = 0; + rsurface.tvector3f = rsurface.array_deformedtvector3f; + rsurface.tvector3f_bufferobject = 0; + rsurface.tvector3f_bufferoffset = 0; + rsurface.normal3f = rsurface.array_deformednormal3f; + rsurface.normal3f_bufferobject = 0; + rsurface.normal3f_bufferoffset = 0; + break; + case Q3DEFORM_WAVE: + // deform vertex array to make wavey water and flags and such + waveparms[0] = deform->waveparms[0]; + waveparms[1] = deform->waveparms[1]; + waveparms[2] = deform->waveparms[2]; + waveparms[3] = deform->waveparms[3]; + // this is how a divisor of vertex influence on deformation + animpos = deform->parms[0] ? 1.0f / deform->parms[0] : 100.0f; + scale = R_EvaluateQ3WaveFunc(deform->wavefunc, waveparms); + for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++) + { + const msurface_t *surface = texturesurfacelist[texturesurfaceindex]; + for (j = 0;j < surface->num_vertices;j++) + { + float *vertex = (rsurface.array_deformedvertex3f + 3 * surface->num_firstvertex) + j*3; + VectorCopy((rsurface.vertex3f + 3 * surface->num_firstvertex) + j*3, vertex); + // if the wavefunc depends on time, evaluate it per-vertex + if (waveparms[3]) { - VectorSubtract((rsurface.modelvertex3f + 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); + 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); } } - 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.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; + // 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); } @@ -3679,7 +4112,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) { @@ -3692,10 +4125,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; @@ -3704,7 +4137,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); @@ -3726,7 +4159,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 @@ -3735,7 +4168,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)); } } } @@ -3757,7 +4190,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) { @@ -3773,10 +4206,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; @@ -3785,7 +4218,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); @@ -3826,7 +4259,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"); @@ -3841,7 +4274,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)); } } } @@ -3859,7 +4292,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))); } } } @@ -3871,7 +4304,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)); } } } @@ -3984,7 +4417,7 @@ static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t { 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) @@ -4018,9 +4451,9 @@ static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t } 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); @@ -4095,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) @@ -4130,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); @@ -4139,7 +4574,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); @@ -4180,11 +4615,11 @@ static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **t 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(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.model->surfmesh.data_texcoordlightmap2f, rsurface.model->surfmesh.vbo, rsurface.model->surfmesh.vbooffset_texcoordlightmap2f); + R_Mesh_TexCoordPointer(4, 2, rsurface.modeltexcoordlightmap2f, rsurface.modeltexcoordlightmap2f_bufferobject, rsurface.modeltexcoordlightmap2f_bufferoffset); 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) @@ -4206,7 +4641,7 @@ 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)) @@ -4270,15 +4705,15 @@ 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) RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog); @@ -4292,9 +4727,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; @@ -4305,9 +4740,9 @@ 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 @@ -4377,9 +4812,9 @@ 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) RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false); @@ -4393,9 +4828,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); } @@ -4405,9 +4840,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); 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); @@ -4420,9 +4855,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], 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; @@ -4434,9 +4869,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); } else @@ -4475,7 +4910,7 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur { if (rsurface.texture->currentmaterialflags & MATERIALFLAG_NODRAW) return; - r_shadow_rtlight = NULL; + rsurface.rtlight = NULL; CHECKGLERROR if (depthonly) { @@ -4485,7 +4920,7 @@ static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **textur 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 @@ -4494,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); @@ -4513,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); @@ -4540,9 +4977,9 @@ 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) @@ -4564,13 +5001,14 @@ 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); GL_DepthMask(writedepth && !(rsurface.texture->currentmaterialflags & MATERIALFLAG_BLENDED)); 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; + // 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) @@ -4604,7 +5042,7 @@ 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; @@ -4615,7 +5053,7 @@ static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const texturesurfacelist[texturenumsurfaces++] = surface; for (;j < endsurface;j++) { - surface = rsurface.model->data_surfaces + surfacelist[j]; + surface = rsurface.modelsurfaces + surfacelist[j]; if (texture != surface->texture || rsurface.uselightmaptexture != (surface->lightmaptexture != NULL)) break; texturesurfacelist[texturenumsurfaces++] = surface; @@ -4660,7 +5098,7 @@ void R_QueueSurfaceList(entity_render_t *ent, int numsurfaces, msurface_t **surf tempcenter[1] = (surface->mins[1] + surface->maxs[1]) * 0.5f; tempcenter[2] = (surface->mins[2] + surface->maxs[2]) * 0.5f; Matrix4x4_Transform(&rsurface.matrix, tempcenter, center); - R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.model->data_surfaces, r_shadow_rtlight); + R_MeshQueue_AddTransparent(rsurface.texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_view.origin : center, R_DrawSurface_TransparentCallback, ent, surface - rsurface.modelsurfaces, rsurface.rtlight); } else { @@ -4703,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); @@ -4763,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) @@ -4783,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);