Water.c

Go to the documentation of this file.

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

typedef struct Procedural
{
        float           PosX;
        float           PosY;
        float           Angle;
        float           TimeToSplashWater;

        int32           NPage;

        uint16          *OriginalBits;
        int16           *WaterData[2];

        geBitmap        *Bitmap;

        int32           Width;
        int32           Height;
        int32           Size;

        uint8           BlendLut[32][32];
} Procedural;

Procedural *Water_Create(geBitmap **Bitmap, const char *StrParms);
void Water_Destroy(Procedural *Water);
geBoolean Water_Animate(Procedural *Water, float ElapsedTime);
geBoolean Water_ApplyToBitmap(Procedural *Water);
void Water_Update(Procedural *Water, float Time);
void Water_BuildRGBLuts(Procedural *Water, float RScale, float GScale, float BScale);

//====================================================================================
//      Water_Create
//====================================================================================
Procedural *Water_Create(geBitmap **Bitmap, const char *StrParms)
{
        Procedural      *Water;

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

        Water = GE_RAM_ALLOCATE_STRUCT(Procedural);

        if (!Water)
                goto ExitWithError;

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

        if (*Bitmap)
        {
                Water->Bitmap = *Bitmap;

                geBitmap_CreateRef(Water->Bitmap);
        }
        else
        {
                // Must make bitmap for tha caller!!!
                goto ExitWithError;
        }

        // We need this to be only 1 miplevel!!!
        if (!geBitmap_ClearMips(Water->Bitmap))
                goto ExitWithError;
        
        {
                // We need to change the format of this bitmap to a 565 in the world (hope he doesn't mind ;)
                gePixelFormat   Format;
                geBitmap_Info   Info;
                int32                   i;

                Format = GE_PIXELFORMAT_16BIT_565_RGB;

                if (!geBitmap_SetFormat(Water->Bitmap, Format, GE_FALSE, 0, NULL))
                        goto ExitWithError;

                if (!geBitmap_GetInfo(Water->Bitmap, &Info, NULL))
                        goto ExitWithError;

                Water->Width = Info.Width;
                Water->Height = Info.Height;
                Water->Size = Water->Width*Water->Height;

                Water->OriginalBits = GE_RAM_ALLOCATE_ARRAY(uint16, Water->Size);

                if (!Water->OriginalBits)
                        goto ExitWithError;

                for (i=0; i<2; i++)
                {
                        Water->WaterData[i] = GE_RAM_ALLOCATE_ARRAY(int16, Water->Size);

                        if (!Water->WaterData[i])
                                goto ExitWithError;

                        memset(Water->WaterData[i], 0, sizeof(int16)*Water->Size);
                }

        }

        // Get the original bits...
        {
                geBitmap                *Src;
                uint16                  *pSrc16;
                int32                   i;
                geBitmap_Info   Info;

                if (!geBitmap_GetInfo(Water->Bitmap, &Info, NULL))
                        goto ExitWithError;

                if (!geBitmap_LockForRead(Water->Bitmap, &Src, 0, 0, Info.Format, GE_TRUE, 255))
                        goto ExitWithError;
                
                pSrc16 = geBitmap_GetBits(Src);

                for (i=0; i<Water->Size; i++)
                        Water->OriginalBits[i] = pSrc16[i];

                if (!geBitmap_UnLock(Src))
                        goto ExitWithError;
                
        }

        Water_BuildRGBLuts(Water, 1.0f, 1.0f, 1.0f);

        return Water;

        ExitWithError:
        {
                if (Water)
                        Water_Destroy(Water);

                return NULL;
        }
}

//====================================================================================
//      Water_Destroy
//====================================================================================
void Water_Destroy(Procedural *Water)
{
        assert(Water);

        if (Water->Bitmap)
        {
                geBitmap_Destroy(&Water->Bitmap);
                Water->Bitmap = NULL;
        }
        
        if (Water->OriginalBits)
                geRam_Free(Water->OriginalBits);
        Water->OriginalBits = NULL;

        if (Water->WaterData[0])
                geRam_Free(Water->WaterData[0]);
        Water->WaterData[0] = NULL;

        if (Water->WaterData[1])
                geRam_Free(Water->WaterData[1]);
        Water->WaterData[1] = NULL;

        geRam_Free(Water);
}

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

        Water_Update(Water, ElapsedTime);

        if (!Water_ApplyToBitmap(Water))
                return GE_FALSE;

        return GE_TRUE;
}

//====================================================================================
//====================================================================================
geBoolean Water_ApplyToBitmap(Procedural *Water)
{
        geBitmap                *Dest;
        uint8                   *pBlendLut;

        assert(Water->Bitmap);

#if 0 //@@ CB BUG Fix!
        {
        geBitmap_Info   MainInfo, Secondary;
        //if (!geBitmap_GetInfo(Water->Bitmap, &Secondary, &MainInfo))
        if (!geBitmap_GetInfo(Water->Bitmap, &MainInfo, &Secondary))
                return GE_FALSE;

        assert(MainInfo.MaximumMip == 0);

        if (MainInfo.Format != GE_PIXELFORMAT_16BIT_565_RGB)
                return GE_TRUE;                 // Oh well...
        
        if (!geBitmap_LockForWrite(Water->Bitmap, &Dest, 0, 0))
                return GE_FALSE;
        }
#else
        if (!geBitmap_LockForWriteFormat(Water->Bitmap, &Dest, 0, 0, GE_PIXELFORMAT_16BIT_565_RGB))
                return GE_FALSE;
                
#endif

        pBlendLut = &Water->BlendLut[0][0];
        
        {
                uint16                  *pSrc16, *pDest16;
                int16                   *pWSrc16, *pOriginalWSrc16;
                int32                   w, h, Extra, WMask, HMask;
                geBitmap_Info   Info;

        //      if (!geBitmap_GetInfo(Dest, &Secondary, &Info)) // CB BUG Fix!
                if (!geBitmap_GetInfo(Dest, &Info, NULL))
                        return GE_FALSE;
                
                assert(Info.Format == GE_PIXELFORMAT_16BIT_565_RGB);

                Extra = Info.Stride - Info.Width;

                WMask = Info.Width - 1;
                HMask = Info.Height - 1;
                
                pSrc16 = Water->OriginalBits;
                pOriginalWSrc16 = pWSrc16 = Water->WaterData[Water->NPage];
                pDest16 = geBitmap_GetBits(Dest);

                // For the love of God, write this in assembly
                for (h=0; h< Info.Height; h++)
                {
                        for (w=0; w< Info.Width; w++)
                        {
                                int32   x, y, Val;
                                uint16  r, g, b;
                                uint16  Color;

                                Val = pWSrc16[w];
                                 
                                if (h < Info.Height-1)
                                        y = Val - pWSrc16[w+Info.Stride];
                                else
                                        y = Val - pOriginalWSrc16[w];

                                x = Val - pWSrc16[(w+1)&WMask];
                        #if 1
                                Val = 127 - (y<<4);

                                if (Val < 0) 
                                        Val = 0;
                                else if (Val > 255) 
                                        Val = 255;

                                Val >>= 3;
                                Val <<= 5;
                        #endif
                                
                                x >>= 4;         
                                y >>= 4;

                                Color = pSrc16[((h+y)&HMask)*Info.Stride + ((w+x)&WMask)];
                                
                        #if 1
                                r = (uint16)pBlendLut[Val+((Color>>11)&31)];
                                g = (uint16)pBlendLut[Val+((Color>>6)&31)];
                                b = (uint16)pBlendLut[Val+(Color&31)];
                                
                                *pDest16++ = (r<<11) | (g<<6) | b;
                        #else
                                *pDest16++ = Color;
                        #endif

                        }

                        pDest16 += Extra;
                        pWSrc16 += Info.Stride;//Extra;
                }
                
                if (!geBitmap_UnLock(Dest))
                {
                        return GE_FALSE;
                }
        }

        return GE_TRUE;
}

//====================================================================================
//====================================================================================
static void CalcRippleData(int16 *Src, int16 *Dest, int16 Density, int32 W, int32 H)
{
        int32   i,j;
        int16   Val;

        //Bottom = W * (H-1);

        for(i=0; i< H; i++)
        {
                for(j=0; j< W; j++)
                {
                        if (i > 0)                                                      // Get top
                                Val = *(Dest - W);
                        else
                                Val = *(Dest + W * (H-1));

                        if (i < H-1)                                            // Get bottom
                                Val += *(Dest + W);
                        else
                                Val += *(Dest - W * (H-1));

                        if (j > 0)                                                      // Get left
                                Val += *(Dest - 1);
                        else
                                Val += *(Dest + (W-1));

                        if (j < W-1)                                            // Get right
                                Val += *(Dest + 1);
                        else
                                Val += *(Dest - (W-1));

                        Val >>= 1;
                        Val -= *Src;
                        Val -= (Val >> Density);
                        /*
                        if (Val > 255)
                                Val = 255;
                        else if (Val < -255)
                                Val = -255;
                        */
                        *Src = Val;

                        Src++;
                        Dest++;

                }
        }
}


//====================================================================================
//      FloatMod
//====================================================================================
static float FloatMod(float In, float Wrap)
{
        Wrap = (float)floor(fabs(In)/Wrap)*Wrap - Wrap;

        if (In > 0)
                In -= Wrap;
        else if (In < 0)
                In += Wrap;

        return In;
}

//====================================================================================
//      Water_Update
//====================================================================================
void Water_Update(Procedural *Water, float Time)
{
        int16           *Page1, *Page2, *Page3;

        Page1 = Water->WaterData[Water->NPage];
        Page2 = Water->WaterData[!Water->NPage];

        Page3 = Page2;

        Water->TimeToSplashWater += Time;
#if 1
        if (Water->TimeToSplashWater > 0.8f)
        {
                int32   px, py, cx, cy, c;
                //int32         w, h;
                
                Water->TimeToSplashWater = 0.0f;
                
                
                for (c=0; c< 2; c++)
                {
                        px=(1+(rand()%(Water->Width-1-10)));
                        py=(1+(rand()%(Water->Height-1-10)));

                        for(cy=py; cy< (py+8); cy++)
                                for(cx=px; cx< (px+8); cx++)
                                        Water->WaterData[!Water->NPage][cy * Water->Width + cx]=255;
                }
                /*
                for (h=0; h<10; h++)
                        for (w=0; w<10; w++)
                                Water->WaterData[!Water->NPage][(((int32)Water->PosY+h)%Water->Height)*Water->Width + (((int32)Water->PosX+w)%Water->Width)] = 255;

                Water->PosX += 8.0f;
                Water->PosY += 2.0f;
                */

        }
#else
        if (Water->TimeToSplashWater > 0.09f)
        {
                int32           w, h;

                Water->TimeToSplashWater = 0.0f;
                
                Water->PosX += (float)cos(Water->Angle)*16.0f;
                Water->PosY += (float)sin(Water->Angle)*16.0f;

                Water->Angle += ((float)rand()/RAND_MAX) * 0.5f - 0.1f;

                Water->Angle = FloatMod(Water->Angle, 3.14159f);

                Water->PosX = FloatMod(Water->PosX, (float)Water->Width);
                Water->PosY = FloatMod(Water->PosY, (float)Water->Height);

                //Water->WaterData[!Water->NPage][(int32)Water->PosY * Water->Width + (int32)Water->PosX]=255;
        
                for (h=0; h<10; h++)
                        for (w=0; w<10; w++)
                                Water->WaterData[!Water->NPage][(((int32)Water->PosY+h)%Water->Height)*Water->Width + (((int32)Water->PosX+w)%Water->Width)] = 255;
        }
#endif

        CalcRippleData(Page1, Page2, 4, Water->Width, Water->Height);

        Water->NPage = !Water->NPage;
}

//====================================================================================
//      Water_BuildRGBLuts
//====================================================================================
void Water_BuildRGBLuts(Procedural *Water, float RScale, float GScale, float BScale)
{
        int32           i, j;

        for (i=0; i<32; i++)            // Shade
        {
                for (j=0; j<32; j++)    // Color
                {
                        int32   Val;

                        Val = (int32)(((float)(31 - i)/14) * (float)j);

                        //Val <<= 2;
                        
                        if (Val > 31)
                                Val = 31;

                        Water->BlendLut[i][j] = (uint8)Val;
                }
        }

}

//====================================================================================
//====================================================================================
static Procedural_Table Water_Table = 
{
        Procedurals_Version,Procedurals_Tag,
        "Water",
        Water_Create,
        Water_Destroy,
        Water_Animate
};

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

//====================================================================================
//====================================================================================
Procedural_Table *Water_GetProcedural_Table(void)
{
        return &Water_Table; 
}

---