---

AEngine.h

Go to the documentation of this file.

/*
CS Senior Project 2003
Team : Leftfield
Project : ModernWarfare
Members :
- Russ Christensen              <rchriste@cs.utah.edu>
- Todd Smith                    <tcsmith@cs.utah.edu>
- Usit Duongsaa                 <duongsaa@cs.utah.edu>
Copyright 2003 Russ Christensen, Usit Duongsaa, and Todd Smith. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
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. 
THIS SOFTWARE IS PROVIDED BY RUSS CHRISTENSEN, USIT DUONGSAA, AND TODD SMITH ``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 RUSS, USIT, TODD OR OTHER 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.
*/


#ifndef INCLUDE_AENGINE
#define INCLUDE_AENGINE

//------------------------------------------------------------------------------------

#include "ExternalLibs.h"
#include "ATypes.h"
#include "AConstants.h"
#include "AUtil.h"

//For memory leak detection when in debug mode
#ifdef _DEBUG
   #define DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
#else
   #define DEBUG_CLIENTBLOCK
#endif // _DEBUG
#include <stdlib.h>
#include <crtdbg.h>
#ifdef _DEBUG
#define new DEBUG_CLIENTBLOCK
#endif


//------------------------------------------------------------------------------------
// System-Level
//------------------------------------------------------------------------------------
void sys_init( HINSTANCE hInst, int width, int height, int colorDepth, bool fullScreen );

// rate=2 means render once, skip twice, render once and skip two more and so on
void sys_setSkipRate( int rate );

void sys_setInitFunc(   AierraInitFunc   f );
void sys_setUpdateFunc( AierraUpdateFunc f );
void sys_setRenderFunc( AierraRenderFunc f );
void sys_setShutdownFunc( AierraShutdownFunc f );

void sys_go();

void sys_terminate();

void sys_showFPS(bool show=true);

void sys_showConsole(bool show=true);

void sys_enableConsoleLog(string filename="console.log");

ostream& sys_console();

void sys_fastForwardUpdate( int times );

void sys_flushConsole();

DWORD sys_getMilliSec();

void  sys_setRandSeed(int seed);
int   sys_randInt();                    // returns 0..32767
FLOAT sys_randFloat();                  // returns -1.000 .. +1.000

int   sys_localRandInt();               // this returns 0..255 from a LOCAL & INDEPENDENT src
                                                                // has no side effect/dependency to sys_rand***
FLOAT sys_localRandFloat();             // same as localRandInt, but returns float in -1..+1

HWND sys_getWindowHandle();

//------------------------------------------------------------------------------------
// Input
//------------------------------------------------------------------------------------
bool input_isKeyDown    ( int key );
bool input_isKeyPressed ( int key );
bool input_isKeyReleased( int key );

        
void input_resetVKeyMapping();

// this maps the 'VKey' to 'key'
// i.e. if the absolute key 'key' is pressed,  a call to isVKeyPressed(VKey) will return true
void input_mapVKey( int key, int VKey );

bool input_isVKeyDown      ( int VKey );
bool input_isVKeyPressed ( int VKey );
bool input_isVKeyReleased( int VKey );

bool input_isMouseLBDown();
bool input_isMouseMBDown();
bool input_isMouseRBDown();
bool input_isMouseLBClicked();
bool input_isMouseMBClicked();
bool input_isMouseRBClicked();
bool input_isMouseLBDblClicked();
bool input_isMouseMBDblClicked();
bool input_isMouseRBDblClicked();

// get the mouse cursor's x,y coordinate
// coordinate system :  (0,0)=top-left (1,1)=bottom-right   (same for all 2D stuffs)
// note : you need to draw the cursor yourself if you want to let the user sees it
float input_getMouseX();
float input_getMouseY();

// range 0..1 (0 means the wheel was rotated all the way forward, and 1 means backward)
float input_getMouseWheel();

// returns how long (in seconds) has the mouse cursor been idle (not moving)
float input_mouseIdleTime();

//------------------------------------------------------------------------------------
// Resource Control
//------------------------------------------------------------------------------------
AFont           load_font( string fontName, string filename="" );
AMesh           load_mesh( string filename );
ATexture        load_texture( string filename );
ATerrain        load_terrain( string filename, FLOAT sizeX, FLOAT sizeY, FLOAT sizeZ, FLOAT offsetZ );

//------------------------------------------------------------------------------------
// Overlay
//------------------------------------------------------------------------------------
// a 2D overlay this is drawn on top of all the 3D renderings
// coordinate system :  (0,0)=top-left (1,1)=bottom-right
// use these functions to draw 2D shapes.  note that a lot of parameters come with default values
// just make sure you specify where to draw!
// Also, note that it doesn't make much sense to use BlendModes::KEY
// *PRIORITY* should be between 0..9  with 9 being the front most
void overlay_point( const Vec2D pt, const FLOAT size=1.0f, const Vec3D rgb=Colors::white,
                                    const int blendMode=BlendModes::NONE, const FLOAT alpha=1.0f, const int priority=0  );

// lines can have patternss 0,1,2  0_______   1-------    2........
void overlay_line(  const Vec2D pt1, const Vec2D pt2,   const Vec3D rgb=Colors::white, 
                                        const int blendMode=BlendModes::NONE, const FLOAT alpha=1.0f, const int priority=0,
                                        const int pattern=0 );
void overlay_rect(  const Vec2D pt1, const Vec2D pt2, const bool fill=true, 
                                        const Vec3D rgb=Colors::white, const int blendMode=BlendModes::NONE, 
                                        const FLOAT alpha=1.0f, const int priority=0   );

// these functions are for drawing text
// just call overlay_text to get an output stream and dump stuffs into it
// call textOut() to display all the stuffs that you put into the stream
// note that calling textOut() will empty the stream
// you can also manually disregard the stuffs inside the stream by calling clearText()
ostream& overlay_text();
void overlay_textOut( const Vec2D pos, const FLOAT scale=1.0f, const Vec3D rgb=Colors::white, const AFont font=NULL, const int priority=6 );
void overlay_clearText();

// used to draw image flatly on to the screen
void overlay_image( const ATexture image, const Vec2D center, const Vec2D size, 
                                    const int blendMode=BlendModes::NONE, const FLOAT alpha=1.0f, const int priority=0 );

//------------------------------------------------------------------------------------
// Camera Control
// move the camera to the specified 'pos' and look at 'target'
// smoothness indicates whether you want the camera to go there instantly (0.0)
// or slowly move to the specified position (0.9)
// 0 <= smoothness < 1
void camera_set( const Vec3D pos,  const Vec3D target, const FLOAT smoothness=0.0f );

void camera_setScreenSize( FLOAT size );

Vec3D camera_getPos();

Vec3D camera_getVec();

void camera_addVibration(float amount);

//------------------------------------------------------------------------------------
// 3D mesh
// use these functions to render 3d objects (like tanks and missiles)
// dir is a direction vector of three components { theta, phi, roll }
//    theta is the heading ( 0=head north, 90=head east, etc )
//    phi   is whether the mesh is pointing upward or downward ( 0=straight up, 90=horizontal, 180=straight down)
//    roll  is whether the mesh 'head' is pointing up(0), 90degress CW(90), 90 degrees CCW(-90)
// ***NOTE** currently, phi&roll are ignored.  only theta for now.
void mesh_render( const AMesh mesh, const Vec3D pos, const Vec3D size, const Vec3D dir,
                                  const ATexture texture, const ATexture bumpmap=NULL,
                                  const Vec3D stripColor=Colors::red );
//------------------------------------------------------------------------------------
// render the specified terrain using 3 textures (low,high,normal)
// 'low' is how the ground looks like at low altitude (maybe lush green grass)
// 'high' is how it looks at high altitude (maybe dry rock)
// 'normal' describes the roughness of the surface.  just use a regular dot3 normal map
// note : you should only render one terrain each frame
void terrain_render( ATerrain terrain, ATexture texLow, ATexture texHigh, ATexture texNormal );

// get the height at a specific point of the terrain
FLOAT terrain_getHeight( ATerrain terrain, FLOAT x, FLOAT y );
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
// linearly-interpolated flare particles
// to use : call lerp_begin, specify the texture and max# of particles in this frame
// keep adding particles (final position will be along the line (pos1,pos2)
// at 'dist' away from pos1
// once all particles are added, call lerp_end()
// should do begin-end only once per frame
// multiplier ==> per-pixel color&alpha multiplier
void flare_begin( ATexture texture, int maxParticles );
void flare_addParticle( const Vec3D &pos1, const Vec3D &pos2, const Vec4D multiplier,
                                                FLOAT dist, FLOAT size );
void flare_end();
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
// general-purpose point sprites
// slightly slower than the specialized lerp-flare
void sprite_add( ATexture tex, int blendMode, Vec3D pos, Vec4D multiplier, FLOAT size );

//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
// given a 2D point in screen coordinate (such as mouse cursor location), calculates
// the 3D location in the world on a flat plane with height z.
Vec3D math_translateScreenToWorldPlane( const Vec2D pt, FLOAT z );

// translate a 3D point in world-space to 2D screen coordinates
Vec2D math_translateWorldToScreen( const Vec3D pt );

Vec3D math_translateObjectToWorld( const Vec3D objPos, const Vec3D objDir, const Vec3D objPt );

// distance between two points
FLOAT math_dist2D( const Vec2D &a, const Vec2D &b );
FLOAT math_dist3D( const Vec3D &a, const Vec3D &b );
FLOAT math_distPlanar3D( const Vec3D &a, const Vec3D &b );              // if nore the z coordinate

// clip to 0..360 degrees
FLOAT math_clipAngle( FLOAT angle );

// the absolute direction from pt. 'from' to pt. 'to'
FLOAT math_getDir( const Vec3D &from, const Vec3D &to );

// how much we need to turn from current direction to new direction.  returnValue is between -180 .. +180
FLOAT math_deltaDir( const FLOAT currentDir, const FLOAT newDir );

//------------------------------------------------------------------------------------
// For profiling how much time a section of code takes.
// 
#define PROFILER_FUNCTION(s) AProfilerBlock funcProfBlock(s);
void profiler_begin(string s);
void profiler_end(string s);

//------------------------------------------------------------------------------------
// Networking

// server-only functions
void net_runAsServer(string myIP, string myName, int maxNumPlayers);
void net_acceptMorePlayers();
void net_finalizeGame();                        // no more joining.  Assigns everyone a number.

void net_runAsFakeServer(string myName, int maxNumPlayers);

// client-only functions
bool net_connectToServer(string ip, string myName);                     // returns true iff succeed

// both-side functions
string net_getSelfIP();
bool net_amIServer();
vector<string> net_getAllPlayers();             // get players' names
void net_send( string msg );

string net_getPlayerName();                             // get my own name

int net_getPlayerNumber();                              // will be -1 if server didn't net_finalizeGame() yet
                                                                                // otherwise, returns the number the server assigned for you

int net_getPlayerNumUsingName(string playerName);
string net_getPlayerNameUsingNum(int num);

void net_disconnect();

string net_recv();                                              // if no incoming message, returns empty string

//------------------------------------------------------------------------------------

#endif

---