MovingMap.cpp

Go to the documentation of this file.

#include "../Instrument.h"

MovingMap::MovingMap(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("MovingMap::ctor");
        defaultFont = 1;

        // @todo could break compass and heading bug stuff into it's own instrument like TCAS
        compass = new Sprite(logger, pDevice, "Textures/Instruments/CompassLarge.png", x, y, 0.2f, 0, 0, 530, 530, 0xFFFFFFFF, xScale, yScale);
        headingBug = new Sprite(logger, pDevice, "Textures/Instruments/HeadingBug.png", x - 6, y - 6, 0.8f, 0, 0, 556, 556, 0xFFFF00FF, xScale, yScale);
        bearingBug = new Sprite(logger, pDevice, "Textures/Instruments/HeadingBug.png", x - 6, y - 6, 0.8f, 0, 0, 556, 556, 0xFF00FF00, xScale, yScale);

        flyoverFix = new Sprite(logger, pDevice, "Textures/Instruments/Waypoints.png", x, y, 0.3f, 0, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);
        malteseFix = new Sprite(logger, pDevice, "Textures/Instruments/Waypoints.png", x, y, 0.3f, 28, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);
        touchdown = new Sprite(logger, pDevice, "Textures/Instruments/Waypoints.png", x, y, 0.3f, 56, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);
        userPin = new Sprite(logger, pDevice, "Textures/Instruments/Waypoints.png", x, y, 0.3f, 84, 0, 28, 28, 0xFFFFFFFF, xScale, yScale);

        // @todo could break assay overlay stuff into it's own instrument like TCAS
        assay = new Sprite(logger, pDevice, "Textures/Instruments/assayBox.png", x, y, 0.1f, 0, 0, 32, 32, 0xFFFFFFFF, xScale, yScale);
        assay->SetRotationCenter(D3DXVECTOR2(0, 0));

        // 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);

        remoteAssayPower = 0.0f;
        bus->assayGrid.tcp = bus->tcp;
}

void MovingMap::Render()
{
        compass->Draw();
        headingBug->Draw();
        bearingBug->Draw();

        /*D3DXMATRIX matRot;
        D3DXMatrixRotationZ(&matRot, -compass->rotate);*/

        //D3DXVECTOR2 lastWaypoint;
        //lastWaypoint.x = 265;
        //lastWaypoint.y = 265;
        //D3DXVECTOR2 nextWaypoint;

        // first one (temporary waypoint) is skipped if it isn't set
        // if distance is beyond 2x scale then skip


        for (UINT i = 0; i < waypoints.size(); i++)
        {
                const Swaypoint waypoint = waypoints.at(i);

                DWORD color;
                if (waypoint.id == bus->WPtargetC)
                        color = 0xFFFF00FF;
                else
                        color = 0xFFFFFFFF;

                // ReSharper disable once CppDefaultCaseNotHandledInSwitchStatement
                switch (waypoint.type)
                {
                case 0:
                        userPin->SetLocation(static_cast<int>(waypoint.location.x), static_cast<int>(waypoint.location.y));
                        userPin->Update();
                        userPin->Draw(color);
                        break;
                case 1:
                {
                        malteseFix->SetLocation(static_cast<int>(waypoint.location.x), static_cast<int>(waypoint.location.y));
                        malteseFix->Update();
                        malteseFix->Draw(color);

                        WCHAR msg[99];
                        swprintf_s(msg, 99, L"%S", waypoint.text);
                        DrawTextW(msg, static_cast<int>(waypoint.location.x + iconOffsetX) + 6 - x, static_cast<int>(waypoint.location.y) - y, 0.3f, DT_NOCLIP, color);
                }
                break;
                case 2:
                {
                        touchdown->SetLocation(static_cast<int>(waypoint.location.x + 7.5f), static_cast<int>(waypoint.location.y));
                        touchdown->mag = max(1.0f, waypoint.length / bus->MapScaleInnerRingKm * 5.0f);
                        touchdown->rotate = 3.141f + headingTrueRad - D3DXToRadian(static_cast<float>(waypoint.heading));
                        touchdown->Update();
                        touchdown->Draw(color);
                }
                break;
                case 3:
                {
                        flyoverFix->SetLocation(static_cast<int>(waypoint.location.x), static_cast<int>(waypoint.location.y));
                        flyoverFix->Update();
                        flyoverFix->Draw(color);

                        WCHAR msg[99];
                        swprintf_s(msg, 99, L"%S", waypoint.text);
                        DrawTextW(msg, static_cast<int>(waypoint.location.x + iconOffsetX) + 6 - x, static_cast<int>(waypoint.location.y) - y, 0.3f, DT_NOCLIP, color);
                }
                break;
                }



                //course.height = static_cast<int>(sqrtf(powf(nextWaypoint.x - lastWaypoint.x, 2.0f) + powf(nextWaypoint.y - lastWaypoint.y, 2.0f)));
                //course.x = static_cast<int>((nextWaypoint.x + lastWaypoint.x)*0.5f);
                //course.y = static_cast<int>(min(nextWaypoint.y, lastWaypoint.y) - (course.height - fabsf(nextWaypoint.y - lastWaypoint.y))*0.5f);
                //if (i == 0)
                //      course.color = 0xFFFF00FF; // first one only
                //else
                //      course.color = 0xFFFFFFFF;

                //course.rotate = -atan2f(lastWaypoint.y - nextWaypoint.y, lastWaypoint.x - nextWaypoint.x) + D3DX_HALFPI;
                //course.Update();
                //course.Draw();

                //lastWaypoint = nextWaypoint;
        }

        if (ourcockpit.remoteAssayPower)
        {
                if (remoteAssayPower > 5.0f)
                {
                        if (bus->RadioAltitudeKm < 0.4f || bus->RadioAltitudeKm > 0.6f)
                                DrawTextW(L"ALT", (int)(relativeCenter.x - 7.0f), (int)(relativeCenter.y + 8.0f), 1.0f, DT_NOCLIP, 0xFFFFAA00);
                        else
                                DrawTextW(L"SCN", (int)(relativeCenter.x - 7.0f), (int)(relativeCenter.y + 8.0f), 1.0f, DT_NOCLIP, 0xFF00FF00);

                        for (int i = 0; i < 21; i++)
                        {
                                assay->SetLocation(assayGrid[i].u + x, assayGrid[i].v + y);
                                assay->Update();
                                assay->Draw(assayColor[i]);
                        }
                }
                else
                {
                        DrawTextW(L"TST", (int)(relativeCenter.x - 7.0f), (int)(relativeCenter.y + 8.0f), 1.0f, DT_NOCLIP, 0xFFFFFFFF);

                        for (int i = 0; i < 21; i++)
                        {
                                assay->SetLocation(assayGrid[i].u + x, assayGrid[i].v + y);
                                assay->Update();
                                assay->Draw(D3DCOLOR_ARGB(255, i * 10, i * 10, i * 10));
                        }
                }
        }
}

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

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

        compass->rotate += diff * fElapsed;
        compass->Update();

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

        headingBug->rotate = diff;
        headingBug->Update();

        bearingBug->rotate = -D3DXToRadian(bear);
        bearingBug->Update();

        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, compass->rotate);
        lookAtLH = lookAtLH * matrixRot;

        waypoints.clear();
        for (UINT i = 0; i < bus->waypoint.size(); i++)
        {
                const Swaypoint waypoint = bus->waypoint.at(i);

                // first one (temporary waypoint) is skipped if it isn't set
                if (i == 0 && waypoint.location.x == 0.0f)
                        continue;

                // if distance is beyond 2x scale then skip
                D3DXVECTOR3 result1;
                D3DXVec3TransformCoord(&result1, &waypoint.location, &lookAtLH);
                // don't show stuff on other side of planet
                if (fabsf(result1.z) > (f_MSL + radiusC))
                        continue;
                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;

                Swaypoint newWaypoint;
                newWaypoint.type = waypoint.type;
                newWaypoint.location.x = nextWaypoint.x + x;
                newWaypoint.location.y = nextWaypoint.y + y;
                newWaypoint.id = i;
                newWaypoint.heading = waypoint.heading;
                newWaypoint.length = waypoint.length;
                strcpy_s(newWaypoint.text, 80, waypoint.text);

                waypoints.emplace_back(newWaypoint);
        }

        if (ourcockpit.remoteAssayPower)
        {
                assay->rotate = D3DXToRadian(bus->HeadingMagneticDegrees + bus->HeadingTrueDegrees);
                assay->mag = 8.0f / bus->MapScaleInnerRingKm;

                float vertexWidth = 2.0f;
                float vertexHeight = 2.0f;
                D3DXMatrixRotationZ(&matrixRot, assay->rotate);
                D3DXMatrixInverse(&matrixRot, nullptr, &matrixRot);
                D3DXVECTOR3 test, result;
                test.z = 0.0f; // UL
                int index = 0;
                for (int xx = 0; xx < 5; xx++)
                {
                        for (int yy = 0; yy < 5; yy++)
                        {
                                if ((xx == 0 && yy == 0) || (xx == 4 && yy == 0) || (xx == 0 && yy == 4) || (xx == 4 && yy == 4))
                                        continue;
                                test.x = ((xx - 2) - bus->assayProgressU - (bus->tcp.u - bus->assayGrid.tcp.u)) * vertexWidth * pixelPerKmX;
                                test.y = ((yy - 2) - bus->assayProgressV - (bus->tcp.v - bus->assayGrid.tcp.v)) * vertexHeight * pixelPerKmY;
                                D3DXVec3TransformCoord(&result, &test, &matrixRot);
                                result.x += relativeCenter.x;
                                result.y += relativeCenter.y;
                                assayGrid[index].u = static_cast<short>(result.x);
                                assayGrid[index].v = static_cast<short>(result.y);

                                assayColor[index] = D3DCOLOR_ARGB(static_cast<int>(bus->assayQuality*255.0f),
                                        bus->assayGrid.gridarray[xx][yy].oreA,
                                        bus->assayGrid.gridarray[xx][yy].oreC,
                                        bus->assayGrid.gridarray[xx][yy].oreD);

                                index++;
                        }
                }
                remoteAssayPower += fElapsed;
        }
        else
        {
                remoteAssayPower = 0.0f;
                bus->assayGrid.tcp = bus->tcp;
        }

        // @todo GPWS overlay
}