st_draw.c revision c31416971e4eac148f8e82d6c4392bd6f9cbc05d
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_atom.h" 39#include "st_cache.h" 40#include "st_context.h" 41#include "st_cb_bufferobjects.h" 42#include "st_draw.h" 43#include "st_program.h" 44 45#include "pipe/p_context.h" 46#include "pipe/p_defines.h" 47#include "pipe/p_winsys.h" 48 49#include "pipe/draw/draw_private.h" 50#include "pipe/draw/draw_context.h" 51 52 53static GLuint double_types[4] = { 54 PIPE_FORMAT_R64_FLOAT, 55 PIPE_FORMAT_R64G64_FLOAT, 56 PIPE_FORMAT_R64G64B64_FLOAT, 57 PIPE_FORMAT_R64G64B64A64_FLOAT 58}; 59 60static GLuint float_types[4] = { 61 PIPE_FORMAT_R32_FLOAT, 62 PIPE_FORMAT_R32G32_FLOAT, 63 PIPE_FORMAT_R32G32B32_FLOAT, 64 PIPE_FORMAT_R32G32B32A32_FLOAT 65}; 66 67static 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 72}; 73 74static 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 79}; 80 81static 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 86}; 87 88static 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 93}; 94 95static 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 100}; 101 102static 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 107}; 108 109static 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 114}; 115 116static 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 121}; 122 123static 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 128}; 129 130static 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 135}; 136 137static 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 142}; 143 144static 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 149}; 150 151 152/** 153 * Return a PIPE_FORMAT_x for the given GL datatype and size. 154 */ 155static GLuint 156pipe_vertex_format(GLenum type, GLuint size, GLboolean normalized) 157{ 158 assert(type >= GL_BYTE); 159 assert(type <= GL_DOUBLE); 160 assert(size >= 1); 161 assert(size <= 4); 162 163 if (normalized) { 164 switch (type) { 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; 174 } 175 } 176 else { 177 switch (type) { 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; 187 } 188 } 189 return 0; /* silence compiler warning */ 190} 191 192 193/** 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. 197 */ 198static void 199create_default_attribs_buffer(struct st_context *st) 200{ 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 ); 204} 205 206 207static void 208destroy_default_attribs_buffer(struct st_context *st) 209{ 210 struct pipe_context *pipe = st->pipe; 211 pipe->winsys->buffer_reference(pipe->winsys, 212 &st->default_attrib_buffer, NULL); 213} 214 215 216/** 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. 220 */ 221void 222st_draw_vbo(GLcontext *ctx, 223 const struct gl_client_array **arrays, 224 const struct _mesa_prim *prims, 225 GLuint nr_prims, 226 const struct _mesa_index_buffer *ib, 227 GLuint min_index, 228 GLuint max_index) 229{ 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]; 235 GLuint attr; 236 237 /* sanity check for pointer arithmetic below */ 238 assert(sizeof(arrays[0]->Ptr[0]) == 1); 239 240 st_validate_state(ctx->st); 241 242 /* must get these after state validation! */ 243 vp = ctx->st->vp; 244 vs = &ctx->st->state.vs->state; 245 246 /* loop over TGSI shader inputs to determine vertex buffer 247 * and attribute info 248 */ 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; 253 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. 258 */ 259 struct st_buffer_object *stobj = st_buffer_object(bufobj); 260 assert(stobj->buffer); 261 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 */ 267 } 268 else { 269 /* attribute data is in user-space memory, not a VBO */ 270 uint bytes; 271 272 if (!arrays[mesaAttr]->StrideB) { 273 bytes = arrays[mesaAttr]->Size 274 * _mesa_sizeof_type(arrays[mesaAttr]->Type); 275 } else { 276 bytes = arrays[mesaAttr]->StrideB * (max_index + 1); 277 } 278 279 /* wrap user data */ 280 vbuffer[attr].buffer 281 = winsys->user_buffer_create(winsys, 282 (void *) arrays[mesaAttr]->Ptr, 283 bytes); 284 vbuffer[attr].buffer_offset = 0; 285 velement.src_offset = 0; 286 } 287 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); 297 298 /* tell pipe about this attribute */ 299 pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]); 300 pipe->set_vertex_element(pipe, attr, &velement); 301 } 302 303 304 /* do actual drawing */ 305 if (ib) { 306 /* indexed primitive */ 307 struct gl_buffer_object *bufobj = ib->obj; 308 struct pipe_buffer_handle *indexBuf = NULL; 309 unsigned indexSize, indexOffset, i; 310 311 switch (ib->type) { 312 case GL_UNSIGNED_INT: 313 indexSize = 4; 314 break; 315 case GL_UNSIGNED_SHORT: 316 indexSize = 2; 317 break; 318 case GL_UNSIGNED_BYTE: 319 indexSize = 1; 320 break; 321 default: 322 assert(0); 323 } 324 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; 331 } 332 else { 333 /* element/indicies are in user space memory */ 334 indexBuf = winsys->user_buffer_create(winsys, 335 (void *) ib->ptr, 336 ib->count * indexSize); 337 indexOffset = 0; 338 } 339 340 /* draw */ 341 for (i = 0; i < nr_prims; i++) { 342 pipe->draw_elements(pipe, indexBuf, indexSize, 343 prims[i].mode, 344 prims[i].start + indexOffset, prims[i].count); 345 } 346 347 winsys->buffer_reference(winsys, &indexBuf, NULL); 348 } 349 else { 350 /* non-indexed */ 351 GLuint i; 352 for (i = 0; i < nr_prims; i++) { 353 pipe->draw_arrays(pipe, prims[i].mode, prims[i].start, prims[i].count); 354 } 355 } 356 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]); 362 } 363} 364 365 366 367/** 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 374 */ 375void 376st_draw_vertices(GLcontext *ctx, unsigned prim, 377 unsigned numVertex, float *verts, 378 unsigned numAttribs) 379{ 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; 387 unsigned i; 388 389 assert(numAttribs > 0); 390 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; 399 } 400 401 /* XXX create one-time */ 402 vbuf = pipe->winsys->buffer_create(pipe->winsys, 32, 0, 0); 403 pipe->winsys->buffer_data(pipe->winsys, vbuf, 404 vertex_bytes, verts, 405 PIPE_BUFFER_USAGE_VERTEX); 406 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); 412 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); 420 } 421 422 /* draw */ 423 pipe->draw_arrays(pipe, prim, 0, numVertex); 424 425 /* XXX: do one-time */ 426 pipe->winsys->buffer_reference(pipe->winsys, &vbuf, NULL); 427} 428 429 430/** 431 * Set the (private) draw module's post-transformed vertex format when in 432 * GL_SELECT or GL_FEEDBACK mode or for glRasterPos. 433 */ 434static void 435set_feedback_vertex_format(GLcontext *ctx) 436{ 437 struct st_context *st = ctx->st; 438 struct vertex_info vinfo; 439 GLuint i; 440 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; 446 } 447 else { 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; 454 } 455 } 456 457 draw_set_vertex_info(st->draw, &vinfo); 458} 459 460 461/** 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. 467 */ 468void 469st_feedback_draw_vbo(GLcontext *ctx, 470 const struct gl_client_array **arrays, 471 const struct _mesa_prim *prims, 472 GLuint nr_prims, 473 const struct _mesa_index_buffer *ib, 474 GLuint min_index, 475 GLuint max_index) 476{ 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]; 485 GLuint attr, i; 486 ubyte *mapped_constants; 487 488 assert(draw); 489 490 st_validate_state(ctx->st); 491 492 /* must get these after state validation! */ 493 vp = ctx->st->vp; 494 vs = &ctx->st->state.vs->state; 495 496 /* 497 * Set up the draw module's state. 498 * 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. 501 */ 502 assert(draw); 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); 508 509 /* loop over TGSI shader inputs to determine vertex buffer 510 * and attribute info 511 */ 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; 516 void *map; 517 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. 522 */ 523 struct st_buffer_object *stobj = st_buffer_object(bufobj); 524 assert(stobj->buffer); 525 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; 530 } 531 else { 532 /* attribute data is in user-space memory, not a VBO */ 533 uint bytes = (arrays[mesaAttr]->Size 534 * _mesa_sizeof_type(arrays[mesaAttr]->Type) 535 * (max_index + 1)); 536 537 /* wrap user data */ 538 vbuffer[attr].buffer 539 = winsys->user_buffer_create(winsys, 540 (void *) arrays[mesaAttr]->Ptr, 541 bytes); 542 vbuffer[attr].buffer_offset = 0; 543 velement.src_offset = 0; 544 } 545 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); 555 556 /* tell draw about this attribute */ 557 draw_set_vertex_buffer(draw, attr, &vbuffer[attr]); 558 draw_set_vertex_element(draw, attr, &velement); 559 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); 565 } 566 567 if (ib) { 568 unsigned indexSize; 569 struct gl_buffer_object *bufobj = ib->obj; 570 struct st_buffer_object *stobj = st_buffer_object(bufobj); 571 index_buffer_handle = stobj->buffer; 572 void *map; 573 574 switch (ib->type) { 575 case GL_UNSIGNED_INT: 576 indexSize = 4; 577 break; 578 case GL_UNSIGNED_SHORT: 579 indexSize = 2; 580 break; 581 default: 582 assert(0); 583 } 584 585 map = pipe->winsys->buffer_map(pipe->winsys, 586 index_buffer_handle, 587 PIPE_BUFFER_FLAG_READ); 588 draw_set_mapped_element_buffer(draw, indexSize, map); 589 } 590 else { 591 /* no index/element buffer */ 592 draw_set_mapped_element_buffer(draw, 0, NULL); 593 } 594 595 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); 601 602 603 /* draw here */ 604 for (i = 0; i < nr_prims; i++) { 605 draw_arrays(draw, prims[i].mode, prims[i].start, prims[i].count); 606 } 607 608 609 /* unmap constant buffers */ 610 winsys->buffer_unmap(winsys, st->state.constants[PIPE_SHADER_VERTEX].buffer); 611 612 /* 613 * unmap vertex/index buffers 614 */ 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); 620 } 621 } 622 if (ib) { 623 pipe->winsys->buffer_unmap(pipe->winsys, index_buffer_handle); 624 draw_set_mapped_element_buffer(draw, 0, NULL); 625 } 626} 627 628 629 630void st_init_draw( struct st_context *st ) 631{ 632 GLcontext *ctx = st->ctx; 633 634 /* actually, not used here, but elsewhere */ 635 create_default_attribs_buffer(st); 636 637 vbo_set_draw_func(ctx, st_draw_vbo); 638} 639 640 641void st_destroy_draw( struct st_context *st ) 642{ 643 destroy_default_attribs_buffer(st); 644} 645 646 647