math_vector.h

/*
 * 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));
}
 
vector
dirFromTarget(vector lookingEnt, vector targetEnt)
{
    return anglesToForward(vectorToAngles(targetEnt - lookingEnt)); 
}
 // end of common