src/mesa/swrast/s_zoom.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "glheader.h"
  26 #include "macros.h"
  27 #include "imports.h"
  28 #include "colormac.h"
  29
  30 #include "s_context.h"
  31 #include "s_span.h"
  32 #include "s_stencil.h"
  33 #include "s_zoom.h"
  34
  35
  36 /**
  37  * Compute the bounds of the region resulting from zooming a pixel span.
  38  * The resulting region will be entirely inside the window/scissor bounds
  39  * so no additional clipping is needed.
  40  * \param imageX, imageY  position of the overall image being drawn
  41  * \param spanX, spanY  position of span being drawing
  42  * \param x0, x1  returned X bounds of zoomed region [x0, x1)
  43  * \param y0, y1  returned Y bounds of zoomed region [y0, y1)
  44  * \return GL_TRUE if any zoomed pixels visible, GL_FALSE if totally clipped
  45  */
  46 static GLboolean
  47 compute_zoomed_bounds(GLcontext *ctx, GLint imageX, GLint imageY,
  48                       GLint spanX, GLint spanY, GLint width,
  49                       GLint *x0, GLint *x1, GLint *y0, GLint *y1)
  50 {
  51    const struct gl_framebuffer *fb = ctx->DrawBuffer;
  52    GLint c0, c1, r0, r1;
  53
  54    ASSERT(spanX >= imageX);
  55    ASSERT(spanY >= imageY);
  56
  57    /*
  58     * Compute destination columns: [c0, c1)
  59     */
  60    c0 = imageX + (GLint) ((spanX - imageX) * ctx->Pixel.ZoomX);
  61    c1 = imageX + (GLint) ((spanX + width - imageX) * ctx->Pixel.ZoomX);
  62    if (c1 < c0) {
  63       /* swap */
  64       GLint tmp = c1;
  65       c1 = c0;
  66       c0 = tmp;
  67    }
  68    c0 = CLAMP(c0, fb->_Xmin, fb->_Xmax);
  69    c1 = CLAMP(c1, fb->_Xmin, fb->_Xmax);
  70    if (c0 == c1) {
  71       return GL_FALSE; /* no width */
  72    }
  73
  74    /*
  75     * Compute destination rows: [r0, r1)
  76     */
  77    r0 = imageY + (GLint) ((spanY - imageY) * ctx->Pixel.ZoomY);
  78    r1 = imageY + (GLint) ((spanY + 1 - imageY) * ctx->Pixel.ZoomY);
  79    if (r1 < r0) {
  80       /* swap */
  81       GLint tmp = r1;
  82       r1 = r0;
  83       r0 = tmp;
  84    }
  85    r0 = CLAMP(r0, fb->_Ymin, fb->_Ymax);
  86    r1 = CLAMP(r1, fb->_Ymin, fb->_Ymax);
  87    if (r0 == r1) {
  88       return GL_FALSE; /* no height */
  89    }
  90
  91    *x0 = c0;
  92    *x1 = c1;
  93    *y0 = r0;
  94    *y1 = r1;
  95
  96    return GL_TRUE;
  97 }
  98
  99
 100 /**
 101  * Can use this for unzooming X or Y values.
 102  */
 103 static INLINE GLint
 104 unzoom_x(GLfloat zoomX, GLint imageX, GLint zx)
 105 {
 106    /*
 107    zx = imageX + (x - imageX) * zoomX;
 108    zx - imageX = (x - imageX) * zoomX;
 109    (zx - imageX) / zoomX = x - imageX;
 110    */
 111    GLint x = imageX + (GLint) ((zx - imageX) / zoomX);
 112    return x;
 113 }
 114
 115
 116
 117 /**
 118  * Helper function called from _swrast_write_zoomed_rgba/rgb/
 119  * index/depth_span().
 120  */
 121 static void
 122 zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const struct sw_span *span,
 123            const GLvoid *src, GLenum format )
 124 {
 125    struct sw_span zoomed;
 126    struct span_arrays zoomed_arrays;  /* this is big! */
 127    GLint x0, x1, y0, y1;
 128    GLint zoomedWidth;
 129
 130    if (!compute_zoomed_bounds(ctx, imgX, imgY, span->x, span->y, span->end,
 131                               &x0, &x1, &y0, &y1)) {
 132       return;  /* totally clipped */
 133    }
 134
 135    zoomedWidth = x1 - x0;
 136    ASSERT(zoomedWidth > 0);
 137    ASSERT(zoomedWidth <= MAX_WIDTH);
 138
 139    /* no pixel arrays! must be horizontal spans. */
 140    ASSERT((span->arrayMask & SPAN_XY) == 0);
 141    ASSERT(span->primitive == GL_BITMAP);
 142
 143    INIT_SPAN(zoomed, GL_BITMAP, 0, 0, 0);
 144    zoomed.x = x0;
 145    zoomed.end = zoomedWidth;
 146    zoomed.array = &zoomed_arrays;
 147
 148    /* copy fog interp info */
 149    zoomed.fog = span->fog;
 150    zoomed.fogStep = span->fogStep;
 151    /* XXX copy texcoord info? */
 152
 153    if (format == GL_RGBA || format == GL_RGB) {
 154       /* copy Z info */
 155       zoomed.z = span->z;
 156       zoomed.zStep = span->zStep;
 157       /* we'll generate an array of colorss */
 158       zoomed.interpMask = span->interpMask & ~SPAN_RGBA;
 159       zoomed.arrayMask |= SPAN_RGBA;
 160       ASSERT(span->arrayMask & SPAN_RGBA);
 161    }
 162    else if (format == GL_COLOR_INDEX) {
 163       /* copy Z info */
 164       zoomed.z = span->z;
 165       zoomed.zStep = span->zStep;
 166       /* we'll generate an array of color indexes */
 167       zoomed.interpMask = span->interpMask & ~SPAN_INDEX;
 168       zoomed.arrayMask |= SPAN_INDEX;
 169       ASSERT(span->arrayMask & SPAN_INDEX);
 170    }
 171    else if (format == GL_DEPTH_COMPONENT) {
 172       /* Copy color info */
 173       zoomed.red = span->red;
 174       zoomed.green = span->green;
 175       zoomed.blue = span->blue;
 176       zoomed.alpha = span->alpha;
 177       zoomed.redStep = span->redStep;
 178       zoomed.greenStep = span->greenStep;
 179       zoomed.blueStep = span->blueStep;
 180       zoomed.alphaStep = span->alphaStep;
 181       /* we'll generate an array of depth values */
 182       zoomed.interpMask = span->interpMask & ~SPAN_Z;
 183       zoomed.arrayMask |= SPAN_Z;
 184       ASSERT(span->arrayMask & SPAN_Z);
 185    }
 186    else {
 187       _mesa_problem(ctx, "Bad format in zoom_span");
 188       return;
 189    }
 190
 191    /* zoom the span horizontally */
 192    if (format == GL_RGBA) {
 193       const GLchan (*rgba)[4] = (const GLchan (*)[4]) src;
 194       GLint i;
 195       for (i = 0; i < zoomedWidth; i++) {
 196          GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
 197          ASSERT(j >= 0);
 198          ASSERT(j < span->end);
 199          COPY_CHAN4(zoomed.array->rgba[i], rgba[j]);
 200       }
 201    }
 202    else if (format == GL_RGB) {
 203       const GLchan (*rgb)[3] = (const GLchan (*)[3]) src;
 204       GLint i;
 205       for (i = 0; i < zoomedWidth; i++) {
 206          GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
 207          ASSERT(j >= 0);
 208          ASSERT(j < span->end);
 209          zoomed.array->rgba[i][0] = rgb[j][0];
 210          zoomed.array->rgba[i][1] = rgb[j][1];
 211          zoomed.array->rgba[i][2] = rgb[j][2];
 212          zoomed.array->rgba[i][3] = CHAN_MAX;
 213       }
 214    }
 215    else if (format == GL_COLOR_INDEX) {
 216       const GLuint *indexes = (const GLuint *) src;
 217       GLint i;
 218       for (i = 0; i < zoomedWidth; i++) {
 219          GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
 220          ASSERT(j >= 0);
 221          ASSERT(j < span->end);
 222          zoomed.array->index[i] = indexes[j];
 223       }
 224    }
 225    else if (format == GL_DEPTH_COMPONENT) {
 226       const GLuint *zValues = (const GLuint *) src;
 227       GLint i;
 228       for (i = 0; i < zoomedWidth; i++) {
 229          GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - span->x;
 230          ASSERT(j >= 0);
 231          ASSERT(j < span->end);
 232          zoomed.array->z[i] = zValues[j];
 233       }
 234       /* Now, fall into either the RGB or COLOR_INDEX path below */
 235       format = ctx->Visual.rgbMode ? GL_RGBA : GL_COLOR_INDEX;
 236    }
 237
 238    /* write the span in rows [r0, r1) */
 239    if (format == GL_RGBA || format == GL_RGB) {
 240       /* Writing the span may modify the colors, so make a backup now if we're
 241        * going to call _swrast_write_zoomed_span() more than once.
 242        * Also, clipping may change the span end value, so store it as well.
 243        */
 244       GLchan rgbaSave[MAX_WIDTH][4];
 245       const GLint end = zoomed.end; /* save */
 246       if (y1 - y0 > 1) {
 247          MEMCPY(rgbaSave, zoomed.array->rgba, zoomed.end * 4 * sizeof(GLchan));
 248       }
 249       for (zoomed.y = y0; zoomed.y < y1; zoomed.y++) {
 250          _swrast_write_rgba_span(ctx, &zoomed);
 251          zoomed.end = end;  /* restore */
 252          if (y1 - y0 > 1) {
 253             /* restore the colors */
 254             MEMCPY(zoomed.array->rgba, rgbaSave, zoomed.end*4 * sizeof(GLchan));
 255          }
 256       }
 257    }
 258    else if (format == GL_COLOR_INDEX) {
 259       GLuint indexSave[MAX_WIDTH];
 260       const GLint end = zoomed.end; /* save */
 261       if (y1 - y0 > 1) {
 262          MEMCPY(indexSave, zoomed.array->index, zoomed.end * sizeof(GLuint));
 263       }
 264       for (zoomed.y = y0; zoomed.y < y1; zoomed.y++) {
 265          _swrast_write_index_span(ctx, &zoomed);
 266          zoomed.end = end;  /* restore */
 267          if (y1 - y0 > 1) {
 268             /* restore the colors */
 269             MEMCPY(zoomed.array->index, indexSave, zoomed.end * sizeof(GLuint));
 270          }
 271       }
 272    }
 273 }
 274
 275
 276 void
 277 _swrast_write_zoomed_rgba_span( GLcontext *ctx, GLint imgX, GLint imgY,
 278                                const struct sw_span *span,
 279                                CONST GLchan rgba[][4])
 280 {
 281    zoom_span(ctx, imgX, imgY, span, (const GLvoid *) rgba, GL_RGBA);
 282 }
 283
 284
 285 void
 286 _swrast_write_zoomed_rgb_span(GLcontext *ctx, GLint imgX, GLint imgY,
 287                               const struct sw_span *span,
 288                               CONST GLchan rgb[][3])
 289 {
 290    zoom_span(ctx, imgX, imgY, span, (const GLvoid *) rgb, GL_RGB);
 291 }
 292
 293
 294 void
 295 _swrast_write_zoomed_index_span(GLcontext *ctx, GLint imgX, GLint imgY,
 296                                 const struct sw_span *span)
 297 {
 298    zoom_span(ctx, imgX, imgY, span,
 299              (const GLvoid *) span->array->index, GL_COLOR_INDEX);
 300 }
 301
 302
 303 void
 304 _swrast_write_zoomed_depth_span(GLcontext *ctx, GLint imgX, GLint imgY,
 305                                 const struct sw_span *span)
 306 {
 307    zoom_span(ctx, imgX, imgY, span,
 308              (const GLvoid *) span->array->z, GL_DEPTH_COMPONENT);
 309 }
 310
 311
 312 /**
 313  * Zoom/write stencil values.
 314  * No per-fragment operations are applied.
 315  */
 316 void
 317 _swrast_write_zoomed_stencil_span(GLcontext *ctx, GLint imgX, GLint imgY,
 318                                   GLint width, GLint spanX, GLint spanY,
 319                                   const GLstencil stencil[])
 320 {
 321    GLstencil zoomedVals[MAX_WIDTH];
 322    GLint x0, x1, y0, y1, y;
 323    GLint i, zoomedWidth;
 324
 325    if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,
 326                               &x0, &x1, &y0, &y1)) {
 327       return;  /* totally clipped */
 328    }
 329
 330    zoomedWidth = x1 - x0;
 331    ASSERT(zoomedWidth > 0);
 332    ASSERT(zoomedWidth <= MAX_WIDTH);
 333
 334    /* zoom the span horizontally */
 335    for (i = 0; i < zoomedWidth; i++) {
 336       GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
 337       ASSERT(j >= 0);
 338       ASSERT(j < width);
 339       zoomedVals[i] = stencil[j];
 340    }
 341
 342    /* write the zoomed spans */
 343    for (y = y0; y < y1; y++) {
 344       _swrast_write_stencil_span(ctx, zoomedWidth, x0, y, zoomedVals);
 345    }
 346 }
 347
 348
 349 /**
 350  * Zoom/write z values (16 or 32-bit).
 351  * No per-fragment operations are applied.
 352  */
 353 void
 354 _swrast_write_zoomed_z_span(GLcontext *ctx, GLint imgX, GLint imgY,
 355                             GLint width, GLint spanX, GLint spanY,
 356                             const GLvoid *z)
 357 {
 358    struct gl_renderbuffer *rb
 359       = ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;
 360    GLushort zoomedVals16[MAX_WIDTH];
 361    GLuint zoomedVals32[MAX_WIDTH];
 362    GLint x0, x1, y0, y1, y;
 363    GLint i, zoomedWidth;
 364
 365    if (!compute_zoomed_bounds(ctx, imgX, imgY, spanX, spanY, width,
 366                               &x0, &x1, &y0, &y1)) {
 367       return;  /* totally clipped */
 368    }
 369
 370    zoomedWidth = x1 - x0;
 371    ASSERT(zoomedWidth > 0);
 372    ASSERT(zoomedWidth <= MAX_WIDTH);
 373
 374    /* zoom the span horizontally */
 375    if (rb->DataType == GL_UNSIGNED_SHORT) {
 376       for (i = 0; i < zoomedWidth; i++) {
 377          GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
 378          ASSERT(j >= 0);
 379          ASSERT(j < width);
 380          zoomedVals16[i] = ((GLushort *) z)[j];
 381       }
 382       z = zoomedVals16;
 383    }
 384    else {
 385       ASSERT(rb->DataType == GL_UNSIGNED_INT);
 386       for (i = 0; i < zoomedWidth; i++) {
 387          GLint j = unzoom_x(ctx->Pixel.ZoomX, imgX, x0 + i) - spanX;
 388          ASSERT(j >= 0);
 389          ASSERT(j < width);
 390          zoomedVals32[i] = ((GLuint *) z)[j];
 391       }
 392       z = zoomedVals32;
 393    }
 394
 395    /* write the zoomed spans */
 396    for (y = y0; y < y1; y++) {
 397       rb->PutRow(ctx, rb, zoomedWidth, x0, y, z, NULL);
 398    }
 399 }