tess.c File Reference

#include "gl.h"

Go to the source code of this file.

Macros
#define	FACE_HASH_BITS   5
#define	FACE_HASH_SIZE   (1 << FACE_HASH_BITS)
#define	FACE_HASH_MASK   (FACE_HASH_SIZE - 1)
#define	PARTICLE_SIZE   (1 + M_SQRT1_2)
#define	PARTICLE_SCALE   (1 / (2 * PARTICLE_SIZE))

Functions
void	GL_Flush2D (void)
void	GL_DrawParticles (void)
void	GL_DrawBeams (void)
void	GL_BindArrays (void)
void	GL_Flush3D (void)
static int	GL_CopyVerts (mface_t *surf)
static int	GL_TextureAnimation (mtexinfo_t *tex)
void	GL_DrawFace (mface_t *surf)
static void	GL_DrawChain (mface_t **head)
void	GL_ClearSolidFaces (void)
void	GL_DrawSolidFaces (void)
void	GL_DrawAlphaFaces (void)
void	GL_AddSolidFace (mface_t *face)
void	GL_AddAlphaFace (mface_t *face)

Variables
tesselator_t	tess
static mface_t *	faces_head [FACE_HASH_SIZE]
static mface_t **	faces_next [FACE_HASH_SIZE]
static mface_t *	faces_alpha

Macro Definition Documentation

FACE_HASH_BITS

#define FACE_HASH_BITS   5

Definition at line 23 of file tess.c.

FACE_HASH_MASK

#define FACE_HASH_MASK   (FACE_HASH_SIZE - 1)

Definition at line 25 of file tess.c.

FACE_HASH_SIZE

#define FACE_HASH_SIZE   (1 << FACE_HASH_BITS)

Definition at line 24 of file tess.c.

PARTICLE_SCALE

#define PARTICLE_SCALE   (1 / (2 * PARTICLE_SIZE))

Definition at line 77 of file tess.c.

PARTICLE_SIZE

#define PARTICLE_SIZE   (1 + M_SQRT1_2)

Definition at line 76 of file tess.c.

Function Documentation

GL_AddAlphaFace()

void GL_AddAlphaFace

(

mface_t *

face

)

Definition at line 476 of file tess.c.

{
    // draw back-to-front
    face->next = faces_alpha;
    faces_alpha = face;
}

Referenced by GL_DrawBspModel(), and GL_DrawNode().

GL_AddSolidFace()

void GL_AddSolidFace

(

mface_t *

face

)

Definition at line 462 of file tess.c.

{
    unsigned hash;
 
    hash = face->texnum[0] ^ face->texnum[1] ^ face->statebits;
    hash ^= hash >> FACE_HASH_BITS;
    hash &= FACE_HASH_MASK;
 
    // preserve front-to-back ordering
    face->next = NULL;
    *faces_next[hash] = face;
    faces_next[hash] = &face->next;
}

Referenced by GL_DrawNode().

GL_BindArrays()

void GL_BindArrays

(

void

)

Definition at line 255 of file tess.c.

{
    vec_t *ptr;
 
    if (gl_static.world.vertices) {
        ptr = tess.vertices;
    } else {
        ptr = NULL;
        qglBindBufferARB(GL_ARRAY_BUFFER_ARB, gl_static.world.bufnum);
    }
 
    GL_VertexPointer(3, VERTEX_SIZE, ptr + 0);
 
    if (gl_lightmap->integer) {
        GL_TexCoordPointer(2, VERTEX_SIZE, ptr + 6);
    } else {
        GL_TexCoordPointer(2, VERTEX_SIZE, ptr + 4);
        if (lm.nummaps) {
            GL_LightCoordPointer(2, VERTEX_SIZE, ptr + 6);
        }
    }
 
    GL_ColorBytePointer(4, VERTEX_SIZE, (GLubyte *)(ptr + 3));
 
    if (!gl_static.world.vertices) {
        qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
    }
}

Referenced by GL_DrawAlphaFaces(), GL_DrawBspModel(), and GL_DrawWorld().

GL_ClearSolidFaces()

void GL_ClearSolidFaces

(

void

)

Definition at line 427 of file tess.c.

{
    int i;
 
    for (i = 0; i < FACE_HASH_SIZE; i++) {
        faces_next[i] = &faces_head[i];
    }
}

Referenced by GL_DrawWorld().

GL_CopyVerts()

static int GL_CopyVerts ( mface_t *  surf )

static

Definition at line 334 of file tess.c.

{
    void *src, *dst;
    int firstvert;
 
    if (tess.numverts + surf->numsurfedges > TESS_MAX_VERTICES) {
        GL_Flush3D();
    }
 
    src = gl_static.world.vertices + surf->firstvert * VERTEX_SIZE;
    dst = tess.vertices + tess.numverts * VERTEX_SIZE;
    memcpy(dst, src, surf->numsurfedges * VERTEX_SIZE * sizeof(vec_t));
 
    firstvert = tess.numverts;
    tess.numverts += surf->numsurfedges;
    return firstvert;
}

Referenced by GL_DrawFace().

GL_DrawAlphaFaces()

void GL_DrawAlphaFaces

(

void

)

Definition at line 445 of file tess.c.

{
    if (!faces_alpha) {
        return;
    }
 
    glr.ent = &gl_world;
 
    GL_LoadMatrix(glr.viewmatrix);
 
    GL_BindArrays();
 
    GL_DrawChain(&faces_alpha);
 
    GL_Flush3D();
}

Referenced by R_RenderFrame_GL().

GL_DrawBeams()

void GL_DrawBeams

(

void

)

Definition at line 164 of file tess.c.

{
    vec3_t d1, d2, d3;
    vec_t *start, *end;
    color_t color;
    vec_t *dst_vert;
    uint32_t *dst_color;
    QGL_INDEX_TYPE *dst_indices;
    vec_t length;
    int numverts;
    int numindices;
    entity_t *ent;
    int i;
 
    if (!glr.num_beams) {
        return;
    }
 
    GL_LoadMatrix(glr.viewmatrix);
    GL_BindTexture(0, TEXNUM_BEAM);
    GL_StateBits(GLS_BLEND_BLEND | GLS_DEPTHMASK_FALSE);
    GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
 
    GL_VertexPointer(3, 5, tess.vertices);
    GL_TexCoordPointer(2, 5, tess.vertices + 3);
    GL_ColorBytePointer(4, 0, tess.colors);
 
    numverts = numindices = 0;
    for (i = 0, ent = glr.fd.entities; i < glr.fd.num_entities; i++, ent++) {
        if (!(ent->flags & RF_BEAM)) {
            continue;
        }
 
        start = ent->origin;
        end = ent->oldorigin;
        VectorSubtract(end, start, d1);
        VectorSubtract(glr.fd.vieworg, start, d2);
        CrossProduct(d1, d2, d3);
        length = VectorLength(d3);
        length = ent->frame * 1.2f / length;
        VectorScale(d3, length, d3);
 
        length = VectorLength(d1);
 
        if (ent->skinnum == -1) {
            color.u32 = ent->rgba.u32;
        } else {
            color.u32 = d_8to24table[ent->skinnum & 0xff];
            color.u8[3] = 255 * ent->alpha;
        }
 
        if (numverts + 4 > TESS_MAX_VERTICES ||
            numindices + 6 > TESS_MAX_INDICES) {
            qglDrawElements(GL_TRIANGLES, numindices,
                            QGL_INDEX_ENUM, tess.indices);
            numverts = numindices = 0;
        }
 
        dst_vert = tess.vertices + numverts * 5;
        VectorAdd(start, d3, dst_vert);
        VectorSubtract(start, d3, dst_vert + 5);
        VectorSubtract(end, d3, dst_vert + 10);
        VectorAdd(end, d3, dst_vert + 15);
 
        dst_vert[3] = 0; dst_vert[4] = 0;
        dst_vert[8] = 1; dst_vert[9] = 0;
        dst_vert[13] = 1; dst_vert[14] = length;
        dst_vert[18] = 0; dst_vert[19] = length;
 
        dst_color = (uint32_t *)tess.colors + numverts;
        dst_color[0] = color.u32;
        dst_color[1] = color.u32;
        dst_color[2] = color.u32;
        dst_color[3] = color.u32;
 
        dst_indices = tess.indices + numindices;
        dst_indices[0] = numverts + 0;
        dst_indices[1] = numverts + 2;
        dst_indices[2] = numverts + 3;
        dst_indices[3] = numverts + 0;
        dst_indices[4] = numverts + 1;
        dst_indices[5] = numverts + 2;
 
        numverts += 4;
        numindices += 6;
    }
 
    qglDrawElements(GL_TRIANGLES, numindices,
                    QGL_INDEX_ENUM, tess.indices);
}

Referenced by R_RenderFrame_GL().

GL_DrawChain()

static void GL_DrawChain ( mface_t **  head )

inlinestatic

Definition at line 416 of file tess.c.

{
    mface_t *face;
 
    for (face = *head; face; face = face->next) {
        GL_DrawFace(face);
    }
 
    *head = NULL;
}

Referenced by GL_DrawAlphaFaces(), and GL_DrawSolidFaces().

GL_DrawFace()

void GL_DrawFace

(

mface_t *

surf

)

Definition at line 367 of file tess.c.

{
    int numtris = surf->numsurfedges - 2;
    int numindices = numtris * 3;
    GLuint texnum[2];
    QGL_INDEX_TYPE *dst_indices;
    int i, j;
 
    if (q_unlikely(gl_lightmap->integer)) {
        texnum[0] = surf->texnum[1];
        if (!texnum[0])
            texnum[0] = GL_TextureAnimation(surf->texinfo);
        texnum[1] = 0;
    } else {
        texnum[0] = GL_TextureAnimation(surf->texinfo);
        texnum[1] = surf->texnum[1];
    }
 
    if (tess.texnum[0] != texnum[0] ||
        tess.texnum[1] != texnum[1] ||
        tess.flags != surf->statebits ||
        tess.numindices + numindices > TESS_MAX_INDICES) {
        GL_Flush3D();
    }
 
    tess.texnum[0] = texnum[0];
    tess.texnum[1] = texnum[1];
    tess.flags = surf->statebits;
 
    if (q_unlikely(gl_static.world.vertices)) {
        j = GL_CopyVerts(surf);
    } else {
        j = surf->firstvert;
    }
 
    dst_indices = tess.indices + tess.numindices;
    for (i = 0; i < numtris; i++) {
        dst_indices[0] = j;
        dst_indices[1] = j + (i + 1);
        dst_indices[2] = j + (i + 2);
        dst_indices += 3;
    }
    tess.numindices += numindices;
 
    c.trisDrawn += numtris;
    c.facesTris += numtris;
    c.facesDrawn++;
}

Referenced by GL_DrawBspModel(), GL_DrawChain(), and GL_DrawNode().

GL_DrawParticles()

void GL_DrawParticles

(

void

)

Definition at line 79 of file tess.c.

{
    particle_t *p;
    int total, count;
    vec3_t transformed;
    vec_t scale, dist;
    color_t color;
    int numverts;
    vec_t *dst_vert;
    uint32_t *dst_color;
    int blend;
 
    if (!glr.fd.num_particles)
        return;
 
    if (gl_partstyle->integer)
        blend = GLS_BLEND_ADD;
    else
        blend = GLS_BLEND_BLEND;
 
    GL_LoadMatrix(glr.viewmatrix);
 
    GL_VertexPointer(3, 5, tess.vertices);
    GL_TexCoordPointer(2, 5, tess.vertices + 3);
    GL_ColorBytePointer(4, 0, tess.colors);
 
    p = glr.fd.particles;
    total = glr.fd.num_particles;
    do {
        GL_BindTexture(0, TEXNUM_PARTICLE);
        GL_StateBits(blend | GLS_DEPTHMASK_FALSE);
        GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
 
        count = total;
        if (count > TESS_MAX_VERTICES / 3)
            count = TESS_MAX_VERTICES / 3;
 
        total -= count;
 
        numverts = 0;
        do {
            VectorSubtract(p->origin, glr.fd.vieworg, transformed);
            dist = DotProduct(transformed, glr.viewaxis[0]);
 
            scale = gl_partscale->value;
            if (dist > 20)
                scale += dist * 0.01f;
 
            if (p->color == -1) {
                color.u32 = p->rgba.u32;
            } else {
                color.u32 = d_8to24table[p->color & 0xff];
                color.u8[3] = 255 * p->alpha;
            }
 
            dst_vert = tess.vertices + numverts * 5;
            VectorMA(p->origin, scale * PARTICLE_SCALE, glr.viewaxis[1], dst_vert);
            VectorMA(dst_vert, -scale * PARTICLE_SCALE, glr.viewaxis[2], dst_vert);
            VectorMA(dst_vert, scale, glr.viewaxis[2], dst_vert + 5);
            VectorMA(dst_vert, -scale, glr.viewaxis[1], dst_vert + 10);
 
            dst_vert[ 3] = 0;               dst_vert[ 4] = 0;
            dst_vert[ 8] = 0;               dst_vert[ 9] = PARTICLE_SIZE;
            dst_vert[13] = PARTICLE_SIZE;   dst_vert[14] = 0;
 
            dst_color = (uint32_t *)tess.colors + numverts;
            dst_color[0] = color.u32;
            dst_color[1] = color.u32;
            dst_color[2] = color.u32;
 
            p++;
            numverts += 3;
        } while (--count);
 
        qglDrawArrays(GL_TRIANGLES, 0, numverts);
 
        if (gl_showtris->integer) {
            GL_EnableOutlines();
            qglDrawArrays(GL_TRIANGLES, 0, numverts);
            GL_DisableOutlines();
        }
    } while (total);
}

Referenced by R_RenderFrame_GL().

GL_DrawSolidFaces()

void GL_DrawSolidFaces

(

void

)

Definition at line 436 of file tess.c.

{
    int i;
 
    for (i = 0; i < FACE_HASH_SIZE; i++) {
        GL_DrawChain(&faces_head[i]);
    }
}

Referenced by GL_DrawWorld().

GL_Flush2D()

void GL_Flush2D

(

void

)

Definition at line 31 of file tess.c.

{
    glStateBits_t bits;
 
    if (!tess.numverts) {
        return;
    }
 
    bits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_FALSE | GLS_CULL_DISABLE;
    if (tess.flags & 2) {
        bits |= GLS_BLEND_BLEND;
    } else if (tess.flags & 1) {
        bits |= GLS_ALPHATEST_ENABLE;
    }
 
    Scrap_Upload();
 
    GL_BindTexture(0, tess.texnum[0]);
    GL_StateBits(bits);
    GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
 
    GL_VertexPointer(2, 4, tess.vertices);
    GL_TexCoordPointer(2, 4, tess.vertices + 2);
    GL_ColorBytePointer(4, 0, tess.colors);
 
    GL_LockArrays(tess.numverts);
 
    qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
 
    if (gl_showtris->integer > 1) {
        GL_EnableOutlines();
        qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
        GL_DisableOutlines();
    }
 
    GL_UnlockArrays();
 
    c.batchesDrawn2D++;
 
    tess.numindices = 0;
    tess.numverts = 0;
    tess.texnum[0] = 0;
    tess.flags = 0;
}

Referenced by _GL_StretchPic(), R_EndFrame_GL(), R_RenderFrame_GL(), R_SetClipRect_GL(), and R_SetScale_GL().

GL_Flush3D()

void GL_Flush3D

(

void

)

Definition at line 284 of file tess.c.

{
    glStateBits_t state = tess.flags;
    glArrayBits_t array = GLA_VERTEX | GLA_TC;
 
    if (!tess.numindices) {
        return;
    }
 
    if (q_likely(tess.texnum[1])) {
        state |= GLS_LIGHTMAP_ENABLE;
        array |= GLA_LMTC;
    }
 
    if (!(state & GLS_TEXTURE_REPLACE)) {
        array |= GLA_COLOR;
    }
 
    GL_StateBits(state);
    GL_ArrayBits(array);
 
    GL_BindTexture(0, tess.texnum[0]);
    if (q_likely(tess.texnum[1])) {
        GL_BindTexture(1, tess.texnum[1]);
    }
 
    if (gl_static.world.vertices) {
        GL_LockArrays(tess.numverts);
    }
 
    qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
 
    if (gl_showtris->integer) {
        GL_EnableOutlines();
        qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
        GL_DisableOutlines();
    }
 
    if (gl_static.world.vertices) {
        GL_UnlockArrays();
    }
 
    c.batchesDrawn++;
 
    tess.texnum[0] = tess.texnum[1] = 0;
    tess.numindices = 0;
    tess.numverts = 0;
    tess.flags = 0;
}

Referenced by GL_CopyVerts(), GL_DrawAlphaFaces(), GL_DrawBspModel(), GL_DrawFace(), and GL_DrawWorld().

GL_TextureAnimation()

static int GL_TextureAnimation ( mtexinfo_t *  tex )

static

Definition at line 352 of file tess.c.

{
    int c;
 
    if (q_unlikely(tex->next)) {
        c = glr.ent->frame % tex->numframes;
        while (c) {
            tex = tex->next;
            c--;
        }
    }
 
    return tex->image->texnum;
}

Referenced by GL_DrawFace().

Variable Documentation

faces_alpha

mface_t* faces_alpha

static

Definition at line 29 of file tess.c.

Referenced by GL_AddAlphaFace(), and GL_DrawAlphaFaces().

faces_head

mface_t* faces_head[FACE_HASH_SIZE]

static

Definition at line 27 of file tess.c.

Referenced by GL_ClearSolidFaces(), and GL_DrawSolidFaces().

faces_next

mface_t** faces_next[FACE_HASH_SIZE]

static

Definition at line 28 of file tess.c.

Referenced by GL_AddSolidFace(), and GL_ClearSolidFaces().

tess

tesselator_t tess

Definition at line 21 of file tess.c.

Referenced by _GL_StretchPic(), draw_alias_mesh(), GL_BindArrays(), GL_CopyVerts(), GL_DrawBeams(), GL_DrawFace(), GL_DrawParticles(), GL_Flush2D(), GL_Flush3D(), tess_lerped_plain(), tess_lerped_shade(), tess_lerped_shell(), tess_static_plain(), tess_static_shade(), tess_static_shell(), upload_surface_vbo(), and upload_world_surfaces().