bumpmap.c

Go to the documentation of this file.

#include "bumpmap.h"
#include "genesis.h"
#include "bitmap.h"
#include "ram.h"
#include <math.h>
#include <Assert.h>
#include <string.h>

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

Procedural *BumpMap_Create(geBitmap **ppBitmap, const char *ParmStart);
void            BumpMap_Destroy(Procedural *Proc);
geBoolean       BumpMap_Animate(Procedural *BumpMap, float ElapsedTime);

static Procedural_Table BumpMap_Table = 
{
        Procedurals_Version,Procedurals_Tag,
        "BumpMap",
        BumpMap_Create,
        BumpMap_Destroy,
        BumpMap_Animate
};

Procedural_Table * BumpMap_GetProcedural_Table(void)
{
        return &BumpMap_Table;
}

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

typedef struct Procedural
{
        uint32          Frame;
        geBitmap *      Bitmap;
} Procedural;

geBoolean BumpMap_CreateFromHeightMap(geBitmap * HeightMap,geBitmap * BumpMap);
geBoolean BumpMap_ComputePalette(geBitmap *BumpMap, geVec3d *Horizontal,geVec3d * Vertical, geVec3d *Pos, geVec3d *LightPos);

/****/

Procedural *BumpMap_Create(geBitmap **ppBitmap, const char *ParmStart)
{
Procedural * P;
geBitmap * HeightMap;

        assert(ppBitmap);

        if ( ! *ppBitmap )
                return NULL;

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

        P->Frame = 0;

        P->Bitmap = *ppBitmap;

        if ( geBitmap_ClearMips(P->Bitmap) )
        {
                if ( geBitmap_SetColorKey(P->Bitmap,GE_FALSE,0,GE_FALSE) )
                {
                        HeightMap = geBitmap_Create(geBitmap_Width(P->Bitmap),geBitmap_Height(P->Bitmap),1,GE_PIXELFORMAT_8BIT_GRAY);
                        if ( HeightMap )
                        {
                                if ( geBitmap_BlitBitmap(P->Bitmap,HeightMap) )
                                {
                                        if ( BumpMap_CreateFromHeightMap(HeightMap,P->Bitmap) )
                                        {
                                                geBitmap_Destroy(&HeightMap);
                                                return P;
                                        }
                                }
                                geBitmap_Destroy(&HeightMap);
                        }
                }
        }

        geRam_Free(P);
        return NULL;
}

void BumpMap_Destroy(Procedural * P)
{
        if ( ! P )
                return;
        geRam_Free(P);
}

geBoolean BumpMap_Animate(Procedural * P,float time)
{
geVec3d Pos,LightPos,Horizontal,Vertical;
geBoolean Ret;

        // <> these should be the sides of the poly we're drawing on,
        //              but we can't get that info easily...
        Horizontal.X = 1.0f;
        Horizontal.Y = 0.0f;
        Horizontal.Z = 0.0f;
        Vertical.X = 0.0f;
        Vertical.Y = 1.0f;
        Vertical.Z = 0.0f;
        Pos.X = 0.0f;
        Pos.Y = 0.0f;
        Pos.Z = 0.0f;
        LightPos.X = (geFloat)(100.0f * cos(P->Frame * 0.05f));
        LightPos.Y = (geFloat)(100.0f * sin(P->Frame * 0.05f));
        LightPos.Z = 100.0f;

        Ret = BumpMap_ComputePalette(P->Bitmap, &Horizontal,&Vertical, &Pos, &LightPos );

        P->Frame ++;
return Ret;
}

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

#define PI              ((double)3.14159265358979323846)
#define TWOPI   (2.0*PI)
#define PIOVER2 (PI*0.5)

static int BumpTableInited = 0;
static float BumpTableX[256];
static float BumpTableY[256];
static float BumpTableZ[256];

geBoolean BumpMap_InitTables(void)
{
int p;
double theta,phi;

        if ( BumpTableInited )
                return GE_TRUE;
        BumpTableInited = 1;

        for(p=0;p<256;p++)
        {
                theta = ((double)(p>>4) + 0.5)*PIOVER2/16.0;
                phi   = ((double)(p&0x0F) + 0.5)*TWOPI/16.0;

                assert( theta >= 0.0    && theta <= PIOVER2 );
                assert( phi >= 0.0              && phi <= TWOPI );

                BumpTableX[p] = (float)( sin(theta) * cos(phi));
                BumpTableY[p] = (float)( sin(theta) * sin(phi));
                BumpTableZ[p] = (float) cos(theta);
        }
return GE_TRUE;
}

geBoolean BumpMap_CreateFromHeightMap(geBitmap * HeightMap,geBitmap * BumpMap)
{
geBitmap *HeightLock=NULL,*BumpLock=NULL;
uint8 *HeightBits,*BumpBits;
geBitmap_Info HeightInfo,BumpInfo;
int w,h;

        assert(HeightMap && BumpMap);

        if ( ! geBitmap_SetFormat(BumpMap,GE_PIXELFORMAT_8BIT_PAL,GE_TRUE,255,NULL) )
                goto fail;

        if ( ! geBitmap_LockForRead(HeightMap,&HeightLock,0,0,GE_PIXELFORMAT_8BIT_GRAY,0,0) )
                goto fail;

        if ( ! geBitmap_GetInfo(HeightLock,&HeightInfo,NULL) )
                goto fail;

        w = HeightInfo.Width;
        h = HeightInfo.Height;

        {
        geBitmap_Palette * Pal;
                Pal = geBitmap_Palette_Create(GE_PIXELFORMAT_32BIT_ARGB,256);
                if ( ! Pal )
                        goto fail;
                if ( ! geBitmap_SetPalette(BumpMap,Pal) )
                        goto fail;
                geBitmap_Palette_Destroy(&Pal);
        }

        if ( ! geBitmap_LockForWriteFormat(BumpMap,&BumpLock,0,0,GE_PIXELFORMAT_8BIT_PAL) )
                goto fail;

        if ( ! geBitmap_GetInfo(BumpLock,&BumpInfo,NULL) )
                goto fail;

        HeightBits      = geBitmap_GetBits(HeightLock);
        BumpBits        = geBitmap_GetBits(BumpLock);

        if ( ! HeightBits || ! BumpBits )
                goto fail; 

{
int x,y,bs,hs;
uint8 *hp,*bp;

        hp = HeightBits;
        bp = BumpBits;
        hs = HeightInfo.Stride;
        bs = BumpInfo.Stride;

        for(y=0;y<(h-1);y++)
        {
                for(x=0;x<(w-1);x++)
                {
                int NW,SW,NE,SE,vx,vy;
                double scale,nX,nY,nZ;
                double theta,phi;
                int _theta,_phi;

                        NW = hp[0];
                        SW = hp[hs];
                        hp++;
                        NE = hp[0];
                        SE = hp[hs];

                        vx = ((NW - NE) + (SW - SE) + 1)>>1;
                        vy = ((NW - SW) + (NE - SE) + 1)>>1;

                        scale = 1.0 / ( 1 + vx*vx + vy*vy );
                        scale = sqrt(scale);

                        nX = scale*vx;
                        nY = scale*vy;
                        nZ = scale;

                        // Z = cos(theta)
                        // X = sin(theta) * cos(phi)
                        // Y = sin(theta) * sin(phi)

                        theta = acos(nZ);
                        if ( fabs(nX) > fabs(nY) )
                        {
                        double cosphi;
                                cosphi = nX / sin(theta);
                                if ( cosphi > 1.0 )
                                        phi = 0.0;
                                else if ( cosphi < -1.0 )
                                        phi = PI;
                                else
                                        phi = acos( cosphi );
                                // (phi in 0 -> PI)
                                if ( nY < 0.0 )
                                        phi = TWOPI - phi;
                        }
                        else
                        {
                        double sinphi;
                                sinphi = nY / sin(theta);
                                if ( sinphi > 1.0 )
                                        phi = PIOVER2;
                                else if ( sinphi < -1.0 )
                                        phi = - PIOVER2;
                                else
                                        phi = asin( sinphi );
                                // (phi in -PI/2 -> PI/2 )
                                if ( nX < 0.0 )
                                        phi = PI - phi;
                                if ( phi < 0.0 )
                                        phi += TWOPI;
                        }

                        assert( theta >= 0.0 && theta <= PIOVER2 );
                        assert( phi >= 0.0 && phi <= TWOPI );

                        theta   = theta * 16.0 / (PIOVER2);
                        phi             = phi   * 16.0 / (TWOPI);

                        // we add 0.5 when we go backwards, so don't do it here
                        _theta  = (int)theta;
                        _phi    = (int)phi;
                        assert( (_theta & 0xF) == _theta );
                        assert( (_phi & 0xF) == _phi );

                        *bp++ = (_theta << 4) | _phi;
                }
                // x == (w-1)
                *bp = bp[-1];
                bp++;
                hp++;

                hp += hs - w;
                bp += bs - w;
        }
        //y == (h-1)
        for(x=0;x<w;x++)
        {
                bp[x] = bp[x - bs];
        }
}

        if ( ! geBitmap_UnLock(BumpLock) )
                goto fail;
        if ( ! geBitmap_UnLock(HeightLock) )
                goto fail;
        
        if ( ! BumpMap_InitTables() )
                goto fail;

        geBitmap_SetPreferredFormat(BumpMap,GE_PIXELFORMAT_8BIT_PAL);

        return GE_TRUE;

fail:

        if ( BumpLock )         geBitmap_UnLock(BumpLock);
        if ( HeightLock )       geBitmap_UnLock(HeightLock);

        return GE_FALSE;
}

geBoolean BumpMap_ComputePalette(geBitmap *BumpMap, geVec3d *pPlaneX,geVec3d *pPlaneY, geVec3d *pPos, geVec3d *pLightPos)
{
geBitmap_Palette *Pal;
geVec3d LightRelPos,PlaneZ;
geFloat LightDist;
void * PalData = NULL;
gePixelFormat PalFormat;
int PalSize;

        assert(BumpMap && pPlaneX && pPlaneY && pPos &&  pLightPos);
        assert( geVec3d_DotProduct(pPlaneX,pPlaneY) == 0.0f );

        geBitmap_SetGammaCorrection(BumpMap, 1.0f, GE_FALSE);

        geVec3d_Subtract(pLightPos ,pPos,&LightRelPos );
        geVec3d_CrossProduct(pPlaneX,pPlaneY,&PlaneZ);
        geVec3d_Normalize(pPlaneX);
        geVec3d_Normalize(pPlaneY);
        geVec3d_Normalize(&PlaneZ);
        LightDist = geVec3d_Normalize(&LightRelPos);

        if ( ! (Pal = geBitmap_GetPalette(BumpMap)) )
                goto fail;

        // if BumpMap is attached to a driver, then this Pal is actually on hardware!

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

        {
        int p,c;
        uint8 * PalPtr;
        float LightX,LightY,LightZ;
                
                LightX = geVec3d_DotProduct(&LightRelPos,pPlaneX) * 250.0f;
                LightY = geVec3d_DotProduct(&LightRelPos,pPlaneY) * 250.0f;
                LightZ = geVec3d_DotProduct(&LightRelPos,&PlaneZ) * 250.0f;

                PalPtr = PalData;
                for(p=0;p<256;p++)
                {
                        
                        c = (int)(LightX * BumpTableX[p] + LightY * BumpTableY[p] + LightZ * BumpTableZ[p]);
                        if ( c < 0 )
                                c = 0;

                        assert( c <= 255 );

                        gePixelFormat_PutColor(PalFormat,&PalPtr,c,c,c,0xFF);
                }               
                assert( ((uint32)PalPtr - (uint32)PalData) == 256 * gePixelFormat_BytesPerPel(PalFormat) );
        }

        PalData = NULL;

        if ( ! geBitmap_Palette_UnLock(Pal) )
                return GE_FALSE;

        Pal = geBitmap_GetPalette(BumpMap);
        if ( ! Pal )
                return GE_FALSE;
        if ( ! geBitmap_SetPalette(BumpMap,Pal) )
                return GE_FALSE;

        return GE_TRUE;

fail:

        if ( PalData )
                geBitmap_Palette_UnLock(Pal);

        return GE_FALSE;
}

---