ElectricFx.c

Go to the documentation of this file.

/****************************************************************************************/
/*  ElectricFx.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"

#include "Errorlog.h"

#define SMOOTH_WRAP GE_TRUE

#define         PI              (3.14159f)
#define         PI_2    (PI*2)

#define         ELECTRICFX_MAX_FX_TYPES 128
#define         ELECTRICFX_MAX_VECS             128

#define         TOKEN_SEPERATOR         " ,"
//#define               TOKEN_SEPERATOR         " \t,+\n\r"

//====================================================================================
//====================================================================================
typedef struct
{
        int32           x, y;
} ElectricFx_Vec2d;

typedef enum
{
        Fx_Line = 0,
        Fx_LineSpin,
        Fx_Sparkle,
        Fx_EnergySpin
} ElectricFx_Type;

typedef struct
{
        ElectricFx_Type Type;                   // Type of fx
        char                    Str[256];               // String name
        int32                   NumVecs;                // Number of vecs required to run fx
} ElectricFx_TypeData;

typedef struct
{
        ElectricFx_TypeData             *TypeData;
        ElectricFx_Vec2d                Vecs[2];

        float                                   Rotation;
} ElectricFx_Fx;

ElectricFx_TypeData FxTypeDataTable[] = 
{
        {Fx_Line, "Fx_Line", 2},
        {Fx_LineSpin, "Fx_LineSpin", 1},
        {Fx_Sparkle, "Fx_Spark", 1},
        {Fx_EnergySpin, "Fx_EnergySpin", 1}
};

typedef struct Procedural
{
        geBitmap                        *Bitmap;
        geBitmap_Info           BitmapInfo;

        int32                           Width;
        int32                           Height;
        int32                           Size;
        int32                           WMask;
        int32                           HMask;

        uint8                           *ZBuffer;                               

        uint16                          CLut[256];

        int32                           PalIndex;

        int32                           NumFx;
        ElectricFx_Fx           Fx[ELECTRICFX_MAX_FX_TYPES];

} Procedural;

static int32 FxTypeDataTableSize = (sizeof(FxTypeDataTable)/sizeof(ElectricFx_TypeData));

void            ElectricFx_Destroy(Procedural *Proc);
geBoolean       ElectricFx_Animate(Procedural *Fx, float ElapsedTime);
geBoolean       ElectricFx_Shade(Procedural *Fx);
void            ElectricFx_Update(Procedural *Fx, float Time);

ElectricFx_TypeData *ElectricFx_GetFxTypeDataFromString(const char *Str);
int32 ElectricFx_GetPalIndexFromString(const char *Str);
geBoolean       ElectricFx_FxParseData(ElectricFx_Fx *Fx);

geBoolean       ElectricFx_InitPalette(Procedural *Proc);
geBoolean       ElectricFx_InitBitmap(Procedural *Fx, geBitmap **ppBitmap);

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

        assert(Bitmap);
        assert(StrParms);

        Proc = GE_RAM_ALLOCATE_STRUCT(Procedural);

        if (!Proc)
                goto ExitWithError;

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

        // Parse the params...
        {
                char            *Token;
                char            Parms[1024];

                strcpy(Parms, StrParms);
                
                Token = strtok(Parms, TOKEN_SEPERATOR);

                if (!Token)             // If nothing was passed in, then default it to something cool
                {
                        //strcpy(Parms, "Fx_PalSlime, Fx_Line, 0, 0, 127, 127, 127, 0, 127, 0");
                        strcpy(Parms, "Fx_PalSlime, Fx_EnergySpin, 63, 63");

                        Token = strtok(Parms, TOKEN_SEPERATOR);

                        assert(Token);
                }

                Proc->PalIndex = ElectricFx_GetPalIndexFromString(Token);

                Token = strtok(NULL, TOKEN_SEPERATOR);

                //if (!Token)
                
                while(Token)
                {
                        ElectricFx_Fx   *Fx;

                        if (Proc->NumFx >= ELECTRICFX_MAX_FX_TYPES)
                                break;          // No more room for more fx...

                        Fx = &Proc->Fx[Proc->NumFx++];

                        Fx->TypeData = ElectricFx_GetFxTypeDataFromString(Token);

                        if (!Fx->TypeData)
                        {
                                geErrorLog_AddString(-1, "ElectricFx_Create:  Invalid FxType:", Token);
                                goto ExitWithError;
                        }

                        if (!ElectricFx_FxParseData(Fx))
                        {
                                geErrorLog_AddString(-1, "ElectricFx_Create:  ElectricFx_FxParseData failed.", NULL);
                                goto ExitWithError;
                        }

                        Token = strtok(NULL, TOKEN_SEPERATOR);
                }
        }

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

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

        return Proc;

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

                return NULL;
        }
}

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

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

        geRam_Free(Proc);
}

//====================================================================================
//      ElectricFx_Animate
//====================================================================================
geBoolean ElectricFx_Animate(Procedural *Fx, float ElapsedTime)
{
        if (!Fx->Bitmap)
                return GE_TRUE;

        ElectricFx_Update(Fx, ElapsedTime);

        // Shade the Fx
        if (!ElectricFx_Shade(Fx))
                return GE_FALSE;

        return GE_TRUE;
}

//====================================================================================
//====================================================================================
static Procedural_Table ElectricFx_Table = 
{
        Procedurals_Version,Procedurals_Tag,
        "ElectricFx",
        ElectricFx_Create,
        ElectricFx_Destroy,
        ElectricFx_Animate
};

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

//====================================================================================
//====================================================================================
Procedural_Table *ElectricFx_GetProcedural_Table(void)
{
        return &ElectricFx_Table; 
}

//                                                                         //
// sgn() - This function is used by Line() to determine the sign of a long //
//                                                                         //

int sgn (long a) 
{
        if (a > 0) 
                return +1;
        else if (a < 0) 
                return -1;
        else 
                return 0;
}


//                                                                         //
// round() - This function is used by Line() to round a long to the        //
//           nearest integer.                                              //
//                                                                         //

int round (long a) 
{
        if ( (a - (int)a) < 0.5) 
                return (int)floor(a);
        else 
                return (int)ceil(a);
}


void ElectricFx_PutZ(Procedural *Fx, int x, int y, int ZVal, float ZAge) 
{
        Fx->ZBuffer[(y&Fx->HMask)*Fx->Width+(x&Fx->WMask)] = ZVal;
}


//                                                                         //
// Line() - This draws a line from a,b to c,d of color col.                //
//          This function will be explained in more detail in tut3new.zip  //
//                                                                         //
void ElectricFx_ZLine(Procedural *Fx, int a, int b, int c, int d, int32 ZVal, float ZAge) 
{

        long    u,s,v,d1x,d1y,d2x,d2y,m,n;
        int             i;

        u   = c-a;                      // x2-x1
        v   = d-b;                      // y2-y1
        d1x = sgn(u);           // d1x is the sign of u (x2-x1) (VALUE -1,0,1)
        d1y = sgn(v);           // d1y is the sign of v (y2-y1) (VALUE -1,0,1)
        d2x = sgn(u);           // d2x is the sign of u (x2-x1) (VALUE -1,0,1)
        d2y = 0;
        m   = abs(u);           // m is the distance between x1 and x2
        n   = abs(v);           // n is the distance between y1 and y2

        if (m<=n)                       // if the x distance is greater than the y distance
        {     
                d2x = 0;
                d2y = sgn(v);   // d2y is the sign of v (x2-x1) (VALUE -1,0,1)
                m   = abs(v);   // m is the distance between y1 and y2
                n   = abs(u);   // n is the distance between x1 and x2
        }

        s = (int)(m>>1);                                                // s is the m distance (either x or y) divided by 2

        for (i=round(m); i>0; i--)                              // repeat this loop until it
        { 
                                                                                        // is = to m (y or x distance)
                ElectricFx_PutZ(Fx, a, b, ZVal, ZAge);// plot a pixel at the original x1, y1

                s += n;                                                         // add n (dis of x or y) to s (dis of x of y)
                if (s >= m)                                                     // if s is >= m (distance between y1 and y2)
                {  
                        s -= m;
                        a += d1x;
                        b += d1y;
                }
                else 
                {
                        a += d2x;
                        b += d2y;
                }
        }

}


void ElectricFx_ZLine2(Procedural *Fx, int x1, int y1, int x2, int y2, int32 ZVal, float ZAge) 
{

        int             x, y, xlength, ylength, dx, dy;
        float   xslope, yslope;

        xlength = abs(x1-x2);

        if ((x1-x2)  < 0) dx = -1;
        if ((x1-x2) == 0) dx =  0;
        if ((x1-x2)  > 0) dx = +1;

        ylength = abs(y1-y2);
        if ((y1-y2)  < 0) dy = -1;
        if ((y1-y2) == 0) dy =  0;
        if ((y1-y2)  > 0) dy = +1;

        if (dy == 0) 
        {
                if (dx < 0)
                        for (x=x1; x<x2+1; x++)
                                ElectricFx_PutZ(Fx, x, y1, ZVal, ZAge);
                if (dx > 0)
                        for (x=x2; x<x1+1; x++)
                                ElectricFx_PutZ(Fx, x, y1, ZVal, ZAge);
        }

        if (dx == 0) 
        {
                if (dy < 0)
                        for (y=y1; y<y2+1; y++)
                                ElectricFx_PutZ(Fx, x1, y, ZVal, ZAge);
                if (dy > 0)
                        for (y=y2; y<y1+1; y++)
                                ElectricFx_PutZ(Fx, x1, y, ZVal, ZAge);
        }

        if ((xlength != 0) && (ylength != 0)) 
        {
                xslope = (float)xlength/(float)ylength;
                yslope = (float)ylength/(float)xlength;
        }
        else 
        {
                xslope = 0.0f;
                yslope = 0.0f;
        }

        if ((xslope != 0) && (yslope != 0) && (yslope/xslope < 1) && (yslope/xslope > -1)) 
        {
                if (dx < 0)
                {
                        for (x=x1; x<x2+1; x++) 
                        {
                                y = round((int)(yslope*x));
                                ElectricFx_PutZ(Fx, x, y, ZVal, ZAge);
                        }
                }
                if (dx > 0)
                {
                        for (x=x2; x<x1+1; x++) 
                        {
                                y = round((int)(yslope*x));
                                ElectricFx_PutZ(Fx, x, y, ZVal, ZAge);
                        }
                }
        }
        else 
        {
                if (dy < 0)
                {
                        for (y=x1; y<x2+1; y++) 
                        {
                                x = round((int)(xslope*y));
                                ElectricFx_PutZ(Fx, x, y, ZVal, ZAge);
                        }
                }
                if (dy > 0)
                {
                        for (y=x2; y<x1+1; y++) 
                        {
                                x = round((int)(xslope*y));
                                ElectricFx_PutZ(Fx, x, y, ZVal, ZAge);
                        }
                }
        }

}

//==================================================================================
//      ElectricFx_ElectricZLine_r
//==================================================================================
void ElectricFx_ElectricZLine_r(        Procedural *Fx, 
                                                        int32 x1, int32 y1, 
                                                        int32 x2, int32 y2, 
                                                        int32 ZVal, float ZAge,
                                                        int32 Recursion)
{
        if (Recursion > 0)
        {
                int32   MidX, MidY;

                MidX = (x1+x2)>>1;
                MidY = (y1+y2)>>1;

                MidX += 8 - (rand()&15);
                MidY += 8 - (rand()&15);
                /*
                if (MidX < 0)
                        MidX = 0;
                else if (MidX >= Fx->Width)
                        MidX = Fx->Width-1;
        
                if (MidY < 0)
                        MidY = 0;
                else if (MidY >= Fx->Height)
                        MidY = Fx->Height-1;
                */

                ElectricFx_ElectricZLine_r(Fx, x1, y1, MidX, MidY, ZVal, ZAge, Recursion>>1);
                ElectricFx_ElectricZLine_r(Fx, MidX, MidY, x2, y2, ZVal, ZAge, Recursion>>1);
        }
        else
        {
                ElectricFx_ZLine(Fx, x1, y1, x2, y2, ZVal, ZAge);
        }
}

//==================================================================================
//
//==================================================================================
geBoolean ElectricFx_Shade(Procedural *Fx)
{
        uint8           *ZBuffer;
        uint8           *Bits;
        int32           i;
        geBitmap        *Lock;

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

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

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

        Bits = geBitmap_GetBits(Lock);
        ZBuffer = Fx->ZBuffer;

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

                if(*ZBuffer == 0)
                        continue;

        #if 1
                Val = (int32)*ZBuffer;

                Result = Val;// - *(ZBuffer-1);

                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);
        #else
                Val = *ZBuffer;

                Result = Val;

                Bits[i] = min(Result + Bits[i], 255);
        #endif

        }

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

        if ( ! geBitmap_UnLock(Lock) )
                goto Fail;

        return GE_TRUE;

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

                return GE_FALSE;
        }

}

//==================================================================================
//==================================================================================
void ElectricFx_Update(Procedural *EFx, float Time)
{
        uint8                   *ZBuffer;
        ElectricFx_Fx   *Fx;
        int32                   i;

        ZBuffer = EFx->ZBuffer;

        // Zero the destination buffer
        memset(ZBuffer,0, EFx->Size*sizeof(uint8));

        Fx = EFx->Fx;

        for (i=0; i< EFx->NumFx; i++, Fx++)
        {
                assert(Fx->TypeData);

                switch(Fx->TypeData->Type)
                {
                        case Fx_Line:
                        {
                                ElectricFx_Vec2d        *pVec1, *pVec2;

                                pVec1 = &Fx->Vecs[0];
                                pVec2 = &Fx->Vecs[1];
                                
                                ElectricFx_ElectricZLine_r(EFx, pVec1->x, pVec1->y, pVec2->x, pVec2->y, 54, 1.0f, 16);
                                break;
                        }

                        case Fx_Sparkle:
                        {
                                int32   i;

                                for (i=0; i<3; i++)
                                {
                                        int32           x, y;
                                        float           r;

                                        r = ((float)i/6.0f)*PI_2;

                                        r += 2.0f - ((float)rand()/RAND_MAX)*4.0f;
                                
                                        x = (int32)(cos(r)*60.0f);
                                        y = (int32)(sin(r)*60.0f);

                                        x += Fx->Vecs[0].x;
                                        y += Fx->Vecs[0].y;

                                        ElectricFx_ElectricZLine_r(EFx, Fx->Vecs[0].x, Fx->Vecs[0].y, x, y, 64, 1.0f, 4);
                                }
                                break;
                        }

                        case Fx_EnergySpin:
                        {
                                int32                           j;
                                ElectricFx_Vec2d        *pVec;

                                pVec = Fx->Vecs;

                                for (j=0; j<Fx->TypeData->NumVecs; j++, pVec++)
                                {
                                        int32   i, x, y;
                                        float   r;

                                        for (i=0; i<3; i++)
                                        {
                                                float   Val;

                                                r = Fx->Rotation;
                                
                                                Val = ((float)i/3) * PI_2;

                                                r += Val;
                                
                                                x = (int32)(cos(r)*63.0f);
                                                y = (int32)(sin(r)*63.0f);

                                                x += pVec->x;
                                                y += pVec->y;

                                                ElectricFx_ElectricZLine_r(EFx, pVec->x, pVec->y, x, y, 74, 1.0f, 8);
                                        }
                                }

                                Fx->Rotation += 2.0f*Time;              // 2 radians per sec

                                if (Fx->Rotation > PI_2)
                                        Fx->Rotation -= PI_2;

                                break;
                        }
                        default:
                        {
                                break;
                        }
                }
        }
}

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

static char PalStr[][256] = {
        "Fx_PalSlime",
        "Fx_PalFire",
        "Fx_PalOrange",
        "Fx_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 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;
}

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

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

        return 0;
}

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

        for (i=0; i<FxTypeDataTableSize; i++)
        {
                if (!stricmp(Str, FxTypeDataTable[i].Str))
                        return &FxTypeDataTable[i];
        }

        return NULL;
}

//====================================================================================
//      ElectricFx_FxParseData
//====================================================================================
geBoolean ElectricFx_FxParseData(ElectricFx_Fx *Fx)
{
        int32   VecNum;
        char    *Token;

        assert(Fx);

        VecNum = 0;
        
        while (1)
        {
                // Parse the first token
                Token = strtok(NULL, TOKEN_SEPERATOR);

                assert(ElectricFx_GetFxTypeDataFromString(Token) == NULL);

                if (!Token)
                        return GE_FALSE;

                Fx->Vecs[VecNum].x = atoi(Token);
                
                // Parse the second token
                Token = strtok(NULL, TOKEN_SEPERATOR);

                assert(ElectricFx_GetFxTypeDataFromString(Token) == NULL);

                if (!Token)
                        return GE_FALSE;

                Fx->Vecs[VecNum].y = atoi(Token);

                VecNum++;

                if (VecNum >= Fx->TypeData->NumVecs)
                        break;
        }
        
        return GE_TRUE;
}

//====================================================================================
//====================================================================================
geBoolean ElectricFx_InitBitmap(Procedural *Fx, 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);
        }

        if (!geBitmap_SetFormat(*ppBitmap,GE_PIXELFORMAT_8BIT_PAL,GE_TRUE,255,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, &Fx->BitmapInfo, NULL))
                return GE_FALSE;

        Fx->Bitmap = *ppBitmap;

        if (!ElectricFx_InitPalette(Fx))
                return GE_FALSE;

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

        Fx->WMask = Fx->Width-1;
        Fx->HMask = Fx->Height-1;

        Fx->ZBuffer = GE_RAM_ALLOCATE_ARRAY(uint8, Fx->Size);

        if (!Fx->ZBuffer)
                return GE_FALSE;

        // Clear the buffers out
        memset(Fx->ZBuffer,0, Fx->Size*sizeof(uint8));

        return GE_TRUE;
}

//====================================================================================
//====================================================================================
geBoolean ElectricFx_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)LerpColor(pPoint[Current].a, pPoint[Next].a, Ratio);
                        R = (uint32)LerpColor(pPoint[Current].r, pPoint[Next].r, Ratio);
                        G = (uint32)LerpColor(pPoint[Current].g, pPoint[Next].g, Ratio);
                        B = (uint32)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;

}

---