• supports shapes, colors and transpareny
• supports textures
• supports multiple models (new)
• built in transform functions such as scale, rotate or translation
• save as a new dat file (new)
• tested for big files
• bugfixed (tested in Ubuntu natty 64 + 32, Windows 7)

• Processing 2.0
• freeware version of Google Sketchup version 8

The importer is tested with latest Sketchup release 8.0.16846 12/19/2012

• It supports no groups
• It supports no repetive textures
• No support for files which have been created in previous Sketchup versions

(To handle it read instructions further down)

Install it as plugin with Library Manager: Choose menubar "Sketch" → "Import Library…" → "Add Library…" then search for "Collada Loader"

Or get latest versionhere as zip

Older library versions won't work with Processing version 2.0 so they're removed from net.

For more details take also a look to my forum

• Save any existing older .skp files into version 8 and restart Sketchup (older files contain another XML-tree)
• Remove all groups in your model:
  • Zoom back press CTRL+A then mouse rightclick and choose "explode" (Fig 1).
  • Save and re-open the model
• Enshure of unique textures:
  • Do mouse rightclick on each faces which have textures applied
  • Then and choose "Make Unique Texture" (Fig 2)

Fig 1: ColladaLoader throws Java Exceptions if you don't ungroup the entire model or you try to load old kmz / dae versions.

Fig 2: Processing produces blurred graphics on the sketch if you don't apply that step. This menu item is not available if SketchUp already considers the texture to be 'unique'.In this example: Susan contains no textures but the wall does.

Considering the rules of Sketchupversion groups and textures, export the model into Processing now:

• Choose in Sketchup "File" → "Export" → "3D-Model"
• save it as kmz or dae into Processing "data" path

The examples folder contain a demo.pde which shows the usage of the library. The very basics to run ColladaLoader is adding the following code into Processing sketch:

• define an attribute e.g.

  ColladaLoader model2;

• define a sketch size with OpenGL e.g.

  size(500, 500, OPENGL);

• instantiate the model with filename and current sketch instance e.g.

  model2 = new ColladaLoader("susan.kmz",this);

• You 're able to instantiate more than one model. ColladaLoader loads in different ways so there exist 3 reserved file suffixes for it:
  • ".kmz" and ".dae" = sketchup models
  • ".dat" = serialized (saved) ColladaLoader objects.

• add the draw method e.g.

  model2.draw();

Take a note that Processing zero points start not in the middle of the sketch and some translations may be nessessary before drawing.

The loading or drawing of 3D models claim lots of CPU time and RAM. That may produce several runtime problems. It can be assumed that the model has been loaded into memory correctly (consistent data) if no explicit "ColladaLoaderException" occurs. There is some ways to improve the performance:

• download latest stable Processing version
• set a low framerate (10 per second or less) in setup() section
• add noloop() method into setup() section and call loop() later (e.g. over a keyPressed event)
• Increase memory size: choose "File" → "Preferences" → "avaiable memory"
• For Mac 64 users: the previous library version throwed ColladaLoaderExceptions. It has been fixed by re-compiling the sources on the same platform. Use the Ant script for it.
• Be shure that the model contains at least one triangle AND one line
• Use the OpenGL Adapter for Processing (see also)

The class cooladaLoader.ColladaLoader is the entry class and defines the interface too. Whose methods support all the features what is mentioned on the top of this doc. The required data to display the model is wrapped into two arrays which resides in this class:

• Triangle[]
• Line[]

The coordinate system and color range of Sketchup is converted into Processing specifications. Following a method/constructor list:

Those classes wrapp all required data to display the model. Each object contains data for one entity. It correlate to coordinates and texture formates of Processing and supports read/write access. Here is a list of properies:

http://processing.org
sketchup.google.com
www.collada.org
www.leo.org
Repository (examples, sources, javadoc)

Last Update: June 2013

There exist 3 fundamental jobs for the entire architecture what must be done:

• Parsing the XML tree from a .dae file into proper java objects
• Interpreting and completing model data from java objects
• Implementing of the interface functions such as transformations or I/O management

The parsing operates with the DOM model and is located in package xmlMapping. At first the XML tree is loaded into memory by Processing API. As next step it follows a readout of each xml tag. For that purpose wrappers are created whose classnames are equal to xml tag names. Whose constructors read xml data or instantiate further wrappers. The order of instantiating those wrappers is important because some wrapper objects are linked to each other. Hence, such objects already must exist or be parsed, respectively. For this controlling there exist the class ColladaRAWLoader. It's the package entry class and contains a main method to test this subpackage separately as well.

The output from ColladaRawLoader class contain data which is based on Sketchup specifications such as coordinate system or color ranges and must be converted to Processing specifications. Furthermore, the data still don't include textues but just filenames of them which files have to be loaded before, and kmz files must be unzipped first. These are jobs that the class LoadingHelper does. It's located in the parent package (cooladaloader). The interface ColladaLoader makes use of it.

The xml structure of a .dae files applies the specifications of collada.org. Whose interface definitions permit lots of combinations of xml tags so it's possible that other 3D programms (e.g. cinema4d), if they export collada likewise, define another xml tree or data. Actually, those definitions diverge from sketchup version to version too. Thats why the ColladaLoader library works on Sketchup version 8 (release dec 2012) only.

Fig 4: On the one hand, the xml tree is a static structure on the other hand there exist dependencies of data what the xml tags or child tags contain. Those two facts must be considered in order to map those data into java objects. To get the point in this case: The order in reading the tags start from bottom up.

Fig 5: This example is a detailed view of xml data what contain one triangle. Vertice coordinate or texture-points are stored here. The <p> tag is a subtag of <lines> or <triangles> and contain indices they link to an index position of a <float_array> tag

In this example the Offset 1 is allocated to textures and the vertices have offset 0. After parsing we get following results:

The <lines> tag construction is simillar. An <accessor> tag says how to read a <float_array> tag.

For further details refer to javaDoc or code comments in each classes.