static rut_input_event_status_t
control_point_grab_cb(rut_input_event_t *event,
void *user_data)
{
grab_state_t *state = user_data;
rig_selection_tool_t *tool = state->tool;
// entity_state_t *entity_state = state->entity_state;
// control_point_t *point = state->point;
rut_input_event_status_t status = RUT_INPUT_EVENT_STATUS_UNHANDLED;
rut_motion_event_action_t action;
if (rut_input_event_get_type(event) == RUT_INPUT_EVENT_TYPE_KEY &&
rut_key_event_get_keysym(event) == RUT_KEY_Escape) {
rut_shell_ungrab_input(
tool->view->shell, control_point_grab_cb, state);
c_slice_free(grab_state_t, state);
return RUT_INPUT_EVENT_STATUS_HANDLED;
}
if (rut_input_event_get_type(event) != RUT_INPUT_EVENT_TYPE_MOTION)
return RUT_INPUT_EVENT_STATUS_UNHANDLED;
action = rut_motion_event_get_action(event);
switch (action) {
case RUT_MOTION_EVENT_ACTION_MOVE:
case RUT_MOTION_EVENT_ACTION_UP: {
// float x = rut_motion_event_get_x (event);
// float y = rut_motion_event_get_y (event);
if (action == RUT_MOTION_EVENT_ACTION_UP) {
if ((rut_motion_event_get_button_state(event) &
RUT_BUTTON_STATE_1) == 0) {
status = RUT_INPUT_EVENT_STATUS_HANDLED;
rut_shell_ungrab_input(
tool->shell, control_point_grab_cb, state);
c_slice_free(grab_state_t, state);
}
} else
status = RUT_INPUT_EVENT_STATUS_HANDLED;
} break;
default:
break;
}
return status;
}
static void
_cg_winsys_onscreen_deinit(cg_onscreen_t *onscreen)
{
cg_onscreen_sdl2_t *sdl_onscreen = onscreen->winsys;
if (sdl_onscreen->window != NULL) {
cg_device_t *dev = CG_FRAMEBUFFER(onscreen)->dev;
cg_device_sdl2_t *sdl_context = dev->winsys;
if (sdl_context->current_window == sdl_onscreen->window) {
cg_display_sdl2_t *sdl_display = dev->display->winsys;
/* SDL explicitly unbinds the context when the currently
* bound window is destroyed. CGlib always needs a context
* bound so that for example it can create texture resources
* at any time even without flushing a framebuffer.
* Therefore we'll bind the dummy window. */
SDL_GL_MakeCurrent(sdl_display->dummy_window, sdl_display->context);
sdl_context->current_window = sdl_display->dummy_window;
}
SDL_DestroyWindow(sdl_onscreen->window);
sdl_onscreen->window = NULL;
}
c_slice_free(cg_onscreen_sdl2_t, sdl_onscreen);
onscreen->winsys = NULL;
}
static void
_cg_winsys_egl_onscreen_deinit(cg_onscreen_t *onscreen)
{
cg_framebuffer_t *framebuffer = CG_FRAMEBUFFER(onscreen);
cg_device_t *dev = framebuffer->dev;
cg_renderer_t *renderer = dev->display->renderer;
cg_xlib_renderer_t *xlib_renderer = _cg_xlib_renderer_get_data(renderer);
cg_xlib_trap_state_t old_state;
cg_onscreen_egl_t *egl_onscreen = onscreen->winsys;
cg_onscreen_xlib_t *xlib_onscreen = egl_onscreen->platform;
_cg_xlib_renderer_trap_errors(renderer, &old_state);
if (!xlib_onscreen->is_foreign_xwin && xlib_onscreen->xwin != None) {
XDestroyWindow(xlib_renderer->xdpy, xlib_onscreen->xwin);
xlib_onscreen->xwin = None;
} else
xlib_onscreen->xwin = None;
XSync(xlib_renderer->xdpy, False);
if (_cg_xlib_renderer_untrap_errors(renderer, &old_state) != Success)
c_warning("X Error while destroying X window");
c_slice_free(cg_onscreen_xlib_t, xlib_onscreen);
}
static void
_cg_winsys_egl_display_destroy(cg_display_t *display)
{
cg_display_egl_t *egl_display = display->winsys;
c_slice_free(cg_display_xlib_t, egl_display->platform);
}
static void
_cg_winsys_renderer_disconnect(cg_renderer_t *renderer)
{
SDL_VideoQuit();
c_slice_free(cg_renderer_sdl2_t, renderer->winsys);
}
static void
_stream_free(void *object)
{
rig_pb_stream_t *stream = object;
#ifdef USE_UV
/* resolve and connect requests take a reference on the stream so
* we should never try and free a stream in these cases... */
c_return_if_fail(stream->resolving == false);
c_return_if_fail(stream->connecting == false);
#endif
rig_pb_stream_disconnect(stream);
if (stream->type == STREAM_TYPE_BUFFER && stream->buffer.connect_idle) {
rut_poll_shell_remove_idle_FIXME(stream->shell, stream->buffer.connect_idle);
stream->buffer.connect_idle = NULL;
}
rut_closure_list_disconnect_all_FIXME(&stream->on_connect_closures);
rut_closure_list_disconnect_all_FIXME(&stream->on_error_closures);
#ifdef USE_UV
c_free(stream->hostname);
c_free(stream->port);
#endif
c_slice_free(rig_pb_stream_t, stream);
}
static void
hash_table_free_cg_cb(void *key, void *value, void *user_data)
{
cg_sampler_cache_entry_t *entry = value;
c_slice_free(cg_sampler_cache_entry_t, entry);
}
static void
_cg_winsys_onscreen_deinit(cg_onscreen_t *onscreen)
{
cg_onscreen_webgl_t *webgl_onscreen = onscreen->winsys;
c_slice_free(cg_onscreen_webgl_t, webgl_onscreen);
onscreen->winsys = NULL;
}
static void
_cg_pixel_buffer_free(cg_pixel_buffer_t *buffer)
{
/* parent's destructor */
_cg_buffer_fini(CG_BUFFER(buffer));
c_slice_free(cg_pixel_buffer_t, buffer);
}
static void
_cg_winsys_renderer_disconnect(cg_renderer_t *renderer)
{
cg_renderer_egl_t *egl_renderer = renderer->winsys;
_cg_xlib_renderer_disconnect(renderer);
eglTerminate(egl_renderer->edpy);
c_slice_free(cg_renderer_egl_t, egl_renderer);
}
static void
hash_table_free_gl_cb(void *key, void *value, void *user_data)
{
cg_device_t *dev = user_data;
cg_sampler_cache_entry_t *entry = value;
if (_cg_has_private_feature(dev, CG_PRIVATE_FEATURE_SAMPLER_OBJECTS))
GE(dev, glDeleteSamplers(1, &entry->sampler_object));
c_slice_free(cg_sampler_cache_entry_t, entry);
}
void
_cg_memory_stack_free(cg_memory_stack_t *stack)
{
while (!c_list_empty(&stack->sub_stacks)) {
cg_memory_sub_stack_t *sub_stack = c_container_of(
stack->sub_stacks.next, cg_memory_sub_stack_t, link);
c_list_remove(&sub_stack->link);
_cg_memory_sub_stack_free(sub_stack);
}
c_slice_free(cg_memory_stack_t, stack);
}
static bool
_cg_winsys_onscreen_init(cg_onscreen_t *onscreen,
cg_error_t **error)
{
cg_framebuffer_t *framebuffer = CG_FRAMEBUFFER(onscreen);
cg_device_t *dev = framebuffer->dev;
cg_display_t *display = dev->display;
cg_display_egl_t *egl_display = display->winsys;
cg_renderer_t *renderer = display->renderer;
cg_renderer_egl_t *egl_renderer = renderer->winsys;
EGLint attributes[MAX_EGL_CONFIG_ATTRIBS];
EGLConfig egl_config;
EGLint config_count = 0;
EGLBoolean status;
c_return_val_if_fail(egl_display->egl_context, false);
egl_attributes_from_framebuffer_config(
display, &framebuffer->config, attributes);
status = eglChooseConfig(
egl_renderer->edpy, attributes, &egl_config, 1, &config_count);
if (status != EGL_TRUE || config_count == 0) {
_cg_set_error(error,
CG_WINSYS_ERROR,
CG_WINSYS_ERROR_CREATE_ONSCREEN,
"Failed to find a suitable EGL configuration");
return false;
}
/* Update the real number of samples_per_pixel now that we have
* found an egl_config... */
if (framebuffer->config.samples_per_pixel) {
EGLint samples;
status = eglGetConfigAttrib(
egl_renderer->edpy, egl_config, EGL_SAMPLES, &samples);
c_return_val_if_fail(status == EGL_TRUE, true);
framebuffer->samples_per_pixel = samples;
}
onscreen->winsys = c_slice_new0(cg_onscreen_egl_t);
if (egl_renderer->platform_vtable->onscreen_init &&
!egl_renderer->platform_vtable->onscreen_init(
onscreen, egl_config, error)) {
c_slice_free(cg_onscreen_egl_t, onscreen->winsys);
return false;
}
return true;
}
void
rig_selection_tool_destroy(rig_selection_tool_t *tool)
{
c_llist_t *l;
rut_closure_list_disconnect_all_FIXME(&tool->selection_event_cb_list);
cg_object_unref(tool->default_pipeline);
for (l = tool->selected_entities; l; l = l->next)
entity_state_destroy(l->data);
c_llist_free(tool->selected_entities);
c_slice_free(rig_selection_tool_t, tool);
}
static void
entity_state_destroy(entity_state_t *entity_state)
{
c_llist_t *l;
for (l = entity_state->control_points; l; l = l->next) {
control_point_t *point = l->data;
rut_graphable_remove_child(point->input_region);
rut_graphable_remove_child(point->transform);
}
rut_object_unref(entity_state->entity);
c_slice_free(entity_state_t, entity_state);
}
static void
_cg_winsys_display_destroy(cg_display_t *display)
{
cg_renderer_egl_t *egl_renderer = display->renderer->winsys;
cg_display_egl_t *egl_display = display->winsys;
c_return_if_fail(egl_display != NULL);
cleanup_device(display);
if (egl_renderer->platform_vtable->display_destroy)
egl_renderer->platform_vtable->display_destroy(display);
c_slice_free(cg_display_egl_t, display->winsys);
display->winsys = NULL;
}
static void
_cg_winsys_display_destroy(cg_display_t *display)
{
cg_display_sdl2_t *sdl_display = display->winsys;
c_return_if_fail(sdl_display != NULL);
if (sdl_display->context)
SDL_GL_DeleteContext(sdl_display->context);
if (sdl_display->dummy_window)
SDL_DestroyWindow(sdl_display->dummy_window);
c_slice_free(cg_display_sdl2_t, display->winsys);
display->winsys = NULL;
}
static void
_cg_winsys_display_destroy(cg_display_t *display)
{
cg_webgl_display_t *webgl_display = display->winsys;
c_return_if_fail(webgl_display != NULL);
if (webgl_display->context > 0)
emscripten_webgl_destroy_context(webgl_display->context);
if (webgl_display->window > 0)
CGlib_Emscripten_DestroyWindow(webgl_display->window);
c_free(webgl_display->window_id);
c_slice_free(cg_webgl_display_t, display->winsys);
display->winsys = NULL;
}
void
rut_headless_shell_handle_stream_event(rut_shell_t *shell,
rut_stream_event_t *stream_event)
{
rut_input_event_t *event = c_slice_alloc0(sizeof(rut_input_event_t));
event->native = stream_event;
event->type = 0;
event->camera_entity = stream_event->camera_entity;
event->onscreen = shell->headless_onscreen;
switch (stream_event->type) {
case RUT_STREAM_EVENT_POINTER_MOVE:
case RUT_STREAM_EVENT_POINTER_DOWN:
case RUT_STREAM_EVENT_POINTER_UP:
event->type = RUT_INPUT_EVENT_TYPE_MOTION;
break;
case RUT_STREAM_EVENT_KEY_DOWN:
case RUT_STREAM_EVENT_KEY_UP:
event->type = RUT_INPUT_EVENT_TYPE_KEY;
break;
}
/* Note: we don't use a default: case since we want the
* compiler to warn us when we forget to handle a new
* enum */
if (!event->type) {
c_warning("Shell: Spurious stream event type %d\n", stream_event->type);
c_slice_free(rut_input_event_t, event);
return;
}
rut_input_queue_append(shell->input_queue, event);
/* FIXME: we need a separate status so we can trigger a new
* frame, but if the input doesn't affect anything then we
* want to avoid any actual rendering. */
rut_shell_queue_redraw(shell);
}
static void
_cg_winsys_onscreen_deinit(cg_onscreen_t *onscreen)
{
cg_framebuffer_t *framebuffer = CG_FRAMEBUFFER(onscreen);
cg_device_t *dev = framebuffer->dev;
cg_display_egl_t *egl_display = dev->display->winsys;
cg_renderer_t *renderer = dev->display->renderer;
cg_renderer_egl_t *egl_renderer = renderer->winsys;
cg_onscreen_egl_t *egl_onscreen = onscreen->winsys;
/* If we never successfully allocated then there's nothing to do */
if (egl_onscreen == NULL)
return;
if (egl_onscreen->egl_surface != EGL_NO_SURFACE) {
/* CGlib always needs a valid context bound to something so if we
* are destroying the onscreen that is currently bound we'll
* switch back to the dummy drawable. */
if (egl_display->dummy_surface != EGL_NO_SURFACE &&
(egl_display->current_draw_surface == egl_onscreen->egl_surface ||
egl_display->current_read_surface == egl_onscreen->egl_surface)) {
_cg_winsys_egl_make_current(dev->display,
egl_display->dummy_surface,
egl_display->dummy_surface,
egl_display->current_context);
}
if (!eglDestroySurface(egl_renderer->edpy, egl_onscreen->egl_surface))
c_warning("Failed to destroy EGL surface");
egl_onscreen->egl_surface = EGL_NO_SURFACE;
}
if (egl_renderer->platform_vtable->onscreen_deinit)
egl_renderer->platform_vtable->onscreen_deinit(onscreen);
c_slice_free(cg_onscreen_egl_t, onscreen->winsys);
onscreen->winsys = NULL;
}
static void
destroy_xlib_renderer_data(void *user_data)
{
c_slice_free(cg_xlib_renderer_t, user_data);
}
static void
_cg_winsys_renderer_disconnect(cg_renderer_t *renderer)
{
c_slice_free(cg_renderer_webgl_t, renderer->winsys);
}
static void
_cg_onscreen_template_free(cg_onscreen_template_t *onscreen_template)
{
c_slice_free(cg_onscreen_template_t, onscreen_template);
}
static void
_cg_indices_free(cg_indices_t *indices)
{
cg_object_unref(indices->buffer);
c_slice_free(cg_indices_t, indices);
}
void
rig_downsampler_free(rig_downsampler_t *downsampler)
{
_rig_downsampler_reset(downsampler);
c_slice_free(rig_downsampler_t, downsampler);
}
static void
rut_headless_free_input_event(rut_input_event_t *event)
{
c_slice_free(rut_stream_event_t, event->native);
c_slice_free(rut_input_event_t, event);
}
static void
_cg_memory_sub_stack_free(cg_memory_sub_stack_t *sub_stack)
{
c_free(sub_stack->data);
c_slice_free(cg_memory_sub_stack_t, sub_stack);
}
