mdl and md2 vertices are now stored in a different structure called aliasvertex_t...
[divverent/darkplaces.git] / gl_models.c
1
2 #include "quakedef.h"
3 #include "cl_collision.h"
4 #include "r_shadow.h"
5
6 typedef struct
7 {
8         float m[3][4];
9 } zymbonematrix;
10
11 // LordHavoc: vertex arrays
12
13 float *aliasvertcolorbuf;
14 float *aliasvertcolor; // this may point at aliasvertcolorbuf or at vertex arrays in the mesh backend
15 float *aliasvert_svectors;
16 float *aliasvert_tvectors;
17 float *aliasvert_normals;
18
19 float *aliasvertcolor2;
20 int *aliasvertusage;
21 zymbonematrix *zymbonepose;
22
23 mempool_t *gl_models_mempool;
24
25 void gl_models_start(void)
26 {
27         // allocate vertex processing arrays
28         gl_models_mempool = Mem_AllocPool("GL_Models");
29         aliasvertcolor = aliasvertcolorbuf = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
30         aliasvert_svectors = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
31         aliasvert_tvectors = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
32         aliasvert_normals = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
33         aliasvertcolor2 = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4])); // used temporarily for tinted coloring
34         zymbonepose = Mem_Alloc(gl_models_mempool, sizeof(zymbonematrix[256]));
35         aliasvertusage = Mem_Alloc(gl_models_mempool, sizeof(int[MD2MAX_VERTS]));
36 }
37
38 void gl_models_shutdown(void)
39 {
40         Mem_FreePool(&gl_models_mempool);
41 }
42
43 void gl_models_newmap(void)
44 {
45 }
46
47 void GL_Models_Init(void)
48 {
49         R_RegisterModule("GL_Models", gl_models_start, gl_models_shutdown, gl_models_newmap);
50 }
51
52 void R_Model_Alias_GetVerts(const entity_render_t *ent, float *vertices, float *normals, float *svectors, float *tvectors)
53 {
54         int i, vertcount;
55         float vlerp1, nlerp1, vlerp2, nlerp2, vlerp3, nlerp3, vlerp4, nlerp4;
56         const aliasvertex_t *verts1, *verts2, *verts3, *verts4;
57
58         if (vertices == NULL)
59                 Host_Error("R_Model_Alias_GetVerts: vertices == NULL.\n");
60         if (svectors != NULL && (tvectors == NULL || normals == NULL))
61                 Host_Error("R_Model_Alias_GetVerts: svectors requires tvectors and normals.\n");
62         if (tvectors != NULL && (svectors == NULL || normals == NULL))
63                 Host_Error("R_Model_Alias_GetVerts: tvectors requires svectors and normals.\n");
64
65         vertcount = ent->model->numverts;
66         verts1 = ent->model->mdlmd2data_pose + ent->frameblend[0].frame * vertcount;
67         vlerp1 = ent->frameblend[0].lerp * (1.0f / 16.0f);
68         nlerp1 = ent->frameblend[0].lerp * (1.0f / 127.0f);
69         if (ent->frameblend[1].lerp)
70         {
71                 verts2 = ent->model->mdlmd2data_pose + ent->frameblend[1].frame * vertcount;
72                 vlerp2 = ent->frameblend[1].lerp * (1.0f / 16.0f);
73                 nlerp2 = ent->frameblend[1].lerp * (1.0f / 127.0f);
74                 if (ent->frameblend[2].lerp)
75                 {
76                         verts3 = ent->model->mdlmd2data_pose + ent->frameblend[2].frame * vertcount;
77                         vlerp3 = ent->frameblend[2].lerp * (1.0f / 16.0f);
78                         nlerp3 = ent->frameblend[2].lerp * (1.0f / 127.0f);
79                         if (ent->frameblend[3].lerp)
80                         {
81                                 verts4 = ent->model->mdlmd2data_pose + ent->frameblend[3].frame * vertcount;
82                                 vlerp4 = ent->frameblend[3].lerp * (1.0f / 16.0f);
83                                 nlerp4 = ent->frameblend[3].lerp * (1.0f / 127.0f);
84                                 // generate vertices
85                                 if (svectors != NULL)
86                                 {
87                                         for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++, verts2++, verts3++, verts4++)
88                                         {
89                                                 VectorMAMAMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vlerp3, verts3->origin, vlerp4, verts4->origin, vertices);
90                                                 VectorMAMAMAM(nlerp1, verts1->normal, nlerp2, verts2->normal, nlerp3, verts3->normal, nlerp4, verts4->normal, normals);
91                                                 VectorMAMAMAM(nlerp1, verts1->svector, nlerp2, verts2->svector, nlerp3, verts3->svector, nlerp4, verts4->svector, svectors);
92                                                 CrossProduct(svectors, normals, tvectors);
93                                         }
94                                 }
95                                 else if (normals != NULL)
96                                 {
97                                         for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++, verts2++, verts3++, verts4++)
98                                         {
99                                                 VectorMAMAMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vlerp3, verts3->origin, vlerp4, verts4->origin, vertices);
100                                                 VectorMAMAMAM(nlerp1, verts1->normal, nlerp2, verts2->normal, nlerp3, verts3->normal, nlerp4, verts4->normal, normals);
101                                         }
102                                 }
103                                 else
104                                         for (i = 0;i < vertcount;i++, vertices += 4, verts1++, verts2++, verts3++, verts4++)
105                                                 VectorMAMAMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vlerp3, verts3->origin, vlerp4, verts4->origin, vertices);
106                         }
107                         else
108                         {
109                                 // generate vertices
110                                 if (svectors != NULL)
111                                 {
112                                         for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++, verts2++, verts3++)
113                                         {
114                                                 VectorMAMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vlerp3, verts3->origin, vertices);
115                                                 VectorMAMAM(nlerp1, verts1->normal, nlerp2, verts2->normal, nlerp3, verts3->normal, normals);
116                                                 VectorMAMAM(nlerp1, verts1->svector, nlerp2, verts2->svector, nlerp3, verts3->svector, svectors);
117                                                 CrossProduct(svectors, normals, tvectors);
118                                         }
119                                 }
120                                 else if (normals != NULL)
121                                 {
122                                         for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++, verts2++, verts3++)
123                                         {
124                                                 VectorMAMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vlerp3, verts3->origin, vertices);
125                                                 VectorMAMAM(nlerp1, verts1->normal, nlerp2, verts2->normal, nlerp3, verts3->normal, normals);
126                                         }
127                                 }
128                                 else
129                                         for (i = 0;i < vertcount;i++, vertices += 4, verts1++, verts2++, verts3++)
130                                                 VectorMAMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vlerp3, verts3->origin, vertices);
131                         }
132                 }
133                 else
134                 {
135                         // generate vertices
136                         if (svectors != NULL)
137                         {
138                                 for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++, verts2++)
139                                 {
140                                         VectorMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vertices);
141                                         VectorMAM(nlerp1, verts1->normal, nlerp2, verts2->normal, normals);
142                                         VectorMAM(nlerp1, verts1->svector, nlerp2, verts2->svector, svectors);
143                                         CrossProduct(svectors, normals, tvectors);
144                                 }
145                         }
146                         else if (normals != NULL)
147                         {
148                                 for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++, verts2++)
149                                 {
150                                         VectorMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vertices);
151                                         VectorMAM(nlerp1, verts1->normal, nlerp2, verts2->normal, normals);
152                                 }
153                         }
154                         else
155                                 for (i = 0;i < vertcount;i++, vertices += 4, verts1++, verts2++)
156                                         VectorMAM(vlerp1, verts1->origin, vlerp2, verts2->origin, vertices);
157                 }
158         }
159         else
160         {
161                 // generate vertices
162                 if (svectors != NULL)
163                 {
164                         for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++)
165                         {
166                                 VectorM(vlerp1, verts1->origin, vertices);
167                                 VectorM(nlerp1, verts1->normal, normals);
168                                 VectorM(nlerp1, verts1->svector, svectors);
169                                 CrossProduct(svectors, normals, tvectors);
170                         }
171                 }
172                 else if (normals != NULL)
173                 {
174                         for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++)
175                         {
176                                 VectorM(vlerp1, verts1->origin, vertices);
177                                 VectorM(nlerp1, verts1->normal, normals);
178                         }
179                 }
180                 else
181                         for (i = 0;i < vertcount;i++, vertices += 4, verts1++)
182                                 VectorM(vlerp1, verts1->origin, vertices);
183         }
184 }
185
186 skinframe_t *R_FetchSkinFrame(const entity_render_t *ent)
187 {
188         model_t *model = ent->model;
189         int s = ent->skinnum;
190         if ((unsigned int)s >= (unsigned int)model->numskins)
191                 s = 0;
192         if (model->skinscenes[s].framecount > 1)
193                 return &model->skinframes[model->skinscenes[s].firstframe + (int) (cl.time * 10) % model->skinscenes[s].framecount];
194         else
195                 return &model->skinframes[model->skinscenes[s].firstframe];
196 }
197
198 void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
199 {
200         int i, c, fullbright, pantsfullbright, shirtfullbright, colormapped, tex;
201         float pantscolor[3], shirtcolor[3];
202         float fog, ifog, colorscale;
203         vec3_t diff;
204         qbyte *bcolor;
205         rmeshstate_t m;
206         model_t *model;
207         skinframe_t *skinframe;
208         const entity_render_t *ent = calldata1;
209         int blendfunc1, blendfunc2;
210
211         R_Mesh_Matrix(&ent->matrix);
212
213         model = ent->model;
214         R_Mesh_ResizeCheck(model->numverts);
215
216         skinframe = R_FetchSkinFrame(ent);
217
218         fullbright = (ent->effects & EF_FULLBRIGHT) != 0;
219
220         fog = 0;
221         if (fogenabled)
222         {
223                 VectorSubtract(ent->origin, r_origin, diff);
224                 fog = DotProduct(diff,diff);
225                 if (fog < 0.01f)
226                         fog = 0.01f;
227                 fog = exp(fogdensity/fog);
228                 if (fog > 1)
229                         fog = 1;
230                 if (fog < 0.01f)
231                         fog = 0;
232                 // fog method: darken, additive fog
233                 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
234                 // 2. render fog as additive
235         }
236         ifog = 1 - fog;
237
238         if (ent->effects & EF_ADDITIVE)
239         {
240                 blendfunc1 = GL_SRC_ALPHA;
241                 blendfunc2 = GL_ONE;
242         }
243         else if (ent->alpha != 1.0 || skinframe->fog != NULL)
244         {
245                 blendfunc1 = GL_SRC_ALPHA;
246                 blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
247         }
248         else
249         {
250                 blendfunc1 = GL_ONE;
251                 blendfunc2 = GL_ZERO;
252         }
253
254         R_Model_Alias_GetVerts(ent, varray_vertex, aliasvert_normals, NULL, NULL);
255         memcpy(varray_texcoord[0], model->mdlmd2data_texcoords, model->numverts * sizeof(float[4]));
256         if (!skinframe->base && !skinframe->pants && !skinframe->shirt && !skinframe->glow)
257         {
258                 // untextured
259                 memset(&m, 0, sizeof(m));
260                 m.blendfunc1 = blendfunc1;
261                 m.blendfunc2 = blendfunc2;
262                 colorscale = r_colorscale;
263                 if (gl_combine.integer)
264                 {
265                         colorscale *= 0.25f;
266                         m.texrgbscale[0] = 4;
267                 }
268                 m.tex[0] = R_GetTexture(r_notexture);
269                 R_Mesh_State(&m);
270                 c_alias_polys += model->numtris;
271                 for (i = 0;i < model->numverts * 4;i += 4)
272                 {
273                         varray_texcoord[0][i + 0] *= 8.0f;
274                         varray_texcoord[0][i + 1] *= 8.0f;
275                 }
276                 R_LightModel(ent, model->numverts, varray_vertex, aliasvert_normals, varray_color, colorscale, colorscale, colorscale, false);
277                 R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
278                 return;
279         }
280
281         colormapped = !skinframe->merged || (ent->colormap >= 0 && skinframe->base && (skinframe->pants || skinframe->shirt));
282         if (colormapped)
283         {
284                 // 128-224 are backwards ranges
285                 c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
286                 bcolor = (qbyte *) (&palette_complete[c]);
287                 pantsfullbright = c >= 224;
288                 VectorScale(bcolor, (1.0f / 255.0f), pantscolor);
289                 c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
290                 bcolor = (qbyte *) (&palette_complete[c]);
291                 shirtfullbright = c >= 224;
292                 VectorScale(bcolor, (1.0f / 255.0f), shirtcolor);
293         }
294         else
295         {
296                 pantscolor[0] = pantscolor[1] = pantscolor[2] = shirtcolor[0] = shirtcolor[1] = shirtcolor[2] = 1;
297                 pantsfullbright = shirtfullbright = false;
298         }
299
300         tex = colormapped ? R_GetTexture(skinframe->base) : R_GetTexture(skinframe->merged);
301         if (tex)
302         {
303                 memset(&m, 0, sizeof(m));
304                 m.blendfunc1 = blendfunc1;
305                 m.blendfunc2 = blendfunc2;
306                 colorscale = r_colorscale;
307                 if (gl_combine.integer)
308                 {
309                         colorscale *= 0.25f;
310                         m.texrgbscale[0] = 4;
311                 }
312                 m.tex[0] = tex;
313                 R_Mesh_State(&m);
314                 if (fullbright)
315                         GL_Color(colorscale * ifog, colorscale * ifog, colorscale * ifog, ent->alpha);
316                 else
317                         R_LightModel(ent, model->numverts, varray_vertex, aliasvert_normals, varray_color, colorscale * ifog, colorscale * ifog, colorscale * ifog, false);
318                 R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
319                 c_alias_polys += model->numtris;
320                 blendfunc1 = GL_SRC_ALPHA;
321                 blendfunc2 = GL_ONE;
322         }
323
324         if (colormapped)
325         {
326                 if (skinframe->pants)
327                 {
328                         tex = R_GetTexture(skinframe->pants);
329                         if (tex)
330                         {
331                                 memset(&m, 0, sizeof(m));
332                                 m.blendfunc1 = blendfunc1;
333                                 m.blendfunc2 = blendfunc2;
334                                 colorscale = r_colorscale;
335                                 if (gl_combine.integer)
336                                 {
337                                         colorscale *= 0.25f;
338                                         m.texrgbscale[0] = 4;
339                                 }
340                                 m.tex[0] = tex;
341                                 R_Mesh_State(&m);
342                                 if (pantsfullbright)
343                                         GL_Color(pantscolor[0] * colorscale * ifog, pantscolor[1] * colorscale * ifog, pantscolor[2] * colorscale * ifog, ent->alpha);
344                                 else
345                                         R_LightModel(ent, model->numverts, varray_vertex, aliasvert_normals, varray_color, pantscolor[0] * colorscale * ifog, pantscolor[1] * colorscale * ifog, pantscolor[2] * colorscale * ifog, false);
346                                 R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
347                                 c_alias_polys += model->numtris;
348                                 blendfunc1 = GL_SRC_ALPHA;
349                                 blendfunc2 = GL_ONE;
350                         }
351                 }
352                 if (skinframe->shirt)
353                 {
354                         tex = R_GetTexture(skinframe->shirt);
355                         if (tex)
356                         {
357                                 memset(&m, 0, sizeof(m));
358                                 m.blendfunc1 = blendfunc1;
359                                 m.blendfunc2 = blendfunc2;
360                                 colorscale = r_colorscale;
361                                 if (gl_combine.integer)
362                                 {
363                                         colorscale *= 0.25f;
364                                         m.texrgbscale[0] = 4;
365                                 }
366                                 m.tex[0] = tex;
367                                 R_Mesh_State(&m);
368                                 if (shirtfullbright)
369                                         GL_Color(shirtcolor[0] * colorscale * ifog, shirtcolor[1] * colorscale * ifog, shirtcolor[2] * colorscale * ifog, ent->alpha);
370                                 else
371                                         R_LightModel(ent, model->numverts, varray_vertex, aliasvert_normals, varray_color, shirtcolor[0] * colorscale * ifog, shirtcolor[1] * colorscale * ifog, shirtcolor[2] * colorscale * ifog, false);
372                                 R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
373                                 c_alias_polys += model->numtris;
374                                 blendfunc1 = GL_SRC_ALPHA;
375                                 blendfunc2 = GL_ONE;
376                         }
377                 }
378         }
379         if (skinframe->glow)
380         {
381                 tex = R_GetTexture(skinframe->glow);
382                 if (tex)
383                 {
384                         memset(&m, 0, sizeof(m));
385                         m.blendfunc1 = blendfunc1;
386                         m.blendfunc2 = blendfunc2;
387                         m.tex[0] = tex;
388                         R_Mesh_State(&m);
389
390                         blendfunc1 = GL_SRC_ALPHA;
391                         blendfunc2 = GL_ONE;
392                         c_alias_polys += model->numtris;
393                         GL_Color(ifog * r_colorscale, ifog * r_colorscale, ifog * r_colorscale, ent->alpha);
394                         R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
395                 }
396         }
397         if (fog)
398         {
399                 memset(&m, 0, sizeof(m));
400                 m.blendfunc1 = GL_SRC_ALPHA;
401                 m.blendfunc2 = GL_ONE;
402                 m.tex[0] = R_GetTexture(skinframe->fog);
403                 R_Mesh_State(&m);
404
405                 c_alias_polys += model->numtris;
406                 GL_Color(fogcolor[0] * fog * r_colorscale, fogcolor[1] * fog * r_colorscale, fogcolor[2] * fog * r_colorscale, ent->alpha);
407                 R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
408         }
409 }
410
411 void R_Model_Alias_Draw(entity_render_t *ent)
412 {
413         if (ent->alpha < (1.0f / 64.0f))
414                 return; // basically completely transparent
415
416         c_models++;
417
418         if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchSkinFrame(ent)->fog != NULL)
419                 R_MeshQueue_AddTransparent(ent->origin, R_DrawAliasModelCallback, ent, 0);
420         else
421                 R_DrawAliasModelCallback(ent, 0);
422 }
423
424 void R_Model_Alias_DrawFakeShadow (entity_render_t *ent)
425 {
426         int i;
427         rmeshstate_t m;
428         model_t *model;
429         float *v, planenormal[3], planedist, dist, projection[3], floororigin[3], surfnormal[3], lightdirection[3], v2[3];
430
431         lightdirection[0] = 0.5;
432         lightdirection[1] = 0.2;
433         lightdirection[2] = -1;
434         VectorNormalizeFast(lightdirection);
435
436         VectorMA(ent->origin, 65536.0f, lightdirection, v2);
437         if (CL_TraceLine(ent->origin, v2, floororigin, surfnormal, 0, false, NULL) == 1)
438                 return;
439
440         R_Mesh_Matrix(&ent->matrix);
441
442         model = ent->model;
443         R_Mesh_ResizeCheck(model->numverts);
444
445         memset(&m, 0, sizeof(m));
446         m.blendfunc1 = GL_SRC_ALPHA;
447         m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
448         R_Mesh_State(&m);
449
450         c_alias_polys += model->numtris;
451         R_Model_Alias_GetVerts(ent, varray_vertex, NULL, NULL, NULL);
452
453         // put a light direction in the entity's coordinate space
454         Matrix4x4_Transform3x3(&ent->inversematrix, lightdirection, projection);
455         VectorNormalizeFast(projection);
456
457         // put the plane's normal in the entity's coordinate space
458         Matrix4x4_Transform3x3(&ent->inversematrix, surfnormal, planenormal);
459         VectorNormalizeFast(planenormal);
460
461         // put the plane's distance in the entity's coordinate space
462         VectorSubtract(floororigin, ent->origin, floororigin);
463         planedist = DotProduct(floororigin, surfnormal) + 2;
464
465         dist = -1.0f / DotProduct(projection, planenormal);
466         VectorScale(projection, dist, projection);
467         for (i = 0, v = varray_vertex;i < model->numverts;i++, v += 4)
468         {
469                 dist = DotProduct(v, planenormal) - planedist;
470                 if (dist > 0)
471                 //if (i & 1)
472                         VectorMA(v, dist, projection, v);
473         }
474         GL_Color(0, 0, 0, 0.5);
475         R_Mesh_Draw(model->numverts, model->numtris, model->mdlmd2data_indices);
476 }
477
478 void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
479 {
480         float projectdistance;
481         projectdistance = lightradius + ent->model->radius - sqrt(DotProduct(relativelightorigin, relativelightorigin));
482         if (projectdistance > 0.1)
483         {
484                 R_Mesh_Matrix(&ent->matrix);
485                 R_Mesh_ResizeCheck(ent->model->numverts * 2);
486                 R_Model_Alias_GetVerts(ent, varray_vertex, NULL, NULL, NULL);
487                 R_Shadow_Volume(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, ent->model->mdlmd2data_triangleneighbors, relativelightorigin, lightradius, projectdistance);
488         }
489 }
490
491 void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor)
492 {
493         int c;
494         float lightcolor2[3];
495         qbyte *bcolor;
496         skinframe_t *skinframe;
497         R_Mesh_Matrix(&ent->matrix);
498         R_Mesh_ResizeCheck(ent->model->numverts);
499         R_Model_Alias_GetVerts(ent, varray_vertex, aliasvert_normals, aliasvert_svectors, aliasvert_tvectors);
500         skinframe = R_FetchSkinFrame(ent);
501
502         // note: to properly handle fog this should scale the lightcolor into lightcolor2 according to 1-fog scaling
503
504         R_Shadow_SpecularLighting(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, ent->model->mdlmd2data_texcoords, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, NULL, NULL, NULL);
505
506         if (!skinframe->base && !skinframe->pants && !skinframe->shirt && !skinframe->glow)
507         {
508                 R_Shadow_DiffuseLighting(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, ent->model->mdlmd2data_texcoords, relativelightorigin, lightradius, lightcolor, r_notexture, NULL, NULL);
509                 return;
510         }
511
512         if (!skinframe->merged || (ent->colormap >= 0 && skinframe->base && (skinframe->pants || skinframe->shirt)))
513         {
514                 // 128-224 are backwards ranges
515                 // we only render non-fullbright ranges here
516                 if (skinframe->pants && (ent->colormap & 0xF) < 0xE)
517                 {
518                         c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
519                         bcolor = (qbyte *) (&palette_complete[c]);
520                         lightcolor2[0] = lightcolor[0] * bcolor[0] * (1.0f / 255.0f);
521                         lightcolor2[1] = lightcolor[1] * bcolor[1] * (1.0f / 255.0f);
522                         lightcolor2[2] = lightcolor[2] * bcolor[2] * (1.0f / 255.0f);
523                         R_Shadow_DiffuseLighting(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, ent->model->mdlmd2data_texcoords, relativelightorigin, lightradius, lightcolor2, skinframe->pants, skinframe->nmap, NULL);
524                 }
525
526                 // we only render non-fullbright ranges here
527                 if (skinframe->shirt && (ent->colormap & 0xF0) < 0xE0)
528                 {
529                         c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
530                         bcolor = (qbyte *) (&palette_complete[c]);
531                         lightcolor2[0] = lightcolor[0] * bcolor[0] * (1.0f / 255.0f);
532                         lightcolor2[1] = lightcolor[1] * bcolor[1] * (1.0f / 255.0f);
533                         lightcolor2[2] = lightcolor[2] * bcolor[2] * (1.0f / 255.0f);
534                         R_Shadow_DiffuseLighting(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, ent->model->mdlmd2data_texcoords, relativelightorigin, lightradius, lightcolor2, skinframe->shirt, skinframe->nmap, NULL);
535                 }
536
537                 if (skinframe->base)
538                         R_Shadow_DiffuseLighting(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, ent->model->mdlmd2data_texcoords, relativelightorigin, lightradius, lightcolor, skinframe->base, skinframe->nmap, NULL);
539         }
540         else
541                 if (skinframe->merged)
542                         R_Shadow_DiffuseLighting(ent->model->numverts, ent->model->numtris, ent->model->mdlmd2data_indices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, ent->model->mdlmd2data_texcoords, relativelightorigin, lightradius, lightcolor, skinframe->merged, skinframe->nmap, NULL);
543 }
544
545 int ZymoticLerpBones(int count, const zymbonematrix *bonebase, const frameblend_t *blend, const zymbone_t *bone)
546 {
547         int i;
548         float lerp1, lerp2, lerp3, lerp4;
549         zymbonematrix *out, rootmatrix, m;
550         const zymbonematrix *bone1, *bone2, *bone3, *bone4;
551
552         rootmatrix.m[0][0] = 1;
553         rootmatrix.m[0][1] = 0;
554         rootmatrix.m[0][2] = 0;
555         rootmatrix.m[0][3] = 0;
556         rootmatrix.m[1][0] = 0;
557         rootmatrix.m[1][1] = 1;
558         rootmatrix.m[1][2] = 0;
559         rootmatrix.m[1][3] = 0;
560         rootmatrix.m[2][0] = 0;
561         rootmatrix.m[2][1] = 0;
562         rootmatrix.m[2][2] = 1;
563         rootmatrix.m[2][3] = 0;
564
565         bone1 = bonebase + blend[0].frame * count;
566         lerp1 = blend[0].lerp;
567         if (blend[1].lerp)
568         {
569                 bone2 = bonebase + blend[1].frame * count;
570                 lerp2 = blend[1].lerp;
571                 if (blend[2].lerp)
572                 {
573                         bone3 = bonebase + blend[2].frame * count;
574                         lerp3 = blend[2].lerp;
575                         if (blend[3].lerp)
576                         {
577                                 // 4 poses
578                                 bone4 = bonebase + blend[3].frame * count;
579                                 lerp4 = blend[3].lerp;
580                                 for (i = 0, out = zymbonepose;i < count;i++, out++)
581                                 {
582                                         // interpolate matrices
583                                         m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3 + bone4->m[0][0] * lerp4;
584                                         m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3 + bone4->m[0][1] * lerp4;
585                                         m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3 + bone4->m[0][2] * lerp4;
586                                         m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3 + bone4->m[0][3] * lerp4;
587                                         m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3 + bone4->m[1][0] * lerp4;
588                                         m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3 + bone4->m[1][1] * lerp4;
589                                         m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3 + bone4->m[1][2] * lerp4;
590                                         m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3 + bone4->m[1][3] * lerp4;
591                                         m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3 + bone4->m[2][0] * lerp4;
592                                         m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3 + bone4->m[2][1] * lerp4;
593                                         m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3 + bone4->m[2][2] * lerp4;
594                                         m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3 + bone4->m[2][3] * lerp4;
595                                         if (bone->parent >= 0)
596                                                 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
597                                         else
598                                                 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
599                                         bone1++;
600                                         bone2++;
601                                         bone3++;
602                                         bone4++;
603                                         bone++;
604                                 }
605                         }
606                         else
607                         {
608                                 // 3 poses
609                                 for (i = 0, out = zymbonepose;i < count;i++, out++)
610                                 {
611                                         // interpolate matrices
612                                         m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3;
613                                         m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3;
614                                         m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3;
615                                         m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3;
616                                         m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3;
617                                         m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3;
618                                         m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3;
619                                         m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3;
620                                         m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3;
621                                         m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3;
622                                         m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3;
623                                         m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3;
624                                         if (bone->parent >= 0)
625                                                 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
626                                         else
627                                                 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
628                                         bone1++;
629                                         bone2++;
630                                         bone3++;
631                                         bone++;
632                                 }
633                         }
634                 }
635                 else
636                 {
637                         // 2 poses
638                         for (i = 0, out = zymbonepose;i < count;i++, out++)
639                         {
640                                 // interpolate matrices
641                                 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2;
642                                 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2;
643                                 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2;
644                                 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2;
645                                 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2;
646                                 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2;
647                                 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2;
648                                 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2;
649                                 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2;
650                                 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2;
651                                 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2;
652                                 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2;
653                                 if (bone->parent >= 0)
654                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
655                                 else
656                                         R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
657                                 bone1++;
658                                 bone2++;
659                                 bone++;
660                         }
661                 }
662         }
663         else
664         {
665                 // 1 pose
666                 if (lerp1 != 1)
667                 {
668                         // lerp != 1.0
669                         for (i = 0, out = zymbonepose;i < count;i++, out++)
670                         {
671                                 // interpolate matrices
672                                 m.m[0][0] = bone1->m[0][0] * lerp1;
673                                 m.m[0][1] = bone1->m[0][1] * lerp1;
674                                 m.m[0][2] = bone1->m[0][2] * lerp1;
675                                 m.m[0][3] = bone1->m[0][3] * lerp1;
676                                 m.m[1][0] = bone1->m[1][0] * lerp1;
677                                 m.m[1][1] = bone1->m[1][1] * lerp1;
678                                 m.m[1][2] = bone1->m[1][2] * lerp1;
679                                 m.m[1][3] = bone1->m[1][3] * lerp1;
680                                 m.m[2][0] = bone1->m[2][0] * lerp1;
681                                 m.m[2][1] = bone1->m[2][1] * lerp1;
682                                 m.m[2][2] = bone1->m[2][2] * lerp1;
683                                 m.m[2][3] = bone1->m[2][3] * lerp1;
684                                 if (bone->parent >= 0)
685                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
686                                 else
687                                         R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
688                                 bone1++;
689                                 bone++;
690                         }
691                 }
692                 else
693                 {
694                         // lerp == 1.0
695                         for (i = 0, out = zymbonepose;i < count;i++, out++)
696                         {
697                                 if (bone->parent >= 0)
698                                         R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &bone1->m[0][0], &out->m[0][0]);
699                                 else
700                                         R_ConcatTransforms(&rootmatrix.m[0][0], &bone1->m[0][0], &out->m[0][0]);
701                                 bone1++;
702                                 bone++;
703                         }
704                 }
705         }
706         return true;
707 }
708
709 void ZymoticTransformVerts(int vertcount, float *vertex, int *bonecounts, zymvertex_t *vert)
710 {
711         int c;
712         float *out = vertex;
713         zymbonematrix *matrix;
714         while(vertcount--)
715         {
716                 c = *bonecounts++;
717                 // FIXME: validate bonecounts at load time (must be >= 1)
718                 // FIXME: need 4th component in origin, for how much of the translate to blend in
719                 if (c == 1)
720                 {
721                         matrix = &zymbonepose[vert->bonenum];
722                         out[0] = vert->origin[0] * matrix->m[0][0] + vert->origin[1] * matrix->m[0][1] + vert->origin[2] * matrix->m[0][2] + matrix->m[0][3];
723                         out[1] = vert->origin[0] * matrix->m[1][0] + vert->origin[1] * matrix->m[1][1] + vert->origin[2] * matrix->m[1][2] + matrix->m[1][3];
724                         out[2] = vert->origin[0] * matrix->m[2][0] + vert->origin[1] * matrix->m[2][1] + vert->origin[2] * matrix->m[2][2] + matrix->m[2][3];
725                         vert++;
726                 }
727                 else
728                 {
729                         VectorClear(out);
730                         while(c--)
731                         {
732                                 matrix = &zymbonepose[vert->bonenum];
733                                 out[0] += vert->origin[0] * matrix->m[0][0] + vert->origin[1] * matrix->m[0][1] + vert->origin[2] * matrix->m[0][2] + matrix->m[0][3];
734                                 out[1] += vert->origin[0] * matrix->m[1][0] + vert->origin[1] * matrix->m[1][1] + vert->origin[2] * matrix->m[1][2] + matrix->m[1][3];
735                                 out[2] += vert->origin[0] * matrix->m[2][0] + vert->origin[1] * matrix->m[2][1] + vert->origin[2] * matrix->m[2][2] + matrix->m[2][3];
736                                 vert++;
737                         }
738                 }
739                 out += 4;
740         }
741 }
742
743 void ZymoticCalcNormals(int vertcount, float *vertex, float *normals, int shadercount, int *renderlist)
744 {
745         int a, b, c, d;
746         float *out, v1[3], v2[3], normal[3], s;
747         int *u;
748         // clear normals
749         memset(normals, 0, sizeof(float) * vertcount * 3);
750         memset(aliasvertusage, 0, sizeof(int) * vertcount);
751         // parse render list and accumulate surface normals
752         while(shadercount--)
753         {
754                 d = *renderlist++;
755                 while (d--)
756                 {
757                         a = renderlist[0]*4;
758                         b = renderlist[1]*4;
759                         c = renderlist[2]*4;
760                         v1[0] = vertex[a+0] - vertex[b+0];
761                         v1[1] = vertex[a+1] - vertex[b+1];
762                         v1[2] = vertex[a+2] - vertex[b+2];
763                         v2[0] = vertex[c+0] - vertex[b+0];
764                         v2[1] = vertex[c+1] - vertex[b+1];
765                         v2[2] = vertex[c+2] - vertex[b+2];
766                         CrossProduct(v1, v2, normal);
767                         VectorNormalizeFast(normal);
768                         // add surface normal to vertices
769                         a = renderlist[0] * 3;
770                         normals[a+0] += normal[0];
771                         normals[a+1] += normal[1];
772                         normals[a+2] += normal[2];
773                         aliasvertusage[renderlist[0]]++;
774                         a = renderlist[1] * 3;
775                         normals[a+0] += normal[0];
776                         normals[a+1] += normal[1];
777                         normals[a+2] += normal[2];
778                         aliasvertusage[renderlist[1]]++;
779                         a = renderlist[2] * 3;
780                         normals[a+0] += normal[0];
781                         normals[a+1] += normal[1];
782                         normals[a+2] += normal[2];
783                         aliasvertusage[renderlist[2]]++;
784                         renderlist += 3;
785                 }
786         }
787         // FIXME: precalc this
788         // average surface normals
789         out = normals;
790         u = aliasvertusage;
791         while(vertcount--)
792         {
793                 if (*u > 1)
794                 {
795                         s = ixtable[*u];
796                         out[0] *= s;
797                         out[1] *= s;
798                         out[2] *= s;
799                 }
800                 u++;
801                 out += 3;
802         }
803 }
804
805 void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
806 {
807         float fog, ifog, colorscale;
808         vec3_t diff;
809         int i, *renderlist, *elements;
810         rtexture_t *texture;
811         rmeshstate_t mstate;
812         const entity_render_t *ent = calldata1;
813         int shadernum = calldata2;
814         int numverts, numtriangles;
815
816         R_Mesh_Matrix(&ent->matrix);
817
818         // find the vertex index list and texture
819         renderlist = ent->model->zymdata_renderlist;
820         for (i = 0;i < shadernum;i++)
821                 renderlist += renderlist[0] * 3 + 1;
822         texture = ent->model->zymdata_textures[shadernum];
823
824         numverts = ent->model->zymnum_verts;
825         numtriangles = *renderlist++;
826         elements = renderlist;
827         R_Mesh_ResizeCheck(numverts);
828
829         fog = 0;
830         if (fogenabled)
831         {
832                 VectorSubtract(ent->origin, r_origin, diff);
833                 fog = DotProduct(diff,diff);
834                 if (fog < 0.01f)
835                         fog = 0.01f;
836                 fog = exp(fogdensity/fog);
837                 if (fog > 1)
838                         fog = 1;
839                 if (fog < 0.01f)
840                         fog = 0;
841                 // fog method: darken, additive fog
842                 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
843                 // 2. render fog as additive
844         }
845         ifog = 1 - fog;
846
847         memset(&mstate, 0, sizeof(mstate));
848         if (ent->effects & EF_ADDITIVE)
849         {
850                 mstate.blendfunc1 = GL_SRC_ALPHA;
851                 mstate.blendfunc2 = GL_ONE;
852         }
853         else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
854         {
855                 mstate.blendfunc1 = GL_SRC_ALPHA;
856                 mstate.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
857         }
858         else
859         {
860                 mstate.blendfunc1 = GL_ONE;
861                 mstate.blendfunc2 = GL_ZERO;
862         }
863         colorscale = r_colorscale;
864         if (gl_combine.integer)
865         {
866                 mstate.texrgbscale[0] = 4;
867                 colorscale *= 0.25f;
868         }
869         mstate.tex[0] = R_GetTexture(texture);
870         R_Mesh_State(&mstate);
871         ZymoticLerpBones(ent->model->zymnum_bones, (zymbonematrix *) ent->model->zymdata_poses, ent->frameblend, ent->model->zymdata_bones);
872         ZymoticTransformVerts(numverts, varray_vertex, ent->model->zymdata_vertbonecounts, ent->model->zymdata_verts);
873         ZymoticCalcNormals(numverts, varray_vertex, aliasvert_normals, ent->model->zymnum_shaders, ent->model->zymdata_renderlist);
874         memcpy(varray_texcoord[0], ent->model->zymdata_texcoords, ent->model->zymnum_verts * sizeof(float[4]));
875         GL_UseColorArray();
876         R_LightModel(ent, numverts, varray_vertex, aliasvert_normals, varray_color, ifog * colorscale, ifog * colorscale, ifog * colorscale, false);
877         R_Mesh_Draw(numverts, numtriangles, elements);
878         c_alias_polys += numtriangles;
879
880         if (fog)
881         {
882                 memset(&mstate, 0, sizeof(mstate));
883                 mstate.blendfunc1 = GL_SRC_ALPHA;
884                 mstate.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
885                 // FIXME: need alpha mask for fogging...
886                 //mstate.tex[0] = R_GetTexture(texture);
887                 R_Mesh_State(&mstate);
888                 GL_Color(fogcolor[0] * r_colorscale, fogcolor[1] * r_colorscale, fogcolor[2] * r_colorscale, ent->alpha * fog);
889                 R_Mesh_Draw(numverts, numtriangles, elements);
890                 c_alias_polys += numtriangles;
891         }
892 }
893
894 void R_Model_Zymotic_Draw(entity_render_t *ent)
895 {
896         int i;
897
898         if (ent->alpha < (1.0f / 64.0f))
899                 return; // basically completely transparent
900
901         c_models++;
902
903         for (i = 0;i < ent->model->zymnum_shaders;i++)
904         {
905                 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->zymdata_textures[i]))
906                         R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
907                 else
908                         R_DrawZymoticModelMeshCallback(ent, i);
909         }
910 }
911
912 void R_Model_Zymotic_DrawFakeShadow(entity_render_t *ent)
913 {
914         // FIXME
915 }
916
917 void R_Model_Zymotic_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, float lightradius2, float lightdistbias, float lightsubtract, float *lightcolor)
918 {
919         // FIXME
920 }
921
922 void R_Model_Zymotic_DrawOntoLight(entity_render_t *ent)
923 {
924         // FIXME
925 }