---

omicron.h

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/18 14:12:16 $
// By           :       $Author: kolrabi $
// $Id: omicron.h,v 1.5 2002/12/18 14:12:16 kolrabi Exp $ 

/*

  $Log: omicron.h,v $
  Revision 1.5  2002/12/18 14:12:16  kolrabi
  *** empty log message ***

  Revision 1.4  2002/12/14 20:02:33  kolrabi
  fixed some memory leaks

  Revision 1.3  2002/12/13 12:29:26  kolrabi
  fixed some bugs

  Revision 1.2  2002/12/11 16:35:43  kolrabi
  sound is now part of the engine

  Revision 1.1.1.1  2002/12/07 19:02:18  kolrabi
  initial release


*/

// Names you shouldn't use in your programs:
// gv, assertions

// And from the chaos there came a voice:
// "Smile and be happy, it could be worse!"
// And I smiled and was happy. And it became worse.


#include            "forward.h"
#include            "vector.h" 

/**************************************************************************** 
 **************************************************************************** 
 * INCLUDES *****************************************************************
 **************************************************************************** 
 ****************************************************************************/ 
 
/* DEFAULT INCLUDES *********************************************************/
#include            <string.h> 
#include            <stdio.h> 
#include            <stdlib.h> 
#include            <math.h> 

#if defined(WIN32)

/* WINDOWS INCLUDES *********************************************************/
#   include         <windows.h> 
 
/* these need to stay here, they define types in the gv struct: */ 

#   include         "extgl.h"

#else 

/* UNIX/LINUX INCLUDES ******************************************************/

#   include         <unistd.h> 
#   include         <sys/time.h> 
#   include         <sys/utsname.h>
#   include         <X11/Xlib.h> 
#   include         <X11/Xutil.h> 

#   include         <GL/gl.h>
#   include         <GL/glx.h> 
#   include         <GL/glext.h>

#   define          MAX_PATH 512
 
#endif

#include            <GL/glu.h> 
// #include            <GL/glaux.h> 

/* OGG VORBIS ***************************************************************/ 
//#include        <vorbis/codec.h> 
//#include        <vorbis/vorbisfile.h> 

/**************************************************************************** 
 **************************************************************************** 
 * DEFINES ****************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

#define         OMICRON_VERSION             "0.1.1" // please increment thx :) 


#define         SafeDelete(a)       \
    { if (a) { delete a; a = NULL; }} 

#define         SafeArrayDelete(a)  \
    { if (a) { delete [] a; a = NULL; }} 

#define         StructElem(type, member)   \
    (ulong)(((type*)(0))->member)


extern unsigned long assertions;

#define DBGSTAMP                                                            \
    _log_printf(MSG_DEBUG, "* DEBUG **********************");               \
    _log_printf(MSG_DEBUG, "%s - at or near line %u", __FILE__, __LINE__);

#define ASTSTAMP(ex)                                                        \
    _log_printf(MSG_DEBUG, "* ASSERTION ******************");               \
    _log_printf(MSG_DEBUG, "Assertion '" #ex "' failed in"                  \
                           "%s - at or near line %u", __FILE__, __LINE__);

#define         DebugReturn                                                 \
    { DBGSTAMP; return;   };

#define         DebugReturnValue(a)                                         \
    { DBGSTAMP; return a; };

#define         AssertReturn(ex)                                            \
    { ASTSTAMP(ex); assertions++; return;   };

#define         AssertReturnValue(ex, a)                                    \
    { ASTSTAMP(ex); assertions++; return a; };

#define         AssertReturn1(a)         \
                { \
                    if (!(a)) AssertReturn(a);\
                };

#define         AssertReturn2(a,b)       \
                { \
                    if (!(a)) AssertReturn(a);\
                    if (!(b)) AssertReturn(b);\
                };

#define         AssertReturn3(a,b,c)     \
                { \
                    if (!(a)) AssertReturn(a);\
                    if (!(b)) AssertReturn(b);\
                    if (!(c)) AssertReturn(c);\
                };

#define         AssertReturn4(a,b,c,d)   \
                { \
                    if (!(a)) AssertReturn(a);\
                    if (!(b)) AssertReturn(b);\
                    if (!(c)) AssertReturn(c);\
                    if (!(d)) AssertReturn(d);\
                };

#define         AssertReturnValue1(a,v)       \
                { \
                    if (!(a)) AssertReturnValue(a,v);\
                };

#define         AssertReturnValue2(a,b,v)     \
                { \
                    if (!(a)) AssertReturnValue(a,v);\
                    if (!(b)) AssertReturnValue(b,v);\
                };

#define         AssertReturnValue3(a,b,c,v)   \
                { \
                    if (!(a)) AssertReturnValue(a,v);\
                    if (!(b)) AssertReturnValue(b,v);\
                    if (!(c)) AssertReturnValue(c,v);\
                };

#define         AssertReturnValue4(a,b,c,d,v) \
                { \
                    if (!(a)) AssertReturnValue(a,v);\
                    if (!(b)) AssertReturnValue(b,v);\
                    if (!(c)) AssertReturnValue(c,v);\
                    if (!(d)) AssertReturnValue(d,v);\
                };

#define         AssertThis          { AssertReturn1(this) };
#define         AssertThisV         { AssertReturnValue1(this, 0) };
#define         AssertThisValue(a)  { AssertReturnValue1(this, a) };

#define         INVALID_INDEX               -1 

#define         PI                          3.1415926535897932384626433832795f

#define         PI2                         6.2831853071795864769252867665590f 

#define         SQRT2                       1.4142135623730950488016887242097f 

#define         SIN45                       0.7071067811865475244008443621048f 

#define         DEG2RAD                     0.0174532925199432957692369076848f 

#define         RAD2DEG                     57.295779513082320876798154814105f 

#define         EQUAL_EPSILON               0.01f 

#define         TRUE_STRING                 "1yYtT"

#define         FALSE_STRING                "0nNfF"

#define         frand(a,b) (((float)rand())/((float)RAND_MAX)*((b)-(a))+(a))

#define         CLAMP(a, min, max) ((a>max)?(max):(a<min?min:a))

#define         GETFRACTION(pos, a, b) ((pos-(a))/(b-(a)))

#define         QUADVERTX(a) ((((a+1)/2)%2)?-1.0f:1.0f)
#define         QUADVERTY(a) ((((a+0)/2)%2)?-1.0f:1.0f)

#define         NQUADVERTX(a) ((((a+1)/2)%2)?0.0f:1.0f)
#define         NQUADVERTY(a) ((((a+0)/2)%2)?0.0f:1.0f)

/* MESSAGE LEVELS ***********************************************************/ 
 
#define         MSG_DEBUG3                  -3 // exteme detail
#define         MSG_DEBUG2                  -2 
#define         MSG_DEBUG                   -1 
#define         MSG_NORMAL                   0 // normal output
#define         MSG_WARNING                  1 
#define         MSG_ERROR                    2 
#define         MSG_CRITICAL                 3 // exits the program
 
#ifndef         OMICRON_GLOBALTYPES_DEFINED 
#define         OMICRON_GLOBALTYPES_DEFINED  

typedef         unsigned long   ulong;    // 32 bit 
typedef         signed   long   slong; 
 
typedef         unsigned short  ushort;   // 16 
typedef         signed   short  sshort; 
 
typedef         unsigned char   uchar;    // 8 
typedef         signed   char   schar; 
 
/****************************************************************************/ 
/* GLOBAL VARIABLES *********************************************************/ 
 
typedef struct initvars_s
{ 
    // system data below.. 
 
#if defined(WIN32)
 
    HINSTANCE   hInstance;          

#else 
 
    Visual      *vis;

    XVisualInfo *vi;

    Display     *dpy;
 
#endif 
 

    ulong       wnd;

    const char  *wndclassname;      

    const char  *wndtitle;          
 
    ushort      hres,               
                vres; 
 
    int         argc;               
    char        **argv;             
 
    char        bpp,                
                zbuffer,
                stencil;
    bool        nosound;            

    bool        nogfx;              

    bool        noinput;            

    bool        fullscreen;         

    bool        nolog;              

} initvars_t;

class engine_interface_c
{
protected:
public:

    virtual void        init(){};
    
    virtual void        deinit(){};

    virtual void        world_update(){};

    virtual void        gui_callback(struct uievent_s*){};

    virtual void        render(){};
    
    virtual void        afterframe(){};
};

typedef struct gvar_s               
{ 
    initvars_t  init;               
 
    // system variables

    bool        bExit;              
 
#if defined(WIN32)
    // for windows, these variables store information about OpenGL 
 
    HGLRC       hrc;                
    HDC         hdc;                
 
#else 
    // under X11 this variables does it.. 
 
    GLXContext  glxc;               
 
#endif 
 
    sshort      debuglevel;         

    list_c<shader_s>    *shaders;       
 
    ulong               lightcount;     
    struct light_s      *lights;        
    sshort              lightmap;       

    texture_manager_c   *texman;        
    file_manager_c      *fileman;       
    net_manager_c       *netman;        
    sound_manager_c     *soundman;      
    renderer_c          *renderer;      
    
    gui_c               *gui;

    // free for all :) ************************************* // 
 
    float       aspect;             
    
    // time stuff 
    float       dtime;              
    float       time;               
    float       timescale;          
    long        frame;              
 
    // input data 
    sshort      mouse_dx;           
    sshort      mouse_dy;           
    sshort      mouse_dz;           
    sshort      mouse_b;            
    sshort      mouse_lb;           
 
    uchar       kbdstate[256];      
    uchar       lkbdstate[256];     

    bool        active;             
    engine_interface_c *iface;
} gvar_t; 

#endif 
 
/**************************************************************************** 
 **************************************************************************** 
 * FUNCTIONS **************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

void            _log_printf
( 
    sshort    level,    
    char      *fmt,     
    ... 
); 
 
void            _convert_file_path
( 
    char        *path   
); 

void            _convert_pak_path   // convert path 
( 
    char        *path   
);

char*           _strtrm
(  
    char        *string,    
    char        *trimchrs   
);
 
schar           _sgn
( 
    float f 
); 
 
float           _interpolate_float_linear  // interpolate floats 
( 
    float       a,      
    float       b,      
    float       frac    
); 

void            _swap_long
(
    ulong        &l
);

extern          gvar_t gv;          

#if !defined(WIN32) 

#define strcmpi strcasecmp 
#define _snprintf snprintf 
 
#endif 

#define fcos      (float)cos
#define fsin      (float)sin
#define ftan      (float)tan

---