void
cogl_program_use (CoglHandle handle)
{
CoglProgram *program;
GLhandleARB gl_handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (handle != COGL_INVALID_HANDLE && !cogl_is_program (handle))
return;
/* The Cogl journal doesn't currently cope with the use of
* shaders so we have to flush all priitives whenever the
* current shader changes... */
_cogl_journal_flush ();
if (handle == COGL_INVALID_HANDLE)
gl_handle = 0;
else
{
program = _cogl_program_pointer_from_handle (handle);
gl_handle = program->gl_handle;
}
glUseProgramObject (gl_handle);
}
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++;
}
int
cogl_program_get_uniform_location (CoglHandle handle,
const gchar *uniform_name)
{
int i;
CoglProgram *program;
if (!cogl_is_program (handle))
return -1;
program = _cogl_program_pointer_from_handle (handle);
/* We can't just ask the GL program object for the uniform location
directly because it will change every time the program is linked
with a new fixed functionality shader. Instead we make our own
mapping of uniform numbers and cache the names */
for (i = 0; program->custom_uniform_names[i]
&& i < COGL_GLES2_NUM_CUSTOM_UNIFORMS; i++)
if (!strcmp (program->custom_uniform_names[i], uniform_name))
return i;
if (i < COGL_GLES2_NUM_CUSTOM_UNIFORMS)
{
program->custom_uniform_names[i] = g_strdup (uniform_name);
return i;
}
else
/* We've run out of space for new uniform names so just pretend it
isn't there */
return -1;
}
static void
cogl_program_uniform_x (CoglHandle handle,
int uniform_no,
int size,
int count,
CoglBoxedType type,
gsize value_size,
gconstpointer value,
gboolean transpose)
{
CoglProgram *program = handle;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
g_return_if_fail (cogl_is_program (handle));
g_return_if_fail (program != NULL);
if (uniform_no >= 0 && uniform_no < program->custom_uniforms->len &&
size >= 1 && size <= 4 && count >= 1)
{
CoglProgramUniform *uniform =
&g_array_index (program->custom_uniforms,
CoglProgramUniform, uniform_no);
if (count == 1)
{
if (uniform->value.count > 1)
g_free (uniform->value.v.array);
memcpy (uniform->value.v.float_value, value, value_size);
}
else
{
if (uniform->value.count > 1)
{
if (uniform->value.count != count ||
uniform->value.size != size ||
uniform->value.type != type)
{
g_free (uniform->value.v.array);
uniform->value.v.array = g_malloc (count * value_size);
}
}
else
uniform->value.v.array = g_malloc (count * value_size);
memcpy (uniform->value.v.array, value, count * value_size);
}
uniform->value.type = type;
uniform->value.size = size;
uniform->value.count = count;
uniform->dirty = TRUE;
}
}
void
cogl_program_use (CoglHandle handle)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (handle != COGL_INVALID_HANDLE && !cogl_is_program (handle))
return;
ctx->gles2.settings.user_program = handle;
ctx->gles2.settings_dirty = TRUE;
}
void
cogl_program_link (CoglHandle handle)
{
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
if (!cogl_is_program (handle))
return;
program = _cogl_program_pointer_from_handle (handle);
glLinkProgram (program->gl_handle);
}
int
cogl_program_get_uniform_location (CoglHandle handle,
const char *uniform_name)
{
CoglProgram *program;
_COGL_GET_CONTEXT (ctx, 0);
if (!cogl_is_program (handle))
return 0;
program = _cogl_program_pointer_from_handle (handle);
return glGetUniformLocation (program->gl_handle, uniform_name);
}
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);
glAttachObject (program->gl_handle, shader->gl_handle);
}
void
cogl_program_set_uniform_matrix (CoglHandle handle,
int uniform_location,
int dimensions,
int count,
gboolean transpose,
const float *value)
{
g_return_if_fail (cogl_is_program (handle));
cogl_program_uniform_x (handle,
uniform_location, dimensions, count,
COGL_BOXED_MATRIX,
sizeof (float) * dimensions * dimensions,
value,
transpose);
}
void
cogl_program_use (CoglHandle handle)
{
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
g_return_if_fail (handle == COGL_INVALID_HANDLE ||
cogl_is_program (handle));
if (ctx->current_program == 0 && handle != 0)
ctx->legacy_state_set++;
else if (handle == 0 && ctx->current_program != 0)
ctx->legacy_state_set--;
if (handle != COGL_INVALID_HANDLE)
cogl_handle_ref (handle);
if (ctx->current_program != COGL_INVALID_HANDLE)
cogl_handle_unref (ctx->current_program);
ctx->current_program = handle;
}
void
cogl_program_attach_shader (CoglHandle program_handle,
CoglHandle shader_handle)
{
CoglProgram *program;
_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);
program->attached_shaders
= g_slist_prepend (program->attached_shaders,
cogl_handle_ref (shader_handle));
/* Whenever the shader changes we will need to relink the program
with the fixed functionality shaders so we should forget the
cached programs */
_cogl_gles2_clear_cache_for_program (program);
}
int
cogl_program_get_uniform_location (CoglHandle handle,
const char *uniform_name)
{
int i;
CoglProgram *program;
CoglProgramUniform *uniform;
if (!cogl_is_program (handle))
return -1;
program = _cogl_program_pointer_from_handle (handle);
/* We can't just ask the GL program object for the uniform location
directly because it will change every time the program is linked
with a different shader. Instead we make our own mapping of
uniform numbers and cache the names */
for (i = 0; i < program->custom_uniforms->len; i++)
{
uniform = &g_array_index (program->custom_uniforms,
CoglProgramUniform, i);
if (!strcmp (uniform->name, uniform_name))
return i;
}
/* Create a new uniform with the given name */
g_array_set_size (program->custom_uniforms,
program->custom_uniforms->len + 1);
uniform = &g_array_index (program->custom_uniforms,
CoglProgramUniform,
program->custom_uniforms->len - 1);
uniform->name = g_strdup (uniform_name);
memset (&uniform->value, 0, sizeof (CoglBoxedValue));
uniform->dirty = TRUE;
uniform->location_valid = FALSE;
return program->custom_uniforms->len - 1;
}