D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spMath.hpp

Go to the documentation of this file.

/*
 * Math header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_MATH_H__
#define __SP_MATH_H__


#include "Base/spStandard.hpp"
#include "Base/spDimensionPoint2D.hpp"
#include "Base/spDimensionRect2D.hpp"
#include "Base/spDimensionLine3D.hpp"
#include "Base/spDimensionVector3D.hpp"
#include "Base/spDimensionTriangle3D.hpp"
#include "Base/spDimensionPlane3D.hpp"
#include "Base/spMathRadianDegree.hpp"
#include "Base/spMaterialColor.hpp"
#include "Base/spMathCore.hpp"

#include <stdlib.h>
#include <vector>


namespace sp
{

namespace dim
{
template <typename T> class matrix4;
typedef matrix4<f32> matrix4f;
}

namespace math
{


template <typename T> inline T getDistance(const dim::point2d<T> &PosA, const dim::point2d<T> &PosB)
{
    return sqrt(Pow2(PosB.X - PosA.X) + Pow2(PosB.Y - PosA.Y));
}
template <typename T> inline T getDistance(const dim::vector3d<T> &PosA, const dim::vector3d<T> &PosB)
{
    return sqrt(Pow2(PosB.X - PosA.X) + Pow2(PosB.Y - PosA.Y) + Pow2(PosB.Z - PosA.Z));
}

template <typename T> inline T getDistanceSq(const dim::point2d<T> &PosA, const dim::point2d<T> &PosB)
{
    return Pow2(PosB.X - PosA.X) + Pow2(PosB.Y - PosA.Y);
}
template <typename T> inline T getDistanceSq(const dim::vector3d<T> &PosA, const dim::vector3d<T> &PosB)
{
    return Pow2(PosB.X - PosA.X) + Pow2(PosB.Y - PosA.Y) + Pow2(PosB.Z - PosA.Z);
}

template <typename T> T getAngle(const dim::point2d<T> &A, const dim::point2d<T> &B)
{
    const dim::point2d<T> Dir(B - A);
    const T Dist = math::getDistance(A, B);
    
    if (Dir.X >= T(0))
    {
        if (Dir.Y >= T(0))
            return math::ASin((B.X - A.X) / Dist);
        return T(180) - math::ASin((B.X - A.X) / Dist);
    }
    
    if (Dir.Y >= T(0))
        return T(360) - math::ASin((A.X - B.X) / Dist);
    return T(180) + math::ASin((A.X - B.X) / Dist);
}

template <typename T> T getAngle(const dim::point2d<T> &A, const dim::point2d<T> &B, const T &OffsetAngle)
{
    T Angle = getAngle<T>(A, B) - OffsetAngle;
    
    while (Angle > T(180))
        Angle -= T(360);
    while (Angle < T(-180))
        Angle += T(360);
    
    return Angle;
}

template <typename T> inline dim::vector3d<T> getNormalVectorSq(
    const dim::vector3d<T> &PosA, const dim::vector3d<T> &PosB, const dim::vector3d<T> &PosC)
{
    return (PosA - PosB).cross(PosB - PosC);
}

template <typename T> inline dim::vector3d<T> getNormalVector(
    const dim::vector3d<T> &PosA, const dim::vector3d<T> &PosB, const dim::vector3d<T> &PosC)
{
    return getNormalVectorSq<T>(PosA, PosB, PosC).normalize();
}

template <typename T> dim::vector3d<T> getBarycentricCoord(
    const dim::triangle3d<T> &Triangle, const dim::vector3d<T> &Point)
{
    const dim::vector3d<T>& p = Point;
    const dim::vector3d<T>& a = Triangle.PointA;
    const dim::vector3d<T>& b = Triangle.PointB;
    const dim::vector3d<T>& c = Triangle.PointC;
    
    // Unnormalized triangle normal
    dim::vector3d<T> m = (b - a).cross(c - a);
    
    // Nominators and one-over-denominator for u and v ratios
    T nu, nv, ood;
    
    // Absolute components for determining projection plane
    const T x = math::Abs(m.X);
    const T y = math::Abs(m.Y);
    const T z = math::Abs(m.Z);
    
    // Compute areas in plane of largest projection
    if (x >= y && x >= z)
    {
        // x is largest, project to the yz plane
        nu = math::getTriangleArea2D<T>(p.Y, p.Z, b.Y, b.Z, c.Y, c.Z);  // Area of PBC in yz plane
        nv = math::getTriangleArea2D<T>(p.Y, p.Z, c.Y, c.Z, a.Y, a.Z);  // Area of PCA in yz plane
        ood = T(1) / m.X;                                               // 1/(2*area of ABC in yz plane)
    }
    else if (y >= x && y >= z)
    {
        // y is largest, project to the xz plane
        nu = math::getTriangleArea2D<T>(p.X, p.Z, b.X, b.Z, c.X, c.Z);
        nv = math::getTriangleArea2D<T>(p.X, p.Z, c.X, c.Z, a.X, a.Z);
        ood = T(1) / -m.Y;
    }
    else
    {
        // z is largest, project to the xy plane
        nu = math::getTriangleArea2D<T>(p.X, p.Y, b.X, b.Y, c.X, c.Y);
        nv = math::getTriangleArea2D<T>(p.X, p.Y, c.X, c.Y, a.X, a.Y);
        ood = T(1) / m.Z;
    }
    
    const T u = nu * ood;
    const T v = nv * ood;
    
    return dim::vector3d<T>(u, v, T(1.0) - u - v);
}


template <typename T> void sortContainerConst(
    std::vector<T> &ObjectList, bool (*lpFuncCmp)(const T &obj1, const T &obj2))
{
    s32 changed, i;
    
    do
    {
        changed = 0;
        
        for (i = 0; i < ObjectList.size() - 1; ++i)
        {
            if (!lpFuncCmp(ObjectList[i], ObjectList[i + 1]))
            {
                changed = 1;
                Swap(ObjectList[i], ObjectList[i + 1]);
            }
        }
    }
    while (changed);
}

template <typename T> void sortContainer(
    std::vector<T> &ObjectList, bool (*lpFuncCmp)(T &obj1, T &obj2))
{
    s32 changed, i;
    
    do
    {
        changed = 0;
        
        for (i = 0; i < ObjectList.size() - 1; ++i)
        {
            if (!lpFuncCmp(ObjectList[i], ObjectList[i + 1]))
            {
                changed = 1;
                Swap(ObjectList[i], ObjectList[i + 1]);
            }
        }
    }
    while (changed);
}


/* === Vertex functions === */

SP_EXPORT void getVertexInterpolation(
    const dim::triangle3df &Triangle, const dim::vector3df &Pos, f32 &Vert, f32 &Horz
);

template <class T> T getVertexInterpolation(
    const T &VertexA, const T &VertexB, const T &VertexC, const f32 Vert, const f32 Horz)
{
    return VertexA + (VertexB - VertexA) * Vert + (VertexC - VertexA) * Horz;
}


/* === Other distance and vector functions === */

SP_EXPORT dim::matrix4f getTangentSpace(
    const dim::vector3df PosA, const dim::vector3df PosB, const dim::vector3df PosC,
    const dim::point2df MapA, const dim::point2df MapB, const dim::point2df MapC,
    dim::vector3df &Tangent, dim::vector3df &Binormal, dim::vector3df &Normal
);


/* === Other math functions === */

inline dim::vector4df Convert(const video::color &Color)
{
    return dim::vector4df(
        static_cast<f32>(Color.Red  ) / 255,
        static_cast<f32>(Color.Green) / 255,
        static_cast<f32>(Color.Blue ) / 255,
        static_cast<f32>(Color.Alpha) / 255
    );
}

inline video::color Convert(const dim::vector4df &Color)
{
    return video::color(
        static_cast<u8>(Color.X * 255),
        static_cast<u8>(Color.Y * 255),
        static_cast<u8>(Color.Z * 255),
        static_cast<u8>(Color.W * 255)
    );
}


} // /namespace math

} // /namespace sp


#endif



// ================================================================================