X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_blend.c;h=1001d6f2124818b82e19ae5a36c46bb1552e72cf;hb=89353febc0fdb1db6ff14633da604a59eee3913a;hp=d22616e36b55e28f612472f33ee098d02d5abdd7;hpb=01915e90e6912f06d43d443a09157f7bbc96ddc5;p=mesa.git diff --git a/src/mesa/swrast/s_blend.c b/src/mesa/swrast/s_blend.c index d22616e36b5..1001d6f2124 100644 --- a/src/mesa/swrast/s_blend.c +++ b/src/mesa/swrast/s_blend.c @@ -1,21 +1,19 @@ -/* $Id: s_blend.c,v 1.5 2001/03/08 15:23:46 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.5 - * - * Copyright (C) 1999-2000 Brian Paul All Rights Reserved. - * + * Version: 6.0 + * + * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL @@ -24,28 +22,77 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/* + * Regarding GL_NV_blend_square: + * + * Portions of this software may use or implement intellectual + * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims + * any and all warranties with respect to such intellectual property, + * including any use thereof or modifications thereto. + */ #include "glheader.h" #include "context.h" +#include "colormac.h" #include "macros.h" #include "s_alphabuf.h" #include "s_blend.h" #include "s_context.h" -#include "s_pb.h" #include "s_span.h" #if defined(USE_MMX_ASM) -#include "X86/mmx.h" -#include "X86/common_x86_asm.h" +#include "x86/mmx.h" +#include "x86/common_x86_asm.h" #define _BLENDAPI _ASMAPI #else #define _BLENDAPI #endif +/* + * Special case for glBlendFunc(GL_ZERO, GL_ONE) + */ +static void _BLENDAPI +blend_noop( GLcontext *ctx, GLuint n, const GLubyte mask[], + GLchan rgba[][4], CONST GLchan dest[][4] ) +{ + GLuint i; + ASSERT(ctx->Color.BlendEquationRGB==GL_FUNC_ADD); + ASSERT(ctx->Color.BlendEquationA==GL_FUNC_ADD); + ASSERT(ctx->Color.BlendSrcRGB==GL_ZERO); + ASSERT(ctx->Color.BlendDstRGB==GL_ONE); + (void) ctx; + + for (i = 0; i < n; i++) { + if (mask[i]) { + COPY_CHAN4( rgba[i], dest[i] ); + } + } +} + + +/* + * Special case for glBlendFunc(GL_ONE, GL_ZERO) + */ +static void _BLENDAPI +blend_replace( GLcontext *ctx, GLuint n, const GLubyte mask[], + GLchan rgba[][4], CONST GLchan dest[][4] ) +{ + ASSERT(ctx->Color.BlendEquationRGB==GL_FUNC_ADD); + ASSERT(ctx->Color.BlendEquationA==GL_FUNC_ADD); + ASSERT(ctx->Color.BlendSrcRGB==GL_ONE); + ASSERT(ctx->Color.BlendDstRGB==GL_ZERO); + (void) ctx; + (void) n; + (void) mask; + (void) rgba; + (void) dest; +} + + /* * Common transparency blending mode. */ @@ -54,14 +101,15 @@ blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[], GLchan rgba[][4], CONST GLchan dest[][4] ) { GLuint i; - ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT); + ASSERT(ctx->Color.BlendEquationRGB==GL_FUNC_ADD); + ASSERT(ctx->Color.BlendEquationA==GL_FUNC_ADD); ASSERT(ctx->Color.BlendSrcRGB==GL_SRC_ALPHA); ASSERT(ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA); (void) ctx; for (i=0;i> 16 - const GLint s = CHAN_MAX - t; - const GLint r = DIV255(rgba[i][RCOMP] * t + dest[i][RCOMP] * s); - const GLint g = DIV255(rgba[i][GCOMP] * t + dest[i][GCOMP] * s); - const GLint b = DIV255(rgba[i][BCOMP] * t + dest[i][BCOMP] * s); - const GLint a = DIV255(rgba[i][ACOMP] * t + dest[i][ACOMP] * s); +#else + GLint temp; +#define DIV255(X) (temp = (X), ((temp << 8) + temp + 256) >> 16) +#endif + const GLint r = DIV255((rgba[i][RCOMP] - dest[i][RCOMP]) * t) + dest[i][RCOMP]; + const GLint g = DIV255((rgba[i][GCOMP] - dest[i][GCOMP]) * t) + dest[i][GCOMP]; + const GLint b = DIV255((rgba[i][BCOMP] - dest[i][BCOMP]) * t) + dest[i][BCOMP]; + const GLint a = DIV255((rgba[i][ACOMP] - dest[i][ACOMP]) * t) + dest[i][ACOMP]; + #undef DIV255 #elif CHAN_BITS == 16 const GLfloat tt = (GLfloat) t / CHAN_MAXF; - const GLfloat s = 1.0 - tt; - const GLint r = (GLint) (rgba[i][RCOMP] * tt + dest[i][RCOMP] * s); - const GLint g = (GLint) (rgba[i][GCOMP] * tt + dest[i][GCOMP] * s); - const GLint b = (GLint) (rgba[i][BCOMP] * tt + dest[i][BCOMP] * s); - const GLint a = (GLint) (rgba[i][ACOMP] * tt + dest[i][ACOMP] * s); + const GLint r = (GLint) ((rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]); + const GLint g = (GLint) ((rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]); + const GLint b = (GLint) ((rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]); + const GLint a = (GLint) ((rgba[i][ACOMP] - dest[i][ACOMP]) * tt + dest[i][ACOMP]); #else /* CHAN_BITS == 32 */ const GLfloat tt = (GLfloat) t / CHAN_MAXF; - const GLfloat s = 1.0 - tt; - const GLfloat r = rgba[i][RCOMP] * tt + dest[i][RCOMP] * s; - const GLfloat g = rgba[i][GCOMP] * tt + dest[i][GCOMP] * s; - const GLfloat b = rgba[i][BCOMP] * tt + dest[i][BCOMP] * s; - const GLfloat a = rgba[i][ACOMP] * tt + dest[i][ACOMP] * s; + const GLfloat r = (rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]; + const GLfloat g = (rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]; + const GLfloat b = (rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]; + const GLfloat a = CLAMP( rgba[i][ACOMP], 0.0F, CHAN_MAXF ) * t + + CLAMP( dest[i][ACOMP], 0.0F, CHAN_MAXF ) * (1.0F - t); #endif #endif ASSERT(r <= CHAN_MAX); @@ -137,13 +189,22 @@ blend_add( GLcontext *ctx, GLuint n, const GLubyte mask[], GLchan rgba[][4], CONST GLchan dest[][4] ) { GLuint i; - ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT); + ASSERT(ctx->Color.BlendEquationRGB==GL_FUNC_ADD); + ASSERT(ctx->Color.BlendEquationA==GL_FUNC_ADD); ASSERT(ctx->Color.BlendSrcRGB==GL_ONE); ASSERT(ctx->Color.BlendDstRGB==GL_ONE); (void) ctx; for (i=0;iColor.BlendEquation==GL_MIN_EXT); + ASSERT(ctx->Color.BlendEquationRGB==GL_MIN); + ASSERT(ctx->Color.BlendEquationA==GL_MIN); (void) ctx; for (i=0;iColor.BlendEquation==GL_MAX_EXT); + ASSERT(ctx->Color.BlendEquationRGB==GL_MAX); + ASSERT(ctx->Color.BlendEquationA==GL_MAX); (void) ctx; for (i=0;i> 8; - GLint g = (rgba[i][GCOMP] * dest[i][GCOMP]) >> 8; - GLint b = (rgba[i][BCOMP] * dest[i][BCOMP]) >> 8; - GLint a = (rgba[i][ACOMP] * dest[i][ACOMP]) >> 8; +#if CHAN_TYPE == GL_FLOAT + rgba[i][RCOMP] = rgba[i][RCOMP] * dest[i][RCOMP]; + rgba[i][GCOMP] = rgba[i][GCOMP] * dest[i][GCOMP]; + rgba[i][BCOMP] = rgba[i][BCOMP] * dest[i][BCOMP]; + rgba[i][ACOMP] = rgba[i][ACOMP] * dest[i][ACOMP]; +#elif CHAN_TYPE == GL_UNSIGNED_SHORT + GLint r = (rgba[i][RCOMP] * dest[i][RCOMP] + 65535) >> 16; + GLint g = (rgba[i][GCOMP] * dest[i][GCOMP] + 65535) >> 16; + GLint b = (rgba[i][BCOMP] * dest[i][BCOMP] + 65535) >> 16; + GLint a = (rgba[i][ACOMP] * dest[i][ACOMP] + 65535) >> 16; + rgba[i][RCOMP] = (GLchan) r; + rgba[i][GCOMP] = (GLchan) g; + rgba[i][BCOMP] = (GLchan) b; + rgba[i][ACOMP] = (GLchan) a; +#else + GLint r = (rgba[i][RCOMP] * dest[i][RCOMP] + 255) >> 8; + GLint g = (rgba[i][GCOMP] * dest[i][GCOMP] + 255) >> 8; + GLint b = (rgba[i][BCOMP] * dest[i][BCOMP] + 255) >> 8; + GLint a = (rgba[i][ACOMP] * dest[i][ACOMP] + 255) >> 8; rgba[i][RCOMP] = (GLchan) r; rgba[i][GCOMP] = (GLchan) g; rgba[i][BCOMP] = (GLchan) b; rgba[i][ACOMP] = (GLchan) a; +#endif } } } @@ -241,31 +331,50 @@ static void _BLENDAPI blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], GLchan rgba[][4], CONST GLchan dest[][4] ) { - GLfloat rscale = 1.0F / CHAN_MAXF; - GLfloat gscale = 1.0F / CHAN_MAXF; - GLfloat bscale = 1.0F / CHAN_MAXF; - GLfloat ascale = 1.0F / CHAN_MAXF; + const GLfloat rscale = 1.0F / CHAN_MAXF; + const GLfloat gscale = 1.0F / CHAN_MAXF; + const GLfloat bscale = 1.0F / CHAN_MAXF; + const GLfloat ascale = 1.0F / CHAN_MAXF; GLuint i; for (i=0;iColor.BlendSrcRGB) { @@ -289,7 +398,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], sR = sG = sB = (GLfloat) As * ascale; break; case GL_ONE_MINUS_SRC_ALPHA: - sR = sG = sB = (GLfloat) 1.0F - (GLfloat) As * ascale; + sR = sG = sB = 1.0F - (GLfloat) As * ascale; break; case GL_DST_ALPHA: sR = sG = sB = (GLfloat) Ad * ascale; @@ -334,7 +443,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], default: /* this should never happen */ _mesa_problem(ctx, "Bad blend source RGB factor in do_blend"); - return; + return; } /* Source Alpha factor */ @@ -355,7 +464,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], sA = (GLfloat) As * ascale; break; case GL_ONE_MINUS_SRC_ALPHA: - sA = (GLfloat) 1.0F - (GLfloat) As * ascale; + sA = 1.0F - (GLfloat) As * ascale; break; case GL_DST_ALPHA: sA =(GLfloat) Ad * ascale; @@ -412,7 +521,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], dR = dG = dB = (GLfloat) As * ascale; break; case GL_ONE_MINUS_SRC_ALPHA: - dR = dG = dB = (GLfloat) 1.0F - (GLfloat) As * ascale; + dR = dG = dB = 1.0F - (GLfloat) As * ascale; break; case GL_DST_ALPHA: dR = dG = dB = (GLfloat) Ad * ascale; @@ -470,7 +579,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], dA = (GLfloat) As * ascale; break; case GL_ONE_MINUS_SRC_ALPHA: - dA = (GLfloat) 1.0F - (GLfloat) As * ascale; + dA = 1.0F - (GLfloat) As * ascale; break; case GL_DST_ALPHA: dA = (GLfloat) Ad * ascale; @@ -500,7 +609,7 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], /* this should never happen */ dA = 0.0F; _mesa_problem(ctx, "Bad blend dest A factor in do_blend"); - return; + return; } /* Due to round-off problems we have to clamp against zero. */ @@ -524,27 +633,117 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], ASSERT( dA <= 1.0 ); /* compute blended color */ - if (ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) { +#if CHAN_TYPE == GL_FLOAT + if (ctx->Color.BlendEquationRGB==GL_FUNC_ADD) { + r = Rs * sR + Rd * dR; + g = Gs * sG + Gd * dG; + b = Bs * sB + Bd * dB; + a = As * sA + Ad * dA; + } + else if (ctx->Color.BlendEquationRGB==GL_FUNC_SUBTRACT) { + r = Rs * sR - Rd * dR; + g = Gs * sG - Gd * dG; + b = Bs * sB - Bd * dB; + a = As * sA - Ad * dA; + } + else if (ctx->Color.BlendEquationRGB==GL_FUNC_REVERSE_SUBTRACT) { + r = Rd * dR - Rs * sR; + g = Gd * dG - Gs * sG; + b = Bd * dB - Bs * sB; + a = Ad * dA - As * sA; + } + else if (ctx->Color.BlendEquationRGB==GL_MIN) { + r = MIN2( Rd, Rs ); + g = MIN2( Gd, Gs ); + b = MIN2( Bd, Bs ); + } + else if (ctx->Color.BlendEquationRGB==GL_MAX) { + r = MAX2( Rd, Rs ); + g = MAX2( Gd, Gs ); + b = MAX2( Bd, Bs ); + } + else { + /* should never get here */ + r = g = b = 0.0F; /* silence uninitialized var warning */ + _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); + } + + if (ctx->Color.BlendEquationA==GL_FUNC_ADD) { + a = As * sA + Ad * dA; + } + else if (ctx->Color.BlendEquationA==GL_FUNC_SUBTRACT) { + a = As * sA - Ad * dA; + } + else if (ctx->Color.BlendEquationA==GL_FUNC_REVERSE_SUBTRACT) { + a = Ad * dA - As * sA; + } + else if (ctx->Color.BlendEquationA==GL_MIN) { + a = MIN2( Ad, As ); + } + else if (ctx->Color.BlendEquationA==GL_MAX) { + a = MAX2( Ad, As ); + } + else { + /* should never get here */ + a = 0.0F; /* silence uninitialized var warning */ + _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); + } + + /* final clamping */ + rgba[i][RCOMP] = MAX2( r, 0.0F ); + rgba[i][GCOMP] = MAX2( g, 0.0F ); + rgba[i][BCOMP] = MAX2( b, 0.0F ); + rgba[i][ACOMP] = CLAMP( a, 0.0F, CHAN_MAXF ); +#else + if (ctx->Color.BlendEquationRGB==GL_FUNC_ADD) { r = Rs * sR + Rd * dR + 0.5F; g = Gs * sG + Gd * dG + 0.5F; b = Bs * sB + Bd * dB + 0.5F; - a = As * sA + Ad * dA + 0.5F; } - else if (ctx->Color.BlendEquation==GL_FUNC_SUBTRACT_EXT) { + else if (ctx->Color.BlendEquationRGB==GL_FUNC_SUBTRACT) { r = Rs * sR - Rd * dR + 0.5F; g = Gs * sG - Gd * dG + 0.5F; b = Bs * sB - Bd * dB + 0.5F; - a = As * sA - Ad * dA + 0.5F; } - else if (ctx->Color.BlendEquation==GL_FUNC_REVERSE_SUBTRACT_EXT) { + else if (ctx->Color.BlendEquationRGB==GL_FUNC_REVERSE_SUBTRACT) { r = Rd * dR - Rs * sR + 0.5F; g = Gd * dG - Gs * sG + 0.5F; b = Bd * dB - Bs * sB + 0.5F; + } + else if (ctx->Color.BlendEquationRGB==GL_MIN) { + r = MIN2( Rd, Rs ); + g = MIN2( Gd, Gs ); + b = MIN2( Bd, Bs ); + } + else if (ctx->Color.BlendEquationRGB==GL_MAX) { + r = MAX2( Rd, Rs ); + g = MAX2( Gd, Gs ); + b = MAX2( Bd, Bs ); + } + else { + /* should never get here */ + r = g = b = 0.0F; /* silence uninitialized var warning */ + _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); + } + + if (ctx->Color.BlendEquationA==GL_FUNC_ADD) { + a = As * sA + Ad * dA + 0.5F; + } + else if (ctx->Color.BlendEquationA==GL_FUNC_SUBTRACT) { + a = As * sA - Ad * dA + 0.5F; + } + else if (ctx->Color.BlendEquationA==GL_FUNC_REVERSE_SUBTRACT) { a = Ad * dA - As * sA + 0.5F; } + else if (ctx->Color.BlendEquationA==GL_MIN) { + a = MIN2( Ad, As ); + } + else if (ctx->Color.BlendEquationA==GL_MAX) { + a = MAX2( Ad, As ); + } else { /* should never get here */ - r = g = b = a = 0.0F; /* silence uninitialized var warning */ + a = 0.0F; /* silence uninitialized var warning */ _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); } @@ -553,55 +752,87 @@ blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[], rgba[i][GCOMP] = (GLchan) (GLint) CLAMP( g, 0.0F, CHAN_MAXF ); rgba[i][BCOMP] = (GLchan) (GLint) CLAMP( b, 0.0F, CHAN_MAXF ); rgba[i][ACOMP] = (GLchan) (GLint) CLAMP( a, 0.0F, CHAN_MAXF ); +#endif } } } - - - /* * Analyze current blending parameters to pick fastest blending function. * Result: the ctx->Color.BlendFunc pointer is updated. */ void _swrast_choose_blend_func( GLcontext *ctx ) { - const GLenum eq = ctx->Color.BlendEquation; + const GLenum eq = ctx->Color.BlendEquationRGB; const GLenum srcRGB = ctx->Color.BlendSrcRGB; const GLenum dstRGB = ctx->Color.BlendDstRGB; const GLenum srcA = ctx->Color.BlendSrcA; const GLenum dstA = ctx->Color.BlendDstA; - if (srcRGB != srcA || dstRGB != dstA) { + if (ctx->Color.BlendEquationRGB != ctx->Color.BlendEquationA) { SWRAST_CONTEXT(ctx)->BlendFunc = blend_general; } - else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_SRC_ALPHA - && dstRGB==GL_ONE_MINUS_SRC_ALPHA) - { + else if (eq==GL_MIN) { + /* Note: GL_MIN ignores the blending weight factors */ +#if defined(USE_MMX_ASM) + if ( cpu_has_mmx ) { + SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_min; + } + else +#endif + SWRAST_CONTEXT(ctx)->BlendFunc = blend_min; + } + else if (eq==GL_MAX) { + /* Note: GL_MAX ignores the blending weight factors */ #if defined(USE_MMX_ASM) if ( cpu_has_mmx ) { - SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_transparency; + SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_max; + } + else +#endif + SWRAST_CONTEXT(ctx)->BlendFunc = blend_max; + } + else if (srcRGB != srcA || dstRGB != dstA) { + SWRAST_CONTEXT(ctx)->BlendFunc = blend_general; + } + else if (eq==GL_FUNC_ADD && srcRGB==GL_SRC_ALPHA + && dstRGB==GL_ONE_MINUS_SRC_ALPHA) { +#if defined(USE_MMX_ASM) + if ( cpu_has_mmx ) { + SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_transparency; } else #endif SWRAST_CONTEXT(ctx)->BlendFunc = blend_transparency; } - else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_ONE && dstRGB==GL_ONE) { - SWRAST_CONTEXT(ctx)->BlendFunc = blend_add; + else if (eq==GL_FUNC_ADD && srcRGB==GL_ONE && dstRGB==GL_ONE) { +#if defined(USE_MMX_ASM) + if ( cpu_has_mmx ) { + SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_add; + } + else +#endif + SWRAST_CONTEXT(ctx)->BlendFunc = blend_add; } - else if (((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_REVERSE_SUBTRACT_EXT) + else if (((eq==GL_FUNC_ADD || eq==GL_FUNC_REVERSE_SUBTRACT) && (srcRGB==GL_ZERO && dstRGB==GL_SRC_COLOR)) || - ((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_SUBTRACT_EXT) + ((eq==GL_FUNC_ADD || eq==GL_FUNC_SUBTRACT) && (srcRGB==GL_DST_COLOR && dstRGB==GL_ZERO))) { - SWRAST_CONTEXT(ctx)->BlendFunc = blend_modulate; +#if defined(USE_MMX_ASM) + if ( cpu_has_mmx ) { + SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_modulate; + } + else +#endif + SWRAST_CONTEXT(ctx)->BlendFunc = blend_modulate; } - else if (eq==GL_MIN_EXT) { - SWRAST_CONTEXT(ctx)->BlendFunc = blend_min; + else if (eq==GL_FUNC_ADD && srcRGB == GL_ZERO && dstRGB == GL_ONE) { + SWRAST_CONTEXT(ctx)->BlendFunc = blend_noop; } - else if (eq==GL_MAX_EXT) { - SWRAST_CONTEXT(ctx)->BlendFunc = blend_max; + else if (eq==GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ZERO) { + SWRAST_CONTEXT(ctx)->BlendFunc = blend_replace; } else { SWRAST_CONTEXT(ctx)->BlendFunc = blend_general; @@ -612,60 +843,38 @@ void _swrast_choose_blend_func( GLcontext *ctx ) /* * Apply the blending operator to a span of pixels. - * Input: n - number of pixels in span - * x, y - location of leftmost pixel in span in window coords. - * mask - boolean mask indicating which pixels to blend. - * In/Out: rgba - pixel values + * We can handle horizontal runs of pixels (spans) or arrays of x/y + * pixel coordinates. */ void -_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y, - GLchan rgba[][4], const GLubyte mask[] ) +_swrast_blend_span( GLcontext *ctx, const struct sw_span *span, + GLchan rgba[][4] ) { - GLchan dest[MAX_WIDTH][4]; + SWcontext *swrast = SWRAST_CONTEXT(ctx); + GLchan framebuffer[MAX_WIDTH][4]; - /* Check if device driver can do the work */ - if (ctx->Color.BlendEquation==GL_LOGIC_OP && - !ctx->Color.ColorLogicOpEnabled) { - return; - } + ASSERT(span->end <= MAX_WIDTH); + ASSERT(span->arrayMask & SPAN_RGBA); + ASSERT(!ctx->Color._LogicOpEnabled); /* Read span of current frame buffer pixels */ - _mesa_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest ); - - SWRAST_CONTEXT(ctx)->BlendFunc( ctx, n, mask, rgba, - (const GLchan (*)[4]) dest ); -} - - - -/* - * Apply the blending operator to an array of pixels. - * Input: n - number of pixels in span - * x, y - array of pixel locations - * mask - boolean mask indicating which pixels to blend. - * In/Out: rgba - pixel values - */ -void -_mesa_blend_pixels( GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - GLchan rgba[][4], const GLubyte mask[] ) -{ - SWcontext *swrast = SWRAST_CONTEXT(ctx); - GLchan dest[PB_SIZE][4]; - - /* Check if device driver can do the work */ - if (ctx->Color.BlendEquation==GL_LOGIC_OP && - !ctx->Color.ColorLogicOpEnabled) { - return; + if (span->arrayMask & SPAN_XY) { + /* array of x/y pixel coords */ + (*swrast->Driver.ReadRGBAPixels)( ctx, span->end, + span->array->x, span->array->y, + framebuffer, span->array->mask ); + if (swrast->_RasterMask & ALPHABUF_BIT) { + _swrast_read_alpha_pixels( ctx, span->end, + span->array->x, span->array->y, + framebuffer, span->array->mask ); + } } - - /* Read pixels from current color buffer */ - (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask ); - if (swrast->_RasterMask & ALPHABUF_BIT) { - _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask ); + else { + /* horizontal run of pixels */ + _swrast_read_rgba_span( ctx, ctx->DrawBuffer, span->end, + span->x, span->y, framebuffer ); } - swrast->BlendFunc( ctx, n, mask, rgba, (const GLchan (*)[4])dest ); + SWRAST_CONTEXT(ctx)->BlendFunc( ctx, span->end, span->array->mask, rgba, + (const GLchan (*)[4]) framebuffer ); } - -