engine.cpp

#include "engine.h"

// Joined engine code
#include "components.h"
#include "textureLoader.h"

////////////////////////////////////////////////////////////////////////////////
// CORE
////////////////////////////////////////////////////////////////////////////////

using namespace NGcommon;

FWutils::package* NGcommon::MainPackage;
NGcomp::timer* NGcommon::mainTimer;
NGcomp::tracker* NGcommon::valTracker;

namespace{
    array_t<unsigned char>  bBuffer1, bBuffer2; // reserved for file buffers

    typedef array_t<NGcommon::item*> renderStorage_t;
    typedef renderStorage_t* renderStack_t;

    renderStack_t cameraStack;
    renderStack_t lightStack;
    //renderStack_t frameBufferStack;
    //renderStack_t shaderStack;
    renderStack_t renderingStack;

    int sumItemCounter;

    // FUNCTION TABLE FOR RENDERING
    //resloveFX_t function_table[256];

    //inline void setFXtable(int id, f_fetch *pFetch, f_render *pRender, f_delete *pDelete){
    //  function_table[id].pDelete = pDelete;
    //  function_table[id].pFetch = pFetch;
    //  //function_table[id].pInit = pInit;
    //  function_table[id].pRender = pRender;
    //}

    //void buildFXtable(){
    //  for (int i=0; i<256; i++){
    //      setFXtable(i, NULL, NULL, NULL);
    //  }
    //  setFXtable((int)ABT_clear,      fetch_ClearColour,  render_ClearColour, denstroy_ClearColour);
    //  setFXtable((int)ABT_skybox,     fetch_Skybox,       render_Skybox,      denstroy_Skybox);
    //  setFXtable((int)ABT_camera,     fetch_Camera,       render_Camera,      denstroy_Camera);
    //  setFXtable((int)ABT_light,      fetch_Light,        render_Light,       denstroy_Light);

    //  setFXtable((int)ABT_sprite,     fetch_Sprite,       render_Sprite,      denstroy_Sprite);

    //  setFXtable((int)ABT_model_3ds,  fetch_Model3DS,     render_Model,       denstroy_Model3DS);

    //  NGloader::initTextureLoader();
    //}

    renderStack_t* _rendering_queue[] = {
        &cameraStack,
        &lightStack,
        &renderingStack,
        NULL    // MUST end w/ NULL !!!
    };

    /// SHADOWS
    //FWrender::texture *depthMapTexture = NULL;
    bool using_depthmap = false;
    FWrender::fbo *depthMap = NULL;
    FWmodel::sprite *depthSprite = NULL;

    /// FULL SCREEN COLOR MAP for postfx
    bool using_colormap = false;
    FWrender::fbo *frameColorMap = NULL;
    FWmodel::sprite *frameColorSprite = NULL;

    // init fx
    inline void _setupDepthMap(){
        int h = FWrender::getHeight();
        int w = FWrender::getWidth();
        float sx = (float)h/2048.0;
        float sy = (float)w/2048.0;
        depthMap = new FWrender::fbo(0,1,0);    // teszu~

        depthSprite = new FWmodel::sprite();
        depthSprite->setPosMode(0);
        depthSprite->setSize(w, h);
        depthSprite->setTexCoord(sx, 0.0, 0.0, sy);
        depthSprite->setTex(depthMap->getDepthTexture());
    }

    inline void _setupColorMap(){
        int h = FWrender::getHeight();
        int w = FWrender::getWidth();
        float sx = (float)h/2048.0;
        float sy = (float)w/2048.0;

        frameColorMap = new FWrender::fbo(2,1,0);
        //frameColorMap = new FWrender::fbo(1,1,0);

        frameColorSprite = new FWmodel::sprite();
        frameColorSprite->setPosMode(0);
        frameColorSprite->setSize(w, h);
        frameColorSprite->setTexCoord(sx, 0.0, 0.0, sy);
        frameColorSprite->setTex(frameColorMap->getColorTexture(0));
    }

    //////////////////////////////////////////
    NGcommon::drawShader *testshader = NULL;
    FWrender::texture rnd_normal;

    int __seed = 0x9001, __step = 0x1000, __start = 128;
    int __pseudorandom(){
        __start *= __seed;
        __start += __step;
        __start = __start % 256;
        return __start;
    }

#define RANDOM_NORMAL_MAP_SIZE 16

    void __setupshader(){
        //FWtexture::bitmap *bmp = new FWtexture::bitmap(RANDOM_NORMAL_MAP_SIZE,RANDOM_NORMAL_MAP_SIZE,3);
        FWtexture::bitmap *bmp = new FWtexture::bitmap();
        //unsigned char *ptr = bmp->getP();
        //for (int i=0; i<RANDOM_NORMAL_MAP_SIZE*RANDOM_NORMAL_MAP_SIZE; i++) { ptr[i] = (unsigned char)__pseudorandom(); }

        NGcommon::MainPackage->getFile("textures/noise.png", bBuffer1);
        bmp->loadMemImage(bBuffer1.data, bBuffer1.size);

        bBuffer1.clear();

        bmp->genOGLTexture(&rnd_normal);

        testshader = new NGcommon::drawShader("basic_ssao.vert", "ssao.frag");
        testshader->fetch();

        delete bmp;
    }
    //////////////////////////////////////////
    void loaderScreen(float p){
        FWrender::clearScene(p*p,p*p,p,1);
        FWrender::flush();
    }
}

void NGcore::loadPackage(char *filename){
    try {
        MainPackage = new FWutils::package(filename);
    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }

}

void NGcore::init(){
    FWcore::initFw();

    loaderScreen(0.0);

    sumItemCounter = 0;

    // setup rendering stacks
    renderStack_t **activeStackPointer = _rendering_queue;

    while (activeStackPointer[0]){
        activeStackPointer[0][0] = new renderStorage_t;
        activeStackPointer++;
    }

    NGloader::initTextureLoader();

    //buildFXtable();

    try {
        init_ClearColour();

    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }

}

void NGcore::fetchPrecalc(){
    try {
        //////////// LOADER /////////////

        loaderScreen(0.0);

        // Fetch fixed functions
        fetch_ClearColour();

        _setupDepthMap();
        _setupColorMap();

        __setupshader();

        // Fetch rendering stack
        renderStack_t **activeStackPointer = _rendering_queue;

        while (activeStackPointer[0]){
            renderStack_t activeStack = activeStackPointer[0][0];
            int s = activeStack->size;
            for (int i=0; i<s; i++){

                NGcommon::item* actual = activeStack->data[i];
                if (!actual) throw (FW_ERROR_UNKNOWN);
                int tyd = 0; int id = 0;
                actual->get(id, tyd);

                actual->_fetch();
                actual->fetch();

                loaderScreen((float)(i)/(float)(s));
            }

            activeStackPointer++;
        }
    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }
}

void NGcore::play(){
    render_ClearColour();

    mainTimer->play();
    try {
        bool exit = false;
        do{
            valTracker->update();

            render_ClearColour();
            //depthMap->bind();
            //http://stackoverflow.com/questions/2171085/opengl-blending-with-previous-contents-of-framebuffer

            frameColorMap->bind();
            {
                render_ClearColour();

                renderStack_t **activeStackPointer = _rendering_queue;

                while (activeStackPointer[0]){
                    renderStack_t activeStack = activeStackPointer[0][0];

                    // SELECT {RENDER, PROCESS} of the following layers

                    for (int i=0; i<activeStack->size; i++){
                        NGcommon::item* actual = activeStack->data[i];
                        if (!actual) throw (FW_ERROR_UNKNOWN);
                        int tyd = 0; int id = 0;
                        actual->get(id, tyd);

                        // select RENDER OR CALC
                        // RENDER
                        //if (function_table[tyd].pRender) function_table[tyd].pRender((void*) actual);
                        actual->draw();
                    }
                    activeStackPointer++;
                }

                // FLUSH PASS
            }

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//POSTFX
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//SKIP_RENDER:


            //depthMap->unbind();
            frameColorMap->unbind();

            render_ClearColour();

            testshader -> bind();

            frameColorSprite->setTex(0, frameColorMap->getColorTexture(0));
            frameColorSprite->setTex(1, frameColorMap->getColorTexture(1));
            frameColorSprite->setTex(2, frameColorMap->getDepthTexture());
            frameColorSprite->setTex(3, &rnd_normal);

            testshader->getShaderP()->set("tex0", 0);
            testshader->getShaderP()->set("normal", 1);
            testshader->getShaderP()->set("depth", 2);
            testshader->getShaderP()->set("rnm", 3);

            frameColorSprite->draw();
            //depthSprite->draw();
            testshader -> unbind();

////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // END OF RENDER
            FWrender::flush();
            exit = FWcore::peekWndMessage() || mainTimer->getEnd();
            //exit = 1; // TGL DBG

        } while (!exit);
    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }
}

void NGcore::release(){
    if (MainPackage) delete MainPackage;
    try {
        //denstroy_ClearColour();

        renderStack_t **activeStackPointer = _rendering_queue;

        while (activeStackPointer[0]){
            renderStack_t activeStack = activeStackPointer[0][0];

            for (int i=0; i<activeStack->size; i++){
                NGcommon::item* actual = activeStack->data[i];
                if (!actual) throw (FW_ERROR_UNKNOWN);
                int tyd = 0; int id = 0;
                actual->get(id, tyd);

                //if (function_table[tyd].pDelete)
                //  function_table[tyd].pDelete((void*) actual);
                //else

                delete actual;

                activeStack->data[i] = NULL;
            }
            activeStackPointer++;
        }

        _MEMORY_SET_ROW_ renderingStack->clear();

        delete renderingStack;

        NGcomp::releasePlayer();

        _MEMORY_SET_ROW_ bBuffer1.clear();
        //_MEMORY_SET_ROW_ bBuffer2.clear();

        // delete buffer objects
        delete depthMap;
        delete depthSprite;
        delete frameColorMap;
        delete frameColorSprite;

        FWcore::releaseFw(0);
    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }
}

////////////////////////////////////////////////////////////////////////////////
// COMPONENTS
////////////////////////////////////////////////////////////////////////////////
namespace {
    array_t<unsigned char>  bMusic;
}
void NGcomp::setPlayer(char* filename, double bpm, int rpb){
    try {
        if (!MainPackage) throw(NG_ERROR_PACAGE_NOPK);;
        char tmp[256];
        sprintf(tmp,"sfx/%s",filename);
        MainPackage->getFile(tmp,bMusic);
        mainTimer = new NGcomp::timer(bpm, rpb, bMusic.data, bMusic.size);
        //_MEMORY_SET_ROW_ bBuffer1.clear();    // FAIL
        valTracker = new NGcomp::tracker(mainTimer);
    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }
}
void NGcomp::setPlayer(double len, char* filename, double bpm, int rpb){
    try {
        if (!MainPackage) throw (NG_ERROR_PACAGE_NOPK);
        char tmp[256];
        sprintf(tmp,"sfx/%s",filename);
        MainPackage->getFile(tmp,bMusic);
        mainTimer = new NGcomp::timer(len, bpm, rpb, bMusic.data, bMusic.size);
        //_MEMORY_SET_ROW_ bBuffer1.clear();    // FAIL
        valTracker = new NGcomp::tracker(mainTimer);
    } catch (int e){
        MessageBox (HWND_DESKTOP, FWerror::translateMessage(e), "Engine halted", MB_OK | MB_ICONEXCLAMATION);
        FWcore::releaseFw(e);
    }
}

void NGcomp::releasePlayer(){
    _MEMORY_SET_ROW_ bMusic.clear();

    if (valTracker) delete valTracker;
    if (mainTimer) delete mainTimer;
}

void NGcomp::pushStack(void* d){
    item * dd = static_cast<item*> (d);

    // select render stack
    int tyd = 0, id = 0; dd->get(id, tyd);
    array_t<NGcommon::item*>* activeStack;

    switch(tyd) {
        case (int)ABT_camera:
            activeStack = cameraStack;
            break;
        case (int)ABT_light:
            activeStack = lightStack;
            break;
        //case (int)ABT_shader:
        //  activeStack = shaderStack;
        //  break;
        default:
            activeStack = renderingStack;
            break;
    }

    // copy ptr to stack
    _MEMORY_SET_ROW_ activeStack->insert(1);
    int index = activeStack->size-1;

    activeStack->data[index] = dd; //(NGcommon::item*) d;

    sumItemCounter++;
}