*
* The function naming convention is:
*
- * write_[span|pixels]_[mono]_[format]_[pixmap|ximage]
+ * [put|get]_[mono]_[row|values]_[format]_[pixmap|ximage]
*
* New functions optimized for specific cases can be added without too much
* trouble. An example might be the 24-bit TrueColor mode 8A8R8G8B which is
/**********************************************************************/
-#define RGBA_SPAN_ARGS const GLcontext *ctx, \
- struct gl_renderbuffer *rb, \
- GLuint n, GLint x, GLint y, \
- CONST GLubyte rgba[][4], const GLubyte mask[]
+#define PUT_ROW_ARGS \
+ GLcontext *ctx, \
+ struct gl_renderbuffer *rb, \
+ GLuint n, GLint x, GLint y, \
+ const void *values, const GLubyte mask[]
-#define RGB_SPAN_ARGS const GLcontext *ctx, \
- struct gl_renderbuffer *rb, \
- GLuint n, GLint x, GLint y, \
- CONST GLubyte rgb[][3], const GLubyte mask[]
+#define RGB_SPAN_ARGS \
+ GLcontext *ctx, \
+ struct gl_renderbuffer *rb, \
+ GLuint n, GLint x, GLint y, \
+ const void *values, const GLubyte mask[]
/* NOTE: if mask==NULL, draw all pixels */
/*
* Write a span of PF_TRUECOLOR pixels to a pixmap.
*/
-static void write_span_TRUECOLOR_pixmap( RGBA_SPAN_ARGS )
+static void put_row_TRUECOLOR_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDisplay *dpy = XMESA_BUFFER(ctx->DrawBuffer)->display;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
unsigned long p;
PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
/*
* Write a span of PF_TRUECOLOR pixels to a pixmap.
*/
-static void write_span_rgb_TRUECOLOR_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_TRUECOLOR_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
unsigned long p;
PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
}
}
-
/*
* Write a span of PF_TRUEDITHER pixels to a pixmap.
*/
-static void write_span_TRUEDITHER_pixmap( RGBA_SPAN_ARGS )
+static void put_row_TRUEDITHER_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
unsigned long p;
PACK_TRUEDITHER(p, x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
/*
* Write a span of PF_TRUEDITHER pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_TRUEDITHER_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_TRUEDITHER_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
unsigned long p;
PACK_TRUEDITHER(p, x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
}
-
/*
* Write a span of PF_8A8B8G8R pixels to a pixmap.
*/
-static void write_span_8A8B8G8R_pixmap( RGBA_SPAN_ARGS )
+static void put_row_8A8B8G8R_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
/*
* Write a span of PF_8A8B8G8R pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_8A8B8G8R_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_8A8B8G8R_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
/*
* Write a span of PF_8A8R8G8B pixels to a pixmap.
*/
-static void write_span_8A8R8G8B_pixmap( RGBA_SPAN_ARGS )
+static void put_row_8A8R8G8B_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8A8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
/*
* Write a span of PF_8A8R8G8B pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_8A8R8G8B_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_8A8R8G8B_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
}
}
-
/*
* Write a span of PF_8R8G8B pixels to a pixmap.
*/
-static void write_span_8R8G8B_pixmap( RGBA_SPAN_ARGS )
+static void put_row_8R8G8B_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
/*
* Write a span of PF_8R8G8B24 pixels to a pixmap.
*/
-static void write_span_8R8G8B24_pixmap( RGBA_SPAN_ARGS )
+static void put_row_8R8G8B24_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
y = YFLIP(xrb, y);
if (mask) {
register GLuint i;
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
register GLuint pixel;
static const GLuint shift[4] = {0, 8, 16, 24};
/*
* Write a span of PF_8R8G8B pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_8R8G8B_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_8R8G8B_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
for (i=0;i<n;i++) {
*ptr4++ = PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
}
}
-
/*
* Write a span of PF_8R8G8B24 pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_8R8G8B24_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_8R8G8B24_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
y = YFLIP(xrb, y);
if (mask) {
register GLuint i;
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLuint *ptr4 = (GLuint *) rowimg->data;
register GLuint pixel;
static const GLuint shift[4] = {0, 8, 16, 24};
/*
* Write a span of PF_5R6G5B pixels to a pixmap.
*/
-static void write_span_5R6G5B_pixmap( RGBA_SPAN_ARGS )
+static void put_row_5R6G5B_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLushort *ptr2 = (GLushort *) rowimg->data;
for (i=0;i<n;i++) {
ptr2[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
/*
* Write a span of PF_DITHER_5R6G5B pixels to a pixmap.
*/
-static void write_span_DITHER_5R6G5B_pixmap( RGBA_SPAN_ARGS )
+static void put_row_DITHER_5R6G5B_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLushort *ptr2 = (GLushort *) rowimg->data;
for (i=0;i<n;i++) {
PACK_TRUEDITHER( ptr2[i], x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
/*
* Write a span of PF_5R6G5B pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_5R6G5B_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_5R6G5B_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLushort *ptr2 = (GLushort *) rowimg->data;
for (i=0;i<n;i++) {
ptr2[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
/*
* Write a span of PF_DITHER_5R6G5B pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_DITHER_5R6G5B_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_DITHER_5R6G5B_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
register GLushort *ptr2 = (GLushort *) rowimg->data;
for (i=0;i<n;i++) {
PACK_TRUEDITHER( ptr2[i], x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
}
-
/*
* Write a span of PF_DITHER pixels to a pixmap.
*/
-static void write_span_DITHER_pixmap( RGBA_SPAN_ARGS )
+static void put_row_DITHER_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
XDITHER_SETUP(y);
y = YFLIP(xrb, y);
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
}
/*
* Write a span of PF_DITHER pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_DITHER_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_DITHER_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
XDITHER_SETUP(y);
y = YFLIP(xrb, y);
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
}
/*
* Write a span of PF_1BIT pixels to a pixmap.
*/
-static void write_span_1BIT_pixmap( RGBA_SPAN_ARGS )
+static void put_row_1BIT_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
SETUP_1BIT;
y = YFLIP(xrb, y);
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0,
DITHER_1BIT( x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
/*
* Write a span of PF_1BIT pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_1BIT_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_1BIT_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
SETUP_1BIT;
y = YFLIP(xrb, y);
}
else {
/* draw all pixels */
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0,
DITHER_1BIT(x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
/*
* Write a span of PF_HPCR pixels to a pixmap.
*/
-static void write_span_HPCR_pixmap( RGBA_SPAN_ARGS )
+static void put_row_HPCR_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
- register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
+ register GLubyte *ptr = (GLubyte *) XMESA_BUFFER(ctx->DrawBuffer)->rowimage->data;
for (i=0;i<n;i++) {
ptr[i] = DITHER_HPCR( (x+i), y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
}
/*
* Write a span of PF_HPCR pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_HPCR_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_HPCR_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
- register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
+ register GLubyte *ptr = (GLubyte *) XMESA_BUFFER(ctx->DrawBuffer)->rowimage->data;
for (i=0;i<n;i++) {
ptr[i] = DITHER_HPCR( (x+i), y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
}
}
}
-
/*
* Write a span of PF_LOOKUP pixels to a pixmap.
*/
-static void write_span_LOOKUP_pixmap( RGBA_SPAN_ARGS )
+static void put_row_LOOKUP_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
LOOKUP_SETUP;
y = YFLIP(xrb, y);
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0, LOOKUP(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
}
/*
* Write a span of PF_LOOKUP pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_LOOKUP_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_LOOKUP_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
LOOKUP_SETUP;
y = YFLIP(xrb, y);
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0, LOOKUP(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
}
}
-
/*
* Write a span of PF_GRAYSCALE pixels to a pixmap.
*/
-static void write_span_GRAYSCALE_pixmap( RGBA_SPAN_ARGS )
+static void put_row_GRAYSCALE_pixmap( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
}
/*
* Write a span of PF_GRAYSCALE pixels to a pixmap (no alpha).
*/
-static void write_span_rgb_GRAYSCALE_pixmap( RGB_SPAN_ARGS )
+static void put_row_rgb_GRAYSCALE_pixmap( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
}
else {
- XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+ XMesaImage *rowimg = XMESA_BUFFER(ctx->DrawBuffer)->rowimage;
for (i=0;i<n;i++) {
XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
}
}
}
-
/*
* Write a span of PF_TRUECOLOR pixels to an XImage.
*/
-static void write_span_TRUECOLOR_ximage( RGBA_SPAN_ARGS )
+static void put_row_TRUECOLOR_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of PF_TRUECOLOR pixels to an XImage (no alpha).
*/
-static void write_span_rgb_TRUECOLOR_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_TRUECOLOR_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of PF_TRUEDITHER pixels to an XImage.
*/
-static void write_span_TRUEDITHER_ximage( RGBA_SPAN_ARGS )
+static void put_row_TRUEDITHER_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of PF_TRUEDITHER pixels to an XImage (no alpha).
*/
-static void write_span_rgb_TRUEDITHER_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_TRUEDITHER_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of PF_8A8B8G8R-format pixels to an ximage.
*/
-static void write_span_8A8B8G8R_ximage( RGBA_SPAN_ARGS )
+static void put_row_8A8B8G8R_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLuint *ptr = PIXEL_ADDR4(xrb, x, y);
/*
* Write a span of PF_8A8B8G8R-format pixels to an ximage (no alpha).
*/
-static void write_span_rgb_8A8B8G8R_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_8A8B8G8R_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLuint *ptr = PIXEL_ADDR4(xrb, x, y);
/*
* Write a span of PF_8A8R8G8B-format pixels to an ximage.
*/
-static void write_span_8A8R8G8B_ximage( RGBA_SPAN_ARGS )
+static void put_row_8A8R8G8B_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLuint *ptr = PIXEL_ADDR4(xrb, x, y);
/*
* Write a span of PF_8A8R8G8B-format pixels to an ximage (no alpha).
*/
-static void write_span_rgb_8A8R8G8B_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_8A8R8G8B_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLuint *ptr = PIXEL_ADDR4(xrb, x, y);
/*
* Write a span of PF_8R8G8B-format pixels to an ximage.
*/
-static void write_span_8R8G8B_ximage( RGBA_SPAN_ARGS )
+static void put_row_8R8G8B_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLuint *ptr = PIXEL_ADDR4(xrb, x, y);
/*
* Write a span of PF_8R8G8B24-format pixels to an ximage.
*/
-static void write_span_8R8G8B24_ximage( RGBA_SPAN_ARGS )
+static void put_row_8R8G8B24_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLubyte *ptr = (GLubyte *) PIXEL_ADDR3(xrb, x, y );
/*
* Write a span of PF_8R8G8B-format pixels to an ximage (no alpha).
*/
-static void write_span_rgb_8R8G8B_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_8R8G8B_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLuint *ptr = PIXEL_ADDR4(xrb, x, y);
/*
* Write a span of PF_8R8G8B24-format pixels to an ximage (no alpha).
*/
-static void write_span_rgb_8R8G8B24_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_8R8G8B24_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLubyte *ptr = (GLubyte *) PIXEL_ADDR3(xrb, x, y);
/*
* Write a span of PF_5R6G5B-format pixels to an ximage.
*/
-static void write_span_5R6G5B_ximage( RGBA_SPAN_ARGS )
+static void put_row_5R6G5B_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLushort *ptr = PIXEL_ADDR2(xrb, x, y);
/*
* Write a span of PF_DITHER_5R6G5B-format pixels to an ximage.
*/
-static void write_span_DITHER_5R6G5B_ximage( RGBA_SPAN_ARGS )
+static void put_row_DITHER_5R6G5B_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLushort *ptr = PIXEL_ADDR2(xrb, x, y);
const GLint y2 = YFLIP(xrb, y);
- ASSERT(xrb->ximage);
if (mask) {
for (i=0;i<n;i++,x++) {
if (mask[i]) {
/*
* Write a span of PF_5R6G5B-format pixels to an ximage (no alpha).
*/
-static void write_span_rgb_5R6G5B_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_5R6G5B_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLushort *ptr = PIXEL_ADDR2(xrb, x, y);
/*
* Write a span of PF_DITHER_5R6G5B-format pixels to an ximage (no alpha).
*/
-static void write_span_rgb_DITHER_5R6G5B_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_DITHER_5R6G5B_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
/*
* Write a span of PF_DITHER pixels to an XImage.
*/
-static void write_span_DITHER_ximage( RGBA_SPAN_ARGS )
+static void put_row_DITHER_ximage( PUT_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
int yy = YFLIP(xrb, y);
XDITHER_SETUP(yy);
/*
* Write a span of PF_DITHER pixels to an XImage (no alpha).
*/
-static void write_span_rgb_DITHER_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_DITHER_ximage( RGB_SPAN_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
int yy = YFLIP(xrb, y);
XDITHER_SETUP(yy);
/*
* Write a span of 8-bit PF_DITHER pixels to an XImage.
*/
-static void write_span_DITHER8_ximage( RGBA_SPAN_ARGS )
+static void put_row_DITHER8_ximage( PUT_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
}
-static void write_span_rgb_DITHER8_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_DITHER8_ximage( RGB_SPAN_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
/*
* Write a span of PF_1BIT pixels to an XImage.
*/
-static void write_span_1BIT_ximage( RGBA_SPAN_ARGS )
+static void put_row_1BIT_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
SETUP_1BIT;
y = YFLIP(xrb, y);
/*
* Write a span of PF_1BIT pixels to an XImage (no alpha).
*/
-static void write_span_rgb_1BIT_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_1BIT_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
SETUP_1BIT;
y = YFLIP(xrb, y);
/*
* Write a span of PF_HPCR pixels to an XImage.
*/
-static void write_span_HPCR_ximage( RGBA_SPAN_ARGS )
+static void put_row_HPCR_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
/*
* Write a span of PF_HPCR pixels to an XImage (no alpha).
*/
-static void write_span_rgb_HPCR_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_HPCR_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
/*
* Write a span of PF_LOOKUP pixels to an XImage.
*/
-static void write_span_LOOKUP_ximage( RGBA_SPAN_ARGS )
+static void put_row_LOOKUP_ximage( PUT_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
LOOKUP_SETUP;
y = YFLIP(xrb, y);
/*
* Write a span of PF_LOOKUP pixels to an XImage (no alpha).
*/
-static void write_span_rgb_LOOKUP_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_LOOKUP_ximage( RGB_SPAN_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
LOOKUP_SETUP;
y = YFLIP(xrb, y);
/*
* Write a span of 8-bit PF_LOOKUP pixels to an XImage.
*/
-static void write_span_LOOKUP8_ximage( RGBA_SPAN_ARGS )
+static void put_row_LOOKUP8_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
LOOKUP_SETUP;
}
-static void write_rgb_LOOKUP8_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_LOOKUP8_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
LOOKUP_SETUP;
/*
* Write a span of PF_GRAYSCALE pixels to an XImage.
*/
-static void write_span_GRAYSCALE_ximage( RGBA_SPAN_ARGS )
+static void put_row_GRAYSCALE_ximage( PUT_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of PF_GRAYSCALE pixels to an XImage (no alpha).
*/
-static void write_span_rgb_GRAYSCALE_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_GRAYSCALE_ximage( RGB_SPAN_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of 8-bit PF_GRAYSCALE pixels to an XImage.
*/
-static void write_span_GRAYSCALE8_ximage( RGBA_SPAN_ARGS )
+static void put_row_GRAYSCALE8_ximage( PUT_ROW_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
if (mask) {
/*
* Write a span of 8-bit PF_GRAYSCALE pixels to an XImage (no alpha).
*/
-static void write_span_rgb_GRAYSCALE8_ximage( RGB_SPAN_ARGS )
+static void put_row_rgb_GRAYSCALE8_ximage( RGB_SPAN_ARGS )
{
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
if (mask) {
/**********************************************************************/
-#define RGBA_PIXEL_ARGS const GLcontext *ctx, \
- struct gl_renderbuffer *rb, \
- GLuint n, const GLint x[], const GLint y[], \
- CONST GLubyte rgba[][4], const GLubyte mask[]
+#define PUT_VALUES_ARGS \
+ GLcontext *ctx, struct gl_renderbuffer *rb, \
+ GLuint n, const GLint x[], const GLint y[], \
+ const void *values, const GLubyte mask[]
/*
* Write an array of PF_TRUECOLOR pixels to a pixmap.
*/
-static void write_pixels_TRUECOLOR_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_TRUECOLOR_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_TRUEDITHER pixels to a pixmap.
*/
-static void write_pixels_TRUEDITHER_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_TRUEDITHER_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_8A8B8G8R pixels to a pixmap.
*/
-static void write_pixels_8A8B8G8R_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_8A8B8G8R_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_8A8R8G8B pixels to a pixmap.
*/
-static void write_pixels_8A8R8G8B_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_8A8R8G8B_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_8R8G8B pixels to a pixmap.
*/
-static void write_pixels_8R8G8B_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_8R8G8B_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_8R8G8B24 pixels to a pixmap.
*/
-static void write_pixels_8R8G8B24_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_8R8G8B24_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_5R6G5B pixels to a pixmap.
*/
-static void write_pixels_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_5R6G5B_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_DITHER_5R6G5B pixels to a pixmap.
*/
-static void write_pixels_DITHER_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_DITHER_5R6G5B_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_DITHER pixels to a pixmap.
*/
-static void write_pixels_DITHER_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_DITHER_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
DITHER_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of PF_1BIT pixels to a pixmap.
*/
-static void write_pixels_1BIT_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_1BIT_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
SETUP_1BIT;
for (i=0;i<n;i++) {
/*
* Write an array of PF_HPCR pixels to a pixmap.
*/
-static void write_pixels_HPCR_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_HPCR_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_LOOKUP pixels to a pixmap.
*/
-static void write_pixels_LOOKUP_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_LOOKUP_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
LOOKUP_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of PF_GRAYSCALE pixels to a pixmap.
*/
-static void write_pixels_GRAYSCALE_pixmap( RGBA_PIXEL_ARGS )
+static void put_values_GRAYSCALE_pixmap( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_TRUECOLOR pixels to an ximage.
*/
-static void write_pixels_TRUECOLOR_ximage( RGBA_PIXEL_ARGS )
+static void put_values_TRUECOLOR_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_TRUEDITHER pixels to an XImage.
*/
-static void write_pixels_TRUEDITHER_ximage( RGBA_PIXEL_ARGS )
+static void put_values_TRUEDITHER_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of PF_8A8B8G8R pixels to an ximage.
*/
-static void write_pixels_8A8B8G8R_ximage( RGBA_PIXEL_ARGS )
+static void put_values_8A8B8G8R_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
for (i=0;i<n;i++) {
/*
* Write an array of PF_8A8R8G8B pixels to an ximage.
*/
-static void write_pixels_8A8R8G8B_ximage( RGBA_PIXEL_ARGS )
+static void put_values_8A8R8G8B_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
for (i=0;i<n;i++) {
/*
* Write an array of PF_8R8G8B pixels to an ximage.
*/
-static void write_pixels_8R8G8B_ximage( RGBA_PIXEL_ARGS )
+static void put_values_8R8G8B_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
for (i=0;i<n;i++) {
/*
* Write an array of PF_8R8G8B24 pixels to an ximage.
*/
-static void write_pixels_8R8G8B24_ximage( RGBA_PIXEL_ARGS )
+static void put_values_8R8G8B24_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
for (i=0;i<n;i++) {
/*
* Write an array of PF_5R6G5B pixels to an ximage.
*/
-static void write_pixels_5R6G5B_ximage( RGBA_PIXEL_ARGS )
+static void put_values_5R6G5B_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
for (i=0;i<n;i++) {
/*
* Write an array of PF_DITHER_5R6G5B pixels to an ximage.
*/
-static void write_pixels_DITHER_5R6G5B_ximage( RGBA_PIXEL_ARGS )
+static void put_values_DITHER_5R6G5B_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
/*
* Write an array of PF_DITHER pixels to an XImage.
*/
-static void write_pixels_DITHER_ximage( RGBA_PIXEL_ARGS )
+static void put_values_DITHER_ximage( PUT_VALUES_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
DITHER_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of 8-bit PF_DITHER pixels to an XImage.
*/
-static void write_pixels_DITHER8_ximage( RGBA_PIXEL_ARGS )
+static void put_values_DITHER8_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
DITHER_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of PF_1BIT pixels to an XImage.
*/
-static void write_pixels_1BIT_ximage( RGBA_PIXEL_ARGS )
+static void put_values_1BIT_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
SETUP_1BIT;
for (i=0;i<n;i++) {
/*
* Write an array of PF_HPCR pixels to an XImage.
*/
-static void write_pixels_HPCR_ximage( RGBA_PIXEL_ARGS )
+static void put_values_HPCR_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
/*
* Write an array of PF_LOOKUP pixels to an XImage.
*/
-static void write_pixels_LOOKUP_ximage( RGBA_PIXEL_ARGS )
+static void put_values_LOOKUP_ximage( PUT_VALUES_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
LOOKUP_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of 8-bit PF_LOOKUP pixels to an XImage.
*/
-static void write_pixels_LOOKUP8_ximage( RGBA_PIXEL_ARGS )
+static void put_values_LOOKUP8_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
LOOKUP_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of PF_GRAYSCALE pixels to an XImage.
*/
-static void write_pixels_GRAYSCALE_ximage( RGBA_PIXEL_ARGS )
+static void put_values_GRAYSCALE_ximage( PUT_VALUES_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of 8-bit PF_GRAYSCALE pixels to an XImage.
*/
-static void write_pixels_GRAYSCALE8_ximage( RGBA_PIXEL_ARGS )
+static void put_values_GRAYSCALE8_ximage( PUT_VALUES_ARGS )
{
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*** Write MONO COLOR SPAN functions ***/
/**********************************************************************/
-#define MONO_SPAN_ARGS const GLcontext *ctx, \
- struct gl_renderbuffer *rb, \
- GLuint n, GLint x, GLint y, const GLchan color[4], \
- const GLubyte mask[]
+#define PUT_MONO_ROW_ARGS \
+ GLcontext *ctx, struct gl_renderbuffer *rb, \
+ GLuint n, GLint x, GLint y, const void *value, \
+ const GLubyte mask[]
+
/*
* Write a span of identical pixels to a pixmap.
*/
-static void write_span_mono_pixmap( MONO_SPAN_ARGS )
+static void put_mono_row_pixmap( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
- const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
+ const unsigned long pixel = xmesa_color_to_pixel(ctx, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
register GLuint i;
XMesaSetForeground( xmesa->display, gc, pixel );
static void
-write_span_mono_index_pixmap( const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, GLint x, GLint y, GLuint colorIndex,
- const GLubyte mask[] )
+put_mono_row_ci_pixmap( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ GLuint colorIndex = *((GLuint *) value);
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
XMesaSetForeground( xmesa->display, gc, colorIndex );
y = YFLIP(xrb, y);
/* Identify and emit contiguous rendered pixels
*/
- while (i < n && mask[i])
+ while (i < n && (!mask || mask[i]))
i++;
if (start < i)
/*
* Write a span of PF_TRUEDITHER pixels to a pixmap.
*/
-static void write_span_mono_TRUEDITHER_pixmap( MONO_SPAN_ARGS )
+static void put_mono_row_TRUEDITHER_pixmap( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLuint i;
int yy = YFLIP(xrb, y);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
unsigned long p;
PACK_TRUEDITHER(p, x, yy, r, g, b);
XMesaSetForeground( dpy, gc, p );
/*
* Write a span of PF_DITHER pixels to a pixmap.
*/
-static void write_span_mono_DITHER_pixmap( MONO_SPAN_ARGS )
+static void put_mono_row_DITHER_pixmap( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLuint i;
int yy = YFLIP(xrb, y);
XDITHER_SETUP(yy);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
XMesaSetForeground( dpy, gc, XDITHER( x, r, g, b ) );
XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
}
/*
* Write a span of PF_1BIT pixels to a pixmap.
*/
-static void write_span_mono_1BIT_pixmap( MONO_SPAN_ARGS )
+static void put_mono_row_1BIT_pixmap( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLuint i;
SETUP_1BIT;
y = YFLIP(xrb, y);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
XMesaSetForeground( dpy, gc, DITHER_1BIT( x, y, r, g, b ) );
XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
}
/*
* Write a span of identical pixels to an XImage.
*/
-static void write_span_mono_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_ximage( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ XMesaImage *img = xrb->ximage;
register GLuint i;
- const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+ const unsigned long pixel = xmesa_color_to_pixel(ctx, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
y = YFLIP(xrb, y);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
XMesaPutPixel( img, x, y, pixel );
}
}
static void
-write_span_mono_index_ximage( const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, GLint x, GLint y, GLuint colorIndex,
- const GLubyte mask[] )
+put_mono_row_ci_ximage( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLuint colorIndex = *((GLuint *) value);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
XMesaPutPixel( img, x, y, colorIndex );
}
}
/*
* Write a span of identical PF_TRUEDITHER pixels to an XImage.
*/
-static void write_span_mono_TRUEDITHER_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_TRUEDITHER_ximage( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ XMesaImage *img = xrb->ximage;
const GLint r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
GLuint i;
y = YFLIP(xrb, y);
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
unsigned long p;
PACK_TRUEDITHER( p, x+i, y, r, g, b);
XMesaPutPixel( img, x+i, y, p );
/*
* Write a span of identical 8A8B8G8R pixels to an XImage.
*/
-static void write_span_mono_8A8B8G8R_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_8A8B8G8R_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
GLuint i, *ptr;
- const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+ const unsigned long pixel = xmesa_color_to_pixel(ctx, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
ptr = PIXEL_ADDR4(xrb, x, y );
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i] = pixel;
}
}
/*
* Write a span of identical 8A8R8G8B pixels to an XImage.
*/
-static void write_span_mono_8A8R8G8B_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_8A8R8G8B_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
GLuint i, *ptr;
- const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const unsigned long pixel = xmesa_color_to_pixel(ctx, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
ptr = PIXEL_ADDR4(xrb, x, y );
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i] = pixel;
}
}
/*
* Write a span of identical 8R8G8B pixels to an XImage.
*/
-static void write_span_mono_8R8G8B_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_8R8G8B_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLuint pixel = PACK_8R8G8B(color[RCOMP], color[GCOMP], color[BCOMP]);
GLuint *ptr = PIXEL_ADDR4(xrb, x, y );
/*
* Write a span of identical 8R8G8B pixels to an XImage.
*/
-static void write_span_mono_8R8G8B24_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_8R8G8B24_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLubyte r = color[RCOMP];
const GLubyte g = color[GCOMP];
GLuint i;
bgr_t *ptr = PIXEL_ADDR3(xrb, x, y );
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i].r = r;
ptr[i].g = g;
ptr[i].b = b;
/*
* Write a span of identical DITHER pixels to an XImage.
*/
-static void write_span_mono_DITHER_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_DITHER_ximage( PUT_MONO_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
int yy = YFLIP(xrb, y);
register GLuint i;
XDITHER_SETUP(yy);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
XMesaPutPixel( img, x, yy, XDITHER( x, r, g, b ) );
}
}
/*
* Write a span of identical 8-bit DITHER pixels to an XImage.
*/
-static void write_span_mono_DITHER8_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_DITHER8_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
register GLuint i;
XDITHER_SETUP(y);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i] = (GLubyte) XDITHER( x, r, g, b );
}
}
/*
* Write a span of identical 8-bit LOOKUP pixels to an XImage.
*/
-static void write_span_mono_LOOKUP8_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_LOOKUP8_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
GLubyte pixel;
LOOKUP_SETUP;
pixel = LOOKUP(color[RCOMP], color[GCOMP], color[BCOMP]);
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i] = pixel;
}
}
/*
* Write a span of identical PF_1BIT pixels to an XImage.
*/
-static void write_span_mono_1BIT_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_1BIT_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
SETUP_1BIT;
y = YFLIP(xrb, y);
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
XMesaPutPixel( img, x, y, DITHER_1BIT( x, y, r, g, b ) );
}
}
/*
* Write a span of identical HPCR pixels to an XImage.
*/
-static void write_span_mono_HPCR_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_HPCR_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLubyte *ptr = PIXEL_ADDR1(xrb, x, y);
register GLuint i;
for (i=0;i<n;i++,x++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i] = DITHER_HPCR( x, y, r, g, b );
}
}
/*
* Write a span of identical 8-bit GRAYSCALE pixels to an XImage.
*/
-static void write_span_mono_GRAYSCALE8_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_GRAYSCALE8_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
const GLubyte p = GRAY_RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
GLubyte *ptr = (GLubyte *) PIXEL_ADDR1(xrb, x, y);
GLuint i;
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
ptr[i] = p;
}
}
/*
* Write a span of identical PF_DITHER_5R6G5B pixels to an XImage.
*/
-static void write_span_mono_DITHER_5R6G5B_ximage( MONO_SPAN_ARGS )
+static void put_mono_row_DITHER_5R6G5B_ximage( PUT_MONO_ROW_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLushort *ptr = PIXEL_ADDR2(xrb, x, y );
GLuint i;
y = YFLIP(xrb, y);
for (i=0;i<n;i++) {
- if (mask[i]) {
+ if (!mask || mask[i]) {
PACK_TRUEDITHER(ptr[i], x+i, y, r, g, b);
}
}
/*** Write MONO COLOR PIXELS functions ***/
/**********************************************************************/
-#define MONO_PIXEL_ARGS const GLcontext *ctx, \
- struct gl_renderbuffer *rb, \
- GLuint n, const GLint x[], const GLint y[], \
- const GLchan color[4], const GLubyte mask[]
+#define PUT_MONO_VALUES_ARGS \
+ GLcontext *ctx, struct gl_renderbuffer *rb, \
+ GLuint n, const GLint x[], const GLint y[], \
+ const void *value, const GLubyte mask[]
+
+
/*
* Write an array of identical pixels to a pixmap.
*/
-static void write_pixels_mono_pixmap( MONO_PIXEL_ARGS )
+static void put_mono_values_pixmap( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
- const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+ const unsigned long pixel = xmesa_color_to_pixel(ctx, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
XMesaSetForeground( xmesa->display, gc, pixel );
for (i=0;i<n;i++) {
static void
-write_pixels_mono_index_pixmap(const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, const GLint x[], const GLint y[],
- GLuint colorIndex, const GLubyte mask[] )
+put_mono_values_ci_pixmap( PUT_MONO_VALUES_ARGS )
{
+ const GLuint colorIndex = *((GLuint *) value);
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
XMesaSetForeground( xmesa->display, gc, colorIndex );
for (i=0;i<n;i++) {
/*
* Write an array of PF_TRUEDITHER pixels to a pixmap.
*/
-static void write_pixels_mono_TRUEDITHER_pixmap( MONO_PIXEL_ARGS )
+static void put_mono_values_TRUEDITHER_pixmap( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
for (i=0;i<n;i++) {
/*
* Write an array of PF_DITHER pixels to a pixmap.
*/
-static void write_pixels_mono_DITHER_pixmap( MONO_PIXEL_ARGS )
+static void put_mono_values_DITHER_pixmap( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
DITHER_SETUP;
/*
* Write an array of PF_1BIT pixels to a pixmap.
*/
-static void write_pixels_mono_1BIT_pixmap( MONO_PIXEL_ARGS )
+static void put_mono_values_1BIT_pixmap( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
SETUP_1BIT;
/*
* Write an array of identical pixels to an XImage.
*/
-static void write_pixels_mono_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
- const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+ const unsigned long pixel = xmesa_color_to_pixel(ctx, color[RCOMP],
color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
for (i=0;i<n;i++) {
if (mask[i]) {
static void
-write_pixels_mono_index_ximage(const GLcontext *ctx,
- struct gl_renderbuffer *rb,
- GLuint n, const GLint x[], const GLint y[],
- GLuint colorIndex, const GLubyte mask[] )
+put_mono_values_ci_ximage( PUT_MONO_VALUES_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLuint colorIndex = *((GLuint *) value);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of identical TRUEDITHER pixels to an XImage.
*/
-static void write_pixels_mono_TRUEDITHER_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_TRUEDITHER_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
const int r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
for (i=0;i<n;i++) {
/*
* Write an array of identical 8A8B8G8R pixels to an XImage
*/
-static void write_pixels_mono_8A8B8G8R_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_8A8B8G8R_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLuint p = PACK_8A8B8G8R(color[RCOMP], color[GCOMP],
color[BCOMP], color[ACOMP]);
/*
* Write an array of identical 8A8R8G8B pixels to an XImage
*/
-static void write_pixels_mono_8A8R8G8B_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_8A8R8G8B_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLuint p = PACK_8A8R8G8B(color[RCOMP], color[GCOMP],
color[BCOMP], color[ACOMP]);
/*
* Write an array of identical 8R8G8B pixels to an XImage.
*/
-static void write_pixels_mono_8R8G8B_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_8R8G8B_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
register GLuint i;
const GLuint p = PACK_8R8G8B(color[RCOMP], color[GCOMP], color[BCOMP]);
/*
* Write an array of identical 8R8G8B pixels to an XImage.
*/
-static void write_pixels_mono_8R8G8B24_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_8R8G8B24_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLuint i;
/*
* Write an array of identical PF_DITHER pixels to an XImage.
*/
-static void write_pixels_mono_DITHER_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_DITHER_ximage( PUT_MONO_VALUES_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
DITHER_SETUP;
for (i=0;i<n;i++) {
/*
* Write an array of identical 8-bit PF_DITHER pixels to an XImage.
*/
-static void write_pixels_mono_DITHER8_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_DITHER8_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
register GLuint i;
DITHER_SETUP;
/*
* Write an array of identical 8-bit PF_LOOKUP pixels to an XImage.
*/
-static void write_pixels_mono_LOOKUP8_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_LOOKUP8_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
GLubyte pixel;
LOOKUP_SETUP;
/*
* Write an array of identical PF_1BIT pixels to an XImage.
*/
-static void write_pixels_mono_1BIT_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_1BIT_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
SETUP_1BIT;
for (i=0;i<n;i++) {
/*
* Write an array of identical PF_HPCR pixels to an XImage.
*/
-static void write_pixels_mono_HPCR_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_HPCR_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
/*
* Write an array of identical 8-bit PF_GRAYSCALE pixels to an XImage.
*/
-static void write_pixels_mono_GRAYSCALE8_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_GRAYSCALE8_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
register GLuint i;
register GLubyte p = GRAY_RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
for (i=0;i<n;i++) {
/*
* Write an array of identical PF_DITHER_5R6G5B pixels to an XImage.
*/
-static void write_pixels_mono_DITHER_5R6G5B_ximage( MONO_PIXEL_ARGS )
+static void put_mono_values_DITHER_5R6G5B_ximage( PUT_MONO_VALUES_ARGS )
{
+ const GLubyte *color = (const GLubyte *) value;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
const int r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
/*** Write INDEX SPAN functions ***/
/**********************************************************************/
-#define INDEX_SPAN_ARGS const GLcontext *ctx, struct gl_renderbuffer *rb, \
- GLuint n, GLint x, GLint y, const GLuint index[], \
- const GLubyte mask[]
-
-#define INDEX8_SPAN_ARGS const GLcontext *ctx, struct gl_renderbuffer *rb, \
- GLuint n, GLint x, GLint y, const GLubyte index[], \
- const GLubyte mask[]
-
-
/*
* Write a span of CI pixels to a Pixmap.
*/
-static void write_span_index_pixmap( INDEX_SPAN_ARGS )
-{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
- struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
- register GLuint i;
- y = YFLIP(xrb, y);
- if (mask) {
- for (i=0;i<n;i++,x++) {
- if (mask[i]) {
- XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
- XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
- }
- }
- }
- else {
- for (i=0;i<n;i++,x++) {
- XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
- XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
- }
- }
-}
-
-
-/*
- * Write a span of 8-bit CI pixels to a Pixmap.
- */
-static void write_span_index8_pixmap( INDEX8_SPAN_ARGS )
+static void put_row_ci_pixmap( PUT_ROW_ARGS )
{
+ const GLuint *index = (GLuint *) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
/*
* Write a span of CI pixels to an XImage.
*/
-static void write_span_index_ximage( INDEX_SPAN_ARGS )
+static void put_row_ci_ximage( PUT_ROW_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLuint *index = (const GLuint *) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
y = YFLIP(xrb, y);
if (mask) {
}
-/*
- * Write a span of 8-bit CI pixels to a non 8-bit XImage.
- */
-static void write_span_index8_ximage( INDEX8_SPAN_ARGS )
-{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
- struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- y = YFLIP(xrb, y);
- if (mask) {
- GLuint i;
- for (i=0;i<n;i++) {
- if (mask[i]) {
- XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
- }
- }
- }
- else {
- GLuint i;
- for (i=0;i<n;i++) {
- XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
- }
- }
-}
-
-/*
- * Write a span of 8-bit CI pixels to an 8-bit XImage.
- */
-static void write_span_index8_ximage8( INDEX8_SPAN_ARGS )
-{
- struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- GLubyte *dst = PIXEL_ADDR1(xrb, x, y);
- if (mask) {
- GLuint i;
- for (i=0;i<n;i++) {
- if (mask[i]) {
- dst[i] = index[i];
- }
- }
- }
- else {
- MEMCPY( dst, index, n );
- }
-}
-
-
-
/**********************************************************************/
/*** Write INDEX PIXELS functions ***/
/**********************************************************************/
-#define INDEX_PIXELS_ARGS const GLcontext *ctx, \
- struct gl_renderbuffer *rb, \
- GLuint n, const GLint x[], const GLint y[], \
- const GLuint index[], const GLubyte mask[]
-
-
/*
* Write an array of CI pixels to a Pixmap.
*/
-static void write_pixels_index_pixmap( INDEX_PIXELS_ARGS )
+static void put_values_ci_pixmap( PUT_VALUES_ARGS )
{
+ const GLuint *index = (const GLuint *) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
XMesaDisplay *dpy = xmesa->xm_visual->display;
- XMesaDrawable buffer = xmesa->xm_buffer->buffer;
- XMesaGC gc = xmesa->xm_buffer->gc;
+ XMesaDrawable buffer = xrb->pixmap;
+ XMesaGC gc = XMESA_BUFFER(ctx->DrawBuffer)->gc;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
/*
* Write an array of CI pixels to an XImage.
*/
-static void write_pixels_index_ximage( INDEX_PIXELS_ARGS )
+static void put_values_ci_ximage( PUT_VALUES_ARGS )
{
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ const GLuint *index = (const GLuint *) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaImage *img = xmesa->xm_buffer->backimage;
+ XMesaImage *img = xrb->ximage;
register GLuint i;
for (i=0;i<n;i++) {
if (mask[i]) {
- XMesaPutPixel( img, x[i], YFLIP(xrb, y[i]), (unsigned long) index[i] );
+ XMesaPutPixel(img, x[i], YFLIP(xrb, y[i]), (unsigned long) index[i]);
}
}
}
* else return number of pixels to skip in the destination array.
*/
static int
-clip_for_xgetimage(XMesaContext xmesa, GLuint *n, GLint *x, GLint *y)
+clip_for_xgetimage(GLcontext *ctx, GLuint *n, GLint *x, GLint *y)
{
- XMesaBuffer source = xmesa->xm_buffer;
+ XMesaContext xmesa = XMESA_CONTEXT(ctx);
+ XMesaBuffer source = XMESA_BUFFER(ctx->DrawBuffer);
Window rootWin = RootWindow(xmesa->display, 0);
Window child;
GLint screenWidth = WidthOfScreen(DefaultScreenOfDisplay(xmesa->display));
GLint dx, dy;
- if (source->type == PBUFFER || source->type == PIXMAP)
+ if (source->type == PBUFFER)
return 0;
- XTranslateCoordinates(xmesa->display, source->frontbuffer, rootWin,
+ XTranslateCoordinates(xmesa->display, source->frontxrb->pixmap, rootWin,
*x, *y, &dx, &dy, &child);
if (dx >= screenWidth) {
/* totally clipped on right */
* Read a horizontal span of color-index pixels.
*/
static void
-read_index_span(const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, GLint x, GLint y, GLuint index[])
+get_row_ci(GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y, void *values)
{
+ GLuint *index = (GLuint *) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaBuffer source = xmesa->xm_buffer;
GLuint i;
y = YFLIP(xrb, y);
- if (source->buffer) {
+ if (xrb->pixmap) {
#ifndef XFree86Server
XMesaImage *span = NULL;
int error;
- int k = clip_for_xgetimage(xmesa, &n, &x, &y);
+ int k = clip_for_xgetimage(ctx, &n, &x, &y);
if (k < 0)
return;
index += k;
catch_xgetimage_errors( xmesa->display );
- span = XGetImage( xmesa->display, source->buffer,
+ span = XGetImage( xmesa->display, xrb->pixmap,
x, y, n, 1, AllPlanes, ZPixmap );
error = check_xgetimage_errors();
if (span && !error) {
~0L, (pointer)index);
#endif
}
- else if (source->backimage) {
- XMesaImage *img = source->backimage;
+ else if (xrb->ximage) {
+ XMesaImage *img = xrb->ximage;
for (i=0;i<n;i++,x++) {
index[i] = (GLuint) XMesaGetPixel( img, x, y );
}
* Read a horizontal span of color pixels.
*/
static void
-read_color_span( const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, GLint x, GLint y, GLubyte rgba[][4] )
+get_row_rgba(GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y, void *values)
{
+ GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- XMesaBuffer source = xmesa->xm_buffer;
+ XMesaBuffer source = XMESA_BUFFER(ctx->DrawBuffer);
- if (source->buffer) {
+ if (xrb->pixmap) {
/* Read from Pixmap or Window */
XMesaImage *span = NULL;
int error;
#else
int k;
y = YFLIP(xrb, y);
- k = clip_for_xgetimage(xmesa, &n, &x, &y);
+ k = clip_for_xgetimage(ctx, &n, &x, &y);
if (k < 0)
return;
rgba += k;
catch_xgetimage_errors( xmesa->display );
- span = XGetImage( xmesa->display, source->buffer,
+ span = XGetImage( xmesa->display, xrb->pixmap,
x, y, n, 1, AllPlanes, ZPixmap );
error = check_xgetimage_errors();
#endif
XMesaDestroyImage( span );
}
}
- else if (source->backimage) {
+ else if (xrb->ximage) {
/* Read from XImage back buffer */
switch (xmesa->pixelformat) {
case PF_Truecolor:
GLint rShift = xmesa->xm_visual->rshift;
GLint gShift = xmesa->xm_visual->gshift;
GLint bShift = xmesa->xm_visual->bshift;
- XMesaImage *img = source->backimage;
+ XMesaImage *img = xrb->ximage;
GLuint i;
y = YFLIP(xrb, y);
for (i=0;i<n;i++) {
}
}
else {
- XMesaImage *img = source->backimage;
+ XMesaImage *img = xrb->ximage;
GLuint i;
y = YFLIP(xrb, y);
for (i=0;i<n;i++,x++) {
break;
case PF_1Bit:
{
- XMesaImage *img = source->backimage;
+ XMesaImage *img = xrb->ximage;
int bitFlip = xmesa->xm_visual->bitFlip;
GLuint i;
y = YFLIP(xrb, y);
* Read an array of color index pixels.
*/
static void
-read_index_pixels( const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, const GLint x[], const GLint y[],
- GLuint indx[], const GLubyte mask[] )
+get_values_ci(GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, const GLint x[], const GLint y[], void *values)
{
+ GLuint *indx = (GLuint *) values;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
- register GLuint i;
- XMesaBuffer source = xmesa->xm_buffer;
-
- if (source->buffer) {
+ GLuint i;
+ if (xrb->pixmap) {
for (i=0;i<n;i++) {
- if (mask[i]) {
- indx[i] = (GLuint) read_pixel( xmesa->display,
- source->buffer,
- x[i], YFLIP(xrb, y[i]) );
- }
+ indx[i] = (GLuint) read_pixel( xmesa->display, xrb->pixmap,
+ x[i], YFLIP(xrb, y[i]) );
}
}
- else if (source->backimage) {
- XMesaImage *img = source->backimage;
+ else if (xrb->ximage) {
+ XMesaImage *img = xrb->ximage;
for (i=0;i<n;i++) {
- if (mask[i]) {
- indx[i] = (GLuint) XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) );
- }
+ indx[i] = (GLuint) XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) );
}
}
}
static void
-read_color_pixels( const GLcontext *ctx, struct gl_renderbuffer *rb,
- GLuint n, const GLint x[], const GLint y[],
- GLubyte rgba[][4], const GLubyte mask[] )
+get_values_rgba(GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, const GLint x[], const GLint y[], void *values)
{
+ GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
struct xmesa_renderbuffer *xrb = (struct xmesa_renderbuffer *) rb;
const XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaDisplay *dpy = xmesa->xm_visual->display;
+ XMesaBuffer source = XMESA_BUFFER(ctx->DrawBuffer);
register GLuint i;
- XMesaBuffer source = xmesa->xm_buffer;
- XMesaDrawable buffer = source->buffer; /* the X drawable */
- if (source->buffer) {
+ if (xrb->pixmap) {
+ XMesaDrawable buffer = xrb->pixmap;
switch (xmesa->pixelformat) {
case PF_Truecolor:
case PF_Dither_True:
GLint gShift = xmesa->xm_visual->gshift;
GLint bShift = xmesa->xm_visual->bshift;
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
- rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
- rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+ rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+ rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+ rgba[i][ACOMP] = 255;
}
}
break;
case PF_8A8B8G8R:
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = (GLubyte) ( p & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ((p >> 16) & 0xff);
- rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
}
break;
case PF_8A8R8G8B:
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
- rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
}
break;
case PF_8R8G8B:
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][ACOMP] = 255;
}
break;
case PF_8R8G8B24:
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p & 0xff);
+ rgba[i][ACOMP] = 255;
}
break;
case PF_HPCR:
- {
- for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = (GLubyte) ( p & 0xE0 );
- rgba[i][GCOMP] = (GLubyte) ((p & 0x1C) << 3);
- rgba[i][BCOMP] = (GLubyte) ((p & 0x03) << 6);
- rgba[i][ACOMP] = (GLubyte) 255;
- }
- }
+ for (i=0;i<n;i++) {
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = (GLubyte) ( p & 0xE0 );
+ rgba[i][GCOMP] = (GLubyte) ((p & 0x1C) << 3);
+ rgba[i][BCOMP] = (GLubyte) ((p & 0x03) << 6);
+ rgba[i][ACOMP] = (GLubyte) 255;
}
break;
case PF_Dither:
GLubyte *gTable = source->pixel_to_g;
GLubyte *bTable = source->pixel_to_b;
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = rTable[p];
- rgba[i][GCOMP] = gTable[p];
- rgba[i][BCOMP] = bTable[p];
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
}
}
break;
{
int bitFlip = xmesa->xm_visual->bitFlip;
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p = read_pixel( dpy, buffer,
- x[i], YFLIP(xrb, y[i])) ^ bitFlip;
- rgba[i][RCOMP] = (GLubyte) (p * 255);
- rgba[i][GCOMP] = (GLubyte) (p * 255);
- rgba[i][BCOMP] = (GLubyte) (p * 255);
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p = read_pixel( dpy, buffer,
+ x[i], YFLIP(xrb, y[i])) ^ bitFlip;
+ rgba[i][RCOMP] = (GLubyte) (p * 255);
+ rgba[i][GCOMP] = (GLubyte) (p * 255);
+ rgba[i][BCOMP] = (GLubyte) (p * 255);
+ rgba[i][ACOMP] = 255;
}
}
break;
return;
}
}
- else if (source->backimage) {
+ else if (xrb->ximage) {
/* Read from XImage back buffer */
switch (xmesa->pixelformat) {
case PF_Truecolor:
GLint rShift = xmesa->xm_visual->rshift;
GLint gShift = xmesa->xm_visual->gshift;
GLint bShift = xmesa->xm_visual->bshift;
- XMesaImage *img = source->backimage;
+ XMesaImage *img = xrb->ximage;
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p;
- p = XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
- rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
- rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p;
+ p = XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+ rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+ rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+ rgba[i][ACOMP] = 255;
}
}
break;
case PF_8A8B8G8R:
for (i=0;i<n;i++) {
- if (mask[i]) {
- GLuint *ptr4 = PIXEL_ADDR4(xrb, x[i], y[i]);
- GLuint p4 = *ptr4;
- rgba[i][RCOMP] = (GLubyte) ( p4 & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
- rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
- }
+ GLuint *ptr4 = PIXEL_ADDR4(xrb, x[i], y[i]);
+ GLuint p4 = *ptr4;
+ rgba[i][RCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
}
break;
case PF_8A8R8G8B:
for (i=0;i<n;i++) {
- if (mask[i]) {
- GLuint *ptr4 = PIXEL_ADDR4(xrb, x[i], y[i]);
- GLuint p4 = *ptr4;
- rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
- rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
- }
+ GLuint *ptr4 = PIXEL_ADDR4(xrb, x[i], y[i]);
+ GLuint p4 = *ptr4;
+ rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
}
break;
case PF_8R8G8B:
for (i=0;i<n;i++) {
- if (mask[i]) {
- GLuint *ptr4 = PIXEL_ADDR4(xrb, x[i], y[i]);
- GLuint p4 = *ptr4;
- rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
- rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
- rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
- rgba[i][ACOMP] = 255;
- }
+ GLuint *ptr4 = PIXEL_ADDR4(xrb, x[i], y[i]);
+ GLuint p4 = *ptr4;
+ rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+ rgba[i][GCOMP] = (GLubyte) ((p4 >> 8) & 0xff);
+ rgba[i][BCOMP] = (GLubyte) ( p4 & 0xff);
+ rgba[i][ACOMP] = 255;
}
break;
case PF_8R8G8B24:
for (i=0;i<n;i++) {
- if (mask[i]) {
- bgr_t *ptr3 = PIXEL_ADDR3(xrb, x[i], y[i]);
- rgba[i][RCOMP] = ptr3->r;
- rgba[i][GCOMP] = ptr3->g;
- rgba[i][BCOMP] = ptr3->b;
- rgba[i][ACOMP] = 255;
- }
+ bgr_t *ptr3 = PIXEL_ADDR3(xrb, x[i], y[i]);
+ rgba[i][RCOMP] = ptr3->r;
+ rgba[i][GCOMP] = ptr3->g;
+ rgba[i][BCOMP] = ptr3->b;
+ rgba[i][ACOMP] = 255;
}
break;
case PF_HPCR:
for (i=0;i<n;i++) {
- if (mask[i]) {
- GLubyte *ptr1 = PIXEL_ADDR1(xrb, x[i], y[i]);
- GLubyte p = *ptr1;
- rgba[i][RCOMP] = p & 0xE0;
- rgba[i][GCOMP] = (p & 0x1C) << 3;
- rgba[i][BCOMP] = (p & 0x03) << 6;
- rgba[i][ACOMP] = 255;
- }
+ GLubyte *ptr1 = PIXEL_ADDR1(xrb, x[i], y[i]);
+ GLubyte p = *ptr1;
+ rgba[i][RCOMP] = p & 0xE0;
+ rgba[i][GCOMP] = (p & 0x1C) << 3;
+ rgba[i][BCOMP] = (p & 0x03) << 6;
+ rgba[i][ACOMP] = 255;
}
break;
case PF_Dither:
GLubyte *rTable = source->pixel_to_r;
GLubyte *gTable = source->pixel_to_g;
GLubyte *bTable = source->pixel_to_b;
- XMesaImage *img = source->backimage;
+ XMesaImage *img = xrb->ximage;
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p;
- p = XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) );
- rgba[i][RCOMP] = rTable[p];
- rgba[i][GCOMP] = gTable[p];
- rgba[i][BCOMP] = bTable[p];
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p;
+ p = XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) );
+ rgba[i][RCOMP] = rTable[p];
+ rgba[i][GCOMP] = gTable[p];
+ rgba[i][BCOMP] = bTable[p];
+ rgba[i][ACOMP] = 255;
}
}
break;
case PF_1Bit:
{
- XMesaImage *img = source->backimage;
+ XMesaImage *img = xrb->ximage;
int bitFlip = xmesa->xm_visual->bitFlip;
for (i=0;i<n;i++) {
- if (mask[i]) {
- unsigned long p;
- p = XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) ) ^ bitFlip;
- rgba[i][RCOMP] = (GLubyte) (p * 255);
- rgba[i][GCOMP] = (GLubyte) (p * 255);
- rgba[i][BCOMP] = (GLubyte) (p * 255);
- rgba[i][ACOMP] = 255;
- }
+ unsigned long p;
+ p = XMesaGetPixel( img, x[i], YFLIP(xrb, y[i]) ) ^ bitFlip;
+ rgba[i][RCOMP] = (GLubyte) (p * 255);
+ rgba[i][GCOMP] = (GLubyte) (p * 255);
+ rgba[i][BCOMP] = (GLubyte) (p * 255);
+ rgba[i][ACOMP] = 255;
}
}
break;
}
-static void
-clear_color_HPCR_ximage( GLcontext *ctx, const GLfloat color[4] )
-{
- int i;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
-
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
-
- if (color[0] == 0.0 && color[1] == 0.0 && color[2] == 0.0) {
- /* black is black */
- MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
- sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
- }
- else {
- /* build clear pattern */
- for (i=0; i<16; i++) {
- xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i] =
- DITHER_HPCR(i, 0,
- xmesa->clearcolor[0],
- xmesa->clearcolor[1],
- xmesa->clearcolor[2]);
- xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i] =
- DITHER_HPCR(i, 1,
- xmesa->clearcolor[0],
- xmesa->clearcolor[1],
- xmesa->clearcolor[2]);
- }
- }
-}
-
-
-static void
-clear_color_HPCR_pixmap( GLcontext *ctx, const GLfloat color[4] )
-{
- int i;
- const XMesaContext xmesa = XMESA_CONTEXT(ctx);
-
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[0], color[0]);
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[1], color[1]);
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[2], color[2]);
- CLAMPED_FLOAT_TO_UBYTE(xmesa->clearcolor[3], color[3]);
-
- if (color[0] == 0.0 && color[1] == 0.0 && color[2] == 0.0) {
- /* black is black */
- for (i=0; i<16; i++) {
- XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
- XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, 0);
- }
- }
- else {
- for (i=0; i<16; i++) {
- XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
- DITHER_HPCR(i, 0,
- xmesa->clearcolor[0],
- xmesa->clearcolor[1],
- xmesa->clearcolor[2]));
- XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
- DITHER_HPCR(i, 1,
- xmesa->clearcolor[0],
- xmesa->clearcolor[1],
- xmesa->clearcolor[2]));
- }
- }
- /* change tile pixmap content */
- XMesaPutImage(xmesa->display,
- (XMesaDrawable)xmesa->xm_visual->hpcr_clear_pixmap,
- xmesa->xm_buffer->cleargc,
- xmesa->xm_visual->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
-}
-
-
-
-void xmesa_update_span_funcs( GLcontext *ctx )
-{
- XMesaContext xmesa = XMESA_CONTEXT(ctx);
- int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);
- struct swrast_device_driver *dd = _swrast_GetDeviceDriverReference( ctx );
-
- if (ctx->DrawBuffer->Name != 0) {
- /* drawing to user framebuffer */
- dd->WriteCI32Span = NULL;
- dd->WriteCI8Span = NULL;
- dd->WriteMonoCISpan = NULL;
- dd->WriteCI32Pixels = NULL;
- dd->WriteMonoCIPixels = NULL;
- dd->WriteRGBASpan = NULL;
- dd->WriteRGBSpan = NULL;
- dd->WriteMonoRGBASpan = NULL;
- dd->WriteRGBAPixels = NULL;
- dd->WriteMonoRGBAPixels = NULL;
- dd->ReadCI32Span = NULL;
- dd->ReadRGBASpan = NULL;
- dd->ReadCI32Pixels = NULL;
- dd->ReadRGBAPixels = NULL;
- return;
- }
-
- /*
- * These drawing functions depend on color buffer config:
- */
- if (xmesa->xm_buffer->buffer!=XIMAGE) {
- /* Writing to window or back pixmap */
- switch (xmesa->pixelformat) {
- case PF_Index:
- dd->WriteCI32Span = write_span_index_pixmap;
- dd->WriteCI8Span = write_span_index8_pixmap;
- dd->WriteMonoCISpan = write_span_mono_index_pixmap;
- dd->WriteCI32Pixels = write_pixels_index_pixmap;
- dd->WriteMonoCIPixels = write_pixels_mono_index_pixmap;
- break;
- case PF_Truecolor:
- dd->WriteRGBASpan = write_span_TRUECOLOR_pixmap;
- dd->WriteRGBSpan = write_span_rgb_TRUECOLOR_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_TRUECOLOR_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_Dither_True:
- dd->WriteRGBASpan = write_span_TRUEDITHER_pixmap;
- dd->WriteRGBSpan = write_span_rgb_TRUEDITHER_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
- dd->WriteRGBAPixels = write_pixels_TRUEDITHER_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
- break;
- case PF_8A8B8G8R:
- dd->WriteRGBASpan = write_span_8A8B8G8R_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8A8B8G8R_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8A8B8G8R_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_8A8R8G8B:
- dd->WriteRGBASpan = write_span_8A8R8G8B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8A8R8G8B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8A8R8G8B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_8R8G8B:
- dd->WriteRGBASpan = write_span_8R8G8B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8R8G8B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_8R8G8B24:
- dd->WriteRGBASpan = write_span_8R8G8B24_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B24_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8R8G8B24_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_5R6G5B:
- dd->WriteRGBASpan = write_span_5R6G5B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_5R6G5B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_5R6G5B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_Dither_5R6G5B:
- dd->WriteRGBASpan = write_span_DITHER_5R6G5B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
- dd->WriteRGBAPixels = write_pixels_DITHER_5R6G5B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
- break;
- case PF_Dither:
- dd->WriteRGBASpan = write_span_DITHER_pixmap;
- dd->WriteRGBSpan = write_span_rgb_DITHER_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER_pixmap;
- dd->WriteRGBAPixels = write_pixels_DITHER_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_pixmap;
- break;
- case PF_1Bit:
- dd->WriteRGBASpan = write_span_1BIT_pixmap;
- dd->WriteRGBSpan = write_span_rgb_1BIT_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_1BIT_pixmap;
- dd->WriteRGBAPixels = write_pixels_1BIT_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_1BIT_pixmap;
- break;
- case PF_HPCR:
- dd->WriteRGBASpan = write_span_HPCR_pixmap;
- dd->WriteRGBSpan = write_span_rgb_HPCR_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_HPCR_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- if (xmesa->xm_visual->hpcr_clear_flag) {
- ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
- }
- break;
- case PF_Lookup:
- dd->WriteRGBASpan = write_span_LOOKUP_pixmap;
- dd->WriteRGBSpan = write_span_rgb_LOOKUP_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_LOOKUP_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- case PF_Grayscale:
- dd->WriteRGBASpan = write_span_GRAYSCALE_pixmap;
- dd->WriteRGBSpan = write_span_rgb_GRAYSCALE_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_GRAYSCALE_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- break;
- default:
- _mesa_problem(ctx, "Bad pixel format in xmesa_update_state (1)");
- return;
- }
- }
- else if (xmesa->xm_buffer->buffer==XIMAGE) {
- /* Writing to back XImage */
- switch (xmesa->pixelformat) {
- case PF_Index:
- dd->WriteCI32Span = write_span_index_ximage;
- if (depth==8)
- dd->WriteCI8Span = write_span_index8_ximage8;
- else
- dd->WriteCI8Span = write_span_index8_ximage;
- dd->WriteMonoCISpan = write_span_mono_index_ximage;
- dd->WriteCI32Pixels = write_pixels_index_ximage;
- dd->WriteMonoCIPixels = write_pixels_mono_index_ximage;
- break;
- case PF_Truecolor:
- /* Generic RGB */
- dd->WriteRGBASpan = write_span_TRUECOLOR_ximage;
- dd->WriteRGBSpan = write_span_rgb_TRUECOLOR_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_TRUECOLOR_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
- break;
- case PF_Dither_True:
- dd->WriteRGBASpan = write_span_TRUEDITHER_ximage;
- dd->WriteRGBSpan = write_span_rgb_TRUEDITHER_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_ximage;
- dd->WriteRGBAPixels = write_pixels_TRUEDITHER_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_ximage;
- break;
- case PF_8A8B8G8R:
- dd->WriteRGBASpan = write_span_8A8B8G8R_ximage;
- dd->WriteRGBSpan = write_span_rgb_8A8B8G8R_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8A8B8G8R_ximage;
- dd->WriteRGBAPixels = write_pixels_8A8B8G8R_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8A8B8G8R_ximage;
- break;
- case PF_8A8R8G8B:
- dd->WriteRGBASpan = write_span_8A8R8G8B_ximage;
- dd->WriteRGBSpan = write_span_rgb_8A8R8G8B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8A8R8G8B_ximage;
- dd->WriteRGBAPixels = write_pixels_8A8R8G8B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8A8R8G8B_ximage;
- break;
- case PF_8R8G8B:
- dd->WriteRGBASpan = write_span_8R8G8B_ximage;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8R8G8B_ximage;
- dd->WriteRGBAPixels = write_pixels_8R8G8B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B_ximage;
- break;
- case PF_8R8G8B24:
- dd->WriteRGBASpan = write_span_8R8G8B24_ximage;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B24_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8R8G8B24_ximage;
- dd->WriteRGBAPixels = write_pixels_8R8G8B24_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B24_ximage;
- break;
- case PF_5R6G5B:
- dd->WriteRGBASpan = write_span_5R6G5B_ximage;
- dd->WriteRGBSpan = write_span_rgb_5R6G5B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_5R6G5B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
- break;
- case PF_Dither_5R6G5B:
- dd->WriteRGBASpan = write_span_DITHER_5R6G5B_ximage;
- dd->WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER_5R6G5B_ximage;
- dd->WriteRGBAPixels = write_pixels_DITHER_5R6G5B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_5R6G5B_ximage;
- break;
- case PF_Dither:
- if (depth==8) {
- dd->WriteRGBASpan = write_span_DITHER8_ximage;
- dd->WriteRGBSpan = write_span_rgb_DITHER8_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER8_ximage;
- dd->WriteRGBAPixels = write_pixels_DITHER8_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER8_ximage;
- }
- else {
- dd->WriteRGBASpan = write_span_DITHER_ximage;
- dd->WriteRGBSpan = write_span_rgb_DITHER_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER_ximage;
- dd->WriteRGBAPixels = write_pixels_DITHER_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_ximage;
- }
- break;
- case PF_1Bit:
- dd->WriteRGBASpan = write_span_1BIT_ximage;
- dd->WriteRGBSpan = write_span_rgb_1BIT_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_1BIT_ximage;
- dd->WriteRGBAPixels = write_pixels_1BIT_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_1BIT_ximage;
- break;
- case PF_HPCR:
- dd->WriteRGBASpan = write_span_HPCR_ximage;
- dd->WriteRGBSpan = write_span_rgb_HPCR_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_HPCR_ximage;
- dd->WriteRGBAPixels = write_pixels_HPCR_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_HPCR_ximage;
- if (xmesa->xm_visual->hpcr_clear_flag) {
- ctx->Driver.ClearColor = clear_color_HPCR_ximage;
- }
- break;
- case PF_Lookup:
- if (depth==8) {
- dd->WriteRGBASpan = write_span_LOOKUP8_ximage;
- dd->WriteRGBSpan = write_rgb_LOOKUP8_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_LOOKUP8_ximage;
- dd->WriteRGBAPixels = write_pixels_LOOKUP8_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_LOOKUP8_ximage;
- }
- else {
- dd->WriteRGBASpan = write_span_LOOKUP_ximage;
- dd->WriteRGBSpan = write_span_rgb_LOOKUP_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_LOOKUP_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
- }
- break;
- case PF_Grayscale:
- if (depth==8) {
- dd->WriteRGBASpan = write_span_GRAYSCALE8_ximage;
- dd->WriteRGBSpan = write_span_rgb_GRAYSCALE8_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_GRAYSCALE8_ximage;
- dd->WriteRGBAPixels = write_pixels_GRAYSCALE8_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_GRAYSCALE8_ximage;
- }
- else {
- dd->WriteRGBASpan = write_span_GRAYSCALE_ximage;
- dd->WriteRGBSpan = write_span_rgb_GRAYSCALE_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_GRAYSCALE_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
- }
- break;
- default:
- _mesa_problem(ctx, "Bad pixel format in xmesa_update_state (2)");
- return;
- }
- }
-
- /* Pixel/span reading functions: */
- dd->ReadCI32Span = read_index_span;
- dd->ReadRGBASpan = read_color_span;
- dd->ReadCI32Pixels = read_index_pixels;
- dd->ReadRGBAPixels = read_color_pixels;
-}
-
-
-#if 000
/**
- * Initialize the renderbuffer's PutRow, GetRow, etc. functions
+ * Initialize the renderbuffer's PutRow, GetRow, etc. functions.
+ * This would generally only need to be called once when the renderbuffer
+ * is created. However, we can change pixel formats on the fly if dithering
+ * is enabled/disabled. Therefore, we may call this more often than that.
*/
-static void
-xmesa_set_renderbuffer_funcs(GLcontext *ctx, struct xmesa_renderbuffer *xrb,
- GLboolean pixmap, enum pixel_format pixelformat)
+void
+xmesa_set_renderbuffer_funcs(struct xmesa_renderbuffer *xrb,
+ enum pixel_format pixelformat, GLint depth)
{
-#if 0
- XMesaContext xmesa = XMESA_CONTEXT(ctx);
- int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
-
-#endif
+ const GLboolean pixmap = xrb->pixmap ? GL_TRUE : GL_FALSE;
switch (pixelformat) {
case PF_Index:
+ ASSERT(xrb->Base.DataType == GL_UNSIGNED_INT);
if (pixmap) {
- /*
- dd->WriteCI32Span = write_span_index_pixmap;
- dd->WriteCI8Span = write_span_index8_pixmap;
- dd->WriteMonoCISpan = write_span_mono_index_pixmap;
- dd->WriteCI32Pixels = write_pixels_index_pixmap;
- dd->WriteMonoCIPixels = write_pixels_mono_index_pixmap;
- */
+ xrb->Base.PutRow = put_row_ci_pixmap;
+ xrb->Base.PutRowRGB = NULL;
+ xrb->Base.PutMonoRow = put_mono_row_ci_pixmap;
+ xrb->Base.PutValues = put_values_ci_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_ci_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_ci_ximage;
+ xrb->Base.PutRowRGB = NULL;
+ xrb->Base.PutMonoRow = put_mono_row_ci_ximage;
+ xrb->Base.PutValues = put_values_ci_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_ci_ximage;
}
break;
case PF_Truecolor:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_TRUECOLOR_pixmap;
- dd->WriteRGBSpan = write_span_rgb_TRUECOLOR_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_TRUECOLOR_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_TRUECOLOR_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_TRUECOLOR_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_TRUECOLOR_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_TRUECOLOR_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_TRUECOLOR_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_ximage;
+ xrb->Base.PutValues = put_values_TRUECOLOR_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_ximage;
}
break;
case PF_Dither_True:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_TRUEDITHER_pixmap;
- dd->WriteRGBSpan = write_span_rgb_TRUEDITHER_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
- dd->WriteRGBAPixels = write_pixels_TRUEDITHER_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
- */
+ xrb->Base.PutRow = put_row_TRUEDITHER_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_TRUEDITHER_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_TRUEDITHER_pixmap;
+ xrb->Base.PutValues = put_values_TRUEDITHER_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_TRUEDITHER_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_TRUEDITHER_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_TRUEDITHER_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_TRUEDITHER_ximage;
+ xrb->Base.PutValues = put_values_TRUEDITHER_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_TRUEDITHER_ximage;
}
break;
case PF_8A8B8G8R:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_8A8B8G8R_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8A8B8G8R_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8A8B8G8R_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_8A8B8G8R_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_8A8B8G8R_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_8A8B8G8R_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_8A8B8G8R_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_8A8B8G8R_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_8A8B8G8R_ximage;
+ xrb->Base.PutValues = put_values_8A8B8G8R_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_8A8B8G8R_ximage;
}
break;
case PF_8A8R8G8B:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_8A8R8G8B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8A8R8G8B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8A8R8G8B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_8A8R8G8B_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_8A8R8G8B_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_8A8R8G8B_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_8A8R8G8B_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_8A8R8G8B_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_8A8R8G8B_ximage;
+ xrb->Base.PutValues = put_values_8A8R8G8B_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_8A8R8G8B_ximage;
}
break;
case PF_8R8G8B:
- /*
- dd->WriteRGBASpan = write_span_8R8G8B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8R8G8B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
if (pixmap) {
- xrb->Base.PutRow = put_row_8R8G8B_pixmap;
- xrb->Base.PutMonoRow = put_mono_row_pixmap;
- xrb->Base.PutValues = put_values_8R8G8B_pixmap;
+ xrb->Base.PutRow = put_row_8R8G8B_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_8R8G8B_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_8R8G8B_pixmap;
xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
+ else {
+ xrb->Base.PutRow = put_row_8R8G8B_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_8R8G8B_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_8R8G8B_ximage;
+ xrb->Base.PutValues = put_values_8R8G8B_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_8R8G8B_ximage;
+ }
break;
case PF_8R8G8B24:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_8R8G8B24_pixmap;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B24_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_8R8G8B24_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_8R8G8B24_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_8R8G8B24_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_8R8G8B24_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_8R8G8B24_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_8R8G8B24_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_8R8G8B24_ximage;
+ xrb->Base.PutValues = put_values_8R8G8B24_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_8R8G8B24_ximage;
}
break;
case PF_5R6G5B:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_5R6G5B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_5R6G5B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_5R6G5B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_5R6G5B_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_5R6G5B_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_5R6G5B_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_5R6G5B_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_5R6G5B_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_ximage;
+ xrb->Base.PutValues = put_values_5R6G5B_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_ximage;
}
break;
case PF_Dither_5R6G5B:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_DITHER_5R6G5B_pixmap;
- dd->WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_pixmap;
- dd->WriteRGBAPixels = write_pixels_DITHER_5R6G5B_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
- */
+ xrb->Base.PutRow = put_row_DITHER_5R6G5B_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_DITHER_5R6G5B_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_TRUEDITHER_pixmap;
+ xrb->Base.PutValues = put_values_DITHER_5R6G5B_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_TRUEDITHER_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_DITHER_5R6G5B_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_DITHER_5R6G5B_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_DITHER_5R6G5B_ximage;
+ xrb->Base.PutValues = put_values_DITHER_5R6G5B_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_DITHER_5R6G5B_ximage;
}
break;
case PF_Dither:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_DITHER_pixmap;
- dd->WriteRGBSpan = write_span_rgb_DITHER_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER_pixmap;
- dd->WriteRGBAPixels = write_pixels_DITHER_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_pixmap;
- */
+ xrb->Base.PutRow = put_row_DITHER_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_DITHER_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_DITHER_pixmap;
+ xrb->Base.PutValues = put_values_DITHER_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_DITHER_pixmap;
}
else {
+ if (depth == 8) {
+ xrb->Base.PutRow = put_row_DITHER8_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_DITHER8_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_DITHER8_ximage;
+ xrb->Base.PutValues = put_values_DITHER8_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_DITHER8_ximage;
+ }
+ else {
+ xrb->Base.PutRow = put_row_DITHER_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_DITHER_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_DITHER_ximage;
+ xrb->Base.PutValues = put_values_DITHER_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_DITHER_ximage;
+ }
}
break;
case PF_1Bit:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_1BIT_pixmap;
- dd->WriteRGBSpan = write_span_rgb_1BIT_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_1BIT_pixmap;
- dd->WriteRGBAPixels = write_pixels_1BIT_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_1BIT_pixmap;
- */
+ xrb->Base.PutRow = put_row_1BIT_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_1BIT_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_1BIT_pixmap;
+ xrb->Base.PutValues = put_values_1BIT_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_1BIT_pixmap;
}
else {
+ xrb->Base.PutRow = put_row_1BIT_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_1BIT_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_1BIT_ximage;
+ xrb->Base.PutValues = put_values_1BIT_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_1BIT_ximage;
}
break;
case PF_HPCR:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_HPCR_pixmap;
- dd->WriteRGBSpan = write_span_rgb_HPCR_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_HPCR_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_HPCR_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_HPCR_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_HPCR_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
- }
- ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
+ xrb->Base.PutRow = put_row_HPCR_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_HPCR_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_HPCR_ximage;
+ xrb->Base.PutValues = put_values_HPCR_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_HPCR_ximage;
}
break;
case PF_Lookup:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_LOOKUP_pixmap;
- dd->WriteRGBSpan = write_span_rgb_LOOKUP_pixmap;
- dd->WriteRGBAPixels = write_pixels_LOOKUP_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_LOOKUP_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_LOOKUP_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_LOOKUP_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ if (depth==8) {
+ xrb->Base.PutRow = put_row_LOOKUP8_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_LOOKUP8_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_LOOKUP8_ximage;
+ xrb->Base.PutValues = put_values_LOOKUP8_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_LOOKUP8_ximage;
+ }
+ else {
+ xrb->Base.PutRow = put_row_LOOKUP_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_LOOKUP_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_ximage;
+ xrb->Base.PutValues = put_values_LOOKUP_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_ximage;
+ }
}
break;
case PF_Grayscale:
if (pixmap) {
- /*
- dd->WriteRGBASpan = write_span_GRAYSCALE_pixmap;
- dd->WriteRGBSpan = write_span_rgb_GRAYSCALE_pixmap;
- dd->WriteMonoRGBASpan = write_span_mono_pixmap;
- dd->WriteRGBAPixels = write_pixels_GRAYSCALE_pixmap;
- dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
- */
+ xrb->Base.PutRow = put_row_GRAYSCALE_pixmap;
+ xrb->Base.PutRowRGB = put_row_rgb_GRAYSCALE_pixmap;
+ xrb->Base.PutMonoRow = put_mono_row_pixmap;
+ xrb->Base.PutValues = put_values_GRAYSCALE_pixmap;
+ xrb->Base.PutMonoValues = put_mono_values_pixmap;
}
else {
+ if (depth == 8) {
+ xrb->Base.PutRow = put_row_GRAYSCALE8_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_GRAYSCALE8_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_GRAYSCALE8_ximage;
+ xrb->Base.PutValues = put_values_GRAYSCALE8_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_GRAYSCALE8_ximage;
+ }
+ else {
+ xrb->Base.PutRow = put_row_GRAYSCALE_ximage;
+ xrb->Base.PutRowRGB = put_row_rgb_GRAYSCALE_ximage;
+ xrb->Base.PutMonoRow = put_mono_row_ximage;
+ xrb->Base.PutValues = put_values_GRAYSCALE_ximage;
+ xrb->Base.PutMonoValues = put_mono_values_ximage;
+ }
}
break;
default:
- _mesa_problem(ctx, "Bad pixel format in xmesa_update_state (1)");
+ _mesa_problem(NULL, "Bad pixel format in xmesa_update_state (1)");
return;
}
-#if 0000
-#if 0
- /* Generic RGB */
- dd->WriteRGBASpan = write_span_TRUECOLOR_ximage;
- dd->WriteRGBSpan = write_span_rgb_TRUECOLOR_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_TRUECOLOR_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
-#endif
- break;
- case PF_Dither_True:
-#if 0
- dd->WriteRGBASpan = write_span_TRUEDITHER_ximage;
- dd->WriteRGBSpan = write_span_rgb_TRUEDITHER_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_TRUEDITHER_ximage;
- dd->WriteRGBAPixels = write_pixels_TRUEDITHER_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_ximage;
-#endif
- break;
- case PF_8A8B8G8R:
-#if 0
- dd->WriteRGBASpan = write_span_8A8B8G8R_ximage;
- dd->WriteRGBSpan = write_span_rgb_8A8B8G8R_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8A8B8G8R_ximage;
- dd->WriteRGBAPixels = write_pixels_8A8B8G8R_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8A8B8G8R_ximage;
-#endif
- break;
- case PF_8A8R8G8B:
-#if 0
- dd->WriteRGBASpan = write_span_8A8R8G8B_ximage;
- dd->WriteRGBSpan = write_span_rgb_8A8R8G8B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8A8R8G8B_ximage;
- dd->WriteRGBAPixels = write_pixels_8A8R8G8B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8A8R8G8B_ximage;
-#endif
- break;
- case PF_8R8G8B:
-#if 0
- dd->WriteRGBASpan = write_span_8R8G8B_ximage;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8R8G8B_ximage;
- dd->WriteRGBAPixels = write_pixels_8R8G8B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B_ximage;
-#endif
- break;
- case PF_8R8G8B24:
-#if 0
- dd->WriteRGBASpan = write_span_8R8G8B24_ximage;
- dd->WriteRGBSpan = write_span_rgb_8R8G8B24_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_8R8G8B24_ximage;
- dd->WriteRGBAPixels = write_pixels_8R8G8B24_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B24_ximage;
-#endif
- break;
- case PF_5R6G5B:
-#if 0
- dd->WriteRGBASpan = write_span_5R6G5B_ximage;
- dd->WriteRGBSpan = write_span_rgb_5R6G5B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_5R6G5B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
-#endif
- break;
- case PF_Dither_5R6G5B:
-#if 0
- dd->WriteRGBASpan = write_span_DITHER_5R6G5B_ximage;
- dd->WriteRGBSpan = write_span_rgb_DITHER_5R6G5B_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER_5R6G5B_ximage;
- dd->WriteRGBAPixels = write_pixels_DITHER_5R6G5B_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_5R6G5B_ximage;
-#endif
- break;
- case PF_Dither:
-#if 0
- if (depth==8) {
- dd->WriteRGBASpan = write_span_DITHER8_ximage;
- dd->WriteRGBSpan = write_span_rgb_DITHER8_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER8_ximage;
- dd->WriteRGBAPixels = write_pixels_DITHER8_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER8_ximage;
- }
- else {
- dd->WriteRGBASpan = write_span_DITHER_ximage;
- dd->WriteRGBSpan = write_span_rgb_DITHER_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_DITHER_ximage;
- dd->WriteRGBAPixels = write_pixels_DITHER_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_ximage;
- }
-#endif
- break;
- case PF_1Bit:
-#if 0
- dd->WriteRGBASpan = write_span_1BIT_ximage;
- dd->WriteRGBSpan = write_span_rgb_1BIT_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_1BIT_ximage;
- dd->WriteRGBAPixels = write_pixels_1BIT_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_1BIT_ximage;
-#endif
- break;
- case PF_HPCR:
-#if 0
- dd->WriteRGBASpan = write_span_HPCR_ximage;
- dd->WriteRGBSpan = write_span_rgb_HPCR_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_HPCR_ximage;
- dd->WriteRGBAPixels = write_pixels_HPCR_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_HPCR_ximage;
- if (xmesa->xm_visual->hpcr_clear_flag) {
- ctx->Driver.ClearColor = clear_color_HPCR_ximage;
- }
-#endif
- break;
- case PF_Lookup:
-#if 0
- if (depth==8) {
- dd->WriteRGBASpan = write_span_LOOKUP8_ximage;
- dd->WriteRGBSpan = write_rgb_LOOKUP8_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_LOOKUP8_ximage;
- dd->WriteRGBAPixels = write_pixels_LOOKUP8_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_LOOKUP8_ximage;
- }
- else {
- dd->WriteRGBASpan = write_span_LOOKUP_ximage;
- dd->WriteRGBSpan = write_span_rgb_LOOKUP_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_LOOKUP_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
- }
-#endif
- break;
- case PF_Grayscale:
-#if 0
- if (depth==8) {
- dd->WriteRGBASpan = write_span_GRAYSCALE8_ximage;
- dd->WriteRGBSpan = write_span_rgb_GRAYSCALE8_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_GRAYSCALE8_ximage;
- dd->WriteRGBAPixels = write_pixels_GRAYSCALE8_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_GRAYSCALE8_ximage;
- }
- else {
- dd->WriteRGBASpan = write_span_GRAYSCALE_ximage;
- dd->WriteRGBSpan = write_span_rgb_GRAYSCALE_ximage;
- dd->WriteMonoRGBASpan = write_span_mono_ximage;
- dd->WriteRGBAPixels = write_pixels_GRAYSCALE_ximage;
- dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
- }
-#endif
- break;
- default:
- _mesa_problem(ctx, "Bad pixel format in xmesa_update_state (2)");
- return;
- }
- }
-#endif
-
- /* Pixel/span reading functions: */
-#if 0
- rb->ReadCI32Span = read_index_span;
- dd->ReadRGBASpan = read_color_span;
- dd->ReadCI32Pixels = read_index_pixels;
- dd->ReadRGBAPixels = read_color_pixels;
-#else
- rb->GetRow = get_row_color;
- rb->GetValues = get_values_color;
-#endif
+ /* Get functions */
+ if (pixelformat == PF_Index) {
+ xrb->Base.GetRow = get_row_ci;
+ xrb->Base.GetValues = get_values_ci;
+ }
+ else {
+ xrb->Base.GetRow = get_row_rgba;
+ xrb->Base.GetValues = get_values_rgba;
+ }
}
-#endif
-
projects / mesa.git / commitdiff