* 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"
/**
- * 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);
(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);
}
}
}
/**
- * 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];
+ }
}
}
}
/**
- * 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] );
+ }
}
}
}
/**
* 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++) {
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;
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:
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;
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:
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];
}
}
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;
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;
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))
((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;
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);
}
}
-/* 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);
}
}
-/* 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)
* 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).
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);
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);
(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
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);
projects / mesa.git / commitdiff