#include "main/fbobject.h"
#include "main/feedback.h"
#include "main/formats.h"
+#include "main/glformats.h"
#include "main/image.h"
#include "main/macros.h"
#include "main/matrix.h"
#include "main/teximage.h"
#include "main/texparam.h"
#include "main/texstate.h"
+#include "main/transformfeedback.h"
#include "main/uniforms.h"
#include "main/varray.h"
#include "main/viewport.h"
struct gl_query_object *CondRenderQuery;
GLenum CondRenderMode;
+#if FEATURE_feedback
/** MESA_META_SELECT_FEEDBACK */
GLenum RenderMode;
struct gl_selection Select;
struct gl_feedback Feedback;
+#endif
+
+ /** MESA_META_MULTISAMPLE */
+ GLboolean MultisampleEnabled;
/** Miscellaneous (always disabled) */
GLboolean Lighting;
+ GLboolean RasterDiscard;
+#if FEATURE_EXT_transform_feedback
+ GLboolean TransformFeedbackNeedsResume;
+#endif
};
/**
struct decompress_state
{
GLuint ArrayObj;
- GLuint VBO, FBO, RBO;
+ GLuint VBO, FBO, RBO, Sampler;
GLint Width, Height;
};
struct drawtex_state DrawTex; /**< For _mesa_meta_DrawTex() */
};
+static void meta_glsl_blit_cleanup(struct gl_context *ctx, struct blit_state *blit);
+static void cleanup_temp_texture(struct gl_context *ctx, struct temp_texture *tex);
+static void meta_glsl_clear_cleanup(struct gl_context *ctx, struct clear_state *clear);
+
static GLuint
compile_shader_with_debug(struct gl_context *ctx, GLenum target, const GLcharARB *source)
{
return shader;
_mesa_GetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
- if (size == 0)
+ if (size == 0) {
+ _mesa_DeleteObjectARB(shader);
return 0;
+ }
info = malloc(size);
- if (!info)
+ if (!info) {
+ _mesa_DeleteObjectARB(shader);
return 0;
+ }
_mesa_GetProgramInfoLog(shader, size, NULL, info);
_mesa_problem(ctx,
info, source);
free(info);
+ _mesa_DeleteObjectARB(shader);
return 0;
}
void
_mesa_meta_free(struct gl_context *ctx)
{
- /* Note: Any textures, VBOs, etc, that we allocate should get
- * freed by the normal context destruction code. But this would be
- * the place to free other meta data someday.
- */
+ GET_CURRENT_CONTEXT(old_context);
+ _mesa_make_current(ctx, NULL, NULL);
+ meta_glsl_blit_cleanup(ctx, &ctx->Meta->Blit);
+ meta_glsl_clear_cleanup(ctx, &ctx->Meta->Clear);
+ cleanup_temp_texture(ctx, &ctx->Meta->TempTex);
+ if (old_context)
+ _mesa_make_current(old_context, old_context->WinSysDrawBuffer, old_context->WinSysReadBuffer);
+ else
+ _mesa_make_current(NULL, NULL, NULL);
free(ctx->Meta);
ctx->Meta = NULL;
}
memset(save, 0, sizeof(*save));
save->SavedState = state;
+#if FEATURE_EXT_transform_feedback
+ /* Pausing transform feedback needs to be done early, or else we won't be
+ * able to change other state.
+ */
+ save->TransformFeedbackNeedsResume =
+ ctx->TransformFeedback.CurrentObject->Active &&
+ !ctx->TransformFeedback.CurrentObject->Paused;
+ if (save->TransformFeedbackNeedsResume)
+ _mesa_PauseTransformFeedback();
+#endif
+
if (state & MESA_META_ALPHA_TEST) {
save->AlphaEnabled = ctx->Color.AlphaEnabled;
save->AlphaFunc = ctx->Color.AlphaFunc;
_mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);
if (ctx->Extensions.NV_texture_rectangle)
_mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_FALSE);
+ if (ctx->Extensions.OES_EGL_image_external)
+ _mesa_set_enable(ctx, GL_TEXTURE_EXTERNAL_OES, GL_FALSE);
_mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_FALSE);
_mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_FALSE);
_mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_FALSE);
_mesa_EndConditionalRender();
}
+#if FEATURE_feedback
if (state & MESA_META_SELECT_FEEDBACK) {
save->RenderMode = ctx->RenderMode;
if (ctx->RenderMode == GL_SELECT) {
_mesa_RenderMode(GL_RENDER);
}
}
+#endif
+
+ if (state & MESA_META_MULTISAMPLE) {
+ save->MultisampleEnabled = ctx->Multisample.Enabled;
+ if (ctx->Multisample.Enabled)
+ _mesa_set_enable(ctx, GL_MULTISAMPLE, GL_FALSE);
+ }
/* misc */
{
save->Lighting = ctx->Light.Enabled;
if (ctx->Light.Enabled)
_mesa_set_enable(ctx, GL_LIGHTING, GL_FALSE);
+ save->RasterDiscard = ctx->RasterDiscard;
+ if (ctx->RasterDiscard)
+ _mesa_set_enable(ctx, GL_RASTERIZER_DISCARD, GL_FALSE);
}
}
save->CondRenderMode);
}
+#if FEATURE_feedback
if (state & MESA_META_SELECT_FEEDBACK) {
if (save->RenderMode == GL_SELECT) {
_mesa_RenderMode(GL_SELECT);
ctx->Feedback = save->Feedback;
}
}
+#endif
+
+ if (state & MESA_META_MULTISAMPLE) {
+ if (ctx->Multisample.Enabled != save->MultisampleEnabled)
+ _mesa_set_enable(ctx, GL_MULTISAMPLE, save->MultisampleEnabled);
+ }
/* misc */
if (save->Lighting) {
_mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
}
+ if (save->RasterDiscard) {
+ _mesa_set_enable(ctx, GL_RASTERIZER_DISCARD, GL_TRUE);
+ }
+#if FEATURE_EXT_transform_feedback
+ if (save->TransformFeedbackNeedsResume)
+ _mesa_ResumeTransformFeedback();
+#endif
}
static INLINE GLfloat
invert_z(GLfloat normZ)
{
- GLfloat objZ = 1.0 - 2.0 * normZ;
+ GLfloat objZ = 1.0f - 2.0f * normZ;
return objZ;
}
_mesa_GenTextures(1, &tex->TexObj);
}
+static void
+cleanup_temp_texture(struct gl_context *ctx, struct temp_texture *tex)
+{
+ if (!tex->TexObj)
+ return;
+ _mesa_DeleteTextures(1, &tex->TexObj);
+ tex->TexObj = 0;
+}
+
/**
* Return pointer to temp_texture info for non-bitmap ops.
if (readAtt && readAtt->Texture) {
const struct gl_texture_object *texObj = readAtt->Texture;
const GLuint srcLevel = readAtt->TextureLevel;
- const GLenum minFilterSave = texObj->Sampler.MinFilter;
- const GLenum magFilterSave = texObj->Sampler.MagFilter;
const GLint baseLevelSave = texObj->BaseLevel;
const GLint maxLevelSave = texObj->MaxLevel;
- const GLenum wrapSSave = texObj->Sampler.WrapS;
- const GLenum wrapTSave = texObj->Sampler.WrapT;
- const GLenum srgbSave = texObj->Sampler.sRGBDecode;
const GLenum fbo_srgb_save = ctx->Color.sRGBEnabled;
const GLenum target = texObj->Target;
+ GLuint sampler, samplerSave =
+ ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler ?
+ ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler->Name : 0;
if (drawAtt->Texture == readAtt->Texture) {
/* Can't use same texture as both the source and dest. We need
return mask;
}
+ _mesa_GenSamplers(1, &sampler);
+ _mesa_BindSampler(ctx->Texture.CurrentUnit, sampler);
+
/*
printf("Blit from texture!\n");
printf(" srcAtt %p dstAtt %p\n", readAtt, drawAtt);
/* Prepare src texture state */
_mesa_BindTexture(target, texObj->Name);
- _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
- _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
+ _mesa_SamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, filter);
+ _mesa_SamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, filter);
if (target != GL_TEXTURE_RECTANGLE_ARB) {
_mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, srcLevel);
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);
}
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ _mesa_SamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ _mesa_SamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
/* Always do our blits with no sRGB decode or encode.*/
if (ctx->Extensions.EXT_texture_sRGB_decode) {
- _mesa_TexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT,
+ _mesa_SamplerParameteri(sampler, GL_TEXTURE_SRGB_DECODE_EXT,
GL_SKIP_DECODE_EXT);
}
if (ctx->Extensions.EXT_framebuffer_sRGB) {
/* Restore texture object state, the texture binding will
* be restored by _mesa_meta_end().
*/
- _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
- _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
if (target != GL_TEXTURE_RECTANGLE_ARB) {
_mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, baseLevelSave);
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
}
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);
- if (ctx->Extensions.EXT_texture_sRGB_decode) {
- _mesa_TexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT, srgbSave);
- }
if (ctx->Extensions.EXT_framebuffer_sRGB && fbo_srgb_save) {
_mesa_set_enable(ctx, GL_FRAMEBUFFER_SRGB_EXT, GL_TRUE);
}
+ _mesa_BindSampler(ctx->Texture.CurrentUnit, samplerSave);
+ _mesa_DeleteSamplers(1, &sampler);
+
/* Done with color buffer */
mask &= ~GL_COLOR_BUFFER_BIT;
}
struct vertex verts[4];
GLboolean newTex;
- if (srcW > maxTexSize || srcH > maxTexSize) {
+ /* In addition to falling back if the blit size is larger than the maximum
+ * texture size, fallback if the source is multisampled. This fallback can
+ * be removed once Mesa gets support ARB_texture_multisample.
+ */
+ if (srcW > maxTexSize || srcH > maxTexSize
+ || ctx->ReadBuffer->Visual.samples > 0) {
/* XXX avoid this fallback */
_swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1, mask, filter);
}
}
+static void
+meta_glsl_blit_cleanup(struct gl_context *ctx, struct blit_state *blit)
+{
+ if (blit->ArrayObj) {
+ _mesa_DeleteVertexArraysAPPLE(1, &blit->ArrayObj);
+ blit->ArrayObj = 0;
+ _mesa_DeleteBuffersARB(1, &blit->VBO);
+ blit->VBO = 0;
+ }
+ if (blit->DepthFP) {
+ _mesa_DeletePrograms(1, &blit->DepthFP);
+ blit->DepthFP = 0;
+ }
+}
+
/**
* Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
clear->ShaderProg = _mesa_CreateProgramObjectARB();
_mesa_AttachShader(clear->ShaderProg, fs);
+ _mesa_DeleteObjectARB(fs);
_mesa_AttachShader(clear->ShaderProg, vs);
+ _mesa_DeleteObjectARB(vs);
_mesa_BindAttribLocationARB(clear->ShaderProg, 0, "position");
_mesa_LinkProgramARB(clear->ShaderProg);
clear->ColorLocation = _mesa_GetUniformLocationARB(clear->ShaderProg,
"color");
- if (ctx->Const.GLSLVersion >= 130) {
+ if (_mesa_is_desktop_gl(ctx) && ctx->Const.GLSLVersion >= 130) {
vs = compile_shader_with_debug(ctx, GL_VERTEX_SHADER, vs_int_source);
fs = compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER, fs_int_source);
clear->IntegerShaderProg = _mesa_CreateProgramObjectARB();
_mesa_AttachShader(clear->IntegerShaderProg, fs);
+ _mesa_DeleteObjectARB(fs);
_mesa_AttachShader(clear->IntegerShaderProg, vs);
+ _mesa_DeleteObjectARB(vs);
_mesa_BindAttribLocationARB(clear->IntegerShaderProg, 0, "position");
/* Note that user-defined out attributes get automatically assigned
}
}
+static void
+meta_glsl_clear_cleanup(struct gl_context *ctx, struct clear_state *clear)
+{
+ if (clear->ArrayObj == 0)
+ return;
+ _mesa_DeleteVertexArraysAPPLE(1, &clear->ArrayObj);
+ clear->ArrayObj = 0;
+ _mesa_DeleteBuffersARB(1, &clear->VBO);
+ clear->VBO = 0;
+ _mesa_DeleteObjectARB(clear->ShaderProg);
+ clear->ShaderProg = 0;
+
+ if (clear->IntegerShaderProg) {
+ _mesa_DeleteObjectARB(clear->IntegerShaderProg);
+ clear->IntegerShaderProg = 0;
+ }
+}
+
/**
* Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
*/
MESA_META_VERTEX |
MESA_META_VIEWPORT |
MESA_META_CLIP |
- MESA_META_CLAMP_FRAGMENT_COLOR);
+ MESA_META_CLAMP_FRAGMENT_COLOR |
+ MESA_META_MULTISAMPLE);
if (!(buffers & BUFFER_BITS_COLOR)) {
/* We'll use colormask to disable color writes. Otherwise,
* Determine if we can do the glDrawPixels with texture mapping.
*/
fallback = GL_FALSE;
- if (ctx->_ImageTransferState ||
- ctx->Fog.Enabled) {
+ if (ctx->Fog.Enabled) {
fallback = GL_TRUE;
}
texIntFormat = GL_ALPHA;
metaExtraSave = (MESA_META_COLOR_MASK |
MESA_META_DEPTH_TEST |
+ MESA_META_PIXEL_TRANSFER |
MESA_META_SHADER |
MESA_META_STENCIL_TEST);
}
MESA_META_CLIP |
MESA_META_VERTEX |
MESA_META_VIEWPORT |
- MESA_META_CLAMP_FRAGMENT_COLOR |
metaExtraSave));
newTex = alloc_texture(tex, width, height, texIntFormat);
/* setup texcoords (XXX what about border?) */
setup_texture_coords(faceTarget,
- 0.0, 0.0, /* width, height never used here */
slice,
+ 0, 0, /* width, height never used here */
verts[0].tex,
verts[1].tex,
verts[2].tex,
/* sanity check */
status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
- abort();
+ _mesa_problem(ctx, "Unexpected incomplete framebuffer in "
+ "_mesa_meta_GenerateMipmap()");
break;
}
switch (baseFormat) {
case GL_RGBA:
case GL_RGB:
+ case GL_RG:
+ case GL_RED:
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
case GL_DEPTH_STENCIL:
return GL_UNSIGNED_INT_24_8;
default:
- _mesa_problem(ctx, "Unexpected format in get_temp_image_type()");
+ _mesa_problem(ctx, "Unexpected format %d in get_temp_image_type()",
+ baseFormat);
return 0;
}
}
* Helper for _mesa_meta_CopyTexSubImage1/2/3D() functions.
* Have to be careful with locking and meta state for pixel transfer.
*/
-static void
-copy_tex_sub_image(struct gl_context *ctx,
- GLuint dims, GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset,
- GLint x, GLint y,
- GLsizei width, GLsizei height)
+void
+_mesa_meta_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
+ struct gl_texture_image *texImage,
+ GLint xoffset, GLint yoffset, GLint zoffset,
+ struct gl_renderbuffer *rb,
+ GLint x, GLint y,
+ GLsizei width, GLsizei height)
{
- struct gl_texture_object *texObj;
- struct gl_texture_image *texImage;
+ struct gl_texture_object *texObj = texImage->TexObject;
GLenum format, type;
GLint bpp;
void *buf;
- texObj = _mesa_get_current_tex_object(ctx, target);
- texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-
/* Choose format/type for temporary image buffer */
format = _mesa_get_format_base_format(texImage->TexFormat);
if (format == GL_LUMINANCE ||
format = GL_RGBA;
}
+ if (_mesa_is_format_integer_color(texImage->TexFormat)) {
+ _mesa_problem(ctx, "unsupported integer color copyteximage");
+ return;
+ }
+
type = get_temp_image_type(ctx, format);
bpp = _mesa_bytes_per_pixel(format, type);
if (bpp <= 0) {
- _mesa_problem(ctx, "Bad bpp in meta copy_tex_sub_image()");
+ _mesa_problem(ctx, "Bad bpp in _mesa_meta_CopyTexSubImage()");
return;
}
* Store texture data (with pixel transfer ops)
*/
_mesa_meta_begin(ctx, MESA_META_PIXEL_STORE);
- if (target == GL_TEXTURE_1D) {
- ctx->Driver.TexSubImage1D(ctx, target, level, xoffset,
- width, format, type, buf,
- &ctx->Unpack, texObj, texImage);
- }
- else if (target == GL_TEXTURE_3D) {
- ctx->Driver.TexSubImage3D(ctx, target, level, xoffset, yoffset, zoffset,
- width, height, 1, format, type, buf,
- &ctx->Unpack, texObj, texImage);
- }
- else {
- ctx->Driver.TexSubImage2D(ctx, target, level, xoffset, yoffset,
- width, height, format, type, buf,
- &ctx->Unpack, texObj, texImage);
- }
+
+ ctx->Driver.TexSubImage(ctx, dims, texImage,
+ xoffset, yoffset, zoffset, width, height, 1,
+ format, type, buf, &ctx->Unpack);
+
_mesa_meta_end(ctx);
_mesa_lock_texture(ctx, texObj); /* re-lock */
}
-void
-_mesa_meta_CopyTexSubImage1D(struct gl_context *ctx, GLenum target, GLint level,
- GLint xoffset,
- GLint x, GLint y, GLsizei width)
-{
- copy_tex_sub_image(ctx, 1, target, level, xoffset, 0, 0,
- x, y, width, 1);
-}
-
-
-void
-_mesa_meta_CopyTexSubImage2D(struct gl_context *ctx, GLenum target, GLint level,
- GLint xoffset, GLint yoffset,
- GLint x, GLint y,
- GLsizei width, GLsizei height)
-{
- copy_tex_sub_image(ctx, 2, target, level, xoffset, yoffset, 0,
- x, y, width, height);
-}
-
-
-void
-_mesa_meta_CopyTexSubImage3D(struct gl_context *ctx, GLenum target, GLint level,
- GLint xoffset, GLint yoffset, GLint zoffset,
- GLint x, GLint y,
- GLsizei width, GLsizei height)
-{
- copy_tex_sub_image(ctx, 3, target, level, xoffset, yoffset, zoffset,
- x, y, width, height);
-}
-
-
/**
* Decompress a texture image by drawing a quad with the compressed
* texture and reading the pixels out of the color buffer.
struct gl_texture_image *texImage,
GLuint slice,
GLenum destFormat, GLenum destType,
- GLvoid *dest, GLint destRowLength)
+ GLvoid *dest)
{
struct decompress_state *decompress = &ctx->Meta->Decompress;
struct gl_texture_object *texObj = texImage->TexObject;
};
struct vertex verts[4];
GLuint fboDrawSave, fboReadSave;
+ GLuint rbSave;
+ GLuint samplerSave;
if (slice > 0) {
assert(target == GL_TEXTURE_3D ||
/* save fbo bindings (not saved by _mesa_meta_begin()) */
fboDrawSave = ctx->DrawBuffer->Name;
fboReadSave = ctx->ReadBuffer->Name;
+ rbSave = ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
- _mesa_meta_begin(ctx, MESA_META_ALL);
+ _mesa_meta_begin(ctx, MESA_META_ALL & ~MESA_META_PIXEL_STORE);
+
+ samplerSave = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler ?
+ ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler->Name : 0;
/* Create/bind FBO/renderbuffer */
if (decompress->FBO == 0) {
}
/* alloc dest surface */
- if (width != decompress->Width || height != decompress->Height) {
+ if (width > decompress->Width || height > decompress->Height) {
+ _mesa_BindRenderbufferEXT(GL_RENDERBUFFER_EXT, decompress->RBO);
_mesa_RenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA,
width, height);
decompress->Width = width;
_mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, decompress->VBO);
}
+ if (!decompress->Sampler) {
+ _mesa_GenSamplers(1, &decompress->Sampler);
+ _mesa_BindSampler(ctx->Texture.CurrentUnit, decompress->Sampler);
+ /* nearest filtering */
+ _mesa_SamplerParameteri(decompress->Sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ _mesa_SamplerParameteri(decompress->Sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ /* No sRGB decode or encode.*/
+ if (ctx->Extensions.EXT_texture_sRGB_decode) {
+ _mesa_SamplerParameteri(decompress->Sampler, GL_TEXTURE_SRGB_DECODE_EXT,
+ GL_SKIP_DECODE_EXT);
+ }
+
+ } else {
+ _mesa_BindSampler(ctx->Texture.CurrentUnit, decompress->Sampler);
+ }
+
setup_texture_coords(faceTarget, slice, width, height,
verts[0].tex,
verts[1].tex,
{
/* save texture object state */
- const GLenum minFilterSave = texObj->Sampler.MinFilter;
- const GLenum magFilterSave = texObj->Sampler.MagFilter;
const GLint baseLevelSave = texObj->BaseLevel;
const GLint maxLevelSave = texObj->MaxLevel;
- const GLenum wrapSSave = texObj->Sampler.WrapS;
- const GLenum wrapTSave = texObj->Sampler.WrapT;
- const GLenum srgbSave = texObj->Sampler.sRGBDecode;
/* restrict sampling to the texture level of interest */
_mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, texImage->Level);
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, texImage->Level);
- /* nearest filtering */
- _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
/* No sRGB decode or encode.*/
- if (ctx->Extensions.EXT_texture_sRGB_decode) {
- _mesa_TexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT,
- GL_SKIP_DECODE_EXT);
- }
if (ctx->Extensions.EXT_framebuffer_sRGB) {
_mesa_set_enable(ctx, GL_FRAMEBUFFER_SRGB_EXT, GL_FALSE);
}
/* Restore texture object state, the texture binding will
* be restored by _mesa_meta_end().
*/
- _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
- _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
if (target != GL_TEXTURE_RECTANGLE_ARB) {
_mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, baseLevelSave);
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
}
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);
- if (ctx->Extensions.EXT_texture_sRGB_decode) {
- _mesa_TexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT, srgbSave);
- }
+
}
/* read pixels from renderbuffer */
_mesa_PixelTransferf(GL_BLUE_SCALE, 0.0f);
}
- ctx->Pack.RowLength = destRowLength;
_mesa_ReadPixels(0, 0, width, height, destFormat, destType, dest);
}
/* disable texture unit */
_mesa_set_enable(ctx, target, GL_FALSE);
+ _mesa_BindSampler(ctx->Texture.CurrentUnit, samplerSave);
+
_mesa_meta_end(ctx);
/* restore fbo bindings */
_mesa_BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fboDrawSave);
_mesa_BindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fboReadSave);
}
+ _mesa_BindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbSave);
}
const GLuint slice = 0; /* only 2D compressed textures for now */
/* Need to unlock the texture here to prevent deadlock... */
_mesa_unlock_texture(ctx, texObj);
- decompress_texture_image(ctx, texImage, slice, format, type, pixels,
- ctx->Pack.RowLength);
+ decompress_texture_image(ctx, texImage, slice, format, type, pixels);
/* ... and relock it */
_mesa_lock_texture(ctx, texObj);
}
projects / mesa.git / blobdiff