scriptup 0.0.0

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

@@ -0,0 +1,36 @@
+// Copyright 2017-2020 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for usage within the SketchUp application.
+ */
+#ifndef SKETCHUP_APPLICATION_APPLICATION_H_
+#define SKETCHUP_APPLICATION_APPLICATION_H_
+
+#include <SketchUpAPI/common.h>
+#include <SketchUpAPI/model/defs.h>
+#pragma pack(push, 8)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@brief Gets a reference to the active model. The reference is owned by the
+       SketchUp application and should not be released.
+@since SketchUp 2019.2, API 7.1
+@param[out] model The model object.
+@see SUModelRef
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if \p model is `NULL`
+- \ref SU_ERROR_NO_DATA if there is no active model
+*/
+SU_RESULT SUApplicationGetActiveModel(SUModelRef* model);
+
+#ifdef __cplusplus
+}
+#endif
+#pragma pack(pop)
+
+#endif  // SKETCHUP_APPLICATION_APPLICATION_H_

data/sketchup-sdk-win/headers/SketchUpAPI/application/model.h

@@ -0,0 +1,59 @@
+// Copyright 2023 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for SUModelRef for live access
+ */
+#ifndef SKETCHUP_APPLICATION_MODEL_H_
+#define SKETCHUP_APPLICATION_MODEL_H_
+
+#include <SketchUpAPI/common.h>
+#include <SketchUpAPI/application/overlay.h>
+
+#pragma pack(push, 8)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@brief Creates an overlay and adds it to the model.
+@since SketchUp 2024, API 12.0
+@param[in] model The model object
+@param[in] info The information needed to create the overlay object
+@param[out] overlay The created overlay object
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_INPUT if \p model is an invalid object
+- \ref SU_ERROR_NULL_POINTER_INPUT if \p info is NULL
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if \p overlay is NULL
+- \ref SU_ERROR_OVERWRITE_VALID if \p overlay is already a valid object
+- \ref SU_ERROR_DUPLICATE if the given SUOverlayCreateInfo::id already exists in the model
+@relatedalso SUModelRef
+@relatedalso SUOverlayRef
+*/
+SU_RESULT SUModelCreateOverlay(
+    SUModelRef model, const struct SUOverlayCreateInfo* info, SUOverlayRef* overlay);
+
+/**
+@brief Releases the overlay after removing it from the model.
+@param[in] model The model object
+@param[in,out] overlay The overlay object to be released, will be set to NULL on return.
+@since SketchUp 2024, API 12.0
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_INPUT if \p model or \p overlay is an invalid object
+- \ref SU_ERROR_NULL_POINTER_INPUT if \p overlay is NULL
+- \ref SU_ERROR_NO_DATA if \p overlay could be found in the model
+@relatedalso SUModelRef
+@relatedalso SUOverlayRef
+*/
+SU_RESULT SUModelReleaseOverlay(SUModelRef model, SUOverlayRef* overlay);
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma pack(pop)
+
+#endif  // SKETCHUP_APPLICATION_MODEL_H_

data/sketchup-sdk-win/headers/SketchUpAPI/application/overlay.h

@@ -0,0 +1,248 @@
+// Copyright 2023 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief An Overlay provides a way to render an image over the SU rendering.
+ */
+#ifndef SKETCHUP_APPLICATION_OVERLAY_H_
+#define SKETCHUP_APPLICATION_OVERLAY_H_
+
+#include <SketchUpAPI/model/defs.h>
+#include <SketchUpAPI/geometry.h>
+
+#pragma pack(push, 8)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@struct SUOverlayRef
+@brief Manages a Overlay object, which is used to blend external images on top of SketchUp
+rendering.
+*/
+
+/**
+@brief Signature for SUOverlayCreateInfo::get_extents callback
+@related SUOverlayRef
+*/
+typedef struct SUBoundingBox3D (*SUOverlayGetExtentsFuncT)(SUOverlayRef, void*);
+
+/**
+@brief Available versions for the SUOverlayCreateInfo::version field.
+@related SUOverlayRef
+*/
+enum SUOverlayBeginFrameInfoVersion : uint32_t {
+  SUOVERLAY_BEGIN_FRAME_INFO_VERSION_1 = 1,
+};
+
+/**
+@brief Current version of the SUBeginFrameInfo struct
+@related SUOverlayRef
+*/
+#define SUOVERLAY_BEGIN_FRAME_INFO_VERSION (SUOVERLAY_BEGIN_FRAME_INFO_VERSION_1)
+
+/**
+@struct SUBeginFrameInfo
+@brief Information about the frame camera and viewport that is passed to
+SUOverlayCreateInfo::begin_frame
+@related SUOverlayRef
+*/
+struct SUBeginFrameInfo {
+  /// Version of SUBeginFrameInfo struct. This will be set by SketchUp.
+  enum SUOverlayBeginFrameInfoVersion version;
+
+  struct SUPoint3D position;      ///< Camera position
+  struct SUPoint3D target;        ///< Camera target position
+  struct SUVector3D up;           ///< Camera up direction
+  double aspect_ratio;            ///< Aspect ratio of the view port
+  double near_clipping_distance;  ///< Distance to near clipping plane from the camera
+  double far_clipping_distance;   ///< Distance to far clipping plane from the camera
+  double projection_matrix[16];   ///< Projection Matrix.
+  double view_matrix[16];         ///< View Matrix
+  double viewport_width;          ///< Viewport width
+  double viewport_height;         ///< Viewport height
+
+  double fov;     ///< Field of view of the perspective camera (in degrees). Valid only when
+                  ///< is_perspective is true.
+  double height;  ///< Parallel projection frustum height. Valid only when is_perspective is false.
+  bool is_perspective;  ///< Whether the camera is perspective or orthographic.
+
+  void* reserved;  ///< Reserved for internal use. This will be set to NULL by SketchUp and should
+                   ///< not be modified.
+};
+
+/**
+@brief Signature for SUOverlayCreateInfo::begin_frame callback
+@related SUOverlayRef
+*/
+typedef void (*SUOverlayBeginFrameFuncT)(SUOverlayRef, const struct SUBeginFrameInfo*, void*);
+
+/**
+@brief Available versions for SUOverlayDrawFrameInfo::version
+@related SUOverlayRef
+*/
+enum SUOverlayDrawFrameInfoVersion : uint32_t { SUOVERLAY_DRAW_FRAME_INFO_VERSION_1 = 1 };
+
+/**
+@brief Current version of SUOverlayDrawFrameInfo struct
+@related SUOverlayRef
+*/
+#define SUOVERLAY_DRAW_FRAME_INFO_VERSION (SUOVERLAY_DRAW_FRAME_INFO_VERSION_1)
+
+/**
+@struct SUDrawFrameMemoryBuffer
+@brief Memory buffer (for color and depth) info used in SUOverlayDrawFrameInfo
+@related SUOverlayRef
+*/
+struct SUDrawFrameMemoryBuffer {
+  /// Pointer to the buffer
+  void* ptr;
+  /// Size (in bytes) from the beginning of one line of the buffer to the next line
+  uint32_t row_pitch;
+  /// Total size (in bytes) of the buffer
+  uint32_t size;
+};
+
+/**
+@brief Supported image formats
+@related SUOverlayRef
+*/
+enum SUOverlayImageFormat : uint8_t {
+  SUOVERLAY_IMAGE_FORMAT_RGBA = 0,
+  SUOVERLAY_IMAGE_FORMAT_BGRA = 1,
+};
+
+/**
+@brief Supported image orientations
+@related SUOverlayRef
+*/
+enum SUOverlayImageOrientation : uint8_t {
+  SUOVERLAY_IMAGE_ORIENTATION_TOP_DOWN = 0,
+  SUOVERLAY_IMAGE_ORIENTATION_BOTTOM_UP = 1,
+};
+
+/**
+@struct SUOverlayDrawFrameInfo
+@brief Data that SketchUp will use the to blend the given color/depth buffer onto SketchUp
+rendering.
+@related SUOverlayRef
+*/
+struct SUOverlayDrawFrameInfo {
+  /// Version of the struct. This will be set by SketchUp.
+  enum SUOverlayDrawFrameInfoVersion version;
+
+  /// Alpha channel of the given color buffer will be multiplied with this value.
+  /// Must be set to 1.0 if an override is not needed.
+  double blending_factor;
+
+  /// Color buffer info. ptr points to a uint8_t buffer with 4 channels.
+  struct SUDrawFrameMemoryBuffer color;
+
+  /// Depth buffer info. ptr points to a float buffer.
+  struct SUDrawFrameMemoryBuffer depth;
+
+  /// Reserved for internal use. This will be set to NULL by SketchUp and should not be modified.
+  void* reserved;
+};
+
+/**
+@brief Signature for SUOverlayCreateInfo::draw_frame callback
+@related SUOverlayRef
+*/
+typedef void (*SUOverlayDrawFrameFuncT)(SUOverlayRef, struct SUOverlayDrawFrameInfo*, void*);
+
+/**
+@brief Signature for SUOverlayCreateInfo::end_frame callback
+@related SUOverlayRef
+*/
+typedef void (*SUOverlayEndFrameFuncT)(SUOverlayRef, void*);
+
+/**
+@brief Signature for SUOverlayCreateInfo::start callback
+@related SUOverlayRef
+*/
+typedef void (*SUOverlayStartFuncT)(SUOverlayRef, void*);
+
+/**
+@brief Signature for SUOverlayCreateInfo::stop callback
+@related SUOverlayRef
+*/
+typedef void (*SUOverlayStopFuncT)(SUOverlayRef, void*);
+
+/**
+@brief Available versions for the SUOverlayCreateInfo::version field.
+@related SUOverlayRef
+*/
+enum SUOverlayCreateInfoVersion : uint32_t {
+  SUOVERLAY_CREATE_INFO_VERSION_1 = 1,
+};
+
+/**
+@brief Current version of the SUOverlayCreateInfo struct.
+@related SUOverlayRef
+*/
+#define SUOVERLAY_CREATE_INFO_VERSION (SUOVERLAY_CREATE_INFO_VERSION_1)
+
+/**
+@struct SUOverlayCreateInfo
+@brief Arguments for creating an overlay object.
+@related SUOverlayRef
+*/
+struct SUOverlayCreateInfo {
+  /// Version of the struct. This must always be set to SUOVERLAY_CREATE_INFO_VERSION
+  enum SUOverlayCreateInfoVersion version;
+
+  /// A pointer that will passed directly back into provided callbacks. SketchUp will not access
+  /// this pointer.
+  void* user_data;
+
+  /// Unique id for the overlay
+  const char* id;
+  /// Name of the overlay. This will be displayed to user.
+  const char* name;
+  /// Description of the overlay. This will be displayed to user.
+  const char* desc;
+  /// Source of the overlay. This will be displayed to user.
+  const char* source;
+
+  /// Image format of the overlay color buffer
+  enum SUOverlayImageFormat image_format;
+  /// Image orientation of the overlay color and depth buffer
+  enum SUOverlayImageOrientation image_orientation;
+
+  /// A function that will be called when user enables the overlay.
+  SUOverlayStartFuncT start;
+  /// A function that will be called when user disables the overlay.
+  SUOverlayStopFuncT stop;
+  /// A function that should return bounds of the overlay.
+  SUOverlayGetExtentsFuncT get_extents;
+
+  /// Function that SketchUp will call at the beginning of a frame.
+  SUOverlayBeginFrameFuncT begin_frame;
+  /// Function that SketchUp will call to get overlay buffers and blending information.
+  SUOverlayDrawFrameFuncT draw_frame;
+  /// Function that SketchUp will call to signal the resources passed in draw_frame are no longer
+  /// needed.
+  SUOverlayEndFrameFuncT end_frame;
+};
+
+/**
+@brief Enables or disables an overlay.
+@related SUOverlayRef
+@param[in] overlay The overlay object
+@param[in] enabled Whether to enable or disable
+@since SketchUp 2024, API 12.0
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_INPUT if overlay is an invalid object
+*/
+SU_RESULT SUOverlayEnable(SUOverlayRef overlay, bool enabled);
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma pack(pop)
+
+#endif  // SKETCHUP_APPLICATION_OVERLAY_H_

data/sketchup-sdk-win/headers/SketchUpAPI/application/ruby_api.h

@@ -0,0 +1,118 @@
+// Copyright 2020 Trimble Inc. All Rights Reserved.
+
+/**
+ * @file
+ * @brief Interfaces for exchanging data between SketchUp's Ruby API and C API.
+ *
+ * @note This is for use only within the SketchUp application.
+ */
+#ifndef SKETCHUP_APPLICATION_RUBY_API_H_
+#define SKETCHUP_APPLICATION_RUBY_API_H_
+
+#include <SketchUpAPI/common.h>
+#include <SketchUpAPI/model/defs.h>
+#pragma pack(push, 8)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+@brief This macro is defining a type matching Ruby's own `VALUE` type and
+       can be used interchangeably.
+*/
+#ifdef __APPLE__
+  #define RUBY_VALUE unsigned long
+#elif _WIN32
+  #define RUBY_VALUE unsigned long long
+#else
+  #warning "Unsupported platform"
+  #define RUBY_VALUE unsigned long
+#endif
+
+/**
+@brief Converts a C API entity to a Ruby API entity.
+
+@since SketchUp 2020.2, API 8.2
+
+@param[in]  entity       The C API entity reference.
+@param[out] ruby_entity  The retrieved Ruby API entity reference.
+@see SUModelRef
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_INPUT if \p entity is an invalid object
+- \ref SU_ERROR_INVALID_ARGUMENT if \p entity is not owned by a model
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if \p ruby_entity is `NULL`
+- \ref SU_ERROR_NO_DATA if this isn't called from within SketchUp
+*/
+SU_RESULT SUEntityToRuby(SUEntityRef entity, RUBY_VALUE* ruby_entity);
+
+/**
+@brief Converts a Ruby API entity to a C API entity.
+
+@since SketchUp 2020.2, API 8.2
+
+@param[in]  ruby_entity  The Ruby API entity reference.
+@param[out] entity       The retrieved C API entity reference.
+@see SUModelRef
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_ARGUMENT if \p ruby_entity refers to a deleted entity
+- \ref SU_ERROR_INVALID_ARGUMENT if \p ruby_entity is not an entity type
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if \p entity is `NULL`
+- \ref SU_ERROR_OVERWRITE_VALID if \p entity is already a valid reference
+- \ref SU_ERROR_NO_DATA if this isn't called from within SketchUp
+*/
+SU_RESULT SUEntityFromRuby(RUBY_VALUE ruby_entity, SUEntityRef* entity);
+
+/**
+@brief Converts a C API entity to a Ruby API imagerep.
+
+@note Ruby takes ownership of the object it should not be released by
+      SUImageRepRelease. It will be released when Ruby garbage collects the
+      Ruby references to it.
+
+@since SketchUp 2020.2, API 8.2
+
+@param[in]  imagerep       The C API imagerep reference.
+@param[out] ruby_imagerep  The retrieved Ruby API imagerep reference.
+@see SUModelRef
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_INPUT if \p imagerep is an invalid object
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if \p ruby_imagerep is `NULL`
+- \ref SU_ERROR_NO_DATA if this isn't called from within SketchUp
+*/
+SU_RESULT SUImageRepToRuby(SUImageRepRef imagerep, RUBY_VALUE* ruby_imagerep);
+
+/**
+@brief Converts a Ruby API imagerep to a C API imagerep.
+
+@note Ruby retains the ownership of the object it should not be released by
+      SUImageRepRelease.
+
+@warning The returned C API reference points to an object that is owned by the
+         Ruby runtime and it may be garbage collected. To avoid this, ensure
+         that the Ruby API reference has a longer lifetime than the C API
+         reference.
+
+@since SketchUp 2020.2, API 8.2
+
+@param[in]  ruby_imagerep  The Ruby API imagerep reference.
+@param[out] imagerep       The retrieved C API imagerep reference.
+@see SUModelRef
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_INVALID_ARGUMENT if \p ruby_imagerep is not an imagerep type
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if \p imagerep is `NULL`
+- \ref SU_ERROR_OVERWRITE_VALID if \p imagerep is already a valid reference
+- \ref SU_ERROR_NO_DATA if this isn't called from within SketchUp
+*/
+SU_RESULT SUImageRepFromRuby(RUBY_VALUE ruby_imagerep, SUImageRepRef* imagerep);
+
+#ifdef __cplusplus
+}
+#endif
+#pragma pack(pop)
+
+#endif  // SKETCHUP_APPLICATION_RUBY_API_H_

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

@@ -0,0 +1,107 @@
+// Copyright 2013 Trimble Inc., All rights reserved.
+
+/**
+ * @file
+ * @brief Interfaces for SUColor.
+ */
+#ifndef SKETCHUP_COLOR_H_
+#define SKETCHUP_COLOR_H_
+
+#include <SketchUpAPI/unicodestring.h>
+
+#pragma pack(push, 8)
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+
+/**
+@typedef SUByte
+@brief A type that stores a byte.
+*/
+typedef unsigned char SUByte;
+
+/**
+@struct SUColor
+@brief Stores a RGBA color with 8 bit channels.
+*/
+typedef struct {
+  SUByte red;    ///< Red color channel
+  SUByte green;  ///< Green color channel
+  SUByte blue;   ///< Blue color channel
+  SUByte alpha;  ///< Alpha color channel
+} SUColor;
+
+/**
+@brief The blend method is used to blend two colors.
+       The blended color will be the result of taking
+       (1 - weight) * sucolor1 + weight * sucolor2.
+@since SketchUp 2018, API 6.0
+@param[in]  color1      A \ref SUColor to blend color2 with.
+@param[in]  color2      A \ref SUColor to blend color1 with.
+@param[in]  weight      A value that determines the weight
+@param[out] blended_color The blended \ref SUColor.
+@related SUColor
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_OUT_OF_RANGE if weight is out of range
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if blended_color is NULL
+*/
+SU_RESULT SUColorBlend(
+    const SUColor color1, const SUColor color2, const double weight, SUColor* blended_color);
+
+/**
+@brief Retrieves the number of color names recognized by SketchUp.
+@since SketchUp 2018, API 6.0
+@param[out] size The number of color names.
+@related SUColor
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if size is NULL
+*/
+SU_RESULT SUColorGetNumNames(size_t* size);
+
+/**
+@brief Retrives all the color names recognized by SketchUp.
+@since SketchUp 2018, API 6.0
+@param[out] names An array of all the SketchUp Color names.
+@param[in]  size  The size of the array.
+@related SUColor
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if names is NULL
+*/
+SU_RESULT SUColorGetNames(SUStringRef names[], const size_t size);
+
+/**
+@brief Sets the color represented by the name.
+@since SketchUp 2018, API 6.0
+@param[out] color   The struct representing the color.
+@param[in]  name    The string representing the color.
+@related SUColor
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if color is NULL
+- \ref SU_ERROR_INVALID_ARGUMENT if name is empty
+*/
+SU_RESULT SUColorSetByName(SUColor* color, const char* name);
+
+/**
+@brief Sets the color with the provided value. The passed in value can either be
+       integer or hexadecimal. Alpha will always be 255 but RGB. For example:
+       if the value is 0x66ccff, rgb will be (102, 204, 255) respectively.
+@since SketchUp 2018, API 6.0
+@param[out] color   The struct representing the color.
+@param[in]  value   A value that represents the color.
+@related SUColor
+@return
+- \ref SU_ERROR_NONE on success
+- \ref SU_ERROR_NULL_POINTER_OUTPUT if color is NULL
+*/
+SU_RESULT SUColorSetByValue(SUColor* color, const size_t value);
+
+#ifdef __cplusplus
+}  // end extern "C"
+#endif  // __cplusplus
+#pragma pack(pop)
+
+#endif  // SKETCHUP_COLOR_H_