1 /**************************************************************************
3 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
5 The Weather Channel (TM) funded Tungsten Graphics to develop the
6 initial release of the Radeon 8500 driver under the XFree86 license.
7 This notice must be preserved.
9 Permission is hereby granted, free of charge, to any person obtaining
10 a copy of this software and associated documentation files (the
11 "Software"), to deal in the Software without restriction, including
12 without limitation the rights to use, copy, modify, merge, publish,
13 distribute, sublicense, and/or sell copies of the Software, and to
14 permit persons to whom the Software is furnished to do so, subject to
15 the following conditions:
17 The above copyright notice and this permission notice (including the
18 next paragraph) shall be included in all copies or substantial
19 portions of the Software.
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
33 * Keith Whitwell <keith@tungstengraphics.com>
37 - Scissor implementation
38 - buffer swap/copy ioctls
41 - cmdbuffer management
45 #include "main/glheader.h"
46 #include "main/imports.h"
47 #include "main/context.h"
48 #include "main/api_arrayelt.h"
49 #include "main/enums.h"
50 #include "main/colormac.h"
51 #include "main/light.h"
52 #include "main/framebuffer.h"
53 #include "main/simple_list.h"
54 #include "main/renderbuffer.h"
55 #include "swrast/swrast.h"
58 #include "tnl/t_pipeline.h"
59 #include "swrast_setup/swrast_setup.h"
61 #include "main/blend.h"
62 #include "main/bufferobj.h"
63 #include "main/buffers.h"
64 #include "main/depth.h"
65 #include "main/shaders.h"
66 #include "main/texstate.h"
67 #include "main/varray.h"
68 #include "glapi/dispatch.h"
69 #include "swrast/swrast.h"
70 #include "main/stencil.h"
71 #include "main/matrix.h"
72 #include "main/attrib.h"
73 #include "main/enable.h"
74 #include "main/viewport.h"
79 #include "radeon_common.h"
80 #include "radeon_bocs_wrapper.h"
81 #include "radeon_lock.h"
82 #include "radeon_drm.h"
83 #include "radeon_mipmap_tree.h"
85 #define DEBUG_CMDBUF 0
87 /* =============================================================
91 static GLboolean
intersect_rect(drm_clip_rect_t
* out
,
92 drm_clip_rect_t
* a
, drm_clip_rect_t
* b
)
103 if (out
->x1
>= out
->x2
)
105 if (out
->y1
>= out
->y2
)
110 void radeonRecalcScissorRects(radeonContextPtr radeon
)
112 drm_clip_rect_t
*out
;
115 /* Grow cliprect store?
117 if (radeon
->state
.scissor
.numAllocedClipRects
< radeon
->numClipRects
) {
118 while (radeon
->state
.scissor
.numAllocedClipRects
<
119 radeon
->numClipRects
) {
120 radeon
->state
.scissor
.numAllocedClipRects
+= 1; /* zero case */
121 radeon
->state
.scissor
.numAllocedClipRects
*= 2;
124 if (radeon
->state
.scissor
.pClipRects
)
125 FREE(radeon
->state
.scissor
.pClipRects
);
127 radeon
->state
.scissor
.pClipRects
=
128 MALLOC(radeon
->state
.scissor
.numAllocedClipRects
*
129 sizeof(drm_clip_rect_t
));
131 if (radeon
->state
.scissor
.pClipRects
== NULL
) {
132 radeon
->state
.scissor
.numAllocedClipRects
= 0;
137 out
= radeon
->state
.scissor
.pClipRects
;
138 radeon
->state
.scissor
.numClipRects
= 0;
140 for (i
= 0; i
< radeon
->numClipRects
; i
++) {
141 if (intersect_rect(out
,
142 &radeon
->pClipRects
[i
],
143 &radeon
->state
.scissor
.rect
)) {
144 radeon
->state
.scissor
.numClipRects
++;
150 void radeon_get_cliprects(radeonContextPtr radeon
,
151 struct drm_clip_rect
**cliprects
,
152 unsigned int *num_cliprects
,
153 int *x_off
, int *y_off
)
155 __DRIdrawablePrivate
*dPriv
= radeon
->dri
.drawable
;
156 struct radeon_framebuffer
*rfb
= dPriv
->driverPrivate
;
158 if (radeon
->constant_cliprect
) {
159 radeon
->fboRect
.x1
= 0;
160 radeon
->fboRect
.y1
= 0;
161 radeon
->fboRect
.x2
= radeon
->glCtx
->DrawBuffer
->Width
;
162 radeon
->fboRect
.y2
= radeon
->glCtx
->DrawBuffer
->Height
;
164 *cliprects
= &radeon
->fboRect
;
168 } else if (radeon
->front_cliprects
||
169 rfb
->pf_active
|| dPriv
->numBackClipRects
== 0) {
170 *cliprects
= dPriv
->pClipRects
;
171 *num_cliprects
= dPriv
->numClipRects
;
175 *num_cliprects
= dPriv
->numBackClipRects
;
176 *cliprects
= dPriv
->pBackClipRects
;
177 *x_off
= dPriv
->backX
;
178 *y_off
= dPriv
->backY
;
183 * Update cliprects and scissors.
185 void radeonSetCliprects(radeonContextPtr radeon
)
187 __DRIdrawablePrivate
*const drawable
= radeon
->dri
.drawable
;
188 __DRIdrawablePrivate
*const readable
= radeon
->dri
.readable
;
189 struct radeon_framebuffer
*const draw_rfb
= drawable
->driverPrivate
;
190 struct radeon_framebuffer
*const read_rfb
= readable
->driverPrivate
;
193 radeon_get_cliprects(radeon
, &radeon
->pClipRects
,
194 &radeon
->numClipRects
, &x_off
, &y_off
);
196 if ((draw_rfb
->base
.Width
!= drawable
->w
) ||
197 (draw_rfb
->base
.Height
!= drawable
->h
)) {
198 _mesa_resize_framebuffer(radeon
->glCtx
, &draw_rfb
->base
,
199 drawable
->w
, drawable
->h
);
200 draw_rfb
->base
.Initialized
= GL_TRUE
;
203 if (drawable
!= readable
) {
204 if ((read_rfb
->base
.Width
!= readable
->w
) ||
205 (read_rfb
->base
.Height
!= readable
->h
)) {
206 _mesa_resize_framebuffer(radeon
->glCtx
, &read_rfb
->base
,
207 readable
->w
, readable
->h
);
208 read_rfb
->base
.Initialized
= GL_TRUE
;
212 if (radeon
->state
.scissor
.enabled
)
213 radeonRecalcScissorRects(radeon
);
219 void radeonUpdateScissor( GLcontext
*ctx
)
221 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
223 if ( rmesa
->dri
.drawable
) {
224 __DRIdrawablePrivate
*dPriv
= rmesa
->dri
.drawable
;
226 int x
= ctx
->Scissor
.X
;
227 int y
= dPriv
->h
- ctx
->Scissor
.Y
- ctx
->Scissor
.Height
;
228 int w
= ctx
->Scissor
.X
+ ctx
->Scissor
.Width
- 1;
229 int h
= dPriv
->h
- ctx
->Scissor
.Y
- 1;
231 rmesa
->state
.scissor
.rect
.x1
= x
+ dPriv
->x
;
232 rmesa
->state
.scissor
.rect
.y1
= y
+ dPriv
->y
;
233 rmesa
->state
.scissor
.rect
.x2
= w
+ dPriv
->x
+ 1;
234 rmesa
->state
.scissor
.rect
.y2
= h
+ dPriv
->y
+ 1;
236 radeonRecalcScissorRects( rmesa
);
240 /* =============================================================
244 void radeonScissor(GLcontext
* ctx
, GLint x
, GLint y
, GLsizei w
, GLsizei h
)
246 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
247 if (ctx
->Scissor
.Enabled
) {
248 /* We don't pipeline cliprect changes */
249 radeon_firevertices(radeon
);
250 radeonUpdateScissor(ctx
);
255 /* ================================================================
256 * SwapBuffers with client-side throttling
259 static uint32_t radeonGetLastFrame(radeonContextPtr radeon
)
261 drm_radeon_getparam_t gp
;
265 gp
.param
= RADEON_PARAM_LAST_FRAME
;
266 gp
.value
= (int *)&frame
;
267 ret
= drmCommandWriteRead(radeon
->dri
.fd
, DRM_RADEON_GETPARAM
,
270 fprintf(stderr
, "%s: drmRadeonGetParam: %d\n", __FUNCTION__
,
278 uint32_t radeonGetAge(radeonContextPtr radeon
)
280 drm_radeon_getparam_t gp
;
284 gp
.param
= RADEON_PARAM_LAST_CLEAR
;
285 gp
.value
= (int *)&age
;
286 ret
= drmCommandWriteRead(radeon
->dri
.fd
, DRM_RADEON_GETPARAM
,
289 fprintf(stderr
, "%s: drmRadeonGetParam: %d\n", __FUNCTION__
,
297 static void radeonEmitIrqLocked(radeonContextPtr radeon
)
299 drm_radeon_irq_emit_t ie
;
302 ie
.irq_seq
= &radeon
->iw
.irq_seq
;
303 ret
= drmCommandWriteRead(radeon
->dri
.fd
, DRM_RADEON_IRQ_EMIT
,
306 fprintf(stderr
, "%s: drmRadeonIrqEmit: %d\n", __FUNCTION__
,
312 static void radeonWaitIrq(radeonContextPtr radeon
)
317 ret
= drmCommandWrite(radeon
->dri
.fd
, DRM_RADEON_IRQ_WAIT
,
318 &radeon
->iw
, sizeof(radeon
->iw
));
319 } while (ret
&& (errno
== EINTR
|| errno
== EBUSY
));
322 fprintf(stderr
, "%s: drmRadeonIrqWait: %d\n", __FUNCTION__
,
328 static void radeonWaitForFrameCompletion(radeonContextPtr radeon
)
330 drm_radeon_sarea_t
*sarea
= radeon
->sarea
;
332 if (radeon
->do_irqs
) {
333 if (radeonGetLastFrame(radeon
) < sarea
->last_frame
) {
334 if (!radeon
->irqsEmitted
) {
335 while (radeonGetLastFrame(radeon
) <
338 UNLOCK_HARDWARE(radeon
);
339 radeonWaitIrq(radeon
);
340 LOCK_HARDWARE(radeon
);
342 radeon
->irqsEmitted
= 10;
345 if (radeon
->irqsEmitted
) {
346 radeonEmitIrqLocked(radeon
);
347 radeon
->irqsEmitted
--;
350 while (radeonGetLastFrame(radeon
) < sarea
->last_frame
) {
351 UNLOCK_HARDWARE(radeon
);
352 if (radeon
->do_usleeps
)
354 LOCK_HARDWARE(radeon
);
360 void radeonWaitForIdleLocked(radeonContextPtr radeon
)
366 ret
= drmCommandNone(radeon
->dri
.fd
, DRM_RADEON_CP_IDLE
);
369 } while (ret
&& ++i
< 100);
372 UNLOCK_HARDWARE(radeon
);
373 fprintf(stderr
, "Error: R300 timed out... exiting\n");
378 static void radeonWaitForIdle(radeonContextPtr radeon
)
380 LOCK_HARDWARE(radeon
);
381 radeonWaitForIdleLocked(radeon
);
382 UNLOCK_HARDWARE(radeon
);
385 static void radeon_flip_renderbuffers(struct radeon_framebuffer
*rfb
)
387 int current_page
= rfb
->pf_current_page
;
388 int next_page
= (current_page
+ 1) % rfb
->pf_num_pages
;
389 struct gl_renderbuffer
*tmp_rb
;
391 /* Exchange renderbuffers if necessary but make sure their
392 * reference counts are preserved.
394 if (rfb
->color_rb
[current_page
] &&
395 rfb
->base
.Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
!=
396 &rfb
->color_rb
[current_page
]->base
) {
398 _mesa_reference_renderbuffer(&tmp_rb
,
399 rfb
->base
.Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
);
400 tmp_rb
= &rfb
->color_rb
[current_page
]->base
;
401 _mesa_reference_renderbuffer(&rfb
->base
.Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
, tmp_rb
);
402 _mesa_reference_renderbuffer(&tmp_rb
, NULL
);
405 if (rfb
->color_rb
[next_page
] &&
406 rfb
->base
.Attachment
[BUFFER_BACK_LEFT
].Renderbuffer
!=
407 &rfb
->color_rb
[next_page
]->base
) {
409 _mesa_reference_renderbuffer(&tmp_rb
,
410 rfb
->base
.Attachment
[BUFFER_BACK_LEFT
].Renderbuffer
);
411 tmp_rb
= &rfb
->color_rb
[next_page
]->base
;
412 _mesa_reference_renderbuffer(&rfb
->base
.Attachment
[BUFFER_BACK_LEFT
].Renderbuffer
, tmp_rb
);
413 _mesa_reference_renderbuffer(&tmp_rb
, NULL
);
417 /* Copy the back color buffer to the front color buffer.
419 void radeonCopyBuffer( __DRIdrawablePrivate
*dPriv
,
420 const drm_clip_rect_t
*rect
)
422 radeonContextPtr rmesa
;
423 struct radeon_framebuffer
*rfb
;
427 assert(dPriv
->driContextPriv
);
428 assert(dPriv
->driContextPriv
->driverPrivate
);
430 rmesa
= (radeonContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
432 LOCK_HARDWARE(rmesa
);
434 rfb
= dPriv
->driverPrivate
;
436 if ( RADEON_DEBUG
& DEBUG_IOCTL
) {
437 fprintf( stderr
, "\n%s( %p )\n\n", __FUNCTION__
, (void *) rmesa
->glCtx
);
440 nbox
= dPriv
->numClipRects
; /* must be in locked region */
442 for ( i
= 0 ; i
< nbox
; ) {
443 GLint nr
= MIN2( i
+ RADEON_NR_SAREA_CLIPRECTS
, nbox
);
444 drm_clip_rect_t
*box
= dPriv
->pClipRects
;
445 drm_clip_rect_t
*b
= rmesa
->sarea
->boxes
;
448 for ( ; i
< nr
; i
++ ) {
454 if (rect
->x1
> b
->x1
)
456 if (rect
->y1
> b
->y1
)
458 if (rect
->x2
< b
->x2
)
460 if (rect
->y2
< b
->y2
)
463 if (b
->x1
>= b
->x2
|| b
->y1
>= b
->y2
)
470 rmesa
->sarea
->nbox
= n
;
475 ret
= drmCommandNone( rmesa
->dri
.fd
, DRM_RADEON_SWAP
);
478 fprintf( stderr
, "DRM_RADEON_SWAP_BUFFERS: return = %d\n", ret
);
479 UNLOCK_HARDWARE( rmesa
);
484 UNLOCK_HARDWARE( rmesa
);
487 static int radeonScheduleSwap(__DRIdrawablePrivate
*dPriv
, GLboolean
*missed_target
)
489 radeonContextPtr rmesa
;
491 rmesa
= (radeonContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
492 radeon_firevertices(rmesa
);
494 LOCK_HARDWARE( rmesa
);
496 if (!dPriv
->numClipRects
) {
497 UNLOCK_HARDWARE(rmesa
);
498 usleep(10000); /* throttle invisible client 10ms */
502 radeonWaitForFrameCompletion(rmesa
);
504 UNLOCK_HARDWARE(rmesa
);
505 driWaitForVBlank(dPriv
, missed_target
);
510 static GLboolean
radeonPageFlip( __DRIdrawablePrivate
*dPriv
)
512 radeonContextPtr radeon
;
514 __DRIscreenPrivate
*psp
;
515 struct radeon_renderbuffer
*rrb
;
516 struct radeon_framebuffer
*rfb
;
519 assert(dPriv
->driContextPriv
);
520 assert(dPriv
->driContextPriv
->driverPrivate
);
522 radeon
= (radeonContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
523 rfb
= dPriv
->driverPrivate
;
524 rrb
= (void *)rfb
->base
.Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
;
526 psp
= dPriv
->driScreenPriv
;
528 LOCK_HARDWARE(radeon
);
530 if ( RADEON_DEBUG
& DEBUG_IOCTL
) {
531 fprintf(stderr
, "%s: pfCurrentPage: %d %d\n", __FUNCTION__
,
532 radeon
->sarea
->pfCurrentPage
, radeon
->sarea
->pfState
);
534 drm_clip_rect_t
*box
= dPriv
->pClipRects
;
535 drm_clip_rect_t
*b
= radeon
->sarea
->boxes
;
537 radeon
->sarea
->nbox
= 1;
539 ret
= drmCommandNone( radeon
->dri
.fd
, DRM_RADEON_FLIP
);
541 UNLOCK_HARDWARE(radeon
);
544 fprintf( stderr
, "DRM_RADEON_FLIP: return = %d\n", ret
);
551 rfb
->pf_current_page
= radeon
->sarea
->pfCurrentPage
;
552 radeon_flip_renderbuffers(rfb
);
553 radeon_draw_buffer(radeon
->glCtx
, &rfb
->base
);
560 * Swap front and back buffer.
562 void radeonSwapBuffers(__DRIdrawablePrivate
* dPriv
)
565 __DRIscreenPrivate
*psp
;
567 if (dPriv
->driContextPriv
&& dPriv
->driContextPriv
->driverPrivate
) {
568 radeonContextPtr radeon
;
571 radeon
= (radeonContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
574 if (ctx
->Visual
.doubleBufferMode
) {
575 GLboolean missed_target
;
576 struct radeon_framebuffer
*rfb
= dPriv
->driverPrivate
;
577 _mesa_notifySwapBuffers(ctx
);/* flush pending rendering comands */
579 radeonScheduleSwap(dPriv
, &missed_target
);
581 if (rfb
->pf_active
) {
582 radeonPageFlip(dPriv
);
584 radeonCopyBuffer(dPriv
, NULL
);
587 psp
= dPriv
->driScreenPriv
;
590 (*psp
->systemTime
->getUST
)( & ust
);
591 if ( missed_target
) {
592 rfb
->swap_missed_count
++;
593 rfb
->swap_missed_ust
= ust
- rfb
->swap_ust
;
597 radeon
->hw
.all_dirty
= GL_TRUE
;
600 /* XXX this shouldn't be an error but we can't handle it for now */
601 _mesa_problem(NULL
, "%s: drawable has no context!",
606 void radeonCopySubBuffer(__DRIdrawablePrivate
* dPriv
,
607 int x
, int y
, int w
, int h
)
609 if (dPriv
->driContextPriv
&& dPriv
->driContextPriv
->driverPrivate
) {
610 radeonContextPtr radeon
;
613 radeon
= (radeonContextPtr
) dPriv
->driContextPriv
->driverPrivate
;
616 if (ctx
->Visual
.doubleBufferMode
) {
617 drm_clip_rect_t rect
;
618 rect
.x1
= x
+ dPriv
->x
;
619 rect
.y1
= (dPriv
->h
- y
- h
) + dPriv
->y
;
620 rect
.x2
= rect
.x1
+ w
;
621 rect
.y2
= rect
.y1
+ h
;
622 _mesa_notifySwapBuffers(ctx
); /* flush pending rendering comands */
623 radeonCopyBuffer(dPriv
, &rect
);
626 /* XXX this shouldn't be an error but we can't handle it for now */
627 _mesa_problem(NULL
, "%s: drawable has no context!",
632 void radeon_draw_buffer(GLcontext
*ctx
, struct gl_framebuffer
*fb
)
634 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
635 struct radeon_renderbuffer
*rrbDepth
= NULL
, *rrbStencil
= NULL
,
641 /* this can happen during the initial context initialization */
645 /* radeons only handle 1 color draw so far */
646 if (fb
->_NumColorDrawBuffers
!= 1) {
647 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_DRAW_BUFFER
, GL_TRUE
);
651 /* Do this here, note core Mesa, since this function is called from
652 * many places within the driver.
654 if (ctx
->NewState
& (_NEW_BUFFERS
| _NEW_COLOR
| _NEW_PIXEL
)) {
655 /* this updates the DrawBuffer->_NumColorDrawBuffers fields, etc */
656 _mesa_update_framebuffer(ctx
);
657 /* this updates the DrawBuffer's Width/Height if it's a FBO */
658 _mesa_update_draw_buffer_bounds(ctx
);
661 if (fb
->_Status
!= GL_FRAMEBUFFER_COMPLETE_EXT
) {
662 /* this may occur when we're called by glBindFrameBuffer() during
663 * the process of someone setting up renderbuffers, etc.
665 /*_mesa_debug(ctx, "DrawBuffer: incomplete user FBO\n");*/
670 ;/* do something depthy/stencily TODO */
675 if (fb
->_ColorDrawBufferIndexes
[0] == BUFFER_FRONT_LEFT
) {
676 rrbColor
= radeon_renderbuffer(fb
->Attachment
[BUFFER_FRONT_LEFT
].Renderbuffer
);
677 radeon
->front_cliprects
= GL_TRUE
;
679 rrbColor
= radeon_renderbuffer(fb
->Attachment
[BUFFER_BACK_LEFT
].Renderbuffer
);
680 radeon
->front_cliprects
= GL_FALSE
;
683 /* user FBO in theory */
684 struct radeon_renderbuffer
*rrb
;
685 rrb
= radeon_renderbuffer(fb
->_ColorDrawBuffers
[0]);
687 offset
= rrb
->draw_offset
;
690 radeon
->constant_cliprect
= GL_TRUE
;
693 if (rrbColor
== NULL
)
694 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_DRAW_BUFFER
, GL_TRUE
);
696 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_DRAW_BUFFER
, GL_FALSE
);
699 if (fb
->_DepthBuffer
&& fb
->_DepthBuffer
->Wrapped
) {
700 rrbDepth
= radeon_renderbuffer(fb
->_DepthBuffer
->Wrapped
);
701 if (rrbDepth
&& rrbDepth
->bo
) {
702 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_DEPTH_BUFFER
, GL_FALSE
);
704 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_DEPTH_BUFFER
, GL_TRUE
);
707 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_DEPTH_BUFFER
, GL_FALSE
);
711 if (fb
->_StencilBuffer
&& fb
->_StencilBuffer
->Wrapped
) {
712 rrbStencil
= radeon_renderbuffer(fb
->_DepthBuffer
->Wrapped
);
713 if (rrbStencil
&& rrbStencil
->bo
) {
714 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_STENCIL_BUFFER
, GL_FALSE
);
715 /* need to re-compute stencil hw state */
717 rrbDepth
= rrbStencil
;
719 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_STENCIL_BUFFER
, GL_TRUE
);
722 radeon
->vtbl
.fallback(ctx
, RADEON_FALLBACK_STENCIL_BUFFER
, GL_FALSE
);
723 if (ctx
->Driver
.Enable
!= NULL
)
724 ctx
->Driver
.Enable(ctx
, GL_STENCIL_TEST
, ctx
->Stencil
.Enabled
);
726 ctx
->NewState
|= _NEW_STENCIL
;
729 /* Update culling direction which changes depending on the
730 * orientation of the buffer:
732 if (ctx
->Driver
.FrontFace
)
733 ctx
->Driver
.FrontFace(ctx
, ctx
->Polygon
.FrontFace
);
735 ctx
->NewState
|= _NEW_POLYGON
;
738 * Update depth test state
740 if (ctx
->Driver
.Enable
) {
741 ctx
->Driver
.Enable(ctx
, GL_DEPTH_TEST
,
742 (ctx
->Depth
.Test
&& fb
->Visual
.depthBits
> 0));
743 ctx
->Driver
.Enable(ctx
, GL_STENCIL_TEST
,
744 (ctx
->Stencil
._Enabled
&& fb
->Visual
.stencilBits
> 0));
746 ctx
->NewState
|= (_NEW_DEPTH
| _NEW_STENCIL
);
749 radeon
->state
.depth
.rrb
= rrbDepth
;
750 radeon
->state
.color
.rrb
= rrbColor
;
751 radeon
->state
.color
.draw_offset
= offset
;
754 /* update viewport since it depends on window size */
755 if (ctx
->Driver
.Viewport
) {
756 ctx
->Driver
.Viewport(ctx
, ctx
->Viewport
.X
, ctx
->Viewport
.Y
,
757 ctx
->Viewport
.Width
, ctx
->Viewport
.Height
);
762 ctx
->NewState
|= _NEW_VIEWPORT
;
764 /* Set state we know depends on drawable parameters:
766 if (ctx
->Driver
.Scissor
)
767 ctx
->Driver
.Scissor(ctx
, ctx
->Scissor
.X
, ctx
->Scissor
.Y
,
768 ctx
->Scissor
.Width
, ctx
->Scissor
.Height
);
769 radeon
->NewGLState
|= _NEW_SCISSOR
;
771 if (ctx
->Driver
.DepthRange
)
772 ctx
->Driver
.DepthRange(ctx
,
776 /* Update culling direction which changes depending on the
777 * orientation of the buffer:
779 if (ctx
->Driver
.FrontFace
)
780 ctx
->Driver
.FrontFace(ctx
, ctx
->Polygon
.FrontFace
);
782 ctx
->NewState
|= _NEW_POLYGON
;
786 * Called via glDrawBuffer.
788 void radeonDrawBuffer( GLcontext
*ctx
, GLenum mode
)
790 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
792 if (RADEON_DEBUG
& DEBUG_DRI
)
793 fprintf(stderr
, "%s %s\n", __FUNCTION__
,
794 _mesa_lookup_enum_by_nr( mode
));
796 radeon_firevertices(radeon
); /* don't pipeline cliprect changes */
798 radeon_draw_buffer(ctx
, ctx
->DrawBuffer
);
801 void radeonReadBuffer( GLcontext
*ctx
, GLenum mode
)
803 /* nothing, until we implement h/w glRead/CopyPixels or CopyTexImage */
804 if (ctx
->ReadBuffer
== ctx
->DrawBuffer
) {
805 /* This will update FBO completeness status.
806 * A framebuffer will be incomplete if the GL_READ_BUFFER setting
807 * refers to a missing renderbuffer. Calling glReadBuffer can set
808 * that straight and can make the drawing buffer complete.
810 radeon_draw_buffer(ctx
, ctx
->DrawBuffer
);
815 /* Turn on/off page flipping according to the flags in the sarea:
817 void radeonUpdatePageFlipping(radeonContextPtr radeon
)
819 struct radeon_framebuffer
*rfb
= radeon
->dri
.drawable
->driverPrivate
;
821 rfb
->pf_active
= radeon
->sarea
->pfState
;
822 rfb
->pf_current_page
= radeon
->sarea
->pfCurrentPage
;
823 rfb
->pf_num_pages
= 2;
824 radeon_flip_renderbuffers(rfb
);
825 radeon_draw_buffer(radeon
->glCtx
, radeon
->glCtx
->DrawBuffer
);
828 void radeon_window_moved(radeonContextPtr radeon
)
830 if (!radeon
->radeonScreen
->driScreen
->dri2
.enabled
) {
831 radeonUpdatePageFlipping(radeon
);
833 radeonSetCliprects(radeon
);
836 void radeon_viewport(GLcontext
*ctx
, GLint x
, GLint y
, GLsizei width
, GLsizei height
)
838 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
839 __DRIcontext
*driContext
= radeon
->dri
.context
;
840 void (*old_viewport
)(GLcontext
*ctx
, GLint x
, GLint y
,
841 GLsizei w
, GLsizei h
);
843 if (!driContext
->driScreenPriv
->dri2
.enabled
)
846 radeon_update_renderbuffers(driContext
, driContext
->driDrawablePriv
);
847 if (driContext
->driDrawablePriv
!= driContext
->driReadablePriv
)
848 radeon_update_renderbuffers(driContext
, driContext
->driReadablePriv
);
850 old_viewport
= ctx
->Driver
.Viewport
;
851 ctx
->Driver
.Viewport
= NULL
;
852 radeon
->dri
.drawable
= driContext
->driDrawablePriv
;
853 radeon_window_moved(radeon
);
854 radeon_draw_buffer(ctx
, radeon
->glCtx
->DrawBuffer
);
855 ctx
->Driver
.Viewport
= old_viewport
;
859 static void radeon_print_state_atom(radeonContextPtr radeon
, struct radeon_state_atom
*state
)
862 int dwords
= (*state
->check
)(radeon
->glCtx
, state
);
864 fprintf(stderr
, "emit %s %d/%d\n", state
->name
, state
->cmd_size
, dwords
);
866 if (RADEON_DEBUG
& DEBUG_VERBOSE
)
867 for (i
= 0 ; i
< dwords
; i
++)
868 fprintf(stderr
, "\t%s[%d]: %x\n", state
->name
, i
, state
->cmd
[i
]);
872 static INLINE
void radeonEmitAtoms(radeonContextPtr radeon
, GLboolean dirty
)
874 BATCH_LOCALS(radeon
);
875 struct radeon_state_atom
*atom
;
878 if (radeon
->vtbl
.pre_emit_atoms
)
879 radeon
->vtbl
.pre_emit_atoms(radeon
);
881 /* Emit actual atoms */
882 foreach(atom
, &radeon
->hw
.atomlist
) {
883 if ((atom
->dirty
|| radeon
->hw
.all_dirty
) == dirty
) {
884 dwords
= (*atom
->check
) (radeon
->glCtx
, atom
);
886 if (DEBUG_CMDBUF
&& RADEON_DEBUG
& DEBUG_STATE
) {
887 radeon_print_state_atom(radeon
, atom
);
890 (*atom
->emit
)(radeon
->glCtx
, atom
);
892 BEGIN_BATCH_NO_AUTOSTATE(dwords
);
893 OUT_BATCH_TABLE(atom
->cmd
, dwords
);
896 atom
->dirty
= GL_FALSE
;
898 if (DEBUG_CMDBUF
&& RADEON_DEBUG
& DEBUG_STATE
) {
899 fprintf(stderr
, " skip state %s\n",
909 GLboolean
radeon_revalidate_bos(GLcontext
*ctx
)
911 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
915 ret
= radeon_cs_space_check(radeon
->cmdbuf
.cs
, radeon
->state
.bos
, radeon
->state
.validated_bo_count
);
916 if (ret
== RADEON_CS_SPACE_OP_TO_BIG
)
918 if (ret
== RADEON_CS_SPACE_FLUSH
) {
928 void radeon_validate_reset_bos(radeonContextPtr radeon
)
932 for (i
= 0; i
< radeon
->state
.validated_bo_count
; i
++) {
933 radeon
->state
.bos
[i
].bo
= NULL
;
934 radeon
->state
.bos
[i
].read_domains
= 0;
935 radeon
->state
.bos
[i
].write_domain
= 0;
936 radeon
->state
.bos
[i
].new_accounted
= 0;
938 radeon
->state
.validated_bo_count
= 0;
941 void radeon_validate_bo(radeonContextPtr radeon
, struct radeon_bo
*bo
, uint32_t read_domains
, uint32_t write_domain
)
943 radeon
->state
.bos
[radeon
->state
.validated_bo_count
].bo
= bo
;
944 radeon
->state
.bos
[radeon
->state
.validated_bo_count
].read_domains
= read_domains
;
945 radeon
->state
.bos
[radeon
->state
.validated_bo_count
].write_domain
= write_domain
;
946 radeon
->state
.bos
[radeon
->state
.validated_bo_count
].new_accounted
= 0;
947 radeon
->state
.validated_bo_count
++;
949 assert(radeon
->state
.validated_bo_count
< RADEON_MAX_BOS
);
952 void radeonEmitState(radeonContextPtr radeon
)
954 if (RADEON_DEBUG
& (DEBUG_STATE
|DEBUG_PRIMS
))
955 fprintf(stderr
, "%s\n", __FUNCTION__
);
957 if (radeon
->vtbl
.pre_emit_state
)
958 radeon
->vtbl
.pre_emit_state(radeon
);
960 /* this code used to return here but now it emits zbs */
961 if (radeon
->cmdbuf
.cs
->cdw
&& !radeon
->hw
.is_dirty
&& !radeon
->hw
.all_dirty
)
964 /* To avoid going across the entire set of states multiple times, just check
965 * for enough space for the case of emitting all state, and inline the
966 * radeonAllocCmdBuf code here without all the checks.
968 rcommonEnsureCmdBufSpace(radeon
, radeon
->hw
.max_state_size
, __FUNCTION__
);
970 if (!radeon
->cmdbuf
.cs
->cdw
) {
971 if (RADEON_DEBUG
& DEBUG_STATE
)
972 fprintf(stderr
, "Begin reemit state\n");
974 radeonEmitAtoms(radeon
, GL_FALSE
);
977 if (RADEON_DEBUG
& DEBUG_STATE
)
978 fprintf(stderr
, "Begin dirty state\n");
980 radeonEmitAtoms(radeon
, GL_TRUE
);
981 radeon
->hw
.is_dirty
= GL_FALSE
;
982 radeon
->hw
.all_dirty
= GL_FALSE
;
987 void radeonFlush(GLcontext
*ctx
)
989 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
990 if (RADEON_DEBUG
& DEBUG_IOCTL
)
991 fprintf(stderr
, "%s %d\n", __FUNCTION__
, radeon
->cmdbuf
.cs
->cdw
);
993 /* okay if we have no cmds in the buffer &&
994 we have no DMA flush &&
995 we have no DMA buffer allocated.
996 then no point flushing anything at all.
998 if (!radeon
->dma
.flush
&& !radeon
->cmdbuf
.cs
->cdw
&& !radeon
->dma
.current
)
1001 if (radeon
->dma
.flush
)
1002 radeon
->dma
.flush( ctx
);
1004 radeonEmitState(radeon
);
1006 if (radeon
->cmdbuf
.cs
->cdw
)
1007 rcommonFlushCmdBuf(radeon
, __FUNCTION__
);
1010 /* Make sure all commands have been sent to the hardware and have
1011 * completed processing.
1013 void radeonFinish(GLcontext
* ctx
)
1015 radeonContextPtr radeon
= RADEON_CONTEXT(ctx
);
1016 struct gl_framebuffer
*fb
= ctx
->DrawBuffer
;
1021 if (radeon
->radeonScreen
->kernel_mm
) {
1022 for (i
= 0; i
< fb
->_NumColorDrawBuffers
; i
++) {
1023 struct radeon_renderbuffer
*rrb
;
1024 rrb
= radeon_renderbuffer(fb
->_ColorDrawBuffers
[i
]);
1026 radeon_bo_wait(rrb
->bo
);
1029 struct radeon_renderbuffer
*rrb
;
1030 rrb
= radeon_get_depthbuffer(radeon
);
1032 radeon_bo_wait(rrb
->bo
);
1034 } else if (radeon
->do_irqs
) {
1035 LOCK_HARDWARE(radeon
);
1036 radeonEmitIrqLocked(radeon
);
1037 UNLOCK_HARDWARE(radeon
);
1038 radeonWaitIrq(radeon
);
1040 radeonWaitForIdle(radeon
);
1046 * Send the current command buffer via ioctl to the hardware.
1048 int rcommonFlushCmdBufLocked(radeonContextPtr rmesa
, const char *caller
)
1052 if (rmesa
->cmdbuf
.flushing
) {
1053 fprintf(stderr
, "Recursive call into r300FlushCmdBufLocked!\n");
1056 rmesa
->cmdbuf
.flushing
= 1;
1058 if (RADEON_DEBUG
& DEBUG_IOCTL
) {
1059 fprintf(stderr
, "%s from %s - %i cliprects\n",
1060 __FUNCTION__
, caller
, rmesa
->numClipRects
);
1063 if (rmesa
->cmdbuf
.cs
->cdw
) {
1064 ret
= radeon_cs_emit(rmesa
->cmdbuf
.cs
);
1065 rmesa
->hw
.all_dirty
= GL_TRUE
;
1067 radeon_cs_erase(rmesa
->cmdbuf
.cs
);
1068 rmesa
->cmdbuf
.flushing
= 0;
1070 if (radeon_revalidate_bos(rmesa
->glCtx
) == GL_FALSE
) {
1071 fprintf(stderr
,"failed to revalidate buffers\n");
1077 int rcommonFlushCmdBuf(radeonContextPtr rmesa
, const char *caller
)
1081 radeonReleaseDmaRegion(rmesa
);
1083 LOCK_HARDWARE(rmesa
);
1084 ret
= rcommonFlushCmdBufLocked(rmesa
, caller
);
1085 UNLOCK_HARDWARE(rmesa
);
1088 fprintf(stderr
, "drmRadeonCmdBuffer: %d\n", ret
);
1096 * Make sure that enough space is available in the command buffer
1097 * by flushing if necessary.
1099 * \param dwords The number of dwords we need to be free on the command buffer
1101 void rcommonEnsureCmdBufSpace(radeonContextPtr rmesa
, int dwords
, const char *caller
)
1103 if ((rmesa
->cmdbuf
.cs
->cdw
+ dwords
+ 128) > rmesa
->cmdbuf
.size
||
1104 radeon_cs_need_flush(rmesa
->cmdbuf
.cs
)) {
1105 rcommonFlushCmdBuf(rmesa
, caller
);
1109 void rcommonInitCmdBuf(radeonContextPtr rmesa
)
1112 /* Initialize command buffer */
1113 size
= 256 * driQueryOptioni(&rmesa
->optionCache
,
1114 "command_buffer_size");
1115 if (size
< 2 * rmesa
->hw
.max_state_size
) {
1116 size
= 2 * rmesa
->hw
.max_state_size
+ 65535;
1118 if (size
> 64 * 256)
1121 if (RADEON_DEBUG
& (DEBUG_IOCTL
| DEBUG_DMA
)) {
1122 fprintf(stderr
, "sizeof(drm_r300_cmd_header_t)=%zd\n",
1123 sizeof(drm_r300_cmd_header_t
));
1124 fprintf(stderr
, "sizeof(drm_radeon_cmd_buffer_t)=%zd\n",
1125 sizeof(drm_radeon_cmd_buffer_t
));
1127 "Allocating %d bytes command buffer (max state is %d bytes)\n",
1128 size
* 4, rmesa
->hw
.max_state_size
* 4);
1131 if (rmesa
->radeonScreen
->kernel_mm
) {
1132 int fd
= rmesa
->radeonScreen
->driScreen
->fd
;
1133 rmesa
->cmdbuf
.csm
= radeon_cs_manager_gem_ctor(fd
);
1135 rmesa
->cmdbuf
.csm
= radeon_cs_manager_legacy_ctor(rmesa
);
1137 if (rmesa
->cmdbuf
.csm
== NULL
) {
1138 /* FIXME: fatal error */
1141 rmesa
->cmdbuf
.cs
= radeon_cs_create(rmesa
->cmdbuf
.csm
, size
);
1142 assert(rmesa
->cmdbuf
.cs
!= NULL
);
1143 rmesa
->cmdbuf
.size
= size
;
1145 if (!rmesa
->radeonScreen
->kernel_mm
) {
1146 radeon_cs_set_limit(rmesa
->cmdbuf
.cs
, RADEON_GEM_DOMAIN_VRAM
, rmesa
->radeonScreen
->texSize
[0]);
1147 radeon_cs_set_limit(rmesa
->cmdbuf
.cs
, RADEON_GEM_DOMAIN_GTT
, rmesa
->radeonScreen
->gartTextures
.size
);
1149 struct drm_radeon_gem_info mminfo
;
1151 if (!drmCommandWriteRead(rmesa
->dri
.fd
, DRM_RADEON_GEM_INFO
, &mminfo
, sizeof(mminfo
)))
1153 radeon_cs_set_limit(rmesa
->cmdbuf
.cs
, RADEON_GEM_DOMAIN_VRAM
, mminfo
.vram_visible
);
1154 radeon_cs_set_limit(rmesa
->cmdbuf
.cs
, RADEON_GEM_DOMAIN_GTT
, mminfo
.gart_size
);
1160 * Destroy the command buffer
1162 void rcommonDestroyCmdBuf(radeonContextPtr rmesa
)
1164 radeon_cs_destroy(rmesa
->cmdbuf
.cs
);
1165 if (rmesa
->radeonScreen
->driScreen
->dri2
.enabled
|| rmesa
->radeonScreen
->kernel_mm
) {
1166 radeon_cs_manager_gem_dtor(rmesa
->cmdbuf
.csm
);
1168 radeon_cs_manager_legacy_dtor(rmesa
->cmdbuf
.csm
);
1172 void rcommonBeginBatch(radeonContextPtr rmesa
, int n
,
1175 const char *function
,
1178 rcommonEnsureCmdBufSpace(rmesa
, n
, function
);
1179 if (!rmesa
->cmdbuf
.cs
->cdw
&& dostate
) {
1180 if (RADEON_DEBUG
& DEBUG_IOCTL
)
1181 fprintf(stderr
, "Reemit state after flush (from %s)\n", function
);
1182 radeonEmitState(rmesa
);
1184 radeon_cs_begin(rmesa
->cmdbuf
.cs
, n
, file
, function
, line
);
1186 if (DEBUG_CMDBUF
&& RADEON_DEBUG
& DEBUG_IOCTL
)
1187 fprintf(stderr
, "BEGIN_BATCH(%d) at %d, from %s:%i\n",
1188 n
, rmesa
->cmdbuf
.cs
->cdw
, function
, line
);
1195 radeon_meta_set_passthrough_transform(radeonContextPtr radeon
)
1197 GLcontext
*ctx
= radeon
->glCtx
;
1199 radeon
->meta
.saved_vp_x
= ctx
->Viewport
.X
;
1200 radeon
->meta
.saved_vp_y
= ctx
->Viewport
.Y
;
1201 radeon
->meta
.saved_vp_width
= ctx
->Viewport
.Width
;
1202 radeon
->meta
.saved_vp_height
= ctx
->Viewport
.Height
;
1203 radeon
->meta
.saved_matrix_mode
= ctx
->Transform
.MatrixMode
;
1205 _mesa_Viewport(0, 0, ctx
->DrawBuffer
->Width
, ctx
->DrawBuffer
->Height
);
1207 _mesa_MatrixMode(GL_PROJECTION
);
1209 _mesa_LoadIdentity();
1210 _mesa_Ortho(0, ctx
->DrawBuffer
->Width
, 0, ctx
->DrawBuffer
->Height
, 1, -1);
1212 _mesa_MatrixMode(GL_MODELVIEW
);
1214 _mesa_LoadIdentity();
1218 radeon_meta_restore_transform(radeonContextPtr radeon
)
1220 _mesa_MatrixMode(GL_PROJECTION
);
1222 _mesa_MatrixMode(GL_MODELVIEW
);
1225 _mesa_MatrixMode(radeon
->meta
.saved_matrix_mode
);
1227 _mesa_Viewport(radeon
->meta
.saved_vp_x
, radeon
->meta
.saved_vp_y
,
1228 radeon
->meta
.saved_vp_width
, radeon
->meta
.saved_vp_height
);
1233 * Perform glClear where mask contains only color, depth, and/or stencil.
1235 * The implementation is based on calling into Mesa to set GL state and
1236 * performing normal triangle rendering. The intent of this path is to
1237 * have as generic a path as possible, so that any driver could make use of
1242 void radeon_clear_tris(GLcontext
*ctx
, GLbitfield mask
)
1244 radeonContextPtr rmesa
= RADEON_CONTEXT(ctx
);
1245 GLfloat vertices
[4][3];
1246 GLfloat color
[4][4];
1248 struct gl_framebuffer
*fb
= ctx
->DrawBuffer
;
1250 GLboolean saved_fp_enable
= GL_FALSE
, saved_vp_enable
= GL_FALSE
;
1251 GLboolean saved_shader_program
= 0;
1252 unsigned int saved_active_texture
;
1254 assert((mask
& ~(TRI_CLEAR_COLOR_BITS
| BUFFER_BIT_DEPTH
|
1255 BUFFER_BIT_STENCIL
)) == 0);
1257 _mesa_PushAttrib(GL_COLOR_BUFFER_BIT
|
1259 GL_DEPTH_BUFFER_BIT
|
1261 GL_STENCIL_BUFFER_BIT
|
1264 _mesa_PushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT
);
1265 saved_active_texture
= ctx
->Texture
.CurrentUnit
;
1267 /* Disable existing GL state we don't want to apply to a clear. */
1268 _mesa_Disable(GL_ALPHA_TEST
);
1269 _mesa_Disable(GL_BLEND
);
1270 _mesa_Disable(GL_CULL_FACE
);
1271 _mesa_Disable(GL_FOG
);
1272 _mesa_Disable(GL_POLYGON_SMOOTH
);
1273 _mesa_Disable(GL_POLYGON_STIPPLE
);
1274 _mesa_Disable(GL_POLYGON_OFFSET_FILL
);
1275 _mesa_Disable(GL_LIGHTING
);
1276 _mesa_Disable(GL_CLIP_PLANE0
);
1277 _mesa_Disable(GL_CLIP_PLANE1
);
1278 _mesa_Disable(GL_CLIP_PLANE2
);
1279 _mesa_Disable(GL_CLIP_PLANE3
);
1280 _mesa_Disable(GL_CLIP_PLANE4
);
1281 _mesa_Disable(GL_CLIP_PLANE5
);
1282 if (ctx
->Extensions
.ARB_fragment_program
&& ctx
->FragmentProgram
.Enabled
) {
1283 saved_fp_enable
= GL_TRUE
;
1284 _mesa_Disable(GL_FRAGMENT_PROGRAM_ARB
);
1286 if (ctx
->Extensions
.ARB_vertex_program
&& ctx
->VertexProgram
.Enabled
) {
1287 saved_vp_enable
= GL_TRUE
;
1288 _mesa_Disable(GL_VERTEX_PROGRAM_ARB
);
1290 if (ctx
->Extensions
.ARB_shader_objects
&& ctx
->Shader
.CurrentProgram
) {
1291 saved_shader_program
= ctx
->Shader
.CurrentProgram
->Name
;
1292 _mesa_UseProgramObjectARB(0);
1295 if (ctx
->Texture
._EnabledUnits
!= 0) {
1298 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
1299 _mesa_ActiveTextureARB(GL_TEXTURE0
+ i
);
1300 _mesa_Disable(GL_TEXTURE_1D
);
1301 _mesa_Disable(GL_TEXTURE_2D
);
1302 _mesa_Disable(GL_TEXTURE_3D
);
1303 if (ctx
->Extensions
.ARB_texture_cube_map
)
1304 _mesa_Disable(GL_TEXTURE_CUBE_MAP_ARB
);
1305 if (ctx
->Extensions
.NV_texture_rectangle
)
1306 _mesa_Disable(GL_TEXTURE_RECTANGLE_NV
);
1307 if (ctx
->Extensions
.MESA_texture_array
) {
1308 _mesa_Disable(GL_TEXTURE_1D_ARRAY_EXT
);
1309 _mesa_Disable(GL_TEXTURE_2D_ARRAY_EXT
);
1314 radeon_meta_set_passthrough_transform(rmesa
);
1316 for (i
= 0; i
< 4; i
++) {
1317 color
[i
][0] = ctx
->Color
.ClearColor
[0];
1318 color
[i
][1] = ctx
->Color
.ClearColor
[1];
1319 color
[i
][2] = ctx
->Color
.ClearColor
[2];
1320 color
[i
][3] = ctx
->Color
.ClearColor
[3];
1323 /* convert clear Z from [0,1] to NDC coord in [-1,1] */
1325 dst_z
= -1.0 + 2.0 * ctx
->Depth
.Clear
;
1326 /* Prepare the vertices, which are the same regardless of which buffer we're
1329 vertices
[0][0] = fb
->_Xmin
;
1330 vertices
[0][1] = fb
->_Ymin
;
1331 vertices
[0][2] = dst_z
;
1332 vertices
[1][0] = fb
->_Xmax
;
1333 vertices
[1][1] = fb
->_Ymin
;
1334 vertices
[1][2] = dst_z
;
1335 vertices
[2][0] = fb
->_Xmax
;
1336 vertices
[2][1] = fb
->_Ymax
;
1337 vertices
[2][2] = dst_z
;
1338 vertices
[3][0] = fb
->_Xmin
;
1339 vertices
[3][1] = fb
->_Ymax
;
1340 vertices
[3][2] = dst_z
;
1342 _mesa_ColorPointer(4, GL_FLOAT
, 4 * sizeof(GLfloat
), &color
);
1343 _mesa_VertexPointer(3, GL_FLOAT
, 3 * sizeof(GLfloat
), &vertices
);
1344 _mesa_Enable(GL_COLOR_ARRAY
);
1345 _mesa_Enable(GL_VERTEX_ARRAY
);
1348 GLuint this_mask
= 0;
1351 color_bit
= _mesa_ffs(mask
& TRI_CLEAR_COLOR_BITS
);
1353 this_mask
|= (1 << (color_bit
- 1));
1355 /* Clear depth/stencil in the same pass as color. */
1356 this_mask
|= (mask
& (BUFFER_BIT_DEPTH
| BUFFER_BIT_STENCIL
));
1358 /* Select the current color buffer and use the color write mask if
1359 * we have one, otherwise don't write any color channels.
1361 if (this_mask
& BUFFER_BIT_FRONT_LEFT
)
1362 _mesa_DrawBuffer(GL_FRONT_LEFT
);
1363 else if (this_mask
& BUFFER_BIT_BACK_LEFT
)
1364 _mesa_DrawBuffer(GL_BACK_LEFT
);
1365 else if (color_bit
!= 0)
1366 _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0
+
1367 (color_bit
- BUFFER_COLOR0
- 1));
1369 _mesa_ColorMask(GL_FALSE
, GL_FALSE
, GL_FALSE
, GL_FALSE
);
1371 /* Control writing of the depth clear value to depth. */
1372 if (this_mask
& BUFFER_BIT_DEPTH
) {
1373 _mesa_DepthFunc(GL_ALWAYS
);
1374 _mesa_DepthMask(GL_TRUE
);
1375 _mesa_Enable(GL_DEPTH_TEST
);
1377 _mesa_Disable(GL_DEPTH_TEST
);
1378 _mesa_DepthMask(GL_FALSE
);
1381 /* Control writing of the stencil clear value to stencil. */
1382 if (this_mask
& BUFFER_BIT_STENCIL
) {
1383 _mesa_Enable(GL_STENCIL_TEST
);
1384 _mesa_StencilOp(GL_REPLACE
, GL_REPLACE
, GL_REPLACE
);
1385 _mesa_StencilFuncSeparate(GL_FRONT
, GL_ALWAYS
, ctx
->Stencil
.Clear
,
1386 ctx
->Stencil
.WriteMask
[0]);
1388 _mesa_Disable(GL_STENCIL_TEST
);
1391 CALL_DrawArrays(ctx
->Exec
, (GL_TRIANGLE_FAN
, 0, 4));
1396 radeon_meta_restore_transform(rmesa
);
1398 _mesa_ActiveTextureARB(GL_TEXTURE0
+ saved_active_texture
);
1399 if (saved_fp_enable
)
1400 _mesa_Enable(GL_FRAGMENT_PROGRAM_ARB
);
1401 if (saved_vp_enable
)
1402 _mesa_Enable(GL_VERTEX_PROGRAM_ARB
);
1404 if (saved_shader_program
)
1405 _mesa_UseProgramObjectARB(saved_shader_program
);
1407 _mesa_PopClientAttrib();