void *aliasvertarrays = NULL;
float *aliasvertcolor4fbuf = NULL;
float *aliasvertcolor4f = NULL; // this may point at aliasvertcolorbuf or at vertex arrays in the mesh backend
+float *aliasvert_vertex3f = NULL;
float *aliasvert_svector3f = NULL;
float *aliasvert_tvector3f = NULL;
float *aliasvert_normal3f = NULL;
aliasvertmax = newmax;
if (aliasvertarrays != NULL)
Mem_Free(aliasvertarrays);
- aliasvertarrays = Mem_Alloc(gl_models_mempool, aliasvertmax * (sizeof(float[4+4+3+3+3]) + sizeof(int[3])));
+ aliasvertarrays = Mem_Alloc(gl_models_mempool, aliasvertmax * (sizeof(float[4+4+3+3+3+3]) + sizeof(int[3])));
data = aliasvertarrays;
aliasvertcolor4f = aliasvertcolor4fbuf = (void *)data;data += aliasvertmax * sizeof(float[4]);
aliasvertcolor2_4f = (void *)data;data += aliasvertmax * sizeof(float[4]); // used temporarily for tinted coloring
+ aliasvert_vertex3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
aliasvert_svector3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
aliasvert_tvector3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
aliasvert_normal3f = (void *)data;data += aliasvertmax * sizeof(float[3]);
aliasvertarrays = NULL;
aliasvertcolor4f = aliasvertcolor4fbuf = NULL;
aliasvertcolor2_4f = NULL;
+ aliasvert_vertex3f = NULL;
aliasvert_svector3f = NULL;
aliasvert_tvector3f = NULL;
aliasvert_normal3f = NULL;
R_RegisterModule("GL_Models", gl_models_start, gl_models_shutdown, gl_models_newmap);
}
-void R_Model_Alias_GetMesh_Vertex3f(const entity_render_t *ent, aliasmesh_t *mesh, float *vertex3f, float *normal3f, float *svector3f, float *tvector3f)
+#define MODELARRAY_VERTEX 0
+#define MODELARRAY_SVECTOR 1
+#define MODELARRAY_TVECTOR 2
+#define MODELARRAY_NORMAL 3
+
+void R_Model_Alias_GetMesh_Array3f(const entity_render_t *ent, aliasmesh_t *mesh, int whicharray, float *out3f)
{
int i, vertcount;
float lerp1, lerp2, lerp3, lerp4;
- const aliasvertex_t *verts1, *verts2, *verts3, *verts4;
+ const float *vertsbase, *verts1, *verts2, *verts3, *verts4;
- if (vertex3f == NULL)
- Host_Error("R_Model_Alias_GetMesh_Vertex3f: vertices == NULL.\n");
- if (svector3f != NULL && (tvector3f == NULL || normal3f == NULL))
- Host_Error("R_Model_Alias_GetMesh_Vertex3f: svectors requires tvectors and normals.\n");
- if (tvector3f != NULL && (svector3f == NULL || normal3f == NULL))
- Host_Error("R_Model_Alias_GetMesh_Vertex3f: tvectors requires svectors and normals.\n");
+ switch(whicharray)
+ {
+ case MODELARRAY_VERTEX:vertsbase = mesh->data_aliasvertex3f;break;
+ case MODELARRAY_SVECTOR:vertsbase = mesh->data_aliassvector3f;break;
+ case MODELARRAY_TVECTOR:vertsbase = mesh->data_aliastvector3f;break;
+ case MODELARRAY_NORMAL:vertsbase = mesh->data_aliasnormal3f;break;
+ default:
+ Host_Error("R_Model_Alias_GetBlendedArray: unknown whicharray %i\n", whicharray);
+ return;
+ }
vertcount = mesh->num_vertices;
- verts1 = mesh->data_aliasvertex + ent->frameblend[0].frame * vertcount;
+ verts1 = vertsbase + ent->frameblend[0].frame * vertcount * 3;
lerp1 = ent->frameblend[0].lerp;
if (ent->frameblend[1].lerp)
{
- verts2 = mesh->data_aliasvertex + ent->frameblend[1].frame * vertcount;
+ verts2 = vertsbase + ent->frameblend[1].frame * vertcount * 3;
lerp2 = ent->frameblend[1].lerp;
if (ent->frameblend[2].lerp)
{
- verts3 = mesh->data_aliasvertex + ent->frameblend[2].frame * vertcount;
+ verts3 = vertsbase + ent->frameblend[2].frame * vertcount * 3;
lerp3 = ent->frameblend[2].lerp;
if (ent->frameblend[3].lerp)
{
- verts4 = mesh->data_aliasvertex + ent->frameblend[3].frame * vertcount;
+ verts4 = vertsbase + ent->frameblend[3].frame * vertcount * 3;
lerp4 = ent->frameblend[3].lerp;
- // generate vertices
- if (svector3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++, verts2++, verts3++, verts4++)
- {
- VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertex3f);
- VectorMAMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, lerp4, verts4->normal, normal3f);
- VectorMAMAMAM(lerp1, verts1->svector, lerp2, verts2->svector, lerp3, verts3->svector, lerp4, verts4->svector, svector3f);
- CrossProduct(svector3f, normal3f, tvector3f);
- }
- }
- else if (normal3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++, verts2++, verts3++, verts4++)
- {
- VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertex3f);
- VectorMAMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, lerp4, verts4->normal, normal3f);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++, verts2++, verts3++, verts4++)
- VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertex3f);
+ for (i = 0;i < vertcount * 3;i++)
+ VectorMAMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, lerp4, verts4 + i, out3f + i);
}
else
- {
- // generate vertices
- if (svector3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++, verts2++, verts3++)
- {
- VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertex3f);
- VectorMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, normal3f);
- VectorMAMAM(lerp1, verts1->svector, lerp2, verts2->svector, lerp3, verts3->svector, svector3f);
- CrossProduct(svector3f, normal3f, tvector3f);
- }
- }
- else if (normal3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++, verts2++, verts3++)
- {
- VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertex3f);
- VectorMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, normal3f);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++, verts2++, verts3++)
- VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertex3f);
- }
+ for (i = 0;i < vertcount * 3;i++)
+ VectorMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, out3f + i);
}
else
- {
- // generate vertices
- if (svector3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++, verts2++)
- {
- VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertex3f);
- VectorMAM(lerp1, verts1->normal, lerp2, verts2->normal, normal3f);
- VectorMAM(lerp1, verts1->svector, lerp2, verts2->svector, svector3f);
- CrossProduct(svector3f, normal3f, tvector3f);
- }
- }
- else if (normal3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++, verts2++)
- {
- VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertex3f);
- VectorMAM(lerp1, verts1->normal, lerp2, verts2->normal, normal3f);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++, verts2++)
- VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertex3f);
- }
+ for (i = 0;i < vertcount * 3;i++)
+ VectorMAM(lerp1, verts1 + i, lerp2, verts2 + i, out3f + i);
}
else
- {
- // generate vertices
- if (svector3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3, verts1++)
- {
- VectorCopy(verts1->origin, vertex3f);
- VectorCopy(verts1->normal, normal3f);
- VectorCopy(verts1->svector, svector3f);
- CrossProduct(svector3f, normal3f, tvector3f);
- }
- }
- else if (normal3f != NULL)
- {
- for (i = 0;i < vertcount;i++, vertex3f += 3, normal3f += 3, verts1++)
- {
- VectorCopy(verts1->origin, vertex3f);
- VectorCopy(verts1->normal, normal3f);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertex3f += 3, verts1++)
- VectorCopy(verts1->origin, vertex3f);
- }
+ memcpy(out3f, verts1, vertcount * sizeof(float[3]));
}
aliaslayer_t r_aliasnoskinlayers[2] = {{ALIASLAYER_DIFFUSE, NULL, NULL}, {ALIASLAYER_FOG | ALIASLAYER_FORCEDRAW_IF_FIRSTPASS, NULL, NULL}};
void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
{
int c, fullbright, layernum, firstpass;
- float tint[3], fog, ifog, colorscale;
+ float tint[3], fog, ifog, colorscale, ambientcolor4f[4], *fcolor;
vec3_t diff;
qbyte *bcolor;
rmeshstate_t m;
aliasmesh_t *mesh = ent->model->aliasdata_meshes + calldata2;
aliaslayer_t *layer;
aliasskin_t *skin;
+ rcachearrayrequest_t request;
R_Mesh_Matrix(&ent->matrix);
ifog = 1 - fog;
firstpass = true;
- memset(&m, 0, sizeof(m));
skin = R_FetchAliasSkin(ent, mesh);
for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
{
|| ((layer->flags & ALIASLAYER_DIFFUSE) && (r_shadow_realtime_world.integer && r_ambient.integer <= 0 && r_fullbright.integer == 0 && !(ent->effects & EF_FULLBRIGHT))))
continue;
}
+ memset(&m, 0, sizeof(m));
if (!firstpass || (ent->effects & EF_ADDITIVE))
{
m.blendfunc1 = GL_SRC_ALPHA;
colorscale *= 0.25f;
m.texrgbscale[0] = 4;
}
- R_Mesh_State(&m);
c_alias_polys += mesh->num_triangles;
- R_Mesh_GetSpace(mesh->num_vertices);
- if (layer->texture != NULL)
- R_Mesh_CopyTexCoord2f(0, mesh->data_texcoord2f, mesh->num_vertices);
+ if (gl_mesh_copyarrays.integer)
+ {
+ R_Mesh_State(&m);
+ R_Mesh_GetSpace(mesh->num_vertices);
+ if (layer->texture != NULL)
+ R_Mesh_CopyTexCoord2f(0, mesh->data_texcoord2f, mesh->num_vertices);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
+ }
+ else
+ {
+ m.pointervertexcount = mesh->num_vertices;
+ memset(&request, 0, sizeof(request));
+ request.data_size = mesh->num_vertices * sizeof(float[3]);
+ request.id_pointer2 = mesh->data_aliasvertex3f;
+ request.id_number1 = layernum;
+ request.id_number2 = 0;
+ request.id_number3 = CRC_Block((void *)ent->frameblend, sizeof(ent->frameblend));
+ if (R_Mesh_CacheArray(&request))
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, request.data);
+ m.pointer_vertex = request.data;
+ m.pointer_texcoord[0] = layer->texture != NULL ? mesh->data_texcoord2f : NULL;
+ }
if (layer->flags & ALIASLAYER_FOG)
{
colorscale *= fog;
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
GL_Color(fogcolor[0] * colorscale, fogcolor[1] * colorscale, fogcolor[2] * colorscale, ent->alpha);
}
else
}
colorscale *= ifog;
if (fullbright || !(layer->flags & ALIASLAYER_DIFFUSE) || r_fullbright.integer || (ent->effects & EF_FULLBRIGHT))
- {
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
GL_Color(tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha);
- }
else if (r_shadow_realtime_world.integer)
{
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
colorscale *= r_ambient.value * (2.0f / 128.0f);
GL_Color(tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha);
}
else
{
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, aliasvert_normal3f, NULL, NULL);
- R_LightModel(ent, mesh->num_vertices, varray_vertex3f, aliasvert_normal3f, varray_color4f, tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, false);
+ if (R_LightModel(ambientcolor4f, ent, tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha, false))
+ {
+ GL_UseColorArray();
+ if (gl_mesh_copyarrays.integer)
+ {
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, aliasvert_normal3f);
+ R_LightModel_CalcVertexColors(ambientcolor4f, mesh->num_vertices, varray_vertex3f, aliasvert_normal3f, varray_color4f);
+ }
+ else
+ {
+ // request color4f cache
+ request.data_size = mesh->num_vertices * sizeof(float[4]);
+ request.id_pointer1 = ent;
+ request.id_number2 = 2;
+ request.id_number3 = CRC_Block((void *)ent->frameblend, sizeof(ent->frameblend)) + CRC_Block((void *)&ent->entlightstime, sizeof(ent->entlightstime));
+ if (R_Mesh_CacheArray(&request))
+ {
+ // save off the color pointer before we blow away the request
+ fcolor = request.data;
+ m.pointer_color = fcolor;
+ // request normal3f cache
+ request.data_size = mesh->num_vertices * sizeof(float[3]);
+ request.id_pointer1 = NULL;
+ request.id_number2 = 3;
+ request.id_number3 = CRC_Block((void *)ent->frameblend, sizeof(ent->frameblend));
+ if (R_Mesh_CacheArray(&request))
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, request.data);
+ R_LightModel_CalcVertexColors(ambientcolor4f, mesh->num_vertices, m.pointer_vertex, request.data, fcolor);
+ }
+ else
+ m.pointer_color = request.data;
+ }
+ }
+ else
+ GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
}
}
+ if (!gl_mesh_copyarrays.integer)
+ R_Mesh_State(&m);
R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
}
}
aliasmesh_t *mesh;
aliasskin_t *skin;
rmeshstate_t m;
- float *v, planenormal[3], planedist, dist, projection[3], floororigin[3], surfnormal[3], lightdirection[3], v2[3];
+ float *v, plane[4], dist, projection[3], floororigin[3], surfnormal[3], lightdirection[3], v2[3];
+ rcachearrayrequest_t request;
if ((ent->effects & EF_ADDITIVE) || ent->alpha < 1)
return;
memset(&m, 0, sizeof(m));
m.blendfunc1 = GL_SRC_ALPHA;
m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
- R_Mesh_State(&m);
+ if (gl_mesh_copyarrays.integer)
+ R_Mesh_State(&m);
GL_Color(0, 0, 0, 0.5);
// put a light direction in the entity's coordinate space
VectorNormalizeFast(projection);
// put the plane's normal in the entity's coordinate space
- Matrix4x4_Transform3x3(&ent->inversematrix, surfnormal, planenormal);
- VectorNormalizeFast(planenormal);
+ Matrix4x4_Transform3x3(&ent->inversematrix, surfnormal, plane);
+ VectorNormalizeFast(plane);
// put the plane's distance in the entity's coordinate space
VectorSubtract(floororigin, ent->origin, floororigin);
- planedist = DotProduct(floororigin, surfnormal) + 2;
+ plane[3] = DotProduct(floororigin, surfnormal) + 2;
- dist = -1.0f / DotProduct(projection, planenormal);
+ dist = -1.0f / DotProduct(projection, plane);
VectorScale(projection, dist, projection);
+ memset(&request, 0, sizeof(request));
for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++)
{
skin = R_FetchAliasSkin(ent, mesh);
if (skin->flags & ALIASSKIN_TRANSPARENT)
continue;
- R_Mesh_GetSpace(mesh->num_vertices);
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
- for (i = 0, v = varray_vertex3f;i < mesh->num_vertices;i++, v += 3)
+ if (gl_mesh_copyarrays.integer)
{
- dist = DotProduct(v, planenormal) - planedist;
- if (dist > 0)
- VectorMA(v, dist, projection, v);
+ R_Mesh_GetSpace(mesh->num_vertices);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
+ for (i = 0, v = varray_vertex3f;i < mesh->num_vertices;i++, v += 3)
+ {
+ dist = DotProduct(v, plane) - plane[3];
+ if (dist > 0)
+ VectorMA(v, dist, projection, v);
+ }
+ }
+ else
+ {
+ request.data_size = mesh->num_vertices * sizeof(float[3]);
+ request.id_pointer1 = mesh;
+ request.id_number1 = CRC_Block((void *)&ent->matrix, sizeof(ent->matrix));
+ request.id_number2 = CRC_Block((void *)&plane, sizeof(plane));
+ request.id_number3 = CRC_Block((void *)&ent->frameblend, sizeof(ent->frameblend));
+ m.pointervertexcount = mesh->num_vertices;
+ if (R_Mesh_CacheArray(&request))
+ {
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, request.data);
+ for (i = 0, v = request.data;i < mesh->num_vertices;i++, v += 3)
+ {
+ dist = DotProduct(v, plane) - plane[3];
+ if (dist > 0)
+ VectorMA(v, dist, projection, v);
+ }
+ }
+ m.pointer_vertex = request.data;
+ R_Mesh_State(&m);
}
c_alias_polys += mesh->num_triangles;
R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
if (skin->flags & ALIASSKIN_TRANSPARENT)
continue;
R_Mesh_GetSpace(mesh->num_vertices * 2);
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, varray_vertex3f, NULL, NULL, NULL);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
R_Shadow_Volume(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, mesh->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
}
}
void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz)
{
int c, meshnum, layernum;
- float fog, ifog, lightcolor2[3], *vertices;
+ float fog, ifog, lightcolor2[3];
vec3_t diff;
qbyte *bcolor;
aliasmesh_t *mesh;
if (skin->flags & ALIASSKIN_TRANSPARENT)
continue;
expandaliasvert(mesh->num_vertices);
- vertices = R_Shadow_VertexBuffer(mesh->num_vertices);
- R_Model_Alias_GetMesh_Vertex3f(ent, mesh, vertices, aliasvert_normal3f, aliasvert_svector3f, aliasvert_tvector3f);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, aliasvert_vertex3f);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_SVECTOR, aliasvert_svector3f);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_TVECTOR, aliasvert_tvector3f);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, aliasvert_normal3f);
for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
{
if (!(layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
if (layer->flags & ALIASLAYER_SPECULAR)
{
c_alias_polys += mesh->num_triangles;
- R_Shadow_SpecularLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertices, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor2, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, NULL);
+ 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_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, NULL);
}
else if (layer->flags & ALIASLAYER_DIFFUSE)
{
lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
}
c_alias_polys += mesh->num_triangles;
- R_Shadow_DiffuseLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertices, aliasvert_svector3f, aliasvert_tvector3f, aliasvert_normal3f, mesh->data_texcoord2f, relativelightorigin, lightradius, lightcolor2, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, NULL);
+ 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_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, NULL);
}
}
}
void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
{
- float fog, ifog, colorscale;
+ float fog, ifog, colorscale, ambientcolor4f[4];
vec3_t diff;
int i, *renderlist, *elements;
rtexture_t *texture;
ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->zymdata_vertbonecounts, ent->model->zymdata_verts);
R_Mesh_CopyTexCoord2f(0, ent->model->zymdata_texcoords, ent->model->zymnum_verts);
ZymoticCalcNormal3f(numverts, varray_vertex3f, aliasvert_normal3f, ent->model->zymnum_shaders, ent->model->zymdata_renderlist);
- R_LightModel(ent, numverts, varray_vertex3f, aliasvert_normal3f, varray_color4f, ifog * colorscale, ifog * colorscale, ifog * colorscale, false);
+ if (R_LightModel(ambientcolor4f, ent, ifog * colorscale, ifog * colorscale, ifog * colorscale, ent->alpha, false))
+ {
+ GL_UseColorArray();
+ R_LightModel_CalcVertexColors(ambientcolor4f, numverts, varray_vertex3f, aliasvert_normal3f, varray_color4f);
+ }
+ else
+ GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
R_Mesh_Draw(numverts, numtriangles, elements);
c_alias_polys += numtriangles;
projects / xonotic / darkplaces.git / blobdiff