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