accomodate newtexstore

fixed wgl interface for fxMesa

1 files changed, 71 insertions, 71 deletions

diff --git a/src/mesa/drivers/glide/fxsetup.c b/src/mesa/drivers/glide/fxsetup.c
index 12a525a1e8e..da4dc2c83c6 100644
--- a/src/mesa/drivers/glide/fxsetup.c
+++ b/src/mesa/drivers/glide/fxsetup.c
@@ -67,77 +67,77 @@ fxTexValidate(GLcontext * ctx, struct gl_texture_object *tObj)
 
 #if FX_RESCALE_BIG_TEXURES_HACK
 {
-   extern void _mesa_rescale_teximage2d( GLuint bytesPerPixel,

-                                         GLuint dstRowStride,

-                                         GLint srcWidth, GLint srcHeight,

-                                         GLint dstWidth, GLint dstHeight,

-                                         const GLvoid *srcImage, GLvoid *dstImage );

-   fxMesaContext fxMesa = FX_CONTEXT(ctx);

-   /* [dBorca]

-    * Ooooooook! Here's a(nother) long story.

-    * We get here because we need to handle a texture larger

-    * than hardware can support. Two cases:

-    * 1) we have mipmaps. Then we just push up to the first supported

-    *    LOD. A possible drawback is that Mesa will ignore the skipped

-    *    LODs on further texture handling.

-    *    Will this interfere with GL_TEXTURE_[MIN|BASE]_LEVEL? How?

-    * 2) we don't have mipmaps. We need to rescale the big LOD in place.

-    *    The above approach is somehow dumb! we might have rescaled

-    *    once in TexImage2D to accomodate aspect ratio, and now we

-    *    are rescaling again. The thing is, in TexImage2D we don't

-    *    know whether we'll hit 1) or 2) by the time of validation.

-    * NB: we could handle mml->[wh]Scale nicely, using (biased) shifts.

-    *

-    * Which brings me to another issue. How can we handle NPOT textures?

-    * - rescaling NPOT to the next bigger POT (mml->[wh]Scale can't shift)

-    * - upping the max LOD to the next power-of-two, in fxTexGetInfo; then

-    *   choosing non-power-of-two values for ti->[st]Scale... Anyhow, we

-    *   still need to align mipmaps correctly in texture memory!

-    */

-   if ((tObj->MinFilter == GL_NEAREST) || (tObj->MinFilter == GL_LINEAR)) {

-      /* no mipmaps! */

-      struct gl_texture_image *texImage = tObj->Image[0][minl];

-      tfxMipMapLevel *mml = FX_MIPMAP_DATA(texImage);

-      GLint _w, _h, maxSize = 1 << fxMesa->textureMaxLod;

-      if ((mml->width > maxSize) || (mml->height > maxSize)) {

-         /* need to rescale */

-         GLint texelBytes = texImage->TexFormat->TexelBytes;

-         GLvoid *texImage_Data = texImage->Data;

-         _w = MIN2(texImage->Width, maxSize);

-         _h = MIN2(texImage->Height, maxSize);

-         if (TDFX_DEBUG & VERBOSE_TEXTURE) {

-            fprintf(stderr, "fxTexValidate: rescaling %d x %d -> %d x %d\n",

-                            texImage->Width, texImage->Height, _w, _h);

-         }

-         /* we should leave these as is and... (!) */

-         texImage->Width = _w;

-         texImage->Height = _h;

-         fxTexGetInfo(_w, _h, NULL, NULL, NULL, NULL,

-                      &(mml->wScale), &(mml->hScale));

-         _w *= mml->wScale;

-         _h *= mml->hScale;

-         texImage->Data = MESA_PBUFFER_ALLOC(_w * _h * texelBytes);

-         _mesa_rescale_teximage2d(texelBytes,

-                                  _w * texelBytes, /* dst stride */

-                                  mml->width, mml->height, /* src */

-                                  _w, _h, /* dst */

-                                  texImage_Data /*src*/, texImage->Data /*dst*/ );

-         MESA_PBUFFER_FREE(texImage_Data);

-         mml->width = _w;

-         mml->height = _h;

-         /* (!) ... and set mml->wScale = _w / texImage->Width */

-      }

-   } else {

-      /* mipmapping */

-      if (maxl - minl > fxMesa->textureMaxLod) {

-         /* skip a certain number of LODs */

-         minl += maxl - fxMesa->textureMaxLod;

-         if (TDFX_DEBUG & VERBOSE_TEXTURE) {

-            fprintf(stderr, "fxTexValidate: skipping %d LODs\n", minl - ti->minLevel);

-         }

-         ti->minLevel = tObj->BaseLevel = minl;

-      }

-   }

+   extern void _mesa_rescale_teximage2d( GLuint bytesPerPixel,
+                                         GLuint dstRowStride,
+                                         GLint srcWidth, GLint srcHeight,
+                                         GLint dstWidth, GLint dstHeight,
+                                         const GLvoid *srcImage, GLvoid *dstImage );
+   fxMesaContext fxMesa = FX_CONTEXT(ctx);
+   /* [dBorca]
+    * Ooooooook! Here's a(nother) long story.
+    * We get here because we need to handle a texture larger
+    * than hardware can support. Two cases:
+    * 1) we have mipmaps. Then we just push up to the first supported
+    *    LOD. A possible drawback is that Mesa will ignore the skipped
+    *    LODs on further texture handling.
+    *    Will this interfere with GL_TEXTURE_[MIN|BASE]_LEVEL? How?
+    * 2) we don't have mipmaps. We need to rescale the big LOD in place.
+    *    The above approach is somehow dumb! we might have rescaled
+    *    once in TexImage2D to accomodate aspect ratio, and now we
+    *    are rescaling again. The thing is, in TexImage2D we don't
+    *    know whether we'll hit 1) or 2) by the time of validation.
+    * NB: we could handle mml->[wh]Scale nicely, using (biased) shifts.
+    *
+    * Which brings me to another issue. How can we handle NPOT textures?
+    * - rescaling NPOT to the next bigger POT (mml->[wh]Scale can't shift)
+    * - upping the max LOD to the next power-of-two, in fxTexGetInfo; then
+    *   choosing non-power-of-two values for ti->[st]Scale... Anyhow, we
+    *   still need to align mipmaps correctly in texture memory!
+    */
+   if ((tObj->MinFilter == GL_NEAREST) || (tObj->MinFilter == GL_LINEAR)) {
+      /* no mipmaps! */
+      struct gl_texture_image *texImage = tObj->Image[0][minl];
+      tfxMipMapLevel *mml = FX_MIPMAP_DATA(texImage);
+      GLint _w, _h, maxSize = 1 << fxMesa->textureMaxLod;
+      if ((mml->width > maxSize) || (mml->height > maxSize)) {
+         /* need to rescale */
+         GLint texelBytes = texImage->TexFormat->TexelBytes;
+         GLvoid *texImage_Data = texImage->Data;
+         _w = MIN2(texImage->Width, maxSize);
+         _h = MIN2(texImage->Height, maxSize);
+         if (TDFX_DEBUG & VERBOSE_TEXTURE) {
+            fprintf(stderr, "fxTexValidate: rescaling %d x %d -> %d x %d\n",
+                            texImage->Width, texImage->Height, _w, _h);
+         }
+         /* we should leave these as is and... (!) */
+         texImage->Width = _w;
+         texImage->Height = _h;
+         fxTexGetInfo(_w, _h, NULL, NULL, NULL, NULL,
+                      &(mml->wScale), &(mml->hScale));
+         _w *= mml->wScale;
+         _h *= mml->hScale;
+         texImage->Data = MESA_PBUFFER_ALLOC(_w * _h * texelBytes);
+         _mesa_rescale_teximage2d(texelBytes,
+                                  _w * texelBytes, /* dst stride */
+                                  mml->width, mml->height, /* src */
+                                  _w, _h, /* dst */
+                                  texImage_Data /*src*/, texImage->Data /*dst*/ );
+         MESA_PBUFFER_FREE(texImage_Data);
+         mml->width = _w;
+         mml->height = _h;
+         /* (!) ... and set mml->wScale = _w / texImage->Width */
+      }
+   } else {
+      /* mipmapping */
+      if (maxl - minl > fxMesa->textureMaxLod) {
+         /* skip a certain number of LODs */
+         minl += maxl - fxMesa->textureMaxLod;
+         if (TDFX_DEBUG & VERBOSE_TEXTURE) {
+            fprintf(stderr, "fxTexValidate: skipping %d LODs\n", minl - ti->minLevel);
+         }
+         ti->minLevel = tObj->BaseLevel = minl;
+      }
+   }
 }
 #endif