Home | History | Annotate | Download | only in vbo 
      1 /*
      2  * mesa 3-D graphics library
      3  *
      4  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the "Software"),
      8  * to deal in the Software without restriction, including without limitation
      9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     10  * and/or sell copies of the Software, and to permit persons to whom the
     11  * Software is furnished to do so, subject to the following conditions:
     12  *
     13  * The above copyright notice and this permission notice shall be included
     14  * in all copies or substantial portions of the Software.
     15  *
     16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
     20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
     21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     22  * OTHER DEALINGS IN THE SOFTWARE.
     23  */
     24 
     25 /**
     26  * \file vbo_context.h
     27  * \brief VBO builder module datatypes and definitions.
     28  * \author Keith Whitwell
     29  */
     30 
     31 
     32 /**
     33  * \mainpage The VBO builder module
     34  *
     35  * This module hooks into the GL dispatch table and catches all vertex
     36  * building and drawing commands, such as glVertex3f, glBegin and
     37  * glDrawArrays.  The module stores all incoming vertex data as arrays
     38  * in GL vertex buffer objects (VBOs), and translates all drawing
     39  * commands into calls to a driver supplied DrawPrimitives() callback.
     40  *
     41  * The module captures both immediate mode and display list drawing,
     42  * and manages the allocation, reference counting and deallocation of
     43  * vertex buffer objects itself.
     44  *
     45  * The DrawPrimitives() callback can be either implemented by the
     46  * driver itself or hooked to the tnl module's _tnl_draw_primitives()
     47  * function for hardware without tnl capablilties or during fallbacks.
     48  */
     49 
     50 
     51 #ifndef _VBO_CONTEXT_H
     52 #define _VBO_CONTEXT_H
     53 
     54 #include "vbo.h"
     55 #include "vbo_attrib.h"
     56 #include "vbo_exec.h"
     57 #include "vbo_save.h"
     58 
     59 #include "main/api_arrayelt.h"
     60 #include "main/macros.h"
     61 
     62 #ifdef __cplusplus
     63 extern "C" {
     64 #endif
     65 
     66 struct vbo_context {
     67    struct gl_vertex_array currval[VBO_ATTRIB_MAX];
     68 
     69    /** Map VERT_ATTRIB_x to VBO_ATTRIB_y */
     70    GLubyte map_vp_none[VERT_ATTRIB_MAX];
     71    GLubyte map_vp_arb[VERT_ATTRIB_MAX];
     72 
     73    struct vbo_exec_context exec;
     74    struct vbo_save_context save;
     75 
     76    /* Callback into the driver.  This must always succeed, the driver
     77     * is responsible for initiating any fallback actions required:
     78     */
     79    vbo_draw_func draw_prims;
     80 
     81    /* Optional callback for indirect draws. This allows multidraws to not be
     82     * broken up, as well as for the actual count to be passed in as a separate
     83     * indirect parameter.
     84     */
     85    vbo_indirect_draw_func draw_indirect_prims;
     86 };
     87 
     88 
     89 static inline struct vbo_context *vbo_context(struct gl_context *ctx)
     90 {
     91    return ctx->vbo_context;
     92 }
     93 
     94 
     95 static inline void
     96 vbo_exec_invalidate_state(struct gl_context *ctx)
     97 {
     98    struct vbo_context *vbo = vbo_context(ctx);
     99    struct vbo_exec_context *exec = &vbo->exec;
    100 
    101    if (ctx->NewState & (_NEW_PROGRAM | _NEW_ARRAY)) {
    102       if (!exec->validating)
    103          exec->array.recalculate_inputs = GL_TRUE;
    104 
    105       _ae_invalidate_state(ctx);
    106    }
    107 
    108    if (ctx->NewState & _NEW_EVAL)
    109       exec->eval.recalculate_maps = GL_TRUE;
    110 }
    111 
    112 
    113 /**
    114  * Return VP_x token to indicate whether we're running fixed-function
    115  * vertex transformation, an NV vertex program or ARB vertex program/shader.
    116  */
    117 static inline enum vp_mode
    118 get_program_mode( struct gl_context *ctx )
    119 {
    120    if (!ctx->VertexProgram._Current)
    121       return VP_NONE;
    122    else if (ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram)
    123       return VP_NONE;
    124    else
    125       return VP_ARB;
    126 }
    127 
    128 
    129 /**
    130  * This is called by glBegin, glDrawArrays and glDrawElements (and
    131  * variations of those calls).  When we transition from immediate mode
    132  * drawing to array drawing we need to invalidate the array state.
    133  *
    134  * glBegin/End builds vertex arrays.  Those arrays may look identical
    135  * to glDrawArrays arrays except that the position of the elements may
    136  * be different.  For example, arrays of (position3v, normal3f) vs. arrays
    137  * of (normal3f, position3f).  So we need to make sure we notify drivers
    138  * that arrays may be changing.
    139  */
    140 static inline void
    141 vbo_draw_method(struct vbo_context *vbo, gl_draw_method method)
    142 {
    143    struct gl_context *ctx = vbo->exec.ctx;
    144 
    145    if (ctx->Array.DrawMethod != method) {
    146       switch (method) {
    147       case DRAW_ARRAYS:
    148          ctx->Array._DrawArrays = vbo->exec.array.inputs;
    149          break;
    150       case DRAW_BEGIN_END:
    151          ctx->Array._DrawArrays = vbo->exec.vtx.inputs;
    152          break;
    153       case DRAW_DISPLAY_LIST:
    154          ctx->Array._DrawArrays = vbo->save.inputs;
    155          break;
    156       default:
    157          assert(0);
    158       }
    159 
    160       ctx->NewDriverState |= ctx->DriverFlags.NewArray;
    161       ctx->Array.DrawMethod = method;
    162    }
    163 }
    164 
    165 /**
    166  * Return if format is integer. The immediate mode commands only emit floats
    167  * for non-integer types, thus everything else is integer.
    168  */
    169 static inline GLboolean
    170 vbo_attrtype_to_integer_flag(GLenum format)
    171 {
    172    switch (format) {
    173    case GL_FLOAT:
    174    case GL_DOUBLE:
    175       return GL_FALSE;
    176    case GL_INT:
    177    case GL_UNSIGNED_INT:
    178    case GL_UNSIGNED_INT64_ARB:
    179       return GL_TRUE;
    180    default:
    181       assert(0);
    182       return GL_FALSE;
    183    }
    184 }
    185 
    186 static inline GLboolean
    187 vbo_attrtype_to_double_flag(GLenum format)
    188 {
    189    switch (format) {
    190    case GL_FLOAT:
    191    case GL_INT:
    192    case GL_UNSIGNED_INT:
    193    case GL_UNSIGNED_INT64_ARB:
    194       return GL_FALSE;
    195    case GL_DOUBLE:
    196       return GL_TRUE;
    197    default:
    198       assert(0);
    199       return GL_FALSE;
    200    }
    201 }
    202 
    203 /**
    204  * Return default component values for the given format.
    205  * The return type is an array of fi_types, because that's how we declare
    206  * the vertex storage : floats , integers or unsigned integers.
    207  */
    208 static inline const fi_type *
    209 vbo_get_default_vals_as_union(GLenum format)
    210 {
    211    static const GLfloat default_float[4] = { 0, 0, 0, 1 };
    212    static const GLint default_int[4] = { 0, 0, 0, 1 };
    213 
    214    switch (format) {
    215    case GL_FLOAT:
    216       return (fi_type *)default_float;
    217    case GL_INT:
    218    case GL_UNSIGNED_INT:
    219       return (fi_type *)default_int;
    220    default:
    221       assert(0);
    222       return NULL;
    223    }
    224 }
    225 
    226 
    227 /**
    228  * Compute the max number of vertices which can be stored in
    229  * a vertex buffer, given the current vertex size, and the amount
    230  * of space already used.
    231  */
    232 static inline unsigned
    233 vbo_compute_max_verts(const struct vbo_exec_context *exec)
    234 {
    235    unsigned n = (VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) /
    236       (exec->vtx.vertex_size * sizeof(GLfloat));
    237    if (n == 0)
    238       return 0;
    239    /* Subtract one so we're always sure to have room for an extra
    240     * vertex for GL_LINE_LOOP -> GL_LINE_STRIP conversion.
    241     */
    242    n--;
    243    return n;
    244 }
    245 
    246 
    247 #ifdef __cplusplus
    248 } // extern "C"
    249 #endif
    250 
    251 #endif
    252