diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c index f8141e312..0ec9826bb 100644 --- a/clutter/clutter/clutter-actor.c +++ b/clutter/clutter/clutter-actor.c @@ -1289,11 +1289,11 @@ _clutter_actor_transform_local_box_to_stage (ClutterActor *self, float z = 0.f; float w = 1.f; - cogl_matrix_transform_point (&transform_to_stage, - &vertices[v].x, - &vertices[v].y, - &z, - &w); + cogl_graphene_matrix_project_point (&transform_to_stage, + &vertices[v].x, + &vertices[v].y, + &z, + &w); } return TRUE; @@ -2873,7 +2873,11 @@ clutter_actor_apply_relative_transform_to_point (ClutterActor *self, } _clutter_actor_get_relative_transformation_matrix (self, ancestor, &matrix); - cogl_matrix_transform_point (&matrix, &vertex->x, &vertex->y, &vertex->z, &w); + cogl_graphene_matrix_project_point (&matrix, + &vertex->x, + &vertex->y, + &vertex->z, + &w); } static gboolean diff --git a/clutter/clutter/clutter-paint-volume.c b/clutter/clutter/clutter-paint-volume.c index 3facd71cf..807d1c401 100644 --- a/clutter/clutter/clutter-paint-volume.c +++ b/clutter/clutter/clutter-paint-volume.c @@ -857,11 +857,11 @@ _clutter_paint_volume_transform (ClutterPaintVolume *pv, { 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); + cogl_graphene_matrix_project_point (matrix, + &pv->vertices[0].x, + &pv->vertices[0].y, + &pv->vertices[0].z, + &w); return; } @@ -876,13 +876,13 @@ _clutter_paint_volume_transform (ClutterPaintVolume *pv, else transform_count = 8; - cogl_matrix_transform_points (matrix, - 3, - sizeof (graphene_point3d_t), - pv->vertices, - sizeof (graphene_point3d_t), - pv->vertices, - transform_count); + cogl_graphene_matrix_transform_points (matrix, + 3, + sizeof (graphene_point3d_t), + pv->vertices, + sizeof (graphene_point3d_t), + pv->vertices, + transform_count); pv->is_axis_aligned = FALSE; } diff --git a/clutter/clutter/clutter-stage.c b/clutter/clutter/clutter-stage.c index 88141377d..9d2acb853 100644 --- a/clutter/clutter/clutter-stage.c +++ b/clutter/clutter/clutter-stage.c @@ -725,13 +725,13 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon, #undef CLIP_X #undef CLIP_Y - cogl_matrix_project_points (inverse_project, - 4, - sizeof (Vector4), - tmp_poly, - sizeof (Vector4), - tmp_poly, - n_vertices * 2); + cogl_graphene_matrix_project_points (inverse_project, + 4, + sizeof (Vector4), + tmp_poly, + sizeof (Vector4), + tmp_poly, + n_vertices * 2); /* XXX: It's quite ugly that we end up with these casts between * Vector4 types and CoglVector3s, it might be better if the diff --git a/clutter/clutter/clutter-util.c b/clutter/clutter/clutter-util.c index 48b36bc05..8d7e1c1b9 100644 --- a/clutter/clutter/clutter-util.c +++ b/clutter/clutter/clutter-util.c @@ -77,31 +77,31 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview, cogl_matrix_multiply (&modelview_projection, projection, modelview); - cogl_matrix_project_points (&modelview_projection, - 3, - sizeof (graphene_point3d_t), - vertices_in, - sizeof (ClutterVertex4), - vertices_tmp, - n_vertices); + cogl_graphene_matrix_project_points (&modelview_projection, + 3, + sizeof (graphene_point3d_t), + vertices_in, + sizeof (ClutterVertex4), + vertices_tmp, + n_vertices); } else { - cogl_matrix_transform_points (modelview, - 3, - sizeof (graphene_point3d_t), - vertices_in, - sizeof (ClutterVertex4), - vertices_tmp, - n_vertices); + cogl_graphene_matrix_transform_points (modelview, + 3, + sizeof (graphene_point3d_t), + vertices_in, + sizeof (ClutterVertex4), + vertices_tmp, + n_vertices); - cogl_matrix_project_points (projection, - 3, - sizeof (ClutterVertex4), - vertices_tmp, - sizeof (ClutterVertex4), - vertices_tmp, - n_vertices); + cogl_graphene_matrix_project_points (projection, + 3, + sizeof (ClutterVertex4), + vertices_tmp, + sizeof (ClutterVertex4), + vertices_tmp, + n_vertices); } for (i = 0; i < n_vertices; i++) diff --git a/cogl/cogl/cogl-graphene.c b/cogl/cogl/cogl-graphene.c new file mode 100644 index 000000000..d9bd3bd42 --- /dev/null +++ b/cogl/cogl/cogl-graphene.c @@ -0,0 +1,276 @@ +/* cogl-graphene.c + * + * Copyright 2020 Georges Basile Stavracas Neto + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#include "cogl/cogl-graphene.h" + +typedef struct _Point2f +{ + float x; + float y; +} Point2f; + +typedef struct _Point3f +{ + float x; + float y; + float z; +} Point3f; + +typedef struct _Point4f +{ + float x; + float y; + float z; + float w; +} Point4f; + +static void +init_matrix_rows (const graphene_matrix_t *matrix, + unsigned int n_rows, + graphene_vec4_t *rows) +{ + graphene_matrix_t m; + unsigned int i; + + graphene_matrix_transpose (matrix, &m); + + for (i = 0; i < n_rows; i++) + graphene_matrix_get_row (&m, i, &rows[i]); +} + +static void +transform_points_f2 (const graphene_matrix_t *matrix, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + graphene_vec4_t rows[3]; + int i; + + init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); + + for (i = 0; i < n_points; i++) + { + Point2f p = *(Point2f *)((uint8_t *)points_in + i * stride_in); + Point3f *o = (Point3f *)((uint8_t *)points_out + i * stride_out); + graphene_vec4_t point; + + graphene_vec4_init (&point, p.x, p.y, 0.f, 1.f); + + o->x = graphene_vec4_dot (&rows[0], &point); + o->y = graphene_vec4_dot (&rows[1], &point); + o->z = graphene_vec4_dot (&rows[2], &point); + } +} + +static void +project_points_f2 (const graphene_matrix_t *matrix, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + graphene_vec4_t rows[4]; + int i; + + init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); + + for (i = 0; i < n_points; i++) + { + Point2f p = *(Point2f *)((uint8_t *)points_in + i * stride_in); + Point4f *o = (Point4f *)((uint8_t *)points_out + i * stride_out); + graphene_vec4_t point; + + graphene_vec4_init (&point, p.x, p.y, 0.f, 1.f); + + o->x = graphene_vec4_dot (&rows[0], &point); + o->y = graphene_vec4_dot (&rows[1], &point); + o->z = graphene_vec4_dot (&rows[2], &point); + o->w = graphene_vec4_dot (&rows[3], &point); + } +} + +static void +transform_points_f3 (const graphene_matrix_t *matrix, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + graphene_vec4_t rows[3]; + int i; + + init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); + + for (i = 0; i < n_points; i++) + { + Point3f p = *(Point3f *)((uint8_t *)points_in + i * stride_in); + Point3f *o = (Point3f *)((uint8_t *)points_out + i * stride_out); + graphene_vec4_t point; + + graphene_vec4_init (&point, p.x, p.y, p.z, 1.f); + + o->x = graphene_vec4_dot (&rows[0], &point); + o->y = graphene_vec4_dot (&rows[1], &point); + o->z = graphene_vec4_dot (&rows[2], &point); + } +} + +static void +project_points_f3 (const graphene_matrix_t *matrix, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + graphene_vec4_t rows[4]; + int i; + + init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); + + for (i = 0; i < n_points; i++) + { + Point3f p = *(Point3f *)((uint8_t *)points_in + i * stride_in); + Point4f *o = (Point4f *)((uint8_t *)points_out + i * stride_out); + graphene_vec4_t point; + + graphene_vec4_init (&point, p.x, p.y, p.z, 1.f); + + o->x = graphene_vec4_dot (&rows[0], &point); + o->y = graphene_vec4_dot (&rows[1], &point); + o->z = graphene_vec4_dot (&rows[2], &point); + o->w = graphene_vec4_dot (&rows[3], &point); + } +} + +static void +project_points_f4 (const graphene_matrix_t *matrix, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + graphene_vec4_t rows[4]; + int i; + + init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); + + for (i = 0; i < n_points; i++) + { + Point4f p = *(Point4f *)((uint8_t *)points_in + i * stride_in); + Point4f *o = (Point4f *)((uint8_t *)points_out + i * stride_out); + graphene_vec4_t point; + + graphene_vec4_init (&point, p.x, p.y, p.z, p.w); + + o->x = graphene_vec4_dot (&rows[0], &point); + o->y = graphene_vec4_dot (&rows[1], &point); + o->z = graphene_vec4_dot (&rows[2], &point); + o->w = graphene_vec4_dot (&rows[3], &point); + } +} + +void +cogl_graphene_matrix_project_point (const graphene_matrix_t *matrix, + float *x, + float *y, + float *z, + float *w) +{ + graphene_vec4_t p; + + graphene_vec4_init (&p, *x, *y, *z, *w); + graphene_matrix_transform_vec4 (matrix, &p, &p); + + *x = graphene_vec4_get_x (&p); + *y = graphene_vec4_get_y (&p); + *z = graphene_vec4_get_z (&p); + *w = graphene_vec4_get_w (&p); +} + +void +cogl_graphene_matrix_transform_points (const graphene_matrix_t *matrix, + int n_components, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + /* The results of transforming always have three components... */ + g_return_if_fail (stride_out >= sizeof (Point3f)); + + if (n_components == 2) + { + transform_points_f2 (matrix, + stride_in, points_in, + stride_out, points_out, + n_points); + } + else + { + g_return_if_fail (n_components == 3); + + transform_points_f3 (matrix, + stride_in, points_in, + stride_out, points_out, + n_points); + } +} + +void +cogl_graphene_matrix_project_points (const graphene_matrix_t *matrix, + int n_components, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points) +{ + if (n_components == 2) + { + project_points_f2 (matrix, + stride_in, points_in, + stride_out, points_out, + n_points); + } + else if (n_components == 3) + { + project_points_f3 (matrix, + stride_in, points_in, + stride_out, points_out, + n_points); + } + else + { + g_return_if_fail (n_components == 4); + + project_points_f4 (matrix, + stride_in, points_in, + stride_out, points_out, + n_points); + } +} diff --git a/cogl/cogl/cogl-graphene.h b/cogl/cogl/cogl-graphene.h new file mode 100644 index 000000000..67ffd8547 --- /dev/null +++ b/cogl/cogl/cogl-graphene.h @@ -0,0 +1,169 @@ +/* cogl-graphene.h + * + * Copyright 2020 Georges Basile Stavracas Neto + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#ifndef COGL_GRAPHENE_H +#define COGL_GRAPHENE_H + +#include +#include +#include + +#include + +#include + +G_BEGIN_DECLS + + +/** + * cogl_graphene_matrix_project_point: + * @matrix: A 4x4 transformation matrix + * @x: (inout): The X component of your points position + * @y: (inout): The Y component of your points position + * @z: (inout): The Z component of your points position + * @w: (inout): The W component of your points position + * + * Transforms a point whose position is given and returned as four float + * components. + */ +COGL_EXPORT void +cogl_graphene_matrix_project_point (const graphene_matrix_t *matrix, + float *x, + float *y, + float *z, + float *w); + +/** + * cogl_graphene_matrix_transform_points: + * @matrix: A transformation matrix + * @n_components: The number of position components for each input point. + * (either 2 or 3) + * @stride_in: The stride in bytes between input points. + * @points_in: A pointer to the first component of the first input point. + * @stride_out: The stride in bytes between output points. + * @points_out: A pointer to the first component of the first output point. + * @n_points: The number of points to transform. + * + * Transforms an array of input points and writes the result to + * another array of output points. The input points can either have 2 + * or 3 components each. The output points always have 3 components. + * The output array can simply point to the input array to do the + * transform in-place. + * + * If you need to transform 4 component points see + * cogl_graphene_matrix_project_points(). + * + * Here's an example with differing input/output strides: + * |[ + * typedef struct { + * float x,y; + * uint8_t r,g,b,a; + * float s,t,p; + * } MyInVertex; + * typedef struct { + * uint8_t r,g,b,a; + * float x,y,z; + * } MyOutVertex; + * MyInVertex vertices[N_VERTICES]; + * MyOutVertex results[N_VERTICES]; + * graphene_matrix_t matrix; + * + * my_load_vertices (vertices); + * my_get_matrix (&matrix); + * + * cogl_graphene_matrix_transform_points (&matrix, + * 2, + * sizeof (MyInVertex), + * &vertices[0].x, + * sizeof (MyOutVertex), + * &results[0].x, + * N_VERTICES); + * ]| + * + * Stability: unstable + */ +COGL_EXPORT void +cogl_graphene_matrix_transform_points (const graphene_matrix_t *matrix, + int n_components, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points); + +/** + * cogl_graphene_matrix_project_points: + * @matrix: A projection matrix + * @n_components: The number of position components for each input point. + * (either 2, 3 or 4) + * @stride_in: The stride in bytes between input points. + * @points_in: A pointer to the first component of the first input point. + * @stride_out: The stride in bytes between output points. + * @points_out: A pointer to the first component of the first output point. + * @n_points: The number of points to transform. + * + * Projects an array of input points and writes the result to another + * array of output points. The input points can either have 2, 3 or 4 + * components each. The output points always have 4 components (known + * as homogeneous coordinates). The output array can simply point to + * the input array to do the transform in-place. + * + * Here's an example with differing input/output strides: + * |[ + * typedef struct { + * float x,y; + * uint8_t r,g,b,a; + * float s,t,p; + * } MyInVertex; + * typedef struct { + * uint8_t r,g,b,a; + * float x,y,z; + * } MyOutVertex; + * MyInVertex vertices[N_VERTICES]; + * MyOutVertex results[N_VERTICES]; + * graphene_matrix_t matrix; + * + * my_load_vertices (vertices); + * my_get_matrix (&matrix); + * + * cogl_graphene_matrix_project_points (&matrix, + * 2, + * sizeof (MyInVertex), + * &vertices[0].x, + * sizeof (MyOutVertex), + * &results[0].x, + * N_VERTICES); + * ]| + * + * Stability: unstable + */ +COGL_EXPORT void +cogl_graphene_matrix_project_points (const graphene_matrix_t *matrix, + int n_components, + size_t stride_in, + const void *points_in, + size_t stride_out, + void *points_out, + int n_points); + + +G_END_DECLS + +#endif /* COGL_GRAPHENE_H */ diff --git a/cogl/cogl/cogl-journal.c b/cogl/cogl/cogl-journal.c index 418fd9895..33e1ea034 100644 --- a/cogl/cogl/cogl-journal.c +++ b/cogl/cogl/cogl-journal.c @@ -32,6 +32,7 @@ #include "cogl-debug.h" #include "cogl-context-private.h" +#include "cogl-graphene.h" #include "cogl-journal-private.h" #include "cogl-texture-private.h" #include "cogl-pipeline-private.h" @@ -1212,14 +1213,14 @@ upload_vertices (CoglJournal *journal, if (entry->modelview_entry != last_modelview_entry) cogl_matrix_entry_get (entry->modelview_entry, &modelview); - cogl_matrix_transform_points (&modelview, - 2, /* n_components */ - sizeof (float) * 2, /* stride_in */ - v, /* points_in */ - /* strideout */ - vb_stride * sizeof (float), - vout, /* points_out */ - 4 /* n_points */); + cogl_graphene_matrix_transform_points (&modelview, + 2, /* n_components */ + sizeof (float) * 2, /* stride_in */ + v, /* points_in */ + /* strideout */ + vb_stride * sizeof (float), + vout, /* points_out */ + 4 /* n_points */); } for (i = 0; i < entry->n_layers; i++) @@ -1672,27 +1673,27 @@ entry_to_screen_polygon (CoglFramebuffer *framebuffer, */ cogl_matrix_entry_get (entry->modelview_entry, &modelview); - cogl_matrix_transform_points (&modelview, - 2, /* n_components */ - sizeof (float) * 4, /* stride_in */ - poly, /* points_in */ - /* strideout */ - sizeof (float) * 4, - poly, /* points_out */ - 4 /* n_points */); + cogl_graphene_matrix_transform_points (&modelview, + 2, /* n_components */ + sizeof (float) * 4, /* stride_in */ + poly, /* points_in */ + /* strideout */ + sizeof (float) * 4, + poly, /* points_out */ + 4 /* n_points */); projection_stack = _cogl_framebuffer_get_projection_stack (framebuffer); cogl_matrix_stack_get (projection_stack, &projection); - cogl_matrix_project_points (&projection, - 3, /* n_components */ - sizeof (float) * 4, /* stride_in */ - poly, /* points_in */ - /* strideout */ - sizeof (float) * 4, - poly, /* points_out */ - 4 /* n_points */); + cogl_graphene_matrix_transform_points (&projection, + 3, /* n_components */ + sizeof (float) * 4, /* stride_in */ + poly, /* points_in */ + /* strideout */ + sizeof (float) * 4, + poly, /* points_out */ + 4 /* n_points */); /* Scale from OpenGL normalized device coordinates (ranging from -1 to 1) * to Cogl window/framebuffer coordinates (ranging from 0 to buffer-size) with diff --git a/cogl/cogl/cogl-matrix.c b/cogl/cogl/cogl-matrix.c index 410156983..c56362785 100644 --- a/cogl/cogl/cogl-matrix.c +++ b/cogl/cogl/cogl-matrix.c @@ -396,255 +396,6 @@ cogl_matrix_get_value (const CoglMatrix *matrix, return graphene_matrix_get_value (matrix, column, row); } -void -cogl_matrix_transform_point (const CoglMatrix *matrix, - float *x, - float *y, - float *z, - float *w) -{ - graphene_vec4_t p; - - graphene_vec4_init (&p, *x, *y, *z, *w); - graphene_matrix_transform_vec4 (matrix, &p, &p); - - *x = graphene_vec4_get_x (&p); - *y = graphene_vec4_get_y (&p); - *z = graphene_vec4_get_z (&p); - *w = graphene_vec4_get_w (&p); -} - -typedef struct _Point2f -{ - float x; - float y; -} Point2f; - -typedef struct _Point3f -{ - float x; - float y; - float z; -} Point3f; - -typedef struct _Point4f -{ - float x; - float y; - float z; - float w; -} Point4f; - -static void -init_matrix_rows (const CoglMatrix *matrix, - unsigned int n_rows, - graphene_vec4_t *rows) -{ - graphene_matrix_t m; - unsigned int i; - - graphene_matrix_transpose (matrix, &m); - - for (i = 0; i < n_rows; i++) - graphene_matrix_get_row (&m, i, &rows[i]); -} - -static void -_cogl_matrix_transform_points_f2 (const CoglMatrix *matrix, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - graphene_vec4_t rows[3]; - int i; - - init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); - - for (i = 0; i < n_points; i++) - { - Point2f p = *(Point2f *)((uint8_t *)points_in + i * stride_in); - Point3f *o = (Point3f *)((uint8_t *)points_out + i * stride_out); - graphene_vec4_t point; - - graphene_vec4_init (&point, p.x, p.y, 0.f, 1.f); - - o->x = graphene_vec4_dot (&rows[0], &point); - o->y = graphene_vec4_dot (&rows[1], &point); - o->z = graphene_vec4_dot (&rows[2], &point); - } -} - -static void -_cogl_matrix_project_points_f2 (const CoglMatrix *matrix, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - graphene_vec4_t rows[4]; - int i; - - init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); - - for (i = 0; i < n_points; i++) - { - Point2f p = *(Point2f *)((uint8_t *)points_in + i * stride_in); - Point4f *o = (Point4f *)((uint8_t *)points_out + i * stride_out); - graphene_vec4_t point; - - graphene_vec4_init (&point, p.x, p.y, 0.f, 1.f); - - o->x = graphene_vec4_dot (&rows[0], &point); - o->y = graphene_vec4_dot (&rows[1], &point); - o->z = graphene_vec4_dot (&rows[2], &point); - o->w = graphene_vec4_dot (&rows[3], &point); - } -} - -static void -_cogl_matrix_transform_points_f3 (const CoglMatrix *matrix, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - graphene_vec4_t rows[3]; - int i; - - init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); - - for (i = 0; i < n_points; i++) - { - Point3f p = *(Point3f *)((uint8_t *)points_in + i * stride_in); - Point3f *o = (Point3f *)((uint8_t *)points_out + i * stride_out); - graphene_vec4_t point; - - graphene_vec4_init (&point, p.x, p.y, p.z, 1.f); - - o->x = graphene_vec4_dot (&rows[0], &point); - o->y = graphene_vec4_dot (&rows[1], &point); - o->z = graphene_vec4_dot (&rows[2], &point); - } -} - -static void -_cogl_matrix_project_points_f3 (const CoglMatrix *matrix, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - graphene_vec4_t rows[4]; - int i; - - init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); - - for (i = 0; i < n_points; i++) - { - Point3f p = *(Point3f *)((uint8_t *)points_in + i * stride_in); - Point4f *o = (Point4f *)((uint8_t *)points_out + i * stride_out); - graphene_vec4_t point; - - graphene_vec4_init (&point, p.x, p.y, p.z, 1.f); - - o->x = graphene_vec4_dot (&rows[0], &point); - o->y = graphene_vec4_dot (&rows[1], &point); - o->z = graphene_vec4_dot (&rows[2], &point); - o->w = graphene_vec4_dot (&rows[3], &point); - } -} - -static void -_cogl_matrix_project_points_f4 (const CoglMatrix *matrix, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - graphene_vec4_t rows[4]; - int i; - - init_matrix_rows (matrix, G_N_ELEMENTS (rows), rows); - - for (i = 0; i < n_points; i++) - { - Point4f p = *(Point4f *)((uint8_t *)points_in + i * stride_in); - Point4f *o = (Point4f *)((uint8_t *)points_out + i * stride_out); - graphene_vec4_t point; - - graphene_vec4_init (&point, p.x, p.y, p.z, p.w); - - o->x = graphene_vec4_dot (&rows[0], &point); - o->y = graphene_vec4_dot (&rows[1], &point); - o->z = graphene_vec4_dot (&rows[2], &point); - o->w = graphene_vec4_dot (&rows[3], &point); - } -} - -void -cogl_matrix_transform_points (const CoglMatrix *matrix, - int n_components, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - /* The results of transforming always have three components... */ - g_return_if_fail (stride_out >= sizeof (Point3f)); - - if (n_components == 2) - _cogl_matrix_transform_points_f2 (matrix, - stride_in, points_in, - stride_out, points_out, - n_points); - else - { - g_return_if_fail (n_components == 3); - - _cogl_matrix_transform_points_f3 (matrix, - stride_in, points_in, - stride_out, points_out, - n_points); - } -} - -void -cogl_matrix_project_points (const CoglMatrix *matrix, - int n_components, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points) -{ - if (n_components == 2) - _cogl_matrix_project_points_f2 (matrix, - stride_in, points_in, - stride_out, points_out, - n_points); - else if (n_components == 3) - _cogl_matrix_project_points_f3 (matrix, - stride_in, points_in, - stride_out, points_out, - n_points); - else - { - g_return_if_fail (n_components == 4); - - _cogl_matrix_project_points_f4 (matrix, - stride_in, points_in, - stride_out, points_out, - n_points); - } -} - gboolean cogl_matrix_is_identity (const CoglMatrix *matrix) { diff --git a/cogl/cogl/cogl-matrix.h b/cogl/cogl/cogl-matrix.h index 072ed61d4..601c29c69 100644 --- a/cogl/cogl/cogl-matrix.h +++ b/cogl/cogl/cogl-matrix.h @@ -503,141 +503,6 @@ COGL_EXPORT gboolean cogl_matrix_get_inverse (const CoglMatrix *matrix, CoglMatrix *inverse); -/* FIXME: to be consistent with cogl_matrix_{transform,project}_points - * this could be renamed to cogl_matrix_project_point for Cogl 2.0... - */ - -/** - * cogl_matrix_transform_point: - * @matrix: A 4x4 transformation matrix - * @x: (inout): The X component of your points position - * @y: (inout): The Y component of your points position - * @z: (inout): The Z component of your points position - * @w: (inout): The W component of your points position - * - * Transforms a point whose position is given and returned as four float - * components. - */ -COGL_EXPORT void -cogl_matrix_transform_point (const CoglMatrix *matrix, - float *x, - float *y, - float *z, - float *w); - -/** - * cogl_matrix_transform_points: - * @matrix: A transformation matrix - * @n_components: The number of position components for each input point. - * (either 2 or 3) - * @stride_in: The stride in bytes between input points. - * @points_in: A pointer to the first component of the first input point. - * @stride_out: The stride in bytes between output points. - * @points_out: A pointer to the first component of the first output point. - * @n_points: The number of points to transform. - * - * Transforms an array of input points and writes the result to - * another array of output points. The input points can either have 2 - * or 3 components each. The output points always have 3 components. - * The output array can simply point to the input array to do the - * transform in-place. - * - * If you need to transform 4 component points see - * cogl_matrix_project_points(). - * - * Here's an example with differing input/output strides: - * |[ - * typedef struct { - * float x,y; - * uint8_t r,g,b,a; - * float s,t,p; - * } MyInVertex; - * typedef struct { - * uint8_t r,g,b,a; - * float x,y,z; - * } MyOutVertex; - * MyInVertex vertices[N_VERTICES]; - * MyOutVertex results[N_VERTICES]; - * CoglMatrix matrix; - * - * my_load_vertices (vertices); - * my_get_matrix (&matrix); - * - * cogl_matrix_transform_points (&matrix, - * 2, - * sizeof (MyInVertex), - * &vertices[0].x, - * sizeof (MyOutVertex), - * &results[0].x, - * N_VERTICES); - * ]| - * - * Stability: unstable - */ -COGL_EXPORT void -cogl_matrix_transform_points (const CoglMatrix *matrix, - int n_components, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points); - -/** - * cogl_matrix_project_points: - * @matrix: A projection matrix - * @n_components: The number of position components for each input point. - * (either 2, 3 or 4) - * @stride_in: The stride in bytes between input points. - * @points_in: A pointer to the first component of the first input point. - * @stride_out: The stride in bytes between output points. - * @points_out: A pointer to the first component of the first output point. - * @n_points: The number of points to transform. - * - * Projects an array of input points and writes the result to another - * array of output points. The input points can either have 2, 3 or 4 - * components each. The output points always have 4 components (known - * as homogeneous coordinates). The output array can simply point to - * the input array to do the transform in-place. - * - * Here's an example with differing input/output strides: - * |[ - * typedef struct { - * float x,y; - * uint8_t r,g,b,a; - * float s,t,p; - * } MyInVertex; - * typedef struct { - * uint8_t r,g,b,a; - * float x,y,z; - * } MyOutVertex; - * MyInVertex vertices[N_VERTICES]; - * MyOutVertex results[N_VERTICES]; - * CoglMatrix matrix; - * - * my_load_vertices (vertices); - * my_get_matrix (&matrix); - * - * cogl_matrix_project_points (&matrix, - * 2, - * sizeof (MyInVertex), - * &vertices[0].x, - * sizeof (MyOutVertex), - * &results[0].x, - * N_VERTICES); - * ]| - * - * Stability: unstable - */ -COGL_EXPORT void -cogl_matrix_project_points (const CoglMatrix *matrix, - int n_components, - size_t stride_in, - const void *points_in, - size_t stride_out, - void *points_out, - int n_points); - /** * cogl_matrix_is_identity: * @matrix: A #CoglMatrix diff --git a/cogl/cogl/cogl.c b/cogl/cogl/cogl.c index 320c0186d..e35b84c24 100644 --- a/cogl/cogl/cogl.c +++ b/cogl/cogl/cogl.c @@ -36,6 +36,7 @@ #include "cogl-i18n-private.h" #include "cogl-debug.h" +#include "cogl-graphene.h" #include "cogl-util.h" #include "cogl-context-private.h" #include "cogl-pipeline-private.h" @@ -184,10 +185,10 @@ _cogl_transform_point (const CoglMatrix *matrix_mv, float w = 1; /* Apply the modelview matrix transform */ - cogl_matrix_transform_point (matrix_mv, x, y, &z, &w); + cogl_graphene_matrix_project_point (matrix_mv, x, y, &z, &w); /* Apply the projection matrix transform */ - cogl_matrix_transform_point (matrix_p, x, y, &z, &w); + cogl_graphene_matrix_project_point (matrix_p, x, y, &z, &w); /* Perform perspective division */ *x /= w; diff --git a/cogl/cogl/cogl.h b/cogl/cogl/cogl.h index 07b496208..142293dac 100644 --- a/cogl/cogl/cogl.h +++ b/cogl/cogl/cogl.h @@ -123,6 +123,7 @@ #include #include #include +#include /* XXX: This will definitely go away once all the Clutter winsys * code has been migrated down into Cogl! */ #include diff --git a/cogl/cogl/driver/gl/cogl-clip-stack-gl.c b/cogl/cogl/driver/gl/cogl-clip-stack-gl.c index 24a714f6c..d5007cf3d 100644 --- a/cogl/cogl/driver/gl/cogl-clip-stack-gl.c +++ b/cogl/cogl/driver/gl/cogl-clip-stack-gl.c @@ -35,6 +35,7 @@ #include "cogl-config.h" #include "cogl-context-private.h" +#include "cogl-graphene.h" #include "cogl-primitives-private.h" #include "cogl-primitive-private.h" #include "driver/gl/cogl-util-gl-private.h" @@ -204,8 +205,8 @@ add_stencil_clip_region (CoglFramebuffer *framebuffer, z2 = 0.f; w2 = 1.f; - cogl_matrix_transform_point (&matrix, &x1, &y1, &z1, &w1); - cogl_matrix_transform_point (&matrix, &x2, &y2, &z2, &w2); + cogl_graphene_matrix_project_point (&matrix, &x1, &y1, &z1, &w1); + cogl_graphene_matrix_project_point (&matrix, &x2, &y2, &z2, &w2); v[0].x = x1; v[0].y = y1; diff --git a/cogl/cogl/meson.build b/cogl/cogl/meson.build index 2947b46c9..360675d4c 100644 --- a/cogl/cogl/meson.build +++ b/cogl/cogl/meson.build @@ -123,6 +123,7 @@ cogl_nonintrospected_headers = [ 'cogl-gtype-private.h', 'cogl-glib-source.h', 'cogl-scanout.h', + 'cogl-graphene.h', ] cogl_nodist_headers = [ @@ -354,6 +355,7 @@ cogl_sources = [ 'deprecated/cogl-clutter.c', 'cogl-glib-source.c', 'cogl-mutter.h', + 'cogl-graphene.c', ] if have_x11 diff --git a/src/compositor/clutter-utils.c b/src/compositor/clutter-utils.c index f05a698f5..6482ceb1a 100644 --- a/src/compositor/clutter-utils.c +++ b/src/compositor/clutter-utils.c @@ -170,11 +170,11 @@ meta_actor_painting_untransformed (CoglFramebuffer *fb, for (i = 0; i < 4; i++) { float w = 1; - cogl_matrix_transform_point (&modelview_projection, - &vertices[i].x, - &vertices[i].y, - &vertices[i].z, - &w); + cogl_graphene_matrix_project_point (&modelview_projection, + &vertices[i].x, + &vertices[i].y, + &vertices[i].z, + &w); vertices[i].x = MTX_GL_SCALE_X (vertices[i].x, w, viewport[2], viewport[0]); vertices[i].y = MTX_GL_SCALE_Y (vertices[i].y, w,