You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4450 lines
138 KiB
4450 lines
138 KiB
/*
|
|
** Copyright 1991, 1992, 1993, Silicon Graphics, Inc.
|
|
** All Rights Reserved.
|
|
**
|
|
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
|
|
** the contents of this file may not be disclosed to third parties, copied or
|
|
** duplicated in any form, in whole or in part, without the prior written
|
|
** permission of Silicon Graphics, Inc.
|
|
**
|
|
** RESTRICTED RIGHTS LEGEND:
|
|
** Use, duplication or disclosure by the Government is subject to restrictions
|
|
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
|
|
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
|
|
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
|
|
** rights reserved under the Copyright Laws of the United States.
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "genrgb.h"
|
|
#include "genclear.h"
|
|
|
|
#define STATIC
|
|
|
|
__GLfloat fDitherIncTable[16] = {
|
|
DITHER_INC(0), DITHER_INC(8), DITHER_INC(2), DITHER_INC(10),
|
|
DITHER_INC(12), DITHER_INC(4), DITHER_INC(14), DITHER_INC(6),
|
|
DITHER_INC(3), DITHER_INC(11), DITHER_INC(1), DITHER_INC(9),
|
|
DITHER_INC(15), DITHER_INC(7), DITHER_INC(13), DITHER_INC(5)
|
|
};
|
|
|
|
/* No Dither, No blend, No Write, No Nothing */
|
|
STATIC void FASTCALL Store_NOT(__GLcolorBuffer *cfb, const __GLfragment *frag)
|
|
{
|
|
}
|
|
|
|
STATIC GLboolean FASTCALL StoreSpanNone(__GLcontext *gc)
|
|
{
|
|
return GL_FALSE;
|
|
}
|
|
|
|
//
|
|
// Special case normal alpha blending (source alpha*src + dst*(1-sa))
|
|
// This case is used in antialiasing and actually jumping through
|
|
// the fetch and blend procs takes up a large amount of time. Moving
|
|
// the code into the store proc removes this overhead
|
|
//
|
|
// The macro requires a standard store proc setup, with gc, cfb, frag,
|
|
// blendColor and so on. It requires a dst_pix variable which
|
|
// will hold a pixel in the destination format.
|
|
// It also takes as an argument a statement which will set dst_pix.
|
|
// The reason it doesn't take the pixel itself is because only the special case
|
|
// actually needs the value. In all the flags cases the pixel
|
|
// retrieval would be wasted.
|
|
//
|
|
|
|
extern void __glDoBlend_SA_MSA(__GLcontext *gc, const __GLcolor *source,
|
|
const __GLcolor *dest, __GLcolor *result);
|
|
|
|
#define SPECIAL_ALPHA_BLEND(dst_pix_gen) \
|
|
color = &blendColor; \
|
|
if( (gc->procs.blendColor == __glDoBlend_SA_MSA) && \
|
|
!( ALPHA_WRITE_ENABLED( cfb )) ) \
|
|
{ \
|
|
__GLfloat a, msa; \
|
|
\
|
|
a = frag->color.a * gc->frontBuffer.oneOverAlphaScale; \
|
|
msa = __glOne - a; \
|
|
\
|
|
dst_pix_gen; \
|
|
blendColor.r = frag->color.r*a + msa*(__GLfloat) \
|
|
((dst_pix & gc->modes.redMask) >> cfb->redShift); \
|
|
blendColor.g = frag->color.g*a + msa*(__GLfloat) \
|
|
((dst_pix & gc->modes.greenMask) >> cfb->greenShift); \
|
|
blendColor.b = frag->color.b*a + msa*(__GLfloat) \
|
|
((dst_pix & gc->modes.blueMask) >> cfb->blueShift); \
|
|
} \
|
|
else \
|
|
{ \
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor ); \
|
|
}
|
|
|
|
#define SPECIAL_ALPHA_BLEND_SPAN(dst_pix_gen) \
|
|
if( (gc->procs.blendColor == __glDoBlend_SA_MSA) && \
|
|
!( ALPHA_WRITE_ENABLED( cfb )) ) \
|
|
{ \
|
|
__GLcolor *color = gc->polygon.shader.colors; \
|
|
\
|
|
for ( i = 0; i < w; i++, color++ ) \
|
|
{ \
|
|
__GLfloat a, msa; \
|
|
\
|
|
a = color->a * gc->frontBuffer.oneOverAlphaScale; \
|
|
msa = __glOne - a; \
|
|
\
|
|
dst_pix_gen; \
|
|
color->r = color->r*a + msa*(__GLfloat) \
|
|
((dst_pix & gc->modes.redMask) >> cfb->redShift); \
|
|
color->g = color->g*a + msa*(__GLfloat) \
|
|
((dst_pix & gc->modes.greenMask) >> cfb->greenShift); \
|
|
color->b = color->b*a + msa*(__GLfloat) \
|
|
((dst_pix & gc->modes.blueMask) >> cfb->blueShift); \
|
|
} \
|
|
} \
|
|
else \
|
|
{ \
|
|
(*gc->procs.blendSpan)( gc ); \
|
|
}
|
|
|
|
#define DitheredRGBColorToBuffer(col, incr, cfb, dest, type) \
|
|
((dest) = (type)(( FTOL((col)->r+(incr)) << (cfb)->redShift) | \
|
|
( FTOL((col)->g+(incr)) << (cfb)->greenShift) | \
|
|
( FTOL((col)->b+(incr)) << (cfb)->blueShift)))
|
|
#define UnditheredRGBColorToBuffer(col, cfb, dest, type) \
|
|
((dest) = (type)(( FTOL((col)->r) << (cfb)->redShift) | \
|
|
( FTOL((col)->g) << (cfb)->greenShift) | \
|
|
( FTOL((col)->b) << (cfb)->blueShift)))
|
|
#define DitheredRGBAColorToBuffer(col, incr, cfb, dest, type) \
|
|
((dest) = (type)(( FTOL((col)->r+(incr)) << (cfb)->redShift) | \
|
|
( FTOL((col)->g+(incr)) << (cfb)->greenShift) | \
|
|
( FTOL((col)->b+(incr)) << (cfb)->blueShift) | \
|
|
( FTOL((col)->a+(incr)) << (cfb)->alphaShift)))
|
|
#define UnditheredRGBAColorToBuffer(col, cfb, dest, type) \
|
|
((dest) = (type)(( FTOL((col)->r) << (cfb)->redShift) | \
|
|
( FTOL((col)->g) << (cfb)->greenShift) | \
|
|
( FTOL((col)->b) << (cfb)->blueShift) | \
|
|
( FTOL((col)->a) << (cfb)->alphaShift)))
|
|
|
|
#define DitheredColorToBuffer(col, incr, cfb, dest, type) \
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) \
|
|
DitheredRGBAColorToBuffer(col, incr, cfb, dest, type); \
|
|
else \
|
|
DitheredRGBColorToBuffer(col, incr, cfb, dest, type);
|
|
|
|
#define UnditheredColorToBuffer(col, cfb, dest, type) \
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) \
|
|
UnditheredRGBAColorToBuffer(col, cfb, dest, type); \
|
|
else \
|
|
UnditheredRGBColorToBuffer(col, cfb, dest, type);
|
|
|
|
#define StoreColorAsRGB(col, dst) \
|
|
(*(dst)++ = (BYTE) FTOL((col)->r), \
|
|
*(dst)++ = (BYTE) FTOL((col)->g), \
|
|
*(dst)++ = (BYTE) FTOL((col)->b) )
|
|
#define StoreColorAsBGR(col, dst) \
|
|
(*(dst)++ = (BYTE) FTOL((col)->b), \
|
|
*(dst)++ = (BYTE) FTOL((col)->g), \
|
|
*(dst)++ = (BYTE) FTOL((col)->r) )
|
|
|
|
// Macro to read RGBA bitfield span, where alpha component has 3 possibilities:
|
|
// 1) No alpha buffer, so use constant alpha
|
|
// 2) Alpha is part of the pixel
|
|
// 3) Alpha is in the software alpha buffer
|
|
// Note, currently this is only used for 16 and 32bpp.
|
|
|
|
#define READ_RGBA_BITFIELD_SPAN(src_pix_gen) \
|
|
if( !gc->modes.alphaBits ) { \
|
|
for( ; w; w--, pResults++ ) \
|
|
{ \
|
|
src_pix_gen; \
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift); \
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift); \
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift); \
|
|
pResults->a = cfb->alphaScale; \
|
|
} \
|
|
} \
|
|
else if( ALPHA_IN_PIXEL( cfb ) ) { \
|
|
for( ; w; w--, pResults++ ) \
|
|
{ \
|
|
src_pix_gen; \
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift); \
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift); \
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift); \
|
|
pResults->a = (__GLfloat) ((pixel & gc->modes.alphaMask) >> cfb->alphaShift); \
|
|
} \
|
|
} else { \
|
|
(*cfb->alphaBuf.readSpan)(&cfb->alphaBuf, x, y, w, pResults); \
|
|
for( ; w; w--, pResults++ ) \
|
|
{ \
|
|
src_pix_gen; \
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift); \
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift); \
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift); \
|
|
} \
|
|
}
|
|
|
|
/*
|
|
* write all
|
|
*/
|
|
STATIC void FASTCALL DIBIndex4Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte result, *puj;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
__GLfloat incr;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLubyte dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
if ( (cfb->buf.flags & NO_CLIP) ||
|
|
(*gengc->pfnPixelVisible)(x, y) )
|
|
{
|
|
incr = (enables & __GL_DITHER_ENABLE) ?
|
|
fDitherIncTable[__GL_DITHER_INDEX(frag->x, frag->y)] : __glHalf;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x >> 1));
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
SPECIAL_ALPHA_BLEND((dst_pix = gengc->pajInvTranslateVector
|
|
[(x & 1) ? (*puj & 0xf) : (*puj >> 4)]));
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
DitheredRGBColorToBuffer(color, incr, cfb, result, GLubyte);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
if( x & 1 )
|
|
{
|
|
dst_pix = (*puj & 0x0f);
|
|
}
|
|
else
|
|
{
|
|
dst_pix = (*puj & 0xf0) >> 4;
|
|
}
|
|
dst_pix = gengc->pajInvTranslateVector[dst_pix];
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLubyte)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLubyte)
|
|
((dst_pix & cfb->destMask) | (result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
// now put it in
|
|
result = gengc->pajTranslateVector[result];
|
|
if (x & 1)
|
|
{
|
|
*puj = (*puj & 0xf0) | result;
|
|
}
|
|
else
|
|
{
|
|
result <<= 4;
|
|
*puj = (*puj & 0x0f) | result;
|
|
}
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
}
|
|
|
|
|
|
STATIC void FASTCALL DIBIndex8Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte result, *puj;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
__GLfloat incr;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLubyte dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
if ( (cfb->buf.flags & NO_CLIP) ||
|
|
(*gengc->pfnPixelVisible)(x, y) )
|
|
{
|
|
incr = (enables & __GL_DITHER_ENABLE) ?
|
|
fDitherIncTable[__GL_DITHER_INDEX(frag->x, frag->y)] : __glHalf;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + x);
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
SPECIAL_ALPHA_BLEND((dst_pix =
|
|
gengc->pajInvTranslateVector[*puj]));
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
DitheredRGBColorToBuffer(color, incr, cfb, result, GLubyte);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = gengc->pajInvTranslateVector[*puj];
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLubyte)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLubyte)
|
|
((dst_pix & cfb->destMask) | (result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
*puj = gengc->pajTranslateVector[result];
|
|
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
}
|
|
|
|
// BMF_24BPP in BGR format
|
|
STATIC void FASTCALL DIBBGRStore(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte *puj;
|
|
GLuint result;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
if ( (cfb->buf.flags & NO_CLIP) ||
|
|
(*gengc->pfnPixelVisible)(x, y) )
|
|
{
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
SPECIAL_ALPHA_BLEND(Copy3Bytes(&dst_pix, puj));
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
Copy3Bytes( &dst_pix, puj );
|
|
|
|
UnditheredRGBColorToBuffer(color, cfb, result, GLuint);
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result =
|
|
(result & cfb->sourceMask) | (dst_pix & cfb->destMask);
|
|
}
|
|
|
|
Copy3Bytes( puj, &result );
|
|
}
|
|
else
|
|
{
|
|
StoreColorAsBGR(color, puj);
|
|
}
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
}
|
|
|
|
// BMF_24BPP in RGB format
|
|
STATIC void FASTCALL DIBRGBAStore(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte *puj;
|
|
GLuint result;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
if ( (cfb->buf.flags & NO_CLIP) ||
|
|
(*gengc->pfnPixelVisible)(x, y) )
|
|
{
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
SPECIAL_ALPHA_BLEND(Copy3Bytes(&dst_pix, puj));
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
Copy3Bytes( &dst_pix, puj );
|
|
UnditheredRGBColorToBuffer(color, cfb, result, GLuint);
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result =
|
|
(result & cfb->sourceMask) | (dst_pix & cfb->destMask);
|
|
}
|
|
|
|
Copy3Bytes( puj, &result );
|
|
}
|
|
else
|
|
{
|
|
StoreColorAsRGB(color, puj);
|
|
}
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
}
|
|
|
|
// BMF_16BPP
|
|
STATIC void FASTCALL DIBBitfield16Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLushort result, *pus;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
__GLfloat incr;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLushort dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
if ( (cfb->buf.flags & NO_CLIP) ||
|
|
(*gengc->pfnPixelVisible)(x, y) )
|
|
{
|
|
incr = (enables & __GL_DITHER_ENABLE) ?
|
|
fDitherIncTable[__GL_DITHER_INDEX(frag->x, frag->y)] : __glHalf;
|
|
|
|
pus = (GLushort *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x << 1));
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
SPECIAL_ALPHA_BLEND((dst_pix = *pus));
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
DitheredColorToBuffer(color, incr, cfb, result, GLushort);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = *pus;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLushort)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLushort)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
*pus = result;
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
}
|
|
|
|
// BMF_32BPP store
|
|
// each component is 8 bits or less
|
|
// XXX could special case if shifting by 8 or use the 24 bit RGB code
|
|
STATIC void FASTCALL DIBBitfield32Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLuint result, *pul;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
if ( (cfb->buf.flags & NO_CLIP) ||
|
|
(*gengc->pfnPixelVisible)(x, y) )
|
|
{
|
|
pul = (GLuint *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x << 2));
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
SPECIAL_ALPHA_BLEND((dst_pix = *pul));
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
UnditheredColorToBuffer(color, cfb, result, GLuint);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = *pul;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (dst_pix & cfb->destMask) | (result & cfb->sourceMask);
|
|
}
|
|
}
|
|
*pul = result;
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
}
|
|
|
|
static GLubyte vubRGBtoVGA[8] = {
|
|
0x00,
|
|
0x90,
|
|
0xa0,
|
|
0xb0,
|
|
0xc0,
|
|
0xd0,
|
|
0xe0,
|
|
0xf0
|
|
};
|
|
|
|
STATIC void FASTCALL DisplayIndex4Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte result, *puj;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
__GLfloat incr;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLubyte dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
incr = (enables & __GL_DITHER_ENABLE) ?
|
|
fDitherIncTable[__GL_DITHER_INDEX(frag->x, frag->y)] : __glHalf;
|
|
|
|
puj = gengc->ColorsBits;
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
color = &blendColor;
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor );
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
DitheredRGBColorToBuffer(color, incr, cfb, result, GLubyte);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
dst_pix = *puj >> 4;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLubyte)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLubyte)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
*puj = vubRGBtoVGA[result];
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, TRUE);
|
|
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
|
|
// Put fragment into created DIB and call copybits for one pixel
|
|
STATIC void FASTCALL DisplayIndex8Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte result, *puj;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
__GLfloat incr;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLubyte dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
incr = (enables & __GL_DITHER_ENABLE) ?
|
|
fDitherIncTable[__GL_DITHER_INDEX(frag->x, frag->y)] : __glHalf;
|
|
|
|
puj = gengc->ColorsBits;
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
color = &blendColor;
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor );
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
DitheredRGBColorToBuffer(color, incr, cfb, result, GLubyte);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
dst_pix = gengc->pajInvTranslateVector[*puj];
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLubyte)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLubyte)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
*puj = gengc->pajTranslateVector[result];
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, TRUE);
|
|
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
|
|
STATIC void FASTCALL DisplayBGRStore(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte *puj;
|
|
GLuint result;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
puj = gengc->ColorsBits;
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
color = &blendColor;
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor );
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
dst_pix = *(GLuint *)puj;
|
|
UnditheredRGBColorToBuffer(color, cfb, result, GLuint);
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask);
|
|
}
|
|
|
|
Copy3Bytes( puj, &result );
|
|
}
|
|
else
|
|
{
|
|
StoreColorAsBGR(color, puj);
|
|
}
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, TRUE);
|
|
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
|
|
STATIC void FASTCALL DisplayRGBStore(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLubyte *puj;
|
|
GLuint result;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
puj = gengc->ColorsBits;
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
color = &blendColor;
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor );
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
dst_pix = *(GLuint *)puj;
|
|
UnditheredRGBColorToBuffer(color, cfb, result, GLuint);
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask);
|
|
}
|
|
|
|
Copy3Bytes( puj, &result );
|
|
}
|
|
else
|
|
{
|
|
StoreColorAsRGB(color, puj);
|
|
}
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, TRUE);
|
|
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
|
|
STATIC void FASTCALL DisplayBitfield16Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLushort result, *pus;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
__GLfloat incr;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLushort dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
incr = (enables & __GL_DITHER_ENABLE) ?
|
|
fDitherIncTable[__GL_DITHER_INDEX(frag->x, frag->y)] : __glHalf;
|
|
|
|
pus = gengc->ColorsBits;
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
color = &blendColor;
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor );
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
DitheredColorToBuffer(color, incr, cfb, result, GLushort);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
dst_pix = *pus;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLushort)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLushort)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
*pus = result;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
|
|
STATIC void FASTCALL DisplayBitfield32Store(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
GLint x, y;
|
|
GLuint result, *pul;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint enables = gc->state.enables.general;
|
|
__GLcolor blendColor;
|
|
const __GLcolor *color;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, frag->x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, frag->y) + cfb->buf.yOrigin;
|
|
// x & y are screen coords now
|
|
|
|
pul = gengc->ColorsBits;
|
|
|
|
if( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
color = &blendColor;
|
|
(*gc->procs.blend)( gc, cfb, frag, &blendColor );
|
|
}
|
|
else
|
|
{
|
|
color = &(frag->color);
|
|
}
|
|
|
|
UnditheredColorToBuffer(color, cfb, result, GLuint);
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
dst_pix = *pul;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask);
|
|
}
|
|
}
|
|
|
|
*pul = result;
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, color);
|
|
}
|
|
|
|
STATIC void FASTCALL AlphaStore(__GLcolorBuffer *cfb,
|
|
const __GLfragment *frag)
|
|
{
|
|
(*cfb->alphaBuf.store)(&cfb->alphaBuf, frag->x, frag->y, &(frag->color) );
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Index8StoreSpan
|
|
*
|
|
* Copies the current span in the renderer into a bitmap. If bDIB is TRUE,
|
|
* then the bitmap is the display in DIB format (or a memory DC). If bDIB
|
|
* is FALSE, then the bitmap is an offscreen scanline buffer and it will be
|
|
* output to the buffer by (*gengc->pfnCopyPixels)().
|
|
*
|
|
* This handles 8-bit CI mode. Blending and dithering are supported.
|
|
*
|
|
* Returns:
|
|
* GL_FALSE always. Soft code ignores return value.
|
|
*
|
|
* History:
|
|
* 15-Nov-1993 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX The returnSpan routine follows this routine very closely. Any changes
|
|
//XXX to this routine should also be reflected in the returnSpan routine
|
|
|
|
STATIC GLboolean FASTCALL Index8StoreSpan( __GLcontext *gc )
|
|
{
|
|
GLint xFrag, yFrag; // current fragment coordinates
|
|
__GLcolor *cp; // current fragment color
|
|
__GLcolorBuffer *cfb; // color frame buffer
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLubyte result, *puj; // current pixel color, current pixel ptr
|
|
GLubyte *pujEnd; // end of scan line
|
|
__GLfloat incr; // current dither adj.
|
|
|
|
GLint w; // span width
|
|
ULONG ulSpanVisibility; // span visibility mode
|
|
GLint cWalls;
|
|
GLint *Walls;
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLuint flags;
|
|
GLboolean bDIB;
|
|
GLubyte dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
// Get span position and length.
|
|
|
|
w = gc->polygon.shader.length;
|
|
xFrag = gc->polygon.shader.frag.x;
|
|
yFrag = gc->polygon.shader.frag.y;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
cfb = gc->drawBuffer;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, xFrag) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, yFrag) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
flags = cfb->buf.flags;
|
|
bDIB = flags & DIB_FORMAT;
|
|
|
|
if( !bDIB || (flags & NO_CLIP) )
|
|
{
|
|
// Device managed or unclipped surface
|
|
ulSpanVisibility = WGL_SPAN_ALL;
|
|
}
|
|
else
|
|
{
|
|
// Device in BITMAP format
|
|
ulSpanVisibility = wglSpanVisible(xScr, yScr, w, &cWalls, &Walls);
|
|
}
|
|
|
|
// Proceed as long as the span is (partially or fully) visible.
|
|
if (ulSpanVisibility != WGL_SPAN_NONE)
|
|
{
|
|
GLboolean bCheckWalls = GL_FALSE;
|
|
GLboolean bDraw;
|
|
GLint NextWall;
|
|
|
|
if (ulSpanVisibility == WGL_SPAN_PARTIAL)
|
|
{
|
|
bCheckWalls = GL_TRUE;
|
|
if (cWalls & 0x01)
|
|
{
|
|
bDraw = GL_TRUE;
|
|
}
|
|
else
|
|
{
|
|
bDraw = GL_FALSE;
|
|
}
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
// Get pointers to fragment colors array and frame buffer.
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
puj = bDIB ? (GLubyte *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + xScr)
|
|
: gengc->ColorsBits;
|
|
pujEnd = puj + w;
|
|
|
|
// Case: no dithering, no masking, no blending
|
|
//
|
|
// Check for the common case (which we'll do the fastest).
|
|
|
|
if ( !(enables & (__GL_DITHER_ENABLE)) &&
|
|
!(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE ) )
|
|
{
|
|
//!!!XXX -- we can also opt. by unrolling the loops
|
|
|
|
incr = __glHalf;
|
|
for (; puj < pujEnd; puj++, cp++)
|
|
{
|
|
if (bCheckWalls)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
}
|
|
|
|
DitheredRGBColorToBuffer(cp, incr, cfb, result, GLubyte);
|
|
*puj = gengc->pajTranslateVector[result];
|
|
}
|
|
}
|
|
|
|
// Case: dithering, no masking, no blending
|
|
//
|
|
// Dithering is pretty common for 8-bit displays, so its probably
|
|
// worth special case also.
|
|
|
|
else if ( !(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
for (; puj < pujEnd; puj++, cp++, xFrag++)
|
|
{
|
|
if (bCheckWalls)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
}
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
DitheredRGBColorToBuffer(cp, incr, cfb, result, GLubyte);
|
|
*puj = gengc->pajTranslateVector[result];
|
|
}
|
|
}
|
|
|
|
// Case: general
|
|
//
|
|
// Otherwise, we'll do it slower.
|
|
|
|
else
|
|
{
|
|
// Fetch pixels we will modify:
|
|
|
|
if( (!bDIB) && (cfb->buf.flags & NEED_FETCH) )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE );
|
|
|
|
// Blend.
|
|
if (enables & __GL_BLEND_ENABLE)
|
|
{
|
|
int i;
|
|
|
|
// this overwrites fragment colors array with blended values
|
|
SPECIAL_ALPHA_BLEND_SPAN(
|
|
(dst_pix =
|
|
gengc->pajInvTranslateVector[*(puj+i)]));
|
|
}
|
|
|
|
for (; puj < pujEnd; puj++, cp++)
|
|
{
|
|
if (bCheckWalls)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
}
|
|
// Dither.
|
|
|
|
if (enables & __GL_DITHER_ENABLE)
|
|
{
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
xFrag++;
|
|
}
|
|
else
|
|
{
|
|
incr = __glHalf;
|
|
}
|
|
|
|
// Convert the RGB color to color index.
|
|
|
|
DitheredRGBColorToBuffer(cp, incr, cfb, result, GLubyte);
|
|
|
|
// Color mask
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = gengc->pajInvTranslateVector[*puj];
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLubyte)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (GLubyte)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
*puj = gengc->pajTranslateVector[result];
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
// Note that we ignore walls here for simplicity...
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
}
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Bitfield16StoreSpan
|
|
*
|
|
* Copies the current span in the renderer into a bitmap. If bDIB is TRUE,
|
|
* then the bitmap is the display in DIB format (or a memory DC). If bDIB
|
|
* is FALSE, then the bitmap is an offscreen scanline buffer and it will be
|
|
* output to the buffer by (*gengc->pfnCopyPixels)().
|
|
*
|
|
* This handles general 16-bit BITFIELDS mode. Blending is supported. There
|
|
* is dithering.
|
|
*
|
|
* Returns:
|
|
* GL_FALSE always. Soft code ignores return value.
|
|
*
|
|
* History:
|
|
* 08-Dec-1993 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX The returnSpan routine follows this routine very closely. Any changes
|
|
//XXX to this routine should also be reflected in the returnSpan routine
|
|
|
|
STATIC GLboolean FASTCALL
|
|
Bitfield16StoreSpanPartial(__GLcontext *gc, GLboolean bDIB, GLint cWalls, GLint *Walls )
|
|
{
|
|
GLint xFrag, yFrag; // current fragment coordinates
|
|
__GLcolor *cp; // current fragment color
|
|
__GLcolorBuffer *cfb; // color frame buffer
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLushort result, *pus; // current pixel color, current pixel ptr
|
|
GLushort *pusEnd; // end of scan line
|
|
__GLfloat incr; // current dither adj.
|
|
|
|
GLint w; // span width
|
|
GLboolean bDraw;
|
|
GLint NextWall;
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLuint flags;
|
|
GLushort dst_pix;
|
|
|
|
// Get span position and length.
|
|
|
|
w = gc->polygon.shader.length;
|
|
xFrag = gc->polygon.shader.frag.x;
|
|
yFrag = gc->polygon.shader.frag.y;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
cfb = gc->drawBuffer;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, xFrag) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, yFrag) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
flags = cfb->buf.flags;
|
|
|
|
|
|
if (cWalls & 0x01)
|
|
{
|
|
bDraw = GL_TRUE;
|
|
}
|
|
else
|
|
{
|
|
bDraw = GL_FALSE;
|
|
}
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
|
|
// Get pointers to fragment colors array and frame buffer.
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
pus = bDIB ? (GLushort *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr<<1))
|
|
: gengc->ColorsBits;
|
|
pusEnd = pus + w;
|
|
|
|
// Case: no masking, no dithering, no blending
|
|
|
|
if ( !(enables & (__GL_DITHER_ENABLE)) &&
|
|
!(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
incr = __glHalf;
|
|
for (; pus < pusEnd; pus++, cp++)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
DitheredColorToBuffer(cp, incr, cfb, result, GLushort);
|
|
*pus = result;
|
|
}
|
|
}
|
|
|
|
// Case: dithering, no masking, no blending
|
|
|
|
else if ( !(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
for (; pus < pusEnd; pus++, cp++, xFrag++)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
DitheredColorToBuffer(cp, incr, cfb, result, GLushort);
|
|
*pus = result;
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
if( (!bDIB) && (cfb->buf.flags & NEED_FETCH) )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if ( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
int i;
|
|
|
|
// this overwrites fragment colors array with blended values
|
|
// XXX is the +i handled properly by the optimizer ?
|
|
SPECIAL_ALPHA_BLEND_SPAN((dst_pix = *(pus+i)));
|
|
}
|
|
|
|
for (; pus < pusEnd; pus++, cp++)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
// Dither.
|
|
|
|
if ( enables & __GL_DITHER_ENABLE )
|
|
{
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
xFrag++;
|
|
}
|
|
else
|
|
{
|
|
incr = __glHalf;
|
|
}
|
|
|
|
// Convert color to 16BPP format.
|
|
|
|
DitheredColorToBuffer(cp, incr, cfb, result, GLushort);
|
|
|
|
// Store result with optional masking.
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = *pus;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLushort)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if ( cfb->buf.flags & COLORMASK_ON )
|
|
{
|
|
result = (GLushort)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
*pus = result;
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
STATIC GLboolean FASTCALL Bitfield16StoreSpan(__GLcontext *gc)
|
|
{
|
|
GLint xFrag, yFrag; // current fragment coordinates
|
|
__GLcolor *cp; // current fragment color
|
|
__GLcolorBuffer *cfb; // color frame buffer
|
|
GLboolean bDIB;
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLushort result, *pus; // current pixel color, current pixel ptr
|
|
GLushort *pusEnd; // end of scan line
|
|
__GLfloat incr; // current dither adj.
|
|
|
|
GLint w; // span width
|
|
GLint cWalls;
|
|
GLint *Walls;
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLuint flags;
|
|
GLushort dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
// Get span position and length.
|
|
|
|
w = gc->polygon.shader.length;
|
|
xFrag = gc->polygon.shader.frag.x;
|
|
yFrag = gc->polygon.shader.frag.y;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
cfb = gc->drawBuffer;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, xFrag) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, yFrag) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
flags = cfb->buf.flags;
|
|
bDIB = flags & DIB_FORMAT;
|
|
|
|
// Check span visibility
|
|
if( bDIB && !(flags & NO_CLIP) )
|
|
{
|
|
// Device in BITMAP format
|
|
ULONG ulSpanVisibility; // span visibility mode
|
|
|
|
ulSpanVisibility = wglSpanVisible(xScr, yScr, w, &cWalls, &Walls);
|
|
|
|
if (ulSpanVisibility == WGL_SPAN_NONE)
|
|
return GL_FALSE;
|
|
else if (ulSpanVisibility == WGL_SPAN_PARTIAL)
|
|
return Bitfield16StoreSpanPartial( gc, bDIB, cWalls, Walls );
|
|
// else span fully visible
|
|
}
|
|
|
|
// Get pointers to fragment colors array and frame buffer.
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
pus = bDIB ? (GLushort *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr<<1))
|
|
: gengc->ColorsBits;
|
|
pusEnd = pus + w;
|
|
|
|
// Case: no masking, no dithering, no blending
|
|
|
|
if ( !(enables & (__GL_DITHER_ENABLE)) &&
|
|
!(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
incr = __glHalf;
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) {
|
|
for (; pus < pusEnd; pus++, cp++)
|
|
DitheredRGBAColorToBuffer(cp, incr, cfb, *pus, GLushort);
|
|
} else {
|
|
for (; pus < pusEnd; pus++, cp++)
|
|
DitheredRGBColorToBuffer(cp, incr, cfb, *pus, GLushort);
|
|
}
|
|
|
|
}
|
|
|
|
// Case: dithering, no masking, no blending
|
|
|
|
else if ( !(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) {
|
|
for (; pus < pusEnd; pus++, cp++, xFrag++)
|
|
{
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
DitheredRGBAColorToBuffer(cp, incr, cfb, *pus, GLushort);
|
|
}
|
|
} else {
|
|
for (; pus < pusEnd; pus++, cp++, xFrag++)
|
|
{
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
DitheredRGBColorToBuffer(cp, incr, cfb, *pus, GLushort);
|
|
}
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
if( (!bDIB) && (cfb->buf.flags & NEED_FETCH) )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if ( enables & __GL_BLEND_ENABLE )
|
|
{
|
|
int i;
|
|
|
|
// this overwrites fragment colors array with blended values
|
|
SPECIAL_ALPHA_BLEND_SPAN((dst_pix = *(pus+i)));
|
|
}
|
|
|
|
for (; pus < pusEnd; pus++, cp++)
|
|
{
|
|
// Dither.
|
|
|
|
if ( enables & __GL_DITHER_ENABLE )
|
|
{
|
|
incr = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
xFrag++;
|
|
}
|
|
else
|
|
{
|
|
incr = __glHalf;
|
|
}
|
|
|
|
// Convert color to 16BPP format.
|
|
|
|
DitheredColorToBuffer(cp, incr, cfb, result, GLushort);
|
|
|
|
// Store result with optional masking.
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = *pus;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result = (GLushort)
|
|
(DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask);
|
|
}
|
|
|
|
if ( cfb->buf.flags & COLORMASK_ON )
|
|
{
|
|
result = (GLushort)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
}
|
|
*pus = result;
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
return GL_FALSE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* BGRStoreSpan
|
|
*
|
|
* Copies the current span in the renderer into a bitmap. If bDIB is TRUE,
|
|
* then the bitmap is the display in DIB format (or a memory DC). If bDIB
|
|
* is FALSE, then the bitmap is an offscreen scanline buffer and it will be
|
|
* output to the buffer by (*gengc->pfnCopyPixels)().
|
|
*
|
|
* This handles GBR 24-bit mode. Blending is supported. There
|
|
* is no dithering.
|
|
*
|
|
* Returns:
|
|
* GL_FALSE always. Soft code ignores return value.
|
|
*
|
|
* History:
|
|
* 10-Jan-1994 -by- Marc Fortier [v-marcf]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX The returnSpan routine follows this routine very closely. Any changes
|
|
//XXX to this routine should also be reflected in the returnSpan routine
|
|
|
|
STATIC GLboolean FASTCALL BGRStoreSpan(__GLcontext *gc )
|
|
{
|
|
__GLcolor *cp; // current fragment color
|
|
__GLcolorBuffer *cfb; // color frame buffer
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLubyte *puj; // current pixel ptr
|
|
GLuint *pul; // current pixel ptr
|
|
GLuint result; // current pixel color
|
|
GLubyte *pujEnd; // end of scan line
|
|
|
|
GLint w; // span width
|
|
ULONG ulSpanVisibility; // span visibility mode
|
|
GLint cWalls;
|
|
GLint *Walls;
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLuint flags;
|
|
GLboolean bDIB;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
// Get span position and length.
|
|
|
|
w = gc->polygon.shader.length;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
cfb = gc->drawBuffer;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, gc->polygon.shader.frag.x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, gc->polygon.shader.frag.y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
|
|
flags = cfb->buf.flags;
|
|
bDIB = flags & DIB_FORMAT;
|
|
|
|
if( !bDIB || (flags & NO_CLIP) )
|
|
{
|
|
// Device managed or unclipped surface
|
|
ulSpanVisibility = WGL_SPAN_ALL;
|
|
}
|
|
else
|
|
{
|
|
// Device in BITMAP format
|
|
ulSpanVisibility = wglSpanVisible(xScr, yScr, w, &cWalls, &Walls);
|
|
}
|
|
|
|
// Proceed as long as the span is (partially or fully) visible.
|
|
if (ulSpanVisibility != WGL_SPAN_NONE)
|
|
{
|
|
GLboolean bCheckWalls = GL_FALSE;
|
|
GLboolean bDraw;
|
|
GLint NextWall;
|
|
|
|
if (ulSpanVisibility == WGL_SPAN_PARTIAL)
|
|
{
|
|
bCheckWalls = GL_TRUE;
|
|
if (cWalls & 0x01)
|
|
{
|
|
bDraw = GL_TRUE;
|
|
}
|
|
else
|
|
{
|
|
bDraw = GL_FALSE;
|
|
}
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
// Get pointers to fragment colors array and frame buffer.
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
puj = bDIB ? (GLubyte *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr*3))
|
|
: gengc->ColorsBits;
|
|
pujEnd = puj + 3*w;
|
|
|
|
// Case: no masking, no blending
|
|
|
|
//!!!XXX -- do extra opt. for RGB and BGR cases
|
|
|
|
//!!!XXX -- we can also opt. by unrolling the loops
|
|
|
|
if ( !(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
for (; puj < pujEnd; cp++)
|
|
{
|
|
if (bCheckWalls)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE) {
|
|
puj += 3;
|
|
continue;
|
|
}
|
|
}
|
|
StoreColorAsBGR(cp, puj);
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
if( (!bDIB) && (cfb->buf.flags & NEED_FETCH) )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if (enables & __GL_BLEND_ENABLE)
|
|
{
|
|
// this overwrites fragment colors array with blended values
|
|
(*gc->procs.blendSpan)( gc );
|
|
}
|
|
|
|
for (; puj < pujEnd; cp++)
|
|
{
|
|
if (bCheckWalls)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE) {
|
|
puj += 3;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
Copy3Bytes(&dst_pix, puj);
|
|
UnditheredRGBColorToBuffer(cp, cfb, result, GLuint);
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result,
|
|
dst_pix) & gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (result & cfb->sourceMask) |
|
|
(dst_pix & cfb->destMask);
|
|
}
|
|
|
|
Copy3Bytes( puj, &result );
|
|
puj += 3;
|
|
}
|
|
else
|
|
{
|
|
StoreColorAsBGR(cp, puj);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
}
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Bitfield32StoreSpan
|
|
*
|
|
* Copies the current span in the renderer into a bitmap. If bDIB is TRUE,
|
|
* then the bitmap is the display in DIB format (or a memory DC). If bDIB
|
|
* is FALSE, then the bitmap is an offscreen scanline buffer and it will be
|
|
* output to the buffer by (*gengc->pfnCopyPixels)().
|
|
*
|
|
* This handles general 32-bit BITFIELDS mode. Blending is supported. There
|
|
* is no dithering.
|
|
*
|
|
* Returns:
|
|
* GL_FALSE always. Soft code ignores return value.
|
|
*
|
|
* History:
|
|
* 15-Nov-1993 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX The returnSpan routine follows this routine very closely. Any changes
|
|
//XXX to this routine should also be reflected in the returnSpan routine
|
|
|
|
STATIC GLboolean FASTCALL
|
|
Bitfield32StoreSpanPartial(__GLcontext *gc, GLboolean bDIB, GLint cWalls, GLint *Walls )
|
|
{
|
|
__GLcolor *cp; // current fragment color
|
|
__GLcolorBuffer *cfb; // color frame buffer
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLuint result, *pul; // current pixel color, current pixel ptr
|
|
GLuint *pulEnd; // end of scan line
|
|
|
|
GLint w; // span width
|
|
|
|
GLboolean bDraw;
|
|
GLint NextWall;
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLuint flags;
|
|
GLuint dst_pix;
|
|
|
|
// Get span position and length.
|
|
|
|
w = gc->polygon.shader.length;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
cfb = gc->drawBuffer;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, gc->polygon.shader.frag.x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, gc->polygon.shader.frag.y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
|
|
flags = cfb->buf.flags;
|
|
|
|
if (cWalls & 0x01)
|
|
{
|
|
bDraw = GL_TRUE;
|
|
}
|
|
else
|
|
{
|
|
bDraw = GL_FALSE;
|
|
}
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
|
|
// Get pointers to fragment colors array and frame buffer.
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
pul = bDIB ? (GLuint *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr<<2))
|
|
: gengc->ColorsBits;
|
|
pulEnd = pul + w;
|
|
|
|
// Case: no masking, no blending
|
|
|
|
//!!!XXX -- do extra opt. for RGB and BGR cases
|
|
|
|
//!!!XXX -- we can also opt. by unrolling the loops
|
|
|
|
if ( !(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
for (; pul < pulEnd; pul++, cp++)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
UnditheredColorToBuffer(cp, cfb, result, GLuint);
|
|
*pul = result;
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
if( (!bDIB) && (cfb->buf.flags & NEED_FETCH) )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if (enables & __GL_BLEND_ENABLE)
|
|
{
|
|
int i;
|
|
|
|
SPECIAL_ALPHA_BLEND_SPAN((dst_pix = *(pul+i)));
|
|
}
|
|
|
|
for (; pul < pulEnd; pul++, cp++)
|
|
{
|
|
if (xScr++ >= NextWall)
|
|
{
|
|
if (bDraw)
|
|
bDraw = GL_FALSE;
|
|
else
|
|
bDraw = GL_TRUE;
|
|
if (cWalls <= 0)
|
|
{
|
|
NextWall = gc->constants.maxViewportWidth;
|
|
}
|
|
else
|
|
{
|
|
NextWall = *Walls++;
|
|
cWalls--;
|
|
}
|
|
}
|
|
if (bDraw == GL_FALSE)
|
|
continue;
|
|
|
|
UnditheredColorToBuffer(cp, cfb, result, GLuint);
|
|
|
|
//!!!XXX again, opt. by unrolling loop
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = *pul;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask);
|
|
}
|
|
}
|
|
*pul = result;
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
STATIC GLboolean FASTCALL Bitfield32StoreSpan( __GLcontext *gc )
|
|
{
|
|
__GLcolor *cp; // current fragment color
|
|
__GLcolorBuffer *cfb; // color frame buffer
|
|
GLboolean bDIB;
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLuint result, *pul; // current pixel color, current pixel ptr
|
|
GLuint *pulEnd; // end of scan line
|
|
|
|
GLint w; // span width
|
|
ULONG ulSpanVisibility; // span visibility mode
|
|
GLint cWalls;
|
|
GLint *Walls;
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLuint flags;
|
|
GLuint dst_pix;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
// Get span position and length.
|
|
|
|
w = gc->polygon.shader.length;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
cfb = gc->drawBuffer;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, gc->polygon.shader.frag.x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, gc->polygon.shader.frag.y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
flags = cfb->buf.flags;
|
|
bDIB = flags & DIB_FORMAT;
|
|
|
|
// Check span visibility
|
|
if( bDIB && !(flags & NO_CLIP) )
|
|
{
|
|
// Device in BITMAP format
|
|
ULONG ulSpanVisibility; // span visibility mode
|
|
|
|
ulSpanVisibility = wglSpanVisible(xScr, yScr, w, &cWalls, &Walls);
|
|
|
|
if (ulSpanVisibility == WGL_SPAN_NONE)
|
|
return GL_FALSE;
|
|
else if (ulSpanVisibility == WGL_SPAN_PARTIAL)
|
|
return Bitfield32StoreSpanPartial( gc, bDIB, cWalls, Walls );
|
|
// else span fully visible
|
|
}
|
|
|
|
// Get pointers to fragment colors array and frame buffer.
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
pul = bDIB ? (GLuint *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr<<2))
|
|
: gengc->ColorsBits;
|
|
pulEnd = pul + w;
|
|
|
|
// Case: no masking, no blending
|
|
|
|
//!!!XXX -- do extra opt. for RGB and BGR cases
|
|
|
|
//!!!XXX -- we can also opt. by unrolling the loops
|
|
|
|
if ( !(cfb->buf.flags & NEED_FETCH) &&
|
|
!(enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) {
|
|
for (; pul < pulEnd; pul++, cp++)
|
|
{
|
|
UnditheredRGBAColorToBuffer(cp, cfb, result, GLuint);
|
|
*pul = result;
|
|
}
|
|
} else {
|
|
for (; pul < pulEnd; pul++, cp++)
|
|
{
|
|
UnditheredRGBColorToBuffer(cp, cfb, result, GLuint);
|
|
*pul = result;
|
|
}
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
if( (!bDIB) && (cfb->buf.flags & NEED_FETCH) )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if (enables & __GL_BLEND_ENABLE)
|
|
{
|
|
int i;
|
|
|
|
SPECIAL_ALPHA_BLEND_SPAN((dst_pix = *(pul+i)));
|
|
}
|
|
|
|
for (; pul < pulEnd; pul++, cp++)
|
|
{
|
|
UnditheredColorToBuffer(cp, cfb, result, GLuint);
|
|
|
|
//!!!XXX again, opt. by unrolling loop
|
|
|
|
if (cfb->buf.flags & NEED_FETCH)
|
|
{
|
|
dst_pix = *pul;
|
|
|
|
if (enables & __GL_COLOR_LOGIC_OP_ENABLE)
|
|
{
|
|
result =
|
|
DoLogicOp(gc->state.raster.logicOp, result, dst_pix) &
|
|
gc->modes.allMask;
|
|
}
|
|
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
result = (dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask);
|
|
}
|
|
}
|
|
*pul = result;
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
STATIC GLboolean FASTCALL AlphaStoreSpan(__GLcontext *gc)
|
|
{
|
|
__GLcolorBuffer *cfb = gc->drawBuffer;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
(*cfb->alphaBuf.storeSpan)( &cfb->alphaBuf );
|
|
return GL_FALSE;
|
|
}
|
|
|
|
STATIC GLboolean FASTCALL StoreMaskedSpan(__GLcontext *gc, GLboolean masked)
|
|
{
|
|
#ifdef REWRITE
|
|
GLint x, y, len;
|
|
int i;
|
|
__GLcolor *cp;
|
|
DWORD *pul;
|
|
WORD *pus;
|
|
BYTE *puj;
|
|
__GLGENcontext *gengc = (__GLGENcontext *)gc;
|
|
|
|
len = gc->polygon.shader.length;
|
|
x = __GL_UNBIAS_X(gc, gc->polygon.shader.frag.x);
|
|
y = __GL_UNBIAS_Y(gc, gc->polygon.shader.frag.y);
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
|
|
switch (gengc->iFormatDC)
|
|
{
|
|
|
|
case BMF_8BPP:
|
|
break;
|
|
|
|
case BMF_16BPP:
|
|
pus = gengc->ColorsBits;
|
|
for (i = 0; i < len; i++) {
|
|
*pus++ = __GL_COLOR_TO_BMF_16BPP(cp);
|
|
cp++;
|
|
}
|
|
break;
|
|
|
|
case BMF_24BPP:
|
|
puj = gengc->ColorsBits;
|
|
for (i = 0; i < len; i++) {
|
|
*puj++ = (BYTE)cp->b; // XXX check order
|
|
*puj++ = (BYTE)cp->g;
|
|
*puj++ = (BYTE)cp->r;
|
|
cp++;
|
|
}
|
|
break;
|
|
|
|
case BMF_32BPP:
|
|
pul = gengc->ColorsBits;
|
|
for (i = 0; i < len; i++) {
|
|
*pul++ = __GL_COLOR_TO_BMF_32BPP(cp);
|
|
cp++;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (masked == GL_TRUE) // XXX mask is BigEndian!!!
|
|
{
|
|
unsigned long *pulstipple;
|
|
unsigned long stip;
|
|
GLint count;
|
|
|
|
pul = gengc->StippleBits;
|
|
pulstipple = gc->polygon.shader.stipplePat;
|
|
count = (len+31)/32;
|
|
for (i = 0; i < count; i++) {
|
|
stip = *pulstipple++;
|
|
*pul++ = (stip&0xff)<<24 | (stip&0xff00)<<8 | (stip&0xff0000)>>8 |
|
|
(stip&0xff000000)>>24;
|
|
}
|
|
wglSpanBlt(CURRENT_DC, gengc->ColorsBitmap, gengc->StippleBitmap,
|
|
x, y, len);
|
|
}
|
|
else
|
|
{
|
|
wglSpanBlt(CURRENT_DC, gengc->ColorsBitmap, (HBITMAP)NULL,
|
|
x, y, len);
|
|
}
|
|
#endif
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
#ifdef TESTSTIPPLE
|
|
STATIC void FASTCALL MessUpStippledSpan(__GLcontext *gc)
|
|
{
|
|
__GLcolor *cp;
|
|
__GLcolorBuffer *cfb;
|
|
__GLstippleWord inMask, bit, *sp;
|
|
GLint count;
|
|
GLint w;
|
|
|
|
w = gc->polygon.shader.length;
|
|
sp = gc->polygon.shader.stipplePat;
|
|
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
while (w) {
|
|
count = w;
|
|
if (count > __GL_STIPPLE_BITS) {
|
|
count = __GL_STIPPLE_BITS;
|
|
}
|
|
w -= count;
|
|
|
|
inMask = *sp++;
|
|
bit = __GL_STIPPLE_SHIFT(0);
|
|
while (--count >= 0) {
|
|
if (!(inMask & bit)) {
|
|
cp->r = cfb->redMax;
|
|
cp->g = cfb->greenMax;
|
|
cp->b = cfb->blueMax;
|
|
}
|
|
|
|
cp++;
|
|
#ifdef __GL_STIPPLE_MSB
|
|
bit >>= 1;
|
|
#else
|
|
bit <<= 1;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// From the PIXMAP code, calls store for each fragment
|
|
STATIC GLboolean FASTCALL SlowStoreSpan(__GLcontext *gc)
|
|
{
|
|
int x, x1;
|
|
int i;
|
|
__GLfragment frag;
|
|
__GLcolor *cp;
|
|
__GLcolorBuffer *cfb;
|
|
GLint w;
|
|
|
|
w = gc->polygon.shader.length;
|
|
|
|
frag.y = gc->polygon.shader.frag.y;
|
|
x = gc->polygon.shader.frag.x;
|
|
x1 = gc->polygon.shader.frag.x + w;
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
for (i = x; i < x1; i++) {
|
|
frag.x = i;
|
|
frag.color = *cp++;
|
|
|
|
(*cfb->store)(cfb, &frag);
|
|
}
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
// From the PIXMAP code, calls store for each fragment with mask test
|
|
STATIC GLboolean FASTCALL SlowStoreStippledSpan(__GLcontext *gc)
|
|
{
|
|
int x;
|
|
__GLfragment frag;
|
|
__GLcolor *cp;
|
|
__GLcolorBuffer *cfb;
|
|
__GLstippleWord inMask, bit, *sp;
|
|
GLint count;
|
|
GLint w;
|
|
|
|
w = gc->polygon.shader.length;
|
|
sp = gc->polygon.shader.stipplePat;
|
|
|
|
frag.y = gc->polygon.shader.frag.y;
|
|
x = gc->polygon.shader.frag.x;
|
|
cp = gc->polygon.shader.colors;
|
|
cfb = gc->polygon.shader.cfb;
|
|
|
|
while (w) {
|
|
count = w;
|
|
if (count > __GL_STIPPLE_BITS) {
|
|
count = __GL_STIPPLE_BITS;
|
|
}
|
|
w -= count;
|
|
|
|
inMask = *sp++;
|
|
bit = __GL_STIPPLE_SHIFT((__GLstippleWord)0);
|
|
while (--count >= 0) {
|
|
if (inMask & bit) {
|
|
frag.x = x;
|
|
frag.color = *cp;
|
|
|
|
(*cfb->store)(cfb, &frag);
|
|
}
|
|
x++;
|
|
cp++;
|
|
#ifdef __GL_STIPPLE_MSB
|
|
bit >>= 1;
|
|
#else
|
|
bit <<= 1;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return GL_FALSE;
|
|
}
|
|
|
|
//
|
|
// Tables to convert 4-bit index to RGB component
|
|
// These tables assume the VGA fixed palette
|
|
// History:
|
|
// 22-NOV-93 Eddie Robinson [v-eddier] Wrote it.
|
|
//
|
|
#ifdef __GL_DOUBLE
|
|
|
|
static __GLfloat vfVGAtoR[16] = {
|
|
0.0, // black
|
|
0.5, // dim red
|
|
0.0, // dim green
|
|
0.5, // dim yellow
|
|
0.0, // dim blue
|
|
0.5, // dim magenta
|
|
0.0, // dim cyan
|
|
0.5, // dim grey
|
|
0.75, // medium grey
|
|
1.0, // bright red
|
|
0.0, // bright green
|
|
1.0, // bright yellow
|
|
0.0, // bright blue
|
|
1.0, // bright magenta
|
|
0.0, // bright cyan
|
|
1.0 // white
|
|
};
|
|
|
|
static __GLfloat vfVGAtoG[16] = {
|
|
0.0, // black
|
|
0.0, // dim red
|
|
0.5, // dim green
|
|
0.5, // dim yellow
|
|
0.0, // dim blue
|
|
0.0, // dim magenta
|
|
0.5, // dim cyan
|
|
0.5, // dim grey
|
|
0.75, // medium grey
|
|
0.0, // bright red
|
|
1.0, // bright green
|
|
1.0, // bright yellow
|
|
0.0, // bright blue
|
|
0.0, // bright magenta
|
|
1.0, // bright cyan
|
|
1.0 // white
|
|
};
|
|
|
|
static __GLfloat vfVGAtoB[16] = {
|
|
0.0, // black
|
|
0.0, // dim red
|
|
0.0, // dim green
|
|
0.0, // dim yellow
|
|
0.5, // dim blue
|
|
0.5, // dim magenta
|
|
0.5, // dim cyan
|
|
0.5, // dim grey
|
|
0.75, // medium grey
|
|
0.0, // bright red
|
|
0.0, // bright green
|
|
0.0, // bright yellow
|
|
1.0, // bright blue
|
|
1.0, // bright magenta
|
|
1.0, // bright cyan
|
|
1.0 // white
|
|
};
|
|
|
|
#else
|
|
|
|
static __GLfloat vfVGAtoR[16] = {
|
|
0.0F, // black
|
|
0.5F, // dim red
|
|
0.0F, // dim green
|
|
0.5F, // dim yellow
|
|
0.0F, // dim blue
|
|
0.5F, // dim magenta
|
|
0.0F, // dim cyan
|
|
0.5F, // dim grey
|
|
0.75F, // medium grey
|
|
1.0F, // bright red
|
|
0.0F, // bright green
|
|
1.0F, // bright yellow
|
|
0.0F, // bright blue
|
|
1.0F, // bright magenta
|
|
0.0F, // bright cyan
|
|
1.0F // white
|
|
};
|
|
|
|
static __GLfloat vfVGAtoG[16] = {
|
|
0.0F, // black
|
|
0.0F, // dim red
|
|
0.5F, // dim green
|
|
0.5F, // dim yellow
|
|
0.0F, // dim blue
|
|
0.0F, // dim magenta
|
|
0.5F, // dim cyan
|
|
0.5F, // dim grey
|
|
0.75F, // medium grey
|
|
0.0F, // bright red
|
|
1.0F, // bright green
|
|
1.0F, // bright yellow
|
|
0.0F, // bright blue
|
|
0.0F, // bright magenta
|
|
1.0F, // bright cyan
|
|
1.0F // white
|
|
};
|
|
|
|
static __GLfloat vfVGAtoB[16] = {
|
|
0.0F, // black
|
|
0.0F, // dim red
|
|
0.0F, // dim green
|
|
0.0F, // dim yellow
|
|
0.5F, // dim blue
|
|
0.5F, // dim magenta
|
|
0.5F, // dim cyan
|
|
0.5F, // dim grey
|
|
0.75F, // medium grey
|
|
0.0F, // bright red
|
|
0.0F, // bright green
|
|
0.0F, // bright yellow
|
|
1.0F, // bright blue
|
|
1.0F, // bright magenta
|
|
1.0F, // bright cyan
|
|
1.0F // white
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
void
|
|
RGBFetchNone(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
result->r = 0.0F;
|
|
result->g = 0.0F;
|
|
result->b = 0.0F;
|
|
if( cfb->buf.gc->modes.alphaBits )
|
|
result->a = 0.0F;
|
|
else
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
RGBReadSpanNone(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *results,
|
|
GLint w)
|
|
{
|
|
GLint i;
|
|
__GLcolor *pResults;
|
|
__GLfloat alphaVal;
|
|
|
|
if( cfb->buf.gc->modes.alphaBits )
|
|
alphaVal = 0.0F;
|
|
else
|
|
alphaVal = cfb->alphaScale;
|
|
|
|
for (i = 0, pResults = results; i < w; i++, pResults++)
|
|
{
|
|
pResults->r = 0.0F;
|
|
pResults->g = 0.0F;
|
|
pResults->b = 0.0F;
|
|
pResults->a = alphaVal;
|
|
}
|
|
}
|
|
|
|
void
|
|
DIBIndex4RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
// Do alpha first, before x,y unbiased
|
|
if( gc->modes.alphaBits ) {
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
} else
|
|
result->a = cfb->alphaScale;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x >> 1));
|
|
|
|
pixel = *puj;
|
|
if (!(x & 1))
|
|
pixel >>= 4;
|
|
|
|
pixel = gengc->pajInvTranslateVector[pixel&0xf];
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
}
|
|
|
|
void
|
|
DIBIndex8RGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base + (y*cfb->buf.outerWidth) + x);
|
|
|
|
pixel = gengc->pajInvTranslateVector[*puj];
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DIBIndex8RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base + (y*cfb->buf.outerWidth) + x);
|
|
|
|
pixel = gengc->pajInvTranslateVector[*puj];
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
}
|
|
|
|
void
|
|
DIBBGRFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
|
|
result->b = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->r = (__GLfloat) *puj;
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DIBBGRAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
|
|
result->b = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->r = (__GLfloat) *puj;
|
|
}
|
|
|
|
void
|
|
DIBRGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
|
|
result->r = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->b = (__GLfloat) *puj;
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DIBRGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
|
|
result->r = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->b = (__GLfloat) *puj;
|
|
}
|
|
|
|
void
|
|
DIBBitfield16RGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLushort *pus, pixel;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
pus = (GLushort *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x << 1));
|
|
pixel = *pus;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DIBBitfield16RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLushort *pus, pixel;
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
pus = (GLushort *)((ULONG_PTR)cfb->buf.base +
|
|
(yScr*cfb->buf.outerWidth) + (xScr << 1));
|
|
pixel = *pus;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
if( ALPHA_IN_PIXEL( cfb ) )
|
|
result->a = (__GLfloat) ((pixel & gc->modes.alphaMask) >> cfb->alphaShift);
|
|
else
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
}
|
|
|
|
void
|
|
DIBBitfield32RGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint *pul, pixel;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
pul = (GLuint *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x << 2));
|
|
pixel = *pul;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DIBBitfield32RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint *pul, pixel;
|
|
GLint xScr, yScr;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
pul = (GLuint *)((ULONG_PTR)cfb->buf.base +
|
|
(yScr*cfb->buf.outerWidth) + (xScr << 2));
|
|
pixel = *pul;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
if( ALPHA_IN_PIXEL( cfb ) )
|
|
result->a = (__GLfloat) ((pixel & gc->modes.alphaMask) >> cfb->alphaShift);
|
|
else
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
}
|
|
|
|
void
|
|
DisplayIndex4RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
if( gc->modes.alphaBits ) {
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
} else
|
|
result->a = cfb->alphaScale;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
pixel = *puj >> 4;
|
|
result->r = vfVGAtoR[pixel];
|
|
result->g = vfVGAtoG[pixel];
|
|
result->b = vfVGAtoB[pixel];
|
|
}
|
|
|
|
void
|
|
DisplayIndex8RGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
pixel = gengc->pajInvTranslateVector[*puj];
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DisplayIndex8RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
pixel = gengc->pajInvTranslateVector[*puj];
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
}
|
|
|
|
void
|
|
DisplayBGRFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
result->b = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->r = (__GLfloat) *puj;
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DisplayBGRAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
result->b = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->r = (__GLfloat) *puj;
|
|
}
|
|
|
|
void
|
|
DisplayRGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
result->r = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->b = (__GLfloat) *puj;
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DisplayRGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
result->r = (__GLfloat) *puj++;
|
|
result->g = (__GLfloat) *puj++;
|
|
result->b = (__GLfloat) *puj;
|
|
}
|
|
|
|
void
|
|
DisplayBitfield16RGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLushort *pus, pixel;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
pus = gengc->ColorsBits;
|
|
pixel = *pus;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DisplayBitfield16RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLushort *pus, pixel;
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
pus = gengc->ColorsBits;
|
|
pixel = *pus;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
if( ALPHA_IN_PIXEL( cfb ) )
|
|
result->a = (__GLfloat) ((pixel & gc->modes.alphaMask) >> cfb->alphaShift);
|
|
else
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
}
|
|
|
|
void
|
|
DisplayBitfield32RGBFetch(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint *pul, pixel;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, 1, FALSE);
|
|
pul = gengc->ColorsBits;
|
|
pixel = *pul;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
result->a = cfb->alphaScale;
|
|
}
|
|
|
|
void
|
|
DisplayBitfield32RGBAFetch(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *result)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint *pul, pixel;
|
|
GLint xScr, yScr;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, 1, FALSE);
|
|
pul = gengc->ColorsBits;
|
|
pixel = *pul;
|
|
result->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
result->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
result->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
if( ALPHA_IN_PIXEL( cfb ) )
|
|
result->a = (__GLfloat) ((pixel & gc->modes.alphaMask) >> cfb->alphaShift);
|
|
else
|
|
(*cfb->alphaBuf.fetch)(&cfb->alphaBuf, x, y, result);
|
|
}
|
|
|
|
static void
|
|
ReadAlphaSpan( __GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *pResults,
|
|
GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
|
|
if( gc->modes.alphaBits )
|
|
(*cfb->alphaBuf.readSpan)(&cfb->alphaBuf, x, y, w, pResults);
|
|
else {
|
|
for( ; w ; w--, pResults++ )
|
|
pResults->a = cfb->alphaScale;
|
|
}
|
|
}
|
|
|
|
void
|
|
DIBIndex4RGBAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *results,
|
|
GLint w)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
__GLcolor *pResults;
|
|
|
|
ReadAlphaSpan( cfb, x, y, results, w );
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base + (y*cfb->buf.outerWidth) +
|
|
(x >> 1));
|
|
|
|
pResults = results;
|
|
if (x & 1)
|
|
{
|
|
pixel = *puj++;
|
|
pixel = gengc->pajInvTranslateVector[pixel & 0xf];
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
pResults++;
|
|
w--;
|
|
}
|
|
while (w > 1)
|
|
{
|
|
pixel = *puj >> 4;
|
|
pixel = gengc->pajInvTranslateVector[pixel];
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
pResults++;
|
|
pixel = *puj++;
|
|
pixel = gengc->pajInvTranslateVector[pixel & 0xf];
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
pResults++;
|
|
w -= 2;
|
|
}
|
|
if (w > 0)
|
|
{
|
|
pixel = *puj >> 4;
|
|
pixel = gengc->pajInvTranslateVector[pixel];
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
}
|
|
}
|
|
|
|
void
|
|
DisplayIndex4RGBAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *results, GLint w)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
__GLcolor *pResults;
|
|
|
|
ReadAlphaSpan( cfb, x, y, results, w );
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, w, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
pResults = results;
|
|
while (w > 1)
|
|
{
|
|
pixel = *puj >> 4;
|
|
pResults->r = vfVGAtoR[pixel];
|
|
pResults->g = vfVGAtoG[pixel];
|
|
pResults->b = vfVGAtoB[pixel];
|
|
pResults++;
|
|
pixel = *puj++ & 0xf;
|
|
pResults->r = vfVGAtoR[pixel];
|
|
pResults->g = vfVGAtoG[pixel];
|
|
pResults->b = vfVGAtoB[pixel];
|
|
pResults++;
|
|
w -= 2;
|
|
}
|
|
if (w > 0)
|
|
{
|
|
pixel = *puj >> 4;
|
|
pResults->r = vfVGAtoR[pixel];
|
|
pResults->g = vfVGAtoG[pixel];
|
|
pResults->b = vfVGAtoB[pixel];
|
|
}
|
|
}
|
|
|
|
void
|
|
Index8RGBAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *pResults,
|
|
GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj, pixel;
|
|
|
|
ReadAlphaSpan( cfb, x, y, pResults, w );
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
if( cfb->buf.flags & DIB_FORMAT )
|
|
{
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base + (y*cfb->buf.outerWidth) + x);
|
|
}
|
|
else
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, w, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
}
|
|
for ( ; w; w--, pResults++)
|
|
{
|
|
pixel = gengc->pajInvTranslateVector[*puj++];
|
|
pResults->r = (__GLfloat) ((pixel & gc->modes.redMask) >> cfb->redShift);
|
|
pResults->g = (__GLfloat) ((pixel & gc->modes.greenMask) >> cfb->greenShift);
|
|
pResults->b = (__GLfloat) ((pixel & gc->modes.blueMask) >> cfb->blueShift);
|
|
}
|
|
}
|
|
|
|
void
|
|
BGRAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *pResults, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
ReadAlphaSpan( cfb, x, y, pResults, w );
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
if( cfb->buf.flags & DIB_FORMAT )
|
|
{
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
}
|
|
else
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, w, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
}
|
|
|
|
for ( ; w; w--, pResults++)
|
|
{
|
|
pResults->b = (__GLfloat) *puj++;
|
|
pResults->g = (__GLfloat) *puj++;
|
|
pResults->r = (__GLfloat) *puj++;
|
|
}
|
|
}
|
|
|
|
void
|
|
RGBAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y, __GLcolor *pResults, GLint w )
|
|
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLubyte *puj;
|
|
|
|
|
|
ReadAlphaSpan( cfb, x, y, pResults, w );
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
x = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
y = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
if( cfb->buf.flags & DIB_FORMAT )
|
|
{
|
|
puj = (GLubyte *)((ULONG_PTR)cfb->buf.base +
|
|
(y*cfb->buf.outerWidth) + (x * 3));
|
|
}
|
|
else
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, x, y, w, FALSE);
|
|
puj = gengc->ColorsBits;
|
|
}
|
|
|
|
for ( ; w; w--, pResults++)
|
|
{
|
|
pResults->r = (__GLfloat) *puj++;
|
|
pResults->g = (__GLfloat) *puj++;
|
|
pResults->b = (__GLfloat) *puj++;
|
|
}
|
|
}
|
|
|
|
void
|
|
Bitfield16RGBAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *pResults, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLushort *pus, pixel;
|
|
GLint xScr, yScr;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
if( cfb->buf.flags & DIB_FORMAT )
|
|
{
|
|
pus = (GLushort *)((ULONG_PTR)cfb->buf.base +
|
|
(yScr*cfb->buf.outerWidth) + (xScr << 1));
|
|
}
|
|
else
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
pus = gengc->ColorsBits;
|
|
}
|
|
READ_RGBA_BITFIELD_SPAN( (pixel = *pus++) );
|
|
}
|
|
|
|
void
|
|
Bitfield32RGBAReadSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
__GLcolor *pResults, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLGENcontext *gengc;
|
|
GLuint *pul, pixel;
|
|
GLint xScr, yScr;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
|
|
if( cfb->buf.flags & DIB_FORMAT )
|
|
{
|
|
pul = (GLuint *)((ULONG_PTR)cfb->buf.base +
|
|
(yScr*cfb->buf.outerWidth) + (xScr << 2));
|
|
}
|
|
else
|
|
{
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
pul = gengc->ColorsBits;
|
|
}
|
|
|
|
READ_RGBA_BITFIELD_SPAN( (pixel = *pul++) );
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
// Used in accumulation
|
|
|
|
// Accumulation helper macros and functions
|
|
|
|
// Clamp a color component between 0 and max
|
|
#define ACCUM_CLAMP_COLOR_COMPONENT( col, max ) \
|
|
if ((col) < (__GLfloat) 0.0) \
|
|
(col) = (__GLfloat) 0.0; \
|
|
else if ((col) > max ) \
|
|
(col) = max;
|
|
|
|
// Extract an accumulation buffer color component by shifting and masking, then
|
|
// multiply it by scale (Requires ap and icol defined).
|
|
#define ACCUM_SCALE_SIGNED_COLOR_COMPONENT( col, shift, sign, mask, scale ) \
|
|
icol = (*ap >> shift) & mask; \
|
|
if (icol & sign) \
|
|
icol |= ~mask; \
|
|
(col) = (icol * scale);
|
|
|
|
// Fetch and scale a span of rgba values from a 32-bit accumulation buffer
|
|
void GetClampedRGBAccum32Values(
|
|
__GLcolorBuffer *cfb, GLuint *pac, __GLcolor *cDest, GLint width,
|
|
__GLfloat scale )
|
|
{
|
|
GLint w, i;
|
|
GLint icol;
|
|
__GLfloat rval, gval, bval, aval;
|
|
__GLuicolor *shift, *mask, *sign;
|
|
GLuint *ap;
|
|
__GLcolor *cp;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLaccumBuffer *afb = &gc->accumBuffer;
|
|
|
|
rval = scale * afb->oneOverRedScale;
|
|
gval = scale * afb->oneOverGreenScale;
|
|
bval = scale * afb->oneOverBlueScale;
|
|
shift = &afb->shift;
|
|
mask = &afb->mask;
|
|
sign = &afb->sign;
|
|
|
|
for ( w = width, cp = cDest, ap = pac; w; w--, cp++, ap++ ) {
|
|
ACCUM_SCALE_SIGNED_COLOR_COMPONENT( cp->r, shift->r, sign->r, mask->r, rval );
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->r, cfb->redScale );
|
|
|
|
ACCUM_SCALE_SIGNED_COLOR_COMPONENT( cp->g, shift->g, sign->g, mask->g, gval );
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->g, cfb->greenScale );
|
|
|
|
ACCUM_SCALE_SIGNED_COLOR_COMPONENT( cp->b, shift->b, sign->b, mask->b, bval );
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->b, cfb->blueScale );
|
|
}
|
|
|
|
if( ! ALPHA_WRITE_ENABLED( cfb ) )
|
|
return;
|
|
|
|
aval = scale * afb->oneOverAlphaScale;
|
|
|
|
for ( w = width, cp = cDest, ap = pac; w; w--, cp++, ap++ ) {
|
|
ACCUM_SCALE_SIGNED_COLOR_COMPONENT( cp->a, shift->a, sign->a, mask->a, aval );
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->a, cfb->alphaScale );
|
|
}
|
|
}
|
|
|
|
// Fetch and scale a span of rgba values from a 64-bit accumulation buffer
|
|
void GetClampedRGBAccum64Values(
|
|
__GLcolorBuffer *cfb, GLshort *pac, __GLcolor *cDest, GLint width,
|
|
__GLfloat scale )
|
|
{
|
|
GLint w;
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
__GLaccumBuffer *afb = &gc->accumBuffer;
|
|
__GLfloat rval, gval, bval, aval;
|
|
__GLcolor *cp;
|
|
GLshort *ap;
|
|
|
|
rval = scale * afb->oneOverRedScale;
|
|
gval = scale * afb->oneOverGreenScale;
|
|
bval = scale * afb->oneOverBlueScale;
|
|
|
|
for ( w = width, cp = cDest, ap = pac; w; w--, cp++, ap+=4 ) {
|
|
cp->r = (ap[0] * rval);
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->r, cfb->redScale );
|
|
cp->g = (ap[1] * gval);
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->g, cfb->greenScale );
|
|
cp->b = (ap[2] * bval);
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->b, cfb->blueScale );
|
|
}
|
|
|
|
if( ! ALPHA_WRITE_ENABLED( cfb ) )
|
|
return;
|
|
|
|
aval = scale * afb->oneOverAlphaScale;
|
|
|
|
// Offset the accumulation pointer to the alpha value:
|
|
ap = pac + 3;
|
|
|
|
for ( w = width, cp = cDest; w; w--, cp++, ap+=4 ) {
|
|
cp->a = (*ap * rval);
|
|
ACCUM_CLAMP_COLOR_COMPONENT( cp->a, cfb->alphaScale );
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Index4ReturnSpan
|
|
* Reads from a 16-bit accumulation buffer and writes the span to a device or
|
|
* a DIB. Only dithering and color mask are applied. Blend is ignored.
|
|
* Since accumulation of 4-bit RGB isn't very useful, this routine is very
|
|
* general and calls through the store function pointers.
|
|
*
|
|
* History:
|
|
* 10-DEC-93 Eddie Robinson [v-eddier] Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX This routine follows the store span routine very closely. Any changes
|
|
//XXX to the store span routine should also be reflected here
|
|
|
|
void Index4ReturnSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
const __GLaccumCell *ac, __GLfloat scale, GLint w)
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
GLuint *ap; // current accum entry
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint saveEnables; // modes enabled in graphics context
|
|
__GLaccumBuffer *afb;
|
|
__GLfragment frag;
|
|
__GLcolor *pAccumCol, *pac;
|
|
|
|
afb = &gc->accumBuffer;
|
|
ap = (GLuint *)ac;
|
|
saveEnables = gc->state.enables.general; // save current enables
|
|
gc->state.enables.general &= ~__GL_BLEND_ENABLE; // disable blend for store procs
|
|
frag.x = x;
|
|
frag.y = y;
|
|
|
|
// Pre-fetch/clamp/scale the accum buffer values
|
|
afb = &gc->accumBuffer;
|
|
pAccumCol = afb->colors;
|
|
GetClampedRGBAccum32Values( cfb, ap, pAccumCol, w, scale );
|
|
|
|
for( pac = pAccumCol ; w; w--, pac++ )
|
|
{
|
|
frag.color = *pac;
|
|
(*cfb->store)(cfb, &frag);
|
|
frag.x++;
|
|
}
|
|
|
|
gc->state.enables.general = saveEnables; // restore current enables
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Index8ReturnSpan
|
|
* Reads from a 32-bit accumulation buffer and writes the span to a device or
|
|
* a DIB. Only dithering and color mask are applied. Blend is ignored.
|
|
*
|
|
* History:
|
|
* 10-DEC-93 Eddie Robinson [v-eddier] Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX This routine follows the store span routine very closely. Any changes
|
|
//XXX to the store span routine should also be reflected here
|
|
|
|
void Index8ReturnSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
const __GLaccumCell *ac, __GLfloat scale, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
GLuint *ap; // current accum entry
|
|
|
|
GLint xFrag, yFrag; // current window (pixel) coordinates
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLubyte result, *puj; // current pixel color, current pixel ptr
|
|
GLubyte *pujEnd; // end of scan line
|
|
__GLfloat inc; // current dither adj.
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLboolean bDIB;
|
|
__GLaccumBuffer *afb;
|
|
GLubyte dst_pix;
|
|
__GLcolor *pAccumCol, *pac;
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
ap = (GLuint *)ac;
|
|
xFrag = x;
|
|
yFrag = y;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
bDIB = cfb->buf.flags & DIB_FORMAT;
|
|
|
|
// Use to call wglSpanVisible, if window level security is added reimplement
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
puj = bDIB ? (GLubyte *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + xScr)
|
|
: gengc->ColorsBits;
|
|
pujEnd = puj + w;
|
|
|
|
afb = &gc->accumBuffer;
|
|
pAccumCol = afb->colors;
|
|
GetClampedRGBAccum32Values( cfb, ap, pAccumCol, w, scale );
|
|
pac = pAccumCol;
|
|
|
|
// Case: no dithering, no masking
|
|
//
|
|
// Check for the common case (which we'll do the fastest).
|
|
|
|
if ( !(enables & (__GL_DITHER_ENABLE)) &&
|
|
!(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
//!!!XXX -- we can also opt. by unrolling the loops
|
|
|
|
for ( ; puj < pujEnd; puj++, pac++ )
|
|
{
|
|
result = ((BYTE) FTOL(pac->r + __glHalf) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + __glHalf) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + __glHalf) << cfb->blueShift);
|
|
*puj = gengc->pajTranslateVector[result];
|
|
}
|
|
}
|
|
|
|
// Case: dithering, no masking, no blending
|
|
//
|
|
// Dithering is pretty common for 8-bit displays, so its probably
|
|
// worth special case also.
|
|
|
|
else if ( !(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
for ( ; puj < pujEnd; puj++, pac++, xFrag++)
|
|
{
|
|
inc = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
result = ((BYTE) FTOL(pac->r + inc) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + inc) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + inc) << cfb->blueShift);
|
|
*puj = gengc->pajTranslateVector[result];
|
|
}
|
|
}
|
|
|
|
// Case: general
|
|
//
|
|
// Otherwise, we'll do it slower.
|
|
|
|
else
|
|
{
|
|
// Color mask pre-fetch
|
|
if ((cfb->buf.flags & COLORMASK_ON) && !bDIB) {
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE );
|
|
}
|
|
|
|
for ( ; puj < pujEnd; puj++, pac++ )
|
|
{
|
|
if (enables & __GL_DITHER_ENABLE)
|
|
{
|
|
inc = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
xFrag++;
|
|
}
|
|
else
|
|
{
|
|
inc = __glHalf;
|
|
}
|
|
result = ((BYTE)FTOL(pac->r + inc) << cfb->redShift) |
|
|
((BYTE)FTOL(pac->g + inc) << cfb->greenShift) |
|
|
((BYTE)FTOL(pac->b + inc) << cfb->blueShift);
|
|
|
|
// Color mask
|
|
if (cfb->buf.flags & COLORMASK_ON)
|
|
{
|
|
dst_pix = gengc->pajInvTranslateVector[*puj];
|
|
result = (GLubyte)((dst_pix & cfb->destMask) |
|
|
(result & cfb->sourceMask));
|
|
}
|
|
*puj = gengc->pajTranslateVector[result];
|
|
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
// Store alpha values
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan2)( &cfb->alphaBuf, x, y, w, pAccumCol );
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* RGBReturnSpan
|
|
* Reads from a 64-bit accumulation buffer and writes the span to a device or
|
|
* a DIB. Only dithering and color mask are applied. Blend is ignored.
|
|
*
|
|
* History:
|
|
* 10-DEC-93 Eddie Robinson [v-eddier] Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX This routine follows the store span routine very closely. Any changes
|
|
//XXX to the store span routine should also be reflected here
|
|
|
|
void RGBReturnSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
const __GLaccumCell *ac, __GLfloat scale, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
GLshort *ap; // current accum entry
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLubyte *puj; // current pixel color, current pixel ptr
|
|
GLubyte *pujEnd; // end of scan line
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLboolean bDIB;
|
|
__GLaccumBuffer *afb;
|
|
__GLcolor *pAccumCol, *pac;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
afb = &gc->accumBuffer;
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
ap = (GLshort *)ac;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
bDIB = cfb->buf.flags & DIB_FORMAT;
|
|
|
|
// Use to call wglSpanVisible, if window level security is added reimplement
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
puj = bDIB ? (GLuint *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr*3))
|
|
: gengc->ColorsBits;
|
|
pujEnd = puj + w*3;
|
|
|
|
// Pre-fetch/clamp/scale the accum buffer values
|
|
afb = &gc->accumBuffer;
|
|
pAccumCol = afb->colors;
|
|
GetClampedRGBAccum64Values( cfb, ap, pAccumCol, w, scale );
|
|
pac = pAccumCol;
|
|
|
|
// Case: no masking
|
|
|
|
if ( !(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
for ( ; puj < pujEnd; puj += 3, pac ++ )
|
|
{
|
|
puj[0] = (GLubyte) FTOL(pac->r);
|
|
puj[1] = (GLubyte) FTOL(pac->g);
|
|
puj[2] = (GLubyte) FTOL(pac->b);
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
else
|
|
{
|
|
GLboolean bRedMask, bGreenMask, bBlueMask;
|
|
GLubyte *pujStart = puj;
|
|
|
|
// Color mask pre-fetch
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if( gc->state.raster.rMask ) {
|
|
for ( puj = pujStart, pac = pAccumCol; puj < pujEnd; puj += 3, pac++ )
|
|
*puj = (GLubyte) FTOL(pac->r);
|
|
}
|
|
pujStart++; pujEnd++;
|
|
if( gc->state.raster.gMask ) {
|
|
for ( puj = pujStart, pac = pAccumCol; puj < pujEnd; puj += 3, pac++ )
|
|
*puj = (GLubyte) FTOL(pac->g);
|
|
}
|
|
pujStart++; pujEnd++;
|
|
if( gc->state.raster.bMask ) {
|
|
for ( puj = pujStart, pac = pAccumCol; puj < pujEnd; puj += 3, pac++ )
|
|
*puj = (GLubyte) FTOL(pac->b);
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
// Store alpha values
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan2)( &cfb->alphaBuf, x, y, w, pAccumCol );
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* BGRReturnSpan
|
|
* Reads from a 64-bit accumulation buffer and writes the span to a device or
|
|
* a DIB. Only dithering and color mask are applied. Blend is ignored.
|
|
*
|
|
* History:
|
|
* 10-DEC-93 Eddie Robinson [v-eddier] Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX This routine follows the store span routine very closely. Any changes
|
|
//XXX to the store span routine should also be reflected here
|
|
|
|
void BGRReturnSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
const __GLaccumCell *ac, __GLfloat scale, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
GLshort *ap; // current accum entry
|
|
__GLcolor *pAccumCol, *pac;
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLubyte *puj; // current pixel color, current pixel ptr
|
|
GLubyte *pujEnd; // end of scan line
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLboolean bDIB;
|
|
|
|
__GLfloat r, g, b;
|
|
__GLfloat rval, gval, bval;
|
|
__GLaccumBuffer *afb;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
afb = &gc->accumBuffer;
|
|
rval = scale * afb->oneOverRedScale;
|
|
gval = scale * afb->oneOverGreenScale;
|
|
bval = scale * afb->oneOverBlueScale;
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
ap = (GLshort *)ac;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
bDIB = cfb->buf.flags & DIB_FORMAT;
|
|
|
|
// Use to call wglSpanVisible, if window level security is added reimplement
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
puj = bDIB ? (GLuint *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr*3))
|
|
: gengc->ColorsBits;
|
|
pujEnd = puj + w*3;
|
|
|
|
// Pre-fetch/clamp/scale the accum buffer values
|
|
afb = &gc->accumBuffer;
|
|
pAccumCol = afb->colors;
|
|
GetClampedRGBAccum64Values( cfb, ap, pAccumCol, w, scale );
|
|
pac = pAccumCol;
|
|
|
|
// Case: no masking
|
|
|
|
if ( !(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
for ( ; puj < pujEnd; puj += 3, pac ++ )
|
|
{
|
|
puj[0] = (GLubyte) FTOL(pac->b);
|
|
puj[1] = (GLubyte) FTOL(pac->g);
|
|
puj[2] = (GLubyte) FTOL(pac->r);
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
GLboolean bRedMask, bGreenMask, bBlueMask;
|
|
GLubyte *pujStart = puj;
|
|
|
|
// Color mask pre-fetch
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
if( gc->state.raster.bMask ) {
|
|
for ( puj = pujStart, pac = pAccumCol; puj < pujEnd; puj += 3, pac++ )
|
|
*puj = (GLubyte) FTOL(pac->b);
|
|
}
|
|
pujStart++; pujEnd++;
|
|
if( gc->state.raster.gMask ) {
|
|
for ( puj = pujStart, pac = pAccumCol; puj < pujEnd; puj += 3, pac++ )
|
|
*puj = (GLubyte) FTOL(pac->g);
|
|
}
|
|
pujStart++; pujEnd++;
|
|
if( gc->state.raster.rMask ) {
|
|
for ( puj = pujStart, pac = pAccumCol; puj < pujEnd; puj += 3, pac++ )
|
|
*puj = (GLubyte) FTOL(pac->r);
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
// Store alpha values
|
|
if( ALPHA_WRITE_ENABLED( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan2)( &cfb->alphaBuf, x, y, w, pAccumCol );
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Bitfield16ReturnSpan
|
|
* Reads from a 32-bit accumulation buffer and writes the span to a device or
|
|
* a DIB. Only dithering and color mask are applied. Blend is ignored.
|
|
*
|
|
* History:
|
|
* 10-DEC-93 Eddie Robinson [v-eddier] Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX This routine follows the store span routine very closely. Any changes
|
|
//XXX to the store span routine should also be reflected here
|
|
|
|
void Bitfield16ReturnSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
const __GLaccumCell *ac, __GLfloat scale, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
GLuint *ap; // current accum entry
|
|
|
|
GLint xFrag, yFrag; // current fragment coordinates
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLushort result, *pus; // current pixel color, current pixel ptr
|
|
GLushort *pusEnd; // end of scan line
|
|
__GLfloat inc; // current dither adj.
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLboolean bDIB;
|
|
__GLcolor *pAccumCol, *pac;
|
|
__GLaccumBuffer *afb;
|
|
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
afb = &gc->accumBuffer;
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
ap = (GLuint *)ac;
|
|
xFrag = x;
|
|
yFrag = y;
|
|
xScr = __GL_UNBIAS_X(gc, xFrag) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, yFrag) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
bDIB = cfb->buf.flags & DIB_FORMAT;
|
|
|
|
// Use to call wglSpanVisible, if window level security is added reimplement
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
pus = bDIB ? (GLushort *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr<<1))
|
|
: gengc->ColorsBits;
|
|
pusEnd = pus + w;
|
|
|
|
// Pre-fetch/clamp/scale the accum buffer values
|
|
afb = &gc->accumBuffer;
|
|
pAccumCol = afb->colors;
|
|
GetClampedRGBAccum32Values( cfb, ap, pAccumCol, w, scale );
|
|
pac = pAccumCol;
|
|
|
|
// Case: no masking, no dithering
|
|
|
|
if ( !(enables & (__GL_DITHER_ENABLE)) &&
|
|
!(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) {
|
|
for ( ; pus < pusEnd; pus++, pac++ )
|
|
{
|
|
*pus = ((BYTE) FTOL(pac->r + __glHalf) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + __glHalf) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + __glHalf) << cfb->blueShift) |
|
|
((BYTE) FTOL(pac->a + __glHalf) << cfb->alphaShift);
|
|
}
|
|
} else {
|
|
for ( ; pus < pusEnd; pus++, pac++ )
|
|
{
|
|
*pus = ((BYTE) FTOL(pac->r + __glHalf) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + __glHalf) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + __glHalf) << cfb->blueShift);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Case: dithering, no masking
|
|
|
|
else if ( !(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) {
|
|
for ( ; pus < pusEnd; pus++, pac++, xFrag++ )
|
|
{
|
|
inc = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
*pus = ((BYTE) FTOL(pac->r + inc) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + inc) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + inc) << cfb->blueShift) |
|
|
((BYTE) FTOL(pac->a + inc) << cfb->alphaShift);
|
|
}
|
|
} else {
|
|
for ( ; pus < pusEnd; pus++, pac++, xFrag++ )
|
|
{
|
|
inc = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
*pus = ((BYTE) FTOL(pac->r + inc) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + inc) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + inc) << cfb->blueShift);
|
|
}
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
// Color mask pre-fetch
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
for ( ; pus < pusEnd; pus++, pac++ )
|
|
{
|
|
inc = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
|
|
// Dither.
|
|
|
|
if ( enables & __GL_DITHER_ENABLE )
|
|
{
|
|
inc = fDitherIncTable[__GL_DITHER_INDEX(xFrag, yFrag)];
|
|
xFrag++;
|
|
}
|
|
else
|
|
{
|
|
inc = __glHalf;
|
|
}
|
|
|
|
// Convert color to 16BPP format.
|
|
|
|
result = ((BYTE) FTOL(pac->r + inc) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g + inc) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b + inc) << cfb->blueShift);
|
|
if( ALPHA_PIXEL_WRITE( cfb ) )
|
|
result |= ((BYTE) FTOL(pac->a + inc) << cfb->alphaShift);
|
|
|
|
// Store result with optional masking.
|
|
|
|
*pus = (GLushort)((*pus & cfb->destMask) | (result & cfb->sourceMask));
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan2)( &cfb->alphaBuf, x, y, w, pAccumCol );
|
|
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* Bitfield32ReturnSpan
|
|
* Reads from a 64-bit accumulation buffer and writes the span to a device or
|
|
* a DIB. Only dithering and color mask are applied. Blend is ignored.
|
|
*
|
|
* History:
|
|
* 10-DEC-93 Eddie Robinson [v-eddier] Wrote it.
|
|
\**************************************************************************/
|
|
|
|
//XXX This routine follows the store span routine very closely. Any changes
|
|
//XXX to the store span routine should also be reflected here
|
|
|
|
void Bitfield32ReturnSpan(__GLcolorBuffer *cfb, GLint x, GLint y,
|
|
const __GLaccumCell *ac, __GLfloat scale, GLint w )
|
|
{
|
|
__GLcontext *gc = cfb->buf.gc;
|
|
GLshort *ap; // current accum entry
|
|
|
|
GLint xScr, yScr; // current screen (pixel) coordinates
|
|
GLuint result, *pul; // current pixel color, current pixel ptr
|
|
GLuint *pulEnd; // end of scan line
|
|
|
|
__GLGENcontext *gengc; // generic graphics context
|
|
GLuint enables; // modes enabled in graphics context
|
|
GLboolean bDIB;
|
|
|
|
__GLfloat r, g, b;
|
|
__GLfloat rval, gval, bval;
|
|
__GLaccumBuffer *afb;
|
|
__GLcolor *pAccumCol, *pac;
|
|
ASSERT_CHOP_ROUND();
|
|
|
|
afb = &gc->accumBuffer;
|
|
rval = scale * afb->oneOverRedScale;
|
|
gval = scale * afb->oneOverGreenScale;
|
|
bval = scale * afb->oneOverBlueScale;
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
ap = (GLshort *)ac;
|
|
xScr = __GL_UNBIAS_X(gc, x) + cfb->buf.xOrigin;
|
|
yScr = __GL_UNBIAS_Y(gc, y) + cfb->buf.yOrigin;
|
|
enables = gc->state.enables.general;
|
|
bDIB = cfb->buf.flags & DIB_FORMAT;
|
|
|
|
// Use to call wglSpanVisible, if window level security is added reimplement
|
|
|
|
// Get pointer to bitmap.
|
|
|
|
pul = bDIB ? (GLuint *)((ULONG_PTR)cfb->buf.base + (yScr*cfb->buf.outerWidth) + (xScr<<2))
|
|
: gengc->ColorsBits;
|
|
pulEnd = pul + w;
|
|
|
|
// Pre-fetch/clamp/scale the accum buffer values
|
|
afb = &gc->accumBuffer;
|
|
pAccumCol = afb->colors;
|
|
GetClampedRGBAccum64Values( cfb, ap, pAccumCol, w, scale );
|
|
pac = pAccumCol;
|
|
|
|
// Case: no masking
|
|
|
|
if ( !(cfb->buf.flags & COLORMASK_ON) )
|
|
{
|
|
if( ALPHA_PIXEL_WRITE( cfb ) ) {
|
|
for ( ; pul < pulEnd; pul++, pac++ )
|
|
{
|
|
*pul = ((BYTE) FTOL(pac->r) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b) << cfb->blueShift) |
|
|
((BYTE) FTOL(pac->a) << cfb->alphaShift);
|
|
}
|
|
} else {
|
|
for ( ; pul < pulEnd; pul++, pac++ )
|
|
{
|
|
*pul = ((BYTE) FTOL(pac->r) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b) << cfb->blueShift);
|
|
}
|
|
}
|
|
}
|
|
|
|
// All other cases
|
|
|
|
else
|
|
{
|
|
// Color mask pre-fetch
|
|
if( !bDIB )
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, FALSE);
|
|
|
|
for ( ; pul < pulEnd; pul++, pac++ )
|
|
{
|
|
result = ((BYTE) FTOL(pac->r) << cfb->redShift) |
|
|
((BYTE) FTOL(pac->g) << cfb->greenShift) |
|
|
((BYTE) FTOL(pac->b) << cfb->blueShift);
|
|
|
|
if( ALPHA_PIXEL_WRITE( cfb ) )
|
|
result |= ((BYTE) FTOL(pac->a) << cfb->alphaShift);
|
|
|
|
//!!!XXX again, opt. by unrolling loop
|
|
*pul = (*pul & cfb->destMask) | (result & cfb->sourceMask);
|
|
}
|
|
}
|
|
|
|
// Output the offscreen scanline buffer to the device. The function
|
|
// (*gengc->pfnCopyPixels) should handle clipping.
|
|
|
|
if (!bDIB)
|
|
(*gengc->pfnCopyPixels)(gengc, cfb, xScr, yScr, w, TRUE);
|
|
|
|
if( ALPHA_BUFFER_WRITE( cfb ) )
|
|
(*cfb->alphaBuf.storeSpan2)( &cfb->alphaBuf, x, y, w, pAccumCol );
|
|
}
|
|
|
|
STATIC void __glSetDrawBuffer(__GLcolorBuffer *cfb)
|
|
{
|
|
|
|
DBGENTRY("__glSetDrawBuffer\n");
|
|
}
|
|
|
|
STATIC void setReadBuffer(__GLcolorBuffer *cfb)
|
|
{
|
|
DBGENTRY("setReadBuffer\n");
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
|
|
STATIC void Resize(__GLGENbuffers *buffers, __GLcolorBuffer *cfb,
|
|
GLint w, GLint h)
|
|
{
|
|
|
|
DBGENTRY("Resize\n");
|
|
|
|
cfb->buf.width = w;
|
|
cfb->buf.height = h;
|
|
}
|
|
|
|
#define DBG_PICK LEVEL_ENTRY
|
|
|
|
// Called at each validate (lots of times, whenever states change)
|
|
STATIC void FASTCALL PickRGB(__GLcontext *gc, __GLcolorBuffer *cfb)
|
|
{
|
|
__GLGENcontext *gengc;
|
|
GLuint totalMask, sourceMask;
|
|
GLboolean colormask;
|
|
PIXELFORMATDESCRIPTOR *pfmt;
|
|
GLuint enables = gc->state.enables.general;
|
|
|
|
sourceMask = 0;
|
|
colormask = GL_FALSE;
|
|
if (gc->state.raster.rMask) {
|
|
sourceMask |= gc->modes.redMask;
|
|
}
|
|
if (gc->state.raster.gMask) {
|
|
sourceMask |= gc->modes.greenMask;
|
|
}
|
|
if (gc->state.raster.bMask) {
|
|
sourceMask |= gc->modes.blueMask;
|
|
}
|
|
|
|
totalMask = gc->modes.redMask | gc->modes.greenMask | gc->modes.blueMask;
|
|
|
|
gengc = (__GLGENcontext *)gc;
|
|
|
|
// If we have alpha bits, need to determine where they belong : for a
|
|
// generic pixel format, they live in the software alpha buffer, but for
|
|
// an mcd type context they will be on the mcd device (or ALPHA_IN_PIXEL ).
|
|
// This is used by all the 'slow' store/fetch procs.
|
|
|
|
if( gc->modes.alphaBits && gengc->pMcdState ) {
|
|
// Set bit in buf.flags indicating alpha is in the pixel
|
|
cfb->buf.flags = cfb->buf.flags | ALPHA_IN_PIXEL_BIT;
|
|
} else {
|
|
// Alpha is not in the pixel, or there is no alpha
|
|
cfb->buf.flags = cfb->buf.flags & ~ALPHA_IN_PIXEL_BIT;
|
|
}
|
|
|
|
if( ALPHA_IN_PIXEL( cfb ) ) {
|
|
// There are alpha bits in the pixels, so need to include alpha in mask
|
|
if (gc->state.raster.aMask) {
|
|
sourceMask |= gc->modes.alphaMask;
|
|
}
|
|
totalMask |= gc->modes.alphaMask;
|
|
}
|
|
|
|
if (sourceMask == totalMask) {
|
|
cfb->buf.flags = cfb->buf.flags & ~COLORMASK_ON;
|
|
} else {
|
|
cfb->buf.flags = cfb->buf.flags | COLORMASK_ON;
|
|
}
|
|
cfb->sourceMask = sourceMask;
|
|
cfb->destMask = totalMask & ~sourceMask;
|
|
|
|
// Determine whether writing alpha values is required
|
|
if( gc->modes.alphaBits && gc->state.raster.aMask )
|
|
cfb->buf.flags = cfb->buf.flags | ALPHA_ON;
|
|
else
|
|
cfb->buf.flags = cfb->buf.flags & ~ALPHA_ON;
|
|
|
|
// If we're doing a logic op or there is a color mask we'll need
|
|
// to fetch the destination value before we write
|
|
if ((enables & __GL_COLOR_LOGIC_OP_ENABLE) ||
|
|
(cfb->buf.flags & COLORMASK_ON))
|
|
{
|
|
cfb->buf.flags = cfb->buf.flags | NEED_FETCH;
|
|
}
|
|
else
|
|
cfb->buf.flags = cfb->buf.flags & ~NEED_FETCH;
|
|
|
|
// Figure out store routines
|
|
if (gc->state.raster.drawBuffer == GL_NONE) {
|
|
cfb->store = Store_NOT;
|
|
cfb->fetch = RGBFetchNone;
|
|
cfb->readSpan = RGBReadSpanNone;
|
|
cfb->storeSpan = StoreSpanNone;
|
|
cfb->storeStippledSpan = StoreSpanNone;
|
|
} else {
|
|
pfmt = &gengc->gsurf.pfd;
|
|
|
|
// Pick functions that work for both DIB and Display formats
|
|
|
|
switch(pfmt->cColorBits) {
|
|
case 4:
|
|
cfb->clear = Index4Clear;
|
|
cfb->returnSpan = Index4ReturnSpan;
|
|
break;
|
|
case 8:
|
|
cfb->storeSpan = Index8StoreSpan;
|
|
cfb->readSpan = Index8RGBAReadSpan;
|
|
cfb->returnSpan = Index8ReturnSpan;
|
|
cfb->clear = Index8Clear;
|
|
break;
|
|
case 16:
|
|
cfb->storeSpan = Bitfield16StoreSpan;
|
|
cfb->readSpan = Bitfield16RGBAReadSpan;
|
|
cfb->returnSpan = Bitfield16ReturnSpan;
|
|
cfb->clear = Bitfield16Clear;
|
|
break;
|
|
case 24:
|
|
if (cfb->redShift == 16)
|
|
{
|
|
cfb->storeSpan = BGRStoreSpan;
|
|
cfb->readSpan = BGRAReadSpan;
|
|
cfb->returnSpan = BGRReturnSpan;
|
|
} else {
|
|
// XXX why no RGBStoreSpan ?
|
|
cfb->readSpan = RGBAReadSpan;
|
|
cfb->returnSpan = RGBReturnSpan;
|
|
}
|
|
cfb->clear = RGBClear;
|
|
break;
|
|
case 32:
|
|
cfb->storeSpan = Bitfield32StoreSpan;
|
|
cfb->readSpan = Bitfield32RGBAReadSpan;
|
|
cfb->returnSpan = Bitfield32ReturnSpan;
|
|
cfb->clear = Bitfield32Clear;
|
|
break;
|
|
}
|
|
|
|
// Pick specific functions for DIB or Display formats
|
|
|
|
if (cfb->buf.flags & DIB_FORMAT) {
|
|
|
|
switch(pfmt->cColorBits) {
|
|
|
|
case 4:
|
|
DBGLEVEL(DBG_PICK, "DIBIndex4Store\n");
|
|
cfb->store = DIBIndex4Store;
|
|
cfb->fetch = DIBIndex4RGBAFetch;
|
|
cfb->readSpan = DIBIndex4RGBAReadSpan;
|
|
break;
|
|
|
|
case 8:
|
|
DBGLEVEL(DBG_PICK, "DIBIndex8Store, "
|
|
"Index8StoreSpan\n");
|
|
cfb->store = DIBIndex8Store;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DIBIndex8RGBAFetch;
|
|
else
|
|
cfb->fetch = DIBIndex8RGBFetch;
|
|
break;
|
|
|
|
case 16:
|
|
DBGLEVEL(DBG_PICK, "DIBBitfield16Store\n");
|
|
cfb->store = DIBBitfield16Store;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DIBBitfield16RGBAFetch;
|
|
else
|
|
cfb->fetch = DIBBitfield16RGBFetch;
|
|
break;
|
|
|
|
case 24:
|
|
if (cfb->redShift == 16)
|
|
{
|
|
DBGLEVEL(DBG_PICK, "DIBBGRStore\n");
|
|
cfb->store = DIBBGRStore;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DIBBGRAFetch;
|
|
else
|
|
cfb->fetch = DIBBGRFetch;
|
|
}
|
|
else
|
|
{
|
|
DBGLEVEL(DBG_PICK, "DIBRGBStore\n");
|
|
cfb->store = DIBRGBAStore;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DIBRGBAFetch;
|
|
else
|
|
cfb->fetch = DIBRGBFetch;
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
DBGLEVEL(DBG_PICK, "DIBBitfield32Store, "
|
|
"Bitfield32StoreSpan\n");
|
|
cfb->store = DIBBitfield32Store;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DIBBitfield32RGBAFetch;
|
|
else
|
|
cfb->fetch = DIBBitfield32RGBFetch;
|
|
break;
|
|
|
|
}
|
|
} else {
|
|
switch(pfmt->cColorBits) {
|
|
|
|
case 4:
|
|
DBGLEVEL(DBG_PICK, "DisplayIndex4Store\n");
|
|
cfb->store = DisplayIndex4Store;
|
|
cfb->fetch = DisplayIndex4RGBAFetch;
|
|
cfb->readSpan = DisplayIndex4RGBAReadSpan;
|
|
break;
|
|
|
|
case 8:
|
|
DBGLEVEL(DBG_PICK, "DisplayIndex8Store, "
|
|
"Index8StoreSpan\n");
|
|
cfb->store = DisplayIndex8Store;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DisplayIndex8RGBAFetch;
|
|
else
|
|
cfb->fetch = DisplayIndex8RGBFetch;
|
|
break;
|
|
|
|
case 16:
|
|
DBGLEVEL(DBG_PICK, "DisplayBitfield16Store\n");
|
|
cfb->store = DisplayBitfield16Store;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DisplayBitfield16RGBAFetch;
|
|
else
|
|
cfb->fetch = DisplayBitfield16RGBFetch;
|
|
break;
|
|
|
|
case 24:
|
|
// Must be RGB or BGR
|
|
if (cfb->redShift == 16)
|
|
{
|
|
DBGLEVEL(DBG_PICK, "DisplayBGRStore\n");
|
|
cfb->store = DisplayBGRStore;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DisplayBGRAFetch;
|
|
else
|
|
cfb->fetch = DisplayBGRFetch;
|
|
}
|
|
else
|
|
{
|
|
DBGLEVEL(DBG_PICK, "DisplayRGBStore\n");
|
|
cfb->store = DisplayRGBStore;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DisplayRGBAFetch;
|
|
else
|
|
cfb->fetch = DisplayRGBFetch;
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
DBGLEVEL(DBG_PICK, "DisplayBitfield32Store, "
|
|
"Bitfield32StoreSpan\n");
|
|
cfb->store = DisplayBitfield32Store;
|
|
if( gc->modes.alphaBits )
|
|
cfb->fetch = DisplayBitfield32RGBAFetch;
|
|
else
|
|
cfb->fetch = DisplayBitfield32RGBFetch;
|
|
break;
|
|
}
|
|
}
|
|
// cfb->readColor is the same as cfb->fetch (so why do we need it ?)
|
|
cfb->readColor = cfb->fetch;
|
|
|
|
// If we are only writing alpha (rgb all masked), can further optimize:
|
|
// Don't bother if logicOp or blending are enabled, and only if we
|
|
// have a software alpha buffer
|
|
if( gc->modes.alphaBits &&
|
|
! ALPHA_IN_PIXEL( cfb ) &&
|
|
(sourceMask == 0) &&
|
|
gc->state.raster.aMask &&
|
|
!(enables & __GL_COLOR_LOGIC_OP_ENABLE) &&
|
|
! (enables & __GL_BLEND_ENABLE) )
|
|
{
|
|
cfb->store = AlphaStore;
|
|
cfb->storeSpan = AlphaStoreSpan;
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void FASTCALL __glGenFreeRGB(__GLcontext *gc, __GLcolorBuffer *cfb)
|
|
{
|
|
DBGENTRY("__glGenFreeRGB\n");
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
// Note: this used to be defined in generic\genrgb.h
|
|
#define __GL_GENRGB_COMPONENT_SCALE_ALPHA 255
|
|
|
|
// called at makecurrent time
|
|
// need to get info out of pixel format structure
|
|
void FASTCALL __glGenInitRGB(__GLcontext *gc, __GLcolorBuffer *cfb, GLenum type)
|
|
{
|
|
__GLGENcontext *gengc = (__GLGENcontext *)gc;
|
|
PIXELFORMATDESCRIPTOR *pfmt;
|
|
|
|
__glInitGenericCB(gc, cfb);
|
|
|
|
cfb->redMax = (1 << gc->modes.redBits) - 1;
|
|
cfb->greenMax = (1 << gc->modes.greenBits) - 1;
|
|
cfb->blueMax = (1 << gc->modes.blueBits) - 1;
|
|
|
|
gc->redVertexScale = cfb->redScale = (__GLfloat)cfb->redMax;
|
|
gc->greenVertexScale = cfb->greenScale = (__GLfloat)cfb->greenMax;
|
|
gc->blueVertexScale = cfb->blueScale = (__GLfloat)cfb->blueMax;
|
|
|
|
cfb->iRedScale = cfb->redMax;
|
|
cfb->iGreenScale = cfb->greenMax;
|
|
cfb->iBlueScale = cfb->blueMax;
|
|
|
|
// Do any initialization related to alpha
|
|
if( gc->modes.alphaBits ) {
|
|
cfb->alphaMax = (1 << gc->modes.alphaBits) - 1;
|
|
cfb->iAlphaScale = cfb->alphaMax;
|
|
gc->alphaVertexScale = cfb->alphaScale = (__GLfloat)cfb->alphaMax;
|
|
// Initialize the software alpha buffer. Actually, we may not need to
|
|
// do this, since if an mcd pixel format supports alpha, we don't need
|
|
// the software alpha buffer. But this is the most convenient place to
|
|
// do it, and no memory will be allocated anyways. just function ptrs
|
|
// initialized.
|
|
__glInitAlpha( gc, cfb );
|
|
} else {
|
|
cfb->alphaMax = __GL_GENRGB_COMPONENT_SCALE_ALPHA;
|
|
cfb->iAlphaScale = __GL_GENRGB_COMPONENT_SCALE_ALPHA;
|
|
gc->alphaVertexScale = cfb->alphaScale = (__GLfloat)cfb->redMax;
|
|
}
|
|
|
|
cfb->buf.elementSize = sizeof(GLubyte); // XXX needed?
|
|
|
|
cfb->pick = PickRGB; // called at each validate
|
|
cfb->resize = Resize;
|
|
cfb->fetchSpan = __glFetchSpan;
|
|
cfb->fetchStippledSpan = __glFetchSpan;
|
|
cfb->storeSpan = SlowStoreSpan;
|
|
cfb->storeStippledSpan = SlowStoreStippledSpan;
|
|
|
|
pfmt = &gengc->gsurf.pfd;
|
|
|
|
cfb->redShift = pfmt->cRedShift;
|
|
cfb->greenShift = pfmt->cGreenShift;
|
|
cfb->blueShift = pfmt->cBlueShift;
|
|
cfb->alphaShift = pfmt->cAlphaShift;
|
|
|
|
glGenInitCommon(gengc, cfb, type);
|
|
|
|
DBGLEVEL3(LEVEL_INFO,"GeninitRGB: redMax %d, greenMax %d, blueMax %d\n",
|
|
cfb->redMax, cfb->greenMax, cfb->blueMax);
|
|
DBGLEVEL3(LEVEL_INFO," redShift %d, greenShift %d, blueShift %d\n",
|
|
cfb->redShift, cfb->greenShift, cfb->blueShift);
|
|
DBGLEVEL2(LEVEL_INFO," dwFlags %X, cColorBits %d\n",
|
|
gengc->dwCurrentFlags, pfmt->cColorBits);
|
|
}
|