vbo_private.h 6.19 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*
 * mesa 3-D graphics library
 *
 * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */


/**
 * Types, functions, etc which are private to the VBO module.
 */


#ifndef VBO_PRIVATE_H
#define VBO_PRIVATE_H


35
36
37
#include "vbo/vbo_attrib.h"
#include "vbo/vbo_exec.h"
#include "vbo/vbo_save.h"
38
#include "main/varray.h"
39
40
41
42
43
44


struct _glapi_table;
struct _mesa_prim;


45
struct vbo_context {
46
47
   struct gl_vertex_buffer_binding binding;
   struct gl_array_attributes current[VBO_ATTRIB_MAX];
48

49
50
   struct gl_vertex_array_object *VAO;

51
52
53
54
   struct vbo_exec_context exec;
   struct vbo_save_context save;
};

55
56
57
58
59
60
61
62

static inline struct vbo_context *
vbo_context(struct gl_context *ctx)
{
   return ctx->vbo_context;
}


63
64
65
66
67
68
69
static inline const struct vbo_context *
vbo_context_const(const struct gl_context *ctx)
{
   return ctx->vbo_context;
}


70
71
72
73
74
75
76
77
78
/**
 * Array to apply the fixed function material aliasing map to
 * an attribute value used in vbo processing inputs to an attribute
 * as they appear in the vao.
 */
extern const GLubyte
_vbo_attribute_alias_map[VP_MODE_MAX][VERT_ATTRIB_MAX];


79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/**
 * Return if format is integer. The immediate mode commands only emit floats
 * for non-integer types, thus everything else is integer.
 */
static inline GLboolean
vbo_attrtype_to_integer_flag(GLenum format)
{
   switch (format) {
   case GL_FLOAT:
   case GL_DOUBLE:
      return GL_FALSE;
   case GL_INT:
   case GL_UNSIGNED_INT:
   case GL_UNSIGNED_INT64_ARB:
      return GL_TRUE;
   default:
      unreachable("Bad vertex attribute type");
      return GL_FALSE;
   }
}

static inline GLboolean
vbo_attrtype_to_double_flag(GLenum format)
{
   switch (format) {
   case GL_FLOAT:
   case GL_INT:
   case GL_UNSIGNED_INT:
      return GL_FALSE;
108
   case GL_UNSIGNED_INT64_ARB:
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
   case GL_DOUBLE:
      return GL_TRUE;
   default:
      unreachable("Bad vertex attribute type");
      return GL_FALSE;
   }
}


/**
 * Return default component values for the given format.
 * The return type is an array of fi_types, because that's how we declare
 * the vertex storage : floats , integers or unsigned integers.
 */
static inline const fi_type *
vbo_get_default_vals_as_union(GLenum format)
{
   static const GLfloat default_float[4] = { 0, 0, 0, 1 };
   static const GLint default_int[4] = { 0, 0, 0, 1 };

   switch (format) {
   case GL_FLOAT:
      return (fi_type *)default_float;
   case GL_INT:
   case GL_UNSIGNED_INT:
      return (fi_type *)default_int;
   default:
      unreachable("Bad vertex format");
      return NULL;
   }
}


/**
 * Compute the max number of vertices which can be stored in
 * a vertex buffer, given the current vertex size, and the amount
 * of space already used.
 */
static inline unsigned
vbo_compute_max_verts(const struct vbo_exec_context *exec)
{
   unsigned n = (VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) /
      (exec->vtx.vertex_size * sizeof(GLfloat));
   if (n == 0)
      return 0;
   /* Subtract one so we're always sure to have room for an extra
    * vertex for GL_LINE_LOOP -> GL_LINE_STRIP conversion.
    */
   n--;
   return n;
}


void
vbo_try_prim_conversion(struct _mesa_prim *p);

bool
vbo_can_merge_prims(const struct _mesa_prim *p0, const struct _mesa_prim *p1);

void
vbo_merge_prims(struct _mesa_prim *p0, const struct _mesa_prim *p1);


172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
/**
 * Get the filter mask for vbo draws depending on the vertex_processing_mode.
 */
static inline GLbitfield
_vbo_get_vao_filter(gl_vertex_processing_mode vertex_processing_mode)
{
   if (vertex_processing_mode == VP_MODE_FF) {
      /* The materials mapped into the generic arrays */
      return VERT_BIT_FF_ALL | VERT_BIT_MAT_ALL;
   } else {
      return VERT_BIT_ALL;
   }
}


/**
 * Translate the bitmask of VBO_ATTRIB_BITs to VERT_ATTRIB_BITS.
 * Note that position/generic0 attribute aliasing is done
 * generically in the VAO.
 */
static inline GLbitfield
_vbo_get_vao_enabled_from_vbo(gl_vertex_processing_mode vertex_processing_mode,
                              GLbitfield64 enabled)
{
   if (vertex_processing_mode == VP_MODE_FF) {
      /* The materials mapped into the generic arrays */
      return (((GLbitfield)enabled) & VERT_BIT_FF_ALL)
         | (((GLbitfield)(enabled >> VBO_MATERIAL_SHIFT)) & VERT_BIT_MAT_ALL);
   } else {
      return ((GLbitfield)enabled) & VERT_BIT_ALL;
   }
}


/**
 * Set the vertex attrib for vbo draw use.
 */
static inline void
_vbo_set_attrib_format(struct gl_context *ctx,
                       struct gl_vertex_array_object *vao,
                       gl_vert_attrib attr, GLintptr buffer_offset,
                       GLubyte size, GLenum16 type, GLuint offset)
{
   const GLboolean integer = vbo_attrtype_to_integer_flag(type);
   const GLboolean doubles = vbo_attrtype_to_double_flag(type);
   _mesa_update_array_format(ctx, vao, attr, size, type, GL_RGBA,
                             GL_FALSE, integer, doubles, offset);
219
220
221
222
223
224
   /* Ptr for userspace arrays.
    * For updating the pointer we would need to add the vao->NewArrays flag
    * to the VAO. But but that is done already unconditionally in
    * _mesa_update_array_format called above.
    */
   assert((vao->NewArrays | ~vao->_Enabled) & VERT_BIT(attr));
225
226
227
228
   vao->VertexAttrib[attr].Ptr = ADD_POINTERS(buffer_offset, offset);
}


229
#endif /* VBO_PRIVATE_H */