sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/examples/cogland.c

1174 lines
32 KiB
C
Raw Normal View History

Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
#include <cogl/cogl.h>
Create standalone public wayland client/server headers Because the wayland-client-protocol.h header defines symbols that collide with the wayland-server-protocol.h header we allow applications to explicitly ensure that they are only including one at a time by exposing corresponding <cogl/cogl-wayland-client.h> and <cogl/cogl-wayland-server.h> headers. This also adds a missing guard to cogl-texture-2d.h that it isn't included directly. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-03-20 13:21:18 +00:00
#include <cogl/cogl-wayland-server.h>
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
#include <glib.h>
#include <stdio.h>
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
#include <stdlib.h>
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
#include <sys/time.h>
#include <string.h>
#include <wayland-server.h>
typedef struct _CoglandCompositor CoglandCompositor;
typedef struct
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
int x1, y1, x2, y2;
} CoglandRegion;
typedef struct
{
struct wl_resource resource;
CoglandRegion region;
} CoglandSharedRegion;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
typedef struct
{
CoglandCompositor *compositor;
cogland: Embed the wl_surface struct directly into CoglandSurface The wl_surface struct has been removed from libwayland-server so instead we can just embed its only memeber, the resource, directly into CoglandSurface. http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654 https://bugzilla.gnome.org/show_bug.cgi?id=700088 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
2013-05-10 16:12:00 +00:00
struct wl_resource resource;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
int x;
int y;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_buffer *buffer;
struct wl_listener buffer_destroy_listener;
CoglTexture2D *texture;
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
CoglBool has_shell_surface;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
/* All the pending state, that wl_surface.commit will apply. */
struct
{
/* wl_surface.attach */
cogland: Correctly handle commits without attaching a new buffer Previously if a client sent a commit message without attaching a new buffer then it would end up detaching the existing buffer because surface->pending.buffer would be NULL. This patch makes it explicitly track when an attach is sent for a commit and so that it can avoid making any changes otherwise. This fixes cases where GTK apps would send a damage event without a new buffer. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit aa412b9c709120bd8d88a014010c448f3b9fcfb7)
2013-05-02 16:56:38 +00:00
CoglBool newly_attached;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_buffer *buffer;
struct wl_listener buffer_destroy_listener;
int32_t sx;
int32_t sy;
/* wl_surface.damage */
CoglandRegion damage;
/* wl_surface.frame */
struct wl_list frame_callback_list;
} pending;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
} CoglandSurface;
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
typedef struct
{
CoglandSurface *surface;
struct wl_resource resource;
struct wl_listener surface_destroy_listener;
} CoglandShellSurface;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
typedef struct
{
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
uint32_t flags;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
int width;
int height;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
int refresh;
} CoglandMode;
typedef struct
{
struct wl_object wayland_output;
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
int32_t x;
int32_t y;
int32_t width_mm;
int32_t height_mm;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
CoglOnscreen *onscreen;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
GList *modes;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
} CoglandOutput;
typedef struct
{
GSource source;
GPollFD pfd;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_display *display;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
} WaylandEventSource;
struct _CoglandCompositor
{
struct wl_display *wayland_display;
struct wl_event_loop *wayland_loop;
CoglContext *cogl_context;
int virtual_width;
int virtual_height;
GList *outputs;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_list frame_callbacks;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
CoglPrimitive *triangle;
framebuffer: Add cogl_framebuffer draw methods This adds cogl_framebuffer_ apis for drawing attributes and primitives that replace corresponding apis that depend on the default CoglContext. This is part of the on going effort to adapt the Cogl api so it no longer depends on a global context variable. All the new drawing functions also take an explicit pipeline argument since we are also aiming to avoid being a stateful api like Cairo and OpenGL. Being stateless makes it easier for orthogonal components to share access to the GPU. Being stateless should also minimize any impedance miss-match for those wanting to build higher level stateless apis on top of Cogl. Note: none of the legacy, global state options such as cogl_set_depth_test_enabled(), cogl_set_backface_culling_enabled() or cogl_program_use() are supported by these new drawing apis and if set will simply be silently ignored. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-01-08 02:59:04 +00:00
CoglPipeline *triangle_pipeline;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
GSource *wayland_event_source;
GList *surfaces;
cogland: Don't redraw constantly Instead of always drawing at 60FPS without ever going idle, Cogland now only redraws when a client commits a frame or a surface is destroyed. This is acheived using an idle handler on the glib main loop. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 906e1b5eb535a86a849bed7a363f800ad71ab9bc) Conflicts: examples/cogland.c
2013-03-22 13:57:58 +00:00
unsigned int redraw_idle;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
};
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
static CoglBool option_multiple_outputs = FALSE;
static GOptionEntry
options[] =
{
{
"multiple", 'm', 0, G_OPTION_ARG_NONE, &option_multiple_outputs,
"Split the compositor into four outputs", NULL
},
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
static CoglBool
process_arguments (int *argc, char ***argv,
GError **error)
{
GOptionContext *context;
CoglBool ret;
GOptionGroup *group;
group = g_option_group_new (NULL, /* name */
NULL, /* description */
NULL, /* help_description */
NULL, /* user_data */
NULL /* destroy notify */);
g_option_group_add_entries (group, options);
context = g_option_context_new ("- An example Wayland compositor using Cogl");
g_option_context_set_main_group (context, group);
ret = g_option_context_parse (context, argc, argv, error);
g_option_context_free (context);
if (ret && *argc > 1)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
"Unknown option '%s'", (* argv)[1]);
ret = FALSE;
}
return ret;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static uint32_t
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
get_time (void)
{
struct timeval tv;
gettimeofday (&tv, NULL);
return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
region_init (CoglandRegion *region)
{
memset (region, 0, sizeof (*region));
}
static CoglBool
region_is_empty (const CoglandRegion *region)
{
return region->x1 == region->x2 || region->y1 == region->y2;
}
static void
region_add (CoglandRegion *region,
int x,
int y,
int w,
int h)
{
if (region_is_empty (region))
{
region->x1 = x;
region->y1 = y;
region->x2 = x + w;
region->y2 = y + h;
}
else
{
if (x < region->x1)
region->x1 = x;
if (y < region->y1)
region->y1 = y;
if (x + w > region->x2)
region->x2 = x + w;
if (y + h > region->y2)
region->y2 = y + h;
}
}
static void
region_subtract (CoglandRegion *region,
int x,
int y,
int w,
int h)
{
/* FIXME */
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
wayland_event_source_prepare (GSource *base, int *timeout)
{
cogland: Flush the clients in prepare, not check The clients should be flushed before going idle, not after so the call to wl_display_flush_clients was in the wrong place. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit a191366fbababd5b551140ef9297a9c6e3852c59)
2013-03-22 13:23:42 +00:00
WaylandEventSource *source = (WaylandEventSource *)base;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
*timeout = -1;
cogland: Flush the clients in prepare, not check The clients should be flushed before going idle, not after so the call to wl_display_flush_clients was in the wrong place. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit a191366fbababd5b551140ef9297a9c6e3852c59)
2013-03-22 13:23:42 +00:00
wl_display_flush_clients (source->display);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
return FALSE;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
wayland_event_source_check (GSource *base)
{
WaylandEventSource *source = (WaylandEventSource *)base;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
return source->pfd.revents;
}
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
static CoglBool
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
wayland_event_source_dispatch (GSource *base,
GSourceFunc callback,
void *data)
{
WaylandEventSource *source = (WaylandEventSource *)base;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_event_loop *loop = wl_display_get_event_loop (source->display);
wl_event_loop_dispatch (loop, 0);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
return TRUE;
}
static GSourceFuncs wayland_event_source_funcs =
{
wayland_event_source_prepare,
wayland_event_source_check,
wayland_event_source_dispatch,
NULL
};
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:21:28 +00:00
static GSource *
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wayland_event_source_new (struct wl_display *display)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
WaylandEventSource *source;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_event_loop *loop =
wl_display_get_event_loop (display);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
source = (WaylandEventSource *) g_source_new (&wayland_event_source_funcs,
sizeof (WaylandEventSource));
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
source->display = display;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
source->pfd.fd = wl_event_loop_get_fd (loop);
source->pfd.events = G_IO_IN | G_IO_ERR;
g_source_add_poll (&source->source, &source->pfd);
return &source->source;
}
cogland: Don't redraw constantly Instead of always drawing at 60FPS without ever going idle, Cogland now only redraws when a client commits a frame or a surface is destroyed. This is acheived using an idle handler on the glib main loop. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 906e1b5eb535a86a849bed7a363f800ad71ab9bc) Conflicts: examples/cogland.c
2013-03-22 13:57:58 +00:00
typedef struct _CoglandFrameCallback
{
struct wl_list link;
/* Pointer back to the compositor */
CoglandCompositor *compositor;
struct wl_resource resource;
} CoglandFrameCallback;
static CoglBool
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->texture)
{
CoglTexture2D *texture = surface->texture;
cogl_set_source_texture (COGL_TEXTURE (texture));
cogl_rectangle (-1, 1, 1, -1);
}
}
cogl_onscreen_swap_buffers (COGL_ONSCREEN (fb));
cogl_pop_framebuffer ();
}
while (!wl_list_empty (&compositor->frame_callbacks))
{
CoglandFrameCallback *callback =
wl_container_of (compositor->frame_callbacks.next, callback, link);
wl_resource_post_event (&callback->resource,
WL_CALLBACK_DONE, get_time ());
wl_resource_destroy (&callback->resource);
}
compositor->redraw_idle = 0;
return G_SOURCE_REMOVE;
}
static void
cogland_queue_redraw (CoglandCompositor *compositor)
{
if (compositor->redraw_idle == 0)
compositor->redraw_idle = g_idle_add (paint_cb, compositor);
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
static void
cogland: Handle damage events for non-shm buffers too When a Wayland compositor gets a commit it only needs to redraw the region specified by the pending damage event. Previously Cogland was ignoring damage events for non-shm buffers and just always queuing a redraw after a commit event. This patch changes it to queue a redraw only in response to a damage event. In practice this doesn't really make much difference because Cogland doesn't do anything clever to handle updating a sub-region of the screen, but it more costly matches the model a compositor should use. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15f00609e41f689234ee8d5b2f9e95fb74612d12)
2013-04-11 15:41:17 +00:00
surface_damaged (CoglandSurface *surface,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_buffer *wayland_buffer = surface->buffer;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Handle damage events for non-shm buffers too When a Wayland compositor gets a commit it only needs to redraw the region specified by the pending damage event. Previously Cogland was ignoring damage events for non-shm buffers and just always queuing a redraw after a commit event. This patch changes it to queue a redraw only in response to a damage event. In practice this doesn't really make much difference because Cogland doesn't do anything clever to handle updating a sub-region of the screen, but it more costly matches the model a compositor should use. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15f00609e41f689234ee8d5b2f9e95fb74612d12)
2013-04-11 15:41:17 +00:00
if (surface->texture &&
wl_buffer_is_shm (surface->buffer))
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
CoglPixelFormat format;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
int stride = wl_shm_buffer_get_stride (wayland_buffer);
const uint8_t *data = wl_shm_buffer_get_data (wayland_buffer);
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
switch (wl_shm_buffer_get_format (wayland_buffer))
{
#if G_BYTE_ORDER == G_BIG_ENDIAN
Updates in line with latest wayland protocol The shm buffer format enum values were renamed and the explicitly premultiplied format was dropped since it's now assumed if the buffer has an alpha component then it's premultiplied.
2012-01-12 20:24:48 +00:00
case WL_SHM_FORMAT_ARGB8888:
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
format = COGL_PIXEL_FORMAT_ARGB_8888_PRE;
break;
Updates in line with latest wayland protocol The shm buffer format enum values were renamed and the explicitly premultiplied format was dropped since it's now assumed if the buffer has an alpha component then it's premultiplied.
2012-01-12 20:24:48 +00:00
case WL_SHM_FORMAT_XRGB8888:
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
format = COGL_PIXEL_FORMAT_ARGB_8888;
break;
#elif G_BYTE_ORDER == G_LITTLE_ENDIAN
Updates in line with latest wayland protocol The shm buffer format enum values were renamed and the explicitly premultiplied format was dropped since it's now assumed if the buffer has an alpha component then it's premultiplied.
2012-01-12 20:24:48 +00:00
case WL_SHM_FORMAT_ARGB8888:
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
format = COGL_PIXEL_FORMAT_BGRA_8888_PRE;
break;
Updates in line with latest wayland protocol The shm buffer format enum values were renamed and the explicitly premultiplied format was dropped since it's now assumed if the buffer has an alpha component then it's premultiplied.
2012-01-12 20:24:48 +00:00
case WL_SHM_FORMAT_XRGB8888:
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
format = COGL_PIXEL_FORMAT_BGRA_8888;
break;
#endif
default:
g_warn_if_reached ();
format = COGL_PIXEL_FORMAT_ARGB_8888;
}
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
cogl_texture_set_region (COGL_TEXTURE (surface->texture),
x, y, /* src_x/y */
x, y, /* dst_x/y */
width, height, /* dst_width/height */
width, height, /* width/height */
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
format,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
stride,
data);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
cogland: Handle damage events for non-shm buffers too When a Wayland compositor gets a commit it only needs to redraw the region specified by the pending damage event. Previously Cogland was ignoring damage events for non-shm buffers and just always queuing a redraw after a commit event. This patch changes it to queue a redraw only in response to a damage event. In practice this doesn't really make much difference because Cogland doesn't do anything clever to handle updating a sub-region of the screen, but it more costly matches the model a compositor should use. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15f00609e41f689234ee8d5b2f9e95fb74612d12)
2013-04-11 15:41:17 +00:00
cogland_queue_redraw (surface->compositor);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
static void
cogland_surface_destroy (struct wl_client *wayland_client,
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
struct wl_resource *wayland_resource)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_resource_destroy (wayland_resource);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
static void
cogland_surface_detach_buffer (CoglandSurface *surface)
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_buffer *buffer = surface->buffer;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
if (buffer)
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_list_remove (&surface->buffer_destroy_listener.link);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
surface->buffer = NULL;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
if (surface->texture)
{
cogl_object_unref (surface->texture);
surface->texture = NULL;
}
cogland: Don't redraw constantly Instead of always drawing at 60FPS without ever going idle, Cogland now only redraws when a client commits a frame or a surface is destroyed. This is acheived using an idle handler on the glib main loop. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 906e1b5eb535a86a849bed7a363f800ad71ab9bc) Conflicts: examples/cogland.c
2013-03-22 13:57:58 +00:00
cogland_queue_redraw (surface->compositor);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
}
static void
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
surface_handle_buffer_destroy (struct wl_listener *listener,
void *data)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
CoglandSurface *surface =
wl_container_of (listener, surface, buffer_destroy_listener);
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland_surface_detach_buffer (surface);
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
cogland_surface_detach_buffer_and_notify (CoglandSurface *surface)
{
struct wl_buffer *buffer = surface->buffer;
if (buffer)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
g_assert (buffer->resource.client != NULL);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_resource_queue_event (&buffer->resource, WL_BUFFER_RELEASE);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
cogland_surface_detach_buffer (surface);
}
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
cogland_surface_attach (struct wl_client *wayland_client,
struct wl_resource *wayland_surface_resource,
struct wl_resource *wayland_buffer_resource,
int32_t sx, int32_t sy)
{
CoglandSurface *surface = wayland_surface_resource->data;
struct wl_buffer *buffer =
wayland_buffer_resource ? wayland_buffer_resource->data : NULL;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
/* Attach without commit in between does not went wl_buffer.release */
if (surface->pending.buffer)
wl_list_remove (&surface->pending.buffer_destroy_listener.link);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
surface->pending.sx = sx;
surface->pending.sy = sy;
surface->pending.buffer = buffer;
cogland: Correctly handle commits without attaching a new buffer Previously if a client sent a commit message without attaching a new buffer then it would end up detaching the existing buffer because surface->pending.buffer would be NULL. This patch makes it explicitly track when an attach is sent for a commit and so that it can avoid making any changes otherwise. This fixes cases where GTK apps would send a damage event without a new buffer. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit aa412b9c709120bd8d88a014010c448f3b9fcfb7)
2013-05-02 16:56:38 +00:00
surface->pending.newly_attached = TRUE;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
if (buffer)
wl_signal_add (&buffer->resource.destroy_signal,
&surface->pending.buffer_destroy_listener);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
static void
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
cogland_surface_damage (struct wl_client *client,
struct wl_resource *resource,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
int32_t x,
int32_t y,
int32_t width,
int32_t height)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
CoglandSurface *surface = resource->data;
region_add (&surface->pending.damage, x, y, width, height);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
static void
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
destroy_frame_callback (struct wl_resource *callback_resource)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
CoglandFrameCallback *callback = callback_resource->data;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_list_remove (&callback->link);
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
g_slice_free (CoglandFrameCallback, callback);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
static void
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
cogland_surface_frame (struct wl_client *client,
struct wl_resource *surface_resource,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
uint32_t callback_id)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
CoglandFrameCallback *callback;
CoglandSurface *surface = surface_resource->data;
callback = g_slice_new0 (CoglandFrameCallback);
cogland: Fix crash when frame callback is destroyed before emitted If a frame callback is destroyed before it is invoked then the struct would be freed but it would not be removed from the array of callbacks so when cogland later tried to emit the callback it would crash. This patch instead stores the callbacks in a GQueue with embedded list nodes so that they can be removed from the list in the resource destructor. That way it doesn't matter how the resource is destroyed, it will still get removed from the list. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-13 17:38:36 +00:00
callback->compositor = surface->compositor;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
callback->resource.object.interface = &wl_callback_interface;
callback->resource.object.id = callback_id;
callback->resource.destroy = destroy_frame_callback;
callback->resource.data = callback;
wl_client_add_resource (client, &callback->resource);
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_list_insert (surface->pending.frame_callback_list.prev, &callback->link);
}
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
cogland_surface_set_opaque_region (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region)
{
}
static void
cogland_surface_set_input_region (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *region)
{
}
static void
cogland_surface_commit (struct wl_client *client,
struct wl_resource *resource)
{
CoglandSurface *surface = resource->data;
CoglandCompositor *compositor = surface->compositor;
/* wl_surface.attach */
cogland: Correctly handle commits without attaching a new buffer Previously if a client sent a commit message without attaching a new buffer then it would end up detaching the existing buffer because surface->pending.buffer would be NULL. This patch makes it explicitly track when an attach is sent for a commit and so that it can avoid making any changes otherwise. This fixes cases where GTK apps would send a damage event without a new buffer. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit aa412b9c709120bd8d88a014010c448f3b9fcfb7)
2013-05-02 16:56:38 +00:00
if (surface->pending.newly_attached &&
surface->buffer != surface->pending.buffer)
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
{
CoglError *error = NULL;
cogland_surface_detach_buffer_and_notify (surface);
if (surface->pending.buffer)
{
surface->texture =
cogl_wayland_texture_2d_new_from_buffer (compositor->cogl_context,
surface->pending.buffer,
&error);
if (!surface->texture)
{
g_error ("Failed to create texture_2d from wayland buffer: %s",
error->message);
cogl_error_free (error);
}
surface->buffer = surface->pending.buffer;
wl_signal_add (&surface->buffer->resource.destroy_signal,
&surface->buffer_destroy_listener);
}
}
cogland: Fix handling the destroy listener for the pending buffer The handler for the destroy signal on the pending buffer was not correctly being removed if the same buffer is committed twice to the surface. It was also not being cleared if the surface is destroyed before the pending buffer is committed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 11683476a7a62cd14a10d84fd52f2cb4b47e33a0)
2013-04-11 11:40:51 +00:00
if (surface->pending.buffer)
{
wl_list_remove (&surface->pending.buffer_destroy_listener.link);
surface->pending.buffer = NULL;
}
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
surface->pending.sx = 0;
surface->pending.sy = 0;
cogland: Correctly handle commits without attaching a new buffer Previously if a client sent a commit message without attaching a new buffer then it would end up detaching the existing buffer because surface->pending.buffer would be NULL. This patch makes it explicitly track when an attach is sent for a commit and so that it can avoid making any changes otherwise. This fixes cases where GTK apps would send a damage event without a new buffer. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit aa412b9c709120bd8d88a014010c448f3b9fcfb7)
2013-05-02 16:56:38 +00:00
surface->pending.newly_attached = FALSE;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
/* wl_surface.damage */
if (surface->buffer &&
surface->texture &&
!region_is_empty (&surface->pending.damage))
{
CoglandRegion *region = &surface->pending.damage;
CoglTexture *texture = COGL_TEXTURE (surface->texture);
if (region->x2 > cogl_texture_get_width (texture))
region->x2 = cogl_texture_get_width (texture);
if (region->y2 > cogl_texture_get_height (texture))
region->y2 = cogl_texture_get_height (texture);
if (region->x1 < 0)
region->x1 = 0;
if (region->y1 < 0)
region->y1 = 0;
cogland: Handle damage events for non-shm buffers too When a Wayland compositor gets a commit it only needs to redraw the region specified by the pending damage event. Previously Cogland was ignoring damage events for non-shm buffers and just always queuing a redraw after a commit event. This patch changes it to queue a redraw only in response to a damage event. In practice this doesn't really make much difference because Cogland doesn't do anything clever to handle updating a sub-region of the screen, but it more costly matches the model a compositor should use. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15f00609e41f689234ee8d5b2f9e95fb74612d12)
2013-04-11 15:41:17 +00:00
surface_damaged (surface,
region->x1,
region->y1,
region->x2 - region->x1,
region->y2 - region->y1);
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
}
region_init (&surface->pending.damage);
/* wl_surface.frame */
wl_list_insert_list (&compositor->frame_callbacks,
&surface->pending.frame_callback_list);
wl_list_init (&surface->pending.frame_callback_list);
}
static void
cogland_surface_set_buffer_transform (struct wl_client *client,
struct wl_resource *resource,
int32_t transform)
{
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
const struct wl_surface_interface cogland_surface_interface = {
cogland_surface_destroy,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
cogland_surface_attach,
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
cogland_surface_damage,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
cogland_surface_frame,
cogland_surface_set_opaque_region,
cogland_surface_set_input_region,
cogland_surface_commit,
cogland_surface_set_buffer_transform
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
};
static void
cogland_surface_free (CoglandSurface *surface)
{
CoglandCompositor *compositor = surface->compositor;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
CoglandFrameCallback *cb, *next;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
compositor->surfaces = g_list_remove (compositor->surfaces, surface);
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
cogland_surface_detach_buffer_and_notify (surface);
cogland: Fix handling the destroy listener for the pending buffer The handler for the destroy signal on the pending buffer was not correctly being removed if the same buffer is committed twice to the surface. It was also not being cleared if the surface is destroyed before the pending buffer is committed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 11683476a7a62cd14a10d84fd52f2cb4b47e33a0)
2013-04-11 11:40:51 +00:00
if (surface->pending.buffer)
wl_list_remove (&surface->pending.buffer_destroy_listener.link);
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_list_for_each_safe (cb, next,
&surface->pending.frame_callback_list, link)
wl_resource_destroy (&cb->resource);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
g_slice_free (CoglandSurface, surface);
}
static void
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
cogland_surface_resource_destroy_cb (struct wl_resource *resource)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
CoglandSurface *surface = resource->data;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland_surface_free (surface);
}
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
surface_handle_pending_buffer_destroy (struct wl_listener *listener,
void *data)
{
CoglandSurface *surface =
wl_container_of (listener, surface, pending.buffer_destroy_listener);
surface->pending.buffer = NULL;
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
static void
cogland_compositor_create_surface (struct wl_client *wayland_client,
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
struct wl_resource *wayland_compositor_resource,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
uint32_t id)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
CoglandCompositor *compositor = wayland_compositor_resource->data;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
CoglandSurface *surface = g_slice_new0 (CoglandSurface);
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
surface->compositor = compositor;
cogland: Embed the wl_surface struct directly into CoglandSurface The wl_surface struct has been removed from libwayland-server so instead we can just embed its only memeber, the resource, directly into CoglandSurface. http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654 https://bugzilla.gnome.org/show_bug.cgi?id=700088 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
2013-05-10 16:12:00 +00:00
surface->resource.destroy =
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland_surface_resource_destroy_cb;
cogland: Embed the wl_surface struct directly into CoglandSurface The wl_surface struct has been removed from libwayland-server so instead we can just embed its only memeber, the resource, directly into CoglandSurface. http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654 https://bugzilla.gnome.org/show_bug.cgi?id=700088 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
2013-05-10 16:12:00 +00:00
surface->resource.object.id = id;
surface->resource.object.interface = &wl_surface_interface;
surface->resource.object.implementation =
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
(void (**)(void)) &cogland_surface_interface;
cogland: Embed the wl_surface struct directly into CoglandSurface The wl_surface struct has been removed from libwayland-server so instead we can just embed its only memeber, the resource, directly into CoglandSurface. http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654 https://bugzilla.gnome.org/show_bug.cgi?id=700088 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
2013-05-10 16:12:00 +00:00
surface->resource.data = surface;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
surface->buffer_destroy_listener.notify =
surface_handle_buffer_destroy;
surface->pending.buffer_destroy_listener.notify =
surface_handle_pending_buffer_destroy;
wl_list_init (&surface->pending.frame_callback_list);
region_init (&surface->pending.damage);
cogland: Embed the wl_surface struct directly into CoglandSurface The wl_surface struct has been removed from libwayland-server so instead we can just embed its only memeber, the resource, directly into CoglandSurface. http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654 https://bugzilla.gnome.org/show_bug.cgi?id=700088 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
2013-05-10 16:12:00 +00:00
wl_client_add_resource (wayland_client, &surface->resource);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
compositor->surfaces = g_list_prepend (compositor->surfaces,
surface);
}
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
cogland_region_destroy (struct wl_client *client,
struct wl_resource *resource)
{
wl_resource_destroy (resource);
}
static void
cogland_region_add (struct wl_client *client,
struct wl_resource *resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
{
CoglandSharedRegion *shared_region = resource->data;
region_add (&shared_region->region, x, y, width, height);
}
static void
cogland_region_subtract (struct wl_client *client,
struct wl_resource *resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height)
{
CoglandSharedRegion *shared_region = resource->data;
region_subtract (&shared_region->region, x, y, width, height);
}
const struct wl_region_interface cogland_region_interface = {
cogland_region_destroy,
cogland_region_add,
cogland_region_subtract
};
static void
cogland_region_resource_destroy_cb (struct wl_resource *resource)
{
CoglandSharedRegion *region = resource->data;
g_slice_free (CoglandSharedRegion, region);
}
static void
cogland_compositor_create_region (struct wl_client *wayland_client,
struct wl_resource *compositor_resource,
uint32_t id)
{
CoglandSharedRegion *region = g_slice_new0 (CoglandSharedRegion);
region->resource.destroy =
cogland_region_resource_destroy_cb;
region->resource.object.id = id;
region->resource.object.interface = &wl_region_interface;
region->resource.object.implementation =
(void (**)(void)) &cogland_region_interface;
region->resource.data = region;
region_init (&region->region);
wl_client_add_resource (wayland_client, &region->resource);
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
static void
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
bind_output (struct wl_client *client,
void *data,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
uint32_t version,
uint32_t id)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
CoglandOutput *output = data;
struct wl_resource *resource =
wl_client_add_object (client, &wl_output_interface, NULL, id, data);
GList *l;
wl_resource_post_event (resource,
WL_OUTPUT_GEOMETRY,
output->x, output->y,
output->width_mm,
output->height_mm,
0, /* subpixel: unknown */
"unknown", /* make */
"unknown"); /* model */
for (l = output->modes; l; l = l->next)
{
CoglandMode *mode = l->data;
wl_resource_post_event (resource,
WL_OUTPUT_MODE,
mode->flags,
mode->width,
mode->height,
mode->refresh);
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
}
Update some of the examples to use the dirty callback This updates Cogland and the three hello examples to use the dirty callback. For Cogland, this removes the manual handling of X events and for the other examples it removes the need to redraw continously. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 108e3c548b7866190845f163c84a05212718bd70)
2013-05-14 12:41:29 +00:00
static void
dirty_cb (CoglOnscreen *onscreen,
const CoglOnscreenDirtyInfo *info,
void *user_data)
{
CoglandCompositor *compositor = user_data;
cogland_queue_redraw (compositor);
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
static void
cogland_compositor_create_output (CoglandCompositor *compositor,
int x,
int y,
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
int width_mm,
int height_mm)
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{
CoglandOutput *output = g_slice_new0 (CoglandOutput);
CoglFramebuffer *fb;
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError *error = NULL;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
CoglandMode *mode;
output->x = x;
output->y = y;
output->width_mm = width_mm;
output->height_mm = height_mm;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
output->wayland_output.interface = &wl_output_interface;
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
wl_display_add_global (compositor->wayland_display,
&wl_output_interface,
output,
bind_output);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
output->onscreen = cogl_onscreen_new (compositor->cogl_context,
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
width_mm, height_mm);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
/* Eventually there will be an implicit allocate on first use so this
* will become optional... */
fb = COGL_FRAMEBUFFER (output->onscreen);
if (!cogl_framebuffer_allocate (fb, &error))
g_error ("Failed to allocate framebuffer: %s\n", error->message);
Update some of the examples to use the dirty callback This updates Cogland and the three hello examples to use the dirty callback. For Cogland, this removes the manual handling of X events and for the other examples it removes the need to redraw continously. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 108e3c548b7866190845f163c84a05212718bd70)
2013-05-14 12:41:29 +00:00
cogl_onscreen_add_dirty_callback (output->onscreen,
dirty_cb,
compositor,
NULL /* destroy */);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogl_onscreen_show (output->onscreen);
Add compiler deprecation warnings This adds compiler symbol deprecation declarations for old Cogl APIs so that users can easily see via compiler warning when they are using these symbols, and also see a hint for what the apis should be replaced with. So that users of Cogl can manage when to show these warnings this introduces a scheme borrowed from glib whereby you can declare what version of the Cogl api you are using: COGL_VERSION_MIN_REQUIRED can be defined to indicate the oldest Cogl api that the application wants to use. Cogl will only warn about deprecations for symbols that were deprecated earlier than this required version. If this is left undefined then by default Cogl will warn about all deprecations. COGL_VERSION_MAX_ALLOWED can be defined to indicate the newest api that the application uses. If the application uses symbols newer than this then Cogl will give a warning about that. This patch removes the need to maintain the COGL_DISABLE_DEPRECATED guards around deprecated symbols. This patch fixes a few uses of deprecated symbols in the examples/ Reviewed-by: Neil Roberts <neil@linux.intel.com>
2013-03-22 21:18:53 +00:00
cogl_framebuffer_set_viewport (fb, -x, -y,
compositor->virtual_width,
compositor->virtual_height);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
mode = g_slice_new0 (CoglandMode);
mode->flags = 0;
mode->width = width_mm;
mode->height = height_mm;
mode->refresh = 60;
output->modes = g_list_prepend (output->modes, mode);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
compositor->outputs = g_list_prepend (compositor->outputs, output);
}
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
const static struct wl_compositor_interface cogland_compositor_interface =
{
cogland_compositor_create_surface,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
cogland_compositor_create_region
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
};
static void
compositor_bind (struct wl_client *client,
cogland: Remove tabs Tabs make me sad. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 18:08:10 +00:00
void *data,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
uint32_t version,
uint32_t id)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
CoglandCompositor *compositor = data;
wl_client_add_object (client, &wl_compositor_interface,
&cogland_compositor_interface, id, compositor);
}
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
static void
shell_surface_pong (struct wl_client *client,
struct wl_resource *resource,
uint32_t serial)
{
}
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
static void
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface_move (struct wl_client *client,
struct wl_resource *resource,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_resource *seat,
uint32_t serial)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
}
static void
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface_resize (struct wl_client *client,
struct wl_resource *resource,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_resource *seat,
uint32_t serial,
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
uint32_t edges)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
}
static void
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface_set_toplevel (struct wl_client *client,
struct wl_resource *resource)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
}
static void
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface_set_transient (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *parent,
int32_t x,
int32_t y,
uint32_t flags)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
}
static void
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface_set_fullscreen (struct wl_client *client,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
struct wl_resource *resource,
uint32_t method,
uint32_t framerate,
struct wl_resource *output)
{
}
static void
shell_surface_set_popup (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *seat,
uint32_t serial,
struct wl_resource *parent,
int32_t x,
int32_t y,
uint32_t flags)
{
}
static void
shell_surface_set_maximized (struct wl_client *client,
struct wl_resource *resource,
struct wl_resource *output)
{
}
static void
shell_surface_set_title (struct wl_client *client,
struct wl_resource *resource,
const char *title)
{
}
static void
shell_surface_set_class (struct wl_client *client,
struct wl_resource *resource,
const char *class_)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
}
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
static const struct wl_shell_surface_interface cogl_shell_surface_interface =
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
shell_surface_pong,
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface_move,
shell_surface_resize,
shell_surface_set_toplevel,
shell_surface_set_transient,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
shell_surface_set_fullscreen,
shell_surface_set_popup,
shell_surface_set_maximized,
shell_surface_set_title,
shell_surface_set_class
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
};
static void
shell_handle_surface_destroy (struct wl_listener *listener,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
void *data)
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
{
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
CoglandShellSurface *shell_surface =
wl_container_of (listener, shell_surface, surface_destroy_listener);
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface->surface->has_shell_surface = FALSE;
shell_surface->surface = NULL;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_resource_destroy (&shell_surface->resource);
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
}
static void
destroy_shell_surface (struct wl_resource *resource)
{
CoglandShellSurface *shell_surface = resource->data;
/* In case cleaning up a dead client destroys shell_surface first */
if (shell_surface->surface)
{
wl_list_remove (&shell_surface->surface_destroy_listener.link);
shell_surface->surface->has_shell_surface = FALSE;
}
g_free (shell_surface);
}
static void
get_shell_surface (struct wl_client *client,
struct wl_resource *resource,
uint32_t id,
struct wl_resource *surface_resource)
{
CoglandSurface *surface = surface_resource->data;
cogland: Don't leak the shell surface struct if requested twice If the shell surface is requested twice then Cogland will hit an error path but it would end up leaking the CoglandShellSurface struct it allocated. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 622d41b04c2689a8e4fb6e1769aaf887a04242e8)
2013-04-11 11:43:53 +00:00
CoglandShellSurface *shell_surface;
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
if (surface->has_shell_surface)
{
wl_resource_post_error (surface_resource,
WL_DISPLAY_ERROR_INVALID_OBJECT,
"wl_shell::get_shell_surface already requested");
return;
}
cogland: Don't leak the shell surface struct if requested twice If the shell surface is requested twice then Cogland will hit an error path but it would end up leaking the CoglandShellSurface struct it allocated. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 622d41b04c2689a8e4fb6e1769aaf887a04242e8)
2013-04-11 11:43:53 +00:00
shell_surface = g_new0 (CoglandShellSurface, 1);
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
shell_surface->resource.destroy = destroy_shell_surface;
shell_surface->resource.object.id = id;
shell_surface->resource.object.interface = &wl_shell_surface_interface;
shell_surface->resource.object.implementation =
(void (**) (void)) &cogl_shell_surface_interface;
shell_surface->resource.data = shell_surface;
shell_surface->surface = surface;
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
shell_surface->surface_destroy_listener.notify = shell_handle_surface_destroy;
cogland: Embed the wl_surface struct directly into CoglandSurface The wl_surface struct has been removed from libwayland-server so instead we can just embed its only memeber, the resource, directly into CoglandSurface. http://cgit.freedesktop.org/wayland/wayland/commit/?id=508dd69b5654 https://bugzilla.gnome.org/show_bug.cgi?id=700088 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 15c58ce03ce97df659dade0e10be7807eb7b2296)
2013-05-10 16:12:00 +00:00
wl_signal_add (&surface->resource.destroy_signal,
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
&shell_surface->surface_destroy_listener);
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
surface->has_shell_surface = TRUE;
wl_client_add_resource (client, &shell_surface->resource);
}
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
static const struct wl_shell_interface cogland_shell_interface =
{
cogland: Update to the new shell interface Wayland has changed so that the shell interface now only has one function which returns a shell surface for the surface. This patch makes it create a dummy service in the same way that the wayland demo compositor does. The implementation of the shell_surface_interface for that dummy service is all no-ops. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 19:31:01 +00:00
get_shell_surface
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
};
static void
bind_shell (struct wl_client *client,
void *data,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 20:56:40 +00:00
uint32_t version,
uint32_t id)
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
{
wl_client_add_object (client, &wl_shell_interface,
&cogland_shell_interface, id, data);
}
cogland: Try forcing an EGL context Cogland works a lot better with an EGL context because then Mesa will automatically set up the wl_drm object and it can accept DRM buffers. However Cogland is still useful with GLX because it can gracefully fallback to accepting only SHM buffers. This patch therefore makes it first try creating and connecting a renderer with the EGL constraint, but if that doesn't work it will try again without it. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 05ddc7d75e77538b5de22d4336d4a444d122063b)
2013-04-11 16:02:05 +00:00
static CoglContext *
create_cogl_context (CoglandCompositor *compositor,
CoglBool use_egl_constraint,
CoglError **error)
{
CoglRenderer *renderer = renderer = cogl_renderer_new ();
CoglDisplay *display;
CoglContext *context;
if (use_egl_constraint)
cogl_renderer_add_constraint (renderer, COGL_RENDERER_CONSTRAINT_USES_EGL);
if (!cogl_renderer_connect (renderer, error))
{
cogl_object_unref (renderer);
return NULL;
}
display = cogl_display_new (renderer, NULL);
cogl_wayland_display_set_compositor_display (display,
compositor->wayland_display);
context = cogl_context_new (display, error);
cogl_object_unref (renderer);
cogl_object_unref (display);
return context;
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
int
main (int argc, char **argv)
{
CoglandCompositor compositor;
GMainLoop *loop;
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 18:28:27 +00:00
CoglError *error = NULL;
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
GError *gerror = NULL;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
CoglVertexP2C4 triangle_vertices[] = {
examples: Fix the first colour in the triangle_vertices The first vertex in the triangle vertices used in the cogl-hello example (which were copied into a few other examples) for some reason has a semi-transparent alpha component. However the colour needs to be pre-multiplied and the red component was still 0xff so the colour is effectively invalid and the transparency isn't shown. This patch just sets the alpha component to 0xff to make it less confusing. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 461879986ec012556b4e680b73e36d440927faaa)
2013-04-19 16:55:29 +00:00
{0, 0.7, 0xff, 0x00, 0x00, 0xff},
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
{-0.7, -0.7, 0x00, 0xff, 0x00, 0xff},
{0.7, -0.7, 0x00, 0x00, 0xff, 0xff}
};
Update all of the examples to use cogl_poll_get_info The aim is that it should be a requirement that all Cogl applications hook their mainloops into Cogl so we should lead by examples. Most of the examples now just call cogl_poll_get_info and then g_poll with a zero timeout so that they can continue to constantly redraw. The SDL example is a bit special because SDL makes it very difficult to wait on either a timeout or any file descriptors. The SDL winsys is documented not to require blocking on any file descriptors so we can ignore that. It implements the timeout by adding an SDL timer which pushes an event to the queue to wake up SDL_GetEvent. The Cogland example was already using the glib main loop so that one has been updated to add the CoglGLibSource to it. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:40:55 +00:00
GSource *cogl_source;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
if (!process_arguments (&argc, &argv, &gerror))
{
fprintf (stderr, "%s\n", gerror->message);
return EXIT_FAILURE;
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
memset (&compositor, 0, sizeof (compositor));
compositor.wayland_display = wl_display_create ();
if (compositor.wayland_display == NULL)
g_error ("failed to create wayland display");
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_list_init (&compositor.frame_callbacks);
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
if (!wl_display_add_global (compositor.wayland_display,
&wl_compositor_interface,
cogland: Remove tabs Tabs make me sad. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 18:08:10 +00:00
&compositor,
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
compositor_bind))
g_error ("Failed to register wayland compositor object");
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wl_display_init_shm (compositor.wayland_display);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
loop = g_main_loop_new (NULL, FALSE);
compositor.wayland_loop =
wl_display_get_event_loop (compositor.wayland_display);
compositor.wayland_event_source =
cogland: Update to the Wayland 1.0 API This updates Cogland example compositor to use the stable Wayland 1.0 API. • When the client attaches a new buffer to a surface it is now added to a struct contaning pending the state instead of immediately switching to the new buffer. This state is then flushed when the surface is committed. • The frame callbacks are now queued in a pending list and only added to the compositor's main list when the surface is committed. Both lists are now a wl_list instead of a GQueue because it makes it easier to remove the callback without knowing which list it is in. • When the buffer is destroyed for a surface the resource for the buffer is now sent a release event. • It now flushes the clients in the prepare for the for the Wayland event GSource. This is part of the multi-threaded API in this Wayland patch: http://cgit.freedesktop.org/wayland/wayland/commit/?id=53d24713a31d59 • Implements a dummy wl_region interface. The only interfaces that actually use regions (the opaque and input regions) are ignored but we need the interface to create a resource. • Most the of the SHM interface is now implemented directly in libwayland-server except that it still needs to copy the data to the subregion of the texture when the damage region is committed. • The callback list for when a resource is destroyed has been unified into a generic wl_signal implementation so the signature for the functions has been changed. http://cgit.freedesktop.org/wayland/wayland/commit/?h=6802eaa68af9022 • The wl_buffer struct no longer has a user_data parameter so we can't attach our own CoglandBuffer data to it. Instead the CoglandSurface now just keeps track of the wl_buffer directly. • The Cogland example is now unconditionally built instead of checking the Wayland version number in the configure script. It looks like this check was broken anyway because it was checking the version of the gbm package rather than a Wayland package. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4cbbc0f8e3de1fd44dee08b487f1c3f97dda8ede) Conflicts: examples/Makefile.am examples/cogland.c
2012-12-19 13:42:52 +00:00
wayland_event_source_new (compositor.wayland_display);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
g_source_attach (compositor.wayland_event_source, NULL);
cogland: Try forcing an EGL context Cogland works a lot better with an EGL context because then Mesa will automatically set up the wl_drm object and it can accept DRM buffers. However Cogland is still useful with GLX because it can gracefully fallback to accepting only SHM buffers. This patch therefore makes it first try creating and connecting a renderer with the EGL constraint, but if that doesn't work it will try again without it. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 05ddc7d75e77538b5de22d4336d4a444d122063b)
2013-04-11 16:02:05 +00:00
/* We want Cogl to use an EGL renderer because otherwise it won't
* set up the wl_drm object and only SHM buffers will work. */
compositor.cogl_context =
create_cogl_context (&compositor,
TRUE /* use EGL constraint */,
&error);
if (compositor.cogl_context == NULL)
{
/* If we couldn't get an EGL context then try any type of
* context */
cogl_error_free (error);
error = NULL;
compositor.cogl_context =
create_cogl_context (&compositor,
FALSE, /* don't set EGL constraint */
&error);
if (compositor.cogl_context)
g_warning ("Failed to create context with EGL constraint, "
"falling back");
else
g_error ("Failed to create a Cogl context: %s\n", error->message);
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Increase the display size to 800x600 The previous display size of 640x480 was a bit small to test with. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 835626e220137765df5acf7419036218e3fc7c97)
2013-03-21 14:00:03 +00:00
compositor.virtual_width = 800;
compositor.virtual_height = 600;
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
if (option_multiple_outputs)
{
cogland: Increase the display size to 800x600 The previous display size of 640x480 was a bit small to test with. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 835626e220137765df5acf7419036218e3fc7c97)
2013-03-21 14:00:03 +00:00
int hw = compositor.virtual_width / 2;
int hh = compositor.virtual_height / 2;
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
/* Emulate compositing with multiple monitors... */
cogland: Increase the display size to 800x600 The previous display size of 640x480 was a bit small to test with. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 835626e220137765df5acf7419036218e3fc7c97)
2013-03-21 14:00:03 +00:00
cogland_compositor_create_output (&compositor, 0, 0, hw, hh);
cogland_compositor_create_output (&compositor, hw, 0, hw, hh);
cogland_compositor_create_output (&compositor, 0, hh, hw, hh);
cogland_compositor_create_output (&compositor, hw, hh, hw, hh);
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
}
else
{
cogland: Increase the display size to 800x600 The previous display size of 640x480 was a bit small to test with. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 835626e220137765df5acf7419036218e3fc7c97)
2013-03-21 14:00:03 +00:00
cogland_compositor_create_output (&compositor,
0, 0,
compositor.virtual_width,
compositor.virtual_height);
cogland: Add an option to split the desktop into four outputs Previously Cogland would always split the desktop into four outputs. Although this is quite neat to demonstrate that it's possible, it's quite annoying in practice while testing. This patch turns it into a command line option which defaults to off. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 5570bf892268c8d2ea36bc26473aeb607c0e2c1d)
2013-03-20 16:53:23 +00:00
}
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
cogland: This updates the example wayland compositor This updates the cogland Wayland compositor example with is an extremely minimal Wayland compositor. It demonstrates a multi(4)-head compositor whereby client buffers are simply stretched to cover all outputs. No input or shell features are implemented since it's really only for demonstrating the use of Cogl. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-12-01 22:58:17 +00:00
if (wl_display_add_global (compositor.wayland_display, &wl_shell_interface,
&compositor, bind_shell) == NULL)
g_error ("Failed to register a global shell object");
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
if (wl_display_add_socket (compositor.wayland_display, "wayland-0"))
g_error ("Failed to create socket");
buffer: explicitly relate buffers to a context All CoglBuffer constructors now take an explicit CoglContext constructor. This is part of the on going effort to adapt to Cogl API so it no longer depends on a global, default context. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-06 17:08:58 +00:00
compositor.triangle = cogl_primitive_new_p2c4 (compositor.cogl_context,
COGL_VERTICES_MODE_TRIANGLES,
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
3, triangle_vertices);
Adds a context arg to cogl_pipeline_new() As we move towards Cogl 2.0 we are aiming to remove the need for a default global CoglContext and so everything should be explicitly related to a context somehow. CoglPipelines are top level objects and so this patch adds a context argument to cogl_pipeline_new(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-18 16:03:10 +00:00
compositor.triangle_pipeline = cogl_pipeline_new (compositor.cogl_context);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
Update all of the examples to use cogl_poll_get_info The aim is that it should be a requirement that all Cogl applications hook their mainloops into Cogl so we should lead by examples. Most of the examples now just call cogl_poll_get_info and then g_poll with a zero timeout so that they can continue to constantly redraw. The SDL example is a bit special because SDL makes it very difficult to wait on either a timeout or any file descriptors. The SDL winsys is documented not to require blocking on any file descriptors so we can ignore that. It implements the timeout by adding an SDL timer which pushes an event to the queue to wake up SDL_GetEvent. The Cogland example was already using the glib main loop so that one has been updated to add the CoglGLibSource to it. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 15:40:55 +00:00
cogl_source = cogl_glib_source_new (compositor.cogl_context,
G_PRIORITY_DEFAULT);
g_source_attach (cogl_source, NULL);
Adds an example cogl wayland compositor This adds an example cogl compositor to test the _cogl_wayland_texture_2d_new_from_buffer API. The compositor emulates 4 output displays but doesn't support input since Cogl doesn't deal with input. It's quite a minimal example of what it takes to write a wayland compositor so could be interesting to anyone learning about wayland.
2011-05-25 18:27:10 +00:00
g_main_loop_run (loop);
return 0;
}
Copy permalink