+
+static rtexture_t *GL_TextureForSkinLayer(const unsigned char *in, int width, int height, const char *name, const unsigned int *palette, int textureflags, qboolean force)
+{
+ int i;
+ if (!force)
+ {
+ for (i = 0;i < width*height;i++)
+ if (((unsigned char *)&palette[in[i]])[3] > 0)
+ break;
+ if (i == width*height)
+ return NULL;
+ }
+ return R_LoadTexture2D (loadmodel->texturepool, name, width, height, in, TEXTYPE_PALETTE, textureflags, palette);
+}
+
+int Mod_LoadSkinFrame(skinframe_t *skinframe, const char *basename, int textureflags, int loadpantsandshirt, int loadglowtexture)
+{
+ imageskin_t s;
+ memset(skinframe, 0, sizeof(*skinframe));
+ skinframe->base = r_texture_notexture;
+ if (cls.state == ca_dedicated)
+ return false;
+ if (!image_loadskin(&s, basename))
+ return false;
+ skinframe->base = R_LoadTexture2D (loadmodel->texturepool, basename, s.basepixels_width, s.basepixels_height, s.basepixels, TEXTYPE_RGBA, textureflags, NULL);
+ if (s.nmappixels != NULL)
+ skinframe->nmap = R_LoadTexture2D (loadmodel->texturepool, va("%s_nmap", basename), s.nmappixels_width, s.nmappixels_height, s.nmappixels, TEXTYPE_RGBA, textureflags, NULL);
+ if (s.glosspixels != NULL)
+ skinframe->gloss = R_LoadTexture2D (loadmodel->texturepool, va("%s_gloss", basename), s.glosspixels_width, s.glosspixels_height, s.glosspixels, TEXTYPE_RGBA, textureflags, NULL);
+ if (s.glowpixels != NULL && loadglowtexture)
+ skinframe->glow = R_LoadTexture2D (loadmodel->texturepool, va("%s_glow", basename), s.glowpixels_width, s.glowpixels_height, s.glowpixels, TEXTYPE_RGBA, textureflags, NULL);
+ if (s.maskpixels != NULL)
+ skinframe->fog = R_LoadTexture2D (loadmodel->texturepool, va("%s_mask", basename), s.maskpixels_width, s.maskpixels_height, s.maskpixels, TEXTYPE_RGBA, textureflags, NULL);
+ if (loadpantsandshirt)
+ {
+ if (s.pantspixels != NULL)
+ skinframe->pants = R_LoadTexture2D (loadmodel->texturepool, va("%s_pants", basename), s.pantspixels_width, s.pantspixels_height, s.pantspixels, TEXTYPE_RGBA, textureflags, NULL);
+ if (s.shirtpixels != NULL)
+ skinframe->shirt = R_LoadTexture2D (loadmodel->texturepool, va("%s_shirt", basename), s.shirtpixels_width, s.shirtpixels_height, s.shirtpixels, TEXTYPE_RGBA, textureflags, NULL);
+ }
+ if (!skinframe->base)
+ skinframe->base = r_texture_notexture;
+ if (!skinframe->nmap)
+ skinframe->nmap = r_texture_blanknormalmap;
+ image_freeskin(&s);
+ return true;
+}
+
+int Mod_LoadSkinFrame_Internal(skinframe_t *skinframe, const char *basename, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height, int bitsperpixel, const unsigned int *palette, const unsigned int *alphapalette)
+{
+ int i;
+ unsigned char *temp1, *temp2;
+ memset(skinframe, 0, sizeof(*skinframe));
+ if (cls.state == ca_dedicated)
+ return false;
+ if (!skindata)
+ return false;
+ if (bitsperpixel == 32)
+ {
+ if (r_shadow_bumpscale_basetexture.value > 0)
+ {
+ temp1 = (unsigned char *)Mem_Alloc(loadmodel->mempool, width * height * 8);
+ temp2 = temp1 + width * height * 4;
+ Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
+ skinframe->nmap = R_LoadTexture2D(loadmodel->texturepool, va("%s_nmap", basename), width, height, temp2, TEXTYPE_RGBA, textureflags | TEXF_ALPHA, NULL);
+ Mem_Free(temp1);
+ }
+ skinframe->base = skinframe->merged = R_LoadTexture2D(loadmodel->texturepool, basename, width, height, skindata, TEXTYPE_RGBA, textureflags, NULL);
+ if (textureflags & TEXF_ALPHA)
+ {
+ for (i = 3;i < width * height * 4;i += 4)
+ if (skindata[i] < 255)
+ break;
+ if (i < width * height * 4)
+ {
+ unsigned char *fogpixels = (unsigned char *)Mem_Alloc(loadmodel->mempool, width * height * 4);
+ memcpy(fogpixels, skindata, width * height * 4);
+ for (i = 0;i < width * height * 4;i += 4)
+ fogpixels[i] = fogpixels[i+1] = fogpixels[i+2] = 255;
+ skinframe->fog = R_LoadTexture2D(loadmodel->texturepool, va("%s_fog", basename), width, height, fogpixels, TEXTYPE_RGBA, textureflags, NULL);
+ Mem_Free(fogpixels);
+ }
+ }
+ }
+ else if (bitsperpixel == 8)
+ {
+ if (r_shadow_bumpscale_basetexture.value > 0)
+ {
+ temp1 = (unsigned char *)Mem_Alloc(loadmodel->mempool, width * height * 8);
+ temp2 = temp1 + width * height * 4;
+ if (bitsperpixel == 32)
+ Image_HeightmapToNormalmap(skindata, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
+ else
+ {
+ // use either a custom palette or the quake palette
+ Image_Copy8bitRGBA(skindata, temp1, width * height, palette ? palette : palette_complete);
+ Image_HeightmapToNormalmap(temp1, temp2, width, height, false, r_shadow_bumpscale_basetexture.value);
+ }
+ skinframe->nmap = R_LoadTexture2D(loadmodel->texturepool, va("%s_nmap", basename), width, height, temp2, TEXTYPE_RGBA, textureflags | TEXF_ALPHA, NULL);
+ Mem_Free(temp1);
+ }
+ // use either a custom palette, or the quake palette
+ skinframe->base = skinframe->merged = GL_TextureForSkinLayer(skindata, width, height, va("%s_merged", basename), palette ? palette : (loadglowtexture ? palette_nofullbrights : ((textureflags & TEXF_ALPHA) ? palette_transparent : palette_complete)), textureflags, true); // all
+ if (!palette && loadglowtexture)
+ skinframe->glow = GL_TextureForSkinLayer(skindata, width, height, va("%s_glow", basename), palette_onlyfullbrights, textureflags, false); // glow
+ if (!palette && loadpantsandshirt)
+ {
+ skinframe->pants = GL_TextureForSkinLayer(skindata, width, height, va("%s_pants", basename), palette_pantsaswhite, textureflags, false); // pants
+ skinframe->shirt = GL_TextureForSkinLayer(skindata, width, height, va("%s_shirt", basename), palette_shirtaswhite, textureflags, false); // shirt
+ }
+ if (skinframe->pants || skinframe->shirt)
+ skinframe->base = GL_TextureForSkinLayer(skindata, width, height, va("%s_nospecial", basename),loadglowtexture ? palette_nocolormapnofullbrights : palette_nocolormap, textureflags, false); // no special colors
+ if (textureflags & TEXF_ALPHA)
+ {
+ // if not using a custom alphapalette, use the quake one
+ if (!alphapalette)
+ alphapalette = palette_alpha;
+ for (i = 0;i < width * height;i++)
+ if (((unsigned char *)alphapalette)[skindata[i]*4+3] < 255)
+ break;
+ if (i < width * height)
+ skinframe->fog = GL_TextureForSkinLayer(skindata, width, height, va("%s_fog", basename), alphapalette, textureflags, true); // fog mask
+ }
+ }
+ else
+ return false;
+ if (!skinframe->nmap)
+ skinframe->nmap = r_texture_blanknormalmap;
+ return true;
+}
+
+void Mod_GetTerrainVertex3fTexCoord2fFromRGBA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
+{
+ float v[3], tc[3];
+ v[0] = ix;
+ v[1] = iy;
+ if (ix >= 0 && iy >= 0 && ix < imagewidth && iy < imageheight)
+ v[2] = (imagepixels[((iy*imagewidth)+ix)*4+0] + imagepixels[((iy*imagewidth)+ix)*4+1] + imagepixels[((iy*imagewidth)+ix)*4+2]) * (1.0f / 765.0f);
+ else
+ v[2] = 0;
+ Matrix4x4_Transform(pixelstepmatrix, v, vertex3f);
+ Matrix4x4_Transform(pixeltexturestepmatrix, v, tc);
+ texcoord2f[0] = tc[0];
+ texcoord2f[1] = tc[1];
+}
+
+void Mod_GetTerrainVertexFromRGBA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *svector3f, float *tvector3f, float *normal3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
+{
+ float vup[3], vdown[3], vleft[3], vright[3];
+ float tcup[3], tcdown[3], tcleft[3], tcright[3];
+ float sv[3], tv[3], nl[3];
+ Mod_GetTerrainVertex3fTexCoord2fFromRGBA(imagepixels, imagewidth, imageheight, ix, iy, vertex3f, texcoord2f, pixelstepmatrix, pixeltexturestepmatrix);
+ Mod_GetTerrainVertex3fTexCoord2fFromRGBA(imagepixels, imagewidth, imageheight, ix, iy - 1, vup, tcup, pixelstepmatrix, pixeltexturestepmatrix);
+ Mod_GetTerrainVertex3fTexCoord2fFromRGBA(imagepixels, imagewidth, imageheight, ix, iy + 1, vdown, tcdown, pixelstepmatrix, pixeltexturestepmatrix);
+ Mod_GetTerrainVertex3fTexCoord2fFromRGBA(imagepixels, imagewidth, imageheight, ix - 1, iy, vleft, tcleft, pixelstepmatrix, pixeltexturestepmatrix);
+ Mod_GetTerrainVertex3fTexCoord2fFromRGBA(imagepixels, imagewidth, imageheight, ix + 1, iy, vright, tcright, pixelstepmatrix, pixeltexturestepmatrix);
+ Mod_BuildBumpVectors(vertex3f, vup, vright, texcoord2f, tcup, tcright, svector3f, tvector3f, normal3f);
+ Mod_BuildBumpVectors(vertex3f, vright, vdown, texcoord2f, tcright, tcdown, sv, tv, nl);
+ VectorAdd(svector3f, sv, svector3f);
+ VectorAdd(tvector3f, tv, tvector3f);
+ VectorAdd(normal3f, nl, normal3f);
+ Mod_BuildBumpVectors(vertex3f, vdown, vleft, texcoord2f, tcdown, tcleft, sv, tv, nl);
+ VectorAdd(svector3f, sv, svector3f);
+ VectorAdd(tvector3f, tv, tvector3f);
+ VectorAdd(normal3f, nl, normal3f);
+ Mod_BuildBumpVectors(vertex3f, vleft, vup, texcoord2f, tcleft, tcup, sv, tv, nl);
+ VectorAdd(svector3f, sv, svector3f);
+ VectorAdd(tvector3f, tv, tvector3f);
+ VectorAdd(normal3f, nl, normal3f);
+}
+
+void Mod_ConstructTerrainPatchFromRGBA(const unsigned char *imagepixels, int imagewidth, int imageheight, int x1, int y1, int width, int height, int *element3i, int *neighbor3i, float *vertex3f, float *svector3f, float *tvector3f, float *normal3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
+{
+ int x, y, ix, iy, *e;
+ e = element3i;
+ for (y = 0;y < height;y++)
+ {
+ for (x = 0;x < width;x++)
+ {
+ e[0] = (y + 1) * (width + 1) + (x + 0);
+ e[1] = (y + 0) * (width + 1) + (x + 0);
+ e[2] = (y + 1) * (width + 1) + (x + 1);
+ e[3] = (y + 0) * (width + 1) + (x + 0);
+ e[4] = (y + 0) * (width + 1) + (x + 1);
+ e[5] = (y + 1) * (width + 1) + (x + 1);
+ e += 6;
+ }
+ }
+ Mod_BuildTriangleNeighbors(neighbor3i, element3i, width*height*2);
+ for (y = 0, iy = y1;y < height + 1;y++, iy++)
+ for (x = 0, ix = x1;x < width + 1;x++, ix++, vertex3f += 3, texcoord2f += 2, svector3f += 3, tvector3f += 3, normal3f += 3)
+ Mod_GetTerrainVertexFromRGBA(imagepixels, imagewidth, imageheight, ix, iy, vertex3f, texcoord2f, svector3f, tvector3f, normal3f, pixelstepmatrix, pixeltexturestepmatrix);
+}
+
+skinfile_t *Mod_LoadSkinFiles(void)
+{
+ int i, words, numtags, line, tagsetsused = false, wordsoverflow;
+ char *text;
+ const char *data;
+ skinfile_t *skinfile = NULL, *first = NULL;
+ skinfileitem_t *skinfileitem;
+ char word[10][MAX_QPATH];
+ overridetagnameset_t tagsets[MAX_SKINS];
+ overridetagname_t tags[256];
+
+/*
+sample file:
+U_bodyBox,models/players/Legoman/BikerA2.tga
+U_RArm,models/players/Legoman/BikerA1.tga
+U_LArm,models/players/Legoman/BikerA1.tga
+U_armor,common/nodraw
+U_sword,common/nodraw
+U_shield,common/nodraw
+U_homb,common/nodraw
+U_backpack,common/nodraw
+U_colcha,common/nodraw
+tag_head,
+tag_weapon,
+tag_torso,
+*/
+ memset(tagsets, 0, sizeof(tagsets));
+ memset(word, 0, sizeof(word));
+ for (i = 0;i < MAX_SKINS && (data = text = (char *)FS_LoadFile(va("%s_%i.skin", loadmodel->name, i), tempmempool, true, NULL));i++)
+ {
+ numtags = 0;
+
+ // If it's the first file we parse
+ if (skinfile == NULL)
+ {
+ skinfile = (skinfile_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfile_t));
+ first = skinfile;
+ }
+ else
+ {
+ skinfile->next = (skinfile_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfile_t));
+ skinfile = skinfile->next;
+ }
+ skinfile->next = NULL;
+
+ for(line = 0;;line++)
+ {
+ // parse line
+ if (!COM_ParseToken(&data, true))
+ break;
+ if (!strcmp(com_token, "\n"))
+ continue;
+ words = 0;
+ wordsoverflow = false;
+ do
+ {
+ if (words < 10)
+ strlcpy(word[words++], com_token, sizeof (word[0]));
+ else
+ wordsoverflow = true;
+ }
+ while (COM_ParseToken(&data, true) && strcmp(com_token, "\n"));
+ if (wordsoverflow)
+ {
+ Con_Printf("Mod_LoadSkinFiles: parsing error in file \"%s_%i.skin\" on line #%i: line with too many statements, skipping\n", loadmodel->name, i, line);
+ continue;
+ }
+ // words is always >= 1
+ if (!strcmp(word[0], "replace"))
+ {
+ if (words == 3)
+ {
+ Con_DPrintf("Mod_LoadSkinFiles: parsed mesh \"%s\" shader replacement \"%s\"\n", word[1], word[2]);
+ skinfileitem = (skinfileitem_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfileitem_t));
+ skinfileitem->next = skinfile->items;
+ skinfile->items = skinfileitem;
+ strlcpy (skinfileitem->name, word[1], sizeof (skinfileitem->name));
+ strlcpy (skinfileitem->replacement, word[2], sizeof (skinfileitem->replacement));
+ }
+ else
+ Con_Printf("Mod_LoadSkinFiles: parsing error in file \"%s_%i.skin\" on line #%i: wrong number of parameters to command \"%s\", see documentation in DP_GFX_SKINFILES extension in dpextensions.qc\n", loadmodel->name, i, line, word[0]);
+ }
+ else if (words == 2 && !strcmp(word[1], ","))
+ {
+ // tag name, like "tag_weapon,"
+ Con_DPrintf("Mod_LoadSkinFiles: parsed tag #%i \"%s\"\n", numtags, word[0]);
+ memset(tags + numtags, 0, sizeof(tags[numtags]));
+ strlcpy (tags[numtags].name, word[0], sizeof (tags[numtags].name));
+ numtags++;
+ }
+ else if (words == 3 && !strcmp(word[1], ","))
+ {
+ // mesh shader name, like "U_RArm,models/players/Legoman/BikerA1.tga"
+ Con_DPrintf("Mod_LoadSkinFiles: parsed mesh \"%s\" shader replacement \"%s\"\n", word[0], word[2]);
+ skinfileitem = (skinfileitem_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfileitem_t));
+ skinfileitem->next = skinfile->items;
+ skinfile->items = skinfileitem;
+ strlcpy (skinfileitem->name, word[0], sizeof (skinfileitem->name));
+ strlcpy (skinfileitem->replacement, word[2], sizeof (skinfileitem->replacement));
+ }
+ else
+ Con_Printf("Mod_LoadSkinFiles: parsing error in file \"%s_%i.skin\" on line #%i: does not look like tag or mesh specification, or replace command, see documentation in DP_GFX_SKINFILES extension in dpextensions.qc\n", loadmodel->name, i, line);
+ }
+ Mem_Free(text);
+
+ if (numtags)
+ {
+ overridetagnameset_t *t;
+ t = tagsets + i;
+ t->num_overridetagnames = numtags;
+ t->data_overridetagnames = (overridetagname_t *)Mem_Alloc(loadmodel->mempool, t->num_overridetagnames * sizeof(overridetagname_t));
+ memcpy(t->data_overridetagnames, tags, t->num_overridetagnames * sizeof(overridetagname_t));
+ tagsetsused = true;
+ }
+ }
+ if (tagsetsused)
+ {
+ loadmodel->data_overridetagnamesforskin = (overridetagnameset_t *)Mem_Alloc(loadmodel->mempool, i * sizeof(overridetagnameset_t));
+ memcpy(loadmodel->data_overridetagnamesforskin, tagsets, i * sizeof(overridetagnameset_t));
+ }
+ if (i)
+ loadmodel->numskins = i;
+ return first;
+}
+
+void Mod_FreeSkinFiles(skinfile_t *skinfile)
+{
+ skinfile_t *next;
+ skinfileitem_t *skinfileitem, *nextitem;
+ for (;skinfile;skinfile = next)
+ {
+ next = skinfile->next;
+ for (skinfileitem = skinfile->items;skinfileitem;skinfileitem = nextitem)
+ {
+ nextitem = skinfileitem->next;
+ Mem_Free(skinfileitem);
+ }
+ Mem_Free(skinfile);
+ }
+}
+
+int Mod_CountSkinFiles(skinfile_t *skinfile)
+{
+ int i;
+ for (i = 0;skinfile;skinfile = skinfile->next, i++);
+ return i;
+}
+
+void Mod_SnapVertices(int numcomponents, int numvertices, float *vertices, float snap)
+{
+ int i;
+ double isnap = 1.0 / snap;
+ for (i = 0;i < numvertices*numcomponents;i++)
+ vertices[i] = floor(vertices[i]*isnap)*snap;
+}
+
+int Mod_RemoveDegenerateTriangles(int numtriangles, const int *inelement3i, int *outelement3i, const float *vertex3f)
+{
+ int i, outtriangles;
+ float d, edgedir[3], temp[3];
+ // a degenerate triangle is one with no width (thickness, surface area)
+ // these are characterized by having all 3 points colinear (along a line)
+ // or having two points identical
+ for (i = 0, outtriangles = 0;i < numtriangles;i++, inelement3i += 3)
+ {
+ // calculate first edge
+ VectorSubtract(vertex3f + inelement3i[1] * 3, vertex3f + inelement3i[0] * 3, edgedir);
+ if (VectorLength2(edgedir) < 0.0001f)
+ continue; // degenerate first edge (no length)
+ VectorNormalize(edgedir);
+ // check if third point is on the edge (colinear)
+ d = -DotProduct(vertex3f + inelement3i[2] * 3, edgedir);
+ VectorMA(vertex3f + inelement3i[2] * 3, d, edgedir, temp);
+ if (VectorLength2(temp) < 0.0001f)
+ continue; // third point colinear with first edge
+ // valid triangle (no colinear points, no duplicate points)
+ VectorCopy(inelement3i, outelement3i);
+ outelement3i += 3;
+ outtriangles++;
+ }
+ return outtriangles;
+}
+
+void Mod_VertexRangeFromElements(int numelements, const int *elements, int *firstvertexpointer, int *lastvertexpointer)
+{
+ int i, e;
+ int firstvertex, lastvertex;
+ if (numelements > 0 && elements)
+ {
+ firstvertex = lastvertex = elements[0];
+ for (i = 1;i < numelements;i++)
+ {
+ e = elements[i];
+ firstvertex = min(firstvertex, e);
+ lastvertex = max(lastvertex, e);
+ }
+ }
+ else
+ firstvertex = lastvertex = 0;
+ if (firstvertexpointer)
+ *firstvertexpointer = firstvertex;
+ if (lastvertexpointer)
+ *lastvertexpointer = lastvertex;
+}
+
+static void Mod_BuildVBOs(void)
+{
+ if (!gl_support_arb_vertex_buffer_object)
+ return;
+
+ // element buffer is easy because it's just one array
+ if (loadmodel->surfmesh.num_triangles)
+ loadmodel->surfmesh.ebo = R_Mesh_CreateStaticEBO(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles * sizeof(int[3]));
+
+ // vertex buffer is several arrays and we put them in the same buffer
+ //
+ // is this wise? the texcoordtexture2f array is used with dynamic
+ // vertex/svector/tvector/normal when rendering animated models, on the
+ // other hand animated models don't use a lot of vertices anyway...
+ if (loadmodel->surfmesh.num_vertices)
+ {
+ size_t size;
+ unsigned char *mem;
+ size = 0;
+ loadmodel->surfmesh.vbooffset_vertex3f = size;if (loadmodel->surfmesh.data_vertex3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.vbooffset_svector3f = size;if (loadmodel->surfmesh.data_svector3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.vbooffset_tvector3f = size;if (loadmodel->surfmesh.data_tvector3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.vbooffset_normal3f = size;if (loadmodel->surfmesh.data_normal3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.vbooffset_texcoordtexture2f = size;if (loadmodel->surfmesh.data_texcoordtexture2f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+ loadmodel->surfmesh.vbooffset_texcoordlightmap2f = size;if (loadmodel->surfmesh.data_texcoordlightmap2f) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+ loadmodel->surfmesh.vbooffset_lightmapcolor4f = size;if (loadmodel->surfmesh.data_lightmapcolor4f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[4]);
+ mem = (unsigned char *)Mem_Alloc(tempmempool, size);
+ if (loadmodel->surfmesh.data_vertex3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_vertex3f , loadmodel->surfmesh.data_vertex3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+ if (loadmodel->surfmesh.data_svector3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_svector3f , loadmodel->surfmesh.data_svector3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+ if (loadmodel->surfmesh.data_tvector3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_tvector3f , loadmodel->surfmesh.data_tvector3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+ if (loadmodel->surfmesh.data_normal3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_normal3f , loadmodel->surfmesh.data_normal3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
+ if (loadmodel->surfmesh.data_texcoordtexture2f ) memcpy(mem + loadmodel->surfmesh.vbooffset_texcoordtexture2f , loadmodel->surfmesh.data_texcoordtexture2f , loadmodel->surfmesh.num_vertices * sizeof(float[2]));
+ if (loadmodel->surfmesh.data_texcoordlightmap2f) memcpy(mem + loadmodel->surfmesh.vbooffset_texcoordlightmap2f, loadmodel->surfmesh.data_texcoordlightmap2f, loadmodel->surfmesh.num_vertices * sizeof(float[2]));
+ if (loadmodel->surfmesh.data_lightmapcolor4f ) memcpy(mem + loadmodel->surfmesh.vbooffset_lightmapcolor4f , loadmodel->surfmesh.data_lightmapcolor4f , loadmodel->surfmesh.num_vertices * sizeof(float[4]));
+ loadmodel->surfmesh.vbo = R_Mesh_CreateStaticVBO(mem, size);
+ Mem_Free(mem);
+ }
+}