proceng.c

Go to the documentation of this file.

/****************************************************************************/
/*    FILE: ProcEng.c                                                                                                           */
/*                                                                          */
/*    Copyright (c) 1998, Eclipse Entertainment; All rights reserved.       */
/*                                                                          */
/****************************************************************************/
#include <stdlib.h>
#include <math.h>
#include <Assert.h>
#include <ctype.h>

#define WIN32_LEAN_AND_MEAN
#include <windows.h>    // for dll stuff

#include "Genesis.h"
#include "Ram.h"
#include "Errorlog.h"
#include "Stdio.h"
#include "String.h"

#include "ProcEng.h"
#include "Procedural.h"

// at the end of this file :
typedef Procedural_Table * (*GetProceduralFunc)(void);

extern GetProceduralFunc GetProceduralFunctions[];
extern int NumGetProceduralFunctions;

#define PROCENG_MAX_PTABLES             32                      // Pre-Loaded tables that procs attach to
#define PROCENG_MAX_PROCS               256                     // Actual procs (created from table data)

//====================================================================================
//====================================================================================
typedef struct ProcEng_PTable
{
        char                            DllName[_MAX_PATH];
        HINSTANCE                       DllHandle;
        Procedural_Table        *Table;
        int                                     Uses;
} ProcEng_PTable;

typedef struct ProcEng_Proc
{
        Procedural_Table        *Table;                         // Table used to create this proc (So we can destroy it)
        Procedural                      *Proc;
        geBitmap                        *Bitmap;
} ProcEng_Proc;

typedef struct ProcEng
{
        geWorld                         *World;

        int32                           NumPTables;
        ProcEng_PTable          PTables[PROCENG_MAX_PTABLES];

        int32                           NumProcs;
        ProcEng_Proc            Procs[PROCENG_MAX_PROCS];
} ProcEng;

geBoolean VFile_ReadBetween(geVFile * File,char *Into,char Start,char Stop);
geBoolean VFile_SeekPastString(geVFile * File,const char *str);
geBoolean VFile_SeekPastSpaces(geVFile * File);
int VFile_GetC(geVFile * File);
void VFile_UnGetC(geVFile * File);
static char * stristr(const char *StrBase,const char *SubBase);

#define SkipWhite(p)            while (   isspace(*p) ) p++
#define SkipNonWhite(p)         while ( ! isspace(*p) && *p ) p++

//====================================================================================
//      ProcEng_Create
//====================================================================================
ProcEng *ProcEng_Create(geVFile *CfgFile, geWorld *World)
{
        ProcEng         *PEng;
        int32           i;

        // For now, hard code in the procedures (but later, load *.dll)...
        PEng = geRam_Allocate(sizeof(*PEng));

        if (!PEng)
                return GE_FALSE;

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

        // init all compiled-in procedurals:

        for(i=0;i<NumGetProceduralFunctions;i++)
        {       
                if ( GetProceduralFunctions[i] )
                {
                Procedural_Table * pTable;
                        pTable = (*GetProceduralFunctions[i]) ();
                        if ( pTable->Tag == Procedurals_Tag && 
                                        pTable->Version == Procedurals_Version )
                        {
                                PEng->PTables[PEng->NumPTables].DllHandle = NULL;
                                PEng->PTables[PEng->NumPTables].Table = pTable;
                                PEng->PTables[PEng->NumPTables].Uses  = 0;
                                PEng->NumPTables ++;
                        }
                        else if ( pTable->Tag == Procedurals_Tag )
                        {
                        //char ErrStr[1024];
                        //      sprintf(ErrStr,"ProcEng_Create : found procedural : %s : but ignored because of version mismatch",pTable->Name);
                        //      geErrorLog_AddString(-1,ErrStr);
                        }
                }
        }

        do
        {
        geVFile * FileBase;
        geVFile_Finder * Finder;
        char BasePath[1024];

                //harcoded path!
                //<>
                strcpy(BasePath,"c:\\genesis\\procedurals");

                FileBase = geVFile_OpenNewSystem(NULL,GE_VFILE_TYPE_DOS,BasePath,NULL,GE_VFILE_OPEN_READONLY|GE_VFILE_OPEN_DIRECTORY);
                if ( ! FileBase )
                {
                        // We really should not use ErrorLog for normal logging info...
                        //geErrorLog_AddString(-1,"ProcEng_Create : Couldn't open procedural DLL directory : non_fatal");
                        break;
                }

                Finder = geVFile_CreateFinder(FileBase,"*.dll");
                if ( ! Finder )
                {
                        //geErrorLog_AddString(-1,"ProcEng_Create : Couldn't open procedural Finder : non_fatal");
                        geVFile_Close(FileBase);
                        break;
                }

                while( geVFile_FinderGetNextFile(Finder) )
                {
                GetProceduralFunc GetProcFunc;
                HMODULE TheDll;
                geVFile_Properties Properties;
                char DLLName[_MAX_PATH];
                Procedural_Table * pTable;
                
                        geVFile_FinderGetProperties(Finder,&Properties);

                        strcpy(DLLName,BasePath);
                        strcat(DLLName,"\\");
                        strcat(DLLName,Properties.Name);

                        TheDll = LoadLibrary(DLLName);
                        if ( ! TheDll )
                        {
                                #if 0
                        //char ErrStr[_MAX_PATH+1024];

                                //sprintf(ErrStr,"ProcEng_Create : LoadLibrary failed on DLL : %s : non-fatal",DLLName);
                                //geErrorLog_AddString(-1,ErrStr);

                                {
                                char string[1024];
                                int plen;
                                DWORD err;
        
                                        err = GetLastError();
                                        sprintf(string,"Windows Error : %d = %08X : \0",err,err);
                                        plen = strlen(string);
                                        FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM , NULL, err, 0, string+plen, sizeof(string)-plen, NULL);
                                        geErrorLog_AddString(-1,string);
                                }
                                #endif

                                continue;
                        }

                        GetProcFunc = (GetProceduralFunc) GetProcAddress(TheDll,"GetProceduralTable");
                        
                        if ( ! GetProcFunc )
                        {
                        //char ErrStr[_MAX_PATH+1024];
                        //      sprintf(ErrStr,"ProcEng_Create : no GetProceduralTable in DLL : %s : non-fatal",DLLName);
                        //      geErrorLog_AddString(-1,ErrStr);
                                FreeLibrary(TheDll);
                                continue;
                        }

                        pTable = GetProcFunc();
                        if ( !pTable || pTable->Tag != Procedurals_Tag || pTable->Version != Procedurals_Version )
                        {
                        //char ErrStr[1024];
                        //      sprintf(ErrStr,"ProcEng_Create : found procedural : %s : but ignored because of version mismatch",pTable == NULL ? "null!" : pTable->Name);
                        //      geErrorLog_AddString(-1,ErrStr);
                                FreeLibrary(TheDll);
                                continue;
                        }

                        strcpy(PEng->PTables[PEng->NumPTables].DllName,DLLName);
                        PEng->PTables[PEng->NumPTables].DllHandle = TheDll;
                        PEng->PTables[PEng->NumPTables].Table = pTable;
                        PEng->PTables[PEng->NumPTables].Uses  = 0;
                        PEng->NumPTables ++;
                }

                geVFile_DestroyFinder(Finder);
                geVFile_Close(FileBase);
        }
        while(0);

        if ( CfgFile && VFile_SeekPastString(CfgFile,"procedurals") )
        {

                if ( ! VFile_SeekPastString(CfgFile,"{") )
                        goto ExitWithError;
                                
                for(;;)
                {
                        char            *TargetName,*ProcName;
                        geBitmap        *Bitmap;
                        char            InputStr[1024];
                        char            *p;
                        int                     ReadLen;

                        if ( ! VFile_SeekPastSpaces(CfgFile) )
                                goto ExitWithError;

                        if ( ! geVFile_GetS(CfgFile,InputStr,sizeof(InputStr)) )
                                goto ExitWithError;

                        ReadLen = strlen(InputStr) + 1;

                        if ( p = strchr(InputStr,'}') )
                        {
                                p ++;
                                // un-read data we haven't looked at
                                geVFile_Seek(CfgFile, (int)p - ((int)InputStr + ReadLen), GE_VFILE_SEEKCUR);
                                break;
                        }

                        p = InputStr;
                        SkipWhite(p);
                        if ( strnicmp(p,"wbm:",4) == 0 )
                        {
                        char ParamStr[4096];
                        int SeekLen;


                                p += 4;
                                SkipWhite(p);
                                TargetName = p;
                                SkipNonWhite(p);
                                if ( *p ) *p++ = 0;
                                SkipWhite(p);
                                ProcName = p;
                                SkipNonWhite(p);
                                
                                if ( strchr(ProcName,'(') < p && strchr(ProcName,'(') )
                                {
                                        p = strchr(ProcName,'(');
                                        SeekLen = (int)p - ((int)InputStr + ReadLen);
                                        // SeekLen --; // ?
                                        *p = 0;
                                }
                                else
                                {
                                        SeekLen = (int)p - ((int)InputStr + ReadLen);
                                        *p = 0;
                                }
                
                                // un-read data we haven't looked at
                                if ( ! geVFile_Seek(CfgFile, SeekLen, GE_VFILE_SEEKCUR) )
                                        goto ExitWithError;

                                VFile_ReadBetween(CfgFile,ParamStr,'(',')');

                                // find name
                                Bitmap = geWorld_GetBitmapByName(World, TargetName);

                                if (!Bitmap)
                                {
                                //char ErrStr[1024];
                                //      sprintf(ErrStr, "ProcEng_Create : couldn't find world bitmap : %s\n",TargetName);
                                //      geErrorLog_AddString(-1,ErrStr);
                                }

                                // Should we really stop when a proc cannot be found for a bitmap?
                                if ( ! ProcEng_AddProcedural(PEng, ProcName, &Bitmap, ParamStr) )
                                {
                                //char ErrStr[1024];
                                //      sprintf(ErrStr, "ProcEng_Create : couldn't find procedural : %s\n",ProcName);
                                //      geErrorLog_AddString(-1,ErrStr);
                                }
                        }
                }
        }

        PEng->World = World;
        //geWorld_CreateRef(World);

        return PEng;                                                                                             

        ExitWithError:

                geErrorLog_AddString(-1,"ProcEng_Create : failure!", NULL);

                if (PEng)
                {
                        ProcEng_Destroy(&PEng);
                }
                        
                return NULL;
}

//====================================================================================
//      ProcEng_Destroy
//====================================================================================
void ProcEng_Destroy(ProcEng **pPEng)
{
        int32                   i;
        ProcEng_Proc    *pProc;
        ProcEng_PTable  *pTable;
        ProcEng                 *PEng;

        assert(pPEng);

        PEng = *pPEng;
        if ( ! PEng )
                return;
        
        // Free all the allocated procs
        pProc = PEng->Procs;
        for (i=0; i< PEng->NumProcs; i++, pProc++)
        {
                assert(pProc->Table);
                assert(pProc->Proc);

                pProc->Table->Destroy(pProc->Proc);

                geBitmap_Destroy(&(pProc->Bitmap)); // we did creatref

                memset(pProc, 0, sizeof(*pProc));       
        }
        PEng->NumProcs = 0;

        // Free all the table dlls...
        pTable = PEng->PTables;
        for (i=0; i< PEng->NumPTables; i++, pTable++)
        {
                if ( pTable->DllHandle )
                {
                        FreeLibrary(pTable->DllHandle);
                }
                memset(pTable, 0, sizeof(*pTable));
        }
        PEng->NumPTables = 0;

        //if (PEng)
        //      geWorld_Free(PEng->World);
        PEng->World = NULL;

        geRam_Free(PEng);

        *pPEng = NULL;
}

//====================================================================================
//      ProcEng_Destroy
//====================================================================================
geBoolean ProcEng_Minimize(ProcEng *PEng)
{
ProcEng_PTable  *pTable;
ProcEng_PTable  *pTableLast;

        assert(PEng);

        // Free all the table dlls...
        pTable = PEng->PTables;
        pTableLast = pTable + (PEng->NumPTables - 1);
        while( pTable <= pTableLast )
        {
                if ( pTable->Uses < 1 )
                {
                        if ( pTable->DllHandle )
                        {
                                FreeLibrary(pTable->DllHandle);
                        }
                        *pTable = *pTableLast;
                        pTableLast--;
                        PEng->NumPTables --;
                }
                else
                {
                        pTable ++;
                }
        }
        return GE_TRUE;
}

//====================================================================================
//      ProcEng_AddProcedural
//      NOTE - The only way to remove procs, is to destroy the ProcEng object, and start over for now
//====================================================================================
geBoolean ProcEng_AddProcedural(ProcEng *PEng, const char *ProcName, geBitmap **pBitmap, const char * Params)
{
        int32                   i;
        ProcEng_PTable  *pTable;

        assert(PEng);
        assert(ProcName);
        assert(pBitmap);

        if (PEng->NumProcs+1 >= PROCENG_MAX_PROCS)
        {
                geErrorLog_AddString(-1, "ProcEng_AddProcedural:  Max procs.", NULL);
                return GE_FALSE;
        }

        // Find Procedural_Table by Name
        pTable = PEng->PTables;
        for (i=0; i< PEng->NumPTables; i++, pTable++)
        {
                // Should we ignore case? ! YES!
                if ( stricmp(pTable->Table->Name, ProcName) == 0)
                        break;
        }

        if (i == PEng->NumPTables)              // Didn't find it
        {
                geErrorLog_AddString(-1, "ProcEng_AddProcedural:  Table not found for procedural.", NULL);
                return GE_FALSE;
        }

        assert(pTable->Table);

        // Create the proc (each bitmap should have it's own)
        PEng->Procs[PEng->NumProcs].Proc = pTable->Table->Create(pBitmap, Params);

        if (!PEng->Procs[PEng->NumProcs].Proc)
        {
                geErrorLog_AddString(-1," ProcEng_AddProcedural:  (%s)->Create failed", pTable->Table->Name);
                return GE_FALSE;
        }
        if (! *pBitmap)
        {
                geErrorLog_AddString(-1,"ProcEng_AddProcedural: No Bitmap:", pTable->Table->Name);
                return GE_FALSE;
        }

        PEng->Procs[PEng->NumProcs].Bitmap = *pBitmap;
        PEng->Procs[PEng->NumProcs].Table = pTable->Table;

        geBitmap_CreateRef(*pBitmap);
        // make sure the bitmap isn't destroyed before our procedural

        PEng->NumProcs++;

        pTable->Uses ++;

        return GE_TRUE;
}

//====================================================================================
//      ProcEng_Animate
//====================================================================================
geBoolean ProcEng_Animate(ProcEng *PEng, float ElapsedTime)
{
        int32                   i;
        ProcEng_Proc    *pProc;

        pProc = PEng->Procs;
        for (i=0; i< PEng->NumProcs; i++, pProc++)
        {
                assert(pProc->Table);
                assert(pProc->Proc);

                if (!geWorld_BitmapIsVisible(PEng->World, pProc->Bitmap))
                        continue;

                if (!pProc->Table->Animate(pProc->Proc, ElapsedTime))
                {
                        geErrorLog_AddString(-1,"ProcEng_Animate: pProc->Table->Animate failed", NULL);
                        return GE_FALSE;
                }
        }
        return GE_TRUE;
}


//====================================================================================
// VFile Seek utils
//====================================================================================

geBoolean VFile_SeekPastString(geVFile * File,const char *str)
{
long LastPosition;
char Buf[1024];
int len;

        if ( strlen(str) == 0 )
                return GE_FALSE;

        if ( ! geVFile_Tell(File,&LastPosition) )
                return GE_FALSE;

        for(;;)
        {
                if ( ! VFile_SeekPastSpaces(File) )
                        goto fail;

                len = strlen(str);
                if ( ! geVFile_Read(File,Buf,len) )
                        goto fail;
                Buf[len] = 0;

                if ( stricmp(Buf,str) == 0 )
                        return GE_TRUE;
                
                len = 1 - len;
                if ( ! geVFile_Seek(File,len,GE_VFILE_SEEKCUR) )
                        goto fail;
        }
        
        fail:

        geVFile_Seek(File,LastPosition,GE_VFILE_SEEKSET);
        return GE_FALSE;
}

int VFile_GetC(geVFile * File)
{
uint8 Char;
        if ( ! geVFile_Read(File,&Char,1) )
                return -1;
return (int)Char;
}

void VFile_UnGetC(geVFile * File)
{
        geVFile_Seek(File,-1,GE_VFILE_SEEKCUR);
}

geBoolean VFile_SeekPastSpaces(geVFile * File)
{
long LastPosition;
int Char;

        if ( ! geVFile_Tell(File,&LastPosition) )
                return GE_FALSE;

        while( (Char = VFile_GetC(File)) != -1 )
        {
                if ( ! isspace(Char) )
                {
                        VFile_UnGetC(File);
                        return GE_TRUE;
                }
        }
        geVFile_Seek(File,LastPosition,GE_VFILE_SEEKSET);
        return GE_FALSE;
}

static char * stristr(const char *StrBase,const char *SubBase)
{

while ( *StrBase )
  {
  if ( toupper(*StrBase) == toupper(*SubBase) )
         {
         const char * Str,* Sub;
         Str = StrBase + 1;
         Sub = SubBase + 1;
         while ( *Sub && toupper(*Sub) == toupper(*Str) )
                {
                Sub++; Str++;
                }
         if ( ! *Sub) return((char *)StrBase);
         }
  StrBase++;
  }

return(NULL);
}

geBoolean VFile_ReadBetween(geVFile * File,char *Into,char Start,char Stop)
{
int c;
int ins;

        Into[0] = 0;

        if ( ! VFile_SeekPastSpaces(File) )
                return GE_FALSE;

        if ( (c = VFile_GetC(File)) == Start )
        {
        char *p;
                ins = 1;
                p = Into;
                for(;;)
                {
                        c = VFile_GetC(File);
                        if ( c == -1 )
                        {
                                *p = 0;
                                return GE_FALSE;
                        }
                        *p = c;
                        if ( c == Start ) ins ++;
                        else if ( c == Stop ) ins --;
                        if ( ins == 0 ) break;
                        p++;
                }
                *p = 0;
        }
        else
        {
                if ( c == -1 )
                        return GE_FALSE;
                else
                        VFile_UnGetC(File);
        }

return GE_TRUE;
}

---