#include "intel_mipmap_tree.h"
#include "intel_regions.h"
#include "intel_chipset.h"
-#include "enums.h"
+#include "main/enums.h"
#define FILE_DEBUG_FLAG DEBUG_MIPTREE
GLuint last_level,
GLuint width0,
GLuint height0,
- GLuint depth0, GLuint cpp, GLuint compress_byte)
+ GLuint depth0, GLuint cpp, GLuint compress_byte,
+ GLboolean expect_accelerated_upload)
{
struct intel_mipmap_tree *mt;
first_level, last_level, width0,
height0, depth0, cpp, compress_byte);
/*
- * pitch == 0 indicates the null texture
+ * pitch == 0 || height == 0 indicates the null texture
*/
- if (!mt || !mt->pitch)
+ if (!mt || !mt->pitch || !mt->total_height)
return NULL;
mt->region = intel_region_alloc(intel,
- mt->cpp, mt->pitch, mt->total_height);
+ mt->cpp,
+ mt->pitch,
+ mt->total_height,
+ mt->pitch,
+ expect_accelerated_upload);
if (!mt->region) {
free(mt);
mt = intel_miptree_create_internal(intel, target, internal_format,
first_level, last_level,
- region->pitch, region->height, depth0,
+ region->width, region->height, 1,
region->cpp, compress_byte);
if (!mt)
return mt;
mt->pitch = region->pitch;
#endif
- mt->region = region;
+ intel_region_reference(&mt->region, region);
return mt;
}
{
/* Images with borders are never pulled into mipmap trees.
*/
- if (image->Border)
+ if (image->Border ||
+ ((image->_BaseFormat == GL_DEPTH_COMPONENT) &&
+ ((image->TexObject->WrapS == GL_CLAMP_TO_BORDER) ||
+ (image->TexObject->WrapT == GL_CLAMP_TO_BORDER))))
return GL_FALSE;
if (image->InternalFormat != mt->internal_format ||
image->IsCompressed != mt->compressed)
return GL_FALSE;
+ if (!image->IsCompressed &&
+ !mt->compressed &&
+ image->TexFormat->TexelBytes != mt->cpp)
+ return GL_FALSE;
+
/* Test image dimensions against the base level image adjusted for
* minification. This will also catch images not present in the
* tree, changed targets, etc.
assert(img < mt->level[level].nr_images);
- mt->level[level].image_offset[img] = (x + y * mt->pitch);
+ mt->level[level].image_offset[img] = (x + y * mt->pitch) * mt->cpp;
DBG("%s level %d img %d pos %d,%d image_offset %x\n",
__FUNCTION__, level, img, x, y, mt->level[level].image_offset[img]);
{
if (mt->target == GL_TEXTURE_CUBE_MAP_ARB)
return (mt->level[level].level_offset +
- mt->level[level].image_offset[face] * mt->cpp);
+ mt->level[level].image_offset[face]);
else
return mt->level[level].level_offset;
}
* Map a teximage in a mipmap tree.
* \param row_stride returns row stride in bytes
* \param image_stride returns image stride in bytes (for 3D textures).
+ * \param image_offsets pointer to array of pixel offsets from the returned
+ * pointer to each depth image
* \return address of mapping
*/
GLubyte *
if (row_stride)
*row_stride = mt->pitch * mt->cpp;
- if (image_offsets) {
- if (mt->target == GL_TEXTURE_CUBE_MAP_ARB)
- memset(image_offsets, 0, mt->level[level].depth * sizeof(GLuint));
- else
- memcpy(image_offsets, mt->level[level].image_offset,
- mt->level[level].depth * sizeof(GLuint));
+ if (mt->target == GL_TEXTURE_3D) {
+ int i;
+
+ for (i = 0; i < mt->level[level].depth; i++)
+ image_offsets[i] = mt->level[level].image_offset[i] / mt->cpp;
+ } else {
+ assert(mt->level[level].depth == 1);
+ assert(mt->target == GL_TEXTURE_CUBE_MAP ||
+ mt->level[level].image_offset[0] == 0);
+ image_offsets[0] = 0;
}
return (intel_region_map(intel, mt->region) +
height = (height + 3) / 4;
intel_region_data(intel,
dst->region,
- dst_offset + dst_depth_offset[i] * dst->cpp, /* dst_offset */
+ dst_offset + dst_depth_offset[i], /* dst_offset */
0, 0, /* dstx, dsty */
src,
src_row_pitch,
for (i = 0; i < depth; i++) {
intel_region_copy(intel,
- dst->region, dst_offset + dst_depth_offset[i] * dst->cpp,
+ dst->region, dst_offset + dst_depth_offset[i],
0,
0,
- src->region, src_offset + src_depth_offset[i] * src->cpp,
+ src->region, src_offset + src_depth_offset[i],
0, 0, width, height);
}