Instrument.h

Go to the documentation of this file.

#pragma once 

#include "../Bus.h"
#include "../Rendering/DeviceObject.h"
#include "../Rendering/Sprite.h"
#include "../Rendering/Font.h"
#include "../Rendering/Text.h"

class Instrument
{
private:
        Instrument();

protected:
        Bus* bus = nullptr;
        Logger* logger = nullptr;
        int screenWidth = 0, screenHeight = 0;
        DEVICE_OBJECT* pDevice = nullptr;
        std::vector<Font>* fonts = nullptr;
        bool flip = false;

        // config items
        int x, y;
        int width = 0, height = 0;
        float xScale, yScale;
        int standardWidth = 0, standardHeight = 0;


public:
        Instrument(int prmX, int prmY, float prmXScale, float prmYScale)
        {
                x = prmX;
                y = prmY;
                xScale = prmXScale;
                yScale = prmYScale;
        };

        virtual void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip)
        {
                bus = prmBus;
                logger = prmLogger;
                pDevice = prmDevice;
                screenWidth = prmScreenWidth;
                screenHeight = prmScreenHeight;
                fonts = prmFonts;
                flip = prmFlip;
        }

        void DrawText(const WCHAR* str, int x, int y, int flags, D3DXCOLOR color, int font, std::string elementName)
        {
                D3DXCOLOR newcolor;
                if (bus->IsDim(elementName))
                        newcolor = color * 0.5f;
                else
                        newcolor = color;

                RECT rc;
                rc.left = x;
                rc.top = y;
                rc.bottom = rc.right = 0;
                HRESULT hr;
                V(fonts->at(font).pFont->DrawText(pDevice->pSprite, str, -1, &rc, flags, newcolor));

                //V(pDevice->pSprite->SetProjectionTransform(&screenMatrix));
        }

        virtual void Render(float fElapsed) = 0;

        virtual ~Instrument()
        {
        }
};


#pragma region PFD
class IndicatedAirSpeedTape : public Instrument
{
private:
        Sprite sprite;
        std::string textureFile;
        float tvpitchscale = 0.0f;
        float vertoffset = 0.0f;
        float tvrange = 0.0f;
        float ias = 0.0f;
        UINT font = 1;
        float modulateKm = 0.0f;

public:
        IndicatedAirSpeedTape(int prmX, int prmY, int prmWidth, int prmHeight, std::string prmTextureFile, float prmModulateKm);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

class AttitudeIndicator : public Instrument
{
private:
        Sprite sprite; // artificial horizon
        Sprite commandBars;
        Sprite glideslope;
        Sprite glideslopebug; // also used for localizer
        Sprite failflag;
        Sprite localizer;
        std::string textureFile;
        float tvpitchscale = 0.0f, cbpitchscale = 0.0f;
        float tvvertoffset = 0.0f, cbvertoffset = 0.0f;
        float tvrange = 0.0f;
        float pitch = 0.0f, roll = 0.0f;

public:
        AttitudeIndicator(int prmX, int prmY, int prmWidth, int prmHeight, std::string prmTextureFile);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

class AltitudeTape : public Instrument
{
private:
        Sprite sprite;
        std::string textureFile;
        float tvpitchscale = 0.0f;
        float vertoffset = 0.0f;
        float alt = 0.0f;
        UINT font = 0;
        float modulateKm = 0.0f;

public:
        AltitudeTape(int prmX, int prmY, int prmWidth, int prmHeight, std::string prmTextureFile, float prmModulateKm);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

class HeadingIndicator : public Instrument
{
private:
        Sprite compassMoving;
        float hdg = 0.0f;
        UINT font = 0;

public:
        HeadingIndicator(int prmX, int prmY, float prmXScale, float prmYScale);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

class FlightModeAnnunciator : public Instrument
{
private:
        Sprite pixel;
        Bus::Afcs::LateralModes oldActiveLateralMode = Bus::Afcs::LateralModes::LateralMode_Off;
        float lateralModeTimer = 3.0f;
        Bus::Afcs::VerticalModes oldActiveVerticalMode = Bus::Afcs::VerticalModes::VerticalMode_Off;
        float verticalModeTimer = 3.0f;
        bool oldAutopilotEngaged = false;
        float autopilotModeTimer = 3.0f;
        UINT font = 1;

public:
        FlightModeAnnunciator(int prmX, int prmY, float prmXScale, float prmYScale);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

#pragma endregion

#pragma region EICAS
class AlertMessageStack : public Instrument
{
private:
        Sprite sprite;

public:
        AlertMessageStack(int prmX, int prmY, float prmXScale, float prmYScale);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

class Diagnostics : public Instrument
{
public:
        Diagnostics(int prmX, int prmY, float prmXScale, float prmYScale);
        void Render(float fElapsed) override;
};

class N1Indicator : public Instrument
{
private:
        Sprite needle;
        //Sprite commanded;
        Sprite pixel;
        Text digital;
        Text status;
        float n1 = 0.0f; // for smoothing
        //UINT font = 0;
        Systems::Fault* fadecFaultPtr = nullptr;
        Systems::Fault* n1FaultPtr = nullptr;
        float* n1GetFloatPtr = nullptr;
        //int engineOrdinal = -1;
        std::string guid1;
        std::string guid2;

public:
        N1Indicator(int prmX, int prmY, float prmXScale, float prmYScale, std::string prmGuid1, std::string prmGuid2, int prmOrdinal);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

class ITTIndicator : public Instrument
{
private:
        Sprite needle;
        //Sprite pixel;
        Text digital;
        Text ignition;
        float itt = 2.0f; // for smoothing
        //UINT font = 0;
        float* ignitorAGetFloatPtr = nullptr;
        //DWORD* ittFaultPtr = NULL;
        float* ittGetFloatPtr = nullptr;
        int engineOrdinal = -1;
        std::string guid1;
        std::string guid2;

public:
        ITTIndicator(int prmX, int prmY, float prmXScale, float prmYScale, std::string prmGuid1, std::string prmGuid2, int prmOrdinal);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};

#pragma endregion

#pragma region MFD
class MovingMap : public Instrument
{
private:
        Sprite compass;
        Sprite waypointSprite;
        Sprite course;

public:
        MovingMap(int prmX, int prmY, float prmXScale, float prmYScale);
        void Initialize(Bus* prmBus, Logger* prmLogger, DEVICE_OBJECT* prmDevice, int prmScreenWidth, int prmScreenHeight, std::vector<Font>* prmFonts, bool prmFlip) override;
        void Render(float fElapsed) override;
};
#pragma endregion