minl = ti->minLevel = tObj->BaseLevel;
maxl = ti->maxLevel = MIN2(tObj->MaxLevel, tObj->Image[0][0]->MaxLog2);
-#if 1||FX_RESCALE_BIG_TEXURES
+#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);
- if (maxl - minl > fxMesa->textureMaxLod) {
- /* [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 texture; two ways:
- * a) create a new LOD and push up ti->minLevel and tObj->BaseLevel
- * but this means we need to rescale on both axes, which
- * yield unnecessary ugly texture. Also, same issues as 1)
- * b) rescale the biggest LOD in place and go two ways:
- * - update texImage->Width and texImage->Height, then
- * decrease maxLevel, so we won't rescale again on the
- * next validation. Changing texImage-> parameters is
- * not quite legal here (see convolution), but...
- * - leaving texImage-> parameters alone, while rescaling
- * texture and decreasing maxLevel makes Mesa puke. Also
- * this approach requires that mml->[wh]Scale go below 1,
- * otherwise bad ju-ju will be in our future (see fetch_texel)
- * Will this interfere with GL_TEXTURE_MAX_LEVEL? How?
- * 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! need to rescale */
- struct gl_texture_image *texImage = tObj->Image[0][minl];
- tfxMipMapLevel *mml = FX_MIPMAP_DATA(texImage);
- GLint texelBytes = texImage->TexFormat->TexelBytes;
- GLvoid *texImage_Data = texImage->Data;
- GLint _w = MIN2(mml->width, 1 << fxMesa->textureMaxLod);
- GLint _h = MIN2(mml->height, 1 << fxMesa->textureMaxLod);
- if (TDFX_DEBUG & VERBOSE_TEXTURE) {
- fprintf(stderr, "fxTexValidate: rescaling %d x %d -> %d x %d\n",
- mml->width, mml->height,
- _w, _h);
- }
- fxTexGetInfo(_w, _h, NULL, NULL, NULL, NULL,
- &(mml->wScale), &(mml->hScale));
- texImage->Width = _w / mml->wScale;
- texImage->Height = _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;
- maxl = ti->maxLevel = tObj->Image[0][0]->MaxLog2 = minl + fxMesa->textureMaxLod;
- } else {
- /* 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,\r
+ GLuint dstRowStride,\r
+ GLint srcWidth, GLint srcHeight,\r
+ GLint dstWidth, GLint dstHeight,\r
+ const GLvoid *srcImage, GLvoid *dstImage );\r
+ fxMesaContext fxMesa = FX_CONTEXT(ctx);\r
+ /* [dBorca]\r
+ * Ooooooook! Here's a(nother) long story.\r
+ * We get here because we need to handle a texture larger\r
+ * than hardware can support. Two cases:\r
+ * 1) we have mipmaps. Then we just push up to the first supported\r
+ * LOD. A possible drawback is that Mesa will ignore the skipped\r
+ * LODs on further texture handling.\r
+ * Will this interfere with GL_TEXTURE_[MIN|BASE]_LEVEL? How?\r
+ * 2) we don't have mipmaps. We need to rescale the big LOD in place.\r
+ * The above approach is somehow dumb! we might have rescaled\r
+ * once in TexImage2D to accomodate aspect ratio, and now we\r
+ * are rescaling again. The thing is, in TexImage2D we don't\r
+ * know whether we'll hit 1) or 2) by the time of validation.\r
+ * NB: we could handle mml->[wh]Scale nicely, using (biased) shifts.\r
+ *\r
+ * Which brings me to another issue. How can we handle NPOT textures?\r
+ * - rescaling NPOT to the next bigger POT (mml->[wh]Scale can't shift)\r
+ * - upping the max LOD to the next power-of-two, in fxTexGetInfo; then\r
+ * choosing non-power-of-two values for ti->[st]Scale... Anyhow, we\r
+ * still need to align mipmaps correctly in texture memory!\r
+ */\r
+ if ((tObj->MinFilter == GL_NEAREST) || (tObj->MinFilter == GL_LINEAR)) {\r
+ /* no mipmaps! */\r
+ struct gl_texture_image *texImage = tObj->Image[0][minl];\r
+ tfxMipMapLevel *mml = FX_MIPMAP_DATA(texImage);\r
+ GLint _w, _h, maxSize = 1 << fxMesa->textureMaxLod;\r
+ if ((mml->width > maxSize) || (mml->height > maxSize)) {\r
+ /* need to rescale */\r
+ GLint texelBytes = texImage->TexFormat->TexelBytes;\r
+ GLvoid *texImage_Data = texImage->Data;\r
+ _w = MIN2(texImage->Width, maxSize);\r
+ _h = MIN2(texImage->Height, maxSize);\r
+ if (TDFX_DEBUG & VERBOSE_TEXTURE) {\r
+ fprintf(stderr, "fxTexValidate: rescaling %d x %d -> %d x %d\n",\r
+ texImage->Width, texImage->Height, _w, _h);\r
+ }\r
+ /* we should leave these as is and... (!) */\r
+ texImage->Width = _w;\r
+ texImage->Height = _h;\r
+ fxTexGetInfo(_w, _h, NULL, NULL, NULL, NULL,\r
+ &(mml->wScale), &(mml->hScale));\r
+ _w *= mml->wScale;\r
+ _h *= mml->hScale;\r
+ texImage->Data = MESA_PBUFFER_ALLOC(_w * _h * texelBytes);\r
+ _mesa_rescale_teximage2d(texelBytes,\r
+ _w * texelBytes, /* dst stride */\r
+ mml->width, mml->height, /* src */\r
+ _w, _h, /* dst */\r
+ texImage_Data /*src*/, texImage->Data /*dst*/ );\r
+ MESA_PBUFFER_FREE(texImage_Data);\r
+ mml->width = _w;\r
+ mml->height = _h;\r
+ /* (!) ... and set mml->wScale = _w / texImage->Width */\r
+ }\r
+ } else {\r
+ /* mipmapping */\r
+ if (maxl - minl > fxMesa->textureMaxLod) {\r
+ /* skip a certain number of LODs */\r
+ minl += maxl - fxMesa->textureMaxLod;\r
+ if (TDFX_DEBUG & VERBOSE_TEXTURE) {\r
+ fprintf(stderr, "fxTexValidate: skipping %d LODs\n", minl - ti->minLevel);\r
+ }\r
+ ti->minLevel = tObj->BaseLevel = minl;\r
+ }\r
+ }\r
}
#endif
projects / mesa.git / commitdiff