} zymbonematrix;
// LordHavoc: vertex arrays
-
-float *aliasvertcolorbuf;
-float *aliasvertcolor; // this may point at aliasvertcolorbuf or at vertex arrays in the mesh backend
-float *aliasvert_svectors;
-float *aliasvert_tvectors;
-float *aliasvert_normals;
-
-float *aliasvertcolor2;
+int aliasvertmax = 0;
+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;
+
+float *aliasvertcolor2_4f = NULL;
int *aliasvertusage;
zymbonematrix *zymbonepose;
mempool_t *gl_models_mempool;
+#define expandaliasvert(newmax) if ((newmax) > aliasvertmax) gl_models_allocarrays(newmax)
+
+void gl_models_allocarrays(int newmax)
+{
+ qbyte *data;
+ aliasvertmax = newmax;
+ if (aliasvertarrays != NULL)
+ Mem_Free(aliasvertarrays);
+ 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]);
+ aliasvertusage = (void *)data;data += aliasvertmax * sizeof(int[3]);
+}
+
+void gl_models_freearrays(void)
+{
+ aliasvertmax = 0;
+ if (aliasvertarrays != NULL)
+ Mem_Free(aliasvertarrays);
+ aliasvertarrays = NULL;
+ aliasvertcolor4f = aliasvertcolor4fbuf = NULL;
+ aliasvertcolor2_4f = NULL;
+ aliasvert_vertex3f = NULL;
+ aliasvert_svector3f = NULL;
+ aliasvert_tvector3f = NULL;
+ aliasvert_normal3f = NULL;
+ aliasvertusage = NULL;
+}
+
void gl_models_start(void)
{
// allocate vertex processing arrays
gl_models_mempool = Mem_AllocPool("GL_Models");
- aliasvertcolor = aliasvertcolorbuf = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
- aliasvert_svectors = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
- aliasvert_tvectors = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
- aliasvert_normals = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4]));
- aliasvertcolor2 = Mem_Alloc(gl_models_mempool, sizeof(float[MD2MAX_VERTS][4])); // used temporarily for tinted coloring
zymbonepose = Mem_Alloc(gl_models_mempool, sizeof(zymbonematrix[256]));
- aliasvertusage = Mem_Alloc(gl_models_mempool, sizeof(int[MD2MAX_VERTS]));
+ gl_models_allocarrays(4096);
}
void gl_models_shutdown(void)
{
+ gl_models_freearrays();
Mem_FreePool(&gl_models_mempool);
}
R_RegisterModule("GL_Models", gl_models_start, gl_models_shutdown, gl_models_newmap);
}
-void R_Model_Alias_GetMeshVerts(const entity_render_t *ent, aliasmesh_t *mesh, float *vertices, float *normals, float *svectors, float *tvectors)
+#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, const 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 (vertices == NULL)
- Host_Error("R_Model_Alias_GetMeshVerts: vertices == NULL.\n");
- if (svectors != NULL && (tvectors == NULL || normals == NULL))
- Host_Error("R_Model_Alias_GetMeshVerts: svectors requires tvectors and normals.\n");
- if (tvectors != NULL && (svectors == NULL || normals == NULL))
- Host_Error("R_Model_Alias_GetMeshVerts: 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_vertices + 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_vertices + 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_vertices + 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_vertices + ent->frameblend[3].frame * vertcount;
+ verts4 = vertsbase + ent->frameblend[3].frame * vertcount * 3;
lerp4 = ent->frameblend[3].lerp;
- // generate vertices
- if (svectors != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++, verts2++, verts3++, verts4++)
- {
- VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertices);
- VectorMAMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, lerp4, verts4->normal, normals);
- VectorMAMAMAM(lerp1, verts1->svector, lerp2, verts2->svector, lerp3, verts3->svector, lerp4, verts4->svector, svectors);
- CrossProduct(svectors, normals, tvectors);
- }
- }
- else if (normals != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++, verts2++, verts3++, verts4++)
- {
- VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertices);
- VectorMAMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, lerp4, verts4->normal, normals);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertices += 4, verts1++, verts2++, verts3++, verts4++)
- VectorMAMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, lerp4, verts4->origin, vertices);
+ 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 (svectors != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++, verts2++, verts3++)
- {
- VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertices);
- VectorMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, normals);
- VectorMAMAM(lerp1, verts1->svector, lerp2, verts2->svector, lerp3, verts3->svector, svectors);
- CrossProduct(svectors, normals, tvectors);
- }
- }
- else if (normals != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++, verts2++, verts3++)
- {
- VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertices);
- VectorMAMAM(lerp1, verts1->normal, lerp2, verts2->normal, lerp3, verts3->normal, normals);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertices += 4, verts1++, verts2++, verts3++)
- VectorMAMAM(lerp1, verts1->origin, lerp2, verts2->origin, lerp3, verts3->origin, vertices);
- }
+ for (i = 0;i < vertcount * 3;i++)
+ VectorMAMAM(lerp1, verts1 + i, lerp2, verts2 + i, lerp3, verts3 + i, out3f + i);
}
else
- {
- // generate vertices
- if (svectors != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++, verts2++)
- {
- VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertices);
- VectorMAM(lerp1, verts1->normal, lerp2, verts2->normal, normals);
- VectorMAM(lerp1, verts1->svector, lerp2, verts2->svector, svectors);
- CrossProduct(svectors, normals, tvectors);
- }
- }
- else if (normals != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++, verts2++)
- {
- VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertices);
- VectorMAM(lerp1, verts1->normal, lerp2, verts2->normal, normals);
- }
- }
- else
- for (i = 0;i < vertcount;i++, vertices += 4, verts1++, verts2++)
- VectorMAM(lerp1, verts1->origin, lerp2, verts2->origin, vertices);
- }
+ for (i = 0;i < vertcount * 3;i++)
+ VectorMAM(lerp1, verts1 + i, lerp2, verts2 + i, out3f + i);
}
else
- {
- // generate vertices
- if (svectors != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, svectors += 4, tvectors += 4, verts1++)
- {
- VectorM(lerp1, verts1->origin, vertices);
- VectorM(lerp1, verts1->normal, normals);
- VectorM(lerp1, verts1->svector, svectors);
- CrossProduct(svectors, normals, tvectors);
- }
- }
- else if (normals != NULL)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, normals += 4, verts1++)
- {
- VectorM(lerp1, verts1->origin, vertices);
- VectorM(lerp1, verts1->normal, normals);
- }
- }
- else if (lerp1 != 1)
- {
- for (i = 0;i < vertcount;i++, vertices += 4, verts1++)
- VectorM(lerp1, verts1->origin, vertices);
- }
- else
- for (i = 0;i < vertcount;i++, vertices += 4, verts1++)
- VectorCopy(verts1->origin, vertices);
- }
+ memcpy(out3f, verts1, vertcount * sizeof(float[3]));
}
+aliaslayer_t r_aliasnoskinlayers[2] = {{ALIASLAYER_DIFFUSE, NULL, NULL}, {ALIASLAYER_FOG | ALIASLAYER_FORCEDRAW_IF_FIRSTPASS, NULL, NULL}};
+aliasskin_t r_aliasnoskin = {0, 2, r_aliasnoskinlayers};
aliasskin_t *R_FetchAliasSkin(const entity_render_t *ent, const aliasmesh_t *mesh)
{
model_t *model = ent->model;
- int s = ent->skinnum;
- if ((unsigned int)s >= (unsigned int)model->numskins)
- s = 0;
- if (model->skinscenes[s].framecount > 1)
- s = model->skinscenes[s].firstframe + (int) (cl.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
+ if (model->numskins)
+ {
+ int s = ent->skinnum;
+ if ((unsigned int)s >= (unsigned int)model->numskins)
+ s = 0;
+ if (model->skinscenes[s].framecount > 1)
+ s = model->skinscenes[s].firstframe + (int) (cl.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
+ else
+ s = model->skinscenes[s].firstframe;
+ if (s >= mesh->num_skins)
+ s = 0;
+ return mesh->data_skins + s;
+ }
else
- s = model->skinscenes[s].firstframe;
- if (s >= mesh->num_skins)
- s = 0;
- return mesh->data_skins + s;
+ {
+ r_aliasnoskinlayers[0].texture = r_notexture;
+ return &r_aliasnoskin;
+ }
}
void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
{
- int c, fullbright, layernum;
- float tint[3], fog, ifog, colorscale;
+ int c, fullbright, layernum, firstpass;
+ float tint[3], fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
vec3_t diff;
qbyte *bcolor;
rmeshstate_t m;
const entity_render_t *ent = calldata1;
- aliasmesh_t *mesh = ent->model->aliasdata_meshes + calldata2;
+ aliasmesh_t *mesh = ent->model->alias.aliasdata_meshes + calldata2;
aliaslayer_t *layer;
aliasskin_t *skin;
}
ifog = 1 - fog;
- memset(&m, 0, sizeof(m));
+ firstpass = true;
skin = R_FetchAliasSkin(ent, mesh);
for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
{
- if (((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
- || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0)
- || (layer->flags & ALIASLAYER_DRAW_PER_LIGHT))
- continue;
- if (layer->flags & ALIASLAYER_FOG)
+ if (!(layer->flags & ALIASLAYER_FORCEDRAW_IF_FIRSTPASS) || !firstpass)
{
- m.blendfunc1 = GL_SRC_ALPHA;
- m.blendfunc2 = GL_ONE;
- colorscale = r_colorscale;
- m.texrgbscale[0] = 1;
- m.tex[0] = R_GetTexture(layer->texture);
- R_Mesh_State(&m);
- GL_Color(fogcolor[0] * fog * colorscale, fogcolor[1] * fog * colorscale, fogcolor[2] * fog * colorscale, ent->alpha);
- c_alias_polys += mesh->num_triangles;
- R_Mesh_GetSpace(mesh->num_vertices);
- R_Model_Alias_GetMeshVerts(ent, mesh, varray_vertex, aliasvert_normals, NULL, NULL);
- memcpy(varray_texcoord[0], mesh->data_texcoords, mesh->num_vertices * sizeof(float[4]));
- R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_elements);
- continue;
+ if (((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
+ || ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0)
+ || ((layer->flags & ALIASLAYER_FOG) && !fogenabled)
+ || (layer->flags & ALIASLAYER_SPECULAR)
+ || ((layer->flags & ALIASLAYER_DIFFUSE) && (r_shadow_realtime_world.integer && r_ambient.integer <= 0 && r_fullbright.integer == 0 && !(ent->effects & EF_FULLBRIGHT))))
+ continue;
}
- if ((layer->flags & ALIASLAYER_ADD) || ((layer->flags & ALIASLAYER_ALPHA) && (ent->effects & EF_ADDITIVE)))
+ if (!firstpass || (ent->effects & EF_ADDITIVE))
{
- m.blendfunc1 = GL_SRC_ALPHA;
- m.blendfunc2 = GL_ONE;
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+ GL_DepthMask(false);
}
- else if ((layer->flags & ALIASLAYER_ALPHA) || ent->alpha != 1.0)
+ else if ((skin->flags & ALIASSKIN_TRANSPARENT) || ent->alpha != 1.0)
{
- m.blendfunc1 = GL_SRC_ALPHA;
- m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
}
else
{
- m.blendfunc1 = GL_ONE;
- m.blendfunc2 = GL_ZERO;
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
}
+ GL_DepthTest(true);
+ firstpass = false;
+ expandaliasvert(mesh->num_vertices);
colorscale = r_colorscale;
- m.texrgbscale[0] = 1;
- if (gl_combine.integer)
- {
- colorscale *= 0.25f;
- m.texrgbscale[0] = 4;
- }
- m.tex[0] = R_GetTexture(layer->texture);
- R_Mesh_State(&m);
- if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
+
+ memset(&m, 0, sizeof(m));
+ if (layer->texture != NULL)
{
- // 128-224 are backwards ranges
- c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
- bcolor = (qbyte *) (&palette_complete[c]);
- fullbright = c >= 224;
- VectorScale(bcolor, (1.0f / 255.0f), tint);
+ m.tex[0] = R_GetTexture(layer->texture);
+ m.pointer_texcoord[0] = mesh->data_texcoord2f;
+ if (gl_combine.integer && layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
+ {
+ colorscale *= 0.25f;
+ m.texrgbscale[0] = 4;
+ }
}
- else if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
+ R_Mesh_State_Texture(&m);
+
+ c_alias_polys += mesh->num_triangles;
+ GL_VertexPointer(varray_vertex3f);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
+ if (layer->flags & ALIASLAYER_FOG)
{
- // 128-224 are backwards ranges
- c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
- bcolor = (qbyte *) (&palette_complete[c]);
- fullbright = c >= 224;
- VectorScale(bcolor, (1.0f / 255.0f), tint);
+ colorscale *= fog;
+ GL_Color(fogcolor[0] * colorscale, fogcolor[1] * colorscale, fogcolor[2] * colorscale, ent->alpha);
}
else
{
- tint[0] = tint[1] = tint[2] = 1;
- fullbright = false;
+ fullbright = !(layer->flags & ALIASLAYER_DIFFUSE) || r_fullbright.integer || (ent->effects & EF_FULLBRIGHT);
+ if (r_shadow_realtime_world.integer && !fullbright)
+ {
+ colorscale *= r_ambient.value * (2.0f / 128.0f);
+ fullbright = true;
+ }
+ if (layer->flags & (ALIASLAYER_COLORMAP_PANTS | ALIASLAYER_COLORMAP_SHIRT))
+ {
+ // 128-224 are backwards ranges
+ if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
+ c = (ent->colormap & 0xF) << 4;
+ else //if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
+ c = (ent->colormap & 0xF0);
+ c += (c >= 128 && c < 224) ? 4 : 12;
+ bcolor = (qbyte *) (&palette_complete[c]);
+ fullbright = fullbright || c >= 224;
+ VectorScale(bcolor, (1.0f / 255.0f), tint);
+ }
+ else
+ tint[0] = tint[1] = tint[2] = 1;
+ colorscale *= ifog;
+ if (fullbright)
+ GL_Color(tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha);
+ else
+ {
+ if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0] * colorscale, tint[1] * colorscale, tint[2] * colorscale, ent->alpha, false))
+ {
+ GL_ColorPointer(varray_color4f);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_NORMAL, varray_normal3f);
+ R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, varray_vertex3f, varray_normal3f, varray_color4f);
+ }
+ else
+ GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
+ }
}
- VectorScale(tint, ifog * colorscale, tint);
- if (!(layer->flags & ALIASLAYER_DIFFUSE))
- fullbright = true;
- if (ent->effects & EF_FULLBRIGHT)
- fullbright = true;
- c_alias_polys += mesh->num_triangles;
- R_Mesh_GetSpace(mesh->num_vertices);
- R_Model_Alias_GetMeshVerts(ent, mesh, varray_vertex, aliasvert_normals, NULL, NULL);
- memcpy(varray_texcoord[0], mesh->data_texcoords, mesh->num_vertices * sizeof(float[4]));
- if (fullbright)
- GL_Color(tint[0], tint[1], tint[2], ent->alpha);
- else
- R_LightModel(ent, mesh->num_vertices, varray_vertex, aliasvert_normals, varray_color, tint[0], tint[1], tint[2], false);
- R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_elements);
+ R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
}
}
c_models++;
- for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++, mesh++)
+ for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
{
if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchAliasSkin(ent, mesh)->flags & ALIASSKIN_TRANSPARENT)
R_MeshQueue_AddTransparent(ent->origin, R_DrawAliasModelCallback, ent, meshnum);
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];
if ((ent->effects & EF_ADDITIVE) || ent->alpha < 1)
return;
VectorNormalizeFast(lightdirection);
VectorMA(ent->origin, 65536.0f, lightdirection, v2);
- if (CL_TraceLine(ent->origin, v2, floororigin, surfnormal, 0, false, NULL) == 1)
+ if (CL_TraceLine(ent->origin, v2, floororigin, surfnormal, false, NULL, SUPERCONTENTS_SOLID) == 1)
return;
R_Mesh_Matrix(&ent->matrix);
memset(&m, 0, sizeof(m));
- m.blendfunc1 = GL_SRC_ALPHA;
- m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
- R_Mesh_State(&m);
+ R_Mesh_State_Texture(&m);
+
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
+ GL_DepthTest(true);
+ GL_VertexPointer(varray_vertex3f);
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);
- for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++)
+ for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++)
{
skin = R_FetchAliasSkin(ent, mesh);
if (skin->flags & ALIASSKIN_TRANSPARENT)
continue;
- R_Mesh_GetSpace(mesh->num_vertices);
- R_Model_Alias_GetMeshVerts(ent, mesh, varray_vertex, NULL, NULL, NULL);
- for (i = 0, v = varray_vertex;i < mesh->num_vertices;i++, v += 4)
+ 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, planenormal) - planedist;
+ dist = DotProduct(v, plane) - plane[3];
if (dist > 0)
VectorMA(v, dist, projection, v);
}
c_alias_polys += mesh->num_triangles;
- R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_elements);
+ R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
}
}
if (projectdistance > 0.1)
{
R_Mesh_Matrix(&ent->matrix);
- for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++, mesh++)
+ for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
{
skin = R_FetchAliasSkin(ent, mesh);
if (skin->flags & ALIASSKIN_TRANSPARENT)
continue;
- R_Mesh_GetSpace(mesh->num_vertices * 2);
- R_Model_Alias_GetMeshVerts(ent, mesh, varray_vertex, NULL, NULL, NULL);
- R_Shadow_Volume(mesh->num_vertices, mesh->num_triangles, mesh->data_elements, mesh->data_neighbors, relativelightorigin, lightradius, projectdistance);
+ R_Model_Alias_GetMesh_Array3f(ent, mesh, MODELARRAY_VERTEX, varray_vertex3f);
+ R_Shadow_Volume(mesh->num_vertices, mesh->num_triangles, varray_vertex3f, 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;
}
ifog = 1 - fog;
- for (meshnum = 0, mesh = ent->model->aliasdata_meshes;meshnum < ent->model->aliasnum_meshes;meshnum++, mesh++)
+ for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
{
skin = R_FetchAliasSkin(ent, mesh);
if (skin->flags & ALIASSKIN_TRANSPARENT)
continue;
- vertices = R_Shadow_VertexBuffer(mesh->num_vertices);
- R_Model_Alias_GetMeshVerts(ent, mesh, vertices, aliasvert_normals, aliasvert_svectors, aliasvert_tvectors);
+ expandaliasvert(mesh->num_vertices);
+ 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_DRAW_PER_LIGHT)
+ if (!(layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
|| ((layer->flags & ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED) && ent->colormap < 0)
|| ((layer->flags & ALIASLAYER_NODRAW_IF_COLORMAPPED) && ent->colormap >= 0))
continue;
if (layer->flags & ALIASLAYER_SPECULAR)
{
c_alias_polys += mesh->num_triangles;
- R_Shadow_SpecularLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_elements, vertices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, mesh->data_texcoords, 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_elements, vertices, aliasvert_svectors, aliasvert_tvectors, aliasvert_normals, mesh->data_texcoords, 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);
}
}
}
vert++;
}
}
- out += 4;
+ out += 3;
}
}
-void ZymoticCalcNormals(int vertcount, float *vertex, float *normals, int shadercount, int *renderlist)
+void ZymoticCalcNormal3f(int vertcount, float *vertex3f, float *normal3f, int shadercount, int *renderlist)
{
int a, b, c, d;
float *out, v1[3], v2[3], normal[3], s;
int *u;
// clear normals
- memset(normals, 0, sizeof(float) * vertcount * 3);
+ memset(normal3f, 0, sizeof(float) * vertcount * 3);
memset(aliasvertusage, 0, sizeof(int) * vertcount);
// parse render list and accumulate surface normals
while(shadercount--)
a = renderlist[0]*4;
b = renderlist[1]*4;
c = renderlist[2]*4;
- v1[0] = vertex[a+0] - vertex[b+0];
- v1[1] = vertex[a+1] - vertex[b+1];
- v1[2] = vertex[a+2] - vertex[b+2];
- v2[0] = vertex[c+0] - vertex[b+0];
- v2[1] = vertex[c+1] - vertex[b+1];
- v2[2] = vertex[c+2] - vertex[b+2];
+ v1[0] = vertex3f[a+0] - vertex3f[b+0];
+ v1[1] = vertex3f[a+1] - vertex3f[b+1];
+ v1[2] = vertex3f[a+2] - vertex3f[b+2];
+ v2[0] = vertex3f[c+0] - vertex3f[b+0];
+ v2[1] = vertex3f[c+1] - vertex3f[b+1];
+ v2[2] = vertex3f[c+2] - vertex3f[b+2];
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
// add surface normal to vertices
a = renderlist[0] * 3;
- normals[a+0] += normal[0];
- normals[a+1] += normal[1];
- normals[a+2] += normal[2];
+ normal3f[a+0] += normal[0];
+ normal3f[a+1] += normal[1];
+ normal3f[a+2] += normal[2];
aliasvertusage[renderlist[0]]++;
a = renderlist[1] * 3;
- normals[a+0] += normal[0];
- normals[a+1] += normal[1];
- normals[a+2] += normal[2];
+ normal3f[a+0] += normal[0];
+ normal3f[a+1] += normal[1];
+ normal3f[a+2] += normal[2];
aliasvertusage[renderlist[1]]++;
a = renderlist[2] * 3;
- normals[a+0] += normal[0];
- normals[a+1] += normal[1];
- normals[a+2] += normal[2];
+ normal3f[a+0] += normal[0];
+ normal3f[a+1] += normal[1];
+ normal3f[a+2] += normal[2];
aliasvertusage[renderlist[2]]++;
renderlist += 3;
}
}
// FIXME: precalc this
// average surface normals
- out = normals;
+ out = normal3f;
u = aliasvertusage;
while(vertcount--)
{
void R_DrawZymoticModelMeshCallback (const void *calldata1, int calldata2)
{
- float fog, ifog, colorscale;
+ float fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
vec3_t diff;
int i, *renderlist, *elements;
rtexture_t *texture;
R_Mesh_Matrix(&ent->matrix);
// find the vertex index list and texture
- renderlist = ent->model->zymdata_renderlist;
+ renderlist = ent->model->alias.zymdata_renderlist;
for (i = 0;i < shadernum;i++)
renderlist += renderlist[0] * 3 + 1;
- texture = ent->model->zymdata_textures[shadernum];
+ texture = ent->model->alias.zymdata_textures[shadernum];
- numverts = ent->model->zymnum_verts;
+ numverts = ent->model->alias.zymnum_verts;
numtriangles = *renderlist++;
elements = renderlist;
+ expandaliasvert(numverts);
+
fog = 0;
if (fogenabled)
{
}
ifog = 1 - fog;
- memset(&mstate, 0, sizeof(mstate));
if (ent->effects & EF_ADDITIVE)
{
- mstate.blendfunc1 = GL_SRC_ALPHA;
- mstate.blendfunc2 = GL_ONE;
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+ GL_DepthMask(false);
}
else if (ent->alpha != 1.0 || R_TextureHasAlpha(texture))
{
- mstate.blendfunc1 = GL_SRC_ALPHA;
- mstate.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
}
else
{
- mstate.blendfunc1 = GL_ONE;
- mstate.blendfunc2 = GL_ZERO;
+ GL_BlendFunc(GL_ONE, GL_ZERO);
+ GL_DepthMask(true);
}
+ GL_DepthTest(true);
+ GL_VertexPointer(varray_vertex3f);
+
+ memset(&mstate, 0, sizeof(mstate));
colorscale = r_colorscale;
if (gl_combine.integer)
{
colorscale *= 0.25f;
}
mstate.tex[0] = R_GetTexture(texture);
- R_Mesh_State(&mstate);
- ZymoticLerpBones(ent->model->zymnum_bones, (zymbonematrix *) ent->model->zymdata_poses, ent->frameblend, ent->model->zymdata_bones);
-
- R_Mesh_GetSpace(numverts);
- ZymoticTransformVerts(numverts, varray_vertex, ent->model->zymdata_vertbonecounts, ent->model->zymdata_verts);
- memcpy(varray_texcoord[0], ent->model->zymdata_texcoords, ent->model->zymnum_verts * sizeof(float[4]));
- ZymoticCalcNormals(numverts, varray_vertex, aliasvert_normals, ent->model->zymnum_shaders, ent->model->zymdata_renderlist);
- R_LightModel(ent, numverts, varray_vertex, aliasvert_normals, varray_color, ifog * colorscale, ifog * colorscale, ifog * colorscale, false);
+ mstate.pointer_texcoord[0] = ent->model->alias.zymdata_texcoords;
+ R_Mesh_State_Texture(&mstate);
+
+ ZymoticLerpBones(ent->model->alias.zymnum_bones, (zymbonematrix *) ent->model->alias.zymdata_poses, ent->frameblend, ent->model->alias.zymdata_bones);
+
+ ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
+ ZymoticCalcNormal3f(numverts, varray_vertex3f, aliasvert_normal3f, ent->model->alias.zymnum_shaders, ent->model->alias.zymdata_renderlist);
+ if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, ifog * colorscale, ifog * colorscale, ifog * colorscale, ent->alpha, false))
+ {
+ GL_ColorPointer(varray_color4f);
+ R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, 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;
if (fog)
{
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ GL_DepthMask(false);
+ GL_DepthTest(true);
+ GL_VertexPointer(varray_vertex3f);
+
memset(&mstate, 0, sizeof(mstate));
- mstate.blendfunc1 = GL_SRC_ALPHA;
- mstate.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
// FIXME: need alpha mask for fogging...
//mstate.tex[0] = R_GetTexture(texture);
- R_Mesh_State(&mstate);
+ //mstate.pointer_texcoord = ent->model->alias.zymdata_texcoords;
+ R_Mesh_State_Texture(&mstate);
+
GL_Color(fogcolor[0] * r_colorscale, fogcolor[1] * r_colorscale, fogcolor[2] * r_colorscale, ent->alpha * fog);
- R_Mesh_GetSpace(numverts);
- ZymoticTransformVerts(numverts, varray_vertex, ent->model->zymdata_vertbonecounts, ent->model->zymdata_verts);
+ ZymoticTransformVerts(numverts, varray_vertex3f, ent->model->alias.zymdata_vertbonecounts, ent->model->alias.zymdata_verts);
R_Mesh_Draw(numverts, numtriangles, elements);
c_alias_polys += numtriangles;
}
c_models++;
- for (i = 0;i < ent->model->zymnum_shaders;i++)
+ for (i = 0;i < ent->model->alias.zymnum_shaders;i++)
{
- if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->zymdata_textures[i]))
+ if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_TextureHasAlpha(ent->model->alias.zymdata_textures[i]))
R_MeshQueue_AddTransparent(ent->origin, R_DrawZymoticModelMeshCallback, ent, i);
else
R_DrawZymoticModelMeshCallback(ent, i);
{
// FIXME
}
+
projects / xonotic / darkplaces.git / blobdiff