1 /**************************************************************************
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
30 * Keith Whitwell <keith@tungstengraphics.com>
33 #include "main/imports.h"
34 #include "main/image.h"
40 #include "st_context.h"
41 #include "st_cb_bufferobjects.h"
43 #include "st_program.h"
45 #include "pipe/p_context.h"
46 #include "pipe/p_defines.h"
47 #include "pipe/p_winsys.h"
49 #include "pipe/draw/draw_private.h"
50 #include "pipe/draw/draw_context.h"
53 static GLuint double_types
[4] = {
54 PIPE_FORMAT_R64_FLOAT
,
55 PIPE_FORMAT_R64G64_FLOAT
,
56 PIPE_FORMAT_R64G64B64_FLOAT
,
57 PIPE_FORMAT_R64G64B64A64_FLOAT
60 static GLuint float_types
[4] = {
61 PIPE_FORMAT_R32_FLOAT
,
62 PIPE_FORMAT_R32G32_FLOAT
,
63 PIPE_FORMAT_R32G32B32_FLOAT
,
64 PIPE_FORMAT_R32G32B32A32_FLOAT
67 static GLuint uint_types_norm
[4] = {
68 PIPE_FORMAT_R32_UNORM
,
69 PIPE_FORMAT_R32G32_UNORM
,
70 PIPE_FORMAT_R32G32B32_UNORM
,
71 PIPE_FORMAT_R32G32B32A32_UNORM
74 static GLuint uint_types_scale
[4] = {
75 PIPE_FORMAT_R32_USCALED
,
76 PIPE_FORMAT_R32G32_USCALED
,
77 PIPE_FORMAT_R32G32B32_USCALED
,
78 PIPE_FORMAT_R32G32B32A32_USCALED
81 static GLuint int_types_norm
[4] = {
82 PIPE_FORMAT_R32_SNORM
,
83 PIPE_FORMAT_R32G32_SNORM
,
84 PIPE_FORMAT_R32G32B32_SNORM
,
85 PIPE_FORMAT_R32G32B32A32_SNORM
88 static GLuint int_types_scale
[4] = {
89 PIPE_FORMAT_R32_SSCALED
,
90 PIPE_FORMAT_R32G32_SSCALED
,
91 PIPE_FORMAT_R32G32B32_SSCALED
,
92 PIPE_FORMAT_R32G32B32A32_SSCALED
95 static GLuint ushort_types_norm
[4] = {
96 PIPE_FORMAT_R16_UNORM
,
97 PIPE_FORMAT_R16G16_UNORM
,
98 PIPE_FORMAT_R16G16B16_UNORM
,
99 PIPE_FORMAT_R16G16B16A16_UNORM
102 static GLuint ushort_types_scale
[4] = {
103 PIPE_FORMAT_R16_USCALED
,
104 PIPE_FORMAT_R16G16_USCALED
,
105 PIPE_FORMAT_R16G16B16_USCALED
,
106 PIPE_FORMAT_R16G16B16A16_USCALED
109 static GLuint short_types_norm
[4] = {
110 PIPE_FORMAT_R16_SNORM
,
111 PIPE_FORMAT_R16G16_SNORM
,
112 PIPE_FORMAT_R16G16B16_SNORM
,
113 PIPE_FORMAT_R16G16B16A16_SNORM
116 static GLuint short_types_scale
[4] = {
117 PIPE_FORMAT_R16_SSCALED
,
118 PIPE_FORMAT_R16G16_SSCALED
,
119 PIPE_FORMAT_R16G16B16_SSCALED
,
120 PIPE_FORMAT_R16G16B16A16_SSCALED
123 static GLuint ubyte_types_norm
[4] = {
124 PIPE_FORMAT_R8_UNORM
,
125 PIPE_FORMAT_R8G8_UNORM
,
126 PIPE_FORMAT_R8G8B8_UNORM
,
127 PIPE_FORMAT_R8G8B8A8_UNORM
130 static GLuint ubyte_types_scale
[4] = {
131 PIPE_FORMAT_R8_USCALED
,
132 PIPE_FORMAT_R8G8_USCALED
,
133 PIPE_FORMAT_R8G8B8_USCALED
,
134 PIPE_FORMAT_R8G8B8A8_USCALED
137 static GLuint byte_types_norm
[4] = {
138 PIPE_FORMAT_R8_SNORM
,
139 PIPE_FORMAT_R8G8_SNORM
,
140 PIPE_FORMAT_R8G8B8_SNORM
,
141 PIPE_FORMAT_R8G8B8A8_SNORM
144 static GLuint byte_types_scale
[4] = {
145 PIPE_FORMAT_R8_SSCALED
,
146 PIPE_FORMAT_R8G8_SSCALED
,
147 PIPE_FORMAT_R8G8B8_SSCALED
,
148 PIPE_FORMAT_R8G8B8A8_SSCALED
153 * Return a PIPE_FORMAT_x for the given GL datatype and size.
156 pipe_vertex_format(GLenum type
, GLuint size
, GLboolean normalized
)
158 assert(type
>= GL_BYTE
);
159 assert(type
<= GL_DOUBLE
);
165 case GL_DOUBLE
: return double_types
[size
-1];
166 case GL_FLOAT
: return float_types
[size
-1];
167 case GL_INT
: return int_types_norm
[size
-1];
168 case GL_SHORT
: return short_types_norm
[size
-1];
169 case GL_BYTE
: return byte_types_norm
[size
-1];
170 case GL_UNSIGNED_INT
: return uint_types_norm
[size
-1];
171 case GL_UNSIGNED_SHORT
: return ushort_types_norm
[size
-1];
172 case GL_UNSIGNED_BYTE
: return ubyte_types_norm
[size
-1];
173 default: assert(0); return 0;
178 case GL_DOUBLE
: return double_types
[size
-1];
179 case GL_FLOAT
: return float_types
[size
-1];
180 case GL_INT
: return int_types_scale
[size
-1];
181 case GL_SHORT
: return short_types_scale
[size
-1];
182 case GL_BYTE
: return byte_types_scale
[size
-1];
183 case GL_UNSIGNED_INT
: return uint_types_scale
[size
-1];
184 case GL_UNSIGNED_SHORT
: return ushort_types_scale
[size
-1];
185 case GL_UNSIGNED_BYTE
: return ubyte_types_scale
[size
-1];
186 default: assert(0); return 0;
189 return 0; /* silence compiler warning */
194 * The default attribute buffer is basically a copy of the
195 * ctx->Current.Attrib[] array. It's used when the vertex program
196 * references an attribute for which we don't have a VBO/array.
199 create_default_attribs_buffer(struct st_context
*st
)
201 struct pipe_context
*pipe
= st
->pipe
;
202 /* XXX don't hardcode magic 32 here */
203 st
->default_attrib_buffer
= pipe
->winsys
->buffer_create( pipe
->winsys
, 32, 0, 0 );
208 destroy_default_attribs_buffer(struct st_context
*st
)
210 struct pipe_context
*pipe
= st
->pipe
;
211 pipe
->winsys
->buffer_reference(pipe
->winsys
,
212 &st
->default_attrib_buffer
, NULL
);
217 * This function gets plugged into the VBO module and is called when
218 * we have something to render.
219 * Basically, translate the information into the format expected by pipe.
222 st_draw_vbo(GLcontext
*ctx
,
223 const struct gl_client_array
**arrays
,
224 const struct _mesa_prim
*prims
,
226 const struct _mesa_index_buffer
*ib
,
230 struct pipe_context
*pipe
= ctx
->st
->pipe
;
231 struct pipe_winsys
*winsys
= pipe
->winsys
;
232 const struct st_vertex_program
*vp
;
233 const struct pipe_shader_state
*vs
;
234 struct pipe_vertex_buffer vbuffer
[PIPE_MAX_SHADER_INPUTS
];
237 /* sanity check for pointer arithmetic below */
238 assert(sizeof(arrays
[0]->Ptr
[0]) == 1);
240 st_validate_state(ctx
->st
);
242 /* must get these after state validation! */
244 vs
= &ctx
->st
->state
.vs
->state
;
246 /* loop over TGSI shader inputs to determine vertex buffer
249 for (attr
= 0; attr
< vs
->num_inputs
; attr
++) {
250 const GLuint mesaAttr
= vp
->index_to_input
[attr
];
251 struct gl_buffer_object
*bufobj
= arrays
[mesaAttr
]->BufferObj
;
252 struct pipe_vertex_element velement
;
254 if (bufobj
&& bufobj
->Name
) {
255 /* Attribute data is in a VBO.
256 * Recall that for VBOs, the gl_client_array->Ptr field is
257 * really an offset from the start of the VBO, not a pointer.
259 struct st_buffer_object
*stobj
= st_buffer_object(bufobj
);
260 assert(stobj
->buffer
);
262 vbuffer
[attr
].buffer
= NULL
;
263 winsys
->buffer_reference(winsys
, &vbuffer
[attr
].buffer
, stobj
->buffer
);
264 vbuffer
[attr
].buffer_offset
= (unsigned) arrays
[0]->Ptr
;/* in bytes */
265 velement
.src_offset
= arrays
[mesaAttr
]->Ptr
- arrays
[0]->Ptr
;
266 assert(velement
.src_offset
<= 2048); /* 11-bit field */
269 /* attribute data is in user-space memory, not a VBO */
272 if (!arrays
[mesaAttr
]->StrideB
) {
273 bytes
= arrays
[mesaAttr
]->Size
274 * _mesa_sizeof_type(arrays
[mesaAttr
]->Type
);
276 bytes
= arrays
[mesaAttr
]->StrideB
* (max_index
+ 1);
281 = winsys
->user_buffer_create(winsys
,
282 (void *) arrays
[mesaAttr
]->Ptr
,
284 vbuffer
[attr
].buffer_offset
= 0;
285 velement
.src_offset
= 0;
288 /* common-case setup */
289 vbuffer
[attr
].pitch
= arrays
[mesaAttr
]->StrideB
; /* in bytes */
290 vbuffer
[attr
].max_index
= 0; /* need this? */
291 velement
.vertex_buffer_index
= attr
;
292 velement
.nr_components
= arrays
[mesaAttr
]->Size
;
293 velement
.src_format
= pipe_vertex_format(arrays
[mesaAttr
]->Type
,
294 arrays
[mesaAttr
]->Size
,
295 arrays
[mesaAttr
]->Normalized
);
296 assert(velement
.src_format
);
298 /* tell pipe about this attribute */
299 pipe
->set_vertex_buffer(pipe
, attr
, &vbuffer
[attr
]);
300 pipe
->set_vertex_element(pipe
, attr
, &velement
);
304 /* do actual drawing */
306 /* indexed primitive */
307 struct gl_buffer_object
*bufobj
= ib
->obj
;
308 struct pipe_buffer_handle
*indexBuf
= NULL
;
309 unsigned indexSize
, indexOffset
, i
;
312 case GL_UNSIGNED_INT
:
315 case GL_UNSIGNED_SHORT
:
318 case GL_UNSIGNED_BYTE
:
325 /* get/create the index buffer object */
326 if (bufobj
&& bufobj
->Name
) {
327 /* elements/indexes are in a real VBO */
328 struct st_buffer_object
*stobj
= st_buffer_object(bufobj
);
329 winsys
->buffer_reference(winsys
, &indexBuf
, stobj
->buffer
);
330 indexOffset
= (unsigned) ib
->ptr
/ indexSize
;
333 /* element/indicies are in user space memory */
334 indexBuf
= winsys
->user_buffer_create(winsys
,
336 ib
->count
* indexSize
);
341 for (i
= 0; i
< nr_prims
; i
++) {
342 pipe
->draw_elements(pipe
, indexBuf
, indexSize
,
344 prims
[i
].start
+ indexOffset
, prims
[i
].count
);
347 winsys
->buffer_reference(winsys
, &indexBuf
, NULL
);
352 for (i
= 0; i
< nr_prims
; i
++) {
353 pipe
->draw_arrays(pipe
, prims
[i
].mode
, prims
[i
].start
, prims
[i
].count
);
357 /* unreference buffers (frees wrapped user-space buffer objects) */
358 for (attr
= 0; attr
< vs
->num_inputs
; attr
++) {
359 winsys
->buffer_reference(winsys
, &vbuffer
[attr
].buffer
, NULL
);
360 assert(!vbuffer
[attr
].buffer
);
361 pipe
->set_vertex_buffer(pipe
, attr
, &vbuffer
[attr
]);
368 * Utility function for drawing simple primitives (such as quads for
369 * glClear and glDrawPixels). Coordinates are in screen space.
370 * \param mode one of PIPE_PRIM_x
371 * \param numVertex number of vertices
372 * \param verts vertex data (all attributes are float[4])
373 * \param numAttribs number of attributes per vertex
376 st_draw_vertices(GLcontext
*ctx
, unsigned prim
,
377 unsigned numVertex
, float *verts
,
380 const float width
= ctx
->DrawBuffer
->Width
;
381 const float height
= ctx
->DrawBuffer
->Height
;
382 const unsigned vertex_bytes
= numVertex
* numAttribs
* 4 * sizeof(float);
383 struct pipe_context
*pipe
= ctx
->st
->pipe
;
384 struct pipe_buffer_handle
*vbuf
;
385 struct pipe_vertex_buffer vbuffer
;
386 struct pipe_vertex_element velement
;
389 assert(numAttribs
> 0);
391 /* convert to clip coords */
392 for (i
= 0; i
< numVertex
; i
++) {
393 float x
= verts
[i
* numAttribs
* 4 + 0];
394 float y
= verts
[i
* numAttribs
* 4 + 1];
395 x
= x
/ width
* 2.0 - 1.0;
396 y
= y
/ height
* 2.0 - 1.0;
397 verts
[i
* numAttribs
* 4 + 0] = x
;
398 verts
[i
* numAttribs
* 4 + 1] = y
;
401 /* XXX create one-time */
402 vbuf
= pipe
->winsys
->buffer_create(pipe
->winsys
, 32, 0, 0);
403 pipe
->winsys
->buffer_data(pipe
->winsys
, vbuf
,
405 PIPE_BUFFER_USAGE_VERTEX
);
407 /* tell pipe about the vertex buffer */
408 vbuffer
.buffer
= vbuf
;
409 vbuffer
.pitch
= numAttribs
* 4 * sizeof(float); /* vertex size */
410 vbuffer
.buffer_offset
= 0;
411 pipe
->set_vertex_buffer(pipe
, 0, &vbuffer
);
413 /* tell pipe about the vertex attributes */
414 for (i
= 0; i
< numAttribs
; i
++) {
415 velement
.src_offset
= i
* 4 * sizeof(GLfloat
);
416 velement
.vertex_buffer_index
= 0;
417 velement
.src_format
= PIPE_FORMAT_R32G32B32A32_FLOAT
;
418 velement
.nr_components
= 4;
419 pipe
->set_vertex_element(pipe
, i
, &velement
);
423 pipe
->draw_arrays(pipe
, prim
, 0, numVertex
);
425 /* XXX: do one-time */
426 pipe
->winsys
->buffer_reference(pipe
->winsys
, &vbuf
, NULL
);
431 * Set the (private) draw module's post-transformed vertex format when in
432 * GL_SELECT or GL_FEEDBACK mode or for glRasterPos.
435 set_feedback_vertex_format(GLcontext
*ctx
)
437 struct st_context
*st
= ctx
->st
;
438 struct vertex_info vinfo
;
441 if (ctx
->RenderMode
== GL_SELECT
) {
442 assert(ctx
->RenderMode
== GL_SELECT
);
443 vinfo
.num_attribs
= 1;
444 vinfo
.format
[0] = FORMAT_4F
;
445 vinfo
.interp_mode
[0] = INTERP_NONE
;
448 /* GL_FEEDBACK, or glRasterPos */
449 /* emit all attribs (pos, color, texcoord) as GLfloat[4] */
450 vinfo
.num_attribs
= st
->state
.vs
->state
.num_outputs
;
451 for (i
= 0; i
< vinfo
.num_attribs
; i
++) {
452 vinfo
.format
[i
] = FORMAT_4F
;
453 vinfo
.interp_mode
[i
] = INTERP_LINEAR
;
457 draw_set_vertex_info(st
->draw
, &vinfo
);
462 * Called by VBO to draw arrays when in selection or feedback mode and
463 * to implement glRasterPos.
464 * This is very much like the normal draw_vbo() function above.
465 * Look at code refactoring some day.
466 * Might move this into the failover module some day.
469 st_feedback_draw_vbo(GLcontext
*ctx
,
470 const struct gl_client_array
**arrays
,
471 const struct _mesa_prim
*prims
,
473 const struct _mesa_index_buffer
*ib
,
477 struct st_context
*st
= ctx
->st
;
478 struct pipe_context
*pipe
= st
->pipe
;
479 struct draw_context
*draw
= st
->draw
;
480 struct pipe_winsys
*winsys
= pipe
->winsys
;
481 const struct st_vertex_program
*vp
;
482 const struct pipe_shader_state
*vs
;
483 struct pipe_buffer_handle
*index_buffer_handle
= 0;
484 struct pipe_vertex_buffer vbuffer
[PIPE_MAX_SHADER_INPUTS
];
486 ubyte
*mapped_constants
;
490 st_validate_state(ctx
->st
);
492 /* must get these after state validation! */
494 vs
= &ctx
->st
->state
.vs
->state
;
497 * Set up the draw module's state.
499 * We'd like to do this less frequently, but the normal state-update
500 * code sends state updates to the pipe, not to our private draw module.
503 draw_set_viewport_state(draw
, &st
->state
.viewport
);
504 draw_set_clip_state(draw
, &st
->state
.clip
);
505 draw_set_rasterizer_state(draw
, &st
->state
.rasterizer
->state
);
506 draw_bind_vertex_shader(draw
, st
->state
.vs
->data
);
507 set_feedback_vertex_format(ctx
);
509 /* loop over TGSI shader inputs to determine vertex buffer
512 for (attr
= 0; attr
< vs
->num_inputs
; attr
++) {
513 const GLuint mesaAttr
= vp
->index_to_input
[attr
];
514 struct gl_buffer_object
*bufobj
= arrays
[mesaAttr
]->BufferObj
;
515 struct pipe_vertex_element velement
;
518 if (bufobj
&& bufobj
->Name
) {
519 /* Attribute data is in a VBO.
520 * Recall that for VBOs, the gl_client_array->Ptr field is
521 * really an offset from the start of the VBO, not a pointer.
523 struct st_buffer_object
*stobj
= st_buffer_object(bufobj
);
524 assert(stobj
->buffer
);
526 vbuffer
[attr
].buffer
= NULL
;
527 winsys
->buffer_reference(winsys
, &vbuffer
[attr
].buffer
, stobj
->buffer
);
528 vbuffer
[attr
].buffer_offset
= (unsigned) arrays
[0]->Ptr
;/* in bytes */
529 velement
.src_offset
= arrays
[mesaAttr
]->Ptr
- arrays
[0]->Ptr
;
532 /* attribute data is in user-space memory, not a VBO */
533 uint bytes
= (arrays
[mesaAttr
]->Size
534 * _mesa_sizeof_type(arrays
[mesaAttr
]->Type
)
539 = winsys
->user_buffer_create(winsys
,
540 (void *) arrays
[mesaAttr
]->Ptr
,
542 vbuffer
[attr
].buffer_offset
= 0;
543 velement
.src_offset
= 0;
546 /* common-case setup */
547 vbuffer
[attr
].pitch
= arrays
[mesaAttr
]->StrideB
; /* in bytes */
548 vbuffer
[attr
].max_index
= 0; /* need this? */
549 velement
.vertex_buffer_index
= attr
;
550 velement
.nr_components
= arrays
[mesaAttr
]->Size
;
551 velement
.src_format
= pipe_vertex_format(arrays
[mesaAttr
]->Type
,
552 arrays
[mesaAttr
]->Size
,
553 arrays
[mesaAttr
]->Normalized
);
554 assert(velement
.src_format
);
556 /* tell draw about this attribute */
557 draw_set_vertex_buffer(draw
, attr
, &vbuffer
[attr
]);
558 draw_set_vertex_element(draw
, attr
, &velement
);
560 /* map the attrib buffer */
561 map
= pipe
->winsys
->buffer_map(pipe
->winsys
,
562 vbuffer
[attr
].buffer
,
563 PIPE_BUFFER_FLAG_READ
);
564 draw_set_mapped_vertex_buffer(draw
, attr
, map
);
569 struct gl_buffer_object
*bufobj
= ib
->obj
;
570 struct st_buffer_object
*stobj
= st_buffer_object(bufobj
);
571 index_buffer_handle
= stobj
->buffer
;
575 case GL_UNSIGNED_INT
:
578 case GL_UNSIGNED_SHORT
:
585 map
= pipe
->winsys
->buffer_map(pipe
->winsys
,
587 PIPE_BUFFER_FLAG_READ
);
588 draw_set_mapped_element_buffer(draw
, indexSize
, map
);
591 /* no index/element buffer */
592 draw_set_mapped_element_buffer(draw
, 0, NULL
);
596 /* map constant buffers */
597 mapped_constants
= winsys
->buffer_map(winsys
,
598 st
->state
.constants
[PIPE_SHADER_VERTEX
].buffer
,
599 PIPE_BUFFER_FLAG_READ
);
600 draw_set_mapped_constant_buffer(st
->draw
, mapped_constants
);
604 for (i
= 0; i
< nr_prims
; i
++) {
605 draw_arrays(draw
, prims
[i
].mode
, prims
[i
].start
, prims
[i
].count
);
609 /* unmap constant buffers */
610 winsys
->buffer_unmap(winsys
, st
->state
.constants
[PIPE_SHADER_VERTEX
].buffer
);
613 * unmap vertex/index buffers
615 for (i
= 0; i
< PIPE_ATTRIB_MAX
; i
++) {
616 if (draw
->vertex_buffer
[i
].buffer
) {
617 pipe
->winsys
->buffer_unmap(pipe
->winsys
,
618 draw
->vertex_buffer
[i
].buffer
);
619 draw_set_mapped_vertex_buffer(draw
, i
, NULL
);
623 pipe
->winsys
->buffer_unmap(pipe
->winsys
, index_buffer_handle
);
624 draw_set_mapped_element_buffer(draw
, 0, NULL
);
630 void st_init_draw( struct st_context
*st
)
632 GLcontext
*ctx
= st
->ctx
;
634 /* actually, not used here, but elsewhere */
635 create_default_attribs_buffer(st
);
637 vbo_set_draw_func(ctx
, st_draw_vbo
);
641 void st_destroy_draw( struct st_context
*st
)
643 destroy_default_attribs_buffer(st
);