/* Возвращает имя класса плагина в виде строки UTF-8 */
char const* GetKicadPluginClass( void );

/* Возвращает информацию о версии API класса плагина */
void GetClassVersion( unsigned char* Major, unsigned char* Minor,
     unsigned char* Patch, unsigned char* Revision );

/*
   Возвращает истину, если реализованная проверка версий в плагине
   определила, что указанный API класса -- совместим.
 */
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()

        # привести неуказанные чатси версии к нулю
        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
# указать имя проекта
project( PLUGIN_DEMO )

# проверить, установлена ли нужная версия CMake со всеми нужными свойствами
cmake_minimum_required( VERSION 2.8.12 FATAL_ERROR )

# указать CMake место для поиска скрипта FindKICAD
set( CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules )

# попытка найти установленные заголовочные файлы и библиотеку KiCad
# и определить переменные:
#     KICAD_INCLUDE_DIR
#     KICAD_LIBRARY
find_package( KICAD 1.0 REQUIRED )

# добавить каталог заголовочных файлов kicad к путям поиска компилятора
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];
}

// возвращает ложь, если плагин не подготовил данные визуализации
bool CanRender( void )
{
    return false;
}

// возвращает NULL пока плагин не подготовит данные визуализации
SCENEGRAPH* Load( char const* aFileName )
{
    // этот примитивный плагин не поддерживает рендеринг никаких моделей
    return NULL;
}

cd ${DEMO_ROOT}
# экспортируйте KICAD_ROOT_DIR, если понадобится
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-плагинов
#include "plugins/3d/3d_plugin.h"
// интерфейс для работы с библиотекой графа сцены из KiCad
#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];
}


// вернёт истину, когда плагин сможет предоставить данные визуализации
bool CanRender( void )
{
    return true;
}


// создание данных визуализации
SCENEGRAPH* Load( char const* aFileName )
{
    // Для этого примера будет создан тетраэдр (tx1), содержащийся в графе
    // сцены SCENEGRAPH (VRML Transform) и состоящий из четырех объектов
    // граней SGSHAPE (VRML Shape) для каждой из его сторон. Каждой грани
    // присваивается цвет (SGAPPEARANCE) и SGFACESET (VRML Geometry->indexedFaceSet).
    // Каждый SGFACESET связывается со списком вершин (SGCOORDS), списком
    // векторов (SGNORMALS) и индексами координат (SGCOORDINDEX). Одна грань
    // используется для представления одной из сторон, так что можно
    // использовать векторы вершин-граней (per-vertex-per-face normals).
    //
    // Этот тетраэдр является дочерним, по отношению к элементу верхнего
    // уровня SCENEGRAPH (tx0), в котором содержится второй дочерний
    // SCENEGRAPH (tx2), который в свою очередь, является результатом
    // преобразования тетраэдра tx1 (поворот + смещение). Этим будет
    // показано как повторно использовать элементы в иерархии графа сцены.

    // объявление вершин тетраэдра
    // face 1: 0, 3, 1
    // face 2: 0, 2, 3
    // face 3: 1, 3, 2
    // face 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 );


    // создание объекта преобразования верхнего уровня; он будет содержать
    // все остальные объекты графов сцены; объект преобразования может
    // содержать дочерние объекты преобразования или грани
    IFSG_TRANSFORM* tx0 = new IFSG_TRANSFORM( true );

    // создать объект преобразования, в котором будут хранится грани
    IFSG_TRANSFORM* tx1 = new IFSG_TRANSFORM( tx0->GetRawPtr() );

    // добавить грань, которая будет служить одной из сторон тетраэдра;
    // грани состоят из набора сторон и атрибутов внешнего вида (appearances)
    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] );

    // индексы координат - примечание: используются треугольники;
    // на практике, плагины, которые не могут определить какая
    // из сторон треугольника будет видна, используют по две точки
    // для каждого треугольника
    IFSG_COORDINDEX* coordIdx = new IFSG_COORDINDEX( *face );
    coordIdx->AddIndex( 0 );
    coordIdx->AddIndex( 1 );
    coordIdx->AddIndex( 2 );

    // определить атрибуты; атрибуты принадлежат грани

    // пурпурный
    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 (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
    };
};

/*
    Эта модель RGB-цвета аналогична модели VRML2.0, где каждому
    цвету присваивается значение в диапазоне [0..1].
 */

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 имеет 3 составляющие (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 для этого объекта
     * или NULL, если объект не имеет родителей (т.е. является
     * объектом преобразования верхнего уровня) или, когда данный
     * объект не связан с SGNODE.
     */
    SGNODE* GetParent( void ) const;

    /**
     * Функция SetParent
     * присваивает родительский SGNODE для данного объекта.
     *
     * @param aParent [входящий] желаемый родитель узла
     * @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
 * это оболочка для совместимости с блоком TRANSFORM из графа сцены VRML
 */

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 );

    /* прочие функции базового класса не показанные здесь */

    /* следующие функции не имеют значения для узлов
       координат и всегда возвращают значение ошибки

        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 );

    /* прочие функции базового класса не показанные здесь */

    /* следующие функции не имеют значения для узла
       индексов координат и всегда возвращают значение ошибки

        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 );

    /* прочие функции базового класса не показанные здесь */

    /* следующие функции не имеют значения для узла
       векторов и всегда возвращают значение ошибки

        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 );

    /* прочие функции базового класса не показанные здесь */

    /* следующие функции не имеют значения для узла
       векторов и всегда возвращают значение ошибки

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

namespace S3D
{
    /**
     * Функция GetLibVersion возвращает информацию о версии
     * библиотеки kicad_3dsg
     */
    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 - должен содержать истину, если нужно перезаписать существующий файл
     * @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
     * с помощью функции IFSG_TRANSFORM::Attach().
     */
    SGLIB_API SGNODE* ReadCache( const char* aFileName, void* aPluginMgr,
        bool (*aTagCheck)( const char*, void* ) );

    /**
     * Функция WriteVRML
     * записывает переданный узел и его дочерние узлы в файл VRML2
     *
     * @param filename - имя файла для записи
     * @param overwrite - должен быть установлен в истину, чтобы перезаписать
     * существующий файл VRML
     * @param aTopNode - указатель на объект SCENEGRAPH, представляющий сцену VRML
     * @param reuse - должен быть установлен в истину, для использования
     * свойств VRML DEF/USE
     * @return true при успешном завершении
     */
    SGLIB_API bool WriteVRML( const char* filename, bool overwrite, SGNODE* aTopNode,
                    bool reuse, bool renameNodes );

    // ПРИМЕЧАНИЕ: следующие функции используются совместно для создания сборки VRML,
    // которая может использовать несколько объектов для каждого SG*-класса.
    // В обычном случае должно быть так:
    // 1) вызов функции 'ResetNodeIndex()' для сброса глобального индекса имен узлов;
    // 2) для каждого указателя модели, полученного с помощью 'S3D_CACHE->Load()',
    //    единожды вызывается 'RenameNodes()'. Таким образом достигают того, чтобы
    //    все узлы, полученные из выходного файла, имели уникальные имена.
    //    Функция RenameNodes() переименовывает полученный узел и все его дочерние
    //    узлы. Связанные узлы остаются без изменений. Использование указателя,
    //    полученного из функции 'S3DCACHE->Load()', позволяет убедиться в том, что
    //    все дочерние узлы, по отношению к последнему, будут иметь уникальные имена;
    // 3) если SG*-дерево создано независимо от S3DCACHE->Load(), то пользователь
    //    должен вызвать RenameNodes() как положено, чтобы обеспечить все узлы
    //    уникальными именами;
    // 4) создать структуру сборки путём создания нового узла IFSG_TRANSFORM, как
    //    полагается для каждого экземпляра компонентов; базовую модель компонента,
    //    возвращаемую функцией S3DCACHE->Load(), можно добавить к данному узлу
    //    IFSG_TRANSFORM с помощью 'AddRefNode()';
    // 5) убедиться, что все новые узлы IFSG_TRANSFORM добавлены в качестве дочерних
    //    к узлу верхнего уровня IFSG_TRANSFORM, подготовив его, таким образом, к
    //    дальнейшему переименованию и записи;
    // 6) вызвать RenameNodes() для узла сборки верхнего уровня;
    // 7) вызвать WriteVRML() в обычном порядке, с параметром renameNodes = false,
    //    чтобы записать всю структуру сборки в один VRML-файл.
    // 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*-класса. Эта функция позволяет безопасно
     * удалять SG*-узлы, не прибегая к связыванию с соответствующей
     * IFSG*-оболочкой.
     */
    SGLIB_API void DestroyNode( SGNODE* aNode );

    // ПРИМЕЧАНИЕ: следующие функции облегчают создание и удаление структур
    // данных для рендеринга

    /**
     * Функция GetModel
     * создаёт представление S3DMODEL для aNode (чистые данные, без преобарзований)
     *
     * @param aNode - узел, который нужно преобразовать в представление S3DMODEL
     * @return - возвращает представление 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 );
};