huge (16%) speed gain on surface rendering by eliminating the surfmesh chain in q1bsp...
authorhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Mon, 22 Sep 2003 01:21:54 +0000 (01:21 +0000)
committerhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Mon, 22 Sep 2003 01:21:54 +0000 (01:21 +0000)
git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@3500 d7cf8633-e32d-0410-b094-e92efae38249

12 files changed:
cl_screen.c
cl_screen.h
cl_video.c
gl_draw.c
gl_rsurf.c
model_alias.c
model_brush.c
model_brush.h
model_shared.c
model_shared.h
portals.c
r_shadow.c

index d28453b..63668ca 100644 (file)
@@ -565,21 +565,21 @@ void DrawQ_SuperPic(float x, float y, char *picname, float width, float height,
                        height = pic->height;
                mesh.texture = pic->tex;
        }
-       mesh.numtriangles = 2;
-       mesh.numvertices = 4;
-       mesh.element3i = picelements;
-       mesh.vertex3f = floats;
-       mesh.texcoord2f = floats + 12;
-       mesh.color4f = floats + 20;
+       mesh.num_triangles = 2;
+       mesh.num_vertices = 4;
+       mesh.data_element3i = picelements;
+       mesh.data_vertex3f = floats;
+       mesh.data_texcoord2f = floats + 12;
+       mesh.data_color4f = floats + 20;
        memset(floats, 0, sizeof(floats));
-       mesh.vertex3f[0] = mesh.vertex3f[9] = x;
-       mesh.vertex3f[1] = mesh.vertex3f[4] = y;
-       mesh.vertex3f[3] = mesh.vertex3f[6] = x + width;
-       mesh.vertex3f[7] = mesh.vertex3f[10] = y + height;
-       mesh.texcoord2f[0] = s1;mesh.texcoord2f[1] = t1;mesh.color4f[ 0] = r1;mesh.color4f[ 1] = g1;mesh.color4f[ 2] = b1;mesh.color4f[ 3] = a1;
-       mesh.texcoord2f[2] = s2;mesh.texcoord2f[3] = t2;mesh.color4f[ 4] = r2;mesh.color4f[ 5] = g2;mesh.color4f[ 6] = b2;mesh.color4f[ 7] = a2;
-       mesh.texcoord2f[4] = s4;mesh.texcoord2f[5] = t4;mesh.color4f[ 8] = r4;mesh.color4f[ 9] = g4;mesh.color4f[10] = b4;mesh.color4f[11] = a4;
-       mesh.texcoord2f[6] = s3;mesh.texcoord2f[7] = t3;mesh.color4f[12] = r3;mesh.color4f[13] = g3;mesh.color4f[14] = b3;mesh.color4f[15] = a3;
+       mesh.data_vertex3f[0] = mesh.data_vertex3f[9] = x;
+       mesh.data_vertex3f[1] = mesh.data_vertex3f[4] = y;
+       mesh.data_vertex3f[3] = mesh.data_vertex3f[6] = x + width;
+       mesh.data_vertex3f[7] = mesh.data_vertex3f[10] = y + height;
+       mesh.data_texcoord2f[0] = s1;mesh.data_texcoord2f[1] = t1;mesh.data_color4f[ 0] = r1;mesh.data_color4f[ 1] = g1;mesh.data_color4f[ 2] = b1;mesh.data_color4f[ 3] = a1;
+       mesh.data_texcoord2f[2] = s2;mesh.data_texcoord2f[3] = t2;mesh.data_color4f[ 4] = r2;mesh.data_color4f[ 5] = g2;mesh.data_color4f[ 6] = b2;mesh.data_color4f[ 7] = a2;
+       mesh.data_texcoord2f[4] = s4;mesh.data_texcoord2f[5] = t4;mesh.data_color4f[ 8] = r4;mesh.data_color4f[ 9] = g4;mesh.data_color4f[10] = b4;mesh.data_color4f[11] = a4;
+       mesh.data_texcoord2f[6] = s3;mesh.data_texcoord2f[7] = t3;mesh.data_color4f[12] = r3;mesh.data_color4f[13] = g3;mesh.data_color4f[14] = b3;mesh.data_color4f[15] = a3;
        DrawQ_Mesh (&mesh, flags);
 }
 
@@ -591,10 +591,10 @@ void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
        drawqueuemesh_t *m;
        size = sizeof(*dq);
        size += sizeof(drawqueuemesh_t);
-       size += sizeof(int[3]) * mesh->numtriangles;
-       size += sizeof(float[3]) * mesh->numvertices;
-       size += sizeof(float[2]) * mesh->numvertices;
-       size += sizeof(float[4]) * mesh->numvertices;
+       size += sizeof(int[3]) * mesh->num_triangles;
+       size += sizeof(float[3]) * mesh->num_vertices;
+       size += sizeof(float[2]) * mesh->num_vertices;
+       size += sizeof(float[4]) * mesh->num_vertices;
        if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
                return;
        dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
@@ -608,13 +608,13 @@ void DrawQ_Mesh (drawqueuemesh_t *mesh, int flags)
        dq->scaley = 0;
        p = (void *)(dq + 1);
        m = p;(qbyte *)p += sizeof(drawqueuemesh_t);
-       m->numtriangles = mesh->numtriangles;
-       m->numvertices = mesh->numvertices;
+       m->num_triangles = mesh->num_triangles;
+       m->num_vertices = mesh->num_vertices;
        m->texture = mesh->texture;
-       m->element3i  = p;memcpy(m->element3i , mesh->element3i , m->numtriangles * sizeof(int[3]));(qbyte *)p += m->numtriangles * sizeof(int[3]);
-       m->vertex3f   = p;memcpy(m->vertex3f  , mesh->vertex3f  , m->numvertices * sizeof(float[3]));(qbyte *)p += m->numvertices * sizeof(float[3]);
-       m->texcoord2f = p;memcpy(m->texcoord2f, mesh->texcoord2f, m->numvertices * sizeof(float[2]));(qbyte *)p += m->numvertices * sizeof(float[2]);
-       m->color4f    = p;memcpy(m->color4f   , mesh->color4f   , m->numvertices * sizeof(float[4]));(qbyte *)p += m->numvertices * sizeof(float[4]);
+       m->data_element3i  = p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));(qbyte *)p += m->num_triangles * sizeof(int[3]);
+       m->data_vertex3f   = p;memcpy(m->data_vertex3f  , mesh->data_vertex3f  , m->num_vertices * sizeof(float[3]));(qbyte *)p += m->num_vertices * sizeof(float[3]);
+       m->data_texcoord2f = p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));(qbyte *)p += m->num_vertices * sizeof(float[2]);
+       m->data_color4f    = p;memcpy(m->data_color4f   , mesh->data_color4f   , m->num_vertices * sizeof(float[4]));(qbyte *)p += m->num_vertices * sizeof(float[4]);
        r_refdef.drawqueuesize += dq->size;
 }
 
index e153b99..881f5b5 100644 (file)
@@ -22,12 +22,12 @@ drawqueue_t;
 typedef struct drawqueuemesh_s
 {
        rtexture_t *texture;
-       int numtriangles;
-       int numvertices;
-       int *element3i;
-       float *vertex3f;
-       float *texcoord2f;
-       float *color4f;
+       int num_triangles;
+       int num_vertices;
+       int *data_element3i;
+       float *data_vertex3f;
+       float *data_texcoord2f;
+       float *data_color4f;
 }
 drawqueuemesh_t;
 
index debe422..b9b215d 100644 (file)
@@ -109,12 +109,12 @@ void CL_DrawVideo(void)
                vertex3f[ 6] = x2;vertex3f[ 7] = y2;vertex3f[ 8] = 0;
                vertex3f[ 9] = x1;vertex3f[10] = y2;vertex3f[11] = 0;
                mesh.texture = cl_videotexture;
-               mesh.numtriangles = 2;
-               mesh.numvertices = 4;
-               mesh.element3i = polygonelements;
-               mesh.vertex3f = vertex3f;
-               mesh.texcoord2f = texcoord2f;
-               mesh.color4f = color4f;
+               mesh.num_triangles = 2;
+               mesh.num_vertices = 4;
+               mesh.data_element3i = polygonelements;
+               mesh.data_vertex3f = vertex3f;
+               mesh.data_texcoord2f = texcoord2f;
+               mesh.data_color4f = color4f;
                DrawQ_Mesh(&mesh, 0);
                //DrawQ_Pic(0, 0, "engine_videoframe", vid.conwidth, vid.conheight, 1, 1, 1, 1, 0);
        }
index 6304fb8..3e0d58d 100644 (file)
--- a/gl_draw.c
+++ b/gl_draw.c
@@ -497,12 +497,12 @@ void R_DrawQueue(void)
                        break;
                case DRAWQUEUE_MESH:
                        mesh = (void *)(dq + 1);
-                       GL_VertexPointer(mesh->vertex3f);
-                       GL_ColorPointer(mesh->color4f);
+                       GL_VertexPointer(mesh->data_vertex3f);
+                       GL_ColorPointer(mesh->data_color4f);
                        m.tex[0] = R_GetTexture(mesh->texture);
-                       m.pointer_texcoord[0] = mesh->texcoord2f;
+                       m.pointer_texcoord[0] = mesh->data_texcoord2f;
                        R_Mesh_State_Texture(&m);
-                       R_Mesh_Draw(mesh->numvertices, mesh->numtriangles, mesh->element3i);
+                       R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
                        currentpic = "\0";
                        break;
                }
index e4f3767..ba73451 100644 (file)
@@ -703,7 +703,6 @@ static int RSurf_LightSeparate_Vertex3f_Color4f(const matrix4x4_t *matrix, const
 static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
 
        // LordHavoc: HalfLife maps have freaky skypolys...
@@ -743,11 +742,8 @@ static void RSurfShader_Sky(const entity_render_t *ent, const texture_t *texture
        {
                if (surf->visframe == r_framecount)
                {
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
        qglColorMask(1,1,1,1);
@@ -758,7 +754,6 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
        const entity_render_t *ent = calldata1;
        const msurface_t *surf = ent->model->brushq1.surfaces + calldata2;
        float colorscale;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        float alpha;
        float modelorg[3];
@@ -828,20 +823,19 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
                qglTexEnvfv (GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, &args[0]);
                qglEnable (GL_TEXTURE_SHADER_NV);
        }
-       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+
+       GL_VertexPointer(surf->mesh.data_vertex3f);
+       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+       m.pointer_texcoord[1] = surf->mesh.data_texcoordtexture2f;
+       m.texcombinergb[1] = GL_REPLACE;
+       R_Mesh_State_Texture(&m);
+       if (fogenabled)
        {
-               GL_VertexPointer(mesh->vertex3f);
-               m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-               m.pointer_texcoord[1] = mesh->texcoordtexture2f;
-               m.texcombinergb[1] = GL_REPLACE;
-               R_Mesh_State_Texture(&m);
-               if (fogenabled)
-               {
-                       R_FillColors(varray_color4f, mesh->numverts, 1, 1, 1, alpha);
-                       RSurf_FogColors_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, colorscale, mesh->numverts, modelorg);
-               }
-               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
+               R_FillColors(varray_color4f, surf->mesh.num_vertices, 1, 1, 1, alpha);
+               RSurf_FogColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, colorscale, surf->mesh.num_vertices, modelorg);
        }
+       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
+
        if (gl_textureshader && r_watershader.integer)
        {
                qglDisable (GL_TEXTURE_SHADER_NV);
@@ -855,15 +849,12 @@ static void RSurfShader_Water_Callback(const void *calldata1, int calldata2)
                GL_DepthMask(false);
                GL_DepthTest(true);
                m.tex[0] = R_GetTexture(texture->skin.fog);
-               for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-               {
-                       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, 1, mesh->numverts, modelorg);
-                       R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-               }
+               GL_VertexPointer(surf->mesh.data_vertex3f);
+               m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+               GL_ColorPointer(varray_color4f);
+               R_Mesh_State_Texture(&m);
+               RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], alpha, 1, surf->mesh.num_vertices, modelorg);
+               R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
        }
 
        if (r_waterscroll.value)
@@ -899,7 +890,6 @@ static void RSurfShader_Water(const entity_render_t *ent, const texture_t *textu
 static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
 {
        float base, colorscale;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        float modelorg[3];
        Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -929,27 +919,24 @@ static void RSurfShader_Wall_Pass_BaseVertex(const entity_render_t *ent, const m
        base = ent->effects & EF_FULLBRIGHT ? 2.0f : r_ambient.value * (1.0f / 64.0f);
        GL_DepthTest(true);
        GL_ColorPointer(varray_color4f);
-       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+
+       GL_VertexPointer(surf->mesh.data_vertex3f);
+       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+       R_Mesh_State_Texture(&m);
+       R_FillColors(varray_color4f, surf->mesh.num_vertices, base, base, base, currentalpha);
+       if (!(ent->effects & EF_FULLBRIGHT))
        {
-               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_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, mesh->numverts, mesh->vertex3f, varray_color4f, 1);
-                       if (surf->flags & SURF_LIGHTMAP)
-                               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_Vertex3f_Color4f(mesh->vertex3f, varray_color4f, colorscale, mesh->numverts, modelorg);
-               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
+               if (surf->dlightframe == r_framecount)
+                       RSurf_LightSeparate_Vertex3f_Color4f(&ent->inversematrix, surf->dlightbits, surf->mesh.num_vertices, surf->mesh.data_vertex3f, varray_color4f, 1);
+               if (surf->flags & SURF_LIGHTMAP)
+                       RSurf_AddLightmapToVertexColors_Color4f(surf->mesh.data_lightmapoffsets, varray_color4f,surf->mesh.num_vertices, surf->samples, ((surf->extents[0]>>4)+1)*((surf->extents[1]>>4)+1)*3, surf->styles);
        }
+       RSurf_FogColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, colorscale, surf->mesh.num_vertices, modelorg);
+       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 }
 
 static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
 {
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        float modelorg[3];
        Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -959,20 +946,17 @@ static void RSurfShader_Wall_Pass_Glow(const entity_render_t *ent, const msurfac
        GL_DepthTest(true);
        m.tex[0] = R_GetTexture(texture->skin.glow);
        GL_ColorPointer(varray_color4f);
-       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-       {
-               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, 1, mesh->numverts, modelorg);
-               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-       }
+
+       GL_VertexPointer(surf->mesh.data_vertex3f);
+       if (m.tex[0])
+               m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+       R_Mesh_State_Texture(&m);
+       RSurf_FoggedColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, 1, 1, 1, currentalpha, 1, surf->mesh.num_vertices, modelorg);
+       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 }
 
 static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface_t *surf, const texture_t *texture, int rendertype, float currentalpha)
 {
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        float modelorg[3];
        Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -982,21 +966,18 @@ static void RSurfShader_Wall_Pass_Fog(const entity_render_t *ent, const msurface
        GL_DepthTest(true);
        m.tex[0] = R_GetTexture(texture->skin.fog);
        GL_ColorPointer(varray_color4f);
-       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-       {
-               GL_VertexPointer(mesh->vertex3f);
-               if (m.tex[0])
-                       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, 1, mesh->numverts, modelorg);
-               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-       }
+
+       GL_VertexPointer(surf->mesh.data_vertex3f);
+       if (m.tex[0])
+               m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+       R_Mesh_State_Texture(&m);
+       RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], currentalpha, 1, surf->mesh.num_vertices, modelorg);
+       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
 }
 
 static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        int lightmaptexturenum;
        float cl;
@@ -1023,15 +1004,12 @@ static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render
                                m.tex[1] = lightmaptexturenum;
                        //      R_Mesh_State_Texture(&m);
                        //}
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               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);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+                       m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
+                       m.pointer_texcoord[2] = surf->mesh.data_texcoorddetail2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1039,7 +1017,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseTripleTexCombine(const entity_render
 static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        int lightmaptexturenum;
        memset(&m, 0, sizeof(m));
@@ -1061,14 +1038,11 @@ static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent
                                m.tex[1] = lightmaptexturenum;
                        //      R_Mesh_State_Texture(&m);
                        //}
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               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);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+                       m.pointer_texcoord[1] = surf->mesh.data_texcoordlightmap2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1076,7 +1050,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseDoubleTex(const entity_render_t *ent
 static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        memset(&m, 0, sizeof(m));
        GL_DepthMask(true);
@@ -1088,13 +1061,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent,
        {
                if (surf->visframe == r_framecount)
                {
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-                               R_Mesh_State_Texture(&m);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1102,7 +1072,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseTexture(const entity_render_t *ent,
 static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        int lightmaptexturenum;
        memset(&m, 0, sizeof(m));
@@ -1123,13 +1092,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
                                m.tex[0] = lightmaptexturenum;
                        //      R_Mesh_State_Texture(&m);
                        //}
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               m.pointer_texcoord[0] = mesh->texcoordlightmap2f;
-                               R_Mesh_State_Texture(&m);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoordlightmap2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1137,7 +1103,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseLightmap(const entity_render_t *ent,
 static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        float modelorg[3];
        Matrix4x4_Transform(&ent->inversematrix, r_origin, modelorg);
@@ -1150,15 +1115,12 @@ static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const te
        {
                if (surf->visframe == r_framecount)
                {
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               if (m.tex[0])
-                                       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, 1, mesh->numverts, modelorg);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       if (m.tex[0])
+                               m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+                       R_Mesh_State_Texture(&m);
+                       RSurf_FogPassColors_Vertex3f_Color4f(surf->mesh.data_vertex3f, varray_color4f, fogcolor[0], fogcolor[1], fogcolor[2], 1, 1, surf->mesh.num_vertices, modelorg);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1166,7 +1128,6 @@ static void RSurfShader_OpaqueWall_Pass_Fog(const entity_render_t *ent, const te
 static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        memset(&m, 0, sizeof(m));
        GL_BlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
@@ -1178,13 +1139,10 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c
        {
                if (surf->visframe == r_framecount)
                {
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               m.pointer_texcoord[0] = mesh->texcoorddetail2f;
-                               R_Mesh_State_Texture(&m);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoorddetail2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1192,7 +1150,6 @@ static void RSurfShader_OpaqueWall_Pass_BaseDetail(const entity_render_t *ent, c
 static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        memset(&m, 0, sizeof(m));
        GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
@@ -1204,13 +1161,10 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t
        {
                if (surf->visframe == r_framecount)
                {
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-                               R_Mesh_State_Texture(&m);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1218,7 +1172,6 @@ static void RSurfShader_OpaqueWall_Pass_Glow(const entity_render_t *ent, const t
 static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, const texture_t *texture, msurface_t **surfchain)
 {
        const msurface_t *surf;
-       const surfmesh_t *mesh;
        rmeshstate_t m;
        memset(&m, 0, sizeof(m));
        GL_BlendFunc(GL_SRC_ALPHA, GL_ZERO);
@@ -1232,13 +1185,10 @@ static void RSurfShader_OpaqueWall_Pass_OpaqueGlow(const entity_render_t *ent, c
        {
                if (surf->visframe == r_framecount)
                {
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                       {
-                               GL_VertexPointer(mesh->vertex3f);
-                               m.pointer_texcoord[0] = mesh->texcoordtexture2f;
-                               R_Mesh_State_Texture(&m);
-                               R_Mesh_Draw(mesh->numverts, mesh->numtriangles, mesh->element3i);
-                       }
+                       GL_VertexPointer(surf->mesh.data_vertex3f);
+                       m.pointer_texcoord[0] = surf->mesh.data_texcoordtexture2f;
+                       R_Mesh_State_Texture(&m);
+                       R_Mesh_Draw(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i);
                }
        }
 }
@@ -1752,7 +1702,6 @@ void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelighto
        int i;
        msurface_t *surf;
        float projectdistance, f, temp[3], lightradius2;
-       surfmesh_t *mesh;
        if (ent->model == NULL)
                return;
        R_Mesh_Matrix(&ent->matrix);
@@ -1773,8 +1722,7 @@ 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_Shadow_Volume(mesh->numverts, mesh->numtriangles, mesh->vertex3f, mesh->element3i, mesh->neighbor3i, relativelightorigin, lightradius, projectdistance);
+                                       R_Shadow_Volume(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_vertex3f, surf->mesh.data_element3i, surf->mesh.data_neighbor3i, relativelightorigin, lightradius, projectdistance);
                        }
                }
        }
@@ -1785,7 +1733,6 @@ void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relative
        int surfnum;
        msurface_t *surf;
        texture_t *t;
-       surfmesh_t *mesh;
        if (ent->model == NULL)
                return;
        R_Mesh_Matrix(&ent->matrix);
@@ -1798,11 +1745,8 @@ void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relative
                        t = surf->texinfo->texture->currentframe;
                        if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
                        {
-                               for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                               {
-                                       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);
-                               }
+                               R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL);
+                               R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL);
                        }
                }
        }
@@ -1814,7 +1758,6 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
        msurface_t *surf;
        texture_t *t;
        float f, lightmins[3], lightmaxs[3];
-       surfmesh_t *mesh;
        if (ent->model == NULL)
                return;
        R_Mesh_Matrix(&ent->matrix);
@@ -1837,11 +1780,8 @@ void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
                                t = surf->texinfo->texture->currentframe;
                                if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
                                {
-                                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
-                                       {
-                                               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);
-                                       }
+                                       R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, NULL);
+                                       R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, NULL);
                                }
                        }
                }
@@ -1860,7 +1800,7 @@ void R_DrawCollisionBrush(colbrushf_t *brush)
 void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
 {
        rmeshstate_t m;
-       if (!face->numtriangles)
+       if (!face->num_triangles)
                return;
        if (face->texture->renderflags)
        {
@@ -1896,7 +1836,7 @@ void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
                        R_Mesh_State_Texture(&m);
 
                        GL_VertexPointer(face->data_vertex3f);
-                       R_Mesh_Draw(face->numvertices, face->numtriangles, face->data_element3i);
+                       R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
                        qglColorMask(1,1,1,1);
                        return;
                }
@@ -1925,7 +1865,7 @@ void R_Q3BSP_DrawFace(entity_render_t *ent, q3mface_t *face)
        }
        R_Mesh_State_Texture(&m);
        GL_VertexPointer(face->data_vertex3f);
-       R_Mesh_Draw(face->numvertices, face->numtriangles, face->data_element3i);
+       R_Mesh_Draw(face->num_vertices, face->num_triangles, face->data_element3i);
 }
 
 /*
@@ -2023,16 +1963,16 @@ void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin,
                //else
                        for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
                                if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
-                                       R_Shadow_Volume(face->numvertices, face->numtriangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
+                                       R_Shadow_Volume(face->num_vertices, face->num_triangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
        }
 }
 
 void R_Q3BSP_DrawFaceLight(entity_render_t *ent, q3mface_t *face, 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)
 {
-       if ((face->texture->renderflags & Q3MTEXTURERENDERFLAGS_NODRAW) || !face->numtriangles)
+       if ((face->texture->renderflags & Q3MTEXTURERENDERFLAGS_NODRAW) || !face->num_triangles)
                return;
-       R_Shadow_DiffuseLighting(face->numvertices, face->numtriangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.base, face->texture->skin.nmap, NULL);
-       R_Shadow_SpecularLighting(face->numvertices, face->numtriangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.gloss, face->texture->skin.nmap, NULL);
+       R_Shadow_DiffuseLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.base, face->texture->skin.nmap, NULL);
+       R_Shadow_SpecularLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.gloss, face->texture->skin.nmap, NULL);
 }
 
 void R_Q3BSP_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)
index c43a37d..aab89ad 100644 (file)
@@ -981,8 +981,8 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer)
        loadmodel->flags = 0; // there are no flags
        loadmodel->numframes = pheader->numscenes;
        loadmodel->synctype = ST_SYNC;
-       //loadmodel->numtris = pheader->numtris;
-       //loadmodel->numverts = 0;
+       //loadmodel->num_triangles = pheader->num_triangles;
+       //loadmodel->num_vertices = 0;
 
        {
                unsigned int i;
index 92ae090..a3e8047 100644 (file)
@@ -169,7 +169,6 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in
        float surfnormal[3];
 #endif
        msurface_t *surf;
-       surfmesh_t *mesh;
        for (surfnum = 0, mark = leaf->firstmarksurface;surfnum < leaf->nummarksurfaces;surfnum++, mark++)
        {
                surf = info->model->brushq1.surfaces + *mark;
@@ -180,103 +179,100 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in
                        if (surf->flags & SURF_PLANEBACK)
                                VectorNegate(surfnormal, surfnormal);
 #endif
-                       for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+                       for (k = 0;k < surf->mesh.num_triangles;k++)
                        {
-                               for (k = 0;k < mesh->numtriangles;k++)
+                               tri = surf->mesh.data_element3i + k * 3;
+                               VectorCopy((surf->mesh.data_vertex3f + tri[0] * 3), vert[0]);
+                               VectorCopy((surf->mesh.data_vertex3f + tri[1] * 3), vert[1]);
+                               VectorCopy((surf->mesh.data_vertex3f + tri[2] * 3), vert[2]);
+                               VectorSubtract(vert[1], vert[0], edge[0]);
+                               VectorSubtract(vert[2], vert[1], edge[1]);
+                               CrossProduct(edge[1], edge[0], facenormal);
+                               if (facenormal[0] || facenormal[1] || facenormal[2])
                                {
-                                       tri = mesh->element3i + k * 3;
-                                       VectorCopy((mesh->vertex3f + tri[0] * 3), vert[0]);
-                                       VectorCopy((mesh->vertex3f + tri[1] * 3), vert[1]);
-                                       VectorCopy((mesh->vertex3f + tri[2] * 3), vert[2]);
-                                       VectorSubtract(vert[1], vert[0], edge[0]);
-                                       VectorSubtract(vert[2], vert[1], edge[1]);
-                                       CrossProduct(edge[1], edge[0], facenormal);
-                                       if (facenormal[0] || facenormal[1] || facenormal[2])
+                                       VectorNormalize(facenormal);
+#if 0
+                                       if (VectorDistance(facenormal, surfnormal) > 0.01f)
+                                               Con_Printf("a2! %f %f %f != %f %f %f\n", facenormal[0], facenormal[1], facenormal[2], surfnormal[0], surfnormal[1], surfnormal[2]);
+#endif
+                                       f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
+                                       if (f <= info->bestdist && f >= -info->bestdist)
                                        {
-                                               VectorNormalize(facenormal);
+                                               VectorSubtract(vert[0], vert[2], edge[2]);
+                                               VectorNormalize(edge[0]);
+                                               VectorNormalize(edge[1]);
+                                               VectorNormalize(edge[2]);
+                                               CrossProduct(facenormal, edge[0], edgenormal[0]);
+                                               CrossProduct(facenormal, edge[1], edgenormal[1]);
+                                               CrossProduct(facenormal, edge[2], edgenormal[2]);
 #if 0
-                                               if (VectorDistance(facenormal, surfnormal) > 0.01f)
-                                                       Con_Printf("a2! %f %f %f != %f %f %f\n", facenormal[0], facenormal[1], facenormal[2], surfnormal[0], surfnormal[1], surfnormal[2]);
+                                               if (samelevel.integer & 1)
+                                                       VectorNegate(edgenormal[0], edgenormal[0]);
+                                               if (samelevel.integer & 2)
+                                                       VectorNegate(edgenormal[1], edgenormal[1]);
+                                               if (samelevel.integer & 4)
+                                                       VectorNegate(edgenormal[2], edgenormal[2]);
+                                               for (i = 0;i < 3;i++)
+                                                       if (DotProduct(vert[0], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
+                                                        || DotProduct(vert[1], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
+                                                        || DotProduct(vert[2], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f)
+                                                               Con_Printf("a! %i : %f %f %f (%f %f %f)\n", i, edgenormal[i][0], edgenormal[i][1], edgenormal[i][2], facenormal[0], facenormal[1], facenormal[2]);
 #endif
-                                               f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
-                                               if (f <= info->bestdist && f >= -info->bestdist)
+                                               // face distance
+                                               if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
+                                                && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
+                                                && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2]))
                                                {
-                                                       VectorSubtract(vert[0], vert[2], edge[2]);
-                                                       VectorNormalize(edge[0]);
-                                                       VectorNormalize(edge[1]);
-                                                       VectorNormalize(edge[2]);
-                                                       CrossProduct(facenormal, edge[0], edgenormal[0]);
-                                                       CrossProduct(facenormal, edge[1], edgenormal[1]);
-                                                       CrossProduct(facenormal, edge[2], edgenormal[2]);
-#if 0
-                                                       if (samelevel.integer & 1)
-                                                               VectorNegate(edgenormal[0], edgenormal[0]);
-                                                       if (samelevel.integer & 2)
-                                                               VectorNegate(edgenormal[1], edgenormal[1]);
-                                                       if (samelevel.integer & 4)
-                                                               VectorNegate(edgenormal[2], edgenormal[2]);
+                                                       // we got lucky, the center is within the face
+                                                       dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
+                                                       if (dist < 0)
+                                                       {
+                                                               dist = -dist;
+                                                               if (info->bestdist > dist)
+                                                               {
+                                                                       info->bestdist = dist;
+                                                                       VectorScale(facenormal, (info->radius - -dist), info->nudge);
+                                                               }
+                                                       }
+                                                       else
+                                                       {
+                                                               if (info->bestdist > dist)
+                                                               {
+                                                                       info->bestdist = dist;
+                                                                       VectorScale(facenormal, (info->radius - dist), info->nudge);
+                                                               }
+                                                       }
+                                               }
+                                               else
+                                               {
+                                                       // check which edge or vertex the center is nearest
                                                        for (i = 0;i < 3;i++)
-                                                               if (DotProduct(vert[0], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
-                                                                || DotProduct(vert[1], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
-                                                                || DotProduct(vert[2], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f)
-                                                                       Con_Printf("a! %i : %f %f %f (%f %f %f)\n", i, edgenormal[i][0], edgenormal[i][1], edgenormal[i][2], facenormal[0], facenormal[1], facenormal[2]);
-#endif
-                                                       // face distance
-                                                       if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
-                                                        && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
-                                                        && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2]))
                                                        {
-                                                               // we got lucky, the center is within the face
-                                                               dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
-                                                               if (dist < 0)
+                                                               f = DotProduct(info->center, edge[i]);
+                                                               if (f >= DotProduct(vert[0], edge[i])
+                                                                && f <= DotProduct(vert[1], edge[i]))
                                                                {
-                                                                       dist = -dist;
+                                                                       // on edge
+                                                                       VectorMA(info->center, -f, edge[i], point);
+                                                                       dist = sqrt(DotProduct(point, point));
                                                                        if (info->bestdist > dist)
                                                                        {
                                                                                info->bestdist = dist;
-                                                                               VectorScale(facenormal, (info->radius - -dist), info->nudge);
+                                                                               VectorScale(point, (info->radius / dist), info->nudge);
                                                                        }
+                                                                       // skip both vertex checks
+                                                                       // (both are further away than this edge)
+                                                                       i++;
                                                                }
                                                                else
                                                                {
+                                                                       // not on edge, check first vertex of edge
+                                                                       VectorSubtract(info->center, vert[i], point);
+                                                                       dist = sqrt(DotProduct(point, point));
                                                                        if (info->bestdist > dist)
                                                                        {
                                                                                info->bestdist = dist;
-                                                                               VectorScale(facenormal, (info->radius - dist), info->nudge);
-                                                                       }
-                                                               }
-                                                       }
-                                                       else
-                                                       {
-                                                               // check which edge or vertex the center is nearest
-                                                               for (i = 0;i < 3;i++)
-                                                               {
-                                                                       f = DotProduct(info->center, edge[i]);
-                                                                       if (f >= DotProduct(vert[0], edge[i])
-                                                                        && f <= DotProduct(vert[1], edge[i]))
-                                                                       {
-                                                                               // on edge
-                                                                               VectorMA(info->center, -f, edge[i], point);
-                                                                               dist = sqrt(DotProduct(point, point));
-                                                                               if (info->bestdist > dist)
-                                                                               {
-                                                                                       info->bestdist = dist;
-                                                                                       VectorScale(point, (info->radius / dist), info->nudge);
-                                                                               }
-                                                                               // skip both vertex checks
-                                                                               // (both are further away than this edge)
-                                                                               i++;
-                                                                       }
-                                                                       else
-                                                                       {
-                                                                               // not on edge, check first vertex of edge
-                                                                               VectorSubtract(info->center, vert[i], point);
-                                                                               dist = sqrt(DotProduct(point, point));
-                                                                               if (info->bestdist > dist)
-                                                                               {
-                                                                                       info->bestdist = dist;
-                                                                                       VectorScale(point, (info->radius / dist), info->nudge);
-                                                                               }
+                                                                               VectorScale(point, (info->radius / dist), info->nudge);
                                                                        }
                                                                }
                                                        }
@@ -1492,13 +1488,13 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surf)
                Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?\n");
 
        surf->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
-       mesh->numverts = subdivpolyverts;
-       mesh->numtriangles = subdivpolytriangles;
+       mesh->num_vertices = subdivpolyverts;
+       mesh->num_triangles = subdivpolytriangles;
        mesh->vertex = (surfvertex_t *)(mesh + 1);
-       mesh->index = (int *)(mesh->vertex + mesh->numverts);
-       memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
+       mesh->index = (int *)(mesh->vertex + mesh->num_vertices);
+       memset(mesh->vertex, 0, mesh->num_vertices * sizeof(surfvertex_t));
 
-       for (i = 0;i < mesh->numtriangles;i++)
+       for (i = 0;i < mesh->num_triangles;i++)
                for (j = 0;j < 3;j++)
                        mesh->index[i*3+j] = subdivpolyindex[i][j];
 
@@ -1515,18 +1511,18 @@ static surfmesh_t *Mod_Q1BSP_AllocSurfMesh(int numverts, int numtriangles)
 {
        surfmesh_t *mesh;
        mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + numtriangles * sizeof(int[6]) + numverts * (3 + 2 + 2 + 2 + 3 + 3 + 3 + 1) * sizeof(float));
-       mesh->numverts = numverts;
-       mesh->numtriangles = numtriangles;
-       mesh->vertex3f = (float *)(mesh + 1);
-       mesh->texcoordtexture2f = mesh->vertex3f + mesh->numverts * 3;
-       mesh->texcoordlightmap2f = mesh->texcoordtexture2f + mesh->numverts * 2;
-       mesh->texcoorddetail2f = mesh->texcoordlightmap2f + mesh->numverts * 2;
-       mesh->svector3f = (float *)(mesh->texcoorddetail2f + mesh->numverts * 2);
-       mesh->tvector3f = mesh->svector3f + mesh->numverts * 3;
-       mesh->normal3f = mesh->tvector3f + mesh->numverts * 3;
-       mesh->lightmapoffsets = (int *)(mesh->normal3f + mesh->numverts * 3);
-       mesh->element3i = mesh->lightmapoffsets + mesh->numverts;
-       mesh->neighbor3i = mesh->element3i + mesh->numtriangles * 3;
+       mesh->num_vertices = numverts;
+       mesh->num_triangles = numtriangles;
+       mesh->data_vertex3f = (float *)(mesh + 1);
+       mesh->data_texcoordtexture2f = mesh->data_vertex3f + mesh->num_vertices * 3;
+       mesh->data_texcoordlightmap2f = mesh->data_texcoordtexture2f + mesh->num_vertices * 2;
+       mesh->data_texcoorddetail2f = mesh->data_texcoordlightmap2f + mesh->num_vertices * 2;
+       mesh->data_svector3f = (float *)(mesh->data_texcoorddetail2f + mesh->num_vertices * 2);
+       mesh->data_tvector3f = mesh->data_svector3f + mesh->num_vertices * 3;
+       mesh->data_normal3f = mesh->data_tvector3f + mesh->num_vertices * 3;
+       mesh->data_lightmapoffsets = (int *)(mesh->data_normal3f + mesh->num_vertices * 3);
+       mesh->data_element3i = mesh->data_lightmapoffsets + mesh->num_vertices;
+       mesh->data_neighbor3i = mesh->data_element3i + mesh->num_triangles * 3;
        return mesh;
 }
 
@@ -1665,52 +1661,51 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
        }
 
        loadmodel->brushq1.entiremesh = Mod_Q1BSP_AllocSurfMesh(totalverts, totaltris);
-       loadmodel->brushq1.surfmeshes = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) * totalmeshes);
 
        for (surfnum = 0, surf = loadmodel->brushq1.surfaces, totalverts = 0, totaltris = 0, totalmeshes = 0;surfnum < count;surfnum++, totalverts += surf->poly_numverts, totaltris += surf->poly_numverts - 2, totalmeshes++, surf++)
        {
-               mesh = surf->mesh = loadmodel->brushq1.surfmeshes + totalmeshes;
-               mesh->numverts = surf->poly_numverts;
-               mesh->numtriangles = surf->poly_numverts - 2;
-               mesh->vertex3f = loadmodel->brushq1.entiremesh->vertex3f + totalverts * 3;
-               mesh->texcoordtexture2f = loadmodel->brushq1.entiremesh->texcoordtexture2f + totalverts * 2;
-               mesh->texcoordlightmap2f = loadmodel->brushq1.entiremesh->texcoordlightmap2f + totalverts * 2;
-               mesh->texcoorddetail2f = loadmodel->brushq1.entiremesh->texcoorddetail2f + totalverts * 2;
-               mesh->svector3f = loadmodel->brushq1.entiremesh->svector3f + totalverts * 3;
-               mesh->tvector3f = loadmodel->brushq1.entiremesh->tvector3f + totalverts * 3;
-               mesh->normal3f = loadmodel->brushq1.entiremesh->normal3f + totalverts * 3;
-               mesh->lightmapoffsets = loadmodel->brushq1.entiremesh->lightmapoffsets + totalverts;
-               mesh->element3i = loadmodel->brushq1.entiremesh->element3i + totaltris * 3;
-               mesh->neighbor3i = loadmodel->brushq1.entiremesh->neighbor3i + totaltris * 3;
+               mesh = &surf->mesh;
+               mesh->num_vertices = surf->poly_numverts;
+               mesh->num_triangles = surf->poly_numverts - 2;
+               mesh->data_vertex3f = loadmodel->brushq1.entiremesh->data_vertex3f + totalverts * 3;
+               mesh->data_texcoordtexture2f = loadmodel->brushq1.entiremesh->data_texcoordtexture2f + totalverts * 2;
+               mesh->data_texcoordlightmap2f = loadmodel->brushq1.entiremesh->data_texcoordlightmap2f + totalverts * 2;
+               mesh->data_texcoorddetail2f = loadmodel->brushq1.entiremesh->data_texcoorddetail2f + totalverts * 2;
+               mesh->data_svector3f = loadmodel->brushq1.entiremesh->data_svector3f + totalverts * 3;
+               mesh->data_tvector3f = loadmodel->brushq1.entiremesh->data_tvector3f + totalverts * 3;
+               mesh->data_normal3f = loadmodel->brushq1.entiremesh->data_normal3f + totalverts * 3;
+               mesh->data_lightmapoffsets = loadmodel->brushq1.entiremesh->data_lightmapoffsets + totalverts;
+               mesh->data_element3i = loadmodel->brushq1.entiremesh->data_element3i + totaltris * 3;
+               mesh->data_neighbor3i = loadmodel->brushq1.entiremesh->data_neighbor3i + totaltris * 3;
 
                surf->lightmaptexturestride = 0;
                surf->lightmaptexture = NULL;
 
-               for (i = 0;i < mesh->numverts;i++)
+               for (i = 0;i < mesh->num_vertices;i++)
                {
-                       mesh->vertex3f[i * 3 + 0] = surf->poly_verts[i * 3 + 0];
-                       mesh->vertex3f[i * 3 + 1] = surf->poly_verts[i * 3 + 1];
-                       mesh->vertex3f[i * 3 + 2] = surf->poly_verts[i * 3 + 2];
-                       s = DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
-                       t = DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
-                       mesh->texcoordtexture2f[i * 2 + 0] = s / surf->texinfo->texture->width;
-                       mesh->texcoordtexture2f[i * 2 + 1] = t / surf->texinfo->texture->height;
-                       mesh->texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
-                       mesh->texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
-                       mesh->texcoordlightmap2f[i * 2 + 0] = 0;
-                       mesh->texcoordlightmap2f[i * 2 + 1] = 0;
-                       mesh->lightmapoffsets[i] = 0;
+                       mesh->data_vertex3f[i * 3 + 0] = surf->poly_verts[i * 3 + 0];
+                       mesh->data_vertex3f[i * 3 + 1] = surf->poly_verts[i * 3 + 1];
+                       mesh->data_vertex3f[i * 3 + 2] = surf->poly_verts[i * 3 + 2];
+                       s = DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
+                       t = DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
+                       mesh->data_texcoordtexture2f[i * 2 + 0] = s / surf->texinfo->texture->width;
+                       mesh->data_texcoordtexture2f[i * 2 + 1] = t / surf->texinfo->texture->height;
+                       mesh->data_texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
+                       mesh->data_texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
+                       mesh->data_texcoordlightmap2f[i * 2 + 0] = 0;
+                       mesh->data_texcoordlightmap2f[i * 2 + 1] = 0;
+                       mesh->data_lightmapoffsets[i] = 0;
                }
 
-               for (i = 0;i < mesh->numtriangles;i++)
+               for (i = 0;i < mesh->num_triangles;i++)
                {
-                       mesh->element3i[i * 3 + 0] = 0;
-                       mesh->element3i[i * 3 + 1] = i + 1;
-                       mesh->element3i[i * 3 + 2] = i + 2;
+                       mesh->data_element3i[i * 3 + 0] = 0;
+                       mesh->data_element3i[i * 3 + 1] = i + 1;
+                       mesh->data_element3i[i * 3 + 2] = i + 2;
                }
 
-               Mod_BuildTriangleNeighbors(mesh->neighbor3i, mesh->element3i, mesh->numtriangles);
-               Mod_BuildTextureVectorsAndNormals(mesh->numverts, mesh->numtriangles, mesh->vertex3f, mesh->texcoordtexture2f, mesh->element3i, mesh->svector3f, mesh->tvector3f, mesh->normal3f);
+               Mod_BuildTriangleNeighbors(mesh->data_neighbor3i, mesh->data_element3i, mesh->num_triangles);
+               Mod_BuildTextureVectorsAndNormals(mesh->num_vertices, mesh->num_triangles, mesh->data_vertex3f, mesh->data_texcoordtexture2f, mesh->data_element3i, mesh->data_svector3f, mesh->data_tvector3f, mesh->data_normal3f);
 
                if (surf->texinfo->texture->shader == &Cshader_wall_lightmap)
                {
@@ -1735,16 +1730,16 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l)
                        uscale = (uscale - ubase) / (smax + 1);
                        vscale = (vscale - vbase) / (tmax + 1);
 
-                       for (i = 0;i < mesh->numverts;i++)
+                       for (i = 0;i < mesh->num_vertices;i++)
                        {
-                               u = ((DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]) + 8 - surf->texturemins[0]) * (1.0 / 16.0);
-                               v = ((DotProduct((mesh->vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]) + 8 - surf->texturemins[1]) * (1.0 / 16.0);
-                               mesh->texcoordlightmap2f[i * 2 + 0] = u * uscale + ubase;
-                               mesh->texcoordlightmap2f[i * 2 + 1] = v * vscale + vbase;
+                               u = ((DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]) + 8 - surf->texturemins[0]) * (1.0 / 16.0);
+                               v = ((DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]) + 8 - surf->texturemins[1]) * (1.0 / 16.0);
+                               mesh->data_texcoordlightmap2f[i * 2 + 0] = u * uscale + ubase;
+                               mesh->data_texcoordlightmap2f[i * 2 + 1] = v * vscale + vbase;
                                // LordHavoc: calc lightmap data offset for vertex lighting to use
                                iu = (int) u;
                                iv = (int) v;
-                               mesh->lightmapoffsets[i] = (bound(0, iv, tmax) * (smax+1) + bound(0, iu, smax)) * 3;
+                               mesh->data_lightmapoffsets[i] = (bound(0, iv, tmax) * (smax+1) + bound(0, iu, smax)) * 3;
                        }
                }
        }
@@ -2655,7 +2650,6 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
        model_t *originalloadmodel;
        float dist, modelyawradius, modelradius, *vec;
        msurface_t *surf;
-       surfmesh_t *mesh;
 
        mod->type = mod_brush;
 
@@ -2775,23 +2769,20 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer)
                                if (mod->brush.numsubmodels - 1)
                                        surf->flags |= SURF_SOLIDCLIP;
                                // calculate bounding shapes
-                               for (mesh = surf->mesh;mesh;mesh = mesh->chain)
+                               for (k = 0, vec = surf->mesh.data_vertex3f;k < surf->mesh.num_vertices;k++, vec += 3)
                                {
-                                       for (k = 0, vec = mesh->vertex3f;k < mesh->numverts;k++, vec += 3)
-                                       {
-                                               if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
-                                               if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
-                                               if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
-                                               if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
-                                               if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
-                                               if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
-                                               dist = vec[0]*vec[0]+vec[1]*vec[1];
-                                               if (modelyawradius < dist)
-                                                       modelyawradius = dist;
-                                               dist += vec[2]*vec[2];
-                                               if (modelradius < dist)
-                                                       modelradius = dist;
-                                       }
+                                       if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
+                                       if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
+                                       if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
+                                       if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
+                                       if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
+                                       if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
+                                       dist = vec[0]*vec[0]+vec[1]*vec[1];
+                                       if (modelyawradius < dist)
+                                               modelyawradius = dist;
+                                       dist += vec[2]*vec[2];
+                                       if (modelradius < dist)
+                                               modelradius = dist;
                                }
                        }
                        modelyawradius = sqrt(modelyawradius);
@@ -3629,25 +3620,24 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
                        out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n];
 
                out->firstvertex = LittleLong(in->firstvertex);
-               out->numvertices = LittleLong(in->numvertices);
+               out->num_vertices = LittleLong(in->numvertices);
                out->firstelement = LittleLong(in->firstelement);
-               out->numelements = LittleLong(in->numelements);
-               out->numtriangles = out->numelements / 3;
-               if (out->firstvertex < 0 || out->firstvertex + out->numvertices > loadmodel->brushq3.num_vertices)
+               out->num_triangles = LittleLong(in->numelements) / 3;
+               if (out->num_triangles * 3 != LittleLong(in->numelements))
                {
-                       Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, out->firstvertex, out->firstvertex + out->numvertices, loadmodel->brushq3.num_vertices);
+                       Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, LittleLong(in->numelements));
                        out->type = 0; // error
                        continue;
                }
-               if (out->firstelement < 0 || out->firstelement + out->numelements > loadmodel->brushq3.num_triangles * 3)
+               if (out->firstvertex < 0 || out->firstvertex + out->num_vertices > loadmodel->brushq3.num_vertices)
                {
-                       Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, out->firstelement, out->firstelement + out->numelements, loadmodel->brushq3.num_triangles * 3);
+                       Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, out->firstvertex, out->firstvertex + out->num_vertices, loadmodel->brushq3.num_vertices);
                        out->type = 0; // error
                        continue;
                }
-               if (out->numtriangles * 3 != out->numelements)
+               if (out->firstelement < 0 || out->firstelement + out->num_triangles * 3 > loadmodel->brushq3.num_triangles * 3)
                {
-                       Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, out->numelements);
+                       Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, out->firstelement, out->firstelement + out->num_triangles * 3, loadmodel->brushq3.num_triangles * 3);
                        out->type = 0; // error
                        continue;
                }
@@ -3702,10 +3692,9 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
                        out->data_neighbor3i = out->data_element3i + finaltriangles * 3;
                        out->type = Q3FACETYPE_MESH;
                        out->firstvertex = -1;
-                       out->numvertices = finalvertices;
+                       out->num_vertices = finalvertices;
                        out->firstelement = -1;
-                       out->numtriangles = finaltriangles;
-                       out->numelements = finaltriangles * 3;
+                       out->num_triangles = finaltriangles;
                        // generate geometry
                        // (note: normals are skipped because they get recalculated)
                        QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_vertex3f);
@@ -3730,13 +3719,13 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
                                        row1++;
                                }
                        }
-                       out->numtriangles = Mod_RemoveDegenerateTriangles(out->numtriangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
+                       out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
                        if (developer.integer)
                        {
-                               if (out->numtriangles < finaltriangles)
-                                       Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->numvertices, finaltriangles, finaltriangles - out->numtriangles, out->numtriangles);
+                               if (out->num_triangles < finaltriangles)
+                                       Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
                                else
-                                       Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->numvertices, out->numtriangles);
+                                       Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles);
                        }
                        // q3map does not put in collision brushes for curves... ugh
                        out->collisions = true;
@@ -3744,35 +3733,35 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l)
                case Q3FACETYPE_FLARE:
                        Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
                        // don't render it
-                       out->numtriangles = 0;
+                       out->num_triangles = 0;
                        break;
                }
-               for (j = 0, invalidelements = 0;j < out->numelements;j++)
-                       if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->numvertices)
+               for (j = 0, invalidelements = 0;j < out->num_triangles * 3;j++)
+                       if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->num_vertices)
                                invalidelements++;
                if (invalidelements)
                {
-                       Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, out->type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, out->firstvertex, out->numvertices, out->firstelement, out->numelements);
-                       for (j = 0;j < out->numelements;j++)
+                       Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, out->type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, out->firstvertex, out->num_vertices, out->firstelement, out->num_triangles * 3);
+                       for (j = 0;j < out->num_triangles * 3;j++)
                        {
                                Con_Printf(" %i", out->data_element3i[j]);
-                               if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->numvertices)
+                               if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->num_vertices)
                                        out->data_element3i[j] = 0;
                        }
                        Con_Printf("\n");
                }
                // for shadow volumes
-               Mod_BuildTriangleNeighbors(out->data_neighbor3i, out->data_element3i, out->numtriangles);
+               Mod_BuildTriangleNeighbors(out->data_neighbor3i, out->data_element3i, out->num_triangles);
                // for per pixel lighting
-               Mod_BuildTextureVectorsAndNormals(out->numvertices, out->numtriangles, out->data_vertex3f, out->data_texcoordtexture2f, out->data_element3i, out->data_svector3f, out->data_tvector3f, out->data_normal3f);
+               Mod_BuildTextureVectorsAndNormals(out->num_vertices, out->num_triangles, out->data_vertex3f, out->data_texcoordtexture2f, out->data_element3i, out->data_svector3f, out->data_tvector3f, out->data_normal3f);
                // calculate a bounding box
                VectorClear(out->mins);
                VectorClear(out->maxs);
-               if (out->numvertices)
+               if (out->num_vertices)
                {
                        VectorCopy(out->data_vertex3f, out->mins);
                        VectorCopy(out->data_vertex3f, out->maxs);
-                       for (j = 1, v = out->data_vertex3f + 3;j < out->numvertices;j++, v += 3)
+                       for (j = 1, v = out->data_vertex3f + 3;j < out->num_vertices;j++, v += 3)
                        {
                                out->mins[0] = min(out->mins[0], v[0]);
                                out->maxs[0] = max(out->maxs[0], v[0]);
@@ -4167,7 +4156,7 @@ static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, q3mnode_t *node
                        {
                                face->collisionmarkframe = markframe;
                                if (BoxesOverlap(segmentmins, segmentmaxs, face->mins, face->maxs))
-                                       Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+                                       Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
                        }
                }
        }
@@ -4251,7 +4240,7 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, q3mnode_t *nod
                                face = leaf->firstleafface[i];
                                // note: this can not be optimized with a face->collisionmarkframe because each triangle of the face would need to be marked as done individually (because each one is bbox culled individually), and if all are marked, then the face could be marked as done
                                if (face->collisions && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
-                                       Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+                                       Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
                        }
                }
        }
@@ -4290,7 +4279,7 @@ static void Mod_Q3BSP_TraceBox(model_t *model, trace_t *trace, const vec3_t boxs
                                {
                                        face = model->brushq3.data_thismodel->firstface + i;
                                        if (face->collisions)
-                                               Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+                                               Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
                                }
                        }
                }
@@ -4313,7 +4302,7 @@ static void Mod_Q3BSP_TraceBox(model_t *model, trace_t *trace, const vec3_t boxs
                                {
                                        face = model->brushq3.data_thismodel->firstface + i;
                                        if (face->collisions)
-                                               Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->numtriangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+                                               Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
                                }
                        }
                }
index 17e6935..609793c 100644 (file)
@@ -145,20 +145,18 @@ mtexinfo_t;
 // LordHavoc: replaces glpoly, triangle mesh
 typedef struct surfmesh_s
 {
-       // can be multiple meshs per surface
-       struct surfmesh_s *chain;
-       int numverts; // number of vertices in the mesh
-       int numtriangles; // number of triangles in the mesh
-       float *vertex3f; // float[verts*3] vertex locations
-       float *svector3f; // float[verts*3] direction of 'S' (right) texture axis for each vertex
-       float *tvector3f; // float[verts*3] direction of 'T' (down) texture axis for each vertex
-       float *normal3f; // float[verts*3] direction of 'R' (out) texture axis for each vertex
-       int *lightmapoffsets; // index into surface's lightmap samples for vertex lighting
-       float *texcoordtexture2f; // float[verts*2] texcoords for surface texture
-       float *texcoordlightmap2f; // float[verts*2] texcoords for lightmap texture
-       float *texcoorddetail2f; // float[verts*2] texcoords for detail texture
-       int *element3i; // int[tris*3] triangles of the mesh, 3 indices into vertex arrays for each
-       int *neighbor3i; // int[tris*3] neighboring triangle on each edge (-1 if none)
+       int num_vertices; // number of vertices in the mesh
+       int num_triangles; // number of triangles in the mesh
+       float *data_vertex3f; // float[verts*3] vertex locations
+       float *data_svector3f; // float[verts*3] direction of 'S' (right) texture axis for each vertex
+       float *data_tvector3f; // float[verts*3] direction of 'T' (down) texture axis for each vertex
+       float *data_normal3f; // float[verts*3] direction of 'R' (out) texture axis for each vertex
+       int *data_lightmapoffsets; // index into surface's lightmap samples for vertex lighting
+       float *data_texcoordtexture2f; // float[verts*2] texcoords for surface texture
+       float *data_texcoordlightmap2f; // float[verts*2] texcoords for lightmap texture
+       float *data_texcoorddetail2f; // float[verts*2] texcoords for detail texture
+       int *data_element3i; // int[tris*3] triangles of the mesh, 3 indices into vertex arrays for each
+       int *data_neighbor3i; // int[tris*3] neighboring triangle on each edge (-1 if none)
 }
 surfmesh_t;
 
@@ -178,7 +176,7 @@ typedef struct msurface_s
        // the lightmap texture fragment to use on the rendering mesh
        rtexture_t *lightmaptexture;
        // mesh for rendering
-       surfmesh_t *mesh;
+       surfmesh_t mesh;
        // if lightmap settings changed, this forces update
        int cached_dlight;
 
index 5c578e3..4126b4a 100644 (file)
@@ -655,7 +655,7 @@ void Mod_ShadowMesh_AddPolygon(mempool_t *mempool, shadowmesh_t *mesh, int numve
        /*
        int i, i1, i2, i3;
        float *v;
-       while (mesh->numverts + numverts > mesh->maxverts || mesh->numtriangles + (numverts - 2) > mesh->maxtriangles)
+       while (mesh->num_vertices + numverts > mesh->maxverts || mesh->num_triangles + (numverts - 2) > mesh->maxtriangles)
        {
                if (mesh->next == NULL)
                        mesh->next = Mod_ShadowMesh_Alloc(mempool, max(mesh->maxtriangles, numverts));
@@ -668,10 +668,10 @@ void Mod_ShadowMesh_AddPolygon(mempool_t *mempool, shadowmesh_t *mesh, int numve
        {
                i2 = i3;
                i3 = Mod_ShadowMesh_AddVertex(mesh, v);
-               mesh->elements[mesh->numtriangles * 3 + 0] = i1;
-               mesh->elements[mesh->numtriangles * 3 + 1] = i2;
-               mesh->elements[mesh->numtriangles * 3 + 2] = i3;
-               mesh->numtriangles++;
+               mesh->elements[mesh->num_triangles * 3 + 0] = i1;
+               mesh->elements[mesh->num_triangles * 3 + 1] = i2;
+               mesh->elements[mesh->num_triangles * 3 + 2] = i3;
+               mesh->num_triangles++;
        }
        */
 }
@@ -703,7 +703,7 @@ shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh)
                        newmesh->next = firstmesh;
                        firstmesh = newmesh;
                        //Con_Printf("mesh\n");
-                       //for (i = 0;i < newmesh->numtriangles;i++)
+                       //for (i = 0;i < newmesh->num_triangles;i++)
                        //      Con_Printf("tri %d %d %d\n", newmesh->elements[i * 3 + 0], newmesh->elements[i * 3 + 1], newmesh->elements[i * 3 + 2]);
                        Mod_ValidateElements(newmesh->element3i, newmesh->numtriangles, newmesh->numverts, __FILE__, __LINE__);
                        Mod_BuildTriangleNeighbors(newmesh->neighbor3i, newmesh->element3i, newmesh->numtriangles);
@@ -714,8 +714,8 @@ shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh)
        shadowmesh_t *mesh;
        for (mesh = firstmesh;mesh;mesh = mesh->next)
        {
-               Mod_ValidateElements(mesh->elements, mesh->numtriangles, mesh->numverts, __FILE__, __LINE__);
-               Mod_BuildTriangleNeighbors(mesh->neighbors, mesh->elements, mesh->numtriangles);
+               Mod_ValidateElements(mesh->elements, mesh->num_triangles, mesh->num_vertices, __FILE__, __LINE__);
+               Mod_BuildTriangleNeighbors(mesh->neighbors, mesh->elements, mesh->num_triangles);
        }
 #endif
        return firstmesh;
index e87a913..92a42ae 100644 (file)
@@ -202,7 +202,6 @@ typedef struct model_brushq1_s
        int                             *surfacepvsframes;
        msurface_t              *surfacepvsnext;
        surfmesh_t              *entiremesh;
-       surfmesh_t              *surfmeshes;
 
        int                             numsurfedges;
        int                             *surfedges;
@@ -358,9 +357,7 @@ typedef struct q3mface_s
        int collisionmarkframe; // don't collide twice in one trace
        int type;
        int firstvertex;
-       int numvertices;
        int firstelement;
-       int numelements;
        int patchsize[2];
        // used for processing
        int markframe;
@@ -370,6 +367,8 @@ typedef struct q3mface_s
        float mins[3];
        float maxs[3];
 
+       int num_vertices;
+       int num_triangles;
        float *data_vertex3f;
        float *data_texcoordtexture2f;
        float *data_texcoordlightmap2f;
@@ -377,7 +376,6 @@ typedef struct q3mface_s
        float *data_tvector3f;
        float *data_normal3f;
        float *data_color4f;
-       int numtriangles;
        int *data_element3i;
        int *data_neighbor3i;
 }
index 725374b..da91b8f 100644 (file)
--- a/portals.c
+++ b/portals.c
@@ -339,7 +339,6 @@ void Portal_RecursiveFlow_ExactMarkSurfaces(portalrecursioninfo_t *info, int *ma
        int i, j, *elements;
        vec3_t trimins, trimaxs;
        msurface_t *surf;
-       surfmesh_t *surfmesh;
        for (i = 0;i < nummarksurfaces;i++, mark++)
        {
                if (!info->surfacemark[*mark])
@@ -362,30 +361,25 @@ void Portal_RecursiveFlow_ExactMarkSurfaces(portalrecursioninfo_t *info, int *ma
                        }
                        else
                        {
-                               for (surfmesh = surf->mesh;surfmesh;surfmesh = surfmesh->chain)
+                               for (j = 0, elements = surf->mesh.data_element3i;j < surf->mesh.num_triangles;j++, elements += 3)
                                {
-                                       for (j = 0, elements = surfmesh->element3i;j < surfmesh->numtriangles;j++, elements += 3)
+                                       VectorCopy((surf->mesh.data_vertex3f + elements[0] * 3), trianglepoints[0]);
+                                       VectorCopy((surf->mesh.data_vertex3f + elements[1] * 3), trianglepoints[1]);
+                                       VectorCopy((surf->mesh.data_vertex3f + elements[2] * 3), trianglepoints[2]);
+                                       if (PointInfrontOfTriangle(info->eye, trianglepoints[0], trianglepoints[1], trianglepoints[2]))
                                        {
-                                               VectorCopy((surfmesh->vertex3f + elements[0] * 3), trianglepoints[0]);
-                                               VectorCopy((surfmesh->vertex3f + elements[1] * 3), trianglepoints[1]);
-                                               VectorCopy((surfmesh->vertex3f + elements[2] * 3), trianglepoints[2]);
-                                               if (PointInfrontOfTriangle(info->eye, trianglepoints[0], trianglepoints[1], trianglepoints[2]))
-                                               {
-                                                       trimins[0] = min(trianglepoints[0][0], min(trianglepoints[1][0], trianglepoints[2][0]));
-                                                       trimaxs[0] = max(trianglepoints[0][0], max(trianglepoints[1][0], trianglepoints[2][0]));
-                                                       trimins[1] = min(trianglepoints[0][1], min(trianglepoints[1][1], trianglepoints[2][1]));
-                                                       trimaxs[1] = max(trianglepoints[0][1], max(trianglepoints[1][1], trianglepoints[2][1]));
-                                                       trimins[2] = min(trianglepoints[0][2], min(trianglepoints[1][2], trianglepoints[2][2]));
-                                                       trimaxs[2] = max(trianglepoints[0][2], max(trianglepoints[1][2], trianglepoints[2][2]));
-                                                       if (BoxesOverlap(trimins, trimaxs, info->boxmins, info->boxmaxs))
-                                                               if (Portal_PortalThroughPortalPlanes(&portalplanes[firstclipplane], numclipplanes, trianglepoints[0], 3, &portaltemppoints2[0][0], 256) >= 3)
-                                                                       break;
-                                               }
+                                               trimins[0] = min(trianglepoints[0][0], min(trianglepoints[1][0], trianglepoints[2][0]));
+                                               trimaxs[0] = max(trianglepoints[0][0], max(trianglepoints[1][0], trianglepoints[2][0]));
+                                               trimins[1] = min(trianglepoints[0][1], min(trianglepoints[1][1], trianglepoints[2][1]));
+                                               trimaxs[1] = max(trianglepoints[0][1], max(trianglepoints[1][1], trianglepoints[2][1]));
+                                               trimins[2] = min(trianglepoints[0][2], min(trianglepoints[1][2], trianglepoints[2][2]));
+                                               trimaxs[2] = max(trianglepoints[0][2], max(trianglepoints[1][2], trianglepoints[2][2]));
+                                               if (BoxesOverlap(trimins, trimaxs, info->boxmins, info->boxmaxs))
+                                                       if (Portal_PortalThroughPortalPlanes(&portalplanes[firstclipplane], numclipplanes, trianglepoints[0], 3, &portaltemppoints2[0][0], 256) >= 3)
+                                                               break;
                                        }
-                                       if (j < surfmesh->numtriangles)
-                                               break;
                                }
-                               if (surfmesh == NULL)
+                               if (j == surf->mesh.num_triangles)
                                        continue;
                        }
                        info->surfacemark[*mark] = true;
index 9782378..52e4f35 100644 (file)
@@ -1711,7 +1711,6 @@ void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style
        shadowmesh_t *mesh, *castmesh;
        mleaf_t *leaf;
        msurface_t *surf;
-       surfmesh_t *surfmesh;
 
        if (radius < 15 || DotProduct(color, color) < 0.03)
        {
@@ -1840,9 +1839,8 @@ void R_Shadow_NewWorldLight(vec3_t origin, float radius, vec3_t color, int style
                        // make a mesh to cast a shadow volume from
                        castmesh = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768);
                        for (j = 0;j < e->numsurfaces;j++)
-                               if (e->surfaces[j]->castshadow == castshadowcount)
-                                       for (surfmesh = e->surfaces[j]->mesh;surfmesh;surfmesh = surfmesh->chain)
-                                               Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surfmesh->vertex3f, surfmesh->numtriangles, surfmesh->element3i);
+                               if ((surf = e->surfaces[j])->castshadow == castshadowcount)
+                                       Mod_ShadowMesh_AddMesh(r_shadow_mempool, castmesh, surf->mesh.data_vertex3f, surf->mesh.num_triangles, surf->mesh.data_element3i);
                        castmesh = Mod_ShadowMesh_Finish(r_shadow_mempool, castmesh);
 
                        // cast shadow volume from castmesh