bool ImGui_ImplGtk3Cogl_CreateDeviceObjects()
{
g_ColorPipeline = cogl_pipeline_new(g_Context);
g_ImagePipeline = cogl_pipeline_new(g_Context);
CoglError *error = NULL;
if (!cogl_pipeline_set_blend(g_ColorPipeline,
"RGB = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))"
"A = ADD(SRC_COLOR[A], DST_COLOR*(1-SRC_COLOR[A]))",
&error))
{
g_warning("Blending: %s", error->message);
g_error_free(error);
return false;
}
cogl_pipeline_set_cull_face_mode(g_ColorPipeline, COGL_PIPELINE_CULL_FACE_MODE_NONE);
CoglDepthState depth_state;
cogl_depth_state_init(&depth_state);
cogl_depth_state_set_test_enabled(&depth_state, FALSE);
if (!cogl_pipeline_set_depth_state(g_ColorPipeline, &depth_state, &error))
{
g_warning("Depth: %s", error->message);
g_error_free(error);
return false;
}
if (!cogl_pipeline_set_blend(g_ImagePipeline,
"RGB = ADD(SRC_COLOR*(SRC_COLOR[A]), DST_COLOR*(1-SRC_COLOR[A]))"
"A = ADD(SRC_COLOR[A], DST_COLOR*(1-SRC_COLOR[A]))",
&error))
{
g_warning("Blending: %s", error->message);
g_error_free(error);
return false;
}
cogl_pipeline_set_cull_face_mode(g_ImagePipeline, COGL_PIPELINE_CULL_FACE_MODE_NONE);
if (!cogl_pipeline_set_depth_state(g_ImagePipeline, &depth_state, &error))
{
g_warning("Depth: %s", error->message);
g_error_free(error);
return false;
}
ImGui_ImplGtk3Cogl_CreateFontsTexture();
/* Disable depth buffer since we're not using it. */
//cogl_framebuffer_set_depth_write_enabled(g_Framebuffer, FALSE);
return true;
}
static void
st_background_effect_init (StBackgroundEffect *self)
{
CoglContext *ctx;
StBackgroundEffectClass *klass = ST_BACKGROUND_EFFECT_GET_CLASS (self);
if (G_UNLIKELY (klass->base_pipeline == NULL))
{
ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
klass->base_pipeline = cogl_pipeline_new (ctx);
}
self->pipeline0 = cogl_pipeline_copy (klass->base_pipeline);
self->pipeline1 = cogl_pipeline_copy (klass->base_pipeline);
self->pipeline2 = cogl_pipeline_copy (klass->base_pipeline);
self->pipeline3 = cogl_pipeline_copy (klass->base_pipeline);
self->pipeline4 = cogl_pipeline_copy (klass->base_pipeline);
CoglSnippet *snippet;
snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_TEXTURE_LOOKUP,
box_blur_glsl_declarations,
NULL);
cogl_snippet_set_replace (snippet, box_blur_glsl_shader);
cogl_pipeline_add_layer_snippet (self->pipeline0, 0, snippet);
cogl_pipeline_add_layer_snippet (self->pipeline1, 0, snippet);
cogl_pipeline_add_layer_snippet (self->pipeline3, 0, snippet);
cogl_object_unref (snippet);
cogl_pipeline_set_layer_wrap_mode (self->pipeline0, 0,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_pipeline_set_layer_wrap_mode (self->pipeline0, 1,
COGL_PIPELINE_WRAP_MODE_REPEAT);
cogl_pipeline_set_layer_wrap_mode (self->pipeline1, 0,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_pipeline_set_layer_wrap_mode (self->pipeline2, 0,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_pipeline_set_layer_wrap_mode (self->pipeline3, 0,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_pipeline_set_layer_wrap_mode (self->pipeline4, 0,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
cogl_pipeline_set_cull_face_mode (self->pipeline0,
COGL_PIPELINE_CULL_FACE_MODE_NONE);
cogl_pipeline_set_cull_face_mode (self->pipeline1,
COGL_PIPELINE_CULL_FACE_MODE_NONE);
cogl_pipeline_set_cull_face_mode (self->pipeline2,
COGL_PIPELINE_CULL_FACE_MODE_NONE);
cogl_pipeline_set_cull_face_mode (self->pipeline3,
COGL_PIPELINE_CULL_FACE_MODE_NONE);
cogl_pipeline_set_cull_face_mode (self->pipeline4,
COGL_PIPELINE_CULL_FACE_MODE_NONE);
cogl_pipeline_set_layer_filters (self->pipeline0, 0,
COGL_PIPELINE_FILTER_LINEAR,
COGL_PIPELINE_FILTER_LINEAR);
cogl_pipeline_set_layer_filters (self->pipeline0, 1,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
cogl_pipeline_set_layer_filters (self->pipeline1, 0,
COGL_PIPELINE_FILTER_LINEAR,
COGL_PIPELINE_FILTER_LINEAR);
cogl_pipeline_set_layer_filters (self->pipeline2, 0,
COGL_PIPELINE_FILTER_LINEAR,
COGL_PIPELINE_FILTER_LINEAR);
cogl_pipeline_set_layer_filters (self->pipeline3, 0,
COGL_PIPELINE_FILTER_LINEAR,
COGL_PIPELINE_FILTER_LINEAR);
cogl_pipeline_set_layer_filters (self->pipeline4, 0,
COGL_PIPELINE_FILTER_LINEAR,
COGL_PIPELINE_FILTER_LINEAR);
cogl_pipeline_set_layer_null_texture (self->pipeline0,
0,
COGL_TEXTURE_TYPE_2D);
cogl_pipeline_set_layer_null_texture (self->pipeline1,
0,
COGL_TEXTURE_TYPE_2D);
cogl_pipeline_set_layer_null_texture (self->pipeline2,
0,
COGL_TEXTURE_TYPE_2D);
cogl_pipeline_set_layer_null_texture (self->pipeline3,
0,
COGL_TEXTURE_TYPE_2D);
cogl_pipeline_set_layer_null_texture (self->pipeline4,
0,
COGL_TEXTURE_TYPE_2D);
self->pixel_step_uniform0 =
cogl_pipeline_get_uniform_location (self->pipeline0, "pixel_step");
self->BumpTex_uniform =
cogl_pipeline_get_uniform_location (self->pipeline0, "BumpTex");
self->bump_step_uniform =
cogl_pipeline_get_uniform_location (self->pipeline0, "bump_step");
self->pixel_step_uniform1 =
cogl_pipeline_get_uniform_location (self->pipeline1, "pixel_step");
self->pixel_step_uniform2 =
cogl_pipeline_get_uniform_location (self->pipeline3, "pixel_step");
cogl_pipeline_set_blend (self->pipeline0,
"RGBA = ADD(SRC_COLOR, DST_COLOR*0)",
NULL);
cogl_pipeline_set_blend (self->pipeline1,
"RGBA = ADD (SRC_COLOR*DST_COLOR[A], DST_COLOR*(1-DST_COLOR[A]))",
NULL);
cogl_pipeline_set_color4ub (self->pipeline1,
0xff,
0xff,
0xff,
0xff);
cogl_pipeline_set_alpha_test_function (self->pipeline2,
COGL_PIPELINE_ALPHA_FUNC_LESS,
0.004f);
cogl_pipeline_set_color_mask (self->pipeline2,
COGL_COLOR_MASK_ALPHA);
cogl_pipeline_set_blend (self->pipeline2,
"RGBA = ADD(SRC_COLOR, DST_COLOR*0)",
NULL);
cogl_pipeline_set_alpha_test_function (self->pipeline3,
COGL_PIPELINE_ALPHA_FUNC_GEQUAL,
0.004f);
cogl_pipeline_set_color_mask (self->pipeline3,
COGL_COLOR_MASK_ALL);
cogl_pipeline_set_blend (self->pipeline3,
"RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))",
NULL);
cogl_pipeline_set_alpha_test_function (self->pipeline4,
COGL_PIPELINE_ALPHA_FUNC_GEQUAL,
0.004f);
cogl_pipeline_set_color_mask (self->pipeline4,
COGL_COLOR_MASK_ALL);
cogl_pipeline_set_blend (self->pipeline4,
"RGBA = ADD (SRC_COLOR, DST_COLOR*(1-SRC_COLOR[A]))",
NULL);
self->bg_texture = NULL;
self->bg_sub_texture = NULL;
self->bumpmap_location = "/usr/share/cinnamon/bumpmaps/frost.png";
self->bg_bumpmap = st_cogl_texture_new_from_file_wrapper (self->bumpmap_location,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888_PRE);
if (self->bg_bumpmap != NULL)
{
self->bumptex_width_i = cogl_texture_get_width (self->bg_bumpmap);
self->bumptex_height_i = cogl_texture_get_height (self->bg_bumpmap);
cogl_pipeline_set_layer_texture (self->pipeline0, 1, self->bg_bumpmap);
}
else
{
cogl_pipeline_set_layer_null_texture (self->pipeline0,
1,
COGL_TEXTURE_TYPE_2D);
}
cogl_pipeline_set_layer_combine (self->pipeline0,1,
"RGBA = REPLACE (PREVIOUS)",
NULL);
self->old_time = 0;
self->opacity = 0;
}
static void
clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)
{
ClutterDeformEffect *self= CLUTTER_DEFORM_EFFECT (effect);
ClutterDeformEffectPrivate *priv = self->priv;
CoglHandle material;
CoglPipeline *pipeline;
CoglDepthState depth_state;
CoglFramebuffer *fb = cogl_get_draw_framebuffer ();
if (priv->is_dirty)
{
ClutterRect rect;
gboolean mapped_buffer;
CoglVertexP3T2C4 *verts;
ClutterActor *actor;
gfloat width, height;
guint opacity;
gint i, j;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
opacity = clutter_actor_get_paint_opacity (actor);
/* if we don't have a target size, fall back to the actor's
* allocation, though wrong it might be
*/
if (clutter_offscreen_effect_get_target_rect (effect, &rect))
{
width = clutter_rect_get_width (&rect);
height = clutter_rect_get_height (&rect);
}
else
clutter_actor_get_size (actor, &width, &height);
/* XXX ideally, the sub-classes should tell us what they
* changed in the texture vertices; we then would be able to
* avoid resubmitting the same data, if it did not change. for
* the time being, we resubmit everything
*/
verts = cogl_buffer_map (COGL_BUFFER (priv->buffer),
COGL_BUFFER_ACCESS_WRITE,
COGL_BUFFER_MAP_HINT_DISCARD);
/* If the map failed then we'll resort to allocating a temporary
buffer */
if (verts == NULL)
{
mapped_buffer = FALSE;
verts = g_malloc (sizeof (*verts) * priv->n_vertices);
}
else
mapped_buffer = TRUE;
for (i = 0; i < priv->y_tiles + 1; i++)
{
for (j = 0; j < priv->x_tiles + 1; j++)
{
CoglVertexP3T2C4 *vertex_out;
CoglTextureVertex vertex;
/* CoglTextureVertex isn't an ideal structure to use for
this because it contains a CoglColor. The internal
layout of CoglColor is mean to be private so Clutter
can not pass a pointer to it as a vertex
attribute. Also it contains padding so we end up
storing more data in the vertex buffer than we need
to. Instead we let the application modify a dummy
vertex and then copy the details back out to a more
well-defined struct */
vertex.tx = (float) j / priv->x_tiles;
vertex.ty = (float) i / priv->y_tiles;
vertex.x = width * vertex.tx;
vertex.y = height * vertex.ty;
vertex.z = 0.0f;
cogl_color_init_from_4ub (&vertex.color, 255, 255, 255, opacity);
clutter_deform_effect_deform_vertex (self,
width, height,
&vertex);
vertex_out = verts + i * (priv->x_tiles + 1) + j;
vertex_out->x = vertex.x;
vertex_out->y = vertex.y;
vertex_out->z = vertex.z;
vertex_out->s = vertex.tx;
vertex_out->t = vertex.ty;
vertex_out->r = cogl_color_get_red_byte (&vertex.color);
vertex_out->g = cogl_color_get_green_byte (&vertex.color);
vertex_out->b = cogl_color_get_blue_byte (&vertex.color);
vertex_out->a = cogl_color_get_alpha_byte (&vertex.color);
}
}
if (mapped_buffer)
cogl_buffer_unmap (COGL_BUFFER (priv->buffer));
else
{
cogl_buffer_set_data (COGL_BUFFER (priv->buffer),
0, /* offset */
verts,
sizeof (*verts) * priv->n_vertices);
g_free (verts);
}
priv->is_dirty = FALSE;
}
material = clutter_offscreen_effect_get_target (effect);
pipeline = COGL_PIPELINE (material);
/* enable depth testing */
cogl_depth_state_init (&depth_state);
cogl_depth_state_set_test_enabled (&depth_state, TRUE);
cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL);
/* enable backface culling if we have a back material */
if (priv->back_pipeline != NULL)
cogl_pipeline_set_cull_face_mode (pipeline,
COGL_PIPELINE_CULL_FACE_MODE_BACK);
/* draw the front */
if (material != NULL)
cogl_framebuffer_draw_primitive (fb, pipeline, priv->primitive);
/* draw the back */
if (priv->back_pipeline != NULL)
{
CoglPipeline *back_pipeline;
/* We probably shouldn't be modifying the user's material so
instead we make a temporary copy */
back_pipeline = cogl_pipeline_copy (priv->back_pipeline);
cogl_pipeline_set_depth_state (back_pipeline, &depth_state, NULL);
cogl_pipeline_set_cull_face_mode (back_pipeline,
COGL_PIPELINE_CULL_FACE_MODE_FRONT);
cogl_framebuffer_draw_primitive (fb, back_pipeline, priv->primitive);
cogl_object_unref (back_pipeline);
}
if (G_UNLIKELY (priv->lines_primitive != NULL))
{
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
CoglPipeline *lines_pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4f (lines_pipeline, 1.0, 0, 0, 1.0);
cogl_framebuffer_draw_primitive (fb, lines_pipeline,
priv->lines_primitive);
cogl_object_unref (lines_pipeline);
}
}
static void
paint_test_backface_culling (TestState *state,
CoglFramebuffer *framebuffer)
{
int draw_num;
CoglPipeline *base_pipeline = cogl_pipeline_new (test_ctx);
cogl_framebuffer_orthographic (framebuffer,
0, 0,
state->width,
state->height,
-1,
100);
cogl_framebuffer_clear4f (framebuffer,
COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_STENCIL,
0, 0, 0, 1);
cogl_pipeline_set_layer_texture (base_pipeline, 0, state->texture);
cogl_pipeline_set_layer_filters (base_pipeline, 0,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
/* Render the scene eight times to test all of the combinations of
cull face mode and winding orders */
for (draw_num = 0; draw_num < 8; draw_num++)
{
float x1 = 0, x2, y1 = 0, y2 = (float)(TEXTURE_RENDER_SIZE);
CoglTextureVertex verts[4];
CoglPipeline *pipeline;
cogl_framebuffer_push_matrix (framebuffer);
cogl_framebuffer_translate (framebuffer,
0, TEXTURE_RENDER_SIZE * draw_num, 0);
pipeline = cogl_pipeline_copy (base_pipeline);
cogl_pipeline_set_front_face_winding (pipeline, FRONT_WINDING (draw_num));
cogl_pipeline_set_cull_face_mode (pipeline, CULL_FACE_MODE (draw_num));
memset (verts, 0, sizeof (verts));
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a front-facing texture */
cogl_framebuffer_draw_rectangle (framebuffer, pipeline, x1, y1, x2, y2);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a front-facing texture with flipped texcoords */
cogl_framebuffer_draw_textured_rectangle (framebuffer,
pipeline,
x1, y1, x2, y2,
1.0, 0.0, 0.0, 1.0);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a back-facing texture */
cogl_framebuffer_draw_rectangle (framebuffer, pipeline, x2, y1, x1, y2);
cogl_framebuffer_pop_matrix (framebuffer);
cogl_object_unref (pipeline);
}
cogl_object_unref (base_pipeline);
}
static void
paint_test_backface_culling (TestState *state)
{
int draw_num;
CoglPipeline *base_pipeline = cogl_pipeline_new ();
CoglColor clear_color;
cogl_ortho (0, state->width, /* left, right */
state->height, 0, /* bottom, top */
-1, 100 /* z near, far */);
cogl_color_init_from_4ub (&clear_color, 0x00, 0x00, 0x00, 0xff);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_STENCIL);
cogl_pipeline_set_layer_texture (base_pipeline, 0, state->texture);
cogl_pipeline_set_layer_filters (base_pipeline, 0,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
/* Render the scene sixteen times to test all of the combinations of
cull face mode, legacy state and winding orders */
for (draw_num = 0; draw_num < 16; draw_num++)
{
float x1 = 0, x2, y1 = 0, y2 = (float)(TEXTURE_RENDER_SIZE);
CoglTextureVertex verts[4];
CoglPipeline *pipeline;
cogl_push_matrix ();
cogl_translate (0, TEXTURE_RENDER_SIZE * draw_num, 0);
pipeline = cogl_pipeline_copy (base_pipeline);
cogl_set_backface_culling_enabled (USE_LEGACY_STATE (draw_num));
cogl_pipeline_set_front_face_winding (pipeline, FRONT_WINDING (draw_num));
cogl_pipeline_set_cull_face_mode (pipeline, CULL_FACE_MODE (draw_num));
cogl_push_source (pipeline);
memset (verts, 0, sizeof (verts));
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a front-facing texture */
cogl_rectangle (x1, y1, x2, y2);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a front-facing texture with flipped texcoords */
cogl_rectangle_with_texture_coords (x1, y1, x2, y2,
1.0, 0.0, 0.0, 1.0);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a back-facing texture */
cogl_rectangle (x2, y1, x1, y2);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* If the texture is sliced then cogl_polygon doesn't work so
we'll just use a solid color instead */
if (cogl_texture_is_sliced (state->texture))
cogl_set_source_color4ub (255, 0, 0, 255);
/* Draw a front-facing polygon */
verts[0].x = x1; verts[0].y = y2;
verts[1].x = x2; verts[1].y = y2;
verts[2].x = x2; verts[2].y = y1;
verts[3].x = x1; verts[3].y = y1;
verts[0].tx = 0; verts[0].ty = 0;
verts[1].tx = 1.0; verts[1].ty = 0;
verts[2].tx = 1.0; verts[2].ty = 1.0;
verts[3].tx = 0; verts[3].ty = 1.0;
cogl_polygon (verts, 4, FALSE);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a back-facing polygon */
verts[0].x = x1; verts[0].y = y1;
verts[1].x = x2; verts[1].y = y1;
verts[2].x = x2; verts[2].y = y2;
verts[3].x = x1; verts[3].y = y2;
verts[0].tx = 0; verts[0].ty = 0;
verts[1].tx = 1.0; verts[1].ty = 0;
verts[2].tx = 1.0; verts[2].ty = 1.0;
verts[3].tx = 0; verts[3].ty = 1.0;
cogl_polygon (verts, 4, FALSE);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
cogl_pop_matrix ();
cogl_pop_source ();
cogl_object_unref (pipeline);
}
cogl_object_unref (base_pipeline);
}
