#include <stdbool.h>
#include "glheader.h"
#include "api_validate.h"
+#include "arrayobj.h"
#include "bufferobj.h"
#include "context.h"
#include "imports.h"
#include "mtypes.h"
+#include "pipelineobj.h"
#include "enums.h"
-#include "vbo/vbo.h"
+#include "state.h"
#include "transformfeedback.h"
-#include <stdbool.h>
+#include "uniforms.h"
+#include "vbo/vbo.h"
+#include "program/prog_print.h"
+
+
+static bool
+check_blend_func_error(struct gl_context *ctx)
+{
+ /* The ARB_blend_func_extended spec's ERRORS section says:
+ *
+ * "The error INVALID_OPERATION is generated by Begin or any procedure
+ * that implicitly calls Begin if any draw buffer has a blend function
+ * requiring the second color input (SRC1_COLOR, ONE_MINUS_SRC1_COLOR,
+ * SRC1_ALPHA or ONE_MINUS_SRC1_ALPHA), and a framebuffer is bound that
+ * has more than the value of MAX_DUAL_SOURCE_DRAW_BUFFERS-1 active
+ * color attachements."
+ */
+ for (unsigned i = ctx->Const.MaxDualSourceDrawBuffers;
+ i < ctx->DrawBuffer->_NumColorDrawBuffers;
+ i++) {
+ if (ctx->Color.Blend[i]._UsesDualSrc) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "dual source blend on illegal attachment");
+ return false;
+ }
+ }
+
+ if (ctx->Color.BlendEnabled && ctx->Color._AdvancedBlendMode) {
+ /* The KHR_blend_equation_advanced spec says:
+ *
+ * "If any non-NONE draw buffer uses a blend equation found in table
+ * X.1 or X.2, the error INVALID_OPERATION is generated by Begin or
+ * any operation that implicitly calls Begin (such as DrawElements)
+ * if:
+ *
+ * * the draw buffer for color output zero selects multiple color
+ * buffers (e.g., FRONT_AND_BACK in the default framebuffer); or
+ *
+ * * the draw buffer for any other color output is not NONE."
+ */
+ if (ctx->DrawBuffer->ColorDrawBuffer[0] == GL_FRONT_AND_BACK) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "advanced blending is active and draw buffer for color "
+ "output zero selects multiple color buffers");
+ return false;
+ }
+
+ for (unsigned i = 1; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {
+ if (ctx->DrawBuffer->ColorDrawBuffer[i] != GL_NONE) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "advanced blending is active with multiple color "
+ "draw buffers");
+ return false;
+ }
+ }
+
+ /* The KHR_blend_equation_advanced spec says:
+ *
+ * "Advanced blending equations require the use of a fragment shader
+ * with a matching "blend_support" layout qualifier. If the current
+ * blend equation is found in table X.1 or X.2, and the active
+ * fragment shader does not include the layout qualifier matching
+ * the blend equation or "blend_support_all_equations", the error
+ * INVALID_OPERATION is generated [...]"
+ */
+ const struct gl_program *prog = ctx->_Shader->_CurrentFragmentProgram;
+ const GLbitfield blend_support = !prog ? 0 : prog->sh.fs.BlendSupport;
+
+ if ((blend_support & ctx->Color._AdvancedBlendMode) == 0) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "fragment shader does not allow advanced blending mode "
+ "(%s)",
+ _mesa_enum_to_string(ctx->Color.Blend[0].EquationRGB));
+ }
+ }
+
+ return true;
+}
+
+
+/**
+ * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
+ * is called to see if it's valid to render. This involves checking that
+ * the current shader is valid and the framebuffer is complete.
+ * It also check the current pipeline object is valid if any.
+ * If an error is detected it'll be recorded here.
+ * \return GL_TRUE if OK to render, GL_FALSE if not
+ */
+GLboolean
+_mesa_valid_to_render(struct gl_context *ctx, const char *where)
+{
+ /* This depends on having up to date derived state (shaders) */
+ if (ctx->NewState)
+ _mesa_update_state(ctx);
+
+ if (ctx->API == API_OPENGL_COMPAT) {
+ /* Any shader stages that are not supplied by the GLSL shader and have
+ * assembly shaders enabled must now be validated.
+ */
+ if (!ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX]
+ && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(vertex program not valid)", where);
+ return GL_FALSE;
+ }
+
+ if (!ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT]) {
+ if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(fragment program not valid)", where);
+ return GL_FALSE;
+ }
+
+ /* If drawing to integer-valued color buffers, there must be an
+ * active fragment shader (GL_EXT_texture_integer).
+ */
+ if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerBuffers) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(integer format but no fragment shader)", where);
+ return GL_FALSE;
+ }
+ }
+ }
+
+ /* A pipeline object is bound */
+ if (ctx->_Shader->Name && !ctx->_Shader->Validated) {
+ if (!_mesa_validate_program_pipeline(ctx, ctx->_Shader)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glValidateProgramPipeline failed to validate the "
+ "pipeline");
+ return GL_FALSE;
+ }
+ }
+
+ /* If a program is active and SSO not in use, check if validation of
+ * samplers succeeded for the active program. */
+ if (ctx->_Shader->ActiveProgram && ctx->_Shader != ctx->Pipeline.Current) {
+ char errMsg[100];
+ if (!_mesa_sampler_uniforms_are_valid(ctx->_Shader->ActiveProgram,
+ errMsg, 100)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s", errMsg);
+ return GL_FALSE;
+ }
+ }
+
+ if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+ _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
+ "%s(incomplete framebuffer)", where);
+ return GL_FALSE;
+ }
+
+ if (!check_blend_func_error(ctx)) {
+ return GL_FALSE;
+ }
+
+#ifdef DEBUG
+ if (ctx->_Shader->Flags & GLSL_LOG) {
+ struct gl_shader_program **shProg = ctx->_Shader->CurrentProgram;
+ gl_shader_stage i;
+
+ for (i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (shProg[i] == NULL || shProg[i]->_LinkedShaders[i] == NULL ||
+ shProg[i]->_LinkedShaders[i]->Program->_Used)
+ continue;
+
+ /* This is the first time this shader is being used.
+ * Append shader's constants/uniforms to log file.
+ *
+ * Only log data for the program target that matches the shader
+ * target. It's possible to have a program bound to the vertex
+ * shader target that also supplied a fragment shader. If that
+ * program isn't also bound to the fragment shader target we don't
+ * want to log its fragment data.
+ */
+ _mesa_append_uniforms_to_file(shProg[i]->_LinkedShaders[i]->Program);
+ }
+
+ for (i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (shProg[i] != NULL && shProg[i]->_LinkedShaders[i] != NULL)
+ shProg[i]->_LinkedShaders[i]->Program->_Used = GL_TRUE;
+ }
+ }
+#endif
+
+ return GL_TRUE;
+}
/**
return false;
}
+ if (!_mesa_all_buffers_are_unmapped(ctx->Array.VAO)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(vertex buffers are mapped)", function);
+ return false;
+ }
+
switch (ctx->API) {
case API_OPENGLES2:
/* For ES2, we can draw if we have a vertex program/shader). */
}
}
+ /* From GL_INTEL_conservative_rasterization spec:
+ *
+ * The conservative rasterization option applies only to polygons with
+ * PolygonMode state set to FILL. Draw requests for polygons with different
+ * PolygonMode setting or for other primitive types (points/lines) generate
+ * INVALID_OPERATION error.
+ */
+ if (ctx->IntelConservativeRasterization) {
+ GLboolean pass = GL_TRUE;
+
+ switch (mode) {
+ case GL_POINTS:
+ case GL_LINES:
+ case GL_LINE_LOOP:
+ case GL_LINE_STRIP:
+ case GL_LINES_ADJACENCY:
+ case GL_LINE_STRIP_ADJACENCY:
+ pass = GL_FALSE;
+ break;
+ case GL_TRIANGLES:
+ case GL_TRIANGLE_STRIP:
+ case GL_TRIANGLE_FAN:
+ case GL_QUADS:
+ case GL_QUAD_STRIP:
+ case GL_POLYGON:
+ case GL_TRIANGLES_ADJACENCY:
+ case GL_TRIANGLE_STRIP_ADJACENCY:
+ if (ctx->Polygon.FrontMode != GL_FILL ||
+ ctx->Polygon.BackMode != GL_FILL)
+ pass = GL_FALSE;
+ break;
+ default:
+ pass = GL_FALSE;
+ }
+ if (!pass) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "mode=%s invalid with GL_INTEL_conservative_rasterization",
+ _mesa_lookup_prim_by_nr(mode));
+ return GL_FALSE;
+ }
+ }
+
return GL_TRUE;
}
const GLvoid *indices,
const char *caller)
{
- /* From the GLES3 specification, section 2.14.2 (Transform Feedback
- * Primitive Capture):
+ /* Section 2.14.2 (Transform Feedback Primitive Capture) of the OpenGL ES
+ * 3.1 spec says:
*
* The error INVALID_OPERATION is also generated by DrawElements,
* DrawElementsInstanced, and DrawRangeElements while transform feedback
* is active and not paused, regardless of mode.
+ *
+ * The OES_geometry_shader_spec says:
+ *
+ * Issues:
+ *
+ * ...
+ *
+ * (13) Does this extension change how transform feedback operates
+ * compared to unextended OpenGL ES 3.0 or 3.1?
+ *
+ * RESOLVED: Yes... Since we no longer require being able to predict how
+ * much geometry will be generated, we also lift the restriction that
+ * only DrawArray* commands are supported and also support the
+ * DrawElements* commands for transform feedback.
+ *
+ * This should also be reflected in the body of the spec, but that appears
+ * to have been overlooked. The body of the spec only explicitly allows
+ * the indirect versions.
*/
if (_mesa_is_gles3(ctx) && !ctx->Extensions.OES_geometry_shader &&
_mesa_is_xfb_active_and_unpaused(ctx)) {
* buffer bound.
*/
if (_mesa_is_gles31(ctx) &&
- ctx->Array.VAO->_Enabled != ctx->Array.VAO->VertexAttribBufferMask) {
+ ctx->Array.VAO->_Enabled & ~ctx->Array.VAO->VertexAttribBufferMask) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(No VBO bound)", name);
return GL_FALSE;
}
*
* "An INVALID_OPERATION error is generated if
* transform feedback is active and not paused."
+ *
+ * The OES_geometry_shader spec says:
+ *
+ * On p. 250 in the errors section for the DrawArraysIndirect command,
+ * and on p. 254 in the errors section for the DrawElementsIndirect
+ * command, delete the errors which state:
+ *
+ * "An INVALID_OPERATION error is generated if transform feedback is
+ * active and not paused."
+ *
+ * (thus allowing transform feedback to work with indirect draw commands).
*/
if (_mesa_is_gles31(ctx) && !ctx->Extensions.OES_geometry_shader &&
_mesa_is_xfb_active_and_unpaused(ctx)) {
_mesa_validate_DispatchCompute(struct gl_context *ctx,
const GLuint *num_groups)
{
+ struct gl_shader_program *prog;
int i;
FLUSH_CURRENT(ctx, 0);
}
}
+ /* The ARB_compute_variable_group_size spec says:
+ *
+ * "An INVALID_OPERATION error is generated by DispatchCompute if the active
+ * program for the compute shader stage has a variable work group size."
+ */
+ prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
+ if (prog->Comp.LocalSizeVariable) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glDispatchCompute(variable work group size forbidden)");
+ return GL_FALSE;
+ }
+
+ return GL_TRUE;
+}
+
+GLboolean
+_mesa_validate_DispatchComputeGroupSizeARB(struct gl_context *ctx,
+ const GLuint *num_groups,
+ const GLuint *group_size)
+{
+ struct gl_shader_program *prog;
+ GLuint total_invocations = 1;
+ int i;
+
+ FLUSH_CURRENT(ctx, 0);
+
+ if (!check_valid_to_compute(ctx, "glDispatchComputeGroupSizeARB"))
+ return GL_FALSE;
+
+ /* The ARB_compute_variable_group_size spec says:
+ *
+ * "An INVALID_OPERATION error is generated by
+ * DispatchComputeGroupSizeARB if the active program for the compute
+ * shader stage has a fixed work group size."
+ */
+ prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
+ if (!prog->Comp.LocalSizeVariable) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glDispatchComputeGroupSizeARB(fixed work group size "
+ "forbidden)");
+ return GL_FALSE;
+ }
+
+ for (i = 0; i < 3; i++) {
+ /* The ARB_compute_variable_group_size spec says:
+ *
+ * "An INVALID_VALUE error is generated if any of num_groups_x,
+ * num_groups_y and num_groups_z are greater than or equal to the
+ * maximum work group count for the corresponding dimension."
+ */
+ if (num_groups[i] > ctx->Const.MaxComputeWorkGroupCount[i]) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glDispatchComputeGroupSizeARB(num_groups_%c)", 'x' + i);
+ return GL_FALSE;
+ }
+
+ /* The ARB_compute_variable_group_size spec says:
+ *
+ * "An INVALID_VALUE error is generated by DispatchComputeGroupSizeARB if
+ * any of <group_size_x>, <group_size_y>, or <group_size_z> is less than
+ * or equal to zero or greater than the maximum local work group size
+ * for compute shaders with variable group size
+ * (MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB) in the corresponding
+ * dimension."
+ *
+ * However, the "less than" is a spec bug because they are declared as
+ * unsigned integers.
+ */
+ if (group_size[i] == 0 ||
+ group_size[i] > ctx->Const.MaxComputeVariableGroupSize[i]) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glDispatchComputeGroupSizeARB(group_size_%c)", 'x' + i);
+ return GL_FALSE;
+ }
+
+ total_invocations *= group_size[i];
+ }
+
+ /* The ARB_compute_variable_group_size spec says:
+ *
+ * "An INVALID_VALUE error is generated by DispatchComputeGroupSizeARB if
+ * the product of <group_size_x>, <group_size_y>, and <group_size_z> exceeds
+ * the implementation-dependent maximum local work group invocation count
+ * for compute shaders with variable group size
+ * (MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB)."
+ */
+ if (total_invocations > ctx->Const.MaxComputeVariableGroupInvocations) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glDispatchComputeGroupSizeARB(product of local_sizes "
+ "exceeds MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB "
+ "(%d > %d))", total_invocations,
+ ctx->Const.MaxComputeVariableGroupInvocations);
+ return GL_FALSE;
+ }
+
return GL_TRUE;
}
GLsizei size, const char *name)
{
const uint64_t end = (uint64_t) indirect + size;
+ struct gl_shader_program *prog;
if (!check_valid_to_compute(ctx, name))
return GL_FALSE;
return GL_FALSE;
}
+ /* The ARB_compute_variable_group_size spec says:
+ *
+ * "An INVALID_OPERATION error is generated if the active program for the
+ * compute shader stage has a variable work group size."
+ */
+ prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
+ if (prog->Comp.LocalSizeVariable) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(variable work group size forbidden)", name);
+ return GL_FALSE;
+ }
+
return GL_TRUE;
}
projects / mesa.git / blobdiff