Skip to content
A complete set of C++ Wrapper classes for SketchUp C API objects
C++ CMake Shell
Branch: master
Clone or download

C++ Wrapper for SketchUp C API



SketchUp C API is made for the C programming language: [ml]:

For C++ programmers, the non-object-orientated nature of the C API means simple operations for retrieving objects through is time consuming. This project provides a wrapper class for every SketchUp C API object that considerably shortens the amount of code required to perform simple tasks.

For example, to get an array of faces from an entities object, you could write this:

SUEntitiesRef entities = SU_INVALID;
SUModelGetEntities(model, &entities);
size_t faceCount = 0;
SUEntitiesGetNumFaces(entities, &faceCount);
std::vector<SUFaceRef> faces[faceCount];
SUEntitiesGetFaces(entities, faceCount, &faces[0], &faceCount);

With the C++ Wrapper, to achieve the above, you just need to write this:

#include <SUAPI-CppWrapper/model/Model.hpp>
#include <SUAPI-CppWrapper/model/Face.hpp>
std::vector<CW::Face> faces = CW::Model(model).entities().faces();

Added to this benefit, the wrapper classes have helper functions to help with geometric manipulations, much in the style of the SketchUp Ruby API



The project is documented in Doxygen, accessible here:


Visual Studio

 CMake .. -G "Visual Studio 15 2017 Win64"


Navigate to the Sketchup-API-C-Wrapper project folder in Terminal and perform these commands:

mkdir xcode
cd xcode
cmake -G "Xcode" ..

If you get an error, it's probably because you haven't fetched the googletests submodules, so do this and try again:

git submodule update --init --recursive


The project uses GoogleTest for unit testing. It's included as a submodule so make sure to also initialize those when checking out the project.

The tests are located under /tests/. One file per testcase. One testcase per class being tested.

Keep tests small, keep their name descriptive.

Running Tests

Visual Studio

  1. Set the SketchUpAPITests project as your startup project.
  2. Build
  3. Run

Alternativly you can use the Google Test Adapter extension which provides overview of the tests from the UI. Makes it easy to run induvidual tests.


Coming soon.

GoogleTests References


Project Objectives

The aims of this set of wrapper classes are:

  • to make the SketchUp C API quicker and easier to use, from a C++ programmer's perspective.
  • to provide all methods in the SketchUp C API, but in a simplified form.
  • to provide all methods that are given in the equivalent classes in the SketchUp Ruby API ( [ml]: ), if it is possible to deliver through the SketchUp C API.


Programming Principles

Data Structure

Each C++ Wrapper class object holds its equivalent C API class object as a member variable (ie - CW::Face holds SUFaceRef). Further variables should be kept to a minimum, if at all.

Releasing Objects

With the use of the C++ Wrapper, the SketchUp API should "feel" like a native C++ API. This means the idea of "releasing" objects that are not attached to a model object, for example, should not have to be considered by the programmer. Instead, the wrapper class will deal with releasing of an object when the object goes out of scope.

The only exception to this rule is if the wrapped object (CW::Face, for example), is converted to a regular C object ( SUFaceRef, for example), in which case it can be assumed that the programmer is taking charge of the C object and will be dealing with any releasing.

Method Names

Method names take inspiration mostly from the SketchUp Ruby API. That said, these are not wholy consistent, and some liberties have been taken to make the method names make sense.

You can’t perform that action at this time.