plasma.c

Go to the documentation of this file.

// <> has jitter when CircleScale is very slow
//      tried some anti-aliasing, but didn't seem to help

//#define DO_TIMER

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

/*

params:

        ( circle_step, roll_step, do_alpha, do_displacement, [palette_spec] )

example :

wbm:Wall3 Plasma(0.005, 0, f, f, trig, 128,128,128,255, 5.0,1.0,5.0,0.0, 0.0,0.5,0.0,0.0 );
wbm:Wall3 Plasma(0.01,  1, f, t );

*/

// work on these :
#define SIZE_SCALE      (150.0)

#define R_PAL_STEP      (0.07)
#define G_PAL_STEP      (0.05)
#define B_PAL_STEP      (0.1)

// Plasma               : 0.001983 : 6.3 %
//              about two millis
//              == 500 fps !

#ifdef DO_TIMER
#include "timer.h"

TIMER_VARS(Plasma);
#endif

#define BM_CREATE_WIDTH         (128)
#define BM_CREATE_HEIGHT        (128)
#define BM_MAX_WIDTH            (128)
#define BM_MAX_HEIGHT           (128)
#define BM_MIN_WIDTH            (128)
#define BM_MIN_HEIGHT           (128)
        // <> to support more widths we would need to make tables for each width;
        //      really, we should do this, and also dynamically allocate all tables
        //      (make a ref count in _Create and decrement it in _Destroy)

#define TAB_WIDTH       (BM_MAX_WIDTH * 2)
#define TAB_HEIGHT      (BM_MAX_HEIGHT* 2)

geBoolean PlasmaAnimator_CreatePalette(Procedural * Proc, double time);
geBoolean PlasmaAnimator_CreatePlasma(Procedural * Proc, double time);

/**************************************************************/

Procedural *Plasma_Create(geBitmap **ppBitmap, const char *ParmStart);
void            Plasma_Destroy(Procedural *Proc);
geBoolean       Plasma_Animate(Procedural *Plasma, float ElapsedTime);

static Procedural_Table Plasma_Table = 
{
        Procedurals_Version,Procedurals_Tag,
        "Plasma",
        Plasma_Create,
        Plasma_Destroy,
        Plasma_Animate
};

Procedural_Table * Plasma_GetProcedural_Table(void)
{
        return &Plasma_Table;
}

/**********************************************************/

typedef struct Procedural
{
        geBitmap * Bitmap;
        geBoolean PlasmaPalette,Displacer;
        geBitmap * DisplaceOriginal;
        
        double  circle1,circle2,circle3,circle4,
                        circle5,circle6,circle7,circle8;
        double roll;
        double R,G,B;
        double CircleScale;
        double RollStep;
} Procedural;

/****/

Procedural *Plasma_Create(geBitmap **ppBitmap, const char *ParmStart)
{
Procedural * P;
geBoolean DoAlpha = GE_FALSE;

        P = geRam_Allocate(sizeof(Procedural));
        if ( ! P )
                return NULL;
        assert(P);
        memset(P,0,sizeof(Procedural));

        if ( ! *ppBitmap )
        {
                *ppBitmap = geBitmap_Create(BM_CREATE_WIDTH,BM_CREATE_HEIGHT,1, GE_PIXELFORMAT_8BIT_PAL);
                if ( ! *ppBitmap )
                {
                        geRam_Free(P);
                        return NULL;
                }
        }
        else
        {
                if ( ! geBitmap_SetFormat(*ppBitmap,GE_PIXELFORMAT_8BIT_PAL,GE_FALSE,0,NULL) )
                {
                        geRam_Free(P);
                        return NULL;
                }

                geBitmap_ClearMips(*ppBitmap);
                geBitmap_CreateRef(*ppBitmap);
        }

        if (geBitmap_Width( *ppBitmap) > BM_MAX_WIDTH  ||
                geBitmap_Height(*ppBitmap) > BM_MAX_HEIGHT ||
                geBitmap_Width( *ppBitmap) < BM_MIN_WIDTH  ||
                geBitmap_Height(*ppBitmap) < BM_MIN_HEIGHT )
        {
                geErrorLog_AddString(-1,"Plasm_Create : target Bitmap width not in supported ranged", NULL);
                geRam_Free(P);
                return NULL;
        }

        P->Bitmap = *ppBitmap;

        if ( ! ParmStart || strlen(ParmStart) < 10 )
        {
                P->PlasmaPalette = GE_TRUE;
                
                if ( ! PlasmaAnimator_CreatePalette(P,0.0) )
                {
                        geRam_Free(P);
                        return NULL;
                }

                P->CircleScale = 1.0;
                P->RollStep = 1.0;

#if 0           
                P->R = 1.0/6.0*PI;
                P->G = 3.0/6.0*PI;
                P->B = 5.0/6.0*PI;
#else
                P->R = (rand() % 6)/6.0*PI;
                P->G = (rand() % 6)/6.0*PI;
                P->B = (rand() % 6)/6.0*PI;
#endif
        }
        else
        {
        char * pstr;
        char ParmWork[1024];

                P->PlasmaPalette = GE_FALSE;

                strcpy(ParmWork,ParmStart);
                pstr = strtok(ParmWork," ,\n\r\r");

                P->CircleScale = atof(pstr);
                pstr = strtok(NULL," ,\n\r\r");

                P->RollStep = atof(pstr);
                pstr = strtok(NULL," ,\n\r\r");

                DoAlpha = ((toupper(*pstr) == 'T') ? GE_TRUE : atol(pstr));
                pstr = strtok(NULL," ,\n\r\r");

                P->Displacer = ((toupper(*pstr) == 'T') ? GE_TRUE : atol(pstr));
                pstr = strtok(NULL," ,\n\r\r");

                if ( ! P->Displacer )
                {
                        ParmStart += (int)(pstr - ParmWork);

                        if ( ! ProcUtil_SetPaletteFromString(P->Bitmap,(char **)&ParmStart) )
                        {
                                geBitmap_Destroy(&(P->Bitmap));
                                geRam_Free(P);
                                return NULL;
                        }
                }
        }

        if ( P->Displacer )
        {
                P->DisplaceOriginal = geBitmap_Create(BM_CREATE_WIDTH,BM_CREATE_HEIGHT,1, GE_PIXELFORMAT_8BIT_PAL);
                if ( ! P->DisplaceOriginal )
                {
                        geBitmap_Destroy(&(P->Bitmap));
                        geRam_Free(P);
                        return NULL;
                }
                geBitmap_BlitBitmap(P->Bitmap,P->DisplaceOriginal);
        }

        if ( DoAlpha )
        {
                // this is the beauty of 'set preferred format'
                //      the only difference between Plasma with and without alpha
                //      is this one call !!!
                if ( ! geBitmap_SetPreferredFormat(P->Bitmap,GE_PIXELFORMAT_16BIT_4444_ARGB) )
                        return GE_FALSE;
        }

        P->circle1 = ( rand() % 10 ) * 0.1;
        P->circle2 = ( rand() % 10 ) * 0.1;
        P->circle3 = ( rand() % 10 ) * 0.1;
        P->circle4 = ( rand() % 10 ) * 0.1;
        P->circle5 = ( rand() % 10 ) * 0.1;
        P->circle6 = ( rand() % 10 ) * 0.1;
        P->circle7 = ( rand() % 10 ) * 0.1;
        P->circle8 = ( rand() % 10 ) * 0.1;
                        
        #ifdef DO_TIMER
                timerFP = fopen("q:\\timer.log","at+");
                Timer_Start();
        #endif

return P;
}

void Plasma_Destroy(Procedural * P)
{
        if ( ! P )
                return;

        if ( P->Bitmap )
                geBitmap_Destroy(&(P->Bitmap));

        if ( P->DisplaceOriginal )
                geBitmap_Destroy(&(P->DisplaceOriginal));

        #ifdef DO_TIMER
        Timer_Stop();
        if ( timerFP )
        {
                TIMER_REPORT(Plasma);
        }
        #endif

        geRam_Free(P);
}

geBoolean Plasma_Animate(Procedural * P,float time)
{
        assert(P && P->Bitmap);

#ifdef DO_TIMER
        TIMER_P(Plasma);
#endif

        if ( P->PlasmaPalette )
        {
                if ( ! PlasmaAnimator_CreatePalette(P,time) )
                        return GE_FALSE;
        }

        if ( ! PlasmaAnimator_CreatePlasma(P,time) )
                return GE_FALSE;
        
#ifdef DO_TIMER
        TIMER_Q(Plasma);
        TIMER_COUNT();
#endif

return GE_TRUE;
}

geBoolean PlasmaAnimator_CreatePalette(Procedural *P,double time)
{
geBitmap_Palette *Pal;
void * PalData = NULL;
gePixelFormat PalFormat;
int PalSize;

        if ( ! (Pal = geBitmap_GetPalette(P->Bitmap)) )
        {

                Pal = geBitmap_Palette_Create(GE_PIXELFORMAT_32BIT_ARGB,256);
                if ( ! Pal )
                        goto fail;

                if ( ! geBitmap_SetPalette(P->Bitmap,Pal) )
                        goto fail;

                geBitmap_Palette_Destroy(&Pal);
                
                if ( ! (Pal = geBitmap_GetPalette(P->Bitmap)) )
                        return GE_FALSE;
        }

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

        {
        int p,r,g,b;
        uint8 * PalPtr;
        double R,G,B;
        float u;

                R = P->R;
                G = P->G;
                B = P->B;

                PalPtr = PalData;
                for(p=0;p<256;p++)
                {
                        u = (float)((PI/128.0) * p);

                        // <>
                        //#define mycol(u,a) (int)((max(0.0,cos((u)+(a))))*255.0)
                        #define mycol(u,a) (int)((cos((u)+(a))+1)*127.0)

                        r = mycol(u,R);
                        g = mycol(u,G);
                        b = mycol(u,B);

                        gePixelFormat_PutColor(PalFormat,&PalPtr,r,g,b,0xFF);
                }

                P->R += R_PAL_STEP * time * 30.0;
                P->G -= G_PAL_STEP * time * 30.0;
                P->B += B_PAL_STEP * time * 30.0;
        }

        PalData = NULL;

        if ( ! geBitmap_Palette_UnLock(Pal) )
                return GE_FALSE;

        return GE_TRUE;

fail:

        if ( PalData )
                geBitmap_Palette_UnLock(Pal);

        return GE_FALSE;
}

/*****

tab1 is the distance to the center of the (doubled) image (hence the corner of the original)
tab2 is basically sin(tab1)
(could save memory by making a sintable[255] instead of tab2)

sintab1[256] is too granular ; would have to use 
        int tab1[]
and sintab1[10000] or something

tables take 128k for a max size of 128x128

******/

static uint8 tab1[TAB_WIDTH * TAB_HEIGHT];
static uint8 tab2[TAB_WIDTH * TAB_HEIGHT];
static uint8 sintab1[256];
static signed char dtable[256];
static int calculated = 0;

void CalculateTables(Procedural * Proc)
{
int x,y;
uint8 *ptab1,*ptab2;
        if ( calculated )
                return;
        calculated = 1;
        ptab1 = tab1;
        ptab2 = tab2;
        for(y=0;y<TAB_HEIGHT;y++)
        {
                for(x=0;x<TAB_WIDTH;x++)
                {
                double d_to_center,r,dx,dy;

                #if 1   // TILE the texture correctly!
                #if 0
                        dx = (x%128);
                        dy = (y%128);
                        dx = 64.0 - dx;
                        dy = 64.0 - dy;
                #else
                        dx = SIZE_SCALE * sin(x*PI/128.0);
                        dy = SIZE_SCALE * cos(y*PI/128.0);
                #endif
                #else
                        dx = (TAB_WIDTH *0.5) - x;
                        dy = (TAB_HEIGHT*0.5) - y;
                #endif

                #if 0   // <> weak anti-alias
                        dx += (( rand() % 50 ) * 0.01);
                        dy += (( rand() % 50 ) * 0.01);
                        r = (( rand() % 50 ) * 0.01);
                #else
                        r = 0.4;
                #endif

                        d_to_center = sqrt( 16.0 + dx*dx + dy*dy ) - 4.0;
                        *ptab1++ = (uint8)(d_to_center * 5.0 + r );
                        *ptab2++= (uint8)((sin(d_to_center/9.5)+1.0)*90.0 + r);
                }
        }

        for(x=0;x<256;x++)
        {
                sintab1[x] = (uint8)((sin(x/(5.0*9.5))+1.0)*90.0 + 0.5);
                dtable[x] = (signed char)(sin(x*2.0*PI/256) * 16.0);
        }
}

int DoCircle(double * pCircle, double step, int w, int doCos);

geBoolean PlasmaAnimator_CreatePlasma(Procedural * Proc,double time)
{
geBitmap *PlasmaLock=NULL;
geBitmap_Info PlasmaInfo;
uint8 *Bits,*bptr;
int x,y,w,h,s;
geBitmap *Bitmap;

        Bitmap = Proc->Bitmap;
        assert(Bitmap);
        
        CalculateTables(Proc);

        geBitmap_SetGammaCorrection(Bitmap, 1.0f, GE_FALSE);

        if ( ! geBitmap_LockForWriteFormat(Bitmap,&PlasmaLock,0,0,GE_PIXELFORMAT_8BIT_PAL) )
                goto fail;

        if ( ! geBitmap_GetInfo(PlasmaLock,&PlasmaInfo,NULL) )
                goto fail;

        Bits = geBitmap_GetBits(PlasmaLock);

        if ( ! Bits )
                goto fail; 

        w = PlasmaInfo.Width;
        h = PlasmaInfo.Height;
        s = PlasmaInfo.Stride;

        // could do every other pixel & smooth
        // main advantage : smaller table

        {
        int     x1,y1,x2,y2,
                x3,y3,x4,y4,
                o1,o2,o3,o4;
        uint8 *ptab1,*ptab2;
        uint8 roll;
        double CircleScale;

                CircleScale = Proc->CircleScale * time * 2.0;

                x1 = DoCircle(&(Proc->circle1),0.3  * CircleScale,w,1);
                y1 = DoCircle(&(Proc->circle2),0.2  * CircleScale,h,0);
                y2 = DoCircle(&(Proc->circle4),0.1  * CircleScale,h,1);
                x2 = DoCircle(&(Proc->circle3),0.85 * CircleScale,w,0);
                x3 = DoCircle(&(Proc->circle5),0.4  * CircleScale,w,1);
                y3 = DoCircle(&(Proc->circle6),0.15 * CircleScale,h,0);
                x4 = DoCircle(&(Proc->circle7),0.35 * CircleScale,w,1);
                y4 = DoCircle(&(Proc->circle8),0.05 * CircleScale,h,0);

                o1 = x1 + TAB_WIDTH*y1;
                o2 = x2 + TAB_WIDTH*y2;
                o3 = x3 + TAB_WIDTH*y3;
                o4 = x4 + TAB_WIDTH*y4;

                roll = (uint8)( Proc->roll + 0.5);
                Proc->roll += Proc->RollStep * time * 30.0;
                        // roll uses the fact that we work modulo 255

                // this is the inner loop;
                // it's very lean, but also not blazing fast, cuz
                //  this is very bad on the cache
                // we have we have FIVE different active segments of memory,
                //      (bptr,ptab1+o1,ptab2+o2,ptab2+o3,ptab2+o4) all of which are
                // too large to fit in the L1 cache, so each mem-hit is 4 clocks

                if ( Proc->Displacer )
                {
                geBitmap *Source,*SourceLock;
                geBitmap_Info SourceInfo;
                void * SourceBits;
                int ss;
                uint8 * sptr;
                        // instensity is a displacement
                
                        Source = Proc->DisplaceOriginal;
                        assert(Source);

                        if ( ! geBitmap_LockForReadNative(Source,&SourceLock,0,0) )
                                goto fail;

                        if ( ! geBitmap_GetInfo(SourceLock,&SourceInfo,NULL) )
                                goto fail;

                        if ( ! (SourceBits = geBitmap_GetBits(SourceLock)) )
                                goto fail; 

                        assert( SourceInfo.Width == w);
                        assert( SourceInfo.Height == h);
                        ss = SourceInfo.Stride;

                        bptr = Bits;
                        sptr = SourceBits;
                        for(y=0;y<h;y++)
                        {
                                ptab1 = tab1 + TAB_WIDTH*y;
                                ptab2 = tab2 + TAB_WIDTH*y;
                                for(x=0;x<w;x++)
                                {
                                int o,sx;
                                        o = ptab1[o1] + ptab2[o2] + ptab2[o3] + ptab2[o4];
                                        o = (o + roll)&0xFF;
                                        o = dtable[o];
                                        ptab1++;
                                        ptab2++;

                                        sx = x + o;
                                        if ( sx < 0 ) sx += w;
                                        else if ( sx >= w ) sx -= w;
                                        assert( sx >= 0 && sx < w );
                                        *bptr++ = sptr[sx];
                                }
                                bptr += (s-w);
                                sptr += ss;
                        }

                        geBitmap_UnLock(SourceLock);
                }
                else
                {
                        // classic style

                        bptr = Bits;
                        if ( PlasmaInfo.HasColorKey )
                        {
                        uint8 CK,pel;
                                CK = (uint8)PlasmaInfo.ColorKey;
                                if ( CK > 200 )
                                {
                                        for(y=0;y<h;y++)
                                        {
                                                ptab1 = tab1 + TAB_WIDTH*y;
                                                ptab2 = tab2 + TAB_WIDTH*y;
                                                for(x=w;x--;)
                                                {
                                                        pel = roll + ptab1[o1] + 
                                                                        ptab2[o2] + ptab2[o3] + ptab2[o4];

                                                        *bptr++ = pel%CK;
                                                        ptab1++;
                                                        ptab2++;
                                                }
                                                bptr += (s-w);
                                        }
                                }
                                else
                                {
                                        for(y=0;y<h;y++)
                                        {
                                                ptab1 = tab1 + TAB_WIDTH*y;
                                                ptab2 = tab2 + TAB_WIDTH*y;
                                                for(x=w;x--;)
                                                {
                                                        pel = roll + ptab1[o1] + 
                                                                        ptab2[o2] + ptab2[o3] + ptab2[o4];

                                                        if ( pel == CK )
                                                                pel ^= 1;

                                                        *bptr++ = pel;
                                                        ptab1++;
                                                        ptab2++;
                                                }
                                                bptr += (s-w);
                                        }
                                }
                        }
                        else
                        {
                                for(y=0;y<h;y++)
                                {
                                        ptab1 = tab1 + TAB_WIDTH*y;
                                        ptab2 = tab2 + TAB_WIDTH*y;
                                        for(x=w;x--;)
                                        {
                                                *bptr++ = roll + ptab1[o1] + 
                                                                ptab2[o2] + ptab2[o3] + ptab2[o4];
                                                ptab1++;
                                                ptab2++;
                                        }
                                        bptr += (s-w);
                                }
                        }
                }
        }

/*
        if ( ! geBitmapUtil_SmoothBits(&PlasmaInfo,Bits,Bits,1) )
                goto fail;
*/

        if ( ! geBitmap_UnLock(PlasmaLock) )
                goto fail;

        return GE_TRUE;
fail:

        if ( PlasmaLock )               geBitmap_UnLock(PlasmaLock);

        return GE_FALSE;
}


int DoCircle(double * pCircle, double step, int w, int doCos)
{
double cp,c,cn;
double xp,x,xn;
int ix,ixp,ixn;
        
        w--;

        // try to do temporal anti-aliasing
        // <> doesn't seem to help

        c = *pCircle;
        cp = c - step;
        cn = c + step;

        *pCircle += step;

        if ( doCos )
        {
                x  = w*0.5*(1.0 + cos(c));
                xp = w*0.5*(1.0 + cos(cp));
                xn = w*0.5*(1.0 + cos(cn));
        }
        else
        {
                x  = w*0.5*(1.0 + sin(c));
                xp = w*0.5*(1.0 + sin(cp));
                xn = w*0.5*(1.0 + sin(cn));
        }

        ixn = (int)xn;
        ixp = (int)xp;
        
        if ( ixp == ixn )
        {
                ix = ixp;
        }
        else
        {
                x += ( rand() % 50 ) * 0.01;
                ix = (int)((x + ixp + ixn)*(1.0/3.0));
        }

        assert( ix >= 0 && ix <= w );

return ix;
}

---