projects / mesa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ARB_Occlusion_query should support multiple query at same time
[mesa.git] / src / mesa / swrast / s_zoom.c
diff --git a/src/mesa/swrast/s_zoom.c b/src/mesa/swrast/s_zoom.c
index 3fd914083f9e7466f875f731833add820eb8f433..29b8df41b7e42dce1f393f8e4acf8e6a984d8877 100644 (file)
--- a/src/mesa/swrast/s_zoom.c
+++ b/src/mesa/swrast/s_zoom.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5
+ * Version:  6.5.2
  *
- * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2006  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"),
@@ -119,11 +119,11 @@ unzoom_x(GLfloat zoomX, GLint imageX, GLint zx)
  * index/depth_span().
  */
 static void
-zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const struct sw_span *span,
+zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const SWspan *span,
            const GLvoid *src, GLenum format )
 {
-   struct sw_span zoomed;
-   struct span_arrays zoomed_arrays;  /* this is big! */
+   SWspan zoomed;
+   SWspanarrays zoomed_arrays;  /* this is big! */
    GLint x0, x1, y0, y1;
    GLint zoomedWidth;
 
@@ -144,6 +144,19 @@ zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const struct sw_span *span,
    zoomed.x = x0;
    zoomed.end = zoomedWidth;
    zoomed.array = &zoomed_arrays;
+   zoomed_arrays.ChanType = span->array->ChanType;
+   /* XXX temporary */
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+   zoomed_arrays.rgba = zoomed_arrays.color.sz1.rgba;
+   zoomed_arrays.spec = zoomed_arrays.color.sz1.spec;
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   zoomed_arrays.rgba = zoomed_arrays.color.sz2.rgba;
+   zoomed_arrays.spec = zoomed_arrays.color.sz2.spec;
+#else
+   zoomed_arrays.rgba = zoomed_arrays.color.sz4.rgba;
+   zoomed_arrays.spec = zoomed_arrays.color.sz4.spec;
+#endif
+
 
    /* copy fog interp info */
    zoomed.fog = span->fog;
@@ -190,26 +203,76 @@ zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const struct sw_span *span,
 
    /* zoom the span horizontally */
    if (format == GL_RGBA) {
-      const GLchan (*rgba)[4] = (const GLchan (*)[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_CHAN4(zoomed.array->rgba[i], rgba[j]);
+      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 < span->end);
+            COPY_4UBV(zoomed.array->color.sz1.rgba[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 < span->end);
+            COPY_4V(zoomed.array->color.sz2.rgba[i], rgba[j]);
+         }
+      }
+      else {
+         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->color.sz4.rgba[i], rgba[j]);
+         }
       }
    }
    else if (format == GL_RGB) {
-      const GLchan (*rgb)[3] = (const GLchan (*)[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->rgba[i][0] = rgb[j][0];
-         zoomed.array->rgba[i][1] = rgb[j][1];
-         zoomed.array->rgba[i][2] = rgb[j][2];
-         zoomed.array->rgba[i][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 < span->end);
+            zoomed.array->color.sz1.rgba[i][0] = rgb[j][0];
+            zoomed.array->color.sz1.rgba[i][1] = rgb[j][1];
+            zoomed.array->color.sz1.rgba[i][2] = rgb[j][2];
+            zoomed.array->color.sz1.rgba[i][3] = 0xff;
+         }
+      }
+      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 < span->end);
+            zoomed.array->color.sz2.rgba[i][0] = rgb[j][0];
+            zoomed.array->color.sz2.rgba[i][1] = rgb[j][1];
+            zoomed.array->color.sz2.rgba[i][2] = rgb[j][2];
+            zoomed.array->color.sz2.rgba[i][3] = 0xffff;
+         }
+      }
+      else {
+         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->color.sz4.rgba[i][0] = rgb[j][0];
+            zoomed.array->color.sz4.rgba[i][1] = rgb[j][1];
+            zoomed.array->color.sz4.rgba[i][2] = rgb[j][2];
+            zoomed.array->color.sz4.rgba[i][3] = 1.0F;
+         }
       }
    }
    else if (format == GL_COLOR_INDEX) {
@@ -241,22 +304,28 @@ zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const struct sw_span *span,
        * 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 */
+      /* use specular color array for temp storage */
+      void *rgbaSave = zoomed.array->spec;
+      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 * 4 * sizeof(GLchan));
+         MEMCPY(rgbaSave, zoomed.array->rgba, zoomed.end * pixelSize);
       }
       for (zoomed.y = y0; zoomed.y < y1; zoomed.y++) {
          _swrast_write_rgba_span(ctx, &zoomed);
          zoomed.end = end;  /* restore */
          if (y1 - y0 > 1) {
             /* restore the colors */
-            MEMCPY(zoomed.array->rgba, rgbaSave, zoomed.end*4 * sizeof(GLchan));
+            MEMCPY(zoomed.array->rgba, rgbaSave, zoomed.end * pixelSize);
          }
       }
    }
    else if (format == GL_COLOR_INDEX) {
-      GLuint indexSave[MAX_WIDTH];
+      /* use specular color array for temp storage */
+      GLuint *indexSave = (GLuint *) zoomed.array->spec;
       const GLint end = zoomed.end; /* save */
       if (y1 - y0 > 1) {
          MEMCPY(indexSave, zoomed.array->index, zoomed.end * sizeof(GLuint));
@@ -274,26 +343,24 @@ zoom_span( GLcontext *ctx, GLint imgX, GLint imgY, const struct sw_span *span,
 
 
 void
-_swrast_write_zoomed_rgba_span( GLcontext *ctx, GLint imgX, GLint imgY,
-                               const struct sw_span *span,
-                               CONST GLchan rgba[][4])
+_swrast_write_zoomed_rgba_span(GLcontext *ctx, GLint imgX, GLint imgY,
+                               const SWspan *span, const GLvoid *rgba)
 {
-   zoom_span(ctx, imgX, imgY, span, (const GLvoid *) rgba, GL_RGBA);
+   zoom_span(ctx, imgX, imgY, span, rgba, GL_RGBA);
 }
 
 
 void
 _swrast_write_zoomed_rgb_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                              const struct sw_span *span,
-                              CONST GLchan rgb[][3])
+                              const SWspan *span, const GLvoid *rgb)
 {
-   zoom_span(ctx, imgX, imgY, span, (const GLvoid *) rgb, GL_RGB);
+   zoom_span(ctx, imgX, imgY, span, rgb, GL_RGB);
 }
 
 
 void
 _swrast_write_zoomed_index_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                                const struct sw_span *span)
+                                const SWspan *span)
 {
    zoom_span(ctx, imgX, imgY, span,
              (const GLvoid *) span->array->index, GL_COLOR_INDEX);
@@ -302,7 +369,7 @@ _swrast_write_zoomed_index_span(GLcontext *ctx, GLint imgX, GLint imgY,
 
 void
 _swrast_write_zoomed_depth_span(GLcontext *ctx, GLint imgX, GLint imgY,
-                                const struct sw_span *span)
+                                const SWspan *span)
 {
    zoom_span(ctx, imgX, imgY, span,
              (const GLvoid *) span->array->z, GL_DEPTH_COMPONENT);