void _cogl_program_flush_uniforms (CoglProgram *program, GLuint gl_program, gboolean gl_program_changed) { CoglProgramUniform *uniform; int i; _COGL_GET_CONTEXT (ctx, NO_RETVAL); g_return_if_fail (ctx->driver != COGL_DRIVER_GLES1); for (i = 0; i < program->custom_uniforms->len; i++) { uniform = &g_array_index (program->custom_uniforms, CoglProgramUniform, i); if (gl_program_changed || uniform->dirty) { if (gl_program_changed || !uniform->location_valid) { if (_cogl_program_get_language (program) == COGL_SHADER_LANGUAGE_GLSL) uniform->location = ctx->glGetUniformLocation (gl_program, uniform->name); else uniform->location = get_local_param_index (uniform->name); uniform->location_valid = TRUE; } /* If the uniform isn't really in the program then there's no need to actually set it */ if (uniform->location != -1) { switch (_cogl_program_get_language (program)) { case COGL_SHADER_LANGUAGE_GLSL: _cogl_program_flush_uniform_glsl (uniform->location, &uniform->value); break; case COGL_SHADER_LANGUAGE_ARBFP: #ifdef HAVE_COGL_GL _cogl_program_flush_uniform_arbfp (uniform->location, &uniform->value); #endif break; } } uniform->dirty = FALSE; } } }
void cogl_program_attach_shader (CoglHandle program_handle, CoglHandle shader_handle) { CoglProgram *program; CoglShader *shader; _COGL_GET_CONTEXT (ctx, NO_RETVAL); if (!cogl_is_program (program_handle) || !cogl_is_shader (shader_handle)) return; program = _cogl_program_pointer_from_handle (program_handle); shader = _cogl_shader_pointer_from_handle (shader_handle); /* Only one shader is allowed if the type is ARBfp */ if (shader->language == COGL_SHADER_LANGUAGE_ARBFP) g_return_if_fail (program->attached_shaders == NULL); else if (shader->language == COGL_SHADER_LANGUAGE_GLSL) g_return_if_fail (_cogl_program_get_language (program) == COGL_SHADER_LANGUAGE_GLSL); program->attached_shaders = g_slist_prepend (program->attached_shaders, cogl_handle_ref (shader_handle)); program->age++; }
static CoglBool _cogl_pipeline_progend_fixed_arbfp_start (CoglPipeline *pipeline) { CoglHandle user_program; _COGL_GET_CONTEXT (ctx, FALSE); if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_FIXED))) return FALSE; if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED)) return FALSE; /* Vertex snippets are only supported in the GLSL fragend */ if (_cogl_pipeline_has_vertex_snippets (pipeline)) return FALSE; /* Validate that we can handle the fragment state using ARBfp */ if (!cogl_has_feature (ctx, COGL_FEATURE_ID_ARBFP)) return FALSE; /* Fragment snippets are only supported in the GLSL fragend */ if (_cogl_pipeline_has_fragment_snippets (pipeline)) return FALSE; user_program = cogl_pipeline_get_user_program (pipeline); if (user_program && _cogl_program_get_language (user_program) != COGL_SHADER_LANGUAGE_ARBFP) return FALSE; /* The ARBfp progend can't handle the per-vertex point size * attribute */ if (cogl_pipeline_get_per_vertex_point_size (pipeline)) return FALSE; return TRUE; }
static gboolean _cogl_pipeline_vertend_glsl_start (CoglPipeline *pipeline, int n_layers, unsigned long pipelines_difference) { CoglPipelineShaderState *shader_state; CoglPipeline *template_pipeline = NULL; CoglProgram *user_program; _COGL_GET_CONTEXT (ctx, FALSE); if (!cogl_features_available (COGL_FEATURE_SHADERS_GLSL)) return FALSE; user_program = cogl_pipeline_get_user_program (pipeline); /* If the user program has a vertex shader that isn't GLSL then the appropriate vertend for that language should handle it */ if (user_program && _cogl_program_has_vertex_shader (user_program) && _cogl_program_get_language (user_program) != COGL_SHADER_LANGUAGE_GLSL) return FALSE; /* Now lookup our glsl backend private state (allocating if * necessary) */ shader_state = get_shader_state (pipeline); if (shader_state == NULL) { CoglPipeline *authority; /* Get the authority for anything affecting vertex shader state */ authority = _cogl_pipeline_find_equivalent_parent (pipeline, COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN & ~COGL_PIPELINE_STATE_LAYERS, COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN); shader_state = get_shader_state (authority); if (shader_state == NULL) { /* Check if there is already a similar cached pipeline whose shader state we can share */ if (G_LIKELY (!(COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_PROGRAM_CACHES)))) { template_pipeline = _cogl_pipeline_cache_get_vertex_template (ctx->pipeline_cache, authority); shader_state = get_shader_state (template_pipeline); } if (shader_state) shader_state->ref_count++; else shader_state = shader_state_new (); set_shader_state (authority, shader_state); if (template_pipeline) { shader_state->ref_count++; set_shader_state (template_pipeline, shader_state); } } if (authority != pipeline) { shader_state->ref_count++; set_shader_state (pipeline, shader_state); } } if (shader_state->gl_shader) { /* If we already have a valid GLSL shader then we don't need to generate a new one. However if there's a user program and it has changed since the last link then we do need a new shader */ if (user_program == NULL || shader_state->user_program_age == user_program->age) return TRUE; /* We need to recreate the shader so destroy the existing one */ GE( ctx, glDeleteShader (shader_state->gl_shader) ); shader_state->gl_shader = 0; } /* If we make it here then we have a shader_state struct without a gl_shader either because this is the first time we've encountered it or because the user program has changed */ if (user_program) shader_state->user_program_age = user_program->age; /* If the user program contains a vertex shader then we don't need to generate one */ if (user_program && _cogl_program_has_vertex_shader (user_program)) return TRUE; /* We reuse two grow-only GStrings for code-gen. One string contains the uniform and attribute declarations while the other contains the main function. We need two strings because we need to dynamically declare attributes as the add_layer callback is invoked */ g_string_set_size (ctx->codegen_header_buffer, 0); g_string_set_size (ctx->codegen_source_buffer, 0); shader_state->header = ctx->codegen_header_buffer; shader_state->source = ctx->codegen_source_buffer; g_string_append (shader_state->source, "void\n" "main ()\n" "{\n"); if (ctx->driver == COGL_DRIVER_GLES2) /* There is no builtin uniform for the pointsize on GLES2 so we need to copy it from the custom uniform in the vertex shader */ g_string_append (shader_state->source, " cogl_point_size_out = cogl_point_size_in;\n"); /* On regular OpenGL we'll just flush the point size builtin */ else if (pipelines_difference & COGL_PIPELINE_STATE_POINT_SIZE) { CoglPipeline *authority = _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_POINT_SIZE); if (ctx->point_size_cache != authority->big_state->point_size) { GE( ctx, glPointSize (authority->big_state->point_size) ); ctx->point_size_cache = authority->big_state->point_size; } } return TRUE; }