#define TAG(x) ffb##x##_888
-#include <spantmp.h>
+#include "spantmp.h"
/**
* Plug in the Get/Put routines for the given driRenderbuffer.
/*
* Specifies buffer for sw fallbacks (spans)
*/
+#if 000
+/* XXX
+ * This function is obsolete. It's not clear how this really effected
+ * span reading/writing above. The span functions should use the
+ * incoming driRenderbuffer (gl_renderbuffer) pointer to determine how
+ * to read from the specified bufer.
+ */
static void ffbDDSetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
GLuint bufferBit)
{
FFB_MAKE_DIRTY(fmesa, FFB_STATE_FBC, 1);
}
}
+#endif
+
static void ffbDDClearColor(GLcontext *ctx, const GLfloat color[4])
{
ctx->Driver.ClearIndex = 0;
ctx->Driver.IndexMask = 0;
*/
-
- {
- struct swrast_device_driver *swdd =
- _swrast_GetDeviceDriverReference(ctx);
- swdd->SetBuffer = ffbDDSetBuffer;
- }
-
-
}
void ffbDDInitContextHwState(GLcontext *ctx)
} else {
GLboolean swStencil = (mesaVis->stencilBits > 0 &&
mesaVis->depthBits != 24);
-#if 0
- driDrawPriv->driverPrivate = (void *)
- _mesa_create_framebuffer(mesaVis,
- GL_FALSE, /* software depth buffer? */
- mesaVis->stencilBits > 0,
- mesaVis->accumRedBits > 0,
- mesaVis->alphaBits > 0);
-#else
struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
{
GL_FALSE, /* alpha */
GL_FALSE /* aux */);
driDrawPriv->driverPrivate = (void *) fb;
-#endif
+
return (driDrawPriv->driverPrivate != NULL);
}
}
#include "i810vb.h"
#include "i810ioctl.h"
+#include "drirenderbuffer.h"
#include "utils.h"
#define need_GL_ARB_multisample
if ( imesa->sarea->pf_current_page == 1 )
front ^= 1;
+
+ driFlipRenderbuffers(ctx->WinSysDrawBuffer, front);
if (front) {
imesa->BufferSetup[I810_DESTREG_DI1] = imesa->i810Screen->fbOffset | imesa->i810Screen->backPitchBits;
- imesa->drawMap = (char *)imesa->driScreen->pFB;
- imesa->readMap = (char *)imesa->driScreen->pFB;
} else {
imesa->BufferSetup[I810_DESTREG_DI1] = imesa->i810Screen->backOffset | imesa->i810Screen->backPitchBits;
- imesa->drawMap = imesa->i810Screen->back.map;
- imesa->readMap = imesa->i810Screen->back.map;
}
imesa->dirty |= I810_UPLOAD_BUFFERS;
/* These refer to the current draw (front vs. back) buffer:
*/
- char *drawMap; /* draw buffer address in virtual mem */
- char *readMap;
int drawX; /* origin of drawable in draw buffer */
int drawY;
GLuint numClipRects; /* cliprects for that buffer */
/*screen->frontOffset*/0, screen->backPitch);
i810SetSpanFunctions(frontRb, mesaVis);
_mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontRb->Base);
+ frontRb->Base.Data = driScrnPriv->pFB;
}
if (mesaVis->doubleBufferMode) {
screen->backOffset, screen->backPitch);
i810SetSpanFunctions(backRb, mesaVis);
_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base);
+ backRb->Base.Data = (GLubyte *) screen->back.map;
}
if (mesaVis->depthBits == 16) {
screen->depthOffset, screen->backPitch);
i810SetSpanFunctions(depthRb, mesaVis);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
+ depthRb->Base.Data = (GLubyte *) screen->depth.map;
}
_mesa_add_soft_renderbuffers(fb,
#define LOCAL_VARS \
i810ContextPtr imesa = I810_CONTEXT(ctx); \
__DRIdrawablePrivate *dPriv = imesa->driDrawable; \
- i810ScreenPrivate *i810Screen = imesa->i810Screen; \
- GLuint pitch = i810Screen->backPitch; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint pitch = drb->pitch; \
GLuint height = dPriv->h; \
GLushort p; \
- char *buf = (char *)(imesa->drawMap + \
+ char *buf = (char *)(drb->flippedData + \
dPriv->x * 2 + \
dPriv->y * pitch); \
- char *read_buf = (char *)(imesa->readMap + \
- dPriv->x * 2 + \
- dPriv->y * pitch); \
+ char *read_buf = buf; \
(void) read_buf; (void) buf; (void) p
#define LOCAL_DEPTH_VARS \
i810ContextPtr imesa = I810_CONTEXT(ctx); \
__DRIdrawablePrivate *dPriv = imesa->driDrawable; \
- i810ScreenPrivate *i810Screen = imesa->i810Screen; \
- GLuint pitch = i810Screen->backPitch; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint pitch = drb->pitch; \
GLuint height = dPriv->h; \
- char *buf = (char *)(i810Screen->depth.map + \
+ char *buf = (char *)(drb->Base.Data + \
dPriv->x * 2 + \
dPriv->y * pitch)
#define READ_DEPTH( d, _x, _y ) \
d = *(GLushort *)(buf + (_x)*2 + (_y)*pitch);
-#define TAG(x) i810##x##_16
+#define TAG(x) i810##x##_z16
#include "depthtmp.h"
-/*
- * This function is called to specify which buffer to read and write
- * for software rasterization (swrast) fallbacks. This doesn't necessarily
- * correspond to glDrawBuffer() or glReadBuffer() calls.
- */
-static void i810SetBuffer(GLcontext *ctx, GLframebuffer *buffer,
- GLuint bufferBit )
-{
- i810ContextPtr imesa = I810_CONTEXT(ctx);
- (void) buffer;
-
- switch(bufferBit) {
- case BUFFER_BIT_FRONT_LEFT:
- if ( imesa->sarea->pf_current_page == 1)
- imesa->readMap = imesa->i810Screen->back.map;
- else
- imesa->readMap = (char*)imesa->driScreen->pFB;
- break;
- case BUFFER_BIT_BACK_LEFT:
- if ( imesa->sarea->pf_current_page == 1)
- imesa->readMap = (char*)imesa->driScreen->pFB;
- else
- imesa->readMap = imesa->i810Screen->back.map;
- break;
- default:
- ASSERT(0);
- break;
- }
- imesa->drawMap = imesa->readMap;
-}
-
/* Move locking out to get reasonable span performance.
*/
void i810SpanRenderStart( GLcontext *ctx )
void i810InitSpanFuncs( GLcontext *ctx )
{
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = i810SetBuffer;
-
-#if 0
- swdd->WriteRGBASpan = i810WriteRGBASpan_565;
- swdd->WriteRGBSpan = i810WriteRGBSpan_565;
- swdd->WriteMonoRGBASpan = i810WriteMonoRGBASpan_565;
- swdd->WriteRGBAPixels = i810WriteRGBAPixels_565;
- swdd->WriteMonoRGBAPixels = i810WriteMonoRGBAPixels_565;
- swdd->ReadRGBASpan = i810ReadRGBASpan_565;
- swdd->ReadRGBAPixels = i810ReadRGBAPixels_565;
-#endif
-
-#if 0
- swdd->ReadDepthSpan = i810ReadDepthSpan_16;
- swdd->WriteDepthSpan = i810WriteDepthSpan_16;
- swdd->ReadDepthPixels = i810ReadDepthPixels_16;
- swdd->WriteDepthPixels = i810WriteDepthPixels_16;
-#endif
-
swdd->SpanRenderStart = i810SpanRenderStart;
swdd->SpanRenderFinish = i810SpanRenderFinish;
}
drb->Base.PutMonoValues = i810WriteMonoRGBAPixels_565;
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = i810ReadDepthSpan_16;
- drb->Base.GetValues = i810ReadDepthPixels_16;
- drb->Base.PutRow = i810WriteDepthSpan_16;
- drb->Base.PutMonoRow = i810WriteMonoDepthSpan_16;
- drb->Base.PutValues = i810WriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
+ i810InitDepthPointers_z16(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
/* should never get here */
imesa->i810Screen->backPitchBits);
i810XMesaSetBackClipRects( imesa );
}
-
- /* We want to update the s/w rast state too so that r200SetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
}
if (imesa->glCtx->Visual.doubleBufferMode && imesa->sarea->pf_current_page == 0) {
/* use back buffer by default */
- imesa->drawMap = i810Screen->back.map;
- imesa->readMap = i810Screen->back.map;
imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->backOffset |
i810Screen->backPitchBits);
} else {
/* use front buffer by default */
- imesa->drawMap = (char *)imesa->driScreen->pFB;
- imesa->readMap = (char *)imesa->driScreen->pFB;
imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->fbOffset |
i810Screen->backPitchBits);
}
return GL_FALSE; /* not implemented */
}
else {
-#if 0
- driDrawPriv->driverPrivate = (void *)
- _mesa_create_framebuffer( mesaVis,
- GL_FALSE, /* software depth buffer? */
- mesaVis->stencilBits > 0,
- mesaVis->accumRedBits > 0,
- mesaVis->alphaBits > 0 );
-#else
struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
{
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
}
else if (mesaVis->depthBits == 24) {
+ /* XXX I don't think 24-bit Z is supported - so this isn't used */
driRenderbuffer *depthRb
= driNewRenderbuffer(GL_DEPTH_COMPONENT24, screen->cpp,
screen->depthOffset, screen->depthPitch);
GL_FALSE, /* alpha */
GL_FALSE /* aux */);
driDrawPriv->driverPrivate = (void *) fb;
-#endif
+
return (driDrawPriv->driverPrivate != NULL);
}
}
#define DBG 0
+#define GET_PTR(X,Y) (sPriv->pFB + drb->offset \
+ + ((dPriv->y + (Y)) * drb->pitch + (dPriv->x + (X))) * drb->cpp)
+
#define LOCAL_VARS \
mach64ContextPtr mmesa = MACH64_CONTEXT(ctx); \
- mach64ScreenRec *mach64Screen = mmesa->mach64Screen; \
- __DRIscreenPrivate *driScreen = mmesa->driScreen; \
+ __DRIscreenPrivate *sPriv = mmesa->driScreen; \
__DRIdrawablePrivate *dPriv = mmesa->driDrawable; \
- GLuint pitch = mmesa->drawPitch * mach64Screen->cpp; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
GLuint height = dPriv->h; \
- char *buf = (char *)(driScreen->pFB + \
- mmesa->drawOffset + \
- (dPriv->x * mach64Screen->cpp) + \
- (dPriv->y * pitch)); \
- char *read_buf = (char *)(driScreen->pFB + \
- mmesa->readOffset + \
- (dPriv->x * mach64Screen->cpp) + \
- (dPriv->y * pitch)); \
GLushort p; \
- (void) read_buf; (void) buf; (void) p
+ (void) p;
#define LOCAL_DEPTH_VARS \
mach64ContextPtr mmesa = MACH64_CONTEXT(ctx); \
- mach64ScreenRec *mach64Screen = mmesa->mach64Screen; \
__DRIdrawablePrivate *dPriv = mmesa->driDrawable; \
__DRIscreenPrivate *driScreen = mmesa->driScreen; \
- GLuint pitch = mach64Screen->depthPitch * 2; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
GLuint height = dPriv->h; \
- char *buf = (char *)(driScreen->pFB + \
- mach64Screen->depthOffset + \
- dPriv->x * 2 + \
- dPriv->y * pitch)
+ char *buf = (char *)(driScreen->pFB + drb->offset + \
+ (dPriv->x + dPriv->y * drb->pitch) * 2)
#define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS
#define TAG(x) mach64##x##_RGB565
#define TAG2(x,y) mach64##x##_RGB565##y
+#define GET_SRC_PTR(X,Y) GET_PTR(X,Y)
+#define GET_DST_PTR(X,Y) GET_SRC_PTR(X,Y)
#include "spantmp2.h"
#define TAG(x) mach64##x##_ARGB8888
#define TAG2(x,y) mach64##x##_ARGB8888##y
+#define GET_SRC_PTR(X,Y) GET_PTR(X,Y)
+#define GET_DST_PTR(X,Y) GET_SRC_PTR(X,Y)
#include "spantmp2.h"
/* 16 bit depthbuffer functions.
*/
#define WRITE_DEPTH( _x, _y, d ) \
- *(GLushort *)(buf + (_x)*2 + (_y)*pitch) = d;
+ *(GLushort *)(buf + ((_x) + (_y) * drb->pitch) * 2) = d;
#define READ_DEPTH( d, _x, _y ) \
- d = *(GLushort *)(buf + (_x)*2 + (_y)*pitch);
+ d = *(GLushort *)(buf + ((_x) + (_y) * drb->pitch) * 2);
-#define TAG(x) mach64##x##_16
+#define TAG(x) mach64##x##_z16
#include "depthtmp.h"
-/*
- * This function is called to specify which buffer to read and write
- * for software rasterization (swrast) fallbacks. This doesn't necessarily
- * correspond to glDrawBuffer() or glReadBuffer() calls.
- */
-static void mach64DDSetBuffer( GLcontext *ctx,
- GLframebuffer *colorBuffer,
- GLuint bufferBit )
-{
- mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
-
- switch ( bufferBit ) {
- case BUFFER_BIT_FRONT_LEFT:
- if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
- fprintf(stderr,"%s: BUFFER_BIT_FRONT_LEFT\n", __FUNCTION__);
- mmesa->drawOffset = mmesa->readOffset = mmesa->mach64Screen->frontOffset;
- mmesa->drawPitch = mmesa->readPitch = mmesa->mach64Screen->frontPitch;
- break;
- case BUFFER_BIT_BACK_LEFT:
- if (MACH64_DEBUG & DEBUG_VERBOSE_MSG)
- fprintf(stderr,"%s: BUFFER_BIT_BACK_LEFT\n", __FUNCTION__);
- mmesa->drawOffset = mmesa->readOffset = mmesa->mach64Screen->backOffset;
- mmesa->drawPitch = mmesa->readPitch = mmesa->mach64Screen->backPitch;
- break;
- default:
- break;
- }
-}
-
static void mach64SpanRenderStart( GLcontext *ctx )
{
mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
void mach64DDInitSpanFuncs( GLcontext *ctx )
{
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = mach64DDSetBuffer;
swdd->SpanRenderStart = mach64SpanRenderStart;
swdd->SpanRenderFinish = mach64SpanRenderFinish;
}
}
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = mach64ReadDepthSpan_16;
- drb->Base.GetValues = mach64ReadDepthPixels_16;
- drb->Base.PutRow = mach64WriteDepthSpan_16;
- drb->Base.PutMonoRow = mach64WriteMonoDepthSpan_16;
- drb->Base.PutValues = mach64WriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
- }
- else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
- /* never */
- drb->Base.GetRow = NULL;
- drb->Base.GetValues = NULL;
- drb->Base.PutRow = NULL;
- drb->Base.PutMonoRow = NULL;
- drb->Base.PutValues = NULL;
- drb->Base.PutMonoValues = NULL;
- }
- else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- /* never */
- drb->Base.GetRow = NULL;
- drb->Base.GetValues = NULL;
- drb->Base.PutRow = NULL;
- drb->Base.PutMonoRow = NULL;
- drb->Base.PutValues = NULL;
- drb->Base.PutMonoValues = NULL;
+ mach64InitDepthPointers_z16(&drb->Base);
}
}
break;
}
- /* We want to update the s/w rast state too so that mach64SetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
-
mmesa->setup.dst_off_pitch = (((mmesa->drawPitch/8) << 22) |
(mmesa->drawOffset >> 3));
* Authors:
* Keith Whitwell <keith@tungstengraphics.com>
*/
-/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgaspan.c,v 1.11 2002/10/30 12:51:36 alanh Exp $ */
#include "mtypes.h"
#include "mgadd.h"
#define DBG 0
#define LOCAL_VARS \
- mgaContextPtr mmesa = MGA_CONTEXT(ctx); \
+ mgaContextPtr mmesa = MGA_CONTEXT(ctx); \
__DRIdrawablePrivate *dPriv = mmesa->mesa_drawable; \
- mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; \
__DRIscreenPrivate *sPriv = mmesa->driScreen; \
- GLuint pitch = mgaScreen->frontPitch; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint pitch = drb->pitch; \
GLuint height = dPriv->h; \
- char *read_buf = (char *)(sPriv->pFB + \
- mmesa->readOffset + \
- dPriv->x * mgaScreen->cpp + \
- dPriv->y * pitch); \
char *buf = (char *)(sPriv->pFB + \
- mmesa->drawOffset + \
- dPriv->x * mgaScreen->cpp + \
+ drb->offset + \
+ dPriv->x * drb->cpp + \
dPriv->y * pitch); \
+ char *read_buf = buf; \
GLuint p; \
(void) read_buf; (void) buf; (void) p
#define LOCAL_DEPTH_VARS \
mgaContextPtr mmesa = MGA_CONTEXT(ctx); \
__DRIdrawablePrivate *dPriv = mmesa->mesa_drawable; \
- mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; \
__DRIscreenPrivate *sPriv = mmesa->driScreen; \
- GLuint pitch = mgaScreen->frontPitch; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint pitch = drb->pitch; \
GLuint height = dPriv->h; \
char *buf = (char *)(sPriv->pFB + \
- mgaScreen->depthOffset + \
- dPriv->x * mgaScreen->cpp + \
+ drb->offset + \
+ dPriv->x * drb->cpp + \
dPriv->y * pitch)
#define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS
#define READ_DEPTH( d, _x, _y ) \
d = *(GLushort *)(buf + (_x)*2 + (_y)*pitch);
-#define TAG(x) mga##x##_16
+#define TAG(x) mga##x##_z16
#include "depthtmp.h"
#define READ_DEPTH( d, _x, _y ) \
d = *(GLuint *)(buf + (_x)*4 + (_y)*pitch);
-#define TAG(x) mga##x##_32
+#define TAG(x) mga##x##_z32
#include "depthtmp.h"
d = (*(GLuint *)(buf + (_x)*4 + (_y)*pitch) & ~0xff) >> 8; \
}
-#define TAG(x) mga##x##_24_8
+#define TAG(x) mga##x##_z24_s8
#include "depthtmp.h"
#define WRITE_STENCIL( _x, _y, d ) { \
#define READ_STENCIL( d, _x, _y ) \
d = *(GLuint *)(buf + _x*4 + _y*pitch) & 0xff;
-#define TAG(x) mga##x##_24_8
+#define TAG(x) mga##x##_z24_s8
#include "stenciltmp.h"
-
-/*
- * This function is called to specify which buffer to read and write
- * for software rasterization (swrast) fallbacks. This doesn't necessarily
- * correspond to glDrawBuffer() or glReadBuffer() calls.
- */
-static void mgaDDSetBuffer(GLcontext *ctx, GLframebuffer *buffer,
- GLuint bufferBit)
-{
- mgaContextPtr mmesa = MGA_CONTEXT(ctx);
- unsigned int offset;
-
- assert((bufferBit == BUFFER_BIT_FRONT_LEFT) || (bufferBit == BUFFER_BIT_BACK_LEFT));
-
- offset = (bufferBit == BUFFER_BIT_FRONT_LEFT)
- ? mmesa->mgaScreen->frontOffset
- : mmesa->mgaScreen->backOffset;
-
- mmesa->drawOffset = offset;
- mmesa->readOffset = offset;
-
- assert( (buffer == mmesa->driDrawable->driverPrivate)
- || (buffer == mmesa->driReadable->driverPrivate) );
-
- mmesa->mesa_drawable = (buffer == mmesa->driDrawable->driverPrivate)
- ? mmesa->driDrawable : mmesa->driReadable;
-}
-
void mgaSpanRenderStart( GLcontext *ctx )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
*/
void mgaDDInitSpanFuncs( GLcontext *ctx )
{
- mgaContextPtr mmesa = MGA_CONTEXT(ctx);
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = mgaDDSetBuffer;
-
- switch (mmesa->mgaScreen->cpp) {
- case 2:
-#if 0
- mgaInitPointers_565( swdd );
- swdd->ReadDepthSpan = mgaReadDepthSpan_16;
- swdd->WriteDepthSpan = mgaWriteDepthSpan_16;
- swdd->ReadDepthPixels = mgaReadDepthPixels_16;
- swdd->WriteDepthPixels = mgaWriteDepthPixels_16;
-#endif
- break;
-
- case 4:
-#if 0
- mgaInitPointers_8888( swdd );
-
- if (!mmesa->hw_stencil) {
- swdd->ReadDepthSpan = mgaReadDepthSpan_32;
- swdd->WriteDepthSpan = mgaWriteDepthSpan_32;
- swdd->ReadDepthPixels = mgaReadDepthPixels_32;
- swdd->WriteDepthPixels = mgaWriteDepthPixels_32;
- } else {
- swdd->ReadDepthSpan = mgaReadDepthSpan_24_8;
- swdd->WriteDepthSpan = mgaWriteDepthSpan_24_8;
- swdd->ReadDepthPixels = mgaReadDepthPixels_24_8;
- swdd->WriteDepthPixels = mgaWriteDepthPixels_24_8;
-
- swdd->ReadStencilSpan = mgaReadStencilSpan_24_8;
- swdd->WriteStencilSpan = mgaWriteStencilSpan_24_8;
- swdd->ReadStencilPixels = mgaReadStencilPixels_24_8;
- swdd->WriteStencilPixels = mgaWriteStencilPixels_24_8;
- }
-#endif
- break;
- }
swdd->SpanRenderStart = mgaSpanRenderStart;
swdd->SpanRenderFinish = mgaSpanRenderFinish;
}
}
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = mgaReadDepthSpan_16;
- drb->Base.GetValues = mgaReadDepthPixels_16;
- drb->Base.PutRow = mgaWriteDepthSpan_16;
- drb->Base.PutMonoRow = mgaWriteMonoDepthSpan_16;
- drb->Base.PutValues = mgaWriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
+ mgaInitDepthPointers_z16(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
- drb->Base.GetRow = mgaReadDepthSpan_24_8;
- drb->Base.GetValues = mgaReadDepthPixels_24_8;
- drb->Base.PutRow = mgaWriteDepthSpan_24_8;
- drb->Base.PutMonoRow = mgaWriteMonoDepthSpan_24_8;
- drb->Base.PutValues = mgaWriteDepthPixels_24_8;
- drb->Base.PutMonoValues = NULL;
+ mgaInitDepthPointers_z24_s8(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT32) {
- drb->Base.GetRow = mgaReadDepthSpan_32;
- drb->Base.GetValues = mgaReadDepthPixels_32;
- drb->Base.PutRow = mgaWriteDepthSpan_32;
- drb->Base.PutMonoRow = mgaWriteMonoDepthSpan_32;
- drb->Base.PutValues = mgaWriteDepthPixels_32;
- drb->Base.PutMonoValues = NULL;
+ mgaInitDepthPointers_z32(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- drb->Base.GetRow = mgaReadStencilSpan_24_8;
- drb->Base.GetValues = mgaReadStencilPixels_24_8;
- drb->Base.PutRow = mgaWriteStencilSpan_24_8;
- drb->Base.PutMonoRow = mgaWriteMonoStencilSpan_24_8;
- drb->Base.PutValues = mgaWriteStencilPixels_24_8;
- drb->Base.PutMonoValues = NULL;
+ mgaInitStencilPointers_z24_s8(&drb->Base);
}
}
FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_TRUE );
return;
}
-
- /* We want to update the s/w rast state too so that r200SetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
}
*/
GLuint doPageFlip;
- /* Drawable, cliprect and scissor information
+ /* Cliprect and scissor information
*/
- GLint drawOffset, drawPitch;
- GLint readOffset, readPitch;
-
GLuint numClipRects; /* Cliprects for the draw buffer */
drm_clip_rect_t *pClipRects;
#include "vblank.h"
#include "mmio.h"
+#include "drirenderbuffer.h"
#define R128_TIMEOUT 2048
#define R128_IDLE_RETRY 32
exit( 1 );
}
- if ( rmesa->sarea->pfCurrentPage == 1 ) {
- rmesa->drawOffset = rmesa->r128Screen->frontOffset;
- rmesa->drawPitch = rmesa->r128Screen->frontPitch;
- } else {
- rmesa->drawOffset = rmesa->r128Screen->backOffset;
- rmesa->drawPitch = rmesa->r128Screen->backPitch;
- }
+ /* Get ready for drawing next frame. Update the renderbuffers'
+ * flippedOffset/Pitch fields so we draw into the right place.
+ */
+ driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
+ rmesa->sarea->pfCurrentPage);
- rmesa->setup.dst_pitch_offset_c = (((rmesa->drawPitch/8) << 21) |
- (rmesa->drawOffset >> 5));
rmesa->new_state |= R128_NEW_WINDOW;
/* FIXME: Do we need this anymore? */
#include "r128_tex.h"
#include "r128_state.h"
+#include "drirenderbuffer.h"
+
+
#if DEBUG_LOCKING
char *prevLockFile = NULL;
int prevLockLine = 0;
static void
r128UpdatePageFlipping( r128ContextPtr rmesa )
{
- int use_back;
-
rmesa->doPageFlip = rmesa->sarea->pfAllowPageFlip;
-
- use_back = (rmesa->glCtx->DrawBuffer->_ColorDrawBufferMask[0] == BUFFER_BIT_BACK_LEFT);
- use_back ^= (rmesa->sarea->pfCurrentPage == 1);
-
- if ( R128_DEBUG & DEBUG_VERBOSE_API )
- fprintf(stderr, "%s allow %d current %d\n", __FUNCTION__,
- rmesa->doPageFlip,
- rmesa->sarea->pfCurrentPage );
-
- if ( use_back ) {
- rmesa->drawOffset = rmesa->r128Screen->backOffset;
- rmesa->drawPitch = rmesa->r128Screen->backPitch;
- } else {
- rmesa->drawOffset = rmesa->r128Screen->frontOffset;
- rmesa->drawPitch = rmesa->r128Screen->frontPitch;
+ if (!rmesa->doPageFlip) {
+ driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer, GL_FALSE);
}
- rmesa->setup.dst_pitch_offset_c = (((rmesa->drawPitch/8) << 21) |
- (rmesa->drawOffset >> 5));
rmesa->new_state |= R128_NEW_WINDOW;
}
return GL_FALSE; /* not implemented */
}
else {
-#if 0
- driDrawPriv->driverPrivate = (void *)
- _mesa_create_framebuffer( mesaVis,
- GL_FALSE, /* software depth buffer? */
- mesaVis->stencilBits > 0,
- mesaVis->accumRedBits > 0,
- mesaVis->alphaBits > 0 );
-#else
struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
{
GL_FALSE, /* alpha */
GL_FALSE /* aux */);
driDrawPriv->driverPrivate = (void *) fb;
-#endif
+
return (driDrawPriv->driverPrivate != NULL);
}
}
#define DBG 0
+#define GET_PTR(X,Y) (sPriv->pFB + drb->flippedOffset \
+ + ((dPriv->y + (Y)) * drb->flippedPitch + (dPriv->x + (X))) * drb->cpp)
+
#define HAVE_HW_DEPTH_SPANS 1
#define HAVE_HW_DEPTH_PIXELS 1
#define LOCAL_VARS \
r128ContextPtr rmesa = R128_CONTEXT(ctx); \
- r128ScreenPtr r128scrn = rmesa->r128Screen; \
__DRIscreenPrivate *sPriv = rmesa->driScreen; \
__DRIdrawablePrivate *dPriv = rmesa->driDrawable; \
- GLuint pitch = r128scrn->frontPitch * r128scrn->cpp; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
GLuint height = dPriv->h; \
- char *buf = (char *)(sPriv->pFB + \
- rmesa->drawOffset + \
- (dPriv->x * r128scrn->cpp) + \
- (dPriv->y * pitch)); \
- char *read_buf = (char *)(sPriv->pFB + \
- rmesa->readOffset + \
- (dPriv->x * r128scrn->cpp) + \
- (dPriv->y * pitch)); \
GLuint p; \
- (void) read_buf; (void) buf; (void) p
+ (void) p;
#define LOCAL_DEPTH_VARS \
r128ContextPtr rmesa = R128_CONTEXT(ctx); \
#define TAG(x) r128##x##_RGB565
#define TAG2(x,y) r128##x##_RGB565##y
+#define GET_SRC_PTR(X,Y) GET_PTR(X,Y)
+#define GET_DST_PTR(X,Y) GET_PTR(X,Y)
#include "spantmp2.h"
#define TAG(x) r128##x##_ARGB8888
#define TAG2(x,y) r128##x##_ARGB8888##y
+#define GET_SRC_PTR(X,Y) GET_PTR(X,Y)
+#define GET_DST_PTR(X,Y) GET_PTR(X,Y)
#include "spantmp2.h"
} \
} while (0)
-#define TAG(x) r128##x##_16
+#define TAG(x) r128##x##_z16
#include "depthtmp.h"
} \
} while (0)
-#define TAG(x) r128##x##_24_8
+#define TAG(x) r128##x##_z24_s8
#include "depthtmp.h"
/* FIXME: Add support for hardware stencil buffers.
*/
-/*
- * This function is called to specify which buffer to read and write
- * for software rasterization (swrast) fallbacks. This doesn't necessarily
- * correspond to glDrawBuffer() or glReadBuffer() calls.
- */
-static void r128DDSetBuffer( GLcontext *ctx,
- GLframebuffer *colorBuffer,
- GLuint bufferBit )
-{
- r128ContextPtr rmesa = R128_CONTEXT(ctx);
-
- switch ( bufferBit ) {
- case BUFFER_BIT_FRONT_LEFT:
- if ( rmesa->sarea->pfCurrentPage == 1 ) {
- rmesa->drawOffset = rmesa->readOffset = rmesa->r128Screen->backOffset;
- rmesa->drawPitch = rmesa->readPitch = rmesa->r128Screen->backPitch;
- } else {
- rmesa->drawOffset = rmesa->readOffset = rmesa->r128Screen->frontOffset;
- rmesa->drawPitch = rmesa->readPitch = rmesa->r128Screen->frontPitch;
- }
- break;
- case BUFFER_BIT_BACK_LEFT:
- if ( rmesa->sarea->pfCurrentPage == 1 ) {
- rmesa->drawOffset = rmesa->readOffset = rmesa->r128Screen->frontOffset;
- rmesa->drawPitch = rmesa->readPitch = rmesa->r128Screen->frontPitch;
- } else {
- rmesa->drawOffset = rmesa->readOffset = rmesa->r128Screen->backOffset;
- rmesa->drawPitch = rmesa->readPitch = rmesa->r128Screen->backPitch;
- }
- break;
- default:
- break;
- }
-}
-
void r128SpanRenderStart( GLcontext *ctx )
{
r128ContextPtr rmesa = R128_CONTEXT(ctx);
void r128DDInitSpanFuncs( GLcontext *ctx )
{
- r128ContextPtr rmesa = R128_CONTEXT(ctx);
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = r128DDSetBuffer;
swdd->SpanRenderStart = r128SpanRenderStart;
swdd->SpanRenderFinish = r128SpanRenderFinish;
}
}
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = r128ReadDepthSpan_16;
- drb->Base.GetValues = r128ReadDepthPixels_16;
- drb->Base.PutRow = r128WriteDepthSpan_16;
- drb->Base.PutMonoRow = r128WriteMonoDepthSpan_16;
- drb->Base.PutValues = r128WriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
+ r128InitDepthPointers_z16(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
- drb->Base.GetRow = r128ReadDepthSpan_24_8;
- drb->Base.GetValues = r128ReadDepthPixels_24_8;
- drb->Base.PutRow = r128WriteDepthSpan_24_8;
- drb->Base.PutMonoRow = r128WriteMonoDepthSpan_24_8;
- drb->Base.PutValues = r128WriteDepthPixels_24_8;
- drb->Base.PutMonoValues = NULL;
- }
- else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- drb->Base.GetRow = NULL;
- drb->Base.GetValues = NULL;
- drb->Base.PutRow = NULL;
- drb->Base.PutMonoRow = NULL;
- drb->Base.PutValues = NULL;
- drb->Base.PutMonoValues = NULL;
+ r128InitDepthPointers_z24_s8(&drb->Base);
}
}
#include "tnl/t_pipeline.h"
+#include "drirenderbuffer.h"
+
/* =============================================================
* Alpha blending
* Window position
*/
-void r128UpdateWindow( GLcontext *ctx )
+static void r128UpdateWindow( GLcontext *ctx )
{
r128ContextPtr rmesa = R128_CONTEXT(ctx);
int x = rmesa->driDrawable->x;
int y = rmesa->driDrawable->y;
+ struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[0][0];
+ driRenderbuffer *drb = (driRenderbuffer *) rb;
rmesa->setup.window_xy_offset = ((y << R128_WINDOW_Y_SHIFT) |
(x << R128_WINDOW_X_SHIFT));
+ rmesa->setup.dst_pitch_offset_c = (((drb->flippedPitch/8) << 21) |
+ (drb->flippedOffset >> 5));
+
+
rmesa->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_WINDOW;
}
+
/* =============================================================
* Viewport
*/
-
static void r128CalcViewport( GLcontext *ctx )
{
r128ContextPtr rmesa = R128_CONTEXT(ctx);
break;
}
- /* We want to update the s/w rast state too so that r128DDSetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
-
- rmesa->setup.dst_pitch_offset_c = (((rmesa->drawPitch/8) << 21) |
- (rmesa->drawOffset >> 5));
rmesa->new_state |= R128_NEW_WINDOW;
}
rmesa->Fallback = 0;
- if ( rmesa->glCtx->Visual.doubleBufferMode && rmesa->sarea->pfCurrentPage == 0 ) {
- rmesa->drawOffset = rmesa->readOffset = rmesa->r128Screen->backOffset;
- rmesa->drawPitch = rmesa->readPitch = rmesa->r128Screen->backPitch;
- } else {
- rmesa->drawOffset = rmesa->readOffset = rmesa->r128Screen->frontOffset;
- rmesa->drawPitch = rmesa->readPitch = rmesa->r128Screen->frontPitch;
- }
-
- /* Harware state:
+ /* Hardware state:
*/
- rmesa->setup.dst_pitch_offset_c = (((rmesa->drawPitch/8) << 21) |
- (rmesa->drawOffset >> 5));
-
rmesa->setup.dp_gui_master_cntl_c = (R128_GMC_DST_PITCH_OFFSET_CNTL |
R128_GMC_DST_CLIPPING |
R128_GMC_BRUSH_SOLID_COLOR |
extern void r128DDUpdateState( GLcontext *ctx );
extern void r128DDUpdateHWState( GLcontext *ctx );
-extern void r128UpdateWindow( GLcontext *ctx );
-
extern void r128EmitHwStateLocked( r128ContextPtr rmesa );
#endif
void s3vGetLock( s3vContextPtr vmesa, GLuint flags );
void s3vInitExtensions( GLcontext *ctx );
void s3vInitDriverFuncs( GLcontext *ctx );
-void s3vInitSpanFuncs( GLcontext *ctx );
void s3vSetSpanFunctions(driRenderbuffer *rb, const GLvisual *vis);
void s3vInitState( s3vContextPtr vmesa );
void s3vInitHW( s3vContextPtr vmesa );
#define DBG 0
#define LOCAL_VARS \
- s3vContextPtr vmesa = S3V_CONTEXT(ctx); \
- s3vScreenPtr s3vscrn = vmesa->s3vScreen; \
- __DRIscreenPrivate *sPriv = vmesa->driScreen; \
- __DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
- GLuint pitch = ( (vmesa->Flags & S3V_BACK_BUFFER) ? \
- ((dPriv->w+31)&~31) * s3vscrn->cpp \
- : sPriv->fbWidth * s3vscrn->cpp); \
- GLuint height = dPriv->h; \
- char *buf = ( (vmesa->Flags & S3V_BACK_BUFFER) ? \
- (char *)(sPriv->pFB + vmesa->drawOffset) \
- : (char *)(sPriv->pFB + vmesa->drawOffset \
- + dPriv->x * s3vscrn->cpp + dPriv->y * pitch) ); \
- char *read_buf = ( (vmesa->Flags & S3V_BACK_BUFFER) ? \
- (char *)(sPriv->pFB + vmesa->drawOffset) \
- : (char *)(sPriv->pFB + vmesa->drawOffset \
- + dPriv->x * s3vscrn->cpp + dPriv->y * pitch) ); \
+ s3vContextPtr vmesa = S3V_CONTEXT(ctx); \
+ __DRIscreenPrivate *sPriv = vmesa->driScreen; \
+ __DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint cpp = drb->cpp; \
+ GLuint pitch = ( (drb->backBuffer) ? \
+ ((dPriv->w+31)&~31) * cpp \
+ : sPriv->fbWidth * cpp); \
+ GLuint height = dPriv->h; \
+ char *buf = (char *)(sPriv->pFB + drb->offset \
+ + (drb->backBuffer ? 0 : dPriv->x * cpp + dPriv->y * pitch));\
+ char *read_buf = buf; \
GLuint p; \
(void) read_buf; (void) buf; (void) p; (void) pitch
/* FIXME! Depth/Stencil read/writes don't work ! */
-#define LOCAL_DEPTH_VARS \
- s3vScreenPtr s3vscrn = vmesa->s3vScreen; \
- __DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
- __DRIscreenPrivate *sPriv = vmesa->driScreen; \
- GLuint pitch = s3vscrn->depthPitch; \
- GLuint height = dPriv->h; \
- char *buf = (char *)(sPriv->pFB + \
- s3vscrn->depthOffset); /* + \
- dPriv->x * s3vscrn->cpp + \
- dPriv->y * pitch)*/ \
+#define LOCAL_DEPTH_VARS \
+ __DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
+ __DRIscreenPrivate *sPriv = vmesa->driScreen; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint pitch = drb->pitch; \
+ GLuint height = dPriv->h; \
+ char *buf = (char *)(sPriv->pFB + drb->offset); \
(void) pitch
#define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS
*(GLushort *)(buf + _x*2 + _y*pitch) = ((((int)r & 0xf8) << 7) | \
(((int)g & 0xf8) << 2) | \
(((int)b & 0xf8) >> 3)); \
- DEBUG(("buf=0x%x drawOffset=0x%x dPriv->x=%i s3vscrn->cpp=%i dPriv->y=%i pitch=%i\n", \
- sPriv->pFB, vmesa->drawOffset, dPriv->x, s3vscrn->cpp, dPriv->y, pitch)); \
+ DEBUG(("buf=0x%x drawOffset=0x%x dPriv->x=%i drb->cpp=%i dPriv->y=%i pitch=%i\n", \
+ sPriv->pFB, vmesa->drawOffset, dPriv->x, drb->cpp, dPriv->y, pitch)); \
DEBUG(("dPriv->w = %i\n", dPriv->w)); \
} while(0)
#define READ_DEPTH( d, _x, _y ) \
d = *(GLushort *)(buf + _x*2 + _y*dPriv->w*2);
-#define TAG(x) s3v##x##_16
+#define TAG(x) s3v##x##_z16
#include "depthtmp.h"
#endif
-static void s3vSetBuffer( GLcontext *ctx, GLframebuffer *colorBuffer,
- GLuint bufferBit )
-{
- s3vContextPtr vmesa = S3V_CONTEXT(ctx);
-
- switch ( bufferBit ) {
- case BUFFER_BIT_FRONT_LEFT:
- vmesa->drawOffset = vmesa->readOffset = 0;
- break;
- case BUFFER_BIT_BACK_LEFT:
- vmesa->drawOffset = vmesa->readOffset = vmesa->driScreen->fbHeight *
- vmesa->driScreen->fbWidth *
- vmesa->s3vScreen->cpp;
- break;
- }
-}
-
-
-void s3vInitSpanFuncs( GLcontext *ctx )
-{
- s3vContextPtr vmesa = S3V_CONTEXT(ctx);
- struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = s3vSetBuffer;
-
-#if 0
- switch ( vmesa->s3vScreen->cpp ) {
- case 2:
- swdd->WriteRGBASpan = s3vWriteRGBASpan_RGB555;
- swdd->WriteRGBSpan = s3vWriteRGBSpan_RGB555;
- swdd->WriteMonoRGBASpan = s3vWriteMonoRGBASpan_RGB555;
- swdd->WriteRGBAPixels = s3vWriteRGBAPixels_RGB555;
- swdd->WriteMonoRGBAPixels = s3vWriteMonoRGBAPixels_RGB555;
- swdd->ReadRGBASpan = s3vReadRGBASpan_RGB555;
- swdd->ReadRGBAPixels = s3vReadRGBAPixels_RGB555;
- break;
-
- case 4:
- swdd->WriteRGBASpan = s3vWriteRGBASpan_ARGB8888;
- swdd->WriteRGBSpan = s3vWriteRGBSpan_ARGB8888;
- swdd->WriteMonoRGBASpan = s3vWriteMonoRGBASpan_ARGB8888;
- swdd->WriteRGBAPixels = s3vWriteRGBAPixels_ARGB8888;
- swdd->WriteMonoRGBAPixels = s3vWriteMonoRGBAPixels_ARGB8888;
-#if 1
- swdd->ReadRGBASpan = s3vReadRGBASpan_ARGB8888;
-#else
- swdd->ReadRGBASpan = s3vReadRGBASpan8888;
-#endif
- swdd->ReadRGBAPixels = s3vReadRGBAPixels_ARGB8888;
- break;
-
- default:
- break;
- }
-#endif
-
- switch ( vmesa->glCtx->Visual.depthBits ) {
- case 15:
- case 16:
-#if 0
- swdd->ReadDepthSpan = s3vReadDepthSpan_16;
- swdd->WriteDepthSpan = s3vWriteDepthSpan_16;
- swdd->ReadDepthPixels = s3vReadDepthPixels_16;
- swdd->WriteDepthPixels = s3vWriteDepthPixels_16;
-#endif
- break;
-
-#if 0
- case 24:
- swdd->ReadDepthSpan = s3vReadDepthSpan_24_8;
- swdd->WriteDepthSpan = s3vWriteDepthSpan_24_8;
- swdd->ReadDepthPixels = s3vReadDepthPixels_24_8;
- swdd->WriteDepthPixels = s3vWriteDepthPixels_24_8;
-
- swdd->ReadStencilSpan = s3vReadStencilSpan_24_8;
- swdd->WriteStencilSpan = s3vWriteStencilSpan_24_8;
- swdd->ReadStencilPixels = s3vReadStencilPixels_24_8;
- swdd->WriteStencilPixels = s3vWriteStencilPixels_24_8;
- break;
-#endif
-
- default:
- break;
- }
-}
-
/**
* Plug in the Get/Put routines for the given driRenderbuffer.
}
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = s3vReadDepthSpan_16;
- drb->Base.GetValues = s3vReadDepthPixels_16;
- drb->Base.PutRow = s3vWriteDepthSpan_16;
- drb->Base.PutMonoRow = s3vWriteMonoDepthSpan_16;
- drb->Base.PutValues = s3vWriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
+ s3vInitDepthPointers_z16(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
- drb->Base.GetRow = NULL;
- drb->Base.GetValues = NULL;
- drb->Base.PutRow = NULL;
- drb->Base.PutMonoRow = NULL;
- drb->Base.PutValues = NULL;
- drb->Base.PutMonoValues = NULL;
+ /* not done yet */
}
else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- drb->Base.GetRow = NULL;
- drb->Base.GetValues = NULL;
- drb->Base.PutRow = NULL;
- drb->Base.PutMonoRow = NULL;
- drb->Base.PutValues = NULL;
- drb->Base.PutMonoValues = NULL;
+ /* not done yet */
}
}
screen->backOffset, screen->backPitch);
s3vSetSpanFunctions(backRb, mesaVis);
_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base);
+ backRb->backBuffer = GL_TRUE;
}
if (mesaVis->depthBits == 16) {
screen->frontOffset, screen->aperturePitch);
savageSetSpanFunctions(frontRb, mesaVis, float_depth);
_mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontRb->Base);
+ frontRb->Base.Data = frontRb->flippedData
+ = (GLubyte *) screen->aperture.map + 0x01000000 * TARGET_FRONT;
}
if (mesaVis->doubleBufferMode) {
screen->backOffset, screen->aperturePitch);
savageSetSpanFunctions(backRb, mesaVis, float_depth);
_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base);
+ backRb->Base.Data = backRb->flippedData
+ = (GLubyte *) screen->aperture.map + 0x01000000 * TARGET_BACK;
}
if (mesaVis->depthBits == 16) {
driRenderbuffer *depthRb
- = driNewRenderbuffer(GL_DEPTH_COMPONENT16, screen->cpp,
+ = driNewRenderbuffer(GL_DEPTH_COMPONENT16, screen->zpp,
screen->depthOffset, screen->aperturePitch);
savageSetSpanFunctions(depthRb, mesaVis, float_depth);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
+ depthRb->Base.Data = depthRb->flippedData
+ = (GLubyte *) screen->aperture.map + 0x01000000 * TARGET_DEPTH;
}
else if (mesaVis->depthBits == 24) {
driRenderbuffer *depthRb
- = driNewRenderbuffer(GL_DEPTH_COMPONENT24, screen->cpp,
+ = driNewRenderbuffer(GL_DEPTH_COMPONENT24, screen->zpp,
screen->depthOffset, screen->aperturePitch);
savageSetSpanFunctions(depthRb, mesaVis, float_depth);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
+ depthRb->Base.Data = depthRb->flippedData
+ = (GLubyte *) screen->aperture.map + 0x01000000 * TARGET_DEPTH;
}
if (mesaVis->stencilBits > 0 && !swStencil) {
driRenderbuffer *stencilRb
- = driNewRenderbuffer(GL_STENCIL_INDEX8_EXT, screen->cpp,
+ = driNewRenderbuffer(GL_STENCIL_INDEX8_EXT, screen->zpp,
screen->depthOffset, screen->aperturePitch);
savageSetSpanFunctions(stencilRb, mesaVis, float_depth);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, &stencilRb->Base);
__DRIdrawablePrivate *driReadPriv)
{
if (driContextPriv) {
- savageContextPtr imesa = (savageContextPtr) driContextPriv->driverPrivate;
-
+ savageContextPtr imesa
+ = (savageContextPtr) driContextPriv->driverPrivate;
+ struct gl_framebuffer *drawBuffer
+ = (GLframebuffer *) driDrawPriv->driverPrivate;
+ struct gl_framebuffer *readBuffer
+ = (GLframebuffer *) driReadPriv->driverPrivate;
+ driRenderbuffer *frontRb = (driRenderbuffer *)
+ drawBuffer->Attachment[BUFFER_FRONT_LEFT].Renderbuffer;
+ driRenderbuffer *backRb = (driRenderbuffer *)
+ drawBuffer->Attachment[BUFFER_BACK_LEFT].Renderbuffer;
+
+ assert(frontRb->Base.Data);
+ assert(backRb->Base.Data);
+
imesa->driReadable = driReadPriv;
imesa->driDrawable = driDrawPriv;
- imesa->mesa_drawable = driDrawPriv;
imesa->dirty = ~0;
- _mesa_make_current(imesa->glCtx,
- (GLframebuffer *) driDrawPriv->driverPrivate,
- (GLframebuffer *) driReadPriv->driverPrivate);
+ _mesa_make_current(imesa->glCtx, drawBuffer, readBuffer);
savageXMesaWindowMoved( imesa );
}
/* These refer to the current draw (front vs. back) buffer:
*/
- GLubyte *drawMap; /* draw buffer address in virtual mem */
- GLubyte *readMap;
int drawX; /* origin of drawable in draw buffer */
int drawY;
GLuint numClipRects; /* cliprects for that buffer */
__DRIdrawablePrivate *driDrawable;
__DRIdrawablePrivate *driReadable;
- /**
- * Drawable used by Mesa for software fallbacks for reading and
- * writing. It is set by Mesa's \c SetBuffer callback, and will always be
- * either \c mga_context_t::driDrawable or \c mga_context_t::driReadable.
- */
- __DRIdrawablePrivate *mesa_drawable;
-
__DRIscreenPrivate *driScreen;
savageScreenPrivate *savageScreen;
drm_savage_sarea_t *sarea;
else
imesa->toggle = TARGET_BACK;
- imesa->drawMap = (char *)imesa->apertureBase[imesa->toggle];
- imesa->readMap = (char *)imesa->apertureBase[imesa->toggle];
-
+ driFlipRenderbuffers(imesa->glCtx->DrawBuffer,
+ imesa->toggle != TARGET_FRONT);
+
imesa->regs.s4.destCtrl.ni.offset = imesa->savageScreen->backOffset>>11;
imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
bciptr = SAVAGE_GET_BCI_POINTER(imesa,3);
#define DBG 0
-#define LOCAL_VARS \
- savageContextPtr imesa = SAVAGE_CONTEXT(ctx); \
- __DRIdrawablePrivate *dPriv = imesa->mesa_drawable; \
- savageScreenPrivate *savageScreen = imesa->savageScreen; \
- GLuint cpp = savageScreen->cpp; \
- GLuint pitch = imesa->aperturePitch; \
- GLuint height = dPriv->h; \
- GLubyte *buf = map + \
- dPriv->x * cpp + \
- dPriv->y * pitch; \
- GLubyte *read_buf = buf; \
- GLuint p; \
+#define LOCAL_VARS \
+ savageContextPtr imesa = SAVAGE_CONTEXT(ctx); \
+ __DRIdrawablePrivate *dPriv = imesa->driDrawable; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint cpp = drb->cpp; \
+ GLuint pitch = drb->pitch; \
+ GLuint height = dPriv->h; \
+ GLubyte *buf = drb->Base.Data + dPriv->x * cpp + dPriv->y * pitch; \
+ GLubyte *read_buf = buf; \
+ GLuint p; \
(void) p; (void) read_buf;
-#define LOCAL_DEPTH_VARS \
- savageContextPtr imesa = SAVAGE_CONTEXT(ctx); \
- __DRIdrawablePrivate *dPriv = imesa->mesa_drawable; \
- savageScreenPrivate *savageScreen = imesa->savageScreen; \
- GLuint zpp = savageScreen->zpp; \
- GLuint pitch = imesa->aperturePitch; \
- GLuint height = dPriv->h; \
- GLubyte *buf = imesa->apertureBase[TARGET_DEPTH] + \
- dPriv->x * zpp + \
- dPriv->y * pitch
+#define LOCAL_DEPTH_VARS \
+ savageContextPtr imesa = SAVAGE_CONTEXT(ctx); \
+ __DRIdrawablePrivate *dPriv = imesa->driDrawable; \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint zpp = drb->cpp; \
+ GLuint pitch = drb->pitch; \
+ GLuint height = dPriv->h; \
+ GLubyte *buf = drb->Base.Data + dPriv->x * zpp + dPriv->y * pitch;
#define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS
#define HW_UNLOCK()
-#define HW_WRITE_LOCK() \
- savageContextPtr imesa = SAVAGE_CONTEXT(ctx); \
- GLubyte *map = imesa->drawMap;
+#define HW_WRITE_LOCK()
-#define HW_READ_LOCK() \
- savageContextPtr imesa = SAVAGE_CONTEXT(ctx); \
- GLubyte *map = imesa->readMap;
+#define HW_READ_LOCK()
/* 16 bit, 565 rgb color spanline and pixel functions
#define READ_DEPTH( d, _x, _y ) \
d = 0xFFFF - *(GLushort *)(buf + ((_x)<<1) + (_y)*pitch)
-#define TAG(x) savage##x##_16
+#define TAG(x) savage##x##_z16
#include "depthtmp.h"
savageDecodeFloat16( *(GLushort *)(buf + ((_x)<<1) + (_y)*pitch) ) * \
65535.0
-#define TAG(x) savage##x##_16f
+#define TAG(x) savage##x##_z16f
#include "depthtmp.h"
#define READ_DEPTH( d, _x, _y ) \
d = 0x00FFFFFF - (*(GLuint *)(buf + ((_x)<<2) + (_y)*pitch) & 0x00FFFFFF)
-#define TAG(x) savage##x##_8_24
+#define TAG(x) savage##x##_s8_z24
#include "depthtmp.h"
*(GLuint *)(buf + ((_x)<<2) + (_y)*pitch) & 0x00FFFFFF) \
* 16777215.0
-#define TAG(x) savage##x##_8_24f
+#define TAG(x) savage##x##_s8_z24f
#include "depthtmp.h"
#define READ_STENCIL( d, _x, _y ) \
d = (GLstencil)((*(GLuint *)(buf + ((_x)<<2) + (_y)*pitch) & 0xFF000000) >> 24)
-#define TAG(x) savage##x##_8_24
+#define TAG(x) savage##x##_s8_z24
#include "stenciltmp.h"
-/*
- * This function is called to specify which buffer to read and write
- * for software rasterization (swrast) fallbacks. This doesn't necessarily
- * correspond to glDrawBuffer() or glReadBuffer() calls.
- */
-static void savageDDSetBuffer(GLcontext *ctx, GLframebuffer *buffer,
- GLuint bufferBit)
-{
- savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
- GLubyte *map;
-
- assert((bufferBit == BUFFER_BIT_FRONT_LEFT) || (bufferBit == BUFFER_BIT_BACK_LEFT));
-
- map = (bufferBit == BUFFER_BIT_FRONT_LEFT)
- ? imesa->apertureBase[TARGET_FRONT]
- : imesa->apertureBase[TARGET_BACK];
-
- imesa->drawMap = map;
- imesa->readMap = map;
-
- assert( (buffer == imesa->driDrawable->driverPrivate)
- || (buffer == imesa->driReadable->driverPrivate) );
-
- imesa->mesa_drawable = (buffer == imesa->driDrawable->driverPrivate)
- ? imesa->driDrawable : imesa->driReadable;
-}
/*
* Wrappers around _swrast_Copy/Draw/ReadPixels that make sure all
void savageDDInitSpanFuncs( GLcontext *ctx )
{
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = savageDDSetBuffer;
swdd->SpanRenderStart = savageSpanRenderStart;
/* Pixel path fallbacks.
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
if (float_depth) {
- drb->Base.GetRow = savageReadDepthSpan_16f;
- drb->Base.GetValues = savageReadDepthPixels_16f;
- drb->Base.PutRow = savageWriteDepthSpan_16f;
- drb->Base.PutMonoRow = savageWriteMonoDepthSpan_16f;
- drb->Base.PutValues = savageWriteDepthPixels_16f;
+ savageInitDepthPointers_z16f(&drb->Base);
}
else {
- drb->Base.GetRow = savageReadDepthSpan_16;
- drb->Base.GetValues = savageReadDepthPixels_16;
- drb->Base.PutRow = savageWriteDepthSpan_16;
- drb->Base.PutMonoRow = savageWriteMonoDepthSpan_16;
- drb->Base.PutValues = savageWriteDepthPixels_16;
+ savageInitDepthPointers_z16(&drb->Base);
}
- drb->Base.PutMonoValues = NULL;
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
if (float_depth) {
- drb->Base.GetRow = savageReadDepthSpan_8_24f;
- drb->Base.GetValues = savageReadDepthPixels_8_24f;
- drb->Base.PutRow = savageWriteDepthSpan_8_24f;
- drb->Base.PutMonoRow = savageWriteMonoDepthSpan_8_24f;
- drb->Base.PutValues = savageWriteDepthPixels_8_24f;
+ savageInitDepthPointers_s8_z24f(&drb->Base);
}
else {
- drb->Base.GetRow = savageReadDepthSpan_8_24;
- drb->Base.GetValues = savageReadDepthPixels_8_24;
- drb->Base.PutRow = savageWriteDepthSpan_8_24;
- drb->Base.PutMonoRow = savageWriteMonoDepthSpan_8_24;
- drb->Base.PutValues = savageWriteDepthPixels_8_24;
+ savageInitDepthPointers_s8_z24(&drb->Base);
}
- drb->Base.PutMonoValues = NULL;
}
else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- drb->Base.GetRow = savageReadStencilSpan_8_24;
- drb->Base.GetValues = savageReadStencilPixels_8_24;
- drb->Base.PutRow = savageWriteStencilSpan_8_24;
- drb->Base.PutMonoRow = savageWriteMonoStencilSpan_8_24;
- drb->Base.PutValues = savageWriteStencilPixels_8_24;
- drb->Base.PutMonoValues = NULL;
+ savageInitStencilPointers_s8_z24(&drb->Base);
}
}
return;
}
- /* We want to update the s/w rast state too so that r200SetBuffer() (?)
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
-
if (destCtrl != imesa->regs.s4.destCtrl.ui)
imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
}
imesa->regs.s4.destCtrl.ni.dstWidthInTile =
(imesa->savageScreen->width+31)>>5;
}
- imesa->drawMap = imesa->apertureBase[imesa->toggle];
- imesa->readMap = imesa->apertureBase[imesa->toggle];
imesa->NotFirstFrame = GL_FALSE;
imesa->regs.s4.zBufOffset.ni.offset=imesa->savageScreen->depthOffset>>11;
/* Drawable, cliprect and scissor information
*/
GLint drawOffset, drawPitch;
- GLint readOffset, readPitch;
/* Mirrors of some DRI state
*/
if (isPixmap)
return GL_FALSE; /* not implemented */
-#if 0
- driDrawPriv->driverPrivate = (void *)_mesa_create_framebuffer(
- mesaVis,
- GL_FALSE, /* software depth buffer? */
- mesaVis->stencilBits > 0,
- mesaVis->accumRedBits > 0,
- mesaVis->alphaBits > 0 ); /* XXX */
-#else
+ {
struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
/* XXX double-check the Offset/Pitch parameters! */
GL_FALSE, /* alpha */
GL_FALSE /* aux */);
driDrawPriv->driverPrivate = (void *) fb;
-#endif
+ }
return (driDrawPriv->driverPrivate != NULL);
}
#define LOCAL_VARS \
sisContextPtr smesa = SIS_CONTEXT(ctx); \
__DRIdrawablePrivate *dPriv = smesa->driDrawable; \
- GLuint pitch = smesa->drawPitch; \
- char *buf = (char *)(smesa->FbBase + smesa->drawOffset); \
- char *read_buf = (char *)(smesa->FbBase + smesa->readOffset); \
+ driRenderbuffer *drb = (driRenderbuffer *) rb; \
+ GLuint pitch = drb->pitch; \
+ char *buf = (char *)(smesa->FbBase + drb->offset); \
+ char *read_buf = buf; \
GLuint p; \
(void) read_buf; (void) buf; (void) p
#define READ_DEPTH( d, _x, _y ) \
d = *(GLushort *)(buf + (_x)*2 + (_y)*smesa->depthPitch);
-#define TAG(x) sis##x##_16
+#define TAG(x) sis##x##_z16
#include "depthtmp.h"
#define READ_DEPTH( d, _x, _y ) \
d = *(GLuint *)(buf + (_x)*4 + (_y)*smesa->depthPitch);
-#define TAG(x) sis##x##_32
+#define TAG(x) sis##x##_z32
#include "depthtmp.h"
d = *(GLuint *)(buf + (_x)*4 + (_y)*smesa->depthPitch) & 0x00ffffff; \
}
-#define TAG(x) sis##x##_24_8
+#define TAG(x) sis##x##_z24_s8
#include "depthtmp.h"
#define WRITE_STENCIL( _x, _y, d ) { \
#define READ_STENCIL( d, _x, _y ) \
d = (*(GLuint *)(buf + (_x)*4 + (_y)*smesa->depthPitch) & 0xff000000) >> 24;
-#define TAG(x) sis##x##_24_8
+#define TAG(x) sis##x##_z24_s8
#include "stenciltmp.h"
-/*
- * This function is called to specify which buffer to read and write
- * for software rasterization (swrast) fallbacks. This doesn't necessarily
- * correspond to glDrawBuffer() or glReadBuffer() calls.
- */
-static void sisDDSetBuffer( GLcontext *ctx,
- GLframebuffer *colorBuffer,
- GLuint bufferBit )
-{
- sisContextPtr smesa = SIS_CONTEXT(ctx);
- switch ( bufferBit ) {
- case BUFFER_BIT_FRONT_LEFT:
- smesa->drawOffset = smesa->readOffset = smesa->frontOffset;
- smesa->drawPitch = smesa->readPitch = smesa->frontPitch;
- break;
- case BUFFER_BIT_BACK_LEFT:
- smesa->drawOffset = smesa->readOffset = smesa->backOffset;
- smesa->drawPitch = smesa->readPitch = smesa->backPitch;
- break;
- default:
- break;
- }
-}
void sisSpanRenderStart( GLcontext *ctx )
{
sisDDInitSpanFuncs( GLcontext *ctx )
{
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = sisDDSetBuffer;
swdd->SpanRenderStart = sisSpanRenderStart;
swdd->SpanRenderFinish = sisSpanRenderFinish;
}
}
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = sisReadDepthSpan_16;
- drb->Base.GetValues = sisReadDepthPixels_16;
- drb->Base.PutRow = sisWriteDepthSpan_16;
- drb->Base.PutMonoRow = sisWriteMonoDepthSpan_16;
- drb->Base.PutValues = sisWriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
+ sisInitDepthPointers_z16(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
- drb->Base.GetRow = sisReadDepthSpan_24_8;
- drb->Base.GetValues = sisReadDepthPixels_24_8;
- drb->Base.PutRow = sisWriteDepthSpan_24_8;
- drb->Base.PutMonoRow = sisWriteMonoDepthSpan_24_8;
- drb->Base.PutValues = sisWriteDepthPixels_24_8;
- drb->Base.PutMonoValues = NULL;
+ sisInitDepthPointers_z24_s8(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT32) {
- drb->Base.GetRow = sisReadDepthSpan_32;
- drb->Base.GetValues = sisReadDepthPixels_32;
- drb->Base.PutRow = sisWriteDepthSpan_32;
- drb->Base.PutMonoRow = sisWriteMonoDepthSpan_32;
- drb->Base.PutValues = sisWriteDepthPixels_32;
- drb->Base.PutMonoValues = NULL;
+ sisInitDepthPointers_z32(&drb->Base);
}
else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- drb->Base.GetRow = sisReadStencilSpan_24_8;
- drb->Base.GetValues = sisReadStencilPixels_24_8;
- drb->Base.PutRow = sisWriteStencilSpan_24_8;
- drb->Base.PutMonoRow = sisWriteMonoStencilSpan_24_8;
- drb->Base.PutValues = sisWriteStencilPixels_24_8;
- drb->Base.PutMonoValues = NULL;
+ sisInitStencilPointers_z24_s8(&drb->Base);
}
}
void sisDDDrawBuffer( GLcontext *ctx, GLenum mode )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
-
__GLSiSHardware *prev = &smesa->prev;
__GLSiSHardware *current = &smesa->current;
+ int pitch;
/*
* _DrawDestMask is easier to cope with than <mode>.
*/
switch ( ctx->DrawBuffer->_ColorDrawBufferMask[0] ) {
case BUFFER_BIT_FRONT_LEFT:
+ FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );
+ pitch = smesa->frontPitch;
+ break;
case BUFFER_BIT_BACK_LEFT:
FALLBACK( smesa, SIS_FALLBACK_DRAW_BUFFER, GL_FALSE );
+ pitch = smesa->backPitch;
break;
default:
/* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
return;
}
- /* We want to update the s/w rast state too so that sisDDSetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
-
current->hwOffsetDest = (smesa->drawOffset) >> 1;
current->hwDstSet &= ~MASK_DstBufferPitch;
- current->hwDstSet |= smesa->drawPitch >> 2;
+ current->hwDstSet |= pitch >> 2;
if (current->hwDstSet != prev->hwDstSet) {
prev->hwDstSet = current->hwDstSet;
#define LOCAL_VARS \
__DRIdrawablePrivate *dPriv = fxMesa->driDrawable; \
tdfxScreenPrivate *fxPriv = fxMesa->fxScreen; \
- GLuint pitch = (fxMesa->glCtx->Color.DrawBuffer[0] == GL_FRONT) \
- ? (fxMesa->screen_width * BYTESPERPIXEL) : \
- (info.strideInBytes); \
+ GLboolean isFront = (ctx->DrawBuffer->_ColorDrawBufferMask[0] \
+ == BUFFER_BIT_FRONT_LEFT); \
+ GLuint pitch = isFront ? (fxMesa->screen_width * BYTESPERPIXEL) \
+ : info.strideInBytes; \
GLuint height = fxMesa->height; \
char *buf = (char *)((char *)info.lfbPtr + \
dPriv->x * fxPriv->cpp + \
UNLOCK_HARDWARE(fxMesa);
}
-/* Set the buffer used for reading */
-static void tdfxDDSetBuffer( GLcontext *ctx,
- GLframebuffer *buffer, GLuint bufferBit )
-{
- tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
- (void) buffer;
-
- switch ( bufferBit ) {
- case BUFFER_BIT_FRONT_LEFT:
- fxMesa->DrawBuffer = fxMesa->ReadBuffer = GR_BUFFER_FRONTBUFFER;
- break;
- case BUFFER_BIT_BACK_LEFT:
- fxMesa->DrawBuffer = fxMesa->ReadBuffer = GR_BUFFER_BACKBUFFER;
- break;
- default:
- break;
- }
-}
-
/**********************************************************************/
/* Initialize swrast device driver */
/**********************************************************************/
void tdfxDDInitSpanFuncs( GLcontext *ctx )
{
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
- swdd->SetBuffer = tdfxDDSetBuffer;
swdd->SpanRenderStart = tdfxSpanRenderStart;
swdd->SpanRenderFinish = tdfxSpanRenderFinish;
}
FALLBACK( fxMesa, TDFX_FALLBACK_DRAW_BUFFER, GL_TRUE );
break;
}
-
- /* We want to update the s/w rast state too so that tdfxDDSetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
}
#include "simple_list.h"
#include "extensions.h"
#include "framebuffer.h"
+#include "renderbuffer.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
}
+static void
+nop_delete_renderbuffer(struct gl_renderbuffer *rb)
+{
+ /* Don't free() since we're contained in via_context struct. */
+}
+
+
+static void
+viaInitRenderbuffer(struct gl_renderbuffer *rb, GLenum format)
+{
+ const GLuint name = 0;
+
+ _mesa_init_renderbuffer(rb, name);
+
+ /* Make sure we're using a null-valued GetPointer routine */
+ assert(rb->GetPointer(NULL, rb, 0, 0) == NULL);
+
+ rb->InternalFormat = format;
+
+ if (format == GL_RGBA) {
+ /* Color */
+ rb->_BaseFormat = GL_RGBA;
+ rb->DataType = GL_UNSIGNED_BYTE;
+ }
+ else if (format == GL_DEPTH_COMPONENT16) {
+ /* Depth */
+ rb->_BaseFormat = GL_DEPTH_COMPONENT;
+ /* we always Get/Put 32-bit Z values */
+ rb->DataType = GL_UNSIGNED_INT;
+ }
+ else if (format == GL_DEPTH_COMPONENT24) {
+ /* Depth */
+ rb->_BaseFormat = GL_DEPTH_COMPONENT;
+ /* we always Get/Put 32-bit Z values */
+ rb->DataType = GL_UNSIGNED_INT;
+ }
+ else {
+ /* Stencil */
+ ASSERT(format == GL_STENCIL_INDEX8);
+ rb->_BaseFormat = GL_STENCIL_INDEX;
+ rb->DataType = GL_UNSIGNED_BYTE;
+ }
+
+ rb->Delete = nop_delete_renderbuffer;
+}
+
+
/**
* Calculate the framebuffer parameters for all buffers (front, back, depth,
* and stencil) associated with the specified context.
* \sa AllocateBuffer
*/
static GLboolean
-calculate_buffer_parameters( struct via_context *vmesa )
+calculate_buffer_parameters( struct via_context *vmesa,
+ struct gl_framebuffer *fb )
{
const unsigned shift = vmesa->viaScreen->bitsPerPixel / 16;
const unsigned extra = 32;
unsigned w;
unsigned h;
+ /* Normally, the renderbuffer would be added to the framebuffer just once
+ * when the framebuffer was created. The VIA driver is a bit funny
+ * though in that the front/back/depth renderbuffers are in the per-context
+ * state!
+ * That should be fixed someday.
+ */
+ _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &vmesa->front.Base);
+ _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &vmesa->back.Base);
+ _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &vmesa->depth.Base);
+ _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &vmesa->stencil.Base);
+
+ if (!vmesa->front.Base.InternalFormat) {
+ /* do one-time init for the renderbuffers */
+ viaInitRenderbuffer(&vmesa->front.Base, GL_RGBA);
+ viaInitRenderbuffer(&vmesa->back.Base, GL_RGBA);
+ if (vmesa->glCtx->Visual.depthBits > 0) {
+ viaInitRenderbuffer(&vmesa->depth.Base,
+ (vmesa->glCtx->Visual.depthBits == 16
+ ? GL_DEPTH_COMPONENT16 : GL_DEPTH_COMPONENT24));
+ }
+ if (vmesa->glCtx->Visual.stencilBits > 0) {
+ viaInitRenderbuffer(&vmesa->stencil.Base, GL_STENCIL_INDEX8_EXT);
+ }
+ }
+
+
/* Allocate front-buffer */
if (vmesa->drawType == GLX_PBUFFER_BIT) {
w = vmesa->driDrawable->w;
h = vmesa->driDrawable->h;
vmesa->front.bpp = vmesa->viaScreen->bitsPerPixel;
- vmesa->front.pitch = buffer_align( w ) << shift;
+ vmesa->front.pitch = buffer_align( w ) << shift; /* bytes, not pixels */
vmesa->front.size = vmesa->front.pitch * h;
if (vmesa->front.map)
h = vmesa->viaScreen->height;
vmesa->front.bpp = vmesa->viaScreen->bitsPerPixel;
- vmesa->front.pitch = buffer_align( w ) << shift;
+ vmesa->front.pitch = buffer_align( w ) << shift; /* bytes, not pixels */
vmesa->front.size = vmesa->front.pitch * h;
if (getenv("ALTERNATE_SCREEN"))
vmesa->front.offset = vmesa->front.size;
(void) memset( & vmesa->depth, 0, sizeof( vmesa->depth ) );
}
+ /* stencil buffer is same as depth buffer */
+ vmesa->stencil.handle = vmesa->depth.handle;
+ vmesa->stencil.size = vmesa->depth.size;
+ vmesa->stencil.offset = vmesa->depth.offset;
+ vmesa->stencil.index = vmesa->depth.index;
+ vmesa->stencil.pitch = vmesa->depth.pitch;
+ vmesa->stencil.bpp = vmesa->depth.bpp;
+ vmesa->stencil.map = vmesa->depth.map;
+ vmesa->stencil.orig = vmesa->depth.orig;
+ vmesa->stencil.origMap = vmesa->depth.origMap;
+
if( vmesa->viaScreen->width == vmesa->driDrawable->w &&
vmesa->viaScreen->height == vmesa->driDrawable->h ) {
vmesa->doPageFlip = vmesa->allowPageFlip;
_mesa_resize_framebuffer(ctx, drawbuffer, width, height);
#endif
- calculate_buffer_parameters( vmesa );
+ calculate_buffer_parameters( vmesa, drawbuffer );
}
static void viaBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height)
if (vmesa->drawW != dPriv->w ||
vmesa->drawH != dPriv->h)
- calculate_buffer_parameters( vmesa );
+ calculate_buffer_parameters( vmesa, vmesa->glCtx->DrawBuffer );
vmesa->drawXoff = (GLuint)(((dPriv->x * bytePerPixel) & 0x1f) /
bytePerPixel);
struct via_context *vmesa =
(struct via_context *)driContextPriv->driverPrivate;
GLcontext *ctx = vmesa->glCtx;
+ struct gl_framebuffer *drawBuffer, *readBuffer;
+
+ drawBuffer = (GLframebuffer *)driDrawPriv->driverPrivate;
+ readBuffer = (GLframebuffer *)driReadPriv->driverPrivate;
if ( vmesa->driDrawable != driDrawPriv ) {
driDrawableInitVBlank( driDrawPriv, vmesa->vblank_flags );
vmesa->driDrawable = driDrawPriv;
- if ( ! calculate_buffer_parameters( vmesa ) ) {
+ if ( ! calculate_buffer_parameters( vmesa, drawBuffer ) ) {
return GL_FALSE;
}
}
- _mesa_make_current(vmesa->glCtx,
- (GLframebuffer *)driDrawPriv->driverPrivate,
- (GLframebuffer *)driReadPriv->driverPrivate);
-
+ _mesa_make_current(vmesa->glCtx, drawBuffer, readBuffer);
ctx->Driver.DrawBuffer( ctx, ctx->Color.DrawBuffer[0] );
typedef void (*via_line_func)(struct via_context *, viaVertex *, viaVertex *);
typedef void (*via_point_func)(struct via_context *, viaVertex *);
-struct via_buffer {
+/**
+ * Derived from gl_renderbuffer.
+ */
+struct via_renderbuffer {
+ struct gl_renderbuffer Base; /* must be first! */
drm_handle_t handle;
drmSize size;
GLuint offset;
GLcontext *glCtx;
GLcontext *shareCtx;
- struct via_buffer front;
- struct via_buffer back;
- struct via_buffer depth;
- struct via_buffer breadcrumb;
+ /* XXX These don't belong here. They should be per-drawable state. */
+ struct via_renderbuffer front;
+ struct via_renderbuffer back;
+ struct via_renderbuffer depth;
+ struct via_renderbuffer stencil; /* mirrors depth */
+ struct via_renderbuffer breadcrumb;
GLboolean hasBack;
GLboolean hasDepth;
*/
GLboolean doPageFlip;
- struct via_buffer *drawBuffer;
- struct via_buffer *readBuffer;
+ struct via_renderbuffer *drawBuffer;
int drawX; /* origin of drawable in draw buffer */
int drawY;
#include <sys/ioctl.h>
GLboolean
-via_alloc_draw_buffer(struct via_context *vmesa, struct via_buffer *buf)
+via_alloc_draw_buffer(struct via_context *vmesa, struct via_renderbuffer *buf)
{
drm_via_mem_t mem;
mem.context = vmesa->hHWContext;
}
void
-via_free_draw_buffer(struct via_context *vmesa, struct via_buffer *buf)
+via_free_draw_buffer(struct via_context *vmesa, struct via_renderbuffer *buf)
{
drm_via_mem_t mem;
#include "via_context.h"
-extern GLboolean via_alloc_draw_buffer(struct via_context *vmesa, struct via_buffer *buf);
+extern GLboolean via_alloc_draw_buffer(struct via_context *vmesa, struct via_renderbuffer *buf);
extern GLboolean via_alloc_dma_buffer(struct via_context *vmesa);
struct via_tex_buffer *
GLuint size,
GLuint memType);
-extern void via_free_draw_buffer(struct via_context *vmesa, struct via_buffer *buf);
+extern void via_free_draw_buffer(struct via_context *vmesa, struct via_renderbuffer *buf);
extern void via_free_dma_buffer(struct via_context *vmesa);
extern void via_free_texture(struct via_context *vmesa, struct via_tex_buffer *t);
void via_release_pending_textures( struct via_context *vmesa );
}
static void viaFillBuffer(struct via_context *vmesa,
- struct via_buffer *buffer,
+ struct via_renderbuffer *buffer,
drm_clip_rect_t *pbox,
int nboxes,
GLuint pixel,
GLuint nbox)
{
GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
- struct via_buffer *front = &vmesa->front;
- struct via_buffer *back = &vmesa->back;
+ struct via_renderbuffer *front = &vmesa->front;
+ struct via_renderbuffer *back = &vmesa->back;
GLuint i;
for (i = 0; i < nbox; i++, b++) {
static void viaEmitBreadcrumbLocked( struct via_context *vmesa )
{
- struct via_buffer *buffer = &vmesa->breadcrumb;
+ struct via_renderbuffer *buffer = &vmesa->breadcrumb;
GLuint value = vmesa->lastBreadcrumbWrite + 1;
if (VIA_DEBUG & DEBUG_IOCTL)
viaDoPageFlipLocked( vmesa, 0 );
if (vmesa->front.offset != 0) {
- struct via_buffer buffer_tmp;
- memcpy(&buffer_tmp, &vmesa->back, sizeof(struct via_buffer));
- memcpy(&vmesa->back, &vmesa->front, sizeof(struct via_buffer));
- memcpy(&vmesa->front, &buffer_tmp, sizeof(struct via_buffer));
+ struct via_renderbuffer buffer_tmp;
+ memcpy(&buffer_tmp, &vmesa->back, sizeof(struct via_renderbuffer));
+ memcpy(&vmesa->back, &vmesa->front, sizeof(struct via_renderbuffer));
+ memcpy(&vmesa->front, &buffer_tmp, sizeof(struct via_renderbuffer));
}
assert(vmesa->front.offset == 0);
{
struct via_context *vmesa =
(struct via_context *)dPriv->driContextPriv->driverPrivate;
- struct via_buffer buffer_tmp;
+ struct via_renderbuffer buffer_tmp;
VIA_FLUSH_DMA(vmesa);
if (vmesa->vblank_flags == VBLANK_FLAG_SYNC &&
/* KW: FIXME: When buffers are freed, could free frontbuffer by
* accident:
*/
- memcpy(&buffer_tmp, &vmesa->back, sizeof(struct via_buffer));
- memcpy(&vmesa->back, &vmesa->front, sizeof(struct via_buffer));
- memcpy(&vmesa->front, &buffer_tmp, sizeof(struct via_buffer));
+ memcpy(&buffer_tmp, &vmesa->back, sizeof(struct via_renderbuffer));
+ memcpy(&vmesa->back, &vmesa->front, sizeof(struct via_renderbuffer));
+ memcpy(&vmesa->front, &buffer_tmp, sizeof(struct via_renderbuffer));
}
static void via_emit_cliprect(struct via_context *vmesa,
drm_clip_rect_t *b)
{
- struct via_buffer *buffer = vmesa->drawBuffer;
+ struct via_renderbuffer *buffer = vmesa->drawBuffer;
GLuint *vb = (GLuint *)(vmesa->dma + vmesa->dmaCliprectAddr);
GLuint format = (vmesa->viaScreen->bitsPerPixel == 0x20
GLboolean swStencil = (mesaVis->stencilBits > 0 &&
mesaVis->depthBits != 24);
-
+ GLboolean swAccum = mesaVis->accumRedBits > 0;
if (isPixmap) {
/* KW: This needs work, disabled for now:
return GL_FALSE;
}
else {
-#if 0
- driDrawPriv->driverPrivate = (void *)
- _mesa_create_framebuffer(mesaVis,
- GL_FALSE, /* software depth buffer? */
- swStencil,
- mesaVis->accumRedBits > 0,
- GL_FALSE /* s/w alpha planes */);
-#else
struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
+ /* The front color, back color and depth renderbuffers are
+ * set up later in calculate_buffer_parameters().
+ * Only create/connect software-based buffers here.
+ */
+
+#if 000
/* XXX check/fix the offset/pitch parameters! */
{
driRenderbuffer *frontRb
viaSetSpanFunctions(stencilRb, mesaVis);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, &stencilRb->Base);
}
+#endif
_mesa_add_soft_renderbuffers(fb,
GL_FALSE, /* color */
GL_FALSE, /* depth */
swStencil,
- mesaVis->accumRedBits > 0,
+ swAccum,
GL_FALSE, /* alpha */
GL_FALSE /* aux */);
driDrawPriv->driverPrivate = (void *) fb;
-#endif
- return (driDrawPriv->driverPrivate != NULL);
+
+ return (driDrawPriv->driverPrivate != NULL);
}
}
#define LOCAL_VARS \
struct via_context *vmesa = VIA_CONTEXT(ctx); \
__DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
- GLuint draw_pitch = vmesa->drawBuffer->pitch; \
- GLuint read_pitch = vmesa->readBuffer->pitch; \
+ struct via_renderbuffer *vrb = (struct via_renderbuffer *) rb; \
+ GLuint pitch = vrb->pitch; \
GLuint height = dPriv->h; \
GLint p = 0; \
- char *buf = (char *)(vmesa->drawBuffer->origMap + vmesa->drawXoff * vmesa->viaScreen->bytesPerPixel); \
- char *read_buf = (char *)(vmesa->readBuffer->origMap + vmesa->drawXoff * vmesa->viaScreen->bytesPerPixel); \
- (void) (read_pitch && draw_pitch && buf && read_buf && p);
+ char *buf = (char *)(vrb->origMap + vmesa->drawXoff * vrb->bpp); \
+ (void) p;
/* ================================================================
* Color buffer
/* 16 bit, RGB565 color spanline and pixel functions
*/
-#define GET_SRC_PTR(_x, _y) (read_buf + (_x) * 2 + (_y) * read_pitch)
-#define GET_DST_PTR(_x, _y) ( buf + (_x) * 2 + (_y) * draw_pitch)
+#define GET_SRC_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#define GET_DST_PTR(_x, _y) GET_SRC_PTR(_x, _y);
#define SPANTMP_PIXEL_FMT GL_RGB
#define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_5_6_5
/* 32 bit, ARGB8888 color spanline and pixel functions
*/
-#define GET_SRC_PTR(_x, _y) (read_buf + (_x) * 4 + (_y) * read_pitch)
-#define GET_DST_PTR(_x, _y) ( buf + (_x) * 4 + (_y) * draw_pitch)
+#define GET_SRC_PTR(_x, _y) (buf + (_x) * 4 + (_y) * pitch)
+#define GET_DST_PTR(_x, _y) GET_SRC_PTR(_x, _y);
#define SPANTMP_PIXEL_FMT GL_BGRA
#define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
/* 16 bit depthbuffer functions.
*/
-#define LOCAL_DEPTH_VARS \
- struct via_context *vmesa = VIA_CONTEXT(ctx); \
- __DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
- GLuint depth_pitch = vmesa->depth.pitch; \
- GLuint height = dPriv->h; \
- char *buf = (char *)(vmesa->depth.map + (vmesa->drawXoff * vmesa->depth.bpp/8))
+#define LOCAL_DEPTH_VARS \
+ struct via_context *vmesa = VIA_CONTEXT(ctx); \
+ __DRIdrawablePrivate *dPriv = vmesa->driDrawable; \
+ struct via_renderbuffer *vrb = (struct via_renderbuffer *) rb; \
+ GLuint depth_pitch = vrb->pitch; \
+ GLuint height = dPriv->h; \
+ char *buf = (char *)(vrb->map + (vmesa->drawXoff * vrb->bpp/8))
#define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS
#define READ_DEPTH(d, _x, _y) \
d = *(volatile GLushort *)(buf + (_x) * 2 + (_y) * depth_pitch);
-#define TAG(x) via##x##_16
+#define TAG(x) via##x##_z16
#include "depthtmp.h"
/* 32 bit depthbuffer functions.
#define READ_DEPTH(d, _x, _y) \
d = *(volatile GLuint *)(buf + (_x) * 4 + (_y) * depth_pitch);
-#define TAG(x) via##x##_32
+#define TAG(x) via##x##_z32
#include "depthtmp.h"
d = (*(GLuint *)(buf + (_x)*4 + (_y)*depth_pitch)) >> 8;
-#define TAG(x) via##x##_24_8
+#define TAG(x) via##x##_z24_s8
#include "depthtmp.h"
#define WRITE_STENCIL( _x, _y, d ) { \
#define READ_STENCIL( d, _x, _y ) \
d = *(GLuint *)(buf + (_x)*4 + (_y)*depth_pitch) & 0xff;
-#define TAG(x) via##x##_24_8
+#define TAG(x) via##x##_z24_s8
#include "stenciltmp.h"
-static void viaSetBuffer(GLcontext *ctx, GLframebuffer *colorBuffer,
- GLuint bufferBit)
-{
- struct via_context *vmesa = VIA_CONTEXT(ctx);
-
- if (bufferBit == BUFFER_BIT_FRONT_LEFT) {
- vmesa->drawBuffer = vmesa->readBuffer = &vmesa->front;
- }
- else if (bufferBit == BUFFER_BIT_BACK_LEFT) {
- vmesa->drawBuffer = vmesa->readBuffer = &vmesa->back;
- }
- else {
- ASSERT(0);
- }
-}
/* Move locking out to get reasonable span performance.
*/
void viaInitSpanFuncs(GLcontext *ctx)
{
-#if 0
- struct via_context *vmesa = VIA_CONTEXT(ctx);
-#endif
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
-
- swdd->SetBuffer = viaSetBuffer;
-#if 0
- if (vmesa->viaScreen->bitsPerPixel == 16) {
- viaInitPointers_565( swdd );
- }
- else if (vmesa->viaScreen->bitsPerPixel == 32) {
- viaInitPointers_8888( swdd );
- }
- else {
- assert(0);
- }
-#endif
-#if 0
- if (vmesa->glCtx->Visual.depthBits == 16) {
- swdd->ReadDepthSpan = viaReadDepthSpan_16;
- swdd->WriteDepthSpan = viaWriteDepthSpan_16;
- swdd->WriteMonoDepthSpan = viaWriteMonoDepthSpan_16;
- swdd->ReadDepthPixels = viaReadDepthPixels_16;
- swdd->WriteDepthPixels = viaWriteDepthPixels_16;
- }
- else if (vmesa->glCtx->Visual.depthBits == 24) {
- swdd->ReadDepthSpan = viaReadDepthSpan_24_8;
- swdd->WriteDepthSpan = viaWriteDepthSpan_24_8;
- swdd->WriteMonoDepthSpan = viaWriteMonoDepthSpan_24_8;
- swdd->ReadDepthPixels = viaReadDepthPixels_24_8;
- swdd->WriteDepthPixels = viaWriteDepthPixels_24_8;
-
- swdd->WriteStencilSpan = viaWriteStencilSpan_24_8;
- swdd->ReadStencilSpan = viaReadStencilSpan_24_8;
- swdd->WriteStencilPixels = viaWriteStencilPixels_24_8;
- swdd->ReadStencilPixels = viaReadStencilPixels_24_8;
- }
- else if (vmesa->glCtx->Visual.depthBits == 32) {
- swdd->ReadDepthSpan = viaReadDepthSpan_32;
- swdd->WriteDepthSpan = viaWriteDepthSpan_32;
- swdd->WriteMonoDepthSpan = viaWriteMonoDepthSpan_32;
- swdd->ReadDepthPixels = viaReadDepthPixels_32;
- swdd->WriteDepthPixels = viaWriteDepthPixels_32;
- }
-#endif
-
swdd->SpanRenderStart = viaSpanRenderStart;
swdd->SpanRenderFinish = viaSpanRenderFinish;
-
-#if 0
- swdd->WriteCI8Span = NULL;
- swdd->WriteCI32Span = NULL;
- swdd->WriteMonoCISpan = NULL;
- swdd->WriteCI32Pixels = NULL;
- swdd->WriteMonoCIPixels = NULL;
- swdd->ReadCI32Span = NULL;
- swdd->ReadCI32Pixels = NULL;
-#endif
}
* Plug in the Get/Put routines for the given driRenderbuffer.
*/
void
-viaSetSpanFunctions(driRenderbuffer *drb, const GLvisual *vis)
+viaSetSpanFunctions(struct via_renderbuffer *vrb, const GLvisual *vis)
{
- if (drb->Base.InternalFormat == GL_RGBA) {
+ if (vrb->Base.InternalFormat == GL_RGBA) {
if (vis->redBits == 5 && vis->greenBits == 6 && vis->blueBits == 5) {
- viaInitPointers_565(&drb->Base);
+ viaInitPointers_565(&vrb->Base);
}
else {
- viaInitPointers_8888(&drb->Base);
+ viaInitPointers_8888(&vrb->Base);
}
}
- else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
- drb->Base.GetRow = viaReadDepthSpan_16;
- drb->Base.GetValues = viaReadDepthPixels_16;
- drb->Base.PutRow = viaWriteDepthSpan_16;
- drb->Base.PutMonoRow = viaWriteMonoDepthSpan_16;
- drb->Base.PutValues = viaWriteDepthPixels_16;
- drb->Base.PutMonoValues = NULL;
+ else if (vrb->Base.InternalFormat == GL_DEPTH_COMPONENT16) {
+ viaInitDepthPointers_z16(&vrb->Base);
}
- else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
- drb->Base.GetRow = viaReadDepthSpan_24_8;
- drb->Base.GetValues = viaReadDepthPixels_24_8;
- drb->Base.PutRow = viaWriteDepthSpan_24_8;
- drb->Base.PutMonoRow = viaWriteMonoDepthSpan_24_8;
- drb->Base.PutValues = viaWriteDepthPixels_24_8;
- drb->Base.PutMonoValues = NULL;
+ else if (vrb->Base.InternalFormat == GL_DEPTH_COMPONENT24) {
+ viaInitDepthPointers_z24_s8(&vrb->Base);
}
- else if (drb->Base.InternalFormat == GL_DEPTH_COMPONENT32) {
- drb->Base.GetRow = viaReadDepthSpan_32;
- drb->Base.GetValues = viaReadDepthPixels_32;
- drb->Base.PutRow = viaWriteDepthSpan_32;
- drb->Base.PutMonoRow = viaWriteMonoDepthSpan_32;
- drb->Base.PutValues = viaWriteDepthPixels_32;
- drb->Base.PutMonoValues = NULL;
+ else if (vrb->Base.InternalFormat == GL_DEPTH_COMPONENT32) {
+ viaInitDepthPointers_z32(&vrb->Base);
}
- else if (drb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
- drb->Base.GetRow = viaReadStencilSpan_24_8;
- drb->Base.GetValues = viaReadStencilPixels_24_8;
- drb->Base.PutRow = viaWriteStencilSpan_24_8;
- drb->Base.PutMonoRow = viaWriteMonoStencilSpan_24_8;
- drb->Base.PutValues = viaWriteStencilPixels_24_8;
- drb->Base.PutMonoValues = NULL;
+ else if (vrb->Base.InternalFormat == GL_STENCIL_INDEX8_EXT) {
+ viaInitStencilPointers_z24_s8(&vrb->Base);
}
}
#ifndef _VIA_SPAN_H
#define _VIA_SPAN_H
-#include "drirenderbuffer.h"
-
extern void viaInitSpanFuncs(GLcontext *ctx);
extern void viaSpanRenderStart( GLcontext *ctx );
extern void viaSpanRenderFinish( GLcontext *ctx );
extern void
-viaSetSpanFunctions(driRenderbuffer *rb, const GLvisual *vis);
+viaSetSpanFunctions(struct via_renderbuffer *vrb, const GLvisual *vis);
#endif
switch ( ctx->DrawBuffer->_ColorDrawBufferMask[0] ) {
case BUFFER_BIT_FRONT_LEFT:
VIA_FLUSH_DMA(vmesa);
- vmesa->drawBuffer = vmesa->readBuffer = &vmesa->front;
+ vmesa->drawBuffer = &vmesa->front;
FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
break;
case BUFFER_BIT_BACK_LEFT:
VIA_FLUSH_DMA(vmesa);
- vmesa->drawBuffer = vmesa->readBuffer = &vmesa->back;
+ vmesa->drawBuffer = &vmesa->back;
FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
break;
default:
viaXMesaWindowMoved(vmesa);
-
- /* We want to update the s/w rast state too so that viaSetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
}
static void viaClearColor(GLcontext *ctx, const GLfloat color[4])
projects / mesa.git / commitdiff