math_vector.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 Vera Visions LLC.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
 
var vector g_vectorCacheLast;
var vector g_vectorCacheForward;
var vector g_vectorCacheRight;
var vector g_vectorCacheUp;
 
static void
anglesMake(vector angle)
{
        makevectors(angle);
        g_vectorCacheLast = angle;
        g_vectorCacheForward = v_forward;
        g_vectorCacheRight = v_right;
        g_vectorCacheUp = v_up;
}
 
vector
anglesToForward(vector angle)
{
        if (angle == g_vectorCacheLast) {
                return g_vectorCacheForward;
        }
 
        anglesMake(angle);
        return g_vectorCacheForward;
}
 
vector
anglesToRight(vector angle)
{
        if (angle == g_vectorCacheLast) {
                return g_vectorCacheRight;
        }
 
        anglesMake(angle);
        return g_vectorCacheRight;
}
 
vector
anglesToUp(vector angle)
{
        if (angle == g_vectorCacheLast) {
                return g_vectorCacheUp;
        }
 
        anglesMake(angle);
        return g_vectorCacheUp;
}
 
float
distanceSquared(vector pointA, vector pointB)
{
        float diffX = pointA[0] - pointB[0];
        float diffY = pointA[1] - pointB[1];
        float diffZ = pointA[2] - pointB[2];
        return (diffX * diffX) + (diffY * diffY) + (diffZ * diffZ);
}
 
float
distance(vector pointA, vector pointB)
{
        return sqrt(distanceSquared(pointA, pointB));
}
 
float
distance2D(vector pointA, vector pointB)
{
        float diffX = pointA[0] - pointB[0];
        float diffY = pointA[1] - pointB[1];
        return sqrt((diffX * diffX) + (diffY * diffY));
}
 
bool
closer(vector referencePoint, vector pointA, vector pointB)
{
        float distanceA = distanceSquared(referencePoint, pointA);
        float distanceB = distanceSquared(referencePoint, pointA);
        return (distanceA < distanceB) ? true : false;
}
 
vector
combineAngles(vector angleA, vector angleB)
{
        makevectors(angleA);
        rotatevectorsbyangle(angleB);
        return vectoangles(v_forward, v_up);
}
 
float
length(vector toCalculate)
{
        static vector lastInput = g_vec_null;
        static float lastOutput = 0.0f;
 
        if (toCalculate == lastInput) {
                return lastOutput;
        }
 
        lastInput = toCalculate;
        lastOutput = vlen(toCalculate);
        return lastOutput;
}
 
float
lengthSquared(vector target)
{
        return (target[0] * target[0]) + (target[1] * target[1]) + (target[2] * target[2]);
}
 
float
vectorDot(vector vectorA, vector vectorB)
{
        return dotproduct(vectorA, vectorB);
}
 
vector
vectorLerp(vector fromVector, vector toVector, float lerpFraction)
{
        static float vectorLerp_Lerp( float fA, float fB, float fPercent) {
                return (fA * (1 - fPercent)) + (fB * fPercent);
        }
 
        vector outputVector = g_vec_null;
        outputVector[0] = vectorLerp_Lerp(fromVector[0], toVector[0], lerpFraction);
        outputVector[1] = vectorLerp_Lerp(fromVector[1], toVector[1], lerpFraction);
        outputVector[2] = vectorLerp_Lerp(fromVector[2], toVector[2], lerpFraction);
        return outputVector;
}
 
vector
vectorNormalize(vector toNormalize)
{
        static vector lastInput = g_vec_null;
        static vector lastOutput = g_vec_null;
 
        if (toNormalize == lastInput) {
                return lastOutput;
        }
 
        lastInput = toNormalize;
        lastOutput = normalize(toNormalize);
        return lastOutput;
}
 
vector
vectorToAngles(vector toAngles)
{
        static vector lastInput = g_vec_null;
        static vector lastOutput = g_vec_null;
 
        if (toAngles == lastInput) {
                return lastOutput;
        }
 
        lastInput = toAngles;
        lastOutput = fixAngle(vectoangles(toAngles));
        return lastOutput;
}
 
vector
vectorToAnglesRoll(vector forwardDir, vector rollDir)
{
        static vector lastInput = g_vec_null;
        static vector lastInput2 = g_vec_null;
        static vector lastOutput = g_vec_null;
 
        if (forwardDir == lastInput && rollDir == lastInput2) {
                return lastOutput;
        }
 
        lastInput = forwardDir;
        lastInput2 = rollDir;
        lastOutput = fixAngle(vectoangles(forwardDir, rollDir));
        return lastOutput;
}
 
vector
lerpAngleVector(vector inputAngle, vector endAngle, float lerpAmount)
{
        vector currentDir = anglesToForward(inputAngle);
        vector desiredDir = anglesToForward(endAngle);
        return vectorToAngles(vectorLerp(currentDir, desiredDir, lerpAmount));
}