void _st_paint_shadow_with_opacity (StShadow *shadow_spec, CoglPipeline *shadow_pipeline, ClutterActorBox *box, guint8 paint_opacity) { CoglFramebuffer *fb = cogl_get_draw_framebuffer (); ClutterActorBox shadow_box; CoglColor color; g_return_if_fail (shadow_spec != NULL); g_return_if_fail (shadow_pipeline != NULL); st_shadow_get_box (shadow_spec, box, &shadow_box); cogl_color_init_from_4ub (&color, shadow_spec->color.red * paint_opacity / 255, shadow_spec->color.green * paint_opacity / 255, shadow_spec->color.blue * paint_opacity / 255, shadow_spec->color.alpha * paint_opacity / 255); cogl_color_premultiply (&color); cogl_pipeline_set_layer_combine_constant (shadow_pipeline, 0, &color); cogl_framebuffer_draw_rectangle (fb, shadow_pipeline, shadow_box.x1, shadow_box.y1, shadow_box.x2, shadow_box.y2); }
void _st_paint_shadow_with_opacity (StShadow *shadow_spec, CoglHandle shadow_material, ClutterActorBox *box, guint8 paint_opacity) { ClutterActorBox shadow_box; CoglColor color; g_return_if_fail (shadow_spec != NULL); g_return_if_fail (shadow_material != COGL_INVALID_HANDLE); st_shadow_get_box (shadow_spec, box, &shadow_box); cogl_color_set_from_4ub (&color, shadow_spec->color.red * paint_opacity / 255, shadow_spec->color.green * paint_opacity / 255, shadow_spec->color.blue * paint_opacity / 255, shadow_spec->color.alpha * paint_opacity / 255); cogl_color_premultiply (&color); cogl_material_set_layer_combine_constant (shadow_material, 0, &color); cogl_set_source (shadow_material); cogl_rectangle_with_texture_coords (shadow_box.x1, shadow_box.y1, shadow_box.x2, shadow_box.y2, 0, 0, 1, 1); }
void _cogl_pango_display_list_render (CoglFramebuffer *fb, CoglPangoDisplayList *dl, const CoglColor *color) { GSList *l; for (l = dl->nodes; l; l = l->next) { CoglPangoDisplayListNode *node = l->data; CoglColor draw_color; if (node->pipeline == NULL) { if (node->type == COGL_PANGO_DISPLAY_LIST_TEXTURE) node->pipeline = _cogl_pango_pipeline_cache_get (dl->pipeline_cache, node->d.texture.texture); else node->pipeline = _cogl_pango_pipeline_cache_get (dl->pipeline_cache, NULL); } if (node->color_override) /* Use the override color but preserve the alpha from the draw color */ cogl_color_init_from_4ub (&draw_color, cogl_color_get_red_byte (&node->color), cogl_color_get_green_byte (&node->color), cogl_color_get_blue_byte (&node->color), cogl_color_get_alpha_byte (color)); else draw_color = *color; cogl_color_premultiply (&draw_color); cogl_pipeline_set_color (node->pipeline, &draw_color); switch (node->type) { case COGL_PANGO_DISPLAY_LIST_TEXTURE: _cogl_framebuffer_draw_display_list_texture (fb, node->pipeline, node); break; case COGL_PANGO_DISPLAY_LIST_RECTANGLE: cogl_framebuffer_draw_rectangle (fb, node->pipeline, node->d.rectangle.x_1, node->d.rectangle.y_1, node->d.rectangle.x_2, node->d.rectangle.y_2); break; case COGL_PANGO_DISPLAY_LIST_TRAPEZOID: cogl_primitive_draw (node->d.trapezoid.primitive, fb, node->pipeline); break; } } }
static void aisleriot_slot_renderer_set_material_for_card (AisleriotSlotRenderer *srend, CoglHandle tex, gboolean show_highlight) { AisleriotSlotRendererPrivate *priv = srend->priv; guint8 opacity = clutter_actor_get_paint_opacity (CLUTTER_ACTOR (srend)); if (priv->material == COGL_INVALID_HANDLE) priv->material = cogl_material_new (); if (show_highlight) { CoglColor color; /* The previous code for drawing the highlight rendered the normal card texture and then rendered the card again multiplied by the highlight color but with 50% transparency. The blend function is alpha*src+(1-alpha*dst) where src is effectively the tex times the highlight color and the dst is the original tex. Therefore the final color is 0.5*tex+0.5*tex*highlight which is the same as (0.5+highlight/2)*tex. We can precompute that value to avoid having to draw the card twice */ cogl_color_set_from_4ub (&color, MIN (priv->highlight_color.red / 2 + 128, 0xff), MIN (priv->highlight_color.green / 2 + 128, 0xff), MIN (priv->highlight_color.blue / 2 + 128, 0xff), opacity); cogl_color_premultiply (&color); cogl_material_set_color (priv->material, &color); } else cogl_material_set_color4ub (priv->material, opacity, opacity, opacity, opacity); cogl_material_set_layer (priv->material, 0, tex); cogl_set_source (priv->material); }
void cogl_set_source_color (const CoglColor *color) { CoglPipeline *pipeline; _COGL_GET_CONTEXT (ctx, NO_RETVAL); if (cogl_color_get_alpha_byte (color) == 0xff) { cogl_pipeline_set_color (ctx->opaque_color_pipeline, color); pipeline = ctx->opaque_color_pipeline; } else { CoglColor premultiplied = *color; cogl_color_premultiply (&premultiplied); cogl_pipeline_set_color (ctx->blended_color_pipeline, &premultiplied); pipeline = ctx->blended_color_pipeline; } cogl_set_source (pipeline); }
/** * meta_create_color_texture_4ub: * @red: * @green: * @blue: * @alpha: * @flags: Optional flags for the texture, or %COGL_TEXTURE_NONE; * %COGL_TEXTURE_NO_SLICING is useful if the texture will be * repeated to create a constant color fill, since hardware * repeat can't be used for a sliced texture. * * Creates a texture that is a single pixel with the specified * unpremultiplied color components. * * Return value: (transfer full): a newly created Cogl texture */ CoglHandle meta_create_color_texture_4ub (guint8 red, guint8 green, guint8 blue, guint8 alpha, CoglTextureFlags flags) { CoglColor color; guint8 pixel[4]; cogl_color_set_from_4ub (&color, red, green, blue, alpha); cogl_color_premultiply (&color); pixel[0] = cogl_color_get_red_byte (&color); pixel[1] = cogl_color_get_green_byte (&color); pixel[2] = cogl_color_get_blue_byte (&color); pixel[3] = cogl_color_get_alpha_byte (&color); return cogl_texture_new_from_data (1, 1, flags, COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_PIXEL_FORMAT_ANY, 4, pixel); }
void _cogl_pango_display_list_render (CoglPangoDisplayList *dl, const CoglColor *color) { GSList *l; for (l = dl->nodes; l; l = l->next) { CoglPangoDisplayListNode *node = l->data; CoglColor draw_color; if (node->pipeline == NULL) { if (node->type == COGL_PANGO_DISPLAY_LIST_TEXTURE) node->pipeline = _cogl_pango_pipeline_cache_get (dl->pipeline_cache, node->d.texture.texture); else node->pipeline = _cogl_pango_pipeline_cache_get (dl->pipeline_cache, NULL); } if (node->color_override) /* Use the override color but preserve the alpha from the draw color */ cogl_color_init_from_4ub (&draw_color, cogl_color_get_red_byte (&node->color), cogl_color_get_green_byte (&node->color), cogl_color_get_blue_byte (&node->color), cogl_color_get_alpha_byte (color)); else draw_color = *color; cogl_color_premultiply (&draw_color); cogl_pipeline_set_color (node->pipeline, &draw_color); cogl_push_source (node->pipeline); switch (node->type) { case COGL_PANGO_DISPLAY_LIST_TEXTURE: _cogl_pango_display_list_render_texture (node); break; case COGL_PANGO_DISPLAY_LIST_RECTANGLE: cogl_rectangle (node->d.rectangle.x_1, node->d.rectangle.y_1, node->d.rectangle.x_2, node->d.rectangle.y_2); break; case COGL_PANGO_DISPLAY_LIST_TRAPEZOID: { float points[8]; CoglPath *path; points[0] = node->d.trapezoid.x_11; points[1] = node->d.trapezoid.y_1; points[2] = node->d.trapezoid.x_12; points[3] = node->d.trapezoid.y_2; points[4] = node->d.trapezoid.x_22; points[5] = node->d.trapezoid.y_2; points[6] = node->d.trapezoid.x_21; points[7] = node->d.trapezoid.y_1; path = cogl_path_new (); cogl_path_polygon (path, points, 4); cogl_path_fill (path); cogl_object_unref (path); } break; } cogl_pop_source (); } }
static void _clone_paint_cb (ClutterActor *actor) { ClutterActor *source; ClutterActorBox box; CoglHandle material; gfloat width, height; guint8 opacity; CoglColor color_1, color_2; CoglTextureVertex vertices[4]; /* if we don't have a source actor, don't paint */ source = clutter_clone_get_source (CLUTTER_CLONE (actor)); if (source == NULL) goto out; /* if the source texture does not have any content, don't paint */ material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (source)); if (material == NULL) goto out; /* get the size of the reflection */ clutter_actor_get_allocation_box (actor, &box); clutter_actor_box_get_size (&box, &width, &height); /* get the composite opacity of the actor */ opacity = clutter_actor_get_paint_opacity (actor); /* figure out the two colors for the reflection: the first is * full color and the second is the same, but at 0 opacity */ cogl_color_init_from_4f (&color_1, 1.0, 1.0, 1.0, opacity / 255.0); cogl_color_premultiply (&color_1); cogl_color_init_from_4f (&color_2, 1.0, 1.0, 1.0, 0.0); cogl_color_premultiply (&color_2); /* now describe the four vertices of the quad; since it has * to be a reflection, we need to invert it as well */ vertices[0].x = 0; vertices[0].y = 0; vertices[0].z = 0; vertices[0].tx = 0.0; vertices[0].ty = 1.0; vertices[0].color = color_1; vertices[1].x = width; vertices[1].y = 0; vertices[1].z = 0; vertices[1].tx = 1.0; vertices[1].ty = 1.0; vertices[1].color = color_1; vertices[2].x = width; vertices[2].y = height; vertices[2].z = 0; vertices[2].tx = 1.0; vertices[2].ty = 0.0; vertices[2].color = color_2; vertices[3].x = 0; vertices[3].y = height; vertices[3].z = 0; vertices[3].tx = 0.0; vertices[3].ty = 0.0; vertices[3].color = color_2; /* paint the same texture but with a different geometry */ cogl_set_source (material); cogl_polygon (vertices, 4, TRUE); out: /* prevent the default clone handler from running */ g_signal_stop_emission_by_name (actor, "paint"); }