* default / window-system FB object.
* If \p attachment is GL_DEPTH_STENCIL_ATTACHMENT, return a pointer to
* the depth buffer attachment point.
+ * Returns if the attachment is a GL_COLOR_ATTACHMENTm_EXT on
+ * is_color_attachment, because several callers would return different errors
+ * if they don't find the attachment.
*/
static struct gl_renderbuffer_attachment *
get_attachment(struct gl_context *ctx, struct gl_framebuffer *fb,
- GLenum attachment)
+ GLenum attachment, bool *is_color_attachment)
{
GLuint i;
assert(_mesa_is_user_fbo(fb));
+ if (is_color_attachment)
+ *is_color_attachment = false;
+
switch (attachment) {
case GL_COLOR_ATTACHMENT0_EXT:
case GL_COLOR_ATTACHMENT1_EXT:
case GL_COLOR_ATTACHMENT13_EXT:
case GL_COLOR_ATTACHMENT14_EXT:
case GL_COLOR_ATTACHMENT15_EXT:
+ if (is_color_attachment)
+ *is_color_attachment = true;
/* Only OpenGL ES 1.x forbids color attachments other than
* GL_COLOR_ATTACHMENT0. For all other APIs the limit set by the
* hardware is used.
switch (attachment) {
case GL_FRONT_LEFT:
- return &fb->Attachment[BUFFER_FRONT_LEFT];
+ /* Front buffers can be allocated on the first use, but
+ * glGetFramebufferAttachmentParameteriv must work even if that
+ * allocation hasn't happened yet. In such case, use the back buffer,
+ * which should be the same.
+ */
+ if (fb->Attachment[BUFFER_FRONT_LEFT].Type == GL_NONE)
+ return &fb->Attachment[BUFFER_BACK_LEFT];
+ else
+ return &fb->Attachment[BUFFER_FRONT_LEFT];
case GL_FRONT_RIGHT:
- return &fb->Attachment[BUFFER_FRONT_RIGHT];
+ /* Same as above. */
+ if (fb->Attachment[BUFFER_FRONT_RIGHT].Type == GL_NONE)
+ return &fb->Attachment[BUFFER_BACK_RIGHT];
+ else
+ return &fb->Attachment[BUFFER_FRONT_RIGHT];
case GL_BACK_LEFT:
return &fb->Attachment[BUFFER_BACK_LEFT];
case GL_BACK_RIGHT:
const struct gl_texture_image *const texImage =
att->Texture->Image[att->CubeMapFace][att->TextureLevel];
- if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
+ if (!texImage ||
+ texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0)
return false;
if ((texImage->TexObject->Target == GL_TEXTURE_1D_ARRAY
mtx_lock(&fb->Mutex);
- att = get_attachment(ctx, fb, attachment);
+ att = get_attachment(ctx, fb, attachment, NULL);
assert(att);
if (rb) {
set_renderbuffer_attachment(ctx, att, rb);
if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
/* do stencil attachment here (depth already done above) */
- att = get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT);
+ att = get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT, NULL);
assert(att);
set_renderbuffer_attachment(ctx, att, rb);
}
remove_attachment(ctx, att);
if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
/* detach stencil (depth was detached above) */
- att = get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT);
+ att = get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT, NULL);
assert(att);
remove_attachment(ctx, att);
}
break;
}
- baseFormat = _mesa_get_format_base_format(texImage->TexFormat);
+ baseFormat = texImage->_BaseFormat;
if (format == GL_COLOR) {
if (!_mesa_is_legal_color_format(ctx, baseFormat)) {
}
}
else if (att->Type == GL_RENDERBUFFER_EXT) {
- const GLenum baseFormat =
- _mesa_get_format_base_format(att->Renderbuffer->Format);
+ const GLenum baseFormat = att->Renderbuffer->_BaseFormat;
assert(att->Renderbuffer);
if (!att->Renderbuffer->InternalFormat ||
fb->_AllColorBuffersFixedPoint = GL_TRUE;
fb->_HasSNormOrFloatColorBuffer = GL_FALSE;
fb->_HasAttachments = true;
+ fb->_IntegerBuffers = 0;
/* Start at -2 to more easily loop over all attachment points.
* -2: depth buffer
continue;
}
- /* check if integer color */
- fb->_IntegerColor = _mesa_is_format_integer_color(attFormat);
-
- /* Update _AllColorBuffersFixedPoint and _HasSNormOrFloatColorBuffer. */
+ /* Update flags describing color buffer datatypes */
if (i >= 0) {
GLenum type = _mesa_get_format_datatype(attFormat);
+ /* check if integer color */
+ if (_mesa_is_format_integer_color(attFormat))
+ fb->_IntegerBuffers |= (1 << i);
+
fb->_AllColorBuffersFixedPoint =
fb->_AllColorBuffersFixedPoint &&
(type == GL_UNSIGNED_NORMALIZED || type == GL_SIGNED_NORMALIZED);
for (j = 0; j < ctx->Const.MaxDrawBuffers; j++) {
if (fb->ColorDrawBuffer[j] != GL_NONE) {
const struct gl_renderbuffer_attachment *att
- = get_attachment(ctx, fb, fb->ColorDrawBuffer[j]);
+ = get_attachment(ctx, fb, fb->ColorDrawBuffer[j], NULL);
assert(att);
if (att->Type == GL_NONE) {
fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT;
/* Check that the ReadBuffer is present */
if (fb->ColorReadBuffer != GL_NONE) {
const struct gl_renderbuffer_attachment *att
- = get_attachment(ctx, fb, fb->ColorReadBuffer);
+ = get_attachment(ctx, fb, fb->ColorReadBuffer, NULL);
assert(att);
if (att->Type == GL_NONE) {
fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT;
ctx->Driver.ValidateFramebuffer(ctx, fb);
if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fbo_incomplete(ctx, "driver marked FBO as incomplete", -1);
+ return;
}
}
- if (fb->_Status == GL_FRAMEBUFFER_COMPLETE_EXT) {
- /*
- * Note that if ARB_framebuffer_object is supported and the attached
- * renderbuffers/textures are different sizes, the framebuffer
- * width/height will be set to the smallest width/height.
- */
- if (numImages != 0) {
- fb->Width = minWidth;
- fb->Height = minHeight;
- }
-
- /* finally, update the visual info for the framebuffer */
- _mesa_update_framebuffer_visual(ctx, fb);
+ /*
+ * Note that if ARB_framebuffer_object is supported and the attached
+ * renderbuffers/textures are different sizes, the framebuffer
+ * width/height will be set to the smallest width/height.
+ */
+ if (numImages != 0) {
+ fb->Width = minWidth;
+ fb->Height = minHeight;
}
+
+ /* finally, update the visual info for the framebuffer */
+ _mesa_update_framebuffer_visual(ctx, fb);
}
static struct gl_renderbuffer *
-allocate_renderbuffer(struct gl_context *ctx, GLuint renderbuffer,
- const char *func)
+allocate_renderbuffer_locked(struct gl_context *ctx, GLuint renderbuffer,
+ const char *func)
{
struct gl_renderbuffer *newRb;
return NULL;
}
assert(newRb->AllocStorage);
- mtx_lock(&ctx->Shared->Mutex);
- _mesa_HashInsert(ctx->Shared->RenderBuffers, renderbuffer, newRb);
+ _mesa_HashInsertLocked(ctx->Shared->RenderBuffers, renderbuffer, newRb);
newRb->RefCount = 1; /* referenced by hash table */
- mtx_unlock(&ctx->Shared->Mutex);
return newRb;
}
}
if (!newRb) {
- newRb = allocate_renderbuffer(ctx, renderbuffer, "glBindRenderbufferEXT");
+ _mesa_HashLockMutex(ctx->Shared->RenderBuffers);
+ newRb = allocate_renderbuffer_locked(ctx, renderbuffer,
+ "glBindRenderbufferEXT");
+ _mesa_HashUnlockMutex(ctx->Shared->RenderBuffers);
}
}
else {
bind_renderbuffer(target, renderbuffer, true);
}
+/**
+ * ARB_framebuffer_no_attachment - Application passes requested param's
+ * here. NOTE: NumSamples requested need not be _NumSamples which is
+ * what the hw supports.
+ */
static void
framebuffer_parameteri(struct gl_context *ctx, struct gl_framebuffer *fb,
GLenum pname, GLint param, const char *func)
fb->DefaultGeometry.Height = param;
break;
case GL_FRAMEBUFFER_DEFAULT_LAYERS:
+ /*
+ * According to the OpenGL ES 3.1 specification section 9.2.1, the
+ * GL_FRAMEBUFFER_DEFAULT_LAYERS parameter name is not supported.
+ */
+ if (_mesa_is_gles31(ctx) && !ctx->Extensions.OES_geometry_shader) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=0x%x)", func, pname);
+ break;
+ }
if (param < 0 || param > ctx->Const.MaxFramebufferLayers)
- _mesa_error(ctx, GL_INVALID_VALUE, "%s", func);
+ _mesa_error(ctx, GL_INVALID_VALUE, "%s", func);
else
fb->DefaultGeometry.Layers = param;
break;
_mesa_error(ctx, GL_INVALID_ENUM,
"%s(pname=0x%x)", func, pname);
}
+
+ invalidate_framebuffer(fb);
+ ctx->NewState |= _NEW_BUFFERS;
}
void GLAPIENTRY
*params = fb->DefaultGeometry.Height;
break;
case GL_FRAMEBUFFER_DEFAULT_LAYERS:
+ /*
+ * According to the OpenGL ES 3.1 specification section 9.2.3, the
+ * GL_FRAMEBUFFER_LAYERS parameter name is not supported.
+ */
+ if (_mesa_is_gles31(ctx) && !ctx->Extensions.OES_geometry_shader) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=0x%x)", func, pname);
+ break;
+ }
*params = fb->DefaultGeometry.Layers;
break;
case GL_FRAMEBUFFER_DEFAULT_SAMPLES:
if (!renderbuffers)
return;
+ _mesa_HashLockMutex(ctx->Shared->RenderBuffers);
+
first = _mesa_HashFindFreeKeyBlock(ctx->Shared->RenderBuffers, n);
for (i = 0; i < n; i++) {
renderbuffers[i] = name;
if (dsa) {
- allocate_renderbuffer(ctx, name, func);
+ allocate_renderbuffer_locked(ctx, name, func);
} else {
/* insert a dummy renderbuffer into the hash table */
- mtx_lock(&ctx->Shared->Mutex);
- _mesa_HashInsert(ctx->Shared->RenderBuffers, name, &DummyRenderbuffer);
- mtx_unlock(&ctx->Shared->Mutex);
+ _mesa_HashInsertLocked(ctx->Shared->RenderBuffers, name,
+ &DummyRenderbuffer);
}
}
+
+ _mesa_HashUnlockMutex(ctx->Shared->RenderBuffers);
}
/** sentinal value, see below */
#define NO_SAMPLES 1000
+void
+_mesa_renderbuffer_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
+ GLenum internalFormat, GLsizei width,
+ GLsizei height, GLsizei samples)
+{
+ const GLenum baseFormat = _mesa_base_fbo_format(ctx, internalFormat);
+
+ assert(baseFormat != 0);
+ assert(width >= 0 && width <= (GLsizei) ctx->Const.MaxRenderbufferSize);
+ assert(height >= 0 && height <= (GLsizei) ctx->Const.MaxRenderbufferSize);
+ assert(samples != NO_SAMPLES);
+ if (samples != 0) {
+ assert(samples > 0);
+ assert(_mesa_check_sample_count(ctx, GL_RENDERBUFFER,
+ internalFormat, samples) == GL_NO_ERROR);
+ }
+
+ FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+
+ if (rb->InternalFormat == internalFormat &&
+ rb->Width == (GLuint) width &&
+ rb->Height == (GLuint) height &&
+ rb->NumSamples == samples) {
+ /* no change in allocation needed */
+ return;
+ }
+
+ /* These MUST get set by the AllocStorage func */
+ rb->Format = MESA_FORMAT_NONE;
+ rb->NumSamples = samples;
+
+ /* Now allocate the storage */
+ assert(rb->AllocStorage);
+ if (rb->AllocStorage(ctx, rb, internalFormat, width, height)) {
+ /* No error - check/set fields now */
+ /* If rb->Format == MESA_FORMAT_NONE, the format is unsupported. */
+ assert(rb->Width == (GLuint) width);
+ assert(rb->Height == (GLuint) height);
+ rb->InternalFormat = internalFormat;
+ rb->_BaseFormat = baseFormat;
+ assert(rb->_BaseFormat != 0);
+ }
+ else {
+ /* Probably ran out of memory - clear the fields */
+ rb->Width = 0;
+ rb->Height = 0;
+ rb->Format = MESA_FORMAT_NONE;
+ rb->InternalFormat = GL_NONE;
+ rb->_BaseFormat = GL_NONE;
+ rb->NumSamples = 0;
+ }
+
+ /* Invalidate the framebuffers the renderbuffer is attached in. */
+ if (rb->AttachedAnytime) {
+ _mesa_HashWalk(ctx->Shared->FrameBuffers, invalidate_rb, rb);
+ }
+}
/**
* Helper function used by renderbuffer_storage_direct() and
*/
sample_count_error = _mesa_check_sample_count(ctx, GL_RENDERBUFFER,
internalFormat, samples);
+
+ /* Section 2.5 (GL Errors) of OpenGL 3.0 specification, page 16:
+ *
+ * "If a negative number is provided where an argument of type sizei or
+ * sizeiptr is specified, the error INVALID VALUE is generated."
+ */
+ if (samples < 0) {
+ sample_count_error = GL_INVALID_VALUE;
+ }
+
if (sample_count_error != GL_NO_ERROR) {
- _mesa_error(ctx, sample_count_error, "%s(samples)", func);
+ _mesa_error(ctx, sample_count_error, "%s(samples=%d)", func, samples);
return;
}
}
- FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
- if (rb->InternalFormat == internalFormat &&
- rb->Width == (GLuint) width &&
- rb->Height == (GLuint) height &&
- rb->NumSamples == samples) {
- /* no change in allocation needed */
- return;
- }
-
- /* These MUST get set by the AllocStorage func */
- rb->Format = MESA_FORMAT_NONE;
- rb->NumSamples = samples;
-
- /* Now allocate the storage */
- assert(rb->AllocStorage);
- if (rb->AllocStorage(ctx, rb, internalFormat, width, height)) {
- /* No error - check/set fields now */
- /* If rb->Format == MESA_FORMAT_NONE, the format is unsupported. */
- assert(rb->Width == (GLuint) width);
- assert(rb->Height == (GLuint) height);
- rb->InternalFormat = internalFormat;
- rb->_BaseFormat = baseFormat;
- assert(rb->_BaseFormat != 0);
- }
- else {
- /* Probably ran out of memory - clear the fields */
- rb->Width = 0;
- rb->Height = 0;
- rb->Format = MESA_FORMAT_NONE;
- rb->InternalFormat = GL_NONE;
- rb->_BaseFormat = GL_NONE;
- rb->NumSamples = 0;
- }
-
- /* Invalidate the framebuffers the renderbuffer is attached in. */
- if (rb->AttachedAnytime) {
- _mesa_HashWalk(ctx->Shared->FrameBuffers, invalidate_rb, rb);
- }
+ _mesa_renderbuffer_storage(ctx, rb, internalFormat, width, height, samples);
}
/**
bind_framebuffer(GLenum target, GLuint framebuffer, bool allow_user_names)
{
struct gl_framebuffer *newDrawFb, *newReadFb;
- struct gl_framebuffer *oldDrawFb, *oldReadFb;
GLboolean bindReadBuf, bindDrawBuf;
GET_CURRENT_CONTEXT(ctx);
newReadFb = ctx->WinSysReadBuffer;
}
- assert(newDrawFb);
- assert(newDrawFb != &DummyFramebuffer);
+ _mesa_bind_framebuffers(ctx,
+ bindDrawBuf ? newDrawFb : ctx->DrawBuffer,
+ bindReadBuf ? newReadFb : ctx->ReadBuffer);
+}
- /* save pointers to current/old framebuffers */
- oldDrawFb = ctx->DrawBuffer;
- oldReadFb = ctx->ReadBuffer;
+void
+_mesa_bind_framebuffers(struct gl_context *ctx,
+ struct gl_framebuffer *newDrawFb,
+ struct gl_framebuffer *newReadFb)
+{
+ struct gl_framebuffer *const oldDrawFb = ctx->DrawBuffer;
+ struct gl_framebuffer *const oldReadFb = ctx->ReadBuffer;
+ const bool bindDrawBuf = oldDrawFb != newDrawFb;
+ const bool bindReadBuf = oldReadFb != newReadFb;
- /* check if really changing bindings */
- if (oldDrawFb == newDrawFb)
- bindDrawBuf = GL_FALSE;
- if (oldReadFb == newReadFb)
- bindReadBuf = GL_FALSE;
+ assert(newDrawFb);
+ assert(newDrawFb != &DummyFramebuffer);
/*
* OK, now bind the new Draw/Read framebuffers, if they're changing.
}
if ((bindDrawBuf || bindReadBuf) && ctx->Driver.BindFramebuffer) {
- ctx->Driver.BindFramebuffer(ctx, target, newDrawFb, newReadFb);
+ /* The few classic drivers that actually hook this function really only
+ * want to know if the draw framebuffer changed.
+ */
+ ctx->Driver.BindFramebuffer(ctx,
+ bindDrawBuf ? GL_FRAMEBUFFER : GL_READ_FRAMEBUFFER,
+ newDrawFb, newReadFb);
}
}
if (!framebuffers)
return;
+ _mesa_HashLockMutex(ctx->Shared->FrameBuffers);
+
first = _mesa_HashFindFreeKeyBlock(ctx->Shared->FrameBuffers, n);
for (i = 0; i < n; i++) {
if (dsa) {
fb = ctx->Driver.NewFramebuffer(ctx, framebuffers[i]);
if (!fb) {
+ _mesa_HashUnlockMutex(ctx->Shared->FrameBuffers);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
return;
}
else
fb = &DummyFramebuffer;
- mtx_lock(&ctx->Shared->Mutex);
- _mesa_HashInsert(ctx->Shared->FrameBuffers, name, fb);
- mtx_unlock(&ctx->Shared->Mutex);
+ _mesa_HashInsertLocked(ctx->Shared->FrameBuffers, name, fb);
}
+
+ _mesa_HashUnlockMutex(ctx->Shared->FrameBuffers);
}
dst_att->Type = src_att->Type;
dst_att->Complete = src_att->Complete;
dst_att->TextureLevel = src_att->TextureLevel;
+ dst_att->CubeMapFace = src_att->CubeMapFace;
dst_att->Zoffset = src_att->Zoffset;
+ dst_att->Layered = src_att->Layered;
}
{
bool err = false;
- switch (dims) {
- case 1:
- switch (textarget) {
- case GL_TEXTURE_1D:
- break;
- case GL_TEXTURE_1D_ARRAY:
- err = !ctx->Extensions.EXT_texture_array;
- break;
- default:
- err = true;
- }
+ switch (textarget) {
+ case GL_TEXTURE_1D:
+ err = dims != 1;
break;
- case 2:
- switch (textarget) {
- case GL_TEXTURE_2D:
- break;
- case GL_TEXTURE_RECTANGLE:
- err = _mesa_is_gles(ctx)
- || !ctx->Extensions.NV_texture_rectangle;
- break;
- case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
- case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
- case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
- case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
- err = !ctx->Extensions.ARB_texture_cube_map;
- break;
- case GL_TEXTURE_2D_ARRAY:
- err = (_mesa_is_gles(ctx) && ctx->Version < 30)
- || !ctx->Extensions.EXT_texture_array;
- break;
- case GL_TEXTURE_2D_MULTISAMPLE:
- case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
- err = (_mesa_is_gles(ctx) ||
- !ctx->Extensions.ARB_texture_multisample) &&
- !_mesa_is_gles31(ctx);
- break;
- default:
- err = true;
- }
+ case GL_TEXTURE_1D_ARRAY:
+ err = dims != 1 || !ctx->Extensions.EXT_texture_array;
break;
- case 3:
- if (textarget != GL_TEXTURE_3D)
- err = true;
+ case GL_TEXTURE_2D:
+ err = dims != 2;
break;
- default:
+ case GL_TEXTURE_2D_ARRAY:
+ err = dims != 2 || !ctx->Extensions.EXT_texture_array ||
+ (_mesa_is_gles(ctx) && ctx->Version < 30);
+ break;
+ case GL_TEXTURE_2D_MULTISAMPLE:
+ case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
+ err = dims != 2 ||
+ !ctx->Extensions.ARB_texture_multisample ||
+ (_mesa_is_gles(ctx) && ctx->Version < 31);
+ break;
+ case GL_TEXTURE_RECTANGLE:
+ err = dims != 2 || _mesa_is_gles(ctx) ||
+ !ctx->Extensions.NV_texture_rectangle;
+ break;
+ case GL_TEXTURE_CUBE_MAP:
+ case GL_TEXTURE_CUBE_MAP_ARRAY:
err = true;
+ break;
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+ case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+ case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+ err = dims != 2 || !ctx->Extensions.ARB_texture_cube_map;
+ break;
+ case GL_TEXTURE_3D:
+ err = dims != 3;
+ break;
+ default:
+ _mesa_error(ctx, GL_INVALID_ENUM,
+ "%s(unknown textarget 0x%x)", caller, textarget);
+ return false;
}
if (err) {
}
/* Not a hash lookup, so we can afford to get the attachment here. */
- att = get_attachment(ctx, fb, attachment);
+ att = get_attachment(ctx, fb, attachment, NULL);
if (att == NULL) {
_mesa_error(ctx, GL_INVALID_ENUM, "%s(invalid attachment %s)", caller,
_mesa_enum_to_string(attachment));
if ((dims == 3) && !check_layer(ctx, texObj->Target, layer, caller))
return;
- }
- if (!check_level(ctx, textarget, level, caller))
- return;
+ if (!check_level(ctx, textarget, level, caller))
+ return;
+ }
_mesa_framebuffer_texture(ctx, fb, attachment, texObj, textarget, level,
layer, GL_FALSE, caller);
_mesa_framebuffer_renderbuffer(struct gl_context *ctx,
struct gl_framebuffer *fb,
GLenum attachment,
- struct gl_renderbuffer *rb,
- const char *func)
+ struct gl_renderbuffer *rb)
+{
+ assert(!_mesa_is_winsys_fbo(fb));
+
+ FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+
+ assert(ctx->Driver.FramebufferRenderbuffer);
+ ctx->Driver.FramebufferRenderbuffer(ctx, fb, attachment, rb);
+
+ /* Some subsequent GL commands may depend on the framebuffer's visual
+ * after the binding is updated. Update visual info now.
+ */
+ _mesa_update_framebuffer_visual(ctx, fb);
+}
+
+static void
+framebuffer_renderbuffer(struct gl_context *ctx,
+ struct gl_framebuffer *fb,
+ GLenum attachment,
+ struct gl_renderbuffer *rb,
+ const char *func)
{
struct gl_renderbuffer_attachment *att;
return;
}
- att = get_attachment(ctx, fb, attachment);
+ att = get_attachment(ctx, fb, attachment, NULL);
if (att == NULL) {
_mesa_error(ctx, GL_INVALID_ENUM,
"%s(invalid attachment %s)", func,
}
}
- FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
- assert(ctx->Driver.FramebufferRenderbuffer);
- ctx->Driver.FramebufferRenderbuffer(ctx, fb, attachment, rb);
-
- /* Some subsequent GL commands may depend on the framebuffer's visual
- * after the binding is updated. Update visual info now.
- */
- _mesa_update_framebuffer_visual(ctx, fb);
+ _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
}
-
void GLAPIENTRY
_mesa_FramebufferRenderbuffer(GLenum target, GLenum attachment,
GLenum renderbuffertarget,
rb = NULL;
}
- _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb,
- "glFramebufferRenderbuffer");
+ framebuffer_renderbuffer(ctx, fb, attachment, rb,
+ "glFramebufferRenderbuffer");
}
rb = NULL;
}
- _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb,
- "glNamedFramebufferRenderbuffer");
+ framebuffer_renderbuffer(ctx, fb, attachment, rb,
+ "glNamedFramebufferRenderbuffer");
}
const struct gl_renderbuffer_attachment *att;
GLenum err;
- /* The error differs in GL and GLES. */
- err = _mesa_is_desktop_gl(ctx) ? GL_INVALID_OPERATION : GL_INVALID_ENUM;
+ /* The error code for an attachment type of GL_NONE differs between APIs.
+ *
+ * From the ES 2.0.25 specification, page 127:
+ * "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, then
+ * querying any other pname will generate INVALID_ENUM."
+ *
+ * From the OpenGL 3.0 specification, page 337, or identically,
+ * the OpenGL ES 3.0.4 specification, page 240:
+ *
+ * "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, no
+ * framebuffer is bound to target. In this case querying pname
+ * FRAMEBUFFER_ATTACHMENT_OBJECT_NAME will return zero, and all other
+ * queries will generate an INVALID_OPERATION error."
+ */
+ err = ctx->API == API_OPENGLES2 && ctx->Version < 30 ?
+ GL_INVALID_ENUM : GL_INVALID_OPERATION;
if (_mesa_is_winsys_fbo(buffer)) {
/* Page 126 (page 136 of the PDF) of the OpenGL ES 2.0.25 spec
_mesa_enum_to_string(attachment));
return;
}
+
+ /* The specs are not clear about how to handle
+ * GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME with the default framebuffer,
+ * but dEQP-GLES3 expects an INVALID_ENUM error. This has also been
+ * discussed in:
+ *
+ * https://cvs.khronos.org/bugzilla/show_bug.cgi?id=12928#c1
+ * and https://bugs.freedesktop.org/show_bug.cgi?id=31947
+ */
+ if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
+ _mesa_error(ctx, GL_INVALID_ENUM,
+ "%s(requesting GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME "
+ "when GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is "
+ "GL_FRAMEBUFFER_DEFAULT is not allowed)", caller);
+ return;
+ }
+
/* the default / window-system FBO */
att = _mesa_get_fb0_attachment(ctx, buffer, attachment);
}
else {
/* user-created framebuffer FBO */
- att = get_attachment(ctx, buffer, attachment);
+ att = get_attachment(ctx, buffer, attachment, NULL);
}
if (att == NULL) {
return;
}
/* the depth and stencil attachments must point to the same buffer */
- depthAtt = get_attachment(ctx, buffer, GL_DEPTH_ATTACHMENT);
- stencilAtt = get_attachment(ctx, buffer, GL_STENCIL_ATTACHMENT);
+ depthAtt = get_attachment(ctx, buffer, GL_DEPTH_ATTACHMENT, NULL);
+ stencilAtt = get_attachment(ctx, buffer, GL_STENCIL_ATTACHMENT, NULL);
if (depthAtt->Renderbuffer != stencilAtt->Renderbuffer) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(DEPTH/STENCIL attachments differ)", caller);
switch (pname) {
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT:
- *params = _mesa_is_winsys_fbo(buffer)
+ /* From the OpenGL spec, 9.2. Binding and Managing Framebuffer Objects:
+ *
+ * "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, then
+ * either no framebuffer is bound to target; or the default framebuffer
+ * is bound, attachment is DEPTH or STENCIL, and the number of depth or
+ * stencil bits, respectively, is zero."
+ */
+ *params = (_mesa_is_winsys_fbo(buffer) &&
+ ((attachment != GL_DEPTH && attachment != GL_STENCIL) ||
+ (att->Type != GL_NONE)))
? GL_FRAMEBUFFER_DEFAULT : att->Type;
return;
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT:
goto invalid_pname_enum;
}
else if (att->Type == GL_NONE) {
- _mesa_error(ctx, err, "%s(invalid pname %s)", caller,
- _mesa_enum_to_string(pname));
+ if (_mesa_is_winsys_fbo(buffer) &&
+ (attachment == GL_DEPTH || attachment == GL_STENCIL)) {
+ *params = GL_LINEAR;
+ } else {
+ _mesa_error(ctx, err, "%s(invalid pname %s)", caller,
+ _mesa_enum_to_string(pname));
+ }
}
else {
if (ctx->Extensions.EXT_framebuffer_sRGB) {
*/
invalidate_framebuffer_storage(ctx, fb, numAttachments, attachments,
0, 0,
- MAX_VIEWPORT_WIDTH, MAX_VIEWPORT_HEIGHT,
+ ctx->Const.MaxViewportWidth,
+ ctx->Const.MaxViewportHeight,
"glInvalidateFramebuffer");
}
*/
invalidate_framebuffer_storage(ctx, fb, numAttachments, attachments,
0, 0,
- MAX_VIEWPORT_WIDTH, MAX_VIEWPORT_HEIGHT,
+ ctx->Const.MaxViewportWidth,
+ ctx->Const.MaxViewportHeight,
"glInvalidateNamedFramebufferData");
}