this->mt = mt;
this->level = level;
this->layer = layer;
- this->width = mt->level[level].width;
- this->height = mt->level[level].height;
+ this->width = minify(mt->physical_width0, level);
+ this->height = minify(mt->physical_height0, level);
intel_miptree_get_image_offset(mt, level, layer, &x_offset, &y_offset);
}
* width of the map (LOD0) is not multiple of 16, fast clear
* optimization must be disabled.
*/
- if (brw->gen == 6 && (mt->level[depth_irb->mt_level].width % 16) != 0)
+ if (brw->gen == 6 && (minify(mt->physical_width0,
+ depth_irb->mt_level) % 16) != 0)
return false;
/* FALLTHROUGH */
for (unsigned level = mt->first_level; level <= mt->last_level; level++) {
unsigned img_height;
- intel_miptree_set_level_info(mt, level, x, y, width,
- height, depth);
+ intel_miptree_set_level_info(mt, level, x, y, depth);
img_height = ALIGN(height, mt->align_h);
if (mt->compressed)
if (mt->target == GL_TEXTURE_CUBE_MAP)
DL = 6;
- intel_miptree_set_level_info(mt, level, 0, 0, WL, HL, DL);
+ intel_miptree_set_level_info(mt, level, 0, 0, DL);
for (unsigned q = 0; q < DL; q++) {
unsigned x = (q % (1 << level)) * wL;
intel_miptree_resolve_color(brw, dst_mt);
if (src_flip)
- src_y = src_mt->level[src_level].height - src_y - height;
+ src_y = minify(src_mt->physical_height0, src_level) - src_y - height;
if (dst_flip)
- dst_y = dst_mt->level[dst_level].height - dst_y - height;
+ dst_y = minify(dst_mt->physical_height0, dst_level) - dst_y - height;
int src_pitch = src_mt->region->pitch;
if (src_flip != dst_flip)
* minification. This will also catch images not present in the
* tree, changed targets, etc.
*/
- if (mt->target == GL_TEXTURE_2D_MULTISAMPLE ||
- mt->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY) {
- /* nonzero level here is always bogus */
- assert(level == 0);
-
- if (width != mt->logical_width0 ||
- height != mt->logical_height0 ||
- depth != mt->logical_depth0) {
- return false;
- }
- }
- else {
- /* all normal textures, renderbuffers, etc */
- if (width != mt->level[level].width ||
- height != mt->level[level].height ||
- depth != mt->level[level].depth) {
- return false;
- }
+ if (width != minify(mt->logical_width0, level) ||
+ height != minify(mt->logical_height0, level) ||
+ depth != mt->level[level].depth) {
+ return false;
}
if (image->NumSamples != mt->num_samples)
void
intel_miptree_set_level_info(struct intel_mipmap_tree *mt,
GLuint level,
- GLuint x, GLuint y,
- GLuint w, GLuint h, GLuint d)
+ GLuint x, GLuint y, GLuint d)
{
- mt->level[level].width = w;
- mt->level[level].height = h;
mt->level[level].depth = d;
mt->level[level].level_x = x;
mt->level[level].level_y = y;
- DBG("%s level %d size: %d,%d,%d offset %d,%d\n", __FUNCTION__,
- level, w, h, d, x, y);
+ DBG("%s level %d, depth %d, offset %d,%d\n", __FUNCTION__,
+ level, d, x, y);
assert(mt->level[level].slice == NULL);
{
mesa_format format = src_mt->format;
- uint32_t width = src_mt->level[level].width;
- uint32_t height = src_mt->level[level].height;
+ uint32_t width = minify(src_mt->physical_width0, level);
+ uint32_t height = minify(src_mt->physical_height0, level);
int slice;
if (face > 0)
assert(mt->hiz_mt);
if (brw->is_haswell) {
- const struct intel_mipmap_level *l = &mt->level[level];
+ uint32_t width = minify(mt->physical_width0, level);
+ uint32_t height = minify(mt->physical_height0, level);
/* Disable HiZ for LOD > 0 unless the width is 8 aligned
* and the height is 4 aligned. This allows our HiZ support
* we can grow the width & height to allow the HiZ op to
* force the proper size alignments.
*/
- if (level > 0 && ((l->width & 7) || (l->height & 3))) {
+ if (level > 0 && ((width & 7) || (height & 3))) {
return false;
}
}
GLuint level_x;
/** Offset to this miptree level, used in computing y_offset. */
GLuint level_y;
- GLuint width;
- GLuint height;
/**
* \brief Number of 2D slices in this miplevel.
void intel_miptree_set_level_info(struct intel_mipmap_tree *mt,
GLuint level,
- GLuint x, GLuint y,
- GLuint w, GLuint h, GLuint d);
+ GLuint x, GLuint y, GLuint d);
void intel_miptree_set_image_offset(struct intel_mipmap_tree *mt,
GLuint level,
intel_region_get_tile_masks(mt->region, &mask_x, &mask_y, false);
intel_miptree_get_image_offset(mt, level, zoffset, &draw_x, &draw_y);
- image->width = mt->level[level].width;
- image->height = mt->level[level].height;
+ image->width = minify(mt->physical_width0, level);
+ image->height = minify(mt->physical_height0, level);
image->tile_x = draw_x & mask_x;
image->tile_y = draw_y & mask_y;