/** * Clear all fields of texture object to zeros. Used for proxy texture tests. * Used for proxy texture tests (and to clean up when a texture memory * allocation fails). */ static void clear_texture_fields(struct gl_context *ctx, struct gl_texture_object *texObj) { const GLenum target = texObj->Target; const GLuint numFaces = _mesa_num_tex_faces(target); GLint level; GLuint face; for (level = 0; level < Elements(texObj->Image[0]); level++) { for (face = 0; face < numFaces; face++) { struct gl_texture_image *texImage = get_tex_image(ctx, texObj, face, level); if (!texImage) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage"); return; } _mesa_init_teximage_fields(ctx, texImage, 0, 0, 0, 0, /* w, h, d, border */ GL_NONE, MESA_FORMAT_NONE); } } }
static GLboolean initialize_texture_fields(struct gl_context *ctx, struct gl_texture_object *texObj, GLint levels, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, mesa_format texFormat) { const GLenum target = texObj->Target; const GLuint numFaces = _mesa_num_tex_faces(target); GLint level, levelWidth = width, levelHeight = height, levelDepth = depth; GLuint face; /* Set up all the texture object's gl_texture_images */ for (level = 0; level < levels; level++) { for (face = 0; face < numFaces; face++) { struct gl_texture_image *texImage = get_tex_image(ctx, texObj, face, level); if (!texImage) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage"); return GL_FALSE; } _mesa_init_teximage_fields(ctx, texImage, levelWidth, levelHeight, levelDepth, 0, internalFormat, texFormat); } _mesa_next_mipmap_level_size(target, 0, levelWidth, levelHeight, levelDepth, &levelWidth, &levelHeight, &levelDepth); } return GL_TRUE; }
/** * Create a new mipmap tree, calculate its layout and allocate memory. */ radeon_mipmap_tree* radeon_miptree_create(radeonContextPtr rmesa, GLenum target, mesa_format mesaFormat, GLuint baseLevel, GLuint numLevels, GLuint width0, GLuint height0, GLuint depth0, GLuint tilebits) { radeon_mipmap_tree *mt = CALLOC_STRUCT(_radeon_mipmap_tree); radeon_print(RADEON_TEXTURE, RADEON_NORMAL, "%s(%p) new tree is %p.\n", __func__, rmesa, mt); mt->mesaFormat = mesaFormat; mt->refcount = 1; mt->target = target; mt->faces = _mesa_num_tex_faces(target); mt->baseLevel = baseLevel; mt->numLevels = numLevels; mt->width0 = width0; mt->height0 = height0; mt->depth0 = depth0; mt->tilebits = tilebits; calculate_miptree_layout(rmesa, mt); mt->bo = radeon_bo_open(rmesa->radeonScreen->bom, 0, mt->totalsize, 1024, RADEON_GEM_DOMAIN_VRAM, 0); return mt; }
/** * ctx->Driver.AllocTextureStorage() handler. * * Compare this to _mesa_alloc_texture_storage, which would call into * intel_alloc_texture_image_buffer() above. */ static GLboolean intel_alloc_texture_storage(struct gl_context *ctx, struct gl_texture_object *texobj, GLsizei levels, GLsizei width, GLsizei height, GLsizei depth) { struct brw_context *brw = brw_context(ctx); struct intel_texture_object *intel_texobj = intel_texture_object(texobj); struct gl_texture_image *first_image = texobj->Image[0][0]; int num_samples = intel_quantize_num_samples(brw->intelScreen, first_image->NumSamples); const int numFaces = _mesa_num_tex_faces(texobj->Target); int face; int level; /* If the object's current miptree doesn't match what we need, make a new * one. */ if (!intel_texobj->mt || !intel_miptree_match_image(intel_texobj->mt, first_image) || intel_texobj->mt->last_level != levels - 1) { intel_miptree_release(&intel_texobj->mt); intel_texobj->mt = intel_miptree_create(brw, texobj->Target, first_image->TexFormat, 0, levels - 1, width, height, depth, false, /* expect_accelerated */ num_samples, INTEL_MIPTREE_TILING_ANY, false); if (intel_texobj->mt == NULL) { return false; } } for (face = 0; face < numFaces; face++) { for (level = 0; level < levels; level++) { struct gl_texture_image *image = texobj->Image[face][level]; struct intel_texture_image *intel_image = intel_texture_image(image); image->NumSamples = num_samples; _swrast_free_texture_image_buffer(ctx, image); if (!_swrast_init_texture_image(image)) return false; intel_miptree_reference(&intel_image->mt, intel_texobj->mt); } } /* The miptree is in a validated state, so no need to check later. */ intel_texobj->needs_validate = false; intel_texobj->validated_first_level = 0; intel_texobj->validated_last_level = levels - 1; intel_texobj->_Format = intel_texobj->mt->format; return true; }
/** * Update/re-validate framebuffer object. */ static void update_fbo_texture(struct gl_context *ctx, struct gl_texture_object *texObj) { const unsigned numFaces = _mesa_num_tex_faces(texObj->Target); for (int level = 0; level < ARRAY_SIZE(texObj->Image[0]); level++) { for (unsigned face = 0; face < numFaces; face++) _mesa_update_fbo_texture(ctx, texObj, face, level); } }
/** * Called via ctx->Driver.AllocTextureStorage() to allocate texture memory * for a whole mipmap stack. */ static GLboolean st_AllocTextureStorage(struct gl_context *ctx, struct gl_texture_object *texObj, GLsizei levels, GLsizei width, GLsizei height, GLsizei depth) { const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); struct st_context *st = st_context(ctx); struct st_texture_object *stObj = st_texture_object(texObj); GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings; enum pipe_format fmt; GLint level; assert(levels > 0); /* Save the level=0 dimensions */ stObj->width0 = width; stObj->height0 = height; stObj->depth0 = depth; stObj->lastLevel = levels - 1; fmt = st_mesa_format_to_pipe_format(texObj->Image[0][0]->TexFormat); bindings = default_bindings(st, fmt); st_gl_texture_dims_to_pipe_dims(texObj->Target, width, height, depth, &ptWidth, &ptHeight, &ptDepth, &ptLayers); stObj->pt = st_texture_create(st, gl_target_to_pipe(texObj->Target), fmt, levels, ptWidth, ptHeight, ptDepth, ptLayers, bindings); if (!stObj->pt) return GL_FALSE; /* Set image resource pointers */ for (level = 0; level < levels; level++) { GLuint face; for (face = 0; face < numFaces; face++) { struct st_texture_image *stImage = st_texture_image(texObj->Image[face][level]); pipe_resource_reference(&stImage->pt, stObj->pt); } } return GL_TRUE; }
void radeon_swrast_map_texture_images(struct gl_context *ctx, struct gl_texture_object *texObj) { radeonContextPtr rmesa = RADEON_CONTEXT(ctx); GLuint nr_faces = _mesa_num_tex_faces(texObj->Target); int i, face; for (i = texObj->BaseLevel; i <= texObj->_MaxLevel; i++) { for (face = 0; face < nr_faces; face++) { radeon_texture_image *image = get_radeon_texture_image(texObj->Image[face][i]); radeon_swrast_map_image(rmesa, image); } } }
void intel_tex_unmap_images(struct intel_context *intel, struct intel_texture_object *intelObj) { GLuint nr_faces = _mesa_num_tex_faces(intelObj->base.Target); int i, face; for (i = intelObj->base.BaseLevel; i <= intelObj->_MaxLevel; i++) { for (face = 0; face < nr_faces; face++) { struct intel_texture_image *intel_image = intel_texture_image(intelObj->base.Image[face][i]); intel_tex_unmap_image_for_swrast(intel, intel_image); } } }
static GLboolean intel_texture_view(struct gl_context *ctx, struct gl_texture_object *texObj, struct gl_texture_object *origTexObj) { struct brw_context *brw = brw_context(ctx); struct intel_texture_object *intel_tex = intel_texture_object(texObj); struct intel_texture_object *intel_orig_tex = intel_texture_object(origTexObj); assert(intel_orig_tex->mt); intel_miptree_reference(&intel_tex->mt, intel_orig_tex->mt); /* Since we can only make views of immutable-format textures, * we can assume that everything is in origTexObj's miptree. * * Mesa core has already made us a copy of all the teximage objects, * except it hasn't copied our mt pointers, etc. */ const int numFaces = _mesa_num_tex_faces(texObj->Target); const int numLevels = texObj->NumLevels; int face; int level; for (face = 0; face < numFaces; face++) { for (level = 0; level < numLevels; level++) { struct gl_texture_image *image = texObj->Image[face][level]; struct intel_texture_image *intel_image = intel_texture_image(image); intel_miptree_reference(&intel_image->mt, intel_orig_tex->mt); } } /* The miptree is in a validated state, so no need to check later. */ intel_tex->needs_validate = false; intel_tex->validated_first_level = 0; intel_tex->validated_last_level = numLevels - 1; /* Set the validated texture format, with the same adjustments that * would have been applied to determine the underlying texture's * mt->format. */ intel_tex->_Format = intel_depth_format_for_depthstencil_format( intel_lower_compressed_format(brw, texObj->Image[0][0]->TexFormat)); return GL_TRUE; }
/** * Initialize new texture's gl_texture_image structures. Will not call driver * to allocate new space, simply record relevant layer, face, format, etc. * \return GL_FALSE if any error, GL_TRUE otherwise. */ static GLboolean initialize_texture_fields(struct gl_context *ctx, GLenum target, struct gl_texture_object *texObj, GLint levels, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, mesa_format texFormat) { const GLuint numFaces = _mesa_num_tex_faces(target); GLint level, levelWidth = width, levelHeight = height, levelDepth = depth; GLuint face; /* Pretend we are bound to initialize the gl_texture_image structs */ texObj->Target = target; /* Set up all the texture object's gl_texture_images */ for (level = 0; level < levels; level++) { for (face = 0; face < numFaces; face++) { struct gl_texture_image *texImage; GLenum faceTarget = target; if (target == GL_TEXTURE_CUBE_MAP) faceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + face; texImage = _mesa_get_tex_image(ctx, texObj, faceTarget, level); if (!texImage) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage"); return GL_FALSE; } _mesa_init_teximage_fields(ctx, texImage, levelWidth, levelHeight, levelDepth, 0, internalFormat, texFormat); } _mesa_next_mipmap_level_size(target, 0, levelWidth, levelHeight, levelDepth, &levelWidth, &levelHeight, &levelDepth); } /* "unbind" */ texObj->Target = 0; return GL_TRUE; }
/** * Compute the size of the given texture object, in bytes. */ static GLuint texture_size(const struct gl_texture_object *texObj) { const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); GLuint face, level, size = 0; for (face = 0; face < numFaces; face++) { for (level = 0; level < MAX_TEXTURE_LEVELS; level++) { const struct gl_texture_image *img = texObj->Image[face][level]; if (img) { GLuint sz = _mesa_format_image_size(img->TexFormat, img->Width, img->Height, img->Depth); size += sz; } } } return size; }
/** * \param mode bitmask of GL_MAP_READ_BIT, GL_MAP_WRITE_BIT */ void intel_tex_map_images(struct intel_context *intel, struct intel_texture_object *intelObj, GLbitfield mode) { GLuint nr_faces = _mesa_num_tex_faces(intelObj->base.Target); int i, face; DBG("%s\n", __FUNCTION__); for (i = intelObj->base.BaseLevel; i <= intelObj->_MaxLevel; i++) { for (face = 0; face < nr_faces; face++) { struct intel_texture_image *intel_image = intel_texture_image(intelObj->base.Image[face][i]); intel_tex_map_image_for_swrast(intel, intel_image, mode); } } }
/** * Called via ctx->Driver.AllocTextureStorage() * Just have to allocate memory for the texture images. */ static GLboolean intel_alloc_texture_storage(struct gl_context *ctx, struct gl_texture_object *texObj, GLsizei levels, GLsizei width, GLsizei height, GLsizei depth) { const int numFaces = _mesa_num_tex_faces(texObj->Target); int face; int level; for (face = 0; face < numFaces; face++) { for (level = 0; level < levels; level++) { struct gl_texture_image *const texImage = texObj->Image[face][level]; if (!intel_alloc_texture_image_buffer(ctx, texImage)) return false; } } return true; }
/** * Clear all fields of texture object to zeros. Used for proxy texture tests * and to clean up when a texture memory allocation fails. */ static void clear_texture_fields(struct gl_context *ctx, struct gl_texture_object *texObj) { const GLenum target = texObj->Target; const GLuint numFaces = _mesa_num_tex_faces(target); GLint level; GLuint face; for (level = 0; level < ARRAY_SIZE(texObj->Image[0]); level++) { for (face = 0; face < numFaces; face++) { struct gl_texture_image *texImage = get_tex_image(ctx, texObj, face, level); if (!texImage) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexStorage"); return; } _mesa_clear_texture_image(ctx, texImage); } } }
/** * Default ctx->Driver.AllocTextureStorage() handler. * * The driver can override this with a more specific implementation if it * desires, but this can be used to get the texture images allocated using the * usual texture image handling code. The immutability of * GL_ARB_texture_storage texture layouts is handled by texObj->Immutable * checks at glTexImage* time. */ GLboolean _mesa_AllocTextureStorage_sw(struct gl_context *ctx, struct gl_texture_object *texObj, GLsizei levels, GLsizei width, GLsizei height, GLsizei depth) { const int numFaces = _mesa_num_tex_faces(texObj->Target); int face; int level; (void) width; (void) height; (void) depth; for (face = 0; face < numFaces; face++) { for (level = 0; level < levels; level++) { struct gl_texture_image *const texImage = texObj->Image[face][level]; if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) return GL_FALSE; } } return GL_TRUE; }
/** * Examine a texture object to determine if it is complete. * * The gl_texture_object::Complete flag will be set to GL_TRUE or GL_FALSE * accordingly. * * \param ctx GL context. * \param t texture object. * * According to the texture target, verifies that each of the mipmaps is * present and has the expected size. */ void _mesa_test_texobj_completeness( const struct gl_context *ctx, struct gl_texture_object *t ) { const GLint baseLevel = t->BaseLevel; const struct gl_texture_image *baseImage; GLint maxLog2 = 0, maxLevels = 0; /* We'll set these to FALSE if tests fail below */ t->_BaseComplete = GL_TRUE; t->_MipmapComplete = GL_TRUE; if (t->Target == GL_TEXTURE_BUFFER) { /* Buffer textures are always considered complete. The obvious case where * they would be incomplete (no BO attached) is actually specced to be * undefined rendering results. */ return; } /* Detect cases where the application set the base level to an invalid * value. */ if ((baseLevel < 0) || (baseLevel >= MAX_TEXTURE_LEVELS)) { incomplete(t, BASE, "base level = %d is invalid", baseLevel); return; } if (t->MaxLevel < baseLevel) { incomplete(t, BASE, "MAX_LEVEL (%d) < BASE_LEVEL (%d)", t->MaxLevel, baseLevel); return; } baseImage = t->Image[0][baseLevel]; /* Always need the base level image */ if (!baseImage) { incomplete(t, BASE, "Image[baseLevel=%d] == NULL", baseLevel); return; } /* Check width/height/depth for zero */ if (baseImage->Width == 0 || baseImage->Height == 0 || baseImage->Depth == 0) { incomplete(t, BASE, "texture width or height or depth = 0"); return; } /* Check if the texture values are integer */ { GLenum datatype = _mesa_get_format_datatype(baseImage->TexFormat); t->_IsIntegerFormat = datatype == GL_INT || datatype == GL_UNSIGNED_INT; } /* Compute _MaxLevel (the maximum mipmap level we'll sample from given the * mipmap image sizes and GL_TEXTURE_MAX_LEVEL state). */ switch (t->Target) { case GL_TEXTURE_1D: case GL_TEXTURE_1D_ARRAY_EXT: maxLog2 = baseImage->WidthLog2; maxLevels = ctx->Const.MaxTextureLevels; break; case GL_TEXTURE_2D: case GL_TEXTURE_2D_ARRAY_EXT: maxLog2 = MAX2(baseImage->WidthLog2, baseImage->HeightLog2); maxLevels = ctx->Const.MaxTextureLevels; break; case GL_TEXTURE_3D: maxLog2 = MAX3(baseImage->WidthLog2, baseImage->HeightLog2, baseImage->DepthLog2); maxLevels = ctx->Const.Max3DTextureLevels; break; case GL_TEXTURE_CUBE_MAP_ARB: maxLog2 = MAX2(baseImage->WidthLog2, baseImage->HeightLog2); maxLevels = ctx->Const.MaxCubeTextureLevels; break; case GL_TEXTURE_RECTANGLE_NV: case GL_TEXTURE_BUFFER: case GL_TEXTURE_EXTERNAL_OES: maxLog2 = 0; /* not applicable */ maxLevels = 1; /* no mipmapping */ break; default: _mesa_problem(ctx, "Bad t->Target in _mesa_test_texobj_completeness"); return; } ASSERT(maxLevels > 0); t->_MaxLevel = baseLevel + maxLog2; /* 'p' in the GL spec */ t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel); t->_MaxLevel = MIN2(t->_MaxLevel, maxLevels - 1); /* 'q' in the GL spec */ /* Compute _MaxLambda = q - b (see the 1.2 spec) used during mipmapping */ t->_MaxLambda = (GLfloat) (t->_MaxLevel - baseLevel); if (t->Immutable) { /* This texture object was created with glTexStorage1/2/3D() so we * know that all the mipmap levels are the right size and all cube * map faces are the same size. * We don't need to do any of the additional checks below. */ return; } if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) { /* Make sure that all six cube map level 0 images are the same size. * Note: we know that the image's width==height (we enforce that * at glTexImage time) so we only need to test the width here. */ GLuint face; assert(baseImage->Width2 == baseImage->Height); for (face = 1; face < 6; face++) { assert(t->Image[face][baseLevel] == NULL || t->Image[face][baseLevel]->Width2 == t->Image[face][baseLevel]->Height2); if (t->Image[face][baseLevel] == NULL || t->Image[face][baseLevel]->Width2 != baseImage->Width2) { incomplete(t, BASE, "Cube face missing or mismatched size"); return; } } } /* * Do mipmap consistency checking. * Note: we don't care about the current texture sampler state here. * To determine texture completeness we'll either look at _BaseComplete * or _MipmapComplete depending on the current minification filter mode. */ { GLint i; const GLint minLevel = baseLevel; const GLint maxLevel = t->_MaxLevel; const GLuint numFaces = _mesa_num_tex_faces(t->Target); GLuint width, height, depth, face; if (minLevel > maxLevel) { incomplete(t, BASE, "minLevel > maxLevel"); return; } /* Get the base image's dimensions */ width = baseImage->Width2; height = baseImage->Height2; depth = baseImage->Depth2; /* Note: this loop will be a no-op for RECT, BUFFER, EXTERNAL textures */ for (i = baseLevel + 1; i < maxLevels; i++) { /* Compute the expected size of image at level[i] */ if (width > 1) { width /= 2; } if (height > 1 && t->Target != GL_TEXTURE_1D_ARRAY) { height /= 2; } if (depth > 1 && t->Target != GL_TEXTURE_2D_ARRAY) { depth /= 2; } /* loop over cube faces (or single face otherwise) */ for (face = 0; face < numFaces; face++) { if (i >= minLevel && i <= maxLevel) { const struct gl_texture_image *img = t->Image[face][i]; if (!img) { incomplete(t, MIPMAP, "TexImage[%d] is missing", i); return; } if (img->TexFormat != baseImage->TexFormat) { incomplete(t, MIPMAP, "Format[i] != Format[baseLevel]"); return; } if (img->Border != baseImage->Border) { incomplete(t, MIPMAP, "Border[i] != Border[baseLevel]"); return; } if (img->Width2 != width) { incomplete(t, MIPMAP, "TexImage[%d] bad width %u", i, img->Width2); return; } if (img->Height2 != height) { incomplete(t, MIPMAP, "TexImage[%d] bad height %u", i, img->Height2); return; } if (img->Depth2 != depth) { incomplete(t, MIPMAP, "TexImage[%d] bad depth %u", i, img->Depth2); return; } /* Extra checks for cube textures */ if (face > 0) { /* check that cube faces are the same size */ if (img->Width2 != t->Image[0][i]->Width2 || img->Height2 != t->Image[0][i]->Height2) { incomplete(t, MIPMAP, "CubeMap Image[n][i] bad size"); return; } } } } if (width == 1 && height == 1 && depth == 1) { return; /* found smallest needed mipmap, all done! */ } } } }
/** * Validate texture mipmap tree. * If individual images are stored in different mipmap trees * use the mipmap tree that has the most of the correct data. */ int radeon_validate_texture_miptree(struct gl_context * ctx, struct gl_sampler_object *samp, struct gl_texture_object *texObj) { radeonContextPtr rmesa = RADEON_CONTEXT(ctx); radeonTexObj *t = radeon_tex_obj(texObj); radeon_mipmap_tree *dst_miptree; if (samp == &texObj->Sampler && (t->validated || t->image_override)) { return GL_TRUE; } calculate_min_max_lod(samp, &t->base, &t->minLod, &t->maxLod); radeon_print(RADEON_TEXTURE, RADEON_NORMAL, "%s: Validating texture %p now, minLod = %d, maxLod = %d\n", __func__, texObj ,t->minLod, t->maxLod); dst_miptree = get_biggest_matching_miptree(t, t->base.BaseLevel, t->base._MaxLevel); radeon_miptree_unreference(&t->mt); if (!dst_miptree) { radeon_try_alloc_miptree(rmesa, t); radeon_print(RADEON_TEXTURE, RADEON_NORMAL, "%s: No matching miptree found, allocated new one %p\n", __func__, t->mt); } else { radeon_miptree_reference(dst_miptree, &t->mt); radeon_print(RADEON_TEXTURE, RADEON_NORMAL, "%s: Using miptree %p\n", __func__, t->mt); } const unsigned faces = _mesa_num_tex_faces(texObj->Target); unsigned face, level; radeon_texture_image *img; /* Validate only the levels that will actually be used during rendering */ for (face = 0; face < faces; ++face) { for (level = t->minLod; level <= t->maxLod; ++level) { img = get_radeon_texture_image(texObj->Image[face][level]); radeon_print(RADEON_TEXTURE, RADEON_TRACE, "Checking image level %d, face %d, mt %p ... ", level, face, img->mt); if (img->mt != t->mt && !img->used_as_render_target) { radeon_print(RADEON_TEXTURE, RADEON_TRACE, "MIGRATING\n"); struct radeon_bo *src_bo = (img->mt) ? img->mt->bo : img->bo; if (src_bo && radeon_bo_is_referenced_by_cs(src_bo, rmesa->cmdbuf.cs)) { radeon_firevertices(rmesa); } migrate_image_to_miptree(t->mt, img, face, level); } else radeon_print(RADEON_TEXTURE, RADEON_TRACE, "OK\n"); } } t->validated = GL_TRUE; return GL_TRUE; }
/** * At rendering-from-a-texture time, make sure that the texture object has a * miptree that can hold the entire texture based on * BaseLevel/MaxLevel/filtering, and copy in any texture images that are * stored in other miptrees. */ GLuint intel_finalize_mipmap_tree(struct brw_context *brw, GLuint unit) { struct gl_context *ctx = &brw->ctx; struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current; struct intel_texture_object *intelObj = intel_texture_object(tObj); struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit); GLuint face, i; GLuint nr_faces = 0; struct intel_texture_image *firstImage; int width, height, depth; /* TBOs require no validation -- they always just point to their BO. */ if (tObj->Target == GL_TEXTURE_BUFFER) return true; /* We know that this is true by now, and if it wasn't, we might have * mismatched level sizes and the copies would fail. */ assert(intelObj->base._BaseComplete); intel_update_max_level(intelObj, sampler); /* What levels does this validated texture image require? */ int validate_first_level = tObj->BaseLevel; int validate_last_level = intelObj->_MaxLevel; /* Skip the loop over images in the common case of no images having * changed. But if the GL_BASE_LEVEL or GL_MAX_LEVEL change to something we * haven't looked at, then we do need to look at those new images. */ if (!intelObj->needs_validate && validate_first_level >= intelObj->validated_first_level && validate_last_level <= intelObj->validated_last_level) { return true; } /* Immutable textures should not get this far -- they should have been * created in a validated state, and nothing can invalidate them. */ assert(!tObj->Immutable); firstImage = intel_texture_image(tObj->Image[0][tObj->BaseLevel]); /* Check tree can hold all active levels. Check tree matches * target, imageFormat, etc. * * For pre-gen4, we have to match first_level == tObj->BaseLevel, * because we don't have the control that gen4 does to make min/mag * determination happen at a nonzero (hardware) baselevel. Because * of that, we just always relayout on baselevel change. */ if (intelObj->mt && (!intel_miptree_match_image(intelObj->mt, &firstImage->base.Base) || validate_first_level < intelObj->mt->first_level || validate_last_level > intelObj->mt->last_level)) { intel_miptree_release(&intelObj->mt); } /* May need to create a new tree: */ if (!intelObj->mt) { intel_miptree_get_dimensions_for_image(&firstImage->base.Base, &width, &height, &depth); perf_debug("Creating new %s %dx%dx%d %d-level miptree to handle " "finalized texture miptree.\n", _mesa_get_format_name(firstImage->base.Base.TexFormat), width, height, depth, validate_last_level + 1); intelObj->mt = intel_miptree_create(brw, intelObj->base.Target, firstImage->base.Base.TexFormat, 0, /* first_level */ validate_last_level, width, height, depth, true, 0 /* num_samples */, INTEL_MIPTREE_TILING_ANY); if (!intelObj->mt) return false; } /* Pull in any images not in the object's tree: */ nr_faces = _mesa_num_tex_faces(intelObj->base.Target); for (face = 0; face < nr_faces; face++) { for (i = validate_first_level; i <= validate_last_level; i++) { struct intel_texture_image *intelImage = intel_texture_image(intelObj->base.Image[face][i]); /* skip too small size mipmap */ if (intelImage == NULL) break; if (intelObj->mt != intelImage->mt) { intel_miptree_copy_teximage(brw, intelImage, intelObj->mt, false /* invalidate */); } /* After we're done, we'd better agree that our layout is * appropriate, or we'll end up hitting this function again on the * next draw */ assert(intel_miptree_match_image(intelObj->mt, &intelImage->base.Base)); } } intelObj->validated_first_level = validate_first_level; intelObj->validated_last_level = validate_last_level; intelObj->_Format = intelObj->mt->format; intelObj->needs_validate = false; return true; }
GLuint intel_finalize_mipmap_tree(struct intel_context *intel, GLuint unit) { struct gl_context *ctx = &intel->ctx; struct gl_texture_object *tObj = intel->ctx.Texture.Unit[unit]._Current; struct intel_texture_object *intelObj = intel_texture_object(tObj); struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit); GLuint face, i; GLuint nr_faces = 0; struct intel_texture_image *firstImage; int width, height, depth; /* TBOs require no validation -- they always just point to their BO. */ if (tObj->Target == GL_TEXTURE_BUFFER) return true; /* We know/require this is true by now: */ assert(intelObj->base._BaseComplete); /* What levels must the tree include at a minimum? */ intel_update_max_level(intelObj, sampler); firstImage = intel_texture_image(tObj->Image[0][tObj->BaseLevel]); /* Check tree can hold all active levels. Check tree matches * target, imageFormat, etc. * * For pre-gen4, we have to match first_level == tObj->BaseLevel, * because we don't have the control that gen4 does to make min/mag * determination happen at a nonzero (hardware) baselevel. Because * of that, we just always relayout on baselevel change. */ if (intelObj->mt && (!intel_miptree_match_image(intelObj->mt, &firstImage->base.Base) || intelObj->mt->first_level != tObj->BaseLevel || intelObj->mt->last_level < intelObj->_MaxLevel)) { intel_miptree_release(&intelObj->mt); } /* May need to create a new tree: */ if (!intelObj->mt) { intel_miptree_get_dimensions_for_image(&firstImage->base.Base, &width, &height, &depth); intelObj->mt = intel_miptree_create(intel, intelObj->base.Target, firstImage->base.Base.TexFormat, tObj->BaseLevel, intelObj->_MaxLevel, width, height, depth, true, 0 /* num_samples */, INTEL_MSAA_LAYOUT_NONE); if (!intelObj->mt) return false; } /* Pull in any images not in the object's tree: */ nr_faces = _mesa_num_tex_faces(intelObj->base.Target); for (face = 0; face < nr_faces; face++) { for (i = tObj->BaseLevel; i <= intelObj->_MaxLevel; i++) { struct intel_texture_image *intelImage = intel_texture_image(intelObj->base.Image[face][i]); /* skip too small size mipmap */ if (intelImage == NULL) break; if (intelObj->mt != intelImage->mt) { intel_miptree_copy_teximage(intel, intelImage, intelObj->mt); } } } return true; }