/* プラグイン クラス名を UTF-8 文字列で返す */
char const* GetKicadPluginClass( void );

/* プラグイン クラス API に関するバージョン情報を返す */
void GetClassVersion( unsigned char* Major, unsigned char* Minor,
     unsigned char* Patch, unsigned char* Revision );

/*
   プラグインに実装されたバージョンチェックが与えられた
   プラグイン クラス API との互換性を確認できた場合、true を返す
 */
bool CheckClassVersion( unsigned char Major,
    unsigned char Minor, unsigned char Patch, unsigned char Revision );

/* 固有のプラグイン名を返す、(例) "PLUGIN_3D_VRML" */
const char* GetKicadPluginName( void );

/* 固有のプラグインに関するバージョン情報を返す */
void GetPluginVersion( unsigned char* Major, unsigned char* Minor,
     unsigned char* Patch, unsigned char* Revision );

mkdir demo && cd demo
export DEMO_ROOT=${PWD}
mkdir CMakeModules && cd CMakeModules
cat > FindKICAD.cmake << _EOF
find_path( KICAD_INCLUDE_DIR kicad/plugins/kicad_plugin.h
    PATHS ${KICAD_ROOT_DIR}/include $ENV{KICAD_ROOT_DIR}/include
    DOC "Kicad plugins header path."
    )

if( NOT ${KICAD_INCLUDE_DIR} STREQUAL "KICAD_INCLUDE_DIR-NOTFOUND" )

    # sg_version.h からバージョン情報の取得を試みる
    find_file( KICAD_SGVERSION sg_version.h
        PATHS ${KICAD_INCLUDE_DIR}
        PATH_SUFFIXES kicad/plugins/3dapi
        NO_DEFAULT_PATH )

    if( NOT ${KICAD_SGVERSION} STREQUAL "KICAD_SGVERSION-NOTFOUND" )

        # "#define KICADSG_VERSION*" 行を抜き出す
        file( STRINGS ${KICAD_SGVERSION} _version REGEX "^#define.*KICADSG_VERSION.*" )

        foreach( SVAR ${_version} )
            string( REGEX MATCH KICADSG_VERSION_[M,A,J,O,R,I,N,P,T,C,H,E,V,I,S]* _VARNAME ${SVAR} )
            string( REGEX MATCH [0-9]+ _VALUE ${SVAR} )

            if( NOT ${_VARNAME} STREQUAL "" AND NOT ${_VALUE} STREQUAL "" )
                set( _${_VARNAME} ${_VALUE} )
            endif()

        endforeach()

        # NOT SG3D_VERSION* が '0' と評価されることを保証する
        if( NOT _KICADSG_VERSION_MAJOR )
            set( _KICADSG_VERSION_MAJOR 0 )
        endif()

        if( NOT _KICADSG_VERSION_MINOR )
            set( _KICADSG_VERSION_MINOR 0 )
        endif()

        if( NOT _KICADSG_VERSION_PATCH )
            set( _KICADSG_VERSION_PATCH 0 )
        endif()

        if( NOT _KICADSG_VERSION_REVISION )
            set( _KICADSG_VERSION_REVISION 0 )
        endif()

        set( KICAD_VERSION ${_KICADSG_VERSION_MAJOR}.${_KICADSG_VERSION_MINOR}.${_KICADSG_VERSION_PATCH}.${_KICADSG_VERSION_REVISION} )
        unset( KICAD_SGVERSION CACHE )

    endif()
endif()


find_library( KICAD_LIBRARY
    NAMES kicad_3dsg
    PATHS
        ${KICAD_ROOT_DIR}/lib $ENV{KICAD_ROOT_DIR}/lib
        ${KICAD_ROOT_DIR}/bin $ENV{KICAD_ROOT_DIR}/bin
    DOC "Kicad scenegraph library path."
    )

include( FindPackageHandleStandardArgs )
FIND_PACKAGE_HANDLE_STANDARD_ARGS( KICAD
    REQUIRED_VARS
        KICAD_INCLUDE_DIR
        KICAD_LIBRARY
        KICAD_VERSION
    VERSION_VAR KICAD_VERSION )


mark_as_advanced( KICAD_INCLUDE_DIR )
set( KICAD_VERSION_MAJOR ${_KICADSG_VERSION_MAJOR} CACHE INTERNAL "" )
set( KICAD_VERSION_MINOR ${_KICADSG_VERSION_MINOR} CACHE INTERNAL "" )
set( KICAD_VERSION_PATCH ${_KICADSG_VERSION_PATCH} CACHE INTERNAL "" )
set( KICAD_VERSION_TWEAK ${_KICADSG_VERSION_REVISION} CACHE INTERNAL "" )
_EOF

cd ${DEMO_ROOT}
cat > CMakeLists.txt << _EOF
# declare the name of the project
project( PLUGIN_DEMO )

# 必要な機能を全て備えた CMake のバージョンかどうかチェックする
cmake_minimum_required( VERSION 2.8.12 FATAL_ERROR )

# FindKICAD スクリプトがどこにあるか CMake に通知する
set( CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules )

# インストール済の KiCad ヘッダとライブラリを見つけるよう試みる
# そして変数にセットする:
#     KICAD_INCLUDE_DIR
#     KICAD_LIBRARY
find_package( KICAD 1.0 REQUIRED )

# コンパイラの検索パスに KiCad include ディレクトリを追加する
include_directories( ${KICAD_INCLUDE_DIR}/kicad )

# s3d_plugin_demo1 という名前のプラグインを作成する
add_library( s3d_plugin_demo1 MODULE
    src/s3d_plugin_demo1.cpp
    )

_EOF

cd ${DEMO_ROOT}
mkdir src && cd src
export DEMO_SRC=${PWD}

#include <iostream>

//  3d_plugin.h ヘッダに 3D プラグインで必要とされる関数を定義する
#include "plugins/3d/3d_plugin.h"

// このプラグインのバージョン情報を定義する; 3d_plugin.h で定義されている
// プラ??グイン クラス バージョンと混同しないでください
#define PLUGIN_3D_DEMO1_MAJOR 1
#define PLUGIN_3D_DEMO1_MINOR 0
#define PLUGIN_3D_DEMO1_PATCH 0
#define PLUGIN_3D_DEMO1_REVNO 0

// このプラグイン名をユーザーに提供する関数を実装する
const char* GetKicadPluginName( void )
{
    return "PLUGIN_3D_DEMO1";
}

// このプラグインのバージョンをユーザに提供する関数を実装する
void GetPluginVersion( unsigned char* Major, unsigned char* Minor,
    unsigned char* Patch, unsigned char* Revision )
{
    if( Major )
        *Major = PLUGIN_3D_DEMO1_MAJOR;

    if( Minor )
        *Minor = PLUGIN_3D_DEMO1_MINOR;

    if( Patch )
        *Patch = PLUGIN_3D_DEMO1_PATCH;

    if( Revision )
        *Revision = PLUGIN_3D_DEMO1_REVNO;

    return;
}

// サポートされている拡張子の数; *NIX システムでは拡張子が
// 倍になります - 一つは小文字、もう一つは大文字です
#ifdef _WIN32
    #define NEXTS 7
#else
    #define NEXTS 14
#endif

// サポートされているフィルタ セットの数
#define NFILS 5

// このプラグインがユーザーに提供するフィルタ文字列と
// 拡張子の文字列を定義する
static char ext0[] = "wrl";
static char ext1[] = "x3d";
static char ext2[] = "emn";
static char ext3[] = "iges";
static char ext4[] = "igs";
static char ext5[] = "stp";
static char ext6[] = "step";

#ifdef _WIN32
static char fil0[] = "VRML 1.0/2.0 (*.wrl)|*.wrl";
static char fil1[] = "X3D (*.x3d)|*.x3d";
static char fil2[] = "IDF 2.0/3.0 (*.emn)|*.emn";
static char fil3[] = "IGESv5.3 (*.igs;*.iges)|*.igs;*.iges";
static char fil4[] = "STEP (*.stp;*.step)|*.stp;*.step";
#else
static char ext7[] = "WRL";
static char ext8[] = "X3D";
static char ext9[] = "EMN";
static char ext10[] = "IGES";
static char ext11[] = "IGS";
static char ext12[] = "STP";
static char ext13[] = "STEP";

static char fil0[] = "VRML 1.0/2.0 (*.wrl;*.WRL)|*.wrl;*.WRL";
static char fil1[] = "X3D (*.x3d;*.X3D)|*.x3d;*.X3D";
static char fil2[] = "IDF 2.0/3.0 (*.emn;*.EMN)|*.emn;*.EMN";
static char fil3[] = "IGESv5.3 (*.igs;*.iges;*.IGS;*.IGES)|*.igs;*.iges;*.IGS;*.IGES";
static char fil4[] = "STEP (*.stp;*.step;*.STP;*.STEP)|*.stp;*.step;*.STP;*.STEP";
#endif

// 拡張子とフィルタ文字列のリストへのアクセスに便利な
// 構造体をインスタンス化する
static struct FILE_DATA
{
    char const* extensions[NEXTS];
    char const* filters[NFILS];

    FILE_DATA()
    {
        extensions[0] = ext0;
        extensions[1] = ext1;
        extensions[2] = ext2;
        extensions[3] = ext3;
        extensions[4] = ext4;
        extensions[5] = ext5;
        extensions[6] = ext6;
        filters[0] = fil0;
        filters[1] = fil1;
        filters[2] = fil2;
        filters[3] = fil3;
        filters[4] = fil4;

#ifndef _WIN32
        extensions[7] = ext7;
        extensions[8] = ext8;
        extensions[9] = ext9;
        extensions[10] = ext10;
        extensions[11] = ext11;
        extensions[12] = ext12;
        extensions[13] = ext13;
#endif
        return;
    }

} file_data;


// このプラグインでサポートされている拡張子の数を返す
int GetNExtensions( void )
{
    return NEXTS;
}

// インデックス化された拡張子文字列を返す
char const* GetModelExtension( int aIndex )
{
    if( aIndex < 0 || aIndex >= NEXTS )
        return NULL;

    return file_data.extensions[aIndex];
}

// このプラグインで提供されるフィルタ文字列の数を返す
int GetNFilters( void )
{
    return NFILS;
}

// インデックス化されたフィルタ文字列を返す
char const* GetFileFilter( int aIndex )
{
    if( aIndex < 0 || aIndex >= NFILS )
        return NULL;

    return file_data.filters[aIndex];
}

// このプラグインは可視化されたデータを提供しないので、false を返す
bool CanRender( void )
{
    return false;
}

// このプラグインは可視化されたデータを提供しないので、NULL を返す
SCENEGRAPH* Load( char const* aFileName )
{
    // this dummy plugin does not support rendering of any models
    return NULL;
}

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

cd ${DEMO_ROOT}
cat >> CMakeLists.txt << _EOF
add_library( s3d_plugin_demo2 MODULE
    src/s3d_plugin_demo2.cpp
    )

target_link_libraries( s3d_plugin_demo2 ${KICAD_LIBRARY} )
_EOF

cd ${DEMO_SRC}

#include <cmath>
// 3D Plugin Class declarations
#include "plugins/3d/3d_plugin.h"
// interface to KiCad Scene Graph Library
#include "plugins/3dapi/ifsg_all.h"

//  このプラグインのバージョン情報
#define PLUGIN_3D_DEMO2_MAJOR 1
#define PLUGIN_3D_DEMO2_MINOR 0
#define PLUGIN_3D_DEMO2_PATCH 0
#define PLUGIN_3D_DEMO2_REVNO 0

// このプラグインの名前を提供する
const char* GetKicadPluginName( void )
{
    return "PLUGIN_3D_DEMO2";
}

// このプラグインのバージョンを提供する
void GetPluginVersion( unsigned char* Major, unsigned char* Minor,
    unsigned char* Patch, unsigned char* Revision )
{
    if( Major )
        *Major = PLUGIN_3D_DEMO2_MAJOR;

    if( Minor )
        *Minor = PLUGIN_3D_DEMO2_MINOR;

    if( Patch )
        *Patch = PLUGIN_3D_DEMO2_PATCH;

    if( Revision )
        *Revision = PLUGIN_3D_DEMO2_REVNO;

    return;
}


// サポートされている拡張子の数
#ifdef _WIN32
#define NEXTS 1
#else
#define NEXTS 2
#endif

// サポートされているフィルタ セットの数
#define NFILS 1

static char ext0[] = "txt";

#ifdef _WIN32
static char fil0[] = "demo (*.txt)|*.txt";
#else
static char ext1[] = "TXT";

static char fil0[] = "demo (*.txt;*.TXT)|*.txt;*.TXT";
#endif


static struct FILE_DATA
{
    char const* extensions[NEXTS];
    char const* filters[NFILS];

    FILE_DATA()
    {
        extensions[0] = ext0;
        filters[0] = fil0;

#ifndef _WIN32
        extensions[1] = ext1;
#endif
        return;
    }

} file_data;


int GetNExtensions( void )
{
    return NEXTS;
}


char const* GetModelExtension( int aIndex )
{
    if( aIndex < 0 || aIndex >= NEXTS )
        return NULL;

    return file_data.extensions[aIndex];
}


int GetNFilters( void )
{
    return NFILS;
}


char const* GetFileFilter( int aIndex )
{
    if( aIndex < 0 || aIndex >= NFILS )
        return NULL;

    return file_data.filters[aIndex];
}


// このプラグインは可視化されたデータを提供するので、true を返す
bool CanRender( void )
{
    return true;
}


// 可視化データを作成する
SCENEGRAPH* Load( char const* aFileName )
{
    // このデモでは、四面体の各面をなす４つの SGSHAPE (VRML Shape)
    // オブジェクトを含んだ SCENEGRAPH (VRML Transform) から構成
    // される四面体 (tx1) を作ります。各 SGSHAPE は色 (SGAPPEARANCE)
    // と SGFACESET (VRML Geometry->indexedFaceSet) を伴います。
    // 各 SGFACESET は vertex list (SGCOORDS)、per-vertex normals
    // list (SGNORMALS) と coordinate index (SGCOORDINDEX) に紐付け
    // られています。
    // 頂点法線と面法線を使えるようにするため、一つのシェイプが各面を表すように
    // 使用されます。
    //
    // 連続した四面体は、四面体 tx1 (rotation + translation) のトランスフォームである
    // ２つ目の子供 SCENEGRAPH (tx2) を持つトップ レベル SCENEGRAPH (tx0) の
    // 子供です。これはシーン グラフ階層内でコンポーネントを再利用する デモとなって
    // います。

    // 四面体の頂点定義
    // 面 1: 0, 3, 1
    // 面 2: 0, 2, 3
    // 面 3: 1, 3, 2
    // 面 4: 0, 1, 2
    double SQ2 = sqrt( 0.5 );
    SGPOINT vert[4];
    vert[0] = SGPOINT( 1.0, 0.0, -SQ2 );
    vert[1] = SGPOINT( -1.0, 0.0, -SQ2 );
    vert[2] = SGPOINT( 0.0, 1.0, SQ2 );
    vert[3] = SGPOINT( 0.0, -1.0, SQ2 );


    // トップ レベル トランスフォームを作成する; これは全ての異なった
    // scenegraph オブジェクトを保持するだろう; あるトランスフォームは
    // 別のトランスフォームとシェイプを保持してもよい
    IFSG_TRANSFORM* tx0 = new IFSG_TRANSFORM( true );

    // シェイプを保持するためのトランスフォームを作成する
    IFSG_TRANSFORM* tx1 = new IFSG_TRANSFORM( tx0->GetRawPtr() );

    // 四面体の一つの面を定義するために用いられるシェイプを追加する;
    // シェイプはファイス セットと外見 (appearance) を保持している
    IFSG_SHAPE* shape = new IFSG_SHAPE( *tx1 );

    // フェイス セットを追加する; これらは、座標リスト、座標位置、
    // 頂点リスト、頂点位置を含み、色のリストとその位置を
    // 含んでもよい

    IFSG_FACESET* face = new IFSG_FACESET( *shape );

    IFSG_COORDS* cp = new IFSG_COORDS( *face );
    cp->AddCoord( vert[0] );
    cp->AddCoord( vert[3] );
    cp->AddCoord( vert[1] );

    // 座標位置 - 注記: 強制的に三角形となる;
    // 実際のプラグインでは、三角形のどちらの面から
    // 見えるかを決定できるようにする必要はなく、
    // 2 点の順番で各三角形を指定しなければならない
    IFSG_COORDINDEX* coordIdx = new IFSG_COORDINDEX( *face );
    coordIdx->AddIndex( 0 );
    coordIdx->AddIndex( 1 );
    coordIdx->AddIndex( 2 );

    // 外見 (appearance) を作成する; 外見 (appearance) はマゼンタ色のシェイプによって

    // 所有される
    IFSG_APPEARANCE* material = new IFSG_APPEARANCE( *shape);
    material->SetSpecular( 0.1, 0.0, 0.1 );
    material->SetDiffuse( 0.8, 0.0, 0.8 );
    material->SetAmbient( 0.2, 0.2, 0.2 );
    material->SetShininess( 0.2 );

    // 法線
    IFSG_NORMALS* np = new IFSG_NORMALS( *face );
    SGVECTOR nval = S3D::CalcTriNorm( vert[0], vert[3], vert[1] );
    np->AddNormal( nval );
    np->AddNormal( nval );
    np->AddNormal( nval );

    //
    // シェイプ2
    // 注記: 新しい構造体を作成して操作するために
    //  IFSG* ラッパーを再利用する
    //
    shape->NewNode( *tx1 );
    face->NewNode( *shape );
    coordIdx->NewNode( *face );
    cp->NewNode( *face );
    np->NewNode( *face );

    // 頂点
    cp->AddCoord( vert[0] );
    cp->AddCoord( vert[2] );
    cp->AddCoord( vert[3] );

    // 位置
    coordIdx->AddIndex( 0 );
    coordIdx->AddIndex( 1 );
    coordIdx->AddIndex( 2 );

    // 法線
    nval = S3D::CalcTriNorm( vert[0], vert[2], vert[3] );
    np->AddNormal( nval );
    np->AddNormal( nval );
    np->AddNormal( nval );
    // 色 (赤)
    material->NewNode( *shape );
    material->SetSpecular( 0.2, 0.0, 0.0 );
    material->SetDiffuse( 0.9, 0.0, 0.0 );
    material->SetAmbient( 0.2, 0.2, 0.2 );
    material->SetShininess( 0.1 );

    //
    // シェイプ3
    //
    shape->NewNode( *tx1 );
    face->NewNode( *shape );
    coordIdx->NewNode( *face );
    cp->NewNode( *face );
    np->NewNode( *face );

    // 頂点
    cp->AddCoord( vert[1] );
    cp->AddCoord( vert[3] );
    cp->AddCoord( vert[2] );

    // 位置
    coordIdx->AddIndex( 0 );
    coordIdx->AddIndex( 1 );
    coordIdx->AddIndex( 2 );

    // 法線
    nval = S3D::CalcTriNorm( vert[1], vert[3], vert[2] );
    np->AddNormal( nval );
    np->AddNormal( nval );
    np->AddNormal( nval );

    // 色 (緑)
    material->NewNode( *shape );
    material->SetSpecular( 0.0, 0.1, 0.0 );
    material->SetDiffuse( 0.0, 0.9, 0.0 );
    material->SetAmbient( 0.2, 0.2, 0.2 );
    material->SetShininess( 0.1 );

    //
    // シェイプ4
    //
    shape->NewNode( *tx1 );
    face->NewNode( *shape );
    coordIdx->NewNode( *face );
    cp->NewNode( *face );
    np->NewNode( *face );

    // 頂点
    cp->AddCoord( vert[0] );
    cp->AddCoord( vert[1] );
    cp->AddCoord( vert[2] );

    // 位置
    coordIdx->AddIndex( 0 );
    coordIdx->AddIndex( 1 );
    coordIdx->AddIndex( 2 );

    // 法線
    nval = S3D::CalcTriNorm( vert[0], vert[1], vert[2] );
    np->AddNormal( nval );
    np->AddNormal( nval );
    np->AddNormal( nval );

    // 色 (青)
    material->NewNode( *shape );
    material->SetSpecular( 0.0, 0.0, 0.1 );
    material->SetDiffuse( 0.0, 0.0, 0.9 );
    material->SetAmbient( 0.2, 0.2, 0.2 );
    material->SetShininess( 0.1 );

    // Z+2 シフトされ、2/3PI 回転した完全な四面体のコピーを作成する
    IFSG_TRANSFORM* tx2 = new IFSG_TRANSFORM( tx0->GetRawPtr() );
    tx2->AddRefNode( *tx1 );
    tx2->SetTranslation( SGPOINT( 0, 0, 2 ) );
    tx2->SetRotation( SGVECTOR( 0, 0, 1 ), M_PI*2.0/3.0 );

    SGNODE* data = tx0->GetRawPtr();

    // ラッパーを削除する
    delete shape;
    delete face;
    delete coordIdx;
    delete material;
    delete cp;
    delete np;
    delete tx0;
    delete tx1;
    delete tx2;

    return (SCENEGRAPH*)data;
}

/*
   シーングラフ クラスのバージョン情報を定義する。
   シーングラフ クラスで使用される全てのクラスは本ヘッダを含む必要があり、
   また互換性を保証するため S3D::GetLibVersion() によって報告される
   バージョンに対してバージョン情報チェックを行わなければならない。
 */

#define KICADSG_VERSION_MAJOR         2
#define KICADSG_VERSION_MINOR         0
#define KICADSG_VERSION_PATCH         0
#define KICADSG_VERSION_REVISION      0

/*
   シーングラフ クラス タイプを定義する; これらのタイプは
   VRML2.0 ノード タイプと密接な関係がある。
 */

namespace S3D
{
    enum SGTYPES
    {
        SGTYPE_TRANSFORM = 0,
        SGTYPE_APPEARANCE,
        SGTYPE_COLORS,
        SGTYPE_COLORINDEX,
        SGTYPE_FACESET,
        SGTYPE_COORDS,
        SGTYPE_COORDINDEX,
        SGTYPE_NORMALS,
        SGTYPE_SHAPE,
        SGTYPE_END
    };
};

/*
    これは、各色が範囲 [0..1] の数を持つ
    VRML2.0 RGB モデルと同等な RGB
    色モデルである。
 */

class SGCOLOR
{
public:
    SGCOLOR();
    SGCOLOR( float aRVal, float aGVal, float aBVal );

    void GetColor( float& aRedVal, float& aGreenVal, float& aBlueVal ) const;
    void GetColor( SGCOLOR& aColor ) const;
    void GetColor( SGCOLOR* aColor ) const;

    bool SetColor( float aRedVal, float aGreenVal, float aBlueVal );
    bool SetColor( const SGCOLOR& aColor );
    bool SetColor( const SGCOLOR* aColor );
};


class SGPOINT
{
public:
    double x;
    double y;
    double z;

public:
    SGPOINT();
    SGPOINT( double aXVal, double aYVal, double aZVal );

    void GetPoint( double& aXVal, double& aYVal, double& aZVal );
    void GetPoint( SGPOINT& aPoint );
    void GetPoint( SGPOINT* aPoint );

    void SetPoint( double aXVal, double aYVal, double aZVal );
    void SetPoint( const SGPOINT& aPoint );
};


/*
    SGVECTOR は点と同じく３つの成分 (x,y,z) を持っています; しかしながら
    ベクトルは保存された値が正規化されていることが保証されており、
    成分の値を直接操作できないようになっています。
 */
class SGVECTOR
{
public:
    SGVECTOR();
    SGVECTOR( double aXVal, double aYVal, double aZVal );

    void GetVector( double& aXVal, double& aYVal, double& aZVal ) const;

    void SetVector( double aXVal, double aYVal, double aZVal );
    void SetVector( const SGVECTOR& aVector );

    SGVECTOR& operator=( const SGVECTOR& source );
};

class IFSG_NODE
{
public:
    IFSG_NODE();
    virtual ~IFSG_NODE();

    /**
     * Destroy 関数
     * このラッパーで保持されているシーングラフ オブジェクトを削除する
     */
    void Destroy( void );

    /**
     * Attach 関数
     * このラッパーに SGNODE* を関連付ける
     */
    virtual bool Attach( SGNODE* aNode ) = 0;

    /**
     * NewNode 関数
     * このラッパーに関連付ける新しいノードを作成する
     */
    virtual bool NewNode( SGNODE* aParent ) = 0;
    virtual bool NewNode( IFSG_NODE& aParent ) = 0;

    /**
     * GetRawPtr() 関数
     * 元々の内部 SGNODE ポインタを返す
     */
    SGNODE* GetRawPtr( void );

    /**
     * GetNodeType 関数
     * このノード インスタンスのタイプを返す
     */
    S3D::SGTYPES GetNodeType( void ) const;

    /**
     * GetParent 関数
     * このオブジェクトの親 SGNODE へのポインタを返す。
     * もしオブジェクトが親を持っていない (例. トップ レベル transform) か、
     * ラッパーが現在の SGNODE と関連付けられていない場合は NULL
     */
    SGNODE* GetParent( void ) const;

    /**
     * SetParent 関数
     * このオブジェクトの親 SGNODE をセットする。
     *
     * @param aParent [in] はセットしたい親ノード
     * @return 関数が成功した場合は true; 与えられた
     * ノードが派生オブジェクトへのペアレントを許されて
     * いない場合は false
     */
    bool SetParent( SGNODE* aParent );

    /**
     * GetNodeTypeName 関数
     * ノード タイプを表すテキストを返す。
     * もし何故かノードが無効なタイプであれば NULL
     */
    const char * GetNodeTypeName( S3D::SGTYPES aNodeType ) const;

    /**
     * AddRefNode 関数
     * このノードが所有していない (子ノードではない)
     * 既存ノードへの参照を追加する。
     *
     * @return 成功した場合は true
     */
    bool AddRefNode( SGNODE* aNode );
    bool AddRefNode( IFSG_NODE& aNode );

    /**
     * AddChildNode 関数
     * このノードが所有する子ノードとして追加する。
     *
     * @return 成功した場合は true
     */
    bool AddChildNode( SGNODE* aNode );
    bool AddChildNode( IFSG_NODE& aNode );
};

/**
 * IFSG_TRANSFORM クラス
 * VRML 互換 TRANSFORM ブロック クラス SCENEGRAPH のラッパー
 */

class IFSG_TRANSFORM : public IFSG_NODE
{
public:
    IFSG_TRANSFORM( bool create );
    IFSG_TRANSFORM( SGNODE* aParent );

    bool SetScaleOrientation( const SGVECTOR& aScaleAxis, double aAngle );
    bool SetRotation( const SGVECTOR& aRotationAxis, double aAngle );
    bool SetScale( const SGPOINT& aScale );
    bool SetScale( double aScale );
    bool SetCenter( const SGPOINT& aCenter );
    bool SetTranslation( const SGPOINT& aTranslation );

    /* いくつかのベース クラス関数はここにありません */
};

/**
 * IFSG_SHAPE クラス
 * SGSHAPE クラスのラッパー
 */

class IFSG_SHAPE : public IFSG_NODE
{
public:
    IFSG_SHAPE( bool create );
    IFSG_SHAPE( SGNODE* aParent );
    IFSG_SHAPE( IFSG_NODE& aParent );

    /* いくつかのベース クラス関数はここにありません */
};

class IFSG_APPEARANCE : public IFSG_NODE
{
public:
    IFSG_APPEARANCE( bool create );
    IFSG_APPEARANCE( SGNODE* aParent );
    IFSG_APPEARANCE( IFSG_NODE& aParent );

    bool SetEmissive( float aRVal, float aGVal, float aBVal );
    bool SetEmissive( const SGCOLOR* aRGBColor );
    bool SetEmissive( const SGCOLOR& aRGBColor );

    bool SetDiffuse( float aRVal, float aGVal, float aBVal );
    bool SetDiffuse( const SGCOLOR* aRGBColor );
    bool SetDiffuse( const SGCOLOR& aRGBColor );

    bool SetSpecular( float aRVal, float aGVal, float aBVal );
    bool SetSpecular( const SGCOLOR* aRGBColor );
    bool SetSpecular( const SGCOLOR& aRGBColor );

    bool SetAmbient( float aRVal, float aGVal, float aBVal );
    bool SetAmbient( const SGCOLOR* aRGBColor );
    bool SetAmbient( const SGCOLOR& aRGBColor );

    bool SetShininess( float aShininess );
    bool SetTransparency( float aTransparency );

    /* いくつかのベース クラス関数はここにありません */

    /* 以下の関数は appearance ノードでは意味がありません。
       また、常に失敗を表すコードを返します。

        bool AddRefNode( SGNODE* aNode );
        bool AddRefNode( IFSG_NODE& aNode );
        bool AddChildNode( SGNODE* aNode );
        bool AddChildNode( IFSG_NODE& aNode );
     */
};

/**
 * IFSG_FACESET クラス
 * SGFACESET クラスのラッパー
 */

class IFSG_FACESET : public IFSG_NODE
{
public:
    IFSG_FACESET( bool create );
    IFSG_FACESET( SGNODE* aParent );
    IFSG_FACESET( IFSG_NODE& aParent );

    bool CalcNormals( SGNODE** aPtr );

    /* いくつかのベース クラス関数はここにありません */
};

/**
 * IFSG_COORDS クラス
 * SGCOORDS のラッパー
 */

class IFSG_COORDS : public IFSG_NODE
{
public:
    IFSG_COORDS( bool create );
    IFSG_COORDS( SGNODE* aParent );
    IFSG_COORDS( IFSG_NODE& aParent );

    bool GetCoordsList( size_t& aListSize, SGPOINT*& aCoordsList );
    bool SetCoordsList( size_t aListSize, const SGPOINT* aCoordsList );
    bool AddCoord( double aXValue, double aYValue, double aZValue );
    bool AddCoord( const SGPOINT& aPoint );

    /* いくつかのベース クラス関数はここにありません */

    /* 以下の関数は coords ノードでは意味がありません。
       また、常に失敗を表すコードを返します。

        bool AddRefNode( SGNODE* aNode );
        bool AddRefNode( IFSG_NODE& aNode );
        bool AddChildNode( SGNODE* aNode );
        bool AddChildNode( IFSG_NODE& aNode );
     */
};

/**
 * IFSG_COORDINDEX クラス
 * SGCOORDINDEX のラッパー
 */

class IFSG_COORDINDEX : public IFSG_INDEX
{
public:
    IFSG_COORDINDEX( bool create );
    IFSG_COORDINDEX( SGNODE* aParent );
    IFSG_COORDINDEX( IFSG_NODE& aParent );

    bool GetIndices( size_t& nIndices, int*& aIndexList );
    bool SetIndices( size_t nIndices, int* aIndexList );
    bool AddIndex( int aIndex );

    /* いくつかのベース クラス関数はここにありません */

    /* 以下の関数は coordindex ノードでは意味がありません。
       また、常に失敗を表すコードを返します。

        bool AddRefNode( SGNODE* aNode );
        bool AddRefNode( IFSG_NODE& aNode );
        bool AddChildNode( SGNODE* aNode );
        bool AddChildNode( IFSG_NODE& aNode );
     */
};

/**
 * IFSG_NORMALS クラス
 * SGNORMALS クラスのラッパー
 */

class IFSG_NORMALS : public IFSG_NODE
{
public:
    IFSG_NORMALS( bool create );
    IFSG_NORMALS( SGNODE* aParent );
    IFSG_NORMALS( IFSG_NODE& aParent );

    bool GetNormalList( size_t& aListSize, SGVECTOR*& aNormalList );
    bool SetNormalList( size_t aListSize, const SGVECTOR* aNormalList );
    bool AddNormal( double aXValue, double aYValue, double aZValue );
    bool AddNormal( const SGVECTOR& aNormal );

    /* いくつかのベース クラス関数はここにありません */

    /* 以下の関数は normals ノードでは意味がありません。
       また、常に失敗を表すコードを返します。

        bool AddRefNode( SGNODE* aNode );
        bool AddRefNode( IFSG_NODE& aNode );
        bool AddChildNode( SGNODE* aNode );
        bool AddChildNode( IFSG_NODE& aNode );
     */
};

/**
 * IFSG_COLORS クラス
 * SGCOLORS のラッパー
 */

class IFSG_COLORS : public IFSG_NODE
{
public:
    IFSG_COLORS( bool create );
    IFSG_COLORS( SGNODE* aParent );
    IFSG_COLORS( IFSG_NODE& aParent );

    bool GetColorList( size_t& aListSize, SGCOLOR*& aColorList );
    bool SetColorList( size_t aListSize, const SGCOLOR* aColorList );
    bool AddColor( double aRedValue, double aGreenValue, double aBlueValue );
    bool AddColor( const SGCOLOR& aColor );

    /* いくつかのベース クラス関数はここにありません */

    /* 以下の関数は normals ノードでは意味がありません。
       また、常に失敗を表すコードを返します。

        bool AddRefNode( SGNODE* aNode );
        bool AddRefNode( IFSG_NODE& aNode );
        bool AddChildNode( SGNODE* aNode );
        bool AddChildNode( IFSG_NODE& aNode );
     */
};

namespace S3D
{
    /**
     * GetLibVersion 関数は、kicad_3dsg library の
     * バージョン情報を取得する
     */
    SGLIB_API void GetLibVersion( unsigned char* Major, unsigned char* Minor,
                                  unsigned char* Patch, unsigned char* Revision );

    // SGNODE ポインタから情報を得るための関数
    SGLIB_API S3D::SGTYPES GetSGNodeType( SGNODE* aNode );
    SGLIB_API SGNODE* GetSGNodeParent( SGNODE* aNode );
    SGLIB_API bool AddSGNodeRef( SGNODE* aParent, SGNODE* aChild );
    SGLIB_API bool AddSGNodeChild( SGNODE* aParent, SGNODE* aChild );
    SGLIB_API void AssociateSGNodeWrapper( SGNODE* aObject, SGNODE** aRefPtr );

    /**
     * CalcTriNorm 関数
     * 頂点 p1, p2, p3 で表される三角形の法線ベクトルを返す
     */
    SGLIB_API SGVECTOR CalcTriNorm( const SGPOINT& p1, const SGPOINT& p2, const SGPOINT& p3 );

    /**
     * WriteCache 関数
     * バイナリ キャッシュ ファイルへ SGNODE ツリーを書き込む
     *
     * @param aFileName 書き込まれるファイル名
     * @param overwrite 既存のファイルへ上書きするためには true をセットしなければならない
     * @param aNode 書き込まれるノード ツリー内にあるノードのいずれか
     * @return 成功した場合は true
     */
    SGLIB_API bool WriteCache( const char* aFileName, bool overwrite, SGNODE* aNode,
        const char* aPluginInfo );

    /**
     * ReadCache 関数
     * バイナリ キャッシュ ファイルを読み込み、SGNODE ツリーを作成する
     *
     * @param aFileName 読み込まれるバイナリ キャッシュ ファイル名
     * @return 失敗した場合は NULL、成功した場合はトップ レベル SCENEGRAPH ノードへのポインタ;
     * 必要なら、このノードを IFSG_TRANSFORM::Attach() 関数経由で
     * IFSG_TRANSFORM ラッパーと関連付けることも可能
     */
    SGLIB_API SGNODE* ReadCache( const char* aFileName, void* aPluginMgr,
        bool (*aTagCheck)( const char*, void* ) );

    /**
     * WriteVRML 関数
     * VRML2 ファイルへ与えられたノードとそのサブノートを書き込む
     *
     * @param filename 出力ファイル名
     * @param overwrite 既存の VRML ファイルへ上書きするためには true をセットしなければならない
     * @param aTopNode VRML シーンで表される SCENEGRAPH オブジェクトへのポインタ
     * @param reuse VRML DEF/USE 機能を使用する場合には true をセットしなければならない
     * @return 成功した場合は true
     */
    SGLIB_API bool WriteVRML( const char* filename, bool overwrite, SGNODE* aTopNode,
                    bool reuse, bool renameNodes );

    // 注記: 以下の関数は、モジュールの各 SG* 表現のいろいろなインスタンスで用いられる
    //  VRML アセンブリの作成とともに使用されます。
    // 典型的な使用例:
    // 1. グローバル ノード名のインデックスをリセットするために 'ResetNodeIndex()' を呼ぶ
    // 2. 'S3DCACHE->Load()' で得られた各モデルのポインタに対して、一度 'RenameNodes()' を呼ぶ;
    //    これにより、全てのノードが最終的な出力ファイルで一意的な名前を持つことが保証されます
    //    内部的には、RenameNodes() は与えられたノードと全ての子サブノートをリネームするだけです;
    //    参照されているだけのノードはリネームされないでしょう。'S3DCACHE->Load()' で得られた
    //    ポインタを使うことで、返ってくるノード (トップ ノード) 以外の全てのノードが少なくとも1つのノードの
    //    子供であることが保証されます。このため、全てのノードは一意的な名前を与えられることになります
    // 3. もし SG* ツリーが S3DCACHE->Load() とは無関係に作られたなら、ユーザーは全てのノードが
    //    一意的な名前を持つことを保証できるよう適宜 RenameNodes() を呼ばなければなりません
    // 4. コンポーネントの各インスタンスに対して適切な IFSG_TRANSFORM ノードを新たに作成し、
    //    アセンブリ構造体を作成します; S3DCACHE->Load() が返すコンポーネント ベース モデルは
    //    'AddRefNode()' 経由でこれらの IFSG_TRANSFORM ノードを追加するかも知れません;
    //    正確さを保証するために IFSG_TRANSFORM ノードのオフセット、回転角などをセットします
    // 5. 最終的にノード名を決定して出力するための準備として、全ての新規 IFSG_TRANSFORM ノードが
    //     トップ レベル IFSG_TRANSFORM ノード内で子ノードとして配置されていることを確認します
    // 6. トップ レベル アセンブリ ノード上で RenameNodes() を呼ぶ
    // 7. 一つの VRML ファイルに全てのアセンブリ構造体を書き込むために、
    //    renameNodes = false として、WriteVRML() を呼ぶ
    // 8. アセンブリ出力のためにだけ作られた全ての追加 IFSG_TRANSFORM ラッパーとそれらの下層 SG*
    //    クラスを削除して後始末を行う

    /**
     * ResetNodeIndex 関数
     * グローバル SG* クラス 値をリセットする
     *
     * @param aNode 有効な SGNODE のいずれか
     */
    SGLIB_API void ResetNodeIndex( SGNODE* aNode );

    /**
     * RenameNodes 関数
     * 現在のグローバル SG* クラス値を基にノードと
     * 全ての子ノードをリネームする
     *
     * @param aNode トップ レベル ノード
     */
    SGLIB_API void RenameNodes( SGNODE* aNode );

    /**
     * DestroyNode 関数
     * 与えられた SG* クラス ノードを削除する。この関数は、対応した IFSG*
     * ラッパーに関連付けられたノード以外の SG* ノードを安全に削除すること
     * を可能にします。
     */
    SGLIB_API void DestroyNode( SGNODE* aNode );

    // 注記: 以下の関数は、レンダリング時のデータ構造の生成と破棄を
    // 容易にするためのものです。

    /**
     * GetModel 関数
     * aNode (raw data, no transforms) の S3DMODEL 表現を作成する
     *
     * @param aNode S3DMODEL 表現へと変換されるノード
     * @return 成功した場合は aNode の S3DMODEL 表現、それ以外は NULL
     */
    SGLIB_API S3DMODEL* GetModel( SCENEGRAPH* aNode );

    /**
     * Destroy3DModel 関数
     * S3DMODEL 構造体で使われていたメモリを開放し、構造体へのポインタに
     * NULL をセットする
     */
    SGLIB_API void Destroy3DModel( S3DMODEL** aModel );

    /**
     * Free3DModel 関数
     * S3DMODEL 構造体で内部的に使われていたメモリを開放する
     */
    SGLIB_API void Free3DModel( S3DMODEL& aModel );

    /**
     * Free3DMesh 関数
     * SMESH 構造体で内部的に使われていたメモリを開放する
     */
    SGLIB_API void Free3DMesh( SMESH& aMesh );

    /**
     * New3DModel 関数
     * S3DMODEL 構造体を作成して初期化する
     */
    SGLIB_API S3DMODEL* New3DModel( void );

    /**
     * Init3DMaterial 関数
     * SMATERIAL 構造体を初期化する
     */
    SGLIB_API void Init3DMaterial( SMATERIAL& aMat );

    /**
     * Init3DMesh 関数
     * SMESH 構造体を作成して初期化する
     */
    SGLIB_API void Init3DMesh( SMESH& aMesh );
};