math.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016-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.
*/
 
#define MATH_PI 3.1415926
noref const vector g_vec_null = [0.0f, 0.0f, 0.0f];
 
#ifdef MENU
 
vector(vector fwd, optional vector up) vectoangles2 = #11;
void(vector angle) rotatevectorsbyangle = #0;
 
#define vectoangles vectoangles2
 
vector v_forward;
vector v_up;
vector v_right;
void makevectors( 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;
}
#endif
 
 
float
lerpAngle(float startAngle, float endAngle, float lerpAmount)
{
        float shortest_angle = ((((endAngle - startAngle) % 360.0f) + 540.0f) % 360.0f) - 180.0f;
        return shortest_angle * lerpAmount;
}
 
float
lerp(float startValue, float endValue, float lerpAmount)
{
        return (startValue * (1 - lerpAmount)) + (endValue * lerpAmount);
}
 
float
fixAngleDelta(float angleValue)
{
        if (angleValue > 180) {
                angleValue -= 360;
        } else if (angleValue < -180) {
                angleValue += 360;
        } else {
                return angleValue;
        }
 
        return fixAngleDelta(angleValue);
}
 
 
vector
fixAngle(vector inputAngle)
{
        inputAngle[0] = fixAngleDelta(inputAngle[0]);
        inputAngle[1] = fixAngleDelta(inputAngle[1]);
        inputAngle[2] = fixAngleDelta(inputAngle[2]);
        return inputAngle;
}
 
vector
reflect(vector hitDirection, vector planeNormal)
{
        return hitDirection - 2 * dotproduct(hitDirection, planeNormal) * planeNormal;
}
 
vector
randomVector(bool flyUp)
{
        vector tmp;
        tmp[0] = random() - 0.5f;
        tmp[1] = random() - 0.5f;
        
        if ( flyUp == true ) {
                tmp[2] = random();
        } else {
                tmp[2] = random() - 0.5f;
        }
 
        return tmp * 2.0f;
}
 
vector
rotateAroundPoint(vector pos, vector pivot, float degr)
{
        vector new = pos;
        new[0] = pivot[0] + (pos[0] - pivot[0]) * cos(degr) - (pos[1] - pivot[1]) * sin(degr);
        new[1] = pivot[1] + (pos[0] - pivot[0]) * sin(degr) + (pos[1] - pivot[1]) * cos(degr);
        return new;
}
 
vector
angleDifference(vector angle1, vector angle2)
{
        static float Math_AngleDiff_S(float from, float to) {
                float angleDelta = from - to;
 
                if (angleDelta > 180) {
                        angleDelta -= 360;
                } else if (angleDelta < -180) {
                        angleDelta += 360;
                }
 
                return angleDelta;
        }
 
        vector newAngle;
 
        /* clean up input angles */
        angle1 = fixAngle(angle1);
        angle2 = fixAngle(angle2);
 
        newAngle[0] = Math_AngleDiff_S(angle1[0], angle2[0]);
        newAngle[1] = Math_AngleDiff_S(angle1[1], angle2[1]);
        newAngle[2] = Math_AngleDiff_S(angle1[2], angle2[2]);
        return newAngle;
}
 
vector
hsvToRGB(float h, float s, float v)
{
        float i,f,p,q,t;
        vector col = [0,0,0];
 
        h = max(0.0, min(360.0, h));
        s = max(0.0, min(100.0, s));
        v = max(0.0, min(100.0, v));
 
        s /= 100;
        v /= 100;
 
        if (s == 0) {
                col[0] = col[1] = col[2] = rint(v*255);
                return col;
        }
 
        h /= 60;
        i = floor(h);
        f = h - i;
        p = v * (1 - s);
        q = v * (1 - s * f);
        t = v * (1 - s * (1 - f));
 
        switch (i) {
        case 0:
                col[0] = rint(255*v);
                col[1] = rint(255*t);
                col[2] = rint(255*p);
                break;
        case 1:
                col[0] = rint(255*q);
                col[1] = rint(255*v);
                col[2] = rint(255*p);
                break;
        case 2:
                col[0] = rint(255*p);
                col[1] = rint(255*v);
                col[2] = rint(255*t);
                break;
        case 3:
                col[0] = rint(255*p);
                col[1] = rint(255*q);
                col[2] = rint(255*v);
                break;
        case 4:
                col[0] = rint(255*t);
                col[1] = rint(255*p);
                col[2] = rint(255*v);
                break;
        default:
                col[0] = rint(255*v);
                col[1] = rint(255*p);
                col[2] = rint(255*q);
        }
        return col;
}
 
#include "math_vector.h"