c_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;
 
void AngleVectors ( vector angles )
{
    float angle;
    float sr, sp, sy, cr, cp, cy;
    
    angle = angles[1] * (M_PI*2 / 360);
    sy = sin(angle);
    cy = cos(angle);
    angle = angles[0] * (M_PI*2 / 360);
    sp = sin(angle);
    cp = cos(angle);
    angle = angles[2] * (M_PI*2 / 360);
    sr = sin(angle);
    cr = cos(angle);
 
    v_forward[0] = cp*cy;
    v_forward[1] = cp*sy;
    v_forward[2] = -sp;
 
    v_right[0] = (-1*sr*sp*cy+-1*cr*-sy);
    v_right[1] = (-1*sr*sp*sy+-1*cr*cy);
    v_right[2] = -1*sr*cp;
 
    v_up[0] = (cr*sp*cy+-sr*-sy);
    v_up[1] = (cr*sp*sy+-sr*cy);
    v_up[2] = cr*cp;
}
 
static void
anglesMake(vector targetAngle)
{
    AngleVectors(targetAngle);
    g_vectorCacheLast = targetAngle;
    g_vectorCacheForward = v_forward;
    g_vectorCacheRight = v_right;
    g_vectorCacheUp = v_up;
}
 
vector
anglesToForward(vector targetAngle)
{
    if (targetAngle != g_vectorCacheLast) {
        anglesMake(targetAngle);
    }
 
    return (g_vectorCacheForward);
}
 
vector
anglesToRight(vector targetAngle)
{
    if (targetAngle != g_vectorCacheLast) {
        anglesMake(targetAngle);
    }
 
    return (g_vectorCacheRight);
}
 
vector
anglesToUp(vector targetAngle)
{
    if (targetAngle != g_vectorCacheLast) {
        anglesMake(targetAngle);
    }
 
    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