Instrument.h

Go to the documentation of this file.

#pragma once

#include "../Displays/DeviceObject.h"
#include "../Displays/Font.h"
#include "../Bus.h"
#include "../Displays/Sprite.h"

class Instrument
{
        std::vector<Font*> fonts;

protected:
        int x = 0;
        int y = 0;
        float xScale = 1.0f;
        float yScale = 1.0f;
        DeviceObject* pDevice = nullptr;
        Bus* bus = nullptr;
        Logger* logger = nullptr;
        UINT defaultFont = 0;

        int uiRow = 0;
        bool showMenu = false;
        int uiMenuColumn = -1;

public:
        Instrument(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts)
        {
                logger = prmLogger;
                logger->AddToCallStack("Instrument::ctor");
                x = prmX;
                y = prmY;
                xScale = prmXScale;
                yScale = prmYScale;
                bus = prmBus;
                pDevice = prmDevice;
                fonts = prmFonts;
        }

        void DrawText(const WCHAR* str, int relativeX, int relativeY, float prmZ, int flags, D3DXCOLOR color, int font = -1, std::string elementName = "", int width = 0, int height = 0)
        {
                logger->AddToCallStack("Instrument::DrawText");

                if (font == -1)
                        font = defaultFont;

                //D3DXCOLOR newcolor;
                //if (bus->IsDim(elementName))
                //      newcolor = color * 0.5f;
                //else
                //      newcolor = color;

                RECT rc;
                rc.left = relativeX + x;
                rc.top = relativeY + y;
                rc.bottom = rc.top + height;
                rc.right = rc.left + width;

                if (font < 0 || font >= static_cast<int>(fonts.size()))
                        throw std::exception("Tried to DrawText with a font that is outside of the fonts collection!");

                D3DXMATRIX transform(
                        1.0f, 0.0f, 0.0f, 0.0f,
                        0.0f, 1.0f, 0.0f, 0.0f,
                        0.0f, 0.0f, 1.0f, 0.0f,
                        0.0f, 0.0f, prmZ, 1.0f);

                HRESULT hr;
                V(pDevice->pSprite->SetTransform(&transform));

                if (FAILED(hr = fonts.at(font)->pFont->DrawTextW(pDevice->pSprite, str, -1, &rc, flags, color)))
                {
                        logger->Log("Instrument::DrawText failed!", Logger::Error, hr);
                }
        }

        virtual void Render() = 0;

        virtual void FrameMove(float fElapsed)
        {
        }

        virtual bool HandleKeyPress(short key, bool shift)
        {
                return false;
        }

        virtual void OnPageChanged()
        {
                //uiRow = 0;
                //showMenu = false;
                //uiMenuColumn = -1;
        }
};

class CargoManagement : public Instrument
{
        std::string rowType[64];
        int rowValue[64] = {};
        void RenderRow(const WCHAR* row, DWORD color, int rowId, std::string type = "", int value = 0);

public:
        CargoManagement(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        bool HandleKeyPress(short key, bool shift) override;
};

class Intermedia : public Instrument
{
public:
        Intermedia(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        bool HandleKeyPress(short key, bool shift) override;
};

class LineInput : public Instrument
{
        int cursorState = false;
        float cursorTime = 0.0f;
        std::string pageName;

public:
        LineInput(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts, std::string prmPageName);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class Diagnostics : public Instrument
{
public:
        Diagnostics(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
};

class Scanner : public Instrument
{
public:
        Scanner(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        bool HandleKeyPress(short key, bool shift) override;
};

class LandingStrut : public Instrument
{
        Sprite* down = nullptr;
        Sprite* up = nullptr;
        Sprite* transit = nullptr;

public:
        LandingStrut(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
};

class LandingGear : public Instrument
{
        Sprite* box = nullptr;
        Sprite* dots = nullptr;

public:
        LandingGear(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
};

class EngineBox : public Instrument
{
        Sprite* box = nullptr;
        int engineIndex = -1;
        WCHAR label[5] = { 0 };
        WCHAR percent[5] = { 0 };
        DWORD color = 0L;

public:
        EngineBox(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts, int prmEngineIndex);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class EngineBar : public Instrument
{
        Sprite* box = nullptr;
        Sprite* bar = nullptr;
        int engineIndex = -1;
        DWORD color = 0L;
        int yBias = 0;
        int bottomBias = 0;

public:
        EngineBar(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts, int prmEngineIndex);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class HeadlightBox : public Instrument
{
        Sprite* box = nullptr;
        Sprite* fill = nullptr;

public:
        HeadlightBox(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
};

class HeadlightIcon : public Instrument
{
        Sprite* icon = nullptr;

public:
        HeadlightIcon(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
};

class ElevatorTrim : public Instrument
{
        Sprite* background = nullptr;
        Sprite* indicator = nullptr;
        int yBias = 0;
        WCHAR label[5] = { 0 };

public:
        ElevatorTrim(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class Flaps : public Instrument
{
        Sprite* slat = nullptr;
        Sprite* background = nullptr;
        Sprite* flap = nullptr;
        float radians = 0.0f;
        WCHAR label[5] = { 0 };

public:
        Flaps(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class AlertMessageStack : public Instrument
{
        Sprite* sprite = nullptr;

public:
        AlertMessageStack(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
};

class MovingMap : public Instrument
{
        Sprite* compass = nullptr;
        Sprite* headingBug = nullptr;
        Sprite* bearingBug = nullptr;
        Sprite* flyoverFix = nullptr;
        Sprite* malteseFix = nullptr;
        Sprite* touchdown = nullptr;
        Sprite* userPin = nullptr;
        Sprite* assay = nullptr;
        //Sprite* course;
        float pixelPerKmX = 0.0f;
        float pixelPerKmY = 0.0f;
        std::vector<Swaypoint> waypoints;
        float iconOffsetX = 0.0f;
        float iconOffsetY = 0.0f;
        float headingTrueRad = 0.0f;
        VECTOR2SHORT assayGrid[21];
        DWORD assayColor[21] = {};
        D3DXVECTOR2 relativeCenter = D3DXVECTOR2(0, 0);
        float remoteAssayPower = 0.0f;

public:
        MovingMap(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class Wind : public Instrument
{
        Sprite* arrow = nullptr;
        float radians = 0.0f;
        WCHAR label[7] = { 0 };

public:
        Wind(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class FMA : public Instrument
{
        Sprite* lateralBox = nullptr;
        Sprite* lateralModeBarCurrent = nullptr;
        Sprite* lateralSetBar = nullptr;
        Sprite* verticalBox = nullptr;
        Sprite* verticalModeBarCurrent = nullptr;
        Sprite* verticalSetBar = nullptr;
        int oldActiveLateralMode = Bus::Afcs::LateralModes::LateralMode_Off;
        int oldActiveVerticalMode = Bus::Afcs::VerticalModes::VerticalMode_Off;
        float oldLateralSetValue = 0.0f;
        float oldVerticalSetValue = 0.0f;
        float lateralModeTimer = 0.0f;
        float verticalModeTimer = 0.0f;
        float lateralSetTimer = 0.0f;
        float verticalSetTimer = 0.0f;
        DWORD lateralModeTextColor = 0xFF00FF00;
        DWORD lateralModeBackColor = 0xFF000000;
        DWORD verticalModeTextColor = 0xFF00FF00;
        DWORD verticalModeBackColor = 0xFF000000;
        WCHAR lateralModeText[10] = { 0 };
        WCHAR lateralSetText[10] = { 0 };
        WCHAR verticalModeText[10] = { 0 };
        WCHAR verticalSetText[10] = { 0 };
        DWORD lateralSetTextColor = 0xFF00FF00;
        DWORD lateralSetBackColor = 0xFF000000;
        DWORD verticalSetTextColor = 0xFF00FF00;
        DWORD verticalSetBackColor = 0xFF000000;


public:
        FMA(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class Orbit : public Instrument
{
        float radians = 0.0f;
        WCHAR label[7] = { 0 };

        D3DXVECTOR3 rx = centerC, vx = centerC, ex = centerC, tv = centerC, hx = centerC, nx = centerC;
        D3DXVECTOR3 oldposition = centerC;
        D3DXVECTOR3 oldvelocity = centerC;
        float ec = 0.0f; // eccentricity
        float tp = 0.0f; // period of the orbit
        float aa = 0.0f; // altitude of apoapsis
        float ap = 0.0f; // altitude of periapsis
        float vo = 0.0f; // degrees from periapsis passage, true anomoly?
        float ix = 0.0f; // inclination from ecliptic
        float halfsec = 0.0f;

public:
        Orbit(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class CarRadio : public Instrument
{
        Sprite* background = nullptr;
        float m_fAnimateFrame = 0.0f;
        float textpos = 0.0f;
        WCHAR nowPlaying[99] = { 0 };

public:
        CarRadio(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class AttitudeIndicator : public Instrument
{
        Sprite* artificialHorizon = nullptr;
        Sprite* commandBars = nullptr;
        Sprite* failFlagLocalizer = nullptr;
        Sprite* failFlagGlideslope = nullptr;
        Sprite* glideslopeBox = nullptr;
        Sprite* glideslopeBug = nullptr;
        Sprite* localizerBox = nullptr;
        Sprite* localizerBug = nullptr;
        Sprite* aoaHigh = nullptr;
        Sprite* aoa = nullptr;
        Sprite* aoaLow = nullptr;
        Sprite* recticle = nullptr;
        Sprite* vector = nullptr;
        float roll = 0.0f;
        float pitch = 0.0f;
        const float width = 348;
        const float height = 344;
        float tvpitchscale = 0.0f;
        float tvvertoffset = 0.0f;
        float cbpitchscale = 0.0f;
        float cbvertoffset = 0.0f;
        int xMargins = 0, yMargins = 0;
        float halftvrange = 0.0f;
        float tvpitch = 0.0f;
        RECT scissor_rect = {};
        char lastAOA = 0;
        D3DXVECTOR3 recticleVec;
        D3DXVECTOR3 velocityVec;

public:
        AttitudeIndicator(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class StreetView : public Instrument
{
        //Sprite* background = nullptr;
        Sprite* cityMap = nullptr;
        Sprite* airplane = nullptr;
        Sprite* navTarget = nullptr;
        float width, height;

public:
        StreetView(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class IndicatedAirSpeed : public Instrument
{
        Sprite* tape = nullptr;

public:
        IndicatedAirSpeed(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class RadioAltimeter : public Instrument
{
        Sprite* tape = nullptr;

public:
        RadioAltimeter(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class Altimeter : public Instrument
{
        Sprite* tape = nullptr;

public:
        Altimeter(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class Compass : public Instrument
{
        Sprite* tape = nullptr;

public:
        Compass(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};

class TCASOverlay : public Instrument
{
        Sprite* noThreat = nullptr;
        Sprite* proximate = nullptr;
        Sprite* potentialThreat = nullptr;
        Sprite* collisionThreat = nullptr;
        float pixelPerKmX = 0.0f;
        float pixelPerKmY = 0.0f;
        std::vector<s_network_objects> targets;
        float iconOffsetX = 0.0f;
        float iconOffsetY = 0.0f;
        float headingTrueRad = 0.0f;
        D3DXVECTOR2 relativeCenter = D3DXVECTOR2(0, 0);
        float rotate = 0.0f;

public:
        TCASOverlay(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts);
        void Render() override;
        void FrameMove(float fElapsed) override;
};