pango 3.1.1-x86-mingw32 → 3.1.2-x86-mingw32

data/vendor/local/include/graphene-1.0/graphene-point3d.h

@@ -0,0 +1,140 @@
+/* graphene-point3d.h: Point in 3D space
+ *
+ * Copyright 2014  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_POINT3D_H__
+#define __GRAPHENE_POINT3D_H__
+
+#if !defined(GRAPHENE_H_INSIDE) && !defined(GRAPHENE_COMPILATION)
+#error "Only graphene.h can be included directly."
+#endif
+
+#include "graphene-types.h"
+
+GRAPHENE_BEGIN_DECLS
+
+/**
+ * GRAPHENE_POINT3D_INIT:
+ * @_x: the X coordinate
+ * @_y: the Y coordinate
+ * @_z: the Z coordinate
+ *
+ * Initializes a #graphene_point3d_t to the given coordinates when declaring it.
+ *
+ * Since: 1.0
+ */
+#define GRAPHENE_POINT3D_INIT(_x,_y,_z) (graphene_point3d_t) { .x = (_x), .y = (_y), .z = (_z) }
+
+/**
+ * GRAPHENE_POINT3D_INIT_ZERO:
+ *
+ * Initializes a #graphene_point3d_t to (0, 0, 0) when declaring it.
+ *
+ * Since: 1.0
+ */
+#define GRAPHENE_POINT3D_INIT_ZERO      GRAPHENE_POINT3D_INIT (0.f, 0.f, 0.f)
+
+/**
+ * graphene_point3d_t:
+ * @x: the X coordinate
+ * @y: the Y coordinate
+ * @z: the Z coordinate
+ *
+ * A point with three components: X, Y, and Z.
+ *
+ * Since: 1.0
+ */
+struct _graphene_point3d_t
+{
+  float x;
+  float y;
+  float z;
+};
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_point3d_t *            graphene_point3d_alloc                  (void);
+GRAPHENE_AVAILABLE_IN_1_0
+void                            graphene_point3d_free                   (graphene_point3d_t       *p);
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_point3d_t *            graphene_point3d_init                   (graphene_point3d_t       *p,
+                                                                         float                     x,
+                                                                         float                     y,
+                                                                         float                     z);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_point3d_t *            graphene_point3d_init_from_point        (graphene_point3d_t       *p,
+                                                                         const graphene_point3d_t *src);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_point3d_t *            graphene_point3d_init_from_vec3         (graphene_point3d_t       *p,
+                                                                         const graphene_vec3_t    *v);
+GRAPHENE_AVAILABLE_IN_1_0
+void                            graphene_point3d_to_vec3                (const graphene_point3d_t *p,
+                                                                         graphene_vec3_t          *v);
+
+GRAPHENE_AVAILABLE_IN_1_0
+bool                            graphene_point3d_equal                  (const graphene_point3d_t *a,
+                                                                         const graphene_point3d_t *b);
+GRAPHENE_AVAILABLE_IN_1_0
+bool                            graphene_point3d_near                   (const graphene_point3d_t *a,
+                                                                         const graphene_point3d_t *b,
+                                                                         float                     epsilon);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                            graphene_point3d_scale                  (const graphene_point3d_t *p,
+                                                                         float                     factor,
+                                                                         graphene_point3d_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                            graphene_point3d_cross                  (const graphene_point3d_t *a,
+                                                                         const graphene_point3d_t *b,
+                                                                         graphene_point3d_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+float                           graphene_point3d_dot                    (const graphene_point3d_t *a,
+                                                                         const graphene_point3d_t *b);
+GRAPHENE_AVAILABLE_IN_1_0
+float                           graphene_point3d_length                 (const graphene_point3d_t *p);
+GRAPHENE_AVAILABLE_IN_1_0
+void                            graphene_point3d_normalize              (const graphene_point3d_t *p,
+                                                                         graphene_point3d_t       *res);
+GRAPHENE_AVAILABLE_IN_1_4
+float                           graphene_point3d_distance               (const graphene_point3d_t *a,
+                                                                         const graphene_point3d_t *b,
+                                                                         graphene_vec3_t          *delta);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                            graphene_point3d_interpolate            (const graphene_point3d_t *a,
+                                                                         const graphene_point3d_t *b,
+                                                                         double                    factor,
+                                                                         graphene_point3d_t       *res);
+
+GRAPHENE_AVAILABLE_IN_1_4
+void                            graphene_point3d_normalize_viewport     (const graphene_point3d_t *p,
+                                                                         const graphene_rect_t    *viewport,
+                                                                         float                     z_near,
+                                                                         float                     z_far,
+                                                                         graphene_point3d_t       *res);
+
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_point3d_t *      graphene_point3d_zero                   (void);
+
+GRAPHENE_END_DECLS
+
+#endif /* __GRAPHENE_POINT3D_H__ */

data/vendor/local/include/graphene-1.0/graphene-quad.h

@@ -0,0 +1,80 @@
+/* graphene-quad.h: Quad
+ *
+ * Copyright 2014  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_QUAD_H__
+#define __GRAPHENE_QUAD_H__
+
+#include "graphene-types.h"
+#include "graphene-point.h"
+
+GRAPHENE_BEGIN_DECLS
+
+/**
+ * graphene_quad_t:
+ *
+ * A 4 vertex quadrilateral, as represented by four #graphene_point_t.
+ *
+ * The contents of a #graphene_quad_t are private and should never be
+ * accessed directly.
+ *
+ * Since: 1.0
+ */
+struct _graphene_quad_t
+{
+  /*< private >*/
+  GRAPHENE_PRIVATE_FIELD (graphene_point_t, points[4]);
+};
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quad_t *       graphene_quad_alloc             (void);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quad_free              (graphene_quad_t        *q);
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quad_t *       graphene_quad_init              (graphene_quad_t        *q,
+                                                         const graphene_point_t *p1,
+                                                         const graphene_point_t *p2,
+                                                         const graphene_point_t *p3,
+                                                         const graphene_point_t *p4);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quad_t *       graphene_quad_init_from_rect    (graphene_quad_t        *q,
+                                                         const graphene_rect_t  *r);
+GRAPHENE_AVAILABLE_IN_1_2
+graphene_quad_t *       graphene_quad_init_from_points  (graphene_quad_t        *q,
+                                                         const graphene_point_t  points[]);
+
+GRAPHENE_AVAILABLE_IN_1_0
+bool                    graphene_quad_contains          (const graphene_quad_t  *q,
+                                                         const graphene_point_t *p);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quad_bounds            (const graphene_quad_t  *q,
+                                                         graphene_rect_t        *r);
+
+GRAPHENE_AVAILABLE_IN_1_0
+const graphene_point_t *graphene_quad_get_point         (const graphene_quad_t  *q,
+                                                         unsigned int            index_);
+
+GRAPHENE_END_DECLS
+
+#endif /* __GRAPHENE_QUAD_H__ */

data/vendor/local/include/graphene-1.0/graphene-quaternion.h

@@ -0,0 +1,136 @@
+/* graphene-quaternion.h: Quaternion
+ *
+ * Copyright 2014  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_QUATERNION_H__
+#define __GRAPHENE_QUATERNION_H__
+
+#if !defined(GRAPHENE_H_INSIDE) && !defined(GRAPHENE_COMPILATION)
+#error "Only graphene.h can be included directly."
+#endif
+
+#include "graphene-types.h"
+#include "graphene-vec4.h"
+
+GRAPHENE_BEGIN_DECLS
+
+/**
+ * graphene_quaternion_t:
+ *
+ * A quaternion.
+ *
+ * The contents of the #graphene_quaternion_t structure are private
+ * and should never be accessed directly.
+ *
+ * Since: 1.0
+ */
+struct _graphene_quaternion_t
+{
+  /*< private >*/
+  GRAPHENE_PRIVATE_FIELD (float, x);
+  GRAPHENE_PRIVATE_FIELD (float, y);
+  GRAPHENE_PRIVATE_FIELD (float, z);
+  GRAPHENE_PRIVATE_FIELD (float, w);
+};
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_alloc                       (void);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_free                        (graphene_quaternion_t       *q);
+
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init                        (graphene_quaternion_t       *q,
+                                                                         float                        x,
+                                                                         float                        y,
+                                                                         float                        z,
+                                                                         float                        w);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init_identity               (graphene_quaternion_t       *q);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init_from_quaternion        (graphene_quaternion_t       *q,
+                                                                         const graphene_quaternion_t *src);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init_from_vec4              (graphene_quaternion_t       *q,
+                                                                         const graphene_vec4_t       *src);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init_from_matrix            (graphene_quaternion_t       *q,
+                                                                         const graphene_matrix_t     *m);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init_from_angles            (graphene_quaternion_t       *q,
+                                                                         float                        deg_x,
+                                                                         float                        deg_y,
+                                                                         float                        deg_z);
+GRAPHENE_AVAILABLE_IN_1_4
+graphene_quaternion_t * graphene_quaternion_init_from_radians           (graphene_quaternion_t       *q,
+                                                                         float                        rad_x,
+                                                                         float                        rad_y,
+                                                                         float                        rad_z);
+GRAPHENE_AVAILABLE_IN_1_0
+graphene_quaternion_t * graphene_quaternion_init_from_angle_vec3        (graphene_quaternion_t       *q,
+                                                                         float                        angle,
+                                                                         const graphene_vec3_t       *axis);
+GRAPHENE_AVAILABLE_IN_1_2
+graphene_quaternion_t * graphene_quaternion_init_from_euler             (graphene_quaternion_t       *q,
+                                                                         const graphene_euler_t      *e);
+
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_to_vec4                     (const graphene_quaternion_t *q,
+                                                                         graphene_vec4_t             *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_to_matrix                   (const graphene_quaternion_t *q,
+                                                                         graphene_matrix_t           *m);
+GRAPHENE_AVAILABLE_IN_1_2
+void                    graphene_quaternion_to_angles                   (const graphene_quaternion_t *q,
+                                                                         float                       *deg_x,
+                                                                         float                       *deg_y,
+                                                                         float                       *deg_z);
+GRAPHENE_AVAILABLE_IN_1_4
+void                    graphene_quaternion_to_radians                  (const graphene_quaternion_t *q,
+                                                                         float                       *rad_x,
+                                                                         float                       *rad_y,
+                                                                         float                       *rad_z);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_to_angle_vec3               (const graphene_quaternion_t *q,
+                                                                         float                       *angle,
+                                                                         graphene_vec3_t             *axis);
+
+GRAPHENE_AVAILABLE_IN_1_0
+bool                    graphene_quaternion_equal                       (const graphene_quaternion_t *a,
+                                                                         const graphene_quaternion_t *b);
+GRAPHENE_AVAILABLE_IN_1_0
+float                   graphene_quaternion_dot                         (const graphene_quaternion_t *a,
+                                                                         const graphene_quaternion_t *b);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_invert                      (const graphene_quaternion_t *q,
+                                                                         graphene_quaternion_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_normalize                   (const graphene_quaternion_t *q,
+                                                                         graphene_quaternion_t       *res);
+GRAPHENE_AVAILABLE_IN_1_0
+void                    graphene_quaternion_slerp                       (const graphene_quaternion_t *a,
+                                                                         const graphene_quaternion_t *b,
+                                                                         float                        factor,
+                                                                         graphene_quaternion_t       *res);
+
+GRAPHENE_END_DECLS
+
+#endif /* __GRAPHENE_QUATERNION_H__ */

data/vendor/local/include/graphene-1.0/graphene-ray.h

@@ -0,0 +1,98 @@
+/* graphene-ray.h: A ray emitted from an origin in a given direction
+ *
+ * Copyright 2015  Emmanuele Bassi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef __GRAPHENE_RAY_H__
+#define __GRAPHENE_RAY_H__
+
+#if !defined(GRAPHENE_H_INSIDE) && !defined(GRAPHENE_COMPILATION)
+#error "Only graphene.h can be included directly."
+#endif
+
+#include "graphene-types.h"
+#include "graphene-vec3.h"
+
+GRAPHENE_BEGIN_DECLS
+
+/**
+ * graphene_ray_t:
+ *
+ * A ray emitted from an origin in a given direction.
+ *
+ * The contents of the `graphene_ray_t` structure are private, and should not
+ * be modified directly.
+ *
+ * Since: 1.4
+ */
+struct _graphene_ray_t
+{
+  /*< private >*/
+  GRAPHENE_PRIVATE_FIELD (graphene_vec3_t, origin);
+  GRAPHENE_PRIVATE_FIELD (graphene_vec3_t, direction);
+};
+
+GRAPHENE_AVAILABLE_IN_1_4
+graphene_ray_t *                graphene_ray_alloc                  (void);
+GRAPHENE_AVAILABLE_IN_1_4
+void                            graphene_ray_free                   (graphene_ray_t           *r);
+
+GRAPHENE_AVAILABLE_IN_1_4
+graphene_ray_t *                graphene_ray_init                   (graphene_ray_t           *r,
+                                                                     const graphene_point3d_t *origin,
+                                                                     const graphene_vec3_t    *direction);
+GRAPHENE_AVAILABLE_IN_1_4
+graphene_ray_t *                graphene_ray_init_from_ray          (graphene_ray_t           *r,
+                                                                     const graphene_ray_t     *src);
+GRAPHENE_AVAILABLE_IN_1_4
+graphene_ray_t *                graphene_ray_init_from_vec3         (graphene_ray_t           *r,
+                                                                     const graphene_vec3_t    *origin,
+                                                                     const graphene_vec3_t    *direction);
+GRAPHENE_AVAILABLE_IN_1_4
+void                            graphene_ray_get_origin             (const graphene_ray_t     *r,
+                                                                     graphene_point3d_t       *origin);
+GRAPHENE_AVAILABLE_IN_1_4
+void                            graphene_ray_get_direction          (const graphene_ray_t     *r,
+                                                                     graphene_vec3_t          *direction);
+
+GRAPHENE_AVAILABLE_IN_1_4
+void                            graphene_ray_get_position_at        (const graphene_ray_t     *r,
+                                                                     float                     t,
+                                                                     graphene_point3d_t       *position);
+GRAPHENE_AVAILABLE_IN_1_4
+float                           graphene_ray_get_distance_to_point  (const graphene_ray_t     *r,
+                                                                     const graphene_point3d_t *p);
+GRAPHENE_AVAILABLE_IN_1_4
+float                           graphene_ray_get_distance_to_plane  (const graphene_ray_t     *r,
+                                                                     const graphene_plane_t   *p);
+
+GRAPHENE_AVAILABLE_IN_1_4
+bool                            graphene_ray_equal                  (const graphene_ray_t     *a,
+                                                                     const graphene_ray_t     *b);
+
+GRAPHENE_AVAILABLE_IN_1_4
+void                            graphene_ray_get_closest_point_to_point   (const graphene_ray_t     *r,
+                                                                           const graphene_point3d_t *p,
+                                                                           graphene_point3d_t       *res);
+
+GRAPHENE_END_DECLS
+
+#endif /* __GRAPHENE_RAY_H__ */