X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rsurf.c;h=2c78a2c6069d2b1901df1200de0d3f314dc4b67a;hb=9a92c162766f97f86ca5ad08771adb11a1e6bee4;hp=cf63d964234f1d27e9b0ed9054db91c050a8221b;hpb=18c3654205b2c1c0a0f6f1b8433fb49148dd6617;p=xonotic%2Fdarkplaces.git diff --git a/gl_rsurf.c b/gl_rsurf.c index cf63d964..2c78a2c6 100644 --- a/gl_rsurf.c +++ b/gl_rsurf.c @@ -571,7 +571,7 @@ void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int ============================================================= */ -static void RSurf_AddLightmapToVertexColors(const int *lightmapoffsets, float *c, int numverts, const qbyte *samples, int size3, const qbyte *styles) +static void RSurf_AddLightmapToVertexColors_Color4f(const int *lightmapoffsets, float *c, int numverts, const qbyte *samples, int size3, const qbyte *styles) { int i; float scale; @@ -605,13 +605,13 @@ static void RSurf_AddLightmapToVertexColors(const int *lightmapoffsets, float *c } } -static void RSurf_FogColors(const float *v, float *c, float colorscale, int numverts, const float *modelorg) +static void RSurf_FogColors_Vertex3f_Color4f(const float *v, float *c, float colorscale, int numverts, const float *modelorg) { int i; float diff[3], f; if (fogenabled) { - for (i = 0;i < numverts;i++, v += 4, c += 4) + for (i = 0;i < numverts;i++, v += 3, c += 4) { VectorSubtract(v, modelorg, diff); f = colorscale * (1 - exp(fogdensity/DotProduct(diff, diff))); @@ -623,7 +623,7 @@ static void RSurf_FogColors(const float *v, float *c, float colorscale, int numv VectorScale(c, colorscale, c); } -static void RSurf_FoggedColors(const float *v, float *c, float r, float g, float b, float a, float colorscale, int numverts, const float *modelorg) +static void RSurf_FoggedColors_Vertex3f_Color4f(const float *v, float *c, float r, float g, float b, float a, float colorscale, int numverts, const float *modelorg) { int i; float diff[3], f; @@ -632,7 +632,7 @@ static void RSurf_FoggedColors(const float *v, float *c, float r, float g, float b *= colorscale; if (fogenabled) { - for (i = 0;i < numverts;i++, v += 4, c += 4) + for (i = 0;i < numverts;i++, v += 3, c += 4) { VectorSubtract(v, modelorg, diff); f = 1 - exp(fogdensity/DotProduct(diff, diff)); @@ -654,14 +654,14 @@ static void RSurf_FoggedColors(const float *v, float *c, float r, float g, float } } -static void RSurf_FogPassColors(const float *v, float *c, float r, float g, float b, float a, float colorscale, int numverts, const float *modelorg) +static void RSurf_FogPassColors_Vertex3f_Color4f(const float *v, float *c, float r, float g, float b, float a, float colorscale, int numverts, const float *modelorg) { int i; float diff[3], f; r *= colorscale; g *= colorscale; b *= colorscale; - for (i = 0;i < numverts;i++, v += 4, c += 4) + for (i = 0;i < numverts;i++, v += 3, c += 4) { VectorSubtract(v, modelorg, diff); f = exp(fogdensity/DotProduct(diff, diff)); @@ -672,15 +672,7 @@ static void RSurf_FogPassColors(const float *v, float *c, float r, float g, floa } } -static void RSurf_ScaleColors(float *c, float scale, int numverts) -{ - int i; - if (scale != 1) - for (i = 0;i < numverts;i++, c += 4) - VectorScale(c, scale, c); -} - -static int RSurf_LightSeparate(const matrix4x4_t *matrix, const int *dlightbits, int numverts, const float *vert, float *color) +static int RSurf_LightSeparate_Vertex3f_Color4f(const matrix4x4_t *matrix, const int *dlightbits, int numverts, const float *vert, float *color, float scale) { float f; const float *v; @@ -694,12 +686,12 @@ static int RSurf_LightSeparate(const matrix4x4_t *matrix, const int *dlightbits, { rd = &r_dlight[l]; Matrix4x4_Transform(matrix, rd->origin, lightorigin); - for (i = 0, v = vert, c = color;i < numverts;i++, v += 4, c += 4) + for (i = 0, v = vert, c = color;i < numverts;i++, v += 3, c += 4) { f = VectorDistance2(v, lightorigin) + LIGHTOFFSET; if (f < rd->cullradius2) { - f = (1.0f / f) - rd->subtract; + f = ((1.0f / f) - rd->subtract) * scale; VectorMA(c, f, rd->light, c); lit = true; } @@ -709,8 +701,7 @@ static int RSurf_LightSeparate(const matrix4x4_t *matrix, const int *dlightbits, return lit; } -// note: this untransforms lights to do the checking, -// and takes surf->mesh->verts data +// note: this untransforms lights to do the checking static int RSurf_LightCheck(const matrix4x4_t *matrix, const int *dlightbits, const surfmesh_t *mesh) { int i, l; @@ -723,7 +714,7 @@ static int RSurf_LightCheck(const matrix4x4_t *matrix, const int *dlightbits, co { rd = &r_dlight[l]; Matrix4x4_Transform(matrix, rd->origin, lightorigin); - for (i = 0, v = mesh->verts;i < mesh->numverts;i++, v += 4) + for (i = 0, v = mesh->vertex3f;i < mesh->numverts;i++, v += 3) if (VectorDistance2(v, lightorigin) < rd->cullradius2) return true; } @@ -750,34 +741,34 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture R_Mesh_Matrix(&ent->matrix); - // draw depth-only polys - memset(&m, 0, sizeof(m)); + GL_Color(fogcolor[0] * r_colorscale, fogcolor[1] * r_colorscale, fogcolor[2] * r_colorscale, 1); if (skyrendermasked) { + // depth-only (masking) qglColorMask(0,0,0,0); // just to make sure that braindead drivers don't draw anything // despite that colormask... - m.blendfunc1 = GL_ZERO; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_ZERO, GL_ONE); } else { // fog sky - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_ONE, GL_ZERO); } - m.depthwrite = true; - R_Mesh_State(&m); + GL_DepthMask(true); + GL_DepthTest(true); + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + while((surf = *surfchain++) != NULL) { if (surf->visframe == r_framecount) { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - GL_Color(fogcolor[0] * r_colorscale, fogcolor[1] * r_colorscale, fogcolor[2] * r_colorscale, 1); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -786,36 +777,40 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture static void RSurfShader_Water_Callback(const void *calldata1, int calldata2) { - int i; const entity_render_t *ent = calldata1; const msurface_t *surf = ent->model->surfaces + calldata2; - float f, colorscale, scroll[2], *v; + float f, colorscale; const surfmesh_t *mesh; rmeshstate_t m; float alpha; float modelorg[3]; texture_t *texture; - Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg); + matrix4x4_t tempmatrix; + + // scrolling in texture matrix + Matrix4x4_CreateTranslate(&tempmatrix, sin(cl.time) * 0.125, sin(cl.time * 0.8f) * 0.125, 0); + R_Mesh_TextureMatrix(0, &tempmatrix); R_Mesh_Matrix(&ent->matrix); + Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg); memset(&m, 0, sizeof(m)); texture = surf->texinfo->texture->currentframe; alpha = texture->currentalpha; if (texture->rendertype == SURFRENDER_ADD) { - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); } else if (texture->rendertype == SURFRENDER_ALPHA) { - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_DepthMask(false); } else { - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(true); } m.tex[0] = R_GetTexture(texture->skin.base); colorscale = r_colorscale; @@ -824,50 +819,46 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2) m.texrgbscale[0] = 4; colorscale *= 0.25f; } - R_Mesh_State(&m); - GL_UseColorArray(); + GL_DepthTest(true); + GL_ColorPointer(varray_color4f); for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - scroll[0] = sin(cl.time) * 0.125f; - scroll[1] = sin(cl.time * 0.8f) * 0.125f; - for (i = 0, v = varray_texcoord[0];i < mesh->numverts;i++, v += 4) - { - v[0] += scroll[0]; - v[1] += scroll[1]; - } + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); f = surf->flags & SURF_DRAWFULLBRIGHT ? 1.0f : ((surf->flags & SURF_LIGHTMAP) ? 0 : 0.5f); - R_FillColors(varray_color, mesh->numverts, f, f, f, alpha); + R_FillColors(varray_color4f, mesh->numverts, f, f, f, alpha); if (!(surf->flags & SURF_DRAWFULLBRIGHT || ent->effects & EF_FULLBRIGHT)) { if (surf->dlightframe == r_framecount) - RSurf_LightSeparate(&ent->inversematrix, surf->dlightbits, mesh->numverts, varray_vertex, varray_color); + RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, 1); if (surf->flags & SURF_LIGHTMAP) - RSurf_AddLightmapToVertexColors(mesh->lightmapoffsets, varray_color, mesh->numverts, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles); + RSurf_AddLightmapToVertexColors_Color4f(mesh->lightmapoffsets, varray_color4f, mesh->numverts, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles); } - RSurf_FogColors(varray_vertex, varray_color, colorscale, mesh->numverts, modelorg); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + RSurf_FogColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, colorscale, mesh->numverts, modelorg); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } if (fogenabled) { memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.fog); - R_Mesh_State(&m); for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - if (m.tex[0]) - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - RSurf_FogPassColors(varray_vertex, varray_color, fogcolor[0], fogcolor[1], fogcolor[2], alpha, r_colorscale, mesh->numverts, modelorg); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + GL_ColorPointer(varray_color4f); + R_Mesh_State_Texture(&m); + RSurf_FogPassColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], alpha, r_colorscale, mesh->numverts, modelorg); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } + + Matrix4x4_CreateIdentity(&tempmatrix); + R_Mesh_TextureMatrix(0, &tempmatrix); } static void RSurfShader_Water(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain) @@ -902,18 +893,18 @@ static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const m memset(&m, 0, sizeof(m)); if (rendertype == SURFRENDER_ADD) { - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); } else if (rendertype == SURFRENDER_ALPHA) { - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_DepthMask(false); } else { - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(true); } m.tex[0] = R_GetTexture(texture->skin.base); colorscale = r_colorscale; @@ -923,23 +914,23 @@ static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const m colorscale *= 0.25f; } base = ent->effects & EF_FULLBRIGHT ? 2.0f : r_ambient.value * (1.0f / 64.0f); - R_Mesh_State(&m); - GL_UseColorArray(); + GL_DepthTest(true); + GL_ColorPointer(varray_color4f); for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - R_FillColors(varray_color, mesh->numverts, base, base, base, currentalpha); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + R_FillColors(varray_color4f, mesh->numverts, base, base, base, currentalpha); if (!(ent->effects & EF_FULLBRIGHT)) { if (surf->dlightframe == r_framecount) - RSurf_LightSeparate(&ent->inversematrix, surf->dlightbits, mesh->numverts, varray_vertex, varray_color); + RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, 1); if (surf->flags & SURF_LIGHTMAP) - RSurf_AddLightmapToVertexColors(mesh->lightmapoffsets, varray_color, mesh->numverts, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles); + RSurf_AddLightmapToVertexColors_Color4f(mesh->lightmapoffsets, varray_color4f, mesh->numverts, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles); } - RSurf_FogColors(varray_vertex, varray_color, colorscale, mesh->numverts, modelorg); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + RSurf_FogColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, colorscale, mesh->numverts, modelorg); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } @@ -950,18 +941,19 @@ static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurfac float modelorg[3]; Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg); memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.glow); - R_Mesh_State(&m); - GL_UseColorArray(); + GL_ColorPointer(varray_color4f); for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - RSurf_FoggedColors(varray_vertex, varray_color, 1, 1, 1, currentalpha, r_colorscale, mesh->numverts, modelorg); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + if (m.tex[0]) + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + RSurf_FoggedColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, 1, 1, 1, currentalpha, r_colorscale, mesh->numverts, modelorg); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } @@ -972,19 +964,19 @@ static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface float modelorg[3]; Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg); memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.fog); - R_Mesh_State(&m); - GL_UseColorArray(); + GL_ColorPointer(varray_color4f); for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); + GL_VertexPointer(mesh->vertex3f); if (m.tex[0]) - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - RSurf_FogPassColors(varray_vertex, varray_color, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, r_colorscale, mesh->numverts, modelorg); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + RSurf_FogPassColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, r_colorscale, mesh->numverts, modelorg); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } @@ -996,35 +988,36 @@ static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render int lightmaptexturenum; float cl; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(true); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.base); m.tex[1] = R_GetTexture((**surfchain).lightmaptexture); m.tex[2] = R_GetTexture(texture->skin.detail); m.texrgbscale[0] = 1; m.texrgbscale[1] = 4; m.texrgbscale[2] = 2; - R_Mesh_State(&m); cl = (float) (1 << r_lightmapscalebit) * r_colorscale; GL_Color(cl, cl, cl, 1); + while((surf = *surfchain++) != NULL) { if (surf->visframe == r_framecount) { lightmaptexturenum = R_GetTexture(surf->lightmaptexture); - if (m.tex[1] != lightmaptexturenum) - { + //if (m.tex[1] != lightmaptexturenum) + //{ m.tex[1] = lightmaptexturenum; - R_Mesh_State(&m); - } + // R_Mesh_State_Texture(&m); + //} for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[1], mesh->uvw, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[2], mesh->abc, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + m.pointer_texcoord[1] = mesh->texcoordlightmap2f; + m.pointer_texcoord[2] = mesh->texcoorddetail2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1037,31 +1030,31 @@ static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent rmeshstate_t m; int lightmaptexturenum; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_ONE, GL_ZERO); + GL_DepthMask(true); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.base); m.tex[1] = R_GetTexture((**surfchain).lightmaptexture); if (gl_combine.integer) m.texrgbscale[1] = 4; - R_Mesh_State(&m); GL_Color(r_colorscale, r_colorscale, r_colorscale, 1); while((surf = *surfchain++) != NULL) { if (surf->visframe == r_framecount) { lightmaptexturenum = R_GetTexture(surf->lightmaptexture); - if (m.tex[1] != lightmaptexturenum) - { + //if (m.tex[1] != lightmaptexturenum) + //{ m.tex[1] = lightmaptexturenum; - R_Mesh_State(&m); - } + // R_Mesh_State_Texture(&m); + //} for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[1], mesh->uvw, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + m.pointer_texcoord[1] = mesh->texcoordlightmap2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1073,10 +1066,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent, const surfmesh_t *mesh; rmeshstate_t m; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_ONE; - m.blendfunc2 = GL_ZERO; + GL_DepthMask(true); + GL_DepthTest(true); + GL_BlendFunc(GL_ONE, GL_ZERO); m.tex[0] = R_GetTexture(texture->skin.base); - R_Mesh_State(&m); GL_Color(1, 1, 1, 1); while((surf = *surfchain++) != NULL) { @@ -1084,10 +1077,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent, { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1100,29 +1093,29 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent, rmeshstate_t m; int lightmaptexturenum; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_ZERO; - m.blendfunc2 = GL_SRC_COLOR; + GL_BlendFunc(GL_ZERO, GL_SRC_COLOR); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture((**surfchain).lightmaptexture); if (gl_combine.integer) m.texrgbscale[0] = 4; - R_Mesh_State(&m); GL_Color(r_colorscale, r_colorscale, r_colorscale, 1); while((surf = *surfchain++) != NULL) { if (surf->visframe == r_framecount) { lightmaptexturenum = R_GetTexture(surf->lightmaptexture); - if (m.tex[0] != lightmaptexturenum) - { + //if (m.tex[0] != lightmaptexturenum) + //{ m.tex[0] = lightmaptexturenum; - R_Mesh_State(&m); - } + // R_Mesh_State_Texture(&m); + //} for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->uvw, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordlightmap2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1136,8 +1129,9 @@ static void RSurfShader_OpaqueWall_Pass_Light(const entity_render_t *ent, const rmeshstate_t m; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.base); colorscale = r_colorscale; if (gl_combine.integer) @@ -1145,8 +1139,7 @@ static void RSurfShader_OpaqueWall_Pass_Light(const entity_render_t *ent, const m.texrgbscale[0] = 4; colorscale *= 0.25f; } - R_Mesh_State(&m); - GL_UseColorArray(); + GL_ColorPointer(varray_color4f); while((surf = *surfchain++) != NULL) { if (surf->visframe == r_framecount && surf->dlightframe == r_framecount) @@ -1155,13 +1148,12 @@ static void RSurfShader_OpaqueWall_Pass_Light(const entity_render_t *ent, const { if (RSurf_LightCheck(&ent->inversematrix, surf->dlightbits, mesh)) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - R_FillColors(varray_color, mesh->numverts, 0, 0, 0, 1); - RSurf_LightSeparate(&ent->inversematrix, surf->dlightbits, mesh->numverts, varray_vertex, varray_color); - RSurf_ScaleColors(varray_color, colorscale, mesh->numverts); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_FillColors(varray_color4f, mesh->numverts, 0, 0, 0, 1); + R_Mesh_State_Texture(&m); + RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, colorscale); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1176,22 +1168,22 @@ static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const te float modelorg[3]; Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg); memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - R_Mesh_State(&m); - GL_UseColorArray(); + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_DepthMask(false); + GL_DepthTest(true); + GL_ColorPointer(varray_color4f); while((surf = *surfchain++) != NULL) { if (surf->visframe == r_framecount) { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); + GL_VertexPointer(mesh->vertex3f); if (m.tex[0]) - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - RSurf_FogPassColors(varray_vertex, varray_color, fogcolor[0], fogcolor[1], fogcolor[2], 1, r_colorscale, mesh->numverts, modelorg); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + RSurf_FogPassColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], 1, r_colorscale, mesh->numverts, modelorg); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1203,10 +1195,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c const surfmesh_t *mesh; rmeshstate_t m; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_DST_COLOR; - m.blendfunc2 = GL_SRC_COLOR; + GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.detail); - R_Mesh_State(&m); GL_Color(1, 1, 1, 1); while((surf = *surfchain++) != NULL) { @@ -1214,10 +1206,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->abc, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoorddetail2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1229,10 +1221,10 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t const surfmesh_t *mesh; rmeshstate_t m; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + GL_DepthMask(false); + GL_DepthTest(true); m.tex[0] = R_GetTexture(texture->skin.glow); - R_Mesh_State(&m); GL_Color(r_colorscale, r_colorscale, r_colorscale, 1); while((surf = *surfchain++) != NULL) { @@ -1240,10 +1232,10 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1255,10 +1247,9 @@ static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, c const surfmesh_t *mesh; rmeshstate_t m; memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ZERO; + GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO); + GL_DepthMask(true); m.tex[0] = R_GetTexture(texture->skin.glow); - R_Mesh_State(&m); if (m.tex[0]) GL_Color(r_colorscale, r_colorscale, r_colorscale, 1); else @@ -1269,10 +1260,10 @@ static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, c { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - memcpy(varray_texcoord[0], mesh->str, mesh->numverts * sizeof(float[4])); - R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->index); + GL_VertexPointer(mesh->vertex3f); + m.pointer_texcoord[0] = mesh->texcoordtexture2f; + R_Mesh_State_Texture(&m); + R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i); } } } @@ -1325,7 +1316,7 @@ static void RSurfShader_Wall_Lightmap(const entity_render_t *ent, const texture_ } } } - else if (r_shadow_lightingmode >= 2) + else if (r_shadow_realtime_world.integer) { // opaque base lighting RSurfShader_OpaqueWall_Pass_OpaqueGlow(ent, texture, surfchain); @@ -1436,7 +1427,7 @@ void R_PrepareSurfaces(entity_render_t *ent) R_UpdateTextureInfo(ent); - if (r_dynamic.integer && r_shadow_lightingmode < 1) + if (r_dynamic.integer && !r_shadow_realtime_dlight.integer) R_MarkLights(ent); if (model->light_ambient != r_ambient.value || model->light_scalebit != r_lightmapscalebit) @@ -1506,12 +1497,15 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2) rmeshstate_t m; const entity_render_t *ent = calldata1; const mportal_t *portal = ent->model->portals + calldata2; - memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + GL_DepthMask(false); + GL_DepthTest(true); R_Mesh_Matrix(&ent->matrix); - R_Mesh_State(&m); - R_Mesh_ResizeCheck(portal->numpoints); + GL_VertexPointer(varray_vertex3f); + + memset(&m, 0, sizeof(m)); + R_Mesh_State_Texture(&m); + i = portal - ent->model->portals; GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f) * r_colorscale, ((i & 0x0038) >> 3) * (1.0f / 7.0f) * r_colorscale, @@ -1519,11 +1513,11 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2) 0.125f); if (PlaneDiff(r_origin, (&portal->plane)) > 0) { - for (i = portal->numpoints - 1, v = varray_vertex;i >= 0;i--, v += 4) + for (i = portal->numpoints - 1, v = varray_vertex3f;i >= 0;i--, v += 3) VectorCopy(portal->points[i].position, v); } else - for (i = 0, v = varray_vertex;i < portal->numpoints;i++, v += 4) + for (i = 0, v = varray_vertex3f;i < portal->numpoints;i++, v += 3) VectorCopy(portal->points[i].position, v); R_Mesh_Draw(portal->numpoints, portal->numpoints - 2, polygonelements); } @@ -1709,8 +1703,6 @@ static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf) } } } - if (r_drawportals.integer) - R_DrawPortals(ent); } void R_PVSUpdate (entity_render_t *ent, mleaf_t *viewleaf) @@ -1731,7 +1723,7 @@ void R_PVSUpdate (entity_render_t *ent, mleaf_t *viewleaf) if (viewleaf) { surfacepvsframes = model->surfacepvsframes; - vis = Mod_LeafPVS (viewleaf, model); + vis = model->LeafPVS(model, viewleaf); for (j = 0;j < model->numleafs;j += 8) { bits = *vis++; @@ -1755,7 +1747,7 @@ void R_PVSUpdate (entity_render_t *ent, mleaf_t *viewleaf) } } } - Mod_BuildPVSTextureChains(model); + model->BuildPVSTextureChains(model); } } } @@ -1766,7 +1758,7 @@ void R_WorldVisibility (entity_render_t *ent) mleaf_t *viewleaf; Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg); - viewleaf = Mod_PointInLeaf (modelorg, ent->model); + viewleaf = ent->model->PointInLeaf(ent->model, modelorg); R_PVSUpdate(ent, viewleaf); if (!viewleaf) @@ -1785,6 +1777,8 @@ void R_DrawWorld (entity_render_t *ent) R_PrepareSurfaces(ent); R_DrawSurfaces(ent, SHADERSTAGE_SKY, ent->model->pvstexturechains); R_DrawSurfaces(ent, SHADERSTAGE_NORMAL, ent->model->pvstexturechains); + if (r_drawportals.integer) + R_DrawPortals(ent); } void R_Model_Brush_DrawSky (entity_render_t *ent) @@ -1832,20 +1826,14 @@ void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelighto temp[1] = bound(surf->poly_mins[1], relativelightorigin[1], surf->poly_maxs[1]) - relativelightorigin[1]; temp[2] = bound(surf->poly_mins[2], relativelightorigin[2], surf->poly_maxs[2]) - relativelightorigin[2]; if (DotProduct(temp, temp) < lightradius2) - { for (mesh = surf->mesh;mesh;mesh = mesh->chain) - { - R_Mesh_ResizeCheck(mesh->numverts * 2); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Shadow_Volume(mesh->numverts, mesh->numtriangles, mesh->index, mesh->triangleneighbors, relativelightorigin, lightradius, projectdistance); - } - } + R_Shadow_Volume(mesh->numverts, mesh->numtriangles, mesh->vertex3f, mesh->element3i, mesh->neighbor3i, relativelightorigin, lightradius, projectdistance); } } } } -void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, msurface_t **surflist, int numsurfaces) +void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, msurface_t **surflist, int numsurfaces, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz) { int surfnum; msurface_t *surf; @@ -1865,92 +1853,47 @@ void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relative { for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->index, mesh->svectors, mesh->tvectors, mesh->normals, mesh->str, relativelightorigin, lightradius, lightcolor, t->skin.base, t->skin.nmap, NULL); - R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->index, mesh->svectors, mesh->tvectors, mesh->normals, mesh->str, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, t->skin.gloss, t->skin.nmap, NULL); + R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL); + R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL); } } } } } -void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor) +void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz) { int surfnum; msurface_t *surf; texture_t *t; - float f, lightradius2, temp[3]; + float f, lightmins[3], lightmaxs[3]; surfmesh_t *mesh; if (ent->model == NULL) return; R_Mesh_Matrix(&ent->matrix); - lightradius2 = lightradius * lightradius; + lightmins[0] = relativelightorigin[0] - lightradius; + lightmins[1] = relativelightorigin[1] - lightradius; + lightmins[2] = relativelightorigin[2] - lightradius; + lightmaxs[0] = relativelightorigin[0] + lightradius; + lightmaxs[1] = relativelightorigin[1] + lightradius; + lightmaxs[2] = relativelightorigin[2] + lightradius; R_UpdateTextureInfo(ent); - if (ent != &cl_entities[0].render) + for (surfnum = 0, surf = ent->model->surfaces + ent->model->firstmodelsurface;surfnum < ent->model->nummodelsurfaces;surfnum++, surf++) { - // bmodel, cull crudely to view and light - for (surfnum = 0, surf = ent->model->surfaces + ent->model->firstmodelsurface;surfnum < ent->model->nummodelsurfaces;surfnum++, surf++) + if ((ent != &cl_entities[0].render || surf->visframe == r_framecount) && BoxesOverlap(surf->poly_mins, surf->poly_maxs, lightmins, lightmaxs)) { - temp[0] = bound(surf->poly_mins[0], relativelightorigin[0], surf->poly_maxs[0]) - relativelightorigin[0]; - temp[1] = bound(surf->poly_mins[1], relativelightorigin[1], surf->poly_maxs[1]) - relativelightorigin[1]; - temp[2] = bound(surf->poly_mins[2], relativelightorigin[2], surf->poly_maxs[2]) - relativelightorigin[2]; - if (DotProduct(temp, temp) < lightradius2) - { - f = PlaneDiff(relativelightorigin, surf->plane); - if (surf->flags & SURF_PLANEBACK) - f = -f; - if (f >= -0.1 && f < lightradius) - { - f = PlaneDiff(relativeeyeorigin, surf->plane); - if (surf->flags & SURF_PLANEBACK) - f = -f; - if (f > 0) - { - t = surf->texinfo->texture->currentframe; - if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT) - { - for (mesh = surf->mesh;mesh;mesh = mesh->chain) - { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->index, mesh->svectors, mesh->tvectors, mesh->normals, mesh->str, relativelightorigin, lightradius, lightcolor, t->skin.base, t->skin.nmap, NULL); - R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->index, mesh->svectors, mesh->tvectors, mesh->normals, mesh->str, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, t->skin.gloss, t->skin.nmap, NULL); - } - } - } - } - } - } - } - else - { - // world, already culled to view, just cull to light - for (surfnum = 0, surf = ent->model->surfaces + ent->model->firstmodelsurface;surfnum < ent->model->nummodelsurfaces;surfnum++, surf++) - { - if (surf->visframe == r_framecount) + f = PlaneDiff(relativelightorigin, surf->plane); + if (surf->flags & SURF_PLANEBACK) + f = -f; + if (f >= -0.1 && f < lightradius) { - temp[0] = bound(surf->poly_mins[0], relativelightorigin[0], surf->poly_maxs[0]) - relativelightorigin[0]; - temp[1] = bound(surf->poly_mins[1], relativelightorigin[1], surf->poly_maxs[1]) - relativelightorigin[1]; - temp[2] = bound(surf->poly_mins[2], relativelightorigin[2], surf->poly_maxs[2]) - relativelightorigin[2]; - if (DotProduct(temp, temp) < lightradius2) + t = surf->texinfo->texture->currentframe; + if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT) { - f = PlaneDiff(relativelightorigin, surf->plane); - if (surf->flags & SURF_PLANEBACK) - f = -f; - if (f >= -0.1 && f < lightradius) + for (mesh = surf->mesh;mesh;mesh = mesh->chain) { - t = surf->texinfo->texture->currentframe; - if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT) - { - for (mesh = surf->mesh;mesh;mesh = mesh->chain) - { - R_Mesh_ResizeCheck(mesh->numverts); - memcpy(varray_vertex, mesh->verts, mesh->numverts * sizeof(float[4])); - R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->index, mesh->svectors, mesh->tvectors, mesh->normals, mesh->str, relativelightorigin, lightradius, lightcolor, t->skin.base, t->skin.nmap, NULL); - R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->index, mesh->svectors, mesh->tvectors, mesh->normals, mesh->str, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, t->skin.gloss, t->skin.nmap, NULL); - } - } + R_Shadow_DiffuseLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL); + R_Shadow_SpecularLighting(mesh->numverts, mesh->numtriangles, mesh->element3i, mesh->vertex3f, mesh->svector3f, mesh->tvector3f, mesh->normal3f, mesh->texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL); } } }