Lines Matching refs:ctx
196 _mesa_init_shader_state(struct gl_context *ctx)
209 memcpy(&ctx->Const.ShaderCompilerOptions[sh], &options, sizeof(options));
211 ctx->Shader.Flags = _mesa_get_shader_flags();
213 if (ctx->Shader.Flags != 0)
214 ctx->Const.GenerateTemporaryNames = true;
217 ctx->Shader.RefCount = 1;
218 ctx->TessCtrlProgram.patch_vertices = 3;
220 ctx->TessCtrlProgram.patch_default_outer_level[i] = 1.0;
222 ctx->TessCtrlProgram.patch_default_inner_level[i] = 1.0;
230 _mesa_free_shader_state(struct gl_context *ctx)
233 _mesa_reference_program(ctx, &ctx->Shader.CurrentProgram[i], NULL);
234 _mesa_reference_shader_program(ctx,
235 &ctx->Shader.ReferencedPrograms[i],
237 free(ctx->SubroutineIndex[i].IndexPtr);
238 ctx->SubroutineIndex[i].IndexPtr = NULL;
240 _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
243 _mesa_reference_pipeline_object(ctx, &ctx->_Shader, NULL);
245 assert(ctx->Shader.RefCount == 1);
275 * \param ctx Current GL context
280 _mesa_validate_shader_target(const struct gl_context *ctx, GLenum type)
283 * invoked with ctx == NULL. In that case, we can only validate that it's
291 return ctx == NULL || ctx->Extensions.ARB_fragment_shader;
293 return ctx == NULL || ctx->Extensions.ARB_vertex_shader;
295 return ctx == NULL || _mesa_has_geometry_shaders(ctx);
298 return ctx == NULL || _mesa_has_tessellation(ctx);
300 return ctx == NULL || _mesa_has_compute_shaders(ctx);
308 is_program(struct gl_context *ctx, GLuint name)
310 struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
316 is_shader(struct gl_context *ctx, GLuint name)
318 struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
327 attach_shader(struct gl_context *ctx, struct gl_shader_program *shProg,
335 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
341 _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
346 attach_shader_err(struct gl_context *ctx, GLuint program, GLuint shader,
353 const bool same_type_disallowed = _mesa_is_gles(ctx);
355 shProg = _mesa_lookup_shader_program_err(ctx, program, caller);
359 sh = _mesa_lookup_shader_err(ctx, shader, caller);
373 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
385 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
390 attach_shader(ctx, shProg, sh);
394 attach_shader_no_error(struct gl_context *ctx, GLuint program, GLuint shader)
399 shProg = _mesa_lookup_shader_program(ctx, program);
400 sh = _mesa_lookup_shader(ctx, shader);
402 attach_shader(ctx, shProg, sh);
406 create_shader(struct gl_context *ctx, GLenum type)
411 _mesa_HashLockMutex(ctx->Shared->ShaderObjects);
412 name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
415 _mesa_HashInsertLocked(ctx->Shared->ShaderObjects, name, sh, true);
416 _mesa_HashUnlockMutex(ctx->Shared->ShaderObjects);
423 create_shader_err(struct gl_context *ctx, GLenum type, const char *caller)
425 if (!_mesa_validate_shader_target(ctx, type)) {
426 _mesa_error(ctx, GL_INVALID_ENUM, "%s(%s)",
431 return create_shader(ctx, type);
436 create_shader_program(struct gl_context *ctx)
441 _mesa_HashLockMutex(ctx->Shared->ShaderObjects);
443 name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
447 _mesa_HashInsertLocked(ctx->Shared->ShaderObjects, name, shProg, true);
451 _mesa_HashUnlockMutex(ctx->Shared->ShaderObjects);
463 delete_shader_program(struct gl_context *ctx, GLuint name)
475 shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
483 _mesa_reference_shader_program(ctx, &shProg, NULL);
489 delete_shader(struct gl_context *ctx, GLuint shader)
493 sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
501 _mesa_reference_shader(ctx, &sh, NULL);
507 detach_shader(struct gl_context *ctx, GLuint program, GLuint shader,
515 shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
519 shProg = _mesa_lookup_shader_program(ctx, program);
530 _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
535 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
570 if (is_shader(ctx, shader) || is_program(ctx, shader))
574 _mesa_error(ctx, err, "glDetachShader(shader)");
581 detach_shader_error(struct gl_context *ctx, GLuint program, GLuint shader)
583 detach_shader(ctx, program, shader, false);
588 detach_shader_no_error(struct gl_context *ctx, GLuint program, GLuint shader)
590 detach_shader(ctx, program, shader, true);
600 get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
606 _mesa_error(ctx, GL_INVALID_VALUE, "glGetAttachedShaders(maxCount < 0)");
611 _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
634 get_handle(struct gl_context *ctx, GLenum pname)
637 if (ctx->_Shader->ActiveProgram)
638 return ctx->_Shader->ActiveProgram->Name;
643 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
661 check_gs_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
668 _mesa_error(ctx, GL_INVALID_OPERATION,
686 check_tcs_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
693 _mesa_error(ctx, GL_INVALID_OPERATION,
712 check_tes_query(struct gl_context *ctx, const struct gl_shader_program *shProg)
719 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramv(linked tessellation "
725 get_shader_program_completion_status(struct gl_context *ctx,
728 struct pipe_screen *screen = ctx->screen;
758 get_programiv(struct gl_context *ctx, GLuint program, GLenum pname,
762 = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramiv(program)");
767 (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.EXT_transform_feedback)
768 || ctx->API == API_OPENGL_CORE
769 || _mesa_is_gles3(ctx);
774 const bool has_gs = _mesa_has_geometry_shaders(ctx);
775 const bool has_tess = _mesa_has_tessellation(ctx);
780 (ctx->API == API_OPENGL_COMPAT &&
781 ctx->Extensions.ARB_uniform_buffer_object)
782 || ctx->API == API_OPENGL_CORE
783 || _mesa_is_gles3(ctx);
794 *params = get_shader_program_completion_status(ctx, shProg);
856 if (check_gs_query(ctx, shProg)) {
863 (_mesa_is_desktop_gl(ctx) && !ctx->Extensions.ARB_gpu_shader5)) {
866 if (check_gs_query(ctx, shProg)) {
874 if (check_gs_query(ctx, shProg)) {
882 if (check_gs_query(ctx, shProg)) {
908 if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles3(ctx))
914 if (ctx->Const.NumProgramBinaryFormats == 0 || !shProg->data->LinkStatus) {
917 _mesa_get_program_binary_length(ctx, shProg, params);
921 if (!ctx->Extensions.ARB_shader_atomic_counters && !_mesa_is_gles31(ctx))
928 if (!_mesa_has_compute_shaders(ctx))
931 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramiv(program not "
936 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramiv(no compute "
954 if (check_tcs_query(ctx, shProg)) {
962 if (check_tes_query(ctx, shProg)) {
984 if (check_tes_query(ctx, shProg)) {
1006 if (check_tes_query(ctx, shProg)) {
1014 if (check_tes_query(ctx, shProg)) {
1023 _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname=%s)",
1032 get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
1035 _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
1066 _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
1073 get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
1085 _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(bufSize < 0)");
1089 shProg = _mesa_lookup_shader_program_err(ctx, program,
1100 get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
1112 _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(bufSize < 0)");
1116 sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderInfoLog(shader)");
1129 get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
1135 _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderSource(bufSize < 0)");
1139 sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
1184 ensure_builtin_types(struct gl_context *ctx)
1186 if (!ctx->shader_builtin_ref) {
1188 ctx->shader_builtin_ref = true;
1196 _mesa_compile_shader(struct gl_context *ctx, struct gl_shader *sh)
1209 _mesa_error(ctx, GL_INVALID_OPERATION, "glCompileShader(SPIR-V)");
1219 if (ctx->_Shader->Flags & GLSL_DUMP) {
1225 ensure_builtin_types(ctx);
1230 _mesa_glsl_compile_shader(ctx, sh, false, false, false);
1232 if (ctx->_Shader->Flags & GLSL_LOG) {
1236 if (ctx->_Shader->Flags & GLSL_DUMP) {
1257 if (ctx->_Shader->Flags & GLSL_DUMP_ON_ERROR) {
1264 if (ctx->_Shader->Flags & GLSL_REPORT_ERRORS) {
1265 _mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
1274 struct gl_context *ctx;
1289 _mesa_use_program(params->ctx, stage, params->shProg, prog, obj);
1299 link_program(struct gl_context *ctx, struct gl_shader_program *shProg,
1311 if (_mesa_transform_feedback_is_using_program(ctx, shProg)) {
1312 _mesa_error(ctx, GL_INVALID_OPERATION,
1319 if (ctx->_Shader)
1321 if (ctx->_Shader->CurrentProgram[stage] &&
1322 ctx->_Shader->CurrentProgram[stage]->Id == shProg->Name) {
1327 ensure_builtin_types(ctx);
1329 FLUSH_VERTICES(ctx, 0, 0);
1330 _mesa_glsl_link_shader(ctx, shProg);
1350 _mesa_use_program(ctx, stage, shProg, prog, ctx->_Shader);
1353 if (ctx->Pipeline.Objects) {
1355 .ctx = ctx,
1358 _mesa_HashWalk(ctx->Pipeline.Objects, update_programs_in_pipeline,
1403 _mesa_warning(ctx, "Failed to open %s", filename);
1411 (ctx->_Shader->Flags & GLSL_REPORT_ERRORS)) {
1412 _mesa_debug(ctx, "Error linking program %u:\n%s\n",
1416 _mesa_update_vertex_processing_mode(ctx);
1417 _mesa_update_valid_to_render_state(ctx);
1439 link_program_error(struct gl_context *ctx, struct gl_shader_program *shProg)
1441 link_program(ctx, shProg, false);
1446 link_program_no_error(struct gl_context *ctx, struct gl_shader_program *shProg)
1448 link_program(ctx, shProg, true);
1453 _mesa_link_program(struct gl_context *ctx, struct gl_shader_program *shProg)
1455 link_program_error(ctx, shProg);
1495 _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
1499 _mesa_error(ctx, GL_INVALID_OPERATION,
1504 if (ctx->Shader.ActiveProgram != shProg) {
1505 _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
1506 _mesa_update_valid_to_render_state(ctx);
1515 _mesa_use_shader_program(struct gl_context *ctx,
1522 _mesa_use_program(ctx, i, shProg, new_prog, &ctx->Shader);
1524 _mesa_active_program(ctx, shProg, "glUseProgram");
1571 validate_program(struct gl_context *ctx, GLuint program)
1576 shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
1595 GET_CURRENT_CONTEXT(ctx);
1596 attach_shader_no_error(ctx, program, shader);
1603 GET_CURRENT_CONTEXT(ctx);
1604 attach_shader_err(ctx, program, shader, "glAttachObjectARB");
1611 GET_CURRENT_CONTEXT(ctx);
1612 attach_shader_no_error(ctx, program, shader);
1619 GET_CURRENT_CONTEXT(ctx);
1620 attach_shader_err(ctx, program, shader, "glAttachShader");
1627 GET_CURRENT_CONTEXT(ctx);
1629 _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
1630 _mesa_compile_shader(ctx, _mesa_lookup_shader_err(ctx, shaderObj,
1638 GET_CURRENT_CONTEXT(ctx);
1639 return create_shader(ctx, type);
1646 GET_CURRENT_CONTEXT(ctx);
1649 _mesa_debug(ctx, "glCreateShader %s\n", _mesa_enum_to_string(type));
1651 return create_shader_err(ctx, type, "glCreateShader");
1658 GET_CURRENT_CONTEXT(ctx);
1659 return create_shader(ctx, type);
1666 GET_CURRENT_CONTEXT(ctx);
1667 return create_shader_err(ctx, type, "glCreateShaderObjectARB");
1674 GET_CURRENT_CONTEXT(ctx);
1676 _mesa_debug(ctx, "glCreateProgram\n");
1677 return create_shader_program(ctx);
1684 GET_CURRENT_CONTEXT(ctx);
1685 return create_shader_program(ctx);
1693 GET_CURRENT_CONTEXT(ctx);
1694 _mesa_debug(ctx, "glDeleteObjectARB(%lu)\n", (unsigned long)obj);
1698 GET_CURRENT_CONTEXT(ctx);
1699 FLUSH_VERTICES(ctx, 0, 0);
1700 if (is_program(ctx, obj)) {
1701 delete_shader_program(ctx, obj);
1703 else if (is_shader(ctx, obj)) {
1704 delete_shader(ctx, obj);
1707 _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteObjectARB");
1717 GET_CURRENT_CONTEXT(ctx);
1718 FLUSH_VERTICES(ctx, 0, 0);
1719 delete_shader_program(ctx, name);
1728 GET_CURRENT_CONTEXT(ctx);
1729 FLUSH_VERTICES(ctx, 0, 0);
1730 delete_shader(ctx, name);
1738 GET_CURRENT_CONTEXT(ctx);
1739 detach_shader_no_error(ctx, program, shader);
1746 GET_CURRENT_CONTEXT(ctx);
1747 detach_shader_error(ctx, program, shader);
1754 GET_CURRENT_CONTEXT(ctx);
1755 detach_shader_no_error(ctx, program, shader);
1762 GET_CURRENT_CONTEXT(ctx);
1763 detach_shader_error(ctx, program, shader);
1771 GET_CURRENT_CONTEXT(ctx);
1772 get_attached_shaders(ctx, (GLuint)container, maxCount, count, NULL, obj);
1780 GET_CURRENT_CONTEXT(ctx);
1781 get_attached_shaders(ctx, program, maxCount, count, obj, NULL);
1789 GET_CURRENT_CONTEXT(ctx);
1790 if (is_program(ctx, object)) {
1791 get_program_info_log(ctx, object, maxLength, length, infoLog);
1793 else if (is_shader(ctx, object)) {
1794 get_shader_info_log(ctx, object, maxLength, length, infoLog);
1797 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
1805 GET_CURRENT_CONTEXT(ctx);
1807 if (is_program(ctx, object)) {
1812 get_programiv(ctx, object, pname, params);
1815 else if (is_shader(ctx, object)) {
1820 get_shaderiv(ctx, object, pname, params);
1824 _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
1842 GET_CURRENT_CONTEXT(ctx);
1843 get_programiv(ctx, program, pname, params);
1850 GET_CURRENT_CONTEXT(ctx);
1851 get_shaderiv(ctx, shader, pname, params);
1859 GET_CURRENT_CONTEXT(ctx);
1860 get_program_info_log(ctx, program, bufSize, length, infoLog);
1868 GET_CURRENT_CONTEXT(ctx);
1869 get_shader_info_log(ctx, shader, bufSize, length, infoLog);
1877 GET_CURRENT_CONTEXT(ctx);
1878 get_shader_source(ctx, shader, maxLength, length, sourceOut);
1885 GET_CURRENT_CONTEXT(ctx);
1886 return get_handle(ctx, pname);
1893 GET_CURRENT_CONTEXT(ctx);
1894 return is_program(ctx, name);
1901 GET_CURRENT_CONTEXT(ctx);
1902 return is_shader(ctx, name);
1909 GET_CURRENT_CONTEXT(ctx);
1912 _mesa_lookup_shader_program(ctx, programObj);
1913 link_program_no_error(ctx, shProg);
1920 GET_CURRENT_CONTEXT(ctx);
1923 _mesa_debug(ctx, "glLinkProgram %u\n", programObj);
1926 _mesa_lookup_shader_program_err(ctx, programObj, "glLinkProgram");
1927 link_program_error(ctx, shProg);
1982 GET_CURRENT_CONTEXT(ctx);
1983 _mesa_warning(ctx, "could not open %s for dumping shader (%s)", name,
2072 shader_source(struct gl_context *ctx, GLuint shaderObj, GLsizei count,
2081 sh = _mesa_lookup_shader_err(ctx, shaderObj, "glShaderSourceARB");
2086 _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
2090 sh = _mesa_lookup_shader(ctx, shaderObj);
2103 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
2110 _mesa_error(ctx, GL_INVALID_OPERATION,
2131 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
2172 GET_CURRENT_CONTEXT(ctx);
2173 shader_source(ctx, shaderObj, count, string, length, true);
2181 GET_CURRENT_CONTEXT(ctx);
2182 shader_source(ctx, shaderObj, count, string, length, false);
2189 GET_CURRENT_CONTEXT(ctx);
2193 _mesa_debug(ctx, "glUseProgram %u\n", program);
2197 shProg = _mesa_lookup_shader_program(ctx, program);
2200 if (_mesa_is_xfb_active_and_unpaused(ctx)) {
2201 _mesa_error(ctx, GL_INVALID_OPERATION,
2208 _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
2213 _mesa_error(ctx, GL_INVALID_OPERATION,
2219 if (ctx->_Shader->Flags & GLSL_USE_PROG) {
2236 _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
2238 _mesa_use_shader_program(ctx, shProg);
2241 _mesa_use_shader_program(ctx, shProg);
2243 _mesa_reference_pipeline_object(ctx, &ctx->_Shader,
2244 ctx->Pipeline.Default);
2246 if (ctx->Pipeline.Current) {
2248 _mesa_BindProgramPipeline_no_error(ctx->Pipeline.Current->Name);
2250 _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
2254 _mesa_update_vertex_processing_mode(ctx);
2275 GET_CURRENT_CONTEXT(ctx);
2276 validate_program(ctx, program);
2289 GET_CURRENT_CONTEXT(ctx);
2293 limits = &ctx->Const.Program[MESA_SHADER_VERTEX];
2296 limits = &ctx->Const.Program[MESA_SHADER_FRAGMENT];
2299 _mesa_error(ctx, GL_INVALID_ENUM,
2324 _mesa_error(ctx, GL_INVALID_ENUM,
2341 GET_CURRENT_CONTEXT(ctx);
2343 if (ctx->shader_builtin_ref) {
2345 ctx->shader_builtin_ref = false;
2357 GET_CURRENT_CONTEXT(ctx);
2368 _mesa_error(ctx, GL_INVALID_VALUE, "glShaderBinary(count or length < 0)");
2376 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderBinary(count)");
2382 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderBinary");
2387 sh[i] = _mesa_lookup_shader_err(ctx, shaders[i], "glShaderBinary");
2393 if (!ctx->Extensions.ARB_gl_spirv) {
2394 _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderBinary(SPIR-V)");
2396 _mesa_spirv_shader_binary(ctx, (unsigned) n, sh, binary,
2403 _mesa_error(ctx, GL_INVALID_ENUM, "glShaderBinary(format)");
2413 GET_CURRENT_CONTEXT(ctx);
2416 _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramBinary(bufSize < 0)");
2420 shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetProgramBinary");
2442 _mesa_error(ctx, GL_INVALID_OPERATION,
2449 if (ctx->Const.NumProgramBinaryFormats == 0) {
2451 _mesa_error(ctx, GL_INVALID_OPERATION,
2454 _mesa_get_program_binary(ctx, shProg, bufSize, length, binaryFormat,
2465 GET_CURRENT_CONTEXT(ctx);
2467 shProg = _mesa_lookup_shader_program_err(ctx, program, "glProgramBinary");
2471 _mesa_clear_shader_program_data(ctx, shProg);
2480 _mesa_error(ctx, GL_INVALID_VALUE, "glProgramBinary(length < 0)");
2484 if (ctx->Const.NumProgramBinaryFormats == 0 ||
2499 _mesa_error(ctx, GL_INVALID_ENUM, "glProgramBinary");
2501 _mesa_program_binary(ctx, shProg, binaryFormat, binary, length);
2507 program_parameteri(struct gl_context *ctx, struct gl_shader_program *shProg,
2564 _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteri(pname=%s)",
2571 _mesa_error(ctx, GL_INVALID_VALUE,
2582 GET_CURRENT_CONTEXT(ctx);
2584 struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, program);
2585 program_parameteri(ctx, shProg, pname, value, true);
2593 GET_CURRENT_CONTEXT(ctx);
2595 shProg = _mesa_lookup_shader_program_err(ctx, program,
2600 program_parameteri(ctx, shProg, pname, value, false);
2605 _mesa_use_program(struct gl_context *ctx, gl_shader_stage stage,
2613 _mesa_program_init_subroutine_defaults(ctx, prog);
2618 if (shTarget == ctx->_Shader) {
2619 FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS, 0);
2622 _mesa_reference_shader_program(ctx,
2625 _mesa_reference_program(ctx, target, prog);
2626 _mesa_update_allow_draw_out_of_order(ctx);
2627 _mesa_update_valid_to_render_state(ctx);
2629 _mesa_update_vertex_processing_mode(ctx);
2676 GET_CURRENT_CONTEXT(ctx);
2678 const GLuint shader = create_shader_err(ctx, type, "glCreateShaderProgramv");
2686 _mesa_error(ctx, GL_INVALID_VALUE, "glCreateShaderProgram (count < 0)");
2691 struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
2694 _mesa_compile_shader(ctx, sh);
2696 program = create_shader_program(ctx);
2701 shProg = _mesa_lookup_shader_program(ctx, program);
2705 get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
2707 attach_shader_err(ctx, program, shader, "glCreateShaderProgramv");
2708 _mesa_link_program(ctx, shProg);
2709 detach_shader_error(ctx, program, shader);
2723 delete_shader(ctx, shader);
2731 set_patch_vertices(struct gl_context *ctx, GLint value)
2733 if (ctx->TessCtrlProgram.patch_vertices != value) {
2734 FLUSH_VERTICES(ctx, 0, GL_CURRENT_BIT);
2735 ctx->NewDriverState |= ST_NEW_TESS_STATE;
2736 ctx->TessCtrlProgram.patch_vertices = value;
2746 GET_CURRENT_CONTEXT(ctx);
2748 set_patch_vertices(ctx, value);
2755 GET_CURRENT_CONTEXT(ctx);
2757 if (!_mesa_has_tessellation(ctx)) {
2758 _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameteri");
2763 _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameteri");
2767 if (value <= 0 || value > ctx->Const.MaxPatchVertices) {
2768 _mesa_error(ctx, GL_INVALID_VALUE, "glPatchParameteri");
2772 set_patch_vertices(ctx, value);
2779 GET_CURRENT_CONTEXT(ctx);
2781 if (!_mesa_has_tessellation(ctx)) {
2782 _mesa_error(ctx, GL_INVALID_OPERATION, "glPatchParameterfv");
2788 FLUSH_VERTICES(ctx, 0, 0);
2789 memcpy(ctx->TessCtrlProgram.patch_default_outer_level, values,
2791 ctx->NewDriverState |= ST_NEW_TESS_STATE;
2794 FLUSH_VERTICES(ctx, 0, 0);
2795 memcpy(ctx->TessCtrlProgram.patch_default_inner_level, values,
2797 ctx->NewDriverState |= ST_NEW_TESS_STATE;
2800 _mesa_error(ctx, GL_INVALID_ENUM, "glPatchParameterfv");
2812 GET_CURRENT_CONTEXT(ctx);
2818 if (!_mesa_validate_shader_target(ctx, shadertype)) {
2819 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2823 shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2829 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2841 GET_CURRENT_CONTEXT(ctx);
2848 if (!_mesa_validate_shader_target(ctx, shadertype)) {
2849 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2853 shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2859 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2877 GET_CURRENT_CONTEXT(ctx);
2887 if (!_mesa_validate_shader_target(ctx, shadertype)) {
2888 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2892 shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2901 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2907 _mesa_error(ctx, GL_INVALID_VALUE, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name);
2952 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2963 GET_CURRENT_CONTEXT(ctx);
2969 if (!_mesa_validate_shader_target(ctx, shadertype)) {
2970 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2974 shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
2980 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
2997 GET_CURRENT_CONTEXT(ctx);
3003 if (!_mesa_validate_shader_target(ctx, shadertype)) {
3004 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3008 shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
3014 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3027 GET_CURRENT_CONTEXT(ctx);
3032 if (!_mesa_validate_shader_target(ctx, shadertype)) {
3033 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3038 struct gl_program *p = ctx->_Shader->CurrentProgram[stage];
3040 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3045 _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
3059 _mesa_flush_vertices_for_uniforms(ctx, uni);
3069 _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
3087 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3091 ctx->SubroutineIndex[p->info.stage].IndexPtr[j] = indices[j];
3102 GET_CURRENT_CONTEXT(ctx);
3106 if (!_mesa_validate_shader_target(ctx, shadertype)) {
3107 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3112 struct gl_program *p = ctx->_Shader->CurrentProgram[stage];
3114 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3119 _mesa_error(ctx, GL_INVALID_VALUE, "%s", api_name);
3123 *params = ctx->SubroutineIndex[p->info.stage].IndexPtr[location];
3131 GET_CURRENT_CONTEXT(ctx);
3137 if (!_mesa_validate_shader_target(ctx, shadertype)) {
3138 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3142 shProg = _mesa_lookup_shader_program_err(ctx, program, api_name);
3165 _mesa_error(ctx, GL_INVALID_OPERATION, "%s", api_name);
3222 _mesa_error(ctx, GL_INVALID_ENUM, "%s", api_name);
3331 validate_and_tokenise_sh_incl(struct gl_context *ctx,
3336 bool relative_path = ctx->Shared->ShaderIncludes->num_include_paths;
3340 _mesa_error(ctx, GL_INVALID_VALUE,
3356 _mesa_error(ctx, GL_INVALID_VALUE,
3382 lookup_shader_include(struct gl_context *ctx, char *path,
3388 if (!validate_and_tokenise_sh_incl(ctx, mem_ctx, &path_list, path,
3396 ctx->Shared->ShaderIncludes->shader_include_tree;
3398 size_t count = ctx->Shared->ShaderIncludes->num_include_paths;
3401 size_t i = ctx->Shared->ShaderIncludes->relative_path_cursor;
3402 bool use_cursor = ctx->Shared->ShaderIncludes->relative_path_cursor;
3411 ctx->Shared->ShaderIncludes->include_paths[i];
3418 path_ht = ctx->Shared->ShaderIncludes->shader_include_tree;
3447 path_ht = ctx->Shared->ShaderIncludes->shader_include_tree;
3473 ctx->Shared->ShaderIncludes->relative_path_cursor = i;
3483 _mesa_lookup_shader_include(struct gl_context *ctx, char *path,
3487 lookup_shader_include(ctx, path, error_check);
3493 copy_string(struct gl_context *ctx, const char *str, int str_len,
3497 _mesa_error(ctx, GL_INVALID_VALUE, "%s(NULL string)", caller);
3516 GET_CURRENT_CONTEXT(ctx);
3520 _mesa_error(ctx, GL_INVALID_VALUE, "%s(invalid type)", caller);
3524 char *name_cp = copy_string(ctx, name, namelen, caller);
3525 char *string_cp = copy_string(ctx, string, stringlen, caller);
3535 if (!validate_and_tokenise_sh_incl(ctx, mem_ctx, &path_list, name_cp,
3543 simple_mtx_lock(&ctx->Shared->ShaderIncludeMutex);
3546 ctx->Shared->ShaderIncludes->shader_include_tree;
3572 simple_mtx_unlock(&ctx->Shared->ShaderIncludeMutex);
3581 GET_CURRENT_CONTEXT(ctx);
3584 char *name_cp = copy_string(ctx, name, namelen, caller);
3589 lookup_shader_include(ctx, name_cp, true);
3592 _mesa_error(ctx, GL_INVALID_OPERATION,
3598 simple_mtx_lock(&ctx->Shared->ShaderIncludeMutex);
3603 simple_mtx_unlock(&ctx->Shared->ShaderIncludeMutex);
3612 GET_CURRENT_CONTEXT(ctx);
3616 _mesa_error(ctx, GL_INVALID_VALUE, "%s(count > 0 && path == NULL)",
3623 simple_mtx_lock(&ctx->Shared->ShaderIncludeMutex);
3625 ctx->Shared->ShaderIncludes->include_paths =
3629 char *path_cp = copy_string(ctx, path[i], length ? length[i] : -1,
3637 if (!validate_and_tokenise_sh_incl(ctx, mem_ctx, &path_list, path_cp,
3643 ctx->Shared->ShaderIncludes->include_paths[i] = path_list;
3652 ctx->Shared->ShaderIncludes->num_include_paths = count;
3654 struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
3656 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(shader)", caller);
3660 _mesa_compile_shader(ctx, sh);
3663 ctx->Shared->ShaderIncludes->num_include_paths = 0;
3664 ctx->Shared->ShaderIncludes->relative_path_cursor = 0;
3665 ctx->Shared->ShaderIncludes->include_paths = NULL;
3667 simple_mtx_unlock(&ctx->Shared->ShaderIncludeMutex);
3675 GET_CURRENT_CONTEXT(ctx);
3680 char *name_cp = copy_string(ctx, name, namelen, "");
3682 const char *source = _mesa_lookup_shader_include(ctx, name_cp, false);
3695 GET_CURRENT_CONTEXT(ctx);
3698 char *name_cp = copy_string(ctx, name, namelen, caller);
3702 const char *source = _mesa_lookup_shader_include(ctx, name_cp, true);
3704 _mesa_error(ctx, GL_INVALID_OPERATION,
3723 GET_CURRENT_CONTEXT(ctx);
3726 char *name_cp = copy_string(ctx, name, namelen, caller);
3730 const char *source = _mesa_lookup_shader_include(ctx, name_cp, true);
3732 _mesa_error(ctx, GL_INVALID_OPERATION,
3746 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname)", caller);
3769 _mesa_shader_write_subroutine_index(struct gl_context *ctx,
3790 val = ctx->SubroutineIndex[p->info.stage].IndexPtr[i + j];
3800 _mesa_shader_write_subroutine_indices(struct gl_context *ctx,
3803 if (ctx->_Shader->CurrentProgram[stage])
3804 _mesa_shader_write_subroutine_index(ctx,
3805 ctx->_Shader->CurrentProgram[stage]);
3809 _mesa_program_init_subroutine_defaults(struct gl_context *ctx,
3814 struct gl_subroutine_index_binding *binding = &ctx->SubroutineIndex[p->info.stage];