return;
}
/* unpack image, apply transfer ops and store in tempImage */
+#if !NEWTEXSTORE
_mesa_transfer_teximage(ctx, 2, texImage->Format,
_final_texImage_TexFormat,
tempImage,
width * texelBytes, /* dstRowStride */
0, /* dstImageStride */
format, type, pixels, packing);
+#else
+ texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
+ _final_texImage_TexFormat, tempImage,
+ 0, 0, 0, /* dstX/Y/Zoffset */
+ width * texelBytes, /* dstRowStride */
+ 0, /* dstImageStride */
+ width, height, 1,
+ format, type, pixels, packing);
+#endif
_mesa_rescale_teximage2d(texelBytes,
mml->width * texelBytes, /* dst stride */
width, height, /* src */
else {
/* no rescaling needed */
/* unpack image, apply transfer ops and store in texImage->Data */
+#if !NEWTEXSTORE
_mesa_transfer_teximage(ctx, 2, texImage->Format,
_final_texImage_TexFormat, _final_texImage_Data,
width, height, 1, 0, 0, 0,
mml->width * texelBytes,
0, /* dstImageStride */
format, type, pixels, packing);
+#else
+ texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
+ _final_texImage_TexFormat, _final_texImage_Data,
+ 0, 0, 0, /* dstX/Y/Zoffset */
+ mml->width * texelBytes, /* dstRowStride */
+ 0, /* dstImageStride */
+ width, height, 1,
+ format, type, pixels, packing);
+#endif
}
/* now compress */
return;
}
+#if !NEWTEXSTORE
_mesa_transfer_teximage(ctx, 2, texImage->Format,/* Tex int format */
texImage->TexFormat, /* dest format */
(GLubyte *) tempImage, /* dest */
width * texelBytes, /* dest row stride */
0, /* dst image stride */
format, type, pixels, packing);
+#else
+ texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
+ texImage->TexFormat, tempImage,
+ 0, 0, 0, /* dstX/Y/Zoffset */
+ width * texelBytes, /* dstRowStride */
+ 0, /* dstImageStride */
+ width, height, 1,
+ format, type, pixels, packing);
+#endif
/* now rescale */
/* compute address of dest subimage within the overal tex image */
}
else {
/* no rescaling needed */
+#if !NEWTEXSTORE
_mesa_transfer_teximage(ctx, 2, texImage->Format, /* Tex int format */
texImage->TexFormat, /* dest format */
(GLubyte *) texImage->Data,/* dest */
mml->width * texelBytes, /* dest row stride */
0, /* dst image stride */
format, type, pixels, packing);
+#else
+ texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
+ texImage->TexFormat, (GLubyte *) texImage->Data,
+ xoffset, yoffset, 0, /* dstX/Y/Zoffset */
+ mml->width * texelBytes, /* dstRowStride */
+ 0, /* dstImageStride */
+ width, height, 1,
+ format, type, pixels, packing);
+#endif
}
/* [dBorca]
#if FX_RESCALE_BIG_TEXURES_HACK
{
- 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
+ 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
projects / mesa.git / commitdiff