got rid of aliasskin/aliaslayer system for rendering models, now uses texture_t like...
authorhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Fri, 18 Mar 2005 01:58:31 +0000 (01:58 +0000)
committerhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Fri, 18 Mar 2005 01:58:31 +0000 (01:58 +0000)
git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@5093 d7cf8633-e32d-0410-b094-e92efae38249

gl_models.c
model_alias.c
model_alias.h

index c84fcf0..7e78b2e 100644 (file)
@@ -6,9 +6,8 @@ void GL_Models_Init(void)
 {
 }
 
-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)
+static texture_t r_aliasnotexture;
+static texture_t *R_FetchAliasSkin(const entity_render_t *ent, const aliasmesh_t *mesh)
 {
        model_t *model = ent->model;
        if (model->numskins)
@@ -17,7 +16,7 @@ aliasskin_t *R_FetchAliasSkin(const entity_render_t *ent, const aliasmesh_t *mes
                if ((unsigned int)s >= (unsigned int)model->numskins)
                        s = 0;
                if (model->skinscenes[s].framecount > 1)
-                       s = model->skinscenes[s].firstframe + (int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
+                       s = model->skinscenes[s].firstframe + (unsigned int) (r_refdef.time * model->skinscenes[s].framerate) % model->skinscenes[s].framecount;
                else
                        s = model->skinscenes[s].firstframe;
                if (s >= mesh->num_skins)
@@ -26,23 +25,23 @@ aliasskin_t *R_FetchAliasSkin(const entity_render_t *ent, const aliasmesh_t *mes
        }
        else
        {
-               r_aliasnoskinlayers[0].texture = r_texture_notexture;
-               return &r_aliasnoskin;
+               memset(&r_aliasnotexture, 0, sizeof(r_aliasnotexture));
+               r_aliasnotexture.skin.base = r_texture_notexture;
+               return &r_aliasnotexture;
        }
 }
 
-void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
+static void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
 {
-       int c, fullbright, layernum, firstpass;
-       float tint[3], fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3];
+       int c, fbbase, fbpants, fbshirt, doglow;
+       float tint[3], fog, ifog, colorscale, ambientcolor4f[4], diffusecolor[3], diffusenormal[3], colorbase[3], colorpants[3], colorshirt[3];
        float *vertex3f, *normal3f;
        vec3_t diff;
        qbyte *bcolor;
        rmeshstate_t m;
        const entity_render_t *ent = calldata1;
        aliasmesh_t *mesh = ent->model->alias.aliasdata_meshes + calldata2;
-       aliaslayer_t *layer;
-       aliasskin_t *skin;
+       texture_t *texture;
 
        R_Mesh_Matrix(&ent->matrix);
 
@@ -64,114 +63,189 @@ void R_DrawAliasModelCallback (const void *calldata1, int calldata2)
        }
        ifog = 1 - fog;
 
-       firstpass = true;
-       skin = R_FetchAliasSkin(ent, mesh);
+       VectorScale(ent->colormod, ifog, colorbase);
+       VectorClear(colorpants);
+       VectorClear(colorshirt);
+       fbbase = ent->effects & EF_FULLBRIGHT;
+       fbpants = fbbase;
+       fbshirt = fbbase;
+       if (ent->colormap >= 0)
+       {
+               // 128-224 are backwards ranges
+               c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
+               if (c >= 224)
+                       fbpants = true;
+               bcolor = (qbyte *) (&palette_complete[c]);
+               colorpants[0] = colorbase[0] * bcolor[0] * (1.0f / 255.0f);
+               colorpants[1] = colorbase[1] * bcolor[1] * (1.0f / 255.0f);
+               colorpants[2] = colorbase[2] * bcolor[2] * (1.0f / 255.0f);
+               // 128-224 are backwards ranges
+               c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
+               if (c >= 224)
+                       fbshirt = true;
+               bcolor = (qbyte *) (&palette_complete[c]);
+               colorshirt[0] = colorbase[0] * bcolor[0] * (1.0f / 255.0f);
+               colorshirt[1] = colorbase[1] * bcolor[1] * (1.0f / 255.0f);
+               colorshirt[2] = colorbase[2] * bcolor[2] * (1.0f / 255.0f);
+       }
 
-       vertex3f = NULL;
-       normal3f = NULL;
-       for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
+       texture = R_FetchAliasSkin(ent, mesh);
+
+       if ((ent->effects & EF_ADDITIVE))
        {
-               if (!(layer->flags & ALIASLAYER_FORCEDRAW_IF_FIRSTPASS) || !firstpass)
-               {
-                       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) && (ent->flags & RENDER_LIGHT) && r_lightmapintensity <= 0 && !(ent->flags & RENDER_TRANSPARENT) && r_ambient.integer <= 0))
-                               continue;
-               }
-               if (!firstpass || (ent->effects & EF_ADDITIVE))
-               {
-                       GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-                       GL_DepthMask(false);
-               }
-               else if ((skin->flags & ALIASSKIN_TRANSPARENT) || ent->alpha != 1.0)
-               {
-                       GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                       GL_DepthMask(false);
-               }
-               else
+               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+               GL_DepthMask(false);
+       }
+       else if (texture->skin.fog || ent->alpha != 1.0)
+       {
+               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+               GL_DepthMask(false);
+       }
+       else
+       {
+               GL_BlendFunc(GL_ONE, GL_ZERO);
+               GL_DepthMask(true);
+       }
+       GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
+       colorscale = 1.0f;
+       if (ent->frameblend[0].frame == 0 && ent->frameblend[0].lerp == 1)
+       {
+               vertex3f = mesh->data_basevertex3f;
+               normal3f = mesh->data_basenormal3f;
+       }
+       else
+       {
+               vertex3f = varray_vertex3f;
+               Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, mesh, vertex3f);
+               normal3f = NULL;
+       }
+
+       doglow = texture->skin.glow != NULL;
+
+       memset(&m, 0, sizeof(m));
+       m.pointer_vertex = vertex3f;
+       m.pointer_texcoord[0] = mesh->data_texcoord2f;
+       if (gl_combine.integer)
+       {
+               colorscale *= 0.25f;
+               m.texrgbscale[0] = 4;
+       }
+
+       m.tex[0] = R_GetTexture((ent->colormap >= 0 || !texture->skin.merged) ? texture->skin.base : texture->skin.merged);
+       VectorScale(colorbase, colorscale, tint);
+       m.pointer_color = NULL;
+       if (fbbase)
+               GL_Color(tint[0], tint[1], tint[2], ent->alpha);
+       else if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0], tint[1], tint[2], ent->alpha, false))
+       {
+               m.pointer_color = varray_color4f;
+               if (normal3f == NULL)
                {
-                       GL_BlendFunc(GL_ONE, GL_ZERO);
-                       GL_DepthMask(true);
+                       normal3f = varray_normal3f;
+                       Mod_BuildNormals(mesh->num_vertices, mesh->num_triangles, vertex3f, mesh->data_element3i, normal3f);
                }
-               GL_DepthTest(!(ent->effects & EF_NODEPTHTEST));
-               firstpass = false;
-               colorscale = 1.0f;
+               R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, vertex3f, normal3f, varray_color4f);
+       }
+       else
+               GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
+       if (gl_combine.integer && doglow)
+       {
+               doglow = false;
+               m.tex[1] = R_GetTexture(texture->skin.glow);
+               m.pointer_texcoord[1] = mesh->data_texcoord2f;
+               m.texcombinergb[1] = GL_ADD;
+       }
+       R_Mesh_State(&m);
+       c_alias_polys += mesh->num_triangles;
+       GL_LockArrays(0, mesh->num_vertices);
+       R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
+       GL_LockArrays(0, 0);
+       m.tex[1] = 0;
+       m.pointer_texcoord[1] = NULL;
+       m.texcombinergb[1] = 0;
 
-               memset(&m, 0, sizeof(m));
-               if (layer->texture != NULL)
+       VectorScale(colorpants, colorscale, tint);
+       if (ent->colormap >= 0 && texture->skin.pants && VectorLength2(tint) >= 0.001)
+       {
+               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+               GL_DepthMask(false);
+               m.tex[0] = R_GetTexture(texture->skin.pants);
+               m.pointer_color = NULL;
+               if (fbpants)
+                       GL_Color(tint[0], tint[1], tint[2], ent->alpha);
+               else if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0], tint[1], tint[2], ent->alpha, false))
                {
-                       m.tex[0] = R_GetTexture(layer->texture);
-                       m.pointer_texcoord[0] = mesh->data_texcoord2f;
-                       if (gl_combine.integer && layer->flags & (ALIASLAYER_DIFFUSE | ALIASLAYER_SPECULAR))
+                       m.pointer_color = varray_color4f;
+                       if (normal3f == NULL)
                        {
-                               colorscale *= 0.25f;
-                               m.texrgbscale[0] = 4;
+                               normal3f = varray_normal3f;
+                               Mod_BuildNormals(mesh->num_vertices, mesh->num_triangles, vertex3f, mesh->data_element3i, normal3f);
                        }
+                       R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, vertex3f, normal3f, varray_color4f);
                }
-               if (!vertex3f)
+               else
+                       GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
+               R_Mesh_State(&m);
+               c_alias_polys += mesh->num_triangles;
+               GL_LockArrays(0, mesh->num_vertices);
+               R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
+               GL_LockArrays(0, 0);
+       }
+
+       VectorScale(colorshirt, colorscale, tint);
+       if (ent->colormap >= 0 && texture->skin.shirt && VectorLength2(tint) >= 0.001)
+       {
+               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+               GL_DepthMask(false);
+               m.tex[0] = R_GetTexture(texture->skin.shirt);
+               m.pointer_color = NULL;
+               if (fbshirt)
+                       GL_Color(tint[0], tint[1], tint[2], ent->alpha);
+               else if (R_LightModel(ambientcolor4f, diffusecolor, diffusenormal, ent, tint[0], tint[1], tint[2], ent->alpha, false))
                {
-                       if (ent->frameblend[0].frame == 0 && ent->frameblend[0].lerp == 1)
-                               vertex3f = mesh->data_basevertex3f;
-                       else
+                       m.pointer_color = varray_color4f;
+                       if (normal3f == NULL)
                        {
-                               vertex3f = varray_vertex3f;
-                               Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, mesh, vertex3f);
+                               normal3f = varray_normal3f;
+                               Mod_BuildNormals(mesh->num_vertices, mesh->num_triangles, vertex3f, mesh->data_element3i, normal3f);
                        }
+                       R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, vertex3f, normal3f, varray_color4f);
                }
-               m.pointer_vertex = vertex3f;
+               else
+                       GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
+               R_Mesh_State(&m);
+               c_alias_polys += mesh->num_triangles;
+               GL_LockArrays(0, mesh->num_vertices);
+               R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
+               GL_LockArrays(0, 0);
+       }
 
+       colorscale = 1;
+       m.texrgbscale[0] = 0;
+
+       if (texture->skin.glow)
+       {
+               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+               GL_DepthMask(false);
+               m.tex[0] = R_GetTexture(texture->skin.glow);
+               m.pointer_color = NULL;
+               GL_Color(1, 1, 1, ent->alpha);
+               R_Mesh_State(&m);
                c_alias_polys += mesh->num_triangles;
-               if (layer->flags & ALIASLAYER_FOG)
-               {
-                       colorscale *= fog;
-                       GL_Color(fogcolor[0] * colorscale, fogcolor[1] * colorscale, fogcolor[2] * colorscale, ent->alpha);
-               }
-               else
-               {
-                       fullbright = !(layer->flags & ALIASLAYER_DIFFUSE) || !(ent->flags & RENDER_LIGHT);
-                       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;
-                       tint[0] *= ent->colormod[0];
-                       tint[1] *= ent->colormod[1];
-                       tint[2] *= ent->colormod[2];
-                       if (!fullbright && !(ent->flags & RENDER_TRANSPARENT))
-                               colorscale *= r_lightmapintensity;
-                       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))
-                       {
-                               m.pointer_color = varray_color4f;
-                               if (normal3f == NULL)
-                               {
-                                       if (ent->frameblend[0].frame == 0 && ent->frameblend[0].lerp == 1)
-                                               normal3f = mesh->data_basenormal3f;
-                                       else
-                                       {
-                                               normal3f = varray_normal3f;
-                                               Mod_BuildNormals(mesh->num_vertices, mesh->num_triangles, vertex3f, mesh->data_element3i, normal3f);
-                                       }
-                               }
-                               R_LightModel_CalcVertexColors(ambientcolor4f, diffusecolor, diffusenormal, mesh->num_vertices, vertex3f, normal3f, varray_color4f);
-                       }
-                       else
-                               GL_Color(ambientcolor4f[0], ambientcolor4f[1], ambientcolor4f[2], ambientcolor4f[3]);
-               }
+               GL_LockArrays(0, mesh->num_vertices);
+               R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
+               GL_LockArrays(0, 0);
+       }
+
+       if (fog > 0)
+       {
+               GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+               GL_DepthMask(false);
+               m.tex[0] = R_GetTexture(texture->skin.fog);
+               m.pointer_color = NULL;
+               GL_Color(fogcolor[0], fogcolor[1], fogcolor[2], fog * ent->alpha);
                R_Mesh_State(&m);
+               c_alias_polys += mesh->num_triangles;
                GL_LockArrays(0, mesh->num_vertices);
                R_Mesh_Draw(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i);
                GL_LockArrays(0, 0);
@@ -189,7 +263,7 @@ void R_Model_Alias_Draw(entity_render_t *ent)
 
        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)
+               if (ent->effects & EF_ADDITIVE || ent->alpha != 1.0 || R_FetchAliasSkin(ent, mesh)->skin.fog)
                        R_MeshQueue_AddTransparent(ent->effects & EF_NODEPTHTEST ? r_vieworigin : ent->origin, R_DrawAliasModelCallback, ent, meshnum);
                else
                        R_DrawAliasModelCallback(ent, meshnum);
@@ -200,7 +274,7 @@ void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightor
 {
        int meshnum;
        aliasmesh_t *mesh;
-       aliasskin_t *skin;
+       texture_t *texture;
        float projectdistance, *vertex3f;
        if (!(ent->flags & RENDER_SHADOW))
                return;
@@ -213,8 +287,8 @@ void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightor
                R_Mesh_Matrix(&ent->matrix);
                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)
+                       texture = R_FetchAliasSkin(ent, mesh);
+                       if (texture->skin.fog)
                                continue;
                        if (ent->frameblend[0].frame == 0 && ent->frameblend[0].lerp == 1)
                                vertex3f = mesh->data_basevertex3f;
@@ -233,14 +307,13 @@ void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightor
 
 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, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int numsurfaces, const int *surfacelist)
 {
-       int c, meshnum, layernum;
-       float fog, ifog, lightcolor2[3], ambientscale2, diffusescale2, specularscale2;
+       int c, meshnum;
+       float fog, ifog, lightcolorbase[3], lightcolorpants[3], lightcolorshirt[3];
        float *vertex3f, *svector3f, *tvector3f, *normal3f;
        vec3_t diff;
        qbyte *bcolor;
        aliasmesh_t *mesh;
-       aliaslayer_t *layer;
-       aliasskin_t *skin;
+       texture_t *texture;
 
        R_Mesh_Matrix(&ent->matrix);
 
@@ -262,92 +335,65 @@ void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, v
        }
        ifog = 1 - fog;
 
+       VectorScale(lightcolor, ifog, lightcolorbase);
+       if (VectorLength2(lightcolorbase) < 0.001)
+               return;
+       VectorClear(lightcolorpants);
+       VectorClear(lightcolorshirt);
+       if (ent->colormap >= 0)
+       {
+               // 128-224 are backwards ranges
+               c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
+               // fullbright passes were already taken care of, so skip them in realtime lighting passes
+               if (c < 224)
+               {
+                       bcolor = (qbyte *) (&palette_complete[c]);
+                       lightcolorpants[0] = lightcolorbase[0] * bcolor[0] * (1.0f / 255.0f);
+                       lightcolorpants[1] = lightcolorbase[1] * bcolor[1] * (1.0f / 255.0f);
+                       lightcolorpants[2] = lightcolorbase[2] * bcolor[2] * (1.0f / 255.0f);
+               }
+               // 128-224 are backwards ranges
+               c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
+               // fullbright passes were already taken care of, so skip them in realtime lighting passes
+               if (c < 224)
+               {
+                       bcolor = (qbyte *) (&palette_complete[c]);
+                       lightcolorshirt[0] = lightcolorbase[0] * bcolor[0] * (1.0f / 255.0f);
+                       lightcolorshirt[1] = lightcolorbase[1] * bcolor[1] * (1.0f / 255.0f);
+                       lightcolorshirt[2] = lightcolorbase[2] * bcolor[2] * (1.0f / 255.0f);
+               }
+       }
+
        for (meshnum = 0, mesh = ent->model->alias.aliasdata_meshes;meshnum < ent->model->alias.aliasnum_meshes;meshnum++, mesh++)
        {
-               skin = R_FetchAliasSkin(ent, mesh);
+               texture = R_FetchAliasSkin(ent, mesh);
                // FIXME: transparent skins need to be lit during the transparent render
-               if (skin->flags & ALIASSKIN_TRANSPARENT)
+               if (texture->skin.fog)
                        continue;
-               vertex3f = NULL;
-               svector3f = NULL;
-               tvector3f = NULL;
-               normal3f = NULL;
-               for (layernum = 0, layer = skin->data_layers;layernum < skin->num_layers;layernum++, layer++)
+               if (ent->frameblend[0].frame == 0 && ent->frameblend[0].lerp == 1)
                {
-                       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;
-                       lightcolor2[0] = lightcolor[0] * ifog;
-                       lightcolor2[1] = lightcolor[1] * ifog;
-                       lightcolor2[2] = lightcolor[2] * ifog;
-                       ambientscale2 = 0;
-                       diffusescale2 = 0;
-                       specularscale2 = 0;
-                       if (layer->flags & ALIASLAYER_SPECULAR)
-                               specularscale2 = specularscale;
-                       if (layer->flags & ALIASLAYER_DIFFUSE)
-                       {
-                               if (layer->flags & ALIASLAYER_COLORMAP_PANTS)
-                               {
-                                       // 128-224 are backwards ranges
-                                       c = (ent->colormap & 0xF) << 4;c += (c >= 128 && c < 224) ? 4 : 12;
-                                       // fullbright passes were already taken care of, so skip them in realtime lighting passes
-                                       if (c < 224)
-                                       {
-                                               bcolor = (qbyte *) (&palette_complete[c]);
-                                               lightcolor2[0] *= bcolor[0] * (1.0f / 255.0f);
-                                               lightcolor2[1] *= bcolor[1] * (1.0f / 255.0f);
-                                               lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
-                                               ambientscale2 = ambientscale;
-                                               diffusescale2 = diffusescale;
-                                       }
-                               }
-                               else if (layer->flags & ALIASLAYER_COLORMAP_SHIRT)
-                               {
-                                       // 128-224 are backwards ranges
-                                       c = (ent->colormap & 0xF0);c += (c >= 128 && c < 224) ? 4 : 12;
-                                       // fullbright passes were already taken care of, so skip them in realtime lighting passes
-                                       if (c < 224)
-                                       {
-                                               bcolor = (qbyte *) (&palette_complete[c]);
-                                               lightcolor2[0] *= bcolor[0] * (1.0f / 255.0f);
-                                               lightcolor2[1] *= bcolor[1] * (1.0f / 255.0f);
-                                               lightcolor2[2] *= bcolor[2] * (1.0f / 255.0f);
-                                               ambientscale2 = ambientscale;
-                                               diffusescale2 = diffusescale;
-                                       }
-                               }
-                               else
-                               {
-                                       ambientscale2 = ambientscale;
-                                       diffusescale2 = diffusescale;
-                               }
-                       }
-                       if (!(ambientscale2 + diffusescale2 + specularscale2) || VectorLength2(lightcolor2) <= 0.01)
-                               continue;
-                       c_alias_polys += mesh->num_triangles;
-                       if (!vertex3f)
-                       {
-                               if (ent->frameblend[0].frame == 0 && ent->frameblend[0].lerp == 1)
-                               {
-                                       vertex3f = mesh->data_basevertex3f;
-                                       svector3f = mesh->data_basesvector3f;
-                                       tvector3f = mesh->data_basetvector3f;
-                                       normal3f = mesh->data_basenormal3f;
-                               }
-                               else
-                               {
-                                       vertex3f = varray_vertex3f;
-                                       svector3f = varray_svector3f;
-                                       tvector3f = varray_tvector3f;
-                                       normal3f = varray_normal3f;
-                                       Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, mesh, vertex3f);
-                                       Mod_BuildTextureVectorsAndNormals(mesh->num_vertices, mesh->num_triangles, vertex3f, mesh->data_texcoord2f, mesh->data_element3i, svector3f, tvector3f, normal3f);
-                               }
-                       }
-                       // TODO: make layer have ->gloss as well as ->texture, and merge specular layer for common non-colormapped case?
-                       R_Shadow_RenderLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertex3f, svector3f, tvector3f, normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightcolor2, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, layer->texture, layer->nmap, layer->texture, lightcubemap, ambientscale2, diffusescale2, specularscale2);
+                       vertex3f = mesh->data_basevertex3f;
+                       svector3f = mesh->data_basesvector3f;
+                       tvector3f = mesh->data_basetvector3f;
+                       normal3f = mesh->data_basenormal3f;
+               }
+               else
+               {
+                       vertex3f = varray_vertex3f;
+                       svector3f = varray_svector3f;
+                       tvector3f = varray_tvector3f;
+                       normal3f = varray_normal3f;
+                       Mod_Alias_GetMesh_Vertex3f(ent->model, ent->frameblend, mesh, vertex3f);
+                       Mod_BuildTextureVectorsAndNormals(mesh->num_vertices, mesh->num_triangles, vertex3f, mesh->data_texcoord2f, mesh->data_element3i, svector3f, tvector3f, normal3f);
+               }
+               c_alias_polys += mesh->num_triangles;
+               R_Shadow_RenderLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertex3f, svector3f, tvector3f, normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightcolorbase, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, (ent->colormap >= 0 || !texture->skin.merged) ? texture->skin.base : texture->skin.merged, texture->skin.nmap, texture->skin.gloss, lightcubemap, ambientscale, diffusescale, specularscale);
+               if (ent->colormap >= 0)
+               {
+                       if (texture->skin.pants && VectorLength2(lightcolorpants) >= 0.001)
+                               R_Shadow_RenderLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertex3f, svector3f, tvector3f, normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightcolorpants, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, texture->skin.pants, texture->skin.nmap, NULL, lightcubemap, ambientscale, diffusescale, 0);
+                       if (texture->skin.shirt && VectorLength2(lightcolorshirt) >= 0.001)
+                               R_Shadow_RenderLighting(mesh->num_vertices, mesh->num_triangles, mesh->data_element3i, vertex3f, svector3f, tvector3f, normal3f, mesh->data_texcoord2f, relativelightorigin, relativeeyeorigin, lightcolorshirt, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, texture->skin.shirt, texture->skin.nmap, NULL, lightcubemap, ambientscale, diffusescale, 0);
                }
        }
 }
index 86b5e64..a35dbb7 100644 (file)
@@ -286,11 +286,8 @@ static void Mod_MDL_LoadFrames (qbyte* datapointer, int inverts, vec3_t scale, v
 }
 
 static skinframe_t missingskinframe;
-aliaslayer_t mod_alias_layersbuffer[16]; // 7 currently used
-void Mod_BuildAliasSkinFromSkinFrame(aliasskin_t *skin, skinframe_t *skinframe)
+static void Mod_BuildAliasSkinFromSkinFrame(texture_t *skin, skinframe_t *skinframe)
 {
-       aliaslayer_t *layer;
-
        // hack
        if (skinframe == NULL)
        {
@@ -299,65 +296,10 @@ void Mod_BuildAliasSkinFromSkinFrame(aliasskin_t *skin, skinframe_t *skinframe)
                skinframe->base = r_texture_notexture;
        }
 
-       memset(&mod_alias_layersbuffer, 0, sizeof(mod_alias_layersbuffer));
-       layer = mod_alias_layersbuffer;
-       layer->flags = ALIASLAYER_SPECULAR;
-       layer->texture = skinframe->gloss;
-       layer->nmap = skinframe->nmap;
-       layer++;
-       if (skinframe->merged != NULL)
-       {
-               layer->flags = ALIASLAYER_DIFFUSE | ALIASLAYER_NODRAW_IF_COLORMAPPED;
-               layer->texture = skinframe->merged;
-               layer->nmap = skinframe->nmap;
-               layer++;
-       }
-       if (skinframe->base != NULL)
-       {
-               layer->flags = ALIASLAYER_DIFFUSE;
-               if (skinframe->merged != NULL)
-                       layer->flags |= ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED;
-               layer->texture = skinframe->base;
-               layer->nmap = skinframe->nmap;
-               layer++;
-       }
-       if (skinframe->pants != NULL)
-       {
-               layer->flags = ALIASLAYER_DIFFUSE | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_COLORMAP_PANTS;
-               layer->texture = skinframe->pants;
-               layer->nmap = skinframe->nmap;
-               layer++;
-       }
-       if (skinframe->shirt != NULL)
-       {
-               layer->flags = ALIASLAYER_DIFFUSE | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_COLORMAP_SHIRT;
-               layer->texture = skinframe->shirt;
-               layer->nmap = skinframe->nmap;
-               layer++;
-       }
-
-       if (skinframe->glow != NULL)
-       {
-               layer->flags = 0;
-               layer->texture = skinframe->glow;
-               layer++;
-       }
-
-       layer->flags = ALIASLAYER_FOG | ALIASLAYER_FORCEDRAW_IF_FIRSTPASS;
-       layer->texture = skinframe->fog;
-       layer++;
-
-       skin->flags = 0;
-       // fog texture only exists if some pixels are transparent...
-       if (skinframe->fog != NULL)
-               skin->flags |= ALIASSKIN_TRANSPARENT;
-
-       skin->num_layers = layer - mod_alias_layersbuffer;
-       skin->data_layers = Mem_Alloc(loadmodel->mempool, skin->num_layers * sizeof(aliaslayer_t));
-       memcpy(skin->data_layers, mod_alias_layersbuffer, skin->num_layers * sizeof(aliaslayer_t));
+       skin->skin = *skinframe;
 }
 
-void Mod_BuildAliasSkinsFromSkinFiles(aliasskin_t *skin, skinfile_t *skinfile, char *meshname, char *shadername)
+static void Mod_BuildAliasSkinsFromSkinFiles(texture_t *skin, skinfile_t *skinfile, char *meshname, char *shadername)
 {
        int i;
        skinfileitem_t *skinfileitem;
@@ -424,7 +366,7 @@ void Mod_IDP0_Load(model_t *mod, void *buffer)
        char name[MAX_QPATH];
        skinframe_t tempskinframe;
        animscene_t *tempskinscenes;
-       aliasskin_t *tempaliasskins;
+       texture_t *tempaliasskins;
        float *vertst;
        int *vertonseam, *vertremap;
        skinfile_t *skinfiles;
@@ -603,7 +545,7 @@ void Mod_IDP0_Load(model_t *mod, void *buffer)
        if ((skinfiles = Mod_LoadSkinFiles()))
        {
                loadmodel->alias.aliasdata_meshes->num_skins = totalskins = loadmodel->numskins;
-               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(texture_t));
                Mod_BuildAliasSkinsFromSkinFiles(loadmodel->alias.aliasdata_meshes->data_skins, skinfiles, "default", "");
                Mod_FreeSkinFiles(skinfiles);
                loadmodel->skinscenes = Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
@@ -618,7 +560,7 @@ void Mod_IDP0_Load(model_t *mod, void *buffer)
        else
        {
                loadmodel->alias.aliasdata_meshes->num_skins = totalskins;
-               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(texture_t));
                loadmodel->skinscenes = Mem_Alloc(loadmodel->mempool, loadmodel->numskins * sizeof(animscene_t));
                totalskins = 0;
                datapointer = startskins;
@@ -680,8 +622,8 @@ void Mod_IDP0_Load(model_t *mod, void *buffer)
                        Mem_Free(tempskinscenes);
 
                        tempaliasskins = loadmodel->alias.aliasdata_meshes->data_skins;
-                       loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, (totalskins + 1) * sizeof(aliasskin_t));
-                       memcpy(loadmodel->alias.aliasdata_meshes->data_skins, tempaliasskins, totalskins * sizeof(aliasskin_t));
+                       loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, (totalskins + 1) * sizeof(texture_t));
+                       memcpy(loadmodel->alias.aliasdata_meshes->data_skins, tempaliasskins, totalskins * sizeof(texture_t));
                        Mem_Free(tempaliasskins);
 
                        // store the info about the new skin
@@ -788,7 +730,7 @@ void Mod_IDP2_Load(model_t *mod, void *buffer)
        if ((skinfiles = Mod_LoadSkinFiles()))
        {
                loadmodel->alias.aliasdata_meshes->num_skins = loadmodel->numskins;
-               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(texture_t));
                Mod_BuildAliasSkinsFromSkinFiles(loadmodel->alias.aliasdata_meshes->data_skins, skinfiles, "default", "");
                Mod_FreeSkinFiles(skinfiles);
        }
@@ -796,7 +738,7 @@ void Mod_IDP2_Load(model_t *mod, void *buffer)
        {
                // skins found (most likely not a player model)
                loadmodel->alias.aliasdata_meshes->num_skins = loadmodel->numskins;
-               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(texture_t));
                for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME)
                {
                        if (Mod_LoadSkinFrame(&tempskinframe, inskin, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_CLAMP | TEXF_PRECACHE | TEXF_PICMIP, true, false, true))
@@ -813,7 +755,7 @@ void Mod_IDP2_Load(model_t *mod, void *buffer)
                // no skins (most likely a player model)
                loadmodel->numskins = 1;
                loadmodel->alias.aliasdata_meshes->num_skins = loadmodel->numskins;
-               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+               loadmodel->alias.aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->alias.aliasdata_meshes->num_skins * sizeof(texture_t));
                Mod_BuildAliasSkinFromSkinFrame(loadmodel->alias.aliasdata_meshes->data_skins, NULL);
        }
 
@@ -1021,7 +963,7 @@ void Mod_IDP3_Load(model_t *mod, void *buffer)
                mesh->num_morphframes = LittleLong(pinmesh->num_frames);
                mesh->num_vertices = LittleLong(pinmesh->num_vertices);
                mesh->num_triangles = LittleLong(pinmesh->num_triangles);
-               mesh->data_skins = Mem_Alloc(loadmodel->mempool, mesh->num_skins * sizeof(aliasskin_t));
+               mesh->data_skins = Mem_Alloc(loadmodel->mempool, mesh->num_skins * sizeof(texture_t));
                mesh->data_element3i = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
                mesh->data_neighbor3i = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
                mesh->data_texcoord2f = Mem_Alloc(loadmodel->mempool, mesh->num_vertices * sizeof(float[2]));
@@ -1252,7 +1194,7 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer)
                mesh = loadmodel->alias.aliasdata_meshes + i;
                mesh->num_skins = loadmodel->numskins;
                mesh->num_triangles = count;
-               mesh->data_skins = Mem_Alloc(loadmodel->mempool, mesh->num_skins * sizeof(aliasskin_t));
+               mesh->data_skins = Mem_Alloc(loadmodel->mempool, mesh->num_skins * sizeof(texture_t));
                mesh->data_element3i = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
                mesh->data_neighbor3i = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
                outelements = mesh->data_element3i;
index 4e6faa0..338e2dd 100644 (file)
@@ -213,42 +213,6 @@ typedef struct md3modelheader_s
 }
 md3modelheader_t;
 
-// this layer is fog (completely specialized behavior, automatic NODRAW_IF_NOTFOGGED behavior)
-#define ALIASLAYER_FOG 1
-// apply diffuse lighting
-#define ALIASLAYER_DIFFUSE 8
-// apply specular lighting
-#define ALIASLAYER_SPECULAR 16
-// tint with pants color
-#define ALIASLAYER_COLORMAP_PANTS 32
-// tint with shirt color
-#define ALIASLAYER_COLORMAP_SHIRT 64
-// don't draw this layer if colormap is not used
-#define ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED 128
-// don't draw this layer if colormap is used
-#define ALIASLAYER_NODRAW_IF_COLORMAPPED 256
-// ignore NODRAW flags on this layer only if all previous layers were skipped
-#define ALIASLAYER_FORCEDRAW_IF_FIRSTPASS 512
-
-typedef struct aliaslayer_s
-{
-       int flags;
-       rtexture_t *texture;
-       rtexture_t *nmap;
-}
-aliaslayer_t;
-
-// indicates this skin is transparent
-#define ALIASSKIN_TRANSPARENT 1
-
-typedef struct aliasskin_s
-{
-       int flags;
-       int num_layers;
-       aliaslayer_t *data_layers;
-}
-aliasskin_t;
-
 typedef struct aliasvertexboneweight_s
 {
        unsigned int vertexindex;
@@ -262,7 +226,7 @@ typedef struct aliasmesh_s
 {
        // skins to choose from (indexed by entity skin)
        int num_skins;
-       aliasskin_t *data_skins;
+       texture_t *data_skins;
 
        // triangles comprising the mesh
        int num_triangles;