void lsNode::MoveThread( lsScene* scn, lsOpenGL* opengl, double delta )
{
#ifdef VORTX_DEBUG_NODES
    cout << "lsNode::MoveThred() ********************************" << endl;
#endif
    
    vector<thread> th;
    lsNode *ptr;
    int threads = 1;
    int tc = 0;
    
    // Threads
    if( scn )
    {
        threads = scn->getThreads();
    } else
    {
        threads = thread::hardware_concurrency() * 2;
    }
    
    // cycle through child and its next nodes
    ptr = getNode_list();
    while( ptr )
    {
        // Add thread
        th.push_back( thread( &lsNode::Move, ptr, scn, opengl, delta ) );
        tc++;
        
        // check our thread count
        if(( tc >= threads )||( ptr->getNext_node() == NULL ))
        {
#ifdef VORTX_DEBUG_NODETHREADS
            // debug
            cout << "lsNode::MoveThread - Thread count : " << tc << endl;
#endif
            // Join and wait
            for( auto &t : th )
            {
                t.join();
            }
            // clean up
            th.clear();
            tc = 0;
        }
        ptr = ptr->getNext_node();
    }
    
    // pass it on
    if( getNode_list() ) getNode_list()->MoveThread( scn, opengl, delta );
    if( getNext_node() ) getNext_node()->MoveThread( scn, opengl, delta );
}

// file : core.h

#ifndef cppThreads_core_h
#define cppThreads_core_h

#include <iostream>
#include <vector>
#include <thread>
#include <mutex>

using namespace std;

/*! Base class
 Used to start some lsThread objects.
 */
class core
{
public:
    core();
    virtual ~core();
    
    void run();
    void logText( const string& val, int tid  );
    
private:
    int nr_threads;
    mutex m;
};


#endif

// file : core.cpp
​
#include "core.h"
#include "lsThread.h"

core::core()
{
    nr_threads = 10;
}

core::~core()
{
}

void core::run()
{
    cout << "########## Start test ##########" << endl;
    
    vector<thread> th;
    lsThread *mt = new lsThread[nr_threads];
    
    //Launch a group of threads
    for( int i = 0; i < nr_threads; ++i )
    {
        mt[i].setTid( i );
        // Shows how to pass args to the start function in lsThread
        th.push_back( thread( &lsThread::start, mt[i], this, 5 ) );
    }
    
    //Join the threads with the main thread which core is running
    for( auto &t : th )
    {
        t.join();
    }
    
    // delete our array of lsThread objects
    delete [] mt;
    cout << "########## End test ##########" << endl;
}

/*! Logging
 This function is here so its in a common thread for all other threads to call.
 Remember in a real world App you would make a better logger.
 */
void core::logText( const string& val, int tid )
{
    // Lock for output
    m.lock();
    cout << "Thread : " << tid << " - " << val << endl;
    m.unlock();
}

// file : lsThread.h
​
#ifndef cppThreads_lsThread_h
#define cppThreads_lsThread_h

#include <iostream>
#include <thread>
#include <vector>

class core;

using namespace std;

/*! Thread class
 Nothing special about this class, you could thread any class.
 */
class lsThread
{
public:
    lsThread();
    virtual ~lsThread();
    
    virtual void start( core *c, int val );
    
    void setTid( int val )
    {
        tid = val;
    }
    
private:
    int tid;
    
};


#endif

// File : lsThread.cpp

#include "core.h"
#include "lsThread.h"
#include "lsThread2.h"

lsThread::lsThread()
{
    tid = 0;
}

lsThread::~lsThread()
{
}

void lsThread::start( core *c, int val )
{
    c->logText( "lsThread start", tid );
    
    // Here we create some more threads with a new class, based on the passed value.
    vector<thread> th;
    int nr_threads = val;
    lsThread2 *mt = new lsThread2[nr_threads];
    
    //Launch a group of threads
    for( int i = 0; i < nr_threads; ++i )
    {
        mt[i].setTid( i );
        th.push_back( thread( &lsThread2::start, mt[i], c ) );
    }
    
    // Join the threads with the current thread
    // This could be any of the threads created by the core class.
    for( auto &t : th )
    {
        t.join();
    }
    
    // delete our array of lsThread2 objects.
    delete [] mt;
}

// File : lsThread2.h

#ifndef cppThreads_lsThread2_h
#define cppThreads_lsThread2_h

#include <iostream>
#include <thread>
#include <vector>

class core;

using namespace std;

class lsThread2
{
public:
    lsThread2();
    virtual ~lsThread2();
    
    virtual void start( core *c );
    
    void setTid( int val )
    {
        tid = val;
    }
    
private:
    int tid;
};


#endif

// File : lsThread2.cpp

#include "core.h"
#include "lsThread2.h"


lsThread2::lsThread2()
{
    tid = 0;
}

lsThread2::~lsThread2()
{
}

void lsThread2::start( core *c )
{
    // In this thread we just call the core class logging function
    c->logText( "lsThread2 start", tid );
}

// File : main.cpp

#include "core.h"


int main(int argc, const char * argv[])
{
    // Thread demo
    core *c = new core();
    c->run();
    delete c;
    
    return 0;
}

# vortxEDIT v1.0 by Lee A. Stripp
# Shaders
add_shader light_tex_dn
add_shader quad
add_shader debug
# Assets
add_asset texture data/textures/tech_2_2_d.tga
add_asset texture data/textures/tech_2_2_n.tga
add_asset mesh data/meshes/Cube.vbm
# Controls
add_composite Composite
add_scene Scene
add_object Quad Scene
add_camera Camera Scene
add_pass DR Scene
add_viewer Viewer
add_scene Scene
add_object Scene#Grid Scene
add_camera Camera Scene
add_light point Light Scene
add_object Point#Light#Empty Light
add_object Test#Cube Scene
add_pass FBO Scene
# EOF