src/glx/indirect_vertex_array_priv.h

   1 /*
   2  * (C) Copyright IBM Corporation 2004, 2005
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19  * IBM,
  20  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  22  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #ifndef _INDIRECT_VA_PRIVATE_
  27 #define _INDIRECT_VA_PRIVATE_
  28
  29 /**
  30  * \file indirect_va_private.h
  31  *
  32  * \author Ian Romanick <idr@us.ibm.com>
  33  */
  34
  35 #include <inttypes.h>
  36
  37 #include "glxclient.h"
  38 #include "indirect.h"
  39 #include <GL/glxproto.h>
  40
  41
  42 /**
  43  * State descriptor for a single array of vertex data.
  44  */
  45 struct array_state
  46 {
  47     /**
  48      * Pointer to the application supplied data.
  49      */
  50    const void *data;
  51
  52     /**
  53      * Enum representing the type of the application supplied data.
  54      */
  55    GLenum data_type;
  56
  57     /**
  58      * Stride value supplied by the application.  This value is not used
  59      * internally.  It is only kept so that it can be queried by the
  60      * application using glGet*v.
  61      */
  62    GLsizei user_stride;
  63
  64     /**
  65      * Calculated size, in bytes, of a single element in the array.  This
  66      * is calculated based on \c count and the size of the data type
  67      * represented by \c data_type.
  68      */
  69    GLsizei element_size;
  70
  71     /**
  72      * Actual byte-stride from one element to the next.  This value will
  73      * be equal to either \c user_stride or \c element_stride.
  74      */
  75    GLsizei true_stride;
  76
  77     /**
  78      * Number of data values in each element.
  79      */
  80    GLint count;
  81
  82     /**
  83      * "Normalized" data is on the range [0,1] (unsigned) or [-1,1] (signed).
  84      * This is used for mapping integral types to floating point types.
  85      */
  86    GLboolean normalized;
  87
  88     /**
  89      * Pre-calculated GLX protocol command header.
  90      */
  91    uint32_t header[2];
  92
  93     /**
  94      * Size of the header data.  For simple data, like glColorPointerfv,
  95      * this is 4.  For complex data that requires either a count (e.g.,
  96      * glWeightfvARB), an index (e.g., glVertexAttrib1fvARB), or a
  97      * selector enum (e.g., glMultiTexCoord2fv) this is 8.
  98      */
  99    unsigned header_size;
 100
 101     /**
 102      * Set to \c GL_TRUE if this array is enabled.  Otherwise, it is set
 103      * to \c GL_FALSE.
 104      */
 105    GLboolean enabled;
 106
 107     /**
 108      * For multi-arrayed data (e.g., texture coordinates, generic vertex
 109      * program attributes, etc.), this specifies which array this is.
 110      */
 111    unsigned index;
 112
 113     /**
 114      * Per-array-type key.  For most arrays, this will be the GL enum for
 115      * that array (e.g., GL_VERTEX_ARRAY for vertex data, GL_NORMAL_ARRAY
 116      * for normal data, GL_TEXTURE_COORD_ARRAY for texture coordinate data,
 117      * etc.).
 118      */
 119    GLenum key;
 120
 121     /**
 122      * If this array can be used with the "classic" \c glDrawArrays protocol,
 123      * this is set to \c GL_TRUE.  Otherwise, it is set to \c GL_FALSE.
 124      */
 125    GLboolean old_DrawArrays_possible;
 126 };
 127
 128
 129 /**
 130  * Array state that is pushed / poped by \c glPushClientAttrib and
 131  * \c glPopClientAttrib.
 132  */
 133 struct array_stack_state
 134 {
 135     /**
 136      * Pointer to the application supplied data.
 137      */
 138    const void *data;
 139
 140     /**
 141      * Enum representing the type of the application supplied data.
 142      */
 143    GLenum data_type;
 144
 145     /**
 146      * Stride value supplied by the application.  This value is not used
 147      * internally.  It is only kept so that it can be queried by the
 148      * application using glGet*v.
 149      */
 150    GLsizei user_stride;
 151
 152     /**
 153      * Number of data values in each element.
 154      */
 155    GLint count;
 156
 157     /**
 158      * Per-array-type key.  For most arrays, this will be the GL enum for
 159      * that array (e.g., GL_VERTEX_ARRAY for vertex data, GL_NORMAL_ARRAY
 160      * for normal data, GL_TEXTURE_COORD_ARRAY for texture coordinate data,
 161      * etc.).
 162      */
 163    GLenum key;
 164
 165     /**
 166      * For multi-arrayed data (e.g., texture coordinates, generic vertex
 167      * program attributes, etc.), this specifies which array this is.
 168      */
 169    unsigned index;
 170
 171     /**
 172      * Set to \c GL_TRUE if this array is enabled.  Otherwise, it is set
 173      * to \c GL_FALSE.
 174      */
 175    GLboolean enabled;
 176 };
 177
 178
 179 /**
 180  * Collection of all the vertex array state.
 181  */
 182 struct array_state_vector
 183 {
 184     /**
 185      * Number of arrays tracked by \c ::arrays.
 186      */
 187    size_t num_arrays;
 188
 189     /**
 190      * Array of vertex array state.  This array contains all of the valid
 191      * vertex arrays.  If a vertex array isn't in this array, then it isn't
 192      * valid.  For example, if an implementation does not support
 193      * EXT_fog_coord, there won't be a GL_FOG_COORD_ARRAY entry in this
 194      * array.
 195      */
 196    struct array_state *arrays;
 197
 198     /**
 199      * Number of currently enabled client-side arrays.  The value of this
 200      * field is only valid if \c array_info_cache_valid is true.
 201      */
 202    size_t enabled_client_array_count;
 203
 204     /**
 205      * \name ARRAY_INFO cache.
 206      *
 207      * These fields track the state of the ARRAY_INFO cache.  The
 208      * \c array_info_cache_size is the size of the actual data stored in
 209      * \c array_info_cache.  \c array_info_cache_buffer_size is the size of
 210      * the buffer.  This will always be greater than or equal to
 211      * \c array_info_cache_size.
 212      *
 213      * \note
 214      * There are some bytes of extra data before \c array_info_cache that is
 215      * used to hold the header for RenderLarge commands.  This is
 216      * \b not included in \c array_info_cache_size or
 217      * \c array_info_cache_buffer_size.  \c array_info_cache_base stores a
 218      * pointer to the true start of the buffer (i.e., what malloc returned).
 219      */
 220    /*@{ */
 221    size_t array_info_cache_size;
 222    size_t array_info_cache_buffer_size;
 223    void *array_info_cache;
 224    void *array_info_cache_base;
 225    /*@} */
 226
 227
 228     /**
 229      * Is the cache of ARRAY_INFO data valid?  The cache can become invalid
 230      * when one of several state changes occur.  Among these chages are
 231      * modifying the array settings for an enabled array and enabling /
 232      * disabling an array.
 233      */
 234    GLboolean array_info_cache_valid;
 235
 236     /**
 237      * Is it possible to use the GL 1.1 / EXT_vertex_arrays protocol?  Use
 238      * of this protocol is disabled with really old servers (i.e., servers
 239      * that don't support GL 1.1 or EXT_vertex_arrays) or when an environment
 240      * variable is set.
 241      *
 242      * \todo
 243      * GL 1.1 and EXT_vertex_arrays use identical protocol, but have different
 244      * opcodes for \c glDrawArrays.  For servers that advertise one or the
 245      * other, there should be a way to select which opcode to use.
 246      */
 247    GLboolean old_DrawArrays_possible;
 248
 249     /**
 250      * Is it possible to use the new GL X.X / ARB_vertex_buffer_object
 251      * protocol?
 252      *
 253      * \todo
 254      * This protocol has not yet been defined by the ARB, but is currently a
 255      * work in progress.  This field is a place-holder.
 256      */
 257    GLboolean new_DrawArrays_possible;
 258
 259     /**
 260      * Active texture unit set by \c glClientActiveTexture.
 261      *
 262      * \sa __glXGetActiveTextureUnit
 263      */
 264    unsigned active_texture_unit;
 265
 266     /**
 267      * Number of supported texture units.  Even if ARB_multitexture /
 268      * GL 1.3 are not supported, this will be at least 1.  When multitexture
 269      * is supported, this will be the value queried by calling
 270      * \c glGetIntegerv with \c GL_MAX_TEXTURE_UNITS.
 271      *
 272      * \todo
 273      * Investigate if this should be the value of \c GL_MAX_TEXTURE_COORDS
 274      * instead (if GL 2.0 / ARB_fragment_shader / ARB_fragment_program /
 275      * NV_fragment_program are supported).
 276      */
 277    unsigned num_texture_units;
 278
 279     /**
 280      * Number of generic vertex program attribs.  If GL_ARB_vertex_program
 281      * is not supported, this will be zero.  Otherwise it will be the value
 282      * queries by calling \c glGetProgramiv with \c GL_VERTEX_PROGRAM_ARB
 283      * and \c GL_MAX_PROGRAM_ATTRIBS_ARB.
 284      */
 285    unsigned num_vertex_program_attribs;
 286
 287     /**
 288      * \n Methods for implementing various GL functions.
 289      *
 290      * These method pointers are only valid \c array_info_cache_valid is set.
 291      * When each function starts, it much check \c array_info_cache_valid.
 292      * If it is not set, it must call \c fill_array_info_cache and call
 293      * the new method.
 294      *
 295      * \sa fill_array_info_cache
 296      *
 297      * \todo
 298      * Write code to plug these functions directly into the dispatch table.
 299      */
 300    /*@{ */
 301    void (*DrawArrays) (GLenum, GLint, GLsizei);
 302    void (*DrawElements) (GLenum mode, GLsizei count, GLenum type,
 303                          const GLvoid * indices);
 304    /*@} */
 305
 306    struct array_stack_state *stack;
 307    unsigned active_texture_unit_stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
 308    unsigned stack_index;
 309 };
 310
 311 #endif /* _INDIRECT_VA_PRIVATE_ */