/*
* Mesa 3-D graphics library
- * Version: 6.5
+ * Version: 7.1
*
- * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2008 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"),
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#include "glheader.h"
-#include "macros.h"
-#include "imports.h"
-#include "colormac.h"
+#include "main/glheader.h"
+#include "main/macros.h"
+#include "main/imports.h"
+#include "main/colormac.h"
#include "s_context.h"
#include "s_span.h"
#include "s_zoom.h"
-/*
- * Helper function called from _swrast_write_zoomed_rgba/rgb/index_span().
+/**
+ * Compute the bounds of the region resulting from zooming a pixel span.
+ * The resulting region will be entirely inside the window/scissor bounds
+ * so no additional clipping is needed.
+ * \param imageX, imageY position of the mage being drawn (gl WindowPos)
+ * \param spanX, spanY position of span being drawing
+ * \param width number of pixels in span
+ * \param x0, x1 returned X bounds of zoomed region [x0, x1)
+ * \param y0, y1 returned Y bounds of zoomed region [y0, y1)
+ * \return GL_TRUE if any zoomed pixels visible, GL_FALSE if totally clipped
+ */
+static GLboolean
+compute_zoomed_bounds(GLcontext *ctx, GLint imageX, GLint imageY,
+ GLint spanX, GLint spanY, GLint width,
+ GLint *x0, GLint *x1, GLint *y0, GLint *y1)
+{
+ const struct gl_framebuffer *fb = ctx->DrawBuffer;
+ GLint c0, c1, r0, r1;
+
+ ASSERT(spanX >= imageX);
+ ASSERT(spanY >= imageY);
+
+ /*
+ * Compute destination columns: [c0, c1)
+ */
+ c0 = imageX + (GLint) ((spanX - imageX) * ctx->Pixel.ZoomX);
+ c1 = imageX + (GLint) ((spanX + width - imageX) * ctx->Pixel.ZoomX);
+ if (c1 < c0) {
+ /* swap */
+ GLint tmp = c1;
+ c1 = c0;
+ c0 = tmp;
+ }
+ c0 = CLAMP(c0, fb->_Xmin, fb->_Xmax);
+ c1 = CLAMP(c1, fb->_Xmin, fb->_Xmax);
+ if (c0 == c1) {
+ return GL_FALSE; /* no width */
+ }
+
+ /*
+ * Compute destination rows: [r0, r1)
+ */
+ r0 = imageY + (GLint) ((spanY - imageY) * ctx->Pixel.ZoomY);
+ r1 = imageY + (GLint) ((spanY + 1 - imageY) * ctx->Pixel.ZoomY);
+ if (r1 < r0) {
+ /* swap */
+ GLint tmp = r1;
+ r1 = r0;
+ r0 = tmp;
+ }
+ r0 = CLAMP(r0, fb->_Ymin, fb->_Ymax);
+ r1 = CLAMP(r1, fb->_Ymin, fb->_Ymax);
+ if (r0 == r1) {
+ return GL_FALSE; /* no height */
+ }
+
+ *x0 = c0;
+ *x1 = c1;
+ *y0 = r0;
+ *y1 = r1;
+
+ return GL_TRUE;
+}
+
+
+/**
+ * Convert a zoomed x image coordinate back to an unzoomed x coord.
+ * 'zx' is screen position of a pixel in the zoomed image, who's left edge
+ * is at 'imageX'.
+ * return corresponding x coord in the original, unzoomed image.
+ * This can use this for unzooming X or Y values.
+ */
+static INLINE GLint
+unzoom_x(GLfloat zoomX, GLint imageX, GLint zx)
+{
+ /*
+ zx = imageX + (x - imageX) * zoomX;
+ zx - imageX = (x - imageX) * zoomX;
+ (zx - imageX) / zoomX = x - imageX;
+ */
+ GLint x;
+ if (zoomX < 0.0)
+ zx++;
+ x = imageX + (GLint) ((zx - imageX) / zoomX);
+ return x;
+}
+
+
+
+/**
+ * Helper function called from _swrast_write_zoomed_rgba/rgb/
+ * index/depth_span().
*/
static void
-zoom_span( GLcontext *ctx, const struct sw_span *span,
- const GLvoid *src, GLint y0, GLenum format, GLint skipPixels )
+zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const SWspan *span,
+ const GLvoid *src, GLenum format )
{
- GLint r0, r1, row;
- GLint c0, c1, skipCol;
- GLint i, j;
- const GLuint maxWidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
- struct sw_span zoomed;
- struct span_arrays zoomed_arrays; /* this is big! */
+ SWcontext *swrast = SWRAST_CONTEXT(ctx);
+ SWspan zoomed;
+ GLint x0, x1, y0, y1;
+ GLint zoomedWidth;
+
+ if (!compute_zoomed_bounds(ctx, imgX, imgY, span->x, span->y, span->end,
+ &x0, &x1, &y0, &y1)) {
+ return; /* totally clipped */
+ }
+
+ if (!swrast->ZoomedArrays) {
+ /* allocate on demand */
+ swrast->ZoomedArrays = (SWspanarrays *) CALLOC(sizeof(SWspanarrays));
+ if (!swrast->ZoomedArrays)
+ return;
+ }
+
+ zoomedWidth = x1 - x0;
+ ASSERT(zoomedWidth > 0);
+ ASSERT(zoomedWidth <= MAX_WIDTH);
/* no pixel arrays! must be horizontal spans. */
ASSERT((span->arrayMask & SPAN_XY) == 0);
ASSERT(span->primitive == GL_BITMAP);
- INIT_SPAN(zoomed, GL_BITMAP, 0, 0, 0);
- zoomed.array = &zoomed_arrays;
-
- /* copy fog interp info */
- zoomed.fog = span->fog;
- zoomed.fogStep = span->fogStep;
- /* XXX copy texcoord info? */
+ INIT_SPAN(zoomed, GL_BITMAP);
+ zoomed.x = x0;
+ zoomed.end = zoomedWidth;
+ zoomed.array = swrast->ZoomedArrays;
+ zoomed.array->ChanType = span->array->ChanType;
+ if (zoomed.array->ChanType == GL_UNSIGNED_BYTE)
+ zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->rgba8;
+ else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT)
+ zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->rgba16;
+ else
+ zoomed.array->rgba = (GLchan (*)[4]) zoomed.array->attribs[FRAG_ATTRIB_COL0];
+
+ COPY_4V(zoomed.attrStart[FRAG_ATTRIB_WPOS], span->attrStart[FRAG_ATTRIB_WPOS]);
+ COPY_4V(zoomed.attrStepX[FRAG_ATTRIB_WPOS], span->attrStepX[FRAG_ATTRIB_WPOS]);
+ COPY_4V(zoomed.attrStepY[FRAG_ATTRIB_WPOS], span->attrStepY[FRAG_ATTRIB_WPOS]);
+
+ zoomed.attrStart[FRAG_ATTRIB_FOGC][0] = span->attrStart[FRAG_ATTRIB_FOGC][0];
+ zoomed.attrStepX[FRAG_ATTRIB_FOGC][0] = span->attrStepX[FRAG_ATTRIB_FOGC][0];
+ zoomed.attrStepY[FRAG_ATTRIB_FOGC][0] = span->attrStepY[FRAG_ATTRIB_FOGC][0];
if (format == GL_RGBA || format == GL_RGB) {
/* copy Z info */
/* we'll generate an array of colorss */
zoomed.interpMask = span->interpMask & ~SPAN_RGBA;
zoomed.arrayMask |= SPAN_RGBA;
- }
- else if (format == GL_COLOR_INDEX) {
- /* copy Z info */
- zoomed.z = span->z;
- zoomed.zStep = span->zStep;
- /* we'll generate an array of color indexes */
- zoomed.interpMask = span->interpMask & ~SPAN_INDEX;
- zoomed.arrayMask |= SPAN_INDEX;
+ zoomed.arrayAttribs |= FRAG_BIT_COL0; /* we'll produce these values */
+ ASSERT(span->arrayMask & SPAN_RGBA);
}
else if (format == GL_DEPTH_COMPONENT) {
/* Copy color info */
/* we'll generate an array of depth values */
zoomed.interpMask = span->interpMask & ~SPAN_Z;
zoomed.arrayMask |= SPAN_Z;
- }
- else if (format == GL_DEPTH_COMPONENT16 ||
- format == GL_DEPTH_COMPONENT32) {
- /* writing Z values directly to depth buffer, bypassing fragment ops */
+ ASSERT(span->arrayMask & SPAN_Z);
}
else {
_mesa_problem(ctx, "Bad format in zoom_span");
return;
}
- /*
- * Compute which columns to draw: [c0, c1)
- */
- c0 = (GLint) (span->x + skipPixels * ctx->Pixel.ZoomX);
- c1 = (GLint) (span->x + (skipPixels + span->end) * ctx->Pixel.ZoomX);
- if (c0 == c1) {
- return;
- }
- else if (c1 < c0) {
- /* swap */
- GLint ctmp = c1;
- c1 = c0;
- c0 = ctmp;
- }
- if (c0 < 0) {
- zoomed.x = 0;
- zoomed.start = 0;
- zoomed.end = c1;
- skipCol = -c0;
- }
- else {
- zoomed.x = c0;
- zoomed.start = 0;
- zoomed.end = c1 - c0;
- skipCol = 0;
- }
- if (zoomed.end > maxWidth)
- zoomed.end = maxWidth;
-
- /*
- * Compute which rows to draw: [r0, r1)
- */
- row = span->y - y0;
- r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
- r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
- if (r0 == r1) {
- return;
- }
- else if (r1 < r0) {
- /* swap */
- GLint rtmp = r1;
- r1 = r0;
- r0 = rtmp;
- }
-
- ASSERT(r0 < r1);
- ASSERT(c0 < c1);
-
- /*
- * Trivial clip rejection testing.
- */
- if (r1 < 0) /* below window */
- return;
- if (r0 >= (GLint) ctx->DrawBuffer->Height) /* above window */
- return;
- if (c1 < 0) /* left of window */
- return;
- if (c0 >= (GLint) ctx->DrawBuffer->Width) /* right of window */
- return;
-
/* zoom the span horizontally */
if (format == GL_RGBA) {
- const GLchan (*rgba)[4] = (const GLchan (*)[4]) src;
- if (ctx->Pixel.ZoomX == -1.0F) {
- /* common case */
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = span->end - (j + skipCol) - 1;
- COPY_CHAN4(zoomed.array->rgba[j], rgba[i]);
+ if (zoomed.array->ChanType == GL_UNSIGNED_BYTE) {
+ const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) src;
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < (GLint) span->end);
+ COPY_4UBV(zoomed.array->rgba8[i], rgba[j]);
+ }
+ }
+ else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT) {
+ const GLushort (*rgba)[4] = (const GLushort (*)[4]) src;
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < (GLint) span->end);
+ COPY_4V(zoomed.array->rgba16[i], rgba[j]);
}
}
else {
- /* general solution */
- const GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = (GLint) ((j + skipCol) * xscale);
- if (ctx->Pixel.ZoomX < 0.0) {
- ASSERT(i <= 0);
- i = span->end + i - 1;
- }
- ASSERT(i >= 0);
- ASSERT(i < (GLint) span->end);
- COPY_CHAN4(zoomed.array->rgba[j], rgba[i]);
+ const GLfloat (*rgba)[4] = (const GLfloat (*)[4]) src;
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < span->end);
+ COPY_4V(zoomed.array->attribs[FRAG_ATTRIB_COL0][i], rgba[j]);
}
}
}
else if (format == GL_RGB) {
- const GLchan (*rgb)[3] = (const GLchan (*)[3]) src;
- if (ctx->Pixel.ZoomX == -1.0F) {
- /* common case */
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = span->end - (j + skipCol) - 1;
- zoomed.array->rgba[j][0] = rgb[i][0];
- zoomed.array->rgba[j][1] = rgb[i][1];
- zoomed.array->rgba[j][2] = rgb[i][2];
- zoomed.array->rgba[j][3] = CHAN_MAX;
+ if (zoomed.array->ChanType == GL_UNSIGNED_BYTE) {
+ const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) src;
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < (GLint) span->end);
+ zoomed.array->rgba8[i][0] = rgb[j][0];
+ zoomed.array->rgba8[i][1] = rgb[j][1];
+ zoomed.array->rgba8[i][2] = rgb[j][2];
+ zoomed.array->rgba8[i][3] = 0xff;
}
}
- else {
- /* general solution */
- const GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = (GLint) ((j + skipCol) * xscale);
- if (ctx->Pixel.ZoomX < 0.0) {
- ASSERT(i <= 0);
- i = span->end + i - 1;
- }
- ASSERT(i >= 0);
- ASSERT(i < (GLint) span->end);
- zoomed.array->rgba[j][0] = rgb[i][0];
- zoomed.array->rgba[j][1] = rgb[i][1];
- zoomed.array->rgba[j][2] = rgb[i][2];
- zoomed.array->rgba[j][3] = CHAN_MAX;
- }
- }
- }
- else if (format == GL_COLOR_INDEX) {
- const GLuint *indexes = (const GLuint *) src;
- if (ctx->Pixel.ZoomX == -1.0F) {
- /* common case */
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = span->end - (j + skipCol) - 1;
- zoomed.array->index[j] = indexes[i];
+ else if (zoomed.array->ChanType == GL_UNSIGNED_SHORT) {
+ const GLushort (*rgb)[3] = (const GLushort (*)[3]) src;
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < (GLint) span->end);
+ zoomed.array->rgba16[i][0] = rgb[j][0];
+ zoomed.array->rgba16[i][1] = rgb[j][1];
+ zoomed.array->rgba16[i][2] = rgb[j][2];
+ zoomed.array->rgba16[i][3] = 0xffff;
}
}
else {
- /* general solution */
- const GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = (GLint) ((j + skipCol) * xscale);
- if (ctx->Pixel.ZoomX < 0.0) {
- ASSERT(i <= 0);
- i = span->end + i - 1;
- }
- ASSERT(i >= 0);
- ASSERT(i < (GLint) span->end);
- zoomed.array->index[j] = indexes[i];
+ const GLfloat (*rgb)[3] = (const GLfloat (*)[3]) src;
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < span->end);
+ zoomed.array->attribs[FRAG_ATTRIB_COL0][i][0] = rgb[j][0];
+ zoomed.array->attribs[FRAG_ATTRIB_COL0][i][1] = rgb[j][1];
+ zoomed.array->attribs[FRAG_ATTRIB_COL0][i][2] = rgb[j][2];
+ zoomed.array->attribs[FRAG_ATTRIB_COL0][i][3] = 1.0F;
}
}
}
else if (format == GL_DEPTH_COMPONENT) {
const GLuint *zValues = (const GLuint *) src;
- if (ctx->Pixel.ZoomX == -1.0F) {
- /* common case */
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = span->end - (j + skipCol) - 1;
- zoomed.array->z[j] = zValues[i];
- }
- }
- else {
- /* general solution */
- const GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = (GLint) ((j + skipCol) * xscale);
- if (ctx->Pixel.ZoomX < 0.0) {
- ASSERT(i <= 0);
- i = span->end + i - 1;
- }
- ASSERT(i >= 0);
- ASSERT(i < (GLint) span->end);
- zoomed.array->z[j] = zValues[i];
- }
+ GLint i;
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
+ ASSERT(j >= 0);
+ ASSERT(j < (GLint) span->end);
+ zoomed.array->z[i] = zValues[j];
}
- /* Now, fall into either the RGB or COLOR_INDEX path below */
- if (ctx->Visual.rgbMode)
- format = GL_RGBA;
- else
- format = GL_COLOR_INDEX;
- }
- else if (format == GL_DEPTH_COMPONENT32) {
- /* 32-bit Z values */
- struct gl_renderbuffer *rb
- = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
- const GLuint *zSrc32 = (const GLuint *) src;
- GLuint zDst32[MAX_WIDTH];
- const GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
- for (j = (GLint) zoomed.start; j < (GLint) zoomed.end; j++) {
- i = (GLint) ((j + skipCol) * xscale);
- if (ctx->Pixel.ZoomX < 0.0) {
- ASSERT(i <= 0);
- i = span->end + i - 1;
- }
- ASSERT(i >= 0);
- ASSERT(i < (GLint) span->end);
- zDst32[j] = zSrc32[i];
- }
- rb->PutRow(ctx, rb, zoomed.end, zoomed.x, zoomed.y, zDst32, NULL);
- return;
+ /* Now, fall into the RGB path below */
+ format = GL_RGBA;
}
/* write the span in rows [r0, r1) */
* going to call _swrast_write_zoomed_span() more than once.
* Also, clipping may change the span end value, so store it as well.
*/
- GLchan rgbaSave[MAX_WIDTH][4];
const GLint end = zoomed.end; /* save */
- if (r1 - r0 > 1) {
- MEMCPY(rgbaSave, zoomed.array->rgba, zoomed.end * 4 * sizeof(GLchan));
+ GLuint rgbaSave[MAX_WIDTH][4];
+ const GLint pixelSize =
+ (zoomed.array->ChanType == GL_UNSIGNED_BYTE) ? 4 * sizeof(GLubyte) :
+ ((zoomed.array->ChanType == GL_UNSIGNED_SHORT) ? 4 * sizeof(GLushort)
+ : 4 * sizeof(GLfloat));
+ if (y1 - y0 > 1) {
+ memcpy(rgbaSave, zoomed.array->rgba, zoomed.end * pixelSize);
}
- for (zoomed.y = r0; zoomed.y < r1; zoomed.y++) {
+ for (zoomed.y = y0; zoomed.y < y1; zoomed.y++) {
_swrast_write_rgba_span(ctx, &zoomed);
zoomed.end = end; /* restore */
- if (r1 - r0 > 1) {
- /* restore the colors */
- MEMCPY(zoomed.array->rgba, rgbaSave, zoomed.end*4 * sizeof(GLchan));
- }
- }
- }
- else if (format == GL_COLOR_INDEX) {
- GLuint indexSave[MAX_WIDTH];
- const GLint end = zoomed.end; /* save */
- if (r1 - r0 > 1) {
- MEMCPY(indexSave, zoomed.array->index, zoomed.end * sizeof(GLuint));
- }
- for (zoomed.y = r0; zoomed.y < r1; zoomed.y++) {
- _swrast_write_index_span(ctx, &zoomed);
- zoomed.end = end; /* restore */
- if (r1 - r0 > 1) {
+ if (y1 - y0 > 1) {
/* restore the colors */
- MEMCPY(zoomed.array->index, indexSave, zoomed.end * sizeof(GLuint));
+ memcpy(zoomed.array->rgba, rgbaSave, zoomed.end * pixelSize);
}
}
}
void
-_swrast_write_zoomed_rgba_span( GLcontext *ctx, const struct sw_span *span,
- CONST GLchan rgba[][4], GLint y0,
- GLint skipPixels )
+_swrast_write_zoomed_rgba_span(GLcontext *ctx, GLint imgX, GLint imgY,
+ const SWspan *span, const GLvoid *rgba)
{
- zoom_span(ctx, span, (const GLvoid *) rgba, y0, GL_RGBA, skipPixels);
+ zoom_span(ctx, imgX, imgY, span, rgba, GL_RGBA);
}
void
-_swrast_write_zoomed_rgb_span( GLcontext *ctx, const struct sw_span *span,
- CONST GLchan rgb[][3], GLint y0,
- GLint skipPixels )
+_swrast_write_zoomed_rgb_span(GLcontext *ctx, GLint imgX, GLint imgY,
+ const SWspan *span, const GLvoid *rgb)
{
- zoom_span(ctx, span, (const GLvoid *) rgb, y0, GL_RGB, skipPixels);
+ zoom_span(ctx, imgX, imgY, span, rgb, GL_RGB);
}
void
-_swrast_write_zoomed_index_span( GLcontext *ctx, const struct sw_span *span,
- GLint y0, GLint skipPixels )
+_swrast_write_zoomed_depth_span(GLcontext *ctx, GLint imgX, GLint imgY,
+ const SWspan *span)
{
- zoom_span(ctx, span, (const GLvoid *) span->array->index, y0,
- GL_COLOR_INDEX, skipPixels);
+ zoom_span(ctx, imgX, imgY, span,
+ (const GLvoid *) span->array->z, GL_DEPTH_COMPONENT);
}
-void
-_swrast_write_zoomed_depth_span( GLcontext *ctx, const struct sw_span *span,
- GLint y0, GLint skipPixels )
-{
- zoom_span(ctx, span, (const GLvoid *) span->array->z, y0,
- GL_DEPTH_COMPONENT, skipPixels);
-}
-
-
-/*
- * As above, but write stencil values.
+/**
+ * Zoom/write stencil values.
+ * No per-fragment operations are applied.
*/
void
-_swrast_write_zoomed_stencil_span( GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- const GLstencil stencil[], GLint y0,
- GLint skipPixels )
+_swrast_write_zoomed_stencil_span(GLcontext *ctx, GLint imgX, GLint imgY,
+ GLint width, GLint spanX, GLint spanY,
+ const GLstencil stencil[])
{
- GLint m;
- GLint r0, r1, row, r;
- GLint i, j, skipcol;
- GLstencil zstencil[MAX_WIDTH]; /* zoomed stencil values */
- GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+ GLstencil zoomedVals[MAX_WIDTH];
+ GLint x0, x1, y0, y1, y;
+ GLint i, zoomedWidth;
- (void) skipPixels; /* XXX this shouldn't be ignored */
-
- /* compute width of output row */
- m = (GLint) FABSF( n * ctx->Pixel.ZoomX );
- if (m==0) {
- return;
- }
- if (ctx->Pixel.ZoomX<0.0) {
- /* adjust x coordinate for left/right mirroring */
- x = x - m;
+ if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,
+ &x0, &x1, &y0, &y1)) {
+ return; /* totally clipped */
}
- /* compute which rows to draw */
- row = y - y0;
- r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
- r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
- if (r0==r1) {
- return;
- }
- else if (r1<r0) {
- GLint rtmp = r1;
- r1 = r0;
- r0 = rtmp;
- }
+ zoomedWidth = x1 - x0;
+ ASSERT(zoomedWidth > 0);
+ ASSERT(zoomedWidth <= MAX_WIDTH);
- /* return early if r0...r1 is above or below window */
- if (r0<0 && r1<0) {
- /* below window */
- return;
- }
- if (r0 >= (GLint) ctx->DrawBuffer->Height &&
- r1 >= (GLint) ctx->DrawBuffer->Height) {
- /* above window */
- return;
+ /* zoom the span horizontally */
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
+ ASSERT(j >= 0);
+ ASSERT(j < width);
+ zoomedVals[i] = stencil[j];
}
- /* check if left edge is outside window */
- skipcol = 0;
- if (x<0) {
- skipcol = -x;
- m += x;
- }
- /* make sure span isn't too long or short */
- if (m>maxwidth) {
- m = maxwidth;
+ /* write the zoomed spans */
+ for (y = y0; y < y1; y++) {
+ _swrast_write_stencil_span(ctx, zoomedWidth, x0, y, zoomedVals);
}
- else if (m<=0) {
- return;
+}
+
+
+/**
+ * Zoom/write z values (16 or 32-bit).
+ * No per-fragment operations are applied.
+ */
+void
+_swrast_write_zoomed_z_span(GLcontext *ctx, GLint imgX, GLint imgY,
+ GLint width, GLint spanX, GLint spanY,
+ const GLvoid *z)
+{
+ struct gl_renderbuffer *rb = ctx->DrawBuffer->_DepthBuffer;
+ GLushort zoomedVals16[MAX_WIDTH];
+ GLuint zoomedVals32[MAX_WIDTH];
+ GLint x0, x1, y0, y1, y;
+ GLint i, zoomedWidth;
+
+ if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,
+ &x0, &x1, &y0, &y1)) {
+ return; /* totally clipped */
}
- ASSERT( m <= MAX_WIDTH );
+ zoomedWidth = x1 - x0;
+ ASSERT(zoomedWidth > 0);
+ ASSERT(zoomedWidth <= MAX_WIDTH);
/* zoom the span horizontally */
- if (ctx->Pixel.ZoomX==-1.0F) {
- /* n==m */
- for (j=0;j<m;j++) {
- i = n - (j+skipcol) - 1;
- zstencil[j] = stencil[i];
+ if (rb->DataType == GL_UNSIGNED_SHORT) {
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
+ ASSERT(j >= 0);
+ ASSERT(j < width);
+ zoomedVals16[i] = ((GLushort *) z)[j];
}
+ z = zoomedVals16;
}
else {
- GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
- for (j=0;j<m;j++) {
- i = (GLint) ((j+skipcol) * xscale);
- if (i<0) i = n + i - 1;
- zstencil[j] = stencil[i];
+ ASSERT(rb->DataType == GL_UNSIGNED_INT);
+ for (i = 0; i < zoomedWidth; i++) {
+ GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
+ ASSERT(j >= 0);
+ ASSERT(j < width);
+ zoomedVals32[i] = ((GLuint *) z)[j];
}
+ z = zoomedVals32;
}
- /* write the span */
- for (r=r0; r<r1; r++) {
- _swrast_write_stencil_span( ctx, m, x+skipcol, r, zstencil );
+ /* write the zoomed spans */
+ for (y = y0; y < y1; y++) {
+ rb->PutRow(ctx, rb, zoomedWidth, x0, y, z, NULL);
}
}
projects / mesa.git / blobdiff