Tutorials: 3D Plugin Class

This section contains a description of two very simple plugins of the PLUGIN_3D class and walks the user through the setup and building of the code.

Basic 3D Plugin

This tutorial walks the user through the development of a very basic 3D plugin named “PLUGIN_3D_DEMO1”. The purpose of this tutorial is only to demonstrate the construction of a very basic 3D plugin which does nothing other than provide a few filter strings which permit the KiCad user to filter file names while browsing for 3D models. The code demonstrated here is the absolute minimum requirement for any 3D plugin and can be used as a template for creating more advanced plugins.

In order to build the demo project we require the following:

  • CMake

  • KiCad plugin headers

  • KiCad Scene Graph library kicad_3dsg

To automatically detect the KiCad headers and library we shall use a CMake FindPackage script; the script supplied in this tutorial should work on Linux and Windows if the relevant header files are installed to ${KICAD_ROOT_DIR}/kicad and the KiCad Scene Graph library is installed in ${KICAD_ROOT_DIR}/lib.

To start let’s create a project directory and the FindPackage script:

  1. mkdir demo && cd demo
  2. export DEMO_ROOT=${PWD}
  3. mkdir CMakeModules && cd CMakeModules
  4. cat > FindKICAD.cmake << _EOF
  5. find_path( KICAD_INCLUDE_DIR kicad/plugins/kicad_plugin.h
  6.     PATHS ${KICAD_ROOT_DIR}/include $ENV{KICAD_ROOT_DIR}/include
  7.     DOC "Kicad plugins header path."
  8.     )
  10. if( NOT ${KICAD_INCLUDE_DIR} STREQUAL "KICAD_INCLUDE_DIR-NOTFOUND" )
  12.     # attempt to extract the version information from sg_version.h
  13.     find_file( KICAD_SGVERSION sg_version.h
  14.         PATHS ${KICAD_INCLUDE_DIR}
  15.         PATH_SUFFIXES kicad/plugins/3dapi
  16.         NO_DEFAULT_PATH )
  18.     if( NOT ${KICAD_SGVERSION} STREQUAL "KICAD_SGVERSION-NOTFOUND" )
  20.         # extract the "#define KICADSG_VERSION*" lines
  21.         file( STRINGS ${KICAD_SGVERSION} _version REGEX "^#define.*KICADSG_VERSION.*" )
  23.         foreach( SVAR ${_version} )
  24.             string( REGEX MATCH KICADSG_VERSION_[M,A,J,O,R,I,N,P,T,C,H,E,V,I,S]* _VARNAME ${SVAR} )
  25.             string( REGEX MATCH [0-9]+ _VALUE ${SVAR} )
  27.             if( NOT ${_VARNAME} STREQUAL "" AND NOT ${_VALUE} STREQUAL "" )
  28.                 set( _${_VARNAME} ${_VALUE} )
  29.             endif()
  31.         endforeach()
  33.         #ensure that NOT SG3D_VERSION* will evaluate to '0'
  34.         if( NOT _KICADSG_VERSION_MAJOR )
  35.             set( _KICADSG_VERSION_MAJOR 0 )
  36.         endif()
  38.         if( NOT _KICADSG_VERSION_MINOR )
  39.             set( _KICADSG_VERSION_MINOR 0 )
  40.         endif()
  42.         if( NOT _KICADSG_VERSION_PATCH )
  43.             set( _KICADSG_VERSION_PATCH 0 )
  44.         endif()
  46.         if( NOT _KICADSG_VERSION_REVISION )
  47.             set( _KICADSG_VERSION_REVISION 0 )
  48.         endif()
  50.         set( KICAD_VERSION ${_KICADSG_VERSION_MAJOR}.${_KICADSG_VERSION_MINOR}.${_KICADSG_VERSION_PATCH}.${_KICADSG_VERSION_REVISION} )
  51.         unset( KICAD_SGVERSION CACHE )
  53.     endif()
  54. endif()
  57. find_library( KICAD_LIBRARY
  58.     NAMES kicad_3dsg
  59.     PATHS
  60.         ${KICAD_ROOT_DIR}/lib $ENV{KICAD_ROOT_DIR}/lib
  61.         ${KICAD_ROOT_DIR}/bin $ENV{KICAD_ROOT_DIR}/bin
  62.     DOC "Kicad scenegraph library path."
  63.     )
  65. include( FindPackageHandleStandardArgs )
  66. FIND_PACKAGE_HANDLE_STANDARD_ARGS( KICAD
  67.     REQUIRED_VARS
  68.         KICAD_INCLUDE_DIR
  69.         KICAD_LIBRARY
  70.         KICAD_VERSION
  71.     VERSION_VAR KICAD_VERSION )
  74. mark_as_advanced( KICAD_INCLUDE_DIR )
  75. set( KICAD_VERSION_MAJOR ${_KICADSG_VERSION_MAJOR} CACHE INTERNAL "" )
  76. set( KICAD_VERSION_MINOR ${_KICADSG_VERSION_MINOR} CACHE INTERNAL "" )
  77. set( KICAD_VERSION_PATCH ${_KICADSG_VERSION_PATCH} CACHE INTERNAL "" )
  78. set( KICAD_VERSION_TWEAK ${_KICADSG_VERSION_REVISION} CACHE INTERNAL "" )
  79. _EOF

Kicad and its plugin headers must be installed; if they are installed to a user directory or under /opt on Linux, or you are using Windows, you will need to set the KICAD_ROOT_DIR environment variable to point to the directory containing the KiCad include and lib directories. For OS X the FindPackage script presented here may require some adjustments.

To configure and build the tutorial code we will use CMake and create a CMakeLists.txt script file:

  1. cd ${DEMO_ROOT}
  2. cat > CMakeLists.txt << _EOF
  3. # declare the name of the project
  4. project( PLUGIN_DEMO )
  6. # check that we have a version of CMake with all required features
  7. cmake_minimum_required( VERSION 2.8.12 FATAL_ERROR )
  9. # inform CMake of where to find the FindKICAD script
  10. set( CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules )
  12. # attempt to discover the installed kicad headers and library
  13. # and set the variables:
  14. #     KICAD_INCLUDE_DIR
  15. #     KICAD_LIBRARY
  16. find_package( KICAD 1.0 REQUIRED )
  18. # add the kicad include directory to the compiler's search path
  19. include_directories( ${KICAD_INCLUDE_DIR}/kicad )
  21. # create a plugin named s3d_plugin_demo1
  22. add_library( s3d_plugin_demo1 MODULE
  23.     src/s3d_plugin_demo1.cpp
  24.     )
  26. _EOF

The first demo project is very basic; it consists of a single file with no external link dependencies other than the compiler defaults. We start by creating a source directory:

  1. cd ${DEMO_ROOT}
  2. mkdir src && cd src
  3. export DEMO_SRC=${PWD}

Now we create the plugin source itself:

s3d_plugin_demo1.cpp

  1. #include <iostream>
  3. // the 3d_plugin.h header defines the functions required of 3D plugins
  4. #include "plugins/3d/3d_plugin.h"
  6. // define the version information of this plugin; do not confuse this
  7. // with the Plugin Class version which is defined in 3d_plugin.h
  8. #define PLUGIN_3D_DEMO1_MAJOR 1
  9. #define PLUGIN_3D_DEMO1_MINOR 0
  10. #define PLUGIN_3D_DEMO1_PATCH 0
  11. #define PLUGIN_3D_DEMO1_REVNO 0
  13. // implement the function which provides users with this plugin's name
  14. const char* GetKicadPluginName( void )
  15. {
  16.     return "PLUGIN_3D_DEMO1";
  17. }
  19. // implement the function which provides users with this plugin's version
  20. void GetPluginVersion( unsigned char* Major, unsigned char* Minor,
  21.     unsigned char* Patch, unsigned char* Revision )
  22. {
  23.     if( Major )
  24.         *Major = PLUGIN_3D_DEMO1_MAJOR;
  26.     if( Minor )
  27.         *Minor = PLUGIN_3D_DEMO1_MINOR;
  29.     if( Patch )
  30.         *Patch = PLUGIN_3D_DEMO1_PATCH;
  32.     if( Revision )
  33.         *Revision = PLUGIN_3D_DEMO1_REVNO;
  35.     return;
  36. }
  38. // number of extensions supported; on *NIX systems the extensions are
  39. // provided twice - once in lower case and once in upper case letters
  40. #ifdef _WIN32
  41.     #define NEXTS 7
  42. #else
  43.     #define NEXTS 14
  44. #endif
  46. // number of filter sets supported
  47. #define NFILS 5
  49. // define the extension strings and filter strings which this
  50. // plugin will supply to the user
  51. static char ext0[] = "wrl";
  52. static char ext1[] = "x3d";
  53. static char ext2[] = "emn";
  54. static char ext3[] = "iges";
  55. static char ext4[] = "igs";
  56. static char ext5[] = "stp";
  57. static char ext6[] = "step";
  59. #ifdef _WIN32
  60. static char fil0[] = "VRML 1.0/2.0 (*.wrl)|*.wrl";
  61. static char fil1[] = "X3D (*.x3d)|*.x3d";
  62. static char fil2[] = "IDF 2.0/3.0 (*.emn)|*.emn";
  63. static char fil3[] = "IGESv5.3 (*.igs;*.iges)|*.igs;*.iges";
  64. static char fil4[] = "STEP (*.stp;*.step)|*.stp;*.step";
  65. #else
  66. static char ext7[] = "WRL";
  67. static char ext8[] = "X3D";
  68. static char ext9[] = "EMN";
  69. static char ext10[] = "IGES";
  70. static char ext11[] = "IGS";
  71. static char ext12[] = "STP";
  72. static char ext13[] = "STEP";
  74. static char fil0[] = "VRML 1.0/2.0 (*.wrl;*.WRL)|*.wrl;*.WRL";
  75. static char fil1[] = "X3D (*.x3d;*.X3D)|*.x3d;*.X3D";
  76. static char fil2[] = "IDF 2.0/3.0 (*.emn;*.EMN)|*.emn;*.EMN";
  77. static char fil3[] = "IGESv5.3 (*.igs;*.iges;*.IGS;*.IGES)|*.igs;*.iges;*.IGS;*.IGES";
  78. static char fil4[] = "STEP (*.stp;*.step;*.STP;*.STEP)|*.stp;*.step;*.STP;*.STEP";
  79. #endif
  81. // instantiate a convenient data structure for accessing the
  82. // lists of extension and filter strings
  83. static struct FILE_DATA
  84. {
  85.     char const* extensions[NEXTS];
  86.     char const* filters[NFILS];
  88.     FILE_DATA()
  89.     {
  90.         extensions[0] = ext0;
  91.         extensions[1] = ext1;
  92.         extensions[2] = ext2;
  93.         extensions[3] = ext3;
  94.         extensions[4] = ext4;
  95.         extensions[5] = ext5;
  96.         extensions[6] = ext6;
  97.         filters[0] = fil0;
  98.         filters[1] = fil1;
  99.         filters[2] = fil2;
  100.         filters[3] = fil3;
  101.         filters[4] = fil4;
  103. #ifndef _WIN32
  104.         extensions[7] = ext7;
  105.         extensions[8] = ext8;
  106.         extensions[9] = ext9;
  107.         extensions[10] = ext10;
  108.         extensions[11] = ext11;
  109.         extensions[12] = ext12;
  110.         extensions[13] = ext13;
  111. #endif
  112.         return;
  113.     }
  115. } file_data;
  118. // return the number of extensions supported by this plugin
  119. int GetNExtensions( void )
  120. {
  121.     return NEXTS;
  122. }
  124. // return the indexed extension string
  125. char const* GetModelExtension( int aIndex )
  126. {
  127.     if( aIndex < 0 || aIndex >= NEXTS )
  128.         return NULL;
  130.     return file_data.extensions[aIndex];
  131. }
  133. // return the number of filter strings provided by this plugin
  134. int GetNFilters( void )
  135. {
  136.     return NFILS;
  137. }
  139. // return the indexed filter string
  140. char const* GetFileFilter( int aIndex )
  141. {
  142.     if( aIndex < 0 || aIndex >= NFILS )
  143.         return NULL;
  145.     return file_data.filters[aIndex];
  146. }
  148. // return false since this plugin does not provide visualization data
  149. bool CanRender( void )
  150. {
  151.     return false;
  152. }
  154. // return NULL since this plugin does not provide visualization data
  155. SCENEGRAPH* Load( char const* aFileName )
  156. {
  157.     // this dummy plugin does not support rendering of any models
  158.     return NULL;
  159. }

This source file meets all the minimum requirements to implement a 3D plugin. The plugin does not produce any data for rendering models but it can provide KiCad with a list of supported model file extensions and file extension filters to enhance the 3D model file selection dialog. Within KiCad the extension strings are used to select the plugins which may be used to load a specified model; for example, if the plugin is wrl then KiCad will invoke each plugin which claims to support the extension wrl until a plugin returns visualization data. The file filters provided by each plugin are passed to the 3D file selector dialog to improve the browsing UI.

To build the plugin:

  1. cd ${DEMO_ROOT}
  2. # export KICAD_ROOT_DIR if necessary
  3. mkdir build && cd build
  4. cmake .. && make

The plugin will be built but not installed; you must copy the plugin file to KiCad’s plugin directory if you wish to load the plugin.

Advanced 3D Plugin

This tutorial walks the user through the development of a 3D plugin named “PLUGIN_3D_DEMO2”. The purpose of this tutorial is to demonstrate the construction of a very basic scene graph which the KiCad previewer can render. The plugin claims to handle files of type txt. Although the file must exist in order for the cache manager to invoke the plugin, the file contents are not processed by this plugin; instead, the plugin simply creates a scene graph containing a pair of tetrahedra. This tutorial assumes that the first tutorial had been completed and that the CMakeLists.txt and FindKICAD.cmake script files have been created.

Place the new source file in the same directory as the previous tutorial’s source file and we will extend the previous tutorial’s CMakeLists.txt file to build this tutorial. Since this plugin will create a scene graph for KiCad we need to link to KiCad’s scene graph library kicad_3dsg. KiCad’s Scene Graph Library provides a set of classes which can be used to build the Scene Graph Object; the Scene Graph Object is an intermediate data visualization format used by the 3D Cache Manager. All plugins which support model visualization must translate the model data into a scene graph via this library.

The first step is to extend CMakeLists.txt to build this tutorial project:

  1. cd ${DEMO_ROOT}
  2. cat >> CMakeLists.txt << _EOF
  3. add_library( s3d_plugin_demo2 MODULE
  4.     src/s3d_plugin_demo2.cpp
  5.     )
  7. target_link_libraries( s3d_plugin_demo2 ${KICAD_LIBRARY} )
  8. _EOF

Now we change to the source directory and create the source file:

  1. cd ${DEMO_SRC}

s3d_plugin_demo2.cpp

  1. #include <cmath>
  2. // 3D Plugin Class declarations
  3. #include "plugins/3d/3d_plugin.h"
  4. // interface to KiCad Scene Graph Library
  5. #include "plugins/3dapi/ifsg_all.h"
  7. // version information for this plugin
  8. #define PLUGIN_3D_DEMO2_MAJOR 1
  9. #define PLUGIN_3D_DEMO2_MINOR 0
  10. #define PLUGIN_3D_DEMO2_PATCH 0
  11. #define PLUGIN_3D_DEMO2_REVNO 0
  13. // provide the name of this plugin
  14. const char* GetKicadPluginName( void )
  15. {
  16.     return "PLUGIN_3D_DEMO2";
  17. }
  19. // provide the version of this plugin
  20. void GetPluginVersion( unsigned char* Major, unsigned char* Minor,
  21.     unsigned char* Patch, unsigned char* Revision )
  22. {
  23.     if( Major )
  24.         *Major = PLUGIN_3D_DEMO2_MAJOR;
  26.     if( Minor )
  27.         *Minor = PLUGIN_3D_DEMO2_MINOR;
  29.     if( Patch )
  30.         *Patch = PLUGIN_3D_DEMO2_PATCH;
  32.     if( Revision )
  33.         *Revision = PLUGIN_3D_DEMO2_REVNO;
  35.     return;
  36. }
  39. // number of extensions supported
  40. #ifdef _WIN32
  41. #define NEXTS 1
  42. #else
  43. #define NEXTS 2
  44. #endif
  46. // number of filter sets supported
  47. #define NFILS 1
  49. static char ext0[] = "txt";
  51. #ifdef _WIN32
  52. static char fil0[] = "demo (*.txt)|*.txt";
  53. #else
  54. static char ext1[] = "TXT";
  56. static char fil0[] = "demo (*.txt;*.TXT)|*.txt;*.TXT";
  57. #endif
  60. static struct FILE_DATA
  61. {
  62.     char const* extensions[NEXTS];
  63.     char const* filters[NFILS];
  65.     FILE_DATA()
  66.     {
  67.         extensions[0] = ext0;
  68.         filters[0] = fil0;
  70. #ifndef _WIN32
  71.         extensions[1] = ext1;
  72. #endif
  73.         return;
  74.     }
  76. } file_data;
  79. int GetNExtensions( void )
  80. {
  81.     return NEXTS;
  82. }
  85. char const* GetModelExtension( int aIndex )
  86. {
  87.     if( aIndex < 0 || aIndex >= NEXTS )
  88.         return NULL;
  90.     return file_data.extensions[aIndex];
  91. }
  94. int GetNFilters( void )
  95. {
  96.     return NFILS;
  97. }
  100. char const* GetFileFilter( int aIndex )
  101. {
  102.     if( aIndex < 0 || aIndex >= NFILS )
  103.         return NULL;
  105.     return file_data.filters[aIndex];
  106. }
  109. // return true since this plugin can provide visualization data
  110. bool CanRender( void )
  111. {
  112.     return true;
  113. }
  116. // create the visualization data
  117. SCENEGRAPH* Load( char const* aFileName )
  118. {
  119.     // For this demonstration we create a tetrahedron (tx1) consisting
  120.     // of a SCENEGRAPH (VRML Transform) which in turn contains 4
  121.     // SGSHAPE (VRML Shape) objects representing each of the sides of
  122.     // the tetrahedron. Each Shape is associated with a color (SGAPPEARANCE)
  123.     // and a SGFACESET (VRML Geometry->indexedFaceSet). Each SGFACESET is
  124.     // associated with a vertex list (SGCOORDS), a per-vertex normals
  125.     // list (SGNORMALS), and a coordinate index (SGCOORDINDEX). One shape
  126.     // is used to represent each face so that we may use per-vertex-per-face
  127.     // normals.
  128.     //
  129.     // The tetrahedron in turn is a child of a top level SCENEGRAPH (tx0)
  130.     // which has a second SCENEGRAPH child (tx2) which is a transformation
  131.     // of the tetrahedron tx1 (rotation + translation). This demonstrates
  132.     // the reuse of components within the scene graph hierarchy.
  134.     // define the vertices of the tetrahedron
  135.     // face 1: 0, 3, 1
  136.     // face 2: 0, 2, 3
  137.     // face 3: 1, 3, 2
  138.     // face 4: 0, 1, 2
  139.     double SQ2 = sqrt( 0.5 );
  140.     SGPOINT vert[4];
  141.     vert[0] = SGPOINT( 1.0, 0.0, -SQ2 );
  142.     vert[1] = SGPOINT( -1.0, 0.0, -SQ2 );
  143.     vert[2] = SGPOINT( 0.0, 1.0, SQ2 );
  144.     vert[3] = SGPOINT( 0.0, -1.0, SQ2 );
  147.     // create the top level transform; this will hold all other
  148.     // scenegraph objects; a transform may hold other transforms and
  149.     // shapes
  150.     IFSG_TRANSFORM* tx0 = new IFSG_TRANSFORM( true );
  152.     // create the transform which will house the shapes
  153.     IFSG_TRANSFORM* tx1 = new IFSG_TRANSFORM( tx0->GetRawPtr() );
  155.     // add a shape which we will use to define one face of the tetrahedron;
  156.     // shapes hold facesets and appearances
  157.     IFSG_SHAPE* shape = new IFSG_SHAPE( *tx1 );
  159.     // add a faceset; these contain coordinate lists, coordinate indices,
  160.     // vertex lists, vertex indices, and may also contain color lists and
  161.     // their indices.
  163.     IFSG_FACESET* face = new IFSG_FACESET( *shape );
  165.     IFSG_COORDS* cp = new IFSG_COORDS( *face );
  166.     cp->AddCoord( vert[0] );
  167.     cp->AddCoord( vert[3] );
  168.     cp->AddCoord( vert[1] );
  170.     // coordinate indices - note: enforce triangles;
  171.     // in real plugins where it is not necessarily possible
  172.     // to determine which side a triangle is visible from,
  173.     // 2 point orders must be specified for each triangle
  174.     IFSG_COORDINDEX* coordIdx = new IFSG_COORDINDEX( *face );
  175.     coordIdx->AddIndex( 0 );
  176.     coordIdx->AddIndex( 1 );
  177.     coordIdx->AddIndex( 2 );
  179.     // create an appearance; appearances are owned by shapes
  181.     // magenta
  182.     IFSG_APPEARANCE* material = new IFSG_APPEARANCE( *shape);
  183.     material->SetSpecular( 0.1, 0.0, 0.1 );
  184.     material->SetDiffuse( 0.8, 0.0, 0.8 );
  185.     material->SetAmbient( 0.2, 0.2, 0.2 );
  186.     material->SetShininess( 0.2 );
  188.     // normals
  189.     IFSG_NORMALS* np = new IFSG_NORMALS( *face );
  190.     SGVECTOR nval = S3D::CalcTriNorm( vert[0], vert[3], vert[1] );
  191.     np->AddNormal( nval );
  192.     np->AddNormal( nval );
  193.     np->AddNormal( nval );
  195.     //
  196.     // Shape2
  197.     // Note: we reuse the IFSG* wrappers to create and manipulate new
  198.     // data structures.
  199.     //
  200.     shape->NewNode( *tx1 );
  201.     face->NewNode( *shape );
  202.     coordIdx->NewNode( *face );
  203.     cp->NewNode( *face );
  204.     np->NewNode( *face );
  206.     // vertices
  207.     cp->AddCoord( vert[0] );
  208.     cp->AddCoord( vert[2] );
  209.     cp->AddCoord( vert[3] );
  211.     // indices
  212.     coordIdx->AddIndex( 0 );
  213.     coordIdx->AddIndex( 1 );
  214.     coordIdx->AddIndex( 2 );
  216.     // normals
  217.     nval = S3D::CalcTriNorm( vert[0], vert[2], vert[3] );
  218.     np->AddNormal( nval );
  219.     np->AddNormal( nval );
  220.     np->AddNormal( nval );
  221.     // color (red)
  222.     material->NewNode( *shape );
  223.     material->SetSpecular( 0.2, 0.0, 0.0 );
  224.     material->SetDiffuse( 0.9, 0.0, 0.0 );
  225.     material->SetAmbient( 0.2, 0.2, 0.2 );
  226.     material->SetShininess( 0.1 );
  228.     //
  229.     // Shape3
  230.     //
  231.     shape->NewNode( *tx1 );
  232.     face->NewNode( *shape );
  233.     coordIdx->NewNode( *face );
  234.     cp->NewNode( *face );
  235.     np->NewNode( *face );
  237.     // vertices
  238.     cp->AddCoord( vert[1] );
  239.     cp->AddCoord( vert[3] );
  240.     cp->AddCoord( vert[2] );
  242.     // indices
  243.     coordIdx->AddIndex( 0 );
  244.     coordIdx->AddIndex( 1 );
  245.     coordIdx->AddIndex( 2 );
  247.     // normals
  248.     nval = S3D::CalcTriNorm( vert[1], vert[3], vert[2] );
  249.     np->AddNormal( nval );
  250.     np->AddNormal( nval );
  251.     np->AddNormal( nval );
  253.     // color (green)
  254.     material->NewNode( *shape );
  255.     material->SetSpecular( 0.0, 0.1, 0.0 );
  256.     material->SetDiffuse( 0.0, 0.9, 0.0 );
  257.     material->SetAmbient( 0.2, 0.2, 0.2 );
  258.     material->SetShininess( 0.1 );
  260.     //
  261.     // Shape4
  262.     //
  263.     shape->NewNode( *tx1 );
  264.     face->NewNode( *shape );
  265.     coordIdx->NewNode( *face );
  266.     cp->NewNode( *face );
  267.     np->NewNode( *face );
  269.     // vertices
  270.     cp->AddCoord( vert[0] );
  271.     cp->AddCoord( vert[1] );
  272.     cp->AddCoord( vert[2] );
  274.     // indices
  275.     coordIdx->AddIndex( 0 );
  276.     coordIdx->AddIndex( 1 );
  277.     coordIdx->AddIndex( 2 );
  279.     // normals
  280.     nval = S3D::CalcTriNorm( vert[0], vert[1], vert[2] );
  281.     np->AddNormal( nval );
  282.     np->AddNormal( nval );
  283.     np->AddNormal( nval );
  285.     // color (blue)
  286.     material->NewNode( *shape );
  287.     material->SetSpecular( 0.0, 0.0, 0.1 );
  288.     material->SetDiffuse( 0.0, 0.0, 0.9 );
  289.     material->SetAmbient( 0.2, 0.2, 0.2 );
  290.     material->SetShininess( 0.1 );
  292.     // create a copy of the entire tetrahedron shifted Z+2 and rotated 2/3PI
  293.     IFSG_TRANSFORM* tx2 = new IFSG_TRANSFORM( tx0->GetRawPtr() );
  294.     tx2->AddRefNode( *tx1 );
  295.     tx2->SetTranslation( SGPOINT( 0, 0, 2 ) );
  296.     tx2->SetRotation( SGVECTOR( 0, 0, 1 ), M_PI*2.0/3.0 );
  298.     SGNODE* data = tx0->GetRawPtr();
  300.     // delete the wrappers
  301.     delete shape;
  302.     delete face;
  303.     delete coordIdx;
  304.     delete material;
  305.     delete cp;
  306.     delete np;
  307.     delete tx0;
  308.     delete tx1;
  309.     delete tx2;
  311.     return (SCENEGRAPH*)data;
  312. }