3 #include "cl_collision.h"
11 // LordHavoc: vertex arrays
13 void *aliasvertarrays = NULL;
14 float *aliasvertcolor4fbuf = NULL;
15 float *aliasvertcolor4f = NULL; // this may point at aliasvertcolorbuf or at vertex arrays in the mesh backend
16 float *aliasvert_vertex3f = NULL;
17 float *aliasvert_svector3f = NULL;
18 float *aliasvert_tvector3f = NULL;
19 float *aliasvert_normal3f = NULL;
21 float *aliasvertcolor2_4f = NULL;
23 zymbonematrix *zymbonepose;
25 mempool_t *gl_models_mempool;
27 #define expandaliasvert(newmax) if ((newmax) > aliasvertmax) gl_models_allocarrays(newmax)
29 void gl_models_allocarrays(int newmax)
32 aliasvertmax = newmax;
33 if (aliasvertarrays != NULL)
34 Mem_Free(aliasvertarrays);
35 aliasvertarrays = Mem_Alloc(gl_models_mempool, aliasvertmax * (sizeof(float[4+4+3+3+3+3]) + sizeof(int[3])));
36 data = aliasvertarrays;
37 aliasvertcolor4f = aliasvertcolor4fbuf = (void *)data;data += aliasvertmax * sizeof(float[4]);
38 aliasvertcolor2_4f = (void *)data;data += aliasvertmax * sizeof(float[4]); // used temporarily for tinted coloring
39 aliasvert_vertex3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
40 aliasvert_svector3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
41 aliasvert_tvector3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
42 aliasvert_normal3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
43 aliasvertusage = (void *)data;data += aliasvertmax * sizeof(int[3]);
46 void gl_models_freearrays(void)
49 if (aliasvertarrays != NULL)
50 Mem_Free(aliasvertarrays);
51 aliasvertarrays = NULL;
52 aliasvertcolor4f = aliasvertcolor4fbuf = NULL;
53 aliasvertcolor2_4f = NULL;
54 aliasvert_vertex3f = NULL;
55 aliasvert_svector3f = NULL;
56 aliasvert_tvector3f = NULL;
57 aliasvert_normal3f = NULL;
58 aliasvertusage = NULL;
61 void gl_models_start(void)
63 // allocate vertex processing arrays
64 gl_models_mempool = Mem_AllocPool("GL_Models");
65 zymbonepose = Mem_Alloc(gl_models_mempool, sizeof(zymbonematrix[256]));
66 gl_models_allocarrays(4096);
69 void gl_models_shutdown(void)
71 gl_models_freearrays();
72 Mem_FreePool(&gl_models_mempool);
75 void gl_models_newmap(void)
79 void GL_Models_Init(void)
81 R_RegisterModule("GL_Models", gl_models_start, gl_models_shutdown, gl_models_newmap);
84 #define MODELARRAY_VERTEX 0
85 #define MODELARRAY_SVECTOR 1
86 #define MODELARRAY_TVECTOR 2
87 #define MODELARRAY_NORMAL 3
89 void R_Model_Alias_GetMesh_Array3f(const entity_render_t *ent, const aliasmesh_t *mesh, int whicharray, float *out3f)
92 float lerp1, lerp2, lerp3, lerp4;
93 const float *vertsbase, *verts1, *verts2, *verts3, *verts4;
97 case MODELARRAY_VERTEX:vertsbase = mesh->data_aliasvertex3f;break;
98 case MODELARRAY_SVECTOR:vertsbase = mesh->data_aliassvector3f;break;
99 case MODELARRAY_TVECTOR:vertsbase = mesh->data_aliastvector3f;break;
100 case MODELARRAY_NORMAL:vertsbase = mesh->data_aliasnormal3f;break;
102 Host_Error("R_Model_Alias_GetBlendedArray: unknown whicharray %i\n", whicharray);
106 vertcount = mesh->num_vertices;
107 verts1 = vertsbase + ent->frameblend[0].frame * vertcount * 3;
108 lerp1 = ent->frameblend[0].lerp;
109 if (ent->frameblend[1].lerp)
111 verts2 = vertsbase + ent->frameblend[1].frame * vertcount * 3;
112 lerp2 = ent->frameblend[1].lerp;
113 if (ent->frameblend[2].lerp)
115 verts3 = vertsbase + ent->frameblend[2].frame * vertcount * 3;
116 lerp3 = ent->frameblend[2].lerp;
117 if (ent->frameblend[3].lerp)
119 verts4 = vertsbase + ent->frameblend[3].frame * vertcount * 3;
120 lerp4 = ent->frameblend[3].lerp;
121 for (i = 0;i < vertcount * 3;i++)
122 VectorMAMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, lerp4, verts4 + i, out3f + i);
125 for (i = 0;i < vertcount * 3;i++)
126 VectorMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, out3f + i);
129 for (i = 0;i < vertcount * 3;i++)
130 VectorMAM(lerp1, verts1 + i, lerp2, verts2 + i, out3f + i);
133 memcpy(out3f, verts1, vertcount * sizeof(float[3]));
136 aliaslayer_t r_aliasnoskinlayers[2] = {{ALIASLAYER_DIFFUSE, NULL, NULL}, {ALIASLAYER_FOG | ALIASLAYER_FORCEDRAW_IF_FIRSTPASS, NULL, NULL}};
137 aliasskin_t r_aliasnoskin = {0, 2, r_aliasnoskinlayers};
138 aliasskin_t *R_FetchAliasSkin(const entity_render_t *ent, const aliasmesh_t *mesh)
140 model_t *model = ent->model;
143 int s = ent->skinnum;
144 if ((unsigned int)s >= (unsigned int)model->numskins)
146 if (model->skinscenes[s].framecount > 1)
147 s = model->skinscenes[s].firstframe + (int) (cl.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
149 s = model->skinscenes[s].firstframe;
150 if (s >= mesh->num_skins)
152 return mesh->data_skins + s;
156 r_aliasnoskinlayers[0].texture = r_notexture;
157 return &r_aliasnoskin;
161 void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
163 int c, fullbright, layernum, firstpass;
164 float tint[3], fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
168 const entity_render_t *ent = calldata1;
169 aliasmesh_t *mesh = ent->model->alias.aliasdata_meshes + calldata2;
173 R_Mesh_Matrix(&ent->matrix);
178 VectorSubtract(ent->origin, r_vieworigin, diff);
179 fog = DotProduct(diff,diff);
182 fog = exp(fogdensity/fog);
187 // fog method: darken, additive fog
188 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
189 // 2. render fog as additive
194 skin = R_FetchAliasSkin(ent, mesh);
195 for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
197 if (!(layer->flags & ALIASLAYER_FORCEDRAW_IF_FIRSTPASS) || !firstpass)
199 if (((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
200 || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0)
201 || ((layer->flags & ALIASLAYER_FOG) && !fogenabled)
202 || (layer->flags & ALIASLAYER_SPECULAR)
203 || ((layer->flags & ALIASLAYER_DIFFUSE) && (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value <= 0 && r_ambient.integer <= 0 && r_fullbright.integer == 0 && !(ent->effects & EF_FULLBRIGHT))))
206 if (!firstpass || (ent->effects & EF_ADDITIVE))
208 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
211 else if ((skin->flags & ALIASSKIN_TRANSPARENT) || ent->alpha != 1.0)
213 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
218 GL_BlendFunc(GL_ONE, GL_ZERO);
223 expandaliasvert(mesh->num_vertices);
226 memset(&m, 0, sizeof(m));
227 if (layer->texture != NULL)
229 m.tex[0] = R_GetTexture(layer->texture);
230 m.pointer_texcoord[0] = mesh->data_texcoord2f;
231 if (gl_combine.integer && layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
234 m.texrgbscale[0] = 4;
237 R_Mesh_State_Texture(&m);
239 c_alias_polys += mesh->num_triangles;
240 GL_VertexPointer(varray_vertex3f);
241 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
242 if (layer->flags & ALIASLAYER_FOG)
245 GL_Color(fogcolor[0] * colorscale, fogcolor[1] * colorscale, fogcolor[2] * colorscale, ent->alpha);
249 fullbright = !(layer->flags & ALIASLAYER_DIFFUSE) || r_fullbright.integer || (ent->effects & EF_FULLBRIGHT);
250 if (r_shadow_realtime_world.integer && r_shadow_realtime_world_lightmaps.value <= 0 && !fullbright)
252 colorscale *= r_ambient.value * (2.0f / 128.0f);
255 if (layer->flags & (ALIASLAYER_COLORMAP_PANTS | ALIASLAYER_COLORMAP_SHIRT))
257 // 128-224 are backwards ranges
258 if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
259 c = (ent->colormap & 0xF) << 4;
260 else //if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
261 c = (ent->colormap & 0xF0);
262 c += (c >= 128 && c < 224) ? 4 : 12;
263 bcolor = (qbyte *) (&palette_complete[c]);
264 fullbright = fullbright || c >= 224;
265 VectorScale(bcolor, (1.0f / 255.0f), tint);
268 tint[0] = tint[1] = tint[2] = 1;
269 if (r_shadow_realtime_world.integer)
270 VectorScale(tint, r_shadow_realtime_world_lightmaps.value, tint);
273 GL_Color(tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha);
276 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha, false))
278 GL_ColorPointer(varray_color4f);
279 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, varray_normal3f);
280 R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, varray_vertex3f, varray_normal3f, varray_color4f);
283 GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
286 R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
290 void R_Model_Alias_Draw(entity_render_t *ent)
294 if (ent->alpha < (1.0f / 64.0f))
295 return; // basically completely transparent
299 for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
301 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchAliasSkin(ent, mesh)->flags & ALIASSKIN_TRANSPARENT)
302 R_MeshQueue_AddTransparent(ent->origin, R_DrawAliasModelCallback, ent, meshnum);
304 R_DrawAliasModelCallback(ent, meshnum);
308 void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
313 float projectdistance;
314 if (ent->effects & EF_ADDITIVE || ent->alpha < 1)
316 projectdistance = lightradius + ent->model->radius - sqrt(DotProduct(relativelightorigin, relativelightorigin));
317 if (projectdistance > 0.1)
319 R_Mesh_Matrix(&ent->matrix);
320 for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
322 skin = R_FetchAliasSkin(ent, mesh);
323 if (skin->flags & ALIASSKIN_TRANSPARENT)
325 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
326 R_Shadow_Volume(mesh->num_vertices, mesh->num_triangles, varray_vertex3f, mesh->data_element3i, mesh->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
331 void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
333 int c, meshnum, layernum;
334 float fog, ifog, lightcolor2[3];
341 if (ent->effects & (EF_ADDITIVE | EF_FULLBRIGHT) || ent->alpha < 1)
344 R_Mesh_Matrix(&ent->matrix);
349 VectorSubtract(ent->origin, r_vieworigin, diff);
350 fog = DotProduct(diff,diff);
353 fog = exp(fogdensity/fog);
358 // fog method: darken, additive fog
359 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
360 // 2. render fog as additive
364 for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
366 skin = R_FetchAliasSkin(ent, mesh);
367 if (skin->flags & ALIASSKIN_TRANSPARENT)
369 expandaliasvert(mesh->num_vertices);
370 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, aliasvert_vertex3f);
371 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_SVECTOR, aliasvert_svector3f);
372 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_TVECTOR, aliasvert_tvector3f);
373 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, aliasvert_normal3f);
374 for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
376 if (!(layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
377 || ((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
378 || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0))
380 lightcolor2[0] = lightcolor[0] * ifog;
381 lightcolor2[1] = lightcolor[1] * ifog;
382 lightcolor2[2] = lightcolor[2] * ifog;
383 if (layer->flags & ALIASLAYER_SPECULAR)
385 c_alias_polys += mesh->num_triangles;
386 R_Shadow_SpecularLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, aliasvert_vertex3f, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, lightcubemap);
388 else if (layer->flags & ALIASLAYER_DIFFUSE)
390 if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
392 // 128-224 are backwards ranges
393 c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
394 // fullbright passes were already taken care of, so skip them in realtime lighting passes
397 bcolor = (qbyte *) (&palette_complete[c]);
398 lightcolor2[0] *= bcolor[0] * (1.0f / 255.0f);
399 lightcolor2[1] *= bcolor[1] * (1.0f / 255.0f);
400 lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
402 else if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
404 // 128-224 are backwards ranges
405 c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
406 // fullbright passes were already taken care of, so skip them in realtime lighting passes
409 bcolor = (qbyte *) (&palette_complete[c]);
410 lightcolor2[0] *= bcolor[0] * (1.0f / 255.0f);
411 lightcolor2[1] *= bcolor[1] * (1.0f / 255.0f);
412 lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
414 c_alias_polys += mesh->num_triangles;
415 R_Shadow_DiffuseLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, aliasvert_vertex3f, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, lightradius, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, lightcubemap);
421 int ZymoticLerpBones(int count, const zymbonematrix *bonebase, const frameblend_t *blend, const zymbone_t *bone)
424 float lerp1, lerp2, lerp3, lerp4;
425 zymbonematrix *out, rootmatrix, m;
426 const zymbonematrix *bone1, *bone2, *bone3, *bone4;
428 rootmatrix.m[0][0] = 1;
429 rootmatrix.m[0][1] = 0;
430 rootmatrix.m[0][2] = 0;
431 rootmatrix.m[0][3] = 0;
432 rootmatrix.m[1][0] = 0;
433 rootmatrix.m[1][1] = 1;
434 rootmatrix.m[1][2] = 0;
435 rootmatrix.m[1][3] = 0;
436 rootmatrix.m[2][0] = 0;
437 rootmatrix.m[2][1] = 0;
438 rootmatrix.m[2][2] = 1;
439 rootmatrix.m[2][3] = 0;
441 bone1 = bonebase + blend[0].frame * count;
442 lerp1 = blend[0].lerp;
445 bone2 = bonebase + blend[1].frame * count;
446 lerp2 = blend[1].lerp;
449 bone3 = bonebase + blend[2].frame * count;
450 lerp3 = blend[2].lerp;
454 bone4 = bonebase + blend[3].frame * count;
455 lerp4 = blend[3].lerp;
456 for (i = 0, out = zymbonepose;i < count;i++, out++)
458 // interpolate matrices
459 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3 + bone4->m[0][0] * lerp4;
460 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3 + bone4->m[0][1] * lerp4;
461 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3 + bone4->m[0][2] * lerp4;
462 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3 + bone4->m[0][3] * lerp4;
463 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3 + bone4->m[1][0] * lerp4;
464 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3 + bone4->m[1][1] * lerp4;
465 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3 + bone4->m[1][2] * lerp4;
466 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3 + bone4->m[1][3] * lerp4;
467 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3 + bone4->m[2][0] * lerp4;
468 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3 + bone4->m[2][1] * lerp4;
469 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3 + bone4->m[2][2] * lerp4;
470 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3 + bone4->m[2][3] * lerp4;
471 if (bone->parent >= 0)
472 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
474 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
485 for (i = 0, out = zymbonepose;i < count;i++, out++)
487 // interpolate matrices
488 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3;
489 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3;
490 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3;
491 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3;
492 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3;
493 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3;
494 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3;
495 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3;
496 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3;
497 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3;
498 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3;
499 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3;
500 if (bone->parent >= 0)
501 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
503 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
514 for (i = 0, out = zymbonepose;i < count;i++, out++)
516 // interpolate matrices
517 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2;
518 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2;
519 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2;
520 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2;
521 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2;
522 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2;
523 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2;
524 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2;
525 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2;
526 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2;
527 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2;
528 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2;
529 if (bone->parent >= 0)
530 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
532 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
545 for (i = 0, out = zymbonepose;i < count;i++, out++)
547 // interpolate matrices
548 m.m[0][0] = bone1->m[0][0] * lerp1;
549 m.m[0][1] = bone1->m[0][1] * lerp1;
550 m.m[0][2] = bone1->m[0][2] * lerp1;
551 m.m[0][3] = bone1->m[0][3] * lerp1;
552 m.m[1][0] = bone1->m[1][0] * lerp1;
553 m.m[1][1] = bone1->m[1][1] * lerp1;
554 m.m[1][2] = bone1->m[1][2] * lerp1;
555 m.m[1][3] = bone1->m[1][3] * lerp1;
556 m.m[2][0] = bone1->m[2][0] * lerp1;
557 m.m[2][1] = bone1->m[2][1] * lerp1;
558 m.m[2][2] = bone1->m[2][2] * lerp1;
559 m.m[2][3] = bone1->m[2][3] * lerp1;
560 if (bone->parent >= 0)
561 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
563 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
571 for (i = 0, out = zymbonepose;i < count;i++, out++)
573 if (bone->parent >= 0)
574 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &bone1->m[0][0], &out->m[0][0]);
576 R_ConcatTransforms(&rootmatrix.m[0][0], &bone1->m[0][0], &out->m[0][0]);
585 void ZymoticTransformVerts(int vertcount, float *vertex, int *bonecounts, zymvertex_t *vert)
589 zymbonematrix *matrix;
593 // FIXME: validate bonecounts at load time (must be >= 1)
594 // FIXME: need 4th component in origin, for how much of the translate to blend in
597 matrix = &zymbonepose[vert->bonenum];
598 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];
599 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];
600 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];
608 matrix = &zymbonepose[vert->bonenum];
609 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];
610 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];
611 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];
619 void ZymoticCalcNormal3f(int vertcount, float *vertex3f, float *normal3f, int shadercount, int *renderlist)
622 float *out, v1[3], v2[3], normal[3], s;
625 memset(normal3f, 0, sizeof(float) * vertcount * 3);
626 memset(aliasvertusage, 0, sizeof(int) * vertcount);
627 // parse render list and accumulate surface normals
636 v1[0] = vertex3f[a+0] - vertex3f[b+0];
637 v1[1] = vertex3f[a+1] - vertex3f[b+1];
638 v1[2] = vertex3f[a+2] - vertex3f[b+2];
639 v2[0] = vertex3f[c+0] - vertex3f[b+0];
640 v2[1] = vertex3f[c+1] - vertex3f[b+1];
641 v2[2] = vertex3f[c+2] - vertex3f[b+2];
642 CrossProduct(v1, v2, normal);
643 VectorNormalizeFast(normal);
644 // add surface normal to vertices
645 a = renderlist[0] * 3;
646 normal3f[a+0] += normal[0];
647 normal3f[a+1] += normal[1];
648 normal3f[a+2] += normal[2];
649 aliasvertusage[renderlist[0]]++;
650 a = renderlist[1] * 3;
651 normal3f[a+0] += normal[0];
652 normal3f[a+1] += normal[1];
653 normal3f[a+2] += normal[2];
654 aliasvertusage[renderlist[1]]++;
655 a = renderlist[2] * 3;
656 normal3f[a+0] += normal[0];
657 normal3f[a+1] += normal[1];
658 normal3f[a+2] += normal[2];
659 aliasvertusage[renderlist[2]]++;
663 // FIXME: precalc this
664 // average surface normals
681 void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
683 float fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
685 int i, *renderlist, *elements;
688 const entity_render_t *ent = calldata1;
689 int shadernum = calldata2;
690 int numverts, numtriangles;
692 R_Mesh_Matrix(&ent->matrix);
694 // find the vertex index list and texture
695 renderlist = ent->model->alias.zymdata_renderlist;
696 for (i = 0;i < shadernum;i++)
697 renderlist += renderlist[0] * 3 + 1;
698 texture = ent->model->alias.zymdata_textures[shadernum];
700 numverts = ent->model->alias.zymnum_verts;
701 numtriangles = *renderlist++;
702 elements = renderlist;
704 expandaliasvert(numverts);
709 VectorSubtract(ent->origin, r_vieworigin, diff);
710 fog = DotProduct(diff,diff);
713 fog = exp(fogdensity/fog);
718 // fog method: darken, additive fog
719 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
720 // 2. render fog as additive
724 if (ent->effects & EF_ADDITIVE)
726 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
729 else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
731 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
736 GL_BlendFunc(GL_ONE, GL_ZERO);
740 GL_VertexPointer(varray_vertex3f);
742 memset(&mstate, 0, sizeof(mstate));
744 if (gl_combine.integer)
746 mstate.texrgbscale[0] = 4;
749 mstate.tex[0] = R_GetTexture(texture);
750 mstate.pointer_texcoord[0] = ent->model->alias.zymdata_texcoords;
751 R_Mesh_State_Texture(&mstate);
753 ZymoticLerpBones(ent->model->alias.zymnum_bones, (zymbonematrix *) ent->model->alias.zymdata_poses, ent->frameblend, ent->model->alias.zymdata_bones);
755 ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
756 ZymoticCalcNormal3f(numverts, varray_vertex3f, aliasvert_normal3f, ent->model->alias.zymnum_shaders, ent->model->alias.zymdata_renderlist);
757 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, ifog * colorscale, ifog * colorscale, ifog * colorscale, ent->alpha, false))
759 GL_ColorPointer(varray_color4f);
760 R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, numverts, varray_vertex3f, aliasvert_normal3f, varray_color4f);
763 GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
764 R_Mesh_Draw(numverts, numtriangles, elements);
765 c_alias_polys += numtriangles;
769 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
772 GL_VertexPointer(varray_vertex3f);
774 memset(&mstate, 0, sizeof(mstate));
775 // FIXME: need alpha mask for fogging...
776 //mstate.tex[0] = R_GetTexture(texture);
777 //mstate.pointer_texcoord = ent->model->alias.zymdata_texcoords;
778 R_Mesh_State_Texture(&mstate);
780 GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], ent->alpha * fog);
781 ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
782 R_Mesh_Draw(numverts, numtriangles, elements);
783 c_alias_polys += numtriangles;
787 void R_Model_Zymotic_Draw(entity_render_t *ent)
791 if (ent->alpha < (1.0f / 64.0f))
792 return; // basically completely transparent
796 for (i = 0;i < ent->model->alias.zymnum_shaders;i++)
798 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->alias.zymdata_textures[i]))
799 R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
801 R_DrawZymoticModelMeshCallback(ent, i);
805 void R_Model_Zymotic_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
810 void R_Model_Zymotic_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)