scriptup 0.0.0

data/sketchup-sdk-win/headers/SketchUpAPI/geometry/vector2d.h

@@ -0,0 +1,235 @@
+// Copyright 2017 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for SUVector2D.
+ */
+#ifndef SKETCHUP_GEOMETRY_VECTOR2D_H_
+#define SKETCHUP_GEOMETRY_VECTOR2D_H_
+
+#include <SketchUpAPI/common.h>
+#include <SketchUpAPI/geometry.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@brief Creates a vector between two point objects.
+@since SketchUp 2018 M0, API 6.0
+@param[in]  from   The first point object.
+@param[in]  to     The second point object.
+@param[out] vector The vector from from to to.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if from or to is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if vector is NULL
+*/
+SU_RESULT SUVector2DCreate(
+    struct SUVector2D* vector, const struct SUPoint2D* from, const struct SUPoint2D* to);
+
+/**
+@brief Determines if a vector is valid. A vector is invalid if its length is
+       zero.
+@since SketchUp 2017, API 5.0
+@param[in]  vector The vector object.
+@param[out] valid  Whether the vector is valid.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if valid is NULL
+*/
+SU_RESULT SUVector2DIsValid(const struct SUVector2D* vector, bool* valid);
+
+/**
+@brief Determines if two vectors are parallel.
+@since SketchUp 2017, API 5.0
+@param[in]  vector1  The first vector object.
+@param[in]  vector2  The second vector object.
+@param[out] parallel Whether the vectors are parallel.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if parallel is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector1 or vector2 is not a valid vector
+*/
+SU_RESULT SUVector2DIsParallelTo(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, bool* parallel);
+
+/**
+@brief Determines if two vectors are perpendicular.
+@since SketchUp 2017, API 5.0
+@param[in]  vector1       The first vector object.
+@param[in]  vector2       The second vector object.
+@param[out] perpendicular Whether the vectors are perpendicular.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if perpendicular is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector1 or vector2 is not a valid vector
+*/
+SU_RESULT SUVector2DIsPerpendicularTo(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, bool* perpendicular);
+
+/**
+@brief Determines if two vectors are parallel and pointing the same direction.
+@since SketchUp 2017, API 5.0
+@param[in]  vector1        The first vector object.
+@param[in]  vector2        The second vector object.
+@param[out] same_direction Whether the vectors are pointing in the same direction.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if same_direction is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector1 or vector2 is not a valid vector
+*/
+SU_RESULT SUVector2DIsSameDirectionAs(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, bool* same_direction);
+
+/**
+@brief Determines if two vectors are equal.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] equal   Whether the vectors are equal.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if equal is NULL
+*/
+SU_RESULT SUVector2DIsEqual(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, bool* equal);
+
+/**
+@brief Normalizes a vector.
+@since SketchUp 2017, API 5.0
+@param[in,out] vector The vector object.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector is not a valid vector
+*/
+SU_RESULT SUVector2DNormalize(struct SUVector2D* vector);
+
+/**
+@brief Reverses a vector.
+@since SketchUp 2017, API 5.0
+@param[in] vector The vector object.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+*/
+SU_RESULT SUVector2DReverse(struct SUVector2D* vector);
+
+/**
+@brief Computes the dot product of two vectors.
+@since SketchUp 2017, API 5.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] dot     The value of the dot product.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if dot is NULL
+*/
+SU_RESULT SUVector2DDot(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, double* dot);
+
+/**
+@brief Computes the cross product of two vectors.
+@since SketchUp 2017, API 5.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] cross   The value of the cross product.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if cross is NULL
+*/
+SU_RESULT SUVector2DCross(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, double* cross);
+
+/**
+@brief Determines if a vector has a length of one.
+@since SketchUp 2017, API 5.0
+@param[in]  vector         The vector object.
+@param[out] is_unit_vector Whether the vector has a length of one.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if is_unit_vector is NULL
+*/
+SU_RESULT SUVector2DIsUnitVector(const struct SUVector2D* vector, bool* is_unit_vector);
+
+/**
+@brief Gets the length of a vector.
+@since SketchUp 2017, API 5.0
+@param[in]  vector The vector object.
+@param[out] length The length of the vector.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if length is NULL
+*/
+SU_RESULT SUVector2DGetLength(const struct SUVector2D* vector, double* length);
+
+/**
+@brief Sets the length of a vector.
+@since SketchUp 2017, API 5.0
+@param[in,out] vector The vector object.
+@param[in]     length The new length the vector should be.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_OUT_OF_RANGE if length is zero
+- \ref SU_ERROR_INVALID_ARGUMENT if vector is not a valid vector
+*/
+SU_RESULT SUVector2DSetLength(struct SUVector2D* vector, double length);
+
+/**
+@brief Gets the angle between two vectors.
+@since SketchUp 2017, API 5.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] angle   The angle between the vectors.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if angle is NULL
+*/
+SU_RESULT SUVector2DAngleBetween(
+    const struct SUVector2D* vector1, const struct SUVector2D* vector2, double* angle);
+
+/**
+@brief Transforms a vector by applying a 2D transformation.
+@since SketchUp 2019, API 7.0
+@param[in]     transform The transformation to be applied.
+@param[in,out] vector    The vector to be transformed.
+@related SUVector2D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if transform is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if vector is NULL
+*/
+SU_RESULT SUVector2DTransform(
+    const struct SUTransformation2D* transform, struct SUVector2D* vector);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // SKETCHUP_GEOMETRY_VECTOR2D_H_

data/sketchup-sdk-win/headers/SketchUpAPI/geometry/vector3d.h

@@ -0,0 +1,285 @@
+// Copyright 2017 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for SUVector3D.
+ */
+#ifndef SKETCHUP_GEOMETRY_VECTOR3D_H_
+#define SKETCHUP_GEOMETRY_VECTOR3D_H_
+
+#include <SketchUpAPI/common.h>
+#include <SketchUpAPI/geometry.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@brief Creates a vector between two point objects.
+@since SketchUp 2018, API 6.0
+@param[in]  from   The first point object.
+@param[in]  to     The second point object.
+@param[out] vector The vector from from to to.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if from or to is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if vector is NULL
+*/
+SU_RESULT SUVector3DCreate(
+    struct SUVector3D* vector, const struct SUPoint3D* from, const struct SUPoint3D* to);
+
+/**
+@brief Determines if a vector is valid. A vector is invalid if its length is
+       zero.
+@since SketchUp 2018, API 6.0
+@param[in]  vector The vector object.
+@param[out] valid  Whether the vector is valid.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if valid is NULL
+*/
+SU_RESULT SUVector3DIsValid(const struct SUVector3D* vector, bool* valid);
+
+/**
+@brief Determines if two vectors are parallel.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1  The first vector object.
+@param[in]  vector2  The second vector object.
+@param[out] parallel Whether the vectors are parallel.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if parallel is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector1 or vector2 is not a valid vector
+*/
+SU_RESULT SUVector3DIsParallelTo(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, bool* parallel);
+
+/**
+@brief Determines if two vectors are perpendicular.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1       The first vector object.
+@param[in]  vector2       The second vector object.
+@param[out] perpendicular Whether the vectors are perpendicular.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if perpendicular is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector1 or vector2 is not a valid vector
+*/
+SU_RESULT SUVector3DIsPerpendicularTo(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, bool* perpendicular);
+
+/**
+@brief Determines if two vectors are parallel and pointing the same direction.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1        The first vector object.
+@param[in]  vector2        The second vector object.
+@param[out] same_direction Whether the vectors are pointing in the same direction.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if same_direction is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector1 or vector2 is not a valid vector
+*/
+SU_RESULT SUVector3DIsSameDirectionAs(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, bool* same_direction);
+
+/**
+@brief Determines if two vectors are equal.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] equal   Whether the vectors are equal.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if equal is NULL
+*/
+SU_RESULT SUVector3DIsEqual(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, bool* equal);
+
+/**
+@brief Determines if vector1 is less than vector2.
+@param[in]  vector1   The first vector object.
+@param[in]  vector2   The second vector object.
+@param[out] less_than Whether vector1 is less than vector2.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if less_than is NULL
+*/
+SU_RESULT SUVector3DLessThan(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, bool* less_than);
+
+/**
+@brief Normalizes a vector.
+@since SketchUp 2018, API 6.0
+@param[in,out] vector The vector object.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector is not a valid vector
+*/
+SU_RESULT SUVector3DNormalize(struct SUVector3D* vector);
+
+/**
+@brief Reverses a vector.
+@since SketchUp 2018, API 6.0
+@param[in,out] vector The vector object.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+*/
+SU_RESULT SUVector3DReverse(struct SUVector3D* vector);
+
+/**
+@brief Computes the dot product of two vectors.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] dot     The value of the dot product.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if dot is NULL
+*/
+SU_RESULT SUVector3DDot(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, double* dot);
+
+/**
+@brief Computes the cross product of two vectors.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] cross   The value of the cross product.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if cross is NULL
+*/
+SU_RESULT SUVector3DCross(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, struct SUVector3D* cross);
+
+/**
+@brief Determines if a vector has a length of one.
+@since SketchUp 2018, API 6.0
+@param[in]  vector         The vector object.
+@param[out] is_unit_vector Whether the vector has a length of one.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if is_unit_vector is NULL
+*/
+SU_RESULT SUVector3DIsUnitVector(const struct SUVector3D* vector, bool* is_unit_vector);
+
+/**
+@brief Gets the length of a vector.
+@since SketchUp 2018, API 6.0
+@param[in]  vector The vector object.
+@param[out] length The length of the vector.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if length is NULL
+*/
+SU_RESULT SUVector3DGetLength(const struct SUVector3D* vector, double* length);
+
+/**
+@brief Sets the length of a vector.
+@since SketchUp 2018, API 6.0
+@param[in,out] vector The vector object.
+@param[in]     length The new length the vector should be.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if vector is not a valid vector
+*/
+SU_RESULT SUVector3DSetLength(struct SUVector3D* vector, double length);
+
+/**
+@brief Gets the angle between two vectors.
+@since SketchUp 2018, API 6.0
+@param[in]  vector1 The first vector object.
+@param[in]  vector2 The second vector object.
+@param[out] angle   The angle between the vectors.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if vector1 or vector2 is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if angle is NULL
+*/
+SU_RESULT SUVector3DAngleBetween(
+    const struct SUVector3D* vector1, const struct SUVector3D* vector2, double* angle);
+
+/**
+@brief Get arbitrary axes perpendicular to this vector. This method uses the
+       arbitrary axis algorithm to calculate the x and y vectors.
+@param[in]  z_axis The vector to use as the z axis.
+@param[out] x_axis The computed x axis vector.
+@param[out] y_axis The computed y axis vector.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if z_axis is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if x_axis or y_axis is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if z_axis is not a valid vector
+*/
+SU_RESULT SUVector3DGetArbitraryAxes(
+    const struct SUVector3D* z_axis, struct SUVector3D* x_axis, struct SUVector3D* y_axis);
+
+/**
+@brief Transforms the provided 3D vector by applying the provided 3D
+       transformation.
+@since SketchUp 2018, API 6.0
+@param[in]     transform The transformation to be applied.
+@param[in,out] vector    The vector to be transformed.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_INPUT if transform is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if vector is NULL
+*/
+SU_RESULT SUVector3DTransform(const struct SUTransformation* transform, struct SUVector3D* vector);
+
+/**
+@brief Creates a new vector as a linear combination of other vectors.
+       This method is generally used to get a vector at some percentage between
+       two vectors.
+@since SketchUp 2018, API 6.0
+@param[in]  vectors An array of vectors. Must be size of 2 or 3.
+@param[in]  weights An array of weights that correspond to the percentage. Must
+                    be the same size as \p vectors.
+@param[in]  size    The size of the \p vectors and \p weights array.
+@param[out] vector  The new computed vector.
+@related SUVector3D
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_OUT_OF_RANGE if size is less than 2 or greater than 3
+- \ref SU_ERROR_NULL_POINTER_INPUT if vectors or weights is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if vector is NULL
+*/
+SU_RESULT SUVector3DLinearCombination(
+    const struct SUVector3D* vectors, const double* weights, const size_t size,
+    struct SUVector3D* vector);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // SKETCHUP_GEOMETRY_VECTOR3D_H_

data/sketchup-sdk-win/headers/SketchUpAPI/geometry.h

@@ -0,0 +1,152 @@
+// Copyright 2013 Trimble Inc., All rights reserved.
+
+/**
+ * @file
+ * @brief Define types for geometric operations.
+ */
+#ifndef SKETCHUP_GEOMETRY_H_
+#define SKETCHUP_GEOMETRY_H_
+
+// includes
+#include <SketchUpAPI/common.h>
+
+#pragma pack(push, 8)
+
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+
+/**
+@struct SUPoint2D
+@brief Represents a point in 2-dimensional space.
+*/
+struct SUPoint2D {
+  double x;  ///< X coordinate
+  double y;  ///< Y coordinate
+};
+
+/**
+@struct SUVector2D
+@brief Represents a vector in 2-dimensional space.
+*/
+struct SUVector2D {
+  double x;  ///< X magnitude
+  double y;  ///< Y magnitude
+};
+
+/**
+@struct SUPoint3D
+@brief Represents a point in 3-dimensional space.
+*/
+struct SUPoint3D {
+  double x;  ///< X coordinate
+  double y;  ///< Y coordinate
+  double z;  ///< Z coordinate
+};
+
+/**
+@struct SUVector3D
+@brief Represents a vector in 3-dimensional space.
+*/
+struct SUVector3D {
+  double x;  ///< X magnitude
+  double y;  ///< Y magnitude
+  double z;  ///< Z magnitude
+};
+
+/**
+@struct SUPlane3D
+@brief Represents a 3D plane by the parameters a, b, c, d.
+       For any point on the plane, ax + by + cz + d = 0.
+       The coeficients are normalized so that a*a + b*b + c*c = 1.
+*/
+struct SUPlane3D {
+  double a;  ///< The "a" factor in the plane equation.
+  double b;  ///< The "b" factor in the plane equation.
+  double c;  ///< The "c" factor in the plane equation.
+  double d;  ///< The "d" factor in the plane equation.
+};
+
+/**
+@struct SUBoundingBox3D
+@brief Represents a 3D axis-aligned bounding box represented by the extreme
+       diagonal corner points with minimum and maximum x,y,z coordinates.
+*/
+struct SUBoundingBox3D {
+  struct SUPoint3D min_point;  ///< A 3D point where x, y and z are minimum
+                               ///< values in the bounding box
+  struct SUPoint3D max_point;  ///< A 3D point where x, y and z are maximum
+                               ///< values in the bounding box
+};
+
+/**
+@struct SUAxisAlignedRect2D
+@brief Represents a 2D rectangle that is aligned with the X and Y axis of the
+       coordinate system.
+*/
+struct SUAxisAlignedRect2D {
+  struct SUPoint2D upper_left;   ///< Upper left corner of the bounding box.
+  struct SUPoint2D lower_right;  ///< Lower right corner of the bounding box.
+};
+
+/**
+@struct SURay3D
+@brief Represents a 3D ray defined by a point and normal vector.
+@since SketchUp 2018, API 6.0
+*/
+struct SURay3D {
+  struct SUPoint3D point;    ///< Origin of the ray.
+  struct SUVector3D normal;  ///< Direction of the ray.
+};
+
+/**
+@struct SUTransformation
+@brief Represents a 3D (4x4) geometric transformation matrix.
+
+Matrix values are in column-major order.
+The transformation is stored as:
+
+@code{.txt}
+     -     -
+     | R T |
+ M = | 0 w |
+     -     -
+@endcode
+
+where:
+<ul>
+<li> M is a 4x4 matrix
+<li> R is a 3x3 sub-matrix. It is the rotation part
+<li> T is a 3x1 sub-matrix. It is the translation part
+<li> w is a scalar.         It is 1/scale.
+</ul>
+*/
+struct SUTransformation {
+  double values[16];  ///< Matrix values in column-major order.
+};
+
+/**
+@struct SUTransformation2D
+@brief Represents a 2D (2x3) affine transformation matrix. The matrix
+       is stored in column-major format:
+<pre>
+ m11 m21 tx
+ m12 m22 ty
+</pre>
+*/
+struct SUTransformation2D {
+  double m11;  ///< the m11 component
+  double m12;  ///< the m12 component
+  double m21;  ///< the m21 component
+  double m22;  ///< the m22 component
+  double tx;   ///< the tx component
+  double ty;   ///< the ty component
+};
+
+#ifdef __cplusplus
+}  // end extern "C"
+#endif  // __cplusplus
+
+#pragma pack(pop)
+
+#endif  // SKETCHUP_GEOMETRY_H_