scriptup 0.0.0

data/ext/material.c

@@ -0,0 +1,242 @@
+#include <stdbool.h>
+#include <material.h>
+#include <SketchUpAPI/sketchup.h>
+#include <utils.h>
+
+static int GETCOLOR(VALUE obj)
+{
+	int color = NUM2INT(obj);
+	if (color > 255)
+		return 255;
+	else if (color < 0)
+		return 0;
+	else
+		return color;
+}
+
+static float GETALPHA(VALUE obj)
+{
+	float alpha = NUM2DBL(obj);
+	if (alpha > 1.0)
+		return 1.0;
+	else if (alpha < 0.0)
+		return 0.0;
+	else
+		return alpha;
+}
+
+static void dealloc(SUColor* ptr)
+{
+	free(ptr);
+}
+
+static VALUE VALUE2COLOR(VALUE obj)
+{
+	if (rb_obj_is_kind_of(obj, rb_path2class(SKETCHUP_COLOR)))
+		return obj;
+	else if (rb_type(obj) == T_ARRAY)
+	{
+		if (RARRAY_LEN(obj) >= 3)
+		{
+			VALUE* start_arr = RARRAY_PTR(obj);
+			VALUE c = rb_obj_alloc(rb_path2class(SKETCHUP_COLOR));
+			SUColor* color = DATA_PTR(c);
+			color->red = GETCOLOR(start_arr[0]);
+			color->green = GETCOLOR(start_arr[1]);
+			color->blue = GETCOLOR(start_arr[2]);
+			color->alpha = 255;
+			return c;
+		}
+		else
+			rb_raise(rb_eArgError, "At least 3 values required");
+	}
+	else
+		rb_raise(rb_eTypeError, "no implicit conversion to Color");
+}
+
+static VALUE VALUE2COLORIZATION(VALUE obj)
+{
+	int colorization = NUM2INT(obj);
+	if (colorization < 0)
+		rb_raise(rb_eRangeError, "value cannot be negative");
+	else if (colorization > 2)
+		rb_raise(rb_eArgError, "Invalid colorization type");
+	else
+		return colorization;
+}
+
+static VALUE Sketchup_Material_Get_name(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	VALUE output;
+	GETSTRING(SUMaterialGetName, material, output);
+	return output;
+}
+
+static VALUE Sketchup_Material_Set_name(VALUE self, VALUE name)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	SUMaterialSetName(material, StringValuePtr(name));
+	return name;
+}
+
+static VALUE Sketchup_Material_Get_texture(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	SUTextureRef texture = SU_INVALID;
+	SUMaterialGetTexture(material, &texture);
+	if (SUIsValid(texture))
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_TEXTURE), 0, 0, texture.ptr);
+	return Qnil;
+}
+
+static VALUE Sketchup_Material_Set_texture(VALUE self, VALUE texturePath)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	if (rb_type(texturePath) == T_NIL)
+	{
+		SUMaterialSetType(material, 0);
+		return Qnil;
+	}
+	else if (rb_type(texturePath) == T_STRING)
+	{
+		SUTextureRef suTexture = SU_INVALID;
+		SUTextureCreateFromFile(&suTexture, StringValuePtr(texturePath), 1.0, 1.0);
+		SUMaterialSetTexture(material, suTexture);
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_TEXTURE), 0, 0, suTexture.ptr);
+	}
+	else
+	{
+		rb_raise(rb_eArgError, "Texture filename or nil required");
+	}
+}
+
+static VALUE Sketchup_Material_materialType(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	enum SUMaterialType suMaterialType = SUMaterialType_Colored;
+	SUMaterialGetType(material, &suMaterialType);
+	return INT2FIX(suMaterialType);
+}
+
+static VALUE Sketchup_Material_Get_color(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	VALUE color = rb_obj_alloc(rb_path2class(SKETCHUP_COLOR));
+	SUMaterialGetColor(material, DATA_PTR(color));
+	return color;
+}
+
+static VALUE Sketchup_Material_Set_color(VALUE self, VALUE color)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	VALUE valueColor = VALUE2COLOR(color);
+	return color;
+}
+
+static VALUE Sketchup_Material_Name_equ(VALUE self, VALUE other)
+{
+	if (!rb_obj_is_kind_of(other, rb_path2class(SKETCHUP_MATERIAL)))
+		rb_raise(rb_eStandardError, "Wrong type of object given");
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcompound-token-split-by-macro"
+	return rb_funcall(Sketchup_Material_Get_name(self), rb_intern("<=>"), 1, Sketchup_Material_Get_name(other));
+#pragma clang diagnostic pop
+}
+
+static VALUE Sketchup_Material_Get_alpha(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	double alpha = 0.0;
+	SUMaterialGetOpacity(material, &alpha);
+	return DBL2NUM(alpha);
+}
+
+static VALUE Sketchup_Material_Set_alpha(VALUE self, VALUE alpha)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	SUMaterialSetOpacity(material, GETALPHA(alpha));
+	return alpha;
+}
+
+static VALUE Sketchup_Material_Use_alpha(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	bool transparency = false;
+	SUMaterialIsDrawnTransparent(material, &transparency);
+	return transparency ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_Material_Get_colorize_type(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	enum SUMaterialColorizeType type = SU_INVALID;
+	SUMaterialGetColorizeType(material, &type);
+	return INT2FIX(type);
+}
+
+static VALUE Sketchup_Material_Set_colorize_type(VALUE self, VALUE type)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	SUMaterialSetColorizeType(material, VALUE2COLORIZATION(type));
+	return type;
+}
+
+static VALUE Sketchup_Material_owner_type(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	enum SUMaterialOwnerType type = SUMaterialOwnerType_DrawingElement;
+	SUMaterialGetOwnerType(material, &type);
+	return INT2FIX(type - 1);
+}
+
+static VALUE Sketchup_Material_colorize_deltas(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	double hue = 0.0;
+	double saturation = 0.0;
+	double lightness = 0.0;
+	SUMaterialGetColorizeDeltas(material, &hue, &saturation, &lightness);
+	VALUE ary = rb_ary_new2(3);
+	rb_ary_push(ary, DBL2NUM(hue));
+	rb_ary_push(ary, DBL2NUM(lightness));
+	rb_ary_push(ary, DBL2NUM(saturation));
+	return ary;
+}
+
+static VALUE Sketchup_Material_save_as(VALUE self, VALUE path)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	SUMaterialWriteToFile(material, StringValuePtr(path));
+	return Qtrue;
+}
+
+static VALUE Sketchup_Material_display_name(VALUE self)
+{
+	SUMaterialRef material = {DATA_PTR(self)};
+	VALUE output;
+	GETSTRING(SUMaterialGetNameLegacyBehavior, material, output);
+	return output;
+}
+
+void Material_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_Material = rb_define_class_under(Sketchup, MATERIAL, Sketchup_Entity);
+	rb_define_method(Sketchup_Material, "name", Sketchup_Material_Get_name, 0);
+	rb_define_method(Sketchup_Material, "name=", Sketchup_Material_Set_name, 1);
+	rb_define_method(Sketchup_Material, "texture", Sketchup_Material_Get_texture, 0);
+	rb_define_method(Sketchup_Material, "texture=", Sketchup_Material_Set_texture, 1);
+	rb_define_method(Sketchup_Material, "materialType", Sketchup_Material_materialType, 0);
+	rb_define_method(Sketchup_Material, "color", Sketchup_Material_Get_color, 0);
+	rb_define_method(Sketchup_Material, "color=", Sketchup_Material_Set_color, 1);
+	rb_define_method(Sketchup_Material, "<=>", Sketchup_Material_Name_equ, 1);
+	rb_define_method(Sketchup_Material, "alpha", Sketchup_Material_Get_alpha, 0);
+	rb_define_method(Sketchup_Material, "alpha=", Sketchup_Material_Set_alpha, 1);
+	rb_define_method(Sketchup_Material, "use_alpha?", Sketchup_Material_Use_alpha, 0);
+	rb_define_method(Sketchup_Material, "colorize_type", Sketchup_Material_Get_colorize_type, 0);
+	rb_define_method(Sketchup_Material, "colorize_type=", Sketchup_Material_Set_colorize_type, 1);
+	rb_define_method(Sketchup_Material, "owner_type", Sketchup_Material_owner_type, 0);
+	rb_define_method(Sketchup_Material, "colorize_deltas", Sketchup_Material_colorize_deltas, 0);
+	rb_define_method(Sketchup_Material, "save_as", Sketchup_Material_save_as, 1);
+	rb_define_method(Sketchup_Material, "display_name", Sketchup_Material_display_name, 0);
+}

data/ext/material.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+void Material_Init(VALUE namespace_object, VALUE parent_class);

data/ext/materials.c

@@ -0,0 +1,80 @@
+#include <stdbool.h>
+#include <materials.h>
+#include <SketchUpAPI/sketchup.h>
+#include <utils.h>
+
+void Sketchup_Materials_Iterator(SUMaterialRef material, void* _)
+{
+	rb_yield(Data_Wrap_Struct(rb_path2class(SKETCHUP_MATERIAL), 0, 0, material.ptr));
+}
+
+static VALUE Sketchup_Materials_each(VALUE self)
+{
+	if (rb_block_given_p())
+	{
+		SUModelRef model = {DATA_PTR(self)};
+		FOREACH(SUModelGetNumMaterials, SUModelGetMaterials, SUMaterialRef, model, Sketchup_Materials_Iterator, 0);
+	}
+	return self;
+}
+
+struct MaterialStringIterationContext
+{
+	VALUE key;
+	SUMaterialRef material;
+};
+
+void Sketchup_Materials_Get_By_String_Iterator(SUMaterialRef material, struct MaterialStringIterationContext* material_struct)
+{
+	VALUE output;
+	GETSTRING(SUMaterialGetName, material, output);
+	if (strcmp(StringValuePtr(output), StringValuePtr(material_struct->key)) == 0)
+		material_struct->material = material;
+}
+
+struct MaterialIndexIterationContext
+{
+	int targetIndex;
+	int currentIndex;
+	SUMaterialRef material;
+};
+
+void Sketchup_Materials_Get_By_Index_Iterator(SUMaterialRef material, struct MaterialIndexIterationContext* material_struct)
+{
+	if (material_struct->targetIndex == material_struct->currentIndex)
+		material_struct->material = material;
+	material_struct->currentIndex += 1;
+}
+
+static VALUE Sketchup_Materials_get(VALUE self, VALUE key)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	if (rb_type(key) == T_STRING)
+	{
+		struct MaterialStringIterationContext material_struct = {key, SU_INVALID};
+		FOREACH(SUModelGetNumMaterials, SUModelGetMaterials, SUMaterialRef, model, Sketchup_Materials_Get_By_String_Iterator, &material_struct);
+		if (SUIsInvalid(material_struct.material))
+			return Qnil;
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_MATERIAL), 0, 0, material_struct.material.ptr);
+	}
+	else
+	{
+		struct MaterialIndexIterationContext material_struct = {NUM2INT(key), 0, SU_INVALID};
+		FOREACH(SUModelGetNumMaterials, SUModelGetMaterials, SUMaterialRef, model, Sketchup_Materials_Get_By_Index_Iterator, &material_struct);
+		if (SUIsInvalid(material_struct.material))
+		{
+			if (material_struct.targetIndex >= material_struct.currentIndex)
+				rb_raise(rb_eIndexError, "index %d out of range [0, %d)", material_struct.targetIndex, material_struct.currentIndex);
+		}
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_MATERIAL), 0, 0, material_struct.material.ptr);
+	}
+}
+
+VALUE Materials_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_Materials = rb_define_class_under(Sketchup, MATERIALS, Sketchup_Entity);
+	rb_include_module(Sketchup_Materials, rb_mEnumerable);
+	rb_define_method(Sketchup_Materials, "each", Sketchup_Materials_each, 0);
+	rb_define_method(Sketchup_Materials, "[]", Sketchup_Materials_get, 1);
+	return Sketchup_Materials;
+}

data/ext/materials.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE Materials_Init(VALUE namespace_object, VALUE parent_class);

data/ext/model.c

@@ -0,0 +1,42 @@
+#include <stdbool.h>
+#include <model.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+#include <sketchup.h>
+
+static VALUE Sketchup_Model_close(VALUE self)
+{
+	SUModelRef model = Sketchup_get_active_model();
+	enum SUResult result = SUModelRelease(&model);
+	Sketchup_set_active_model(model);
+	if(result != SU_ERROR_NONE)
+		return false;
+	return Qnil;
+}
+
+static VALUE Sketchup_Model_materials(VALUE self)
+{
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_MATERIALS), 0, 0, DATA_PTR(self));
+}
+
+static VALUE Sketchup_Model_definitions(VALUE self)
+{
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_DEFINITIONLIST), 0, 0, DATA_PTR(self));
+}
+
+static VALUE Sketchup_Model_attribute_dictionaries(VALUE self)
+{
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARIES), 0, 0, DATA_PTR(self));
+}
+
+VALUE Model_Init(VALUE Sketchup, VALUE rb_cObject)
+{
+	VALUE Sketchup_Model = rb_define_class_under(Sketchup, MODEL, rb_cObject);
+	rb_define_const(Sketchup_Model, "LOAD_STATUS_SUCCESS", INT2FIX(0));
+	rb_define_const(Sketchup_Model, "LOAD_STATUS_SUCCESS_MORE_RECENT", INT2FIX(1));
+	rb_define_method(Sketchup_Model, "close", Sketchup_Model_close, 0);
+	rb_define_method(Sketchup_Model, "materials", Sketchup_Model_materials, 0);
+	rb_define_method(Sketchup_Model, "definitions", Sketchup_Model_definitions, 0);
+	rb_define_method(Sketchup_Model, "attribute_dictionaries", Sketchup_Model_attribute_dictionaries, 0);
+	return Sketchup_Model;
+}

data/ext/model.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE Model_Init(VALUE namespace_object, VALUE parent_class);

data/ext/sketchup.c

@@ -0,0 +1,89 @@
+#include <ruby.h>
+#include <stdbool.h>
+#include <sketchup.h>
+#include <entity.h>
+#include <entities.h>
+#include <model.h>
+#include <material.h>
+#include <materials.h>
+#include <texture.h>
+#include <color.h>
+#include <attribute_dictionary.h>
+#include <attribute_dictionaries.h>
+#include <component_definition.h>
+#include <component_instance.h>
+#include <definition_list.h>
+#include <drawing_element.h>
+#include <behavior.h>
+#include <utils.h>
+
+SUModelRef active_model = SU_INVALID;
+
+SUModelRef Sketchup_get_active_model()
+{
+	return active_model;
+}
+void Sketchup_set_active_model(SUModelRef model)
+{
+	active_model = model;
+}
+
+static VALUE Sketchup_open_file(int argc, VALUE *argv, VALUE self)
+{
+	VALUE path;
+	VALUE kwarg_hash;
+	rb_scan_args(argc, argv, "1:", &path, &kwarg_hash);
+
+	const VALUE kwarg_ids[1] = {
+		rb_intern_const("with_status")
+	};
+	VALUE kwargs[1];
+	rb_get_kwargs(kwarg_hash, kwarg_ids, 0, 1, kwargs);
+	bool with_status = true;
+	if (RDEF(kwargs[0]))
+		with_status = RTEST(kwargs[0]);
+
+	enum SUModelLoadStatus status;
+	SUModelRef model = SU_INVALID;
+	enum SUResult result = SUModelCreateFromFileWithStatus(&model, StringValuePtr(path), &status);
+	if (result != SU_ERROR_NONE)
+		return false;
+
+	Sketchup_set_active_model(model);
+	if (with_status)
+		return INT2FIX(status);
+	else
+		return Qtrue;
+}
+
+static VALUE Sketchup_active_model(VALUE self)
+{
+	if (SUIsValid(active_model))
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_MODEL), 0, 0, active_model.ptr);
+	else
+		return Qnil;
+}
+
+void Init_sketchup() {
+	SUInitialize();
+	VALUE Sketchup = rb_define_module(SKETCHUP);
+	rb_define_singleton_method(Sketchup, "open_file", Sketchup_open_file, -1);
+	rb_define_singleton_method(Sketchup, "active_model", Sketchup_active_model, 0);
+
+	Model_Init(Sketchup, rb_cObject);
+	Color_Init(Sketchup, rb_cObject);
+
+	VALUE Sketchup_Entities = Entities_Init(Sketchup, rb_cObject);
+	VALUE Sketchup_Entity = Entity_Init(Sketchup, rb_cObject);
+	Materials_Init(Sketchup, Sketchup_Entity);
+	Material_Init(Sketchup, Sketchup_Entity);
+	DefinitionList_Init(Sketchup, Sketchup_Entity);
+	AttributeDictionary_Init(Sketchup, Sketchup_Entity);
+	AttributeDictionaries_Init(Sketchup, Sketchup_Entity);
+	Texture_Init(Sketchup, Sketchup_Entity);
+	Behavior_Init(Sketchup, Sketchup_Entity);
+	
+	VALUE Sketchup_DrawingElement = DrawingElement_Init(Sketchup, Sketchup_Entity);
+	ComponentInstance_Init(Sketchup, Sketchup_DrawingElement);
+	ComponentDefinition_Init(Sketchup, Sketchup_DrawingElement);
+}

data/ext/sketchup.h

@@ -0,0 +1,4 @@
+#include <SketchUpAPI/sketchup.h>
+
+SUModelRef Sketchup_get_active_model();
+void Sketchup_set_active_model(SUModelRef model);

data/ext/texture.c

@@ -0,0 +1,9 @@
+#include <stdbool.h>
+#include <texture.h>
+#include <SketchUpAPI/sketchup.h>
+#include <utils.h>
+
+void Texture_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_Texture = rb_define_class_under(Sketchup, TEXTURE, Sketchup_Entity);
+}

data/ext/texture.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+void Texture_Init(VALUE namespace_object, VALUE parent_class);

data/ext/typed_value.c

@@ -0,0 +1,84 @@
+#include <stdbool.h>
+#include <typed_value.h>
+#include <utils.h>
+
+VALUE TypedValue_get_value_type(SUTypedValueRef* typedValue)
+{
+	enum SUTypedValueType type = SUTypedValueType_Empty;
+	enum SUResult result = SUTypedValueGetType(*typedValue, &type);
+	if(result != SU_ERROR_NONE)
+		return Qnil;
+	switch (type)
+	{
+		case SUTypedValueType_Empty:
+		{
+			return Qnil;
+		}
+		case SUTypedValueType_Byte:
+		{
+			return Qnil;
+		}
+		case SUTypedValueType_Short:
+		{
+			int16_t value;
+			SUTypedValueGetInt16(*typedValue, &value);
+			return INT2FIX(value);
+		}
+		case SUTypedValueType_Int32:
+		{
+			int32_t value;
+			SUTypedValueGetInt32(*typedValue, &value);
+			return INT2NUM(value);
+		}
+		case SUTypedValueType_Float:
+		{
+			float value;
+			SUTypedValueGetFloat(*typedValue, &value);
+			return DBL2NUM(value);
+		}
+		case SUTypedValueType_Double:
+		{
+			double value;
+			SUTypedValueGetDouble(*typedValue, &value);
+			return DBL2NUM(value);
+		}
+ 		case SUTypedValueType_Bool:
+		{
+			bool value;
+			SUTypedValueGetBool(*typedValue, &value);
+			return value ? Qtrue : Qfalse;
+		}
+		case SUTypedValueType_String:
+		{
+			VALUE output;
+			GETSTRING(SUTypedValueGetString, *typedValue, output);
+			return output;
+		} 
+		case SUTypedValueType_Color:
+		case SUTypedValueType_Time:
+		case SUTypedValueType_Vector3D:
+		case SUTypedValueType_Array:
+		{
+			rb_raise(rb_eStandardError, "unimplemented");
+		}
+	}
+}
+
+VALUE TypedValue_set_value_type(SUTypedValueRef* typedValue, VALUE value)
+{
+	VALUE type = rb_type(value);
+	switch (type)
+	{
+		case RUBY_T_FLOAT:
+		{
+			SUTypedValueSetFloat(*typedValue, NUM2DBL(value));
+			break;
+		}
+		case RUBY_T_STRING:
+		{
+			SUTypedValueSetString(*typedValue, StringValuePtr(value));
+			break;
+		}
+	}
+	return value;
+}

data/ext/typed_value.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include <SketchUpAPI/sketchup.h>
+
+VALUE TypedValue_get_value_type(SUTypedValueRef* typedValue);
+VALUE TypedValue_set_value_type(SUTypedValueRef* typedValue, VALUE value);

data/ext/utils.h

@@ -0,0 +1,80 @@
+#include <ruby.h>
+
+#ifndef UTILS_H
+#define SKETCHUP "Sketchup"
+#define MODEL "Model"
+#define MATERIAL "Material"
+#define MATERIALS "Materials"
+#define TEXTURE "Texture"
+#define ENTITY "Entity"
+#define ENTITIES "Entities"
+#define COLOR "Color"
+#define COMPONENTDEFINITION "ComponentDefinition"
+#define COMPONENTINSTANCE "ComponentInstance"
+#define DEFINITIONLIST "DefinitionList"
+#define ATTRIBUTEDICTIONARY "AttributeDictionary"
+#define ATTRIBUTEDICTIONARIES "AttributeDictionaries"
+#define DRAWINGELEMENT "DrawingElement"
+#define BEHAVIOR "Behavior"
+#define SKETCHUP_MATERIAL SKETCHUP "::" MATERIAL
+#define SKETCHUP_MATERIALS SKETCHUP "::" MATERIALS
+#define SKETCHUP_TEXTURE SKETCHUP "::" TEXTURE
+#define SKETCHUP_ENTITIES SKETCHUP "::" ENTITIES
+#define SKETCHUP_COLOR SKETCHUP "::" COLOR
+#define SKETCHUP_COMPONENTDEFINITION SKETCHUP "::" COMPONENTDEFINITION
+#define SKETCHUP_COMPONENTINSTANCE SKETCHUP "::" COMPONENTINSTANCE
+#define SKETCHUP_MODEL SKETCHUP "::" MODEL
+#define SKETCHUP_ATTRIBUTEDICTIONARY SKETCHUP "::" ATTRIBUTEDICTIONARY
+#define SKETCHUP_ATTRIBUTEDICTIONARIES SKETCHUP "::" ATTRIBUTEDICTIONARIES
+#define SKETCHUP_DEFINITIONLIST SKETCHUP "::" DEFINITIONLIST
+#define SKETCHUP_BEHAVIOR SKETCHUP "::" BEHAVIOR
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wbackslash-newline-escape"
+
+#define RDEF(arg) (arg != Qundef)
+
+#define FOREACH(SUGetNum, SUGet, SURef, ref, callback, userdata) {\
+	size_t num; \
+	SUGetNum(ref, &num); \
+	SURef* array = malloc(num * sizeof(SURef)); \
+	SUGet(ref, num, array, &num); \
+	for( int i = 0; i < num; i++) \
+		callback(array[i], userdata); \
+	free(array); \
+}
+
+#define FOREACHSTRING(SUGetNum, SUGet, SURef, ref, callback, userdata) {\
+	size_t num; \
+	SUGetNum(ref, &num); \
+	SURef* array = malloc(num * sizeof(SURef)); \
+	for (int i = 0; i < num; i++) \
+	{ \
+		array[i].ptr = 0; \
+		SUStringCreate(&array[i]); \
+	} \
+	SUGet(ref, num, array, &num); \
+	for (int i = 0; i < num; i++) \
+		callback(array[i], userdata); \
+	for (int i = 0; i < num; i++) \
+		SUStringRelease(&array[i]); \
+	free(array); \
+}
+
+#define GETUTF8FROMSTRING(suString, output) { \
+	size_t count; \
+	SUStringGetUTF8Length(suString, &count); \
+	output = rb_utf8_str_new(0, count); \
+	SUStringGetUTF8(suString, count + 1, RSTRING_PTR(output), &count); \
+}
+
+#define GETSTRING(SUName, arg, output) { \
+	SUStringRef name = SU_INVALID; \
+	SUStringCreate(&name); \
+	SUName(arg, &name); \
+	GETUTF8FROMSTRING(name, output); \
+	SUStringRelease(&name); \
+}
+#endif // UTILS_H
+
+#pragma clang diagnostic pop

data/lib/sketchup.rb

@@ -0,0 +1,12 @@
+case RUBY_PLATFORM
+when /darwin/
+    require "#{__dir__}/sketchup.bundle"
+when /linux/
+    raise "Unsupported platform for SketchUpAPI"
+else # assuming windows
+    require 'fiddle'
+    Fiddle.dlopen("#{__dir__}/../sketchup-sdk-win/binaries/sketchup/x64/SketchUpCommonPreferences.dll")
+    Fiddle.dlopen("#{__dir__}/../sketchup-sdk-win/binaries/sketchup/x64/SketchUpAPI.dll")
+    require "#{__dir__}/sketchup.so"
+end
+