electric.c

Go to the documentation of this file.

/****************************************************************************/
/*    FILE: electric.c                                                      */
/*                                                                          */
/*    Copyright (c) 1997, Eclipse Entertainment; All rights reserved.       */
/*                                                                          */
/****************************************************************************/

#include        <windows.h>
#include        <math.h>
#include        <assert.h>

#include        "genesis.h"
#include        "ErrorLog.h"

#include        "Electric.h"
#include        "..\\Procedurals\\gebmutil.h"

extern  geFloat         EffectScale;

static  geBitmap                        *Bitmap;
static  geSound_Def *           LoopingDef;
static  geSound_Def *           SingleDef;
static  geSound_System *        SoundSys;

static geBoolean        Electric_SetWorld(geWorld *World, geVFile *Context);

typedef struct  Electric_BoltEffect
{
        int                     beInitialized;
        int                     beNumPoints;
        geFloat         beWildness;

        /* For rendering */
        geVec3d         beStart;
        geVec3d         beEnd;

        /* For generating the geometry */
        geVec3d *       beCenterPoints;
        geVec3d *       beCurrentPoint;

        geFloat         beBaseColors[3];
        geFloat         beCurrentColors[3];
        geFloat         beBaseBlue;
        int                     beDecayRate;
        int                     beDominantColor;

        int                     beWidth;

        geBitmap        *beBitmap;

}       Electric_BoltEffect;

Electric_BoltEffect * Electric_BoltEffectCreate(
        geBitmap                                *Texture,       /* The texture we map onto the bolt */
        geBitmap                                *Texture2,      /* The texture we map onto the bolt */
        int                                     NumPolys,       /* Number of polys, must be power of 2 */
        int                                             Width,          /* Width in world units of the bolt */
        geFloat                                 Wildness);      /* How wild the bolt is (0 to 1 inclusive) */

void Electric_BoltEffectDestroy(Electric_BoltEffect *Effect);

void Electric_BoltEffectAnimate(
        Electric_BoltEffect *   Effect,
        const geVec3d *                 start,          /* Starting point of the bolt */
        const geVec3d *                 end);           /* Ending point of the bolt */

void Electric_BoltEffectRender(
        geWorld *                               World,          /* World to render for */
        Electric_BoltEffect *   Effect,         /* Bolt to render */
        const geXForm3d *               XForm);         /* Transform of our point of view */

void Electric_BoltEffectSetColorInfo(
        Electric_BoltEffect *   Effect,
        GE_RGBA *                               BaseColor,              /* Base color of the bolt (2 colors should be the same */
        int                                             DominantColor); /* Which color is the one to leave fixed */

static  int             logBase2(int n)
{
        int     i = 0;

        assert(n != 0);

        while   (!(n & 1))
        {
                n = n >> 1;
                i++;
        }

        assert((n & ~1) == 0);

        return i;
}

static  geBoolean       IsPowerOf2(int n)
{
        if      (n == 0)
                return GE_TRUE;

        while   (!(n & 1))
                n = n >> 1;

        if      (n & ~1)
                return GE_FALSE;

        return GE_TRUE;
}

Electric_BoltEffect * Electric_BoltEffectCreate(
        geBitmap                *Bitmap,
        geBitmap                *Bitmap2,
        int NumPolys,
        int Width,
        geFloat Wildness)
{
        Electric_BoltEffect *   be;
        GE_RGBA                                 color;

        assert(Wildness >= 0.0f && Wildness <= 1.0f);

        /* Asserts power of 2 */
        logBase2(NumPolys);

        be = (Electric_BoltEffect *)malloc(sizeof(*be));
        if      (!be)
                return be;

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

        be->beCenterPoints = (geVec3d *)malloc(sizeof(*be->beCenterPoints) * (NumPolys + 1));
        if      (!be->beCenterPoints)
                goto fail;

        be->beBitmap    = Bitmap;
//      be->beBitmap2   = Bitmap2;
        be->beNumPoints = NumPolys;
        be->beWildness  = Wildness;
        be->beWidth             = Width;

//      color.r = 255.0f;
//      color.g = 60.0f;
//      color.b = 60.0f;
//      Electric_BoltEffectSetColorInfo(be, &color, ELECTRIC_BOLT_REDDOMINANT);

//      color.r = 60.0f;
//      color.g = 255.0f;
//      color.b = 60.0f;
//      Electric_BoltEffectSetColorInfo(be, &color, ELECTRIC_BOLT_GREENDOMINANT);

        color.r = 160.0f;
        color.g = 160.0f;
        color.b = 255.0f;
        Electric_BoltEffectSetColorInfo(be, &color, ELECTRIC_BOLT_BLUEDOMINANT);

        return be;

fail:
        if      (be->beCenterPoints)
                free(be->beCenterPoints);

        return NULL;
}

void Electric_BoltEffectDestroy(Electric_BoltEffect *Effect)
{
        free(Effect->beCenterPoints);
        free(Effect);
}

static  geFloat GaussRand(void)
{
        int     i;
        int     r;

        r = 0;

        for     (i = 0; i < 6; i++)
                r = r + rand() - rand();

        return (geFloat)r / ((geFloat)RAND_MAX * 6.0f);
}

static  void    subdivide(
        Electric_BoltEffect *   be,
        const geVec3d *                 start,
        const geVec3d *                 end,
        geFloat                                 s,
        int                                     n)
{
        geVec3d tmp;

        if      (n == 0)
        {
                be->beCurrentPoint++;
                *be->beCurrentPoint = *end;
                return;
        }
        
        tmp.X = (end->X + start->X) / 2 + s * GaussRand();
        tmp.Y = (end->Y + start->Y) / 2 + s * GaussRand();
        tmp.Z = (end->Z + start->Z) / 2 + s * GaussRand();
        subdivide(be,  start, &tmp, s / 2, n - 1);
        subdivide(be, &tmp,    end, s / 2, n - 1);
}

#define LIGHTNINGWIDTH 8.0f

static  void    genLightning(
        Electric_BoltEffect *   be,
        int                                     RangeLow,
        int                                     RangeHigh,
        const geVec3d *                 start,
        const geVec3d *                 end)
{
        geFloat length;
        int             seed;

        assert(be);
        assert(start);
        assert(end);
        assert(RangeHigh > RangeLow);
        assert(IsPowerOf2(RangeHigh - RangeLow));

        /* Manhattan length is good enough for this */
        length = (geFloat)(fabs(start->X - end->X) +
                                                fabs(start->Y - end->Y) +
                                                fabs(start->Z - end->Z));

        seed = rand();

        srand(seed);
        be->beCurrentPoint                                      = be->beCenterPoints + RangeLow;
        be->beCenterPoints[RangeLow]            = *start;
        be->beCenterPoints[RangeHigh]           = *end;
//      be->beCenterPoints[be->beNumPoints] = *end;
//      subdivide(be, start, end, length * be->beWildness, logBase2(be->beNumPoints));
        subdivide(be, start, end, length * be->beWildness, logBase2(RangeHigh - RangeLow));
}

void Electric_BoltEffectSetColorInfo(
        Electric_BoltEffect *   Effect,
        GE_RGBA *                               BaseColor,
        int                                             DominantColor)
{
        Effect->beBaseColors[0]         = BaseColor->r;
        Effect->beBaseColors[1]         = BaseColor->g;
        Effect->beBaseColors[2]         = BaseColor->b;
        Effect->beCurrentColors[0]      = BaseColor->r;
        Effect->beCurrentColors[1]      = BaseColor->g;
        Effect->beCurrentColors[2]      = BaseColor->b;
        Effect->beDominantColor         = DominantColor;
}

void Electric_BoltEffectAnimate(
        Electric_BoltEffect *   Effect,
        const geVec3d *                 start,
        const geVec3d *                 end)
{
        int             dominant;
        int             nonDominant1;
        int             nonDominant2;
        geVec3d SubdivideStart;
        geVec3d SubdivideEnd;
        int             LowIndex;
        int             HighIndex;

        Effect->beStart = *start;
        Effect->beEnd   = *end;

        dominant = Effect->beDominantColor;
        nonDominant1 = (dominant + 1) % 3;
        nonDominant2 = (dominant + 2) % 3;
        if      (Effect->beBaseColors[nonDominant1] == Effect->beCurrentColors[nonDominant1])
        {
                int     DecayRate;
                int     Spike;

                DecayRate = rand() % (int)(Effect->beBaseColors[dominant] - Effect->beBaseColors[nonDominant1]);
                DecayRate = max(DecayRate, 5);
                Effect->beDecayRate = DecayRate;
                if      (Effect->beBaseColors[nonDominant1] >= 1.0f)
                        Spike = rand() % (int)(Effect->beBaseColors[nonDominant1]);
                else
                        Spike = 0;
                Effect->beCurrentColors[nonDominant1] -= Spike;
                Effect->beCurrentColors[nonDominant2] -= Spike;
        }
        else
        {
                Effect->beCurrentColors[nonDominant1] += Effect->beDecayRate;
                Effect->beCurrentColors[nonDominant2] += Effect->beDecayRate;
                if      (Effect->beCurrentColors[nonDominant1] > Effect->beBaseColors[nonDominant1])
                {
                        Effect->beCurrentColors[nonDominant1] = Effect->beBaseColors[nonDominant1];
                        Effect->beCurrentColors[nonDominant2] = Effect->beBaseColors[nonDominant2];
                }
        }

        if      (Effect->beInitialized && Effect->beNumPoints > 16)
        {
                int             P1;
                int             P2;
                int             P3;
                int             P4;

                switch  (rand() % 7)
                {
                        case    0:
                                genLightning(Effect, 0, Effect->beNumPoints, start, end);
                                return;

                        case    1:
                        case    2:
                        case    3:
                                P1 = 0;
                                P2 = Effect->beNumPoints / 2;
                                P3 = P2 + Effect->beNumPoints / 4;
                                P4 = Effect->beNumPoints;
                                break;

                        case    4:
                        case    5:
                        case    6:
                                P1 = 0;
                                P3 = Effect->beNumPoints / 2;
                                P2 = P3 - Effect->beNumPoints / 4;
                                P4 = Effect->beNumPoints;
                                break;
                }
                SubdivideStart = Effect->beCenterPoints[P1];
                SubdivideEnd = Effect->beCenterPoints[P2];
                genLightning(Effect, P1, P2, &SubdivideStart, &SubdivideEnd);
                SubdivideStart = Effect->beCenterPoints[P2];
                SubdivideEnd = Effect->beCenterPoints[P3];
                genLightning(Effect, P2, P3, &SubdivideStart, &SubdivideEnd);
                SubdivideStart = Effect->beCenterPoints[P3];
                SubdivideEnd = Effect->beCenterPoints[P4];
                genLightning(Effect, P3, P4, &SubdivideStart, &SubdivideEnd);
        }
        else
        {
                Effect->beInitialized = 1;
                LowIndex = 0;
                HighIndex = Effect->beNumPoints;
                SubdivideStart = *start;
                SubdivideEnd   = *end;

                genLightning(Effect, LowIndex, HighIndex, &SubdivideStart, &SubdivideEnd);
        }
}

#if 0
static  void    DrawPoint(geWorld *world, geVec3d *pos, geBitmap *Bitmap, int r, int g, int b)
{
        GE_LVertex      vert;

        vert.X = pos->X;
        vert.Y = pos->Y;
        vert.Z = pos->Z;
        vert.r = (geFloat)r;
        vert.g = (geFloat)g;
        vert.b = (geFloat)b;
        vert.a = 255.0f;
        vert.u = vert.v = 0.0f;

        GE_WorldAddPolyOnce(world,
                                                &vert,
                                                1,
                                                Bitmap,
                                                GE_TEXTURED_POINT,
                                                GE_FX_TRANSPARENT,
                                                EffectScale);
}
#endif

#define LIGHTNINGALPHA  160.0f

void Electric_BoltEffectRender(
        geWorld *                               World,
        Electric_BoltEffect *   be,
        const geXForm3d *               XForm)
{
        geVec3d                 perp;
        geVec3d                 temp;
        geVec3d                 in;
        GE_LVertex              verts[4];
        int                             i;

        geVec3d_Subtract(&be->beStart, &be->beEnd, &temp);
        geXForm3d_GetIn(XForm, &in);

        geVec3d_CrossProduct(&in, &temp, &perp);
        geVec3d_Normalize(&perp);

        geVec3d_Scale(&perp, be->beWidth / 2.0f, &perp);

        /*
                We've got the perpendicular to the camera in the
                rough direction of the electric bolt center.  Walk
                the left and right sides, constructing verts, then
                do the drawing.
        */
        for     (i = 0; i < be->beNumPoints - 1; i++)
        {
                geVec3d temp;

                geVec3d_Subtract(&be->beCenterPoints[i], &perp, &temp);
                verts[0].X = temp.X;
                verts[0].Y = temp.Y;
                verts[0].Z = temp.Z;
                verts[0].u = 0.0f;
                verts[0].v = 0.0f;
                verts[0].r = be->beCurrentColors[0];
                verts[0].g = be->beCurrentColors[1];
                verts[0].b = be->beCurrentColors[2];
                verts[0].a = LIGHTNINGALPHA;

                geVec3d_Subtract(&be->beCenterPoints[i + 1], &perp, &temp);
                verts[1].X = temp.X;
                verts[1].Y = temp.Y;
                verts[1].Z = temp.Z;
                verts[1].u = 0.0f;
                verts[1].v = 1.0f;
                verts[1].r = be->beCurrentColors[0];
                verts[1].g = be->beCurrentColors[1];
                verts[1].b = be->beCurrentColors[2];
                verts[1].a = LIGHTNINGALPHA;

                geVec3d_Add(&be->beCenterPoints[i + 1], &perp, &temp);
                verts[2].X = temp.X;
                verts[2].Y = temp.Y;
                verts[2].Z = temp.Z;
                verts[2].u = 1.0f;
                verts[2].v = 1.0f;
                verts[2].r = be->beCurrentColors[0];
                verts[2].g = be->beCurrentColors[1];
                verts[2].b = be->beCurrentColors[2];
                verts[2].a = LIGHTNINGALPHA;

                geVec3d_Add(&be->beCenterPoints[i], &perp, &temp);
                verts[3].X = temp.X;
                verts[3].Y = temp.Y;
                verts[3].Z = temp.Z;
                verts[3].u = 1.0f;
                verts[3].v = 0.0f;
                verts[3].r = be->beCurrentColors[0];
                verts[3].g = be->beCurrentColors[1];
                verts[3].b = be->beCurrentColors[2];
                verts[3].a = LIGHTNINGALPHA;

                geWorld_AddPolyOnce(World,
                                                        verts,
                                                        4,
                                                        be->beBitmap,
                                                        GE_TEXTURED_POLY,
                                                        GE_RENDER_DO_NOT_OCCLUDE_OTHERS,
                                                        1.0f);

//              DrawPoint(World, &be->beCenterPoints[i], be->beTexture, 255, 0, 0);
        }
}

geBoolean Electric_Init(geEngine *Engine, geWorld *World, geVFile * MainFS, geSound_System *SoundSystem)
{
        Engine;

        if      (SoundSystem)
        {
                geVFile *       File;

                SoundSys = SoundSystem;
                assert(SoundSys);
                File = geVFile_Open(MainFS, "wav\\loopbzzt.wav", GE_VFILE_OPEN_READONLY);
                if      (!File)
                        return GE_FALSE;
                LoopingDef = geSound_LoadSoundDef(SoundSys, File);
                geVFile_Close(File);
                File = geVFile_Open(MainFS, "wav\\onebzzt.wav", GE_VFILE_OPEN_READONLY);
                if      (!File)
                        return GE_FALSE;
                
                SingleDef = geSound_LoadSoundDef(SoundSys, File);
                
                geVFile_Close(File);
                if      (!LoopingDef || !SingleDef)
                        return GE_FALSE;
        }

        if (!Electric_SetWorld(World, MainFS))
        {
                // FIXME: Free more stuff
                return GE_FALSE;
        }

        return GE_TRUE;
}

geBoolean Electric_Reset(geWorld *World)
{
        geEntity_EntitySet *    Set;
        geEntity *                              Entity;

        if      (!World)
                return GE_TRUE;
 
        Set = geWorld_GetEntitySet(World, "ElectricBolt");
        if      (Set == NULL)
                return GE_TRUE;

        Entity = geEntity_EntitySetGetNextEntity(Set, NULL);
        while   (Entity)
        {
                ElectricBolt *          Bolt;

                Bolt = geEntity_GetUserData(Entity);
                Bolt->LastTime = 0.0f;
                Bolt->LastBoltTime = 0.0f;

                Entity = geEntity_EntitySetGetNextEntity(Set, Entity);
        }

        return GE_TRUE;
}

static geBoolean Electric_SetWorld(geWorld *World, geVFile *MainFS)
{
        geEntity_EntitySet *    Set;
        geEntity *                              Entity;

        assert(World);
        assert(MainFS);

        assert(Bitmap == NULL);

        Set = geWorld_GetEntitySet(World, "ElectricBolt");

        if      (Set == NULL)
                return GE_TRUE;

        Bitmap = geBitmapUtil_CreateFromFileAndAlphaNames(MainFS, "Bmp\\Bolt.Bmp", "Bmp\\Bolt.Bmp");

        if (!Bitmap)
        {
                geErrorLog_AddString(-1, "Electric_SetWorld:  geBitmapUtil_CreateFromFileAndAlphaNames failed:", "Bmp\\Bolt.Bmp, Bmp\\Bolt.Bmp");
                return GE_FALSE;
        }

        if (!geWorld_AddBitmap(World, Bitmap))
        {
                geBitmap_Destroy(&Bitmap);
                return GE_FALSE;
        }

        Entity = geEntity_EntitySetGetNextEntity(Set, NULL);
        while   (Entity)
        {
                ElectricBolt *  Bolt;

                Bolt = geEntity_GetUserData(Entity);
                if (Bolt->Terminus == NULL)
                        {
                                #define MAX_NAME 100
                                char    EntityName[MAX_NAME];
                                char    s[MAX_NAME + 200];
                                geEntity_GetName(Entity, EntityName, MAX_NAME-1);
                                EntityName[MAX_NAME-1]=0;
                                sprintf(s,"Name='%s' Origin=%f,%f,%f",EntityName,Bolt->origin.X,Bolt->origin.Y,Bolt->origin.Z);
                                geErrorLog_AddString(-1,"Electric_SetWorld:  ElectricBolt entity has no terminius.  ",s);
                                geWorld_RemoveBitmap(World, Bitmap);
                                geBitmap_Destroy(&Bitmap);
                                return GE_FALSE;
                        }
                Bolt->Bolt = Electric_BoltEffectCreate(Bitmap,
                                                                                           NULL,
                                                                                           Bolt->NumPoints,
                                                                                           Bolt->Width,
                                                                                           Bolt->Wildness);

                Electric_BoltEffectSetColorInfo(Bolt->Bolt, &Bolt->Color, Bolt->DominantColor);

                if      (Bolt->Bolt == NULL)
                {
                        geWorld_RemoveBitmap(World, Bitmap);
                        geBitmap_Destroy(&Bitmap);
                        return GE_FALSE;
                }

                if      (!Bolt->Intermittent && SoundSys)
                {
                        Bolt->LoopingSound = geSound_PlaySoundDef(SoundSys,
                                                                                                          LoopingDef,
                                                                                                          0.0f,
                                                                                                          0.0f,
                                                                                                          0.0f,
                                                                                                          GE_TRUE);
                        if      (!Bolt->LoopingSound)
                        {
                                geWorld_RemoveBitmap(World, Bitmap);
                                geBitmap_Destroy(&Bitmap);
                                return GE_FALSE;
                        }
                }

                Entity = geEntity_EntitySetGetNextEntity(Set, Entity);
        }

        return GE_TRUE;
}

geBoolean Electric_Shutdown(void)
{
        if (LoopingDef)
        {
                geSound_FreeSoundDef(SoundSys, LoopingDef);
                LoopingDef = NULL;
        }
        
        if (SingleDef)
        {
                geSound_FreeSoundDef(SoundSys, SingleDef);
                SingleDef = NULL;
        }

        if (Bitmap)
        {
                //geWorld_RemoveBitmap(World, Bitmap);
                geBitmap_Destroy(&Bitmap);
                Bitmap = NULL;
        }

        return GE_TRUE;
}

static  geFloat frand(geFloat Low, geFloat High)
{
        geFloat Range;

        //assert(High > Low);

        Range = High - Low;

        return ((geFloat)(((rand() % 1000) + 1))) / 1000.0f * Range + Low;
}

#define LIGHTNINGSTROKEDURATION 0.05f

geBoolean Electric_Frame(geWorld *World, const geXForm3d *XForm, geFloat DeltaTime)
{
        geEntity_EntitySet *    Set;
        geEntity *                              Entity;
 
        if      (!World)
                return GE_TRUE;

        Set = geWorld_GetEntitySet(World, "ElectricBolt");
        if      (Set == NULL)
                return GE_TRUE;

        Entity = geEntity_EntitySetGetNextEntity(Set, NULL);
        while   (Entity)
        {
                ElectricBolt *  Bolt;
                geFloat                 Volume;
                geFloat                 Pan;
                geFloat                 Frequency;
                geVec3d                 MidPoint;
                int32                   Leaf;

                Bolt = geEntity_GetUserData(Entity);

                geVec3d_Subtract(&Bolt->Terminus->origin, &Bolt->origin, &MidPoint);
                geVec3d_AddScaled(&Bolt->origin, &MidPoint, 0.5f, &MidPoint);

                geWorld_GetLeaf(World, &MidPoint, &Leaf);
                
                if (geWorld_MightSeeLeaf(World, Leaf))
                {
                geSound3D_GetConfig(World,
                                                        XForm,
                                                        &MidPoint,
                                                        600.0f,
                                                        2.0f,
                                                        &Volume,
                                                        &Pan,
                                                        &Frequency);

                Bolt->LastTime += DeltaTime;

                if      (!Bolt->Intermittent ||
                         (Bolt->LastTime - Bolt->LastBoltTime > frand(Bolt->MaxFrequency, Bolt->MinFrequency)))
                {
                        Electric_BoltEffectAnimate(Bolt->Bolt,
                                                                           &Bolt->origin,
                                                                           &Bolt->Terminus->origin);

                        if      (Bolt->Intermittent && SoundSys)
                                geSound_PlaySoundDef(SoundSys, SingleDef, Volume, Pan, Frequency, GE_FALSE);

                        Bolt->LastBoltTime = Bolt->LastTime;
                }

                if      (!Bolt->Intermittent && SoundSys)
                        geSound_ModifySound(SoundSys, Bolt->LoopingSound, Volume, Pan, Frequency);

                if      (Bolt->LastTime - Bolt->LastBoltTime <= LIGHTNINGSTROKEDURATION)
                        Electric_BoltEffectRender(World, Bolt->Bolt, XForm);
                }

                Entity = geEntity_EntitySetGetNextEntity(Set, Entity);
        }

        return GE_TRUE;
}

---