src/mesa/vbo/vbo_save.h

   1 /**************************************************************************
   2
   3 Copyright 2002 VMware, Inc.
   4
   5 All Rights Reserved.
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a
   8 copy of this software and associated documentation files (the "Software"),
   9 to deal in the Software without restriction, including without limitation
  10 on the rights to use, copy, modify, merge, publish, distribute, sub
  11 license, and/or sell copies of the Software, and to permit persons to whom
  12 the Software is furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice (including the next
  15 paragraph) shall be included in all copies or substantial portions of the
  16 Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21 VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24 USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *   Keith Whitwell <keithw@vmware.com>
  31  *
  32  */
  33
  34 #ifndef VBO_SAVE_H
  35 #define VBO_SAVE_H
  36
  37 #include "main/mtypes.h"
  38 #include "vbo.h"
  39 #include "vbo_attrib.h"
  40
  41
  42 struct vbo_save_copied_vtx {
  43    fi_type buffer[VBO_ATTRIB_MAX * 4 * VBO_MAX_COPIED_VERTS];
  44    GLuint nr;
  45 };
  46
  47
  48 /* For display lists, this structure holds a run of vertices of the
  49  * same format, and a strictly well-formed set of begin/end pairs,
  50  * starting on the first vertex and ending at the last.  Vertex
  51  * copying on buffer breaks is precomputed according to these
  52  * primitives, though there are situations where the copying will need
  53  * correction at execute-time, perhaps by replaying the list as
  54  * immediate mode commands.
  55  *
  56  * On executing this list, the 'current' values may be updated with
  57  * the values of the final vertex, and often no fixup of the start of
  58  * the vertex list is required.
  59  *
  60  * Eval and other commands that don't fit into these vertex lists are
  61  * compiled using the fallback opcode mechanism provided by dlist.c.
  62  */
  63 struct vbo_save_vertex_list {
  64    GLbitfield64 enabled; /**< mask of enabled vbo arrays. */
  65    GLubyte attrsz[VBO_ATTRIB_MAX];
  66    GLenum16 attrtype[VBO_ATTRIB_MAX];
  67    GLuint vertex_size;  /**< size in GLfloats */
  68    struct gl_vertex_array_object *VAO[VP_MODE_MAX];
  69
  70    /* Copy of the final vertex from node->vertex_store->bufferobj.
  71     * Keep this in regular (non-VBO) memory to avoid repeated
  72     * map/unmap of the VBO when updating GL current data.
  73     */
  74    fi_type *current_data;
  75    GLuint current_size;
  76
  77    GLuint buffer_offset;        /**< in bytes */
  78    GLuint start_vertex;         /**< first vertex used by any primitive */
  79    GLuint vertex_count;         /**< number of vertices in this list */
  80    GLuint wrap_count;           /* number of copied vertices at start */
  81
  82    struct _mesa_prim *prims;
  83    GLuint prim_count;
  84
  85    struct vbo_save_vertex_store *vertex_store;
  86    struct vbo_save_primitive_store *prim_store;
  87 };
  88
  89
  90 /**
  91  * Is the vertex list's buffer offset an exact multiple of the
  92  * vertex size (in bytes)?  This is used to check for a vertex array /
  93  * drawing optimization.
  94  */
  95 static inline bool
  96 aligned_vertex_buffer_offset(const struct vbo_save_vertex_list *node)
  97 {
  98    unsigned vertex_size = node->vertex_size * sizeof(GLfloat); /* in bytes */
  99    return vertex_size != 0 && node->buffer_offset % vertex_size == 0;
 100 }
 101
 102
 103 /**
 104  * Return the stride in bytes of the display list node.
 105  */
 106 static inline GLsizei
 107 _vbo_save_get_stride(const struct vbo_save_vertex_list *node)
 108 {
 109    return node->VAO[0]->BufferBinding[0].Stride;
 110 }
 111
 112
 113 /**
 114  * Return the first referenced vertex index in the display list node.
 115  */
 116 static inline GLuint
 117 _vbo_save_get_min_index(const struct vbo_save_vertex_list *node)
 118 {
 119    assert(node->prim_count > 0);
 120    return node->prims[0].start;
 121 }
 122
 123
 124 /**
 125  * Return the last referenced vertex index in the display list node.
 126  */
 127 static inline GLuint
 128 _vbo_save_get_max_index(const struct vbo_save_vertex_list *node)
 129 {
 130    assert(node->prim_count > 0);
 131    const struct _mesa_prim *last_prim = &node->prims[node->prim_count - 1];
 132    return last_prim->start + last_prim->count - 1;
 133 }
 134
 135
 136 /**
 137  * Return the vertex count in the display list node.
 138  */
 139 static inline GLuint
 140 _vbo_save_get_vertex_count(const struct vbo_save_vertex_list *node)
 141 {
 142    assert(node->prim_count > 0);
 143    const struct _mesa_prim *first_prim = &node->prims[0];
 144    const struct _mesa_prim *last_prim = &node->prims[node->prim_count - 1];
 145    return last_prim->start - first_prim->start + last_prim->count;
 146 }
 147
 148
 149 /* These buffers should be a reasonable size to support upload to
 150  * hardware.  Current vbo implementation will re-upload on any
 151  * changes, so don't make too big or apps which dynamically create
 152  * dlists and use only a few times will suffer.
 153  *
 154  * Consider stategy of uploading regions from the VBO on demand in the
 155  * case of dynamic vbos.  Then make the dlist code signal that
 156  * likelyhood as it occurs.  No reason we couldn't change usage
 157  * internally even though this probably isn't allowed for client VBOs?
 158  */
 159 #define VBO_SAVE_BUFFER_SIZE (256*1024) /* dwords */
 160 #define VBO_SAVE_PRIM_SIZE   128
 161 #define VBO_SAVE_PRIM_MODE_MASK         0x3f
 162 #define VBO_SAVE_PRIM_WEAK              0x40
 163 #define VBO_SAVE_PRIM_NO_CURRENT_UPDATE 0x80
 164
 165 #define VBO_SAVE_FALLBACK    0x10000000
 166
 167 /* Storage to be shared among several vertex_lists.
 168  */
 169 struct vbo_save_vertex_store {
 170    struct gl_buffer_object *bufferobj;
 171    fi_type *buffer_map;
 172    GLuint used;           /**< Number of 4-byte words used in buffer */
 173    GLuint refcount;
 174 };
 175
 176 struct vbo_save_primitive_store {
 177    struct _mesa_prim prims[VBO_SAVE_PRIM_SIZE];
 178    GLuint used;
 179    GLuint refcount;
 180 };
 181
 182
 183 struct vbo_save_context {
 184    struct gl_context *ctx;
 185    GLvertexformat vtxfmt;
 186    GLvertexformat vtxfmt_noop;  /**< Used if out_of_memory is true */
 187
 188    GLbitfield64 enabled; /**< mask of enabled vbo arrays. */
 189    GLubyte attrsz[VBO_ATTRIB_MAX];  /**< 1, 2, 3 or 4 */
 190    GLenum16 attrtype[VBO_ATTRIB_MAX];  /**< GL_FLOAT, GL_INT, etc */
 191    GLubyte active_sz[VBO_ATTRIB_MAX];  /**< 1, 2, 3 or 4 */
 192    GLuint vertex_size;  /**< size in GLfloats */
 193    struct gl_vertex_array_object *VAO[VP_MODE_MAX];
 194
 195    GLboolean out_of_memory;  /**< True if last VBO allocation failed */
 196
 197    GLbitfield replay_flags;
 198
 199    struct _mesa_prim *prims;
 200    GLuint prim_count, prim_max;
 201
 202    struct vbo_save_vertex_store *vertex_store;
 203    struct vbo_save_primitive_store *prim_store;
 204
 205    fi_type *buffer_map;            /**< Mapping of vertex_store's buffer */
 206    fi_type *buffer_ptr;            /**< cursor, points into buffer_map */
 207    fi_type vertex[VBO_ATTRIB_MAX*4];       /* current values */
 208    fi_type *attrptr[VBO_ATTRIB_MAX];
 209    GLuint vert_count;
 210    GLuint max_vert;
 211    GLboolean dangling_attr_ref;
 212
 213    GLuint opcode_vertex_list;
 214
 215    struct vbo_save_copied_vtx copied;
 216
 217    fi_type *current[VBO_ATTRIB_MAX]; /* points into ctx->ListState */
 218    GLubyte *currentsz[VBO_ATTRIB_MAX];
 219 };
 220
 221 void vbo_save_init(struct gl_context *ctx);
 222 void vbo_save_destroy(struct gl_context *ctx);
 223 void vbo_save_fallback(struct gl_context *ctx, GLboolean fallback);
 224
 225 /* save_loopback.c:
 226  */
 227 void _vbo_loopback_vertex_list(struct gl_context *ctx,
 228                                const struct vbo_save_vertex_list* node);
 229
 230 /* Callbacks:
 231  */
 232 void
 233 vbo_save_playback_vertex_list(struct gl_context *ctx, void *data);
 234
 235 void
 236 vbo_save_api_init(struct vbo_save_context *save);
 237
 238 fi_type *
 239 vbo_save_map_vertex_store(struct gl_context *ctx,
 240                           struct vbo_save_vertex_store *vertex_store);
 241
 242 void
 243 vbo_save_unmap_vertex_store(struct gl_context *ctx,
 244                             struct vbo_save_vertex_store *vertex_store);
 245
 246 #endif /* VBO_SAVE_H */