doxygen.h

class ScriptContext
{
public:

    void print( string str );

    NodeGraph* rootGraph( void );

    NodeGraph* current(void);

    void setCurrent( NodeGraph *graph );

    NodeGraphList *selected( void );

    float randomFloat( float min, float max );

    int randomInt( int min, int max );

    void registerFunctionDesc( string decl, string description );

    void registerMacro( string macro, string function );

    int year( void );

    void setYear( int year );
};

class Instance
{
public:

    void print( string str );

    NodeGraph* rootGraph( void );

    float randomFloat( float min, float max );

    int time( void );

    int year( void );
};

class InstanceContext
{
public:

    bool getBooleanForVariable( string name );

    float getValueForVariable( string name );

    string getStringForVariable( string );
};

class IntList
{
public:
    IntList();

    void clear( void );

    void append( int value );

    int at( int i );

    int count( void );
};

class FloatList
{
public:
    FloatList();

    void clear( void );

    void append( float value );

    float at( int i );

    int count( void );
};

class StringList
{
public:
    StringList();

    void clear( void );

    void append( string value );

    string at( int i );

    int count( void );
};

class NodeDescriptor
{
public:

    string path( void );

    string uuid( void );

    string caption( void );
    //string info( void );
};

class NodeDescriptorList
{
    NodeDescriptorList();

    void append( NodeDescriptor &item );

    NodeDescriptor* at( int i );

    int count( void );
};

class Rgb
{
public:

    Rgb();

    Rgb( int red, int green, int blue );

    int red( void );

    int green ( void );

    int blue( void );

    void setRed( int red );

    void setGreen( int green );

    void setBlue( int blue );

    int minComponent();

    int maxComponent();
};

class Terminal
{

public:

    string name( void );

    TerminalList *connectedList( void );

    bool connect( Terminal& connectTo );

    void disconnect( Terminal& disconnectFrom );

    void disconnectAll( void );

    unsigned int inConnectFlags( void );

    unsigned int outConnectFlags( void );
};

class TerminalList
{
    TerminalList();

    void append( Terminal &item );

    Terminal* at( int i );

    int count( void );
};

class Tool
{
public:

    string category( void );

    string uuid( void );

    string caption( void );

    ParameterContainer *paramContainer( NodeGraphList &graphList );

    void execute( NodeGraphList &graphList, ParameterContainer &pc );
};

class ToolList
{
    ToolList();

    void append( Tool &item );

    Tool* at( int i );

    int count( void );
};

class ListParameter
{
    TerminalList();

    void append( string item );

    string at( int i );

    int count( void );
};

class ParameterContainer
{
public:

    string name( void );

    bool getCheckBoxParam( string name );

    void setCheckBoxParam( string name, bool value );

    string getStringParam( string name );

    void setStringParam( string name, string value );

    Rgb* getColorParam( string name );

    void setColorParam( string name, Rgb &value );

    int getListParam( string name );

    string getListParamString( string name );

    void setListParam( string name, int value );

    int getIntParam( string name, int index=0 );

    void setIntParam( string name, int value, int index=0 );

    void setIntGroupParam( std::string name, int value1, int value2, int value3 );

    float getFloatParam( string name, int index=0 );

    void setFloatParam( string name, float value, int index=0 );

    void setFloatGroupParam( string name, float value1, float value2, float value3 );

    string contents( void );

    void addGroupBox( string name, string title );

    void addColorParam( string name, string title, Rgb &rgb );

    void addIntParam( string name, string title, int value, int min, int max );

    void addFloatParam( string name, string title, float value, float min, float max );

    void addListParam( string name, string title, ListParameter &listParameter );

    void addCheckBoxParam( string name, string title, bool defaultValue );

    void addStringParam( string name, string title, string defaultValue );
};

class Image
{
public:
    void save( string );
};

class Tracer
{
public:
    Image* image( void );
};

class Node
{
public:

    string name( void );

    void setName( string );

    int id( void );

    ParameterContainer *paramContainer( void );

    NodeGraph *parentGraph( void );

    NodeGraph *rootGraph( void );

    NodeGraph *toNodeGraph( void );

    NodeDescriptor *descriptor( void );

    TerminalList *terminalList( void );

    Terminal *terminal( string name );
};

class NodeList
{
    NodeList();

    void append( Node &item );

    Node* at( int i );

    int count( void );
};

class NodeGraph : public Node
{
public:

    Node *lastNode( void );

    Node *addNode( string name );

    NodeGraph *addSubGraph( void );

    bool moveNode( Node *node, NodeGraph *dest );

    bool moveNodeGraph( NodeGraph *graph, NodeGraph *dest );

    NodeDescriptorList *availableNodeList( void );

    ToolList *availableToolList( void );

    NodeList *nodeList( void );

    bool contains( string uuid, bool recursive=true );

    NodeList *findNodes( string uuid, bool recursive=true );

    Node *findNode( int id, bool recursive=true );

    Node *findNodeByName( name );

    NodeGraphList *findNodeGraphsByName( string name );

    bool removeNode( Node * );

    Tool* getTool( string uuid );

    Mesh* getMesh( bool recursive=false );

    Vector3 *boundingBoxSize( void );

    Vector3 *boundingBox( int minMax );

    void sortNodes( void );

    void loadObjectTemplate( string templateId, int year=-1, string style="", string tag="", string adjectives="" );

    void loadMaterialTemplate( string templateId );

};

class NodeGraphList
{
    NodeGraphList();

    void append( NodeGraph &item );

    NodeGraph* at( int i );

    int count( void );
};

// ----------------------------------------------------------------------------------------------- Mesh

class TransMatrix
{
public:

    TransMatrix();

    TransMatrix( float scaleX, float scaleY, float scaleZ, float rotX, float rotY, float rotZ, float posX, float posY, float posZ, float pivotX, float pivotY, float pivotZ );
};

class Vector3
{
public:

    Vector3( float x, float y, float z );

    float x( void );

    float y( void );

    float z( void );

    void set(  float x, float y, float z );

    float index( int offset );

    void transform( const TransMatrix& matrix );

    Vector3* transformed( const TransMatrix& matrix );
};

class VertexHandle
{
public:

    VertexHandle( int index );

    uint index( void );
};

class VertexHandleList
{
    VertexHandleList();

    void append( VertexHandle &item );

    VertexHandle* at( int i );

    int count( void );
};

class EdgeHandle
{
public:

    EdgeHandle( int index );

    uint index( void );
};

class FaceHandle
{
public:

    FaceHandle( int index );

    uint index( void );
};

class Mesh
{
public:

    // --- Faces

    FaceHandle *addFace( VertexHandleList *verticesList );

    FaceHandle *addFace( VertexHandle *v0, VertexHandle *v1, VertexHandle *v2 );

    FaceHandle *addFace( VertexHandle *v0, VertexHandle *v1, VertexHandle *v2, VertexHandle *v3 );

    void deleteVertex( VertexHandle *handle, bool deleteIsolatedVertices = false );

    VertexHandleList *face( unsigned int index );

    VertexHandleList *face( FaceHandle& handle );

    Vector3* faceNormal( unsigned int index );

    Vector3* faceNormal( FaceHandle *handle );

    void setFaceNormal( FaceHandle *handle, Vector3 *vertexValue );

    // --- Edges

    VertexHandleList *edge( unsigned int index );

    VertexHandleList *edge( EdgeHandle& handle );

    uint edgeCount( void ) const;

    void deleteEdge( EdgeHandle *handle, bool deleteIsolatedVertices = false );

    // --- Vertices

    VertexHandle *addVertex( Vector3 *vertexValue );

    void setVertex( VertexHandle *handle, Vector3 *vertexValue );

    void setVertexNormal( VertexHandle *handle, Vector3 *vertexValue );

    void deleteVertex( VertexHandle *handle, bool deleteIsolatedVertices = false );

    uint vertexCount( void ) const;

    Vector3* vertex( unsigned int index );

    Vector3* vertex( VertexHandle *handle );

    Vector3* vertexNormal( unsigned int index );

    Vector3* vertexNormal( VertexHandle *handle );

    int materialId( int face_idx );

    int materialsCount( void );

    void setMaterialId( int face_idx, int matId );

    void removeMaterial( int matId );

    int textureId( int face_idx );

    int texturesCount( void );

    void setTextureId( int face_idx, int texId );

    void removeTexture( int texId );

    void collectGarbage( void );

    void deleteIsolatedVertices( void );

    void update( void );

    void updateNormals(bool updateFace = true, bool updateVertex = true);


    void subtract( Mesh *second_arg, bool reorient, float tolerance );
};