#include "main/imports.h"
-#include "main/macros.h"
#include "main/mipmap.h"
#include "main/teximage.h"
-#include "main/texformat.h"
-
-#include "shader/prog_instruction.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "util/u_inlines.h"
#include "util/u_format.h"
#include "util/u_gen_mipmap.h"
-#include "util/u_math.h"
-
-#include "cso_cache/cso_cache.h"
-#include "cso_cache/cso_context.h"
#include "st_debug.h"
#include "st_context.h"
-#include "st_gen_mipmap.h"
#include "st_texture.h"
+#include "st_gen_mipmap.h"
#include "st_cb_texture.h"
-#include "st_inlines.h"
/**
{
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
- struct pipe_sampler_view *psv = st_get_stobj_sampler_view(stObj);
+ struct pipe_sampler_view *psv;
const uint face = _mesa_tex_target_to_face(target);
- assert(target != GL_TEXTURE_3D); /* not done yet */
+#if 0
+ assert(target != GL_TEXTURE_3D); /* implemented but untested */
+#endif
/* check if we can render in the texture's format */
- if (!screen->is_format_supported(screen, psv->format, psv->texture->target,
- PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+ /* XXX should probably kill this and always use util_gen_mipmap
+ since this implements a sw fallback as well */
+ if (!screen->is_format_supported(screen, stObj->pt->format,
+ stObj->pt->target,
+ 0, PIPE_BIND_RENDER_TARGET)) {
return FALSE;
}
+ psv = st_create_texture_sampler_view(pipe, stObj->pt);
+
util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,
PIPE_TEX_FILTER_LINEAR);
- return TRUE;
-}
-
+ pipe_sampler_view_reference(&psv, NULL);
-static void
-fallback_generate_mipmap(GLcontext *ctx, GLenum target,
- struct gl_texture_object *texObj)
-{
- struct pipe_context *pipe = ctx->st->pipe;
- struct pipe_texture *pt = st_get_texobj_texture(texObj);
- const uint baseLevel = texObj->BaseLevel;
- const uint lastLevel = pt->last_level;
- const uint face = _mesa_tex_target_to_face(target), zslice = 0;
- uint dstLevel;
- GLenum datatype;
- GLuint comps;
-
- if (ST_DEBUG & DEBUG_FALLBACK)
- debug_printf("%s: fallback processing\n", __FUNCTION__);
-
- assert(target != GL_TEXTURE_3D); /* not done yet */
-
- _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,
- &datatype, &comps);
-
- for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
- const uint srcLevel = dstLevel - 1;
- struct pipe_transfer *srcTrans, *dstTrans;
- const ubyte *srcData;
- ubyte *dstData;
- int srcStride, dstStride;
-
- srcTrans = st_cond_flush_get_tex_transfer(st_context(ctx), pt, face,
- srcLevel, zslice,
- PIPE_TRANSFER_READ, 0, 0,
- u_minify(pt->width0, srcLevel),
- u_minify(pt->height0, srcLevel));
-
- dstTrans = st_cond_flush_get_tex_transfer(st_context(ctx), pt, face,
- dstLevel, zslice,
- PIPE_TRANSFER_WRITE, 0, 0,
- u_minify(pt->width0, dstLevel),
- u_minify(pt->height0, dstLevel));
-
- srcData = (ubyte *) pipe->transfer_map(pipe, srcTrans);
- dstData = (ubyte *) pipe->transfer_map(pipe, dstTrans);
-
- srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->texture->format);
- dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->texture->format);
-
- _mesa_generate_mipmap_level(target, datatype, comps,
- 0 /*border*/,
- u_minify(pt->width0, srcLevel),
- u_minify(pt->height0, srcLevel),
- u_minify(pt->depth0, srcLevel),
- srcData,
- srcStride, /* stride in texels */
- u_minify(pt->width0, dstLevel),
- u_minify(pt->height0, dstLevel),
- u_minify(pt->depth0, dstLevel),
- dstData,
- dstStride); /* stride in texels */
-
- pipe->transfer_unmap(pipe, srcTrans);
- pipe->transfer_unmap(pipe, dstTrans);
-
- pipe->tex_transfer_destroy(pipe, srcTrans);
- pipe->tex_transfer_destroy(pipe, dstTrans);
- }
+ return TRUE;
}
-
/**
* Compute the expected number of mipmap levels in the texture given
* the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/
* GL_TEXTURE_MAX_LEVEL settings. This will tell us how many mipmap
- * level should be generated.
+ * levels should be generated.
*/
static GLuint
-compute_num_levels(GLcontext *ctx,
+compute_num_levels(struct gl_context *ctx,
struct gl_texture_object *texObj,
GLenum target)
{
- if (target == GL_TEXTURE_RECTANGLE_ARB) {
- return 1;
- }
- else {
- const GLuint maxLevels = texObj->MaxLevel - texObj->BaseLevel + 1;
- const struct gl_texture_image *baseImage =
- _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);
- GLuint size, numLevels;
+ const struct gl_texture_image *baseImage;
+ GLuint numLevels;
- size = MAX2(baseImage->Width2, baseImage->Height2);
- size = MAX2(size, baseImage->Depth2);
+ baseImage = _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);
- numLevels = 0;
+ numLevels = texObj->BaseLevel + baseImage->MaxNumLevels;
+ numLevels = MIN2(numLevels, (GLuint) texObj->MaxLevel + 1);
+ assert(numLevels >= 1);
- while (size > 0) {
- numLevels++;
- size >>= 1;
- }
-
- numLevels = MIN2(numLevels, maxLevels);
-
- return numLevels;
- }
+ return numLevels;
}
+/**
+ * Called via ctx->Driver.GenerateMipmap().
+ */
void
-st_generate_mipmap(GLcontext *ctx, GLenum target,
+st_generate_mipmap(struct gl_context *ctx, GLenum target,
struct gl_texture_object *texObj)
{
- struct st_context *st = ctx->st;
+ struct st_context *st = st_context(ctx);
struct st_texture_object *stObj = st_texture_object(texObj);
- struct pipe_texture *pt = st_get_texobj_texture(texObj);
+ struct pipe_resource *pt = st_get_texobj_resource(texObj);
const uint baseLevel = texObj->BaseLevel;
uint lastLevel;
uint dstLevel;
if (!pt)
return;
- /* find expected last mipmap level */
+ /* not sure if this ultimately actually should work,
+ but we're not supporting multisampled textures yet. */
+ assert(pt->nr_samples < 2);
+
+ /* find expected last mipmap level to generate*/
lastLevel = compute_num_levels(ctx, texObj, target) - 1;
if (lastLevel == 0)
return;
+ /* The texture isn't in a "complete" state yet so set the expected
+ * lastLevel here, since it won't get done in st_finalize_texture().
+ */
+ stObj->lastLevel = lastLevel;
+
if (pt->last_level < lastLevel) {
/* The current gallium texture doesn't have space for all the
* mipmap levels we need to generate. So allocate a new texture.
*/
- struct pipe_texture *oldTex = stObj->pt;
- GLboolean needFlush;
+ struct pipe_resource *oldTex = stObj->pt;
/* create new texture with space for more levels */
stObj->pt = st_texture_create(st,
oldTex->width0,
oldTex->height0,
oldTex->depth0,
- oldTex->tex_usage);
-
- /* The texture isn't in a "complete" state yet so set the expected
- * lastLevel here, since it won't get done in st_finalize_texture().
- */
- stObj->lastLevel = lastLevel;
+ oldTex->array_size,
+ 0,
+ oldTex->bind);
/* This will copy the old texture's base image into the new texture
* which we just allocated.
*/
- st_finalize_texture(ctx, st->pipe, texObj, &needFlush);
+ st_finalize_texture(ctx, st->pipe, texObj);
/* release the old tex (will likely be freed too) */
- pipe_texture_reference(&oldTex, NULL);
+ pipe_resource_reference(&oldTex, NULL);
pipe_sampler_view_reference(&stObj->sampler_view, NULL);
-
- pt = stObj->pt;
}
+ else {
+ /* Make sure that the base texture image data is present in the
+ * texture buffer.
+ */
+ st_finalize_texture(ctx, st->pipe, texObj);
+ }
+
+ pt = stObj->pt;
- assert(lastLevel <= pt->last_level);
+ assert(pt->last_level >= lastLevel);
- /* Recall that the Mesa BaseLevel image is stored in the gallium
- * texture's level[0] position. So pass baseLevel=0 here.
+ /* Try to generate the mipmap by rendering/texturing. If that fails,
+ * use the software fallback.
*/
- if (!st_render_mipmap(st, target, stObj, 0, lastLevel)) {
- fallback_generate_mipmap(ctx, target, texObj);
+ if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {
+ /* since the util code actually also has a fallback, should
+ probably make it never fail and kill this */
+ _mesa_generate_mipmap(ctx, target, texObj);
}
/* Fill in the Mesa gl_texture_image fields */
= _mesa_get_tex_image(ctx, texObj, target, srcLevel);
struct gl_texture_image *dstImage;
struct st_texture_image *stImage;
- uint dstWidth = u_minify(pt->width0, dstLevel);
- uint dstHeight = u_minify(pt->height0, dstLevel);
- uint dstDepth = u_minify(pt->depth0, dstLevel);
uint border = srcImage->Border;
+ uint dstWidth, dstHeight, dstDepth;
+
+ dstWidth = u_minify(pt->width0, dstLevel);
+ if (texObj->Target == GL_TEXTURE_1D_ARRAY) {
+ dstHeight = pt->array_size;
+ }
+ else {
+ dstHeight = u_minify(pt->height0, dstLevel);
+ }
+ if (texObj->Target == GL_TEXTURE_2D_ARRAY) {
+ dstDepth = pt->array_size;
+ }
+ else {
+ dstDepth = u_minify(pt->depth0, dstLevel);
+ }
dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);
if (!dstImage) {
}
/* Free old image data */
- if (dstImage->Data)
- ctx->Driver.FreeTexImageData(ctx, dstImage);
+ ctx->Driver.FreeTextureImageBuffer(ctx, dstImage);
/* initialize new image */
- _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
- dstDepth, border, srcImage->InternalFormat);
+ _mesa_init_teximage_fields(ctx, dstImage, dstWidth, dstHeight,
+ dstDepth, border, srcImage->InternalFormat,
+ srcImage->TexFormat);
- dstImage->TexFormat = srcImage->TexFormat;
+ stImage = st_texture_image(dstImage);
- stImage = (struct st_texture_image *) dstImage;
- pipe_texture_reference(&stImage->pt, pt);
+ pipe_resource_reference(&stImage->pt, pt);
}
}
projects / mesa.git / blobdiff