particles.c

Go to the documentation of this file.

//#define DO_TIMER

/*}{**************/

#include "Particles.h"
#include "genesis.h"
#include "ram.h"
#include "errorlog.h"
#include "procutil.h"
#include "gebmutil.h"
#include "vec3d.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>

#ifdef DO_TIMER
#include "timer.h"

TIMER_VARS(Particles);
#endif

// optimized :
// Particles            : 0.000759 = 1313 fps !
//

/*****

Particles (
        parts, sources, 
        coloring_scheme, 
        smoothes, smoothradius,
        capper,
        do_magentism {field},
        do_attractor {strength, is_vec, {vec,} pos}
[for all sources:] {
[base:]         pos, velocity, deathtime, color,
[variance:] pos, velocity, deathtime, color, shade,
                        emission_delay, drag,
                                        }
        "end"
        )
// [] are comments
// {} are conditional fields

*******/

static const char * Params_Oil = "100, 1, oil,  1, 1, wrap, t, 0, 1, 0, f,"
                        "0.5, 0.5, 0.5, 0,0,0, 1.0, 0,                                                                                  "                                       
                        "0,0,0, 0.3,0.2,0, 0, 99,0,     0.01,0.0,                                                       "
                        "end";
static const char * Params_Jet = "200, 1, fire, 1, 1, hard, f, t, 100, t, 0, 1, 0, 0.5, 0, 0.5,"
                        "0.5, 0, 0.5, 0,0.6,0, 0.03, 0,                                                                                 "
                        "0,0,0, 0.5,0.4,0, 0, 99, 0,    0.01,0.0,                                                       "
                        "end)";
static const char * Params_Steam = "50, 1, steam,       2, 1, hard, f, f,               "                                                                                                                       
                        "0.5, 0, 0.5, 0,0.25,0, 0.7, 0,                                                                                 "
                        "0,0,0, 0.15,0.10,0,0.3,99,0,0.02,0.0005,                                               "
                        "end";
static const char * Params_Explosion = "300, 1,fire,    1, 1, bounce, f, f,"
                        "0.5, 0.5, 0.5, 0,0,0,                  0.1, 0,"
                        "0,0,0,                         0.3,0.3,0.3,    0.05, 0, 0,     0.01, 0.0003,"
                        "end)";

#define DefaultParams Params_Steam

#include "gebmutil.h"

#define NUM_CLEAR_POINTS        (0)
        /* the idea of clear points is that the "smoothing" bleads in clear points
        *       from the outside, but sometimes you get solid pockets in the middle
        *       with no particles that don't get cleared.
        */

#define BM_CREATE_WIDTH         (128)
#define BM_CREATE_HEIGHT        (128)

/*}{**************/

#define PIXEL_INDEX(c,s,nc)     (((s)*(nc)) + (c))
#define PIXEL_SHADE(pel,nc)     ((pel)/(nc))
#define PIXEL_COLOR(pel,nc)     ((pel)%(nc))

typedef void (*CoordCapperFunc) (float *x,float *v, int size);
typedef void (*PixelRGBAFunc) (Procedural *Proc,int c,int s,int *R,int *G,int *B,int *);

typedef struct
{
        float   p[3],   //position in pixels
                        v[3];   //velocity in pixels per second
        int color,shade; // shade < 0 for inactive
        float DeathTime,CurDeathTime;
        float Drag;
} Particle;

typedef struct
{
        Particle Base;  
        Particle Random;
        float   RandomVMagnitude;
        float   Delay,CurTime;
} ParticleSource;

typedef struct Procedural
{
        geBitmap * Bitmap;
        Particle * Particles;
        ParticleSource * Sources;

        int NumActiveParticles;
        int SizeX,SizeY,SizeZ;
        geBitmap_Info BmInfo;

        int NumParticles,NumSources;
        int NumColors,NumShades;
        int NumSmoothes,SmoothRadius;
        geBoolean SmoothWrap;
        
        CoordCapperFunc Capper;
        PixelRGBAFunc PixelRGBA;
        
        geBoolean DoMagnetic;
        geVec3d MagneticField;

        geBoolean DoAttractor;
        geBoolean AttractorIsAxis;
        geVec3d AttractorPos,AttractorAxis;
        float AttractorStrength;
} Procedural;

/*}{**************/

geBoolean Particles_InitBitmap(geBitmap **ppBitmap);
geBoolean Particles_InitPalette(Procedural * Proc);
void Particles_Destroy(Procedural * Proc);

Particle * Particles_NewParticle(Procedural *Proc);
void Particles_EmitSources(Procedural *Proc,float time);
void Particles_MoveParticles(Procedural * Proc,float time);
geBoolean Particles_Draw(Procedural *Proc);

void Capper_Wrap(float *x,float *v, int size);
void Capper_Hard(float *x,float *v, int size);
void Capper_Bounce(float *x,float *v, int size);

void PixelRGBA_OilColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A);
void PixelRGBA_FireColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A);
void PixelRGBA_OpaqueFireColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A);
void PixelRGBA_SteamColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A);

/*}{**************/

#define ABS(x)  ( (x) < 0 ? (-(x)) : (x) )
#define minmax(x,lo,hi) ( (x)<(lo)?(lo):( (x)>(hi)?(hi):(x)) )
#define putminmax(x,lo,hi) x = minmax(x,lo,hi)

static const char * strbreakers = " ,`\t\n\r\034\009";

#define nextparam(pstr)         do { pstr = strtok(NULL,strbreakers); if ( ! pstr ) { Particles_Destroy(Proc); geErrorLog_AddString(-1,"Particle Procedural : params insufficient", NULL); return NULL; } } while(0)
#define getint(pstr)    atol(pstr); nextparam(pstr);
#define getbool(pstr)   ( toupper(*pstr) == 'T' ? GE_TRUE : (toupper(*pstr) == 'F' ? GE_FALSE : (atol(pstr)) ) ); nextparam(pstr);
#define getfloat(pstr)  (float)atof(pstr); nextparam(pstr);
#define getvec(pstr,pvec)       do { ((geVec3d *)pvec)->X = getfloat(pstr); ((geVec3d *)pvec)->Y = getfloat(pstr); ((geVec3d *)pvec)->Z = getfloat(pstr); } while(0)
#define scalevec(pvec)  do { ((geVec3d *)pvec)->X *= Proc->SizeX; ((geVec3d *)pvec)->Y *= Proc->SizeY; ((geVec3d *)pvec)->Z *= Proc->SizeZ; } while(0)
#define absvec(pvec)    do { ((geVec3d *)pvec)->X = ABS(((geVec3d *)pvec)->X); ((geVec3d *)pvec)->Y = ABS(((geVec3d *)pvec)->Y); ((geVec3d *)pvec)->Z = ABS(((geVec3d *)pvec)->Z); } while(0)
#define matchstr(str,vs)        ( strnicmp(str,vs,strlen(vs)) == 0 )

/*}{**************/

Procedural * Particles_Create(geBitmap **ppBitmap, const char *InputParams)
{
Procedural * Proc;
int i;
char ParamWork[8192],*pstr;

        if ( ! (Proc = geRam_AllocateClear(sizeof(Procedural))) )
                return NULL;

        /**** read Params *****/

        if ( strlen(InputParams) < 20 )
        {
                strcpy(ParamWork,DefaultParams);
                geErrorLog_AddString(-1,"Particle Procedural : no params : using default ", NULL);
        }
        else
        {
                strcpy(ParamWork,InputParams);
        }

        pstr = strtok(ParamWork,strbreakers);

        Proc->NumParticles = getint(pstr);
        Proc->NumSources = getint(pstr);

        /**** make Bitmap *****/

        if ( ! Particles_InitBitmap(ppBitmap) )
                goto fail;
        Proc->Bitmap = *ppBitmap;

        Proc->SizeX  = geBitmap_Width(Proc->Bitmap);
        Proc->SizeY = geBitmap_Height(Proc->Bitmap);
        geBitmap_GetInfo(Proc->Bitmap,&(Proc->BmInfo),NULL);
        Proc->SizeZ = min(Proc->SizeX,Proc->SizeY);

        /**** make Particles *****/

        Proc->Particles = geRam_AllocateClear(Proc->NumParticles * sizeof(Particle));
        if (! (Proc->Particles) )
                goto fail;
        for(i=0;i<Proc->NumParticles;i++)
        {
                Proc->Particles[i].shade = -1;
        }
        Proc->NumActiveParticles = 0;

        /**** make Sources *****/

        Proc->Sources = geRam_AllocateClear(Proc->NumSources * sizeof(ParticleSource));
        if (! (Proc->Sources) )
                goto fail;

        /**** More Params *****/

        // <> for stock schemes, take a few colors as parameters

        if ( matchstr(pstr,"oil") )
        {
                nextparam(pstr);
                Proc->NumColors = Proc->NumShades = 16;
                Proc->PixelRGBA = PixelRGBA_OilColor;
        }
        else if ( matchstr(pstr,"fire") )
        {
                nextparam(pstr);
                Proc->NumColors = 1;
                Proc->NumShades = 256;
                Proc->PixelRGBA = PixelRGBA_FireColor;
        }
        else if ( matchstr(pstr,"opaquefire") )
        {
                nextparam(pstr);
                Proc->NumColors = 1;
                Proc->NumShades = 256;
                Proc->PixelRGBA = PixelRGBA_OpaqueFireColor;
        }
        else if ( matchstr(pstr,"steam") )
        {
                nextparam(pstr);
                Proc->NumColors = 1;
                Proc->NumShades = 256;
                Proc->PixelRGBA = PixelRGBA_SteamColor;
        }
        else
        {
                Proc->NumColors = getint(pstr);
                Proc->NumShades = getint(pstr);
                Proc->PixelRGBA = PixelRGBA_OilColor; 
                // <>
                // way to read in general spline of colors ?
        }

        if ( (Proc->NumColors * Proc->NumShades) < 256 )
        {
                Proc->NumColors = min(Proc->NumColors,256);
                Proc->NumShades = 256 / Proc->NumColors;
        }

        Proc->NumSmoothes       = getint(pstr);
        Proc->SmoothRadius      = getint(pstr);

        if ( matchstr(pstr,"bounce") )
        {
                Proc->Capper = Capper_Bounce;
                Proc->SmoothWrap = GE_FALSE;
        }
        else if ( matchstr(pstr,"wrap") )
        {
                Proc->Capper = Capper_Wrap;
                Proc->SmoothWrap = GE_TRUE;
        }
        else if ( matchstr(pstr,"hard") )
        {
                Proc->Capper = Capper_Hard;
                Proc->SmoothWrap = GE_FALSE;
        }
        else
        {
                goto fail;
        }
        nextparam(pstr);

        Proc->DoMagnetic = getbool(pstr);
        if ( Proc->DoMagnetic )
        {
                getvec(pstr,&(Proc->MagneticField));
        }

        Proc->DoAttractor = getbool(pstr);
        if ( Proc->DoAttractor )
        {
                Proc->AttractorStrength = getfloat(pstr); // negative for repulsive
                Proc->AttractorIsAxis = getbool(pstr);
                if ( Proc->AttractorIsAxis )
                {
                        getvec(pstr,&(Proc->AttractorAxis));
                        geVec3d_Normalize(&(Proc->AttractorAxis));
                }
                getvec(pstr,&(Proc->AttractorPos));
                scalevec(&(Proc->AttractorPos));
        }

        /**** LUT's *****/

        if ( ! Particles_InitPalette(Proc) )
                goto fail;

        for(i=0;i< Proc->NumSources; i++)
        {
        ParticleSource * pSource;
        Particle * pParticle;

                pSource = Proc->Sources + i;

                pParticle = &(pSource->Base);

                getvec(pstr,pParticle->p);
                getvec(pstr,pParticle->v);
                scalevec(pParticle->p);
                scalevec(pParticle->v);
                pParticle->DeathTime = getfloat(pstr);
                pParticle->color = getint(pstr);
                pParticle->shade = Proc->NumShades - 1;
                pParticle->CurDeathTime = 0.0f;

                pParticle = &(pSource->Random);

                getvec(pstr,pParticle->p);
                getvec(pstr,pParticle->v);
                scalevec(pParticle->p);
                scalevec(pParticle->v);
                absvec(pParticle->p);
                absvec(pParticle->v);

                pParticle->DeathTime = getfloat(pstr);
                
                pParticle->color = getint(pstr);
                pParticle->shade = getint(pstr);
                pParticle->CurDeathTime = 0.0f;

                pSource->RandomVMagnitude = geVec3d_Normalize( (geVec3d *) (pParticle->v) );

                pSource->Delay = getfloat(pstr); // seconds
                pSource->Base.Drag = getfloat(pstr);
                pSource->CurTime = pSource->Delay;
        }

        if ( strnicmp(pstr,"end",3) != 0 )
        {
                //geErrorLog_AddString(-1,"Particles_Create : non-fatal : Didn't get 'end' of Particle Prodedural config");
        }

        #ifdef DO_TIMER
                timerFP = fopen("q:\\timer.log","at+");
                Timer_Start();
        #endif

        return Proc;

        fail:

        Particles_Destroy(Proc);
        return NULL;
}

/*}{**************/

void Particles_Destroy(Procedural * Proc)
{
        if ( ! Proc )
                return;

        if ( Proc->Bitmap )
                geBitmap_Destroy(&(Proc->Bitmap)); // we did creatref
        if ( Proc->Particles )
                geRam_Free(Proc->Particles);
        if ( Proc->Sources )
                geRam_Free(Proc->Sources);
                
        #ifdef DO_TIMER
        Timer_Stop();
        if ( timerFP )
        {
                TIMER_REPORT(Particles);
        }
        #endif

        geRam_Free(Proc);
}

/*}{**************/

geBoolean Particles_Animate(Procedural * Proc,float time)
{

        #ifdef DO_TIMER
        TIMER_P(Particles);
        #endif

        Particles_EmitSources(Proc,time);

        Particles_MoveParticles(Proc,time);

        Particles_Draw(Proc);

        #ifdef DO_TIMER
        TIMER_Q(Particles);
        TIMER_COUNT();
        #endif

return GE_TRUE;
}

/*}{**************/

Particle * Particles_NewParticle(Procedural *Proc)
{
Particle * pP;
int p;
        pP = Proc->Particles;
        for(p= Proc->NumParticles;p--;pP++)
        {
                if ( pP->shade < 0 )
                {
                        Proc->NumActiveParticles++;
                        return pP;
                }
        }
        pP = NULL;
        assert(pP);
return pP;
}
void Particles_DeleteParticle(Procedural *Proc,Particle *pP)
{
Particle * pPNew;
        pPNew = Proc->Particles + (Proc->NumActiveParticles - 1);
        Proc->NumActiveParticles --;
        *pP = *pPNew;
        pPNew->shade = -1;
}

void Particles_EmitSources(Procedural *Proc,float time)
{
int cnt;
ParticleSource * pSource;
Particle *pP,*pR;

        pSource = Proc->Sources;
        for(cnt=Proc->NumSources;cnt--;pSource++)
        {
                pSource->CurTime += time;
                while ( pSource->CurTime > pSource->Delay &&
                        Proc->NumActiveParticles < Proc->NumParticles )
                {
                float rv,t;

                        pSource->CurTime -= pSource->Delay;

                        pP = Particles_NewParticle(Proc);
                        *pP = pSource->Base;
                        pR = &(pSource->Random);
                        rv = ProcUtil_RandSignedFloat( pSource->RandomVMagnitude );
                        t = ProcUtil_RandSignedUnitFloat();
                        pP->v[0] += rv * pR->v[0] * t;
                        t = ProcUtil_RandSignedUnitFloat();
                        pP->v[1] += rv * pR->v[1] * t;
                        t = ProcUtil_RandSignedUnitFloat();
                        pP->v[2] += rv * pR->v[2] * t;
                        pP->p[0] += ProcUtil_RandSignedFloat(pR->p[0]);
                        pP->p[1] += ProcUtil_RandSignedFloat(pR->p[1]);
                        pP->p[2] += ProcUtil_RandSignedFloat(pR->p[2]);
                        pP->color += ProcUtil_RandSigned(pR->color);
                        pP->shade += ProcUtil_RandSigned(pR->shade);
                        putminmax(pP->color,0,Proc->NumColors - 1);
                        putminmax(pP->shade,0,Proc->NumShades - 1);
                        
                        assert( geVec3d_IsValid((geVec3d *)pP->p) );
                        assert( geVec3d_IsValid((geVec3d *)pP->v) );
                }
        }

}

void Particles_MoveParticles(Procedural * Proc,float time)
{
int cnt;
Particle * pP;

        pP = Proc->Particles;
        for(cnt=0;cnt<Proc->NumActiveParticles;cnt++,pP++)
        {
        float mul,vsqr;

                assert( pP->shade >= 0 );
                assert( geVec3d_IsValid((geVec3d *)pP->p) );
                assert( geVec3d_IsValid((geVec3d *)pP->v) );

                pP->CurDeathTime += time;
                if ( pP->CurDeathTime > pP->DeathTime )
                {
                        pP->shade -= (Proc->NumShades + 15)>>4;
                        pP->CurDeathTime -= pP->DeathTime;
                }

                if ( pP->shade < 0 )
                {
                        Particles_DeleteParticle(Proc,pP);
                        if ( cnt >= Proc->NumActiveParticles )
                                break;
                }

                assert( geVec3d_IsValid((geVec3d *)pP->p) );
                assert( geVec3d_IsValid((geVec3d *)pP->v) );

                pP->p[0] += pP->v[0] * time;
                Proc->Capper( pP->p + 0, pP->v + 0, Proc->SizeX);

                pP->p[1] += pP->v[1] * time;
                Proc->Capper( pP->p + 1, pP->v + 1, Proc->SizeY);

                pP->p[2] += pP->v[2] * time;
                Proc->Capper( pP->p + 2, pP->v + 2, Proc->SizeZ);

                assert( geVec3d_IsValid((geVec3d *)pP->p) );
                assert( geVec3d_IsValid((geVec3d *)pP->v) );

                vsqr = geVec3d_LengthSquared((geVec3d *)pP->v);
                assert( vsqr >= 0.0f );
                if ( vsqr > 100.0f ) vsqr = 100.0f;
                mul = vsqr * pP->Drag;
                if ( mul > 0.05f ) mul = 0.05f;
                pP->v[0] -= pP->v[0] * mul;
                pP->v[1] -= pP->v[1] * mul;
                pP->v[2] -= pP->v[2] * mul;

                // change velocity based on some forces

                assert( geVec3d_IsValid((geVec3d *)pP->p) );
                assert( geVec3d_IsValid((geVec3d *)pP->v) );

                if ( Proc->DoMagnetic )
                {
                geVec3d A;

                        geVec3d_CrossProduct( (geVec3d *) (pP->v) , &(Proc->MagneticField), &A);
                        pP->v[0] += time * A.X;
                        pP->v[1] += time * A.Y;
                        pP->v[2] += time * A.Z;

                        assert( geVec3d_IsValid((geVec3d *)pP->p) );
                        assert( geVec3d_IsValid((geVec3d *)pP->v) );
                }

                if ( Proc->DoAttractor )
                {
                float ax,ay,az,q;

                        if ( Proc->AttractorIsAxis )
                        {
                        geVec3d Diff;
                                geVec3d_Subtract( (geVec3d *) pP->p , &(Proc->AttractorPos), &Diff);
                                q = geVec3d_DotProduct( &(Proc->AttractorAxis), &Diff );
                                ax = q * Proc->AttractorAxis.X - Diff.X;
                                ay = q * Proc->AttractorAxis.Y - Diff.Y;
                                az = q * Proc->AttractorAxis.Z - Diff.Z;
                        }
                        else
                        {
                                ax = Proc->AttractorPos.X - pP->p[0];
                                ay = Proc->AttractorPos.Y - pP->p[1];
                                az = Proc->AttractorPos.Z - pP->p[2];
                        }

                        #if 0 // Electric Attractor
                        q = (float)sqrt(ax*ax + ay*ay + az*az + 1.0);
                        q = Proc->AttractorStrength * 100.0f * time / (q*q*q);
                        #else // Spring Attractor
                        q = Proc->AttractorStrength * time;
                        #endif
                        ax *= q;
                        ay *= q;
                        az *= q;

                        pP->v[0] += ax;
                        pP->v[1] += ay;
                        pP->v[2] += az;
                }
                
                assert( geVec3d_IsValid((geVec3d *)pP->p) );
                assert( geVec3d_IsValid((geVec3d *)pP->v) );
        }
}

geBoolean Particles_Draw(Procedural *Proc)
{
geBitmap *Lock=NULL;
uint8 *Bits;
int w,h,s,cnt,x,y;
Particle * pP;
uint8 *pBits,pel;

        assert(Proc->Bitmap);

        geBitmap_SetGammaCorrection(Proc->Bitmap, 1.0f, GE_FALSE);

        if ( ! geBitmap_LockForWriteFormat(Proc->Bitmap,&Lock,0,0,GE_PIXELFORMAT_8BIT_PAL) )
                goto fail;

        if ( ! geBitmap_GetInfo(Lock,&(Proc->BmInfo),NULL) )
                goto fail;

        if ( Proc->BmInfo.Format != GE_PIXELFORMAT_8BIT_PAL )
                goto fail;

        Bits = geBitmap_GetBits(Lock);

        if ( ! Bits )
                goto fail; 

        w = Proc->BmInfo.Width;
        h = Proc->BmInfo.Height;
        s = Proc->BmInfo.Stride;

        for( cnt = NUM_CLEAR_POINTS; cnt --; )
        {
        int shade,color;
        int nc = Proc->NumColors;
                x = ProcUtil_Rand(w);
                y = ProcUtil_Rand(h);
                pBits = Bits + y*s + x;
                shade = PIXEL_SHADE(*pBits,nc);
                color = PIXEL_COLOR(*pBits,nc);
                shade >>= 1;
                *pBits = PIXEL_INDEX(color,shade,nc);
        }

        for(    cnt=Proc->NumActiveParticles,   pP = Proc->Particles;
                        cnt > 0 ;
                        pP++    )
        {
                assert( pP->shade >= 0 );

                x = (int)(pP->p[0]);
                y = (int)(pP->p[1]);
                putminmax(x, 1, w-2);
                putminmax(y, 1, h-2);
                pBits = Bits + (y * s) + x;
                pel = PIXEL_INDEX(pP->color,pP->shade,Proc->NumColors);
                pBits[0] = pBits[1] = pBits[-1] = pBits[s] = pBits[-s] = pel;

                cnt--;
        }

        for( cnt = Proc->NumSmoothes; cnt--; )
        {
                if ( ! geBitmapUtil_SmoothBits(&(Proc->BmInfo),Bits,Bits,Proc->SmoothRadius,Proc->SmoothWrap) )
                        goto fail;
        }

        if ( ! geBitmap_UnLock(Lock) )
                goto fail;

        return GE_TRUE;
fail:

        if ( Lock )             geBitmap_UnLock(Lock);

        return GE_FALSE;
}

/*}{**************/

geBoolean Particles_InitBitmap(geBitmap **ppBitmap)
{
        assert( ppBitmap);
        if ( ! *ppBitmap )
        {
                *ppBitmap = geBitmap_Create(BM_CREATE_WIDTH,BM_CREATE_HEIGHT,1, GE_PIXELFORMAT_8BIT_PAL);
                if ( ! *ppBitmap )
                        return GE_FALSE;
        }
        else
        {
                geBitmap_CreateRef(*ppBitmap);
        }

        if ( ! geBitmap_SetFormat(*ppBitmap,GE_PIXELFORMAT_8BIT_PAL,GE_FALSE,0,NULL) )
                return GE_FALSE;

        if ( ! geBitmap_ClearMips(*ppBitmap) )
                return GE_FALSE;

        if ( ! geBitmap_SetPreferredFormat(*ppBitmap,GE_PIXELFORMAT_16BIT_4444_ARGB) )
                return GE_FALSE;

        if ( ! geBitmapUtil_SetColor(*ppBitmap,0,0,0,0) )
                return GE_FALSE;

        return GE_TRUE;
}

geBoolean Particles_InitPalette(Procedural * Proc)
{
geBitmap_Info Info;
geBitmap_Palette *Pal;
void * PalData = NULL;
gePixelFormat PalFormat;
int PalSize;

        Pal = geBitmap_Palette_Create(GE_PIXELFORMAT_32BIT_ARGB,256);
        if ( ! Pal )
                goto fail;
        if ( ! geBitmap_SetPalette(Proc->Bitmap,Pal) )
                goto fail;
        geBitmap_Palette_Destroy(&Pal);

        if ( ! geBitmap_GetInfo(Proc->Bitmap,&Info,NULL) )
                goto fail;

        if ( Info.Format != GE_PIXELFORMAT_8BIT_PAL )
                goto fail;

        if ( ! (Pal = geBitmap_GetPalette(Proc->Bitmap)) )
                goto fail;

        if ( ! geBitmap_Palette_Lock(Pal,&PalData, &PalFormat, &PalSize) )
                goto fail;
        if ( PalSize < 256 )
                goto fail;

        {
        int p;
        uint8 * PalPtr;
        int R,G,B,A;
        int c,s;

                for(c=0;c<(Proc->NumColors);c++)
                {
                        for(s=0;s<(Proc->NumShades);s++)
                        {
                                p = PIXEL_INDEX(c,s,Proc->NumColors);
                                Proc->PixelRGBA(Proc,c,s,&R,&G,&B,&A);
                                PalPtr = ((uint8 *)PalData) + p * gePixelFormat_BytesPerPel(PalFormat);
                                gePixelFormat_PutColor(PalFormat,&PalPtr,R,G,B,A);
                        }
                }
        }

        PalData = NULL;

        if ( ! geBitmap_Palette_UnLock(Pal) )
                return GE_FALSE;

        return GE_TRUE;

fail:

        if ( PalData )
                geBitmap_Palette_UnLock(Pal);

        return GE_FALSE;

}

/*}{**************/

void Capper_Wrap(float *x,float *v, int size)
{
        if ( *x < 0 )
        {
                *x += size;
        }
        else if ( *x >= size )
        {
                *x -= size;
        }
}

void Capper_Hard(float *x,float *v, int size)
{
        if ( *x < 0 )
        {
                *x = 0;
        }
        else if ( *x >= size )
        {
                *x = (float)(size - 1);
        }
}

void Capper_Bounce(float *x,float *v, int size)
{
        if ( *x < 0 )
        {
                *x = 0;
                *v *= -1;
        }
        else if ( *x >= size )
        {
                *x = (float)(size - 1);
                *v *= -1;
        }
}

/*}{**************/

static Procedural_Table Particles_Table = 
{
        Procedurals_Version,Procedurals_Tag,
        "Particles",
        Particles_Create,
        Particles_Destroy,
        Particles_Animate
};

Procedural_Table * Particles_GetProcedural_Table(void)
{
        return &Particles_Table;
}

/*}{**************/

void PixelRGBA_OilColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A)
{
/*
        *R = *B = (255 * c) / (Proc->NumColors - 1);    
        *G = 255 - *B;
*/
        if ( Proc->NumColors == 1 ) *B = 0;
        else *B = (255 * c) / (Proc->NumColors - 1);    
        *G = *R = 255 - *B;
        *A = (255 * s) / (Proc->NumShades - 1);
        if ( *A > 200 ) *A = 255;
        else *A = (int)(300 * pow((*A)/255.0,0.7));
}

void PixelRGBA_FireColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A)
{
float sfrac;
        sfrac = (float)s / (Proc->NumShades - 1);       
        *R = (int)(255 * pow(sfrac, 0.3));
        *G = (int)(255 * pow(sfrac, 0.7));
        *B = (int)(128 * pow(sfrac, 3.0));
        if ( sfrac > 0.4 )      *A = 255;
        else                            *A = (int)(530 * pow(sfrac, 0.8));
}

void PixelRGBA_OpaqueFireColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A)
{
float sfrac;
        sfrac = (float)s / (Proc->NumShades - 1);       
        *R = (int)(255 * pow(sfrac, 0.3));
        *G = (int)(255 * pow(sfrac, 0.7));
        *B = (int)(128 * pow(sfrac, 3.0));
        *A = min((int)(400 * pow(sfrac, 0.3)),255);
}

void PixelRGBA_SteamColor(Procedural *Proc,int c,int s,int *R,int *G,int *B,int *A)
{
float sfrac;
        sfrac = (float)s / (Proc->NumShades - 1);       
        *A = (int)(255 * pow(sfrac, 0.5));
        *R = *G = *B = *A;
}

---