scriptup 0.0.0

data/ext/definition_list.c

@@ -0,0 +1,145 @@
+#include <stdbool.h>
+#include <definition_list.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+void Sketchup_ComponentDefinition_Iterator(SUComponentDefinitionRef definition, void* _)
+{
+	rb_yield(Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTDEFINITION), 0, 0, definition.ptr));
+}
+
+void Sketchup_Group_Iterator(SUComponentDefinitionRef group, void* _)
+{
+	rb_yield(Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTDEFINITION), 0, 0, group.ptr));
+}
+
+static VALUE Sketchup_DefinitionList_each(VALUE self)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	FOREACH(SUModelGetNumComponentDefinitions, SUModelGetComponentDefinitions, SUComponentDefinitionRef, model, Sketchup_ComponentDefinition_Iterator, 0);
+	FOREACH(SUModelGetNumGroupDefinitions, SUModelGetGroupDefinitions, SUComponentDefinitionRef, model, Sketchup_Group_Iterator, 0);
+	return self;
+}
+
+static VALUE Sketchup_DefinitionList_count(VALUE self)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	size_t cd_count = 0;
+	size_t gd_count = 0;
+	SUModelGetNumComponentDefinitions(model, &cd_count);
+	SUModelGetNumGroupDefinitions(model, &gd_count);
+	return INT2NUM(cd_count + gd_count);
+}
+
+static VALUE Sketchup_DefinitionList_load(VALUE self, VALUE path)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	SUComponentDefinitionRef definition = SU_INVALID;
+	enum SUModelLoadStatus status;
+	enum SUResult result = SUModelLoadDefinitionWithStatus(model, StringValuePtr(path), &definition, &status);
+	if (result != SU_ERROR_NONE)
+		rb_raise(rb_eStandardError, "Unsuccessful loading of the definition!");
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTDEFINITION), 0, 0, definition.ptr);
+}
+
+struct DefinitionStringIterationContext
+{
+	VALUE key;
+	SUComponentDefinitionRef definition;
+};
+
+void Sketchup_DefinitionList_Get_By_String_Iterator(SUComponentDefinitionRef definition, struct DefinitionStringIterationContext* definition_struct)
+{
+	VALUE definition_name;
+	VALUE definition_guid;
+	GETSTRING(SUComponentDefinitionGetName, definition, definition_name);
+	GETSTRING(SUComponentDefinitionGetGuid, definition, definition_guid);
+	if (strcmp(StringValuePtr(definition_name), StringValuePtr(definition_struct->key)) == 0 ||
+		strcmp(StringValuePtr(definition_guid), StringValuePtr(definition_struct->key)) == 0)
+		definition_struct->definition = definition;
+}
+
+struct DefinitionIndexIterationContext
+{
+	int targetIndex;
+	int currentIndex;
+	SUComponentDefinitionRef definition;
+};
+
+void Sketchup_DefinitionList_Get_By_Index_Iterator(SUComponentDefinitionRef definition, struct DefinitionIndexIterationContext* definition_struct)
+{
+	if (definition_struct->targetIndex == definition_struct->currentIndex)
+		definition_struct->definition = definition;
+	definition_struct->currentIndex += 1;
+}
+
+static VALUE Sketchup_DefinitionList_get(VALUE self, VALUE key)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	if (rb_type(key) == T_STRING)
+	{
+		struct DefinitionStringIterationContext definition_struct = {key, SU_INVALID};
+		FOREACH(
+			SUModelGetNumComponentDefinitions,
+			SUModelGetComponentDefinitions,
+			SUComponentDefinitionRef,
+			model,
+			Sketchup_DefinitionList_Get_By_String_Iterator,
+			&definition_struct);
+		if (SUIsInvalid(definition_struct.definition))
+			return Qnil;
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTDEFINITION), 0, 0, definition_struct.definition.ptr);
+	}
+	else
+	{
+		struct DefinitionIndexIterationContext definition_struct = {NUM2INT(key), 0, SU_INVALID};
+		FOREACH(
+			SUModelGetNumComponentDefinitions,
+			SUModelGetComponentDefinitions,
+			SUComponentDefinitionRef,
+			model,
+			Sketchup_DefinitionList_Get_By_Index_Iterator,
+			&definition_struct);
+		if (SUIsInvalid(definition_struct.definition))
+		{
+			if (definition_struct.targetIndex >= definition_struct.currentIndex)
+				rb_raise(rb_eIndexError, "index %d out of range [0, %d)", definition_struct.targetIndex, definition_struct.currentIndex);
+		}
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTDEFINITION), 0, 0, definition_struct.definition.ptr);
+	}
+}
+
+static VALUE Sketchup_DefinitionList_add(VALUE self, VALUE name)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	SUComponentDefinitionRef definition = SU_INVALID;
+	SUComponentDefinitionCreate(&definition);
+	SUComponentDefinitionSetName(definition, StringValuePtr(name));
+	SUModelAddComponentDefinitions(model, 1, &definition);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTDEFINITION), 0, 0, definition.ptr);
+}
+
+static VALUE Sketchup_DefinitionList_remove(VALUE self, VALUE rb_definition)
+{
+	if (!rb_obj_is_kind_of(rb_definition, rb_path2class(SKETCHUP_COMPONENTDEFINITION)))
+		rb_raise(rb_eTypeError, "Wrong type of object given");
+	SUModelRef model = {DATA_PTR(self)};
+	SUComponentDefinitionRef definition = {DATA_PTR(rb_definition)};
+	SUModelRemoveComponentDefinitions(model, 1, &definition);
+	return Qtrue;
+}
+
+VALUE DefinitionList_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_DefinitionList = rb_define_class_under(Sketchup, DEFINITIONLIST, Sketchup_Entity);
+	rb_include_module(Sketchup_DefinitionList, rb_mEnumerable);
+	rb_define_method(Sketchup_DefinitionList, "each", Sketchup_DefinitionList_each, 0);
+	rb_define_method(Sketchup_DefinitionList, "count", Sketchup_DefinitionList_count, 0);
+	rb_define_method(Sketchup_DefinitionList, "size", Sketchup_DefinitionList_count, 0);
+	rb_define_method(Sketchup_DefinitionList, "length", Sketchup_DefinitionList_count, 0);
+	rb_define_method(Sketchup_DefinitionList, "load", Sketchup_DefinitionList_load, 1);
+	rb_define_method(Sketchup_DefinitionList, "[]", Sketchup_DefinitionList_get, 1);
+	rb_define_method(Sketchup_DefinitionList, "add", Sketchup_DefinitionList_add, 1);
+	rb_define_method(Sketchup_DefinitionList, "remove", Sketchup_DefinitionList_remove, 1);
+	return Sketchup_DefinitionList;
+}

data/ext/definition_list.h

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

data/ext/drawing_element.c

@@ -0,0 +1,10 @@
+#include <stdbool.h>
+#include <drawing_element.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+VALUE DrawingElement_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_DrawingElement = rb_define_class_under(Sketchup, DRAWINGELEMENT, Sketchup_Entity);
+	return Sketchup_DrawingElement;
+}

data/ext/drawing_element.h

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

data/ext/entities.c

@@ -0,0 +1,11 @@
+#include <stdbool.h>
+#include <entities.h>
+#include <SketchUpAPI/sketchup.h>
+#include <utils.h>
+
+
+VALUE Entities_Init(VALUE Sketchup, VALUE rb_cObject)
+{
+	VALUE Sketchup_Entities = rb_define_class_under(Sketchup, ENTITIES, rb_cObject);
+	return Sketchup_Entities;
+}

data/ext/entities.h

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

data/ext/entity.c

@@ -0,0 +1,253 @@
+#include <stdbool.h>
+#include <entity.h>
+#include <SketchUpAPI/sketchup.h>
+#include <utils.h>
+
+static VALUE Sketchup_Entity_persistentId(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	int64_t presistent_id = 0;
+	SUEntityGetPersistentID(entity, &presistent_id);
+	return LONG2NUM(presistent_id);
+}
+
+static VALUE Sketchup_Entity_entityId(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	int32_t entityId = 0;
+	SUEntityGetID(entity, &entityId);
+	return LONG2NUM(entityId);
+}
+
+static VALUE Sketchup_Entity_typename(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	switch (SUEntityGetType(entity))
+	{
+		case SURefType_Unknown: return rb_str_new2("Unknown");
+  		case SURefType_AttributeDictionary: return rb_str_new2("AttributeDictionary");
+  		case SURefType_Camera: return rb_str_new2("Camera");
+  		case SURefType_ComponentDefinition: return rb_str_new2("ComponentDefinition");
+  		case SURefType_ComponentInstance: return rb_str_new2("ComponentInstance");
+  		case SURefType_Curve: return rb_str_new2("Curve");
+  		case SURefType_Edge: return rb_str_new2("Edge");
+  		case SURefType_EdgeUse: return rb_str_new2("EdgeUse");
+  		case SURefType_Entities: return rb_str_new2("Entities");
+  		case SURefType_Face: return rb_str_new2("Face");
+  		case SURefType_Group: return rb_str_new2("Group");
+  		case SURefType_Image: return rb_str_new2("Image");
+  		case SURefType_Layer: return rb_str_new2("Layer");
+  		case SURefType_Location: return rb_str_new2("Location");
+  		case SURefType_Loop: return rb_str_new2("Loop");
+  		case SURefType_MeshHelper: return rb_str_new2("MeshHelper");
+  		case SURefType_Material: return rb_str_new2("Material");
+  		case SURefType_Model: return rb_str_new2("Model");
+  		case SURefType_Polyline3D: return rb_str_new2("Polyline3D");
+  		case SURefType_Scene: return rb_str_new2("Scene");
+  		case SURefType_Texture: return rb_str_new2("Texture");
+  		case SURefType_TextureWriter: return rb_str_new2("TextureWriter");
+  		case SURefType_TypedValue: return rb_str_new2("TypedValue");
+  		case SURefType_UVHelper: return rb_str_new2("UVHelper");
+  		case SURefType_Vertex: return rb_str_new2("Vertex");
+  		case SURefType_RenderingOptions: return rb_str_new2("RenderingOptions");
+  		case SURefType_GuidePoint: return rb_str_new2("GuidePoint");
+  		case SURefType_GuideLine: return rb_str_new2("GuideLine");
+  		case SURefType_Schema: return rb_str_new2("Schema");
+  		case SURefType_SchemaType: return rb_str_new2("SchemaType");
+  		case SURefType_ShadowInfo: return rb_str_new2("ShadowInfo");
+  		case SURefType_Axes: return rb_str_new2("Axes");
+  		case SURefType_ArcCurve: return rb_str_new2("ArcCurve");
+  		case SURefType_SectionPlane: return rb_str_new2("SectionPlane");
+  		case SURefType_DynamicComponentInfo: return rb_str_new2("DynamicComponentInfo");
+  		case SURefType_DynamicComponentAttribute: return rb_str_new2("DynamicComponentAttribute");
+  		case SURefType_Style: return rb_str_new2("Style");
+  		case SURefType_Styles: return rb_str_new2("Styles");
+  		case SURefType_ImageRep: return rb_str_new2("ImageRep");
+  		case SURefType_InstancePath: return rb_str_new2("InstancePath");
+  		case SURefType_Font: return rb_str_new2("Font");
+  		case SURefType_Dimension: return rb_str_new2("Dimension");
+  		case SURefType_DimensionLinear: return rb_str_new2("DimensionLinear");
+  		case SURefType_DimensionRadial: return rb_str_new2("DimensionRadial");
+  		case SURefType_DimensionStyle: return rb_str_new2("DimensionStyle");
+  		case SURefType_Text: return rb_str_new2("Text");
+  		case SURefType_EntityList: return rb_str_new2("EntityList");
+  		case SURefType_EntityListIterator: return rb_str_new2("EntityListIterator");
+  		case SURefType_DrawingElement: return rb_str_new2("DrawingElement");
+  		case SURefType_Entity: return rb_str_new2("Entity");
+  		case SURefType_LengthFormatter: return rb_str_new2("LengthFormatter");
+  		case SURefType_LineStyle: return rb_str_new2("LineStyle");
+  		case SURefType_LineStyleManager: return rb_str_new2("LineStyleManager");
+  		case SURefType_Selection: return rb_str_new2("Selection");
+  		case SURefType_LayerFolder: return rb_str_new2("LayerFolder");
+	}
+}
+
+static VALUE Sketchup_Entity_parent(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	SUEntitiesRef entities = SU_INVALID;
+	SUEntityGetParentEntities(entity, &entities);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_DEFINITIONLIST), 0, 0, entities.ptr);
+}
+
+static VALUE Sketchup_Entity_model(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	SUModelRef model = SU_INVALID;
+	SUEntityGetModel(entity, &model);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_MODEL), 0, 0, model.ptr);
+}
+
+static VALUE Sketchup_Entity_remove_observer(VALUE self, VALUE observer)
+{
+	#pragma clang diagnostic push
+	#pragma clang diagnostic ignored "-Wcompound-token-split-by-macro"
+	if (!RTEST(rb_ivar_defined(self, rb_intern("@observers"))))
+	#pragma clang diagnostic pop
+		return Qfalse;
+
+	VALUE result = rb_hash_delete(rb_iv_get(self, "@observers"), observer);
+
+	return RTEST(result) ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_Entity_add_observer(VALUE self, VALUE observer)
+{
+	VALUE observers = Qnil;
+	#pragma clang diagnostic push
+	#pragma clang diagnostic ignored "-Wcompound-token-split-by-macro"
+	if (RTEST(rb_ivar_defined(self, rb_intern("@observers"))))
+	#pragma clang diagnostic pop
+	{
+		observers = rb_iv_get(self, "@observers");
+	}
+	else
+	{
+		observers = rb_hash_new();
+		rb_iv_set(self, "@observers", rb_hash_new());
+	}
+	rb_hash_aset(self, observer, observer);
+	return Qtrue;
+}
+
+void Sketchup_Entity_attribute_dictionaries_Iterator(SUAttributeDictionaryRef dictionary, VALUE* ary)
+{
+	rb_ary_push(*ary, Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARY), 0, 0, dictionary.ptr));
+}
+
+static VALUE Sketchup_Entity_attribute_dictionaries(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARIES), 0, 0, entity.ptr);
+}
+
+struct AttributeDictionaryIterationContext
+{
+	VALUE key;
+	SUAttributeDictionaryRef dictionary;
+};
+
+
+void Sketchup_Entity_attribute_dictionary_Iterator(SUAttributeDictionaryRef dictionary, struct AttributeDictionaryIterationContext* attribute_dictionary_struct)
+{
+	VALUE output;
+	GETSTRING(SUAttributeDictionaryGetName, dictionary, output);
+	if (strcmp(StringValuePtr(output), StringValuePtr(attribute_dictionary_struct->key)) == 0)
+		attribute_dictionary_struct->dictionary = dictionary;
+}
+
+static VALUE Sketchup_Entity_attribute_dictionary(int argc, VALUE* argv, VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	struct AttributeDictionaryIterationContext attribute_dictionary_struct = {argv[0], SU_INVALID};
+	FOREACH(SUEntityGetNumAttributeDictionaries, SUEntityGetAttributeDictionaries, SUAttributeDictionaryRef, entity, Sketchup_Entity_attribute_dictionary_Iterator, &attribute_dictionary_struct);
+	if (SUIsInvalid(attribute_dictionary_struct.dictionary) && argc > 1 && argv[1])
+	{
+		SUAttributeDictionaryCreate(&attribute_dictionary_struct.dictionary, StringValuePtr(argv[0]));
+		SUEntityAddAttributeDictionary(entity, attribute_dictionary_struct.dictionary);
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARY), 0, 0, attribute_dictionary_struct.dictionary.ptr);
+	}
+	else if(SUIsValid(attribute_dictionary_struct.dictionary))
+		return Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARY), 0, 0, attribute_dictionary_struct.dictionary.ptr);
+	else
+		return Qnil;
+}
+
+static VALUE Sketchup_Entity_delete_attribute(int argc, VALUE* argv, VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	if (argc == 0)
+	{
+		rb_raise(rb_eArgError, "Dictionary name required");
+	}
+	else if (argc == 1 && rb_type(argv[0]) == T_STRING)
+	{
+		if (strcmp(StringValuePtr(argv[0]), "SU_InstanceSet") == 0 || strcmp(StringValuePtr(argv[0]), "SU_DefinitionSet") == 0)
+			rb_raise(rb_eArgError, "Cannot delete internal");
+
+		struct AttributeDictionaryIterationContext attribute_dictionary_struct = {argv[0], SU_INVALID};
+		FOREACH(SUEntityGetNumAttributeDictionaries, SUEntityGetAttributeDictionaries, SUAttributeDictionaryRef, entity, Sketchup_Entity_attribute_dictionary_Iterator, &attribute_dictionary_struct);
+		if (SUIsValid(attribute_dictionary_struct.dictionary))
+		{
+			SUAttributeDictionaryRelease(&attribute_dictionary_struct.dictionary);
+			return Qtrue;
+		}
+	}
+	else if (argc > 1)
+	{
+		//ToDo use Sketchup_AttributeDictionary_delete_key
+	}
+	return Qfalse;
+}
+
+static VALUE Sketchup_Entity_deleted(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	return SUIsInvalid(entity) ? Qtrue : Qfalse;	
+}
+
+static VALUE Sketchup_Entity_valid(VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	return SUIsValid(entity) ? Qtrue : Qfalse;	
+}
+
+static VALUE Sketchup_Entity_get_attribute(int argc, VALUE* argv, VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	struct AttributeDictionaryIterationContext attribute_dictionary_struct = {argv[0], SU_INVALID};
+	FOREACH(SUEntityGetNumAttributeDictionaries, SUEntityGetAttributeDictionaries, SUAttributeDictionaryRef, entity, Sketchup_Entity_attribute_dictionary_Iterator, &attribute_dictionary_struct);
+	// use Sketchup_AttributeDictionary_get
+	return Qnil;
+	
+}
+
+static VALUE Sketchup_Entity_set_attribute(int argc, VALUE* argv, VALUE self)
+{
+	SUEntityRef entity = {DATA_PTR(self)};
+	struct AttributeDictionaryIterationContext attribute_dictionary_struct = {argv[0], SU_INVALID};
+	FOREACH(SUEntityGetNumAttributeDictionaries, SUEntityGetAttributeDictionaries, SUAttributeDictionaryRef, entity, Sketchup_Entity_attribute_dictionary_Iterator, &attribute_dictionary_struct);
+	// use Sketchup_AttributeDictionary_set
+	return Qnil;
+	
+}
+
+VALUE Entity_Init(VALUE Sketchup, VALUE rb_cObject)
+{
+	VALUE Sketchup_Entity = rb_define_class_under(Sketchup, ENTITY, rb_cObject);
+	rb_define_method(Sketchup_Entity, "persistent_id", Sketchup_Entity_persistentId, 0);
+	rb_define_method(Sketchup_Entity, "entityID", Sketchup_Entity_entityId, 0);
+	rb_define_method(Sketchup_Entity, "typename", Sketchup_Entity_typename, 0);
+	rb_define_method(Sketchup_Entity, "parent", Sketchup_Entity_parent, 0);
+	rb_define_method(Sketchup_Entity, "model", Sketchup_Entity_model, 0);
+	rb_define_method(Sketchup_Entity, "remove_observer", Sketchup_Entity_remove_observer, 1);
+	rb_define_method(Sketchup_Entity, "add_observer", Sketchup_Entity_add_observer, 1);
+	rb_define_method(Sketchup_Entity, "attribute_dictionaries", Sketchup_Entity_attribute_dictionaries, 0);
+	rb_define_method(Sketchup_Entity, "attribute_dictionary", Sketchup_Entity_attribute_dictionary, -1);
+	rb_define_method(Sketchup_Entity, "delete_attribute", Sketchup_Entity_delete_attribute, -1);
+	rb_define_method(Sketchup_Entity, "deleted?", Sketchup_Entity_deleted, 0);
+	rb_define_method(Sketchup_Entity, "valid?", Sketchup_Entity_valid, 0);
+	rb_define_method(Sketchup_Entity, "get_attribute", Sketchup_Entity_get_attribute, -1);
+	rb_define_method(Sketchup_Entity, "set_attribute", Sketchup_Entity_set_attribute, -1);
+	return Sketchup_Entity;
+}

data/ext/entity.h

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

data/ext/extconf.rb

@@ -0,0 +1,38 @@
+require 'mkmf'
+
+MAC = RUBY_PLATFORM =~ /darwin/
+WIN = !MAC
+
+extension_name = 'sketchup'
+sdk_path = "#{__dir__}/../sketchup-sdk-#{MAC ? 'mac' : 'win'}"
+
+# Work around for how framework headers are structured
+if MAC && !File.exist?("#{sdk_path}/headers/SketchUpAPI")
+  FileUtils.mkdir_p("#{sdk_path}/headers")
+  FileUtils.symlink('../SketchUpAPI.framework/Headers', "#{sdk_path}/headers/SketchUpAPI")
+end
+
+# Work around for fact gems can't handle symlinks
+if MAC
+  framework = "#{sdk_path}/SketchUpAPI.framework"
+  FileUtils.symlink('Versions/A/SketchUpAPI', "#{framework}/SketchUpAPI") unless File.exist?("#{framework}/SketchUpAPI")
+  FileUtils.symlink('Versions/A/Resources', "#{framework}/Resources") unless File.exist?("#{framework}/Resources")
+  FileUtils.symlink('Versions/A/Headers', "#{framework}/Headers") unless File.exist?("#{framework}/Headers")
+  FileUtils.symlink('A', "#{framework}/Versions/Current") unless File.exist?("#{framework}/Versions/Current")
+end
+
+# rubocop:disable Style/GlobalVars
+$INCFLAGS << " -I#{sdk_path}/headers"
+$CFLAGS << " #{'-Werror' if MAC } -O0 " if ENV['SCRIPTUP_DEVELOPMENT']
+
+if MAC
+  $DLDFLAGS.gsub!('-Wl,-multiply_defined,suppress', '')
+  $DLDFLAGS << ' -Wl,-ld_classic'
+  $DLDFLAGS << " -F#{sdk_path} -framework SketchUpAPI"
+  $DLDFLAGS << " -Wl,-rpath,#{sdk_path}"
+else
+  $DLDFLAGS << " -L#{sdk_path}/binaries/sketchup/x64 -lSketchUpAPI"
+end
+# rubocop:enable Style/GlobalVars
+
+create_makefile(extension_name)