Avionics.cpp

Go to the documentation of this file.

#define DIRECTINPUT_VERSION 0x0800


//--------------------------------------------------------------------------------------
// Includes
//--------------------------------------------------------------------------------------
#include "Config.h"
#include "Virtualization.h"
#include "Devices/Printer.h"

#include <time.h>

//--------------------------------------------------------------------------------------
// Global variables
//--------------------------------------------------------------------------------------
LPDIRECTINPUT8 g_pDI = nullptr;
Logger logger;
Bus bus = Bus(&logger);
Systems::Virtualization virtualization = Systems::Virtualization(&logger, &bus);
std::vector<Module*> modules;
Viewport viewport = Viewport(&bus, &logger);
Config config;
Devices::Apcupsd ups;
std::vector<Devices::InterfaceKit> ifKits;
std::vector<Devices::Analog> analogs;
std::vector<Devices::Encoder> encoders;
Devices::Keyboard keyboard;
Devices::Spatial spatial;
Devices::RakNet rakNet;
std::vector<Devices::Bass> audioDevices;
Devices::TeamSpeak teamSpeak;
std::vector<Devices::Joystick> joysticks;
Devices::Webcam webcam;
Devices::YouTube youTube;
Devices::Xplane xplane;
Devices::Printer printer;


//--------------------------------------------------------------------------------------
// Forward declarations 
//--------------------------------------------------------------------------------------
void FrameMove(double fTime, float fElapsedTime);
void InitApp(HINSTANCE hInstance);
void Teardown();


//--------------------------------------------------------------------------------------
// Entry point to the program. Initializes everything and goes into a message processing 
// loop. Idle time is used to render the scene.
//--------------------------------------------------------------------------------------
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int)
{
        // Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
        _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_CRT_DF);
        //_CrtSetBreakAlloc(3);
#endif

        ShowCursor(false);

        // more realistic random number generation
        srand(static_cast<unsigned int>(time(nullptr)));

        config.Initialize(&logger, &modules, &bus, &viewport, lpCmdLine);

        InitApp(hInstance); // joystick.cpp and keyboard.cpp devices need HINSTANCE

        // Start the timer
        CDXUTTimer Timer;
        float fElapsedTime = 0.0f;
        Timer.Start();
        double fTime = Timer.GetTime();
        int frameCount = 0;
        float frameTime = 0.0f;

        // Now we're ready to receive and process Windows messages.
        bool bGotMsg;
        MSG msg;
        msg.message = WM_NULL;
        PeekMessage(&msg, nullptr, 0U, 0U, PM_NOREMOVE);

        while (WM_QUIT != msg.message)
        {
                // Use PeekMessage() so we can use idle time to render the scene. 
                bGotMsg = (PeekMessage(&msg, nullptr, 0U, 0U, PM_REMOVE) != 0);

                if (bGotMsg)
                {
                        // Translate and dispatch the message
//                      if (g_hWndPrimary == NULL ||
//                              0 == TranslateAccelerator(g_hWndPrimary, NULL, &msg))
                        {
                                TranslateMessage(&msg);
                                DispatchMessage(&msg);
                        }
                }
                else
                {
                        frameCount++;
                        frameTime += fElapsedTime;
                        if (frameTime > 1.0f)
                        {
                                bus.frameRate = static_cast<float>(frameCount) / frameTime;
                                frameTime = 0.0f;
                                frameCount = 0;
                        }

                        FrameMove(fTime, fElapsedTime);

                        // Render a frame during idle time (no messages are waiting)
                        viewport.FrameMove();
                        viewport.Render(fElapsedTime);
                }

                fTime = Timer.GetTime();
                fElapsedTime = Timer.GetElapsedTime();
        }

        Teardown();

        return 0;
}


//--------------------------------------------------------------------------------------
// Initialize the app 
//--------------------------------------------------------------------------------------
void InitApp(HINSTANCE hInstance)
{
        ups.Initialize(&logger, &config.apcupsdConfig, &bus);
        rakNet.Initialize(&logger, &config.rakNetConfig, &bus);
        xplane.Initialize(&logger, &config.xplaneConfig, &bus);

#pragma region InterfaceKits
        ifKits.resize(config.interfaceKitConfigs.size());
        for (UINT i = 0; i < ifKits.size(); i++)
        {
                Devices::InterfaceKit* ifKit = &ifKits.at(i); // otherwise Doxygen doesn't see it!
                ifKit->Initialize(&logger, &config.interfaceKitConfigs.at(i), &bus);
        }
#pragma endregion

#pragma region Encoders
        encoders.resize(config.encoderConfigs.size());
        for (UINT i = 0; i < encoders.size(); i++)
        {
                Devices::Encoder* encoder = &encoders.at(i); // otherwise Doxygen doesn't see it!
                encoder->Initialize(&logger, &config.encoderConfigs.at(i), &bus);
        }
#pragma endregion

#pragma region Analogs
        analogs.resize(config.analogConfigs.size());
        for (UINT i = 0; i < analogs.size(); i++)
        {
                Devices::Analog* analog = &analogs.at(i); // otherwise Doxygen doesn't see it!
                analog->Initialize(&logger, &config.analogConfigs.at(i), &bus);
        }
#pragma endregion

        if (config.spatialConfig.enable)
                spatial.Initialize(&logger, &config.spatialConfig, &bus);

        if (config.teamSpeakConfig.enable)
                teamSpeak.Initialize(&logger, &config.teamSpeakConfig, &bus);

#pragma region Bass
        audioDevices.resize(config.bassConfigs.size());
        for (UINT i = 0; i < audioDevices.size(); i++)
        {
                Devices::Bass* bass = &audioDevices.at(i); // otherwise Doxygen doesn't see it!
                bass->Initialize(&logger, &config.bassConfigs.at(i), &bus);

                for (UINT m = 0; m < modules.size(); m++)
                {
                        if (typeid(*modules.at(m)) == typeid(Vmu))
                        {
                                if (config.bassConfigs.at(i).soundDevice == static_cast<Vmu*>(modules.at(m))->soundDevice)
                                {
                                        static_cast<Vmu*>(modules.at(m))->Initialize(bass);
                                }
                        }
                        else if (typeid(*modules.at(m)) == typeid(Fadec))
                        {
                                if (config.bassConfigs.at(i).soundDevice == static_cast<Fadec*>(modules.at(m))->soundDevice)
                                {
                                        static_cast<Fadec*>(modules.at(m))->Initialize(nullptr, bass);
                                }
                        }
                        else if (typeid(*modules.at(m)) == typeid(Ase))
                        {
                                if (config.bassConfigs.at(i).soundDevice == static_cast<Ase*>(modules.at(m))->soundDevice)
                                {
                                        static_cast<Ase*>(modules.at(m))->Initialize(bass);
                                }
                        }
                }
        }
#pragma endregion

#pragma region DirectInput
        HRESULT hr;
        if (FAILED(hr = DirectInput8Create(hInstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&g_pDI, NULL)))
        {
                logger.Log("InitApp DirectInput8Create failed!", Logger::Error, hr);
        }
        else
        {
                joysticks.resize(config.joystickConfigs.size());
                for (UINT i = 0; i < joysticks.size(); i++)
                {
                        Devices::Joystick* joystick = &joysticks.at(i); // otherwise Doxygen doesn't see it!
                        joystick->Initialize(&logger, &config.joystickConfigs.at(i), &bus, g_pDI);

                        if (config.joystickConfigs.at(i).registerWithFcs)
                        {
                                for (UINT m = 0; m < modules.size(); m++)
                                {
                                        if (typeid(*modules.at(m)) == typeid(Fcs))
                                        {
                                                static_cast<Fcs*>(modules.at(m))->Initialize(joystick);
                                        }
                                }
                        }
                        if (config.joystickConfigs.at(i).enable && config.joystickConfigs.at(i).registerWithFadec)
                        {
                                for (UINT m = 0; m < modules.size(); m++)
                                {
                                        if (typeid(*modules.at(m)) == typeid(Fadec))
                                        {
                                                static_cast<Fadec*>(modules.at(m))->Initialize(joystick, nullptr);
                                        }
                                }
                        }
                }

                keyboard.Initialize(&logger, &config.keyboardConfig, &bus, g_pDI);
        }
#pragma endregion

        webcam.Initialize(&logger, &config.webcamConfig, &bus);

        youTube.Initialize(&logger, &bus, &config.youTubeConfig);

        viewport.Initialize(hInstance);
        keyboard.SetWindowHandles(viewport.GetWindowHandles());

        printer.Initialize(&logger, &bus, nullptr);



        Vehicle platform177;
        platform177.location.x = -57.0f / 180.0f * 19012.290420994710720528225226931f;
        platform177.location.y = 7.5f / 90.0f*9506.1452104973553602641126134654f;
        platform177.location.z = -35.0f;
        platform177.type = Vehicle::Platform;
        platform177.VehicleId = "E177";
        D3DXMatrixRotationX(&platform177.mBaseOrient, D3DX_PI); // now facing north
        D3DXQuaternionRotationYawPitchRoll(&platform177.orientation, 0, 0, D3DXToRadian(-120.0f)); // left to 240
        bus.vehicles.push_back(platform177);

        Vehicle platform419;
        platform419.location.x = -57.0f / 180.0f * 19012.290420994710720528225226931f - 45.0f;
        platform419.location.y = 7.5f / 90.0f*9506.1452104973553602641126134654f;
        platform419.location.z = -35.0f;
        platform419.type = Vehicle::Platform;
        platform419.VehicleId = "E419";
        D3DXMatrixRotationX(&platform419.mBaseOrient, D3DX_PI);
        D3DXQuaternionRotationYawPitchRoll(&platform419.orientation, 0, 0, -D3DX_PI*0.5f); // left to 270, was north facing
        bus.vehicles.push_back(platform419);
}


void Teardown()
{
        viewport.Destroy();

        for (UINT i = 0; i < ifKits.size(); i++)
        {
                Devices::InterfaceKit* ifKit = &ifKits.at(i); // otherwise Doxygen misses it
                ifKit->Destroy();
        }

        for (UINT i = 0; i < encoders.size(); i++)
        {
                Devices::Encoder* encoder = &encoders.at(i); // otherwise Doxygen misses it
                encoder->Destroy();
        }

        for (UINT i = 0; i < analogs.size(); i++)
        {
                Devices::Analog* analog = &analogs.at(i); // otherwise Doxygen misses it
                analog->Destroy();
        }

        if (config.spatialConfig.enable)
                spatial.Destroy();

        if (config.teamSpeakConfig.enable)
                teamSpeak.Destroy();

        for (UINT i = 0; i < audioDevices.size(); i++)
        {
                Devices::Bass* bass = &audioDevices.at(i); // otherwise Doxygen misses it
                bass->Destroy();
        }

#pragma region Modules
        for (std::vector<Module*>::iterator it = modules.begin(); it != modules.end(); ++it)
        {
                delete *it;
        }
#pragma endregion

#pragma region DirectInput
        for (UINT i = 0; i < joysticks.size(); i++)
        {
                Devices::Joystick* joystick = &joysticks.at(i); // otherwise Doxygen misses it
                joystick->Destroy();
        }

        keyboard.Destroy();

        SAFE_RELEASE(g_pDI);
#pragma endregion

        webcam.Destroy();
}


//--------------------------------------------------------------------------------------
// Handle updates to the scene.  This is called regardless of which D3D API is used
//--------------------------------------------------------------------------------------
void FrameMove(double fTime, float fElapsedTime)
{
        Sleep(20);

        //static int cycle = 0;
        //static float cycleLimit = 0.0f;
        //cycleLimit += fElapsedTime;
        //if (cycleLimit >= 0.2f)
        //{
        //      cycleLimit -= 0.2f;
        //      cycle++;
        //      if (cycle > 4)
        //              cycle = 0;
        //}


        try
        {
                bus.FrameMove(fElapsedTime, fTime);

#pragma region Inputs
                if (config.apcupsdConfig.enable)
                {
                        ups.FrameMove(fElapsedTime);
                }

                if (config.spatialConfig.enable)
                        spatial.FrameMove(fElapsedTime);

                if (config.keyboardConfig.enable)
                        keyboard.FrameMove(fElapsedTime);

                for (UINT i = 0; i < joysticks.size(); i++)
                {
                        Devices::Joystick* joystick = &joysticks.at(i); // otherwise Doxygen misses it
                        joystick->FrameMove(fElapsedTime);
                }

                if (config.webcamConfig.enabled)
                {
                        //if (cycle==2)
                                webcam.FrameMove();
                }

                printer.FrameMove();


#pragma endregion

#pragma region Other I/O
                for (UINT i = 0; i < ifKits.size(); i++)
                {
                        Devices::InterfaceKit* ifKit = &ifKits.at(i); // otherwise Doxygen misses it
                        ifKit->FrameMove();
                }

                if (config.rakNetConfig.enabled)
                        rakNet.FrameMove(fElapsedTime);

                if (config.teamSpeakConfig.enable)
                        teamSpeak.FrameMove();

                if (config.xplaneConfig.enabled)
                        xplane.FrameMove();

#pragma endregion

#pragma region Modules (Input and Ouput to Data Bus)
                for (UINT i = 0; i < modules.size(); i++)
                {
                        Module* module = modules.at(i); // otherwise Doxygen doesn't see it!
                        module->FrameMove(fElapsedTime);
                }
#pragma endregion

#pragma region Outputs
                for (UINT i = 0; i < analogs.size(); i++)
                {
                        Devices::Analog* analog = &analogs.at(i); // otherwise Doxygen misses it
                        analog->FrameMove();
                }

                for (UINT i = 0; i < audioDevices.size(); i++)
                {
                        Devices::Bass* bass = &audioDevices.at(i); // otherwise Doxygen misses it
                        bass->FrameMove();
                }
#pragma endregion

                static float lastErrorTime = 60.0f;
                lastErrorTime += fElapsedTime;
                if (logger.lastLevel == Logger::Level::Error || logger.lastLevel == Logger::Level::Fatal)
                {
                        if (logger.lastError.find("SendEmail") == std::string::npos && lastErrorTime > 60.0f)
                        {
                                rakNet.SendEmail("Logged Error or Fatal", logger.lastError.c_str());
                                lastErrorTime = 0.0f;
                        }

                        if (logger.lastLevel == Logger::Level::Fatal)
                                DXUTShutdown();

                        logger.lastLevel = Logger::Level::None;
                }

                for (UINT i = 0; i < 10; i++)
                        virtualization.FrameMove(fTime); // can't send elapsed time unless we hit them all every frame!

                if (fElapsedTime > 3.0f)
                {
                        char msg[99];
                        sprintf_s(msg, 99, "Program delay detected (%.3f)!", fElapsedTime);
                        logger.Log(msg, Logger::Warn);
                }
        }
        catch (std::exception& e)
        {
                rakNet.SendEmail("OnFrameMove Exception", e.what());
                logger.Log(e.what(), Logger::Level::Error);
                Sleep(5000);
                exit(0);
        }
}