#include "state_tracker/st_context.h"
#include "state_tracker/st_cb_texture.h"
+#include "state_tracker/st_format.h"
#include "state_tracker/st_mipmap_tree.h"
#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
#define DBG if (0) printf
}
+static unsigned
+gl_target_to_pipe(GLenum target)
+{
+ switch (target) {
+ case GL_TEXTURE_1D:
+ return PIPE_TEXTURE_1D;
+
+ case GL_TEXTURE_2D:
+ case GL_TEXTURE_RECTANGLE_NV:
+ return PIPE_TEXTURE_2D;
+
+ case GL_TEXTURE_3D:
+ return PIPE_TEXTURE_3D;
+
+ case GL_TEXTURE_CUBE_MAP_ARB:
+ return PIPE_TEXTURE_CUBE;
+
+ default:
+ assert(0);
+ return 0;
+ }
+}
+
+
static int
-intel_compressed_num_bytes(GLuint mesaFormat)
+compressed_num_bytes(GLuint mesaFormat)
{
int bytes = 0;
switch(mesaFormat) {
}
-/* It works out that this function is fine for all the supported
- * hardware. However, there is still a need to map the formats onto
- * hardware descriptors.
- */
-/* Note that the i915 can actually support many more formats than
- * these if we take the step of simply swizzling the colors
- * immediately after sampling...
- */
-static const struct gl_texture_format *
-st_ChooseTextureFormat(GLcontext * ctx, GLint internalFormat,
- GLenum format, GLenum type)
-{
-#if 0
- struct intel_context *intel = intel_context(ctx);
- const GLboolean do32bpt = (intel->intelScreen->front.cpp == 4);
-#else
- const GLboolean do32bpt = 1;
-#endif
-
- switch (internalFormat) {
- case 4:
- case GL_RGBA:
- case GL_COMPRESSED_RGBA:
- if (format == GL_BGRA) {
- if (type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_INT_8_8_8_8_REV) {
- return &_mesa_texformat_argb8888;
- }
- else if (type == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
- return &_mesa_texformat_argb4444;
- }
- else if (type == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
- return &_mesa_texformat_argb1555;
- }
- }
- return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_argb4444;
-
- case 3:
- case GL_RGB:
- case GL_COMPRESSED_RGB:
- if (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) {
- return &_mesa_texformat_rgb565;
- }
- return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_rgb565;
-
- case GL_RGBA8:
- case GL_RGB10_A2:
- case GL_RGBA12:
- case GL_RGBA16:
- return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_argb4444;
-
- case GL_RGBA4:
- case GL_RGBA2:
- return &_mesa_texformat_argb4444;
-
- case GL_RGB5_A1:
- return &_mesa_texformat_argb1555;
-
- case GL_RGB8:
- case GL_RGB10:
- case GL_RGB12:
- case GL_RGB16:
- return &_mesa_texformat_argb8888;
-
- case GL_RGB5:
- case GL_RGB4:
- case GL_R3_G3_B2:
- return &_mesa_texformat_rgb565;
-
- case GL_ALPHA:
- case GL_ALPHA4:
- case GL_ALPHA8:
- case GL_ALPHA12:
- case GL_ALPHA16:
- case GL_COMPRESSED_ALPHA:
- return &_mesa_texformat_a8;
-
- case 1:
- case GL_LUMINANCE:
- case GL_LUMINANCE4:
- case GL_LUMINANCE8:
- case GL_LUMINANCE12:
- case GL_LUMINANCE16:
- case GL_COMPRESSED_LUMINANCE:
- return &_mesa_texformat_l8;
-
- case 2:
- case GL_LUMINANCE_ALPHA:
- case GL_LUMINANCE4_ALPHA4:
- case GL_LUMINANCE6_ALPHA2:
- case GL_LUMINANCE8_ALPHA8:
- case GL_LUMINANCE12_ALPHA4:
- case GL_LUMINANCE12_ALPHA12:
- case GL_LUMINANCE16_ALPHA16:
- case GL_COMPRESSED_LUMINANCE_ALPHA:
- return &_mesa_texformat_al88;
-
- case GL_INTENSITY:
- case GL_INTENSITY4:
- case GL_INTENSITY8:
- case GL_INTENSITY12:
- case GL_INTENSITY16:
- case GL_COMPRESSED_INTENSITY:
- return &_mesa_texformat_i8;
-
- case GL_YCBCR_MESA:
- if (type == GL_UNSIGNED_SHORT_8_8_MESA || type == GL_UNSIGNED_BYTE)
- return &_mesa_texformat_ycbcr;
- else
- return &_mesa_texformat_ycbcr_rev;
-
- case GL_COMPRESSED_RGB_FXT1_3DFX:
- return &_mesa_texformat_rgb_fxt1;
- case GL_COMPRESSED_RGBA_FXT1_3DFX:
- return &_mesa_texformat_rgba_fxt1;
-
- case GL_RGB_S3TC:
- case GL_RGB4_S3TC:
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- return &_mesa_texformat_rgb_dxt1;
-
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
- return &_mesa_texformat_rgba_dxt1;
-
- case GL_RGBA_S3TC:
- case GL_RGBA4_S3TC:
- case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
- return &_mesa_texformat_rgba_dxt3;
-
- case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
- return &_mesa_texformat_rgba_dxt5;
-
- case GL_DEPTH_COMPONENT:
- case GL_DEPTH_COMPONENT16:
- case GL_DEPTH_COMPONENT24:
- case GL_DEPTH_COMPONENT32:
- return &_mesa_texformat_z16;
-
- case GL_DEPTH_STENCIL_EXT:
- case GL_DEPTH24_STENCIL8_EXT:
- return &_mesa_texformat_z24_s8;
-
- default:
- fprintf(stderr, "unexpected texture format %s in %s\n",
- _mesa_lookup_enum_by_nr(internalFormat), __FUNCTION__);
- return NULL;
- }
-
- return NULL; /* never get here */
-}
static GLboolean
*/
static void
guess_and_alloc_mipmap_tree(struct pipe_context *pipe,
- struct st_texture_object *intelObj,
- struct st_texture_image *intelImage)
+ struct st_texture_object *stObj,
+ struct st_texture_image *stImage)
{
GLuint firstLevel;
GLuint lastLevel;
- GLuint width = intelImage->base.Width;
- GLuint height = intelImage->base.Height;
- GLuint depth = intelImage->base.Depth;
+ GLuint width = stImage->base.Width;
+ GLuint height = stImage->base.Height;
+ GLuint depth = stImage->base.Depth;
GLuint l2width, l2height, l2depth;
GLuint i, comp_byte = 0;
DBG("%s\n", __FUNCTION__);
- if (intelImage->base.Border)
+ if (stImage->base.Border)
return;
- if (intelImage->level > intelObj->base.BaseLevel &&
- (intelImage->base.Width == 1 ||
- (intelObj->base.Target != GL_TEXTURE_1D &&
- intelImage->base.Height == 1) ||
- (intelObj->base.Target == GL_TEXTURE_3D &&
- intelImage->base.Depth == 1)))
+ if (stImage->level > stObj->base.BaseLevel &&
+ (stImage->base.Width == 1 ||
+ (stObj->base.Target != GL_TEXTURE_1D &&
+ stImage->base.Height == 1) ||
+ (stObj->base.Target == GL_TEXTURE_3D &&
+ stImage->base.Depth == 1)))
return;
/* If this image disrespects BaseLevel, allocate from level zero.
* Usually BaseLevel == 0, so it's unlikely to happen.
*/
- if (intelImage->level < intelObj->base.BaseLevel)
+ if (stImage->level < stObj->base.BaseLevel)
firstLevel = 0;
else
- firstLevel = intelObj->base.BaseLevel;
+ firstLevel = stObj->base.BaseLevel;
/* Figure out image dimensions at start level.
*/
- for (i = intelImage->level; i > firstLevel; i--) {
+ for (i = stImage->level; i > firstLevel; i--) {
width <<= 1;
if (height != 1)
height <<= 1;
* resizable buffers, or require that buffers implement lazy
* pagetable arrangements.
*/
- if ((intelObj->base.MinFilter == GL_NEAREST ||
- intelObj->base.MinFilter == GL_LINEAR) &&
- intelImage->level == firstLevel) {
+ if ((stObj->base.MinFilter == GL_NEAREST ||
+ stObj->base.MinFilter == GL_LINEAR) &&
+ stImage->level == firstLevel) {
lastLevel = firstLevel;
}
else {
lastLevel = firstLevel + MAX2(MAX2(l2width, l2height), l2depth);
}
- assert(!intelObj->mt);
- if (intelImage->base.IsCompressed)
- comp_byte = intel_compressed_num_bytes(intelImage->base.TexFormat->MesaFormat);
- intelObj->mt = st_miptree_create(pipe,
- intelObj->base.Target,
- intelImage->base.InternalFormat,
- firstLevel,
- lastLevel,
- width,
- height,
- depth,
- intelImage->base.TexFormat->TexelBytes,
- comp_byte);
+ assert(!stObj->mt);
+ if (stImage->base.IsCompressed)
+ comp_byte = compressed_num_bytes(stImage->base.TexFormat->MesaFormat);
+ stObj->mt = st_miptree_create(pipe,
+ gl_target_to_pipe(stObj->base.Target),
+ stImage->base.InternalFormat,
+ firstLevel,
+ lastLevel,
+ width,
+ height,
+ depth,
+ stImage->base.TexFormat->TexelBytes,
+ comp_byte);
+
+ stObj->mt->format
+ = st_mesa_format_to_pipe_format(stImage->base.TexFormat->MesaFormat);
DBG("%s - success\n", __FUNCTION__);
}
*/
static GLboolean
try_pbo_upload(GLcontext *ctx,
- struct st_texture_image *intelImage,
+ struct st_texture_image *stImage,
const struct gl_pixelstore_attrib *unpack,
GLint internalFormat,
GLint width, GLint height,
else
src_stride = width;
- dst_offset = st_miptree_image_offset(intelImage->mt,
- intelImage->face,
- intelImage->level);
+ dst_offset = st_miptree_image_offset(stImage->mt,
+ stImage->face,
+ stImage->level);
- dst_stride = intelImage->mt->pitch;
+ dst_stride = stImage->mt->pitch;
intelFlush(&intel->ctx);
LOCK_HARDWARE(intel);
/* Temporary hack: cast to _DriBufferObject:
*/
struct _DriBufferObject *dst_buffer =
- (struct _DriBufferObject *)intelImage->mt->region->buffer;
+ (struct _DriBufferObject *)stImage->mt->region->buffer;
intelEmitCopyBlit(intel,
- intelImage->mt->cpp,
+ stImage->mt->cpp,
src_stride, src_buffer, src_offset,
dst_stride, dst_buffer, dst_offset,
0, 0, 0, 0, width, height,
static GLboolean
try_pbo_zcopy(GLcontext *ctx,
- struct st_texture_image *intelImage,
+ struct st_texture_image *stImage,
const struct gl_pixelstore_attrib *unpack,
GLint internalFormat,
GLint width, GLint height,
struct gl_texture_image *texImage, GLsizei imageSize, int compressed)
{
struct pipe_context *pipe = ctx->st->pipe;
- struct st_texture_object *intelObj = st_texture_object(texObj);
- struct st_texture_image *intelImage = st_texture_image(texImage);
+ struct st_texture_object *stObj = st_texture_object(texObj);
+ struct st_texture_image *stImage = st_texture_image(texImage);
GLint postConvWidth = width;
GLint postConvHeight = height;
GLint texelBytes, sizeInBytes;
intelFlush(ctx);
#endif
- intelImage->face = target_to_face(target);
- intelImage->level = level;
+ stImage->face = target_to_face(target);
+ stImage->level = level;
if (ctx->_ImageTransferState & IMAGE_CONVOLUTION_BIT) {
_mesa_adjust_image_for_convolution(ctx, dims, &postConvWidth,
/* Release the reference to a potentially orphaned buffer.
* Release any old malloced memory.
*/
- if (intelImage->mt) {
- st_miptree_release(pipe, &intelImage->mt);
+ if (stImage->mt) {
+ st_miptree_release(pipe, &stImage->mt);
assert(!texImage->Data);
}
else if (texImage->Data) {
* bmBufferData with NULL data to free the old block and avoid
* waiting on any outstanding fences.
*/
- if (intelObj->mt &&
- intelObj->mt->first_level == level &&
- intelObj->mt->last_level == level &&
- intelObj->mt->target != GL_TEXTURE_CUBE_MAP_ARB &&
- !st_miptree_match_image(intelObj->mt, &intelImage->base,
- intelImage->face, intelImage->level)) {
+ if (stObj->mt &&
+ stObj->mt->first_level == level &&
+ stObj->mt->last_level == level &&
+ stObj->mt->target != PIPE_TEXTURE_CUBE &&
+ !st_miptree_match_image(stObj->mt, &stImage->base,
+ stImage->face, stImage->level)) {
DBG("release it\n");
- st_miptree_release(pipe, &intelObj->mt);
- assert(!intelObj->mt);
+ st_miptree_release(pipe, &stObj->mt);
+ assert(!stObj->mt);
}
- if (!intelObj->mt) {
- guess_and_alloc_mipmap_tree(pipe, intelObj, intelImage);
- if (!intelObj->mt) {
+ if (!stObj->mt) {
+ guess_and_alloc_mipmap_tree(pipe, stObj, stImage);
+ if (!stObj->mt) {
DBG("guess_and_alloc_mipmap_tree: failed\n");
}
}
- assert(!intelImage->mt);
+ assert(!stImage->mt);
- if (intelObj->mt &&
- st_miptree_match_image(intelObj->mt, &intelImage->base,
- intelImage->face, intelImage->level)) {
+ if (stObj->mt &&
+ st_miptree_match_image(stObj->mt, &stImage->base,
+ stImage->face, stImage->level)) {
- st_miptree_reference(&intelImage->mt, intelObj->mt);
- assert(intelImage->mt);
+ st_miptree_reference(&stImage->mt, stObj->mt);
+ assert(stImage->mt);
}
- if (!intelImage->mt)
+ if (!stImage->mt)
DBG("XXX: Image did not fit into tree - storing in local memory!\n");
#if 0 /* XXX FIX when st_buffer_objects are in place */
/* PBO fastpaths:
*/
if (dims <= 2 &&
- intelImage->mt &&
+ stImage->mt &&
intel_buffer_object(unpack->BufferObj) &&
check_pbo_format(internalFormat, format,
- type, intelImage->base.TexFormat)) {
+ type, stImage->base.TexFormat)) {
DBG("trying pbo upload\n");
* performance (in particular when pipe_region_cow() is
* required).
*/
- if (intelObj->mt == intelImage->mt &&
- intelObj->mt->first_level == level &&
- intelObj->mt->last_level == level) {
+ if (stObj->mt == stImage->mt &&
+ stObj->mt->first_level == level &&
+ stObj->mt->last_level == level) {
- if (try_pbo_zcopy(intel, intelImage, unpack,
+ if (try_pbo_zcopy(intel, stImage, unpack,
internalFormat,
width, height, format, type, pixels)) {
/* Otherwise, attempt to use the blitter for PBO image uploads.
*/
- if (try_pbo_upload(intel, intelImage, unpack,
+ if (try_pbo_upload(intel, stImage, unpack,
internalFormat,
width, height, format, type, pixels)) {
DBG("pbo upload succeeded\n");
if (!pixels)
return;
-
- if (intelImage->mt)
- pipe->region_idle(pipe, intelImage->mt->region);
-
-#if 0
- LOCK_HARDWARE(intel);
-#endif
-
- if (intelImage->mt) {
+ if (stImage->mt) {
texImage->Data = st_miptree_image_map(pipe,
- intelImage->mt,
- intelImage->face,
- intelImage->level,
+ stImage->mt,
+ stImage->face,
+ stImage->level,
&dstRowStride,
- intelImage->base.ImageOffsets);
+ stImage->base.ImageOffsets);
}
else {
/* Allocate regular memory and store the image there temporarily. */
_mesa_unmap_teximage_pbo(ctx, unpack);
- if (intelImage->mt) {
- st_miptree_image_unmap(pipe, intelImage->mt);
+ if (stImage->mt) {
+ st_miptree_image_unmap(pipe, stImage->mt);
texImage->Data = NULL;
}
-#if 0
- UNLOCK_HARDWARE(intel);
-#endif
-
#if 0
/* GL_SGIS_generate_mipmap -- this can be accelerated now.
*/
if (!pixels)
return;
- if (stImage->mt)
- pipe->region_idle(pipe, stImage->mt->region);
-
-#if 0
- LOCK_HARDWARE(intel);
-#endif
-
/* Map buffer if necessary. Need to lock to prevent other contexts
* from uploading the buffer under us.
*/
st_miptree_image_unmap(pipe, stImage->mt);
texImage->Data = NULL;
}
-
-#if 0
- UNLOCK_HARDWARE(intel);
-#endif
}
struct gl_texture_object *texObj,
struct gl_texture_image *texImage)
{
- st_TexSubimage(ctx, 3,
- target, level,
- xoffset, yoffset, zoffset,
- width, height, depth,
- format, type, pixels, packing, texObj, texImage);
+ st_TexSubimage(ctx, 3, target, level,
+ xoffset, yoffset, zoffset,
+ width, height, depth,
+ format, type, pixels, packing, texObj, texImage);
}
struct gl_texture_object *texObj,
struct gl_texture_image *texImage)
{
- st_TexSubimage(ctx, 2,
- target, level,
- xoffset, yoffset, 0,
- width, height, 1,
- format, type, pixels, packing, texObj, texImage);
+ st_TexSubimage(ctx, 2, target, level,
+ xoffset, yoffset, 0,
+ width, height, 1,
+ format, type, pixels, packing, texObj, texImage);
}
struct gl_texture_object *texObj,
struct gl_texture_image *texImage)
{
- st_TexSubimage(ctx, 1,
- target, level,
- xoffset, 0, 0,
- width, 1, 1,
- format, type, pixels, packing, texObj, texImage);
+ st_TexSubimage(ctx, 1, target, level,
+ xoffset, 0, 0,
+ width, 1, 1,
+ format, type, pixels, packing, texObj, texImage);
}
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
*/
static void
-intel_calculate_first_last_level(struct st_texture_object *intelObj)
+calculate_first_last_level(struct st_texture_object *stObj)
{
- struct gl_texture_object *tObj = &intelObj->base;
+ struct gl_texture_object *tObj = &stObj->base;
const struct gl_texture_image *const baseImage =
tObj->Image[0][tObj->BaseLevel];
}
/* save these values */
- intelObj->firstLevel = firstLevel;
- intelObj->lastLevel = lastLevel;
+ stObj->firstLevel = firstLevel;
+ stObj->lastLevel = lastLevel;
}
static void
copy_image_data_to_tree(struct pipe_context *pipe,
- struct st_texture_object *intelObj,
+ struct st_texture_object *stObj,
struct st_texture_image *stImage)
{
if (stImage->mt) {
/* Copy potentially with the blitter:
*/
st_miptree_image_copy(pipe,
- intelObj->mt,
+ stObj->mt,
stImage->face,
stImage->level, stImage->mt);
/* More straightforward upload.
*/
st_miptree_image_data(pipe,
- intelObj->mt,
+ stObj->mt,
stImage->face,
stImage->level,
stImage->base.Data,
stImage->base.Data = NULL;
}
- st_miptree_reference(&stImage->mt, intelObj->mt);
+ st_miptree_reference(&stImage->mt, stObj->mt);
}
/*
*/
-GLuint
+GLboolean
st_finalize_mipmap_tree(GLcontext *ctx,
struct pipe_context *pipe, GLuint unit,
GLboolean *needFlush)
{
struct gl_texture_object *tObj = ctx->Texture.Unit[unit]._Current;
- struct st_texture_object *intelObj = st_texture_object(tObj);
+ struct st_texture_object *stObj = st_texture_object(tObj);
int comp_byte = 0;
int cpp;
/* We know/require this is true by now:
*/
- assert(intelObj->base._Complete);
+ assert(stObj->base._Complete);
/* What levels must the tree include at a minimum?
*/
- intel_calculate_first_last_level(intelObj);
+ calculate_first_last_level(stObj);
firstImage =
- st_texture_image(intelObj->base.Image[0][intelObj->firstLevel]);
+ st_texture_image(stObj->base.Image[0][stObj->firstLevel]);
/* Fallback case:
*/
if (firstImage->base.Border) {
- if (intelObj->mt) {
- st_miptree_release(pipe, &intelObj->mt);
+ if (stObj->mt) {
+ st_miptree_release(pipe, &stObj->mt);
}
return GL_FALSE;
}
- /* If both firstImage and intelObj have a tree which can contain
+ /* If both firstImage and stObj have a tree 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->mt &&
- firstImage->mt != intelObj->mt &&
- firstImage->mt->first_level <= intelObj->firstLevel &&
- firstImage->mt->last_level >= intelObj->lastLevel) {
+ firstImage->mt != stObj->mt &&
+ firstImage->mt->first_level <= stObj->firstLevel &&
+ firstImage->mt->last_level >= stObj->lastLevel) {
- if (intelObj->mt)
- st_miptree_release(pipe, &intelObj->mt);
+ if (stObj->mt)
+ st_miptree_release(pipe, &stObj->mt);
- st_miptree_reference(&intelObj->mt, firstImage->mt);
+ st_miptree_reference(&stObj->mt, firstImage->mt);
}
if (firstImage->base.IsCompressed) {
- comp_byte = intel_compressed_num_bytes(firstImage->base.TexFormat->MesaFormat);
+ comp_byte = compressed_num_bytes(firstImage->base.TexFormat->MesaFormat);
cpp = comp_byte;
}
else cpp = firstImage->base.TexFormat->TexelBytes;
* programming minLod, maxLod, baseLevel into the hardware and
* leaving the tree alone.
*/
- if (intelObj->mt &&
- (intelObj->mt->target != intelObj->base.Target ||
- intelObj->mt->internal_format != firstImage->base.InternalFormat ||
- intelObj->mt->first_level != intelObj->firstLevel ||
- intelObj->mt->last_level != intelObj->lastLevel ||
- intelObj->mt->width0 != firstImage->base.Width ||
- intelObj->mt->height0 != firstImage->base.Height ||
- intelObj->mt->depth0 != firstImage->base.Depth ||
- intelObj->mt->cpp != cpp ||
- intelObj->mt->compressed != firstImage->base.IsCompressed)) {
- st_miptree_release(pipe, &intelObj->mt);
+ if (stObj->mt &&
+ (stObj->mt->target != gl_target_to_pipe(stObj->base.Target) ||
+ stObj->mt->internal_format != firstImage->base.InternalFormat ||
+ stObj->mt->first_level != stObj->firstLevel ||
+ stObj->mt->last_level != stObj->lastLevel ||
+ stObj->mt->width0 != firstImage->base.Width ||
+ stObj->mt->height0 != firstImage->base.Height ||
+ stObj->mt->depth0 != firstImage->base.Depth ||
+ stObj->mt->cpp != cpp ||
+ stObj->mt->compressed != firstImage->base.IsCompressed)) {
+ st_miptree_release(pipe, &stObj->mt);
}
/* May need to create a new tree:
*/
- if (!intelObj->mt) {
- intelObj->mt = st_miptree_create(pipe,
- intelObj->base.Target,
- firstImage->base.InternalFormat,
- intelObj->firstLevel,
- intelObj->lastLevel,
- firstImage->base.Width,
- firstImage->base.Height,
- firstImage->base.Depth,
- cpp,
- comp_byte);
+ if (!stObj->mt) {
+ stObj->mt = st_miptree_create(pipe,
+ gl_target_to_pipe(stObj->base.Target),
+ firstImage->base.InternalFormat,
+ stObj->firstLevel,
+ stObj->lastLevel,
+ firstImage->base.Width,
+ firstImage->base.Height,
+ firstImage->base.Depth,
+ cpp,
+ comp_byte);
+
+ stObj->mt->format
+ = st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
}
/* Pull in any images not in the object's tree:
*/
- nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
+ nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
for (face = 0; face < nr_faces; face++) {
- for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++) {
+ for (i = stObj->firstLevel; i <= stObj->lastLevel; i++) {
struct st_texture_image *stImage =
- st_texture_image(intelObj->base.Image[face][i]);
+ st_texture_image(stObj->base.Image[face][i]);
/* Need to import images in main memory or held in other trees.
*/
- if (intelObj->mt != stImage->mt) {
- copy_image_data_to_tree(pipe, intelObj, stImage);
+ if (stObj->mt != stImage->mt) {
+ copy_image_data_to_tree(pipe, stObj, stImage);
*needFlush = GL_TRUE;
}
}
#if 0 /* unused? */
void
st_tex_map_images(struct pipe_context *pipe,
- struct st_texture_object *intelObj)
+ struct st_texture_object *stObj)
{
- GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
+ GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
GLuint face, i;
DBG("%s\n", __FUNCTION__);
for (face = 0; face < nr_faces; face++) {
- for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++) {
+ for (i = stObj->firstLevel; i <= stObj->lastLevel; i++) {
struct st_texture_image *stImage =
- st_texture_image(intelObj->base.Image[face][i]);
+ st_texture_image(stObj->base.Image[face][i]);
if (stImage->mt) {
- stImage->base.Data =
- st_miptree_image_map(pipe,
- stImage->mt,
- stImage->face,
- stImage->level,
- &stImage->base.RowStride,
- stImage->base.ImageOffsets);
+ stImage->base.Data
+ = st_miptree_image_map(pipe,
+ stImage->mt,
+ stImage->face,
+ stImage->level,
+ &stImage->base.RowStride,
+ stImage->base.ImageOffsets);
/* convert stride to texels, not bytes */
stImage->base.RowStride /= stImage->mt->cpp;
/* stImage->base.ImageStride /= stImage->mt->cpp; */
void
st_tex_unmap_images(struct pipe_context *pipe,
- struct st_texture_object *intelObj)
+ struct st_texture_object *stObj)
{
- GLuint nr_faces = (intelObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
+ GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
GLuint face, i;
for (face = 0; face < nr_faces; face++) {
- for (i = intelObj->firstLevel; i <= intelObj->lastLevel; i++) {
+ for (i = stObj->firstLevel; i <= stObj->lastLevel; i++) {
struct st_texture_image *stImage =
- st_texture_image(intelObj->base.Image[face][i]);
+ st_texture_image(stObj->base.Image[face][i]);
if (stImage->mt) {
st_miptree_image_unmap(pipe, stImage->mt);
projects / mesa.git / blobdiff