MathUtilities.h

Go to the documentation of this file.

#pragma once

inline float Clamp(float val, float min, float max)
{
        if (val < min) 
                return min;
        if (val > max) 
                return max;
        return val;
}

inline float Lerp(float val1, float val2, float lerp)
{
        return val2 * lerp + val1 * (1.0f - lerp);
}

inline D3DXVECTOR2 CalculateLatLng(D3DXVECTOR3 position)
{
        position = -position; // needs the inverse

        D3DXVECTOR2 latlng;

        // Latitude and longitude       
        latlng.x = -D3DXToDegree(atanf(position.z / sqrtf(position.x*position.x + position.y*position.y)));
        if (position.x <= 0 && position.y > 0)
                latlng.y = -D3DXToDegree(atanf(position.x / position.y)); // PM to EP
        else if (position.x < 0 && position.y <= 0)
                latlng.y = D3DXToDegree(atanf(position.y / position.x)) + 90.0f; // EP to IDL
        else if (position.x >= 0 && position.y < 0)
                latlng.y = -D3DXToDegree(atanf(position.x / position.y)) - 180.0f; // IDL to WP
        else if (position.x > 0 && position.y >= 0) // west?
                latlng.y = D3DXToDegree(atanf(position.y / position.x)) - 90.0f; // WP to PM

        return latlng;
}

inline float GetArcDist(D3DXVECTOR3 from, D3DXVECTOR3 to, bool includeAltDiff)
{
        D3DXVECTOR3 result = to - from;
        const float olddist = D3DXVec3Length(&result);
        const float lerp = max(0.0f, min(1.0f, (olddist - 320.0f) / 160.0f)); // 320 then 0... 480 then 1...

        D3DXVECTOR2 latlng34 = CalculateLatLng(from);
        D3DXVECTOR2 latlng56 = CalculateLatLng(to);

        const float dLat = D3DXToRadian(latlng34.x - latlng56.x);
        const float dLon = D3DXToRadian(latlng34.y - latlng56.y);

        const float a = sinf(dLat * 0.5f) * sinf(dLat * 0.5f) + cosf(D3DXToRadian(latlng56.x)) * cosf(D3DXToRadian(latlng34.x)) *
                sinf(dLon * 0.5f) * sinf(dLon * 0.5f);
        const float c = 2.0f * atan2f(sqrtf(a), sqrtf(1.0f - a));
        float newdist = c * radiusC;

        if (includeAltDiff)
        {
                const float alt = D3DXVec3Length(&from) - D3DXVec3Length(&to);
                newdist = sqrtf(newdist*newdist + alt * alt);
        }

        return newdist * lerp + olddist * (1.0f - lerp);
}

inline D3DXVECTOR3 GetArcBear(D3DXVECTOR3 vec2, float dist, float altd, D3DXVECTOR3 posnorml)
{
        // effect is based on 160 to 320 km 0 to 1

        D3DXVECTOR3 cross, location = -posnorml, tempvelocity, relativel;
        D3DXVec3Normalize(&tempvelocity, &vec2);
        D3DXVec3Cross(&cross, &location, &tempvelocity); // Find perpendicular vector
        float f_temp;
        const float angle = D3DXVec3Dot(&location, &tempvelocity); // Find our trajectory to the surface
                                                                                                                           // curvalinear mark, if it is far away it is 0, if it is div0 it is 1
        if (angle >= 1.0f)
                f_temp = -D3DX_HALFPI; 
        else if (angle <= -1.0f)
                f_temp = -D3DX_PI; 
        else
        {
                f_temp = -acosf(angle) - D3DX_HALFPI;
                f_temp += atanf(altd / dist); // alt of change over distance, at 1km each it is 45 deg
        }

        D3DXMATRIX dor;
        D3DXMatrixRotationAxis(&dor, &cross, f_temp); // Set up a matrix
        D3DXVec3TransformCoord(&relativel, &tempvelocity, &dor); // Use DOR to fix trajectory

        const float lerp = max(0.0f, min(1.0f, (dist - 320.0f) / 160.0f)); // 320 then 0... 480 then 1...
        return -relativel * lerp + vec2 * (1.0f - lerp);
}

inline bool RectEquality(RECT rect1, RECT rect2)
{
        return rect1.left == rect2.left && rect1.right == rect2.right && rect1.top == rect2.top && rect1.bottom == rect2.bottom;
}

// Returns a random floating point number between 0 and 1
inline float RandomFloat()
{
        return static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
}