TCASOverlay.cpp

Go to the documentation of this file.

#include "../Instrument.h"

TCASOverlay::TCASOverlay(int prmX, int prmY, float prmXScale, float prmYScale, Bus* prmBus, Logger* prmLogger, DeviceObject* prmDevice, std::vector<Font*> prmFonts) :
        Instrument(prmX, prmY, prmXScale, prmYScale, prmBus, prmLogger, prmDevice, prmFonts)
{
        logger->AddToCallStack("TCAS::ctor");
        defaultFont = 1;

        noThreat = new Sprite(logger, pDevice, "Textures/Instruments/TCAS.png", x, y, 0.3f, 0, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);
        proximate = new Sprite(logger, pDevice, "Textures/Instruments/TCAS.png", x, y, 0.3f, 28, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);
        potentialThreat = new Sprite(logger, pDevice, "Textures/Instruments/TCAS.png", x, y, 0.3f, 56, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);
        collisionThreat = new Sprite(logger, pDevice, "Textures/Instruments/TCAS.png", x, y, 0.3f, 84, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);

        // offset from middle to top left of 28x28 sprite
        iconOffsetX = 14 * xScale;
        iconOffsetY = 14 * yScale;

        relativeCenter = D3DXVECTOR2(530.0f * 0.5f * xScale, 530.0f * 0.5f * yScale);
}

void TCASOverlay::Render()
{
        for (UINT i = 0; i < targets.size(); i++)
        {
                const s_network_objects target = targets.at(i);

                DWORD color = 0xFF0088FF;
                if (target.ordinal == bus->TCASTargetOrdinal)
                {
                        if (bus->TCAS == Bus::TcasEnum::Traffic_Advisory)
                                color = 0xFFFFAA00;
                        else if (bus->TCAS >= Bus::TcasEnum::RA_Climb)
                                color = 0xFFFF0000;
                }

                if (color==0xFFFFAA00)
                {
                        potentialThreat->SetLocation(static_cast<int>(target.acc.x), static_cast<int>(target.acc.y));
                        potentialThreat->Update();
                        potentialThreat->Draw(color);
                }
                else if (color == 0xFFFF0000)
                {
                        collisionThreat->SetLocation(static_cast<int>(target.acc.x), static_cast<int>(target.acc.y));
                        collisionThreat->Update();
                        collisionThreat->Draw(color);
                }
                else
                {
                        // check altitude for proximate (within 1200 feet, 0.36576 km)
                        if (fabsf(target.acc.z) <= 0.36576f)
                        {
                                proximate->SetLocation(static_cast<int>(target.acc.x), static_cast<int>(target.acc.y));
                                proximate->Update();
                                proximate->Draw(color);
                        }
                        else
                        {
                                noThreat->SetLocation(static_cast<int>(target.acc.x), static_cast<int>(target.acc.y));
                                noThreat->Update();
                                noThreat->Draw(color);
                        }
                }

                if (target.acc.z > 0)
                        DrawTextW(target.tcasOnly, static_cast<int>(target.acc.x) - x, static_cast<int>(target.acc.y) - y - 10, 0.4f, DT_NOCLIP, color);
                else
                        DrawTextW(target.tcasOnly, static_cast<int>(target.acc.x) - x, static_cast<int>(target.acc.y) - y + 10, 0.4f, DT_NOCLIP, color);
        }
}

void TCASOverlay::FrameMove(float fElapsed)
{
        headingTrueRad = D3DXToRadian(bus->HeadingTrueDegrees);

        // so 6.28 - 0 is a 6.28 or -6.28 difference!
        float diff = headingTrueRad - rotate;
        if (diff > D3DX_PI)
                diff -= D3DX_TAU;
        else if (diff < -D3DX_PI)
                diff += D3DX_TAU;

        rotate += diff * fElapsed;

        /*diff = rotate - bus->AFCS.DesiredHeadingRadians;
        if (diff > D3DX_PI)
                diff -= D3DX_TAU;
        else if (diff < -D3DX_PI)
                diff += D3DX_TAU;*/

        pixelPerKmX = 530.0f * 0.25f / bus->MapScaleInnerRingKm * xScale;
        pixelPerKmY = 530.0f * 0.25f / bus->MapScaleInnerRingKm * yScale;

        D3DXVECTOR3 posnorml;
        D3DXVec3Normalize(&posnorml, &playerships[0].position);
        D3DXMATRIX lookAtLH;
        D3DXMatrixLookAtLH(&lookAtLH, &playerships[0].position, &northpoleC, &posnorml);
        D3DXMATRIX matrixRot;
        D3DXMatrixRotationZ(&matrixRot, rotate);
        lookAtLH = lookAtLH * matrixRot;

        targets.clear();
        for (UINT ii = 1; ii < MAX_SCAN; ii++)
        {
                s_network_objects target = playerships[ii];

                if (!target.active || !target.visible)
                        continue;

                if (!target.logolight ||
                        //target.docked || // we want to show them but not alert on them
                        target.groundvehicle ||
                        //target.reference == REF_ONGROUND || // we want to show them but not alert on them
                        target.reference == REF_INANOTHER ||
                        target.distance >= 75.0f || // ourcockpit.scanrange || // CRJ-200 was limited to 75 km / 40 nm
                        target.type == VehicleType::FloatingMan ||
                        target.type == VehicleType::BeishtKione)
                        //target.closurerate <= 0.0f) // we want to show them but not alert on them
                        continue;

                D3DXVECTOR3 result1;
                D3DXVec3TransformCoord(&result1, &target.position, &lookAtLH);
                // if they are more than 10,000 feet difference then we skip
                if (fabsf(result1.z) >= 3.0f)
                        continue;

                // if distance is beyond 2x scale then skip
                D3DXVECTOR2 result2 = D3DXVECTOR2(result1.x, result1.y);
                const float dist = D3DXVec2Length(&result2);
                if (dist > bus->MapScaleInnerRingKm * 2.0f)
                        continue;

                const D3DXVECTOR2 diff2d = D3DXVECTOR2(-result2.x * pixelPerKmX, result2.y * pixelPerKmY);
                D3DXVECTOR2 nextWaypoint = relativeCenter + diff2d;
                nextWaypoint.x = static_cast<int>(nextWaypoint.x) - iconOffsetX;
                nextWaypoint.y = static_cast<int>(nextWaypoint.y) - iconOffsetY;
                target.acc.x = nextWaypoint.x + x;
                target.acc.y = nextWaypoint.y + y;
                target.acc.z = -result1.z; // relative altitude!
                if (fabsf(target.acc.z) < 0.05f)
                        target.acc.z = 0.0f;
                swprintf_s(target.tcasOnly, 16, L"%02.0f", fabsf(target.acc.z) * 10.0f); // .5 km becomes 05, 3.0 becomes 30
                if (target.vsi > 0.001f)
                        wcscat_s(target.tcasOnly, 16, L"\u2191"); // up arrow
                else if (target.vsi < -0.001f)
                        wcscat_s(target.tcasOnly, 16, L"\u2193"); // down arrow

                target.ordinal = ii;

                targets.emplace_back(target);
        }
}