tgf.h

Go to the documentation of this file.

/***************************************************************************
                    tgf.h -- Interface file for The Gaming Framework                                    
                             -------------------                                         
    created              : Fri Aug 13 22:32:14 CEST 1999
    copyright            : (C) 1999-2026 by Eric Espie, Bernhard Wymann                         
    email                : berniw#bluewin.ch   
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef __TGF__H__
#define __TGF__H__

#include <stdio.h>
#ifndef WIN32
#include <sys/param.h>
#include <assert.h>
#endif /* WIN32 */
#include <stdlib.h>
#ifdef WIN32
#include <windows.h>
#endif
#include <stdarg.h>
#include <cstring>
#include <math.h>
#include <osspec.h>


/* typedef double tdble; */
typedef float tdble;

extern void GfInit(void);

#ifndef MAX
#define MAX(x,y) ((x) > (y) ? (x) : (y))
#endif

#ifndef MIN
#define MIN(x,y) ((x) < (y) ? (x) : (y))
#endif

#define FREEZ(x) do {               \
    if (x) {                    \
    free(x);                \
    x = 0;                  \
    }                       \
} while (0)

#define freez FREEZ

const double PI = 3.14159265358979323846;  
const tdble G = 9.80665f; 
/* conversion */
#define RADS2RPM(x) ((x)*9.549296585)       
#define RPM2RADS(x) ((x)*.104719755)        
#define RAD2DEG(x)  ((x)*(180.0/PI))        
#define DEG2RAD(x)  ((x)*(PI/180.0))        
#define FEET2M(x)   ((x)*0.304801)      
#define SIGN(x)     ((x) < 0.0f ? -1.0f : 1.0f) 
#define NORM0_2PI(x)                \
do {                        \
    while ((x) > 2.0*PI) { (x) -= (tdble) (2.0*PI); }   \
    while ((x) < 0.0) { (x) += (tdble) (2.0*PI); }  \
} while (0)

#define NORM_PI_PI(x)               \
do {                        \
    while ((x) > PI) { (x) -= (tdble) (2.0*PI); }   \
    while ((x) < -PI) { (x) += (tdble) (2.0*PI); }  \
} while (0)


#ifndef DIST

#define DIST(x1, y1, x2, y2) sqrt(((x1) - (x2)) * ((x1) - (x2)) + ((y1) - (y2)) * ((y1) - (y2)))
#endif

#ifndef MIN

#define MIN(x,y) ((x) < (y) ? (x) : (y))
#endif


typedef struct {
    float   x;
    float   y;
    float   z;
} t3Df;

typedef struct {
    tdble   x;      
    tdble   y;      
    tdble   z;      
} t3Dd;

typedef struct {
    int     x;
    int     y;
    int     z;
} t3Di;

typedef struct {
    tdble   x;      
    tdble   y;      
    tdble   z;      
    tdble   ax;     
    tdble   ay;     
    tdble   az;     
} tPosd;

typedef struct 
{
    tPosd pos; 
    tPosd vel; 
    tPosd acc; 
} tDynPt;

typedef struct
{
    t3Dd F; 
    t3Dd M; 
} tForces;


// <esppat>
#ifdef WIN32
#define malloc _tgf_win_malloc
#define calloc _tgf_win_calloc
#define realloc _tgf_win_realloc
#define free _tgf_win_free
#define strdup _tgf_win_strdup
#define _strdup _tgf_win_strdup
extern void * _tgf_win_malloc(size_t size);
extern void * _tgf_win_calloc(size_t num, size_t size);
extern void * _tgf_win_realloc(void * memblock, size_t size);
extern void _tgf_win_free(void * memblock);
extern char * _tgf_win_strdup(const char * str);
#endif // WIN32
// </esppat>

/*********************************
 * Interface For Dynamic Modules *
 *********************************/

typedef int (*tfModPrivInit)(int index, void *);

#define MAX_MOD_ITF 10

typedef struct ModInfo {
    char        *name;      
    char        *desc;      
    tfModPrivInit   fctInit;    
    unsigned int    gfId;       
    int         index;      
    int         prio;       
    int         magic;      
    enum        { INVALID_INDEX = -9999 };
} tModInfo;

/* module init function interface */
typedef int (*tfModInfo)(tModInfo *);   /* first function called in the module */

typedef struct ModList {
    tModInfo        modInfo[MAX_MOD_ITF];   
#ifdef _WIN32
    HMODULE     handle;         
#else
    void        *handle;        
#endif
    char        *sopath;        
    struct ModList  *next;          
} tModList;


extern int GfModLoad(unsigned int gfid, char *dllname, tModList **modlist);
extern int GfModLoadDir(unsigned int gfid, char *dir, tModList **modlist);
extern int GfModUnloadList(tModList **modlist);
extern int GfModInfo(unsigned int gfid, char *filename, tModList **modlist);
extern int GfModInfoDir(unsigned int gfid, char *dir, int level, tModList **modlist);
extern int GfModFreeInfoList(tModList **modlist);

/************************
 * Directory management *
 ************************/

typedef struct FList 
{
    struct FList *next;     
    struct FList *prev;     
    char *name;             
    char *dispName;         
    void *userData;         
} tFList;

extern tFList *GfDirGetList(const char *dir);
extern tFList *GfDirGetListFiltered(const char *dir, const char *suffix);
typedef void (*tfDirfreeUserData)(void*);   
extern void GfDirFreeList(tFList *list, tfDirfreeUserData freeUserDatabool, bool freename = false, bool freedispname = false);


/**********************************
 *  Interface For Parameter Files *
 **********************************/

/*
 *  This set of function is used to store and retrieve
 *  values in parameters files.
 */


/* parameters file type */
#define GFPARM_PARAMETER    0   
#define GFPARM_TEMPLATE     1   
#define GFPARM_PARAM_STR    "param"
#define GFPARM_TEMPL_STR    "template"

/* parameters access mode */
#define GFPARM_MODIFIABLE   1   
#define GFPARM_WRITABLE     2   
/* parameter file read */
#define GFPARM_RMODE_STD    0x01    
#define GFPARM_RMODE_REREAD 0x02    
#define GFPARM_RMODE_CREAT  0x04    
#define GFPARM_RMODE_PRIVATE    0x08

extern void *GfParmReadFile(const char *file, int mode);
/* parameter file write */
extern int GfParmWriteFile(const char *file, void* handle, const char *name);
extern int GfParmCreateDirectory(const char *file, void *parmHandle);

extern char *GfParmGetName(void *handle);
extern char *GfParmGetFileName(void *handle);

/* set the dtd and header values */
extern void GfParmSetDTD (void *parmHandle, char *dtd, char*header);

/* get string parameter value */
extern const char *GfParmGetStr(void *handle, const char *path, const char *key, const char *deflt);
/* get string parameter value */
extern const char *GfParmGetCurStr(void *handle, const char *path, const char *key, const char *deflt);
/* set string parameter value */
extern int GfParmSetStr(void *handle, const char *path, const char *key, const char *val);
/* set string parameter value */
extern int GfParmSetCurStr(void *handle, const char *path, const char *key, const char *val);

/* get num parameter value */
extern tdble GfParmGetNum(void *handle, const char *path, const char *key, const char *unit, tdble deflt);
/* get num parameter value */
extern tdble GfParmGetCurNum(void *handle, const char *path, const char *key, const char *unit, tdble deflt);
/* set num parameter value */
extern int GfParmSetNum(void *handle, const char *path, const char *key, const char *unit, tdble val);
extern int GfParmSetNumEx(void *handle, const char *path, const char *key, const char *unit, tdble val, tdble min, tdble max);
/* set num parameter value */
extern int GfParmSetCurNum(void *handle, const char *path, const char *key, const char *unit, tdble val);


/* clean all the parameters of a set */
extern void GfParmClean(void *handle);
/* clean the parms and release the handle without updating the file */
extern void GfParmReleaseHandle(void *handle);

/* Convert a value in "units" into SI */
extern tdble GfParmUnit2SI(const char *unit, tdble val);
/* convert a value in SI to "units" */
extern tdble GfParmSI2Unit(const char *unit, tdble val);

/* compare and merge different handles */
extern int GfParmCheckHandle(void *ref, void *tgt);
#define GFPARM_MMODE_SRC    1 
#define GFPARM_MMODE_DST    2 
#define GFPARM_MMODE_RELSRC 4 
#define GFPARM_MMODE_RELDST 8 
extern void *GfParmMergeHandles(void *ref, void *tgt, int mode);
extern int GfParmGetNumBoundaries(void *handle, const char *path, const char *key, tdble *min, tdble *max);


extern int GfParmGetEltNb(void *handle, const char *path);
extern int GfParmListSeekFirst(void *handle, const char *path);
extern int GfParmListSeekNext(void *handle, const char *path);
extern char *GfParmListGetCurEltName(void *handle, const char *path);
extern int GfParmListClean(void *handle, const char *path);

/******************* 
 * Trace Interface *
 *******************/

#ifdef WIN32
#define GfTrace printf
#define GfFatal printf
#else

#define GfTrace printf

static inline void
GfFatal(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vprintf(fmt, ap);
    va_end(ap);
    /* GfScrShutdown(); */
    assert (0);
    exit (1);
}
#endif

#define GfError printf

#if !(_DEBUG || DEBUG)
//#ifdef WIN32
//#define GfOut printf
//#else


static inline void
GfOut(const char *fmt, ...)
{
}

//#endif /* WIN32 */

#else /* _DEBUG || DEBUG */

#define GfOut printf

#endif /* _DEBUG || DEBUG */

/******************* 
 * Time  Interface *
 *******************/
extern double GfTimeClock(void);

/* Mean values */
#define GF_MEAN_MAX_VAL 5

typedef struct 
{
    int     curNum;
    tdble   val[GF_MEAN_MAX_VAL+1];
} tMeanVal;

extern tdble gfMean(tdble v, tMeanVal *pvt, int n, int w);
extern void gfMeanReset(tdble v, tMeanVal *pvt);

/* MISC */
extern char *GetLocalDir(void);
extern void SetLocalDir(char *buf);
extern char *GetLibDir(void);
extern void SetLibDir(char *buf);
extern char *GetDataDir(void);
extern void SetDataDir(char *buf);
extern int GetSingleTextureMode (void);
extern void SetSingleTextureMode (void);
extern int GfNearestPow2 (int x);
extern int GfCreateDir(char *path);
extern int GfCreateDirForFile(const char *filenameandpath);


/*
 * Copyright (c) 1991, 1993
 *  The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by the University of
 *  California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *  @(#)queue.h 8.5 (Berkeley) 8/20/94
 */

/*
 * Tail queue definitions.
 */
#define GF_TAILQ_HEAD(name, type)                   \
typedef struct name {                           \
    type *tqh_first;    /* first element */         \
    type **tqh_last;    /* addr of last next element */     \
} t ## name

#define GF_TAILQ_ENTRY(type)                        \
struct {                                \
    type *tqe_next; /* next element */              \
    type **tqe_prev;    /* address of previous next element */  \
}

#define GF_TAILQ_FIRST(head)        ((head)->tqh_first)

#define GF_TAILQ_NEXT(elm, field)   ((elm)->field.tqe_next)

#define GF_TAILQ_END(head)      NULL

#define GF_TAILQ_LAST(head, headname)                   \
    (*(((struct headname *)((head)->tqh_last))->tqh_last))

#define GF_TAILQ_PREV(elm, headname, field)                 \
    (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

/*
 * Tail queue functions.
 */
#define GF_TAILQ_INIT(head) do {                    \
    (head)->tqh_first = NULL;                   \
    (head)->tqh_last = &(head)->tqh_first;              \
} while (0)

#define GF_TAILQ_INIT_ENTRY(elm, field) do {    \
  (elm)->field.tqe_next = 0;            \
  (elm)->field.tqe_prev = 0;            \
} while (0)

#define GF_TAILQ_INSERT_HEAD(head, elm, field) do {         \
    if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)    \
        (head)->tqh_first->field.tqe_prev =         \
            &(elm)->field.tqe_next;             \
    else                                \
        (head)->tqh_last = &(elm)->field.tqe_next;      \
    (head)->tqh_first = (elm);                  \
    (elm)->field.tqe_prev = &(head)->tqh_first;         \
} while (0)

#define GF_TAILQ_INSERT_TAIL(head, elm, field) do {         \
    (elm)->field.tqe_next = NULL;                   \
    (elm)->field.tqe_prev = (head)->tqh_last;           \
    *(head)->tqh_last = (elm);                  \
    (head)->tqh_last = &(elm)->field.tqe_next;          \
} while (0)

#define GF_TAILQ_INSERT_AFTER(head, listelm, elm, field) do {       \
    if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
        (elm)->field.tqe_next->field.tqe_prev =         \
            &(elm)->field.tqe_next;             \
    else                                \
        (head)->tqh_last = &(elm)->field.tqe_next;      \
    (listelm)->field.tqe_next = (elm);              \
    (elm)->field.tqe_prev = &(listelm)->field.tqe_next;     \
} while (0)

#define GF_TAILQ_INSERT_BEFORE(listelm, elm, field) do {        \
    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;      \
    (elm)->field.tqe_next = (listelm);              \
    *(listelm)->field.tqe_prev = (elm);             \
    (listelm)->field.tqe_prev = &(elm)->field.tqe_next;     \
} while (0)

#define GF_TAILQ_REMOVE(head, elm, field) do {              \
    if (((elm)->field.tqe_next) != NULL)                \
        (elm)->field.tqe_next->field.tqe_prev =         \
            (elm)->field.tqe_prev;              \
    else                                \
        (head)->tqh_last = (elm)->field.tqe_prev;       \
    *(elm)->field.tqe_prev = (elm)->field.tqe_next;         \
} while (0)


/* author      : Henrik Enqvist IB (henqvist@abo.fi) */
#ifdef PROFILER

#include <vector>
#include <map>

#define START_PROFILE(name) Profiler::getInstance()->startProfile(name)
#define STOP_PROFILE(name) Profiler::getInstance()->stopProfile()
#define STOP_ACTIVE_PROFILES() Profiler::getInstance()->stopActiveProfiles()
#define PRINT_PROFILE() Profiler::getInstance()->printProfile()

class ProfileInstance {
 public:
  ProfileInstance(const char * pname);
  ~ProfileInstance();
  char name[256];
  int calls;
  int openCalls;
  double totalTime;
  double addTime;
  double subTime;
  double tmpStart;
  std::map<ProfileInstance *, void *> mapChildren;
};

class Profiler {
 protected:
  Profiler();
 public:
  ~Profiler();
  static Profiler * getInstance();
  void startProfile(const char * pname);
  void stopProfile();
  void stopActiveProfiles();
  void printProfile();
 private:
  static Profiler * profiler;
  ProfileInstance * curProfile;
  double fStartTime;
  std::vector<ProfileInstance *> vecProfiles;
  std::vector<ProfileInstance *> stkProfiles;
  std::map<ProfileInstance *, void *> mapWarning;
};

#else /* PROFILER */
#define START_PROFILE(a)
#define STOP_PROFILE(a)
#define STOP_ACTIVE_PROFILES()
#define PRINT_PROFILE()
#endif

/*******************/
/*   Hash Tables   */
/*******************/
#define GF_HASH_TYPE_STR    0   
#define GF_HASH_TYPE_BUF    1   
typedef void (*tfHashFree)(const void*);    
void *GfHashCreate(int type);
int GfHashAddStr(void *hash, const char *key, const void *data);
const void *GfHashRemStr(void *hash, char *key);
const void *GfHashGetStr(void *hash, const char *key);
void GfHashAddBuf(void *hash, char *key, size_t sz, void *data);
const void *GfHashRemBuf(void *hash, char *key, size_t sz);
const void *GfHashGetBuf(void *hash, char *key, size_t sz);
void GfHashRelease(void *hash, tfHashFree hashFree);
const void *GfHashGetFirst(void *hash);
const void *GfHashGetNext(void *hash);

#define GF_DIR_CREATION_FAILED 0
#define GF_DIR_CREATED 1

#endif /* __TGF__H__ */