mesh.c File Reference

#include "gl.h"

Go to the source code of this file.

Typedefs
typedef void(*	tessfunc_t) (const maliasmesh_t *)

Functions
static void	setup_dotshading (void)
static vec_t	shadedot (const vec_t *normal)
static vec_t *	get_static_normal (vec_t *normal, const maliasvert_t *vert)
static void	tess_static_shell (const maliasmesh_t *mesh)
static void	tess_static_shade (const maliasmesh_t *mesh)
static void	tess_static_plain (const maliasmesh_t *mesh)
static vec_t *	get_lerped_normal (vec_t *normal, const maliasvert_t *oldvert, const maliasvert_t *newvert)
static void	tess_lerped_shell (const maliasmesh_t *mesh)
static void	tess_lerped_shade (const maliasmesh_t *mesh)
static void	tess_lerped_plain (const maliasmesh_t *mesh)
static glCullResult_t	cull_static_model (model_t *model)
static glCullResult_t	cull_lerped_model (model_t *model)
static void	setup_color (void)
static void	setup_celshading (void)
static void	draw_celshading (maliasmesh_t *mesh)
static void	setup_shadow (void)
static void	draw_shadow (maliasmesh_t *mesh)
static int	texnum_for_mesh (maliasmesh_t *mesh)
static void	draw_alias_mesh (maliasmesh_t *mesh)
void	GL_DrawAliasModel (model_t *model)

Variables
static int	oldframenum
static int	newframenum
static float	frontlerp
static float	backlerp
static vec3_t	origin
static vec3_t	oldscale
static vec3_t	newscale
static vec3_t	translate
static vec_t	shellscale
static tessfunc_t	tessfunc
static vec4_t	color
static const vec_t *	shadelight
static vec3_t	shadedir
static float	celscale
static GLfloat	shadowmatrix [16]

Typedef Documentation

tessfunc_t

typedef void(* tessfunc_t) (const maliasmesh_t *)

Definition at line 21 of file mesh.c.

Function Documentation

cull_lerped_model()

static glCullResult_t cull_lerped_model ( model_t *  model )

static

Definition at line 291 of file mesh.c.

{
    maliasframe_t *newframe = &model->frames[newframenum];
    maliasframe_t *oldframe = &model->frames[oldframenum];
    vec3_t bounds[2];
    vec_t radius;
    glCullResult_t cull;
 
    if (glr.entrotated) {
        radius = newframe->radius > oldframe->radius ?
                 newframe->radius : oldframe->radius;
        cull = GL_CullSphere(origin, radius);
        if (cull == CULL_OUT) {
            c.spheresCulled++;
            return cull;
        }
        UnionBounds(newframe->bounds, oldframe->bounds, bounds);
        if (cull == CULL_CLIP) {
            cull = GL_CullLocalBox(origin, bounds);
            if (cull == CULL_OUT) {
                c.rotatedBoxesCulled++;
                return cull;
            }
        }
    } else {
        UnionBounds(newframe->bounds, oldframe->bounds, bounds);
        VectorAdd(bounds[0], origin, bounds[0]);
        VectorAdd(bounds[1], origin, bounds[1]);
        cull = GL_CullBox(bounds);
        if (cull == CULL_OUT) {
            c.boxesCulled++;
            return cull;
        }
    }
 
    VectorScale(oldframe->scale, backlerp, oldscale);
    VectorScale(newframe->scale, frontlerp, newscale);
 
    LerpVector2(oldframe->translate, newframe->translate,
                backlerp, frontlerp, translate);
 
    return cull;
}

Referenced by GL_DrawAliasModel().

cull_static_model()

static glCullResult_t cull_static_model ( model_t *  model )

static

Definition at line 256 of file mesh.c.

{
    maliasframe_t *newframe = &model->frames[newframenum];
    vec3_t bounds[2];
    glCullResult_t cull;
 
    if (glr.entrotated) {
        cull = GL_CullSphere(origin, newframe->radius);
        if (cull == CULL_OUT) {
            c.spheresCulled++;
            return cull;
        }
        if (cull == CULL_CLIP) {
            cull = GL_CullLocalBox(origin, newframe->bounds);
            if (cull == CULL_OUT) {
                c.rotatedBoxesCulled++;
                return cull;
            }
        }
    } else {
        VectorAdd(newframe->bounds[0], origin, bounds[0]);
        VectorAdd(newframe->bounds[1], origin, bounds[1]);
        cull = GL_CullBox(bounds);
        if (cull == CULL_OUT) {
            c.boxesCulled++;
            return cull;
        }
    }
 
    VectorCopy(newframe->scale, newscale);
    VectorCopy(newframe->translate, translate);
 
    return cull;
}

Referenced by GL_DrawAliasModel().

draw_alias_mesh()

static void draw_alias_mesh ( maliasmesh_t *  mesh )

static

Definition at line 571 of file mesh.c.

{
    glStateBits_t state = GLS_DEFAULT;
 
    // fall back to entity matrix
    GL_LoadMatrix(glr.entmatrix);
 
    if (shadelight)
        state |= GLS_SHADE_SMOOTH;
 
    if (glr.ent->flags & RF_TRANSLUCENT)
        state |= GLS_BLEND_BLEND | GLS_DEPTHMASK_FALSE;
 
    GL_StateBits(state);
 
    GL_BindTexture(0, texnum_for_mesh(mesh));
 
    (*tessfunc)(mesh);
    c.trisDrawn += mesh->numtris;
 
    if (shadelight) {
        GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
        GL_VertexPointer(3, VERTEX_SIZE, tess.vertices);
        GL_ColorFloatPointer(4, VERTEX_SIZE, tess.vertices + 4);
    } else {
        GL_ArrayBits(GLA_VERTEX | GLA_TC);
        GL_VertexPointer(3, 4, tess.vertices);
        qglColor4fv(color);
    }
 
    GL_TexCoordPointer(2, 0, (GLfloat *)mesh->tcoords);
 
    GL_LockArrays(mesh->numverts);
 
    qglDrawElements(GL_TRIANGLES, mesh->numindices, QGL_INDEX_ENUM,
                    mesh->indices);
 
    draw_celshading(mesh);
 
    if (gl_showtris->integer) {
        GL_EnableOutlines();
        qglDrawElements(GL_TRIANGLES, mesh->numindices, QGL_INDEX_ENUM,
                        mesh->indices);
        GL_DisableOutlines();
    }
 
    // FIXME: unlock arrays before changing matrix?
    draw_shadow(mesh);
 
    GL_UnlockArrays();
}

Referenced by GL_DrawAliasModel().

draw_celshading()

static void draw_celshading ( maliasmesh_t *  mesh )

static

Definition at line 420 of file mesh.c.

{
    if (celscale < 0.01f || celscale > 1)
        return;
 
    GL_BindTexture(0, TEXNUM_BLACK);
    GL_StateBits(GLS_BLEND_BLEND);
    GL_ArrayBits(GLA_VERTEX);
 
    qglLineWidth(gl_celshading->value * celscale);
    qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    qglCullFace(GL_FRONT);
    qglColor4f(0, 0, 0, color[3] * celscale);
    qglDrawElements(GL_TRIANGLES, mesh->numindices, QGL_INDEX_ENUM,
                    mesh->indices);
    qglCullFace(GL_BACK);
    qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    qglLineWidth(1);
}

Referenced by draw_alias_mesh().

draw_shadow()

static void draw_shadow ( maliasmesh_t *  mesh )

static

Definition at line 512 of file mesh.c.

{
    if (shadowmatrix[15] < 0.5f)
        return;
 
    // load shadow projection matrix
    GL_LoadMatrix(shadowmatrix);
 
    // eliminate z-fighting by utilizing stencil buffer, if available
    if (gl_config.stencilbits) {
        qglEnable(GL_STENCIL_TEST);
        qglStencilFunc(GL_EQUAL, 0, 0xff);
        qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
    }
 
    GL_StateBits(GLS_BLEND_BLEND);
    GL_BindTexture(0, TEXNUM_WHITE);
    GL_ArrayBits(GLA_VERTEX);
 
    qglEnable(GL_POLYGON_OFFSET_FILL);
    qglPolygonOffset(-1.0f, -2.0f);
    qglColor4f(0, 0, 0, color[3] * 0.5f);
    qglDrawElements(GL_TRIANGLES, mesh->numindices, QGL_INDEX_ENUM,
                    mesh->indices);
    qglDisable(GL_POLYGON_OFFSET_FILL);
 
    // once we have drawn something to stencil buffer, continue to clear it for
    // the lifetime of OpenGL context. leaving stencil buffer "dirty" and
    // clearing just depth is slower (verified for Nvidia and ATI drivers).
    if (gl_config.stencilbits) {
        qglDisable(GL_STENCIL_TEST);
        gl_static.stencil_buffer_bit |= GL_STENCIL_BUFFER_BIT;
    }
}

Referenced by draw_alias_mesh().

get_lerped_normal()

static vec_t* get_lerped_normal ( vec_t *  normal, const maliasvert_t *  oldvert, const maliasvert_t *  newvert  )

inlinestatic

Definition at line 154 of file mesh.c.

{
    vec3_t oldnorm, newnorm, tmp;
    vec_t len;
 
    get_static_normal(oldnorm, oldvert);
    get_static_normal(newnorm, newvert);
 
    LerpVector2(oldnorm, newnorm, backlerp, frontlerp, tmp);
 
    // normalize result
    len = 1 / VectorLength(tmp);
    VectorScale(tmp, len, normal);
 
    return normal;
}

Referenced by tess_lerped_shade(), and tess_lerped_shell().

get_static_normal()

static vec_t* get_static_normal ( vec_t *  normal, const maliasvert_t *  vert  )

inlinestatic

Definition at line 80 of file mesh.c.

{
    unsigned int lat = vert->norm[0];
    unsigned int lng = vert->norm[1];
 
    normal[0] = TAB_SIN(lat) * TAB_COS(lng);
    normal[1] = TAB_SIN(lat) * TAB_SIN(lng);
    normal[2] = TAB_COS(lat);
 
    return normal;
}

Referenced by get_lerped_normal(), tess_static_shade(), and tess_static_shell().

GL_DrawAliasModel()

void GL_DrawAliasModel

(

model_t *

model

)

Definition at line 623 of file mesh.c.

{
    entity_t *ent = glr.ent;
    glCullResult_t cull;
    int i;
 
    newframenum = ent->frame;
    if (newframenum < 0 || newframenum >= model->numframes) {
        Com_DPrintf("%s: no such frame %d\n", __func__, newframenum);
        newframenum = 0;
    }
 
    oldframenum = ent->oldframe;
    if (oldframenum < 0 || oldframenum >= model->numframes) {
        Com_DPrintf("%s: no such oldframe %d\n", __func__, oldframenum);
        oldframenum = 0;
    }
 
    backlerp = ent->backlerp;
    frontlerp = 1.0f - backlerp;
 
    // optimized case
    if (backlerp == 0)
        oldframenum = newframenum;
 
    // interpolate origin, if necessarry
    if (ent->flags & RF_FRAMELERP)
        LerpVector2(ent->oldorigin, ent->origin,
                    backlerp, frontlerp, origin);
    else
        VectorCopy(ent->origin, origin);
 
    // cull the model, setup scale and translate vectors
    if (newframenum == oldframenum)
        cull = cull_static_model(model);
    else
        cull = cull_lerped_model(model);
    if (cull == CULL_OUT)
        return;
 
    // setup parameters common for all meshes
    setup_color();
    setup_celshading();
    setup_dotshading();
    setup_shadow();
 
    // select proper tessfunc
    if (ent->flags & RF_SHELL_MASK) {
        shellscale = (ent->flags & RF_WEAPONMODEL) ?
            WEAPONSHELL_SCALE : POWERSUIT_SCALE;
        tessfunc = newframenum == oldframenum ?
            tess_static_shell : tess_lerped_shell;
    } else if (shadelight) {
        tessfunc = newframenum == oldframenum ?
            tess_static_shade : tess_lerped_shade;
    } else {
        tessfunc = newframenum == oldframenum ?
            tess_static_plain : tess_lerped_plain;
    }
 
    float scale = 1.f;
    if (ent->scale > 0.f)
        scale = ent->scale;
 
    GL_RotateForEntity(origin, scale);
 
    if ((ent->flags & (RF_WEAPONMODEL | RF_LEFTHAND)) ==
        (RF_WEAPONMODEL | RF_LEFTHAND)) {
        qglMatrixMode(GL_PROJECTION);
        qglScalef(-1, 1, 1);
        qglMatrixMode(GL_MODELVIEW);
        qglFrontFace(GL_CCW);
    }
 
    if (ent->flags & RF_DEPTHHACK)
        qglDepthRange(0, 0.25f);
 
    // draw all the meshes
    for (i = 0; i < model->nummeshes; i++)
        draw_alias_mesh(&model->meshes[i]);
 
    if (ent->flags & RF_DEPTHHACK)
        qglDepthRange(0, 1);
 
    if ((ent->flags & (RF_WEAPONMODEL | RF_LEFTHAND)) ==
        (RF_WEAPONMODEL | RF_LEFTHAND)) {
        qglMatrixMode(GL_PROJECTION);
        qglScalef(-1, 1, 1);
        qglMatrixMode(GL_MODELVIEW);
        qglFrontFace(GL_CW);
    }
}

Referenced by GL_DrawEntities().

setup_celshading()

static void setup_celshading ( void  )

static

Definition at line 403 of file mesh.c.

{
    float value = Cvar_ClampValue(gl_celshading, 0, 10);
    vec3_t dir;
 
    celscale = 0;
 
    if (value == 0)
        return;
 
    if (glr.ent->flags & (RF_TRANSLUCENT | RF_SHELL_MASK))
        return;
 
    VectorSubtract(origin, glr.fd.vieworg, dir);
    celscale = 1.0f - VectorLength(dir) / 700.0f;
}

Referenced by GL_DrawAliasModel().

setup_color()

static void setup_color ( void  )

static

Definition at line 335 of file mesh.c.

{
    int flags = glr.ent->flags;
    float f, m;
    int i;
 
    memset(&glr.lightpoint, 0, sizeof(glr.lightpoint));
 
    if (flags & RF_SHELL_MASK) {
        VectorClear(color);
        if (flags & RF_SHELL_HALF_DAM) {
            color[0] = 0.56f;
            color[1] = 0.59f;
            color[2] = 0.45f;
        }
        if (flags & RF_SHELL_DOUBLE) {
            color[0] = 0.9f;
            color[1] = 0.7f;
        }
        if (flags & RF_SHELL_RED) {
            color[0] = 1;
        }
        if (flags & RF_SHELL_GREEN) {
            color[1] = 1;
        }
        if (flags & RF_SHELL_BLUE) {
            color[2] = 1;
        }
    } else if (flags & RF_FULLBRIGHT) {
        VectorSet(color, 1, 1, 1);
    } else if ((flags & RF_IR_VISIBLE) && (glr.fd.rdflags & RDF_IRGOGGLES)) {
        VectorSet(color, 1, 0, 0);
    } else {
        GL_LightPoint(origin, color);
 
        if (flags & RF_MINLIGHT) {
            for (i = 0; i < 3; i++) {
                if (color[i] > 0.1f) {
                    break;
                }
            }
            if (i == 3) {
                VectorSet(color, 0.1f, 0.1f, 0.1f);
            }
        }
 
        if (flags & RF_GLOW) {
            f = 0.1f * sin(glr.fd.time * 7);
            for (i = 0; i < 3; i++) {
                m = color[i] * 0.8f;
                color[i] += f;
                if (color[i] < m)
                    color[i] = m;
            }
        }
 
        for (i = 0; i < 3; i++) {
            clamp(color[i], 0, 1);
        }
    }
 
    if (flags & RF_TRANSLUCENT) {
        color[3] = glr.ent->alpha;
    } else {
        color[3] = 1;
    }
}

Referenced by GL_DrawAliasModel().

setup_dotshading()

static void setup_dotshading ( void  )

static

Definition at line 42 of file mesh.c.

{
    float cp, cy, sp, sy;
    vec_t yaw;
 
    shadelight = NULL;
 
    if (!gl_dotshading->integer)
        return;
 
    if (glr.ent->flags & RF_SHELL_MASK)
        return;
 
    shadelight = color;
 
    // matches the anormtab.h precalculations
    yaw = -DEG2RAD(glr.ent->angles[YAW]);
    cy = cos(yaw);
    sy = sin(yaw);
    cp = cos(-M_PI / 4);
    sp = sin(-M_PI / 4);
    shadedir[0] = cp * cy;
    shadedir[1] = cp * sy;
    shadedir[2] = -sp;
}

Referenced by GL_DrawAliasModel().

setup_shadow()

static void setup_shadow ( void  )

static

Definition at line 440 of file mesh.c.

{
    GLfloat matrix[16], tmp[16];
    cplane_t *plane;
    vec3_t dir;
 
    shadowmatrix[15] = 0;
 
    if (!gl_shadows->integer)
        return;
 
    if (glr.ent->flags & (RF_WEAPONMODEL | RF_NOSHADOW))
        return;
 
    if (!glr.lightpoint.surf)
        return;
 
    // position fake light source straight over the model
    if (glr.lightpoint.surf->drawflags & DSURF_PLANEBACK)
        VectorSet(dir, 0, 0, -1);
    else
        VectorSet(dir, 0, 0, 1);
 
    // project shadow on ground plane
    plane = &glr.lightpoint.plane;
 
    matrix[0] = plane->normal[1] * dir[1] + plane->normal[2] * dir[2];
    matrix[4] = -plane->normal[1] * dir[0];
    matrix[8] = -plane->normal[2] * dir[0];
    matrix[12] = plane->dist * dir[0];
 
    matrix[1] = -plane->normal[0] * dir[1];
    matrix[5] = plane->normal[0] * dir[0] + plane->normal[2] * dir[2];
    matrix[9] = -plane->normal[2] * dir[1];
    matrix[13] = plane->dist * dir[1];
 
    matrix[2] = -plane->normal[0] * dir[2];
    matrix[6] = -plane->normal[1] * dir[2];
    matrix[10] = plane->normal[0] * dir[0] + plane->normal[1] * dir[1];
    matrix[14] = plane->dist * dir[2];
 
    matrix[3] = 0;
    matrix[7] = 0;
    matrix[11] = 0;
    matrix[15] = DotProduct(plane->normal, dir);
 
    GL_MultMatrix(tmp, glr.viewmatrix, matrix);
 
    // rotate for entity
    matrix[0] = glr.entaxis[0][0];
    matrix[4] = glr.entaxis[1][0];
    matrix[8] = glr.entaxis[2][0];
    matrix[12] = origin[0];
 
    matrix[1] = glr.entaxis[0][1];
    matrix[5] = glr.entaxis[1][1];
    matrix[9] = glr.entaxis[2][1];
    matrix[13] = origin[1];
 
    matrix[2] = glr.entaxis[0][2];
    matrix[6] = glr.entaxis[1][2];
    matrix[10] = glr.entaxis[2][2];
    matrix[14] = origin[2];
 
    matrix[3] = 0;
    matrix[7] = 0;
    matrix[11] = 0;
    matrix[15] = 1;
 
    GL_MultMatrix(shadowmatrix, tmp, matrix);
}

Referenced by GL_DrawAliasModel().

shadedot()

static vec_t shadedot ( const vec_t *  normal )

inlinestatic

Definition at line 68 of file mesh.c.

{
    vec_t d = DotProduct(normal, shadedir);
 
    // matches the anormtab.h precalculations
    if (d < 0) {
        d *= 0.3f;
    }
 
    return d + 1;
}

Referenced by tess_lerped_shade(), and tess_static_shade().

tess_lerped_plain()

static void tess_lerped_plain ( const maliasmesh_t *  mesh )

static

Definition at line 232 of file mesh.c.

{
    maliasvert_t *src_oldvert = &mesh->verts[oldframenum * mesh->numverts];
    maliasvert_t *src_newvert = &mesh->verts[newframenum * mesh->numverts];
    vec_t *dst_vert = tess.vertices;
    int count = mesh->numverts;
 
    while (count--) {
        dst_vert[0] =
            src_oldvert->pos[0] * oldscale[0] +
            src_newvert->pos[0] * newscale[0] + translate[0];
        dst_vert[1] =
            src_oldvert->pos[1] * oldscale[1] +
            src_newvert->pos[1] * newscale[1] + translate[1];
        dst_vert[2] =
            src_oldvert->pos[2] * oldscale[2] +
            src_newvert->pos[2] * newscale[2] + translate[2];
        dst_vert += 4;
 
        src_oldvert++;
        src_newvert++;
    }
}

Referenced by GL_DrawAliasModel().

tess_lerped_shade()

static void tess_lerped_shade ( const maliasmesh_t *  mesh )

static

Definition at line 200 of file mesh.c.

{
    maliasvert_t *src_oldvert = &mesh->verts[oldframenum * mesh->numverts];
    maliasvert_t *src_newvert = &mesh->verts[newframenum * mesh->numverts];
    vec_t *dst_vert = tess.vertices;
    int count = mesh->numverts;
    vec3_t normal;
    vec_t d;
 
    while (count--) {
        d = shadedot(get_lerped_normal(normal, src_oldvert, src_newvert));
 
        dst_vert[0] =
            src_oldvert->pos[0] * oldscale[0] +
            src_newvert->pos[0] * newscale[0] + translate[0];
        dst_vert[1] =
            src_oldvert->pos[1] * oldscale[1] +
            src_newvert->pos[1] * newscale[1] + translate[1];
        dst_vert[2] =
            src_oldvert->pos[2] * oldscale[2] +
            src_newvert->pos[2] * newscale[2] + translate[2];
        dst_vert[4] = shadelight[0] * d;
        dst_vert[5] = shadelight[1] * d;
        dst_vert[6] = shadelight[2] * d;
        dst_vert[7] = shadelight[3];
        dst_vert += VERTEX_SIZE;
 
        src_oldvert++;
        src_newvert++;
    }
}

Referenced by GL_DrawAliasModel().

tess_lerped_shell()

static void tess_lerped_shell ( const maliasmesh_t *  mesh )

static

Definition at line 173 of file mesh.c.

{
    maliasvert_t *src_oldvert = &mesh->verts[oldframenum * mesh->numverts];
    maliasvert_t *src_newvert = &mesh->verts[newframenum * mesh->numverts];
    vec_t *dst_vert = tess.vertices;
    int count = mesh->numverts;
    vec3_t normal;
 
    while (count--) {
        get_lerped_normal(normal, src_oldvert, src_newvert);
 
        dst_vert[0] = normal[0] * shellscale +
                      src_oldvert->pos[0] * oldscale[0] +
                      src_newvert->pos[0] * newscale[0] + translate[0];
        dst_vert[1] = normal[1] * shellscale +
                      src_oldvert->pos[1] * oldscale[1] +
                      src_newvert->pos[1] * newscale[1] + translate[1];
        dst_vert[2] = normal[2] * shellscale +
                      src_oldvert->pos[2] * oldscale[2] +
                      src_newvert->pos[2] * newscale[2] + translate[2];
        dst_vert += 4;
 
        src_oldvert++;
        src_newvert++;
    }
}

Referenced by GL_DrawAliasModel().

tess_static_plain()

static void tess_static_plain ( const maliasmesh_t *  mesh )

static

Definition at line 138 of file mesh.c.

{
    maliasvert_t *src_vert = &mesh->verts[newframenum * mesh->numverts];
    vec_t *dst_vert = tess.vertices;
    int count = mesh->numverts;
 
    while (count--) {
        dst_vert[0] = src_vert->pos[0] * newscale[0] + translate[0];
        dst_vert[1] = src_vert->pos[1] * newscale[1] + translate[1];
        dst_vert[2] = src_vert->pos[2] * newscale[2] + translate[2];
        dst_vert += 4;
 
        src_vert++;
    }
}

Referenced by GL_DrawAliasModel().

tess_static_shade()

static void tess_static_shade ( const maliasmesh_t *  mesh )

static

Definition at line 114 of file mesh.c.

{
    maliasvert_t *src_vert = &mesh->verts[newframenum * mesh->numverts];
    vec_t *dst_vert = tess.vertices;
    int count = mesh->numverts;
    vec3_t normal;
    vec_t d;
 
    while (count--) {
        d = shadedot(get_static_normal(normal, src_vert));
 
        dst_vert[0] = src_vert->pos[0] * newscale[0] + translate[0];
        dst_vert[1] = src_vert->pos[1] * newscale[1] + translate[1];
        dst_vert[2] = src_vert->pos[2] * newscale[2] + translate[2];
        dst_vert[4] = shadelight[0] * d;
        dst_vert[5] = shadelight[1] * d;
        dst_vert[6] = shadelight[2] * d;
        dst_vert[7] = shadelight[3];
        dst_vert += VERTEX_SIZE;
 
        src_vert++;
    }
}

Referenced by GL_DrawAliasModel().

tess_static_shell()

static void tess_static_shell ( const maliasmesh_t *  mesh )

static

Definition at line 92 of file mesh.c.

{
    maliasvert_t *src_vert = &mesh->verts[newframenum * mesh->numverts];
    vec_t *dst_vert = tess.vertices;
    int count = mesh->numverts;
    vec3_t normal;
 
    while (count--) {
        get_static_normal(normal, src_vert);
 
        dst_vert[0] = normal[0] * shellscale +
                      src_vert->pos[0] * newscale[0] + translate[0];
        dst_vert[1] = normal[1] * shellscale +
                      src_vert->pos[1] * newscale[1] + translate[1];
        dst_vert[2] = normal[2] * shellscale +
                      src_vert->pos[2] * newscale[2] + translate[2];
        dst_vert += 4;
 
        src_vert++;
    }
}

Referenced by GL_DrawAliasModel().

texnum_for_mesh()

static int texnum_for_mesh ( maliasmesh_t *  mesh )

static

Definition at line 547 of file mesh.c.

{
    entity_t *ent = glr.ent;
 
    if (ent->flags & RF_SHELL_MASK)
        return TEXNUM_WHITE;
 
    if (ent->skin)
        return IMG_ForHandle(ent->skin)->texnum;
 
    if (!mesh->numskins)
        return TEXNUM_DEFAULT;
 
    if (ent->skinnum < 0 || ent->skinnum >= mesh->numskins) {
        Com_DPrintf("%s: no such skin: %d\n", "GL_DrawAliasModel", ent->skinnum);
        return mesh->skins[0]->texnum;
    }
 
    if (mesh->skins[ent->skinnum]->texnum == TEXNUM_DEFAULT)
        return mesh->skins[0]->texnum;
 
    return mesh->skins[ent->skinnum]->texnum;
}

Referenced by draw_alias_mesh().

Variable Documentation

backlerp

float backlerp

static

Definition at line 26 of file mesh.c.

Referenced by CL_CalcViewValues(), cull_lerped_model(), Draw(), get_lerped_normal(), GL_DrawAliasModel(), and R_AliasSetUpLerpData().

celscale

float celscale

static

Definition at line 38 of file mesh.c.

Referenced by draw_celshading(), and setup_celshading().

color

vec4_t color

static

Definition at line 33 of file mesh.c.

Referenced by _GL_LightPoint(), _GL_StretchPic(), _R_LightPoint(), add_dlights(), build_surface_poly(), cast_u32_to_f32_color(), CL_AddExplosionLight(), CL_AddParticles(), CL_BlasterParticles2(), CL_BloodParticleEffect(), CL_ColorExplosionParticles(), CL_FlagTrail(), CL_ForceWall(), CL_GenericParticleEffect(), CL_HdrColor_m(), CL_LogoutEffect(), CL_ParticleEffect(), CL_ParticleEffect2(), CL_ParticleEffect3(), CL_ParticleEffectWaterSplash(), CL_ParticleSmokeEffect(), CL_ParticleSteamEffect(), CL_RailLights(), CL_TagTrail(), Cmd_EchoEx_f(), Com_SetColor(), Con_DrawLine(), Con_SetColor(), create_invalid_texture(), D_FlatFillSurface(), draw_alias_mesh(), draw_celshading(), draw_shadow(), enqueue_stretch_pic(), Field_Draw(), fire_lead(), GL_AdjustColor(), GL_Blend(), GL_DrawBeams(), GL_DrawParticles(), GL_LightPoint(), GL_SampleLightPoint(), HUD_DrawNumber(), MenuList_Draw(), PF_DebugGraph(), process_regular_entity(), R_AliasSetupBlend(), R_DrawBeam(), R_DrawFill32(), R_DrawFill32_GL(), R_DrawFill32_RTX(), R_DrawFill8(), R_DrawFixedData(), R_DrawParticles(), R_DrawStretchData(), R_IMFlatShadedQuad(), R_LightPoint(), R_LightPoint_GL(), R_SetColor(), R_SetColor_GL(), R_SetColor_RTX(), sample_surface_verts(), SCR_Color_g(), SCR_Draw_f(), SCR_ExecuteLayoutString(), SCR_ParseColor(), setup_color(), setup_dotshading(), vkpt_build_beam_lights(), vkpt_build_cylinder_light(), vkpt_extract_emissive_texture_info(), and vkpt_normalize_normal_map().

frontlerp

float frontlerp

static

Definition at line 25 of file mesh.c.

Referenced by cull_lerped_model(), get_lerped_normal(), GL_DrawAliasModel(), and R_AliasSetUpLerpData().

newframenum

int newframenum

static

Definition at line 24 of file mesh.c.

Referenced by cull_lerped_model(), cull_static_model(), GL_DrawAliasModel(), tess_lerped_plain(), tess_lerped_shade(), tess_lerped_shell(), tess_static_plain(), tess_static_shade(), and tess_static_shell().

newscale

vec3_t newscale

static

Definition at line 29 of file mesh.c.

Referenced by cull_lerped_model(), cull_static_model(), tess_lerped_plain(), tess_lerped_shade(), tess_lerped_shell(), tess_static_plain(), tess_static_shade(), and tess_static_shell().

oldframenum

int oldframenum

static

Definition at line 23 of file mesh.c.

Referenced by cull_lerped_model(), GL_DrawAliasModel(), tess_lerped_plain(), tess_lerped_shade(), and tess_lerped_shell().

oldscale

vec3_t oldscale

static

Definition at line 28 of file mesh.c.

Referenced by cull_lerped_model(), tess_lerped_plain(), tess_lerped_shade(), and tess_lerped_shell().

origin

vec3_t origin

static

Definition at line 27 of file mesh.c.

Referenced by AL_AddLoopSounds(), AL_Spatialize(), CL_AddExplosionLight(), CL_AddPacketEntities(), CL_FlyEffect(), CL_FlyParticles(), CL_MonsterPlasma_Shell(), CL_MuzzleFlash2(), CL_ParticleEffect(), CL_ParticleEffectWaterSplash(), CL_SmokeAndFlash(), CL_Tracker_Explode(), CL_Tracker_Shell(), CM_TransformedBoxTrace(), CM_TransformedPointContents(), create_entity_matrix(), cull_lerped_model(), cull_static_model(), entity_update(), entity_update_new(), entity_update_old(), floater_zap(), func_explosive_explode(), GL_CullLocalBox(), GL_CullSphere(), GL_DrawAliasModel(), GL_LightPoint(), GL_RotateForEntity(), Grenade_Explode(), M_Menu_PlayerConfig(), make_box_points(), MVD_ParseEntityString(), MVD_ParseSound(), PF_PositionedSound(), PF_StartSound(), PM_GoodPosition(), process_bsp_entity(), R_DrawBeam(), R_LightPoint_GL(), rocket_touch(), S_StartSound(), SelectSpawnPoint(), setup_celshading(), setup_color(), setup_shadow(), SpawnDamage(), SV_Multicast(), ThrowDebris(), ThrowGib(), UpdateTerrainShadowMapView(), and write_particle_geometry().

shadedir

vec3_t shadedir

static

Definition at line 36 of file mesh.c.

Referenced by setup_dotshading(), and shadedot().

shadelight

const vec_t* shadelight

static

Definition at line 35 of file mesh.c.

Referenced by draw_alias_mesh(), GL_DrawAliasModel(), setup_dotshading(), tess_lerped_shade(), tess_static_shade(), and V_SetLightLevel().

shadowmatrix

GLfloat shadowmatrix[16]

static

Definition at line 40 of file mesh.c.

Referenced by draw_shadow(), and setup_shadow().

shellscale

vec_t shellscale

static

Definition at line 31 of file mesh.c.

Referenced by GL_DrawAliasModel(), tess_lerped_shell(), and tess_static_shell().

tessfunc

tessfunc_t tessfunc

static

Definition at line 32 of file mesh.c.

Referenced by GL_DrawAliasModel().

translate

vec3_t translate

static

Definition at line 30 of file mesh.c.

Referenced by cull_lerped_model(), cull_static_model(), tess_lerped_plain(), tess_lerped_shade(), tess_lerped_shell(), tess_static_plain(), tess_static_shade(), and tess_static_shell().