st_cb_texture.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
GLboolean	st_finalize_texture (GLcontext *ctx, struct pipe_context *pipe, struct gl_texture_object *tObj, GLboolean *needFlush)
	Called during state validation.
struct gl_texture_object *	st_get_default_texture (struct st_context *st)
	Returns pointer to a default/dummy texture.
void	st_init_texture_functions (struct dd_function_table *functions)

---

Function Documentation

GLboolean st_finalize_texture	(	GLcontext *	ctx,
		struct pipe_context *	pipe,
		struct gl_texture_object *	tObj,
		GLboolean *	needFlush
	)

Called during state validation.

When this function is finished, the texture object should be ready for rendering.

Returns:

GL_TRUE for success, GL_FALSE for failure (out of mem)

Definition at line 1364 of file st_cb_texture.c.

References assert, st_texture_image::base, st_texture_object::base, pipe_texture::block, calculate_first_last_level(), pipe_texture::compressed, compressed_num_bytes(), copy_image_data_to_texture(), pipe_texture::depth, pipe_texture::format, gl_target_to_pipe(), pipe_format_block::height, pipe_texture::height, pipe_texture::last_level, st_texture_object::lastLevel, st_texture_image::level, pf_is_depth_stencil(), pipe_texture_reference(), pipe_texture_release(), PIPE_TEXTURE_USAGE_DEPTH_STENCIL, PIPE_TEXTURE_USAGE_RENDER_TARGET, PIPE_TEXTURE_USAGE_SAMPLER, st_texture_object::pt, st_texture_image::pt, pipe_format_block::size, st_mesa_format_to_pipe_format(), ST_NEW_FRAMEBUFFER, st_texture_create(), st_texture_image(), st_texture_object(), pipe_texture::target, pipe_format_block::width, and pipe_texture::width.

{
   struct st_texture_object *stObj = st_texture_object(tObj);
   const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   int comp_byte = 0;
   int cpp;
   GLuint face;
   struct st_texture_image *firstImage;

   *needFlush = GL_FALSE;

   /* We know/require this is true by now: 
    */
   assert(stObj->base._Complete);

   /* What levels must the texture include at a minimum?
    */
   calculate_first_last_level(stObj);
   firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);

   /* If both firstImage and stObj point to a texture which can contain
    * all active images, favour firstImage.  Note that because of the
    * completeness requirement, we know that the image dimensions
    * will match.
    */
   if (firstImage->pt &&
       firstImage->pt != stObj->pt &&
       firstImage->pt->last_level >= stObj->lastLevel) {

      pipe_texture_reference(&stObj->pt, firstImage->pt);
   }

   /* FIXME: determine format block instead of cpp */
   if (firstImage->base.IsCompressed) {
      comp_byte = compressed_num_bytes(firstImage->base.TexFormat->MesaFormat);
      cpp = comp_byte;
   }
   else {
      cpp = firstImage->base.TexFormat->TexelBytes;
   }

   /* If we already have a gallium texture, check that it matches the texture
    * object's format, target, size, num_levels, etc.
    */
   if (stObj->pt) {
      const enum pipe_format fmt =
         st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
      if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
          stObj->pt->format != fmt ||
          stObj->pt->last_level < stObj->lastLevel ||
          stObj->pt->width[0] != firstImage->base.Width2 ||
          stObj->pt->height[0] != firstImage->base.Height2 ||
          stObj->pt->depth[0] != firstImage->base.Depth2 ||
          stObj->pt->block.size != cpp ||
          stObj->pt->block.width != 1 ||
          stObj->pt->block.height != 1 ||
          stObj->pt->compressed != firstImage->base.IsCompressed) {
         pipe_texture_release(&stObj->pt);
         ctx->st->dirty.st |= ST_NEW_FRAMEBUFFER;
      }
   }

   /* May need to create a new gallium texture:
    */
   if (!stObj->pt) {
      const enum pipe_format fmt =
         st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
      stObj->pt = st_texture_create(ctx->st,
                                    gl_target_to_pipe(stObj->base.Target),
                                    fmt,
                                    stObj->lastLevel,
                                    firstImage->base.Width2,
                                    firstImage->base.Height2,
                                    firstImage->base.Depth2,
                                    comp_byte,
                                    ( (pf_is_depth_stencil(fmt) ?
                                      PIPE_TEXTURE_USAGE_DEPTH_STENCIL :
                                      PIPE_TEXTURE_USAGE_RENDER_TARGET) |
                                      PIPE_TEXTURE_USAGE_SAMPLER ));

      if (!stObj->pt) {
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
         return GL_FALSE;
      }
   }

   /* Pull in any images not in the object's texture:
    */
   for (face = 0; face < nr_faces; face++) {
      GLuint level;
      for (level = 0; level <= stObj->lastLevel; level++) {
         struct st_texture_image *stImage =
            st_texture_image(stObj->base.Image[face][stObj->base.BaseLevel + level]);

         /* Need to import images in main memory or held in other textures.
          */
         if (stImage && stObj->pt != stImage->pt) {
            copy_image_data_to_texture(ctx->st, stObj, level, stImage);
            *needFlush = GL_TRUE;
         }
      }
   }

   return GL_TRUE;
}

struct gl_texture_object* st_get_default_texture

(

struct st_context *

st

)

[read]

Returns pointer to a default/dummy texture.

This is typically used when the current shader has tex/sample instructions but the user has not provided a (any) texture(s).

Definition at line 1480 of file st_cb_texture.c.

References st_context::ctx, st_context::default_texture, and st_TexImage().

{
   if (!st->default_texture) {
      static const GLenum target = GL_TEXTURE_2D;
      GLubyte pixels[16][16][4];
      struct gl_texture_object *texObj;
      struct gl_texture_image *texImg;

      /* init image to gray */
      memset(pixels, 127, sizeof(pixels));

      texObj = st->ctx->Driver.NewTextureObject(st->ctx, 0, target);

      texImg = _mesa_get_tex_image(st->ctx, texObj, target, 0);

      _mesa_init_teximage_fields(st->ctx, target, texImg,
                                 16, 16, 1, 0,  /* w, h, d, border */
                                 GL_RGBA);

      st_TexImage(st->ctx, 2, target,
                  0, GL_RGBA,    /* level, intformat */
                  16, 16, 1, 0,  /* w, h, d, border */
                  GL_RGBA, GL_UNSIGNED_BYTE, pixels,
                  &st->ctx->DefaultPacking,
                  texObj, texImg,
                  0, 0);

      texObj->MinFilter = GL_NEAREST;
      texObj->MagFilter = GL_NEAREST;
      texObj->_Complete = GL_TRUE;

      st->default_texture = texObj;
   }
   return st->default_texture;
}

void st_init_texture_functions

(

struct dd_function_table *

functions

)

Definition at line 1518 of file st_cb_texture.c.

References do_memcpy(), st_ChooseTextureFormat(), st_CompressedTexImage2D(), st_CopyTexImage1D(), st_CopyTexImage2D(), st_CopyTexSubImage1D(), st_CopyTexSubImage2D(), st_CopyTexSubImage3D(), st_DeleteTextureObject(), st_FreeTextureImageData(), st_generate_mipmap(), st_GetCompressedTexImage(), st_GetTexImage(), st_NewTextureImage(), st_NewTextureObject(), st_TexImage1D(), st_TexImage2D(), st_TexImage3D(), st_TexSubImage1D(), st_TexSubImage2D(), and st_TexSubImage3D().

{
   functions->ChooseTextureFormat = st_ChooseTextureFormat;
   functions->TexImage1D = st_TexImage1D;
   functions->TexImage2D = st_TexImage2D;
   functions->TexImage3D = st_TexImage3D;
   functions->TexSubImage1D = st_TexSubImage1D;
   functions->TexSubImage2D = st_TexSubImage2D;
   functions->TexSubImage3D = st_TexSubImage3D;
   functions->CopyTexImage1D = st_CopyTexImage1D;
   functions->CopyTexImage2D = st_CopyTexImage2D;
   functions->CopyTexSubImage1D = st_CopyTexSubImage1D;
   functions->CopyTexSubImage2D = st_CopyTexSubImage2D;
   functions->CopyTexSubImage3D = st_CopyTexSubImage3D;
   functions->GenerateMipmap = st_generate_mipmap;

   functions->GetTexImage = st_GetTexImage;

   /* compressed texture functions */
   functions->CompressedTexImage2D = st_CompressedTexImage2D;
   functions->GetCompressedTexImage = st_GetCompressedTexImage;
   functions->CompressedTextureSize = _mesa_compressed_texture_size;

   functions->NewTextureObject = st_NewTextureObject;
   functions->NewTextureImage = st_NewTextureImage;
   functions->DeleteTexture = st_DeleteTextureObject;
   functions->FreeTexImageData = st_FreeTextureImageData;
   functions->UpdateTexturePalette = 0;

   functions->TextureMemCpy = do_memcpy;

   /* XXX Temporary until we can query pipe's texture sizes */
   functions->TestProxyTexImage = _mesa_test_proxy_teximage;
}

---