Ejemplo n.º 1
0
static void
create_dummy_control_points(entity_state_t *entity_state)
{
    rig_selection_tool_t *tool = entity_state->tool;
    cg_texture_t *tex =
        rut_load_texture_from_data_file(tool->shell, "dot.png", NULL);
    control_point_t *point;

    point = c_slice_new0(control_point_t);
    point->entity_state = entity_state;
    point->x = 0;
    point->y = 0;
    point->z = 0;

    point->transform = rut_transform_new(tool->shell);
    rut_graphable_add_child(tool->tool_overlay, point->transform);
    rut_object_unref(point->transform);

    point->marker = rut_nine_slice_new(tool->shell, tex, 0, 0, 0, 0, 10, 10);
    rut_graphable_add_child(point->transform, point->marker);
    rut_object_unref(point->marker);

    point->input_region =
        rut_input_region_new_circle(0, 0, 5, control_point_input_cb, point);
    rut_graphable_add_child(tool->tool_overlay, point->input_region);
    rut_object_unref(point->input_region);
    entity_state->control_points =
        c_llist_prepend(entity_state->control_points, point);

    point = c_slice_new0(control_point_t);
    point->entity_state = entity_state;
    point->x = 100;
    point->y = 0;
    point->z = 0;

    point->transform = rut_transform_new(tool->shell);
    rut_graphable_add_child(tool->tool_overlay, point->transform);
    rut_object_unref(point->transform);

    point->marker = rut_nine_slice_new(tool->shell, tex, 0, 0, 0, 0, 10, 10);
    rut_graphable_add_child(point->transform, point->marker);
    rut_object_unref(point->marker);

    point->input_region =
        rut_input_region_new_circle(0, 0, 5, control_point_input_cb, point);
    rut_graphable_add_child(tool->tool_overlay, point->input_region);
    rut_object_unref(point->input_region);
    entity_state->control_points =
        c_llist_prepend(entity_state->control_points, point);

    cg_object_unref(tex);
}
Ejemplo n.º 2
0
static rut_input_event_status_t
control_point_input_cb(
    rut_input_region_t *region, rut_input_event_t *event, void *user_data)
{
    control_point_t *point = user_data;
    entity_state_t *entity_state = point->entity_state;
    rig_selection_tool_t *tool = entity_state->tool;

    c_return_val_if_fail(tool->selected_entities != NULL,
                         RUT_INPUT_EVENT_STATUS_UNHANDLED);

    if (rut_input_event_get_type(event) == RUT_INPUT_EVENT_TYPE_MOTION &&
        rut_motion_event_get_action(event) == RUT_MOTION_EVENT_ACTION_DOWN &&
        rut_motion_event_get_button_state(event) == RUT_BUTTON_STATE_1) {
        // float x = rut_motion_event_get_x (event);
        // float y = rut_motion_event_get_y (event);
        grab_state_t *state = c_slice_new0(grab_state_t);

        state->tool = tool;
        state->entity_state = entity_state;
        state->point = point;

        rut_shell_grab_input(tool->shell,
                             rut_input_event_get_camera(event),
                             control_point_grab_cb,
                             state);

        return RUT_INPUT_EVENT_STATUS_HANDLED;
    }

    return RUT_INPUT_EVENT_STATUS_UNHANDLED;
}
Ejemplo n.º 3
0
cg_pixel_buffer_t *cg_pixel_buffer_new(cg_device_t *dev,
                                       size_t size,
                                       const void *data,
                                       cg_error_t **error)
{
    cg_pixel_buffer_t *pixel_buffer = c_slice_new0(cg_pixel_buffer_t);
    cg_buffer_t *buffer = CG_BUFFER(pixel_buffer);

    /* parent's constructor */
    _cg_buffer_initialize(buffer,
                          dev,
                          size,
                          CG_BUFFER_BIND_TARGET_PIXEL_UNPACK,
                          CG_BUFFER_USAGE_HINT_TEXTURE,
                          CG_BUFFER_UPDATE_HINT_STATIC);

    _cg_pixel_buffer_object_new(pixel_buffer);

    if (data) {
        if (!cg_buffer_set_data(
                CG_BUFFER(pixel_buffer), 0, data, size, error)) {
            cg_object_unref(pixel_buffer);
            return NULL;
        }
    }

    return pixel_buffer;
}
Ejemplo n.º 4
0
static bool
_cg_winsys_renderer_connect(cg_renderer_t *renderer,
                            cg_error_t **error)
{
    cg_renderer_egl_t *egl_renderer;
    cg_xlib_renderer_t *xlib_renderer;

    renderer->winsys = c_slice_new0(cg_renderer_egl_t);
    egl_renderer = renderer->winsys;
    xlib_renderer = _cg_xlib_renderer_get_data(renderer);

    egl_renderer->platform_vtable = &_cg_winsys_egl_vtable;

    if (!_cg_xlib_renderer_connect(renderer, error))
        goto error;

    egl_renderer->edpy = eglGetDisplay((NativeDisplayType)xlib_renderer->xdpy);

    if (!_cg_winsys_egl_renderer_connect_common(renderer, error))
        goto error;

    return true;

error:
    _cg_winsys_renderer_disconnect(renderer);
    return false;
}
Ejemplo n.º 5
0
rig_selection_tool_t *
rig_selection_tool_new(rig_camera_view_t *view,
                       rut_object_t *overlay)
{
    rig_selection_tool_t *tool = c_slice_new0(rig_selection_tool_t);
    rut_shell_t *shell = view->shell;

    tool->view = view;
    tool->shell = shell;

    /* Note: we don't take a reference on this overlay to avoid creating
     * a circular reference. */
    tool->tool_overlay = overlay;

    tool->camera = view->view_camera;
    tool->camera_component =
        rig_entity_get_component(tool->camera, RIG_COMPONENT_TYPE_CAMERA);

    c_list_init(&tool->selection_event_cb_list);

    /* pipeline to draw the tool */
    tool->default_pipeline = cg_pipeline_new(shell->cg_device);

    return tool;
}
Ejemplo n.º 6
0
static bool
_cg_winsys_renderer_connect(cg_renderer_t *renderer,
                            cg_error_t **error)
{
    renderer->winsys = c_slice_new0(cg_renderer_webgl_t);

    return true;
}
Ejemplo n.º 7
0
cg_memory_stack_t *
_cg_memory_stack_new(size_t initial_size_bytes)
{
    cg_memory_stack_t *stack = c_slice_new0(cg_memory_stack_t);

    c_list_init(&stack->sub_stacks);

    _cg_memory_stack_add_sub_stack(stack, initial_size_bytes);

    return stack;
}
Ejemplo n.º 8
0
static void
objects_selection_event_cb(rig_objects_selection_t *selection,
                           rig_objects_selection_event_t event,
                           rut_object_t *object,
                           void *user_data)
{
    rig_selection_tool_t *tool = user_data;
    entity_state_t *entity_state;
    c_llist_t *l;

    if (!tool->active && event == RIG_OBJECTS_SELECTION_ADD_EVENT)
        return;

    if (rut_object_get_type(object) != &rig_entity_type)
        return;

    for (l = tool->selected_entities; l; l = l->next) {
        entity_state = l->data;
        if (entity_state->entity == object)
            break;
    }
    if (l == NULL)
        entity_state = NULL;

    switch (event) {
    case RIG_OBJECTS_SELECTION_ADD_EVENT: {
        c_return_if_fail(entity_state == NULL);

        entity_state = c_slice_new0(entity_state_t);
        entity_state->tool = tool;
        entity_state->entity = rut_object_ref(object);
        entity_state->control_points = NULL;

        tool->selected_entities =
            c_llist_prepend(tool->selected_entities, entity_state);

        entity_state->sizeable = find_sizeable_component(entity_state->entity);
        if (entity_state->sizeable)
            create_sizeable_control_points(entity_state);
        else
            create_dummy_control_points(entity_state);

        break;
    }

    case RIG_OBJECTS_SELECTION_REMOVE_EVENT:
        c_return_if_fail(entity_state != NULL);

        tool->selected_entities =
            c_llist_remove(tool->selected_entities, entity_state);
        entity_state_destroy(entity_state);
        break;
    }
}
Ejemplo n.º 9
0
static bool
_cg_winsys_egl_display_setup(cg_display_t *display,
                             cg_error_t **error)
{
    cg_display_egl_t *egl_display = display->winsys;
    cg_display_xlib_t *xlib_display;

    xlib_display = c_slice_new0(cg_display_xlib_t);
    egl_display->platform = xlib_display;

    return true;
}
Ejemplo n.º 10
0
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;
}
Ejemplo n.º 11
0
static bool
_cg_winsys_display_setup(cg_display_t *display, cg_error_t **error)
{
    cg_webgl_display_t *webgl_display;
    int window;
    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context;
    EmscriptenWebGLContextAttributes attribs;
    char *id;

    c_return_val_if_fail(display->winsys == NULL, false);

    init_webgl_attribs_from_framebuffer_config(&attribs,
                                               &display->onscreen_template->config);

    window = CGlib_Emscripten_CreateWindow(100, 100, 0, 0);

    if (window < 0) {
        _cg_set_error(error,
                      CG_WINSYS_ERROR,
                      CG_WINSYS_ERROR_INIT,
                      "create window failed");
        return false;
    }

    CGlib_Emscripten_HideWindow(window);

    id = c_strdup_printf("cg_window_%d", window);
    context = emscripten_webgl_create_context(id, &attribs);

    if (context < 0) {
        _cg_set_error(error,
                      CG_WINSYS_ERROR,
                      CG_WINSYS_ERROR_INIT,
                      "create context failed");
        CGlib_Emscripten_DestroyWindow(window);
        c_free(id);
        return false;
    }

    emscripten_webgl_make_context_current(context);

    webgl_display = c_slice_new0(cg_webgl_display_t);
    display->winsys = webgl_display;

    webgl_display->window = window;
    webgl_display->window_id = id;
    webgl_display->context = context;

    return true;
}
Ejemplo n.º 12
0
rig_downsampler_t *
rig_downsampler_new(rig_engine_t *engine)
{
    rig_downsampler_t *downsampler = c_slice_new0(rig_downsampler_t);
    cg_pipeline_t *pipeline;

    downsampler->engine = engine;

    pipeline = cg_pipeline_new(engine->shell->cg_device);
    cg_pipeline_set_layer_texture(pipeline, 0, NULL);
    cg_pipeline_set_blend(pipeline, "RGBA=ADD(SRC_COLOR, 0)", NULL);

    downsampler->pipeline = pipeline;

    return downsampler;
}
Ejemplo n.º 13
0
static bool
_cg_winsys_renderer_connect(cg_renderer_t *renderer,
                            cg_error_t **error)
{
    if (SDL_VideoInit(NULL) < 0) {
        _cg_set_error(error,
                      CG_WINSYS_ERROR,
                      CG_WINSYS_ERROR_INIT,
                      "SDL_Init failed: %s",
                      SDL_GetError());
        return false;
    }

    renderer->winsys = c_slice_new0(cg_renderer_sdl2_t);

    return true;
}
Ejemplo n.º 14
0
cg_onscreen_template_t *
cg_onscreen_template_new(void)
{
    cg_onscreen_template_t *onscreen_template =
        c_slice_new0(cg_onscreen_template_t);
    char *user_config;

    onscreen_template->config.swap_throttled = true;
    onscreen_template->config.need_stencil = true;
    onscreen_template->config.samples_per_pixel = 0;

    user_config = getenv("CG_POINT_SAMPLES_PER_PIXEL");
    if (user_config) {
        unsigned long samples_per_pixel = strtoul(user_config, NULL, 10);
        if (samples_per_pixel != ULONG_MAX)
            onscreen_template->config.samples_per_pixel = samples_per_pixel;
    }

    return _cg_onscreen_template_object_new(onscreen_template);
}
Ejemplo n.º 15
0
static bool
_cg_winsys_display_setup(cg_display_t *display, cg_error_t **error)
{
    cg_display_egl_t *egl_display;
    cg_renderer_t *renderer = display->renderer;
    cg_renderer_egl_t *egl_renderer = renderer->winsys;

    c_return_val_if_fail(display->winsys == NULL, false);

    egl_display = c_slice_new0(cg_display_egl_t);
    display->winsys = egl_display;

#ifdef CG_HAS_WAYLAND_EGL_SERVER_SUPPORT
    if (display->wayland_compositor_display) {
        struct wl_display *wayland_display =
            display->wayland_compositor_display;
        cg_renderer_egl_t *egl_renderer = display->renderer->winsys;

        if (egl_renderer->pf_eglBindWaylandDisplay)
            egl_renderer->pf_eglBindWaylandDisplay(egl_renderer->edpy,
                                                   wayland_display);
    }
#endif

    if (egl_renderer->platform_vtable->display_setup &&
        !egl_renderer->platform_vtable->display_setup(display, error))
        goto error;

    if (!try_create_context(display, error))
        goto error;

    egl_display->found_egl_config = true;

    return true;

error:
    _cg_winsys_display_destroy(display);
    return false;
}
Ejemplo n.º 16
0
cg_xlib_renderer_t *
_cg_xlib_renderer_get_data(cg_renderer_t *renderer)
{
    static cg_user_data_key_t key;
    cg_xlib_renderer_t *data;

    /* Constructs a cg_xlib_renderer_t struct on demand and attaches it to
       the object using user data. It's done this way instead of using a
       subclassing hierarchy in the winsys data because all EGL winsys's
       need the EGL winsys data but only one of them wants the Xlib
       data. */

    data = cg_object_get_user_data(CG_OBJECT(renderer), &key);

    if (data == NULL) {
        data = c_slice_new0(cg_xlib_renderer_t);

        cg_object_set_user_data(
            CG_OBJECT(renderer), &key, data, destroy_xlib_renderer_data);
    }

    return data;
}
Ejemplo n.º 17
0
static bool
_cg_winsys_display_setup(cg_display_t *display, cg_error_t **error)
{
    cg_display_sdl2_t *sdl_display;
    const char *(*get_string_func)(GLenum name);
    const char *gl_version;

    c_return_val_if_fail(display->winsys == NULL, false);

    sdl_display = c_slice_new0(cg_display_sdl2_t);
    display->winsys = sdl_display;

    set_gl_attribs_from_framebuffer_config(&display->onscreen_template->config);

    if (display->renderer->driver == CG_DRIVER_GLES2) {
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
                            SDL_GL_CONTEXT_PROFILE_ES);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
    } else if (display->renderer->driver == CG_DRIVER_GL3) {
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
                            SDL_GL_CONTEXT_PROFILE_CORE);
        SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS,
                            SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
    }

    /* Create a dummy 1x1 window that never gets display so that we can
     * create a GL context */
    sdl_display->dummy_window =
        SDL_CreateWindow("",
                         0,
                         0, /* x/y */
                         1,
                         1, /* w/h */
                         SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN);
    if (sdl_display->dummy_window == NULL) {
        _cg_set_error(error,
                      CG_WINSYS_ERROR,
                      CG_WINSYS_ERROR_INIT,
                      "SDL_CreateWindow failed: %s",
                      SDL_GetError());
        goto error;
    }

    sdl_display->context = SDL_GL_CreateContext(sdl_display->dummy_window);

    if (sdl_display->context == NULL) {
        _cg_set_error(error,
                      CG_WINSYS_ERROR,
                      CG_WINSYS_ERROR_INIT,
                      "SDL_GL_CreateContext failed: %s",
                      SDL_GetError());
        goto error;
    }

    /* SDL doesn't seem to provide a way to select between GL and GLES
     * and instead it will just pick one itself. We can at least try to
     * verify that it picked the one we were expecting by looking at the
     * GL version string */
    get_string_func = SDL_GL_GetProcAddress("glGetString");
    gl_version = get_string_func(GL_VERSION);

    switch (display->renderer->driver) {
    case CG_DRIVER_GL:
    case CG_DRIVER_GL3:
        /* The first character of the version string will be a digit if
         * it's normal GL */
        if (!c_ascii_isdigit(gl_version[0])) {
            _cg_set_error(error,
                          CG_WINSYS_ERROR,
                          CG_WINSYS_ERROR_INIT,
                          "The GL driver was requested but SDL is using GLES");
            goto error;
        }

        if (display->renderer->driver == CG_DRIVER_GL3 && gl_version[0] < '3') {
            _cg_set_error(error,
                          CG_WINSYS_ERROR,
                          CG_WINSYS_ERROR_INIT,
                          "The GL3 driver was requested but SDL is using "
                          "GL %c",
                          gl_version[0]);
            goto error;
        }
        break;

    case CG_DRIVER_GLES2:
        if (!c_str_has_prefix(gl_version, "OpenGL ES 2") &&
            !c_str_has_prefix(gl_version, "OpenGL ES 3")) {
            _cg_set_error(error,
                          CG_WINSYS_ERROR,
                          CG_WINSYS_ERROR_INIT,
                          "The GLES2 driver was requested but SDL is "
                          "not using GLES2 or GLES3");
            goto error;
        }
        break;

    default:
        c_assert_not_reached();
    }

    return true;

error:
    _cg_winsys_display_destroy(display);
    return false;
}