ir03-main.cpp

//===============================================================================================================//
/*
 * Demo #3
 * Chocolate Cake
 * Indistrial Revlutioners / Experience 2012
 * Caiwan
 *
*/
//===============================================================================================================//

#include <cmath>
#include "engine/csncEngine.h"

using namespace NGcomp;
using namespace NGcore;
using namespace NGcommon;

//#define NO_MIPMAP_FBO
//#define NO_SSAO
//#define NO_HDR_POSTFX

// -----------------------------------------------------
//#global - globalisan mindenre
namespace {
    clearColor *bgnd;
    camera *cam0, *cam1, *cam2;

    light *light0;
}

void play_callback(float time);

// -----------------------------------------------------
//#HDR, #SSAO
namespace {
    drawShader *ssao_prefx, *ssao_postfx, *hdr_postfx;
    FWrender::texture *ssao_rnm;

    //#global shaderek, postfx
    FWrender::fbo *ssaoMap_map, *ssaoMap_map_hdr;
    sprite *ssaoMap_sprite, *ssaoMap_sprite_hdr;

#define RNM_SIZE 16
#define KERNEL_SIZE 32

    vec3float kernels[KERNEL_SIZE];
    //sync
    vtrack *blur_radius, *ssao_radius, *hdr_values;
}

void HDR_SSAO_PostfxInit();
void HDR_SSAO_PostfxSyncInit();
void HDR_SSAO_PostfxDestruct();

// -----------------------------------------------------
//#pottyok
namespace{
    FWmodel::particles *tentacles, *eleje_korok;
    sprite **eleje_feliratok;

    model *eleje_felirat_3d;

    FWtexture::dynTexture *partice_tex[2]; //, *lsd_tex;

    drawShader *calc_particle, *post_particle;

    vtrack *elejeBind;

    vtrack *pBind;
    vtrack *pFade;
    vtrack *pEltol;

    sprite *particleMap_sprite;
}

void particle_Init();
void particle_SyncInit();
void particle_Destruct();

int particle_isActive();
void particle_SkyboxDraw();
void particle_Draw();

int particle_eleje_isActive();
void  particle_eleje_Draw();

// -----------------------------------------------------
//#tunnel
namespace{
    tunnel *cso, *cso1, *cso2;
    drawShader *pointlight, **tunnelShader;

    FWtexture::dynTexture *cso_particle_tex;

#define CSOBE_PARTICLE_DARAB 256

    static struct {
        int index;
        int id;
        vec3float pont;
        // ...
    } csobe_particle_data[CSOBE_PARTICLE_DARAB];

    FWmodel::particles **csobe_particle;
}

void tunnel_Init();
void tunnel_SyncInit();

int tunnel_isActive();
void tunnel_MeshDraw();
void tunnel_FXDraw();

void tunnel_Destruct();
// -----------------------------------------------------
//#overlay
namespace{
}
void overlay_Init();
void overlay_SyncInit();

void overlay_Draw();

// -----------------------------------------------------
//#greetings

namespace{
#include "demo\greetings_Data.h"
    model *greet_kocka;

    pointsprite **greetings_psprite;
    NGcomp::vtrack *greetings_bind;

    drawShader *greet_shader;

#define KOCKAK_SZAMA 4096
#define KOCKAK_HOSSZ 1000

    static struct{
        vec3float pont;
        vec3float tavolsag;
        vec3float szog;
        vec3float szin;
        int sorszam;
    } kockak_data [KOCKAK_SZAMA];
}

void greetings_Init();
void greetings_SyncInit();
void greetings_Destruct();

int greetings_isActive();
void greetings_Draw();
void greetings_SpriteDraw();

namespace{
    void _greetings(FWtexture::bitmap *b, void *params);
}
/*
    ******************************************************************************************
*/

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    init();
    loadPackage("pack.zip");

    /******************************************
     * DEMO INIT
    ******************************************/
    // kamera
    cam0 = new camera("cam0");
    cam0->getP()->setPosMode(FWrender::CAMERA_POS_fix_center);
    cam0->getP()->setCoordMode(FWrender::CAMERA_COORD_polar, FWrender::CAMERA_COORD_descartes);

    cam1 = new camera("cam1");
    cam1->getP()->setPosMode(FWrender::CAMERA_POS_fix_center);
    cam1->getP()->setCoordMode(FWrender::CAMERA_COORD_polar, FWrender::CAMERA_COORD_descartes);

    light0 = new light("light0");

    HDR_SSAO_PostfxInit();
    tunnel_Init();
    particle_Init();
    greetings_Init();
    overlay_Init();

    /******************************************/
    setPlayer("GabrielDream_Rhythm.mp3", 128, 8);
    fetchPrecalc();

    // todo: ezt megbaszni
    /******************************************
    * SETUP VALUE TRACKER
    ******************************************/
    cam0->exportCenter();
    cam0->exportEye();
    cam0->exportRotation();

    cam1->exportCenter();
    cam1->exportEye();
    cam1->exportRotation();

    NGcomp::exportClearColor();

    light0->exportPosition();
    light0->getP()->setColors(.1,.1,.1, .5,.5,.5, 1.,1.,1.);

    HDR_SSAO_PostfxSyncInit();
    tunnel_SyncInit();
    particle_SyncInit();
    greetings_SyncInit();
    overlay_SyncInit();
    /******************************************/
    // mainloop + release
    setPlayerCallback(play_callback);
    play();

    HDR_SSAO_PostfxDestruct();
    tunnel_Destruct();
    particle_Destruct();
    greetings_Destruct();

    release();
}

/******************************************
* DRAW
******************************************/
namespace {
    FWrender::camera *activeCam = NULL;
    FWrender::light *activeLight = NULL;
}

void play_callback(float time){
    FWrender::setProjection();
    FWrender::applyView();

    cam0->draw();   //activeCam = cam0->getP();
    light0->draw(); activeLight = light0->getP();

    NGcommon::render_ClearColour();
//HDR PosztFX
#if 1
    if (greetings_isActive()) // csak aktiv elemekre
    {
        float m[16],
            blurRadiusV = 0.f,
            ssaoRadiusV = 0.f,
            ssaoRadiusF = 0.f,
            ssaoRadiusB = 0.f;

        FWrender::mat_Get(FWrender::MM_PROJECTION, m);

        ssaoMap_map->bind();
        NGcommon::render_ClearColour();

        // draw
        {
            ssao_prefx ->bind();
            //tunnel_MeshDraw();
            greetings_Draw();
            ssao_prefx->unbind();
        }
        ssaoMap_map->unbind();

        // SSAO kiszamol
#if 1
#ifndef NO_SSAO
        ssaoMap_map_hdr->bind();
        NGcommon::render_ClearColour();
        //ssao

        ssao_postfx->bind();
        ssao_postfx->getShaderP()->set("normalTex", (int)1);
        ssao_postfx->getShaderP()->set("depthTex",  (int)3);
        ssao_postfx->getShaderP()->set("noiseTex",  (int)2);

        //const float ssao_radius = 3.f;
        ssaoRadiusV = ssao_radius->getFV()[0] / 100.;
        ssaoRadiusF = ssao_radius->getFV()[1] / 100. + 1.;
        ssaoRadiusB = ssao_radius->getFV()[2] / 1024.;

        ssao_postfx->getShaderP()->set("radius",        ssaoRadiusV);
        ssao_postfx->getShaderP()->set("radius2",       ssaoRadiusV / (800.f*ssaoRadiusF));
        ssao_postfx->getShaderP()->setv("kernel",   3,  KERNEL_SIZE, (float*)kernels);
        ssao_postfx->getShaderP()->set("noiseSize",     (float)RNM_SIZE);

        ssao_postfx->getShaderP()->set("near",          3.f);
        ssao_postfx->getShaderP()->set("far",           800.f);
        ssao_postfx->getShaderP()->set("fov",           (float)((60.f/180.f)*M_PI));
        ssao_postfx->getShaderP()->set("aspectRatio",   16.f/9.f);

        ssao_postfx->getShaderP()->setm4x4("projectionMatrix", m);

        ssaoMap_sprite->draw();

        ssao_postfx->unbind();
        ssaoMap_map_hdr->unbind();
#endif /*NO_SSAO*/
#endif
        FWrender::switchBlend(true);
        // blur + hdr correction
#if 1
        NGcommon::render_ClearColour();
        hdr_postfx->bind();

        blurRadiusV = blur_radius->getF();
        hdr_postfx->getShaderP()->set("blurRadius",     blurRadiusV/1024.f);

        hdr_postfx->getShaderP()->set("SSAORadius",     0.005f + ssaoRadiusB);
        hdr_postfx->getShaderP()->set("illumMapPhong",  (int)1);
        hdr_postfx->getShaderP()->set("illumMapSSAO",   (int)2);

        vec3float hdrVal; hdr_values->getVec3Float(hdrVal);

        hdr_postfx->getShaderP()->set("bias",           1.f+hdrVal.x / 100.f);
        hdr_postfx->getShaderP()->set("bloomLevel",     1.f+hdrVal.y / 100.f);
        hdr_postfx->getShaderP()->set("exposure",       1.f+hdrVal.z / 100.f);

        ssaoMap_sprite_hdr->draw();
        hdr_postfx->unbind();
#else
        ssaoMap_sprite_hdr->draw();
#endif
    greetings_SpriteDraw();
    FWrender::switchBlend(false);
    }
#endif

    // feny ki
    activeLight->unbind(false);

// tunnel
#if 1
    if (tunnel_isActive()){
        tunnel_FXDraw();
    } else
#endif

#if 1
    // tobbi
    if (particle_isActive()){

        ssaoMap_map->bind();

        NGcommon::render_ClearColour();
        {
            particle_SkyboxDraw();
            particle_Draw();
        }

        ssaoMap_map->unbind();

        // postfx
        post_particle->bind();

        post_particle->getShaderP()->set("skybox", (int)1);

        particleMap_sprite->draw();
        post_particle->unbind();
    } else
#endif

        // Particlek
#if 1
    // legeleje
    if (particle_eleje_isActive())
    {
        particle_eleje_Draw();
    }
#endif

// overlay
#if 1
#endif
    overlay_Draw();
}

//=========================================================================//
// other callbacks
// HDR+SSAO
void HDR_SSAO_PostfxInit(){
    // render buffers
#ifndef NO_MIPMAP_FBO
    ssaoMap_map     = new FWrender::fbo(4, 1, 0, true);
    ssaoMap_map_hdr = new FWrender::fbo(2, 1, 0, true);
#else
    ssaoMap_map     = new FWrender::fbo(4, 1, 0, false);
    ssaoMap_map_hdr = new FWrender::fbo(2, 1, 0, false);
#endif
    ssaoMap_sprite = new sprite("postfx");
    ssaoMap_sprite->noBindExport();

    ssaoMap_sprite_hdr = new sprite("ssaoMap_mipmap");
    ssaoMap_sprite_hdr->noBindExport();

    ssaoMap_sprite->setupFullscreenQuad(ssaoMap_map->getFBOTextureSize());
    ssaoMap_sprite_hdr->setupFullscreenQuad(ssaoMap_map->getFBOTextureSize());

    ssaoMap_sprite->getP()->setTex(0, ssaoMap_map->getColorTexture(0));
    ssaoMap_sprite->getP()->setTex(1, ssaoMap_map->getColorTexture(1));
    ssaoMap_sprite->getP()->setTex(3, ssaoMap_map->getColorTexture(2));
    //ssaoMap_sprite->getP()->setTex(3, ssaoMap_map->getDepthTexture());

    ssaoMap_sprite_hdr->getP()->setTex(0, ssaoMap_map    ->getColorTexture(0)); //color map
    ssaoMap_sprite_hdr->getP()->setTex(1, ssaoMap_map    ->getColorTexture(3)); //illum map

    ssaoMap_sprite_hdr->getP()->setTex(2, ssaoMap_map_hdr->getColorTexture(0)); //ssao post-color

    // ssao map and kernel
    ssao_rnm = new FWrender::texture();
    FWtexture::bitmap *ssao_rnm_bmp = new FWtexture::bitmap(RNM_SIZE,RNM_SIZE,4);
    unsigned char *bmp=ssao_rnm_bmp->getP();
    for (int i=0; i<RNM_SIZE*RNM_SIZE*4; i++) bmp[i] = rand()%256;

    ssao_rnm->props.wrap.r = FWrender::TW_REPEAT;
    ssao_rnm->props.wrap.s = FWrender::TW_REPEAT;
    ssao_rnm->props.wrap.t = FWrender::TW_REPEAT;
    ssao_rnm_bmp->genOGLTexture(ssao_rnm);

    delete ssao_rnm_bmp;

    ssaoMap_sprite->getP()->setTex(2, ssao_rnm);

    for(int i=0; i<KERNEL_SIZE; i++) {
        kernels[i].x = 1. - (float)(rand()%10000)/5000.;
        kernels[i].y = 1. - (float)(rand()%10000)/5000.;
        kernels[i].z =      (float)(rand()%10000)/10000.;
        //kernels[i].z = (float)(rand()%1000) / 1000.;
        //kernels[i].z = 1.f;
        kernels[i] /= kernels[i].vlen();
    }

    // shader
    ssao_prefx  = new drawShader("ssao_1",      "basic.vert.c",       "pointlight.frag.c");
    ssao_postfx = new drawShader("ssao_2",      "passthrough.vert.c", "ssao.frag.c");

#ifndef NO_HDR_POSTFX
    hdr_postfx  = new drawShader("hdr_process", "passthrough.vert.c",       "blur2.frag.c");
#else
    hdr_postfx  = new drawShader("hdr_process", "passthrough.vert.c",       "hdr_pass.frag.c");
#endif
}
void HDR_SSAO_PostfxSyncInit(){
    blur_radius = new vtrack("blur", "r", "",    NGcomp::VTT_scalar);
    ssao_radius = new vtrack("ssao", "r", "123", NGcomp::VTT_vec3);
    hdr_values  = new vtrack("hdr",  "v", "ble", NGcomp::VTT_vec3);
}
void HDR_SSAO_PostfxDestruct(){
    if (ssaoMap_map) delete ssaoMap_map;
    if (ssaoMap_map_hdr) delete ssaoMap_map_hdr;
    if (ssao_rnm) delete ssao_rnm;
}

//#tunnel
namespace {
    float tunnel_atmero[] = {25, 75, 100};

#define CSO_DARABOK (sizeof(tunnel_atmero)/sizeof(*tunnel_atmero))
}

void tunnel_Init(){
    FWmath::Spline* spline = NULL; //new FWmath::Spline(nodes, nodesT, sizeof(nodesT)/sizeof(*nodesT)); //nigger

    cso  = new tunnel("cso0", 50, 300, tunnel_atmero[0], 1., spline);
    cso1 = new tunnel("cso1", 50, 300, tunnel_atmero[1], 8., spline);
    cso2 = new tunnel("cso2", 50, 300, tunnel_atmero[2], 8., spline); // takarjon be folddel a siraso azt a jo buzi kurva anyadat te geci

    cso1->noBindExport();
    cso2->noBindExport();

    cso->calculate();
    cso1->calculate();
    cso2->calculate();

    // particlek

    cso_particle_tex = new FWtexture::dynTexture();
    cso_particle_tex->setName("particle3.jpg");
    cso_particle_tex->requestTexture();

    csobe_particle = new FWmodel::particles* [CSO_DARABOK+1];
    for (int i=0; i<CSO_DARABOK+1; ++i){
        csobe_particle[i] = new FWmodel::particles();
        csobe_particle[i]->setTex(cso_particle_tex);
    }

    for(int i=0; i<CSOBE_PARTICLE_DARAB; ++i){
        vec3float pont = FWmath::getRandomVector() * 100; //szelesseg
        vec3float hely = pont; hely.x = 0.;

        pont.x = (-1 + ((float) i / CSOBE_PARTICLE_DARAB) * 2)*300; // hossz

        float tavolsag = hely.vlen();

        int level = 0;
        if (tavolsag >= tunnel_atmero[CSO_DARABOK-1])
            level = CSO_DARABOK;
        else if (tavolsag >= tunnel_atmero[0]){
            for(int j=0; j<CSO_DARABOK - 1; ++j){
                if (tavolsag < tunnel_atmero[j+1] && tavolsag >= tunnel_atmero[j]){
                    level = j+1;
                    break;
                }
            }
        }

        int n = csobe_particle[level]->push();
        csobe_particle[level]->setPos(n, pont);

        csobe_particle[level]->setSize(n, 5);

        csobe_particle_data[i].index = level;
        csobe_particle_data[i].id = n;
        csobe_particle_data[i].pont = pont;
    }

    if (spline) delete spline;

    tunnelShader = new drawShader* [4];

    pointlight      = new drawShader("pointlight",   "basic.vert.c",  "pointlight2.frag.c");
    tunnelShader[0] = new drawShader("tunnelShader", "tunnel.vert.c", "tunnel1.frag.c");
    tunnelShader[1] = new drawShader("tunnelShader", "tunnel.vert.c", "tunnel2.frag.c");
    tunnelShader[2] = new drawShader("tunnelShader", "tunnel.vert.c", "tunnel3.frag.c");
    tunnelShader[3] = new drawShader("tunnelShader", "basic.vert.c",  "particle2.frag.c");
}
void tunnel_SyncInit(){}
int tunnel_isActive(){
    if (cso->isActive())
        return 1;
    else
        return 0;
}
void tunnel_MeshDraw(){
    if (!tunnel_isActive()) return;
    //NGcommon::render_ClearColour();
    //tunnelShader->unbind();

    // nagy budos lofasz van itt kerem :C
}

inline void tunnel_particle(int l){
    tunnelShader[3]->bind();
    csobe_particle[l]->draw();
    tunnelShader[3]->unbind();
}

void tunnel_FXDraw(){
    // tunnel

    // 1. belso cso
    FWrender::switchBlend(true);
    FWrender::setBlend(FWrender::BC_SRC_ALPHA, FWrender::BC_ONE_MINUS_SRC_ALPHA);

    tunnel_particle(3);

    // 3. bgnd
    tunnelShader[0]->bind();
    cso2->bind();

    cso2->draw();
    cso2->unbind();
    tunnelShader[0]->unbind();

    tunnel_particle(2);

    FWrender::clearDepth(1000.);

#if 1
    //FWrender::setDepthMask(false);
    // 2. kulso cso
    tunnelShader[2]->bind();

    cso1->bind();

    cso1->draw();
    cso1->unbind();

    tunnelShader[2]->unbind();

    FWrender::clearDepth(1000.);

    tunnel_particle(1);

    // 1.
    tunnelShader[1]->bind();
    cso->bind();

    cso->draw();
    cso->unbind();

    tunnelShader[1]->unbind();

    //FWrender::setDepthMask(false);
    tunnel_particle(0);
#endif
    FWrender::switchBlend(false);
    FWrender::clearDepth(1000.);
}

void tunnel_Destruct(){}

//#pottyok
namespace {
    // eleje
    const char *eleje_spriteok_neve[] = {
        "cred0", "image_01.jpg", "image_01a.jpg",
        "cred1", "image_02.jpg", "image_02a.jpg",
        "cred2", "image_03.jpg", "image_03a.jpg",
    };

    const unsigned char eleje_sprite_szinek_random[] = {
        0x94, 0x72, 0x6B, 0xFF ,
        0x41, 0x33, 0x30, 0xFF ,
        0x12, 0x0F, 0x0E, 0xFF, //RGBA
    };

    FWmodel::sprite *eleje_sprite_takaro;

#define SZINEK_SZAMA (sizeof(eleje_sprite_szinek_random) / sizeof(*eleje_sprite_szinek_random) / 4)
#define ELEJE_SPRITEOK_DARAB (sizeof(eleje_spriteok_neve)/sizeof(*eleje_spriteok_neve)/3)

    FWtexture::dynTexture *eleje_spriteok_alhpa[ELEJE_SPRITEOK_DARAB];

#define ELEJE_KOROK_DARAB 64

    // vege
#define POTTYOK_DARAB 256
#define POTTYOK_HOSSZ 50

#define POTTYOK_RANDOM_ELTOL 20.
#define POTTYOK_RANDOM_ELTOL_SAV (2. / POTTYOK_HOSSZ)

    struct {
        vec3float irany, maszk;
    } csapok_irany[] = {
        vec3float( 1,  0,  0), vec3float(0, 1, 1),
        vec3float(-1,  0,  0), vec3float(0, 1, 1),
        vec3float( 0,  1,  0), vec3float(1, 0, 1),
        vec3float( 0, -1,  0), vec3float(1, 0, 1),
        vec3float( 0,  0,  1), vec3float(1, 1, 0),
        vec3float( 0,  0, -1), vec3float(1, 1, 0),
    };

#define CSAPOK_AGAK_DARAB (sizeof(csapok_irany) / sizeof(*csapok_irany))
#define CSAPOK_OSSZES_POTYIKE_A_VILAGEGYETEMBEN  (CSAPOK_AGAK_DARAB * POTTYOK_DARAB)

#define CSAPOK_NODE_HOSSZ 16
#define CSAPOK_NODE_SZORAS 11.5

    static struct {
        vec3double *spline_coord;
        double *spline_pos;
        int length;
        FWmath::Spline *spline;
    } splineData [CSAPOK_AGAK_DARAB];

    static struct {
        float ag_pozicio;
        vec3float pozicio;
        vec3float iranyvektor;
        vec3float celpozicio;
        vec3float szin;
        int id;
    } pottyok_data [CSAPOK_OSSZES_POTYIKE_A_VILAGEGYETEMBEN];

    vtrack *elejeScollEltol;

    skybox *csapok_skybox;
    drawShader *csapok_skyboxShader;
}

void particle_Init(){
    partice_tex[0] = new FWtexture::dynTexture();
    partice_tex[0] ->setName("PARTICLE0.JPG");
    partice_tex[0] ->requestTexture();

    partice_tex[1] = new FWtexture::dynTexture();
    partice_tex[1] ->setName("PARTICLE1.JPG");
    partice_tex[1] ->requestTexture();

// elejere lofaszok
    eleje_sprite_takaro = new FWmodel::sprite();
    eleje_sprite_takaro->setSize(2, 2);
    eleje_sprite_takaro->setAlignMode(ORIGN_ALIGN_CENTER_BIT | POS_ALIGN_CENTER_BIT);
    eleje_sprite_takaro->setColor(0.847, 0.803, 0.796);

    eleje_feliratok = new sprite* [ELEJE_SPRITEOK_DARAB];
    for (int i=0; i<ELEJE_SPRITEOK_DARAB; ++i){
        eleje_feliratok[i] = new sprite(eleje_spriteok_neve[3*i+0], eleje_spriteok_neve[3*i+1]);
        eleje_feliratok[i]->noBindExport();

        eleje_spriteok_alhpa[i] = new FWtexture::dynTexture();
        eleje_spriteok_alhpa[i]->setName(eleje_spriteok_neve[3*i+2]);
        eleje_spriteok_alhpa[i]->requestTexture();

        eleje_feliratok[i]->getP()->setTex(1, eleje_spriteok_alhpa[i]);
        //eleje_feliratok[i]->setSize(fullscreen);
        eleje_feliratok[i]->setSize(1);
        eleje_feliratok[i]->setAlignMode(ORIGN_ALIGN_CENTER_BIT | POS_ALIGN_CENTER_BIT);
    }

    // korok
    eleje_korok = new FWmodel::particles();
    eleje_korok->setTex(partice_tex[0]);
    for (int i=0; i<ELEJE_KOROK_DARAB; i++){
        vec3float rv = FWmath::getRandomNormalVector();
        rv *= FWmath::getRandomNormalVector();
        rv *= 50.f;

        vec3float v(rv.x, rv.y, 50 - 50*((float)i / ELEJE_KOROK_DARAB));

        int n= eleje_korok->push();
        eleje_korok->setSize (n, 2);
        eleje_korok->setPos  (n, v);

        int r = rand()%SZINEK_SZAMA;

        FWmath::rgbaCol color(
            eleje_sprite_szinek_random[4*r + 0],
            eleje_sprite_szinek_random[4*r + 1],
            eleje_sprite_szinek_random[4*r + 2],
            eleje_sprite_szinek_random[4*r + 3]
        );
        //FWmath::rgbaCol color(*(unsigned int*)&eleje_sprite_szinek_random[4*r + 0]);
        eleje_korok->setColor(n, color);
    }

    eleje_felirat_3d = new model3ds("title", "title.3ds");
    eleje_felirat_3d->noBindExport();

// tentacles
    tentacles = new FWmodel::particles();
    tentacles->setTex(partice_tex[1]);

    vec3float color1(1., .8, 0.);
    vec3float color2(0., .8, 1.);

    vec3float eltolMesszire, rnd;

    int i, j, k = 0, l, m, n = 0, hossz;
    float u, t, node_pos, node_step = 1./(CSAPOK_NODE_HOSSZ-2);

    for (i=0; i<CSAPOK_AGAK_DARAB; ++i){
        vec3float irany = csapok_irany[i].irany;
        vec3float maszk = csapok_irany[i].maszk , p , pp;

        splineData[i].spline_coord = new vec3double[CSAPOK_NODE_HOSSZ+1];
        splineData[i].spline_pos   = new double[CSAPOK_NODE_HOSSZ+1];
        splineData[i].length = CSAPOK_NODE_HOSSZ+1;

        splineData[i].spline_coord[0].setZero();
        splineData[i].spline_pos[0] = 0.;

        for (j=1; j<CSAPOK_NODE_HOSSZ+1; ++j){
            rnd = FWmath::getRandomVector() * CSAPOK_NODE_SZORAS;

            node_pos = ((float) j * node_step) * POTTYOK_HOSSZ;

            splineData[i].spline_coord[j].x = (double)rnd.x;
            splineData[i].spline_coord[j].y = (double)rnd.y;
            splineData[i].spline_coord[j].z = (double)rnd.z;

            splineData[i].spline_pos[j] = (double)node_pos;
        }

        splineData[i].spline = new FWmath::Spline(splineData[i].spline_coord, splineData[i].spline_pos, CSAPOK_NODE_HOSSZ);

        for (j = 0; j<POTTYOK_DARAB; ++j){
            n = tentacles->push();

            t =  ((float)j / POTTYOK_DARAB);
            u = POTTYOK_HOSSZ * t;

            pp = splineData[i].spline->getVec3Float(u);
            //pp.setZero();
            p = irany * u + pp * maszk;

            tentacles->setPos(n, p);

            pottyok_data[k].ag_pozicio = t;
            pottyok_data[k].pozicio = p;
            pottyok_data[k].id = n;

            eltolMesszire = pottyok_data[k].iranyvektor = FWmath::getRandomNormalVector() * POTTYOK_RANDOM_ELTOL;
            eltolMesszire += p;

            hossz = eltolMesszire.vlen() + FWmath::getRandomNumber() * POTTYOK_RANDOM_ELTOL;
            eltolMesszire /= eltolMesszire.vlen();

            pottyok_data[k].celpozicio = p + eltolMesszire * hossz;

            vec3float c = pottyok_data[k].szin = color2*t + color1*(1.-t);

            tentacles->setColor(n, c.x, c.y, c.z, 1.);

            k++;
        }
    }

    csapok_skybox = new skybox("tentacleSkybox_ejel12_45van", "starfield.jpg\0starfield.jpg\0starfield.jpg\0starfield.jpg\0starfield.jpg\0starfield.jpg\0");
    csapok_skybox->noBindExport();

    // particle postfx
    particleMap_sprite = new sprite("particle_postfx");
    particleMap_sprite->noBindExport();
    particleMap_sprite->setupFullscreenQuad(ssaoMap_map->getFBOTextureSize());

    particleMap_sprite->getP()->setTex(0, ssaoMap_map->getColorTexture(0));
    particleMap_sprite->getP()->setTex(1, ssaoMap_map->getColorTexture(1));

    // shader
    calc_particle = new drawShader("particle1",      "basic.vert.c",       "particle1.frag.c");
    post_particle = new drawShader("particle1_post", "passthrough.vert.c", "particle1_post.frag.c");

    csapok_skyboxShader = new drawShader("particle1_post", "passthrough.vert.c", "skybox.frag.c");
}
void particle_SyncInit(){
    //lsd_tex->requestTexture();

    pBind           = new vtrack("tent", "bind", NULL, VTT_switch);
    pFade           = new vtrack("tent", "fade", NULL, VTT_scalar);
    pEltol          = new vtrack("tent", "eltol", NULL, VTT_scalar);
//  greetings_bind  = new vtrack("greet", "bind", NULL, NGcomp::VTT_bool_switch);

    elejeBind       = new vtrack("eleje", "bind",  NULL, VTT_switch);
    elejeScollEltol = new vtrack("eleje", "eltol", NULL, VTT_scalar);
}

// eleje
int particle_eleje_isActive(){
    if (elejeBind->getB())
        return 1;
    else
        return 0;
}
void  particle_eleje_Draw(){
    if (!particle_eleje_isActive()) return;

    FWrender::switchBlend(true);
    FWrender::setBlend(FWrender::BC_DST_COLOR, FWrender::BC_ONE);
    calc_particle->bind();

    calc_particle->getShaderP()->set("mode", (int)1);
    calc_particle->getShaderP()->set("alphaMap", (int)1);

    eleje_korok->draw();

    cam1->draw();

    FWrender::setBlend(FWrender::BC_SRC_ALPHA, FWrender::BC_ONE_MINUS_SRC_ALPHA);
    eleje_felirat_3d->draw(); // EZ SZAR

    calc_particle->getShaderP()->set("mode", (int)2);

    float eltol = elejeScollEltol->getF();

    for (int i=0; i<ELEJE_SPRITEOK_DARAB; ++i){
        eleje_feliratok[i]->setPosition(0, eltol+(float)i);
        eleje_feliratok[i]->draw();
    }

    calc_particle->getShaderP()->set("mode", (int)1);
    eleje_sprite_takaro->setPos(0, eltol+2.3164);
    eleje_sprite_takaro->draw();

    calc_particle->unbind();
    FWrender::setBlend(FWrender::BC_SRC_ALPHA, FWrender::BC_ONE_MINUS_SRC_ALPHA);
    FWrender::switchBlend(false);
}
int particle_isActive(){
    if (pBind->getB())
        return 1;
    else
        return 0;
}

float inline smooth(float t){
    return t * t * (3 - 2 * t);
}

// tobbi

void particle_SkyboxDraw(){
    if (!particle_isActive()) return;
    csapok_skyboxShader->bind();
    csapok_skybox->draw();
    csapok_skyboxShader->unbind();
}

void particle_Draw(){
    if (!particle_isActive()) return;

    FWrender::setBlend(FWrender::BC_DST_COLOR, FWrender::BC_ONE);
    FWrender::switchBlend(true);

    calc_particle->bind();

    calc_particle->getShaderP()->set("mode", (int)3);

    float trans = pFade->getF();
    float eltolas = pEltol->getF(), eltol_faktor = 0., eltol_hatar = 1.-eltolas, eltol_interpol = smooth(eltolas), t;

    vec3float sz;

    for (int i=0; i<CSAPOK_OSSZES_POTYIKE_A_VILAGEGYETEMBEN; i++){
        int n = pottyok_data[i].id;
        float pos = pottyok_data[i].ag_pozicio;
        float alpha = trans - pos;
        alpha = (alpha<0)? 0. : alpha;
        alpha = (alpha>1)? 1. : alpha;

        sz = pottyok_data[i].szin;

        tentacles->setColor(n, sz.x,sz.y,sz.z, alpha);

        if ((eltolas>0) && (pos > eltol_hatar)){

                eltol_faktor = eltolas - (1.-pos);

                eltol_faktor = (eltol_faktor<0)? 0. : eltol_faktor;
                eltol_faktor = (eltol_faktor>1)? 1. : eltol_faktor;

                t = (eltol_interpol * eltol_faktor) + (eltol_faktor * 1.-eltol_faktor);

                vec3float ujlofasz = (pottyok_data[i].pozicio * 1.-t) + (pottyok_data[i].celpozicio * t);
                tentacles->setPos(n, ujlofasz);
        } else {
            tentacles->setPos(n, pottyok_data[i].pozicio);
        }

    }
    // csapok
    tentacles->draw();

    calc_particle->unbind();

    FWrender::switchBlend(false);
    FWrender::setBlend(FWrender::BC_SRC_ALPHA, FWrender::BC_ONE_MINUS_SRC_ALPHA);
}
void particle_Destruct(){

}

// #Greetings
namespace{
#define KOCKA_MERET 20
    vtrack *griccFeliratBind;
    vtrack *kockakFeny, *kockakMelyikVillog;
}

void greetings_Init(){
    greet_kocka = new model3ds("gricc", "cube10by10.3ds");

    for (int i=0; i<KOCKAK_SZAMA; ++i){
        kockak_data[i].pont.z = 0;
        kockak_data[i].pont.y = 0;
        kockak_data[i].pont.x = ((float)i / KOCKAK_SZAMA) * KOCKAK_HOSSZ;

        vec3float random  = FWmath::getRandomVector() * KOCKA_MERET;
        vec3float random2 = FWmath::getRandomVector() * 360;

        kockak_data[i].tavolsag = random;
        kockak_data[i].szog     = random2;

        kockak_data[i].szin = FWmath::getRandomVector();

        kockak_data[i].szin.x = fabs(kockak_data[i].szin.x);
        kockak_data[i].szin.y = fabs(kockak_data[i].szin.y);
        kockak_data[i].szin.z = fabs(kockak_data[i].szin.z);

        float rnd = fabs(FWmath::getRandomNumber() * 20.);
        int k = (int)rnd;
        kockak_data[i].sorszam = k;
    }

    // greet spriteok
    greetings_psprite = new pointsprite* [GRICC_HOSSZ];

    for (int i=0; i<GRICC_HOSSZ; i++){
        NGloader::textureLoader_pushProcTextureCallback(greetings[2*i], _greetings, greetings[2*i+1]);

        greetings_psprite[i] = new pointsprite(greetings[2*i], greetings[2*i]);
        greetings_psprite[i]->noBindExport();

        greetings_psprite[i]->getP()->setTex(1, ssaoMap_map->getDepthTexture());

        vec3float rnd = FWmath::getRandomVector() * 30;

        float fade = (1. / (float)(GRICC_HOSSZ)) * (float)i; //#define-nel vigyazni kell a ()-re.
        float anyad = fade * KOCKAK_HOSSZ;

        rnd.x += anyad;

        greetings_psprite[i]->getP()->setPos(rnd);
        greetings_psprite[i]->getP()->setSize(25,25);
    }

    greet_shader = new drawShader("greetUtolsoShaderBAZDMEG", "basic.vert.c", "particle3.frag.c");
}

void greetings_SyncInit(){
    greetings_bind     = new vtrack("griccTXT", "bind", NULL, NGcomp::VTT_bool_switch);
    kockakFeny         = new vtrack("kocka", "villog", NULL, NGcomp::VTT_velocity);
    kockakMelyikVillog = new vtrack("kocka", "sor", NULL, NGcomp::VTT_velocity);
}

void greetings_Destruct(){}

int greetings_isActive(){
    if (greet_kocka->isActive()) return 1; else return 0;
}

void greetings_Draw(){
    if (!greetings_isActive()) return;
    // ------------------------------
    // greet_kockak

    int rokagonba = kockakMelyikVillog->getI();
    float cicabogar = kockakFeny->getF();

    ssao_prefx->bind(); // ez nem plight, hanem ssao_shader

    for (int i=0; i<KOCKAK_SZAMA; i+=10){
        if (kockak_data[i].sorszam == rokagonba){
            vec3float a = kockak_data[i].szin;
            ssao_prefx->getShaderP()->set("joreggelt", (float)cicabogar);
            ssao_prefx->getShaderP()->set("color", a.x, a.y, a.z);
        }else {
            ssao_prefx->getShaderP()->set("joreggelt", (float)0.);
        }

        greet_kocka->getGModelView()->identity();

        greet_kocka->getGModelView()->rotate(kockak_data[i].szog.x, 1,0,0);
        greet_kocka->getGModelView()->rotate(kockak_data[i].szog.y, 0,1,0);
        greet_kocka->getGModelView()->rotate(kockak_data[i].szog.z, 0,0,1);

        greet_kocka->getGModelView()->translate(kockak_data[i].pont);
        greet_kocka->getGModelView()->translate(kockak_data[i].tavolsag);

        greet_kocka->draw();
    }
    ssao_prefx->getShaderP()->set("joreggelt", (float)0.);
    ssao_prefx->unbind();
}

void greetings_SpriteDraw(){
    if (!greetings_isActive() || !greetings_bind->getB()) return;
    // ------------------------------
    greet_shader->bind();

    greet_shader->getShaderP()->set("zmap", (int)1);
    for (int i=0; i<GRICC_HOSSZ; i++)
        greetings_psprite[i]->draw();

    greet_shader->unbind();
}

//#overlay
namespace{
    FWmodel::sprite *feherSprite, *feketeSprite;

    FWtexture::dynTexture *kacsaAlpha, *exp12Alpha;

    sprite *kacsa, *exp12;

    vtrack *feherFade, *feketeFade;
    vtrack *kacsaFade;

    FWmodel::particles *vege_particle;

#define VEGE_KOROK_DARAB 128
}

void overlay_Init(){
    feherSprite = new FWmodel::sprite();
    feherSprite->setSize(2, 2);

    feketeSprite = new FWmodel::sprite();
    feketeSprite->setSize(2, 2);
    feketeSprite->setColor(0,0,0); // [s]PIROS!!! [/s] fekete.

    kacsa = new sprite("kacsa",  "duck2.png"),
    exp12 = new sprite("kacsa2", "exp12.png");
    exp12->noBindExport();

    kacsaAlpha = new FWtexture::dynTexture(), exp12Alpha = new FWtexture::dynTexture();
    kacsaAlpha->setName("duck2a.png");
    kacsaAlpha->requestTexture();

    kacsa->getP()->setTex(1, kacsaAlpha);

    exp12Alpha->setName("exp12a.png");
    exp12Alpha->requestTexture();

    exp12->getP()->setTex(1, exp12Alpha);

    kacsa->setAlignMode(POS_ALIGN_CENTER_BIT | ORIGN_ALIGN_CENTER_BIT);
    kacsa->setSize(1.15, 1.15);
    kacsa->setPosition(0, -0.3);

    exp12->setAlignMode(POS_ALIGN_CENTER_BIT | ORIGN_ALIGN_CENTER_BIT | POS_ALIGN_BOTTOM_BIT | ORIGN_ALIGN_BOTTOM_BIT);
    exp12->setSize(.75, .75);

    vege_particle = new FWmodel::particles();

        // korok
    vege_particle = new FWmodel::particles();
    vege_particle->setTex(partice_tex[0]);
    for (int i=0; i<VEGE_KOROK_DARAB; i++){
        vec3float rv = FWmath::getRandomNormalVector();
        rv *= FWmath::getRandomNormalVector();
        rv *= 50.f;

        vec3float v(100 - 200*((float)i / VEGE_KOROK_DARAB), rv.y, rv.z);

        int n= vege_particle->push();
        vege_particle->setSize (n, 2);
        vege_particle->setPos  (n, v);
        vege_particle->setColor(n, 0,0,0,.2);
    }

}

void overlay_SyncInit(){
    feherFade = new vtrack("feher",  "fade", "", VTT_velocity);
    feketeFade= new vtrack("fekete", "fade", "", VTT_velocity);

    kacsaFade = new vtrack("kacsa", "fade", "", VTT_velocity);
}

void overlay_Draw(){
    FWrender::switchBlend(true);
    FWrender::setBlend(FWrender::BC_SRC_ALPHA, FWrender::BC_ONE_MINUS_SRC_ALPHA);

    if (kacsa->isActive()){
        calc_particle->bind();

        calc_particle->getShaderP()->set("mode", (int)1);
        vege_particle->draw();

        calc_particle->getShaderP()->set("mode", (int)4);
        calc_particle->getShaderP()->set("alphaMap", (int)1);

        float fade = kacsaFade->getF();
        calc_particle->getShaderP()->set("csoda", fade);

        kacsa->draw();
        exp12->draw();

        calc_particle->unbind();
    }

    float feher_fade = feherFade->getF();
    if (feher_fade>0.){
        feherSprite->setAlpha(feher_fade);
        feherSprite->draw();
    }

    float fekete_fade = feketeFade->getF();
    if (fekete_fade>0.){
        feketeSprite->setAlpha(fekete_fade);
        feketeSprite->draw();
    }

    FWrender::switchBlend(false);
}

// --------------------------------------------------------------------------------
////// callbacks  /////
namespace {
    void _greetings(FWtexture::bitmap *b, void *params){
        b->resizeForced(512, 512, 4);
        //b->resizeForced(1024, 1024, 4); // too much?

        FWtexture::gen_text test;
        test.text = (const char*)(params);
        test.size = 24;

        test.font = FWtexture::FONT_Times_New_Roman;

        test.generate(b);
    }
}