static void pre_paint_windows (MetaCompositor *compositor) { GList *l; MetaWindowActor *top_window; if (compositor->onscreen == NULL) { compositor->onscreen = COGL_ONSCREEN (cogl_get_draw_framebuffer ()); compositor->frame_closure = cogl_onscreen_add_frame_callback (compositor->onscreen, frame_callback, compositor, NULL); } if (compositor->windows == NULL) return; top_window = g_list_last (compositor->windows)->data; if (meta_window_actor_should_unredirect (top_window) && compositor->disable_unredirect_count == 0) set_unredirected_window (compositor, meta_window_actor_get_meta_window (top_window)); else set_unredirected_window (compositor, NULL); for (l = compositor->windows; l; l = l->next) meta_window_actor_pre_paint (l->data); if (compositor->frame_has_updated_xsurfaces) { /* We need to make sure that any X drawing that happens before * the XDamageSubtract() for each window above is visible to * subsequent GL rendering; the only standardized way to do this * is EXT_x11_sync_object, which isn't yet widely available. For * now, we count on details of Xorg and the open source drivers, * and hope for the best otherwise. * * Xorg and open source driver specifics: * * The X server makes sure to flush drawing to the kernel before * sending out damage events, but since we use * DamageReportBoundingBox there may be drawing between the last * damage event and the XDamageSubtract() that needs to be * flushed as well. * * Xorg always makes sure that drawing is flushed to the kernel * before writing events or responses to the client, so any * round trip request at this point is sufficient to flush the * GLX buffers. */ XSync (compositor->display->xdisplay, False); compositor->frame_has_updated_xsurfaces = FALSE; } }
static void _set_up_pipeline (gpointer instance, gpointer user_data) { Data* data = (Data*) user_data; /* The cogl-gst sink, depending on the video format, can use up to 3 texture layers to render a frame. To avoid overwriting frame data, the first free layer in the cogl pipeline needs to be queried before adding any additional textures. */ int free_layer = cogl_gst_video_sink_get_free_layer (data->sink); data->video_pipeline = cogl_gst_video_sink_get_pipeline (data->sink); while (free_layer > 0) { free_layer--; cogl_pipeline_set_layer_filters (data->video_pipeline, free_layer, COGL_PIPELINE_FILTER_LINEAR_MIPMAP_LINEAR, COGL_PIPELINE_FILTER_LINEAR); } /* disable blending... */ cogl_pipeline_set_blend (data->video_pipeline, "RGBA = ADD (SRC_COLOR, 0)", NULL); /* Now that we know the video size we can perform letterboxing */ _resize_callback (COGL_ONSCREEN (data->fb), data->onscreen_width, data->onscreen_height, data); cogl_onscreen_add_frame_callback (COGL_ONSCREEN (data->fb), _frame_callback, data, NULL); /* The cogl-gst-new-frame signal is emitted when the cogl-gst sink has retrieved a new frame and attached it to the cogl pipeline. This can be used to make sure cogl doesn't do any unnecessary drawing i.e. keeps to the frame-rate of the video. */ g_signal_connect (data->sink, "new-frame", G_CALLBACK (_new_frame_cb), data); }
int main (int argc, char **argv) { Data data; CoglOnscreen *onscreen; CoglError *error = NULL; CoglVertexP2C4 triangle_vertices[] = { {0, 0.7, 0xff, 0x00, 0x00, 0x80}, {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff}, {0.7, -0.7, 0x00, 0x00, 0xff, 0xff} }; GSource *cogl_source; GMainLoop *loop; data.ctx = cogl_context_new (NULL, &error); if (!data.ctx) { fprintf (stderr, "Failed to create context: %s\n", error->message); return 1; } onscreen = cogl_onscreen_new (data.ctx, 640, 480); cogl_onscreen_show (onscreen); data.fb = COGL_FRAMEBUFFER (onscreen); cogl_onscreen_set_resizable (onscreen, TRUE); data.triangle = cogl_primitive_new_p2c4 (data.ctx, COGL_VERTICES_MODE_TRIANGLES, 3, triangle_vertices); data.pipeline = cogl_pipeline_new (data.ctx); cogl_source = cogl_glib_source_new (data.ctx, G_PRIORITY_DEFAULT); g_source_attach (cogl_source, NULL); cogl_onscreen_add_frame_callback (COGL_ONSCREEN (data.fb), frame_event_cb, &data, NULL); /* destroy notify */ g_idle_add (paint_cb, &data); loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); return 0; }
int main (int argc, char **argv) { CoglContext *ctx; CoglOnscreen *onscreen; CoglError *error = NULL; CoglVertexP2C4 triangle_vertices[] = { {0, 0.7, 0xff, 0x00, 0x00, 0xff}, {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff}, {0.7, -0.7, 0x00, 0x00, 0xff, 0xff} }; Data data; SDL_Event event; ctx = cogl_sdl_context_new (SDL_USEREVENT, &error); if (!ctx) { fprintf (stderr, "Failed to create context: %s\n", error->message); return 1; } onscreen = cogl_onscreen_new (ctx, 800, 600); data.fb = COGL_FRAMEBUFFER (onscreen); cogl_onscreen_add_frame_callback (onscreen, frame_cb, &data, NULL /* destroy callback */); cogl_onscreen_add_dirty_callback (onscreen, dirty_cb, &data, NULL /* destroy callback */); data.center_x = 0.0f; data.center_y = 0.0f; data.quit = FALSE; cogl_onscreen_show (onscreen); data.triangle = cogl_primitive_new_p2c4 (ctx, COGL_VERTICES_MODE_TRIANGLES, 3, triangle_vertices); data.pipeline = cogl_pipeline_new (ctx); data.redraw_queued = FALSE; data.ready_to_draw = TRUE; while (!data.quit) { if (!SDL_PollEvent (&event)) { if (data.redraw_queued && data.ready_to_draw) { redraw (&data); data.redraw_queued = FALSE; data.ready_to_draw = FALSE; continue; } cogl_sdl_idle (ctx); if (!SDL_WaitEvent (&event)) { fprintf (stderr, "Error waiting for SDL events"); return 1; } } handle_event (&data, &event); cogl_sdl_handle_event (ctx, &event); } cogl_object_unref (ctx); return 0; }
int main (int argc, char **argv) { CoglContext *ctx; CoglOnscreen *onscreen; CoglFramebuffer *fb; CoglError *error = NULL; Data data; PangoRectangle hello_label_size; float fovy, aspect, z_near, z_2d, z_far; CoglDepthState depth_state; ctx = cogl_context_new (NULL, &error); if (!ctx) { fprintf (stderr, "Failed to create context: %s\n", error->message); return 1; } onscreen = cogl_onscreen_new (ctx, 640, 480); fb = COGL_FRAMEBUFFER (onscreen); data.fb = fb; data.framebuffer_width = cogl_framebuffer_get_width (fb); data.framebuffer_height = cogl_framebuffer_get_height (fb); data.timer = g_timer_new (); cogl_onscreen_show (onscreen); cogl_framebuffer_set_viewport (fb, 0, 0, data.framebuffer_width, data.framebuffer_height); fovy = 60; /* y-axis field of view */ aspect = (float)data.framebuffer_width/(float)data.framebuffer_height; z_near = 0.1; /* distance to near clipping plane */ z_2d = 1000; /* position to 2d plane */ z_far = 2000; /* distance to far clipping plane */ cogl_framebuffer_perspective (fb, fovy, aspect, z_near, z_far); /* Since the pango renderer emits geometry in pixel/device coordinates * and the anti aliasing is implemented with the assumption that the * geometry *really* does end up pixel aligned, we setup a modelview * matrix so that for geometry in the plane z = 0 we exactly map x * coordinates in the range [0,stage_width] and y coordinates in the * range [0,stage_height] to the framebuffer extents with (0,0) being * the top left. * * This is roughly what Clutter does for a ClutterStage, but this * demonstrates how it is done manually using Cogl. */ cogl_matrix_init_identity (&data.view); cogl_matrix_view_2d_in_perspective (&data.view, fovy, aspect, z_near, z_2d, data.framebuffer_width, data.framebuffer_height); cogl_framebuffer_set_modelview_matrix (fb, &data.view); /* Initialize some convenient constants */ cogl_matrix_init_identity (&identity); cogl_color_init_from_4ub (&white, 0xff, 0xff, 0xff, 0xff); /* rectangle indices allow the GPU to interpret a list of quads (the * faces of our cube) as a list of triangles. * * Since this is a very common thing to do * cogl_get_rectangle_indices() is a convenience function for * accessing internal index buffers that can be shared. */ data.indices = cogl_get_rectangle_indices (ctx, 6 /* n_rectangles */); data.prim = cogl_primitive_new_p3t2 (ctx, COGL_VERTICES_MODE_TRIANGLES, G_N_ELEMENTS (vertices), vertices); /* Each face will have 6 indices so we have 6 * 6 indices in total... */ cogl_primitive_set_indices (data.prim, data.indices, 6 * 6); /* Load a jpeg crate texture from a file */ printf ("crate.jpg (CC by-nc-nd http://bit.ly/9kP45T) ShadowRunner27 http://bit.ly/m1YXLh\n"); data.texture = COGL_TEXTURE ( cogl_texture_2d_new_from_file (ctx, COGL_EXAMPLES_DATA "crate.jpg", COGL_PIXEL_FORMAT_ANY, &error)); if (!data.texture) g_error ("Failed to load texture: %s", error->message); /* a CoglPipeline conceptually describes all the state for vertex * processing, fragment processing and blending geometry. When * drawing the geometry for the crate this pipeline says to sample a * single texture during fragment processing... */ data.crate_pipeline = cogl_pipeline_new (ctx); cogl_pipeline_set_layer_texture (data.crate_pipeline, 0, data.texture); /* Since the box is made of multiple triangles that will overlap * when drawn and we don't control the order they are drawn in, we * enable depth testing to make sure that triangles that shouldn't * be visible get culled by the GPU. */ cogl_depth_state_init (&depth_state); cogl_depth_state_set_test_enabled (&depth_state, TRUE); cogl_pipeline_set_depth_state (data.crate_pipeline, &depth_state, NULL); /* Setup a Pango font map and context */ data.pango_font_map = COGL_PANGO_FONT_MAP (cogl_pango_font_map_new (ctx)); cogl_pango_font_map_set_use_mipmapping (data.pango_font_map, TRUE); data.pango_context = pango_font_map_create_context (PANGO_FONT_MAP (data.pango_font_map)); data.pango_font_desc = pango_font_description_new (); pango_font_description_set_family (data.pango_font_desc, "Sans"); pango_font_description_set_size (data.pango_font_desc, 30 * PANGO_SCALE); /* Setup the "Hello Cogl" text */ data.hello_label = pango_layout_new (data.pango_context); pango_layout_set_font_description (data.hello_label, data.pango_font_desc); pango_layout_set_text (data.hello_label, "Hello Cogl", -1); pango_layout_get_extents (data.hello_label, NULL, &hello_label_size); data.hello_label_width = PANGO_PIXELS (hello_label_size.width); data.hello_label_height = PANGO_PIXELS (hello_label_size.height); data.swap_ready = TRUE; cogl_onscreen_add_frame_callback (COGL_ONSCREEN (fb), frame_event_cb, &data, NULL); /* destroy notify */ while (1) { CoglPollFD *poll_fds; int n_poll_fds; int64_t timeout; if (data.swap_ready) { paint (&data); cogl_onscreen_swap_buffers (COGL_ONSCREEN (fb)); } cogl_poll_renderer_get_info (cogl_context_get_renderer (ctx), &poll_fds, &n_poll_fds, &timeout); g_poll ((GPollFD *) poll_fds, n_poll_fds, timeout == -1 ? -1 : timeout / 1000); cogl_poll_renderer_dispatch (cogl_context_get_renderer (ctx), poll_fds, n_poll_fds); } return 0; }
int main (int argc, char *argv[]) { CoglTexture *tex; CoglOnscreen *onscreen; GSource *cogl_source; GMainLoop *loop; Data data; int i; data.context = cogl_context_new (NULL, NULL); create_primitive (&data); data.pipeline = cogl_pipeline_new (data.context); data.last_spark_time = g_timer_new (); data.next_spark_num = 0; cogl_pipeline_set_point_size (data.pipeline, TEXTURE_SIZE); tex = generate_round_texture (data.context); cogl_pipeline_set_layer_texture (data.pipeline, 0, tex); cogl_object_unref (tex); cogl_pipeline_set_layer_point_sprite_coords_enabled (data.pipeline, 0, /* layer */ TRUE, NULL /* error */); for (i = 0; i < N_FIREWORKS; i++) { data.fireworks[i].x = -FLT_MAX; data.fireworks[i].y = FLT_MAX; data.fireworks[i].size = 0.0f; data.fireworks[i].timer = g_timer_new (); } for (i = 0; i < N_SPARKS; i++) { data.sparks[i].x = 2.0f; data.sparks[i].y = 2.0f; } onscreen = cogl_onscreen_new (data.context, 800, 600); cogl_onscreen_show (onscreen); data.fb = onscreen; cogl_source = cogl_glib_source_new (data.context, G_PRIORITY_DEFAULT); g_source_attach (cogl_source, NULL); cogl_onscreen_add_frame_callback (onscreen, frame_event_cb, &data, NULL /* destroy notify */); loop = g_main_loop_new (NULL, TRUE); paint (&data); g_main_loop_run (loop); g_main_loop_unref (loop); g_source_destroy (cogl_source); cogl_object_unref (data.pipeline); cogl_object_unref (data.attribute_buffer); cogl_object_unref (data.primitive); cogl_object_unref (onscreen); cogl_object_unref (data.context); g_timer_destroy (data.last_spark_time); for (i = 0; i < N_FIREWORKS; i++) g_timer_destroy (data.fireworks[i].timer); return 0; }
int main (int argc, char **argv) { Data data; CoglOnscreen *onscreen; CoglError *error = NULL; CoglVertexP2C4 triangle_vertices[] = { {0, 0.7, 0xff, 0x00, 0x00, 0xff}, {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff}, {0.7, -0.7, 0x00, 0x00, 0xff, 0xff} }; GSource *cogl_source; GMainLoop *loop; CoglRenderer *renderer; CoglDisplay *display; renderer = cogl_renderer_new (); cogl_renderer_add_constraint (renderer, COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2); display = cogl_display_new (renderer, NULL); data.ctx = cogl_context_new (display, NULL); onscreen = cogl_onscreen_new (data.ctx, 640, 480); cogl_onscreen_show (onscreen); data.fb = COGL_FRAMEBUFFER (onscreen); /* Prepare onscreen primitive */ data.triangle = cogl_primitive_new_p2c4 (data.ctx, COGL_VERTICES_MODE_TRIANGLES, 3, triangle_vertices); data.pipeline = cogl_pipeline_new (data.ctx); data.offscreen_texture = COGL_TEXTURE ( cogl_texture_2d_new_with_size (data.ctx, OFFSCREEN_WIDTH, OFFSCREEN_HEIGHT, COGL_PIXEL_FORMAT_ANY)); data.offscreen = cogl_offscreen_new_to_texture (data.offscreen_texture); data.gles2_ctx = cogl_gles2_context_new (data.ctx, &error); if (!data.gles2_ctx) { g_error ("Failed to create GLES2 context: %s\n", error->message); } data.gles2_vtable = cogl_gles2_context_get_vtable (data.gles2_ctx); /* Draw scene with GLES2 */ if (!cogl_push_gles2_context (data.ctx, data.gles2_ctx, data.fb, data.fb, &error)) { g_error ("Failed to push gles2 context: %s\n", error->message); } cogl_pop_gles2_context (data.ctx); cogl_source = cogl_glib_source_new (data.ctx, G_PRIORITY_DEFAULT); g_source_attach (cogl_source, NULL); cogl_onscreen_add_frame_callback (COGL_ONSCREEN (data.fb), frame_event_cb, &data, NULL); /* destroy notify */ g_idle_add (paint_cb, &data); loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); return 0; }
static gboolean meta_pre_paint_func (gpointer data) { GList *l; MetaWindowActor *top_window; MetaCompositor *compositor = data; if (compositor->onscreen == NULL) { compositor->onscreen = COGL_ONSCREEN (cogl_get_draw_framebuffer ()); compositor->frame_closure = cogl_onscreen_add_frame_callback (compositor->onscreen, frame_callback, compositor, NULL); } if (compositor->windows == NULL) return TRUE; top_window = g_list_last (compositor->windows)->data; if (meta_window_actor_should_unredirect (top_window) && compositor->disable_unredirect_count == 0) set_unredirected_window (compositor, meta_window_actor_get_meta_window (top_window)); else set_unredirected_window (compositor, NULL); for (l = compositor->windows; l; l = l->next) meta_window_actor_pre_paint (l->data); if (compositor->frame_has_updated_xsurfaces) { /* We need to make sure that any X drawing that happens before * the XDamageSubtract() for each window above is visible to * subsequent GL rendering; the standardized way to do this is * GL_EXT_X11_sync_object. Since this isn't implemented yet in * mesa, we also have a path that relies on the implementation * of the open source drivers. * * Anything else, we just hope for the best. * * Xorg and open source driver specifics: * * The X server makes sure to flush drawing to the kernel before * sending out damage events, but since we use * DamageReportBoundingBox there may be drawing between the last * damage event and the XDamageSubtract() that needs to be * flushed as well. * * Xorg always makes sure that drawing is flushed to the kernel * before writing events or responses to the client, so any * round trip request at this point is sufficient to flush the * GLX buffers. */ if (compositor->have_x11_sync_object) compositor->have_x11_sync_object = meta_sync_ring_insert_wait (); else XSync (compositor->display->xdisplay, False); } return TRUE; }
int main (int argc, char **argv) { Data data; CoglOnscreen *onscreen; CoglError *error = NULL; GSource *cogl_source; GMainLoop *loop; CoglRenderer *renderer; CoglDisplay *display; renderer = cogl_renderer_new (); cogl_renderer_add_constraint (renderer, COGL_RENDERER_CONSTRAINT_SUPPORTS_COGL_GLES2); display = cogl_display_new (renderer, NULL); data.ctx = cogl_context_new (display, NULL); onscreen = cogl_onscreen_new (data.ctx, 300, 300); cogl_onscreen_show (onscreen); data.fb = COGL_FRAMEBUFFER (onscreen); data.gles2_ctx = cogl_gles2_context_new (data.ctx, &error); if (!data.gles2_ctx) g_error ("Failed to create GLES2 context: %s\n", error->message); /* Draw scene with GLES2 */ if (!cogl_push_gles2_context (data.ctx, data.gles2_ctx, data.fb, data.fb, &error)) { g_error ("Failed to push gles2 context: %s\n", error->message); } gears_reshape (cogl_framebuffer_get_width (data.fb), cogl_framebuffer_get_height (data.fb)); /* Initialize the gears */ gears_init(); cogl_pop_gles2_context (data.ctx); cogl_source = cogl_glib_source_new (data.ctx, G_PRIORITY_DEFAULT); g_source_attach (cogl_source, NULL); cogl_onscreen_add_frame_callback (COGL_ONSCREEN (data.fb), frame_event_cb, &data, NULL); /* destroy notify */ g_idle_add (paint_cb, &data); data.timer = g_timer_new (); data.frames = 0; data.last_elapsed = 0; loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); return 0; }