2 /**************************************************************************
4 * Copyright 2007 VMware, Inc.
5 * Copyright 2012 Marek Olšák <maraeo@gmail.com>
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
23 * IN NO EVENT SHALL AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 **************************************************************************/
31 * This converts the VBO's vertex attribute/array information into
32 * Gallium vertex state and binds it.
35 * Keith Whitwell <keithw@vmware.com>
36 * Marek Olšák <maraeo@gmail.com>
39 #include "st_context.h"
41 #include "st_cb_bufferobjects.h"
43 #include "st_program.h"
45 #include "cso_cache/cso_context.h"
46 #include "util/u_math.h"
47 #include "main/bufferobj.h"
48 #include "main/glformats.h"
51 static GLuint double_types
[4] = {
52 PIPE_FORMAT_R64_FLOAT
,
53 PIPE_FORMAT_R64G64_FLOAT
,
54 PIPE_FORMAT_R64G64B64_FLOAT
,
55 PIPE_FORMAT_R64G64B64A64_FLOAT
58 static GLuint float_types
[4] = {
59 PIPE_FORMAT_R32_FLOAT
,
60 PIPE_FORMAT_R32G32_FLOAT
,
61 PIPE_FORMAT_R32G32B32_FLOAT
,
62 PIPE_FORMAT_R32G32B32A32_FLOAT
65 static GLuint half_float_types
[4] = {
66 PIPE_FORMAT_R16_FLOAT
,
67 PIPE_FORMAT_R16G16_FLOAT
,
68 PIPE_FORMAT_R16G16B16_FLOAT
,
69 PIPE_FORMAT_R16G16B16A16_FLOAT
72 static GLuint uint_types_norm
[4] = {
73 PIPE_FORMAT_R32_UNORM
,
74 PIPE_FORMAT_R32G32_UNORM
,
75 PIPE_FORMAT_R32G32B32_UNORM
,
76 PIPE_FORMAT_R32G32B32A32_UNORM
79 static GLuint uint_types_scale
[4] = {
80 PIPE_FORMAT_R32_USCALED
,
81 PIPE_FORMAT_R32G32_USCALED
,
82 PIPE_FORMAT_R32G32B32_USCALED
,
83 PIPE_FORMAT_R32G32B32A32_USCALED
86 static GLuint uint_types_int
[4] = {
88 PIPE_FORMAT_R32G32_UINT
,
89 PIPE_FORMAT_R32G32B32_UINT
,
90 PIPE_FORMAT_R32G32B32A32_UINT
93 static GLuint int_types_norm
[4] = {
94 PIPE_FORMAT_R32_SNORM
,
95 PIPE_FORMAT_R32G32_SNORM
,
96 PIPE_FORMAT_R32G32B32_SNORM
,
97 PIPE_FORMAT_R32G32B32A32_SNORM
100 static GLuint int_types_scale
[4] = {
101 PIPE_FORMAT_R32_SSCALED
,
102 PIPE_FORMAT_R32G32_SSCALED
,
103 PIPE_FORMAT_R32G32B32_SSCALED
,
104 PIPE_FORMAT_R32G32B32A32_SSCALED
107 static GLuint int_types_int
[4] = {
108 PIPE_FORMAT_R32_SINT
,
109 PIPE_FORMAT_R32G32_SINT
,
110 PIPE_FORMAT_R32G32B32_SINT
,
111 PIPE_FORMAT_R32G32B32A32_SINT
114 static GLuint ushort_types_norm
[4] = {
115 PIPE_FORMAT_R16_UNORM
,
116 PIPE_FORMAT_R16G16_UNORM
,
117 PIPE_FORMAT_R16G16B16_UNORM
,
118 PIPE_FORMAT_R16G16B16A16_UNORM
121 static GLuint ushort_types_scale
[4] = {
122 PIPE_FORMAT_R16_USCALED
,
123 PIPE_FORMAT_R16G16_USCALED
,
124 PIPE_FORMAT_R16G16B16_USCALED
,
125 PIPE_FORMAT_R16G16B16A16_USCALED
128 static GLuint ushort_types_int
[4] = {
129 PIPE_FORMAT_R16_UINT
,
130 PIPE_FORMAT_R16G16_UINT
,
131 PIPE_FORMAT_R16G16B16_UINT
,
132 PIPE_FORMAT_R16G16B16A16_UINT
135 static GLuint short_types_norm
[4] = {
136 PIPE_FORMAT_R16_SNORM
,
137 PIPE_FORMAT_R16G16_SNORM
,
138 PIPE_FORMAT_R16G16B16_SNORM
,
139 PIPE_FORMAT_R16G16B16A16_SNORM
142 static GLuint short_types_scale
[4] = {
143 PIPE_FORMAT_R16_SSCALED
,
144 PIPE_FORMAT_R16G16_SSCALED
,
145 PIPE_FORMAT_R16G16B16_SSCALED
,
146 PIPE_FORMAT_R16G16B16A16_SSCALED
149 static GLuint short_types_int
[4] = {
150 PIPE_FORMAT_R16_SINT
,
151 PIPE_FORMAT_R16G16_SINT
,
152 PIPE_FORMAT_R16G16B16_SINT
,
153 PIPE_FORMAT_R16G16B16A16_SINT
156 static GLuint ubyte_types_norm
[4] = {
157 PIPE_FORMAT_R8_UNORM
,
158 PIPE_FORMAT_R8G8_UNORM
,
159 PIPE_FORMAT_R8G8B8_UNORM
,
160 PIPE_FORMAT_R8G8B8A8_UNORM
163 static GLuint ubyte_types_scale
[4] = {
164 PIPE_FORMAT_R8_USCALED
,
165 PIPE_FORMAT_R8G8_USCALED
,
166 PIPE_FORMAT_R8G8B8_USCALED
,
167 PIPE_FORMAT_R8G8B8A8_USCALED
170 static GLuint ubyte_types_int
[4] = {
172 PIPE_FORMAT_R8G8_UINT
,
173 PIPE_FORMAT_R8G8B8_UINT
,
174 PIPE_FORMAT_R8G8B8A8_UINT
177 static GLuint byte_types_norm
[4] = {
178 PIPE_FORMAT_R8_SNORM
,
179 PIPE_FORMAT_R8G8_SNORM
,
180 PIPE_FORMAT_R8G8B8_SNORM
,
181 PIPE_FORMAT_R8G8B8A8_SNORM
184 static GLuint byte_types_scale
[4] = {
185 PIPE_FORMAT_R8_SSCALED
,
186 PIPE_FORMAT_R8G8_SSCALED
,
187 PIPE_FORMAT_R8G8B8_SSCALED
,
188 PIPE_FORMAT_R8G8B8A8_SSCALED
191 static GLuint byte_types_int
[4] = {
193 PIPE_FORMAT_R8G8_SINT
,
194 PIPE_FORMAT_R8G8B8_SINT
,
195 PIPE_FORMAT_R8G8B8A8_SINT
198 static GLuint fixed_types
[4] = {
199 PIPE_FORMAT_R32_FIXED
,
200 PIPE_FORMAT_R32G32_FIXED
,
201 PIPE_FORMAT_R32G32B32_FIXED
,
202 PIPE_FORMAT_R32G32B32A32_FIXED
207 * Return a PIPE_FORMAT_x for the given GL datatype and size.
210 st_pipe_vertex_format(GLenum type
, GLuint size
, GLenum format
,
211 GLboolean normalized
, GLboolean integer
)
213 assert((type
>= GL_BYTE
&& type
<= GL_DOUBLE
) ||
214 type
== GL_FIXED
|| type
== GL_HALF_FLOAT
||
215 type
== GL_INT_2_10_10_10_REV
||
216 type
== GL_UNSIGNED_INT_2_10_10_10_REV
||
217 type
== GL_UNSIGNED_INT_10F_11F_11F_REV
);
220 assert(format
== GL_RGBA
|| format
== GL_BGRA
);
222 if (type
== GL_INT_2_10_10_10_REV
||
223 type
== GL_UNSIGNED_INT_2_10_10_10_REV
) {
227 if (format
== GL_BGRA
) {
228 if (type
== GL_INT_2_10_10_10_REV
) {
230 return PIPE_FORMAT_B10G10R10A2_SNORM
;
232 return PIPE_FORMAT_B10G10R10A2_SSCALED
;
235 return PIPE_FORMAT_B10G10R10A2_UNORM
;
237 return PIPE_FORMAT_B10G10R10A2_USCALED
;
240 if (type
== GL_INT_2_10_10_10_REV
) {
242 return PIPE_FORMAT_R10G10B10A2_SNORM
;
244 return PIPE_FORMAT_R10G10B10A2_SSCALED
;
247 return PIPE_FORMAT_R10G10B10A2_UNORM
;
249 return PIPE_FORMAT_R10G10B10A2_USCALED
;
254 if (type
== GL_UNSIGNED_INT_10F_11F_11F_REV
) {
257 assert(format
== GL_RGBA
);
259 return PIPE_FORMAT_R11G11B10_FLOAT
;
262 if (format
== GL_BGRA
) {
263 /* this is an odd-ball case */
264 assert(type
== GL_UNSIGNED_BYTE
);
266 return PIPE_FORMAT_B8G8R8A8_UNORM
;
271 case GL_INT
: return int_types_int
[size
-1];
272 case GL_SHORT
: return short_types_int
[size
-1];
273 case GL_BYTE
: return byte_types_int
[size
-1];
274 case GL_UNSIGNED_INT
: return uint_types_int
[size
-1];
275 case GL_UNSIGNED_SHORT
: return ushort_types_int
[size
-1];
276 case GL_UNSIGNED_BYTE
: return ubyte_types_int
[size
-1];
277 default: assert(0); return 0;
280 else if (normalized
) {
282 case GL_DOUBLE
: return double_types
[size
-1];
283 case GL_FLOAT
: return float_types
[size
-1];
284 case GL_HALF_FLOAT
: return half_float_types
[size
-1];
285 case GL_INT
: return int_types_norm
[size
-1];
286 case GL_SHORT
: return short_types_norm
[size
-1];
287 case GL_BYTE
: return byte_types_norm
[size
-1];
288 case GL_UNSIGNED_INT
: return uint_types_norm
[size
-1];
289 case GL_UNSIGNED_SHORT
: return ushort_types_norm
[size
-1];
290 case GL_UNSIGNED_BYTE
: return ubyte_types_norm
[size
-1];
291 case GL_FIXED
: return fixed_types
[size
-1];
292 default: assert(0); return 0;
297 case GL_DOUBLE
: return double_types
[size
-1];
298 case GL_FLOAT
: return float_types
[size
-1];
299 case GL_HALF_FLOAT
: return half_float_types
[size
-1];
300 case GL_INT
: return int_types_scale
[size
-1];
301 case GL_SHORT
: return short_types_scale
[size
-1];
302 case GL_BYTE
: return byte_types_scale
[size
-1];
303 case GL_UNSIGNED_INT
: return uint_types_scale
[size
-1];
304 case GL_UNSIGNED_SHORT
: return ushort_types_scale
[size
-1];
305 case GL_UNSIGNED_BYTE
: return ubyte_types_scale
[size
-1];
306 case GL_FIXED
: return fixed_types
[size
-1];
307 default: assert(0); return 0;
310 return PIPE_FORMAT_NONE
; /* silence compiler warning */
313 static const struct gl_client_array
*
314 get_client_array(const struct st_vertex_program
*vp
,
315 const struct gl_client_array
**arrays
,
318 const GLuint mesaAttr
= vp
->index_to_input
[attr
];
319 /* st_program uses 0xffffffff to denote a double placeholder attribute */
320 if (mesaAttr
== ST_DOUBLE_ATTRIB_PLACEHOLDER
)
322 return arrays
[mesaAttr
];
326 * Examine the active arrays to determine if we have interleaved
327 * vertex arrays all living in one VBO, or all living in user space.
330 is_interleaved_arrays(const struct st_vertex_program
*vp
,
331 const struct st_vp_variant
*vpv
,
332 const struct gl_client_array
**arrays
)
335 const struct gl_buffer_object
*firstBufObj
= NULL
;
336 GLint firstStride
= -1;
337 const GLubyte
*firstPtr
= NULL
;
338 GLboolean userSpaceBuffer
= GL_FALSE
;
340 for (attr
= 0; attr
< vpv
->num_inputs
; attr
++) {
341 const struct gl_client_array
*array
;
342 const struct gl_buffer_object
*bufObj
;
345 array
= get_client_array(vp
, arrays
, attr
);
349 stride
= array
->StrideB
; /* in bytes */
350 bufObj
= array
->BufferObj
;
352 /* save info about the first array */
353 firstStride
= stride
;
354 firstPtr
= array
->Ptr
;
355 firstBufObj
= bufObj
;
356 userSpaceBuffer
= !bufObj
|| !bufObj
->Name
;
359 /* check if other arrays interleave with the first, in same buffer */
360 if (stride
!= firstStride
)
361 return GL_FALSE
; /* strides don't match */
363 if (bufObj
!= firstBufObj
)
364 return GL_FALSE
; /* arrays in different VBOs */
366 if (llabs(array
->Ptr
- firstPtr
) > firstStride
)
367 return GL_FALSE
; /* arrays start too far apart */
369 if ((!_mesa_is_bufferobj(bufObj
)) != userSpaceBuffer
)
370 return GL_FALSE
; /* mix of VBO and user-space arrays */
377 static void init_velement(struct pipe_vertex_element
*velement
,
378 int src_offset
, int format
,
379 int instance_divisor
, int vbo_index
)
381 velement
->src_offset
= src_offset
;
382 velement
->src_format
= format
;
383 velement
->instance_divisor
= instance_divisor
;
384 velement
->vertex_buffer_index
= vbo_index
;
385 assert(velement
->src_format
);
388 static void init_velement_lowered(struct st_context
*st
,
389 const struct st_vertex_program
*vp
,
390 struct pipe_vertex_element
*velements
,
391 int src_offset
, int format
,
392 int instance_divisor
, int vbo_index
,
393 int nr_components
, GLboolean doubles
,
400 if (nr_components
< 2)
401 lower_format
= PIPE_FORMAT_R32G32_UINT
;
403 lower_format
= PIPE_FORMAT_R32G32B32A32_UINT
;
405 init_velement(&velements
[idx
], src_offset
,
406 lower_format
, instance_divisor
, vbo_index
);
409 if (idx
< vp
->num_inputs
&&
410 vp
->index_to_input
[idx
] == ST_DOUBLE_ATTRIB_PLACEHOLDER
) {
411 if (nr_components
>= 3) {
412 if (nr_components
== 3)
413 lower_format
= PIPE_FORMAT_R32G32_UINT
;
415 lower_format
= PIPE_FORMAT_R32G32B32A32_UINT
;
417 init_velement(&velements
[idx
], src_offset
+ 4 * sizeof(float),
418 lower_format
, instance_divisor
, vbo_index
);
420 /* The values here are undefined. Fill in some conservative
423 init_velement(&velements
[idx
], src_offset
, PIPE_FORMAT_R32G32_UINT
,
424 instance_divisor
, vbo_index
);
430 init_velement(&velements
[idx
], src_offset
,
431 format
, instance_divisor
, vbo_index
);
438 * Set up for drawing interleaved arrays that all live in one VBO
439 * or all live in user space.
440 * \param vbuffer returns vertex buffer info
441 * \param velements returns vertex element info
444 setup_interleaved_attribs(struct st_context
*st
,
445 const struct st_vertex_program
*vp
,
446 const struct st_vp_variant
*vpv
,
447 const struct gl_client_array
**arrays
,
448 struct pipe_vertex_buffer
*vbuffer
,
449 struct pipe_vertex_element velements
[])
452 const GLubyte
*low_addr
= NULL
;
453 GLboolean usingVBO
; /* all arrays in a VBO? */
454 struct gl_buffer_object
*bufobj
;
457 /* Find the lowest address of the arrays we're drawing,
458 * Init bufobj and stride.
460 if (vpv
->num_inputs
) {
461 const struct gl_client_array
*array
;
463 array
= get_client_array(vp
, arrays
, 0);
466 /* Since we're doing interleaved arrays, we know there'll be at most
467 * one buffer object and the stride will be the same for all arrays.
470 bufobj
= array
->BufferObj
;
471 stride
= array
->StrideB
;
473 low_addr
= arrays
[vp
->index_to_input
[0]]->Ptr
;
475 for (attr
= 1; attr
< vpv
->num_inputs
; attr
++) {
476 const GLubyte
*start
;
477 array
= get_client_array(vp
, arrays
, attr
);
481 low_addr
= MIN2(low_addr
, start
);
485 /* not sure we'll ever have zero inputs, but play it safe */
491 /* are the arrays in user space? */
492 usingVBO
= _mesa_is_bufferobj(bufobj
);
494 for (attr
= 0; attr
< vpv
->num_inputs
;) {
495 const struct gl_client_array
*array
;
499 array
= get_client_array(vp
, arrays
, attr
);
502 src_offset
= (unsigned) (array
->Ptr
- low_addr
);
503 assert(array
->_ElementSize
==
504 _mesa_bytes_per_vertex_attrib(array
->Size
, array
->Type
));
506 src_format
= st_pipe_vertex_format(array
->Type
,
512 init_velement_lowered(st
, vp
, velements
, src_offset
, src_format
,
513 array
->InstanceDivisor
, 0,
514 array
->Size
, array
->Doubles
, &attr
);
518 * Return the vbuffer info and setup user-space attrib info, if needed.
520 if (vpv
->num_inputs
== 0) {
521 /* just defensive coding here */
522 vbuffer
->buffer
= NULL
;
523 vbuffer
->user_buffer
= NULL
;
524 vbuffer
->buffer_offset
= 0;
528 /* all interleaved arrays in a VBO */
529 struct st_buffer_object
*stobj
= st_buffer_object(bufobj
);
531 if (!stobj
|| !stobj
->buffer
) {
532 return FALSE
; /* out-of-memory error probably */
535 vbuffer
->buffer
= stobj
->buffer
;
536 vbuffer
->user_buffer
= NULL
;
537 vbuffer
->buffer_offset
= pointer_to_offset(low_addr
);
538 vbuffer
->stride
= stride
;
541 /* all interleaved arrays in user memory */
542 vbuffer
->buffer
= NULL
;
543 vbuffer
->user_buffer
= low_addr
;
544 vbuffer
->buffer_offset
= 0;
545 vbuffer
->stride
= stride
;
551 * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each
553 * \param vbuffer returns vertex buffer info
554 * \param velements returns vertex element info
557 setup_non_interleaved_attribs(struct st_context
*st
,
558 const struct st_vertex_program
*vp
,
559 const struct st_vp_variant
*vpv
,
560 const struct gl_client_array
**arrays
,
561 struct pipe_vertex_buffer vbuffer
[],
562 struct pipe_vertex_element velements
[],
563 unsigned *num_vbuffers
)
565 struct gl_context
*ctx
= st
->ctx
;
570 for (attr
= 0; attr
< vpv
->num_inputs
;) {
571 const GLuint mesaAttr
= vp
->index_to_input
[attr
];
572 const struct gl_client_array
*array
;
573 struct gl_buffer_object
*bufobj
;
578 array
= get_client_array(vp
, arrays
, attr
);
581 bufidx
= (*num_vbuffers
)++;
583 stride
= array
->StrideB
;
584 bufobj
= array
->BufferObj
;
585 assert(array
->_ElementSize
==
586 _mesa_bytes_per_vertex_attrib(array
->Size
, array
->Type
));
588 if (_mesa_is_bufferobj(bufobj
)) {
589 /* Attribute data is in a VBO.
590 * Recall that for VBOs, the gl_client_array->Ptr field is
591 * really an offset from the start of the VBO, not a pointer.
593 struct st_buffer_object
*stobj
= st_buffer_object(bufobj
);
595 if (!stobj
|| !stobj
->buffer
) {
596 return FALSE
; /* out-of-memory error probably */
599 vbuffer
[bufidx
].buffer
= stobj
->buffer
;
600 vbuffer
[bufidx
].user_buffer
= NULL
;
601 vbuffer
[bufidx
].buffer_offset
= pointer_to_offset(array
->Ptr
);
608 ptr
= (void *) array
->Ptr
;
611 /* no array, use ctx->Current.Attrib[] value */
612 ptr
= (void *) ctx
->Current
.Attrib
[mesaAttr
];
618 vbuffer
[bufidx
].buffer
= NULL
;
619 vbuffer
[bufidx
].user_buffer
= ptr
;
620 vbuffer
[bufidx
].buffer_offset
= 0;
623 /* common-case setup */
624 vbuffer
[bufidx
].stride
= stride
; /* in bytes */
626 src_format
= st_pipe_vertex_format(array
->Type
,
632 init_velement_lowered(st
, vp
, velements
, 0, src_format
,
633 array
->InstanceDivisor
, bufidx
,
634 array
->Size
, array
->Doubles
, &attr
);
640 static void update_array(struct st_context
*st
)
642 struct gl_context
*ctx
= st
->ctx
;
643 const struct gl_client_array
**arrays
= ctx
->Array
._DrawArrays
;
644 const struct st_vertex_program
*vp
;
645 const struct st_vp_variant
*vpv
;
646 struct pipe_vertex_buffer vbuffer
[PIPE_MAX_SHADER_INPUTS
];
647 struct pipe_vertex_element velements
[PIPE_MAX_ATTRIBS
];
648 unsigned num_vbuffers
;
650 st
->vertex_array_out_of_memory
= FALSE
;
652 /* No drawing has been done yet, so do nothing. */
656 /* vertex program validation must be done before this */
658 vpv
= st
->vp_variant
;
660 memset(velements
, 0, sizeof(struct pipe_vertex_element
) * vpv
->num_inputs
);
663 * Setup the vbuffer[] and velements[] arrays.
665 if (is_interleaved_arrays(vp
, vpv
, arrays
)) {
666 if (!setup_interleaved_attribs(st
, vp
, vpv
, arrays
, vbuffer
, velements
)) {
667 st
->vertex_array_out_of_memory
= TRUE
;
672 if (vpv
->num_inputs
== 0)
676 if (!setup_non_interleaved_attribs(st
, vp
, vpv
, arrays
, vbuffer
,
677 velements
, &num_vbuffers
)) {
678 st
->vertex_array_out_of_memory
= TRUE
;
683 cso_set_vertex_buffers(st
->cso_context
, 0, num_vbuffers
, vbuffer
);
684 if (st
->last_num_vbuffers
> num_vbuffers
) {
685 /* Unbind remaining buffers, if any. */
686 cso_set_vertex_buffers(st
->cso_context
, num_vbuffers
,
687 st
->last_num_vbuffers
- num_vbuffers
, NULL
);
689 st
->last_num_vbuffers
= num_vbuffers
;
690 cso_set_vertex_elements(st
->cso_context
, vpv
->num_inputs
, velements
);
694 const struct st_tracked_state st_update_array
= {
695 update_array
/* update */