random_racer/src/VRSTerrainLoader.cpp

Go to the documentation of this file.

#include <assert.h>
#include <stdio.h>

#include <iostream>

#include <vrs/box.h>
#include <vrs/container/dataiterator.h>
#include <vrs/mesh.h>
#include <vrs/sg/scenething.h>
#include <vrs/translation.h>

#include "MeshBeautifier.h"
#include "TerrainGenerator.h"
#include "ControlPointContainer.h"

#include "VRSTerrainLoader.h"

using namespace VRS;

// #define RR_DEBUG_LOADER_THREADING


namespace random_racer
{

VRSTerrainLoader::VRSTerrainLoader(
    SO<SceneThing> p_thing,
    SO<ControlPointContainer> p_container,
    double p_boxSize,
    double p_viewSize) :  TerrainLoader(p_thing, p_boxSize, p_viewSize)
{
    assert(sizeof(m_terrainCache) == 4*sizeof(TerrainPart));

    const unsigned int levelOfDetail = 64;


    m_thing->clear();

    m_translation = new Translation((m_viewSize/-2.0), 0.0, (m_viewSize/-2.0));

    m_vertexIter    = new DataIterator<Vector>();
    m_textureIter   = new DataIterator<Vector>();
    m_colorIter     = new DataIterator<Color>();

    m_generator = new TerrainGenerator(
        p_container, m_viewSize, 32.0, levelOfDetail);

    m_generator->generate(0.0, 0.0, &(m_vertexIter->data));

    m_beautifier = new MeshBeautifier(
                        this,
                        p_container->minHeight(),
                        p_container->maxHeight());

    m_mesh = new Mesh(levelOfDetail, levelOfDetail, m_vertexIter);

    m_thing->append(m_translation);

    m_beautifier->initializeSceneThing(m_thing);

    beautifyMesh();

    m_mesh->setColorIterator(m_colorIter);
    m_mesh->setTextureIterator(m_textureIter);


    m_thing->append(m_mesh);    


    m_terminateWorker   = false;

    m_signalWhenDoneWith= -2;
    m_workerIsWaiting   = false;

    m_vertexMutex       = SDL_CreateMutex();
    m_controlMutex      = SDL_CreateMutex();
    m_generateWakeMutex = SDL_CreateMutex();

    m_replaceWakeCond   = SDL_CreateCond();
    m_generateWakeCond  = SDL_CreateCond();

    assert(m_vertexMutex != NULL);
    assert(m_controlMutex != NULL && m_generateWakeMutex != NULL);
    assert(m_replaceWakeCond != NULL && m_generateWakeCond != NULL);


    m_worker = SDL_CreateThread(&VRSTerrainLoader::workerWrapper, this);
    assert(m_worker != NULL);


    for(;;)
    {
        SDL_LockMutex(m_generateWakeMutex);

        if(m_workerIsWaiting)
            break;

        SDL_UnlockMutex(m_generateWakeMutex);

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "worker not yet waiting (postCtor)" << std::endl;
#endif
    }

#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "SIGNALING worker (postCtor)" << std::endl;
#endif

    SDL_UnlockMutex(m_generateWakeMutex);
    SDL_CondSignal(m_generateWakeCond);
}



void
VRSTerrainLoader::replaceTerrain(
    const Vector& p_position, const Vector& p_center)
{
#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "replaceTerrain()" << std::endl
              << "  p_position: " << p_position << std::endl
              << "  diff: " << (p_position - m_position) << std::endl;
#endif


    unsigned int nearest;
    bool indexIsDone;


    SDL_LockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "locked m_controlMutex" << std::endl;
#endif


    nearest = nearestIndex(
                     p_position[0], p_position[2], m_terrainCache, 4);

    indexIsDone = m_terrainCache[nearest].isDone;


#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "nearest is " << nearest << " and it is ";
#endif


    if(!indexIsDone)
    {
#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "NOT done" << std::endl
                  << "waiting..." << std::endl;
#endif
        m_signalWhenDoneWith = nearest; // WAKE ME IF WHAT I NEED IS DONE

        SDL_CondWait(m_replaceWakeCond, m_controlMutex);

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "ok, i'm back" << std::endl;
#endif
    }
    else
    {
#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "DONE" << std::endl
                  << "continuing" << std::endl;
#endif
        m_signalWhenDoneWith = -1; // YOU CAN STOP NOW. GENERATE AGAIN
    }


    Vector translate;

    translate[0] = m_terrainCache[nearest].x - (m_viewSize/2.0);
    translate[1] = 0.0;
    translate[2] = m_terrainCache[nearest].y - (m_viewSize/2.0);


    lock();

    m_translation->setTranslate(translate);

    // replace the old vertices with the new ones (COPY)
    m_vertexIter->data = m_terrainCache[nearest].points;

    unlock();


#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "COPIED the points" << std::endl;
#endif


    // recalculate the cached terrains with the new position
    m_position = p_center;

    
    if(!indexIsDone || m_workerIsWaiting)
    {
        SDL_UnlockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "UNlocked m_controlMutex" << std::endl
                  << "waking the worker" << std::endl;
#endif

        for(;;)
        {
            SDL_LockMutex(m_generateWakeMutex);

            if(m_workerIsWaiting)
                break;

            SDL_UnlockMutex(m_generateWakeMutex);

#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << "worker not yet waiting (replaceTerrain)" << std::endl;
#endif
        }

        m_signalWhenDoneWith = -2; // WORK NORMALY NOW PLZ

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "SIGNALING worker (replaceTerrain)" << std::endl;
#endif

        SDL_UnlockMutex(m_generateWakeMutex);
        SDL_CondSignal(m_generateWakeCond);
    }
    else
    {
        SDL_UnlockMutex(m_controlMutex);

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "BEST CASE" << std::endl
                  << "UNlocked m_controlMutex" << std::endl;
#endif
    }    


    beautifyMesh();

#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "DONE" << std::endl;
#endif

}

int
VRSTerrainLoader::workerWrapper(void* p_self)
{
    return ((VRSTerrainLoader*)p_self)->generate();
}

int
VRSTerrainLoader::generate()
{
#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "\tworker started" << std::endl;
#endif

    // used to remember if we have to wake replaceTerrain()
    // or if we did so already
    enum {SIGNAL, GOTO, CONTINUE} loopResult = CONTINUE;

    // half boxsize
    double h = m_boxSize*0.5;


    SDL_LockMutex(m_generateWakeMutex);
#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "\tlocked m_generateWakeMutex" << std::endl;
#endif


    // the thread loop
    for(;;)
    {
        if(loopResult != GOTO)
        {
            SDL_LockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << "\tlocked m_controlMutex for waiting = true"
                      << std::endl;
#endif

            m_workerIsWaiting = true;

            SDL_UnlockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << "\tUNlocked m_controlMutex" << std::endl;
#endif


#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << "\twaiting..." << std::endl;
#endif
            SDL_CondWait(m_generateWakeCond, m_generateWakeMutex);
        }
        else
            m_signalWhenDoneWith = -2;


        SDL_LockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "\tlocked m_controlMutex for waiting = false" << std::endl;
#endif

        // stop the thread if somebody whishes this
        if(m_terminateWorker)
        {
            SDL_UnlockMutex(m_controlMutex);
            return 1;
        }

        m_workerIsWaiting = false;

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "\ti am awake" << std::endl;
#endif

        // precalculate the terrains positions
        for(unsigned int i = 0; i < 4; i++)
        {
            // FIXME: do this more clever so that the...
            // terrains which are highly propable that we need them
            // will be generated first and then the other ones.

            switch(i)
            {
            // left top
            case 0:
                m_terrainCache[i].x = m_position[0]-h;
                m_terrainCache[i].y = m_position[2]+h;
                break;
            // left bottom
            case 1:
                m_terrainCache[i].x = m_position[0]-h;
                m_terrainCache[i].y = m_position[2]-h;
                break;
            // right bottom
            case 2:
                m_terrainCache[i].x = m_position[0]+h;
                m_terrainCache[i].y = m_position[2]-h;
                break;
            // right top
            case 3:
                m_terrainCache[i].x = m_position[0]+h;
                m_terrainCache[i].y = m_position[2]+h;
                break;
            }

            m_terrainCache[i].isDone = false;
        }

        SDL_UnlockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "\tUNlocked m_controlMutex" << std::endl;
#endif

        loopResult = CONTINUE;

        // now calculate the real terrain data and check after
        // each generation if we can stop now.
        for(unsigned int i = 0; i < 4; i++)
        {
            m_terrainCache[i].points.clear();

            m_generator->generate(
                m_terrainCache[i].x,
                m_terrainCache[i].y,
                &(m_terrainCache[i].points));


            SDL_LockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << "\tlocked m_controlMutex" << std::endl;
#endif

            m_terrainCache[i].isDone = true;


#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << '\t' << i << " is done" << std::endl;
#endif

            if(m_signalWhenDoneWith == -1)
            {
#ifdef RR_DEBUG_LOADER_THREADING
                std::cout << "\tm_signalWhenDoneWith == -1" << std::endl;
#endif
                loopResult = GOTO;

                SDL_UnlockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
                std::cout << "\tUNlocked m_controlMutex" << std::endl;
#endif
                break;
            }
            else if(m_signalWhenDoneWith >= 0 && m_signalWhenDoneWith <= int(i))
            {
#ifdef RR_DEBUG_LOADER_THREADING
                std::cout << "\tm_signalWhenDoneWith <= i" << std::endl;
#endif
                loopResult = SIGNAL;

                SDL_UnlockMutex(m_controlMutex);
#ifdef RR_DEBUG_LOADER_THREADING
                std::cout << "\tUNlocked m_controlMutex" << std::endl;
#endif
                break;
            }
            else
            {
                SDL_UnlockMutex(m_controlMutex);

#ifdef RR_DEBUG_LOADER_THREADING
                std::cout << "\tm_signalWhenDoneWith ELSE" << std::endl
                          << "\tUNlocked m_controlMutex" << std::endl;
#endif
            }
        }

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "\tDONE" << std::endl;
#endif

        if(loopResult == SIGNAL)
        {
#ifdef RR_DEBUG_LOADER_THREADING
            std::cout << "\ti have to SIGNAL replaceTerrain()" << std::endl;
#endif
            SDL_CondSignal(m_replaceWakeCond);
        }

    }  // for(;;)

    return 0;
}

VRSTerrainLoader::~VRSTerrainLoader()
{
    m_thing->clear();
    // terminate();
}

void
VRSTerrainLoader::beautifyMesh()
{
    m_mesh->setNormalIterator(m_mesh->constructNormalIterator(false, false));

    m_textureIter->data.clear();
    m_colorIter->data.clear();

    m_beautifier->generateColorsAndTexCoords(
        m_vertexIter->data.begin(),
        m_vertexIter->data.end(),
        &(m_textureIter->data),
        &(m_colorIter->data),
        m_translation->getTranslate());
}

void
VRSTerrainLoader::terminate()
{
    for(;;)
    {
        SDL_LockMutex(m_generateWakeMutex);

        if(m_workerIsWaiting)
            break;

        SDL_UnlockMutex(m_generateWakeMutex);

#ifdef RR_DEBUG_LOADER_THREADING
        std::cout << "worker not yet waiting (terminate)" << std::endl;
#endif
    }

#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "SIGNALING worker (terminate)" << std::endl;
#endif

    SDL_LockMutex(m_controlMutex);
    m_terminateWorker = true;
    SDL_UnlockMutex(m_controlMutex);

    SDL_UnlockMutex(m_generateWakeMutex);
    SDL_CondSignal(m_generateWakeCond);


    // this has to be done for freeing the resources of the thread
    SDL_WaitThread(m_worker, NULL);

#ifdef RR_DEBUG_LOADER_THREADING
    std::cout << "WORKER TERMINATED" << std::endl;
#endif
}

VRS::SO<VRS::Mesh>
VRSTerrainLoader::mesh()
{
    return m_mesh;
}

VRS::Vector
VRSTerrainLoader::heightAt(double p_x, double p_z)
{
    double lodSpacing = 8.0;

    VRS::Vector position    = VRS::Vector(p_x, 0, p_z);
    VRS::Vector translation = m_vertexIter->data[0] +
            m_translation->getTranslate();

    position -= translation;

    position[0] = round(position[0] / lodSpacing);
    position[2] = round(position[2] / lodSpacing);


    VRS::Vector result = m_vertexIter->data[(position[2] * 64) + position[0]];
    result += m_translation->getTranslate();

    return result;
}

} // namespace random_racer

---