projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'lp-offset-twoside'
[mesa.git] / src / mesa / drivers / dri / r300 / r300_draw.c
1 /**************************************************************************
2 *
3 * Copyright 2009 Maciej Cencora
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
15 * of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL THE AUTHOR(S) AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 **************************************************************************/
26
27 #include <stdlib.h>
28
29 #include "main/glheader.h"
30 #include "main/context.h"
31 #include "main/state.h"
32 #include "main/enums.h"
33 #include "main/simple_list.h"
34
35 #include "r300_reg.h"
36 #include "r300_context.h"
37 #include "r300_emit.h"
38 #include "r300_render.h"
39 #include "r300_state.h"
40 #include "r300_tex.h"
41 #include "r300_cmdbuf.h"
42
43 #include "radeon_buffer_objects.h"
44 #include "radeon_common_context.h"
45
46 #include "tnl/tnl.h"
47 #include "tnl/t_vp_build.h"
48 #include "vbo/vbo_context.h"
49
50
51 static int getTypeSize(GLenum type)
52 {
53 switch (type) {
54 case GL_DOUBLE:
55 return sizeof(GLdouble);
56 case GL_HALF_FLOAT:
57 return sizeof(GLhalfARB);
58 case GL_FLOAT:
59 return sizeof(GLfloat);
60 case GL_INT:
61 return sizeof(GLint);
62 case GL_UNSIGNED_INT:
63 return sizeof(GLuint);
64 case GL_SHORT:
65 return sizeof(GLshort);
66 case GL_UNSIGNED_SHORT:
67 return sizeof(GLushort);
68 case GL_BYTE:
69 return sizeof(GLbyte);
70 case GL_UNSIGNED_BYTE:
71 return sizeof(GLubyte);
72 default:
73 assert(0);
74 return 0;
75 }
76 }
77
78 static void r300FixupIndexBuffer(struct gl_context *ctx, const struct _mesa_index_buffer *mesa_ind_buf)
79 {
80 r300ContextPtr r300 = R300_CONTEXT(ctx);
81 GLvoid *src_ptr;
82 GLuint *out;
83 int i;
84 GLboolean mapped_named_bo = GL_FALSE;
85
86 if (mesa_ind_buf->obj->Name && !mesa_ind_buf->obj->Pointer) {
87 ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY_ARB, mesa_ind_buf->obj);
88 mapped_named_bo = GL_TRUE;
89 assert(mesa_ind_buf->obj->Pointer != NULL);
90 }
91 src_ptr = ADD_POINTERS(mesa_ind_buf->obj->Pointer, mesa_ind_buf->ptr);
92
93 radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
94 "%s: Fixing index buffer format. type %d\n",
95 __func__, mesa_ind_buf->type);
96
97 if (mesa_ind_buf->type == GL_UNSIGNED_BYTE) {
98 GLuint size = sizeof(GLushort) * ((mesa_ind_buf->count + 1) & ~1);
99 GLubyte *in = (GLubyte *)src_ptr;
100
101 radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo, &r300->ind_buf.bo_offset, size, 4);
102 radeon_bo_map(r300->ind_buf.bo, 1);
103 assert(r300->ind_buf.bo->ptr != NULL);
104 out = (GLuint *)ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
105
106 for (i = 0; i + 1 < mesa_ind_buf->count; i += 2) {
107 *out++ = in[i] | in[i + 1] << 16;
108 }
109
110 if (i < mesa_ind_buf->count) {
111 *out++ = in[i];
112 }
113 radeon_bo_unmap(r300->ind_buf.bo);
114 #if MESA_BIG_ENDIAN
115 } else { /* if (mesa_ind_buf->type == GL_UNSIGNED_SHORT) */
116 GLushort *in = (GLushort *)src_ptr;
117 GLuint size = sizeof(GLushort) * ((mesa_ind_buf->count + 1) & ~1);
118
119 radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo,
120 &r300->ind_buf.bo_offset, size, 4);
121
122 radeon_bo_map(r300->ind_buf.bo, 1);
123 assert(r300->ind_buf.bo->ptr != NULL);
124 out = (GLuint *)ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
125
126 for (i = 0; i + 1 < mesa_ind_buf->count; i += 2) {
127 *out++ = in[i] | in[i + 1] << 16;
128 }
129
130 if (i < mesa_ind_buf->count) {
131 *out++ = in[i];
132 }
133 radeon_bo_unmap(r300->ind_buf.bo);
134 #endif
135 }
136
137 r300->ind_buf.is_32bit = GL_FALSE;
138 r300->ind_buf.count = mesa_ind_buf->count;
139
140 if (mapped_named_bo) {
141 ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, mesa_ind_buf->obj);
142 }
143 }
144
145
146 static void r300SetupIndexBuffer(struct gl_context *ctx, const struct _mesa_index_buffer *mesa_ind_buf)
147 {
148 r300ContextPtr r300 = R300_CONTEXT(ctx);
149
150 if (!mesa_ind_buf) {
151 r300->ind_buf.bo = NULL;
152 return;
153 }
154 radeon_print(RADEON_RENDER, RADEON_TRACE, "%s\n", __func__);
155
156 #if MESA_BIG_ENDIAN
157 if (mesa_ind_buf->type == GL_UNSIGNED_INT) {
158 #else
159 if (mesa_ind_buf->type != GL_UNSIGNED_BYTE) {
160 #endif
161 const GLvoid *src_ptr;
162 GLvoid *dst_ptr;
163 GLboolean mapped_named_bo = GL_FALSE;
164
165 if (mesa_ind_buf->obj->Name && !mesa_ind_buf->obj->Pointer) {
166 ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY_ARB, mesa_ind_buf->obj);
167 assert(mesa_ind_buf->obj->Pointer != NULL);
168 mapped_named_bo = GL_TRUE;
169 }
170
171 src_ptr = ADD_POINTERS(mesa_ind_buf->obj->Pointer, mesa_ind_buf->ptr);
172
173 const GLuint size = mesa_ind_buf->count * getTypeSize(mesa_ind_buf->type);
174
175 radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo, &r300->ind_buf.bo_offset, size, 4);
176
177 radeon_bo_map(r300->ind_buf.bo, 1);
178 assert(r300->ind_buf.bo->ptr != NULL);
179 dst_ptr = ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
180 memcpy(dst_ptr, src_ptr, size);
181
182 radeon_bo_unmap(r300->ind_buf.bo);
183 r300->ind_buf.is_32bit = (mesa_ind_buf->type == GL_UNSIGNED_INT);
184 r300->ind_buf.count = mesa_ind_buf->count;
185
186 if (mapped_named_bo) {
187 ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, mesa_ind_buf->obj);
188 }
189 } else {
190 r300FixupIndexBuffer(ctx, mesa_ind_buf);
191 }
192 }
193
194 #define CONVERT( TYPE, MACRO ) do { \
195 GLuint i, j, sz; \
196 sz = input->Size; \
197 if (input->Normalized) { \
198 for (i = 0; i < count; i++) { \
199 const TYPE *in = (TYPE *)src_ptr; \
200 for (j = 0; j < sz; j++) { \
201 *dst_ptr++ = MACRO(*in); \
202 in++; \
203 } \
204 src_ptr += stride; \
205 } \
206 } else { \
207 for (i = 0; i < count; i++) { \
208 const TYPE *in = (TYPE *)src_ptr; \
209 for (j = 0; j < sz; j++) { \
210 *dst_ptr++ = (GLfloat)(*in); \
211 in++; \
212 } \
213 src_ptr += stride; \
214 } \
215 } \
216 } while (0)
217
218 /**
219 * Convert attribute data type to float
220 * If the attribute uses named buffer object replace the bo with newly allocated bo
221 */
222 static void r300ConvertAttrib(struct gl_context *ctx, int count, const struct gl_client_array *input, struct vertex_attribute *attr)
223 {
224 r300ContextPtr r300 = R300_CONTEXT(ctx);
225 const GLvoid *src_ptr;
226 GLboolean mapped_named_bo = GL_FALSE;
227 GLfloat *dst_ptr;
228 GLuint stride;
229
230 stride = (input->StrideB == 0) ? getTypeSize(input->Type) * input->Size : input->StrideB;
231
232 /* Convert value for first element only */
233 if (input->StrideB == 0)
234 count = 1;
235
236 if (input->BufferObj->Name) {
237 if (!input->BufferObj->Pointer) {
238 ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER, GL_READ_ONLY_ARB, input->BufferObj);
239 mapped_named_bo = GL_TRUE;
240 }
241
242 src_ptr = ADD_POINTERS(input->BufferObj->Pointer, input->Ptr);
243 } else {
244 src_ptr = input->Ptr;
245 }
246
247 radeonAllocDmaRegion(&r300->radeon, &attr->bo, &attr->bo_offset, sizeof(GLfloat) * input->Size * count, 32);
248 radeon_bo_map(attr->bo, 1);
249 dst_ptr = (GLfloat *)ADD_POINTERS(attr->bo->ptr, attr->bo_offset);
250
251 radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
252 "%s: Converting vertex attributes, attribute data format %x,"
253 "stride %d, components %d\n"
254 , __FUNCTION__, input->Type
255 , stride, input->Size);
256
257 assert(src_ptr != NULL);
258
259 switch (input->Type) {
260 case GL_DOUBLE:
261 CONVERT(GLdouble, (GLfloat));
262 break;
263 case GL_UNSIGNED_INT:
264 CONVERT(GLuint, UINT_TO_FLOAT);
265 break;
266 case GL_INT:
267 CONVERT(GLint, INT_TO_FLOAT);
268 break;
269 case GL_UNSIGNED_SHORT:
270 CONVERT(GLushort, USHORT_TO_FLOAT);
271 break;
272 case GL_SHORT:
273 CONVERT(GLshort, SHORT_TO_FLOAT);
274 break;
275 case GL_UNSIGNED_BYTE:
276 assert(input->Format != GL_BGRA);
277 CONVERT(GLubyte, UBYTE_TO_FLOAT);
278 break;
279 case GL_BYTE:
280 CONVERT(GLbyte, BYTE_TO_FLOAT);
281 break;
282 default:
283 assert(0);
284 break;
285 }
286
287 radeon_bo_unmap(attr->bo);
288 if (mapped_named_bo) {
289 ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, input->BufferObj);
290 }
291 }
292
293 static void r300AlignDataToDword(struct gl_context *ctx, const struct gl_client_array *input, int count, struct vertex_attribute *attr)
294 {
295 r300ContextPtr r300 = R300_CONTEXT(ctx);
296 const int dst_stride = (input->StrideB + 3) & ~3;
297 const int size = getTypeSize(input->Type) * input->Size * count;
298 GLboolean mapped_named_bo = GL_FALSE;
299
300 radeonAllocDmaRegion(&r300->radeon, &attr->bo, &attr->bo_offset, size, 32);
301
302 radeon_bo_map(attr->bo, 1);
303
304 if (!input->BufferObj->Pointer) {
305 ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER, GL_READ_ONLY_ARB, input->BufferObj);
306 mapped_named_bo = GL_TRUE;
307 }
308
309 radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT, "%s. Vertex alignment doesn't match hw requirements.\n", __func__);
310
311 {
312 GLvoid *src_ptr = ADD_POINTERS(input->BufferObj->Pointer, input->Ptr);
313 GLvoid *dst_ptr = ADD_POINTERS(attr->bo->ptr, attr->bo_offset);
314 int i;
315
316 for (i = 0; i < count; ++i) {
317 memcpy(dst_ptr, src_ptr, input->StrideB);
318 src_ptr += input->StrideB;
319 dst_ptr += dst_stride;
320 }
321 }
322
323 if (mapped_named_bo) {
324 ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, input->BufferObj);
325 }
326
327 radeon_bo_unmap(attr->bo);
328 attr->stride = dst_stride;
329 }
330
331 static void r300TranslateAttrib(struct gl_context *ctx, GLuint attr, int count, const struct gl_client_array *input)
332 {
333 r300ContextPtr r300 = R300_CONTEXT(ctx);
334 struct r300_vertex_buffer *vbuf = &r300->vbuf;
335 struct vertex_attribute r300_attr = { 0 };
336 GLenum type;
337 GLuint stride;
338
339 radeon_print(RADEON_RENDER, RADEON_TRACE, "%s\n", __func__);
340 stride = (input->StrideB == 0) ? getTypeSize(input->Type) * input->Size : input->StrideB;
341
342 if (input->Type == GL_DOUBLE || input->Type == GL_UNSIGNED_INT || input->Type == GL_INT ||
343 #if MESA_BIG_ENDIAN
344 getTypeSize(input->Type) != 4 ||
345 #endif
346 stride < 4) {
347
348 type = GL_FLOAT;
349
350 if (input->StrideB == 0) {
351 r300_attr.stride = 0;
352 } else {
353 r300_attr.stride = sizeof(GLfloat) * input->Size;
354 }
355 r300_attr.dwords = input->Size;
356 r300_attr.is_named_bo = GL_FALSE;
357 } else {
358 type = input->Type;
359 r300_attr.dwords = (getTypeSize(type) * input->Size + 3)/ 4;
360 if (!input->BufferObj->Name) {
361
362 if (input->StrideB == 0) {
363 r300_attr.stride = 0;
364 } else {
365 r300_attr.stride = (getTypeSize(type) * input->Size + 3) & ~3;
366 }
367
368 r300_attr.is_named_bo = GL_FALSE;
369 }
370 }
371
372 r300_attr.size = input->Size;
373 r300_attr.element = attr;
374 r300_attr.dst_loc = vbuf->num_attribs;
375
376 switch (type) {
377 case GL_FLOAT:
378 switch (input->Size) {
379 case 1: r300_attr.data_type = R300_DATA_TYPE_FLOAT_1; break;
380 case 2: r300_attr.data_type = R300_DATA_TYPE_FLOAT_2; break;
381 case 3: r300_attr.data_type = R300_DATA_TYPE_FLOAT_3; break;
382 case 4: r300_attr.data_type = R300_DATA_TYPE_FLOAT_4; break;
383 }
384 r300_attr._signed = 0;
385 r300_attr.normalize = 0;
386 break;
387 case GL_HALF_FLOAT:
388 switch (input->Size) {
389 case 1:
390 case 2:
391 r300_attr.data_type = R300_DATA_TYPE_FLT16_2;
392 break;
393 case 3:
394 case 4:
395 r300_attr.data_type = R300_DATA_TYPE_FLT16_4;
396 break;
397 }
398 break;
399 case GL_SHORT:
400 r300_attr._signed = 1;
401 r300_attr.normalize = input->Normalized;
402 switch (input->Size) {
403 case 1:
404 case 2:
405 r300_attr.data_type = R300_DATA_TYPE_SHORT_2;
406 break;
407 case 3:
408 case 4:
409 r300_attr.data_type = R300_DATA_TYPE_SHORT_4;
410 break;
411 }
412 break;
413 case GL_BYTE:
414 r300_attr._signed = 1;
415 r300_attr.normalize = input->Normalized;
416 r300_attr.data_type = R300_DATA_TYPE_BYTE;
417 break;
418 case GL_UNSIGNED_SHORT:
419 r300_attr._signed = 0;
420 r300_attr.normalize = input->Normalized;
421 switch (input->Size) {
422 case 1:
423 case 2:
424 r300_attr.data_type = R300_DATA_TYPE_SHORT_2;
425 break;
426 case 3:
427 case 4:
428 r300_attr.data_type = R300_DATA_TYPE_SHORT_4;
429 break;
430 }
431 break;
432 case GL_UNSIGNED_BYTE:
433 r300_attr._signed = 0;
434 r300_attr.normalize = input->Normalized;
435 if (input->Format == GL_BGRA)
436 r300_attr.data_type = R300_DATA_TYPE_D3DCOLOR;
437 else
438 r300_attr.data_type = R300_DATA_TYPE_BYTE;
439 break;
440
441 default:
442 case GL_DOUBLE:
443 case GL_INT:
444 case GL_UNSIGNED_INT:
445 assert(0);
446 break;
447 }
448
449 switch (input->Size) {
450 case 4:
451 r300_attr.swizzle = SWIZZLE_XYZW;
452 break;
453 case 3:
454 r300_attr.swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ONE);
455 break;
456 case 2:
457 r300_attr.swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_ZERO, SWIZZLE_ONE);
458 break;
459 case 1:
460 r300_attr.swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO, SWIZZLE_ZERO, SWIZZLE_ONE);
461 break;
462 }
463
464 r300_attr.write_mask = MASK_XYZW;
465
466 vbuf->attribs[vbuf->num_attribs] = r300_attr;
467 ++vbuf->num_attribs;
468 }
469
470 static void r300SetVertexFormat(struct gl_context *ctx, const struct gl_client_array *arrays[], int count)
471 {
472 r300ContextPtr r300 = R300_CONTEXT(ctx);
473 struct r300_vertex_buffer *vbuf = &r300->vbuf;
474 radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s\n", __func__);
475 {
476 int i, tmp;
477
478 tmp = r300->selected_vp->code.InputsRead;
479 i = 0;
480 vbuf->num_attribs = 0;
481 while (tmp) {
482 /* find first enabled bit */
483 while (!(tmp & 1)) {
484 tmp >>= 1;
485 ++i;
486 }
487
488 r300TranslateAttrib(ctx, i, count, arrays[i]);
489
490 tmp >>= 1;
491 ++i;
492 }
493 }
494
495 r300SwitchFallback(ctx, R300_FALLBACK_AOS_LIMIT, vbuf->num_attribs > R300_MAX_AOS_ARRAYS);
496 if (r300->fallback)
497 return;
498 }
499
500 static void r300AllocDmaRegions(struct gl_context *ctx, const struct gl_client_array *input[], int count)
501 {
502 r300ContextPtr r300 = R300_CONTEXT(ctx);
503 struct r300_vertex_buffer *vbuf = &r300->vbuf;
504 GLuint stride;
505 int ret;
506 int i, index;
507 radeon_print(RADEON_RENDER, RADEON_VERBOSE,
508 "%s: count %d num_attribs %d\n",
509 __func__, count, vbuf->num_attribs);
510
511 for (index = 0; index < vbuf->num_attribs; index++) {
512 struct radeon_aos *aos = &r300->radeon.tcl.aos[index];
513 i = vbuf->attribs[index].element;
514
515 stride = (input[i]->StrideB == 0) ? getTypeSize(input[i]->Type) * input[i]->Size : input[i]->StrideB;
516
517 if (input[i]->Type == GL_DOUBLE || input[i]->Type == GL_UNSIGNED_INT || input[i]->Type == GL_INT ||
518 #if MESA_BIG_ENDIAN
519 getTypeSize(input[i]->Type) != 4 ||
520 #endif
521 stride < 4) {
522
523 r300ConvertAttrib(ctx, count, input[i], &vbuf->attribs[index]);
524 } else {
525 if (input[i]->BufferObj->Name) {
526 if (stride % 4 != 0 || (intptr_t)input[i]->Ptr % 4 != 0) {
527 r300AlignDataToDword(ctx, input[i], count, &vbuf->attribs[index]);
528 vbuf->attribs[index].is_named_bo = GL_FALSE;
529 } else {
530 vbuf->attribs[index].stride = input[i]->StrideB;
531 vbuf->attribs[index].bo_offset = (intptr_t) input[i]->Ptr;
532 vbuf->attribs[index].bo = get_radeon_buffer_object(input[i]->BufferObj)->bo;
533 vbuf->attribs[index].is_named_bo = GL_TRUE;
534 }
535 } else {
536
537 int size;
538 int local_count = count;
539 uint32_t *dst;
540
541 if (input[i]->StrideB == 0) {
542 size = getTypeSize(input[i]->Type) * input[i]->Size;
543 local_count = 1;
544 } else {
545 size = getTypeSize(input[i]->Type) * input[i]->Size * local_count;
546 }
547
548 radeonAllocDmaRegion(&r300->radeon, &vbuf->attribs[index].bo, &vbuf->attribs[index].bo_offset, size, 32);
549 radeon_bo_map(vbuf->attribs[index].bo, 1);
550 assert(vbuf->attribs[index].bo->ptr != NULL);
551 dst = (uint32_t *)ADD_POINTERS(vbuf->attribs[index].bo->ptr, vbuf->attribs[index].bo_offset);
552 switch (vbuf->attribs[index].dwords) {
553 case 1: radeonEmitVec4(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
554 case 2: radeonEmitVec8(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
555 case 3: radeonEmitVec12(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
556 case 4: radeonEmitVec16(dst, input[i]->Ptr, input[i]->StrideB, local_count); break;
557 default: assert(0); break;
558 }
559 radeon_bo_unmap(vbuf->attribs[index].bo);
560
561 }
562 }
563
564 aos->count = vbuf->attribs[index].stride == 0 ? 1 : count;
565 aos->stride = vbuf->attribs[index].stride / sizeof(float);
566 aos->components = vbuf->attribs[index].dwords;
567 aos->bo = vbuf->attribs[index].bo;
568 aos->offset = vbuf->attribs[index].bo_offset;
569
570 if (vbuf->attribs[index].is_named_bo) {
571 radeon_cs_space_add_persistent_bo(r300->radeon.cmdbuf.cs, r300->vbuf.attribs[index].bo, RADEON_GEM_DOMAIN_GTT, 0);
572 }
573 }
574
575 r300->radeon.tcl.aos_count = vbuf->num_attribs;
576 ret = radeon_cs_space_check_with_bo(r300->radeon.cmdbuf.cs, first_elem(&r300->radeon.dma.reserved)->bo, RADEON_GEM_DOMAIN_GTT, 0);
577 r300SwitchFallback(ctx, R300_FALLBACK_INVALID_BUFFERS, ret);
578
579 }
580
581 static void r300FreeData(struct gl_context *ctx)
582 {
583 /* Need to zero tcl.aos[n].bo and tcl.elt_dma_bo
584 * to prevent double unref in radeonReleaseArrays
585 * called during context destroy
586 */
587 radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s\n", __func__);
588 r300ContextPtr r300 = R300_CONTEXT(ctx);
589 {
590 int i;
591
592 for (i = 0; i < r300->vbuf.num_attribs; i++) {
593 if (!r300->vbuf.attribs[i].is_named_bo) {
594 radeon_bo_unref(r300->vbuf.attribs[i].bo);
595 }
596 r300->radeon.tcl.aos[i].bo = NULL;
597 }
598 }
599
600 {
601 if (r300->ind_buf.bo != NULL) {
602 radeon_bo_unref(r300->ind_buf.bo);
603 }
604 }
605 }
606
607 static GLuint r300PredictTryDrawPrimsSize(struct gl_context *ctx,
608 GLuint nr_prims, const struct _mesa_prim *prim)
609 {
610 struct r300_context *r300 = R300_CONTEXT(ctx);
611 struct r300_vertex_buffer *vbuf = &r300->vbuf;
612 GLboolean flushed;
613 GLuint dwords;
614 GLuint state_size;
615 int i;
616 GLuint extra_prims = 0;
617
618 /* Check for primitive splitting. */
619 for (i = 0; i < nr_prims; ++i) {
620 const GLuint num_verts = r300NumVerts(r300, prim[i].count, prim[i].mode);
621 extra_prims += num_verts/(65535 - 32);
622 }
623 nr_prims += extra_prims;
624
625 dwords = 2*CACHE_FLUSH_BUFSZ;
626 dwords += PRE_EMIT_STATE_BUFSZ;
627 dwords += (AOS_BUFSZ(vbuf->num_attribs)
628 + SCISSORS_BUFSZ*2
629 + FIREAOS_BUFSZ )*nr_prims;
630
631 state_size = radeonCountStateEmitSize(&r300->radeon);
632 flushed = rcommonEnsureCmdBufSpace(&r300->radeon,
633 dwords + state_size,
634 __FUNCTION__);
635 if (flushed)
636 dwords += radeonCountStateEmitSize(&r300->radeon);
637 else
638 dwords += state_size;
639
640 radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s: total prediction size is %d.\n", __FUNCTION__, dwords);
641 return dwords;
642 }
643
644 static GLboolean r300TryDrawPrims(struct gl_context *ctx,
645 const struct gl_client_array *arrays[],
646 const struct _mesa_prim *prim,
647 GLuint nr_prims,
648 const struct _mesa_index_buffer *ib,
649 GLuint min_index,
650 GLuint max_index )
651 {
652 struct r300_context *r300 = R300_CONTEXT(ctx);
653 GLuint i;
654
655 radeon_print(RADEON_RENDER, RADEON_NORMAL, "%s: %u (%d-%d) cs begin at %d\n",
656 __FUNCTION__, nr_prims, min_index, max_index, r300->radeon.cmdbuf.cs->cdw );
657
658 if (ctx->NewState)
659 _mesa_update_state( ctx );
660
661 if (r300->options.hw_tcl_enabled)
662 _tnl_UpdateFixedFunctionProgram(ctx);
663
664 r300UpdateShaders(r300);
665
666 r300SwitchFallback(ctx, R300_FALLBACK_INVALID_BUFFERS, !r300ValidateBuffers(ctx));
667
668 r300SetVertexFormat(ctx, arrays, max_index + 1);
669
670 if (r300->fallback)
671 return GL_FALSE;
672
673 r300SetupVAP(ctx, r300->selected_vp->code.InputsRead, r300->selected_vp->code.OutputsWritten);
674
675 r300UpdateShaderStates(r300);
676
677 /* ensure we have the cmd buf space in advance to cover
678 * the state + DMA AOS pointers */
679 GLuint emit_end = r300PredictTryDrawPrimsSize(ctx, nr_prims, prim)
680 + r300->radeon.cmdbuf.cs->cdw;
681
682 r300SetupIndexBuffer(ctx, ib);
683
684 r300AllocDmaRegions(ctx, arrays, max_index + 1);
685
686 if (r300->fallback)
687 return GL_FALSE;
688
689 r300EmitCacheFlush(r300);
690 radeonEmitState(&r300->radeon);
691
692 for (i = 0; i < nr_prims; ++i) {
693 r300RunRenderPrimitive(ctx, prim[i].start, prim[i].start + prim[i].count, prim[i].mode);
694 }
695
696 r300EmitCacheFlush(r300);
697
698 r300FreeData(ctx);
699
700 radeon_print(RADEON_RENDER, RADEON_VERBOSE, "%s: %u (%d-%d) cs ending at %d\n",
701 __FUNCTION__, nr_prims, min_index, max_index, r300->radeon.cmdbuf.cs->cdw );
702
703 if (emit_end < r300->radeon.cmdbuf.cs->cdw)
704 WARN_ONCE("Rendering was %d commands larger than predicted size."
705 " We might overflow command buffer.\n", r300->radeon.cmdbuf.cs->cdw - emit_end);
706
707 return GL_TRUE;
708 }
709
710 static void r300DrawPrims(struct gl_context *ctx,
711 const struct gl_client_array *arrays[],
712 const struct _mesa_prim *prim,
713 GLuint nr_prims,
714 const struct _mesa_index_buffer *ib,
715 GLboolean index_bounds_valid,
716 GLuint min_index,
717 GLuint max_index)
718 {
719 GLboolean retval;
720 struct r300_context *r300 = R300_CONTEXT(ctx);
721 radeonContextPtr radeon = &r300->radeon;
722
723 radeon_prepare_render(radeon);
724
725 /* This check should get folded into just the places that
726 * min/max index are really needed.
727 */
728 if (!index_bounds_valid) {
729 vbo_get_minmax_index(ctx, prim, ib, &min_index, &max_index);
730 }
731
732 if (min_index) {
733 radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
734 "%s: Rebasing primitives. %p nr_prims %d min_index %u max_index %u\n",
735 __func__, prim, nr_prims, min_index, max_index);
736 vbo_rebase_prims( ctx, arrays, prim, nr_prims, ib, min_index, max_index, r300DrawPrims );
737 return;
738 }
739
740 /* Make an attempt at drawing */
741 retval = r300TryDrawPrims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
742
743 /* If failed run tnl pipeline - it should take care of fallbacks */
744 if (!retval)
745 _tnl_draw_prims(ctx, arrays, prim, nr_prims, ib, min_index, max_index);
746 }
747
748 void r300InitDraw(struct gl_context *ctx)
749 {
750 struct vbo_context *vbo = vbo_context(ctx);
751
752 vbo->draw_prims = r300DrawPrims;
753 }