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); }