/**
* Called via glBegin.
*/
static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
{
GET_CURRENT_CONTEXT( ctx );
struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
int i;
if (_mesa_inside_begin_end(ctx)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glBegin");
return;
}
if (!_mesa_valid_prim_mode(ctx, mode, "glBegin")) {
return;
}
vbo_draw_method(vbo_context(ctx), DRAW_BEGIN_END);
if (ctx->NewState) {
_mesa_update_state( ctx );
CALL_Begin(ctx->Exec, (mode));
return;
}
if (!_mesa_valid_to_render(ctx, "glBegin")) {
return;
}
/* Heuristic: attempt to isolate attributes occurring outside
* begin/end pairs.
*/
if (exec->vtx.vertex_size && !exec->vtx.attrsz[0])
vbo_exec_FlushVertices_internal(exec, GL_FALSE);
i = exec->vtx.prim_count++;
exec->vtx.prim[i].mode = mode;
exec->vtx.prim[i].begin = 1;
exec->vtx.prim[i].end = 0;
exec->vtx.prim[i].indexed = 0;
exec->vtx.prim[i].weak = 0;
exec->vtx.prim[i].pad = 0;
exec->vtx.prim[i].start = exec->vtx.vert_count;
exec->vtx.prim[i].count = 0;
exec->vtx.prim[i].num_instances = 1;
exec->vtx.prim[i].base_instance = 0;
exec->vtx.prim[i].is_indirect = 0;
ctx->Driver.CurrentExecPrimitive = mode;
ctx->Exec = ctx->BeginEnd;
/* We may have been called from a display list, in which case we should
* leave dlist.c's dispatch table in place.
*/
if (ctx->CurrentDispatch == ctx->OutsideBeginEnd) {
ctx->CurrentDispatch = ctx->BeginEnd;
_glapi_set_dispatch(ctx->CurrentDispatch);
} else {
assert(ctx->CurrentDispatch == ctx->Save);
}
}
/**
* Check if OK to draw arrays/elements.
*/
static GLboolean
check_valid_to_render(struct gl_context *ctx, const char *function)
{
if (!_mesa_valid_to_render(ctx, function)) {
return GL_FALSE;
}
switch (ctx->API) {
#if FEATURE_es2_glsl
case API_OPENGLES2:
/* For ES2, we can draw if any vertex array is enabled (and we
* should always have a vertex program/shader). */
if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current)
return GL_FALSE;
break;
#endif
#if FEATURE_ES1
case API_OPENGLES:
/* For OpenGL ES, only draw if we have vertex positions
*/
if (!ctx->Array.ArrayObj->Vertex.Enabled)
return GL_FALSE;
break;
#endif
#if FEATURE_GL
case API_OPENGL:
{
const struct gl_shader_program *vsProg =
ctx->Shader.CurrentVertexProgram;
GLboolean haveVertexShader = (vsProg && vsProg->LinkStatus);
GLboolean haveVertexProgram = ctx->VertexProgram._Enabled;
if (haveVertexShader || haveVertexProgram) {
/* Draw regardless of whether or not we have any vertex arrays.
* (Ex: could draw a point using a constant vertex pos)
*/
return GL_TRUE;
}
else {
/* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
* array [0]).
*/
return (ctx->Array.ArrayObj->Vertex.Enabled ||
ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
}
}
break;
#endif
default:
ASSERT_NO_FEATURE();
}
return GL_TRUE;
}
/**
* Called via glBegin.
*/
static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
{
GET_CURRENT_CONTEXT( ctx );
if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END) {
struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
int i;
if (!_mesa_valid_prim_mode(ctx, mode, "glBegin")) {
return;
}
vbo_draw_method(vbo_context(ctx), DRAW_BEGIN_END);
if (ctx->Driver.PrepareExecBegin)
ctx->Driver.PrepareExecBegin(ctx);
if (ctx->NewState) {
_mesa_update_state( ctx );
CALL_Begin(ctx->Exec, (mode));
return;
}
if (!_mesa_valid_to_render(ctx, "glBegin")) {
return;
}
/* Heuristic: attempt to isolate attributes occuring outside
* begin/end pairs.
*/
if (exec->vtx.vertex_size && !exec->vtx.attrsz[0])
vbo_exec_FlushVertices_internal(exec, GL_FALSE);
i = exec->vtx.prim_count++;
exec->vtx.prim[i].mode = mode;
exec->vtx.prim[i].begin = 1;
exec->vtx.prim[i].end = 0;
exec->vtx.prim[i].indexed = 0;
exec->vtx.prim[i].weak = 0;
exec->vtx.prim[i].pad = 0;
exec->vtx.prim[i].start = exec->vtx.vert_count;
exec->vtx.prim[i].count = 0;
exec->vtx.prim[i].num_instances = 1;
exec->vtx.prim[i].base_instance = 0;
ctx->Driver.CurrentExecPrimitive = mode;
}
else
_mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
}
/**
* Check if OK to draw arrays/elements.
*/
static GLboolean
check_valid_to_render(GLcontext *ctx, const char *function)
{
if (!_mesa_valid_to_render(ctx, function)) {
return GL_FALSE;
}
#if FEATURE_es2_glsl
/* For ES2, we can draw if any vertex array is enabled (and we should
* always have a vertex program/shader).
*/
if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current)
return GL_FALSE;
#else
/* For regular OpenGL, only draw if we have vertex positions (regardless
* of whether or not we have a vertex program/shader).
*/
if (!ctx->Array.ArrayObj->Vertex.Enabled &&
!ctx->Array.ArrayObj->VertexAttrib[0].Enabled)
return GL_FALSE;
#endif
return GL_TRUE;
}
/**
* Check if OK to draw arrays/elements.
*/
static bool
check_valid_to_render(struct gl_context *ctx, const char *function)
{
if (!_mesa_valid_to_render(ctx, function)) {
return false;
}
switch (ctx->API) {
case API_OPENGLES2:
/* For ES2, we can draw if we have a vertex program/shader). */
return ctx->VertexProgram._Current != NULL;
case API_OPENGLES:
/* For OpenGL ES, only draw if we have vertex positions
*/
if (!ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled)
return false;
break;
case API_OPENGL_CORE:
/* Section 10.4 (Drawing Commands Using Vertex Arrays) of the OpenGL 4.5
* Core Profile spec says:
*
* "An INVALID_OPERATION error is generated if no vertex array
* object is bound (see section 10.3.1)."
*/
if (ctx->Array.VAO == ctx->Array.DefaultVAO) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(no VAO bound)", function);
return false;
}
/* The spec argues that this is allowed because a tess ctrl shader
* without a tess eval shader can be used with transform feedback.
* However, glBeginTransformFeedback doesn't allow GL_PATCHES and
* therefore doesn't allow tessellation.
*
* Further investigation showed that this is indeed a spec bug and
* a tess ctrl shader without a tess eval shader shouldn't have been
* allowed, because there is no API in GL 4.0 that can make use this
* to produce something useful.
*
* Also, all vendors except one don't support a tess ctrl shader without
* a tess eval shader anyway.
*/
if (ctx->TessCtrlProgram._Current && !ctx->TessEvalProgram._Current) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(tess eval shader is missing)", function);
return false;
}
/* Section 7.3 (Program Objects) of the OpenGL 4.5 Core Profile spec
* says:
*
* "If there is no active program for the vertex or fragment shader
* stages, the results of vertex and/or fragment processing will be
* undefined. However, this is not an error."
*
* The fragment shader is not tested here because other state (e.g.,
* GL_RASTERIZER_DISCARD) affects whether or not we actually care.
*/
return ctx->VertexProgram._Current != NULL;
case API_OPENGL_COMPAT:
if (ctx->VertexProgram._Current != NULL) {
/* Draw regardless of whether or not we have any vertex arrays.
* (Ex: could draw a point using a constant vertex pos)
*/
return true;
} else {
/* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
* array [0]).
*/
return (ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled ||
ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled);
}
break;
default:
unreachable("Invalid API value in check_valid_to_render()");
}
return true;
}
/*
* Execute glDrawPixels
*/
static void GLAPIENTRY
_mesa_DrawPixels( GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *pixels )
{
GLenum err;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glDrawPixels(%d, %d, %s, %s, %p) // to %s at %d, %d\n",
width, height,
_mesa_lookup_enum_by_nr(format),
_mesa_lookup_enum_by_nr(type),
pixels,
_mesa_lookup_enum_by_nr(ctx->DrawBuffer->ColorDrawBuffer[0]),
IROUND(ctx->Current.RasterPos[0]),
IROUND(ctx->Current.RasterPos[1]));
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0)" );
return;
}
/* We're not using the current vertex program, and the driver may install
* its own. Note: this may dirty some state.
*/
_mesa_set_vp_override(ctx, GL_TRUE);
/* Note: this call does state validation */
if (!_mesa_valid_to_render(ctx, "glDrawPixels")) {
goto end; /* the error code was recorded */
}
/* GL 3.0 introduced a new restriction on glDrawPixels() over what was in
* GL_EXT_texture_integer. From section 3.7.4 ("Rasterization of Pixel
* Rectangles) on page 151 of the GL 3.0 specification:
*
* "If format contains integer components, as shown in table 3.6, an
* INVALID OPERATION error is generated."
*
* Since DrawPixels rendering would be merely undefined if not an error (due
* to a lack of defined mapping from integer data to gl_Color fragment shader
* input), NVIDIA's implementation also just returns this error despite
* exposing GL_EXT_texture_integer, just return an error regardless.
*/
if (_mesa_is_enum_format_integer(format)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glDrawPixels(integer format)");
goto end;
}
err = _mesa_error_check_format_and_type(ctx, format, type);
if (err != GL_NO_ERROR) {
_mesa_error(ctx, err, "glDrawPixels(invalid format %s and/or type %s)",
_mesa_lookup_enum_by_nr(format),
_mesa_lookup_enum_by_nr(type));
goto end;
}
/* do special format-related checks */
switch (format) {
case GL_STENCIL_INDEX:
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_EXT:
/* these buffers must exist */
if (!_mesa_dest_buffer_exists(ctx, format)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawPixels(missing deest buffer)");
goto end;
}
break;
case GL_COLOR_INDEX:
if (ctx->PixelMaps.ItoR.Size == 0 ||
ctx->PixelMaps.ItoG.Size == 0 ||
ctx->PixelMaps.ItoB.Size == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawPixels(drawing color index pixels into RGB buffer)");
goto end;
}
break;
default:
/* for color formats it's not an error if the destination color
* buffer doesn't exist.
*/
break;
}
if (ctx->RasterDiscard) {
goto end;
}
if (!ctx->Current.RasterPosValid) {
goto end; /* no-op, not an error */
}
if (ctx->RenderMode == GL_RENDER) {
if (width > 0 && height > 0) {
/* Round, to satisfy conformance tests (matches SGI's OpenGL) */
GLint x = IROUND(ctx->Current.RasterPos[0]);
GLint y = IROUND(ctx->Current.RasterPos[1]);
if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
/* unpack from PBO */
if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height,
1, format, type, INT_MAX, pixels)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawPixels(invalid PBO access)");
goto end;
}
if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {
/* buffer is mapped - that's an error */
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawPixels(PBO is mapped)");
goto end;
}
}
ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
&ctx->Unpack, pixels);
}
}
else if (ctx->RenderMode == GL_FEEDBACK) {
/* Feedback the current raster pos info */
FLUSH_CURRENT( ctx, 0 );
_mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterTexCoords[0] );
}
else {
ASSERT(ctx->RenderMode == GL_SELECT);
/* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */
}
end:
_mesa_set_vp_override(ctx, GL_FALSE);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
}
}
static void GLAPIENTRY
_mesa_Bitmap( GLsizei width, GLsizei height,
GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
const GLubyte *bitmap )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );
return;
}
if (!ctx->Current.RasterPosValid) {
return; /* do nothing */
}
/* Note: this call does state validation */
if (!_mesa_valid_to_render(ctx, "glBitmap")) {
/* the error code was recorded */
return;
}
if (ctx->RasterDiscard)
return;
if (ctx->RenderMode == GL_RENDER) {
/* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
if (width > 0 && height > 0) {
const GLfloat epsilon = 0.0001F;
GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig);
GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig);
if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
/* unpack from PBO */
if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height,
1, GL_COLOR_INDEX, GL_BITMAP,
INT_MAX, (const GLvoid *) bitmap)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBitmap(invalid PBO access)");
return;
}
if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {
/* buffer is mapped - that's an error */
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBitmap(PBO is mapped)");
return;
}
}
ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
}
}
#if _HAVE_FULL_GL
else if (ctx->RenderMode == GL_FEEDBACK) {
FLUSH_CURRENT(ctx, 0);
_mesa_feedback_token( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterTexCoords[0] );
}
else {
ASSERT(ctx->RenderMode == GL_SELECT);
/* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */
}
#endif
/* update raster position */
ctx->Current.RasterPos[0] += xmove;
ctx->Current.RasterPos[1] += ymove;
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
}
}
static void GLAPIENTRY
_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
GLenum type )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx,
"glCopyPixels(%d, %d, %d, %d, %s) // from %s to %s at %d, %d\n",
srcx, srcy, width, height,
_mesa_lookup_enum_by_nr(type),
_mesa_lookup_enum_by_nr(ctx->ReadBuffer->ColorReadBuffer),
_mesa_lookup_enum_by_nr(ctx->DrawBuffer->ColorDrawBuffer[0]),
IROUND(ctx->Current.RasterPos[0]),
IROUND(ctx->Current.RasterPos[1]));
if (width < 0 || height < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)");
return;
}
/* Note: more detailed 'type' checking is done by the
* _mesa_source/dest_buffer_exists() calls below. That's where we
* check if the stencil buffer exists, etc.
*/
if (type != GL_COLOR &&
type != GL_DEPTH &&
type != GL_STENCIL &&
type != GL_DEPTH_STENCIL) {
_mesa_error(ctx, GL_INVALID_ENUM, "glCopyPixels(type=%s)",
_mesa_lookup_enum_by_nr(type));
return;
}
/* We're not using the current vertex program, and the driver may install
* it's own. Note: this may dirty some state.
*/
_mesa_set_vp_override(ctx, GL_TRUE);
/* Note: this call does state validation */
if (!_mesa_valid_to_render(ctx, "glCopyPixels")) {
goto end; /* the error code was recorded */
}
/* Check read buffer's status (draw buffer was already checked) */
if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"glCopyPixels(incomplete framebuffer)" );
goto end;
}
if (_mesa_is_user_fbo(ctx->ReadBuffer) &&
ctx->ReadBuffer->Visual.samples > 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glCopyPixels(multisample FBO)");
goto end;
}
if (!_mesa_source_buffer_exists(ctx, type) ||
!_mesa_dest_buffer_exists(ctx, type)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glCopyPixels(missing source or dest buffer)");
goto end;
}
if (ctx->RasterDiscard) {
goto end;
}
if (!ctx->Current.RasterPosValid || width == 0 || height == 0) {
goto end; /* no-op, not an error */
}
if (ctx->RenderMode == GL_RENDER) {
/* Round to satisfy conformance tests (matches SGI's OpenGL) */
if (width > 0 && height > 0) {
GLint destx = IROUND(ctx->Current.RasterPos[0]);
GLint desty = IROUND(ctx->Current.RasterPos[1]);
ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
type );
}
}
else if (ctx->RenderMode == GL_FEEDBACK) {
FLUSH_CURRENT( ctx, 0 );
_mesa_feedback_token( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterTexCoords[0] );
}
else {
ASSERT(ctx->RenderMode == GL_SELECT);
/* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */
}
end:
_mesa_set_vp_override(ctx, GL_FALSE);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
}
}
