smoke.c

Go to the documentation of this file.

/****************************************************************************************/
/*  Smoke.c                                                                             */
/*                                                                                      */
/*  Author: John Pollard                                                                */
/*  Description:                                                                        */
/*                                                                                      */
/*  Copyright (c) 1997, 1999, Eclipse Entertainment; All rights reserved.               */
/*                                                                                      */
/*  See the accompanying file LICENSE.TXT for terms on the use of this library.         */
/*  This library is distributed in the hope that it will be useful but WITHOUT          */
/*  ANY WARRANTY OF ANY KIND and without any implied warranty of MERCHANTABILITY        */
/*  or FITNESS FOR ANY PURPOSE.  Refer to LICENSE.TXT for more details.                 */
/*                                                                                      */
/****************************************************************************************/
#include <Assert.h>
#include <Stdlib.h>

#include <Math.h>

#include "Procedural.h"
#include "String.h"
#include "Bitmap.h"
#include "Ram.h"
#include "gebmutil.h"

#define SMOOTH_WRAP GE_FALSE

//====================================================================================
//====================================================================================
// 3D Smoke effect
#define     NSMPARTICLES   1024

typedef struct
{
   // S15.16 fixed point
   int32                Velocity[3];
   int32                Position[3];
} Smoke_Data;

typedef struct Procedural
{
        geBitmap                *Bitmap;
        geBitmap_Info   BitmapInfo;

        int32           Width;
        int32           Height;
        int32           Size;

        // Buffer of data about smoke particles
        Smoke_Data      Smbuf[NSMPARTICLES];

        int32           *ZBuffer;                               // 16.16 zbuffer
        float           *ZAge;                                  // ZBuffer age

        int32           NumParticles;
        float           x, y, z, vx, vy, vz;

        int32           PalIndex;
} Procedural;

void Smoke_Destroy(Procedural *Proc);
geBoolean Smoke_Animate(Procedural *Smoke, float ElapsedTime);

// Create a particle, based on Position and Velocity supplied, 
// but with a small reandom deviation
void  Smoke_FillParticle(Smoke_Data *particle,
                         float xp,
                         float yp,
                         float zp,
                         float xv,
                         float yv,
                         float zv);

geBoolean Smoke_Shade(Procedural *Smoke);

geBoolean Smoke_Update( Procedural *Smoke,
                                        int nparticles,
                                        float xp,
                                        float yp,
                                        float zp,
                                        float xv,
                                        float yv,
                                        float zv,
                                        int lightdir);

int32 Smoke_GetPalIndexFromString(const char *Str);
geBoolean Smoke_InitBitmap(Procedural *Proc, geBitmap **ppBitmap);
geBoolean Smoke_InitPalette(Procedural *Proc);

//====================================================================================
//      Smoke_Create
//====================================================================================
Procedural *Smoke_Create(geBitmap **Bitmap, const char *StrParms)
{
        Procedural      *Proc;

        assert(Bitmap);
        //assert(ParmStart);    // Unremark this when implemented!!!!!

        Proc = GE_RAM_ALLOCATE_STRUCT(Procedural);

        if (!Proc)
                goto ExitWithError;

        memset(Proc, 0, sizeof(*Proc));

        {
                char            *Token;
                int32           TokenNum;
                char            Parms[1024];

                Proc->PalIndex = 0;

                Proc->NumParticles = 128;
                
                Proc->x = 6.0f;
                Proc->y = 64.0f;
                Proc->z = 25.0f;

                Proc->vx = 4.0f;
                Proc->vy = 5.0f;
                Proc->vz = 1.0f;

                strcpy(Parms, StrParms);
                
                TokenNum = 0;

                Token = strtok(Parms," \t,+\n\r");

                while(Token)
                {
                        switch(TokenNum)
                        {
                                case 0:
                                        Proc->PalIndex = Smoke_GetPalIndexFromString(Token);
                                        break;
                                case 1:
                                        Proc->NumParticles = atoi(Token);
                                        break;
                                case 2:
                                        Proc->x = (float)atof(Token);
                                        break;
                                case 3:
                                        Proc->y = (float)atof(Token);
                                        break;
                                case 4:
                                        Proc->z = (float)atof(Token);
                                        break;
                                case 5:
                                        Proc->vx = (float)atof(Token);
                                        break;
                                case 6:
                                        Proc->vy = (float)atof(Token);
                                        break;
                                case 7:
                                        Proc->vz = (float)atof(Token);
                                        break;
                        }

                        TokenNum++;

                        if (TokenNum >= 8)
                                break;

                        Token = strtok(NULL," \t,+\n\r");

                }

        }

        if (!Smoke_InitBitmap(Proc, Bitmap))
                goto ExitWithError;

        if (Proc->x < 0.0f) 
                Proc->x = 0.0f;
        if (Proc->x > Proc->Width-1) 
                Proc->x = (float)Proc->Width-1;
        if (Proc->y < 0.0f) 
                Proc->x = 0.0f;
        if (Proc->y > Proc->Height-1) 
                Proc->y = (float)Proc->Height-1;

        if (!Smoke_Animate(Proc, 0.1f))
        {
                goto ExitWithError;
        }

        return Proc;

        ExitWithError:
        {
                if (Proc)
                        Smoke_Destroy(Proc);

                return NULL;
        }
}

//====================================================================================
//      Smoke_Destroy
//====================================================================================
void Smoke_Destroy(Procedural *Proc)
{
        assert(Proc);

        if (Proc->ZBuffer)
        {
                geRam_Free(Proc->ZBuffer);
                Proc->ZBuffer = NULL;
        }
        
        if (Proc->ZAge)
        {
                geRam_Free(Proc->ZAge);
                Proc->ZAge = NULL;
        }

        if (Proc->Bitmap)
        {
                geBitmap_Destroy(&Proc->Bitmap);
                Proc->Bitmap = NULL;
        }

        geRam_Free(Proc);
}

//====================================================================================
//      Smoke_Animate
//====================================================================================
geBoolean Smoke_Animate(Procedural *Smoke, float ElapsedTime)
{
        if (!Smoke->Bitmap)
                return GE_TRUE;
        
        if (!Smoke_Update(Smoke, Smoke->NumParticles, Smoke->x, Smoke->y, Smoke->z, Smoke->vx, Smoke->vy, Smoke->vz, 1))
                return GE_FALSE;

        return GE_TRUE;
}

//====================================================================================
//====================================================================================
static Procedural_Table Smoke_Table = 
{
        Procedurals_Version,Procedurals_Tag,
        "Smoke",
        Smoke_Create,
        Smoke_Destroy,
        Smoke_Animate
};

/*
//====================================================================================
//====================================================================================
DllExport Procedural_Table *GetProcedural_Table()
{
        return Smoke_GetProcedural_Table();
}
*/

//====================================================================================
//====================================================================================
Procedural_Table *Smoke_GetProcedural_Table(void)
{
        return &Smoke_Table; 
}

//==================================================================================
// Create a particle, based on Position and Velocity supplied, 
// but with a small random deviation
//==================================================================================
void  Smoke_FillParticle(Smoke_Data *particle,
                         float xp,
                         float yp,
                         float zp,
                         float xv,
                         float yv,
                         float zv)
{
   int   tmp;

   particle->Position[0] = (int32)((xp * 0x10000) + ((rand()&1) ? (rand() * xp) : (-rand() * xp)));

   tmp = rand() << 3;
   if(rand() & 1)
      tmp = -tmp;

   particle->Position[1] = (int32)(yp * 0x10000) + tmp;

   tmp = rand() << 1;
   if(rand() & 1)
      tmp = -tmp;

   particle->Position[2] = (int32)(zp * 0x10000) + tmp;

   tmp = rand() << 1;
   if(rand() & 1)
      tmp = -tmp;
   particle->Velocity[0] = (int32)(xv * 0x10000) + tmp;
//   if(rand() & 1)
//      particle->Velocity[0] = -particle->Velocity[0];

   particle->Velocity[1] = (int32)(yv * rand() );
   if(rand() & 1)
      particle->Velocity[1] = -particle->Velocity[1];
   particle->Velocity[2] = (int32)(zv * (rand() << 1));
   if(rand() & 1)
      particle->Velocity[2] = -particle->Velocity[2];
}

//==================================================================================
//
//==================================================================================
geBoolean Smoke_Shade(Procedural *Smoke)
{
        int32   *ZBuffer;
        float   *ZAge;
        uint8   *Bits;
        int             i;

        geBitmap        *Lock;

        if (!geBitmap_LockForWriteFormat(Smoke->Bitmap, &Lock, 0, 0, GE_PIXELFORMAT_8BIT_PAL))
                goto Fail;

        if (!geBitmap_GetInfo(Lock, &(Smoke->BitmapInfo),NULL) )
                goto Fail;

        if (Smoke->BitmapInfo.Format != GE_PIXELFORMAT_8BIT_PAL )
                goto Fail;

        Bits = geBitmap_GetBits(Lock);
        ZBuffer = Smoke->ZBuffer;
        ZAge = Smoke->ZAge;

        // Shade the data for the smoke using the z buffer to provide
        // occlusion information.
        for(i=0;i != Smoke->Size-5; i++, ZBuffer++, ZAge++)
        {
                int32   Result;
                int32   Val;

                if(*ZBuffer == 0)
                        continue;

                Val = *ZBuffer;

                Result = Val - *(ZBuffer-1);
                Result >>= 16;

                Result += 128;
                        
                if(Result > 255)
                        Result = 255;
                else if(Result < 0)
                        Result = 0;

                // Age the smoke particle
                Result *= (int32)*ZAge;

                Bits[i] = min(Result + Bits[i], 255);
                
                if(Val > ZBuffer[1])
                        Bits[i+1] = max(Bits[i+1]-3,0);
                if(Val > ZBuffer[2])
                        Bits[i+1] = max(Bits[i+2]-7,0);
                if(Val > ZBuffer[3])
                        Bits[i+3] = max(Bits[i+3]-10,0);
                if(Val > ZBuffer[4])
                        Bits[i+4] = max(Bits[i+4]-15,0);
                if(Val > ZBuffer[5])
                        Bits[i+5] = max(Bits[i+5]-7,0);
        }

        // Smoth the bitmap
        for(i=0;i<2;i++)
        {
                geBitmapUtil_SmoothBits(&Smoke->BitmapInfo, Bits, Bits, 1, SMOOTH_WRAP);
        }

        if (!geBitmap_UnLock(Lock))
                goto Fail;

        return GE_TRUE;

        Fail:
        {
                if (Lock )              
                        geBitmap_UnLock(Lock);

                return GE_FALSE;
        }
}

//==================================================================================
//==================================================================================
geBoolean Smoke_Update( Procedural *Smoke,
                                        int nparticles,
                                        float xp,
                                        float yp,
                                        float zp,
                                        float xv,
                                        float yv,
                                        float zv,
                                        int lightdir)
{
        int32           *ZBuffer;
        float           *ZAge;
        Smoke_Data      *Smbuf;
        int32           i;

        ZBuffer = Smoke->ZBuffer;
        ZAge = Smoke->ZAge;
        Smbuf = Smoke->Smbuf;

        // Zero the destination buffer
        memset(ZBuffer,0, Smoke->Size*sizeof(int32));
        memset(ZAge,0, Smoke->Size*sizeof(float));

        // Update Positions for all the particles in the smoke
        // and update the data in the destination buffer
        for(i=0;i<nparticles;i++)
        {
                int   x,y;
                
                if(Smbuf[i].Velocity[0] < 0x1000)
                {
                        // recreate the smoke particle if it is too old
                        Smoke_FillParticle(&Smbuf[i],xp,yp,zp,xv,yv,zv);
                        continue;
                }

                Smbuf[i].Position[0] += Smbuf[i].Velocity[0];
                Smbuf[i].Position[1] += Smbuf[i].Velocity[1];
                Smbuf[i].Position[2] += Smbuf[i].Velocity[2];

                // Damp the Velocity by a percentage of itself
                Smbuf[i].Velocity[0] -= (Smbuf[i].Velocity[0] >> 5);
                Smbuf[i].Velocity[1] -= (Smbuf[i].Velocity[1] >> 5);
                Smbuf[i].Velocity[1] -= 0x800;
                Smbuf[i].Velocity[2] -= (Smbuf[i].Velocity[2] >> 5);

                // Check if particle has moved off the texture map, and if so, recreate it
                if((Smbuf[i].Position[0]>>16) > (Smoke->Width-1))
                        Smoke_FillParticle(&(Smbuf[i]),xp,yp,zp,xv,yv,zv);
                else if ((Smbuf[i].Position[0]>>16) < 0)
                        Smoke_FillParticle(&(Smbuf[i]),xp,yp,zp,xv,yv,zv);
                else if((Smbuf[i].Position[1]>>16) > (Smoke->Height-1) || (Smbuf[i].Position[1]>>16) < 0)
                        Smoke_FillParticle((&Smbuf[i]),xp,yp,zp,xv,yv,zv);

                // Now plot this particle into the destination buffer if its Z is
                // nearer than the one currently there
                // Get integer coordinate
                x = Smbuf[i].Position[0] >> 16;
                y = Smbuf[i].Position[1] >> 16;

                // Do Z buffer operation and age the particle.
                if(Smbuf[i].Position[2] > ZBuffer[(y*Smoke->Width) + x])
                {
                        ZBuffer[(y*Smoke->Width) + x] = Smbuf[i].Position[2];
                        ZAge[(y*Smoke->Width) + x] = Smbuf[i].Velocity[0] * (2.5f / 0x30000);
                }
        }

        // Shade the smoke
        if (!Smoke_Shade(Smoke))
                return GE_FALSE;

        return GE_TRUE;
}

typedef struct
{
        float   f, a, r, g, b;
} CPoint;

static char PalStr[][256] = {
        "Smoke_PalSlime",
        "Smoke_PalFire",
        "Smoke_PalOrange",
        "Smoke_PalBlue",
};

#define PalStrTableSize (sizeof(PalStr) / sizeof(char[256]))

static CPoint CPoints[PalStrTableSize][3] =
{
        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 
        30.0f, 70.0f, 0.0f, 30.0f, 0.0f, 
        180.0f, 255.0f, 255.0f, 255.0f, 25.0f,
        
        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 
        30.0f, 70.0f, 40.0f, 0.0f, 0.0f, 
        180.0f, 255.0f, 255.0f, 255.0f, 25.0f,

        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 
        30.0f, 70.0f, 70.0f, 10.0f, 0.0f, 
        180.0f, 255.0f, 255.0f, 255.0f, 25.0f,
        
        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 
        30.0f, 60.0f, 5.0f, 5.0f, 30.0f, 
        180.0f, 255.0f, 100.0f, 100.0f, 165.0f
};

static uint16 Smoke_LerpColor(float c1, float c2, float Ratio)
{
        float   Val;

        Val = c1+(c2 - c1)*Ratio;

        Val *= 8.0f;

        if (Val > 255.0f)
                Val = 255.0f;

        return (uint16)Val;
}

//====================================================================================
//      Smoke_GetPalIndexFromString
//====================================================================================
int32 Smoke_GetPalIndexFromString(const char *Str)
{
        int32           i;

        for (i=0; i<PalStrTableSize; i++)
        {
                if (!stricmp(Str, PalStr[i]))
                        return i;
        }

        return 0;
}


//====================================================================================
//====================================================================================
geBoolean Smoke_InitBitmap(Procedural *Proc, geBitmap **ppBitmap)
{
        assert( ppBitmap);

        if ( ! *ppBitmap )
        {
                *ppBitmap = geBitmap_Create(128, 128, 1, GE_PIXELFORMAT_8BIT_PAL);
                
                if ( ! *ppBitmap )
                        return GE_FALSE;
        }
        else
        {
                geBitmap_CreateRef(*ppBitmap);
                geBitmap_SetColorKey(*ppBitmap,GE_FALSE,0,0);
        }

        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;

        if (!geBitmap_GetInfo(*ppBitmap, &Proc->BitmapInfo, NULL))
                return GE_FALSE;

        Proc->Bitmap = *ppBitmap;

        if (!Smoke_InitPalette(Proc))
                return GE_FALSE;

        Proc->Width = Proc->BitmapInfo.Width;
        Proc->Height = Proc->BitmapInfo.Height;
        Proc->Size = Proc->Width*Proc->Height;

        Proc->ZBuffer = GE_RAM_ALLOCATE_ARRAY(int32, Proc->Size);
        
        if (!Proc->ZBuffer)
                goto ExitWithError;

        Proc->ZAge = GE_RAM_ALLOCATE_ARRAY(float, Proc->Size);

        if (!Proc->ZAge)
                goto ExitWithError;

        // Clear the buffers out
        memset(Proc->ZBuffer,0, Proc->Size*sizeof(int32));
        memset(Proc->ZAge,0, Proc->Size*sizeof(float));
        memset(Proc->Smbuf, 0, NSMPARTICLES*sizeof(Smoke_Data));

        return GE_TRUE;
        
        ExitWithError:
        {
                if (Proc->ZBuffer)
                {
                        geRam_Free(Proc->ZBuffer);
                        Proc->ZBuffer = NULL;
                }
        
                if (Proc->ZAge)
                {
                        geRam_Free(Proc->ZAge);
                        Proc->ZAge = NULL;
                }
        }

        return GE_FALSE;
}

//====================================================================================
//====================================================================================
geBoolean Smoke_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;

        {
                int32   i;
                int32   NumControlPoints, Current;
                CPoint  *pPoint;

                // Fill the palette
                NumControlPoints = 3;
                
                Current = 0;

                pPoint = &CPoints[Proc->PalIndex][0];

                for (i=0; i<256; i++)
                {
                        float   Ratio;
                        int32   Next;
                        uint32  R,G,B,A;
                        uint8   *PalPtr;

                        Next = Current+1;

                        if (Next > NumControlPoints-1)
                                Next = NumControlPoints-1;

                        Ratio = (float)(i-pPoint[Current].f)/pPoint[Next].f;

                        if (Ratio > 1.0f)
                                Ratio = 1.0f;
                        else if (Ratio < 0.0f)
                                Ratio = 0.0f;

                        PalPtr = ((uint8 *)PalData) + i * gePixelFormat_BytesPerPel(PalFormat);

                        A = (uint32)Smoke_LerpColor(pPoint[Current].a, pPoint[Next].a, Ratio);
                        R = (uint32)Smoke_LerpColor(pPoint[Current].r, pPoint[Next].r, Ratio);
                        G = (uint32)Smoke_LerpColor(pPoint[Current].g, pPoint[Next].g, Ratio);
                        B = (uint32)Smoke_LerpColor(pPoint[Current].b, pPoint[Next].b, Ratio);

                        gePixelFormat_PutColor(PalFormat,&PalPtr,R,G,B,A);

                        if ((float)i >= pPoint[Next].f)
                        {
                                Current++;

                                if (Current > NumControlPoints-1)
                                        Current = NumControlPoints-1;
                        }
                }
        }

        PalData = NULL;

        if ( ! geBitmap_Palette_UnLock(Pal) )
                return GE_FALSE;

        return GE_TRUE;

fail:

        if ( PalData )
                geBitmap_Palette_UnLock(Pal);

        return GE_FALSE;

}

---