fxParticleSystem.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

//
// FILE: fxParticleSystem.cpp
// Particle System
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core.h"

double fxParticleSystem::_dParticleDensity = 1;

laPoint2* fxParticleSystem::_arParticleUV = NULL;
unsigned     fxParticleSystem::_nCntMax = 0;

fxParticleSystem_params::fxParticleSystem_params()
{
    gen_maxcnt = 32;
    ang = ang_var = 0;

    gen_percent = 100;
    gen_htime   = 0;
    gen_loop    = M_TRUE;
    gen_linearEmitter = M_FALSE;

    p_rgb     = laColor(255,255,255);
    p_alpha_filter = 0.005;
    p_size    = M_UNIT;
    p_speed   = M_UNIT;
    p_mass    = 0;
    p_ttl     = 1;
    pv_ramble = 0;
    pv_speed  = 0;

    pv_size  = 0;
    pv_speed = 0;
    pv_mass  = 0;
    pv_ttl   = 0;
}

fxParticleSystem::fxParticleSystem(void)
{
    _bEnabled    = M_TRUE;
    _bGenEnabled = M_TRUE;

    _particles          = NULL;
    _arParticlePos      = NULL;
    _arParticleSize     = NULL;
    _arParticleColors   = NULL;

    _nCnt = _nValidParticles = 0;
}

fxParticleSystem::~fxParticleSystem(void)
{
    if(_particles)          delete [] _particles;
    if(_arParticlePos)      delete [] _arParticlePos;
    if(_arParticleSize)     delete [] _arParticleSize;
    if(_arParticleColors)   delete [] _arParticleColors;
}

// Create particle sysyem
//
void fxParticleSystem::create(fxParticleSystem_params &p)
{
    // Allocate memory for the particle Fx
    //
    _nCnt = (unsigned)(p.gen_maxcnt*_dParticleDensity);

    _particles          = new fxParticleSystem_particle [_nCnt];
    _arParticlePos      = new laPoint3 [_nCnt];
    _arParticleSize     = new double [_nCnt];
    _arParticleColors   = new laColor [_nCnt*4];

    // Particle UVs are in a shared array fxParticleSystem::_arParticleUV; Re-allocate if size exceeds the max
    //
    if( _nCntMax < _nCnt )
    {
        if(_arParticleUV) delete [] _arParticleUV;
        _arParticleUV = new laPoint2 [_nCnt*4];
        _nCntMax = _nCnt;

        for(unsigned i=0; i<_nCntMax; i++)
        {
            _arParticleUV[i*4 + 0] = laPoint2(0, 0);
            _arParticleUV[i*4 + 1] = laPoint2(0, 1);
            _arParticleUV[i*4 + 2] = laPoint2(1, 1);
            _arParticleUV[i*4 + 3] = laPoint2(1, 0);
        }
    }

    // Misc
    //
    if(p.ang_var<1) p.ang_var = 1;

    _nSimGenCnt = (unsigned)((_nCnt/100.0)*p.gen_percent);

    _nGenCnt = _nSimGenCnt;
    _bHold = M_FALSE;

    parameters = p;
    strcpy(parameters.p_texture, p.p_texture);

    lnEmitter.build_vec( *this, laPoint3(parameters.gen_emitter_sz.x(), parameters.gen_emitter_sz.y(), 0) );
}

// Draw
//
#include <GL\GL.h>

void fxParticleSystem::draw(laRenderer *r)
{
    PROFILE_REN(fxParticleSystem_draw);
    if(!_bEnabled) return;

    // Particles have a custom alpha filter, so override the default
    double dOldFilter = r->modeBlendFilter(parameters.p_alpha_filter);

    // z-Buffer Setup:
    // Enable the depth test (i.e. don't draw if there's stuff in front of the FX),
    // Don't write to the depth buffer (so particles don't obscure each other, which causes artefacts)
    //
    // Particles are drawn *after all geometry in the level*, so this setup should be OK in most cases;
    // ( But if 2 particle FXs overlap, the color won't be mixed correctly )
    //
    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_FALSE);

    // Lazy-load the particle texture
    //
    if( !texSprite.id() ) texSprite.load(parameters.p_texture, M_TEX_TMAP);
    texSprite.use();

    // Render particles
    // NOTE: Do not translate here, in most cases the partilce Fx can be positioned together with the object
    // NOTE: Translating the particle Fx moves all existing particles, whereas changing emitter pos - only newly generated
    //
    //r->transPush();
    //r->transTranslate( pos );
    r->vquadsMakeBillboards(_nValidParticles, _arParticlePos, _arParticleSize);
    r->vquadsDraw(_nValidParticles, _arParticleUV, _arParticleColors, M_TRUE, M_TRUE);
    //r->transPop();

    // Restore stuff
    //
    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);
    r->modeBlendFilter( dOldFilter );
}

// Animate
//
void fxParticleSystem::animate(laTimer &t)
{
    //PROFILE_REN(fxParticleSystem_animate);
    static fxParticleSystem_particle *p;
    static laPoint3 *ppos;
    static double *psz;
    static laColor *pcol;

    _nValidParticles = 0;

    if(!_bEnabled) return;

    if(_bHold)
    {
        if( _dHoldLeft<t.delta() )
        {
            _bHold = M_FALSE;
            _nGenCnt = _nSimGenCnt;
        }
        else _dHoldLeft -= t.delta();
    }

    //Adaptive generation (compensate for low FPS)
    /*if((parameters.gen_htime*2)<(t.delta()))
    {
        parameters[1]en_percent += 1;
        parameters.gen_htime +=   (t.delta()-parameters.gen_htime)*(parameters.gen_htime/t.delta());

        _nSimGenCnt = (unsigned)((_nCnt/100.0)*parameters[1]en_percent);
    }*/

    // Animate each particle
    //
    for(unsigned i=0; i<_nCnt; i++)
    {
        p       = _particles + i;
        ppos    = _arParticlePos + i;
        psz     = _arParticleSize + i;
        pcol    = _arParticleColors + i*4;

        // Animate an existing particle
        //
        if( p->bValid )
        {
            // Check if particle expires
            //
            if( p->dTTL < t.delta() ) {
                p->bValid = M_FALSE;
                continue;
            }
            else _nValidParticles++;

            // Update TTL, color and size
            //
            p->dTTL -= t.delta();
            pcol[0][3] = pcol[1][3] = pcol[2][3] = pcol[3][3] = (char)( (p->dTTL/p->dTTL_Total) * parameters.p_rgb[3] );

            // Apply velocity
            //
            *ppos += t.delta()*p->velocity;

            // Ramble effect
            //
            p->velocity[0] += t.delta()*((rand()%1000)*(parameters.pv_ramble/1000.0) - parameters.pv_ramble/2);
            p->velocity[1] += t.delta()*((rand()%1000)*(parameters.pv_ramble/1000.0) - parameters.pv_ramble/2);

            // Gravitation effect
            //
            p->velocity[1] += parameters.p_mass*t.delta();

        }

        //Create a new particle if there is generator quota
        //
        else if( (_nGenCnt>0) && _bGenEnabled )
        {
            //Disable recreation if this the emitter is not supposed to loop
            if( (p->bCreatedOnce) && (!parameters.gen_loop)) continue;

            // Randomised start position
            //
            if(parameters.gen_linearEmitter)    lnEmitter.at( (rand()%100)/200.0 + 0.25, ppos );
            else    *ppos = *this;

            *ppos += ((rand()%100)/100.0 - 0.5) * parameters.gen_emitter_sz * 0.5;

            //prect->pt[0][0] += ((rand()%100)/100.0 - 0.5) * parameters->gen_emitter_sz.x();
            //prect->pt[0][1] += ((rand()%100)/100.0 - 0.5) * parameters->gen_emitter_sz.y();
            //prect->pt[0][2] += ((rand()%100)/100.0 - 0.5) * parameters->gen_emitter_sz.z();

            //Randomised emission angle
            //
            laPhForce f;
            f.buildFromAngle( parameters.ang + (rand()%1000)*(parameters.ang_var/1000.0)-parameters.ang_var/2);

            double speed_randomness = (rand()%1000)*(parameters.pv_speed/1000.0);

            p->velocity[0] = f.compX()*(parameters.p_speed+speed_randomness);
            p->velocity[1] = f.compY()*(parameters.p_speed+speed_randomness);

            //Randomised size
            //
            *psz = parameters.p_size;
            if(parameters.pv_size!=0) *psz += (rand()%1000)*(parameters.pv_size/1000);

            // Color
            //
            pcol[0] = pcol[1] = pcol[2] = pcol[3] = parameters.p_rgb;

            //Randomised TTL
            //
            double ttl_randomness = (rand()%1000)*(parameters.pv_ttl/1000.0)-parameters.pv_ttl/2;
            p->dTTL_Total = p->dTTL = parameters.p_ttl + ttl_randomness;

            // Spawn it
            //
            p->bValid = p->bCreatedOnce = M_TRUE;
            _nGenCnt--;
        }
    }

    if( (_nGenCnt<=0) && (!_bHold))
    {
        _bHold = M_TRUE;
        _dHoldLeft = parameters.gen_htime;
    }

}

void fxParticleSystem::destroy()
{
    ASSERT(M_FALSE, "Not implemented");
}

void fxParticleSystem::reset()
{
    for(unsigned i=0; i<_nCnt; i++)
    {
        _particles[i].bValid = M_FALSE;
        _particles[i].bCreatedOnce = M_FALSE;
    }
}

void fxParticleSystem_params::load(class laFileParser *fp)
{
    //laPropertyList pl;
    //fp.readObj(&pl, M_FALSE);

    char junk[128];

    //Emitter
    try{ fp->readSectionSeparator(junk); }catch(laError& ){ throw laError("Section [EMITTER] expected but not found (while parsing '%s')", fp->getFileName()); }
    _strupr(junk);
    if(strcmp(junk, "EMITTER")) throw laError("Section [EMITTER] expected, [%s] found (while parsing '%s')", junk, fp->getFileName());

    fp->readDouble(&ang);
    fp->readDouble(&ang_var);

    fp->readObj(&gen_emitter_sz);

    gen_emitter_sz[0] *= M_UNIT;
    gen_emitter_sz[1] *= M_UNIT;
    gen_emitter_sz[2] *= M_UNIT;

    fp->readBool(&gen_loop);
    fp->readDouble(&gen_maxcnt);
    fp->readDouble(&gen_percent);
    fp->readDouble(&gen_htime);

    //Particle
    try{ fp->readSectionSeparator(junk); }catch(laError& ){ throw laError("Section [PARTICLE] expected but not found (while parsing '%s')", fp->getFileName()); }
    _strupr(junk);
    if(strcmp(junk, "PARTICLE")) throw laError("Section [PARTICLE] expected, [%s] found (while parsing '%s')", junk, fp->getFileName());

    fp->readText(p_texture);
    fp->readObj(&p_rgb);
    fp->readDouble(&p_alpha_filter);

    fp->readDouble(&p_size);
    fp->readDouble(&p_speed);
    fp->readDouble(&p_mass);
    fp->readDouble(&p_ttl);

    p_size  *= M_UNIT;
    p_speed *= M_UNIT;

    //Varation
    try{ fp->readSectionSeparator(junk); }catch(laError& ){ throw laError("Section [VARATION] expected but not found (while parsing '%s')", fp->getFileName()); }
    _strupr(junk);
    if(strcmp(junk, "VARATION")) throw laError("Section [VARATION] expected, [%s] found (while parsing '%s')", junk, fp->getFileName());

    fp->readDouble(&pv_size);
    fp->readDouble(&pv_speed);
    fp->readDouble(&pv_mass);
    fp->readDouble(&pv_ttl);
    fp->readDouble(&pv_ramble);

    if(pv_ttl>=p_ttl) pv_ttl = p_ttl;

    pv_size *= M_UNIT;
    pv_speed *= M_UNIT;
    pv_ramble *= M_UNIT;
}


void fxParticleSystem::ctlRewind(unsigned nframes, double fps)
{
    laTimer t;
    t.frameForce(fps);
    for(unsigned i=0; i<nframes; i++) animate(t);
}

void fxParticleSystem::load(class laFileParser *fp)
{
    laFileParser fxp;
    fxParticleSystem_params parameters;
    char strFilePath[128]=M_DIR_FX;
    char strFxFile[128];
    laPoint3 pos, size;
    double ang;

    //Read the .fx file name and the positional information
    try{
        fp->readText(strFxFile, M_FALSE);
        fp->readObj(&pos, M_FALSE);
        fp->readObj(&size, M_FALSE);
        fp->readDouble(&ang, M_FALSE);
    }
    catch(laError& )
    {
        throw laError("FX description appears to be corrupted");
    }

    //Load the .fx file into a fxParticleSystem_params structure
    strcat(strFilePath, strFxFile);
    fxp.fileOpen(strFilePath);
    fxp.readObj(&parameters, M_FALSE);
    fxp.fileClose();

    x( pos.x()*M_UNIT );
    y( pos.y()*M_UNIT );
    z( pos.z()*M_UNIT );

    //Create the fx spray
    create(parameters);
}

void fxParticleSystem::copyStyle(fxParticleSystem* pSource)
{
    parameters.p_rgb  = pSource->parameters.p_rgb;
    texSprite       =  pSource->texSprite;

}