7 * Mesa 3-D graphics library
9 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
42 * Check if given blend source factor is legal.
43 * \return GL_TRUE if legal, GL_FALSE otherwise.
46 legal_src_factor(const struct gl_context
*ctx
, GLenum factor
)
50 case GL_ONE_MINUS_SRC_COLOR
:
54 case GL_ONE_MINUS_DST_COLOR
:
56 case GL_ONE_MINUS_SRC_ALPHA
:
58 case GL_ONE_MINUS_DST_ALPHA
:
59 case GL_SRC_ALPHA_SATURATE
:
61 case GL_CONSTANT_COLOR
:
62 case GL_ONE_MINUS_CONSTANT_COLOR
:
63 case GL_CONSTANT_ALPHA
:
64 case GL_ONE_MINUS_CONSTANT_ALPHA
:
65 return _mesa_is_desktop_gl(ctx
) || ctx
->API
== API_OPENGLES2
;
68 case GL_ONE_MINUS_SRC1_COLOR
:
69 case GL_ONE_MINUS_SRC1_ALPHA
:
70 return ctx
->API
!= API_OPENGLES
71 && ctx
->Extensions
.ARB_blend_func_extended
;
79 * Check if given blend destination factor is legal.
80 * \return GL_TRUE if legal, GL_FALSE otherwise.
83 legal_dst_factor(const struct gl_context
*ctx
, GLenum factor
)
87 case GL_ONE_MINUS_DST_COLOR
:
91 case GL_ONE_MINUS_SRC_COLOR
:
93 case GL_ONE_MINUS_SRC_ALPHA
:
95 case GL_ONE_MINUS_DST_ALPHA
:
97 case GL_CONSTANT_COLOR
:
98 case GL_ONE_MINUS_CONSTANT_COLOR
:
99 case GL_CONSTANT_ALPHA
:
100 case GL_ONE_MINUS_CONSTANT_ALPHA
:
101 return _mesa_is_desktop_gl(ctx
) || ctx
->API
== API_OPENGLES2
;
102 case GL_SRC_ALPHA_SATURATE
:
103 return (ctx
->API
!= API_OPENGLES
104 && ctx
->Extensions
.ARB_blend_func_extended
)
105 || _mesa_is_gles3(ctx
);
108 case GL_ONE_MINUS_SRC1_COLOR
:
109 case GL_ONE_MINUS_SRC1_ALPHA
:
110 return ctx
->API
!= API_OPENGLES
111 && ctx
->Extensions
.ARB_blend_func_extended
;
119 * Check if src/dest RGB/A blend factors are legal. If not generate
121 * \return GL_TRUE if factors are legal, GL_FALSE otherwise.
124 validate_blend_factors(struct gl_context
*ctx
, const char *func
,
125 GLenum sfactorRGB
, GLenum dfactorRGB
,
126 GLenum sfactorA
, GLenum dfactorA
)
128 if (!legal_src_factor(ctx
, sfactorRGB
)) {
129 _mesa_error(ctx
, GL_INVALID_ENUM
,
130 "%s(sfactorRGB = %s)", func
,
131 _mesa_enum_to_string(sfactorRGB
));
135 if (!legal_dst_factor(ctx
, dfactorRGB
)) {
136 _mesa_error(ctx
, GL_INVALID_ENUM
,
137 "%s(dfactorRGB = %s)", func
,
138 _mesa_enum_to_string(dfactorRGB
));
142 if (sfactorA
!= sfactorRGB
&& !legal_src_factor(ctx
, sfactorA
)) {
143 _mesa_error(ctx
, GL_INVALID_ENUM
,
144 "%s(sfactorA = %s)", func
,
145 _mesa_enum_to_string(sfactorA
));
149 if (dfactorA
!= dfactorRGB
&& !legal_dst_factor(ctx
, dfactorA
)) {
150 _mesa_error(ctx
, GL_INVALID_ENUM
,
151 "%s(dfactorA = %s)", func
,
152 _mesa_enum_to_string(dfactorA
));
161 blend_factor_is_dual_src(GLenum factor
)
163 return (factor
== GL_SRC1_COLOR
||
164 factor
== GL_SRC1_ALPHA
||
165 factor
== GL_ONE_MINUS_SRC1_COLOR
||
166 factor
== GL_ONE_MINUS_SRC1_ALPHA
);
170 update_uses_dual_src(struct gl_context
*ctx
, int buf
)
172 ctx
->Color
.Blend
[buf
]._UsesDualSrc
=
173 (blend_factor_is_dual_src(ctx
->Color
.Blend
[buf
].SrcRGB
) ||
174 blend_factor_is_dual_src(ctx
->Color
.Blend
[buf
].DstRGB
) ||
175 blend_factor_is_dual_src(ctx
->Color
.Blend
[buf
].SrcA
) ||
176 blend_factor_is_dual_src(ctx
->Color
.Blend
[buf
].DstA
));
181 * Return the number of per-buffer blend states to update in
182 * glBlendFunc, glBlendFuncSeparate, glBlendEquation, etc.
184 static inline unsigned
185 num_buffers(const struct gl_context
*ctx
)
187 return ctx
->Extensions
.ARB_draw_buffers_blend
188 ? ctx
->Const
.MaxDrawBuffers
: 1;
192 /* Returns true if there was no change */
194 skip_blend_state_update(const struct gl_context
*ctx
,
195 GLenum sfactorRGB
, GLenum dfactorRGB
,
196 GLenum sfactorA
, GLenum dfactorA
)
198 /* Check if we're really changing any state. If not, return early. */
199 if (ctx
->Color
._BlendFuncPerBuffer
) {
200 const unsigned numBuffers
= num_buffers(ctx
);
202 /* Check all per-buffer states */
203 for (unsigned buf
= 0; buf
< numBuffers
; buf
++) {
204 if (ctx
->Color
.Blend
[buf
].SrcRGB
!= sfactorRGB
||
205 ctx
->Color
.Blend
[buf
].DstRGB
!= dfactorRGB
||
206 ctx
->Color
.Blend
[buf
].SrcA
!= sfactorA
||
207 ctx
->Color
.Blend
[buf
].DstA
!= dfactorA
) {
213 /* only need to check 0th per-buffer state */
214 if (ctx
->Color
.Blend
[0].SrcRGB
!= sfactorRGB
||
215 ctx
->Color
.Blend
[0].DstRGB
!= dfactorRGB
||
216 ctx
->Color
.Blend
[0].SrcA
!= sfactorA
||
217 ctx
->Color
.Blend
[0].DstA
!= dfactorA
) {
227 blend_func_separate(struct gl_context
*ctx
,
228 GLenum sfactorRGB
, GLenum dfactorRGB
,
229 GLenum sfactorA
, GLenum dfactorA
)
231 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewBlend
? 0 : _NEW_COLOR
);
232 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewBlend
;
234 const unsigned numBuffers
= num_buffers(ctx
);
235 for (unsigned buf
= 0; buf
< numBuffers
; buf
++) {
236 ctx
->Color
.Blend
[buf
].SrcRGB
= sfactorRGB
;
237 ctx
->Color
.Blend
[buf
].DstRGB
= dfactorRGB
;
238 ctx
->Color
.Blend
[buf
].SrcA
= sfactorA
;
239 ctx
->Color
.Blend
[buf
].DstA
= dfactorA
;
242 update_uses_dual_src(ctx
, 0);
243 for (unsigned buf
= 1; buf
< numBuffers
; buf
++) {
244 ctx
->Color
.Blend
[buf
]._UsesDualSrc
= ctx
->Color
.Blend
[0]._UsesDualSrc
;
247 ctx
->Color
._BlendFuncPerBuffer
= GL_FALSE
;
249 if (ctx
->Driver
.BlendFuncSeparate
) {
250 ctx
->Driver
.BlendFuncSeparate(ctx
, sfactorRGB
, dfactorRGB
,
257 * Specify the blending operation.
259 * \param sfactor source factor operator.
260 * \param dfactor destination factor operator.
262 * \sa glBlendFunc, glBlendFuncSeparateEXT
265 _mesa_BlendFunc( GLenum sfactor
, GLenum dfactor
)
267 GET_CURRENT_CONTEXT(ctx
);
269 if (skip_blend_state_update(ctx
, sfactor
, dfactor
, sfactor
, dfactor
))
272 if (!validate_blend_factors(ctx
, "glBlendFunc",
273 sfactor
, dfactor
, sfactor
, dfactor
)) {
277 blend_func_separate(ctx
, sfactor
, dfactor
, sfactor
, dfactor
);
282 _mesa_BlendFunc_no_error(GLenum sfactor
, GLenum dfactor
)
284 GET_CURRENT_CONTEXT(ctx
);
286 if (skip_blend_state_update(ctx
, sfactor
, dfactor
, sfactor
, dfactor
))
289 blend_func_separate(ctx
, sfactor
, dfactor
, sfactor
, dfactor
);
294 * Set the separate blend source/dest factors for all draw buffers.
296 * \param sfactorRGB RGB source factor operator.
297 * \param dfactorRGB RGB destination factor operator.
298 * \param sfactorA alpha source factor operator.
299 * \param dfactorA alpha destination factor operator.
302 _mesa_BlendFuncSeparate( GLenum sfactorRGB
, GLenum dfactorRGB
,
303 GLenum sfactorA
, GLenum dfactorA
)
305 GET_CURRENT_CONTEXT(ctx
);
307 if (MESA_VERBOSE
& VERBOSE_API
)
308 _mesa_debug(ctx
, "glBlendFuncSeparate %s %s %s %s\n",
309 _mesa_enum_to_string(sfactorRGB
),
310 _mesa_enum_to_string(dfactorRGB
),
311 _mesa_enum_to_string(sfactorA
),
312 _mesa_enum_to_string(dfactorA
));
316 if (skip_blend_state_update(ctx
, sfactorRGB
, dfactorRGB
, sfactorA
, dfactorA
))
319 if (!validate_blend_factors(ctx
, "glBlendFuncSeparate",
320 sfactorRGB
, dfactorRGB
,
321 sfactorA
, dfactorA
)) {
325 blend_func_separate(ctx
, sfactorRGB
, dfactorRGB
, sfactorA
, dfactorA
);
330 _mesa_BlendFuncSeparate_no_error(GLenum sfactorRGB
, GLenum dfactorRGB
,
331 GLenum sfactorA
, GLenum dfactorA
)
333 GET_CURRENT_CONTEXT(ctx
);
335 if (skip_blend_state_update(ctx
, sfactorRGB
, dfactorRGB
, sfactorA
, dfactorA
))
338 blend_func_separate(ctx
, sfactorRGB
, dfactorRGB
, sfactorA
, dfactorA
);
343 _mesa_BlendFunciARB_no_error(GLuint buf
, GLenum sfactor
, GLenum dfactor
)
345 _mesa_BlendFuncSeparateiARB_no_error(buf
, sfactor
, dfactor
, sfactor
,
351 * Set blend source/dest factors for one color buffer/target.
354 _mesa_BlendFunciARB(GLuint buf
, GLenum sfactor
, GLenum dfactor
)
356 _mesa_BlendFuncSeparateiARB(buf
, sfactor
, dfactor
, sfactor
, dfactor
);
360 static ALWAYS_INLINE
void
361 blend_func_separatei(GLuint buf
, GLenum sfactorRGB
, GLenum dfactorRGB
,
362 GLenum sfactorA
, GLenum dfactorA
, bool no_error
)
364 GET_CURRENT_CONTEXT(ctx
);
367 if (!ctx
->Extensions
.ARB_draw_buffers_blend
) {
368 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBlendFunc[Separate]i()");
372 if (buf
>= ctx
->Const
.MaxDrawBuffers
) {
373 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBlendFuncSeparatei(buffer=%u)",
379 if (ctx
->Color
.Blend
[buf
].SrcRGB
== sfactorRGB
&&
380 ctx
->Color
.Blend
[buf
].DstRGB
== dfactorRGB
&&
381 ctx
->Color
.Blend
[buf
].SrcA
== sfactorA
&&
382 ctx
->Color
.Blend
[buf
].DstA
== dfactorA
)
383 return; /* no change */
385 if (!no_error
&& !validate_blend_factors(ctx
, "glBlendFuncSeparatei",
386 sfactorRGB
, dfactorRGB
,
387 sfactorA
, dfactorA
)) {
391 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewBlend
? 0 : _NEW_COLOR
);
392 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewBlend
;
394 ctx
->Color
.Blend
[buf
].SrcRGB
= sfactorRGB
;
395 ctx
->Color
.Blend
[buf
].DstRGB
= dfactorRGB
;
396 ctx
->Color
.Blend
[buf
].SrcA
= sfactorA
;
397 ctx
->Color
.Blend
[buf
].DstA
= dfactorA
;
398 update_uses_dual_src(ctx
, buf
);
399 ctx
->Color
._BlendFuncPerBuffer
= GL_TRUE
;
404 _mesa_BlendFuncSeparateiARB_no_error(GLuint buf
, GLenum sfactorRGB
,
405 GLenum dfactorRGB
, GLenum sfactorA
,
408 blend_func_separatei(buf
, sfactorRGB
, dfactorRGB
, sfactorA
, dfactorA
,
414 * Set separate blend source/dest factors for one color buffer/target.
417 _mesa_BlendFuncSeparateiARB(GLuint buf
, GLenum sfactorRGB
, GLenum dfactorRGB
,
418 GLenum sfactorA
, GLenum dfactorA
)
420 blend_func_separatei(buf
, sfactorRGB
, dfactorRGB
, sfactorA
, dfactorA
,
426 * Return true if \p mode is a legal blending equation, excluding
427 * GL_KHR_blend_equation_advanced modes.
430 legal_simple_blend_equation(const struct gl_context
*ctx
, GLenum mode
)
434 case GL_FUNC_SUBTRACT
:
435 case GL_FUNC_REVERSE_SUBTRACT
:
439 return ctx
->Extensions
.EXT_blend_minmax
;
445 static enum gl_advanced_blend_mode
446 advanced_blend_mode_from_gl_enum(GLenum mode
)
449 case GL_MULTIPLY_KHR
:
450 return BLEND_MULTIPLY
;
454 return BLEND_OVERLAY
;
458 return BLEND_LIGHTEN
;
459 case GL_COLORDODGE_KHR
:
460 return BLEND_COLORDODGE
;
461 case GL_COLORBURN_KHR
:
462 return BLEND_COLORBURN
;
463 case GL_HARDLIGHT_KHR
:
464 return BLEND_HARDLIGHT
;
465 case GL_SOFTLIGHT_KHR
:
466 return BLEND_SOFTLIGHT
;
467 case GL_DIFFERENCE_KHR
:
468 return BLEND_DIFFERENCE
;
469 case GL_EXCLUSION_KHR
:
470 return BLEND_EXCLUSION
;
472 return BLEND_HSL_HUE
;
473 case GL_HSL_SATURATION_KHR
:
474 return BLEND_HSL_SATURATION
;
475 case GL_HSL_COLOR_KHR
:
476 return BLEND_HSL_COLOR
;
477 case GL_HSL_LUMINOSITY_KHR
:
478 return BLEND_HSL_LUMINOSITY
;
485 * If \p mode is one of the advanced blending equations defined by
486 * GL_KHR_blend_equation_advanced (and the extension is supported),
487 * return the corresponding BLEND_* enum. Otherwise, return BLEND_NONE
488 * (which can also be treated as false).
490 static enum gl_advanced_blend_mode
491 advanced_blend_mode(const struct gl_context
*ctx
, GLenum mode
)
493 return _mesa_has_KHR_blend_equation_advanced(ctx
) ?
494 advanced_blend_mode_from_gl_enum(mode
) : BLEND_NONE
;
497 /* This is really an extension function! */
499 _mesa_BlendEquation( GLenum mode
)
501 GET_CURRENT_CONTEXT(ctx
);
502 const unsigned numBuffers
= num_buffers(ctx
);
504 bool changed
= false;
505 enum gl_advanced_blend_mode advanced_mode
= advanced_blend_mode(ctx
, mode
);
507 if (MESA_VERBOSE
& VERBOSE_API
)
508 _mesa_debug(ctx
, "glBlendEquation(%s)\n",
509 _mesa_enum_to_string(mode
));
511 if (ctx
->Color
._BlendEquationPerBuffer
) {
512 /* Check all per-buffer states */
513 for (buf
= 0; buf
< numBuffers
; buf
++) {
514 if (ctx
->Color
.Blend
[buf
].EquationRGB
!= mode
||
515 ctx
->Color
.Blend
[buf
].EquationA
!= mode
) {
522 /* only need to check 0th per-buffer state */
523 if (ctx
->Color
.Blend
[0].EquationRGB
!= mode
||
524 ctx
->Color
.Blend
[0].EquationA
!= mode
) {
533 if (!legal_simple_blend_equation(ctx
, mode
) && !advanced_mode
) {
534 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBlendEquation");
538 _mesa_flush_vertices_for_blend_state(ctx
);
540 for (buf
= 0; buf
< numBuffers
; buf
++) {
541 ctx
->Color
.Blend
[buf
].EquationRGB
= mode
;
542 ctx
->Color
.Blend
[buf
].EquationA
= mode
;
544 ctx
->Color
._BlendEquationPerBuffer
= GL_FALSE
;
545 ctx
->Color
._AdvancedBlendMode
= advanced_mode
;
547 if (ctx
->Driver
.BlendEquationSeparate
)
548 ctx
->Driver
.BlendEquationSeparate(ctx
, mode
, mode
);
553 * Set blend equation for one color buffer/target.
556 blend_equationi(struct gl_context
*ctx
, GLuint buf
, GLenum mode
,
557 enum gl_advanced_blend_mode advanced_mode
)
559 if (ctx
->Color
.Blend
[buf
].EquationRGB
== mode
&&
560 ctx
->Color
.Blend
[buf
].EquationA
== mode
)
561 return; /* no change */
563 _mesa_flush_vertices_for_blend_state(ctx
);
564 ctx
->Color
.Blend
[buf
].EquationRGB
= mode
;
565 ctx
->Color
.Blend
[buf
].EquationA
= mode
;
566 ctx
->Color
._BlendEquationPerBuffer
= GL_TRUE
;
569 ctx
->Color
._AdvancedBlendMode
= advanced_mode
;
574 _mesa_BlendEquationiARB_no_error(GLuint buf
, GLenum mode
)
576 GET_CURRENT_CONTEXT(ctx
);
578 enum gl_advanced_blend_mode advanced_mode
= advanced_blend_mode(ctx
, mode
);
579 blend_equationi(ctx
, buf
, mode
, advanced_mode
);
584 _mesa_BlendEquationiARB(GLuint buf
, GLenum mode
)
586 GET_CURRENT_CONTEXT(ctx
);
587 enum gl_advanced_blend_mode advanced_mode
= advanced_blend_mode(ctx
, mode
);
589 if (MESA_VERBOSE
& VERBOSE_API
)
590 _mesa_debug(ctx
, "glBlendEquationi(%u, %s)\n",
591 buf
, _mesa_enum_to_string(mode
));
593 if (buf
>= ctx
->Const
.MaxDrawBuffers
) {
594 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBlendEquationi(buffer=%u)",
599 if (!legal_simple_blend_equation(ctx
, mode
) && !advanced_mode
) {
600 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBlendEquationi");
604 blend_equationi(ctx
, buf
, mode
, advanced_mode
);
609 blend_equation_separate(struct gl_context
*ctx
, GLenum modeRGB
, GLenum modeA
,
612 const unsigned numBuffers
= num_buffers(ctx
);
614 bool changed
= false;
616 if (ctx
->Color
._BlendEquationPerBuffer
) {
617 /* Check all per-buffer states */
618 for (buf
= 0; buf
< numBuffers
; buf
++) {
619 if (ctx
->Color
.Blend
[buf
].EquationRGB
!= modeRGB
||
620 ctx
->Color
.Blend
[buf
].EquationA
!= modeA
) {
626 /* only need to check 0th per-buffer state */
627 if (ctx
->Color
.Blend
[0].EquationRGB
!= modeRGB
||
628 ctx
->Color
.Blend
[0].EquationA
!= modeA
) {
637 if ((modeRGB
!= modeA
) && !ctx
->Extensions
.EXT_blend_equation_separate
) {
638 _mesa_error(ctx
, GL_INVALID_OPERATION
,
639 "glBlendEquationSeparateEXT not supported by driver");
643 /* Only allow simple blending equations.
644 * The GL_KHR_blend_equation_advanced spec says:
646 * "NOTE: These enums are not accepted by the <modeRGB> or <modeAlpha>
647 * parameters of BlendEquationSeparate or BlendEquationSeparatei."
649 if (!legal_simple_blend_equation(ctx
, modeRGB
)) {
650 _mesa_error(ctx
, GL_INVALID_ENUM
,
651 "glBlendEquationSeparateEXT(modeRGB)");
655 if (!legal_simple_blend_equation(ctx
, modeA
)) {
656 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBlendEquationSeparateEXT(modeA)");
661 _mesa_flush_vertices_for_blend_state(ctx
);
663 for (buf
= 0; buf
< numBuffers
; buf
++) {
664 ctx
->Color
.Blend
[buf
].EquationRGB
= modeRGB
;
665 ctx
->Color
.Blend
[buf
].EquationA
= modeA
;
667 ctx
->Color
._BlendEquationPerBuffer
= GL_FALSE
;
668 ctx
->Color
._AdvancedBlendMode
= BLEND_NONE
;
670 if (ctx
->Driver
.BlendEquationSeparate
)
671 ctx
->Driver
.BlendEquationSeparate(ctx
, modeRGB
, modeA
);
676 _mesa_BlendEquationSeparate_no_error(GLenum modeRGB
, GLenum modeA
)
678 GET_CURRENT_CONTEXT(ctx
);
679 blend_equation_separate(ctx
, modeRGB
, modeA
, true);
684 _mesa_BlendEquationSeparate(GLenum modeRGB
, GLenum modeA
)
686 GET_CURRENT_CONTEXT(ctx
);
688 if (MESA_VERBOSE
& VERBOSE_API
)
689 _mesa_debug(ctx
, "glBlendEquationSeparateEXT(%s %s)\n",
690 _mesa_enum_to_string(modeRGB
),
691 _mesa_enum_to_string(modeA
));
693 blend_equation_separate(ctx
, modeRGB
, modeA
, false);
697 static ALWAYS_INLINE
void
698 blend_equation_separatei(struct gl_context
*ctx
, GLuint buf
, GLenum modeRGB
,
699 GLenum modeA
, bool no_error
)
701 if (ctx
->Color
.Blend
[buf
].EquationRGB
== modeRGB
&&
702 ctx
->Color
.Blend
[buf
].EquationA
== modeA
)
703 return; /* no change */
706 /* Only allow simple blending equations.
707 * The GL_KHR_blend_equation_advanced spec says:
709 * "NOTE: These enums are not accepted by the <modeRGB> or <modeAlpha>
710 * parameters of BlendEquationSeparate or BlendEquationSeparatei."
712 if (!legal_simple_blend_equation(ctx
, modeRGB
)) {
713 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBlendEquationSeparatei(modeRGB)");
717 if (!legal_simple_blend_equation(ctx
, modeA
)) {
718 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBlendEquationSeparatei(modeA)");
723 _mesa_flush_vertices_for_blend_state(ctx
);
724 ctx
->Color
.Blend
[buf
].EquationRGB
= modeRGB
;
725 ctx
->Color
.Blend
[buf
].EquationA
= modeA
;
726 ctx
->Color
._BlendEquationPerBuffer
= GL_TRUE
;
727 ctx
->Color
._AdvancedBlendMode
= BLEND_NONE
;
732 _mesa_BlendEquationSeparateiARB_no_error(GLuint buf
, GLenum modeRGB
,
735 GET_CURRENT_CONTEXT(ctx
);
736 blend_equation_separatei(ctx
, buf
, modeRGB
, modeA
, true);
741 * Set separate blend equations for one color buffer/target.
744 _mesa_BlendEquationSeparateiARB(GLuint buf
, GLenum modeRGB
, GLenum modeA
)
746 GET_CURRENT_CONTEXT(ctx
);
748 if (MESA_VERBOSE
& VERBOSE_API
)
749 _mesa_debug(ctx
, "glBlendEquationSeparatei(%u, %s %s)\n", buf
,
750 _mesa_enum_to_string(modeRGB
),
751 _mesa_enum_to_string(modeA
));
753 if (buf
>= ctx
->Const
.MaxDrawBuffers
) {
754 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBlendEquationSeparatei(buffer=%u)",
759 blend_equation_separatei(ctx
, buf
, modeRGB
, modeA
, false);
764 * Set the blending color.
766 * \param red red color component.
767 * \param green green color component.
768 * \param blue blue color component.
769 * \param alpha alpha color component.
771 * \sa glBlendColor().
773 * Clamps the parameters and updates gl_colorbuffer_attrib::BlendColor. On a
774 * change, flushes the vertices and notifies the driver via
775 * dd_function_table::BlendColor callback.
778 _mesa_BlendColor( GLclampf red
, GLclampf green
, GLclampf blue
, GLclampf alpha
)
781 GET_CURRENT_CONTEXT(ctx
);
788 if (TEST_EQ_4V(tmp
, ctx
->Color
.BlendColorUnclamped
))
791 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewBlendColor
? 0 : _NEW_COLOR
);
792 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewBlendColor
;
793 COPY_4FV( ctx
->Color
.BlendColorUnclamped
, tmp
);
795 ctx
->Color
.BlendColor
[0] = CLAMP(tmp
[0], 0.0F
, 1.0F
);
796 ctx
->Color
.BlendColor
[1] = CLAMP(tmp
[1], 0.0F
, 1.0F
);
797 ctx
->Color
.BlendColor
[2] = CLAMP(tmp
[2], 0.0F
, 1.0F
);
798 ctx
->Color
.BlendColor
[3] = CLAMP(tmp
[3], 0.0F
, 1.0F
);
800 if (ctx
->Driver
.BlendColor
)
801 ctx
->Driver
.BlendColor(ctx
, ctx
->Color
.BlendColor
);
806 * Specify the alpha test function.
808 * \param func alpha comparison function.
809 * \param ref reference value.
811 * Verifies the parameters and updates gl_colorbuffer_attrib.
812 * On a change, flushes the vertices and notifies the driver via
813 * dd_function_table::AlphaFunc callback.
816 _mesa_AlphaFunc( GLenum func
, GLclampf ref
)
818 GET_CURRENT_CONTEXT(ctx
);
820 if (MESA_VERBOSE
& VERBOSE_API
)
821 _mesa_debug(ctx
, "glAlphaFunc(%s, %f)\n",
822 _mesa_enum_to_string(func
), ref
);
824 if (ctx
->Color
.AlphaFunc
== func
&& ctx
->Color
.AlphaRefUnclamped
== ref
)
825 return; /* no change */
836 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewAlphaTest
? 0 : _NEW_COLOR
);
837 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewAlphaTest
;
838 ctx
->Color
.AlphaFunc
= func
;
839 ctx
->Color
.AlphaRefUnclamped
= ref
;
840 ctx
->Color
.AlphaRef
= CLAMP(ref
, 0.0F
, 1.0F
);
842 if (ctx
->Driver
.AlphaFunc
)
843 ctx
->Driver
.AlphaFunc(ctx
, func
, ctx
->Color
.AlphaRef
);
847 _mesa_error( ctx
, GL_INVALID_ENUM
, "glAlphaFunc(func)" );
853 static ALWAYS_INLINE
void
854 logic_op(struct gl_context
*ctx
, GLenum opcode
, bool no_error
)
856 if (ctx
->Color
.LogicOp
== opcode
)
864 case GL_COPY_INVERTED
:
874 case GL_AND_INVERTED
:
879 _mesa_error( ctx
, GL_INVALID_ENUM
, "glLogicOp" );
884 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewLogicOp
? 0 : _NEW_COLOR
);
885 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewLogicOp
;
886 ctx
->Color
.LogicOp
= opcode
;
888 if (ctx
->Driver
.LogicOpcode
)
889 ctx
->Driver
.LogicOpcode(ctx
, opcode
);
894 * Specify a logic pixel operation for color index rendering.
896 * \param opcode operation.
898 * Verifies that \p opcode is a valid enum and updates
899 * gl_colorbuffer_attrib::LogicOp.
900 * On a change, flushes the vertices and notifies the driver via the
901 * dd_function_table::LogicOpcode callback.
904 _mesa_LogicOp( GLenum opcode
)
906 GET_CURRENT_CONTEXT(ctx
);
908 if (MESA_VERBOSE
& VERBOSE_API
)
909 _mesa_debug(ctx
, "glLogicOp(%s)\n", _mesa_enum_to_string(opcode
));
911 logic_op(ctx
, opcode
, false);
916 _mesa_LogicOp_no_error(GLenum opcode
)
918 GET_CURRENT_CONTEXT(ctx
);
919 logic_op(ctx
, opcode
, true);
924 _mesa_IndexMask( GLuint mask
)
926 GET_CURRENT_CONTEXT(ctx
);
928 if (ctx
->Color
.IndexMask
== mask
)
931 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewColorMask
? 0 : _NEW_COLOR
);
932 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewColorMask
;
933 ctx
->Color
.IndexMask
= mask
;
938 * Enable or disable writing of frame buffer color components.
940 * \param red whether to mask writing of the red color component.
941 * \param green whether to mask writing of the green color component.
942 * \param blue whether to mask writing of the blue color component.
943 * \param alpha whether to mask writing of the alpha color component.
947 * Sets the appropriate value of gl_colorbuffer_attrib::ColorMask. On a
948 * change, flushes the vertices and notifies the driver via the
949 * dd_function_table::ColorMask callback.
952 _mesa_ColorMask( GLboolean red
, GLboolean green
,
953 GLboolean blue
, GLboolean alpha
)
955 GET_CURRENT_CONTEXT(ctx
);
960 if (MESA_VERBOSE
& VERBOSE_API
)
961 _mesa_debug(ctx
, "glColorMask(%d, %d, %d, %d)\n",
962 red
, green
, blue
, alpha
);
964 /* Shouldn't have any information about channel depth in core mesa
965 * -- should probably store these as the native booleans:
967 tmp
[RCOMP
] = red
? 0xff : 0x0;
968 tmp
[GCOMP
] = green
? 0xff : 0x0;
969 tmp
[BCOMP
] = blue
? 0xff : 0x0;
970 tmp
[ACOMP
] = alpha
? 0xff : 0x0;
973 for (i
= 0; i
< ctx
->Const
.MaxDrawBuffers
; i
++) {
974 if (!TEST_EQ_4V(tmp
, ctx
->Color
.ColorMask
[i
])) {
976 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewColorMask
? 0 : _NEW_COLOR
);
977 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewColorMask
;
980 COPY_4UBV(ctx
->Color
.ColorMask
[i
], tmp
);
984 if (ctx
->Driver
.ColorMask
)
985 ctx
->Driver
.ColorMask( ctx
, red
, green
, blue
, alpha
);
990 * For GL_EXT_draw_buffers2 and GL3
993 _mesa_ColorMaski( GLuint buf
, GLboolean red
, GLboolean green
,
994 GLboolean blue
, GLboolean alpha
)
997 GET_CURRENT_CONTEXT(ctx
);
999 if (MESA_VERBOSE
& VERBOSE_API
)
1000 _mesa_debug(ctx
, "glColorMaskIndexed %u %d %d %d %d\n",
1001 buf
, red
, green
, blue
, alpha
);
1003 if (buf
>= ctx
->Const
.MaxDrawBuffers
) {
1004 _mesa_error(ctx
, GL_INVALID_VALUE
, "glColorMaskIndexed(buf=%u)", buf
);
1008 /* Shouldn't have any information about channel depth in core mesa
1009 * -- should probably store these as the native booleans:
1011 tmp
[RCOMP
] = red
? 0xff : 0x0;
1012 tmp
[GCOMP
] = green
? 0xff : 0x0;
1013 tmp
[BCOMP
] = blue
? 0xff : 0x0;
1014 tmp
[ACOMP
] = alpha
? 0xff : 0x0;
1016 if (TEST_EQ_4V(tmp
, ctx
->Color
.ColorMask
[buf
]))
1019 FLUSH_VERTICES(ctx
, ctx
->DriverFlags
.NewColorMask
? 0 : _NEW_COLOR
);
1020 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewColorMask
;
1021 COPY_4UBV(ctx
->Color
.ColorMask
[buf
], tmp
);
1026 _mesa_ClampColor(GLenum target
, GLenum clamp
)
1028 GET_CURRENT_CONTEXT(ctx
);
1030 /* Check for both the extension and the GL version, since the Intel driver
1031 * does not advertise the extension in core profiles.
1033 if (ctx
->Version
<= 30 && !ctx
->Extensions
.ARB_color_buffer_float
) {
1034 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glClampColor()");
1038 if (clamp
!= GL_TRUE
&& clamp
!= GL_FALSE
&& clamp
!= GL_FIXED_ONLY_ARB
) {
1039 _mesa_error(ctx
, GL_INVALID_ENUM
, "glClampColorARB(clamp)");
1044 case GL_CLAMP_VERTEX_COLOR_ARB
:
1045 if (ctx
->API
== API_OPENGL_CORE
)
1047 FLUSH_VERTICES(ctx
, _NEW_LIGHT
);
1048 ctx
->Light
.ClampVertexColor
= clamp
;
1049 _mesa_update_clamp_vertex_color(ctx
, ctx
->DrawBuffer
);
1051 case GL_CLAMP_FRAGMENT_COLOR_ARB
:
1052 if (ctx
->API
== API_OPENGL_CORE
)
1054 FLUSH_VERTICES(ctx
, _NEW_FRAG_CLAMP
);
1055 ctx
->Color
.ClampFragmentColor
= clamp
;
1056 _mesa_update_clamp_fragment_color(ctx
, ctx
->DrawBuffer
);
1058 case GL_CLAMP_READ_COLOR_ARB
:
1059 ctx
->Color
.ClampReadColor
= clamp
;
1067 _mesa_error(ctx
, GL_INVALID_ENUM
, "glClampColor(%s)",
1068 _mesa_enum_to_string(target
));
1072 get_clamp_color(const struct gl_framebuffer
*fb
, GLenum clamp
)
1074 if (clamp
== GL_TRUE
|| clamp
== GL_FALSE
)
1077 assert(clamp
== GL_FIXED_ONLY
);
1081 return fb
->_AllColorBuffersFixedPoint
;
1085 _mesa_get_clamp_fragment_color(const struct gl_context
*ctx
,
1086 const struct gl_framebuffer
*drawFb
)
1088 return get_clamp_color(drawFb
, ctx
->Color
.ClampFragmentColor
);
1092 _mesa_get_clamp_vertex_color(const struct gl_context
*ctx
,
1093 const struct gl_framebuffer
*drawFb
)
1095 return get_clamp_color(drawFb
, ctx
->Light
.ClampVertexColor
);
1099 _mesa_get_clamp_read_color(const struct gl_context
*ctx
,
1100 const struct gl_framebuffer
*readFb
)
1102 return get_clamp_color(readFb
, ctx
->Color
.ClampReadColor
);
1106 * Update the ctx->Color._ClampFragmentColor field
1109 _mesa_update_clamp_fragment_color(struct gl_context
*ctx
,
1110 const struct gl_framebuffer
*drawFb
)
1113 * - there is no colorbuffer
1114 * - all colorbuffers are unsigned normalized, so clamping has no effect
1115 * - there is an integer colorbuffer
1117 if (!drawFb
|| !drawFb
->_HasSNormOrFloatColorBuffer
||
1118 drawFb
->_IntegerBuffers
)
1119 ctx
->Color
._ClampFragmentColor
= GL_FALSE
;
1121 ctx
->Color
._ClampFragmentColor
=
1122 _mesa_get_clamp_fragment_color(ctx
, drawFb
);
1126 * Update the ctx->Color._ClampVertexColor field
1129 _mesa_update_clamp_vertex_color(struct gl_context
*ctx
,
1130 const struct gl_framebuffer
*drawFb
)
1132 ctx
->Light
._ClampVertexColor
=
1133 _mesa_get_clamp_vertex_color(ctx
, drawFb
);
1137 * Returns an appropriate mesa_format for color rendering based on the
1138 * GL_FRAMEBUFFER_SRGB state.
1140 * Some drivers implement GL_FRAMEBUFFER_SRGB using a flag on the blend state
1141 * (which GL_FRAMEBUFFER_SRGB maps to reasonably), but some have to do so by
1142 * overriding the format of the surface. This is a helper for doing the
1143 * surface format override variant.
1146 _mesa_get_render_format(const struct gl_context
*ctx
, mesa_format format
)
1148 if (ctx
->Color
.sRGBEnabled
)
1151 return _mesa_get_srgb_format_linear(format
);
1154 /**********************************************************************/
1155 /** \name Initialization */
1159 * Initialization of the context's Color attribute group.
1161 * \param ctx GL context.
1163 * Initializes the related fields in the context color attribute group,
1164 * __struct gl_contextRec::Color.
1166 void _mesa_init_color( struct gl_context
* ctx
)
1170 /* Color buffer group */
1171 ctx
->Color
.IndexMask
= ~0u;
1172 memset(ctx
->Color
.ColorMask
, 0xff, sizeof(ctx
->Color
.ColorMask
));
1173 ctx
->Color
.ClearIndex
= 0;
1174 ASSIGN_4V( ctx
->Color
.ClearColor
.f
, 0, 0, 0, 0 );
1175 ctx
->Color
.AlphaEnabled
= GL_FALSE
;
1176 ctx
->Color
.AlphaFunc
= GL_ALWAYS
;
1177 ctx
->Color
.AlphaRef
= 0;
1178 ctx
->Color
.BlendEnabled
= 0x0;
1179 for (i
= 0; i
< ARRAY_SIZE(ctx
->Color
.Blend
); i
++) {
1180 ctx
->Color
.Blend
[i
].SrcRGB
= GL_ONE
;
1181 ctx
->Color
.Blend
[i
].DstRGB
= GL_ZERO
;
1182 ctx
->Color
.Blend
[i
].SrcA
= GL_ONE
;
1183 ctx
->Color
.Blend
[i
].DstA
= GL_ZERO
;
1184 ctx
->Color
.Blend
[i
].EquationRGB
= GL_FUNC_ADD
;
1185 ctx
->Color
.Blend
[i
].EquationA
= GL_FUNC_ADD
;
1187 ASSIGN_4V( ctx
->Color
.BlendColor
, 0.0, 0.0, 0.0, 0.0 );
1188 ASSIGN_4V( ctx
->Color
.BlendColorUnclamped
, 0.0, 0.0, 0.0, 0.0 );
1189 ctx
->Color
.IndexLogicOpEnabled
= GL_FALSE
;
1190 ctx
->Color
.ColorLogicOpEnabled
= GL_FALSE
;
1191 ctx
->Color
.LogicOp
= GL_COPY
;
1192 ctx
->Color
.DitherFlag
= GL_TRUE
;
1194 /* GL_FRONT is not possible on GLES. Instead GL_BACK will render to either
1195 * the front or the back buffer depending on the config */
1196 if (ctx
->Visual
.doubleBufferMode
|| _mesa_is_gles(ctx
)) {
1197 ctx
->Color
.DrawBuffer
[0] = GL_BACK
;
1200 ctx
->Color
.DrawBuffer
[0] = GL_FRONT
;
1203 ctx
->Color
.ClampFragmentColor
= ctx
->API
== API_OPENGL_COMPAT
?
1204 GL_FIXED_ONLY_ARB
: GL_FALSE
;
1205 ctx
->Color
._ClampFragmentColor
= GL_FALSE
;
1206 ctx
->Color
.ClampReadColor
= GL_FIXED_ONLY_ARB
;
1208 /* GLES 1/2/3 behaves as though GL_FRAMEBUFFER_SRGB is always enabled
1209 * if EGL_KHR_gl_colorspace has been used to request sRGB.
1211 ctx
->Color
.sRGBEnabled
= _mesa_is_gles(ctx
);
1213 ctx
->Color
.BlendCoherent
= true;