diff options
| -rw-r--r-- | src/mesa/swrast/s_blend.c | 975 | ||||
| -rw-r--r-- | src/mesa/swrast/s_blend.h | 2 | ||||
| -rw-r--r-- | src/mesa/swrast/s_context.c | 8 | ||||
| -rw-r--r-- | src/mesa/swrast/s_context.h | 2 | ||||
| -rw-r--r-- | src/mesa/swrast/s_span.c | 466 |
5 files changed, 706 insertions, 747 deletions
diff --git a/src/mesa/swrast/s_blend.c b/src/mesa/swrast/s_blend.c index 4e6c3d909f4..a8d45bbf5f2 100644 --- a/src/mesa/swrast/s_blend.c +++ b/src/mesa/swrast/s_blend.c @@ -22,16 +22,19 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/* - * Regarding GL_NV_blend_square: + +/** + * \file swrast/s_blend.c + * \brief software blending. + * \author Brian Paul * - * 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. + * Only a few blend modes have been optimized (min, max, transparency, add) + * more optimized cases can easily be added if needed. + * Celestia uses glBlendFunc(GL_SRC_ALPHA, GL_ONE), for example. */ + #include "glheader.h" #include "context.h" #include "colormac.h" @@ -52,33 +55,51 @@ /** - * Special case for glBlendFunc(GL_ZERO, GL_ONE) + * Integer divide by 255 + * Declare "int divtemp" before using. + * This satisfies Glean and should be reasonably fast. + * Contributed by Nathan Hand. + */ +#define DIV255(X) (divtemp = (X), ((divtemp << 8) + divtemp + 256) >> 16) + + + +/** + * Special case for glBlendFunc(GL_ZERO, GL_ONE). + * No-op means the framebuffer values remain unchanged. + * Any chanType ok. */ static void _BLENDAPI -blend_noop_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType) +blend_noop(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) { - GLuint i; + GLint bytes; + 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] ); - } - } + /* just memcpy */ + if (chanType == GL_UNSIGNED_BYTE) + bytes = 4 * n * sizeof(GLubyte); + else if (chanType == GL_UNSIGNED_SHORT) + bytes = 4 * n * sizeof(GLushort); + else + bytes = 4 * n * sizeof(GLfloat); + + _mesa_memcpy(src, dst, bytes); } /** * Special case for glBlendFunc(GL_ONE, GL_ZERO) + * Any chanType ok. */ static void _BLENDAPI blend_replace(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType) + GLvoid *src, const GLvoid *dst, GLenum chanType) { ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD); ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD); @@ -87,95 +108,129 @@ blend_replace(GLcontext *ctx, GLuint n, const GLubyte mask[], (void) ctx; (void) n; (void) mask; - (void) rgba; - (void) dest; + (void) src; + (void) dst; } /** - * Common transparency blending mode. + * Common transparency blending mode: + * glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA). */ static void _BLENDAPI blend_transparency_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], - GLenum chanType) + GLvoid *src, const GLvoid *dst, GLenum chanType) { + GLubyte (*rgba)[4] = (GLubyte (*)[4]) src; + const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst; GLuint i; + ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD); ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD); ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA); ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA); ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA); ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA); + ASSERT(chanType == GL_UNSIGNED_BYTE); + (void) ctx; - for (i=0;i<n;i++) { + for (i = 0; i < n; i++) { if (mask[i]) { - const GLchan t = rgba[i][ACOMP]; /* t in [0, CHAN_MAX] */ + const GLint t = rgba[i][ACOMP]; /* t is in [0, 255] */ if (t == 0) { /* 0% alpha */ - rgba[i][RCOMP] = dest[i][RCOMP]; - rgba[i][GCOMP] = dest[i][GCOMP]; - rgba[i][BCOMP] = dest[i][BCOMP]; - rgba[i][ACOMP] = dest[i][ACOMP]; - } - else if (t == CHAN_MAX) { - /* 100% alpha, no-op */ + COPY_4UBV(rgba[i], dest[i]); } - else { -#if 0 - /* This is pretty close, but Glean complains */ - const GLint s = CHAN_MAX - t; - const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s + 1) >> 8; - const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s + 1) >> 8; - const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s + 1) >> 8; - const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s + 1) >> 8; -#elif 0 - /* This is slower but satisfies Glean */ - const GLint s = CHAN_MAX - t; - const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) / 255; - const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) / 255; - const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) / 255; - const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) / 255; -#else -#if CHAN_BITS == 8 - /* This satisfies Glean and should be reasonably fast */ - /* Contributed by Nathan Hand */ -#if 0 -#define DIV255(X) (((X) << 8) + (X) + 256) >> 16 -#else - GLint temp; -#define DIV255(X) (temp = (X), ((temp << 8) + temp + 256) >> 16) -#endif + else if (t != 255) { + GLint divtemp; 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]; + ASSERT(r <= 255); + ASSERT(g <= 255); + ASSERT(b <= 255); + ASSERT(a <= 255); + rgba[i][RCOMP] = (GLubyte) r; + rgba[i][GCOMP] = (GLubyte) g; + rgba[i][BCOMP] = (GLubyte) b; + rgba[i][ACOMP] = (GLubyte) a; + } + } + } +} -#undef DIV255 -#elif CHAN_BITS == 16 - const GLfloat tt = (GLfloat) t / CHAN_MAXF; - 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 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); - ASSERT(g <= CHAN_MAX); - ASSERT(b <= CHAN_MAX); - ASSERT(a <= CHAN_MAX); - rgba[i][RCOMP] = (GLchan) r; - rgba[i][GCOMP] = (GLchan) g; - rgba[i][BCOMP] = (GLchan) b; - rgba[i][ACOMP] = (GLchan) a; + +static void _BLENDAPI +blend_transparency_ushort(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) +{ + GLushort (*rgba)[4] = (GLushort (*)[4]) src; + const GLushort (*dest)[4] = (const GLushort (*)[4]) dst; + GLuint i; + + ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD); + ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD); + ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA); + ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA); + ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA); + ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA); + ASSERT(chanType == GL_UNSIGNED_SHORT); + + (void) ctx; + + for (i = 0; i < n; i++) { + if (mask[i]) { + const GLint t = rgba[i][ACOMP]; + if (t == 0) { + /* 0% alpha */ + COPY_4V(rgba[i], dest[i]); + } + else if (t != 65535) { + const GLfloat tt = (GLfloat) t / 65535.0F; + GLushort r = (GLushort) ((rgba[i][RCOMP] - dest[i][RCOMP]) * tt + dest[i][RCOMP]); + GLushort g = (GLushort) ((rgba[i][GCOMP] - dest[i][GCOMP]) * tt + dest[i][GCOMP]); + GLushort b = (GLushort) ((rgba[i][BCOMP] - dest[i][BCOMP]) * tt + dest[i][BCOMP]); + GLushort a = (GLushort) ((rgba[i][ACOMP] - dest[i][ACOMP]) * tt + dest[i][ACOMP]); + ASSIGN_4V(rgba[i], r, g, b, a); + } + } + } +} + + +static void _BLENDAPI +blend_transparency_float(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) +{ + GLfloat (*rgba)[4] = (GLfloat (*)[4]) src; + const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst; + GLuint i; + + ASSERT(ctx->Color.BlendEquationRGB == GL_FUNC_ADD); + ASSERT(ctx->Color.BlendEquationA == GL_FUNC_ADD); + ASSERT(ctx->Color.BlendSrcRGB == GL_SRC_ALPHA); + ASSERT(ctx->Color.BlendSrcA == GL_SRC_ALPHA); + ASSERT(ctx->Color.BlendDstRGB == GL_ONE_MINUS_SRC_ALPHA); + ASSERT(ctx->Color.BlendDstA == GL_ONE_MINUS_SRC_ALPHA); + ASSERT(chanType == GL_FLOAT); + + (void) ctx; + + for (i = 0; i < n; i++) { + if (mask[i]) { + const GLfloat t = rgba[i][ACOMP]; /* t in [0, 1] */ + if (t == 0.0F) { + /* 0% alpha */ + COPY_4V(rgba[i], dest[i]); + } + else if (t != 1.0F) { + GLfloat r = (rgba[i][RCOMP] - dest[i][RCOMP]) * t + dest[i][RCOMP]; + GLfloat g = (rgba[i][GCOMP] - dest[i][GCOMP]) * t + dest[i][GCOMP]; + GLfloat b = (rgba[i][BCOMP] - dest[i][BCOMP]) * t + dest[i][BCOMP]; + GLfloat a = (rgba[i][ACOMP] - dest[i][ACOMP]) * t + dest[i][ACOMP]; + ASSIGN_4V(rgba[i], r, g, b, a); } } } @@ -184,38 +239,65 @@ blend_transparency_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], /** - * Add src and dest. + * Add src and dest: glBlendFunc(GL_ONE, GL_ONE). + * Any chanType ok. */ static void _BLENDAPI -blend_add_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType) +blend_add(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) { GLuint i; + 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;i<n;i++) { - if (mask[i]) { -#if CHAN_TYPE == GL_FLOAT - /* don't RGB clamp to max */ - GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, CHAN_MAXF) + dest[i][ACOMP]; - rgba[i][RCOMP] += dest[i][RCOMP]; - rgba[i][GCOMP] += dest[i][GCOMP]; - rgba[i][BCOMP] += dest[i][BCOMP]; - rgba[i][ACOMP] = (GLchan) MIN2( a, CHAN_MAXF ); -#else - GLint r = rgba[i][RCOMP] + dest[i][RCOMP]; - GLint g = rgba[i][GCOMP] + dest[i][GCOMP]; - GLint b = rgba[i][BCOMP] + dest[i][BCOMP]; - GLint a = rgba[i][ACOMP] + dest[i][ACOMP]; - rgba[i][RCOMP] = (GLchan) MIN2( r, CHAN_MAX ); - rgba[i][GCOMP] = (GLchan) MIN2( g, CHAN_MAX ); - rgba[i][BCOMP] = (GLchan) MIN2( b, CHAN_MAX ); - rgba[i][ACOMP] = (GLchan) MIN2( a, CHAN_MAX ); -#endif + if (chanType == GL_UNSIGNED_BYTE) { + GLubyte (*rgba)[4] = (GLubyte (*)[4]) src; + const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + GLint r = rgba[i][RCOMP] + dest[i][RCOMP]; + GLint g = rgba[i][GCOMP] + dest[i][GCOMP]; + GLint b = rgba[i][BCOMP] + dest[i][BCOMP]; + GLint a = rgba[i][ACOMP] + dest[i][ACOMP]; + rgba[i][RCOMP] = (GLubyte) MIN2( r, 255 ); + rgba[i][GCOMP] = (GLubyte) MIN2( g, 255 ); + rgba[i][BCOMP] = (GLubyte) MIN2( b, 255 ); + rgba[i][ACOMP] = (GLubyte) MIN2( a, 255 ); + } + } + } + else if (chanType == GL_UNSIGNED_SHORT) { + GLushort (*rgba)[4] = (GLushort (*)[4]) src; + const GLushort (*dest)[4] = (const GLushort (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + GLint r = rgba[i][RCOMP] + dest[i][RCOMP]; + GLint g = rgba[i][GCOMP] + dest[i][GCOMP]; + GLint b = rgba[i][BCOMP] + dest[i][BCOMP]; + GLint a = rgba[i][ACOMP] + dest[i][ACOMP]; + rgba[i][RCOMP] = (GLshort) MIN2( r, 255 ); + rgba[i][GCOMP] = (GLshort) MIN2( g, 255 ); + rgba[i][BCOMP] = (GLshort) MIN2( b, 255 ); + rgba[i][ACOMP] = (GLshort) MIN2( a, 255 ); + } + } + } + else { + GLfloat (*rgba)[4] = (GLfloat (*)[4]) src; + const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst; + ASSERT(chanType == GL_FLOAT); + for (i=0;i<n;i++) { + if (mask[i]) { + /* don't RGB clamp to max */ + rgba[i][RCOMP] += dest[i][RCOMP]; + rgba[i][GCOMP] += dest[i][GCOMP]; + rgba[i][BCOMP] += dest[i][BCOMP]; + rgba[i][ACOMP] += dest[i][ACOMP]; + } } } } @@ -223,57 +305,106 @@ blend_add_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], /** - * Blend min function (for GL_EXT_blend_minmax) + * Blend min function. + * Any chanType ok. */ static void _BLENDAPI -blend_min_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType) +blend_min(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) { GLuint i; ASSERT(ctx->Color.BlendEquationRGB == GL_MIN); ASSERT(ctx->Color.BlendEquationA == GL_MIN); (void) ctx; - for (i=0;i<n;i++) { - if (mask[i]) { - rgba[i][RCOMP] = (GLchan) MIN2( rgba[i][RCOMP], dest[i][RCOMP] ); - rgba[i][GCOMP] = (GLchan) MIN2( rgba[i][GCOMP], dest[i][GCOMP] ); - rgba[i][BCOMP] = (GLchan) MIN2( rgba[i][BCOMP], dest[i][BCOMP] ); -#if CHAN_TYPE == GL_FLOAT - rgba[i][ACOMP] = (GLchan) MIN2(CLAMP(rgba[i][ACOMP], 0.0F, CHAN_MAXF), - dest[i][ACOMP]); -#else - rgba[i][ACOMP] = (GLchan) MIN2( rgba[i][ACOMP], dest[i][ACOMP] ); -#endif + if (chanType == GL_UNSIGNED_BYTE) { + GLubyte (*rgba)[4] = (GLubyte (*)[4]) src; + const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] ); + rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] ); + rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] ); + rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] ); + } + } + } + else if (chanType == GL_UNSIGNED_SHORT) { + GLushort (*rgba)[4] = (GLushort (*)[4]) src; + const GLushort (*dest)[4] = (const GLushort (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] ); + rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] ); + rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] ); + rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] ); + } + } + } + else { + GLfloat (*rgba)[4] = (GLfloat (*)[4]) src; + const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst; + ASSERT(chanType == GL_FLOAT); + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = MIN2( rgba[i][RCOMP], dest[i][RCOMP] ); + rgba[i][GCOMP] = MIN2( rgba[i][GCOMP], dest[i][GCOMP] ); + rgba[i][BCOMP] = MIN2( rgba[i][BCOMP], dest[i][BCOMP] ); + rgba[i][ACOMP] = MIN2( rgba[i][ACOMP], dest[i][ACOMP] ); + } } } } - /** - * Blend max function (for GL_EXT_blend_minmax) + * Blend max function. + * Any chanType ok. */ static void _BLENDAPI -blend_max_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType) +blend_max(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) { GLuint i; ASSERT(ctx->Color.BlendEquationRGB == GL_MAX); ASSERT(ctx->Color.BlendEquationA == GL_MAX); (void) ctx; - for (i=0;i<n;i++) { - if (mask[i]) { - rgba[i][RCOMP] = (GLchan) MAX2( rgba[i][RCOMP], dest[i][RCOMP] ); - rgba[i][GCOMP] = (GLchan) MAX2( rgba[i][GCOMP], dest[i][GCOMP] ); - rgba[i][BCOMP] = (GLchan) MAX2( rgba[i][BCOMP], dest[i][BCOMP] ); -#if CHAN_TYPE == GL_FLOAT - rgba[i][ACOMP] = (GLchan) MAX2(CLAMP(rgba[i][ACOMP], 0.0F, CHAN_MAXF), - dest[i][ACOMP]); -#else - rgba[i][ACOMP] = (GLchan) MAX2( rgba[i][ACOMP], dest[i][ACOMP] ); -#endif + if (chanType == GL_UNSIGNED_BYTE) { + GLubyte (*rgba)[4] = (GLubyte (*)[4]) src; + const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] ); + rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] ); + rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] ); + rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] ); + } + } + } + else if (chanType == GL_UNSIGNED_SHORT) { + GLushort (*rgba)[4] = (GLushort (*)[4]) src; + const GLushort (*dest)[4] = (const GLushort (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] ); + rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] ); + rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] ); + rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] ); + } + } + } + else { + GLfloat (*rgba)[4] = (GLfloat (*)[4]) src; + const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst; + ASSERT(chanType == GL_FLOAT); + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = MAX2( rgba[i][RCOMP], dest[i][RCOMP] ); + rgba[i][GCOMP] = MAX2( rgba[i][GCOMP], dest[i][GCOMP] ); + rgba[i][BCOMP] = MAX2( rgba[i][BCOMP], dest[i][BCOMP] ); + rgba[i][ACOMP] = MAX2( rgba[i][ACOMP], dest[i][ACOMP] ); + } } } } @@ -282,59 +413,68 @@ blend_max_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], /** * Modulate: result = src * dest + * Any chanType ok. */ static void _BLENDAPI -blend_modulate_ubyte(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], GLenum chanType) +blend_modulate(GLcontext *ctx, GLuint n, const GLubyte mask[], + GLvoid *src, const GLvoid *dst, GLenum chanType) { GLuint i; (void) ctx; - for (i=0;i<n;i++) { - if (mask[i]) { -#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 + if (chanType == GL_UNSIGNED_BYTE) { + GLubyte (*rgba)[4] = (GLubyte (*)[4]) src; + const GLubyte (*dest)[4] = (const GLubyte (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + GLint divtemp; + rgba[i][RCOMP] = DIV255(rgba[i][RCOMP] * dest[i][RCOMP]); + rgba[i][GCOMP] = DIV255(rgba[i][GCOMP] * dest[i][GCOMP]); + rgba[i][BCOMP] = DIV255(rgba[i][BCOMP] * dest[i][BCOMP]); + rgba[i][ACOMP] = DIV255(rgba[i][ACOMP] * dest[i][ACOMP]); + } + } + } + else if (chanType == GL_UNSIGNED_SHORT) { + GLushort (*rgba)[4] = (GLushort (*)[4]) src; + const GLushort (*dest)[4] = (const GLushort (*)[4]) dst; + for (i=0;i<n;i++) { + if (mask[i]) { + rgba[i][RCOMP] = (rgba[i][RCOMP] * dest[i][RCOMP] + 65535) >> 16; + rgba[i][GCOMP] = (rgba[i][GCOMP] * dest[i][GCOMP] + 65535) >> 16; + rgba[i][BCOMP] = (rgba[i][BCOMP] * dest[i][BCOMP] + 65535) >> 16; + rgba[i][ACOMP] = (rgba[i][ACOMP] * dest[i][ACOMP] + 65535) >> 16; + } + } + } + else { + GLfloat (*rgba)[4] = (GLfloat (*)[4]) src; + const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst; + ASSERT(chanType == GL_FLOAT); + for (i=0;i<n;i++) { + if (mask[i]) { + 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]; + } } } } -#if 0 /** * Do any blending operation, using floating point. * \param n number of pixels * \param mask fragment writemask array - * \param src array of incoming (and modified) pixels - * \param dst array of pixels from the dest color buffer + * \param rgba array of incoming (and modified) pixels + * \param dest array of pixels from the dest color buffer */ static void blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLvoid *src, const GLvoid *dst, GLenum chanType) + GLfloat rgba[][4], GLfloat dest[][4], + GLenum chanType) { - GLfloat (*rgba)[4] = (GLfloat (*)[4]) src; - const GLfloat (*dest)[4] = (const GLfloat (*)[4]) dst; GLuint i; for (i = 0; i < n; i++) { @@ -413,12 +553,12 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[], case GL_ONE_MINUS_CONSTANT_ALPHA: sR = sG = sB = 1.0F - ctx->Color.BlendColor[3]; break; - case GL_SRC_COLOR: /* GL_NV_blend_square */ + case GL_SRC_COLOR: sR = Rs; sG = Gs; sB = Bs; break; - case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */ + case GL_ONE_MINUS_SRC_COLOR: sR = 1.0F - Rs; sG = 1.0F - Gs; sB = 1.0F - Bs; @@ -470,10 +610,10 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[], case GL_ONE_MINUS_CONSTANT_ALPHA: sA = 1.0F - ctx->Color.BlendColor[3]; break; - case GL_SRC_COLOR: /* GL_NV_blend_square */ + case GL_SRC_COLOR: sA = As; break; - case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */ + case GL_ONE_MINUS_SRC_COLOR: sA = 1.0F - As; break; default: @@ -529,12 +669,12 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[], case GL_ONE_MINUS_CONSTANT_ALPHA: dR = dG = dB = 1.0F - ctx->Color.BlendColor[3]; break; - case GL_DST_COLOR: /* GL_NV_blend_square */ + case GL_DST_COLOR: dR = Rd; dG = Gd; dB = Bd; break; - case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */ + case GL_ONE_MINUS_DST_COLOR: dR = 1.0F - Rd; dG = 1.0F - Gd; dB = 1.0F - Bd; @@ -584,10 +724,10 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[], case GL_ONE_MINUS_CONSTANT_ALPHA: dA = 1.0F - ctx->Color.BlendColor[3]; break; - case GL_DST_COLOR: /* GL_NV_blend_square */ + case GL_DST_COLOR: dA = Ad; break; - case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */ + case GL_ONE_MINUS_DST_COLOR: dA = 1.0F - Ad; break; default: @@ -663,20 +803,21 @@ blend_general_float(GLcontext *ctx, GLuint n, const GLubyte mask[], 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 ); + rgba[i][ACOMP] = CLAMP( a, 0.0F, 1.0F ); #else ASSIGN_4V(rgba[i], r, g, b, a); #endif } } } -#endif -#if 0 /* not ready yet */ +/** + * Do any blending operation, any chanType. + */ static void -blend_general2(GLcontext *ctx, GLuint n, const GLubyte mask[], - void *src, const void *dst, GLenum chanType) +blend_general(GLcontext *ctx, GLuint n, const GLubyte mask[], + void *src, const void *dst, GLenum chanType) { GLfloat rgbaF[MAX_WIDTH][4], destF[MAX_WIDTH][4]; @@ -739,460 +880,18 @@ blend_general2(GLcontext *ctx, GLuint n, const GLubyte mask[], } } else { - blend_general_float(ctx, n, mask, (GLfloat (*)[4]) rgbaF, - (const GLfloat (*)[4]) destF, chanType); + blend_general_float(ctx, n, mask, rgbaF, destF, chanType); } } -#endif - - -static void _BLENDAPI -blend_general(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan rgba[][4], CONST GLchan dest[][4], - GLenum chanType) -{ - 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;i<n;i++) { - if (mask[i]) { -#if CHAN_TYPE == GL_FLOAT - GLfloat Rs, Gs, Bs, As; /* Source colors */ - GLfloat Rd, Gd, Bd, Ad; /* Dest colors */ -#else - GLint Rs, Gs, Bs, As; /* Source colors */ - GLint Rd, Gd, Bd, Ad; /* Dest colors */ -#endif - GLfloat sR, sG, sB, sA; /* Source scaling */ - GLfloat dR, dG, dB, dA; /* Dest scaling */ - GLfloat r, g, b, a; /* result color */ - /* Incoming/source Color */ - Rs = rgba[i][RCOMP]; - Gs = rgba[i][GCOMP]; - Bs = rgba[i][BCOMP]; - As = rgba[i][ACOMP]; -#if CHAN_TYPE == GL_FLOAT - /* clamp */ - Rs = MIN2(Rs, CHAN_MAXF); - Gs = MIN2(Gs, CHAN_MAXF); - Bs = MIN2(Bs, CHAN_MAXF); - As = MIN2(As, CHAN_MAXF); -#endif - - /* Frame buffer/dest color */ - Rd = dest[i][RCOMP]; - Gd = dest[i][GCOMP]; - Bd = dest[i][BCOMP]; - Ad = dest[i][ACOMP]; -#if CHAN_TYPE == GL_FLOAT - /* clamp */ - Rd = MIN2(Rd, CHAN_MAXF); - Gd = MIN2(Gd, CHAN_MAXF); - Bd = MIN2(Bd, CHAN_MAXF); - Ad = MIN2(Ad, CHAN_MAXF); -#endif - - /* Source RGB factor */ - switch (ctx->Color.BlendSrcRGB) { - case GL_ZERO: - sR = sG = sB = 0.0F; - break; - case GL_ONE: - sR = sG = sB = 1.0F; - break; - case GL_DST_COLOR: - sR = (GLfloat) Rd * rscale; - sG = (GLfloat) Gd * gscale; - sB = (GLfloat) Bd * bscale; - break; - case GL_ONE_MINUS_DST_COLOR: - sR = 1.0F - (GLfloat) Rd * rscale; - sG = 1.0F - (GLfloat) Gd * gscale; - sB = 1.0F - (GLfloat) Bd * bscale; - break; - case GL_SRC_ALPHA: - sR = sG = sB = (GLfloat) As * ascale; - break; - case GL_ONE_MINUS_SRC_ALPHA: - sR = sG = sB = 1.0F - (GLfloat) As * ascale; - break; - case GL_DST_ALPHA: - sR = sG = sB = (GLfloat) Ad * ascale; - break; - case GL_ONE_MINUS_DST_ALPHA: - sR = sG = sB = 1.0F - (GLfloat) Ad * ascale; - break; - case GL_SRC_ALPHA_SATURATE: - if (As < CHAN_MAX - Ad) { - sR = sG = sB = (GLfloat) As * ascale; - } - else { - sR = sG = sB = 1.0F - (GLfloat) Ad * ascale; - } - break; - case GL_CONSTANT_COLOR: - sR = ctx->Color.BlendColor[0]; - sG = ctx->Color.BlendColor[1]; - sB = ctx->Color.BlendColor[2]; - break; - case GL_ONE_MINUS_CONSTANT_COLOR: - sR = 1.0F - ctx->Color.BlendColor[0]; - sG = 1.0F - ctx->Color.BlendColor[1]; - sB = 1.0F - ctx->Color.BlendColor[2]; - break; - case GL_CONSTANT_ALPHA: - sR = sG = sB = ctx->Color.BlendColor[3]; - break; - case GL_ONE_MINUS_CONSTANT_ALPHA: - sR = sG = sB = 1.0F - ctx->Color.BlendColor[3]; - break; - case GL_SRC_COLOR: /* GL_NV_blend_square */ - sR = (GLfloat) Rs * rscale; - sG = (GLfloat) Gs * gscale; - sB = (GLfloat) Bs * bscale; - break; - case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */ - sR = 1.0F - (GLfloat) Rs * rscale; - sG = 1.0F - (GLfloat) Gs * gscale; - sB = 1.0F - (GLfloat) Bs * bscale; - break; - default: - /* this should never happen */ - _mesa_problem(ctx, "Bad blend source RGB factor in blend_general"); - return; - } - - /* Source Alpha factor */ - switch (ctx->Color.BlendSrcA) { - case GL_ZERO: - sA = 0.0F; - break; - case GL_ONE: - sA = 1.0F; - break; - case GL_DST_COLOR: - sA = (GLfloat) Ad * ascale; - break; - case GL_ONE_MINUS_DST_COLOR: - sA = 1.0F - (GLfloat) Ad * ascale; - break; - case GL_SRC_ALPHA: - sA = (GLfloat) As * ascale; - break; - case GL_ONE_MINUS_SRC_ALPHA: - sA = 1.0F - (GLfloat) As * ascale; - break; - case GL_DST_ALPHA: - sA = (GLfloat) Ad * ascale; - break; - case GL_ONE_MINUS_DST_ALPHA: - sA = 1.0F - (GLfloat) Ad * ascale; - break; - case GL_SRC_ALPHA_SATURATE: - sA = 1.0; - break; - case GL_CONSTANT_COLOR: - sA = ctx->Color.BlendColor[3]; - break; - case GL_ONE_MINUS_CONSTANT_COLOR: - sA = 1.0F - ctx->Color.BlendColor[3]; - break; - case GL_CONSTANT_ALPHA: - sA = ctx->Color.BlendColor[3]; - break; - case GL_ONE_MINUS_CONSTANT_ALPHA: - sA = 1.0F - ctx->Color.BlendColor[3]; - break; - case GL_SRC_COLOR: /* GL_NV_blend_square */ - sA = (GLfloat) As * ascale; - break; - case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */ - sA = 1.0F - (GLfloat) As * ascale; - break; - default: - /* this should never happen */ - sA = 0.0F; - _mesa_problem(ctx, "Bad blend source A factor in blend_general"); - return; - } - - /* Dest RGB factor */ - switch (ctx->Color.BlendDstRGB) { - case GL_ZERO: - dR = dG = dB = 0.0F; - break; - case GL_ONE: - dR = dG = dB = 1.0F; - break; - case GL_SRC_COLOR: - dR = (GLfloat) Rs * rscale; - dG = (GLfloat) Gs * gscale; - dB = (GLfloat) Bs * bscale; - break; - case GL_ONE_MINUS_SRC_COLOR: - dR = 1.0F - (GLfloat) Rs * rscale; - dG = 1.0F - (GLfloat) Gs * gscale; - dB = 1.0F - (GLfloat) Bs * bscale; - break; - case GL_SRC_ALPHA: - dR = dG = dB = (GLfloat) As * ascale; - break; - case GL_ONE_MINUS_SRC_ALPHA: - dR = dG = dB = 1.0F - (GLfloat) As * ascale; - break; - case GL_DST_ALPHA: - dR = dG = dB = (GLfloat) Ad * ascale; - break; - case GL_ONE_MINUS_DST_ALPHA: - dR = dG = dB = 1.0F - (GLfloat) Ad * ascale; - break; - case GL_CONSTANT_COLOR: - dR = ctx->Color.BlendColor[0]; - dG = ctx->Color.BlendColor[1]; - dB = ctx->Color.BlendColor[2]; - break; - case GL_ONE_MINUS_CONSTANT_COLOR: - dR = 1.0F - ctx->Color.BlendColor[0]; - dG = 1.0F - ctx->Color.BlendColor[1]; - dB = 1.0F - ctx->Color.BlendColor[2]; - break; - case GL_CONSTANT_ALPHA: - dR = dG = dB = ctx->Color.BlendColor[3]; - break; - case GL_ONE_MINUS_CONSTANT_ALPHA: - dR = dG = dB = 1.0F - ctx->Color.BlendColor[3]; - break; - case GL_DST_COLOR: /* GL_NV_blend_square */ - dR = (GLfloat) Rd * rscale; - dG = (GLfloat) Gd * gscale; - dB = (GLfloat) Bd * bscale; - break; - case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */ - dR = 1.0F - (GLfloat) Rd * rscale; - dG = 1.0F - (GLfloat) Gd * gscale; - dB = 1.0F - (GLfloat) Bd * bscale; - break; - default: - /* this should never happen */ - dR = dG = dB = 0.0F; - _mesa_problem(ctx, "Bad blend dest RGB factor in blend_general"); - return; - } - - /* Dest Alpha factor */ - switch (ctx->Color.BlendDstA) { - case GL_ZERO: - dA = 0.0F; - break; - case GL_ONE: - dA = 1.0F; - break; - case GL_SRC_COLOR: - dA = (GLfloat) As * ascale; - break; - case GL_ONE_MINUS_SRC_COLOR: - dA = 1.0F - (GLfloat) As * ascale; - break; - case GL_SRC_ALPHA: - dA = (GLfloat) As * ascale; - break; - case GL_ONE_MINUS_SRC_ALPHA: - dA = 1.0F - (GLfloat) As * ascale; - break; - case GL_DST_ALPHA: - dA = (GLfloat) Ad * ascale; - break; - case GL_ONE_MINUS_DST_ALPHA: - dA = 1.0F - (GLfloat) Ad * ascale; - break; - case GL_CONSTANT_COLOR: - dA = ctx->Color.BlendColor[3]; - break; - case GL_ONE_MINUS_CONSTANT_COLOR: - dA = 1.0F - ctx->Color.BlendColor[3]; - break; - case GL_CONSTANT_ALPHA: - dA = ctx->Color.BlendColor[3]; - break; - case GL_ONE_MINUS_CONSTANT_ALPHA: - dA = 1.0F - ctx->Color.BlendColor[3]; - break; - case GL_DST_COLOR: /* GL_NV_blend_square */ - dA = (GLfloat) Ad * ascale; - break; - case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */ - dA = 1.0F - (GLfloat) Ad * ascale; - break; - default: - /* this should never happen */ - dA = 0.0F; - _mesa_problem(ctx, "Bad blend dest A factor in blend_general"); - return; - } - - /* Due to round-off problems we have to clamp against zero. */ - /* Optimization: we don't have to do this for all src & dst factors */ - if (dA < 0.0F) dA = 0.0F; - if (dR < 0.0F) dR = 0.0F; - if (dG < 0.0F) dG = 0.0F; - if (dB < 0.0F) dB = 0.0F; - if (sA < 0.0F) sA = 0.0F; - if (sR < 0.0F) sR = 0.0F; - if (sG < 0.0F) sG = 0.0F; - if (sB < 0.0F) sB = 0.0F; - - ASSERT( sR <= 1.0 ); - ASSERT( sG <= 1.0 ); - ASSERT( sB <= 1.0 ); - ASSERT( sA <= 1.0 ); - ASSERT( dR <= 1.0 ); - ASSERT( dG <= 1.0 ); - ASSERT( dB <= 1.0 ); - ASSERT( dA <= 1.0 ); - - /* compute blended color */ -#if CHAN_TYPE == GL_FLOAT - switch (ctx->Color.BlendEquationRGB) { - case GL_FUNC_ADD: - r = Rs * sR + Rd * dR; - g = Gs * sG + Gd * dG; - b = Bs * sB + Bd * dB; - a = As * sA + Ad * dA; - break; - case GL_FUNC_SUBTRACT: - r = Rs * sR - Rd * dR; - g = Gs * sG - Gd * dG; - b = Bs * sB - Bd * dB; - a = As * sA - Ad * dA; - break; - case GL_FUNC_REVERSE_SUBTRACT: - r = Rd * dR - Rs * sR; - g = Gd * dG - Gs * sG; - b = Bd * dB - Bs * sB; - a = Ad * dA - As * sA; - break; - case GL_MIN: - r = MIN2( Rd, Rs ); - g = MIN2( Gd, Gs ); - b = MIN2( Bd, Bs ); - break; - case GL_MAX: - r = MAX2( Rd, Rs ); - g = MAX2( Gd, Gs ); - b = MAX2( Bd, Bs ); - break; - default: - /* should never get here */ - r = g = b = 0.0F; /* silence uninitialized var warning */ - _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); - return; - } - - switch (ctx->Color.BlendEquationA) { - case GL_FUNC_ADD: - a = As * sA + Ad * dA; - break; - case GL_FUNC_SUBTRACT: - a = As * sA - Ad * dA; - break; - case GL_FUNC_REVERSE_SUBTRACT: - a = Ad * dA - As * sA; - break; - case GL_MIN: - a = MIN2( Ad, As ); - break; - case GL_MAX: - a = MAX2( Ad, As ); - break; - default: - /* should never get here */ - a = 0.0F; /* silence uninitialized var warning */ - _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); - return; - } - - /* 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 - switch (ctx->Color.BlendEquationRGB) { - case GL_FUNC_ADD: - r = Rs * sR + Rd * dR + 0.5F; - g = Gs * sG + Gd * dG + 0.5F; - b = Bs * sB + Bd * dB + 0.5F; - break; - case GL_FUNC_SUBTRACT: - r = Rs * sR - Rd * dR + 0.5F; - g = Gs * sG - Gd * dG + 0.5F; - b = Bs * sB - Bd * dB + 0.5F; - break; - case 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; - break; - case GL_MIN: - r = MIN2( Rd, Rs ); - g = MIN2( Gd, Gs ); - b = MIN2( Bd, Bs ); - break; - case GL_MAX: - r = MAX2( Rd, Rs ); - g = MAX2( Gd, Gs ); - b = MAX2( Bd, Bs ); - break; - default: - /* should never get here */ - r = g = b = 0.0F; /* silence uninitialized var warning */ - _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); - return; - } - - switch (ctx->Color.BlendEquationA) { - case GL_FUNC_ADD: - a = As * sA + Ad * dA + 0.5F; - break; - case GL_FUNC_SUBTRACT: - a = As * sA - Ad * dA + 0.5F; - break; - case GL_FUNC_REVERSE_SUBTRACT: - a = Ad * dA - As * sA + 0.5F; - break; - case GL_MIN: - a = MIN2( Ad, As ); - break; - case GL_MAX: - a = MAX2( Ad, As ); - break; - default: - /* should never get here */ - a = 0.0F; /* silence uninitialized var warning */ - _mesa_problem(ctx, "unexpected BlendEquation in blend_general()"); - return; - } - - /* final clamping */ - rgba[i][RCOMP] = (GLchan) (GLint) CLAMP( r, 0.0F, CHAN_MAXF ); - 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 ) +void +_swrast_choose_blend_func(GLcontext *ctx, GLenum chanType) { SWcontext *swrast = SWRAST_CONTEXT(ctx); const GLenum eq = ctx->Color.BlendEquationRGB; @@ -1207,22 +906,22 @@ void _swrast_choose_blend_func( GLcontext *ctx ) else if (eq == GL_MIN) { /* Note: GL_MIN ignores the blending weight factors */ #if defined(USE_MMX_ASM) - if ( cpu_has_mmx ) { + if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) { swrast->BlendFunc = _mesa_mmx_blend_min; } else #endif - swrast->BlendFunc = blend_min_ubyte; + swrast->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 ) { + if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) { swrast->BlendFunc = _mesa_mmx_blend_max; } else #endif - swrast->BlendFunc = blend_max_ubyte; + swrast->BlendFunc = blend_max; } else if (srcRGB != srcA || dstRGB != dstA) { swrast->BlendFunc = blend_general; @@ -1230,21 +929,28 @@ void _swrast_choose_blend_func( GLcontext *ctx ) 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 ) { + if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) { swrast->BlendFunc = _mesa_mmx_blend_transparency; } else #endif - swrast->BlendFunc = blend_transparency_ubyte; + { + if (chanType == GL_UNSIGNED_BYTE) + swrast->BlendFunc = blend_transparency_ubyte; + else if (chanType == GL_UNSIGNED_SHORT) + swrast->BlendFunc = blend_transparency_ushort; + else + swrast->BlendFunc = blend_transparency_float; + } } else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ONE) { #if defined(USE_MMX_ASM) - if ( cpu_has_mmx ) { + if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) { swrast->BlendFunc = _mesa_mmx_blend_add; } else #endif - swrast->BlendFunc = blend_add_ubyte; + swrast->BlendFunc = blend_add; } else if (((eq == GL_FUNC_ADD || eq == GL_FUNC_REVERSE_SUBTRACT) && (srcRGB == GL_ZERO && dstRGB == GL_SRC_COLOR)) @@ -1252,15 +958,15 @@ void _swrast_choose_blend_func( GLcontext *ctx ) ((eq == GL_FUNC_ADD || eq == GL_FUNC_SUBTRACT) && (srcRGB == GL_DST_COLOR && dstRGB == GL_ZERO))) { #if defined(USE_MMX_ASM) - if ( cpu_has_mmx ) { + if (cpu_has_mmx && chanType == GL_UNSIGNED_BYTE) { swrast->BlendFunc = _mesa_mmx_blend_modulate; } else #endif - swrast->BlendFunc = blend_modulate_ubyte; + swrast->BlendFunc = blend_modulate; } else if (eq == GL_FUNC_ADD && srcRGB == GL_ZERO && dstRGB == GL_ONE) { - swrast->BlendFunc = blend_noop_ubyte; + swrast->BlendFunc = blend_noop; } else if (eq == GL_FUNC_ADD && srcRGB == GL_ONE && dstRGB == GL_ZERO) { swrast->BlendFunc = blend_replace; @@ -1292,6 +998,5 @@ _swrast_blend_span(GLcontext *ctx, struct gl_renderbuffer *rb, rbPixels = _swrast_get_dest_rgba(ctx, rb, span); swrast->BlendFunc(ctx, span->end, span->array->mask, - span->array->rgba, (const GLchan (*)[4]) rbPixels, - span->array->ChanType); + span->array->rgba, rbPixels, span->array->ChanType); } diff --git a/src/mesa/swrast/s_blend.h b/src/mesa/swrast/s_blend.h index 8baa8cd71d8..5b8e3b75924 100644 --- a/src/mesa/swrast/s_blend.h +++ b/src/mesa/swrast/s_blend.h @@ -37,7 +37,7 @@ _swrast_blend_span(GLcontext *ctx, struct gl_renderbuffer *rb, extern void -_swrast_choose_blend_func(GLcontext *ctx); +_swrast_choose_blend_func(GLcontext *ctx, GLenum chanType); #endif diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c index bb096be75a1..950561b5fca 100644 --- a/src/mesa/swrast/s_context.c +++ b/src/mesa/swrast/s_context.c @@ -291,6 +291,7 @@ _swrast_validate_triangle( GLcontext *ctx, _swrast_validate_derived( ctx ); swrast->choose_triangle( ctx ); + ASSERT(swrast->Triangle); if (ctx->Texture._EnabledUnits == 0 && NEED_SECONDARY_COLOR(ctx) @@ -314,6 +315,7 @@ _swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 ) _swrast_validate_derived( ctx ); swrast->choose_line( ctx ); + ASSERT(swrast->Line); if (ctx->Texture._EnabledUnits == 0 && NEED_SECONDARY_COLOR(ctx) @@ -355,13 +357,13 @@ _swrast_validate_point( GLcontext *ctx, const SWvertex *v0 ) */ static void _ASMAPI _swrast_validate_blend_func(GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan src[][4], CONST GLchan dst[][4], + GLvoid *src, const GLvoid *dst, GLenum chanType ) { SWcontext *swrast = SWRAST_CONTEXT(ctx); - _swrast_validate_derived( ctx ); - _swrast_choose_blend_func( ctx ); + _swrast_validate_derived( ctx ); /* why is this needed? */ + _swrast_choose_blend_func( ctx, chanType ); swrast->BlendFunc( ctx, n, mask, src, dst, chanType ); } diff --git a/src/mesa/swrast/s_context.h b/src/mesa/swrast/s_context.h index 0f3df3b48a4..b0447902140 100644 --- a/src/mesa/swrast/s_context.h +++ b/src/mesa/swrast/s_context.h @@ -251,7 +251,7 @@ typedef void (*texture_sample_func)(GLcontext *ctx, typedef void (_ASMAPIP blend_func)( GLcontext *ctx, GLuint n, const GLubyte mask[], - GLchan src[][4], CONST GLchan dst[][4], + GLvoid *src, const GLvoid *dst, GLenum chanType); typedef void (*swrast_point_func)( GLcontext *ctx, const SWvertex *); diff --git a/src/mesa/swrast/s_span.c b/src/mesa/swrast/s_span.c index 72b14ebf3af..8c4ee3e9099 100644 --- a/src/mesa/swrast/s_span.c +++ b/src/mesa/swrast/s_span.c @@ -149,62 +149,218 @@ _swrast_span_default_texcoords( GLcontext *ctx, struct sw_span *span ) } -/* Fill in the span.color.rgba array from the interpolation values */ +/** + * Interpolate colors to fill in the span->array->color array. + * \param specular if true, interpolate specular, else interpolate rgba. + */ static void -interpolate_colors(GLcontext *ctx, struct sw_span *span) +interpolate_colors(GLcontext *ctx, struct sw_span *span, GLboolean specular) { const GLuint n = span->end; - GLchan (*rgba)[4] = span->array->rgba; GLuint i; (void) ctx; - ASSERT((span->interpMask & SPAN_RGBA) && - !(span->arrayMask & SPAN_RGBA)); + if (!specular) { + ASSERT((span->interpMask & SPAN_RGBA) && + !(span->arrayMask & SPAN_RGBA)); + } if (span->interpMask & SPAN_FLAT) { /* constant color */ - GLchan color[4]; - color[RCOMP] = FixedToChan(span->red); - color[GCOMP] = FixedToChan(span->green); - color[BCOMP] = FixedToChan(span->blue); - color[ACOMP] = FixedToChan(span->alpha); - for (i = 0; i < n; i++) { - COPY_CHAN4(span->array->rgba[i], color); + switch (span->array->ChanType) { + case GL_UNSIGNED_BYTE: + { + GLubyte (*rgba)[4] = specular + ? span->array->color.sz1.spec : span->array->color.sz1.rgba; + GLubyte color[4]; + if (specular) { + color[RCOMP] = FixedToInt(span->specRed); + color[GCOMP] = FixedToInt(span->specGreen); + color[BCOMP] = FixedToInt(span->specBlue); + color[ACOMP] = 0; + } + else { + color[RCOMP] = FixedToInt(span->red); + color[GCOMP] = FixedToInt(span->green); + color[BCOMP] = FixedToInt(span->blue); + color[ACOMP] = FixedToInt(span->alpha); + } + for (i = 0; i < n; i++) { + COPY_4UBV(rgba[i], color); + } + } + break; + case GL_UNSIGNED_SHORT: + { + GLushort (*rgba)[4] = specular + ? span->array->color.sz2.spec : span->array->color.sz2.rgba; + GLushort color[4]; + if (specular) { + color[RCOMP] = FixedToInt(span->specRed); + color[GCOMP] = FixedToInt(span->specGreen); + color[BCOMP] = FixedToInt(span->specBlue); + color[ACOMP] = 0; + } + else { + color[RCOMP] = FixedToInt(span->red); + color[GCOMP] = FixedToInt(span->green); + color[BCOMP] = FixedToInt(span->blue); + color[ACOMP] = FixedToInt(span->alpha); + } + for (i = 0; i < n; i++) { + COPY_4V(rgba[i], color); + } + } + break; + case GL_FLOAT: + { + GLfloat (*rgba)[4] = specular ? + span->array->color.sz4.spec : span->array->color.sz4.rgba; + GLfloat color[4]; + ASSERT(CHAN_TYPE == GL_FLOAT); + if (specular) { + color[RCOMP] = span->specRed; + color[GCOMP] = span->specGreen; + color[BCOMP] = span->specBlue; + color[ACOMP] = 0.0F; + } + else { + color[RCOMP] = span->red; + color[GCOMP] = span->green; + color[BCOMP] = span->blue; + color[ACOMP] = span->alpha; + } + for (i = 0; i < n; i++) { + COPY_4V(rgba[i], color); + } + } + break; + default: + _mesa_problem(ctx, "bad datatype in interpolate_colors"); } } else { /* interpolate */ -#if CHAN_TYPE == GL_FLOAT - GLfloat r = span->red; - GLfloat g = span->green; - GLfloat b = span->blue; - GLfloat a = span->alpha; - const GLfloat dr = span->redStep; - const GLfloat dg = span->greenStep; - const GLfloat db = span->blueStep; - const GLfloat da = span->alphaStep; -#else - GLfixed r = span->red; - GLfixed g = span->green; - GLfixed b = span->blue; - GLfixed a = span->alpha; - const GLint dr = span->redStep; - const GLint dg = span->greenStep; - const GLint db = span->blueStep; - const GLint da = span->alphaStep; -#endif - for (i = 0; i < n; i++) { - rgba[i][RCOMP] = FixedToChan(r); - rgba[i][GCOMP] = FixedToChan(g); - rgba[i][BCOMP] = FixedToChan(b); - rgba[i][ACOMP] = FixedToChan(a); - r += dr; - g += dg; - b += db; - a += da; + switch (span->array->ChanType) { + case GL_UNSIGNED_BYTE: + { + GLubyte (*rgba)[4] = specular + ? span->array->color.sz1.spec : span->array->color.sz1.rgba; + GLfixed r, g, b, a; + GLint dr, dg, db, da; + if (specular) { + r = span->specRed; + g = span->specGreen; + b = span->specBlue; + a = 0; + dr = span->specRedStep; + dg = span->specGreenStep; + db = span->specBlueStep; + da = 0; + } + else { + r = span->red; + g = span->green; + b = span->blue; + a = span->alpha; + dr = span->redStep; + dg = span->greenStep; + db = span->blueStep; + da = span->alphaStep; + } + for (i = 0; i < n; i++) { + rgba[i][RCOMP] = FixedToChan(r); + rgba[i][GCOMP] = FixedToChan(g); + rgba[i][BCOMP] = FixedToChan(b); + rgba[i][ACOMP] = FixedToChan(a); + r += dr; + g += dg; + b += db; + a += da; + } + } + break; + case GL_UNSIGNED_SHORT: + { + GLushort (*rgba)[4] = specular + ? span->array->color.sz2.spec : span->array->color.sz2.rgba; + GLfixed r, g, b, a; + GLint dr, dg, db, da; + if (specular) { + r = span->specRed; + g = span->specGreen; + b = span->specBlue; + a = 0; + dr = span->specRedStep; + dg = span->specGreenStep; + db = span->specBlueStep; + da = 0; + } + else { + r = span->red; + g = span->green; + b = span->blue; + a = span->alpha; + dr = span->redStep; + dg = span->greenStep; + db = span->blueStep; + da = span->alphaStep; + } + for (i = 0; i < n; i++) { + rgba[i][RCOMP] = FixedToChan(r); + rgba[i][GCOMP] = FixedToChan(g); + rgba[i][BCOMP] = FixedToChan(b); + rgba[i][ACOMP] = FixedToChan(a); + r += dr; + g += dg; + b += db; + a += da; + } + } + break; + case GL_FLOAT: + { + GLfloat (*rgba)[4] = specular ? + span->array->color.sz4.spec : span->array->color.sz4.rgba; + GLfloat r, g, b, a, dr, dg, db, da; + if (specular) { + r = span->specRed; + g = span->specGreen; + b = span->specBlue; + a = 0.0F; + dr = span->specRedStep; + dg = span->specGreenStep; + db = span->specBlueStep; + da = 0.0F; + } + else { + r = span->red; + g = span->green; + b = span->blue; + a = span->alpha; + dr = span->redStep; + dg = span->greenStep; + db = span->blueStep; + da = span->alphaStep; + } + ASSERT(CHAN_TYPE == GL_FLOAT); + for (i = 0; i < n; i++) { + rgba[i][RCOMP] = r; + rgba[i][GCOMP] = g; + rgba[i][BCOMP] = b; + rgba[i][ACOMP] = a; + r += dr; + g += dg; + b += db; + a += da; + } + } + break; + default: + _mesa_problem(ctx, "bad datatype in interpolate_colors"); } } - span->arrayMask |= SPAN_RGBA; + span->arrayMask |= (specular ? SPAN_SPEC : SPAN_RGBA); } @@ -240,48 +396,6 @@ interpolate_indexes(GLcontext *ctx, struct sw_span *span) } -/* Fill in the span.->array->spec array from the interpolation values */ -static void -interpolate_specular(GLcontext *ctx, struct sw_span *span) -{ - (void) ctx; - if (span->interpMask & SPAN_FLAT) { - /* constant color */ - const GLchan r = FixedToChan(span->specRed); - const GLchan g = FixedToChan(span->specGreen); - const GLchan b = FixedToChan(span->specBlue); - GLuint i; - for (i = 0; i < span->end; i++) { - span->array->spec[i][RCOMP] = r; - span->array->spec[i][GCOMP] = g; - span->array->spec[i][BCOMP] = b; - } - } - else { - /* interpolate */ -#if CHAN_TYPE == GL_FLOAT - GLfloat r = span->specRed; - GLfloat g = span->specGreen; - GLfloat b = span->specBlue; -#else - GLfixed r = span->specRed; - GLfixed g = span->specGreen; - GLfixed b = span->specBlue; -#endif - GLuint i; - for (i = 0; i < span->end; i++) { - span->array->spec[i][RCOMP] = FixedToChan(r); - span->array->spec[i][GCOMP] = FixedToChan(g); - span->array->spec[i][BCOMP] = FixedToChan(b); - r += span->specRedStep; - g += span->specGreenStep; - b += span->specBlueStep; - } - } - span->arrayMask |= SPAN_SPEC; -} - - /* Fill in the span.array.fog values from the interpolation values */ static void interpolate_fog(const GLcontext *ctx, struct sw_span *span) @@ -1040,28 +1154,160 @@ _swrast_write_index_span( GLcontext *ctx, struct sw_span *span) * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR. */ static void -add_colors(GLuint n, GLchan rgba[][4], GLchan specular[][4] ) +add_specular(GLcontext *ctx, struct sw_span *span) { - GLuint i; - for (i = 0; i < n; i++) { -#if CHAN_TYPE == GL_FLOAT - /* no clamping */ - rgba[i][RCOMP] += specular[i][RCOMP]; - rgba[i][GCOMP] += specular[i][GCOMP]; - rgba[i][BCOMP] += specular[i][BCOMP]; -#else - GLint r = rgba[i][RCOMP] + specular[i][RCOMP]; - GLint g = rgba[i][GCOMP] + specular[i][GCOMP]; - GLint b = rgba[i][BCOMP] + specular[i][BCOMP]; - rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX); - rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX); - rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX); -#endif + switch (span->array->ChanType) { + case GL_UNSIGNED_BYTE: + { + GLubyte (*rgba)[4] = span->array->color.sz1.rgba; + GLubyte (*spec)[4] = span->array->color.sz1.spec; + GLuint i; + for (i = 0; i < span->end; i++) { + GLint r = rgba[i][RCOMP] + spec[i][RCOMP]; + GLint g = rgba[i][GCOMP] + spec[i][GCOMP]; + GLint b = rgba[i][BCOMP] + spec[i][BCOMP]; + GLint a = rgba[i][ACOMP] + spec[i][ACOMP]; + rgba[i][RCOMP] = MIN2(r, 255); + rgba[i][GCOMP] = MIN2(g, 255); + rgba[i][BCOMP] = MIN2(b, 255); + rgba[i][ACOMP] = MIN2(a, 255); + } + } + break; + case GL_UNSIGNED_SHORT: + { + GLushort (*rgba)[4] = span->array->color.sz2.rgba; + GLushort (*spec)[4] = span->array->color.sz2.spec; + GLuint i; + for (i = 0; i < span->end; i++) { + GLint r = rgba[i][RCOMP] + spec[i][RCOMP]; + GLint g = rgba[i][GCOMP] + spec[i][GCOMP]; + GLint b = rgba[i][BCOMP] + spec[i][BCOMP]; + GLint a = rgba[i][ACOMP] + spec[i][ACOMP]; + rgba[i][RCOMP] = MIN2(r, 65535); + rgba[i][GCOMP] = MIN2(g, 65535); + rgba[i][BCOMP] = MIN2(b, 65535); + rgba[i][ACOMP] = MIN2(a, 65535); + } + } + break; + case GL_FLOAT: + { + GLfloat (*rgba)[4] = span->array->color.sz4.rgba; + GLfloat (*spec)[4] = span->array->color.sz4.spec; + GLuint i; + for (i = 0; i < span->end; i++) { + rgba[i][RCOMP] += spec[i][RCOMP]; + rgba[i][GCOMP] += spec[i][GCOMP]; + rgba[i][BCOMP] += spec[i][BCOMP]; + rgba[i][ACOMP] += spec[i][ACOMP]; + } + } + break; + default: + _mesa_problem(ctx, "Invalid datatype in add_specular"); } } /** + * Convert the span's color arrays to the given type. + */ +static void +convert_color_type(GLcontext *ctx, struct sw_span *span, GLenum newType) +{ + const GLubyte *mask = span->array->mask; + GLubyte (*rgba1)[4] = span->array->color.sz1.rgba; + GLushort (*rgba2)[4] = span->array->color.sz2.rgba; + GLfloat (*rgba4)[4] = span->array->color.sz4.rgba; + + ASSERT(span->array->ChanType != newType); + + switch (span->array->ChanType) { + case GL_UNSIGNED_BYTE: + if (newType == GL_UNSIGNED_SHORT) { + GLuint i; + for (i = 0; i < span->end; i++) { + if (mask[i]) { + rgba2[i][RCOMP] = UBYTE_TO_USHORT(rgba1[i][RCOMP]); + rgba2[i][GCOMP] = UBYTE_TO_USHORT(rgba1[i][GCOMP]); + rgba2[i][BCOMP] = UBYTE_TO_USHORT(rgba1[i][BCOMP]); + rgba2[i][ACOMP] = UBYTE_TO_USHORT(rgba1[i][ACOMP]); + } + } + } + else { + GLuint i; + ASSERT(newType == GL_FLOAT); + for (i = 0; i < span->end; i++) { + if (mask[i]) { + rgba4[i][RCOMP] = UBYTE_TO_FLOAT(rgba1[i][RCOMP]); + rgba4[i][GCOMP] = UBYTE_TO_FLOAT(rgba1[i][GCOMP]); + rgba4[i][BCOMP] = UBYTE_TO_FLOAT(rgba1[i][BCOMP]); + rgba4[i][ACOMP] = UBYTE_TO_FLOAT(rgba1[i][ACOMP]); + } + } + } + break; + case GL_UNSIGNED_SHORT: + if (newType == GL_UNSIGNED_BYTE) { + GLuint i; + for (i = 0; i < span->end; i++) { + if (mask[i]) { + rgba1[i][RCOMP] = USHORT_TO_UBYTE(rgba2[i][RCOMP]); + rgba1[i][GCOMP] = USHORT_TO_UBYTE(rgba2[i][GCOMP]); + rgba1[i][BCOMP] = USHORT_TO_UBYTE(rgba2[i][BCOMP]); + rgba1[i][ACOMP] = USHORT_TO_UBYTE(rgba2[i][ACOMP]); + } + } + } + else { + GLuint i; + ASSERT(newType == GL_FLOAT); + for (i = 0; i < span->end; i++) { + if (mask[i]) { + rgba4[i][RCOMP] = USHORT_TO_FLOAT(rgba2[i][RCOMP]); + rgba4[i][GCOMP] = USHORT_TO_FLOAT(rgba2[i][GCOMP]); + rgba4[i][BCOMP] = USHORT_TO_FLOAT(rgba2[i][BCOMP]); + rgba4[i][ACOMP] = USHORT_TO_FLOAT(rgba2[i][ACOMP]); + } + } + } + break; + case GL_FLOAT: + if (newType == GL_UNSIGNED_BYTE) { + GLuint i; + for (i = 0; i < span->end; i++) { + if (mask[i]) { + UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][RCOMP], rgba4[i][RCOMP]); + UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][GCOMP], rgba4[i][GCOMP]); + UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][BCOMP], rgba4[i][BCOMP]); + UNCLAMPED_FLOAT_TO_UBYTE(rgba1[i][ACOMP], rgba4[i][ACOMP]); + } + } + } + else { + GLuint i; + ASSERT(newType == GL_UNSIGNED_SHORT); + for (i = 0; i < span->end; i++) { + if (mask[i]) { + UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][RCOMP], rgba4[i][RCOMP]); + UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][GCOMP], rgba4[i][GCOMP]); + UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][BCOMP], rgba4[i][BCOMP]); + UNCLAMPED_FLOAT_TO_USHORT(rgba2[i][ACOMP], rgba4[i][ACOMP]); + } + } + } + break; + default: + _mesa_problem(ctx, "Invalid datatype in convert_color_type"); + } + span->array->ChanType = newType; +} + + + +/** * Apply all the per-fragment operations to a span. * This now includes texturing (_swrast_write_texture_span() is history). * This function may modify any of the array values in the span. @@ -1144,10 +1390,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span) if (!deferredTexture) { /* Now we need the rgba array, fill it in if needed */ if ((span->interpMask & SPAN_RGBA) && (span->arrayMask & SPAN_RGBA) == 0) - interpolate_colors(ctx, span); + interpolate_colors(ctx, span, GL_FALSE); if (span->interpMask & SPAN_SPEC) - interpolate_specular(ctx, span); + interpolate_colors(ctx, span, GL_TRUE); if (span->interpMask & SPAN_FOG) interpolate_fog(ctx, span); @@ -1232,10 +1478,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span) if (deferredTexture) { /* Now we need the rgba array, fill it in if needed */ if ((span->interpMask & SPAN_RGBA) && (span->arrayMask & SPAN_RGBA) == 0) - interpolate_colors(ctx, span); + interpolate_colors(ctx, span, GL_FALSE); if (span->interpMask & SPAN_SPEC) - interpolate_specular(ctx, span); + interpolate_colors(ctx, span, GL_TRUE); if (span->interpMask & SPAN_FOG) interpolate_fog(ctx, span); @@ -1264,10 +1510,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span) (ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)) { if (span->interpMask & SPAN_SPEC) { - interpolate_specular(ctx, span); + interpolate_colors(ctx, span, GL_TRUE); } if (span->arrayMask & SPAN_SPEC) { - add_colors( span->end, span->array->rgba, span->array->spec ); + add_specular(ctx, span); } else { /* We probably added the base/specular colors during the @@ -1316,14 +1562,20 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span) GLchan rgbaSave[MAX_WIDTH][4]; GLuint buf; + if (numDrawBuffers > 0) { + if (fb->_ColorDrawBuffers[output][0]->DataType + != span->array->ChanType) { + convert_color_type(ctx, span, + fb->_ColorDrawBuffers[output][0]->DataType); + } + } + if (numDrawBuffers > 1) { /* save colors for second, third renderbuffer writes */ _mesa_memcpy(rgbaSave, span->array->rgba, 4 * span->end * sizeof(GLchan)); } - /* XXX check that span's ChanType == rb's DataType, convert if needed */ - for (buf = 0; buf < numDrawBuffers; buf++) { struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[output][buf]; ASSERT(rb->_BaseFormat == GL_RGBA); |