Viewscreen.h

Go to the documentation of this file.

#pragma once

#include <WinSock2.h>
#include <WS2tcpip.h>
#include <Windows.h>
#include "DXUT.h"

#ifndef DIRECTINPUT_VERSION
#define DIRECTINPUT_VERSION     0x0800  // dinput.h throws a notice if we don't define it, We should look at moving this define to globals.h
#include "dinput.h"                                                     //Needed for Directinput like joystick / force feedbacl / keyboard
#endif

#include "grid.h"                                                       //Class that does stuff related to the grid
#include "weapon.h"                                                     //Pew! Pew!
#include "buildings.h"                                          //All building update related stuff
#include "keyboard.h"                                           //To handle all keyboard related things
#include "joystick.h"                                           //Handles joystick updating
#include "FreeTrack.h"                                          //Handles Head Tracker updating
#include "propulsion.h"                                         //Handles propulsion updating
#include "renderer.h"                                           //Handles render stuff, like loading textures. 
#include "weather.h"                                            //All the code that used to be in fog.cpp is now in here.
#include "cockpit.h"                                            //Cockpit drawing code in here
#include "instruments.h"                                        //The old stats.cpp code for now
#include "waypoints.h"

#include "../GameClass.h"

#define depthFloorResolutionC 2048L

class Viewscreen
{
        //Utility variable
        char msg[199];

        float lowframeTime;
        float frameRateHeartbeat = 240.0f; // send every 5 minutes but send after first minute

        //LARGE_INTEGER newTime, oldTime, frequency;

public:

        std::vector<RECT> rooms;
        D3DXVECTOR3 compassnorth;

        //----------- Fonts! Yes we want them too! -----------
        LPD3DXFONT              m_pFont = nullptr;                                              // A font to output text
        LPD3DXFONT              m_pFontLicense = nullptr;
        LPD3DXFONT              m_pFont3 = nullptr;
        LPD3DXFONT              m_pFontHull = nullptr;

        std::vector<std::string> sofTracking;

        Viewscreen(GameClass *);
        ~Viewscreen();

        void Initialize();
        HRESULT OnCreateDevice(IDirect3DDevice9* pd3dDevice);
        void SetProjectionMatrices();
        HRESULT OnResetDevice(IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc);
        void OnLostDevice();
        void OnDestroyDevice();
        void DumpSofTracking();
        bool AssertTelemetry(const char* location, short id);
        void OutsideView(bool outside);
        static RECT WhichRoom(const std::vector<tagRECT>& rooms, float x, float y, short* roomIndex);
        void OnFrameMove(double fTime, float fElapsedTime);
        void OnFrameRender(IDirect3DDevice9* pd3dDevice, double fTime) const;
        void OnFrameRender2(IDirect3DDevice9* pd3dDevice, float fElapsedTime);

        void ApplyEnvironmentMap();
        float CalculateAGL(short u, short v, D3DXVECTOR3 position, bool makeleveler);
        float CalculateAGLd(D3DXVECTOR3 terpos, double terprecisionx, double terprecisiony, double terprecisionz, double proposedx, double proposedy, double proposedz, D3DXVECTOR3 proposed, bool makeleveler);
        void LoadVehicleProfile(short t, bool forceCockpitTextures = false);
        float ProbeBoundSphere(D3DXVECTOR3* position, const D3DXVECTOR3* Xsunlight) const;
        Sani GetAni(float f_time, unsigned char ani) const;
        static D3DXVECTOR3 CalculateBarycentric(D3DXVECTOR3* position, D3DXVECTOR3* gthrust, float* radius);
        bool CheckPlotRoads(float f_tempu, float f_tempv);
        //      Sani GetAni( float f_time, unsigned char ani );
        void Movement(short t, float ElapsedTime);
        char CalculateCube(D3DXVECTOR3 position) const;
        VECTOR2SHORT CalculateCGC(D3DXVECTOR3 position, char cube) const;
        //float CalculateBCL(short u, short v, D3DXVECTOR3 position) const;
        VECTOR2SHORT CalculateWrap(short u, short v, char cube, char* rotate) const;
        LOCALGRID2 CalculateSRV(short t, short s, VECTOR2SHORT tcp, char cube, SRenderVertex sourcedata);
        D3DXVECTOR3 D3DXVec3Qerp(D3DXVECTOR3 *vel0, D3DXVECTOR3 *vel1, D3DXVECTOR3 *vel2, float t) const;
        long FontOffset(char letter) const;
        float CheckDepthMap(VECTOR2SHORT newdepthpos, short u, short v);
        float CheckFloorMap(VECTOR2SHORT newdepthpos, short u, short v);
        float CheckRtsBumpMap(VECTOR2SHORT rts, VECTOR2SHORT bump, short u, short v);
        void Undock() const;
        void TriggerBCLLightning(float distanceScalar, float intensityScalar) const;

        D3DXVECTOR3 CalculatePlanar(short u, short v);

        //----------- Force feedback and general input devices -> Input class -----------
        LPDIRECTINPUT8        g_pDI = nullptr; // The DirectInput interface       


        //----------- Vertex & Index buffers ------------
        // Static VB, doesn't change every frame
        LPDIRECT3DVERTEXBUFFER9 m_avStaticStars = nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avCone = nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avSunVertices = nullptr;
#ifdef treetestC
        LPDIRECT3DVERTEXBUFFER9 m_avTree;
#endif
        LPDIRECT3DVERTEXBUFFER9 m_avRunningLights = nullptr;    // For the running lights
        LPDIRECT3DINDEXBUFFER9  m_aiCloudGrid = nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avCloudGrid = nullptr;
        //LPDIRECT3DINDEXBUFFER9        m_aiLocalGrid= nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avLocalGrid = nullptr;

        // Dynamic VB, changes every frame
        LPDIRECT3DVERTEXBUFFER9 m_avRainDrops = nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avSkyDome = nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avSkyRing = nullptr;
        LPDIRECT3DVERTEXBUFFER9 m_avScreen = nullptr;                   // Alpha blended viewscreen
        LPDIRECT3DVERTEXBUFFER9 m_avInstrument = nullptr;               // Instrumentation
        LPDIRECT3DVERTEXBUFFER9 m_avLightning = nullptr;

        //----------- Textures -----------
        // Static Textures
        //LPDIRECT3DTEXTURE9 m_pddsDetail1;
        LPDIRECT3DTEXTURE9 m_pddsWorld2a1 = nullptr;                    // Iomere
        LPDIRECT3DTEXTURE9 m_pddsCloudBaseMap = nullptr;                // Clouds
        LPDIRECT3DTEXTURE9 m_pddsCloudDetailAbove = nullptr;    // Clouds
        LPDIRECT3DTEXTURE9 m_pddsCloudDetailBelow = nullptr;    // Clouds
        LPDIRECT3DTEXTURE9 m_pddsBinoculars = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsBinocularsCompass = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsBinocularsArrow = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsSunglasses = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsSunTexture = nullptr; // Yonmara
        LPDIRECT3DTEXTURE9 m_pddsStarTexture = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsHolidayTexture = nullptr;

        LPDIRECT3DTEXTURE9 m_pddsWeapon[weaponanimateC];
        LPDIRECT3DTEXTURE9 m_pddsSinker[weaponanimateC];
        LPDIRECT3DVOLUMETEXTURE9 m_pddsFuzerX = nullptr;
        LPDIRECT3DVOLUMETEXTURE9 m_pddsSinkerX = nullptr;
        LPDIRECT3DVOLUMETEXTURE9 m_pddsBlastX = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsFirework1[firework1C];
        LPDIRECT3DTEXTURE9 m_pddsFirework2[firework2C];
        LPDIRECT3DTEXTURE9 m_pddsFirework3[firework3C];
        LPDIRECT3DTEXTURE9 m_pddsElmo[elmoAnimateC];
#ifdef smoketestC
        LPDIRECT3DTEXTURE9 m_pddsSmoke[smoketrailC];
#endif
        LPDIRECT3DTEXTURE9 m_pddsDIHV[dihvanimateC];
        LPDIRECT3DTEXTURE9 m_pddsHeart[heartanimateC];
        LPDIRECT3DVOLUMETEXTURE9 m_pddsReentry = nullptr;


        // Cockpit dashes
        LPDIRECT3DTEXTURE9 m_pddsGVDialSmall = nullptr; // must be seperate, rotates
        LPDIRECT3DTEXTURE9 m_pddsGVBackground = nullptr; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsNamePlate = nullptr; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsGVCompass = nullptr; // must be seperate, wraps
        LPDIRECT3DTEXTURE9 m_pddsGVDirection = nullptr; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsLightsCruiseIcons = nullptr; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsFuelIcon = nullptr; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsAOA[3]; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsCockpitTexture[cockpittextureC];
        LPDIRECT3DTEXTURE9 m_pddsCockpitLights[cockpittextureC];
        // Not reloaded with new cockpit
        //LPDIRECT3DTEXTURE9 m_pddsVector = nullptr; // could be combined
        //LPDIRECT3DTEXTURE9 m_pddsAGLtape = nullptr; // could be combined
        LPDIRECT3DTEXTURE9 m_pddsInterlace[2]; // must be seperate, wraps
        LPDIRECT3DTEXTURE9 m_pddsKeycard = nullptr;



        // Interface
        //LPDIRECT3DTEXTURE9 m_pddsCardioscan = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsLetters = nullptr;

        LPDIRECT3DTEXTURE9 m_pddsLightningBelow[3];
        LPDIRECT3DTEXTURE9 m_pddsLightningAbove[3];
        LPDIRECT3DTEXTURE9 m_pddsAtmosphere = nullptr;
#ifdef treetestC
        LPDIRECT3DTEXTURE9 m_pddsTree;
#endif
        LPDIRECT3DTEXTURE9 m_pddsShipTexture[shiptextureC];
        LPDIRECT3DTEXTURE9 m_pddsShipLights[shiptextureC];
        LPDIRECT3DTEXTURE9 m_pddsDockTexture[docktextureC];
        LPDIRECT3DTEXTURE9 m_pddsDockLights[docktextureC];
        LPDIRECT3DTEXTURE9 m_pddsRTSTexture[RTStextureC];
        LPDIRECT3DTEXTURE9 m_pddsRTSLights[RTStextureC];
        LPDIRECT3DTEXTURE9 m_pddsCityTexture[citytextureC];
        LPDIRECT3DTEXTURE9 m_pddsCityLights[citytextureC];

        LPDIRECT3DTEXTURE9 m_pddsLandform[landformtextureC];
        LPDIRECT3DTEXTURE9 m_pddsTransition[transitiontextureC];
        LPDIRECT3DTEXTURE9 m_pddsWaterNormal = nullptr;

        LPDIRECT3DTEXTURE9 m_pddsMarston1 = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsRunwayEdgeLight1 = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsRoad = nullptr;
        LPDIRECT3DTEXTURE9 m_pddsIntersection = nullptr;

        // Dynamic Textures - Used for shipnames on hull
        LPDIRECT3DTEXTURE9 m_pddsDynamicTexture = nullptr; // instrumentation texture
        LPDIRECT3DSURFACE9 m_pddsDynamicSurface = nullptr; // instrumentation surface
        LPDIRECT3DTEXTURE9 m_pddsProjectionTexture = nullptr; // projection texture
        LPDIRECT3DSURFACE9 m_pddsProjectionSurface = nullptr; // projection surface
        LPD3DXRENDERTOSURFACE m_pRenderToSurface = nullptr; // 907x352
        LPD3DXRENDERTOSURFACE m_pRenderToSurfaceNextGen = nullptr; // 1135, 388
        LPD3DXRENDERTOSURFACE m_pHullRender2Surface = nullptr; // 256x128

        LPDIRECT3DTEXTURE9 m_pddsHullDynamicTexture[MAX_SCAN] = {}; // hull and license plates



        // Sprites
        LPD3DXSPRITE m_spriteVector = nullptr;

        D3DMATERIAL9 restore;
        D3DLIGHT9 sunlight, headlight; // 0 and 1 for Yonmara and headlight, allows PUREDEVICE
        float fAspect = 0.0f;
        D3DXMATRIX matrixProj, matrixProjCock, matrixProjnodistort, matrixProjSim;
        D3DXMATRIX matrixView, matrixLook, matrixLookAdj;
        D3DXMATRIX matGridRot; // this is used for the lookhdg exclusion of terrain on gridvisible[][]


        bool m_bDeviceSupportsVizQuery = false, m_bCloudShadow = false, m_bFourStages = false, m_bPsize = false;
        LPDIRECT3DQUERY9 m_pLightSunVizQuery = nullptr;




        D3DXVECTOR3 headlightvec, lookvec;
        D3DXCOLOR alphascreen = 0UL;
        D3DXVECTOR4 gammascreen; // x is currentframe0-63, y is speedFPS, z is numberOfFramesToRunSequentially, w is opasity
        D3DXVECTOR3 terpos;
        float insthdgDegrees = 0.0f, lookhdg = 0.0f, insttrk = 0.0f, lookAzimuthDegrees = 0.0f;
        double terprecisionx = 0.0, terprecisiony = 0.0, terprecisionz = 0.0;
        double cloudprecisionx = 0.0, cloudprecisiony = 0.0, cloudprecisionz = 0.0;
        float pitchInput = 0.0f, rollInput = 0.0f, yawInput = 0.0f;
        float rcsThrustOutputX = 0.0f, rcsThrustOutputY = 0.0f, rcsThrustOutputZ = 0.0f;
        float rcsThrustRequestX = 0.0f, rcsThrustRequestY = 0.0f, rcsThrustRequestZ = 0.0f;
        bool advanceframe = false;
        char causechain = 0; // like old dead used to be
        unsigned short causearray = 0; // for ship they hit, etc
        float lateraltime = 0.0f, verticaltime = 0.0f;
        bool lateralmod = false, verticalmod = false, yawmod = false;
        short oldRoomIndex = -1; // for menus

        D3DXVECTOR3 position; // Used in Latitude/Longitude and for facet distances in Vieneo
        D3DXVECTOR3 posnorml; // used for wind calculations, etc

        //These came from Viewscreen Keyboard class 
        float lateralincr = 0.0f;
        float verticalincr = 0.0f;

        // Internal arrays
        s_polygon_extras2 polyextras2 = s_polygon_extras2();
        //      VECTOR2SHORT newdepthpos;

        D3DXVECTOR3 cloudpos;
        D3DXVECTOR3 rainarray[MAX_RAINDROPS];
        short raindrops = 0;

        bool gridvisible[63][63]; // this is based on our FOV (stored without rotation info)
        bool visiblegrid[63][63]; // within 32 plots circle scribed out of the square grid

        short waterloop = 0, heartloop = 0;
        short BCLoffsetu = 0, BCLoffsetv = 0;
        float H2Ooffsetu = 0.0f;
        short dockTexture = 0, oldDockTexture = 0, dockTextureStage = 0;
        char flicker = 0;
        float interlace = 0.0f;
        float lampTest = 0.0f;
        bool outside = false;


        // For scanners
        short scanslot[MAX_SCAN];
        float scandist[MAX_SCAN];

        grid* ptrGrid = nullptr;
        weapon* ptrWeapon = nullptr;
        buildings* ptrBuildings = nullptr;
        keyboard* ptrKeyboard = nullptr;
        joystick* ptrJoystick = nullptr;
        FreeTrack* ptrFreeTrack = nullptr;
        propulsion* ptrPropulsion = nullptr;
        renderer* ptrRenderer = nullptr;
        weather* ptrWeather = nullptr;
        cockpit* ptrCockpit = nullptr;
        instruments* ptrInstruments = nullptr;
        waypoints* ptrWaypoints = nullptr;

        GameClass* gameclass = nullptr;
        Logger* logger = nullptr;

#ifdef _DEBUG
        CStopWatch *cityTimer = nullptr;
        CStopWatch *cockpitFrameMoveTimer = nullptr;
        CStopWatch *instrumentsFrameMoveTimer = nullptr;
        CStopWatch *weatherFrameMoveTimer = nullptr;
        CStopWatch *modulesFrameMoveTimer = nullptr;
        CStopWatch *displaysFrameMoveTimer = nullptr;
        CStopWatch *inputFrameMoveTimer = nullptr;
        CStopWatch *weaponsFrameMoveTimer = nullptr;
        CStopWatch *propulsionFrameMoveTimer = nullptr;
        CStopWatch *otherFrameMoveTimer = nullptr;
        CStopWatch *shipTimer = nullptr;
        CStopWatch *liteTimer = nullptr;
#endif


        float leftright = 0.0f, targetLeftright = 0.0f; // Radians
        float updown = -D3DXToRadian(10.0f), targetUpdown = -D3DXToRadian(10.0f);
        float rolltilt = 0.0f; // Radians
        float leftlimit, rightlimit, uplimit, downlimit, tiltlimitL, tiltlimitR = 0.0f; // Radians
        float counteri = 0.0f, counterj = 0.0f, counterk = 0.0f;
        
        // For skyring
        float radperseg = D3DX_TAU / static_cast<float>(skydomeC);
};