Math.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */

#ifndef HPL_MATH_H
#define HPL_MATH_H

#include "hpl1/engine/math/BoundingVolume.h"
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/math/MeshTypes.h"

#include "hpl1/engine/graphics/Color.h"

namespace hpl {

class cMath {
public:

    static int RandRectl(int alMin, int alMax);

    static float RandRectf(float alMin, float alMax);

    static cVector2f RandRectVector2f(const cVector3f &avMin, const cVector3f &avMax);

    static cVector3f RandRectVector3f(const cVector3f &avMin, const cVector3f &avMax);

    static cColor RandRectColor(const cColor &aMin, const cColor &aMax);

    static void Randomize(int alSeed = -1);


    static bool BoxCollision(cRect2l aRect1, cRect2l aRect2);
    static bool BoxCollision(cRect2f aRect1, cRect2f aRect2);

    static bool PointBoxCollision(cVector2f avPoint, cRect2f aRect);

    static bool BoxFit(cRect2l aRectSrc, cRect2l aRectDest);
    static bool BoxFit(cRect2f aRectSrc, cRect2f aRectDest);

    static float Dist2D(const cVector2f &avPosA, const cVector2f &avPosB);
    static float Dist2D(const cVector3f &avPosA, const cVector3f &avPosB);

    static float SqrDist2D(const cVector2f &avPosA, const cVector2f &avPosB);
    static float SqrDist2D(const cVector3f &avPosA, const cVector3f &avPosB);

    static cRect2f &ClipRect(cRect2f &aRectSrc, const cRect2f &aRectDest);

    static bool CheckCollisionBV(cBoundingVolume &aBV1, cBoundingVolume &aBV2);

    static bool PointBVCollision(const cVector3f &avPoint, cBoundingVolume &aBV2);

    static bool GetClipRectFromBV(cRect2l &aDestRect, cBoundingVolume &aBV,
                                  const cMatrixf &a_mtxView, const cMatrixf &a_mtxProj,
                                  float afNearClipPlane, const cVector2l &avScreenSize);

    static bool CheckSphereInPlanes(const cVector3f &avCenter, float afRadius,
                                    const cPlanef *apPlanes, int alPlaneCount);


    static float GetFraction(float afVal);
    static float Modulus(float afDividend, float afDivisor);

    static float ToRad(float afAngle);
    static float ToDeg(float afAngle);

    static int Log2ToInt(int alX);

    static bool IsPow2(int alX);

    static float Wrap(float afX, float afMin, float afMax);

    static float Clamp(float afX, float afMin, float afMax);

    inline static float Max(float afX, float afY) {
        if (afX > afY)
            return afX;
        return afY;
    }
    inline static float Min(float afX, float afY) {
        if (afX < afY)
            return afX;
        return afY;
    }

    inline static int Max(int alX, int alY) {
        if (alX > alY)
            return alX;
        return alY;
    }
    inline static int Min(int alX, int alY) {
        if (alX < alY)
            return alX;
        return alY;
    }

    inline static float Abs(float afX) { return afX < 0 ? -afX : afX; }
    inline static int Abs(int alX) { return alX < 0 ? -alX : alX; }

    static float GetAngleDistance(float afAngle1, float afAngle2, float afMaxAngle);
    static float GetAngleDistanceRad(float afAngle1, float afAngle2);
    static float GetAngleDistanceDeg(float afAngle1, float afAngle2);

    static float TurnAngle(float afAngle, float afFinalAngle, float afSpeed, float afMaxAngle);
    static float TurnAngleRad(float afAngle, float afFinalAngle, float afSpeed);
    static float TurnAngleDeg(float afAngle, float afFinalAngle, float afSpeed);

    static float InterpolateFloat(float afA, float afB, float afT);

    template<typename Vector>
        static decltype(Vector::x) & GetVectorX(Vector &v) {
        return v.x;
    }

    template<typename Vector>
        static decltype(Vector::y) & GetVectorY(Vector &v) {
        return v.y;
    }
    template<typename Vector>
        static decltype(Vector::z) & GetVectorZ(Vector &v) {
        return v.z;
    }


    static float GetAngleFromPoints2D(const cVector2f &aStartPos, const cVector2f &avGoalPos);
    static cVector2f GetVectorFromAngle2D(float afAngle, float afLength);
    static void GetAngleFromVector(const cVector2f &avVec, float *apAngle, float *apLength);

    static cVector2f ProjectVector2D(const cVector2f &avSrcVec, const cVector2f &avDestVec);


    static inline cVector3f Vector3ToRad(const cVector3f &avVec) {
        return cVector3f(ToRad(avVec.x), ToRad(avVec.y), ToRad(avVec.z));
    }

    static inline cVector3f Vector3ToDeg(const cVector3f &avVec) {
        return cVector3f(ToDeg(avVec.x), ToDeg(avVec.y), ToDeg(avVec.z));
    }

    static inline cVector3f Vector3Normalize(const cVector3f &avVec) {
        cVector3f vNorm = avVec;
        vNorm.Normalise();
        return vNorm;
    }

    static inline float Vector3DistSqr(const cVector3f &avStartPos, const cVector3f &avEndPos) {
        float fDX = avEndPos.x - avStartPos.x;
        float fDY = avEndPos.y - avStartPos.y;
        float fDZ = avEndPos.z - avStartPos.z;

        return fDX * fDX + fDY * fDY + fDZ * fDZ;
    }

    static inline float Vector3Dist(const cVector3f &avStartPos, const cVector3f &avEndPos) {
        return sqrt(Vector3DistSqr(avStartPos, avEndPos));
    }

    static cVector3f GetAngleFromPoints3D(const cVector3f &avStartPos, const cVector3f &avGoalPos);

    static cVector3f Vector3Cross(const cVector3f &avVecA, const cVector3f &avVecB);

    static float Vector3Dot(const cVector3f &avVecA, const cVector3f &avVecB);

    static cVector3f ProjectVector3D(const cVector3f &avSrcVec, const cVector3f &avDestVec);

    static float Vector3Angle(const cVector3f &avVecA, const cVector3f &avVecB);

    static cVector3f Vector3UnProject(const cVector3f &avVec, const cRect2f &aScreenRect,
                                      cMatrixf a_mtxViewProj);

    static float PlaneToPointDist(const cPlanef &aPlane, const cVector3f &avVec);

    static void PlaneIntersectionLine(const cPlanef &aPA, const cPlanef &aPB,
                                      cVector3f &avDir, cVector3f &avPoint);

    static bool CheckFrustumLineIntersection(const cPlanef *apPlanePairs, const cVector3f &avPoint1,
                                             const cVector3f &avPoint2, int alPairNum);

    static bool CheckFrustumQuadMeshIntersection(const cPlanef *apPlanePairs, tVector3fVec *apPoints,
                                                 int alPairNum);


    static cQuaternion QuaternionSlerp(float afT, const cQuaternion &aqA, const cQuaternion &aqB,
                                       bool abShortestPath);

    static float QuaternionDot(const cQuaternion &aqA, const cQuaternion &aqB);


    static cMatrixf MatrixSlerp(float afT, const cMatrixf &a_mtxA, const cMatrixf &a_mtxB,
                                bool abShortestPath);

    static cMatrixf MatrixMul(const cMatrixf &a_mtxA, const cMatrixf &a_mtxB);
    static cVector3f MatrixMul(const cMatrixf &a_mtxA, const cVector3f &avB);
    static cVector3f MatrixMulDivideW(const cMatrixf &a_mtxA, const cVector3f &avB);

    static cMatrixf MatrixMulScalar(const cMatrixf &a_mtxA, float afB);

    static cMatrixf MatrixRotate(cVector3f avRot, eEulerRotationOrder aOrder);
    static cMatrixf MatrixRotateX(float afAngle);
    static cMatrixf MatrixRotateY(float afAngle);
    static cMatrixf MatrixRotateZ(float afAngle);
    static cMatrixf MatrixScale(cVector3f avScale);
    static cMatrixf MatrixTranslate(cVector3f avTrans);

    static cMatrixf MatrixQuaternion(const cQuaternion &aqRot);

    static inline float MatrixMinor(const cMatrixf &a_mtxA,
                                    const size_t r0, const size_t r1, const size_t r2,
                                    const size_t c0, const size_t c1, const size_t c2);
    static inline cMatrixf MatrixAdjoint(const cMatrixf &a_mtxA);

    static inline float MatrixDeterminant(const cMatrixf &a_mtxA);

    static cMatrixf MatrixInverse(const cMatrixf &a_mtxA);

    static cVector3f MatrixToEulerAngles(const cMatrixf &a_mtxA, eEulerRotationOrder aOrder);

    static const char *MatrixToChar(const cMatrixf &a_mtxA);


    static bool CreateTriTangentVectors(float *apDestArray,
                                        const unsigned int *apIndexArray, int alIndexNum,
                                        const float *apVertexArray, int alVtxStride,
                                        const float *apTexArray,
                                        const float *apNormalArray, int alVertexNum);

    static bool CreateTriangleData(tTriangleDataVec &avTriangles,
                                   const unsigned int *apIndexArray, int alIndexNum,
                                   const float *apVertexArray, int alVtxStride, int alVertexNum);

    static bool CreateEdges(tTriEdgeVec &avEdges,
                            const unsigned int *apIndexArray, int alIndexNum,
                            const float *apVertexArray, int alVtxStride, int alVertexNum,
                            bool *apIsDoubleSided);
};

} // namespace hpl

#endif // HPL_MATH_H