X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fswrast%2Fs_drawpix.c;h=8e97b619bf29cbf75311fbd4d010ffb305065f87;hb=1c5ff572aaaf533377f91dbd4bcd4411d855fabc;hp=fb11af5e4416914549c4155d1752b6de02e62a8e;hpb=af197f5f8f182c04ab29cd3c7a18a0cb95a1d9b7;p=mesa.git diff --git a/src/mesa/swrast/s_drawpix.c b/src/mesa/swrast/s_drawpix.c index fb11af5e441..8e97b619bf2 100644 --- a/src/mesa/swrast/s_drawpix.c +++ b/src/mesa/swrast/s_drawpix.c @@ -1,10 +1,8 @@ -/* $Id: s_drawpix.c,v 1.21 2001/06/18 23:55:18 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 3.5 + * Version: 5.1 * - * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -26,22 +24,18 @@ #include "glheader.h" -#include "colormac.h" #include "context.h" #include "convolve.h" #include "image.h" #include "macros.h" -#include "mem.h" -#include "mmath.h" +#include "imports.h" #include "pixel.h" #include "s_context.h" #include "s_drawpix.h" -#include "s_fog.h" #include "s_pixeltex.h" #include "s_span.h" #include "s_stencil.h" -#include "s_texture.h" #include "s_zoom.h" @@ -54,7 +48,7 @@ * GL_FALSE if image was completely clipped away (draw nothing) */ GLboolean -_mesa_clip_pixelrect(const GLcontext *ctx, +_swrast_clip_pixelrect(const GLcontext *ctx, GLint *destX, GLint *destY, GLsizei *width, GLsizei *height, GLint *skipPixels, GLint *skipRows) @@ -103,15 +97,23 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, { SWcontext *swrast = SWRAST_CONTEXT(ctx); const struct gl_pixelstore_attrib *unpack = &ctx->Unpack; - GLchan rgb[MAX_WIDTH][3]; - GLchan rgba[MAX_WIDTH][4]; + struct sw_span span; + + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA); if (!ctx->Current.RasterPosValid) { return GL_TRUE; /* no-op */ } - if ((SWRAST_CONTEXT(ctx)->_RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0 - && ctx->Texture._ReallyEnabled == 0 + if (ctx->Depth.Test) + _swrast_span_default_z(ctx, &span); + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); + if (ctx->Texture._EnabledCoordUnits) + _swrast_span_default_texcoords(ctx, &span); + + if ((SWRAST_CONTEXT(ctx)->_RasterMask & ~CLIP_BIT) == 0 + && ctx->Texture._EnabledCoordUnits == 0 && unpack->Alignment == 1 && !unpack->SwapBytes && !unpack->LsbFirst) { @@ -132,7 +134,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, rowLength = width; /* If we're not using pixel zoom then do all clipping calculations - * now. Otherwise, we'll let the _mesa_write_zoomed_*_span() functions + * now. Otherwise, we'll let the _swrast_write_zoomed_*_span() functions * handle the clipping. */ if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) { @@ -186,7 +188,8 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* setup array of fragment Z value to pass to zoom function */ GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMaxF); GLint i; - ASSERT(drawWidth < MAX_WIDTH); + if (drawWidth > MAX_WIDTH) + return GL_FALSE; /* fall back to general case path */ for (i=0; irgb[i][0] = src[i]; + span.array->rgb[i][1] = src[i]; + span.array->rgb[i][2] = src[i]; } (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, - (CONST GLchan (*)[3]) rgb, NULL); + (CONST GLchan (*)[3]) span.array->rgb, NULL); src += rowLength; destY++; } @@ -307,13 +316,13 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, for (row=0; rowrgb[i][0] = src[i]; + span.array->rgb[i][1] = src[i]; + span.array->rgb[i][2] = src[i]; } destY--; (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY, - (CONST GLchan (*)[3]) rgb, NULL); + (CONST GLchan (*)[3]) span.array->rgb, NULL); src += rowLength; } } @@ -324,12 +333,15 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, for (row=0; rowrgb[i][0] = src[i]; + span.array->rgb[i][1] = src[i]; + span.array->rgb[i][2] = src[i]; } - _mesa_write_zoomed_rgb_span(ctx, drawWidth, destX, destY, - zSpan, 0, (CONST GLchan (*)[3]) rgb, zoomY0); + span.x = destX; + span.y = destY; + span.end = drawWidth; + _swrast_write_zoomed_rgb_span(ctx, &span, + (CONST GLchan (*)[3]) span.array->rgb, zoomY0, 0); src += rowLength; destY++; } @@ -350,13 +362,13 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint i; GLchan *ptr = src; for (i=0;irgba[i][0] = *ptr; + span.array->rgba[i][1] = *ptr; + span.array->rgba[i][2] = *ptr++; + span.array->rgba[i][3] = *ptr++; } (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (CONST GLchan (*)[4]) rgba, NULL); + (CONST GLchan (*)[4]) span.array->rgba, NULL); src += rowLength*2; destY++; } @@ -369,14 +381,14 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint i; GLchan *ptr = src; for (i=0;irgba[i][0] = *ptr; + span.array->rgba[i][1] = *ptr; + span.array->rgba[i][2] = *ptr++; + span.array->rgba[i][3] = *ptr++; } destY--; (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (CONST GLchan (*)[4]) rgba, NULL); + (CONST GLchan (*)[4]) span.array->rgba, NULL); src += rowLength*2; } } @@ -388,13 +400,16 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLchan *ptr = src; GLint i; for (i=0;irgba[i][0] = *ptr; + span.array->rgba[i][1] = *ptr; + span.array->rgba[i][2] = *ptr++; + span.array->rgba[i][3] = *ptr++; } - _mesa_write_zoomed_rgba_span(ctx, drawWidth, destX, destY, - zSpan, 0, (CONST GLchan (*)[4]) rgba, zoomY0); + span.x = destX; + span.y = destY; + span.end = drawWidth; + _swrast_write_zoomed_rgba_span(ctx, &span, + (CONST GLchan (*)[4]) span.array->rgba, zoomY0, 0); src += rowLength*2; destY++; } @@ -411,10 +426,9 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint row; for (row=0; rowrgba); (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (const GLchan (*)[4]) rgba, - NULL); + (const GLchan (*)[4]) span.array->rgba, NULL); src += rowLength; destY++; } @@ -425,11 +439,10 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint row; for (row=0; rowrgba); destY--; (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY, - (CONST GLchan (*)[4]) rgba, - NULL); + (CONST GLchan (*)[4]) span.array->rgba, NULL); src += rowLength; } return GL_TRUE; @@ -439,9 +452,12 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, GLint row; for (row=0; rowrgba); + span.x = destX; + span.y = destY; + span.end = drawWidth; + _swrast_write_zoomed_rgba_span(ctx, &span, + (CONST GLchan (*)[4]) span.array->rgba, zoomY0, 0); src += rowLength; destY++; } @@ -480,7 +496,7 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y, /* - * Do glDrawPixels of index pixels. + * Draw color index image. */ static void draw_index_pixels( GLcontext *ctx, GLint x, GLint y, @@ -488,58 +504,53 @@ draw_index_pixels( GLcontext *ctx, GLint x, GLint y, GLenum type, const GLvoid *pixels ) { const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; - const GLint desty = y; - GLint row, drawWidth; - GLdepth zspan[MAX_WIDTH]; - GLfloat fogSpan[MAX_WIDTH]; + GLint row, skipPixels; + struct sw_span span; - drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width; - - /* Fragment depth values */ - if (ctx->Depth.Test || ctx->Fog.Enabled) { - GLdepth zval = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMaxF); - GLfloat fog; - GLint i; - - if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT) { - fog = ctx->Current.RasterFogCoord; - } - else { - fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance); - } + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_INDEX); - for (i = 0; i < drawWidth; i++) { - zspan[i] = zval; - fogSpan[i] = fog; - } - } + if (ctx->Depth.Test) + _swrast_span_default_z(ctx, &span); + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); /* * General solution */ - for (row = 0; row < height; row++, y++) { - GLuint indexes[MAX_WIDTH]; - const GLvoid *source = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0); - _mesa_unpack_index_span(ctx, drawWidth, GL_UNSIGNED_INT, indexes, - type, source, &ctx->Unpack, - ctx->_ImageTransferState); - if (zoom) { - _mesa_write_zoomed_index_span(ctx, drawWidth, x, y, zspan, fogSpan, - indexes, desty); - } - else { - _mesa_write_index_span(ctx, drawWidth, x, y, zspan, fogSpan, indexes, - NULL, GL_BITMAP); - } + skipPixels = 0; + while (skipPixels < width) { + const GLint spanX = x + (zoom ? 0 : skipPixels); + GLint spanY = y; + const GLint spanEnd = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + ASSERT(spanEnd <= MAX_WIDTH); + for (row = 0; row < height; row++, span.y++) { + const GLvoid *source = _mesa_image_address(&ctx->Unpack, pixels, + width, height, + GL_COLOR_INDEX, type, + 0, row, skipPixels); + _mesa_unpack_index_span(ctx, span.end, GL_UNSIGNED_INT, + span.array->index, type, source, &ctx->Unpack, + ctx->_ImageTransferState); + + /* These may get changed during writing/clipping */ + span.x = spanX; + span.y = spanY; + span.end = spanEnd; + + if (zoom) + _swrast_write_zoomed_index_span(ctx, &span, y, skipPixels); + else + _swrast_write_index_span(ctx, &span); + } + skipPixels += spanEnd; } } /* - * Do glDrawPixels of stencil image. The image datatype may either - * be GLubyte or GLbitmap. + * Draw stencil image. */ static void draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y, @@ -548,7 +559,7 @@ draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y, { const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; const GLint desty = y; - GLint row, drawWidth; + GLint row, skipPixels; if (type != GL_BYTE && type != GL_UNSIGNED_BYTE && @@ -562,38 +573,53 @@ draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y, return; } - drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width; - - for (row = 0; row < height; row++, y++) { - GLstencil values[MAX_WIDTH]; - GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte)) - ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT; - const GLvoid *source = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0); - _mesa_unpack_index_span(ctx, drawWidth, destType, values, - type, source, &ctx->Unpack, - ctx->_ImageTransferState); - if (ctx->_ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) { - _mesa_shift_and_offset_stencil( ctx, drawWidth, values ); - } - if (ctx->Pixel.MapStencilFlag) { - _mesa_map_stencil( ctx, drawWidth, values ); - } + if (ctx->Visual.stencilBits == 0) { + _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawPixels(no stencil buffer)"); + return; + } - if (zoom) { - _mesa_write_zoomed_stencil_span( ctx, (GLuint) drawWidth, x, y, - values, desty ); - } - else { - _mesa_write_stencil_span( ctx, (GLuint) drawWidth, x, y, values ); + /* if width > MAX_WIDTH, have to process image in chunks */ + skipPixels = 0; + while (skipPixels < width) { + const GLint spanX = x; + GLint spanY = y; + const GLint spanWidth = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + + for (row = 0; row < height; row++, spanY++) { + GLstencil values[MAX_WIDTH]; + GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte)) + ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT; + const GLvoid *source = _mesa_image_address(&ctx->Unpack, pixels, + width, height, + GL_COLOR_INDEX, type, + 0, row, skipPixels); + _mesa_unpack_index_span(ctx, spanWidth, destType, values, + type, source, &ctx->Unpack, + ctx->_ImageTransferState); + if (ctx->_ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) { + _mesa_shift_and_offset_stencil(ctx, spanWidth, values); + } + if (ctx->Pixel.MapStencilFlag) { + _mesa_map_stencil(ctx, spanWidth, values); + } + + if (zoom) { + _swrast_write_zoomed_stencil_span(ctx, (GLuint) spanWidth, + spanX, spanY, values, desty, 0); + } + else { + _swrast_write_stencil_span(ctx, (GLuint) spanWidth, + spanX, spanY, values); + } } + skipPixels += spanWidth; } } - /* - * Do a glDrawPixels of depth values. + * Draw depth image. */ static void draw_depth_pixels( GLcontext *ctx, GLint x, GLint y, @@ -601,11 +627,11 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y, GLenum type, const GLvoid *pixels ) { const GLboolean bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0; - const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; + const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0; const GLint desty = y; - GLchan rgba[MAX_WIDTH][4]; - GLuint ispan[MAX_WIDTH]; - GLint drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width; + struct sw_span span; + + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_Z); if (type != GL_BYTE && type != GL_UNSIGNED_BYTE @@ -618,103 +644,101 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y, return; } - /* Colors or indexes */ - if (ctx->Visual.rgbMode) { - GLint i; - GLint r, g, b, a; - UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]); - UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]); - UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]); - UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]); - for (i = 0; i < drawWidth; i++) { - rgba[i][RCOMP] = r; - rgba[i][GCOMP] = g; - rgba[i][BCOMP] = b; - rgba[i][ACOMP] = a; - } - } - else { - GLint i; - for (i = 0; i < drawWidth; i++) { - ispan[i] = ctx->Current.RasterIndex; - } - } + _swrast_span_default_color(ctx, &span); - if (type==GL_UNSIGNED_SHORT && sizeof(GLdepth)==sizeof(GLushort) - && !bias_or_scale && !zoom && ctx->Visual.rgbMode) { + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); + if (ctx->Texture._EnabledCoordUnits) + _swrast_span_default_texcoords(ctx, &span); + + if (type == GL_UNSIGNED_SHORT && ctx->Visual.depthBits == 16 + && !bias_or_scale && !zoom && ctx->Visual.rgbMode + && width < MAX_WIDTH) { /* Special case: directly write 16-bit depth values */ GLint row; - for (row = 0; row < height; row++, y++) { - GLdepth zspan[MAX_WIDTH]; + span.x = x; + span.y = y; + span.end = width; + for (row = 0; row < height; row++, span.y++) { const GLushort *zptr = (const GLushort *) _mesa_image_address(&ctx->Unpack, pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); GLint i; for (i = 0; i < width; i++) - zspan[i] = zptr[i]; - _mesa_write_rgba_span(ctx, width, x, y, zspan, 0, rgba, - NULL, GL_BITMAP); + span.array->z[i] = zptr[i]; + _swrast_write_rgba_span(ctx, &span); } } - else if (type==GL_UNSIGNED_INT && ctx->Visual.depthBits == 32 - && !bias_or_scale && !zoom && ctx->Visual.rgbMode) { + else if (type == GL_UNSIGNED_INT && ctx->Visual.depthBits == 32 + && !bias_or_scale && !zoom && ctx->Visual.rgbMode + && width < MAX_WIDTH) { /* Special case: directly write 32-bit depth values */ GLint row; - for (row = 0; row < height; row++, y++) { + span.x = x; + span.y = y; + span.end = width; + for (row = 0; row < height; row++, span.y++) { const GLuint *zptr = (const GLuint *) _mesa_image_address(&ctx->Unpack, pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); - _mesa_write_rgba_span(ctx, width, x, y, zptr, 0, rgba, - NULL, GL_BITMAP); + MEMCPY(span.array->z, zptr, width * sizeof(GLdepth)); + _swrast_write_rgba_span(ctx, &span); } } else { /* General case */ - GLint row; - for (row = 0; row < height; row++, y++) { - GLfloat fspan[MAX_WIDTH]; - GLdepth zspan[MAX_WIDTH]; - const GLvoid *src = _mesa_image_address(&ctx->Unpack, - pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0); - _mesa_unpack_depth_span( ctx, drawWidth, fspan, type, src, - &ctx->Unpack ); - /* clamp depth values to [0,1] and convert from floats to integers */ - { - const GLfloat zs = ctx->DepthMaxF; - GLint i; - for (i = 0; i < drawWidth; i++) { - zspan[i] = (GLdepth) (fspan[i] * zs); + GLint row, skipPixels = 0; + + /* in case width > MAX_WIDTH do the copy in chunks */ + while (skipPixels < width) { + const GLint spanX = x + (zoom ? 0 : skipPixels); + GLint spanY = y; + const GLint spanEnd = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + ASSERT(span.end <= MAX_WIDTH); + for (row = 0; row < height; row++, spanY++) { + GLfloat floatSpan[MAX_WIDTH]; + const GLvoid *src = _mesa_image_address(&ctx->Unpack, + pixels, width, height, + GL_DEPTH_COMPONENT, type, + 0, row, skipPixels); + + /* Set these for each row since the _swrast_write_* function may + * change them while clipping. + */ + span.x = spanX; + span.y = spanY; + span.end = spanEnd; + + _mesa_unpack_depth_span(ctx, span.end, floatSpan, type, + src, &ctx->Unpack); + /* clamp depth values to [0,1] and convert from floats to ints */ + { + const GLfloat zs = ctx->DepthMaxF; + GLuint i; + for (i = 0; i < span.end; i++) { + span.array->z[i] = (GLdepth) (floatSpan[i] * zs + 0.5F); + } } - } - - if (ctx->Visual.rgbMode) { if (zoom) { - _mesa_write_zoomed_rgba_span(ctx, width, x, y, zspan, 0, - (const GLchan (*)[4]) rgba, desty); + _swrast_write_zoomed_depth_span(ctx, &span, desty, skipPixels); } - else { - _mesa_write_rgba_span(ctx, width, x, y, zspan, 0, - rgba, NULL, GL_BITMAP); - } - } - else { - if (zoom) { - _mesa_write_zoomed_index_span(ctx, width, x, y, zspan, 0, - ispan, GL_BITMAP); + else if (ctx->Visual.rgbMode) { + _swrast_write_rgba_span(ctx, &span); } else { - _mesa_write_index_span(ctx, width, x, y, zspan, 0, - ispan, NULL, GL_BITMAP); + _swrast_write_index_span(ctx, &span); } } - + skipPixels += spanEnd; } } } + /* - * Do glDrawPixels of RGBA pixels. + * Draw RGBA image. */ static void draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, @@ -725,11 +749,12 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, const struct gl_pixelstore_attrib *unpack = &ctx->Unpack; const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0; const GLint desty = y; - GLdepth zspan[MAX_WIDTH]; - GLfloat fogSpan[MAX_WIDTH]; GLboolean quickDraw; GLfloat *convImage = NULL; GLuint transferOps = ctx->_ImageTransferState; + struct sw_span span; + + INIT_SPAN(span, GL_BITMAP, 0, 0, SPAN_RGBA); if (!_mesa_is_legal_format_and_type(format, type)) { _mesa_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)"); @@ -740,30 +765,16 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, if (fast_draw_pixels(ctx, x, y, width, height, format, type, pixels)) return; - /* Fragment depth values */ - if (ctx->Depth.Test || ctx->Fog.Enabled) { - /* fill in array of z values */ - GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMaxF); - GLfloat fog; - GLint i; - - if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT) { - fog = ctx->Current.RasterFogCoord; - } - else { - fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance); - } - - for (i=0;iDepth.Test) + _swrast_span_default_z(ctx, &span); + if (ctx->Fog.Enabled) + _swrast_span_default_fog(ctx, &span); + if (ctx->Texture._EnabledCoordUnits) + _swrast_span_default_texcoords(ctx, &span); if (SWRAST_CONTEXT(ctx)->_RasterMask == 0 && !zoom && x >= 0 && y >= 0 - && x + width <= ctx->DrawBuffer->Width - && y + height <= ctx->DrawBuffer->Height) { + && x + width <= (GLint) ctx->DrawBuffer->Width + && y + height <= (GLint) ctx->DrawBuffer->Height) { quickDraw = GL_TRUE; } else { @@ -826,62 +837,59 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y, * General solution */ { - GLchan rgba[MAX_WIDTH][4]; - GLint row; - if (width > MAX_WIDTH) - width = MAX_WIDTH; - for (row = 0; row < height; row++, y++) { - const GLvoid *source = _mesa_image_address(unpack, - pixels, width, height, format, type, 0, row, 0); - _mesa_unpack_chan_color_span(ctx, width, GL_RGBA, (GLchan *) rgba, - format, type, source, unpack, - transferOps); - if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) || - (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink)) - continue; - - if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) { - GLchan primary_rgba[MAX_WIDTH][4]; - GLuint unit; - DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */ - DEFARRAY(GLfloat, t, MAX_WIDTH); - DEFARRAY(GLfloat, r, MAX_WIDTH); - DEFARRAY(GLfloat, q, MAX_WIDTH); - CHECKARRAY(s, return); /* mac 32k limitation */ - CHECKARRAY(t, return); - CHECKARRAY(r, return); - CHECKARRAY(q, return); - - /* XXX not sure how multitexture is supposed to work here */ - MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan)); - - for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) { - if (ctx->Texture.Unit[unit]._ReallyEnabled) { - _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba, - s, t, r, q); - _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL, - (CONST GLchan (*)[4]) primary_rgba, - rgba); - } + const GLuint interpMask = span.interpMask; + const GLuint arrayMask = span.arrayMask; + GLint row, skipPixels = 0; + + /* if the span is wider than MAX_WIDTH we have to do it in chunks */ + while (skipPixels < width) { + const GLint spanX = x + (zoom ? 0 : skipPixels); + GLint spanY = y; + const GLint spanEnd = (width - skipPixels > MAX_WIDTH) + ? MAX_WIDTH : (width - skipPixels); + ASSERT(span.end <= MAX_WIDTH); + + for (row = 0; row < height; row++, spanY++) { + const GLvoid *source = _mesa_image_address(unpack, + pixels, width, height, format, type, 0, row, skipPixels); + + /* Set these for each row since the _swrast_write_* function may + * change them while clipping. + */ + span.x = spanX; + span.y = spanY; + span.end = spanEnd; + span.arrayMask = arrayMask; + span.interpMask = interpMask; + + _mesa_unpack_chan_color_span(ctx, span.end, GL_RGBA, + (GLchan *) span.array->rgba, + format, type, source, unpack, + transferOps); + + if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) || + (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink)) + continue; + + if (ctx->Pixel.PixelTextureEnabled && ctx->Texture._EnabledUnits) { + _swrast_pixel_texture(ctx, &span); } - UNDEFARRAY(s); /* mac 32k limitation */ - UNDEFARRAY(t); - UNDEFARRAY(r); - UNDEFARRAY(q); - } - if (quickDraw) { - (*swrast->Driver.WriteRGBASpan)(ctx, width, x, y, - (CONST GLchan (*)[4]) rgba, NULL); - } - else if (zoom) { - _mesa_write_zoomed_rgba_span(ctx, width, x, y, zspan, fogSpan, - (CONST GLchan (*)[4]) rgba, desty); - } - else { - _mesa_write_rgba_span(ctx, (GLuint) width, x, y, zspan, fogSpan, - rgba, NULL, GL_BITMAP); + /* draw the span */ + if (quickDraw) { + (*swrast->Driver.WriteRGBASpan)(ctx, span.end, span.x, span.y, + (CONST GLchan (*)[4]) span.array->rgba, NULL); + } + else if (zoom) { + _swrast_write_zoomed_rgba_span(ctx, &span, + (CONST GLchan (*)[4]) span.array->rgba, desty, skipPixels); + } + else { + _swrast_write_rgba_span(ctx, &span); + } } + + skipPixels += spanEnd; } } @@ -906,7 +914,6 @@ _swrast_DrawPixels( GLcontext *ctx, SWcontext *swrast = SWRAST_CONTEXT(ctx); (void) unpack; - if (swrast->NewState) _swrast_validate_derived( ctx ); @@ -944,3 +951,55 @@ _swrast_DrawPixels( GLcontext *ctx, RENDER_FINISH(swrast,ctx); } + + + +#if 0 /* experimental */ +/* + * Execute glDrawDepthPixelsMESA(). + */ +void +_swrast_DrawDepthPixelsMESA( GLcontext *ctx, + GLint x, GLint y, + GLsizei width, GLsizei height, + GLenum colorFormat, GLenum colorType, + const GLvoid *colors, + GLenum depthType, const GLvoid *depths, + const struct gl_pixelstore_attrib *unpack ) +{ + SWcontext *swrast = SWRAST_CONTEXT(ctx); + (void) unpack; + + if (swrast->NewState) + _swrast_validate_derived( ctx ); + + RENDER_START(swrast,ctx); + + switch (colorFormat) { + case GL_COLOR_INDEX: + if (ctx->Visual.rgbMode) + draw_rgba_pixels(ctx, x,y, width, height, colorFormat, colorType, colors); + else + draw_index_pixels(ctx, x, y, width, height, colorType, colors); + break; + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + case GL_LUMINANCE: + case GL_LUMINANCE_ALPHA: + case GL_RGB: + case GL_BGR: + case GL_RGBA: + case GL_BGRA: + case GL_ABGR_EXT: + draw_rgba_pixels(ctx, x, y, width, height, colorFormat, colorType, colors); + break; + default: + _mesa_error( ctx, GL_INVALID_ENUM, + "glDrawDepthPixelsMESA(colorFormat)" ); + } + + RENDER_FINISH(swrast,ctx); +} +#endif