+ memcpy(batchelements, rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle, surface->num_triangles * sizeof(int[3]));
+ batchtriangles = surface->num_triangles;
+ firstvertex = surface->num_firstvertex;
+ endvertex = surface->num_firstvertex + surface->num_vertices;
+ for (;j < texturenumsurfaces;j++)
+ {
+ surface2 = texturesurfacelist[j];
+ if (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]));
+ batchtriangles += surface2->num_triangles;
+ firstvertex = min(firstvertex, surface2->num_firstvertex);
+ endvertex = max(endvertex, surface2->num_firstvertex + surface2->num_vertices);
+ }
+ surface2 = texturesurfacelist[j-1];
+ numvertices = endvertex - firstvertex;
+ R_Mesh_Draw(firstvertex, numvertices, batchtriangles, batchelements, 0, 0);
+ }
+ }
+ else if (r_batchmode.integer == 1)
+ {
+#if 0
+ Con_Printf("%s batch sizes ignoring lightmap:", rsurface_texture->name);
+ for (i = 0;i < texturenumsurfaces;i = j)
+ {
+ surface = texturesurfacelist[i];
+ for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
+ if (texturesurfacelist[j] != surface2)
+ break;
+ Con_Printf(" %i", j - i);
+ }
+ Con_Printf("\n");
+ Con_Printf("%s batch sizes honoring lightmap:", rsurface_texture->name);
+#endif
+ for (i = 0;i < texturenumsurfaces;i = j)
+ {
+ surface = texturesurfacelist[i];
+ R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
+ if (deluxemaptexunit >= 0)
+ R_Mesh_TexBind(deluxemaptexunit, R_GetTexture(surface->deluxemaptexture));
+ for (j = i + 1, surface2 = surface + 1;j < texturenumsurfaces;j++, surface2++)
+ if (texturesurfacelist[j] != surface2 || texturesurfacelist[j]->lightmaptexture != surface->lightmaptexture)
+ break;
+#if 0
+ Con_Printf(" %i", j - i);
+#endif
+ surface2 = texturesurfacelist[j-1];
+ numvertices = surface2->num_firstvertex + surface2->num_vertices - surface->num_firstvertex;
+ numtriangles = surface2->num_firsttriangle + surface2->num_triangles - surface->num_firsttriangle;
+ GL_LockArrays(surface->num_firstvertex, numvertices);
+ R_Mesh_Draw(surface->num_firstvertex, numvertices, numtriangles, (rsurface_model->surfmesh.data_element3i + 3 * surface->num_firsttriangle), rsurface_model->surfmesh.ebo, (sizeof(int[3]) * surface->num_firsttriangle));
+ }
+#if 0
+ Con_Printf("\n");
+#endif
+ }
+ else
+ {
+ for (i = 0;i < texturenumsurfaces;i++)
+ {
+ surface = texturesurfacelist[i];
+ R_Mesh_TexBind(lightmaptexunit, R_GetTexture(surface->lightmaptexture));
+ 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));
+ }
+ }
+}
+
+static void RSurf_DrawBatch_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ int j;
+ int texturesurfaceindex;
+ if (r_showsurfaces.integer == 2)
+ {
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (j = 0;j < surface->num_triangles;j++)
+ {
+ 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)));
+ }
+ }
+ }
+ else
+ {
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ 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));
+ }
+ }
+}
+
+static void RSurf_DrawBatch_GL11_ApplyFog(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ int texturesurfaceindex;
+ int i;
+ float f;
+ float *v, *c, *c2;
+ if (rsurface_lightmapcolor4f)
+ {
+ // generate color arrays for the surfaces in this list
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4, c2 += 4)
+ {
+ f = FogPoint_Model(v);
+ c2[0] = c[0] * f;
+ c2[1] = c[1] * f;
+ c2[2] = c[2] * f;
+ c2[3] = c[3];
+ }
+ }
+ }
+ else
+ {
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c2 += 4)
+ {
+ f = FogPoint_Model(v);
+ c2[0] = f;
+ c2[1] = f;
+ c2[2] = f;
+ c2[3] = 1;
+ }
+ }
+ }
+ rsurface_lightmapcolor4f = rsurface_array_color4f;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+}
+
+static void RSurf_DrawBatch_GL11_ApplyColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a)
+{
+ int texturesurfaceindex;
+ int i;
+ float *c, *c2;
+ if (!rsurface_lightmapcolor4f)
+ return;
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (i = 0, c = (rsurface_lightmapcolor4f + 4 * surface->num_firstvertex), c2 = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, c += 4, c2 += 4)
+ {
+ c2[0] = c[0] * r;
+ c2[1] = c[1] * g;
+ c2[2] = c[2] * b;
+ c2[3] = c[3] * a;
+ }
+ }
+ rsurface_lightmapcolor4f = rsurface_array_color4f;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+}
+
+static void RSurf_DrawBatch_GL11_Lightmap(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
+{
+ // TODO: optimize
+ rsurface_lightmapcolor4f = NULL;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+ if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
+ if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
+ R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+ GL_Color(r, g, b, a);
+ RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 0, -1);
+}
+
+static void RSurf_DrawBatch_GL11_Unlit(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
+{
+ // TODO: optimize applyfog && applycolor case
+ // just apply fog if necessary, and tint the fog color array if necessary
+ rsurface_lightmapcolor4f = NULL;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+ if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
+ if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
+ R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+ GL_Color(r, g, b, a);
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+}
+
+static void RSurf_DrawBatch_GL11_VertexColor(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
+{
+ int texturesurfaceindex;
+ int i;
+ float *c;
+ // TODO: optimize
+ if (texturesurfacelist[0]->lightmapinfo && texturesurfacelist[0]->lightmapinfo->stainsamples)
+ {
+ // generate color arrays for the surfaces in this list
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (i = 0, c = rsurface_array_color4f + 4 * surface->num_firstvertex;i < surface->num_vertices;i++, c += 4)
+ {
+ if (surface->lightmapinfo->samples)
+ {
+ const unsigned char *lm = surface->lightmapinfo->samples + (rsurface_model->surfmesh.data_lightmapoffsets + 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)
+ {
+ int size3 = ((surface->lightmapinfo->extents[0]>>4)+1)*((surface->lightmapinfo->extents[1]>>4)+1)*3;
+ lm += size3;
+ scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[1]] * (1.0f / 32768.0f);
+ VectorMA(c, scale, lm, c);
+ if (surface->lightmapinfo->styles[2] != 255)
+ {
+ lm += size3;
+ scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[2]] * (1.0f / 32768.0f);
+ VectorMA(c, scale, lm, c);
+ if (surface->lightmapinfo->styles[3] != 255)
+ {
+ lm += size3;
+ scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[3]] * (1.0f / 32768.0f);
+ VectorMA(c, scale, lm, c);
+ }
+ }
+ }
+ }
+ else
+ VectorClear(c);
+ c[3] = 1;
+ }
+ }
+ rsurface_lightmapcolor4f = rsurface_array_color4f;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+ }
+ else
+ {
+ rsurface_lightmapcolor4f = rsurface_model->surfmesh.data_lightmapcolor4f;
+ rsurface_lightmapcolor4f_bufferobject = rsurface_model->surfmesh.vbo;
+ rsurface_lightmapcolor4f_bufferoffset = rsurface_model->surfmesh.vbooffset_lightmapcolor4f;
+ }
+ if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
+ if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
+ R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+ GL_Color(r, g, b, a);
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+}
+
+static void RSurf_DrawBatch_GL11_VertexShade(int texturenumsurfaces, msurface_t **texturesurfacelist, float r, float g, float b, float a, qboolean applycolor, qboolean applyfog)
+{
+ int texturesurfaceindex;
+ int i;
+ float f;
+ float *v, *c, *c2;
+ vec3_t ambientcolor;
+ vec3_t diffusecolor;
+ vec3_t lightdir;
+ // TODO: optimize
+ // model lighting
+ VectorCopy(rsurface_entity->modellight_lightdir, lightdir);
+ ambientcolor[0] = rsurface_entity->modellight_ambient[0] * r * 0.5f;
+ ambientcolor[1] = rsurface_entity->modellight_ambient[1] * g * 0.5f;
+ ambientcolor[2] = rsurface_entity->modellight_ambient[2] * b * 0.5f;
+ diffusecolor[0] = rsurface_entity->modellight_diffuse[0] * r * 0.5f;
+ diffusecolor[1] = rsurface_entity->modellight_diffuse[1] * g * 0.5f;
+ diffusecolor[2] = rsurface_entity->modellight_diffuse[2] * b * 0.5f;
+ if (VectorLength2(diffusecolor) > 0)
+ {
+ // generate color arrays for the surfaces in this list
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ int numverts = surface->num_vertices;
+ v = rsurface_vertex3f + 3 * surface->num_firstvertex;
+ c2 = rsurface_normal3f + 3 * surface->num_firstvertex;
+ c = rsurface_array_color4f + 4 * surface->num_firstvertex;
+ // q3-style directional shading
+ for (i = 0;i < numverts;i++, v += 3, c2 += 3, c += 4)
+ {
+ if ((f = DotProduct(c2, lightdir)) > 0)
+ VectorMA(ambientcolor, f, diffusecolor, c);
+ else
+ VectorCopy(ambientcolor, c);
+ c[3] = a;
+ }
+ }
+ r = 1;
+ g = 1;
+ b = 1;
+ a = 1;
+ applycolor = false;
+ rsurface_lightmapcolor4f = rsurface_array_color4f;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+ }
+ else
+ {
+ r = ambientcolor[0];
+ g = ambientcolor[1];
+ b = ambientcolor[2];
+ rsurface_lightmapcolor4f = NULL;
+ rsurface_lightmapcolor4f_bufferobject = 0;
+ rsurface_lightmapcolor4f_bufferoffset = 0;
+ }
+ if (applyfog) RSurf_DrawBatch_GL11_ApplyFog(texturenumsurfaces, texturesurfacelist);
+ if (applycolor) RSurf_DrawBatch_GL11_ApplyColor(texturenumsurfaces, texturesurfacelist, r, g, b, a);
+ R_Mesh_ColorPointer(rsurface_lightmapcolor4f, rsurface_lightmapcolor4f_bufferobject, rsurface_lightmapcolor4f_bufferoffset);
+ GL_Color(r, g, b, a);
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+}
+
+static void R_DrawTextureSurfaceList_ShowSurfaces(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+ GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
+ GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+ if (rsurface_mode != RSURFMODE_SHOWSURFACES)
+ {
+ rsurface_mode = RSURFMODE_SHOWSURFACES;
+ GL_DepthMask(true);
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ R_Mesh_ResetTextureState();
+ }
+ RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
+ RSurf_DrawBatch_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
+}
+
+static void R_DrawTextureSurfaceList_Sky(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ // transparent sky would be ridiculous
+ if ((rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
+ return;
+ if (rsurface_mode != RSURFMODE_SKY)
+ {
+ if (rsurface_mode == RSURFMODE_GLSL)
+ {
+ qglUseProgramObjectARB(0);CHECKGLERROR
+ }
+ rsurface_mode = RSURFMODE_SKY;
+ }
+ if (skyrendernow)
+ {
+ skyrendernow = false;
+ R_Sky();
+ // restore entity matrix
+ R_Mesh_Matrix(&rsurface_entity->matrix);
+ }
+ GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+ GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
+ GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+ GL_DepthMask(true);
+ // LordHavoc: HalfLife maps have freaky skypolys so don't use
+ // skymasking on them, and Quake3 never did sky masking (unlike
+ // software Quake and software Quake2), so disable the sky masking
+ // 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)
+ {
+ 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);
+ R_Mesh_ResetTextureState();
+ if (skyrendermasked)
+ {
+ // depth-only (masking)
+ GL_ColorMask(0,0,0,0);
+ // just to make sure that braindead drivers don't draw
+ // anything despite that colormask...
+ GL_BlendFunc(GL_ZERO, GL_ONE);
+ }
+ else
+ {
+ // fog sky
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ }
+ RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+ if (skyrendermasked)
+ GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
+ }
+}
+
+static void R_DrawTextureSurfaceList_GL20(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ if (rsurface_mode != RSURFMODE_GLSL)
+ {
+ rsurface_mode = RSURFMODE_GLSL;
+ R_Mesh_ResetTextureState();
+ }
+
+ R_SetupSurfaceShader(vec3_origin, rsurface_lightmode == 2, 1, 1, rsurface_texture->specularscale);
+ if (!r_glsl_permutation)
+ return;
+
+ if (rsurface_lightmode == 2)
+ RSurf_PrepareVerticesForBatch(true, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
+ else
+ RSurf_PrepareVerticesForBatch(r_glsl_permutation->loc_Texture_Normal >= 0, r_glsl_permutation->loc_Texture_Normal >= 0, texturenumsurfaces, texturesurfacelist);
+ R_Mesh_TexCoordPointer(0, 2, rsurface_model->surfmesh.data_texcoordtexture2f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_texcoordtexture2f);
+ R_Mesh_TexCoordPointer(1, 3, rsurface_svector3f, rsurface_svector3f_bufferobject, rsurface_svector3f_bufferoffset);
+ R_Mesh_TexCoordPointer(2, 3, rsurface_tvector3f, rsurface_tvector3f_bufferobject, rsurface_tvector3f_bufferoffset);
+ R_Mesh_TexCoordPointer(3, 3, rsurface_normal3f, rsurface_normal3f_bufferobject, rsurface_normal3f_bufferoffset);
+ R_Mesh_TexCoordPointer(4, 2, rsurface_model->surfmesh.data_texcoordlightmap2f, rsurface_model->surfmesh.vbo, rsurface_model->surfmesh.vbooffset_texcoordlightmap2f);
+
+ if (rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT)
+ {
+ R_Mesh_TexBind(7, R_GetTexture(r_texture_white));
+ if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
+ R_Mesh_TexBind(8, R_GetTexture(r_texture_blanknormalmap));
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ }
+ else if (rsurface_uselightmaptexture)
+ {
+ R_Mesh_TexBind(7, R_GetTexture(texturesurfacelist[0]->lightmaptexture));
+ if (r_glsl_permutation->loc_Texture_Deluxemap >= 0)
+ R_Mesh_TexBind(8, R_GetTexture(texturesurfacelist[0]->deluxemaptexture));
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ }
+ else
+ {
+ 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);
+ }
+
+ if (rsurface_uselightmaptexture && !(rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT))
+ RSurf_DrawBatch_WithLightmapSwitching(texturenumsurfaces, texturesurfacelist, 7, r_glsl_permutation->loc_Texture_Deluxemap >= 0 ? 8 : -1);
+ else
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+ if (rsurface_texture->backgroundnumskinframes && !(rsurface_texture->currentmaterialflags & MATERIALFLAGMASK_DEPTHSORTED))
+ {
+ }
+}
+
+static void R_DrawTextureSurfaceList_GL13(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ // OpenGL 1.3 path - anything not completely ancient
+ int texturesurfaceindex;
+ qboolean applycolor;
+ qboolean applyfog;
+ rmeshstate_t m;
+ int layerindex;
+ const texturelayer_t *layer;
+ if (rsurface_mode != RSURFMODE_MULTIPASS)
+ rsurface_mode = RSURFMODE_MULTIPASS;
+ RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
+ for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
+ {
+ vec4_t layercolor;
+ int layertexrgbscale;
+ if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+ {
+ if (layerindex == 0)
+ GL_AlphaTest(true);
+ else
+ {
+ GL_AlphaTest(false);
+ qglDepthFunc(GL_EQUAL);CHECKGLERROR
+ }
+ }
+ GL_DepthMask(layer->depthmask);
+ GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
+ if ((layer->color[0] > 2 || layer->color[1] > 2 || layer->color[2] > 2) && (gl_combine.integer || layer->depthmask))
+ {
+ layertexrgbscale = 4;
+ VectorScale(layer->color, 0.25f, layercolor);
+ }
+ else if ((layer->color[0] > 1 || layer->color[1] > 1 || layer->color[2] > 1) && (gl_combine.integer || layer->depthmask))
+ {
+ layertexrgbscale = 2;
+ VectorScale(layer->color, 0.5f, layercolor);
+ }
+ else
+ {
+ layertexrgbscale = 1;
+ VectorScale(layer->color, 1.0f, layercolor);
+ }
+ layercolor[3] = layer->color[3];
+ applycolor = layercolor[0] != 1 || layercolor[1] != 1 || layercolor[2] != 1 || layercolor[3] != 1;
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
+ switch (layer->type)
+ {
+ 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.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;
+ R_Mesh_TextureState(&m);
+ if (rsurface_lightmode == 2)
+ RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
+ else if (rsurface_uselightmaptexture)
+ RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
+ else
+ RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
+ break;
+ case TEXTURELAYERTYPE_TEXTURE:
+ memset(&m, 0, sizeof(m));
+ 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;
+ R_Mesh_TextureState(&m);
+ RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layercolor[0], layercolor[1], layercolor[2], layercolor[3], applycolor, applyfog);
+ break;
+ case TEXTURELAYERTYPE_FOG:
+ memset(&m, 0, sizeof(m));
+ m.texrgbscale[0] = layertexrgbscale;
+ if (layer->texture)
+ {
+ 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;
+ }
+ R_Mesh_TextureState(&m);
+ // generate a color array for the fog pass
+ R_Mesh_ColorPointer(rsurface_array_color4f, 0, 0);
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ int i;
+ float f, *v, *c;
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
+ {
+ f = 1 - FogPoint_Model(v);
+ c[0] = layercolor[0];
+ c[1] = layercolor[1];
+ c[2] = layercolor[2];
+ c[3] = f * layercolor[3];
+ }
+ }
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+ break;
+ default:
+ Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
+ }
+ GL_LockArrays(0, 0);
+ }
+ CHECKGLERROR
+ if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+ {
+ qglDepthFunc(GL_LEQUAL);CHECKGLERROR
+ GL_AlphaTest(false);
+ }
+}
+
+static void R_DrawTextureSurfaceList_GL11(int texturenumsurfaces, msurface_t **texturesurfacelist)
+{
+ // OpenGL 1.1 - crusty old voodoo path
+ int texturesurfaceindex;
+ qboolean applyfog;
+ rmeshstate_t m;
+ int layerindex;
+ const texturelayer_t *layer;
+ if (rsurface_mode != RSURFMODE_MULTIPASS)
+ rsurface_mode = RSURFMODE_MULTIPASS;
+ RSurf_PrepareVerticesForBatch(true, false, texturenumsurfaces, texturesurfacelist);
+ for (layerindex = 0, layer = rsurface_texture->currentlayers;layerindex < rsurface_texture->currentnumlayers;layerindex++, layer++)
+ {
+ if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+ {
+ if (layerindex == 0)
+ GL_AlphaTest(true);
+ else
+ {
+ GL_AlphaTest(false);
+ qglDepthFunc(GL_EQUAL);CHECKGLERROR
+ }
+ }
+ GL_DepthMask(layer->depthmask);
+ GL_BlendFunc(layer->blendfunc1, layer->blendfunc2);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ applyfog = (layer->flags & TEXTURELAYERFLAG_FOGDARKEN) != 0;
+ switch (layer->type)
+ {
+ case TEXTURELAYERTYPE_LITTEXTURE:
+ if (layer->blendfunc1 == GL_ONE && layer->blendfunc2 == GL_ZERO)
+ {
+ // two-pass lit texture with 2x rgbscale
+ // 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;
+ R_Mesh_TextureState(&m);
+ if (rsurface_lightmode == 2)
+ RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
+ else if (rsurface_uselightmaptexture)
+ RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
+ else
+ RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
+ GL_LockArrays(0, 0);
+ // then apply the texture to it
+ GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
+ 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;
+ 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);
+ }
+ else
+ {
+ // single pass vertex-lighting-only texture with 1x rgbscale and transparency support
+ 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;
+ 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);
+ else
+ RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
+ }
+ break;
+ case TEXTURELAYERTYPE_TEXTURE:
+ // singletexture unlit texture with transparency support
+ 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;
+ R_Mesh_TextureState(&m);
+ RSurf_DrawBatch_GL11_Unlit(texturenumsurfaces, texturesurfacelist, layer->color[0], layer->color[1], layer->color[2], layer->color[3], layer->color[0] != 1 || layer->color[1] != 1 || layer->color[2] != 1 || layer->color[3] != 1, applyfog);
+ break;
+ case TEXTURELAYERTYPE_FOG:
+ // singletexture fogging
+ R_Mesh_ColorPointer(rsurface_array_color4f, 0, 0);
+ if (layer->texture)
+ {
+ memset(&m, 0, sizeof(m));
+ m.tex[0] = R_GetTexture(layer->texture);
+ m.texmatrix[0] = layer->texmatrix;
+ m.pointer_texcoord[0] = rsurface_model->surfmesh.data_texcoordtexture2f;
+ m.pointer_texcoord_bufferobject[0] = rsurface_model->surfmesh.vbo;
+ m.pointer_texcoord_bufferoffset[0] = rsurface_model->surfmesh.vbooffset_texcoordtexture2f;
+ R_Mesh_TextureState(&m);
+ }
+ else
+ R_Mesh_ResetTextureState();
+ // generate a color array for the fog pass
+ for (texturesurfaceindex = 0;texturesurfaceindex < texturenumsurfaces;texturesurfaceindex++)
+ {
+ int i;
+ float f, *v, *c;
+ const msurface_t *surface = texturesurfacelist[texturesurfaceindex];
+ for (i = 0, v = (rsurface_vertex3f + 3 * surface->num_firstvertex), c = (rsurface_array_color4f + 4 * surface->num_firstvertex);i < surface->num_vertices;i++, v += 3, c += 4)
+ {
+ f = 1 - FogPoint_Model(v);
+ c[0] = layer->color[0];
+ c[1] = layer->color[1];
+ c[2] = layer->color[2];
+ c[3] = f * layer->color[3];
+ }
+ }
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+ break;
+ default:
+ Con_Printf("R_DrawTextureSurfaceList: unknown layer type %i\n", layer->type);
+ }
+ GL_LockArrays(0, 0);
+ }
+ CHECKGLERROR
+ if (rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST)
+ {
+ qglDepthFunc(GL_LEQUAL);CHECKGLERROR
+ GL_AlphaTest(false);
+ }
+}
+
+static void R_DrawTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist, qboolean writedepth, qboolean depthonly)
+{
+ if (rsurface_texture->currentmaterialflags & MATERIALFLAG_NODRAW)
+ return;
+ r_shadow_rtlight = NULL;
+ CHECKGLERROR
+ if (depthonly)
+ {
+ if ((rsurface_texture->currentmaterialflags & (MATERIALFLAG_NODEPTHTEST | MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
+ return;
+ if (rsurface_mode != RSURFMODE_MULTIPASS)
+ rsurface_mode = RSURFMODE_MULTIPASS;
+ if (r_depthfirst.integer == 3)
+ {
+ int i = (int)(texturesurfacelist[0] - rsurface_model->data_surfaces);
+ GL_Color(((i >> 6) & 7) / 7.0f, ((i >> 3) & 7) / 7.0f, (i & 7) / 7.0f,1);
+ }
+ else
+ {
+ GL_ColorMask(0,0,0,0);
+ GL_Color(1,1,1,1);
+ }
+ GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+ GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+ GL_DepthTest(true);
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
+ GL_AlphaTest(false);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ R_Mesh_ResetTextureState();
+ RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
+ RSurf_DrawBatch_Simple(texturenumsurfaces, texturesurfacelist);
+ GL_ColorMask(r_view.colormask[0], r_view.colormask[1], r_view.colormask[2], 1);
+ r_refdef.stats.entities_surfaces += texturenumsurfaces;
+ }
+ else if (r_depthfirst.integer == 3)
+ return;
+ else if (r_showsurfaces.integer)
+ {
+ if (rsurface_mode != RSURFMODE_MULTIPASS)
+ rsurface_mode = RSURFMODE_MULTIPASS;
+ GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+ 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);
+ GL_DepthMask(writedepth);
+ GL_Color(1,1,1,1);
+ GL_AlphaTest(false);
+ R_Mesh_ColorPointer(NULL, 0, 0);
+ R_Mesh_ResetTextureState();
+ RSurf_PrepareVerticesForBatch(false, false, texturenumsurfaces, texturesurfacelist);
+ R_DrawTextureSurfaceList_ShowSurfaces(texturenumsurfaces, texturesurfacelist);
+ r_refdef.stats.entities_surfaces += texturenumsurfaces;
+ }
+ else if (gl_lightmaps.integer)
+ {
+ rmeshstate_t m;
+ if (rsurface_mode != RSURFMODE_MULTIPASS)
+ rsurface_mode = RSURFMODE_MULTIPASS;
+ GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+ 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);
+ GL_DepthMask(writedepth);
+ GL_Color(1,1,1,1);
+ GL_AlphaTest(false);
+ 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;
+ R_Mesh_TextureState(&m);
+ RSurf_PrepareVerticesForBatch(rsurface_lightmode == 2, false, texturenumsurfaces, texturesurfacelist);
+ if (rsurface_lightmode == 2)
+ RSurf_DrawBatch_GL11_VertexShade(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
+ else if (rsurface_uselightmaptexture)
+ RSurf_DrawBatch_GL11_Lightmap(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
+ else
+ RSurf_DrawBatch_GL11_VertexColor(texturenumsurfaces, texturesurfacelist, 1, 1, 1, 1, false, false);
+ r_refdef.stats.entities_surfaces += texturenumsurfaces;
+ }
+ else if (rsurface_texture->currentmaterialflags & MATERIALFLAG_SKY)
+ {
+ R_DrawTextureSurfaceList_Sky(texturenumsurfaces, texturesurfacelist);
+ r_refdef.stats.entities_surfaces += texturenumsurfaces;
+ }
+ else if (rsurface_texture->currentnumlayers)
+ {
+ // write depth for anything we skipped on the depth-only pass earlier
+ if (!writedepth && (rsurface_texture->currentmaterialflags & (MATERIALFLAG_BLENDED | MATERIALFLAG_ALPHATEST)))
+ writedepth = true;
+ GL_DepthRange(0, (rsurface_texture->currentmaterialflags & MATERIALFLAG_SHORTDEPTHRANGE) ? 0.0625 : 1);
+ GL_DepthTest(!(rsurface_texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST));
+ GL_CullFace((rsurface_texture->currentmaterialflags & MATERIALFLAG_NOCULLFACE) ? GL_NONE : GL_FRONT); // quake is backwards, this culls back faces
+ GL_BlendFunc(rsurface_texture->currentlayers[0].blendfunc1, rsurface_texture->currentlayers[0].blendfunc2);
+ GL_DepthMask(writedepth && !(rsurface_texture->currentmaterialflags & MATERIALFLAG_BLENDED));
+ GL_Color(rsurface_entity->colormod[0], rsurface_entity->colormod[1], rsurface_entity->colormod[2], rsurface_texture->currentalpha);
+ GL_AlphaTest((rsurface_texture->currentmaterialflags & MATERIALFLAG_ALPHATEST) != 0);
+ // FIXME: identify models using a better check than rsurface_model->brush.shadowmesh
+ rsurface_lightmode = ((rsurface_texture->currentmaterialflags & MATERIALFLAG_FULLBRIGHT) || rsurface_model->brush.shadowmesh) ? 0 : 2;
+ if (r_glsl.integer && gl_support_fragment_shader)
+ R_DrawTextureSurfaceList_GL20(texturenumsurfaces, texturesurfacelist);
+ else if (gl_combine.integer && r_textureunits.integer >= 2)
+ R_DrawTextureSurfaceList_GL13(texturenumsurfaces, texturesurfacelist);
+ else
+ R_DrawTextureSurfaceList_GL11(texturenumsurfaces, texturesurfacelist);
+ r_refdef.stats.entities_surfaces += texturenumsurfaces;
+ }
+ CHECKGLERROR
+ GL_LockArrays(0, 0);
+}
+
+static void R_DrawSurface_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
+{
+ int i, j;
+ int texturenumsurfaces, endsurface;
+ texture_t *texture;
+ msurface_t *surface;
+ msurface_t *texturesurfacelist[1024];
+
+ // if the model is static it doesn't matter what value we give for
+ // wantnormals and wanttangents, so this logic uses only rules applicable
+ // to a model, knowing that they are meaningless otherwise
+ if (ent == r_refdef.worldentity)
+ RSurf_ActiveWorldEntity();
+ else if ((ent->effects & EF_FULLBRIGHT) || r_showsurfaces.integer || VectorLength2(ent->modellight_diffuse) < (1.0f / 256.0f))
+ RSurf_ActiveModelEntity(ent, false, false);
+ else
+ RSurf_ActiveModelEntity(ent, true, r_glsl.integer && gl_support_fragment_shader);
+
+ for (i = 0;i < numsurfaces;i = j)
+ {
+ j = i + 1;
+ surface = rsurface_model->data_surfaces + surfacelist[i];
+ texture = surface->texture;
+ R_UpdateTextureInfo(ent, texture);
+ rsurface_texture = texture->currentframe;
+ rsurface_uselightmaptexture = surface->lightmaptexture != NULL;
+ // scan ahead until we find a different texture
+ endsurface = min(i + 1024, numsurfaces);
+ texturenumsurfaces = 0;
+ texturesurfacelist[texturenumsurfaces++] = surface;
+ for (;j < endsurface;j++)
+ {
+ surface = rsurface_model->data_surfaces + surfacelist[j];
+ if (texture != surface->texture || rsurface_uselightmaptexture != (surface->lightmaptexture != NULL))
+ break;
+ texturesurfacelist[texturenumsurfaces++] = surface;