diff --git a/clutter/clutter/x11/clutter-stage-x11.c b/clutter/clutter/x11/clutter-stage-x11.c index ee7857cb6..62a67708e 100644 --- a/clutter/clutter/x11/clutter-stage-x11.c +++ b/clutter/clutter/x11/clutter-stage-x11.c @@ -631,7 +631,6 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window) stage_x11->onscreen = cogl_onscreen_new (backend->cogl_context, width, height); - cogl_onscreen_set_swap_throttled (stage_x11->onscreen, TRUE); stage_x11->frame_closure = cogl_onscreen_add_frame_callback (stage_x11->onscreen, frame_cb, diff --git a/cogl/.gitignore b/cogl/.gitignore index 8449b17fd..7f7367087 100644 --- a/cogl/.gitignore +++ b/cogl/.gitignore @@ -66,7 +66,6 @@ TAGS /tests/conform/config.env /tests/conform/.log /tests/unit/.log -/tests/micro-perf/test-journal /tests/config.env /po/POTFILES /po/*.gmo diff --git a/cogl/cogl/cogl-framebuffer-private.h b/cogl/cogl/cogl-framebuffer-private.h index 3701eab21..d78bd408d 100644 --- a/cogl/cogl/cogl-framebuffer-private.h +++ b/cogl/cogl/cogl-framebuffer-private.h @@ -59,7 +59,6 @@ typedef struct CoglSwapChain *swap_chain; CoglBool need_stencil; int samples_per_pixel; - CoglBool swap_throttled; CoglBool depth_texture_enabled; CoglBool stereo_enabled; } CoglFramebufferConfig; diff --git a/cogl/cogl/cogl-onscreen-private.h b/cogl/cogl/cogl-onscreen-private.h index 0a67832ac..5a4aebc2e 100644 --- a/cogl/cogl/cogl-onscreen-private.h +++ b/cogl/cogl/cogl-onscreen-private.h @@ -65,8 +65,6 @@ struct _CoglOnscreen void *foreign_update_mask_data; #endif - CoglBool swap_throttled; - CoglList frame_closures; CoglBool resizable; diff --git a/cogl/cogl/cogl-onscreen-template.c b/cogl/cogl/cogl-onscreen-template.c index 0e7bd1e20..6fcbe5d7c 100644 --- a/cogl/cogl/cogl-onscreen-template.c +++ b/cogl/cogl/cogl-onscreen-template.c @@ -62,7 +62,6 @@ cogl_onscreen_template_new (CoglSwapChain *swap_chain) else onscreen_template->config.swap_chain = cogl_swap_chain_new (); - onscreen_template->config.swap_throttled = TRUE; onscreen_template->config.need_stencil = TRUE; onscreen_template->config.samples_per_pixel = 0; @@ -86,14 +85,6 @@ cogl_onscreen_template_set_samples_per_pixel ( onscreen_template->config.samples_per_pixel = samples_per_pixel; } -void -cogl_onscreen_template_set_swap_throttled ( - CoglOnscreenTemplate *onscreen_template, - CoglBool throttled) -{ - onscreen_template->config.swap_throttled = throttled; -} - void cogl_onscreen_template_set_stereo_enabled ( CoglOnscreenTemplate *onscreen_template, diff --git a/cogl/cogl/cogl-onscreen-template.h b/cogl/cogl/cogl-onscreen-template.h index 9831375e6..52dcdcfaa 100644 --- a/cogl/cogl/cogl-onscreen-template.h +++ b/cogl/cogl/cogl-onscreen-template.h @@ -85,23 +85,6 @@ cogl_onscreen_template_set_samples_per_pixel ( CoglOnscreenTemplate *onscreen_template, int n); -/** - * cogl_onscreen_template_set_swap_throttled: - * @onscreen_template: A #CoglOnscreenTemplate template framebuffer - * @throttled: Whether throttling should be enabled - * - * Requests that any future #CoglOnscreen framebuffers derived from this - * template should enable or disable swap throttling according to the given - * @throttled argument. - * - * Since: 1.10 - * Stability: unstable - */ -void -cogl_onscreen_template_set_swap_throttled ( - CoglOnscreenTemplate *onscreen_template, - CoglBool throttled); - /** * cogl_onscreen_template_set_stereo_enabled: * @onscreen_template: A #CoglOnscreenTemplate template framebuffer diff --git a/cogl/cogl/cogl-onscreen.c b/cogl/cogl/cogl-onscreen.c index 4e01d133d..f5db270c8 100644 --- a/cogl/cogl/cogl-onscreen.c +++ b/cogl/cogl/cogl-onscreen.c @@ -557,20 +557,6 @@ cogl_onscreen_remove_swap_buffers_callback (CoglOnscreen *onscreen, cogl_onscreen_remove_frame_callback (onscreen, closure); } -void -cogl_onscreen_set_swap_throttled (CoglOnscreen *onscreen, - CoglBool throttled) -{ - CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen); - framebuffer->config.swap_throttled = throttled; - if (framebuffer->allocated) - { - const CoglWinsysVtable *winsys = - _cogl_framebuffer_get_winsys (framebuffer); - winsys->onscreen_update_swap_throttled (onscreen); - } -} - void cogl_onscreen_show (CoglOnscreen *onscreen) { diff --git a/cogl/cogl/cogl-onscreen.h b/cogl/cogl/cogl-onscreen.h index a4f062ecb..675a32a4b 100644 --- a/cogl/cogl/cogl-onscreen.h +++ b/cogl/cogl/cogl-onscreen.h @@ -162,23 +162,6 @@ uint32_t cogl_x11_onscreen_get_visual_xid (CoglOnscreen *onscreen); #endif /* COGL_HAS_X11 */ -/** - * cogl_onscreen_set_swap_throttled: - * @onscreen: A #CoglOnscreen framebuffer - * @throttled: Whether swap throttling is wanted or not. - * - * Requests that the given @onscreen framebuffer should have swap buffer - * requests (made using cogl_onscreen_swap_buffers()) throttled either by a - * displays vblank period or perhaps some other mechanism in a composited - * environment. - * - * Since: 1.8 - * Stability: unstable - */ -void -cogl_onscreen_set_swap_throttled (CoglOnscreen *onscreen, - CoglBool throttled); - /** * cogl_onscreen_show: * @onscreen: The onscreen framebuffer to make visible @@ -554,9 +537,8 @@ typedef void (*CoglSwapBuffersNotify) (CoglFramebuffer *framebuffer, * registered callbacks will be called if this feature is not supported. * * We recommend using this mechanism when available to manually throttle your - * applications (in conjunction with cogl_onscreen_set_swap_throttled()) so - * your application will be able to avoid long blocks in the driver caused by - * throttling when you request to swap buffers too quickly. + * applications so your application will be able to avoid long blocks in the + * driver caused by throttling when you request to swap buffers too quickly. * * Return value: a unique identifier that can be used to remove to remove * the callback later. diff --git a/cogl/cogl/cogl.symbols b/cogl/cogl/cogl.symbols index d7f700012..68a624f4a 100644 --- a/cogl/cogl/cogl.symbols +++ b/cogl/cogl/cogl.symbols @@ -578,7 +578,6 @@ cogl_onscreen_get_gtype cogl_onscreen_get_resizable cogl_onscreen_hide cogl_onscreen_new -cogl_onscreen_set_swap_throttled cogl_onscreen_remove_dirty_callback cogl_onscreen_remove_frame_callback cogl_onscreen_remove_resize_callback @@ -587,7 +586,6 @@ cogl_onscreen_remove_swap_buffers_callback cogl_onscreen_resize_closure_get_gtype #endif cogl_onscreen_set_resizable -cogl_onscreen_set_swap_throttled cogl_onscreen_show cogl_onscreen_swap_buffers cogl_onscreen_swap_buffers_with_damage @@ -597,7 +595,6 @@ cogl_onscreen_template_get_gtype #endif cogl_onscreen_template_new cogl_onscreen_template_set_samples_per_pixel -cogl_onscreen_template_set_swap_throttled cogl_ortho diff --git a/cogl/cogl/winsys/cogl-winsys-egl.c b/cogl/cogl/winsys/cogl-winsys-egl.c index 56f423a75..222e5a6e7 100644 --- a/cogl/cogl/winsys/cogl-winsys-egl.c +++ b/cogl/cogl/winsys/cogl-winsys-egl.c @@ -724,10 +724,7 @@ bind_onscreen_with_context (CoglOnscreen *onscreen, CoglRenderer *renderer = context->display->renderer; CoglRendererEGL *egl_renderer = renderer->winsys; - if (fb->config.swap_throttled) - eglSwapInterval (egl_renderer->edpy, 1); - else - eglSwapInterval (egl_renderer->edpy, 0); + eglSwapInterval (egl_renderer->edpy, 1); } return status; @@ -854,21 +851,6 @@ _cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen, eglSwapBuffers (egl_renderer->edpy, egl_onscreen->egl_surface); } -static void -_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen) -{ - CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context; - CoglDisplayEGL *egl_display = context->display->winsys; - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - - if (egl_display->current_draw_surface != egl_onscreen->egl_surface) - return; - - egl_display->current_draw_surface = EGL_NO_SURFACE; - - _cogl_winsys_onscreen_bind (onscreen); -} - static void _cogl_winsys_save_context (CoglContext *ctx) { @@ -985,8 +967,6 @@ static CoglWinsysVtable _cogl_winsys_vtable = _cogl_winsys_onscreen_swap_buffers_with_damage, .onscreen_swap_region = _cogl_winsys_onscreen_swap_region, .onscreen_get_buffer_age = _cogl_winsys_onscreen_get_buffer_age, - .onscreen_update_swap_throttled = - _cogl_winsys_onscreen_update_swap_throttled, /* CoglGLES2Context related methods */ .save_context = _cogl_winsys_save_context, diff --git a/cogl/cogl/winsys/cogl-winsys-glx.c b/cogl/cogl/winsys/cogl-winsys-glx.c index dfdcf6490..012c712bd 100644 --- a/cogl/cogl/winsys/cogl-winsys-glx.c +++ b/cogl/cogl/winsys/cogl-winsys-glx.c @@ -1685,13 +1685,7 @@ _cogl_winsys_onscreen_bind (CoglOnscreen *onscreen) * exclusive. */ if (glx_renderer->glXSwapInterval) - { - CoglFramebuffer *fb = COGL_FRAMEBUFFER (onscreen); - if (fb->config.swap_throttled) - glx_renderer->glXSwapInterval (1); - else - glx_renderer->glXSwapInterval (0); - } + glx_renderer->glXSwapInterval (1); XSync (xlib_renderer->xdpy, False); @@ -2074,16 +2068,8 @@ _cogl_winsys_onscreen_swap_region (CoglOnscreen *onscreen, framebuffer, COGL_FRAMEBUFFER_STATE_BIND); - if (framebuffer->config.swap_throttled) - { - have_counter = glx_display->have_vblank_counter; - can_wait = glx_display->can_vblank_wait; - } - else - { - have_counter = FALSE; - can_wait = FALSE; - } + have_counter = glx_display->have_vblank_counter; + can_wait = glx_display->can_vblank_wait; /* We need to ensure that all the rendering is done, otherwise * redraw operations that are slower than the framerate can @@ -2250,71 +2236,66 @@ _cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen, drawable = glx_onscreen->glxwin ? glx_onscreen->glxwin : xlib_onscreen->xwin; - if (framebuffer->config.swap_throttled) + have_counter = glx_display->have_vblank_counter; + + if (glx_renderer->glXSwapInterval) { - have_counter = glx_display->have_vblank_counter; - - if (glx_renderer->glXSwapInterval) + if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_THREADED_SWAP_WAIT)) { - if (_cogl_has_private_feature (context, COGL_PRIVATE_FEATURE_THREADED_SWAP_WAIT)) - { - /* If we didn't wait for the GPU here, then it's easy to get the case - * where there is a VBlank between the point where we get the vsync counter - * and the point where the GPU is ready to actually perform the glXSwapBuffers(), - * and the swap wait terminates at the first VBlank rather than the one - * where the swap buffers happens. Calling glFinish() here makes this a - * rare race since the GPU is already ready to swap when we call glXSwapBuffers(). - * The glFinish() also prevents any serious damage if the rare race happens, - * since it will wait for the preceding glXSwapBuffers() and prevent us from - * getting premanently ahead. (For NVIDIA drivers, glFinish() after glXSwapBuffers() - * waits for the buffer swap to happen.) - */ - _cogl_winsys_wait_for_gpu (onscreen); - start_threaded_swap_wait (onscreen, _cogl_winsys_get_vsync_counter (context)); - } - } - else - { - CoglBool can_wait = have_counter || glx_display->can_vblank_wait; - - uint32_t end_frame_vsync_counter = 0; - - /* If the swap_region API is also being used then we need to track - * the vsync counter for each swap request so we can manually - * throttle swap_region requests. */ - if (have_counter) - end_frame_vsync_counter = _cogl_winsys_get_vsync_counter (context); - - /* If we are going to wait for VBLANK manually, we not only - * need to flush out pending drawing to the GPU before we - * sleep, we need to wait for it to finish. Otherwise, we - * may end up with the situation: - * - * - We finish drawing - GPU drawing continues - * - We go to sleep - GPU drawing continues - * VBLANK - We call glXSwapBuffers - GPU drawing continues - * - GPU drawing continues - * - Swap buffers happens - * - * Producing a tear. Calling glFinish() first will cause us - * to properly wait for the next VBLANK before we swap. This - * obviously does not happen when we use _GLX_SWAP and let - * the driver do the right thing + /* If we didn't wait for the GPU here, then it's easy to get the case + * where there is a VBlank between the point where we get the vsync counter + * and the point where the GPU is ready to actually perform the glXSwapBuffers(), + * and the swap wait terminates at the first VBlank rather than the one + * where the swap buffers happens. Calling glFinish() here makes this a + * rare race since the GPU is already ready to swap when we call glXSwapBuffers(). + * The glFinish() also prevents any serious damage if the rare race happens, + * since it will wait for the preceding glXSwapBuffers() and prevent us from + * getting premanently ahead. (For NVIDIA drivers, glFinish() after glXSwapBuffers() + * waits for the buffer swap to happen.) */ _cogl_winsys_wait_for_gpu (onscreen); - - if (have_counter && can_wait) - { - if (glx_onscreen->last_swap_vsync_counter == - end_frame_vsync_counter) - _cogl_winsys_wait_for_vblank (onscreen); - } - else if (can_wait) - _cogl_winsys_wait_for_vblank (onscreen); + start_threaded_swap_wait (onscreen, _cogl_winsys_get_vsync_counter (context)); } } else - have_counter = FALSE; + { + CoglBool can_wait = have_counter || glx_display->can_vblank_wait; + + uint32_t end_frame_vsync_counter = 0; + + /* If the swap_region API is also being used then we need to track + * the vsync counter for each swap request so we can manually + * throttle swap_region requests. */ + if (have_counter) + end_frame_vsync_counter = _cogl_winsys_get_vsync_counter (context); + + /* If we are going to wait for VBLANK manually, we not only + * need to flush out pending drawing to the GPU before we + * sleep, we need to wait for it to finish. Otherwise, we + * may end up with the situation: + * + * - We finish drawing - GPU drawing continues + * - We go to sleep - GPU drawing continues + * VBLANK - We call glXSwapBuffers - GPU drawing continues + * - GPU drawing continues + * - Swap buffers happens + * + * Producing a tear. Calling glFinish() first will cause us + * to properly wait for the next VBLANK before we swap. This + * obviously does not happen when we use _GLX_SWAP and let + * the driver do the right thing + */ + _cogl_winsys_wait_for_gpu (onscreen); + + if (have_counter && can_wait) + { + if (glx_onscreen->last_swap_vsync_counter == + end_frame_vsync_counter) + _cogl_winsys_wait_for_vblank (onscreen); + } + else if (can_wait) + _cogl_winsys_wait_for_vblank (onscreen); + } glx_renderer->glXSwapBuffers (xlib_renderer->xdpy, drawable); @@ -2332,23 +2313,6 @@ _cogl_winsys_onscreen_x11_get_window_xid (CoglOnscreen *onscreen) return xlib_onscreen->xwin; } -static void -_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen) -{ - CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context; - CoglContextGLX *glx_context = context->winsys; - CoglOnscreenGLX *glx_onscreen = onscreen->winsys; - CoglOnscreenXlib *xlib_onscreen = onscreen->winsys; - GLXDrawable drawable = - glx_onscreen->glxwin ? glx_onscreen->glxwin : xlib_onscreen->xwin; - - if (glx_context->current_drawable != drawable) - return; - - glx_context->current_drawable = 0; - _cogl_winsys_onscreen_bind (onscreen); -} - static void _cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen, CoglBool visibility) @@ -3022,8 +2986,6 @@ static CoglWinsysVtable _cogl_winsys_vtable = _cogl_winsys_onscreen_swap_buffers_with_damage, .onscreen_swap_region = _cogl_winsys_onscreen_swap_region, .onscreen_get_buffer_age = _cogl_winsys_onscreen_get_buffer_age, - .onscreen_update_swap_throttled = - _cogl_winsys_onscreen_update_swap_throttled, .onscreen_x11_get_window_xid = _cogl_winsys_onscreen_x11_get_window_xid, .onscreen_set_visibility = _cogl_winsys_onscreen_set_visibility, diff --git a/cogl/cogl/winsys/cogl-winsys-private.h b/cogl/cogl/winsys/cogl-winsys-private.h index ba4ad13e3..38626dd2b 100644 --- a/cogl/cogl/winsys/cogl-winsys-private.h +++ b/cogl/cogl/winsys/cogl-winsys-private.h @@ -122,9 +122,6 @@ typedef struct _CoglWinsysVtable const int *rectangles, int n_rectangles); - void - (*onscreen_update_swap_throttled) (CoglOnscreen *onscreen); - void (*onscreen_set_visibility) (CoglOnscreen *onscreen, CoglBool visibility); diff --git a/cogl/cogl/winsys/cogl-winsys-stub.c b/cogl/cogl/winsys/cogl-winsys-stub.c index 06815ea0a..1349d9687 100644 --- a/cogl/cogl/winsys/cogl-winsys-stub.c +++ b/cogl/cogl/winsys/cogl-winsys-stub.c @@ -143,11 +143,6 @@ _cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen, { } -static void -_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen) -{ -} - static void _cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen, CoglBool visibility) @@ -184,8 +179,6 @@ _cogl_winsys_stub_get_vtable (void) vtable.onscreen_bind = _cogl_winsys_onscreen_bind; vtable.onscreen_swap_buffers_with_damage = _cogl_winsys_onscreen_swap_buffers_with_damage; - vtable.onscreen_update_swap_throttled = - _cogl_winsys_onscreen_update_swap_throttled; vtable.onscreen_set_visibility = _cogl_winsys_onscreen_set_visibility; vtable_inited = TRUE; diff --git a/cogl/configure.ac b/cogl/configure.ac index 4c3f2eb2c..8c02b392c 100644 --- a/cogl/configure.ac +++ b/cogl/configure.ac @@ -693,7 +693,6 @@ tests/Makefile tests/config.env tests/conform/Makefile tests/unit/Makefile -tests/micro-perf/Makefile tests/data/Makefile ) diff --git a/cogl/tests/Makefile.am b/cogl/tests/Makefile.am index 7e483291f..3d0c1b25d 100644 --- a/cogl/tests/Makefile.am +++ b/cogl/tests/Makefile.am @@ -4,9 +4,9 @@ if UNIT_TESTS SUBDIRS += unit endif -SUBDIRS += micro-perf data +SUBDIRS += data -DIST_SUBDIRS = conform unit micro-perf data +DIST_SUBDIRS = conform unit data EXTRA_DIST = README test-launcher.sh run-tests.sh diff --git a/cogl/tests/meson.build b/cogl/tests/meson.build index a1853774a..e5b85bbfc 100644 --- a/cogl/tests/meson.build +++ b/cogl/tests/meson.build @@ -11,4 +11,3 @@ cogl_config_env = configure_file( subdir('conform') subdir('unit') -subdir('micro-perf') diff --git a/cogl/tests/micro-perf/Makefile.am b/cogl/tests/micro-perf/Makefile.am deleted file mode 100644 index 83837f293..000000000 --- a/cogl/tests/micro-perf/Makefile.am +++ /dev/null @@ -1,24 +0,0 @@ -NULL = - -AM_CPPFLAGS = \ - -I$(top_srcdir) \ - -I$(top_builddir)/cogl \ - -DCOGL_DISABLE_DEPRECATED - -test_conformance_CPPFLAGS = \ - -DTESTS_DATADIR=\""$(top_srcdir)/tests/data"\" - - -noinst_PROGRAMS = - -noinst_PROGRAMS += test-journal - -AM_CFLAGS = $(COGL_DEP_CFLAGS) $(COGL_EXTRA_CFLAGS) - -common_ldadd = \ - $(COGL_DEP_LIBS) \ - $(top_builddir)/cogl/libmutter-cogl-$(LIBMUTTER_API_VERSION).la \ - $(LIBM) - -test_journal_SOURCES = test-journal.c -test_journal_LDADD = $(common_ldadd) diff --git a/cogl/tests/micro-perf/meson.build b/cogl/tests/micro-perf/meson.build deleted file mode 100644 index b6d93b2cf..000000000 --- a/cogl/tests/micro-perf/meson.build +++ /dev/null @@ -1,18 +0,0 @@ -cogl_test_journal_sources = [ - 'test-journal.c', -] - -cogl_test_journal = executable('test-journal', - sources: cogl_test_journal_sources, - c_args: cogl_debug_c_args + [ - '-DCOGL_DISABLE_DEPRECATED', - '-DTESTS_DATADIR="@0@"'.format(join_paths(cogl_srcdir, 'tests/data')), - ], - include_directories: cogl_includepath, - dependencies: [ - cogl_deps, - libmutter_cogl_dep, - libmutter_cogl_path_dep, - ], - install: false, -) diff --git a/cogl/tests/micro-perf/test-journal.c b/cogl/tests/micro-perf/test-journal.c deleted file mode 100644 index 7bfdcf790..000000000 --- a/cogl/tests/micro-perf/test-journal.c +++ /dev/null @@ -1,190 +0,0 @@ -#include -#include -#include - -#include "cogl/cogl-profile.h" - -#define FRAMEBUFFER_WIDTH 800 -#define FRAMEBUFFER_HEIGHT 600 - -CoglBool run_all = FALSE; - -typedef struct _Data -{ - CoglContext *ctx; - CoglFramebuffer *fb; - CoglPipeline *pipeline; - CoglPipeline *alpha_pipeline; - GTimer *timer; - int frame; -} Data; - -static void -test_rectangles (Data *data) -{ -#define RECT_WIDTH 5 -#define RECT_HEIGHT 5 - int x; - int y; - - cogl_framebuffer_clear4f (data->fb, COGL_BUFFER_BIT_COLOR, 1, 1, 1, 1); - - cogl_framebuffer_push_rectangle_clip (data->fb, - 10, - 10, - FRAMEBUFFER_WIDTH - 10, - FRAMEBUFFER_HEIGHT - 10); - - /* Should the rectangles be randomly positioned/colored/rotated? - * - * It could be good to develop equivalent GL and Cairo tests so we can - * have a sanity check for our Cogl performance. - * - * The color should vary to check that we correctly batch color changes - * The use of alpha should vary so we have a variation of which rectangles - * require blending. - * Should this be a random variation? - * It could be good to experiment with focibly enabling blending for - * rectangles that don't technically need it for the sake of extending - * batching. E.g. if you a long run of interleved rectangles with every - * other rectangle needing blending then it may be worth enabling blending - * for all the rectangles to avoid the state changes. - * The modelview should change between rectangles to check the software - * transform codepath. - * Should we group some rectangles under the same modelview? Potentially - * we could avoid software transform for long runs of rectangles with the - * same modelview. - * - */ - for (y = 0; y < FRAMEBUFFER_HEIGHT; y += RECT_HEIGHT) - { - for (x = 0; x < FRAMEBUFFER_WIDTH; x += RECT_WIDTH) - { - cogl_framebuffer_push_matrix (data->fb); - cogl_framebuffer_translate (data->fb, x, y, 0); - cogl_framebuffer_rotate (data->fb, 45, 0, 0, 1); - - cogl_pipeline_set_color4f (data->pipeline, - 1, - (1.0f/FRAMEBUFFER_WIDTH)*y, - (1.0f/FRAMEBUFFER_HEIGHT)*x, - 1); - cogl_framebuffer_draw_rectangle (data->fb, - data->pipeline, - 0, 0, RECT_WIDTH, RECT_HEIGHT); - - cogl_framebuffer_pop_matrix (data->fb); - } - } - - for (y = 0; y < FRAMEBUFFER_HEIGHT; y += RECT_HEIGHT) - { - for (x = 0; x < FRAMEBUFFER_WIDTH; x += RECT_WIDTH) - { - cogl_framebuffer_push_matrix (data->fb); - cogl_framebuffer_translate (data->fb, x, y, 0); - - cogl_pipeline_set_color4f (data->alpha_pipeline, - 1, - (1.0f/FRAMEBUFFER_WIDTH)*x, - (1.0f/FRAMEBUFFER_HEIGHT)*y, - (1.0f/FRAMEBUFFER_WIDTH)*x); - cogl_framebuffer_draw_rectangle (data->fb, - data->alpha_pipeline, - 0, 0, RECT_WIDTH, RECT_HEIGHT); - - cogl_framebuffer_pop_matrix (data->fb); - } - } - - cogl_framebuffer_pop_clip (data->fb); -} - -static CoglBool -paint_cb (void *user_data) -{ - Data *data = user_data; - double elapsed; - - data->frame++; - - test_rectangles (data); - - cogl_onscreen_swap_buffers (COGL_ONSCREEN (data->fb)); - - elapsed = g_timer_elapsed (data->timer, NULL); - if (elapsed > 1.0) - { - g_print ("fps = %f\n", data->frame / elapsed); - g_timer_start (data->timer); - data->frame = 0; - } - - return FALSE; /* remove the callback */ -} - -static void -frame_event_cb (CoglOnscreen *onscreen, - CoglFrameEvent event, - CoglFrameInfo *info, - void *user_data) -{ - if (event == COGL_FRAME_EVENT_SYNC) - paint_cb (user_data); -} - -int -main (int argc, char **argv) -{ - Data data; - CoglOnscreen *onscreen; - GSource *cogl_source; - GMainLoop *loop; - COGL_STATIC_TIMER (mainloop_timer, - NULL, //no parent - "Mainloop", - "The time spent in the glib mainloop", - 0); // no application private data - - data.ctx = cogl_context_new (NULL, NULL); - - onscreen = cogl_onscreen_new (data.ctx, - FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT); - cogl_onscreen_set_swap_throttled (onscreen, FALSE); - cogl_onscreen_show (onscreen); - - data.fb = onscreen; - cogl_framebuffer_orthographic (data.fb, - 0, 0, - FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT, - -1, - 100); - - data.pipeline = cogl_pipeline_new (data.ctx); - cogl_pipeline_set_color4f (data.pipeline, 1, 1, 1, 1); - data.alpha_pipeline = cogl_pipeline_new (data.ctx); - cogl_pipeline_set_color4f (data.alpha_pipeline, 1, 1, 1, 0.5); - - cogl_source = cogl_glib_source_new (data.ctx, G_PRIORITY_DEFAULT); - - g_source_attach (cogl_source, NULL); - - cogl_onscreen_add_frame_callback (COGL_ONSCREEN (data.fb), - frame_event_cb, - &data, - NULL); /* destroy notify */ - - g_idle_add (paint_cb, &data); - - data.frame = 0; - data.timer = g_timer_new (); - g_timer_start (data.timer); - - loop = g_main_loop_new (NULL, TRUE); - COGL_TIMER_START (uprof_get_mainloop_context (), mainloop_timer); - g_main_loop_run (loop); - COGL_TIMER_STOP (uprof_get_mainloop_context (), mainloop_timer); - - return 0; -} - diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c index 0a06beb87..338eec2d4 100644 --- a/src/backends/native/meta-renderer-native.c +++ b/src/backends/native/meta-renderer-native.c @@ -2727,9 +2727,6 @@ meta_renderer_native_create_onscreen (MetaRendererNative *renderer_native, onscreen = cogl_onscreen_new (context, width, height); - /* We have wait_for_pending_flips hardcoded, so throttling always. */ - cogl_onscreen_set_swap_throttled (onscreen, TRUE); - if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error)) { cogl_object_unref (onscreen);