static void mex_tile_paint (ClutterActor *actor) { MexTilePrivate *priv = MEX_TILE (actor)->priv; MxPadding padding; ClutterActorBox box; CLUTTER_ACTOR_CLASS (mex_tile_parent_class)->paint (actor); clutter_actor_paint (priv->child); mx_widget_get_padding (MX_WIDGET (actor), &padding); if (priv->header_visible) { clutter_actor_get_allocation_box (actor, &box); if (priv->header_background_color) { cogl_set_source_color4ub (priv->header_background_color->red, priv->header_background_color->green, priv->header_background_color->blue, priv->header_background_color->alpha); cogl_rectangle (padding.left, padding.top, box.x2 - box.x1 - padding.right, priv->header_height); } if (cogl_material_get_n_layers (priv->material) > 0) { guint8 opacity; opacity = clutter_actor_get_paint_opacity (actor); cogl_material_set_color4ub (priv->material, opacity, opacity, opacity, opacity); cogl_set_source (priv->material); cogl_rectangle (padding.left, padding.top, box.x2 - box.x1 - padding.right, priv->header_height); } clutter_actor_paint (priv->box_layout); if (priv->icon1) clutter_actor_paint (priv->icon1); if (priv->icon2) clutter_actor_paint (priv->icon2); } }
static void st_background_effect_paint_target (ClutterOffscreenEffect *effect) { StBackgroundEffect *self = ST_BACKGROUND_EFFECT (effect); if ((self->bg_texture != NULL) && (self->opacity == 0xff)) { cogl_push_source (self->pipeline2); cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i)); cogl_pop_source (); CoglOffscreen *vertical_FBO; vertical_FBO = cogl_offscreen_new_to_texture (self->bg_sub_texture); cogl_push_framebuffer ((CoglFramebuffer*)vertical_FBO); cogl_push_source (self->pipeline0); cogl_rectangle (-1.0f, 1.0f, 1.0f, -1.0f); cogl_pop_source (); cogl_pop_framebuffer (); cogl_handle_unref (vertical_FBO); cogl_pipeline_set_layer_texture (self->pipeline1, 0, self->bg_sub_texture); cogl_push_source (self->pipeline1); cogl_rectangle (4.0f, 4.0f, (self->bg_width_i) + 4.0f, (self->bg_height_i) + 4.0f); cogl_pop_source (); } cogl_pipeline_set_color4ub (self->pipeline3, 0x00, 0x00, 0x00, 0x80); cogl_push_source (self->pipeline3); cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i)); cogl_pop_source (); clutter_actor_queue_redraw (self->actor); cogl_pipeline_set_color4ub (self->pipeline4, self->opacity, self->opacity, self->opacity, self->opacity); cogl_push_source (self->pipeline4); cogl_rectangle (0.0f, 0.0f, (self->fg_width_i), (self->fg_height_i)); cogl_pop_source (); clutter_actor_queue_redraw (self->actor); }
static void mx_table_paint (ClutterActor *self) { MxTablePrivate *priv = MX_TABLE (self)->priv; ClutterActorIter iter; ClutterActor *child; /* make sure the background gets painted first */ CLUTTER_ACTOR_CLASS (mx_table_parent_class)->paint (self); clutter_actor_iter_init (&iter, self); while (clutter_actor_iter_next (&iter, &child)) { if (CLUTTER_ACTOR_IS_VISIBLE (child)) clutter_actor_paint (child); } if (_mx_debug (MX_DEBUG_LAYOUT)) { int i; float width, height; gfloat pos = 0; DimensionData *rows, *cols; rows = &g_array_index (priv->rows, DimensionData, 0); cols = &g_array_index (priv->columns, DimensionData, 0); clutter_actor_get_size (self, &width, &height); cogl_set_source_color4f (0.0, 0.0, 1.0, 0.7); for (i = 0; i < priv->n_rows; i++) { cogl_rectangle (0, pos, 10, pos + rows[i].final_size); pos += rows[i].final_size + priv->row_spacing; } cogl_set_source_color4f (1.0, 0.0, 0.0, 0.7); pos = 0; for (i = 0; i < priv->n_rows; i++) { cogl_rectangle (pos, 0, pos + cols[i].final_size, 10); pos += cols[i].final_size + priv->col_spacing; } } }
static void paint (TestState *state) { CoglColor bg; int i; cogl_set_source_color4ub (255, 255, 255, 255); /* We push the third framebuffer first so that later we can switch back to it by popping to test that that works */ cogl_push_framebuffer (state->fbo[2]); cogl_push_framebuffer (state->fbo[0]); cogl_rectangle (-1.0, -1.0, 1.0, 1.0); cogl_pop_framebuffer (); cogl_push_framebuffer (state->fbo[1]); cogl_rectangle (-1.0, -1.0, 1.0, 1.0); cogl_pop_framebuffer (); /* We should now be back on the third framebuffer */ cogl_rectangle (-1.0, -1.0, 1.0, 1.0); cogl_pop_framebuffer (); cogl_color_init_from_4ub (&bg, 128, 128, 128, 255); cogl_clear (&bg, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH); /* Render all of the textures to the screen */ for (i = 0; i < NUM_FBOS; i++) { cogl_set_source_texture (state->tex[i]); cogl_rectangle (2.0f / NUM_FBOS * i - 1.0f, -1.0f, 2.0f / NUM_FBOS * (i + 1) - 1.0f, 1.0f); } /* Verify all of the fbos drew the right color */ for (i = 0; i < NUM_FBOS; i++) { guint8 expected_colors[NUM_FBOS][4] = { { 0xff, 0x00, 0x00, 0xff }, { 0x00, 0xff, 0x00, 0xff }, { 0x00, 0x00, 0xff, 0xff } }; test_utils_check_pixel_rgb (state->width * (i + 0.5f) / NUM_FBOS, state->height / 2, expected_colors[i][0], expected_colors[i][1], expected_colors[i][2]); } }
static void paint_pipeline (CoglPipeline *pipeline, int pos) { cogl_push_source (pipeline); cogl_rectangle (pos * 10, 0, pos * 10 + 10, 10); cogl_pop_source (); }
static void test_coglbox_paint(ClutterActor *self) { TestCoglboxPrivate *priv = TEST_COGLBOX_GET_PRIVATE (self); ClutterColor cback = {0x66, 0x66, 0xDD, 0xFF}; ClutterColor cwhite = {0xFF, 0xFF, 0xFF, 0xFF}; ClutterFixed texcoords[4] = { CLUTTER_FLOAT_TO_FIXED (0.3f), CLUTTER_FLOAT_TO_FIXED (0.3f), CLUTTER_FLOAT_TO_FIXED (0.7f), CLUTTER_FLOAT_TO_FIXED (0.7f) }; priv = TEST_COGLBOX_GET_PRIVATE (self); cogl_color (&cback); cogl_rectangle (0,0,400,400); cogl_color (&cwhite); cogl_push_matrix (); cogl_translate (100,100,0); cogl_texture_rectangle (priv->cogl_handle, 0, 0, CLUTTER_INT_TO_FIXED (200), CLUTTER_INT_TO_FIXED (200), texcoords[0], texcoords[1], texcoords[2], texcoords[3]); cogl_pop_matrix(); }
static void key_group_paint (ClutterActor *actor) { KeyGroup *self = KEY_GROUP (actor); GList *children, *l; gint i; children = clutter_container_get_children (CLUTTER_CONTAINER (self)); for (l = children, i = 0; l != NULL; l = l->next, i++) { ClutterActor *child = l->data; /* paint the selection rectangle */ if (i == self->selected_index) { ClutterActorBox box = { 0, }; clutter_actor_get_allocation_box (child, &box); box.x1 -= 2; box.y1 -= 2; box.x2 += 2; box.y2 += 2; cogl_set_source_color4ub (255, 255, 0, 224); cogl_rectangle (box.x1, box.y1, box.x2, box.y2); } clutter_actor_paint (child); } g_list_free (children); }
static void aisleriot_slot_renderer_paint_card (AisleriotSlotRenderer *srend, guint card_num) { AisleriotSlotRendererPrivate *priv = srend->priv; Card card = CARD (priv->slot->cards->data[card_num]); CoglHandle cogl_tex; guint tex_width, tex_height; int cardx, cardy; cogl_tex = ar_card_textures_cache_get_card_texture (priv->cache, card); if (G_UNLIKELY (cogl_tex == COGL_INVALID_HANDLE)) return; tex_width = cogl_texture_get_width (cogl_tex); tex_height = cogl_texture_get_height (cogl_tex); aisleriot_game_get_card_offset (priv->slot, card_num, FALSE, &cardx, &cardy); aisleriot_slot_renderer_set_material_for_card (srend, cogl_tex, priv->show_highlight && card_num >= priv->highlight_start); cogl_rectangle (cardx, cardy, cardx + tex_width, cardy + tex_height); }
static void _cogl_path_fill_nodes_with_clipped_rectangle (CoglPath *path) { CoglFramebuffer *fb; _COGL_GET_CONTEXT (ctx, NO_RETVAL); if (!(ctx->private_feature_flags & COGL_PRIVATE_FEATURE_STENCIL_BUFFER)) { static gboolean seen_warning = FALSE; if (!seen_warning) { g_warning ("Paths can not be filled using materials with " "sliced textures unless there is a stencil " "buffer"); seen_warning = TRUE; } } fb = cogl_get_draw_framebuffer (); cogl_framebuffer_push_path_clip (fb, path); cogl_rectangle (path->data->path_nodes_min.x, path->data->path_nodes_min.y, path->data->path_nodes_max.x, path->data->path_nodes_max.y); cogl_framebuffer_pop_clip (fb); }
static void shell_grid_desaturate_effect_paint_target (ClutterOffscreenEffect *effect) { ShellGridDesaturateEffect *self = SHELL_GRID_DESATURATE_EFFECT (effect); ClutterActor *actor; CoglHandle texture; guint8 paint_opacity; texture = clutter_offscreen_effect_get_texture (effect); cogl_pipeline_set_layer_texture (self->pipeline, 0, texture); actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect)); paint_opacity = clutter_actor_get_paint_opacity (actor); cogl_pipeline_set_color4ub (self->pipeline, paint_opacity, paint_opacity, paint_opacity, paint_opacity); cogl_push_source (self->pipeline); cogl_rectangle (0, 0, cogl_texture_get_width (texture), cogl_texture_get_height (texture)); cogl_pop_source (); }
static void clutter_box_real_paint (ClutterActor *actor) { ClutterBoxPrivate *priv = CLUTTER_BOX (actor)->priv; if (priv->color_set) { ClutterActorBox box = { 0, }; gfloat width, height; guint8 tmp_alpha; clutter_actor_get_allocation_box (actor, &box); clutter_actor_box_get_size (&box, &width, &height); tmp_alpha = clutter_actor_get_paint_opacity (actor) * priv->color.alpha / 255; cogl_set_source_color4ub (priv->color.red, priv->color.green, priv->color.blue, tmp_alpha); cogl_rectangle (0, 0, width, height); } g_list_foreach (priv->children, (GFunc) clutter_actor_paint, NULL); }
static void aisleriot_card_paint (ClutterActor *actor) { AisleriotCard *card = (AisleriotCard *) actor; AisleriotCardPrivate *priv = card->priv; CoglHandle top_tex, bottom_tex; ClutterActorBox alloc_box; cogl_enable_backface_culling (TRUE); top_tex = games_card_textures_cache_get_card_texture (priv->cache, priv->top_card); bottom_tex = games_card_textures_cache_get_card_texture (priv->cache, priv->bottom_card); if (G_UNLIKELY (top_tex == COGL_INVALID_HANDLE || bottom_tex == COGL_INVALID_HANDLE)) return; clutter_actor_get_allocation_box (actor, &alloc_box); /* Draw both sides of the card. Backface culling is enabled so only one side will actually be rendered */ cogl_set_source_texture (top_tex); cogl_rectangle (0.0f, 0.0f, CLUTTER_UNITS_TO_FLOAT (alloc_box.x2 - alloc_box.x1), CLUTTER_UNITS_TO_FLOAT (alloc_box.y2 - alloc_box.y1)); cogl_set_source_texture (bottom_tex); /* Rotate along the y-axis about the center of the card to make the bottom of the card face the other way */ cogl_push_matrix (); cogl_translate (CLUTTER_UNITS_TO_DEVICE (alloc_box.x2 - alloc_box.x1) / 2, 0, 0); cogl_rotate (180, 0, 1, 0); cogl_translate (-CLUTTER_UNITS_TO_DEVICE (alloc_box.x2 - alloc_box.x1) / 2, 0, 0); cogl_rectangle (0.0f, 0.0f, CLUTTER_UNITS_TO_FLOAT (alloc_box.x2 - alloc_box.x1), CLUTTER_UNITS_TO_FLOAT (alloc_box.y2 - alloc_box.y1)); cogl_pop_matrix (); cogl_enable_backface_culling (FALSE); }
void _example_draw_at (int x, int y) { cogl_set_source_color4ub ('\xFF', '1', '1', 255); cogl_ortho (0, 64, 0, 64, -5, 5); CoglMatrix idmtx; cogl_matrix_init_identity (&idmtx); cogl_set_modelview_matrix (&idmtx); cogl_rectangle (x+1, y+1, x-1, y-1); cogl_flush (); }
static void paint_cb (ClutterActor *actor) { int stage_width = clutter_actor_get_width (actor); int stage_height = clutter_actor_get_height (actor); int image_width = cogl_texture_get_width (redhand); int image_height = cogl_texture_get_height (redhand); cogl_set_source (material); cogl_rectangle (stage_width/2.0f - image_width/2.0f, stage_height/2.0f - image_height/2.0f, stage_width/2.0f + image_width/2.0f, stage_height/2.0f + image_height/2.0f); }
static void aisleriot_slot_renderer_paint (ClutterActor *actor) { AisleriotSlotRenderer *srend = (AisleriotSlotRenderer *) actor; AisleriotSlotRendererPrivate *priv = srend->priv; guint n_cards, n_animated_cards; guint i; g_return_if_fail (priv->cache != NULL); g_return_if_fail (priv->slot != NULL); n_cards = priv->slot->cards->len; n_animated_cards = priv->animations->len + priv->n_unexposed_animated_cards; g_assert (n_cards >= priv->slot->exposed); g_assert (priv->n_unexposed_animated_cards == 0 || priv->animations->len > 0); g_assert (n_cards >= n_animated_cards); if (n_cards <= n_animated_cards) { CoglHandle cogl_tex; guint tex_width, tex_height; cogl_tex = ar_card_textures_cache_get_slot_texture (priv->cache); if (G_UNLIKELY (cogl_tex == COGL_INVALID_HANDLE)) return; tex_width = cogl_texture_get_width (cogl_tex); tex_height = cogl_texture_get_height (cogl_tex); aisleriot_slot_renderer_set_material_for_card (srend, cogl_tex, priv->show_highlight); cogl_rectangle (0, 0, tex_width, tex_height); } else { guint first_card, last_card; first_card = MIN (n_cards - n_animated_cards - 1, n_cards - priv->slot->exposed); last_card = n_cards - n_animated_cards; for (i = first_card; i < last_card; i++) if (i != priv->revealed_card) aisleriot_slot_renderer_paint_card (srend, i); /* Paint the revealed card after all of the other cards so that it * will appeear on top. */ if (priv->revealed_card >= first_card && priv->revealed_card < last_card) aisleriot_slot_renderer_paint_card (srend, priv->revealed_card); } }
static VALUE rb_cogl_rectangle (VALUE self, VALUE x, VALUE y, VALUE width, VALUE height) { /* If all of the values are fixed nums then use the integer version */ if (FIXNUM_P (x) && FIXNUM_P (y) && FIXNUM_P (width) && FIXNUM_P (height)) cogl_rectangle (FIX2LONG (x), FIX2LONG (y), FIX2ULONG (width), FIX2ULONG (height)); else cogl_rectanglex (rbclt_num_to_fixed (x), rbclt_num_to_fixed (y), rbclt_num_to_fixed (width), rbclt_num_to_fixed (height)); return Qnil; }
static gboolean paint_cb (void *user_data) { CoglandCompositor *compositor = user_data; GList *l; for (l = compositor->outputs; l; l = l->next) { CoglandOutput *output = l->data; CoglFramebuffer *fb = COGL_FRAMEBUFFER (output->onscreen); GList *l2; cogl_push_framebuffer (fb); cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1); cogl_framebuffer_draw_primitive (fb, compositor->triangle_pipeline, compositor->triangle); for (l2 = compositor->surfaces; l2; l2 = l2->next) { CoglandSurface *surface = l2->data; if (surface->buffer) { CoglTexture2D *texture = surface->buffer->texture; cogl_set_source_texture (COGL_TEXTURE (texture)); cogl_rectangle (-1, 1, 1, -1); } } cogl_framebuffer_swap_buffers (fb); cogl_pop_framebuffer (); } while (!g_queue_is_empty (&compositor->frame_callbacks)) { CoglandFrameCallback *callback = g_queue_peek_head (&compositor->frame_callbacks); wl_resource_post_event (&callback->resource, WL_CALLBACK_DONE, get_time ()); wl_resource_destroy (&callback->resource, 0); } return TRUE; }
static void mnb_launcher_button_pick (ClutterActor *actor, const ClutterColor *color) { MnbLauncherButtonPrivate *priv = MNB_LAUNCHER_BUTTON (actor)->priv; ClutterGeometry geom; /* draw a rectangle to conver the entire actor */ clutter_actor_get_allocation_geometry (actor, &geom); cogl_set_source_color4ub (color->red, color->green, color->blue, color->alpha); cogl_rectangle (0, 0, geom.width, geom.height); if (priv->fav_toggle) clutter_actor_paint (priv->fav_toggle); }
/* * MxWidget::paint_background vfunction implementation. */ static void mpl_panel_background_paint_background (MxWidget *self, ClutterActor *background, const ClutterColor *color) { MxPadding padding = { 0, }; mx_widget_get_padding (self, &padding); /* * Paint any solid background colour that is not completely transparent. */ if (color && color->alpha != 0) { ClutterActor *actor = CLUTTER_ACTOR (self); ClutterActorBox allocation = { 0, }; ClutterColor bg_color = *color; gfloat w, h; bg_color.alpha = clutter_actor_get_paint_opacity (actor) * bg_color.alpha / 255; clutter_actor_get_allocation_box (actor, &allocation); w = allocation.x2 - allocation.x1; h = allocation.y2 - allocation.y1; cogl_set_source_color4ub (bg_color.red, bg_color.green, bg_color.blue, bg_color.alpha); cogl_rectangle (padding.left, padding.top, w - padding.left - padding.right, h - padding.top - padding.bottom); } /* * Now paint the asset. */ if (background) mpl_panel_background_paint_border_image (MX_TEXTURE_FRAME (background), &padding); }
static gboolean draw_rectangle (TestState *state, int x, int y, TestDepthState *rect_state) { guint8 Cr = MASK_RED (rect_state->color); guint8 Cg = MASK_GREEN (rect_state->color); guint8 Cb = MASK_BLUE (rect_state->color); guint8 Ca = MASK_ALPHA (rect_state->color); CoglHandle pipeline; CoglDepthState depth_state; cogl_depth_state_init (&depth_state); cogl_depth_state_set_test_enabled (&depth_state, rect_state->test_enable); cogl_depth_state_set_test_function (&depth_state, rect_state->test_function); cogl_depth_state_set_write_enabled (&depth_state, rect_state->write_enable); cogl_depth_state_set_range (&depth_state, rect_state->range_near, rect_state->range_far); pipeline = cogl_pipeline_new (); if (!cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL)) { cogl_object_unref (pipeline); return FALSE; } cogl_pipeline_set_color4ub (pipeline, Cr, Cg, Cb, Ca); cogl_set_source (pipeline); cogl_push_matrix (); cogl_translate (0, 0, rect_state->depth); cogl_rectangle (x * QUAD_WIDTH, y * QUAD_WIDTH, x * QUAD_WIDTH + QUAD_WIDTH, y * QUAD_WIDTH + QUAD_WIDTH); cogl_pop_matrix (); cogl_object_unref (pipeline); return TRUE; }
static void paint (TestState *state) { float stage_viewport[4]; CoglMatrix stage_projection; CoglMatrix stage_modelview; paint_test_backface_culling (state); /* * Now repeat the test but rendered to an offscreen * framebuffer. Note that by default the conformance tests are * always run to an offscreen buffer but we might as well have this * check anyway in case it is being run with COGL_TEST_ONSCREEN=1 */ cogl_get_viewport (stage_viewport); cogl_get_projection_matrix (&stage_projection); cogl_get_modelview_matrix (&stage_modelview); cogl_push_framebuffer (state->offscreen); cogl_set_viewport (stage_viewport[0], stage_viewport[1], stage_viewport[2], stage_viewport[3]); cogl_set_projection_matrix (&stage_projection); cogl_set_modelview_matrix (&stage_modelview); paint_test_backface_culling (state); cogl_pop_framebuffer (); /* Incase we want feedback of what was drawn offscreen we draw it * to the stage... */ cogl_set_source_texture (state->offscreen_tex); cogl_rectangle (0, TEXTURE_RENDER_SIZE * 16, stage_viewport[2], stage_viewport[3] + TEXTURE_RENDER_SIZE * 16); validate_result (0); validate_result (16); }
static gboolean paint_cb (void *user_data) { CoglandCompositor *compositor = user_data; GList *l; for (l = compositor->outputs; l; l = l->next) { CoglandOutput *output = l->data; CoglFramebuffer *fb = COGL_FRAMEBUFFER (output->onscreen); GList *l2; cogl_push_framebuffer (fb); #if 0 cogl_framebuffer_clear (fb, COGL_BUFFER_BIT_COLOR); #else cogl_clear (&black, COGL_BUFFER_BIT_COLOR); #endif cogl_primitive_draw (compositor->triangle); for (l2 = compositor->surfaces; l2; l2 = l2->next) { CoglandSurface *surface = l2->data; if (surface->buffer) { CoglTexture2D *texture = surface->buffer->texture; cogl_set_source_texture (texture); cogl_rectangle (-1, 1, 1, -1); } wl_display_post_frame (compositor->wayland_display, &surface->wayland_surface, get_time ()); } cogl_framebuffer_swap_buffers (fb); cogl_pop_framebuffer (); } return TRUE; }
static void hand_post_paint (ClutterActor *actor, gpointer user_data) { SuperOH *oh = user_data; gfloat w, h; int actor_num; for (actor_num = 0; oh->hand[actor_num] != actor; actor_num++) ; g_assert (oh->paint_guards[actor_num] == TRUE); clutter_actor_get_size (actor, &w, &h); cogl_set_source_color4ub (0, 255, 0, 128); cogl_rectangle (w / 2, h / 2, w, h); oh->paint_guards[actor_num] = FALSE; }
void cogl2_path_fill (CoglPath *path) { _COGL_RETURN_IF_FAIL (cogl_is_path (path)); if (path->data->path_nodes->len == 0) return; /* If the path is a simple rectangle then we can divert to using cogl_rectangle which should be faster because it can go through the journal instead of uploading the geometry just for two triangles */ if (path->data->is_rectangle) { float x_1, y_1, x_2, y_2; _cogl_path_get_bounds (path, &x_1, &y_1, &x_2, &y_2); cogl_rectangle (x_1, y_1, x_2, y_2); } else _cogl_path_fill_nodes (path, 0); }
static void test_rectangles (TestState *state) { #define RECT_WIDTH 5 #define RECT_HEIGHT 5 int x; int y; /* Should the rectangles be randomly positioned/colored/rotated? * * It could be good to develop equivalent GL and Cairo tests so we can * have a sanity check for our Cogl performance. * * The color should vary to check that we correctly batch color changes * The use of alpha should vary so we have a variation of which rectangles * require blending. * Should this be a random variation? * It could be good to experiment with focibly enabling blending for * rectangles that don't technically need it for the sake of extending * batching. E.g. if you a long run of interleved rectangles with every * other rectangle needing blending then it may be worth enabling blending * for all the rectangles to avoid the state changes. * The modelview should change between rectangles to check the software * transform codepath. * Should we group some rectangles under the same modelview? Potentially * we could avoid software transform for long runs of rectangles with the * same modelview. * */ for (y = 0; y < STAGE_HEIGHT; y += RECT_HEIGHT) { for (x = 0; x < STAGE_WIDTH; x += RECT_WIDTH) { cogl_push_matrix (); cogl_translate (x, y, 0); cogl_rotate (45, 0, 0, 1); cogl_set_source_color4f (1, (1.0f/STAGE_WIDTH)*y, (1.0f/STAGE_HEIGHT)*x, 1); cogl_rectangle (0, 0, RECT_WIDTH, RECT_HEIGHT); cogl_pop_matrix (); } } for (y = 0; y < STAGE_HEIGHT; y += RECT_HEIGHT) { for (x = 0; x < STAGE_WIDTH; x += RECT_WIDTH) { cogl_push_matrix (); cogl_translate (x, y, 0); cogl_rotate (0, 0, 0, 1); cogl_set_source_color4f (1, (1.0f/STAGE_WIDTH)*x, (1.0f/STAGE_HEIGHT)*y, (1.0f/STAGE_WIDTH)*x); cogl_rectangle (0, 0, RECT_WIDTH, RECT_HEIGHT); cogl_pop_matrix (); } } }
static void mnb_toolbar_background_paint_background (MxWidget *self, ClutterActor *background, const ClutterColor *color) { MnbToolbarBackgroundPrivate *priv = TOOLBAR_BACKGROUND_PRIVATE (self); ClutterActor *actor = (ClutterActor *) self; CoglHandle cogl_texture, cogl_material; ClutterActorBox box = { 0, }; gfloat width, height; gfloat tex_width, tex_height; gfloat ex, ey; gfloat tx1, ty1, tx2, ty2; guint8 opacity; /* Copied from MxWidget: * * Default implementation just draws the background * colour and the image on top */ if (color && color->alpha != 0) { ClutterColor bg_color = *color; bg_color.alpha = clutter_actor_get_paint_opacity (actor) * bg_color.alpha / 255; clutter_actor_get_allocation_box (actor, &box); width = box.x2 - box.x1; height = box.y2 - box.y1; cogl_set_source_color4ub (bg_color.red, bg_color.green, bg_color.blue, bg_color.alpha); cogl_rectangle (0, 0, width, height); } /* * Copied from MxTextureFrame */ /* no need to paint stuff if we don't have a texture */ if (G_UNLIKELY (priv->parent_texture == NULL)) return; cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture); if (cogl_texture == COGL_INVALID_HANDLE) return; cogl_material = clutter_texture_get_cogl_material (priv->parent_texture); if (cogl_material == COGL_INVALID_HANDLE) return; tex_width = cogl_texture_get_width (cogl_texture); tex_height = cogl_texture_get_height (cogl_texture); clutter_actor_get_allocation_box (actor, &box); width = box.x2 - box.x1; height = box.y2 - box.y1; opacity = clutter_actor_get_paint_opacity (actor); /* Paint using the parent texture's material. It should already have the cogl texture set as the first layer */ /* NB: for correct blending we need set a preumultiplied color here: */ cogl_material_set_color4ub (cogl_material, opacity, opacity, opacity, opacity); selector_texture = mnb_toolbar_get_selector_texture (priv->toolbar); cogl_material_set_layer (cogl_material, 1, selector_texture); cogl_material_set_layer_wrap_mode (cogl_material, 1, COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE); if (!cogl_material_set_layer_combine (cogl_material, 1, "RGBA = MODULATE(PREVIOUS,TEXTURE)", &error)) { g_warning (G_STRLOC ": Error setting layer combine blend string: %s", error->message); g_error_free (error); } cogl_set_source (cogl_material); /* simple stretch */ if (priv->left == 0 && priv->right == 0 && priv->top == 0 && priv->bottom == 0) { float spot_width, spot_height; float coords[8] = { 0, 0, 1, 1, 0, 0, 0, 0 }; mnb_toolbar_get_selector_allocation_box (priv->toolbar, &box); spot_width = box.x2 - box.x1; spot_height = box.y2 - box.y1; coords[4] = -(box.x1 / width) * (width / spot_width); coords[5] = -(box.y1 / height) * (height / spot_height); coords[6] = width / spot_width - (box.x1 / width) * (width / spot_width); coords[7] = height / spot_height - (box.y1 / height) * (height / spot_height); cogl_rectangle_with_multitexture_coords (0, 0, width, height, coords, 8); return; } tx1 = priv->left / tex_width; tx2 = (tex_width - priv->right) / tex_width; ty1 = priv->top / tex_height; ty2 = (tex_height - priv->bottom) / tex_height; ex = width - priv->right; if (ex < priv->left) ex = priv->left; ey = height - priv->bottom; if (ey < priv->top) ey = priv->top; { GLfloat rectangles[] = { /* top left corner */ 0, 0, priv->left, priv->top, 0.0, 0.0, tx1, ty1, /* top middle */ priv->left, 0, MAX (priv->left, ex), priv->top, tx1, 0.0, tx2, ty1, /* top right */ ex, 0, MAX (ex + priv->right, width), priv->top, tx2, 0.0, 1.0, ty1, /* mid left */ 0, priv->top, priv->left, ey, 0.0, ty1, tx1, ty2, /* center */ priv->left, priv->top, ex, ey, tx1, ty1, tx2, ty2, /* mid right */ ex, priv->top, MAX (ex + priv->right, width), ey, tx2, ty1, 1.0, ty2, /* bottom left */ 0, ey, priv->left, MAX (ey + priv->bottom, height), 0.0, ty2, tx1, 1.0, /* bottom center */ priv->left, ey, ex, MAX (ey + priv->bottom, height), tx1, ty2, tx2, 1.0, /* bottom right */ ex, ey, MAX (ex + priv->right, width), MAX (ey + priv->bottom, height), tx2, ty2, 1.0, 1.0 }; cogl_rectangles_with_texture_coords (rectangles, 9); } }
static void clutter_rectangle_paint (ClutterActor *self) { ClutterRectangle *rectangle = CLUTTER_RECTANGLE(self); ClutterRectanglePrivate *priv; ClutterGeometry geom; ClutterColor tmp_col; rectangle = CLUTTER_RECTANGLE(self); priv = rectangle->priv; CLUTTER_NOTE (PAINT, "painting rect '%s'", clutter_actor_get_name (self) ? clutter_actor_get_name (self) : "unknown"); clutter_actor_get_allocation_geometry (self, &geom); CLUTTER_NOTE (PAINT, "paint to x1: %i, y1: %i x2: %i, y2: %i " "opacity: %i", geom.x, geom.y, geom.x+geom.width, geom.y+geom.height, clutter_actor_get_opacity (self)); /* parent paint call will have translated us into position so * paint from 0, 0 */ if (priv->has_border) { tmp_col.red = priv->border_color.red; tmp_col.green = priv->border_color.green; tmp_col.blue = priv->border_color.blue; tmp_col.alpha = clutter_actor_get_paint_opacity (self) * priv->border_color.alpha / 255; cogl_color (&tmp_col); /* this sucks, but it's the only way to make a border */ cogl_rectangle (priv->border_width, 0, geom.width - priv->border_width, priv->border_width); cogl_rectangle (geom.width - priv->border_width, priv->border_width, priv->border_width, geom.height - priv->border_width); cogl_rectangle (0, geom.height - priv->border_width, geom.width - priv->border_width, priv->border_width); cogl_rectangle (0, 0, priv->border_width, geom.height - priv->border_width); tmp_col.red = priv->color.red; tmp_col.green = priv->color.green; tmp_col.blue = priv->color.blue; tmp_col.alpha = clutter_actor_get_paint_opacity (self) * priv->color.alpha / 255; cogl_color (&tmp_col); cogl_rectangle (priv->border_width, priv->border_width, geom.width - priv->border_width * 2, geom.height - priv->border_width * 2); } else { tmp_col.red = priv->color.red; tmp_col.green = priv->color.green; tmp_col.blue = priv->color.blue; tmp_col.alpha = clutter_actor_get_paint_opacity (self) * priv->color.alpha / 255; cogl_color (&tmp_col); cogl_rectangle (0, 0, geom.width, geom.height); } }
static void on_paint (ClutterActor *actor, CallbackData *data) { int i; ClutterGeometry stage_size; gint hand_width, hand_height; GSList *node; clutter_actor_get_allocation_geometry (data->stage, &stage_size); hand_width = cogl_texture_get_width (data->hand); hand_height = cogl_texture_get_height (data->hand); /* Setup the clipping */ for (node = data->clips; node; node = node->next) { Clip *clip = (Clip *) node->data; if (clip->type == CLIP_RECTANGLE) cogl_clip_push_rectangle (clip->x1, clip->y1, clip->x2, clip->y2); else if (clip->type == CLIP_ROTATED_RECTANGLE) { float size = MIN (ABS (clip->x2 - clip->x1), ABS (clip->y2 - clip->y1)); int cx = (clip->x1 + clip->x2) / 2; int cy = (clip->y1 + clip->y2) / 2; size = sqrtf ((size / 2) * (size / 2) * 2); cogl_push_matrix (); /* Rotate 45° about the centre point */ cogl_translate (cx, cy, 0.0f); cogl_rotate (45.0f, 0.0f, 0.0f, 1.0f); cogl_clip_push_rectangle (-size / 2, -size / 2, size / 2, size / 2); cogl_pop_matrix (); } else { make_clip_path (clip); cogl_clip_push_from_path (); } } /* Draw a rectangle filling the entire stage */ cogl_set_source_color4ub (0x80, 0x80, 0xff, 0xff); cogl_rectangle (0, 0, stage_size.width, stage_size.height); draw_shapes (10, 10); /* Draw the hand at different rotations */ for (i = -2; i <= 2; i++) { cogl_push_matrix (); cogl_translate (stage_size.width / 2 + stage_size.width / 6 * i, stage_size.height / 2, 0); cogl_rotate (i * 40, 0, 1, 0); cogl_set_source_color4ub (0xff, 0xff, 0xff, 0xff); cogl_set_source_texture (data->hand); cogl_rectangle_with_texture_coords ((-hand_width / 2), (-hand_height / 2), (hand_width / 2), (hand_height / 2), 0, 0, 1, 1); cogl_pop_matrix (); } draw_shapes (stage_size.width - 310, stage_size.height - 110); /* Remove all of the clipping */ g_slist_foreach (data->clips, (GFunc) cogl_clip_pop, NULL); /* Draw the bounding box for each of the clips */ for (node = data->clips; node; node = node->next) { Clip *clip = (Clip *) node->data; make_clip_path (clip); cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff); cogl_path_stroke (); } /* Draw the bounding box for the pending new clip */ if (data->current_clip.type != CLIP_NONE) { make_clip_path (&data->current_clip); cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff); cogl_path_stroke (); } }
void add_stencil_clip_rectangle (float x_1, float y_1, float x_2, float y_2, gboolean first) { CoglHandle current_source; CoglHandle framebuffer = _cogl_get_framebuffer (); _COGL_GET_CONTEXT (ctx, NO_RETVAL); /* We don't log changes to the stencil buffer so need to flush any * batched geometry before we start... */ _cogl_journal_flush (); _cogl_framebuffer_flush_state (framebuffer, 0); /* temporarily swap in our special stenciling material */ current_source = cogl_handle_ref (ctx->source_material); cogl_set_source (ctx->stencil_material); if (first) { GE( glEnable (GL_STENCIL_TEST) ); /* Initially disallow everything */ GE( glClearStencil (0) ); GE( glClear (GL_STENCIL_BUFFER_BIT) ); /* Punch out a hole to allow the rectangle */ GE( glStencilFunc (GL_NEVER, 0x1, 0x1) ); GE( glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE) ); cogl_rectangle (x_1, y_1, x_2, y_2); } else { CoglMatrixStack *modelview_stack = _cogl_framebuffer_get_modelview_stack (framebuffer); CoglMatrixStack *projection_stack = _cogl_framebuffer_get_projection_stack (framebuffer); /* Add one to every pixel of the stencil buffer in the rectangle */ GE( glStencilFunc (GL_NEVER, 0x1, 0x3) ); GE( glStencilOp (GL_INCR, GL_INCR, GL_INCR) ); cogl_rectangle (x_1, y_1, x_2, y_2); /* make sure our rectangle hits the stencil buffer before we * change the stencil operation */ _cogl_journal_flush (); /* Subtract one from all pixels in the stencil buffer so that only pixels where both the original stencil buffer and the rectangle are set will be valid */ GE( glStencilOp (GL_DECR, GL_DECR, GL_DECR) ); _cogl_matrix_stack_push (projection_stack); _cogl_matrix_stack_load_identity (projection_stack); _cogl_matrix_stack_push (modelview_stack); _cogl_matrix_stack_load_identity (modelview_stack); cogl_rectangle (-1.0, -1.0, 1.0, 1.0); _cogl_matrix_stack_pop (modelview_stack); _cogl_matrix_stack_pop (projection_stack); } /* make sure our rectangles hit the stencil buffer before we restore * the stencil function / operation */ _cogl_journal_flush (); /* Restore the stencil mode */ GE( glStencilFunc (GL_EQUAL, 0x1, 0x1) ); GE( glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP) ); /* restore the original source material */ cogl_set_source (current_source); cogl_handle_unref (current_source); }
static CoglBool draw_rectangle (TestState *state, int x, int y, TestDepthState *rect_state, CoglBool legacy_mode) { uint8_t Cr = MASK_RED (rect_state->color); uint8_t Cg = MASK_GREEN (rect_state->color); uint8_t Cb = MASK_BLUE (rect_state->color); uint8_t Ca = MASK_ALPHA (rect_state->color); CoglPipeline *pipeline; CoglDepthState depth_state; cogl_depth_state_init (&depth_state); cogl_depth_state_set_test_enabled (&depth_state, rect_state->test_enable); cogl_depth_state_set_test_function (&depth_state, rect_state->test_function); cogl_depth_state_set_write_enabled (&depth_state, rect_state->write_enable); cogl_depth_state_set_range (&depth_state, rect_state->range_near, rect_state->range_far); pipeline = cogl_pipeline_new (test_ctx); if (!cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL)) { cogl_object_unref (pipeline); return FALSE; } if (!legacy_mode) { cogl_pipeline_set_color4ub (pipeline, Cr, Cg, Cb, Ca); cogl_framebuffer_set_depth_write_enabled (test_fb, rect_state->fb_write_enable); cogl_framebuffer_push_matrix (test_fb); cogl_framebuffer_translate (test_fb, 0, 0, rect_state->depth); cogl_framebuffer_draw_rectangle (test_fb, pipeline, x * QUAD_WIDTH, y * QUAD_WIDTH, x * QUAD_WIDTH + QUAD_WIDTH, y * QUAD_WIDTH + QUAD_WIDTH); cogl_framebuffer_pop_matrix (test_fb); } else { cogl_push_framebuffer (test_fb); cogl_push_matrix (); cogl_set_source_color4ub (Cr, Cg, Cb, Ca); cogl_translate (0, 0, rect_state->depth); cogl_rectangle (x * QUAD_WIDTH, y * QUAD_WIDTH, x * QUAD_WIDTH + QUAD_WIDTH, y * QUAD_WIDTH + QUAD_WIDTH); cogl_pop_matrix (); cogl_pop_framebuffer (); } cogl_object_unref (pipeline); return TRUE; }