1/*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
5 * (C) Copyright IBM Corporation 2006
6 * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
24 * OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27#ifndef ARRAYOBJ_H
28#define ARRAYOBJ_H
29
30#include "glheader.h"
31#include "mtypes.h"
32#include "glformats.h"
33#include "vbo/vbo.h"
34
35struct gl_context;
36
37/**
38 * \file arrayobj.h
39 * Functions for the GL_ARB_vertex_array_object extension.
40 *
41 * \author Ian Romanick <idr@us.ibm.com>
42 * \author Brian Paul
43 */
44
45/*
46 * Internal functions
47 */
48
49extern struct gl_vertex_array_object *
50_mesa_lookup_vao(struct gl_context *ctx, GLuint id);
51
52extern struct gl_vertex_array_object *
53_mesa_lookup_vao_err(struct gl_context *ctx, GLuint id, const char *caller);
54
55extern struct gl_vertex_array_object *
56_mesa_new_vao(struct gl_context *ctx, GLuint name);
57
58extern void
59_mesa_delete_vao(struct gl_context *ctx, struct gl_vertex_array_object *obj);
60
61extern void
62_mesa_reference_vao_(struct gl_context *ctx,
63                     struct gl_vertex_array_object **ptr,
64                     struct gl_vertex_array_object *vao);
65
66static inline void
67_mesa_reference_vao(struct gl_context *ctx,
68                    struct gl_vertex_array_object **ptr,
69                    struct gl_vertex_array_object *vao)
70{
71   if (*ptr != vao)
72      _mesa_reference_vao_(ctx, ptr, vao);
73}
74
75
76extern void
77_mesa_initialize_vao(struct gl_context *ctx,
78                     struct gl_vertex_array_object *obj, GLuint name);
79
80
81extern void
82_mesa_update_vao_derived_arrays(struct gl_context *ctx,
83                                struct gl_vertex_array_object *vao);
84
85
86/**
87 * Mark the vao as shared and immutable, do remaining updates.
88 */
89extern void
90_mesa_set_vao_immutable(struct gl_context *ctx,
91                        struct gl_vertex_array_object *vao);
92
93
94/* Returns true if all varying arrays reside in vbos */
95extern bool
96_mesa_all_varyings_in_vbos(const struct gl_vertex_array_object *vao);
97
98/* Returns true if all vbos are unmapped */
99extern bool
100_mesa_all_buffers_are_unmapped(const struct gl_vertex_array_object *vao);
101
102
103extern void
104_mesa_vao_map_arrays(struct gl_context *ctx, struct gl_vertex_array_object *vao,
105                     GLbitfield access);
106
107extern void
108_mesa_vao_map(struct gl_context *ctx, struct gl_vertex_array_object *vao,
109              GLbitfield access);
110
111
112extern void
113_mesa_vao_unmap_arrays(struct gl_context *ctx,
114                       struct gl_vertex_array_object *vao);
115
116extern void
117_mesa_vao_unmap(struct gl_context *ctx,
118                struct gl_vertex_array_object *vao);
119
120
121/**
122 * Array to apply the position/generic0 aliasing map to
123 * an attribute value used in vertex processing inputs to an attribute
124 * as they appear in the vao.
125 */
126extern const GLubyte
127_mesa_vao_attribute_map[ATTRIBUTE_MAP_MODE_MAX][VERT_ATTRIB_MAX];
128
129
130/**
131 * Apply the position/generic0 aliasing map to a bitfield from the vao.
132 * Use for example to convert gl_vertex_array_object::Enabled
133 * or gl_vertex_buffer_binding::_VertexBinding from the vao numbering to
134 * the numbering used with vertex processing inputs.
135 */
136static inline GLbitfield
137_mesa_vao_enable_to_vp_inputs(gl_attribute_map_mode mode, GLbitfield enabled)
138{
139   switch (mode) {
140   case ATTRIBUTE_MAP_MODE_IDENTITY:
141      return enabled;
142   case ATTRIBUTE_MAP_MODE_POSITION:
143      /* Copy VERT_ATTRIB_POS enable bit into GENERIC0 position */
144      return (enabled & ~VERT_BIT_GENERIC0)
145         | ((enabled & VERT_BIT_POS) << VERT_ATTRIB_GENERIC0);
146   case ATTRIBUTE_MAP_MODE_GENERIC0:
147      /* Copy VERT_ATTRIB_GENERIC0 enable bit into POS position */
148      return (enabled & ~VERT_BIT_POS)
149         | ((enabled & VERT_BIT_GENERIC0) >> VERT_ATTRIB_GENERIC0);
150   default:
151      return 0;
152   }
153}
154
155
156/**
157 * Return the vp_inputs enabled bitmask after application of
158 * the position/generic0 aliasing map.
159 */
160static inline GLbitfield
161_mesa_get_vao_vp_inputs(const struct gl_vertex_array_object *vao)
162{
163   const gl_attribute_map_mode mode = vao->_AttributeMapMode;
164   return _mesa_vao_enable_to_vp_inputs(mode, vao->Enabled);
165}
166
167
168/**
169 * Helper functions for consuming backends to walk the
170 * ctx->Array._DrawVAO for driver side array setup.
171 * Note that mesa provides preprocessed minimal binding information
172 * in the VAO. See _mesa_update_vao_derived_arrays for documentation.
173 */
174
175/**
176 * Return enabled vertex attribute bits for draw.
177 */
178static inline GLbitfield
179_mesa_draw_array_bits(const struct gl_context *ctx)
180{
181   return ctx->Array._DrawVAOEnabledAttribs;
182}
183
184
185/**
186 * Return enabled buffer object vertex attribute bits for draw.
187 *
188 * Needs the a fully updated VAO ready for draw.
189 */
190static inline GLbitfield
191_mesa_draw_vbo_array_bits(const struct gl_context *ctx)
192{
193   const struct gl_vertex_array_object *const vao = ctx->Array._DrawVAO;
194   assert(vao->NewArrays == 0);
195   return vao->_EffEnabledVBO & ctx->Array._DrawVAOEnabledAttribs;
196}
197
198
199/**
200 * Return enabled user space vertex attribute bits for draw.
201 *
202 * Needs the a fully updated VAO ready for draw.
203 */
204static inline GLbitfield
205_mesa_draw_user_array_bits(const struct gl_context *ctx)
206{
207   const struct gl_vertex_array_object *const vao = ctx->Array._DrawVAO;
208   assert(vao->NewArrays == 0);
209   return ~vao->_EffEnabledVBO & ctx->Array._DrawVAOEnabledAttribs;
210}
211
212
213/**
214 * Return enabled current values attribute bits for draw.
215 */
216static inline GLbitfield
217_mesa_draw_current_bits(const struct gl_context *ctx)
218{
219   return ~ctx->Array._DrawVAOEnabledAttribs & VERT_BIT_ALL;
220}
221
222
223/**
224 * Return vertex buffer binding provided the attribute struct.
225 *
226 * Needs the a fully updated VAO ready for draw.
227 */
228static inline const struct gl_vertex_buffer_binding*
229_mesa_draw_buffer_binding_from_attrib(const struct gl_vertex_array_object *vao,
230                                      const struct gl_array_attributes *attrib)
231{
232   assert(vao->NewArrays == 0);
233   return &vao->BufferBinding[attrib->_EffBufferBindingIndex];
234}
235
236
237/**
238 * Return vertex array attribute provided the attribute number.
239 */
240static inline const struct gl_array_attributes*
241_mesa_draw_array_attrib(const struct gl_vertex_array_object *vao,
242                        gl_vert_attrib attr)
243{
244   assert(vao->NewArrays == 0);
245   const gl_attribute_map_mode map_mode = vao->_AttributeMapMode;
246   return &vao->VertexAttrib[_mesa_vao_attribute_map[map_mode][attr]];
247}
248
249
250/**
251 * Return vertex buffer binding provided an attribute number.
252 */
253static inline const struct gl_vertex_buffer_binding*
254_mesa_draw_buffer_binding(const struct gl_vertex_array_object *vao,
255                          gl_vert_attrib attr)
256{
257   const struct gl_array_attributes *const attrib
258      = _mesa_draw_array_attrib(vao, attr);
259   return _mesa_draw_buffer_binding_from_attrib(vao, attrib);
260}
261
262
263/**
264 * Return vertex attribute bits bound at the provided binding.
265 *
266 * Needs the a fully updated VAO ready for draw.
267 */
268static inline GLbitfield
269_mesa_draw_bound_attrib_bits(const struct gl_vertex_buffer_binding *binding)
270{
271   return binding->_EffBoundArrays;
272}
273
274
275/**
276 * Return the vertex offset bound at the provided binding.
277 *
278 * Needs the a fully updated VAO ready for draw.
279 */
280static inline GLintptr
281_mesa_draw_binding_offset(const struct gl_vertex_buffer_binding *binding)
282{
283   return binding->_EffOffset;
284}
285
286
287/**
288 * Return the relative offset of the provided attrib.
289 *
290 * Needs the a fully updated VAO ready for draw.
291 */
292static inline GLushort
293_mesa_draw_attributes_relative_offset(const struct gl_array_attributes *attrib)
294{
295   return attrib->_EffRelativeOffset;
296}
297
298
299/**
300 * Return a current value vertex array attribute provided the attribute number.
301 */
302static inline const struct gl_array_attributes*
303_mesa_draw_current_attrib(const struct gl_context *ctx, gl_vert_attrib attr)
304{
305   return _vbo_current_attrib(ctx, attr);
306}
307
308
309/**
310 * Return true if we have the VERT_ATTRIB_EDGEFLAG array enabled.
311 */
312static inline bool
313_mesa_draw_edge_flag_array_enabled(const struct gl_context *ctx)
314{
315   return ctx->Array._DrawVAOEnabledAttribs & VERT_BIT_EDGEFLAG;
316}
317
318
319/**
320 * Return the attrib for the given attribute.
321 */
322static inline const struct gl_array_attributes*
323_mesa_draw_attrib(const struct gl_context *ctx, gl_vert_attrib attr)
324{
325   if (ctx->Array._DrawVAOEnabledAttribs & VERT_BIT(attr)) {
326      const struct gl_vertex_array_object *vao = ctx->Array._DrawVAO;
327      return _mesa_draw_array_attrib(vao, attr);
328   } else {
329      return _vbo_current_attrib(ctx, attr);
330   }
331}
332
333
334/**
335 * Return the attrib, binding pair for the given attribute.
336 */
337static inline void
338_mesa_draw_attrib_and_binding(const struct gl_context *ctx, gl_vert_attrib attr,
339                              const struct gl_array_attributes **attrib,
340                              const struct gl_vertex_buffer_binding **binding)
341{
342   if (ctx->Array._DrawVAOEnabledAttribs & VERT_BIT(attr)) {
343      const struct gl_vertex_array_object *vao = ctx->Array._DrawVAO;
344      *attrib = _mesa_draw_array_attrib(vao, attr);
345      *binding = _mesa_draw_buffer_binding_from_attrib(vao, *attrib);
346   } else {
347      *attrib = _vbo_current_attrib(ctx, attr);
348      *binding = _vbo_current_binding(ctx);
349   }
350}
351
352
353/*
354 * API functions
355 */
356
357
358void GLAPIENTRY
359_mesa_BindVertexArray_no_error(GLuint id);
360
361void GLAPIENTRY _mesa_BindVertexArray( GLuint id );
362
363void GLAPIENTRY
364_mesa_DeleteVertexArrays_no_error(GLsizei n, const GLuint *ids);
365
366void GLAPIENTRY _mesa_DeleteVertexArrays(GLsizei n, const GLuint *ids);
367
368void GLAPIENTRY
369_mesa_GenVertexArrays_no_error(GLsizei n, GLuint *arrays);
370
371void GLAPIENTRY _mesa_GenVertexArrays(GLsizei n, GLuint *arrays);
372
373void GLAPIENTRY
374_mesa_CreateVertexArrays_no_error(GLsizei n, GLuint *arrays);
375
376void GLAPIENTRY _mesa_CreateVertexArrays(GLsizei n, GLuint *arrays);
377
378GLboolean GLAPIENTRY _mesa_IsVertexArray( GLuint id );
379
380void GLAPIENTRY
381_mesa_VertexArrayElementBuffer_no_error(GLuint vaobj, GLuint buffer);
382
383void GLAPIENTRY _mesa_VertexArrayElementBuffer(GLuint vaobj, GLuint buffer);
384
385void GLAPIENTRY _mesa_GetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param);
386
387#endif /* ARRAYOBJ_H */
388