void _clutter_util_fully_transform_vertices (const CoglMatrix *modelview, const CoglMatrix *projection, const float *viewport, const ClutterVertex *vertices_in, ClutterVertex *vertices_out, int n_vertices) { CoglMatrix modelview_projection; ClutterVertex4 *vertices_tmp; int i; vertices_tmp = g_alloca (sizeof (ClutterVertex4) * n_vertices); if (n_vertices >= 4) { /* XXX: we should find a way to cache this per actor */ cogl_matrix_multiply (&modelview_projection, projection, modelview); cogl_matrix_project_points (&modelview_projection, 3, sizeof (ClutterVertex), vertices_in, sizeof (ClutterVertex4), vertices_tmp, n_vertices); } else { cogl_matrix_transform_points (modelview, 3, sizeof (ClutterVertex), vertices_in, sizeof (ClutterVertex4), vertices_tmp, n_vertices); cogl_matrix_project_points (projection, 3, sizeof (ClutterVertex4), vertices_tmp, sizeof (ClutterVertex4), vertices_tmp, n_vertices); } for (i = 0; i < n_vertices; i++) { ClutterVertex4 vertex_tmp = vertices_tmp[i]; ClutterVertex *vertex_out = &vertices_out[i]; /* Finally translate from OpenGL coords to window coords */ vertex_out->x = MTX_GL_SCALE_X (vertex_tmp.x, vertex_tmp.w, viewport[2], viewport[0]); vertex_out->y = MTX_GL_SCALE_Y (vertex_tmp.y, vertex_tmp.w, viewport[3], viewport[1]); } }
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; }
void _clutter_paint_volume_transform (ClutterPaintVolume *pv, const CoglMatrix *matrix) { int transform_count; if (pv->is_empty) { gfloat w = 1; /* Just transform the origin */ cogl_matrix_transform_point (matrix, &pv->vertices[0].x, &pv->vertices[0].y, &pv->vertices[0].z, &w); return; } /* All the vertices must be up to date, since after the transform * it wont be trivial to derive the other vertices. */ _clutter_paint_volume_complete (pv); /* Most actors are 2D so we only have to transform the front 4 * vertices of the paint volume... */ if (G_LIKELY (pv->is_2d)) transform_count = 4; else transform_count = 8; cogl_matrix_transform_points (matrix, 3, sizeof (ClutterVertex), pv->vertices, sizeof (ClutterVertex), pv->vertices, transform_count); pv->is_axis_aligned = FALSE; }
void _rut_volume_transform (RutVolume *volume, const CoglMatrix *matrix) { int transform_count; if (volume->is_empty) { float w = 1; /* Just transform the origin */ cogl_matrix_transform_point (matrix, &volume->vertices[0].x, &volume->vertices[0].y, &volume->vertices[0].z, &w); return; } /* All the vertices must be up to date, since after the transform * it wont be trivial to derive the other vertices. */ _rut_volume_complete (volume); /* Most actors are 2D so we only have to transform the front 4 * vertices of the volume... */ if (G_LIKELY (volume->is_2d)) transform_count = 4; else transform_count = 8; cogl_matrix_transform_points (matrix, 3, sizeof (RutVector3), volume->vertices, sizeof (RutVector3), volume->vertices, transform_count); volume->is_axis_aligned = FALSE; }
void update_control_point_positions (RigSelectionTool *tool, RutCamera *paint_camera) /* 2d ui camera */ { RutCamera *camera = tool->camera_component; GList *l; for (l = tool->selected_entities; l; l = l->next) { EntityState *entity_state = l->data; CoglMatrix transform; const CoglMatrix *projection; float screen_space[4], x, y; const float *viewport; GList *l2; get_modelview_matrix (tool->camera, entity_state->entity, &transform); projection = rut_camera_get_projection (camera); viewport = rut_camera_get_viewport (camera); for (l2 = entity_state->control_points; l2; l2 = l2->next) { ControlPoint *point = l2->data; point->position[0] = point->x; point->position[1] = point->y; point->position[2] = point->z; cogl_matrix_transform_points (&transform, 3, /* num components for input */ sizeof (float) * 3, /* input stride */ point->position, sizeof (float) * 3, /* output stride */ point->position, 1 /* n_points */); /* update the input region, need project the transformed point and do * the viewport transform */ screen_space[0] = point->position[0]; screen_space[1] = point->position[1]; screen_space[2] = point->position[2]; cogl_matrix_project_points (projection, 3, /* num components for input */ sizeof (float) * 3, /* input stride */ screen_space, sizeof (float) * 4, /* output stride */ screen_space, 1 /* n_points */); /* perspective divide */ screen_space[0] /= screen_space[3]; screen_space[1] /= screen_space[3]; /* apply viewport transform */ x = VIEWPORT_TRANSFORM_X (screen_space[0], viewport[0], viewport[2]); y = VIEWPORT_TRANSFORM_Y (screen_space[1], viewport[1], viewport[3]); point->screen_pos[0] = x; point->screen_pos[1] = y; map_window_coords_to_overlay_coord (paint_camera, tool->tool_overlay, &x, &y); rut_transform_init_identity (point->transform); rut_transform_translate (point->transform, x, y, 0); rut_input_region_set_circle (point->input_region, x, y, 10); } } }