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 m.pointer_vertex = varray_vertex3f;
239 c_alias_polys += mesh->num_triangles;
240 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
241 if (layer->flags & ALIASLAYER_FOG)
244 GL_Color(fogcolor[0] * colorscale, fogcolor[1] * colorscale, fogcolor[2] * colorscale, ent->alpha);
248 fullbright = !(layer->flags & ALIASLAYER_DIFFUSE) || r_fullbright.integer || (ent->effects & EF_FULLBRIGHT);
249 if (layer->flags & (ALIASLAYER_COLORMAP_PANTS | ALIASLAYER_COLORMAP_SHIRT))
251 // 128-224 are backwards ranges
252 if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
253 c = (ent->colormap & 0xF) << 4;
254 else //if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
255 c = (ent->colormap & 0xF0);
256 c += (c >= 128 && c < 224) ? 4 : 12;
257 bcolor = (qbyte *) (&palette_complete[c]);
258 fullbright = fullbright || c >= 224;
259 VectorScale(bcolor, (1.0f / 255.0f), tint);
262 tint[0] = tint[1] = tint[2] = 1;
263 if (r_shadow_realtime_world.integer && !fullbright)
264 VectorScale(tint, r_shadow_realtime_world_lightmaps.value, tint);
267 GL_Color(tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha);
270 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha, false))
272 m.pointer_color = varray_color4f;
273 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, varray_normal3f);
274 R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, varray_vertex3f, varray_normal3f, varray_color4f);
277 GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
281 GL_LockArrays(0, mesh->num_vertices);
282 R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
287 void R_Model_Alias_Draw(entity_render_t *ent)
291 if (ent->alpha < (1.0f / 64.0f))
292 return; // basically completely transparent
296 for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
298 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchAliasSkin(ent, mesh)->flags & ALIASSKIN_TRANSPARENT)
299 R_MeshQueue_AddTransparent(ent->origin, R_DrawAliasModelCallback, ent, meshnum);
301 R_DrawAliasModelCallback(ent, meshnum);
305 void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
310 float projectdistance;
311 if (ent->effects & EF_ADDITIVE || ent->alpha < 1)
313 projectdistance = lightradius + ent->model->radius;// - sqrt(DotProduct(relativelightorigin, relativelightorigin));
314 if (projectdistance > 0.1)
316 R_Mesh_Matrix(&ent->matrix);
317 for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
319 skin = R_FetchAliasSkin(ent, mesh);
320 if (skin->flags & ALIASSKIN_TRANSPARENT)
322 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
323 R_Shadow_VolumeFromSphere(mesh->num_vertices, mesh->num_triangles, varray_vertex3f, mesh->data_element3i, mesh->data_neighbor3i, relativelightorigin, projectdistance, lightradius);
328 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)
330 int c, meshnum, layernum;
331 float fog, ifog, lightcolor2[3];
338 if (ent->effects & (EF_ADDITIVE | EF_FULLBRIGHT) || ent->alpha < 1)
341 R_Mesh_Matrix(&ent->matrix);
346 VectorSubtract(ent->origin, r_vieworigin, diff);
347 fog = DotProduct(diff,diff);
350 fog = exp(fogdensity/fog);
355 // fog method: darken, additive fog
356 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
357 // 2. render fog as additive
361 for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
363 skin = R_FetchAliasSkin(ent, mesh);
364 if (skin->flags & ALIASSKIN_TRANSPARENT)
366 expandaliasvert(mesh->num_vertices);
367 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, aliasvert_vertex3f);
368 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_SVECTOR, aliasvert_svector3f);
369 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_TVECTOR, aliasvert_tvector3f);
370 R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, aliasvert_normal3f);
371 for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
373 if (!(layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
374 || ((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
375 || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0))
377 lightcolor2[0] = lightcolor[0] * ifog;
378 lightcolor2[1] = lightcolor[1] * ifog;
379 lightcolor2[2] = lightcolor[2] * ifog;
380 if (layer->flags & ALIASLAYER_SPECULAR)
382 c_alias_polys += mesh->num_triangles;
383 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, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, lightcubemap);
385 else if (layer->flags & ALIASLAYER_DIFFUSE)
387 if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
389 // 128-224 are backwards ranges
390 c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
391 // fullbright passes were already taken care of, so skip them in realtime lighting passes
394 bcolor = (qbyte *) (&palette_complete[c]);
395 lightcolor2[0] *= bcolor[0] * (1.0f / 255.0f);
396 lightcolor2[1] *= bcolor[1] * (1.0f / 255.0f);
397 lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
399 else if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
401 // 128-224 are backwards ranges
402 c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
403 // fullbright passes were already taken care of, so skip them in realtime lighting passes
406 bcolor = (qbyte *) (&palette_complete[c]);
407 lightcolor2[0] *= bcolor[0] * (1.0f / 255.0f);
408 lightcolor2[1] *= bcolor[1] * (1.0f / 255.0f);
409 lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
411 c_alias_polys += mesh->num_triangles;
412 R_Shadow_DiffuseLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, aliasvert_vertex3f, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, lightcubemap);
418 int ZymoticLerpBones(int count, const zymbonematrix *bonebase, const frameblend_t *blend, const zymbone_t *bone)
421 float lerp1, lerp2, lerp3, lerp4;
422 zymbonematrix *out, rootmatrix, m;
423 const zymbonematrix *bone1, *bone2, *bone3, *bone4;
425 rootmatrix.m[0][0] = 1;
426 rootmatrix.m[0][1] = 0;
427 rootmatrix.m[0][2] = 0;
428 rootmatrix.m[0][3] = 0;
429 rootmatrix.m[1][0] = 0;
430 rootmatrix.m[1][1] = 1;
431 rootmatrix.m[1][2] = 0;
432 rootmatrix.m[1][3] = 0;
433 rootmatrix.m[2][0] = 0;
434 rootmatrix.m[2][1] = 0;
435 rootmatrix.m[2][2] = 1;
436 rootmatrix.m[2][3] = 0;
438 bone1 = bonebase + blend[0].frame * count;
439 lerp1 = blend[0].lerp;
442 bone2 = bonebase + blend[1].frame * count;
443 lerp2 = blend[1].lerp;
446 bone3 = bonebase + blend[2].frame * count;
447 lerp3 = blend[2].lerp;
451 bone4 = bonebase + blend[3].frame * count;
452 lerp4 = blend[3].lerp;
453 for (i = 0, out = zymbonepose;i < count;i++, out++)
455 // interpolate matrices
456 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3 + bone4->m[0][0] * lerp4;
457 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3 + bone4->m[0][1] * lerp4;
458 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3 + bone4->m[0][2] * lerp4;
459 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3 + bone4->m[0][3] * lerp4;
460 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3 + bone4->m[1][0] * lerp4;
461 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3 + bone4->m[1][1] * lerp4;
462 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3 + bone4->m[1][2] * lerp4;
463 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3 + bone4->m[1][3] * lerp4;
464 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3 + bone4->m[2][0] * lerp4;
465 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3 + bone4->m[2][1] * lerp4;
466 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3 + bone4->m[2][2] * lerp4;
467 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3 + bone4->m[2][3] * lerp4;
468 if (bone->parent >= 0)
469 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
471 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
482 for (i = 0, out = zymbonepose;i < count;i++, out++)
484 // interpolate matrices
485 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2 + bone3->m[0][0] * lerp3;
486 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2 + bone3->m[0][1] * lerp3;
487 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2 + bone3->m[0][2] * lerp3;
488 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2 + bone3->m[0][3] * lerp3;
489 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2 + bone3->m[1][0] * lerp3;
490 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2 + bone3->m[1][1] * lerp3;
491 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2 + bone3->m[1][2] * lerp3;
492 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2 + bone3->m[1][3] * lerp3;
493 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2 + bone3->m[2][0] * lerp3;
494 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2 + bone3->m[2][1] * lerp3;
495 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2 + bone3->m[2][2] * lerp3;
496 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2 + bone3->m[2][3] * lerp3;
497 if (bone->parent >= 0)
498 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
500 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
511 for (i = 0, out = zymbonepose;i < count;i++, out++)
513 // interpolate matrices
514 m.m[0][0] = bone1->m[0][0] * lerp1 + bone2->m[0][0] * lerp2;
515 m.m[0][1] = bone1->m[0][1] * lerp1 + bone2->m[0][1] * lerp2;
516 m.m[0][2] = bone1->m[0][2] * lerp1 + bone2->m[0][2] * lerp2;
517 m.m[0][3] = bone1->m[0][3] * lerp1 + bone2->m[0][3] * lerp2;
518 m.m[1][0] = bone1->m[1][0] * lerp1 + bone2->m[1][0] * lerp2;
519 m.m[1][1] = bone1->m[1][1] * lerp1 + bone2->m[1][1] * lerp2;
520 m.m[1][2] = bone1->m[1][2] * lerp1 + bone2->m[1][2] * lerp2;
521 m.m[1][3] = bone1->m[1][3] * lerp1 + bone2->m[1][3] * lerp2;
522 m.m[2][0] = bone1->m[2][0] * lerp1 + bone2->m[2][0] * lerp2;
523 m.m[2][1] = bone1->m[2][1] * lerp1 + bone2->m[2][1] * lerp2;
524 m.m[2][2] = bone1->m[2][2] * lerp1 + bone2->m[2][2] * lerp2;
525 m.m[2][3] = bone1->m[2][3] * lerp1 + bone2->m[2][3] * lerp2;
526 if (bone->parent >= 0)
527 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
529 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
542 for (i = 0, out = zymbonepose;i < count;i++, out++)
544 // interpolate matrices
545 m.m[0][0] = bone1->m[0][0] * lerp1;
546 m.m[0][1] = bone1->m[0][1] * lerp1;
547 m.m[0][2] = bone1->m[0][2] * lerp1;
548 m.m[0][3] = bone1->m[0][3] * lerp1;
549 m.m[1][0] = bone1->m[1][0] * lerp1;
550 m.m[1][1] = bone1->m[1][1] * lerp1;
551 m.m[1][2] = bone1->m[1][2] * lerp1;
552 m.m[1][3] = bone1->m[1][3] * lerp1;
553 m.m[2][0] = bone1->m[2][0] * lerp1;
554 m.m[2][1] = bone1->m[2][1] * lerp1;
555 m.m[2][2] = bone1->m[2][2] * lerp1;
556 m.m[2][3] = bone1->m[2][3] * lerp1;
557 if (bone->parent >= 0)
558 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &m.m[0][0], &out->m[0][0]);
560 R_ConcatTransforms(&rootmatrix.m[0][0], &m.m[0][0], &out->m[0][0]);
568 for (i = 0, out = zymbonepose;i < count;i++, out++)
570 if (bone->parent >= 0)
571 R_ConcatTransforms(&zymbonepose[bone->parent].m[0][0], &bone1->m[0][0], &out->m[0][0]);
573 R_ConcatTransforms(&rootmatrix.m[0][0], &bone1->m[0][0], &out->m[0][0]);
582 void ZymoticTransformVerts(int vertcount, float *vertex, int *bonecounts, zymvertex_t *vert)
586 zymbonematrix *matrix;
590 // FIXME: validate bonecounts at load time (must be >= 1)
591 // FIXME: need 4th component in origin, for how much of the translate to blend in
594 matrix = &zymbonepose[vert->bonenum];
595 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];
596 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];
597 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];
605 matrix = &zymbonepose[vert->bonenum];
606 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];
607 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];
608 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];
616 void ZymoticCalcNormal3f(int vertcount, float *vertex3f, float *normal3f, int shadercount, int *renderlist)
619 float *out, v1[3], v2[3], normal[3], s;
622 memset(normal3f, 0, sizeof(float) * vertcount * 3);
623 memset(aliasvertusage, 0, sizeof(int) * vertcount);
624 // parse render list and accumulate surface normals
633 v1[0] = vertex3f[a+0] - vertex3f[b+0];
634 v1[1] = vertex3f[a+1] - vertex3f[b+1];
635 v1[2] = vertex3f[a+2] - vertex3f[b+2];
636 v2[0] = vertex3f[c+0] - vertex3f[b+0];
637 v2[1] = vertex3f[c+1] - vertex3f[b+1];
638 v2[2] = vertex3f[c+2] - vertex3f[b+2];
639 CrossProduct(v1, v2, normal);
640 VectorNormalizeFast(normal);
641 // add surface normal to vertices
642 a = renderlist[0] * 3;
643 normal3f[a+0] += normal[0];
644 normal3f[a+1] += normal[1];
645 normal3f[a+2] += normal[2];
646 aliasvertusage[renderlist[0]]++;
647 a = renderlist[1] * 3;
648 normal3f[a+0] += normal[0];
649 normal3f[a+1] += normal[1];
650 normal3f[a+2] += normal[2];
651 aliasvertusage[renderlist[1]]++;
652 a = renderlist[2] * 3;
653 normal3f[a+0] += normal[0];
654 normal3f[a+1] += normal[1];
655 normal3f[a+2] += normal[2];
656 aliasvertusage[renderlist[2]]++;
660 // FIXME: precalc this
661 // average surface normals
678 void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
680 float fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
682 int i, *renderlist, *elements;
685 const entity_render_t *ent = calldata1;
686 int shadernum = calldata2;
687 int numverts, numtriangles;
689 R_Mesh_Matrix(&ent->matrix);
691 // find the vertex index list and texture
692 renderlist = ent->model->alias.zymdata_renderlist;
693 for (i = 0;i < shadernum;i++)
694 renderlist += renderlist[0] * 3 + 1;
695 texture = ent->model->alias.zymdata_textures[shadernum];
697 numverts = ent->model->alias.zymnum_verts;
698 numtriangles = *renderlist++;
699 elements = renderlist;
701 expandaliasvert(numverts);
706 VectorSubtract(ent->origin, r_vieworigin, diff);
707 fog = DotProduct(diff,diff);
710 fog = exp(fogdensity/fog);
715 // fog method: darken, additive fog
716 // 1. render model as normal, scaled by inverse of fog alpha (darkens it)
717 // 2. render fog as additive
721 if (ent->effects & EF_ADDITIVE)
723 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
726 else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
728 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
733 GL_BlendFunc(GL_ONE, GL_ZERO);
738 memset(&mstate, 0, sizeof(mstate));
740 if (gl_combine.integer)
742 mstate.texrgbscale[0] = 4;
745 mstate.tex[0] = R_GetTexture(texture);
746 mstate.pointer_texcoord[0] = ent->model->alias.zymdata_texcoords;
747 mstate.pointer_vertex = varray_vertex3f;
749 ZymoticLerpBones(ent->model->alias.zymnum_bones, (zymbonematrix *) ent->model->alias.zymdata_poses, ent->frameblend, ent->model->alias.zymdata_bones);
751 ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
752 ZymoticCalcNormal3f(numverts, varray_vertex3f, aliasvert_normal3f, ent->model->alias.zymnum_shaders, ent->model->alias.zymdata_renderlist);
753 if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, ifog * colorscale, ifog * colorscale, ifog * colorscale, ent->alpha, false))
755 mstate.pointer_color = varray_color4f;
756 R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, numverts, varray_vertex3f, aliasvert_normal3f, varray_color4f);
759 GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
760 R_Mesh_State(&mstate);
761 GL_LockArrays(0, numverts);
762 R_Mesh_Draw(numverts, numtriangles, elements);
764 c_alias_polys += numtriangles;
768 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
772 memset(&mstate, 0, sizeof(mstate));
773 // FIXME: need alpha mask for fogging...
774 //mstate.tex[0] = R_GetTexture(texture);
775 //mstate.pointer_texcoord = ent->model->alias.zymdata_texcoords;
776 mstate.pointer_vertex = varray_vertex3f;
777 R_Mesh_State(&mstate);
779 GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], ent->alpha * fog);
780 ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
781 R_Mesh_State(&mstate);
782 GL_LockArrays(0, numverts);
783 R_Mesh_Draw(numverts, numtriangles, elements);
785 c_alias_polys += numtriangles;
789 void R_Model_Zymotic_Draw(entity_render_t *ent)
793 if (ent->alpha < (1.0f / 64.0f))
794 return; // basically completely transparent
798 for (i = 0;i < ent->model->alias.zymnum_shaders;i++)
800 if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->alias.zymdata_textures[i]))
801 R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
803 R_DrawZymoticModelMeshCallback(ent, i);
807 void R_Model_Zymotic_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
812 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)