void fd3_prog_fini(struct pipe_context *pctx) { struct fd_context *ctx = fd_context(pctx); delete_shader(ctx->solid_prog.vp); delete_shader(ctx->solid_prog.fp); delete_shader(ctx->blit_prog.vp); delete_shader(ctx->blit_prog.fp); }
static struct fd2_shader_stateobj * compile(struct fd_program_stateobj *prog, struct fd2_shader_stateobj *so) { int ret; if (fd_mesa_debug & FD_DBG_DISASM) { DBG("dump tgsi: type=%d", so->type); tgsi_dump(so->tokens, 0); } ret = fd2_compile_shader(prog, so); if (ret) goto fail; /* NOTE: we don't assemble yet because for VS we don't know the * type information for vertex fetch yet.. so those need to be * patched up later before assembling. */ so->info.sizedwords = 0; return so; fail: debug_error("compile failed!"); delete_shader(so); return NULL; }
void cogl_shader_source (CoglHandle handle, const char *source) { CoglShader *shader; CoglShaderLanguage language; _COGL_GET_CONTEXT (ctx, NO_RETVAL); if (!cogl_is_shader (handle)) return; shader = handle; #ifdef HAVE_COGL_GL if (strncmp (source, "!!ARBfp1.0", 10) == 0) language = COGL_SHADER_LANGUAGE_ARBFP; else #endif language = COGL_SHADER_LANGUAGE_GLSL; /* Delete the old object if the language is changing... */ if (G_UNLIKELY (language != shader->language) && shader->gl_handle) delete_shader (shader); shader->source = g_strdup (source); shader->language = language; }
void GLAPIENTRY _mesa_DeleteShader(GLuint name) { if (name) { GET_CURRENT_CONTEXT(ctx); FLUSH_VERTICES(ctx, 0); delete_shader(ctx, name); } }
static struct fd3_shader_stateobj * create_shader(struct pipe_context *pctx, const struct pipe_shader_state *cso, enum shader_t type) { struct fd3_shader_stateobj *so = CALLOC_STRUCT(fd3_shader_stateobj); int ret; if (!so) return NULL; so->type = type; if (fd_mesa_debug & FD_DBG_DISASM) { DBG("dump tgsi: type=%d", so->type); tgsi_dump(cso->tokens, 0); } if (type == SHADER_FRAGMENT) { /* we seem to get wrong colors (maybe swap/endianess or hw issue?) * with full precision color reg. And blob driver only seems to * use half precision register for color output (that I can find * so far), even with highp precision. So for force half precision * for frag shader: */ so->half_precision = true; } ret = fd3_compile_shader(so, cso->tokens); if (ret) { debug_error("compile failed!"); goto fail; } assemble_shader(pctx, so); if (!so->bo) { debug_error("assemble failed!"); goto fail; } if (type == SHADER_VERTEX) fixup_vp_regfootprint(so); if (fd_mesa_debug & FD_DBG_DISASM) { DBG("disassemble: type=%d", so->type); disasm_a3xx(fd_bo_map(so->bo), so->info.sizedwords, 0, so->type); } return so; fail: delete_shader(so); return NULL; }
/** * For GL_EXT_separate_shader_objects */ GLuint GLAPIENTRY _mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string) { GET_CURRENT_CONTEXT(ctx); const GLuint shader = create_shader(ctx, type); GLuint program = 0; if (shader) { shader_source(ctx, shader, _mesa_strdup(string)); compile_shader(ctx, shader); program = create_shader_program(ctx); if (program) { struct gl_shader_program *shProg; struct gl_shader *sh; GLint compiled = GL_FALSE; shProg = _mesa_lookup_shader_program(ctx, program); sh = _mesa_lookup_shader(ctx, shader); get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled); if (compiled) { attach_shader(ctx, program, shader); link_program(ctx, program); detach_shader(ctx, program, shader); #if 0 /* Possibly... */ if (active-user-defined-varyings-in-linked-program) { append-error-to-info-log; shProg->LinkStatus = GL_FALSE; } #endif } ralloc_strcat(&shProg->InfoLog, sh->InfoLog); } delete_shader(ctx, shader); } return program; }
static struct fd2_shader_stateobj * assemble(struct fd2_shader_stateobj *so) { free(so->bin); so->bin = ir2_shader_assemble(so->ir, &so->info); if (!so->bin) goto fail; if (fd_mesa_debug & FD_DBG_DISASM) { DBG("disassemble: type=%d", so->type); disasm_a2xx(so->bin, so->info.sizedwords, 0, so->type); } return so; fail: debug_error("assemble failed!"); delete_shader(so); return NULL; }
void GLAPIENTRY _mesa_DeleteObjectARB(GLhandleARB obj) { if (MESA_VERBOSE & VERBOSE_API) { GET_CURRENT_CONTEXT(ctx); _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj); } if (obj) { GET_CURRENT_CONTEXT(ctx); FLUSH_VERTICES(ctx, 0); if (is_program(ctx, obj)) { delete_shader_program(ctx, obj); } else if (is_shader(ctx, obj)) { delete_shader(ctx, obj); } else { /* error? */ } } }
static void fd2_vp_state_delete(struct pipe_context *pctx, void *hwcso) { struct fd2_shader_stateobj *so = hwcso; delete_shader(so); }
void _cogl_shader_compile_real (CoglHandle handle, CoglPipeline *pipeline) { CoglShader *shader = handle; _COGL_GET_CONTEXT (ctx, NO_RETVAL); #ifdef HAVE_COGL_GL if (shader->language == COGL_SHADER_LANGUAGE_ARBFP) { #ifdef COGL_GL_DEBUG GLenum gl_error; #endif if (shader->gl_handle) return; GE (ctx, glGenPrograms (1, &shader->gl_handle)); GE (ctx, glBindProgram (GL_FRAGMENT_PROGRAM_ARB, shader->gl_handle)); if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_SHOW_SOURCE))) g_message ("user ARBfp program:\n%s", shader->source); #ifdef COGL_GL_DEBUG _cogl_gl_util_clear_gl_errors (ctx); #endif ctx->glProgramString (GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen (shader->source), shader->source); #ifdef COGL_GL_DEBUG gl_error = _cogl_gl_util_get_error (ctx); if (gl_error != GL_NO_ERROR) { g_warning ("%s: GL error (%d): Failed to compile ARBfp:\n%s\n%s", G_STRLOC, gl_error, shader->source, ctx->glGetString (GL_PROGRAM_ERROR_STRING_ARB)); } #endif } else #endif { GLenum gl_type; GLint status; if (shader->gl_handle) { CoglPipeline *prev = shader->compilation_pipeline; /* XXX: currently the only things that will affect the * boilerplate for user shaders, apart from driver features, * are the pipeline layer-indices and texture-unit-indices */ if (pipeline == prev || _cogl_pipeline_layer_and_unit_numbers_equal (prev, pipeline)) return; } if (shader->gl_handle) delete_shader (shader); switch (shader->type) { case COGL_SHADER_TYPE_VERTEX: gl_type = GL_VERTEX_SHADER; break; case COGL_SHADER_TYPE_FRAGMENT: gl_type = GL_FRAGMENT_SHADER; break; default: g_assert_not_reached (); break; } shader->gl_handle = ctx->glCreateShader (gl_type); _cogl_glsl_shader_set_source_with_boilerplate (ctx, shader->gl_handle, gl_type, pipeline, 1, (const char **) &shader->source, NULL); GE (ctx, glCompileShader (shader->gl_handle)); shader->compilation_pipeline = cogl_object_ref (pipeline); GE (ctx, glGetShaderiv (shader->gl_handle, GL_COMPILE_STATUS, &status)); if (!status) { char buffer[512]; int len = 0; ctx->glGetShaderInfoLog (shader->gl_handle, 511, &len, buffer); buffer[len] = '\0'; g_warning ("Failed to compile GLSL program:\n" "src:\n%s\n" "error:\n%s\n", shader->source, buffer); } } }