---

AState.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_ASTATE
#define INCLUDE_ASTATE

#include "ExternalLibs.h"
#include "ATypes.h"
#include "AVertexTypes.h"

const int MAX_CONSOLE_LINES             =       30;
const int MAX_KEY                               =       300;

const int MAX_STATE_TYPE        =       256;
const int MAX_STREAM            =       32;
const int MAX_TEXTURE           =       4;
const int MAX_LOCAL_RANDON_NUM          =       512;
const int MAX_LOCAL_RANDON_FLOAT        =       1024;


//------------------------------------------------------------------------------------
struct AState
{
        // system stuffs.  handle to system resource
        HINSTANCE                               hInst;
        HWND                                    hWnd;
        LPDIRECT3D8                             pD3D;
        LPDIRECT3DDEVICE8               pDevice;

        // window spec
        int                                             windowWidth, windowHeight, colorDepth;
        bool                                    isFullScreen;
        DWORD                                   clearFlags;                     // flags indicating which bits of the video buffer should be cleared

        // game loop call-back functions & control values       
        AierraInitFunc                  initFunc;
        AierraUpdateFunc                updateFunc;
        AierraRenderFunc                renderFunc;
        AierraShutdownFunc              shutdownFunc;
        DWORD                                   idealMS;                        // ideally(running at 62.5Hz), this would be the time in millisec
        DWORD                                   lastCountResetMS;       // time when we last reset updateCount
        DWORD                                   updateCount;            // number of updates's since last reset
        FLOAT                                   updateRate;                     // rate (updates/sec)
        DWORD                                   renderCount;
        FLOAT                                   renderRate;
        DWORD                                   excessCount;            // if we update&render too fast, this keeps track of excess time
        FLOAT                                   excessRate;
        bool                                    showFPS;
        int                                             renderNumber;           // +=1 every time we try to render (skipped or not)
        int                                             skipRate;                       // normally 0.  2 means render once skip twice
        int                                             fastForwardAmount;      // when you call sys_fastForwardUpdate, we store the number of times here


        // console
        bool                                    showConsole;
        ofstream                                *pConsoleLogFile;
        ostringstream                   *pConsoleStream;
        string                                  consoleLines[MAX_CONSOLE_LINES];        // each line of the console window
        int                                             consoleLineIndex;
        
        // input
        NDX_Input                               ndxInput;                                       // NukeDX Wrapper of Direct Input
        bool                                    keyDownLastCycle[MAX_KEY];      // Whether each of the keys was down last cycle
        bool                                    keyDownThisCycle[MAX_KEY];
        int                                             VKmapping[MAX_KEY];                     // keyCode = mapping[VKeyCode]
        FLOAT                                   input_mouseWheel;
        Vec2D                                   input_lastTickMousePos;
        int                                             input_mouseIdleTickCount;

        // rendering device     
        DWORD device_renderStates[MAX_STATE_TYPE];
        DWORD device_vsh, device_psh;
        void *device_vb[MAX_STREAM];
        void *device_ib;
        IDirect3DBaseTexture8 *device_texture[MAX_TEXTURE];

        // shaders
        DWORD vshader_overlay;
        DWORD pshader_overlay;
        DWORD pshader_textureConstAlpha;
        DWORD pshader_texturePixelAlpha;
        DWORD vshader_mesh;
        DWORD pshader_mesh;
        DWORD vshader_terrain;
        DWORD pshader_terrain;
        DWORD vshader_lerpParticle;
        DWORD pshader_lerpParticle;
        DWORD vshader_sprite;
        DWORD pshader_sprite;

        // overlay
        LPDIRECT3DVERTEXBUFFER8         overlay_pVB;
        vector<OverlayEntry>            overlay_entries;
        ostringstream                           *overlay_pTextStream;

        // resource
        vector<CD3DFont*>                       res_fonts;
        vector<LPDIRECT3DTEXTURE8>      res_textures;
        vector<MeshEntry>                       res_meshes;
        vector<TerrainEntry>            res_terrains;
        vector<int>                                     res_localRandomNums;
        int                                                     res_localRandomNumIndex;
        vector<float>                           res_localRandomFloats;
        int                                                     res_localRandomFloatIndex;

        // mesh support
        vector<MeshRenderRequestEntry>          mesh_renderList;
        LPDIRECT3DVERTEXBUFFER8         mesh_vb;
        LPDIRECT3DINDEXBUFFER8          mesh_ib;
        vector<MeshVertex>                      mesh_raw_vb;
        vector<USHORT>                          mesh_raw_ib;

        // camera
        Vec3D           camera_pos;
        Vec3D           camera_target;
        D3DXMATRIX      camera_viewMatrix, camera_projMatrix;
        D3DXMATRIX      camera_world2projMatrix;
        FLOAT           camera_screenSize;
        FLOAT           camera_vibratePos;                      // with position and speed, we will simulate underdamped vibration
        FLOAT           camera_vibrateSpeed;

        // particle systems
        // lerp-flare
        LPDIRECT3DVERTEXBUFFER8         flare_vb;
        ATexture                                        flare_texture;
        int                                                     flare_startRenderingIndex;
        int                                                     flare_renderCount;
        int                                                     flare_reservedCount;                    // how much the user reserved (via flare_begin())
        LerpParticleVertex                      *flare_pVertex;
        // general point sprites
        LPDIRECT3DVERTEXBUFFER8         sprite_vb;
        int                                                     sprite_startRenderingIndex;     
        vector<SpriteRenderRequestEntry>        sprite_renderList;



        // profiler
        map<string,__int64>             profiler_startTime, profiler_totalTime;
        vector<string>                  profiler_names;
        __int64                                 profiler_RDTSClastReset;        // rdtsc time when we last reset total time
        int                                             profiler_MSlastReset;           // MilliSec when we last reset total time

        // networking
        NDX_Connect                             net_ndxConnect;
        bool                                    net_isInit;                                     // whether the whole network system was init'ed
        bool                                    net_isServer;                           // am I a server?
        list<string>                    net_serverSendQueue;            // msgs in server still waiting to be sent
        string                                  net_myName;
        bool                                    net_gameFinalized;
        int                                             net_myPlayerNum;
        DPID                                    net_serverDPID;
        bool                                    net_isFakeServer;
        map<int,string>                 net_mapNumToName;                       // map playerName <--> playerNumber
        map<string,int>                 net_mapNameToNum;
};
//------------------------------------------------------------------------------------

extern AState AS;

#endif

---