st_draw.c revision bae90edfdae0eac6c844ede21285453ef96a4f6e
1/************************************************************************** 2 * 3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * 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 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: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * 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 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. 25 * 26 **************************************************************************/ 27 28 /* 29 * Authors: 30 * Keith Whitwell <keith@tungstengraphics.com> 31 */ 32 33#include "main/imports.h" 34#include "main/image.h" 35 36#include "vbo/vbo.h" 37 38#include "st_context.h" 39#include "st_atom.h" 40#include "st_cb_bufferobjects.h" 41#include "st_draw.h" 42#include "st_program.h" 43 44#include "pipe/p_context.h" 45#include "pipe/p_defines.h" 46#include "pipe/p_inlines.h" 47 48#include "draw/draw_private.h" 49#include "draw/draw_context.h" 50 51 52static GLuint double_types[4] = { 53 PIPE_FORMAT_R64_FLOAT, 54 PIPE_FORMAT_R64G64_FLOAT, 55 PIPE_FORMAT_R64G64B64_FLOAT, 56 PIPE_FORMAT_R64G64B64A64_FLOAT 57}; 58 59static GLuint float_types[4] = { 60 PIPE_FORMAT_R32_FLOAT, 61 PIPE_FORMAT_R32G32_FLOAT, 62 PIPE_FORMAT_R32G32B32_FLOAT, 63 PIPE_FORMAT_R32G32B32A32_FLOAT 64}; 65 66static GLuint uint_types_norm[4] = { 67 PIPE_FORMAT_R32_UNORM, 68 PIPE_FORMAT_R32G32_UNORM, 69 PIPE_FORMAT_R32G32B32_UNORM, 70 PIPE_FORMAT_R32G32B32A32_UNORM 71}; 72 73static GLuint uint_types_scale[4] = { 74 PIPE_FORMAT_R32_USCALED, 75 PIPE_FORMAT_R32G32_USCALED, 76 PIPE_FORMAT_R32G32B32_USCALED, 77 PIPE_FORMAT_R32G32B32A32_USCALED 78}; 79 80static GLuint int_types_norm[4] = { 81 PIPE_FORMAT_R32_SNORM, 82 PIPE_FORMAT_R32G32_SNORM, 83 PIPE_FORMAT_R32G32B32_SNORM, 84 PIPE_FORMAT_R32G32B32A32_SNORM 85}; 86 87static GLuint int_types_scale[4] = { 88 PIPE_FORMAT_R32_SSCALED, 89 PIPE_FORMAT_R32G32_SSCALED, 90 PIPE_FORMAT_R32G32B32_SSCALED, 91 PIPE_FORMAT_R32G32B32A32_SSCALED 92}; 93 94static GLuint ushort_types_norm[4] = { 95 PIPE_FORMAT_R16_UNORM, 96 PIPE_FORMAT_R16G16_UNORM, 97 PIPE_FORMAT_R16G16B16_UNORM, 98 PIPE_FORMAT_R16G16B16A16_UNORM 99}; 100 101static GLuint ushort_types_scale[4] = { 102 PIPE_FORMAT_R16_USCALED, 103 PIPE_FORMAT_R16G16_USCALED, 104 PIPE_FORMAT_R16G16B16_USCALED, 105 PIPE_FORMAT_R16G16B16A16_USCALED 106}; 107 108static GLuint short_types_norm[4] = { 109 PIPE_FORMAT_R16_SNORM, 110 PIPE_FORMAT_R16G16_SNORM, 111 PIPE_FORMAT_R16G16B16_SNORM, 112 PIPE_FORMAT_R16G16B16A16_SNORM 113}; 114 115static GLuint short_types_scale[4] = { 116 PIPE_FORMAT_R16_SSCALED, 117 PIPE_FORMAT_R16G16_SSCALED, 118 PIPE_FORMAT_R16G16B16_SSCALED, 119 PIPE_FORMAT_R16G16B16A16_SSCALED 120}; 121 122static GLuint ubyte_types_norm[4] = { 123 PIPE_FORMAT_R8_UNORM, 124 PIPE_FORMAT_R8G8_UNORM, 125 PIPE_FORMAT_R8G8B8_UNORM, 126 PIPE_FORMAT_R8G8B8A8_UNORM 127}; 128 129static GLuint ubyte_types_scale[4] = { 130 PIPE_FORMAT_R8_USCALED, 131 PIPE_FORMAT_R8G8_USCALED, 132 PIPE_FORMAT_R8G8B8_USCALED, 133 PIPE_FORMAT_R8G8B8A8_USCALED 134}; 135 136static GLuint byte_types_norm[4] = { 137 PIPE_FORMAT_R8_SNORM, 138 PIPE_FORMAT_R8G8_SNORM, 139 PIPE_FORMAT_R8G8B8_SNORM, 140 PIPE_FORMAT_R8G8B8A8_SNORM 141}; 142 143static GLuint byte_types_scale[4] = { 144 PIPE_FORMAT_R8_SSCALED, 145 PIPE_FORMAT_R8G8_SSCALED, 146 PIPE_FORMAT_R8G8B8_SSCALED, 147 PIPE_FORMAT_R8G8B8A8_SSCALED 148}; 149 150static GLuint fixed_types[4] = { 151 PIPE_FORMAT_R32_FIXED, 152 PIPE_FORMAT_R32G32_FIXED, 153 PIPE_FORMAT_R32G32B32_FIXED, 154 PIPE_FORMAT_R32G32B32A32_FIXED 155}; 156 157 158 159/** 160 * Return a PIPE_FORMAT_x for the given GL datatype and size. 161 */ 162static GLuint 163pipe_vertex_format(GLenum type, GLuint size, GLboolean normalized) 164{ 165 assert((type >= GL_BYTE && type <= GL_DOUBLE) || 166 type == GL_FIXED); 167 assert(size >= 1); 168 assert(size <= 4); 169 170 if (normalized) { 171 switch (type) { 172 case GL_DOUBLE: return double_types[size-1]; 173 case GL_FLOAT: return float_types[size-1]; 174 case GL_INT: return int_types_norm[size-1]; 175 case GL_SHORT: return short_types_norm[size-1]; 176 case GL_BYTE: return byte_types_norm[size-1]; 177 case GL_UNSIGNED_INT: return uint_types_norm[size-1]; 178 case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1]; 179 case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1]; 180 case GL_FIXED: return fixed_types[size-1]; 181 default: assert(0); return 0; 182 } 183 } 184 else { 185 switch (type) { 186 case GL_DOUBLE: return double_types[size-1]; 187 case GL_FLOAT: return float_types[size-1]; 188 case GL_INT: return int_types_scale[size-1]; 189 case GL_SHORT: return short_types_scale[size-1]; 190 case GL_BYTE: return byte_types_scale[size-1]; 191 case GL_UNSIGNED_INT: return uint_types_scale[size-1]; 192 case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1]; 193 case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1]; 194 case GL_FIXED: return fixed_types[size-1]; 195 default: assert(0); return 0; 196 } 197 } 198 return 0; /* silence compiler warning */ 199} 200 201 202/* 203 * If edge flags are needed, setup an bitvector of flags and call 204 * pipe->set_edgeflags(). 205 * XXX memleak: need to free the returned pointer at some point 206 */ 207static void * 208setup_edgeflags(GLcontext *ctx, GLenum primMode, GLint start, GLint count, 209 const struct gl_client_array *array) 210{ 211 struct pipe_context *pipe = ctx->st->pipe; 212 213 if ((primMode == GL_TRIANGLES || 214 primMode == GL_QUADS || 215 primMode == GL_POLYGON) && 216 (ctx->Polygon.FrontMode != GL_FILL || 217 ctx->Polygon.BackMode != GL_FILL)) { 218 /* need edge flags */ 219 GLint i; 220 unsigned *vec; 221 struct st_buffer_object *stobj = st_buffer_object(array->BufferObj); 222 ubyte *map; 223 224 if (!stobj) 225 return NULL; 226 227 vec = (unsigned *) calloc(sizeof(unsigned), (count + 31) / 32); 228 if (!vec) 229 return NULL; 230 231 map = pipe_buffer_map(pipe, stobj->buffer, PIPE_BUFFER_USAGE_CPU_READ); 232 map = ADD_POINTERS(map, array->Ptr); 233 234 for (i = 0; i < count; i++) { 235 if (*((float *) map)) 236 vec[i/32] |= 1 << (i % 32); 237 238 map += array->StrideB; 239 } 240 241 pipe_buffer_unmap(pipe, stobj->buffer); 242 243 pipe->set_edgeflags(pipe, vec); 244 245 return vec; 246 } 247 else { 248 /* edge flags not needed */ 249 pipe->set_edgeflags(pipe, NULL); 250 return NULL; 251 } 252} 253 254 255 256/** 257 * This function gets plugged into the VBO module and is called when 258 * we have something to render. 259 * Basically, translate the information into the format expected by pipe. 260 */ 261void 262st_draw_vbo(GLcontext *ctx, 263 const struct gl_client_array **arrays, 264 const struct _mesa_prim *prims, 265 GLuint nr_prims, 266 const struct _mesa_index_buffer *ib, 267 GLuint min_index, 268 GLuint max_index) 269{ 270 struct pipe_context *pipe = ctx->st->pipe; 271 const struct st_vertex_program *vp; 272 const struct pipe_shader_state *vs; 273 struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS]; 274 GLuint attr; 275 struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS]; 276 277 /* sanity check for pointer arithmetic below */ 278 assert(sizeof(arrays[0]->Ptr[0]) == 1); 279 280 st_validate_state(ctx->st); 281 282 /* must get these after state validation! */ 283 vp = ctx->st->vp; 284 vs = &ctx->st->vp->state; 285 286 /* loop over TGSI shader inputs to determine vertex buffer 287 * and attribute info 288 */ 289 for (attr = 0; attr < vp->num_inputs; attr++) { 290 const GLuint mesaAttr = vp->index_to_input[attr]; 291 struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj; 292 293 if (bufobj && bufobj->Name) { 294 /* Attribute data is in a VBO. 295 * Recall that for VBOs, the gl_client_array->Ptr field is 296 * really an offset from the start of the VBO, not a pointer. 297 */ 298 struct st_buffer_object *stobj = st_buffer_object(bufobj); 299 assert(stobj->buffer); 300 301 vbuffer[attr].buffer = NULL; 302 pipe_reference_buffer(pipe, &vbuffer[attr].buffer, stobj->buffer); 303 vbuffer[attr].buffer_offset = (unsigned) arrays[mesaAttr]->Ptr; 304 velements[attr].src_offset = 0; 305 } 306 else { 307 /* attribute data is in user-space memory, not a VBO */ 308 uint bytes; 309 310 if (!arrays[mesaAttr]->StrideB) { 311 bytes = arrays[mesaAttr]->Size 312 * _mesa_sizeof_type(arrays[mesaAttr]->Type); 313 } else { 314 bytes = arrays[mesaAttr]->StrideB * (max_index + 1); 315 } 316 317 /* wrap user data */ 318 vbuffer[attr].buffer 319 = pipe_user_buffer_create(pipe, (void *) arrays[mesaAttr]->Ptr, 320 bytes); 321 vbuffer[attr].buffer_offset = 0; 322 velements[attr].src_offset = 0; 323 } 324 325 assert(velements[attr].src_offset <= 2048); /* 11-bit field */ 326 327 /* common-case setup */ 328 vbuffer[attr].pitch = arrays[mesaAttr]->StrideB; /* in bytes */ 329 vbuffer[attr].max_index = max_index; 330 velements[attr].vertex_buffer_index = attr; 331 velements[attr].nr_components = arrays[mesaAttr]->Size; 332 velements[attr].src_format 333 = pipe_vertex_format(arrays[mesaAttr]->Type, 334 arrays[mesaAttr]->Size, 335 arrays[mesaAttr]->Normalized); 336 assert(velements[attr].src_format); 337 } 338 339#if 0 340 { 341 GLuint i; 342 char buf[100]; 343 for (i = 0; i < vp->num_inputs; i++) { 344 printf("buffers[%d].pitch = %u\n", i, vbuffer[i].pitch); 345 printf("buffers[%d].max_index = %u\n", i, vbuffer[i].max_index); 346 printf("buffers[%d].buffer_offset = %u\n", i, vbuffer[i].buffer_offset); 347 printf("buffers[%d].buffer = %p\n", i, (void*) vbuffer[i].buffer); 348 } 349 for (i = 0; i < vp->num_inputs; i++) { 350 printf("vlements[%d].src_offset = %u\n", i, velements[i].src_offset); 351 printf("vlements[%d].vbuffer_index = %u\n", i, velements[i].vertex_buffer_index); 352 printf("vlements[%d].nr_comps = %u\n", i, velements[i].nr_components); 353 printf("vlements[%d].format = %s\n", i, pf_sprint_name(buf, velements[i].src_format)); 354 } 355 } 356#endif 357 358 pipe->set_vertex_buffers(pipe, vp->num_inputs, vbuffer); 359 pipe->set_vertex_elements(pipe, vp->num_inputs, velements); 360 361 /* do actual drawing */ 362 if (ib) { 363 /* indexed primitive */ 364 struct gl_buffer_object *bufobj = ib->obj; 365 struct pipe_buffer *indexBuf = NULL; 366 unsigned indexSize, indexOffset, i; 367 368 switch (ib->type) { 369 case GL_UNSIGNED_INT: 370 indexSize = 4; 371 break; 372 case GL_UNSIGNED_SHORT: 373 indexSize = 2; 374 break; 375 case GL_UNSIGNED_BYTE: 376 indexSize = 1; 377 break; 378 default: 379 assert(0); 380 return; 381 } 382 383 /* get/create the index buffer object */ 384 if (bufobj && bufobj->Name) { 385 /* elements/indexes are in a real VBO */ 386 struct st_buffer_object *stobj = st_buffer_object(bufobj); 387 pipe_reference_buffer(pipe, &indexBuf, stobj->buffer); 388 indexOffset = (unsigned) ib->ptr / indexSize; 389 } 390 else { 391 /* element/indicies are in user space memory */ 392 indexBuf = pipe_user_buffer_create(pipe, (void *) ib->ptr, 393 ib->count * indexSize); 394 indexOffset = 0; 395 } 396 397 /* draw */ 398 if (nr_prims == 1 && pipe->draw_range_elements != NULL) { 399 i = 0; 400 401 /* XXX: exercise temporary path to pass min/max directly 402 * through to driver & draw module. These interfaces still 403 * need a bit of work... 404 */ 405 setup_edgeflags(ctx, prims[i].mode, 406 prims[i].start + indexOffset, prims[i].count, 407 arrays[VERT_ATTRIB_EDGEFLAG]); 408 409 pipe->draw_range_elements(pipe, indexBuf, indexSize, 410 min_index, 411 max_index, 412 prims[i].mode, 413 prims[i].start + indexOffset, prims[i].count); 414 } 415 else { 416 for (i = 0; i < nr_prims; i++) { 417 setup_edgeflags(ctx, prims[i].mode, 418 prims[i].start + indexOffset, prims[i].count, 419 arrays[VERT_ATTRIB_EDGEFLAG]); 420 421 pipe->draw_elements(pipe, indexBuf, indexSize, 422 prims[i].mode, 423 prims[i].start + indexOffset, prims[i].count); 424 } 425 } 426 427 pipe_reference_buffer(pipe, &indexBuf, NULL); 428 } 429 else { 430 /* non-indexed */ 431 GLuint i; 432 for (i = 0; i < nr_prims; i++) { 433 setup_edgeflags(ctx, prims[i].mode, 434 prims[i].start, prims[i].count, 435 arrays[VERT_ATTRIB_EDGEFLAG]); 436 437 pipe->draw_arrays(pipe, prims[i].mode, prims[i].start, prims[i].count); 438 } 439 } 440 441 /* unreference buffers (frees wrapped user-space buffer objects) */ 442 for (attr = 0; attr < vp->num_inputs; attr++) { 443 pipe_reference_buffer(pipe, &vbuffer[attr].buffer, NULL); 444 assert(!vbuffer[attr].buffer); 445 } 446 pipe->set_vertex_buffers(pipe, vp->num_inputs, vbuffer); 447} 448 449 450#if FEATURE_feedback || FEATURE_drawpix 451 452/** 453 * Set the (private) draw module's post-transformed vertex format when in 454 * GL_SELECT or GL_FEEDBACK mode or for glRasterPos. 455 */ 456static void 457set_feedback_vertex_format(GLcontext *ctx) 458{ 459#if 0 460 struct st_context *st = ctx->st; 461 struct vertex_info vinfo; 462 GLuint i; 463 464 memset(&vinfo, 0, sizeof(vinfo)); 465 466 if (ctx->RenderMode == GL_SELECT) { 467 assert(ctx->RenderMode == GL_SELECT); 468 vinfo.num_attribs = 1; 469 vinfo.format[0] = FORMAT_4F; 470 vinfo.interp_mode[0] = INTERP_LINEAR; 471 } 472 else { 473 /* GL_FEEDBACK, or glRasterPos */ 474 /* emit all attribs (pos, color, texcoord) as GLfloat[4] */ 475 vinfo.num_attribs = st->state.vs->cso->state.num_outputs; 476 for (i = 0; i < vinfo.num_attribs; i++) { 477 vinfo.format[i] = FORMAT_4F; 478 vinfo.interp_mode[i] = INTERP_LINEAR; 479 } 480 } 481 482 draw_set_vertex_info(st->draw, &vinfo); 483#endif 484} 485 486 487/** 488 * Called by VBO to draw arrays when in selection or feedback mode and 489 * to implement glRasterPos. 490 * This is very much like the normal draw_vbo() function above. 491 * Look at code refactoring some day. 492 * Might move this into the failover module some day. 493 */ 494void 495st_feedback_draw_vbo(GLcontext *ctx, 496 const struct gl_client_array **arrays, 497 const struct _mesa_prim *prims, 498 GLuint nr_prims, 499 const struct _mesa_index_buffer *ib, 500 GLuint min_index, 501 GLuint max_index) 502{ 503 struct st_context *st = ctx->st; 504 struct pipe_context *pipe = st->pipe; 505 struct draw_context *draw = st->draw; 506 const struct st_vertex_program *vp; 507 const struct pipe_shader_state *vs; 508 struct pipe_buffer *index_buffer_handle = 0; 509 struct pipe_vertex_buffer vbuffers[PIPE_MAX_SHADER_INPUTS]; 510 struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS]; 511 GLuint attr, i; 512 ubyte *mapped_constants; 513 514 assert(draw); 515 516 st_validate_state(ctx->st); 517 518 /* must get these after state validation! */ 519 vp = ctx->st->vp; 520 vs = &st->vp->state; 521 522 if (!st->vp->draw_shader) { 523 st->vp->draw_shader = draw_create_vertex_shader(draw, vs); 524 } 525 526 /* 527 * Set up the draw module's state. 528 * 529 * We'd like to do this less frequently, but the normal state-update 530 * code sends state updates to the pipe, not to our private draw module. 531 */ 532 assert(draw); 533 draw_set_viewport_state(draw, &st->state.viewport); 534 draw_set_clip_state(draw, &st->state.clip); 535 draw_set_rasterizer_state(draw, &st->state.rasterizer); 536 draw_bind_vertex_shader(draw, st->vp->draw_shader); 537 set_feedback_vertex_format(ctx); 538 539 /* loop over TGSI shader inputs to determine vertex buffer 540 * and attribute info 541 */ 542 for (attr = 0; attr < vp->num_inputs; attr++) { 543 const GLuint mesaAttr = vp->index_to_input[attr]; 544 struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj; 545 void *map; 546 547 if (bufobj && bufobj->Name) { 548 /* Attribute data is in a VBO. 549 * Recall that for VBOs, the gl_client_array->Ptr field is 550 * really an offset from the start of the VBO, not a pointer. 551 */ 552 struct st_buffer_object *stobj = st_buffer_object(bufobj); 553 assert(stobj->buffer); 554 555 vbuffers[attr].buffer = NULL; 556 pipe_reference_buffer(pipe, &vbuffers[attr].buffer, stobj->buffer); 557 vbuffers[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */ 558 velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr; 559 } 560 else { 561 /* attribute data is in user-space memory, not a VBO */ 562 uint bytes = (arrays[mesaAttr]->Size 563 * _mesa_sizeof_type(arrays[mesaAttr]->Type) 564 * (max_index + 1)); 565 566 /* wrap user data */ 567 vbuffers[attr].buffer 568 = pipe_user_buffer_create(pipe, (void *) arrays[mesaAttr]->Ptr, 569 bytes); 570 vbuffers[attr].buffer_offset = 0; 571 velements[attr].src_offset = 0; 572 } 573 574 /* common-case setup */ 575 vbuffers[attr].pitch = arrays[mesaAttr]->StrideB; /* in bytes */ 576 vbuffers[attr].max_index = max_index; 577 velements[attr].vertex_buffer_index = attr; 578 velements[attr].nr_components = arrays[mesaAttr]->Size; 579 velements[attr].src_format = pipe_vertex_format(arrays[mesaAttr]->Type, 580 arrays[mesaAttr]->Size, 581 arrays[mesaAttr]->Normalized); 582 assert(velements[attr].src_format); 583 584 /* tell draw about this attribute */ 585#if 0 586 draw_set_vertex_buffer(draw, attr, &vbuffer[attr]); 587#endif 588 589 /* map the attrib buffer */ 590 map = pipe_buffer_map(pipe, vbuffers[attr].buffer, 591 PIPE_BUFFER_USAGE_CPU_READ); 592 draw_set_mapped_vertex_buffer(draw, attr, map); 593 } 594 595 draw_set_vertex_buffers(draw, vp->num_inputs, vbuffers); 596 draw_set_vertex_elements(draw, vp->num_inputs, velements); 597 598 if (ib) { 599 unsigned indexSize; 600 struct gl_buffer_object *bufobj = ib->obj; 601 struct st_buffer_object *stobj = st_buffer_object(bufobj); 602 void *map; 603 604 index_buffer_handle = stobj->buffer; 605 606 switch (ib->type) { 607 case GL_UNSIGNED_INT: 608 indexSize = 4; 609 break; 610 case GL_UNSIGNED_SHORT: 611 indexSize = 2; 612 break; 613 default: 614 assert(0); 615 return; 616 } 617 618 map = pipe_buffer_map(pipe, index_buffer_handle, 619 PIPE_BUFFER_USAGE_CPU_READ); 620 draw_set_mapped_element_buffer(draw, indexSize, map); 621 } 622 else { 623 /* no index/element buffer */ 624 draw_set_mapped_element_buffer(draw, 0, NULL); 625 } 626 627 628 /* map constant buffers */ 629 mapped_constants = pipe_buffer_map(pipe, 630 st->state.constants[PIPE_SHADER_VERTEX].buffer, 631 PIPE_BUFFER_USAGE_CPU_READ); 632 draw_set_mapped_constant_buffer(st->draw, mapped_constants, 633 st->state.constants[PIPE_SHADER_VERTEX].buffer->size); 634 635 636 /* draw here */ 637 for (i = 0; i < nr_prims; i++) { 638 draw_arrays(draw, prims[i].mode, prims[i].start, prims[i].count); 639 } 640 641 642 /* unmap constant buffers */ 643 pipe_buffer_unmap(pipe, st->state.constants[PIPE_SHADER_VERTEX].buffer); 644 645 /* 646 * unmap vertex/index buffers 647 */ 648 for (i = 0; i < PIPE_MAX_ATTRIBS; i++) { 649 if (draw->pt.vertex_buffer[i].buffer) { 650 pipe_buffer_unmap(pipe, draw->pt.vertex_buffer[i].buffer); 651 pipe_reference_buffer(pipe, &draw->pt.vertex_buffer[i].buffer, NULL); 652 draw_set_mapped_vertex_buffer(draw, i, NULL); 653 } 654 } 655 if (ib) { 656 pipe_buffer_unmap(pipe, index_buffer_handle); 657 draw_set_mapped_element_buffer(draw, 0, NULL); 658 } 659} 660 661#endif /* FEATURE_feedback || FEATURE_drawpix */ 662 663 664void st_init_draw( struct st_context *st ) 665{ 666 GLcontext *ctx = st->ctx; 667 668 vbo_set_draw_func(ctx, st_draw_vbo); 669} 670 671 672void st_destroy_draw( struct st_context *st ) 673{ 674} 675 676 677