r_array.cpp

Go to the documentation of this file.

/*
Copyright(c) 1997-2001 Id Software, Inc.
Copyright(c) 2002 The Quakeforge Project.
Copyright(c) 2006 Quake2World.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#include "r_local.h"

#define R_ARRAY_VERTEX          0x1
#define R_ARRAY_COLOR           0x2
#define R_ARRAY_NORMAL          0x4
#define R_ARRAY_TANGENT         0x8
#define R_ARRAY_TEX_DIFFUSE     0x10
#define R_ARRAY_TEX_LIGHTMAP    0x20
#define R_ARRAY_ELEMENT 0x1000

typedef struct r_array_state_s {
    const mBspModel_t* bspmodel;
    int arrays;
} r_array_state_t;

static r_array_state_t r_array_state;


static int R_ArraysMask (void)
{
    int mask;

    mask = R_ARRAY_VERTEX | R_ARRAY_ELEMENT;

    if (r_state.color_array_enabled)
        mask |= R_ARRAY_COLOR;

    if (r_state.lighting_enabled) {
        mask |= R_ARRAY_NORMAL;

        if (r_bumpmap->value > 0.0)
            mask |= R_ARRAY_TANGENT;
    }

    if (texunit_diffuse.enabled)
        mask |= R_ARRAY_TEX_DIFFUSE;

    if (texunit_lightmap.enabled)
        mask |= R_ARRAY_TEX_LIGHTMAP;

    return mask;
}

static inline void R_SetVertexArrayState (const mBspModel_t* bsp, int mask)
{
    /* vertex array */
    if (mask & R_ARRAY_VERTEX)
        R_BindArray(GL_VERTEX_ARRAY, GL_FLOAT, bsp->verts);

    /* normals and tangents for lighting */
    if (r_state.lighting_enabled) {
        if (mask & R_ARRAY_NORMAL)
            R_BindArray(GL_NORMAL_ARRAY, GL_FLOAT, bsp->normals);

        if (mask & R_ARRAY_TANGENT)
            R_BindArray(GL_TANGENT_ARRAY, GL_FLOAT, bsp->tangents);
    }

    /* diffuse texcoords */
    if (texunit_diffuse.enabled) {
        if (mask & R_ARRAY_TEX_DIFFUSE)
            R_BindArray(GL_TEXTURE_COORD_ARRAY, GL_FLOAT, bsp->texcoords);
    }

    if (texunit_lightmap.enabled) {  /* lightmap texcoords */
        if (mask & R_ARRAY_TEX_LIGHTMAP) {
            R_SelectTexture(&texunit_lightmap);
            R_BindArray(GL_TEXTURE_COORD_ARRAY, GL_FLOAT, bsp->lmtexcoords);
            R_SelectTexture(&texunit_diffuse);
        }
    }
}

static inline void R_SetVertexBufferState (const mBspModel_t* bsp, int mask)
{
    /* vertex array */
    if (mask & R_ARRAY_VERTEX)
        R_BindBuffer(GL_VERTEX_ARRAY, GL_FLOAT, bsp->vertex_buffer);

    /* index array */
    if (mask & R_ARRAY_ELEMENT)
        R_BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0, bsp->index_buffer);
        /* R_BindBuffer ignores the type parameter for GL_ELEMENT_ARRAY_BUFFER, and GL_INT is not defined in GLES */

    if (r_state.lighting_enabled) { /* normals and tangents for lighting */
        if (mask & R_ARRAY_NORMAL)
            R_BindBuffer(GL_NORMAL_ARRAY, GL_FLOAT, bsp->normal_buffer);

        if (mask & R_ARRAY_TANGENT)
            R_BindBuffer(GL_TANGENT_ARRAY, GL_FLOAT, bsp->tangent_buffer);
    }

    /* diffuse texcoords */
    if (texunit_diffuse.enabled) {
        if (mask & R_ARRAY_TEX_DIFFUSE)
            R_BindBuffer(GL_TEXTURE_COORD_ARRAY, GL_FLOAT, bsp->texcoord_buffer);
    }

    /* lightmap texcoords */
    if (texunit_lightmap.enabled) {
        if (mask & R_ARRAY_TEX_LIGHTMAP) {
            R_SelectTexture(&texunit_lightmap);
            R_BindBuffer(GL_TEXTURE_COORD_ARRAY, GL_FLOAT, bsp->lmtexcoord_buffer);
            R_SelectTexture(&texunit_diffuse);
        }
    }
}

void R_SetArrayState (const mBspModel_t* bsp)
{
    int arrays, mask;

    if (r_vertexbuffers->modified) {  /* force a full re-bind */
        r_array_state.bspmodel = nullptr;
        r_array_state.arrays = 0xFFFF;
        r_vertexbuffers->modified = false;
    }

    /* resolve the desired arrays mask */
    mask = 0xFFFF, arrays = R_ArraysMask();

    /* try to save some binds */
    if (r_array_state.bspmodel == bsp) {
        const int xorR = r_array_state.arrays ^ arrays;
        if (!xorR)  /* no changes, we're done */
            return;

        /* resolve what's left to turn on */
        mask = arrays & xorR;
    }

    if (r_vertexbuffers->integer && qglGenBuffers)  /* use vbo */
        R_SetVertexBufferState(bsp, mask);
    else  /* or arrays */
        R_SetVertexArrayState(bsp, mask);

    r_array_state.bspmodel = bsp;
    r_array_state.arrays = arrays;
}

void R_ResetArrayState (void)
{
    r_array_state.bspmodel = nullptr;
    r_array_state.arrays = 0;

    /* vbo */
    R_BindBuffer(0, 0, 0);
    if (qglBindBuffer && r_vertexbuffers->integer)
        qglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 
    /* vertex array */
    R_BindDefaultArray(GL_VERTEX_ARRAY);

    /* color array */
    if (r_state.color_array_enabled)
        R_BindDefaultArray(GL_COLOR_ARRAY);

    /* normals and tangents */
    if (r_state.lighting_enabled) {
        R_BindDefaultArray(GL_NORMAL_ARRAY);

        R_BindDefaultArray(GL_TANGENT_ARRAY);
    }

    /* diffuse texcoords */
    if (texunit_diffuse.enabled)
        R_BindDefaultArray(GL_TEXTURE_COORD_ARRAY);

    /* lightmap texcoords */
    if (texunit_lightmap.enabled) {
        R_SelectTexture(&texunit_lightmap);
        R_BindDefaultArray(GL_TEXTURE_COORD_ARRAY);
        R_SelectTexture(&texunit_diffuse);
    }
}