2010-12-02 14:00:46 +00:00
|
|
|
/*
|
|
|
|
* Cogl
|
|
|
|
*
|
|
|
|
* An object oriented GL/GLES Abstraction/Utility Layer
|
|
|
|
*
|
|
|
|
* Copyright (C) 2010 Intel Corporation.
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library. If not, see
|
|
|
|
* <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Neil Roberts <neil@linux.intel.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2011-09-23 08:43:05 +00:00
|
|
|
#include "cogl-context-private.h"
|
2010-12-02 14:00:46 +00:00
|
|
|
#include "cogl-pipeline-private.h"
|
|
|
|
#include "cogl-pipeline-opengl-private.h"
|
|
|
|
|
|
|
|
#ifdef COGL_PIPELINE_PROGEND_GLSL
|
|
|
|
|
|
|
|
#include "cogl.h"
|
|
|
|
#include "cogl-internal.h"
|
2010-11-04 22:25:52 +00:00
|
|
|
#include "cogl-context-private.h"
|
2010-12-02 14:00:46 +00:00
|
|
|
#include "cogl-handle.h"
|
|
|
|
#include "cogl-program-private.h"
|
|
|
|
#include "cogl-pipeline-fragend-glsl-private.h"
|
2010-12-02 20:48:45 +00:00
|
|
|
#include "cogl-pipeline-vertend-glsl-private.h"
|
2011-06-30 17:34:05 +00:00
|
|
|
#include "cogl-pipeline-cache.h"
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
#ifdef HAVE_COGL_GLES2
|
2011-01-13 18:24:22 +00:00
|
|
|
|
|
|
|
/* These are used to generalise updating some uniforms that are
|
|
|
|
required when building for GLES2 */
|
|
|
|
|
|
|
|
typedef void (* UpdateUniformFunc) (CoglPipeline *pipeline,
|
|
|
|
int uniform_location,
|
|
|
|
void *getter_func);
|
|
|
|
|
|
|
|
static void update_float_uniform (CoglPipeline *pipeline,
|
|
|
|
int uniform_location,
|
|
|
|
void *getter_func);
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
const char *uniform_name;
|
|
|
|
void *getter_func;
|
|
|
|
UpdateUniformFunc update_func;
|
|
|
|
CoglPipelineState change;
|
|
|
|
} BuiltinUniformData;
|
|
|
|
|
|
|
|
static BuiltinUniformData builtin_uniforms[] =
|
|
|
|
{
|
|
|
|
{ "cogl_point_size_in",
|
|
|
|
cogl_pipeline_get_point_size, update_float_uniform,
|
|
|
|
COGL_PIPELINE_STATE_POINT_SIZE },
|
|
|
|
{ "_cogl_alpha_test_ref",
|
|
|
|
cogl_pipeline_get_alpha_test_reference, update_float_uniform,
|
|
|
|
COGL_PIPELINE_STATE_ALPHA_FUNC_REFERENCE }
|
|
|
|
};
|
|
|
|
|
2010-12-02 14:00:46 +00:00
|
|
|
#endif /* HAVE_COGL_GLES2 */
|
|
|
|
|
|
|
|
const CoglPipelineProgend _cogl_pipeline_glsl_progend;
|
|
|
|
|
|
|
|
typedef struct _UnitState
|
|
|
|
{
|
|
|
|
unsigned int dirty_combine_constant:1;
|
2010-12-06 12:31:51 +00:00
|
|
|
unsigned int dirty_texture_matrix:1;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
GLint combine_constant_uniform;
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
GLint texture_matrix_uniform;
|
2010-12-02 14:00:46 +00:00
|
|
|
} UnitState;
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
unsigned int ref_count;
|
|
|
|
|
|
|
|
/* Age that the user program had last time we generated a GL
|
|
|
|
program. If it's different then we need to relink the program */
|
|
|
|
unsigned int user_program_age;
|
|
|
|
|
|
|
|
GLuint program;
|
|
|
|
|
|
|
|
/* To allow writing shaders that are portable between GLES 2 and
|
|
|
|
* OpenGL Cogl prepends a number of boilerplate #defines and
|
|
|
|
* declarations to user shaders. One of those declarations is an
|
|
|
|
* array of texture coordinate varyings, but to know how to emit the
|
|
|
|
* declaration we need to know how many texture coordinate
|
|
|
|
* attributes are in use. The boilerplate also needs to be changed
|
|
|
|
* if this increases. */
|
|
|
|
int n_tex_coord_attribs;
|
|
|
|
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
2011-01-13 18:24:22 +00:00
|
|
|
unsigned long dirty_builtin_uniforms;
|
|
|
|
GLint builtin_uniform_locations[G_N_ELEMENTS (builtin_uniforms)];
|
2010-12-03 17:46:16 +00:00
|
|
|
|
|
|
|
/* Under GLES2 we can't use the builtin functions to set attribute
|
|
|
|
pointers such as the vertex position. Instead the vertex
|
|
|
|
attribute code needs to query the attribute numbers from the
|
|
|
|
progend backend */
|
|
|
|
int position_attribute_location;
|
|
|
|
int color_attribute_location;
|
|
|
|
int normal_attribute_location;
|
|
|
|
int tex_coord0_attribute_location;
|
|
|
|
/* We only allocate this array if more than one tex coord attribute
|
|
|
|
is requested because most pipelines will only use one layer */
|
|
|
|
GArray *tex_coord_attribute_locations;
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
GLint modelview_uniform;
|
|
|
|
GLint projection_uniform;
|
|
|
|
GLint mvp_uniform;
|
|
|
|
|
|
|
|
CoglMatrixStack *flushed_modelview_stack;
|
|
|
|
unsigned int flushed_modelview_stack_age;
|
|
|
|
gboolean flushed_modelview_is_identity;
|
|
|
|
CoglMatrixStack *flushed_projection_stack;
|
|
|
|
unsigned int flushed_projection_stack_age;
|
2010-12-02 14:00:46 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* We need to track the last pipeline that the program was used with
|
|
|
|
* so know if we need to update all of the uniforms */
|
|
|
|
CoglPipeline *last_used_for_pipeline;
|
|
|
|
|
|
|
|
UnitState *unit_state;
|
2011-06-30 12:39:48 +00:00
|
|
|
} CoglPipelineProgramState;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
static CoglUserDataKey program_state_key;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
static CoglPipelineProgramState *
|
|
|
|
get_program_state (CoglPipeline *pipeline)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
return cogl_object_get_user_data (COGL_OBJECT (pipeline), &program_state_key);
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
2010-12-03 17:46:16 +00:00
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
|
|
|
|
#define ATTRIBUTE_LOCATION_UNKNOWN -2
|
|
|
|
|
|
|
|
/* Under GLES2 the vertex attribute API needs to query the attribute
|
|
|
|
numbers because it can't used the fixed function API to set the
|
|
|
|
builtin attributes. We cache the attributes here because the
|
|
|
|
progend knows when the program is changed so it can clear the
|
|
|
|
cache. This should always be called after the pipeline is flushed
|
|
|
|
so they can assert that the gl program is valid */
|
|
|
|
|
|
|
|
int
|
|
|
|
_cogl_pipeline_progend_glsl_get_position_attribute (CoglPipeline *pipeline)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (pipeline);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, -1);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
g_return_val_if_fail (program_state != NULL, -1);
|
|
|
|
g_return_val_if_fail (program_state->program != 0, -1);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->position_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN)
|
|
|
|
GE_RET( program_state->position_attribute_location,
|
|
|
|
ctx, glGetAttribLocation (program_state->program,
|
|
|
|
"cogl_position_in") );
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
return program_state->position_attribute_location;
|
2010-12-03 17:46:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_cogl_pipeline_progend_glsl_get_color_attribute (CoglPipeline *pipeline)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (pipeline);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, -1);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
g_return_val_if_fail (program_state != NULL, -1);
|
|
|
|
g_return_val_if_fail (program_state->program != 0, -1);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->color_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN)
|
|
|
|
GE_RET( program_state->color_attribute_location,
|
|
|
|
ctx, glGetAttribLocation (program_state->program,
|
|
|
|
"cogl_color_in") );
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
return program_state->color_attribute_location;
|
2010-12-03 17:46:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_cogl_pipeline_progend_glsl_get_normal_attribute (CoglPipeline *pipeline)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (pipeline);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, -1);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
g_return_val_if_fail (program_state != NULL, -1);
|
|
|
|
g_return_val_if_fail (program_state->program != 0, -1);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->normal_attribute_location == ATTRIBUTE_LOCATION_UNKNOWN)
|
|
|
|
GE_RET( program_state->normal_attribute_location,
|
|
|
|
ctx, glGetAttribLocation (program_state->program,
|
|
|
|
"cogl_normal_in") );
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
return program_state->normal_attribute_location;
|
2010-12-03 17:46:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_cogl_pipeline_progend_glsl_get_tex_coord_attribute (CoglPipeline *pipeline,
|
|
|
|
int unit)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (pipeline);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, -1);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
g_return_val_if_fail (program_state != NULL, -1);
|
|
|
|
g_return_val_if_fail (program_state->program != 0, -1);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
|
|
|
if (unit == 0)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->tex_coord0_attribute_location ==
|
|
|
|
ATTRIBUTE_LOCATION_UNKNOWN)
|
|
|
|
GE_RET( program_state->tex_coord0_attribute_location,
|
|
|
|
ctx, glGetAttribLocation (program_state->program,
|
2011-07-06 20:51:00 +00:00
|
|
|
"cogl_tex_coord0_in") );
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
return program_state->tex_coord0_attribute_location;
|
2010-12-03 17:46:16 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char *name = g_strdup_printf ("cogl_tex_coord%i_in", unit);
|
|
|
|
int *locations;
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->tex_coord_attribute_locations == NULL)
|
|
|
|
program_state->tex_coord_attribute_locations =
|
|
|
|
g_array_new (FALSE, FALSE, sizeof (int));
|
|
|
|
if (program_state->tex_coord_attribute_locations->len <= unit - 1)
|
2010-12-03 17:46:16 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
int i = program_state->tex_coord_attribute_locations->len;
|
|
|
|
g_array_set_size (program_state->tex_coord_attribute_locations, unit);
|
2010-12-03 17:46:16 +00:00
|
|
|
for (; i < unit; i++)
|
2011-06-30 12:39:48 +00:00
|
|
|
g_array_index (program_state->tex_coord_attribute_locations, int, i)
|
|
|
|
= ATTRIBUTE_LOCATION_UNKNOWN;
|
2010-12-03 17:46:16 +00:00
|
|
|
}
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
locations = &g_array_index (program_state->tex_coord_attribute_locations,
|
|
|
|
int, 0);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
|
|
|
if (locations[unit - 1] == ATTRIBUTE_LOCATION_UNKNOWN)
|
|
|
|
GE_RET( locations[unit - 1],
|
2011-06-30 12:39:48 +00:00
|
|
|
ctx, glGetAttribLocation (program_state->program, name) );
|
2010-12-03 17:46:16 +00:00
|
|
|
|
|
|
|
g_free (name);
|
|
|
|
|
|
|
|
return locations[unit - 1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-30 12:39:48 +00:00
|
|
|
clear_attribute_cache (CoglPipelineProgramState *program_state)
|
2010-12-03 17:46:16 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->position_attribute_location = ATTRIBUTE_LOCATION_UNKNOWN;
|
|
|
|
program_state->color_attribute_location = ATTRIBUTE_LOCATION_UNKNOWN;
|
|
|
|
program_state->normal_attribute_location = ATTRIBUTE_LOCATION_UNKNOWN;
|
|
|
|
program_state->tex_coord0_attribute_location = ATTRIBUTE_LOCATION_UNKNOWN;
|
|
|
|
if (program_state->tex_coord_attribute_locations)
|
2010-12-03 17:46:16 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
g_array_free (program_state->tex_coord_attribute_locations, TRUE);
|
|
|
|
program_state->tex_coord_attribute_locations = NULL;
|
2010-12-03 17:46:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-06 12:31:51 +00:00
|
|
|
static void
|
2011-06-30 12:39:48 +00:00
|
|
|
clear_flushed_matrix_stacks (CoglPipelineProgramState *program_state)
|
2010-12-06 12:31:51 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->flushed_modelview_stack)
|
2010-12-06 12:31:51 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
cogl_object_unref (program_state->flushed_modelview_stack);
|
|
|
|
program_state->flushed_modelview_stack = NULL;
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->flushed_projection_stack)
|
2010-12-06 12:31:51 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
cogl_object_unref (program_state->flushed_projection_stack);
|
|
|
|
program_state->flushed_projection_stack = NULL;
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->flushed_modelview_is_identity = FALSE;
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
|
2010-12-03 17:46:16 +00:00
|
|
|
#endif /* HAVE_COGL_GLES2 */
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
static CoglPipelineProgramState *
|
|
|
|
program_state_new (int n_layers)
|
|
|
|
{
|
|
|
|
CoglPipelineProgramState *program_state;
|
|
|
|
|
|
|
|
program_state = g_slice_new (CoglPipelineProgramState);
|
|
|
|
program_state->ref_count = 1;
|
|
|
|
program_state->program = 0;
|
|
|
|
program_state->n_tex_coord_attribs = 0;
|
|
|
|
program_state->unit_state = g_new (UnitState, n_layers);
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
program_state->tex_coord_attribute_locations = NULL;
|
|
|
|
program_state->flushed_modelview_stack = NULL;
|
|
|
|
program_state->flushed_modelview_is_identity = FALSE;
|
|
|
|
program_state->flushed_projection_stack = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return program_state;
|
|
|
|
}
|
|
|
|
|
2010-12-02 14:00:46 +00:00
|
|
|
static void
|
2011-10-23 19:22:23 +00:00
|
|
|
destroy_program_state (void *user_data,
|
|
|
|
void *instance)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = user_data;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2010-12-05 18:02:05 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-10-23 19:22:23 +00:00
|
|
|
/* If the program state was last used for this pipeline then clear
|
|
|
|
it so that if same address gets used again for a new pipeline
|
|
|
|
then we won't think it's the same pipeline and avoid updating the
|
|
|
|
uniforms */
|
|
|
|
if (program_state->last_used_for_pipeline == instance)
|
|
|
|
program_state->last_used_for_pipeline = NULL;
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (--program_state->ref_count == 0)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2010-12-03 17:46:16 +00:00
|
|
|
#ifdef HAVE_COGL_GLES2
|
2011-07-07 19:44:56 +00:00
|
|
|
if (ctx->driver == COGL_DRIVER_GLES2)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
clear_attribute_cache (program_state);
|
|
|
|
clear_flushed_matrix_stacks (program_state);
|
2011-07-07 19:44:56 +00:00
|
|
|
}
|
2010-12-03 17:46:16 +00:00
|
|
|
#endif
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->program)
|
|
|
|
GE( ctx, glDeleteProgram (program_state->program) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
g_free (program_state->unit_state);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
g_slice_free (CoglPipelineProgramState, program_state);
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-30 12:39:48 +00:00
|
|
|
set_program_state (CoglPipeline *pipeline,
|
|
|
|
CoglPipelineProgramState *program_state)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-10-23 19:22:23 +00:00
|
|
|
_cogl_object_set_user_data (COGL_OBJECT (pipeline),
|
|
|
|
&program_state_key,
|
|
|
|
program_state,
|
|
|
|
destroy_program_state);
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-30 12:39:48 +00:00
|
|
|
dirty_program_state (CoglPipeline *pipeline)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
|
|
|
cogl_object_set_user_data (COGL_OBJECT (pipeline),
|
2011-06-30 12:39:48 +00:00
|
|
|
&program_state_key,
|
2010-12-02 14:00:46 +00:00
|
|
|
NULL,
|
2011-06-30 12:39:48 +00:00
|
|
|
NULL);
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
link_program (GLint gl_program)
|
|
|
|
{
|
|
|
|
GLint link_status;
|
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
GE( ctx, glLinkProgram (gl_program) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
GE( ctx, glGetProgramiv (gl_program, GL_LINK_STATUS, &link_status) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
if (!link_status)
|
|
|
|
{
|
|
|
|
GLint log_length;
|
|
|
|
GLsizei out_log_length;
|
|
|
|
char *log;
|
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
GE( ctx, glGetProgramiv (gl_program, GL_INFO_LOG_LENGTH, &log_length) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
log = g_malloc (log_length);
|
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
GE( ctx, glGetProgramInfoLog (gl_program, log_length,
|
|
|
|
&out_log_length, log) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
g_warning ("Failed to link GLSL program:\n%.*s\n",
|
|
|
|
log_length, log);
|
|
|
|
|
|
|
|
g_free (log);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
int unit;
|
|
|
|
GLuint gl_program;
|
|
|
|
gboolean update_all;
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state;
|
2010-12-02 14:00:46 +00:00
|
|
|
} UpdateUniformsState;
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
get_uniform_cb (CoglPipeline *pipeline,
|
|
|
|
int layer_index,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
UpdateUniformsState *state = user_data;
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = state->program_state;
|
|
|
|
UnitState *unit_state = &program_state->unit_state[state->unit];
|
2010-12-02 14:00:46 +00:00
|
|
|
GLint uniform_location;
|
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, FALSE);
|
|
|
|
|
|
|
|
/* We can reuse the source buffer to create the uniform name because
|
|
|
|
the program has now been linked */
|
2010-12-02 18:05:22 +00:00
|
|
|
g_string_set_size (ctx->codegen_source_buffer, 0);
|
|
|
|
g_string_append_printf (ctx->codegen_source_buffer,
|
2010-12-02 14:00:46 +00:00
|
|
|
"_cogl_sampler_%i", state->unit);
|
|
|
|
|
|
|
|
GE_RET( uniform_location,
|
2011-07-06 20:51:00 +00:00
|
|
|
ctx, glGetUniformLocation (state->gl_program,
|
|
|
|
ctx->codegen_source_buffer->str) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
/* We can set the uniform immediately because the samplers are the
|
|
|
|
unit index not the texture object number so it will never
|
|
|
|
change. Unfortunately GL won't let us use a constant instead of a
|
|
|
|
uniform */
|
|
|
|
if (uniform_location != -1)
|
2011-07-06 20:51:00 +00:00
|
|
|
GE( ctx, glUniform1i (uniform_location, state->unit) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2010-12-02 18:05:22 +00:00
|
|
|
g_string_set_size (ctx->codegen_source_buffer, 0);
|
|
|
|
g_string_append_printf (ctx->codegen_source_buffer,
|
2010-12-02 14:00:46 +00:00
|
|
|
"_cogl_layer_constant_%i", state->unit);
|
|
|
|
|
|
|
|
GE_RET( uniform_location,
|
2011-07-06 20:51:00 +00:00
|
|
|
ctx, glGetUniformLocation (state->gl_program,
|
|
|
|
ctx->codegen_source_buffer->str) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
unit_state->combine_constant_uniform = uniform_location;
|
|
|
|
|
2010-12-06 12:31:51 +00:00
|
|
|
#ifdef HAVE_COGL_GLES2
|
2011-07-07 19:44:56 +00:00
|
|
|
if (ctx->driver == COGL_DRIVER_GLES2)
|
|
|
|
{
|
|
|
|
g_string_set_size (ctx->codegen_source_buffer, 0);
|
|
|
|
g_string_append_printf (ctx->codegen_source_buffer,
|
|
|
|
"cogl_texture_matrix[%i]", state->unit);
|
2010-12-06 12:31:51 +00:00
|
|
|
|
2011-07-07 19:44:56 +00:00
|
|
|
GE_RET( uniform_location,
|
|
|
|
ctx, glGetUniformLocation (state->gl_program,
|
|
|
|
ctx->codegen_source_buffer->str) );
|
2010-12-06 12:31:51 +00:00
|
|
|
|
2011-07-07 19:44:56 +00:00
|
|
|
unit_state->texture_matrix_uniform = uniform_location;
|
|
|
|
}
|
2010-12-06 12:31:51 +00:00
|
|
|
#endif
|
|
|
|
|
2010-12-02 14:00:46 +00:00
|
|
|
state->unit++;
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
update_constants_cb (CoglPipeline *pipeline,
|
|
|
|
int layer_index,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
UpdateUniformsState *state = user_data;
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = state->program_state;
|
|
|
|
UnitState *unit_state = &program_state->unit_state[state->unit++];
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, FALSE);
|
|
|
|
|
|
|
|
if (unit_state->combine_constant_uniform != -1 &&
|
|
|
|
(state->update_all || unit_state->dirty_combine_constant))
|
|
|
|
{
|
|
|
|
float constant[4];
|
|
|
|
_cogl_pipeline_get_layer_combine_constant (pipeline,
|
|
|
|
layer_index,
|
|
|
|
constant);
|
2011-07-06 20:51:00 +00:00
|
|
|
GE (ctx, glUniform4fv (unit_state->combine_constant_uniform,
|
|
|
|
1, constant));
|
2010-12-02 14:00:46 +00:00
|
|
|
unit_state->dirty_combine_constant = FALSE;
|
|
|
|
}
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
|
2011-07-07 19:44:56 +00:00
|
|
|
if (ctx->driver == COGL_DRIVER_GLES2 &&
|
|
|
|
unit_state->texture_matrix_uniform != -1 &&
|
2010-12-06 12:31:51 +00:00
|
|
|
(state->update_all || unit_state->dirty_texture_matrix))
|
|
|
|
{
|
|
|
|
const CoglMatrix *matrix;
|
|
|
|
const float *array;
|
|
|
|
|
|
|
|
matrix = _cogl_pipeline_get_layer_matrix (pipeline, layer_index);
|
|
|
|
array = cogl_matrix_get_array (matrix);
|
2011-07-06 20:51:00 +00:00
|
|
|
GE (ctx, glUniformMatrix4fv (unit_state->texture_matrix_uniform,
|
|
|
|
1, FALSE, array));
|
2010-12-06 12:31:51 +00:00
|
|
|
unit_state->dirty_texture_matrix = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* HAVE_COGL_GLES2 */
|
|
|
|
|
2010-12-02 14:00:46 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
|
|
|
|
static void
|
2011-01-13 18:24:22 +00:00
|
|
|
update_builtin_uniforms (CoglPipeline *pipeline,
|
|
|
|
GLuint gl_program,
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-01-13 18:24:22 +00:00
|
|
|
int i;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->dirty_builtin_uniforms == 0)
|
2011-01-13 18:24:22 +00:00
|
|
|
return;
|
2010-12-02 20:48:45 +00:00
|
|
|
|
2011-01-13 18:24:22 +00:00
|
|
|
for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++)
|
2011-06-30 12:39:48 +00:00
|
|
|
if ((program_state->dirty_builtin_uniforms & (1 << i)) &&
|
|
|
|
program_state->builtin_uniform_locations[i] != -1)
|
2011-01-13 18:24:22 +00:00
|
|
|
builtin_uniforms[i].update_func (pipeline,
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state
|
|
|
|
->builtin_uniform_locations[i],
|
2011-01-13 18:24:22 +00:00
|
|
|
builtin_uniforms[i].getter_func);
|
2010-12-02 20:48:45 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->dirty_builtin_uniforms = 0;
|
2010-12-02 20:48:45 +00:00
|
|
|
}
|
|
|
|
|
2010-12-02 14:00:46 +00:00
|
|
|
#endif /* HAVE_COGL_GLES2 */
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cogl_pipeline_progend_glsl_end (CoglPipeline *pipeline,
|
|
|
|
unsigned long pipelines_difference,
|
|
|
|
int n_tex_coord_attribs)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state;
|
2010-12-02 14:00:46 +00:00
|
|
|
GLuint gl_program;
|
|
|
|
gboolean program_changed = FALSE;
|
|
|
|
UpdateUniformsState state;
|
|
|
|
CoglProgram *user_program;
|
2011-06-30 17:34:05 +00:00
|
|
|
CoglPipeline *template_pipeline = NULL;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
|
|
|
/* If neither of the glsl fragend or vertends are used then we don't
|
|
|
|
need to do anything */
|
2010-12-02 20:48:45 +00:00
|
|
|
if (pipeline->fragend != COGL_PIPELINE_FRAGEND_GLSL &&
|
|
|
|
pipeline->vertend != COGL_PIPELINE_VERTEND_GLSL)
|
2010-12-02 14:00:46 +00:00
|
|
|
return;
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state = get_program_state (pipeline);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
user_program = cogl_pipeline_get_user_program (pipeline);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state == NULL)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
|
|
|
CoglPipeline *authority;
|
|
|
|
|
|
|
|
/* Get the authority for anything affecting program state. This
|
|
|
|
should include both fragment codegen state and vertex codegen
|
|
|
|
state */
|
|
|
|
authority = _cogl_pipeline_find_equivalent_parent
|
|
|
|
(pipeline,
|
2010-12-02 20:48:45 +00:00
|
|
|
(COGL_PIPELINE_STATE_AFFECTS_VERTEX_CODEGEN |
|
2011-07-07 19:44:56 +00:00
|
|
|
_cogl_pipeline_get_state_for_fragment_codegen (ctx)) &
|
2010-12-02 14:00:46 +00:00
|
|
|
~COGL_PIPELINE_STATE_LAYERS,
|
2011-07-07 19:44:56 +00:00
|
|
|
_cogl_pipeline_get_layer_state_for_fragment_codegen (ctx) |
|
2011-01-11 16:02:06 +00:00
|
|
|
COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state = get_program_state (authority);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state == NULL)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-06-30 17:34:05 +00:00
|
|
|
/* Check if there is already a similar cached pipeline whose
|
|
|
|
program state we can share */
|
|
|
|
if (G_LIKELY (!(COGL_DEBUG_ENABLED
|
|
|
|
(COGL_DEBUG_DISABLE_PROGRAM_CACHES))))
|
|
|
|
{
|
|
|
|
template_pipeline =
|
|
|
|
_cogl_pipeline_cache_get_combined_template (ctx->pipeline_cache,
|
|
|
|
authority);
|
|
|
|
|
|
|
|
program_state = get_program_state (template_pipeline);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (program_state)
|
|
|
|
program_state->ref_count++;
|
|
|
|
else
|
|
|
|
program_state
|
|
|
|
= program_state_new (cogl_pipeline_get_n_layers (authority));
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
set_program_state (authority, program_state);
|
2011-06-30 17:34:05 +00:00
|
|
|
|
|
|
|
if (template_pipeline)
|
|
|
|
{
|
|
|
|
program_state->ref_count++;
|
|
|
|
set_program_state (template_pipeline, program_state);
|
|
|
|
}
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (authority != pipeline)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->ref_count++;
|
|
|
|
set_program_state (pipeline, program_state);
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the program has changed since the last link then we do
|
|
|
|
* need to relink
|
|
|
|
*
|
|
|
|
* Also if the number of texture coordinate attributes in use has
|
|
|
|
* increased, then delete the program so we can prepend a new
|
|
|
|
* _cogl_tex_coord[] varying array declaration. */
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->program && user_program &&
|
|
|
|
(user_program->age != program_state->user_program_age ||
|
|
|
|
n_tex_coord_attribs > program_state->n_tex_coord_attribs))
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glDeleteProgram (program_state->program) );
|
|
|
|
program_state->program = 0;
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->program == 0)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
|
|
|
GLuint backend_shader;
|
|
|
|
GSList *l;
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE_RET( program_state->program, ctx, glCreateProgram () );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
/* Attach all of the shader from the user program */
|
|
|
|
if (user_program)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->n_tex_coord_attribs > n_tex_coord_attribs)
|
|
|
|
n_tex_coord_attribs = program_state->n_tex_coord_attribs;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
/* Find the largest count of texture coordinate attributes
|
|
|
|
* associated with each of the shaders so we can ensure a consistent
|
|
|
|
* _cogl_tex_coord[] array declaration across all of the shaders.*/
|
2011-07-07 19:44:56 +00:00
|
|
|
if (ctx->driver == COGL_DRIVER_GLES2 &&
|
|
|
|
user_program)
|
2010-12-02 14:00:46 +00:00
|
|
|
for (l = user_program->attached_shaders; l; l = l->next)
|
|
|
|
{
|
|
|
|
CoglShader *shader = l->data;
|
|
|
|
n_tex_coord_attribs = MAX (shader->n_tex_coord_attribs,
|
|
|
|
n_tex_coord_attribs);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for (l = user_program->attached_shaders; l; l = l->next)
|
|
|
|
{
|
|
|
|
CoglShader *shader = l->data;
|
|
|
|
|
|
|
|
_cogl_shader_compile_real (shader, n_tex_coord_attribs);
|
|
|
|
|
|
|
|
g_assert (shader->language == COGL_SHADER_LANGUAGE_GLSL);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glAttachShader (program_state->program,
|
2011-07-06 20:51:00 +00:00
|
|
|
shader->gl_handle) );
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->user_program_age = user_program->age;
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Attach any shaders from the GLSL backends */
|
|
|
|
if (pipeline->fragend == COGL_PIPELINE_FRAGEND_GLSL &&
|
|
|
|
(backend_shader = _cogl_pipeline_fragend_glsl_get_shader (pipeline)))
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glAttachShader (program_state->program, backend_shader) );
|
2010-12-02 20:48:45 +00:00
|
|
|
if (pipeline->vertend == COGL_PIPELINE_VERTEND_GLSL &&
|
|
|
|
(backend_shader = _cogl_pipeline_vertend_glsl_get_shader (pipeline)))
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glAttachShader (program_state->program, backend_shader) );
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
link_program (program_state->program);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
program_changed = TRUE;
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->n_tex_coord_attribs = n_tex_coord_attribs;
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
gl_program = program_state->program;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2010-12-02 20:48:45 +00:00
|
|
|
if (pipeline->fragend == COGL_PIPELINE_FRAGEND_GLSL)
|
|
|
|
_cogl_use_fragment_program (gl_program, COGL_PIPELINE_PROGRAM_TYPE_GLSL);
|
|
|
|
if (pipeline->vertend == COGL_PIPELINE_VERTEND_GLSL)
|
|
|
|
_cogl_use_vertex_program (gl_program, COGL_PIPELINE_PROGRAM_TYPE_GLSL);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
state.unit = 0;
|
|
|
|
state.gl_program = gl_program;
|
2011-06-30 12:39:48 +00:00
|
|
|
state.program_state = program_state;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
if (program_changed)
|
|
|
|
cogl_pipeline_foreach_layer (pipeline,
|
|
|
|
get_uniform_cb,
|
|
|
|
&state);
|
|
|
|
|
|
|
|
state.unit = 0;
|
|
|
|
state.update_all = (program_changed ||
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->last_used_for_pipeline != pipeline);
|
2010-12-02 14:00:46 +00:00
|
|
|
|
|
|
|
cogl_pipeline_foreach_layer (pipeline,
|
|
|
|
update_constants_cb,
|
|
|
|
&state);
|
|
|
|
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
2011-07-07 19:44:56 +00:00
|
|
|
if (ctx->driver == COGL_DRIVER_GLES2)
|
2010-12-02 20:48:45 +00:00
|
|
|
{
|
2011-07-07 19:44:56 +00:00
|
|
|
if (program_changed)
|
|
|
|
{
|
|
|
|
int i;
|
2011-01-13 18:24:22 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
clear_attribute_cache (program_state);
|
|
|
|
clear_flushed_matrix_stacks (program_state);
|
2010-12-03 17:46:16 +00:00
|
|
|
|
2011-07-07 19:44:56 +00:00
|
|
|
for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++)
|
2011-06-30 12:39:48 +00:00
|
|
|
GE_RET( program_state->builtin_uniform_locations[i], ctx,
|
2011-07-07 19:44:56 +00:00
|
|
|
glGetUniformLocation (gl_program,
|
|
|
|
builtin_uniforms[i].uniform_name) );
|
2010-12-02 20:48:45 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE_RET( program_state->modelview_uniform, ctx,
|
|
|
|
glGetUniformLocation (gl_program,
|
|
|
|
"cogl_modelview_matrix") );
|
2010-12-06 12:31:51 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE_RET( program_state->projection_uniform, ctx,
|
|
|
|
glGetUniformLocation (gl_program,
|
|
|
|
"cogl_projection_matrix") );
|
2010-12-06 12:31:51 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE_RET( program_state->mvp_uniform, ctx,
|
2011-07-07 19:44:56 +00:00
|
|
|
glGetUniformLocation (gl_program,
|
|
|
|
"cogl_modelview_projection_matrix") );
|
|
|
|
}
|
|
|
|
if (program_changed ||
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->last_used_for_pipeline != pipeline)
|
|
|
|
program_state->dirty_builtin_uniforms = ~(unsigned long) 0;
|
2010-12-02 14:00:46 +00:00
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
update_builtin_uniforms (pipeline, gl_program, program_state);
|
2011-07-07 19:44:56 +00:00
|
|
|
}
|
2010-12-02 14:00:46 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (user_program)
|
|
|
|
_cogl_program_flush_uniforms (user_program,
|
|
|
|
gl_program,
|
|
|
|
program_changed);
|
|
|
|
|
|
|
|
/* We need to track the last pipeline that the program was used with
|
|
|
|
* so know if we need to update all of the uniforms */
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->last_used_for_pipeline = pipeline;
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cogl_pipeline_progend_glsl_pre_change_notify (CoglPipeline *pipeline,
|
|
|
|
CoglPipelineState change,
|
|
|
|
const CoglColor *new_color)
|
|
|
|
{
|
2011-07-07 19:44:56 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
|
|
|
if ((change & _cogl_pipeline_get_state_for_fragment_codegen (ctx)))
|
2011-06-30 12:39:48 +00:00
|
|
|
dirty_program_state (pipeline);
|
|
|
|
|
2010-12-02 20:48:45 +00:00
|
|
|
#ifdef HAVE_COGL_GLES2
|
2011-07-07 19:44:56 +00:00
|
|
|
else if (ctx->driver == COGL_DRIVER_GLES2)
|
2010-12-02 20:48:45 +00:00
|
|
|
{
|
2011-01-13 18:24:22 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (builtin_uniforms); i++)
|
|
|
|
if ((change & builtin_uniforms[i].change))
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state
|
|
|
|
= get_program_state (pipeline);
|
|
|
|
if (program_state)
|
|
|
|
program_state->dirty_builtin_uniforms |= 1 << i;
|
2011-01-13 18:24:22 +00:00
|
|
|
return;
|
|
|
|
}
|
2010-12-02 20:48:45 +00:00
|
|
|
}
|
|
|
|
#endif /* HAVE_COGL_GLES2 */
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* NB: layers are considered immutable once they have any dependants
|
|
|
|
* so although multiple pipelines can end up depending on a single
|
|
|
|
* static layer, we can guarantee that if a layer is being *changed*
|
|
|
|
* then it can only have one pipeline depending on it.
|
|
|
|
*
|
|
|
|
* XXX: Don't forget this is *pre* change, we can't read the new value
|
|
|
|
* yet!
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
_cogl_pipeline_progend_glsl_layer_pre_change_notify (
|
|
|
|
CoglPipeline *owner,
|
|
|
|
CoglPipelineLayer *layer,
|
|
|
|
CoglPipelineLayerState change)
|
|
|
|
{
|
2011-07-07 19:44:56 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
|
|
|
if ((change & _cogl_pipeline_get_state_for_fragment_codegen (ctx)))
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
dirty_program_state (owner);
|
2010-12-02 14:00:46 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (change & COGL_PIPELINE_LAYER_STATE_COMBINE_CONSTANT)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (owner);
|
|
|
|
if (program_state)
|
2010-12-02 14:00:46 +00:00
|
|
|
{
|
|
|
|
int unit_index = _cogl_pipeline_layer_get_unit_index (layer);
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->unit_state[unit_index].dirty_combine_constant = TRUE;
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
}
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
if (change & COGL_PIPELINE_LAYER_STATE_USER_MATRIX)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (owner);
|
|
|
|
if (program_state)
|
2010-12-06 12:31:51 +00:00
|
|
|
{
|
|
|
|
int unit_index = _cogl_pipeline_layer_get_unit_index (layer);
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->unit_state[unit_index].dirty_texture_matrix = TRUE;
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
|
|
|
|
static void
|
|
|
|
flush_modelview_cb (gboolean is_identity,
|
|
|
|
const CoglMatrix *matrix,
|
|
|
|
void *user_data)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = user_data;
|
2010-12-06 12:31:51 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glUniformMatrix4fv (program_state->modelview_uniform, 1, FALSE,
|
2011-07-06 20:51:00 +00:00
|
|
|
cogl_matrix_get_array (matrix)) );
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
flush_projection_cb (gboolean is_identity,
|
|
|
|
const CoglMatrix *matrix,
|
|
|
|
void *user_data)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = user_data;
|
2010-12-06 12:31:51 +00:00
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glUniformMatrix4fv (program_state->projection_uniform, 1, FALSE,
|
2011-07-06 20:51:00 +00:00
|
|
|
cogl_matrix_get_array (matrix)) );
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state;
|
2010-12-06 12:31:51 +00:00
|
|
|
const CoglMatrix *projection_matrix;
|
|
|
|
} FlushCombinedData;
|
|
|
|
|
|
|
|
static void
|
|
|
|
flush_combined_step_two_cb (gboolean is_identity,
|
|
|
|
const CoglMatrix *matrix,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
FlushCombinedData *data = user_data;
|
|
|
|
CoglMatrix mvp_matrix;
|
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2010-12-06 12:31:51 +00:00
|
|
|
/* If the modelview is the identity then we can bypass the matrix
|
|
|
|
multiplication */
|
|
|
|
if (is_identity)
|
2011-07-06 20:51:00 +00:00
|
|
|
{
|
|
|
|
const float *array = cogl_matrix_get_array (data->projection_matrix);
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glUniformMatrix4fv (data->program_state->mvp_uniform,
|
|
|
|
1, FALSE, array ) );
|
2011-07-06 20:51:00 +00:00
|
|
|
}
|
2010-12-06 12:31:51 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
cogl_matrix_multiply (&mvp_matrix,
|
|
|
|
data->projection_matrix,
|
|
|
|
matrix);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
GE( ctx, glUniformMatrix4fv (data->program_state->mvp_uniform, 1, FALSE,
|
2011-07-06 20:51:00 +00:00
|
|
|
cogl_matrix_get_array (&mvp_matrix)) );
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
2010-12-02 14:00:46 +00:00
|
|
|
}
|
|
|
|
|
2010-12-06 12:31:51 +00:00
|
|
|
static void
|
|
|
|
flush_combined_step_one_cb (gboolean is_identity,
|
|
|
|
const CoglMatrix *matrix,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
FlushCombinedData data;
|
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
data.program_state = user_data;
|
2010-12-06 12:31:51 +00:00
|
|
|
data.projection_matrix = matrix;
|
|
|
|
|
|
|
|
_cogl_matrix_stack_prepare_for_flush (ctx->flushed_modelview_stack,
|
|
|
|
COGL_MATRIX_MODELVIEW,
|
|
|
|
flush_combined_step_two_cb,
|
|
|
|
&data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_cogl_pipeline_progend_glsl_pre_paint (CoglPipeline *pipeline)
|
|
|
|
{
|
2011-06-30 12:39:48 +00:00
|
|
|
CoglPipelineProgramState *program_state = get_program_state (pipeline);
|
2010-12-06 12:31:51 +00:00
|
|
|
gboolean modelview_changed;
|
|
|
|
gboolean projection_changed;
|
|
|
|
|
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-07-07 19:44:56 +00:00
|
|
|
if (ctx->driver != COGL_DRIVER_GLES2)
|
|
|
|
return;
|
|
|
|
|
2010-12-06 12:31:51 +00:00
|
|
|
/* We only need to update the matrices if we're using the the GLSL
|
|
|
|
vertend, but this is a requirement on GLES2 anyway */
|
|
|
|
g_return_if_fail (pipeline->vertend == COGL_PIPELINE_VERTEND_GLSL);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state = get_program_state (pipeline);
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
/* An initial pipeline is flushed while creating the context. At
|
|
|
|
this point there are no matrices flushed so we can't do
|
|
|
|
anything */
|
|
|
|
if (ctx->flushed_modelview_stack == NULL ||
|
|
|
|
ctx->flushed_projection_stack == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* When flushing from the journal the modelview matrix is usually
|
|
|
|
the identity matrix so it makes sense to optimise this case by
|
|
|
|
specifically checking whether we already have the identity matrix
|
|
|
|
which will catch a lot of common cases of redundant flushing */
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->flushed_modelview_is_identity &&
|
2010-12-06 12:31:51 +00:00
|
|
|
_cogl_matrix_stack_has_identity_flag (ctx->flushed_modelview_stack))
|
|
|
|
modelview_changed = FALSE;
|
|
|
|
else
|
|
|
|
modelview_changed =
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->flushed_modelview_stack != ctx->flushed_modelview_stack ||
|
|
|
|
program_state->flushed_modelview_stack_age !=
|
|
|
|
_cogl_matrix_stack_get_age (program_state->flushed_modelview_stack);
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
projection_changed =
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->flushed_projection_stack != ctx->flushed_projection_stack ||
|
|
|
|
program_state->flushed_projection_stack_age !=
|
|
|
|
_cogl_matrix_stack_get_age (program_state->flushed_projection_stack);
|
2010-12-06 12:31:51 +00:00
|
|
|
|
|
|
|
if (modelview_changed)
|
|
|
|
{
|
|
|
|
cogl_object_ref (ctx->flushed_modelview_stack);
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->flushed_modelview_stack)
|
|
|
|
cogl_object_unref (program_state->flushed_modelview_stack);
|
|
|
|
program_state->flushed_modelview_stack = ctx->flushed_modelview_stack;
|
|
|
|
program_state->flushed_modelview_stack_age =
|
2010-12-06 12:31:51 +00:00
|
|
|
_cogl_matrix_stack_get_age (ctx->flushed_modelview_stack);
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state->flushed_modelview_is_identity =
|
2010-12-06 12:31:51 +00:00
|
|
|
_cogl_matrix_stack_has_identity_flag (ctx->flushed_modelview_stack);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->modelview_uniform != -1)
|
|
|
|
_cogl_matrix_stack_prepare_for_flush (program_state
|
|
|
|
->flushed_modelview_stack,
|
2010-12-06 12:31:51 +00:00
|
|
|
COGL_MATRIX_MODELVIEW,
|
|
|
|
flush_modelview_cb,
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state);
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (projection_changed)
|
|
|
|
{
|
|
|
|
cogl_object_ref (ctx->flushed_projection_stack);
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->flushed_projection_stack)
|
|
|
|
cogl_object_unref (program_state->flushed_projection_stack);
|
|
|
|
program_state->flushed_projection_stack = ctx->flushed_projection_stack;
|
|
|
|
program_state->flushed_projection_stack_age =
|
2010-12-06 12:31:51 +00:00
|
|
|
_cogl_matrix_stack_get_age (ctx->flushed_projection_stack);
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->projection_uniform != -1)
|
|
|
|
_cogl_matrix_stack_prepare_for_flush (program_state
|
|
|
|
->flushed_projection_stack,
|
2010-12-06 12:31:51 +00:00
|
|
|
COGL_MATRIX_PROJECTION,
|
|
|
|
flush_projection_cb,
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state);
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
|
2011-06-30 12:39:48 +00:00
|
|
|
if (program_state->mvp_uniform != -1 &&
|
|
|
|
(modelview_changed || projection_changed))
|
2010-12-06 12:31:51 +00:00
|
|
|
_cogl_matrix_stack_prepare_for_flush (ctx->flushed_projection_stack,
|
|
|
|
COGL_MATRIX_PROJECTION,
|
|
|
|
flush_combined_step_one_cb,
|
2011-06-30 12:39:48 +00:00
|
|
|
program_state);
|
2010-12-06 12:31:51 +00:00
|
|
|
}
|
|
|
|
|
2011-01-13 18:24:22 +00:00
|
|
|
static void
|
|
|
|
update_float_uniform (CoglPipeline *pipeline,
|
|
|
|
int uniform_location,
|
|
|
|
void *getter_func)
|
|
|
|
{
|
|
|
|
float (* float_getter_func) (CoglPipeline *) = getter_func;
|
|
|
|
float value;
|
|
|
|
|
2011-07-06 20:51:00 +00:00
|
|
|
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
|
|
|
|
|
2011-01-13 18:24:22 +00:00
|
|
|
value = float_getter_func (pipeline);
|
2011-07-06 20:51:00 +00:00
|
|
|
GE( ctx, glUniform1f (uniform_location, value) );
|
2011-01-13 18:24:22 +00:00
|
|
|
}
|
|
|
|
|
2010-12-06 12:31:51 +00:00
|
|
|
#endif
|
|
|
|
|
2010-12-02 14:00:46 +00:00
|
|
|
const CoglPipelineProgend _cogl_pipeline_glsl_progend =
|
|
|
|
{
|
|
|
|
_cogl_pipeline_progend_glsl_end,
|
|
|
|
_cogl_pipeline_progend_glsl_pre_change_notify,
|
2010-12-06 12:31:51 +00:00
|
|
|
_cogl_pipeline_progend_glsl_layer_pre_change_notify,
|
|
|
|
#ifdef HAVE_COGL_GLES2
|
|
|
|
_cogl_pipeline_progend_glsl_pre_paint
|
|
|
|
#else
|
|
|
|
NULL
|
|
|
|
#endif
|
2010-12-02 14:00:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* COGL_PIPELINE_PROGEND_GLSL */
|
|
|
|
|