RutBin *
rut_bin_new (RutContext *ctx)
{
RutBin *bin = g_slice_new0 (RutBin);
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_bin_init_type ();
initialized = TRUE;
}
bin->ref_count = 1;
bin->context = rut_refable_ref (ctx);
bin->x_position = RUT_BIN_POSITION_EXPAND;
bin->y_position = RUT_BIN_POSITION_EXPAND;
rut_list_init (&bin->preferred_size_cb_list);
rut_object_init (&bin->_parent, &rut_bin_type);
rut_graphable_init (RUT_OBJECT (bin));
bin->child_transform = rut_transform_new (ctx);
rut_graphable_add_child (bin, bin->child_transform);
return bin;
}
RutShape *
rut_shape_new (RutContext *ctx,
CoglBool shaped,
int tex_width,
int tex_height)
{
RutShape *shape = g_slice_new0 (RutShape);
rut_object_init (&shape->_parent, &rut_shape_type);
shape->ref_count = 1;
shape->component.type = RUT_COMPONENT_TYPE_GEOMETRY;
shape->ctx = rut_refable_ref (ctx);
shape->tex_width = tex_width;
shape->tex_height = tex_height;
shape->shaped = shaped;
rut_list_init (&shape->reshaped_cb_list);
rut_simple_introspectable_init (shape,
_rut_shape_prop_specs,
shape->properties);
return shape;
}
RutShim *
rut_shim_new (RutContext *ctx,
float width,
float height)
{
RutShim *shim = g_slice_new0 (RutShim);
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_shim_init_type ();
initialized = TRUE;
}
rut_object_init (&shim->_parent, &rut_shim_type);
shim->ref_count = 1;
shim->context = ctx;
rut_list_init (&shim->preferred_size_cb_list);
rut_graphable_init (shim);
shim->width = width;
shim->height = height;
return shim;
}
RutFixed *
rut_fixed_new (RutContext *ctx,
float width,
float height)
{
RutFixed *fixed = g_slice_new0 (RutFixed);
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_fixed_init_type ();
initialized = TRUE;
}
rut_object_init (&fixed->_parent, &rut_fixed_type);
fixed->ref_count = 1;
fixed->context = ctx;
rut_list_init (&fixed->preferred_size_cb_list);
rut_graphable_init (fixed);
fixed->width = width;
fixed->height = height;
return fixed;
}
RutRectangle *
rut_rectangle_new4f (RutContext *ctx,
float width,
float height,
float red,
float green,
float blue,
float alpha)
{
RutRectangle *rectangle = g_slice_new0 (RutRectangle);
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_rectangle_init_type ();
initialized = TRUE;
}
rut_object_init (&rectangle->_parent, &rut_rectangle_type);
rectangle->ref_count = 1;
rut_graphable_init (rectangle);
rut_paintable_init (rectangle);
rectangle->width = width;
rectangle->height = height;
rectangle->pipeline = cogl_pipeline_new (ctx->cogl_context);
cogl_pipeline_set_color4f (rectangle->pipeline,
red, green, blue, alpha);
return rectangle;
}
RutCamera *
rut_camera_new (RutContext *ctx, CoglFramebuffer *framebuffer)
{
RutCamera *camera = g_slice_new0 (RutCamera);
camera->ctx = rut_refable_ref (ctx);
rut_object_init (&camera->_parent, &rut_camera_type);
camera->ref_count = 1;
camera->component.type = RUT_COMPONENT_TYPE_CAMERA;
rut_camera_set_background_color4f (camera, 0, 0, 0, 1);
camera->clear_fb = TRUE;
//rut_graphable_init (RUT_OBJECT (camera));
camera->orthographic = TRUE;
camera->x1 = 0;
camera->y1 = 0;
camera->x2 = 100;
camera->y2 = 100;
camera->near = -1;
camera->far = 100;
camera->zoom = 1;
camera->focal_distance = 30;
camera->depth_of_field = 3;
camera->projection_cache_age = -1;
camera->inverse_projection_age = -1;
cogl_matrix_init_identity (&camera->view);
camera->inverse_view_age = -1;
camera->transform_age = 0;
cogl_matrix_init_identity (&camera->input_transform);
if (framebuffer)
{
int width = cogl_framebuffer_get_width (framebuffer);
int height = cogl_framebuffer_get_height (framebuffer);
camera->fb = cogl_object_ref (framebuffer);
camera->viewport[2] = width;
camera->viewport[3] = height;
camera->x2 = width;
camera->y2 = height;
}
rut_simple_introspectable_init (camera,
_rut_camera_prop_specs,
camera->properties);
return camera;
}
RutPointalismGrid *
rut_pointalism_grid_new (RutContext *ctx,
float size,
int tex_width,
int tex_height)
{
RutPointalismGrid *grid = g_slice_new0 (RutPointalismGrid);
RutBuffer *buffer = rut_buffer_new (sizeof (CoglVertexP3) * 6);
RutMesh *pick_mesh = rut_mesh_new_from_buffer_p3 (COGL_VERTICES_MODE_TRIANGLES,
6,
buffer);
CoglVertexP3 *pick_vertices = (CoglVertexP3 *)buffer->data;
float half_tex_width;
float half_tex_height;
rut_object_init (&grid->_parent, &rut_pointalism_grid_type);
grid->ref_count = 1;
grid->component.type = RUT_COMPONENT_TYPE_GEOMETRY;
grid->ctx = rut_refable_ref (ctx);
rut_list_init (&grid->updated_cb_list);
grid->slice = pointalism_grid_slice_new (tex_width, tex_height,
size);
half_tex_width = tex_width / 2.0f;
half_tex_height = tex_height / 2.0f;
pick_vertices[0].x = -half_tex_width;
pick_vertices[0].y = -half_tex_height;
pick_vertices[1].x = -half_tex_width;
pick_vertices[1].y = half_tex_height;
pick_vertices[2].x = half_tex_width;
pick_vertices[2].y = half_tex_height;
pick_vertices[3] = pick_vertices[0];
pick_vertices[4] = pick_vertices[2];
pick_vertices[5].x = half_tex_width;
pick_vertices[5].y = -half_tex_height;
grid->pick_mesh = pick_mesh;
grid->pointalism_scale = 1;
grid->pointalism_z = 1;
grid->pointalism_lighter = TRUE;
grid->cell_size = size;
grid->tex_width = tex_width;
grid->tex_height = tex_height;
rut_simple_introspectable_init (grid, _rut_pointalism_grid_prop_specs,
grid->properties);
return grid;
}
RutObject *
_rut_object_alloc0 (size_t bytes, RutType *type, RutTypeInit type_init)
{
RutObject *object = g_slice_alloc0 (bytes);
if (G_UNLIKELY (type->name == NULL))
type_init ();
rut_object_init (object, type);
return object;
}
RutDiamond *
rut_diamond_new (RutContext *ctx,
float size,
int tex_width,
int tex_height)
{
RutDiamond *diamond = g_slice_new0 (RutDiamond);
RutBuffer *buffer = rut_buffer_new (sizeof (CoglVertexP3) * 6);
RutMesh *pick_mesh = rut_mesh_new_from_buffer_p3 (COGL_VERTICES_MODE_TRIANGLES,
6,
buffer);
CoglVertexP3 *pick_vertices = (CoglVertexP3 *)buffer->data;
rut_object_init (&diamond->_parent, &rut_diamond_type);
diamond->ref_count = 1;
diamond->component.type = RUT_COMPONENT_TYPE_GEOMETRY;
diamond->ctx = rut_refable_ref (ctx);
diamond->size = size;
/* XXX: It could be worth maintaining a cache of diamond slices
* indexed by the <size, tex_width, tex_height> tuple... */
diamond->slice = diamond_slice_new (ctx, size, tex_width, tex_height);
pick_vertices[0].x = 0;
pick_vertices[0].y = 0;
pick_vertices[1].x = 0;
pick_vertices[1].y = size;
pick_vertices[2].x = size;
pick_vertices[2].y = size;
pick_vertices[3] = pick_vertices[0];
pick_vertices[4] = pick_vertices[2];
pick_vertices[5].x = size;
pick_vertices[5].y = 0;
cogl_matrix_transform_points (&diamond->slice->rotate_matrix,
2,
sizeof (CoglVertexP3),
pick_vertices,
sizeof (CoglVertexP3),
pick_vertices,
6);
diamond->pick_mesh = pick_mesh;
return diamond;
}
static RutPointalismGridSlice *
pointalism_grid_slice_new (int tex_width,
int tex_height,
float size)
{
RutPointalismGridSlice *grid_slice = g_slice_new (RutPointalismGridSlice);
rut_object_init (&grid_slice->_parent, &rut_pointalism_grid_slice_type);
grid_slice->ref_count = 1;
grid_slice->mesh = NULL;
pointalism_generate_grid (grid_slice, tex_width, tex_height, size);
return grid_slice;
}
RigTransition *
rig_transition_new (RutContext *context,
uint32_t id)
{
//CoglError *error = NULL;
RigTransition *transition;
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rig_transition_type_init ();
initialized = TRUE;
}
transition = g_slice_new0 (RigTransition);
transition->id = id;
transition->context = rut_refable_ref (context);
rut_object_init (&transition->_parent, &rig_transition_type);
rut_list_init (&transition->operation_cb_list);
rut_simple_introspectable_init (transition, _rig_transition_prop_specs, transition->props);
transition->progress = 0;
transition->properties = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL, /* key_destroy */
free_prop_data_cb);
#if 0
rut_property_set_binding (&transition->props[RUT_TRANSITION_PROP_PROGRESS],
update_transition_progress_cb,
engine,
engine->timeline_elapsed,
NULL);
#endif
return transition;
}
RutTransform *
rut_transform_new (RutContext *ctx)
{
RutTransform *transform = g_slice_new (RutTransform);
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_transform_init_type ();
initialized = TRUE;
}
rut_object_init (&transform->_parent, &rut_transform_type);
transform->ref_count = 1;
rut_graphable_init (transform);
cogl_matrix_init_identity (&transform->matrix);
return transform;
}
RutLight *
rut_light_new (RutContext *context)
{
RutLight *light;
light = g_slice_new0 (RutLight);
rut_object_init (&light->_parent, &rut_light_type);
light->ref_count = 1;
light->component.type = RUT_COMPONENT_TYPE_LIGHT;
light->context = rut_refable_ref (context);
rut_simple_introspectable_init (light,
_rut_light_prop_specs,
light->properties);
cogl_color_init_from_4f (&light->ambient, 1.0, 1.0, 1.0, 1.0);
cogl_color_init_from_4f (&light->diffuse, 1.0, 1.0, 1.0, 1.0);
cogl_color_init_from_4f (&light->specular, 1.0, 1.0, 1.0, 1.0);
return light;
}
static RutDiamondSlice *
diamond_slice_new (RutContext *ctx,
float size,
int tex_width,
int tex_height)
{
RutDiamondSlice *diamond_slice = g_slice_new (RutDiamondSlice);
float width = size;
float height = size;
#define DIAMOND_SLICE_CORNER_RADIUS 20
CoglMatrix matrix;
float tex_aspect;
rut_object_init (&diamond_slice->_parent, &rut_diamond_slice_type);
diamond_slice->ref_count = 1;
diamond_slice->size = size;
{
/* x0,y0,x1,y1 and s0,t0,s1,t1 define the postion and texture
* coordinates for the center rectangle... */
float x0 = DIAMOND_SLICE_CORNER_RADIUS;
float y0 = DIAMOND_SLICE_CORNER_RADIUS;
float x1 = width - DIAMOND_SLICE_CORNER_RADIUS;
float y1 = height - DIAMOND_SLICE_CORNER_RADIUS;
/* The center region of the nine-slice can simply map to the
* degenerate center of the circle */
float s0 = 0.5;
float t0 = 0.5;
float s1 = 0.5;
float t1 = 0.5;
int n_vertices;
int i;
/*
* 0,0 x0,0 x1,0 width,0
* 0,0 s0,0 s1,0 1,0
* 0 1 2 3
*
* 0,y0 x0,y0 x1,y0 width,y0
* 0,t0 s0,t0 s1,t0 1,t0
* 4 5 6 7
*
* 0,y1 x0,y1 x1,y1 width,y1
* 0,t1 s0,t1 s1,t1 1,t1
* 8 9 10 11
*
* 0,height x0,height x1,height width,height
* 0,1 s0,1 s1,1 1,1
* 12 13 14 15
*/
VertexP2T2T2 vertices[] =
{
{ 0, 0, 0, 0, 0, 0 },
{ x0, 0, s0, 0, x0, 0},
{ x1, 0, s1, 0, x1, 0},
{ width, 0, 1, 0, width, 0},
{ 0, y0, 0, t0, 0, y0},
{ x0, y0, s0, t0, x0, y0},
{ x1, y0, s1, t0, x1, y0},
{ width, y0, 1, t0, width, y0},
{ 0, y1, 0, t1, 0, y1},
{ x0, y1, s0, t1, x0, y1},
{ x1, y1, s1, t1, x1, y1},
{ width, y1, 1, t1, width, y1},
{ 0, height, 0, 1, 0, height},
{ x0, height, s0, 1, x0, height},
{ x1, height, s1, 1, x1, height},
{ width, height, 1, 1, width, height},
};
cogl_matrix_init_identity (&diamond_slice->rotate_matrix);
cogl_matrix_rotate (&diamond_slice->rotate_matrix, 45, 0, 0, 1);
cogl_matrix_translate (&diamond_slice->rotate_matrix, - width / 2.0, - height / 2.0, 0);
n_vertices = sizeof (vertices) / sizeof (VertexP2T2T2);
for (i = 0; i < n_vertices; i++)
{
float z = 0, w = 1;
cogl_matrix_transform_point (&diamond_slice->rotate_matrix,
&vertices[i].x,
&vertices[i].y,
&z,
&w);
#ifdef MESA_CONST_ATTRIB_BUG_WORKAROUND
vertices[i].Nx = 0;
vertices[i].Ny = 0;
vertices[i].Nz = 1;
vertices[i].Tx = 1;
vertices[i].Ty = 0;
vertices[i].Tz = 0;
#endif
}
cogl_matrix_init_identity (&matrix);
{
float s_scale = 1.0, t_scale = 1.0;
float s0, t0;
float diagonal_size_scale = 1.0 / (sinf (G_PI_4) * 2.0);
tex_aspect = (float)tex_width / (float)tex_height;
if (tex_aspect < 1) /* taller than it is wide */
t_scale *= tex_aspect;
else /* wider than it is tall */
{
float inverse_aspect = 1.0f / tex_aspect;
s_scale *= inverse_aspect;
}
s_scale *= diagonal_size_scale;
t_scale *= diagonal_size_scale;
s0 = 0.5 - (s_scale / 2.0);
t0 = 0.5 - (t_scale / 2.0);
cogl_matrix_translate (&matrix, s0, t0, 0);
cogl_matrix_scale (&matrix, s_scale / width, t_scale / height, 1);
cogl_matrix_translate (&matrix, width / 2.0, height / 2.0, 1);
cogl_matrix_rotate (&matrix, 45, 0, 0, 1);
cogl_matrix_translate (&matrix, -width / 2.0, -height / 2.0, 1);
}
n_vertices = sizeof (vertices) / sizeof (VertexP2T2T2);
for (i = 0; i < n_vertices; i++)
{
float z = 0, w = 1;
cogl_matrix_transform_point (&matrix,
&vertices[i].s1,
&vertices[i].t1,
&z,
&w);
}
diamond_slice->primitive =
primitive_new_p2t2t2 (ctx->cogl_context,
COGL_VERTICES_MODE_TRIANGLES,
n_vertices,
vertices);
/* The vertices uploaded only map to the key intersection points of the
* 9-slice grid which isn't a topology that GPUs can handle directly so
* this specifies an array of indices that allow the GPU to interpret the
* vertices as a list of triangles... */
cogl_primitive_set_indices (diamond_slice->primitive,
ctx->nine_slice_indices,
sizeof (_rut_nine_slice_indices_data) /
sizeof (_rut_nine_slice_indices_data[0]));
}
return diamond_slice;
}
RutAsset *
rut_asset_new_from_data (RutContext *ctx,
const char *path,
RutAssetType type,
uint8_t *data,
size_t len)
{
RutAsset *asset = g_slice_new0 (RutAsset);
rut_object_init (&asset->_parent, &rut_asset_type);
asset->ref_count = 1;
asset->ctx = ctx;
asset->type = type;
switch (type)
{
case RUT_ASSET_TYPE_BUILTIN:
case RUT_ASSET_TYPE_TEXTURE:
case RUT_ASSET_TYPE_NORMAL_MAP:
case RUT_ASSET_TYPE_ALPHA_MASK:
{
GInputStream *istream = g_memory_input_stream_new_from_data (data, len, NULL);
GError *error = NULL;
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_stream (istream, NULL, &error);
CoglBitmap *bitmap;
CoglError *cogl_error = NULL;
if (!pixbuf)
{
g_slice_free (RutAsset, asset);
g_warning ("Failed to load asset texture: %s", error->message);
g_error_free (error);
return NULL;
}
g_object_unref (istream);
bitmap = bitmap_new_from_pixbuf (ctx->cogl_context, pixbuf);
asset->texture = COGL_TEXTURE (
cogl_texture_2d_new_from_bitmap (bitmap,
COGL_PIXEL_FORMAT_ANY,
&cogl_error));
cogl_object_unref (bitmap);
g_object_unref (pixbuf);
if (!asset->texture)
{
g_slice_free (RutAsset, asset);
g_warning ("Failed to load asset texture: %s", cogl_error->message);
cogl_error_free (cogl_error);
return NULL;
}
break;
}
case RUT_ASSET_TYPE_PLY_MODEL:
{
RutPLYAttributeStatus padding_status[G_N_ELEMENTS (ply_attributes)];
GError *error = NULL;
asset->mesh = rut_mesh_new_from_ply_data (ctx,
data,
len,
ply_attributes,
G_N_ELEMENTS (ply_attributes),
padding_status,
&error);
if (!asset->mesh)
{
g_slice_free (RutAsset, asset);
g_warning ("could not load model %s: %s", path, error->message);
g_error_free (error);
return NULL;
}
break;
}
}
asset->path = g_strdup (path);
return asset;
}
RutButton *
rut_button_new (RutContext *ctx,
const char *label)
{
RutButton *button = g_slice_new0 (RutButton);
GError *error = NULL;
float text_width, text_height;
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_button_init_type ();
initialized = TRUE;
}
rut_object_init (RUT_OBJECT (button), &rut_button_type);
button->ref_count = 1;
rut_list_init (&button->on_click_cb_list);
rut_graphable_init (RUT_OBJECT (button));
rut_paintable_init (RUT_OBJECT (button));
button->ctx = ctx;
button->state = BUTTON_STATE_NORMAL;
button->normal_texture =
rut_load_texture_from_data_file (ctx, "button.png", &error);
if (button->normal_texture)
{
button->background_normal =
rut_nine_slice_new (ctx, button->normal_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button texture: %s", error->message);
g_error_free (error);
}
button->hover_texture =
rut_load_texture_from_data_file (ctx, "button-hover.png", &error);
if (button->hover_texture)
{
button->background_hover =
rut_nine_slice_new (ctx, button->hover_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button-hover texture: %s", error->message);
g_error_free (error);
}
button->active_texture =
rut_load_texture_from_data_file (ctx, "button-active.png", &error);
if (button->active_texture)
{
button->background_active =
rut_nine_slice_new (ctx, button->active_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button-active texture: %s", error->message);
g_error_free (error);
}
button->disabled_texture =
rut_load_texture_from_data_file (ctx, "button-disabled.png", &error);
if (button->disabled_texture)
{
button->background_disabled =
rut_nine_slice_new (ctx, button->disabled_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button-disabled texture: %s", error->message);
g_error_free (error);
}
button->text = rut_text_new_with_text (ctx, NULL, label);
button->text_transform = rut_transform_new (ctx);
rut_graphable_add_child (button, button->text_transform);
rut_graphable_add_child (button->text_transform, button->text);
rut_sizable_get_size (button->text, &text_width, &text_height);
button->width = text_width + BUTTON_HPAD;
button->height = text_height + BUTTON_VPAD;
cogl_color_init_from_4f (&button->text_color, 0, 0, 0, 1);
button->input_region =
rut_input_region_new_rectangle (0, 0, button->width, button->height,
_rut_button_input_cb,
button);
//rut_input_region_set_graphable (button->input_region, button);
rut_graphable_add_child (button, button->input_region);
queue_allocation (button);
return button;
}
static RutShapeModel *
shape_model_new (RutContext *ctx,
CoglBool shaped,
float tex_width,
float tex_height)
{
RutShapeModel *shape_model = g_slice_new (RutShapeModel);
RutBuffer *buffer = rut_buffer_new (sizeof (CoglVertexP3) * 6);
RutMesh *pick_mesh = rut_mesh_new_from_buffer_p3 (COGL_VERTICES_MODE_TRIANGLES,
6,
buffer);
CoglVertexP3 *pick_vertices = (CoglVertexP3 *)buffer->data;
CoglMatrix matrix;
float tex_aspect;
float size_x;
float size_y;
float half_size_x;
float half_size_y;
float geom_size_x;
float geom_size_y;
float half_geom_size_x;
float half_geom_size_y;
rut_object_init (&shape_model->_parent, &rut_shape_model_type);
shape_model->ref_count = 1;
if (shaped)
{
/* In this case we are using a shape mask texture which is has a
* square size and is padded with transparent pixels to provide
* antialiasing. The shape mask is half the size of the texture
* itself so we make the geometry twice as large to compensate.
*/
size_x = MIN (tex_width, tex_height);
size_y = size_x;
geom_size_x = size_x * 2.0;
geom_size_y = geom_size_x;
}
else
{
size_x = tex_width;
size_y = tex_height;
geom_size_x = tex_width;
geom_size_y = tex_height;
}
half_size_x = size_x / 2.0;
half_size_y = size_y / 2.0;
half_geom_size_x = geom_size_x / 2.0;
half_geom_size_y = geom_size_y / 2.0;
{
int n_vertices;
int i;
VertexP2T2T2 vertices[] =
{
{ -half_geom_size_x, -half_geom_size_y, 0, 0, 0, 0 },
{ -half_geom_size_x, half_geom_size_y, 0, 1, 0, 1 },
{ half_geom_size_x, half_geom_size_y, 1, 1, 1, 1 },
{ -half_geom_size_x, -half_geom_size_y, 0, 0, 0, 0 },
{ half_geom_size_x, half_geom_size_y, 1, 1, 1, 1 },
{ half_geom_size_x, -half_geom_size_y, 1, 0, 1, 0 },
};
cogl_matrix_init_identity (&matrix);
tex_aspect = (float)tex_width / (float)tex_height;
if (shaped)
{
float s_scale, t_scale;
float s0, t0;
/* NB: The circle mask texture has a centered circle that is
* half the width of the texture itself. We want the primary
* texture to be mapped to this center circle. */
s_scale = 2;
t_scale = 2;
if (tex_aspect < 1) /* taller than it is wide */
t_scale *= tex_aspect;
else /* wider than it is tall */
{
float inverse_aspect = 1.0f / tex_aspect;
s_scale *= inverse_aspect;
}
s0 = 0.5 - (s_scale / 2.0);
t0 = 0.5 - (t_scale / 2.0);
cogl_matrix_translate (&matrix, s0, t0, 0);
cogl_matrix_scale (&matrix, s_scale, t_scale, 1);
}
n_vertices = sizeof (vertices) / sizeof (VertexP2T2T2);
for (i = 0; i < n_vertices; i++)
{
float z = 0, w = 1;
cogl_matrix_transform_point (&matrix,
&vertices[i].s1,
&vertices[i].t1,
&z,
&w);
#ifdef MESA_CONST_ATTRIB_BUG_WORKAROUND
vertices[i].Nx = 0;
vertices[i].Ny = 0;
vertices[i].Nz = 1;
vertices[i].Tx = 1;
vertices[i].Ty = 0;
vertices[i].Tz = 0;
#endif
}
shape_model->primitive =
primitive_new_p2t2t2 (ctx->cogl_context,
COGL_VERTICES_MODE_TRIANGLES,
n_vertices,
vertices);
}
shape_model->shape_texture = cogl_object_ref (ctx->circle_texture);
pick_vertices[0].x = -half_size_x;
pick_vertices[0].y = -half_size_y;
pick_vertices[1].x = -half_size_x;
pick_vertices[1].y = half_size_y;
pick_vertices[2].x = half_size_x;
pick_vertices[2].y = half_size_y;
pick_vertices[3] = pick_vertices[0];
pick_vertices[4] = pick_vertices[2];
pick_vertices[5].x = half_size_x;
pick_vertices[5].y = -half_size_y;
shape_model->pick_mesh = pick_mesh;
return shape_model;
}
RutFold *
rut_fold_new (RutContext *ctx,
const char *label)
{
RutFold *fold = g_slice_new0 (RutFold);
static CoglBool initialized = FALSE;
RutBoxLayout *header_hbox;
RutStack *left_header_stack;
RutBoxLayout *left_header_hbox;
RutBin *label_bin;
RutBin *fold_icon_align;
CoglTexture *texture;
CoglColor black;
if (initialized == FALSE)
{
_rut_fold_init_type ();
initialized = TRUE;
}
fold->ref_count = 1;
fold->context = ctx;
rut_object_init (&fold->_parent, &rut_fold_type);
rut_graphable_init (fold);
rut_simple_introspectable_init (fold,
_rut_fold_prop_specs,
fold->properties);
fold->vbox = rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_TOP_TO_BOTTOM);
header_hbox =
rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_LEFT_TO_RIGHT);
rut_box_layout_add (fold->vbox, FALSE, header_hbox);
rut_refable_unref (header_hbox);
left_header_stack = rut_stack_new (ctx, 0, 0);
rut_box_layout_add (header_hbox, TRUE, left_header_stack);
rut_refable_unref (left_header_stack);
left_header_hbox =
rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_LEFT_TO_RIGHT);
rut_stack_add (left_header_stack, left_header_hbox);
rut_refable_unref (left_header_hbox);
fold_icon_align = rut_bin_new (ctx);
rut_bin_set_x_position (fold_icon_align, RUT_BIN_POSITION_BEGIN);
rut_bin_set_y_position (fold_icon_align, RUT_BIN_POSITION_CENTER);
rut_bin_set_right_padding (fold_icon_align, 10);
rut_box_layout_add (left_header_hbox, FALSE, fold_icon_align);
rut_refable_unref (fold_icon_align);
texture = rut_load_texture_from_data_file (ctx, "tri-fold-up.png", NULL);
fold->fold_up_icon = rut_nine_slice_new (ctx, texture,
0, 0, 0, 0,
cogl_texture_get_width (texture),
cogl_texture_get_height (texture));
cogl_object_unref (texture);
texture = rut_load_texture_from_data_file (ctx, "tri-fold-down.png", NULL);
fold->fold_down_icon = rut_nine_slice_new (ctx, texture,
0, 0, 0, 0,
cogl_texture_get_width (texture),
cogl_texture_get_height (texture));
cogl_object_unref (texture);
fold->fold_icon_shim = rut_fixed_new (ctx,
cogl_texture_get_width (texture),
cogl_texture_get_height (texture));
rut_bin_set_child (fold_icon_align, fold->fold_icon_shim);
rut_refable_unref (fold->fold_icon_shim);
rut_graphable_add_child (fold->fold_icon_shim, fold->fold_down_icon);
/* NB: we keep references to the icons so they can be swapped
* without getting disposed. */
label_bin = rut_bin_new (ctx);
rut_bin_set_y_position (label_bin, RUT_BIN_POSITION_CENTER);
rut_box_layout_add (left_header_hbox, FALSE, label_bin);
rut_refable_unref (label_bin);
fold->label = rut_text_new_with_text (ctx, NULL, label);
rut_bin_set_child (label_bin, fold->label);
rut_refable_unref (fold->label);
fold->header_hbox_right =
rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_RIGHT_TO_LEFT);
rut_box_layout_add (header_hbox, TRUE, fold->header_hbox_right);
rut_refable_unref (fold->header_hbox_right);
cogl_color_init_from_4f (&black, 0, 0, 0, 1);
rut_fold_set_folder_color (fold, &black);
rut_fold_set_label_color (fold, &black);
rut_graphable_add_child (fold, fold->vbox);
rut_refable_unref (fold->vbox);
fold->input_region = rut_input_region_new_rectangle (0, 0, 0, 0,
input_cb,
fold);
rut_stack_add (left_header_stack, fold->input_region);
rut_refable_unref (fold->input_region);
fold->folded = FALSE;
return fold;
}
RutIconButton *
rut_icon_button_new (RutContext *ctx,
const char *label,
RutIconButtonPosition label_position,
const char *normal_icon,
const char *hover_icon,
const char *active_icon,
const char *disabled_icon)
{
RutIconButton *button = g_slice_new0 (RutIconButton);
float natural_width, natural_height;
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_icon_button_init_type ();
initialized = TRUE;
}
rut_object_init (RUT_OBJECT (button), &rut_icon_button_type);
button->ref_count = 1;
rut_list_init (&button->on_click_cb_list);
rut_graphable_init (RUT_OBJECT (button));
rut_paintable_init (RUT_OBJECT (button));
button->ctx = ctx;
button->state = ICON_BUTTON_STATE_NORMAL;
button->stack = rut_stack_new (ctx, 100, 100);
button->layout = rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_TOP_TO_BOTTOM);
rut_stack_add (button->stack, button->layout);
rut_refable_unref (button->layout);
button->bin = rut_bin_new (ctx);
rut_box_layout_add (button->layout, TRUE, button->bin);
rut_refable_unref (button->bin);
button->label_position = label_position;
if (label)
{
RutBin *bin = rut_bin_new (ctx);
rut_bin_set_x_position (bin, RUT_BIN_POSITION_CENTER);
button->label = rut_text_new_with_text (ctx, NULL, label);
rut_bin_set_child (bin, button->label);
rut_box_layout_add (button->layout, FALSE, bin);
rut_refable_unref (bin);
update_layout (button);
}
rut_icon_button_set_normal (button, normal_icon);
rut_icon_button_set_hover (button, hover_icon);
rut_icon_button_set_active (button, active_icon);
rut_icon_button_set_disabled (button, disabled_icon);
button->input_region =
rut_input_region_new_rectangle (0, 0, 100, 100,
_rut_icon_button_input_cb,
button);
rut_stack_add (button->stack, button->input_region);
rut_refable_unref (button->input_region);
rut_sizable_get_preferred_width (button->stack, -1, NULL,
&natural_width);
rut_sizable_get_preferred_height (button->stack, natural_width, NULL,
&natural_height);
rut_sizable_set_size (button->stack, natural_width, natural_height);
rut_graphable_add_child (button, button->stack);
return button;
}
static RutAsset *
rut_asset_new_full (RutContext *ctx,
const char *path,
RutAssetType type)
{
RutAsset *asset = g_slice_new0 (RutAsset);
const char *real_path;
char *full_path;
#ifndef __ANDROID__
if (type == RUT_ASSET_TYPE_BUILTIN)
{
full_path = rut_find_data_file (path);
if (full_path == NULL)
full_path = g_strdup (path);
}
else
full_path = g_build_filename (ctx->assets_location, path, NULL);
real_path = full_path;
#else
real_path = path;
#endif
asset->ref_count = 1;
asset->ctx = ctx;
asset->type = type;
switch (type)
{
case RUT_ASSET_TYPE_BUILTIN:
case RUT_ASSET_TYPE_TEXTURE:
case RUT_ASSET_TYPE_NORMAL_MAP:
case RUT_ASSET_TYPE_ALPHA_MASK:
{
CoglError *error = NULL;
asset->texture = rut_load_texture (ctx, real_path, &error);
if (!asset->texture)
{
g_slice_free (RutAsset, asset);
g_warning ("Failed to load asset texture: %s", error->message);
cogl_error_free (error);
asset = NULL;
goto DONE;
}
break;
}
case RUT_ASSET_TYPE_PLY_MODEL:
{
RutPLYAttributeStatus padding_status[G_N_ELEMENTS (ply_attributes)];
GError *error = NULL;
asset->mesh = rut_mesh_new_from_ply (ctx,
real_path,
ply_attributes,
G_N_ELEMENTS (ply_attributes),
padding_status,
&error);
if (!asset->mesh)
{
g_slice_free (RutAsset, asset);
g_warning ("could not load model %s: %s", path, error->message);
g_error_free (error);
asset = NULL;
goto DONE;
}
break;
}
}
asset->path = g_strdup (path);
rut_object_init (&asset->_parent, &rut_asset_type);
//rut_simple_introspectable_init (asset);
DONE:
#ifndef __ANDROID__
g_free (full_path);
#endif
return asset;
}