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

Go to the documentation of this file.

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

#ifndef __SP_MATH_COLLISIONLIB_H__
#define __SP_MATH_COLLISIONLIB_H__


#include "Base/spStandard.hpp"
#include "Base/spMath.hpp"
#include "Base/spDimensionPolygon.hpp"


namespace sp
{
namespace scene
{
    class ViewFrustum;
}
namespace math
{


namespace CollisionLibrary
{

SP_EXPORT dim::vector3df getClosestPoint(const dim::triangle3df &Triangle, const dim::vector3df &Point);

SP_EXPORT bool getClosestPointStraight(
    const dim::triangle3df &Triangle, const dim::vector3df &Point, dim::vector3df &PointOnTriangle
);

SP_EXPORT dim::vector3df getClosestPoint(const dim::aabbox3df &Box, const dim::vector3df &Point);

SP_EXPORT dim::vector3df getClosestPoint(
    const dim::aabbox3df &Box, const dim::vector3df &Point, dim::vector3df &Normal
);

SP_EXPORT dim::vector3df getClosestPoint(const dim::obbox3df &Box, const dim::vector3df &Point);

SP_EXPORT dim::line3df getClosestLine(const dim::triangle3df &Triangle, const dim::line3df &Line);

SP_EXPORT bool getClosestLineStraight(const dim::triangle3df &Triangle, const dim::line3df &Line, dim::line3df &LineToTriangle);

SP_EXPORT dim::line3df getClosestLine(const dim::quadrangle3df &Quadrangle, const dim::line3df &Line);

SP_EXPORT dim::line3df getClosestLine(const dim::aabbox3df &Box, const dim::line3df &Line);

SP_EXPORT f32 getPointBoxDistanceSq(const dim::obbox3df &Box, const dim::vector3df &Point);

inline f32 getPointBoxDistance(const dim::obbox3df &Box, const dim::vector3df &Point)
{
    return sqrt(getPointBoxDistanceSq(Box, Point));
}

SP_EXPORT f32 getLineBoxDistanceSq(const dim::aabbox3df &Box, const dim::line3df &Line);

inline f32 getLineBoxDistance(const dim::aabbox3df &Box, const dim::line3df &Line)
{
    return sqrt(getLineBoxDistanceSq(Box, Line));
}

SP_EXPORT f32 getLineLineDistanceSq(
    const dim::line3df &LineA, const dim::line3df &LineB, dim::vector3df &PointP, dim::vector3df &PointQ
);

inline f32 getLineLineDistance(
    const dim::line3df &LineA, const dim::line3df &LineB, dim::vector3df &PointP, dim::vector3df &PointQ)
{
    return sqrt(getLineLineDistanceSq(LineA, LineB, PointP, PointQ));
}

SP_EXPORT bool getLineLineIntersection(
    const dim::line3df &LineA, const dim::line3df &LineB, dim::vector3df &Intersection
);

SP_EXPORT dim::point2df get2DLineLineIntersectionStraight(
    const dim::point2df &A, const dim::point2df &B, const dim::point2df &C, const dim::point2df &D
);

/* === Intersection tests === */

SP_EXPORT bool checkLineTriangleIntersection(
    const dim::triangle3df &Triangle, const dim::line3df &Line, dim::vector3df &Intersection
);

SP_EXPORT bool checkLineSphereIntersection(
    const dim::line3df &Line, const dim::vector3df &SpherePosition, const f32 SphereRadius, dim::vector3df &Intersection, bool MakeRayTest = false
);

SP_EXPORT bool checkLineBoxIntersection(
    const dim::line3df &Line, const dim::aabbox3df &Box, dim::vector3df &Intersection, bool MakeRayTest = false
);

SP_EXPORT bool checkTriangleTriangleIntersection(
    const dim::triangle3df &TriangleA, const dim::triangle3df &TriangleB, dim::line3df &Intersection
);

/* === Overlap tests === */

SP_EXPORT bool checkLineBoxOverlap(
    const dim::line3df &Line, const dim::aabbox3df &Box
);

SP_EXPORT bool checkPlaneBoxOverlap(
    const dim::plane3df &Plane, const dim::aabbox3df &Box
);

SP_EXPORT bool checkTriangleBoxOverlap(
    const dim::triangle3df &Triangle, const dim::aabbox3df &Box
);

SP_EXPORT bool checkOBBoxOBBoxOverlap(
    const dim::obbox3df &BoxA, const dim::obbox3df &BoxB
);

bool checkPyramidPyramidOverlap(
    const dim::vector3df &OriginA, const scene::ViewFrustum &FrustumA,
    const dim::vector3df &OriginB, const scene::ViewFrustum &FrustumB
);

/* === Polygon clippint === */

template <typename T, typename C> bool getLinePlaneIntersection(
    const dim::plane3d<T> &Plane, const C &LineStart, const C &LineEnd, C &Intersection)
{
    C Direction(LineEnd);
    Direction -= LineStart;
    
    const T t = (Plane.Distance - Plane.Normal.dot(LineStart.getCoord())) / Plane.Normal.dot(Direction.getCoord());
    
    if (t >= T(0) && t <= T(1))
    {
        // Intersection := LineStart + Direction * t
        Intersection = Direction;
        Intersection *= t;
        Intersection += LineStart;
        return true;
    }
    
    return false;
}

template <typename T, typename C> bool clipPolygon(
    const dim::polygon<C> &Poly, const dim::plane3d<T> &Plane, dim::polygon<C> &FrontPoly, dim::polygon<C> &BackPoly)
{
    if (Poly.getCount() < 3)
    {
        #ifdef SP_DEBUGMODE
        io::Log::debug("CollisionLibrary::clipPolygon", "Polygon has not enough points to be cliped");
        #endif
        return false;
    }
    
    // Test all edges (a, b) starting with edge from last to first vertex
    const u32 PointCount = Poly.getCount();
    C a = Poly.Points.back();
    
    dim::EPlanePointRelations aSide = Plane.getPointRelation(a.getCoord());
    
    // Loop over all edges given by vertex pair (n-1, n)
    for (u32 i = 0; i < PointCount; ++i)
    {
        C b = Poly[i];
        
        dim::EPlanePointRelations bSide = Plane.getPointRelation(b.getCoord());
        
        if (bSide == dim::POINT_INFRONTOF_PLANE)
        {
            if (aSide == dim::POINT_BEHIND_PLANE)
            {
                // Edge (a, b) straddles, output intersection point to both sides
                C Intersection;
                getLinePlaneIntersection(Plane, a, b, Intersection);
                
                //if (Plane.getPointRelation(Intersection) != dim::POINT_ON_PLANE)
                //    return false;
                
                FrontPoly.push(Intersection);
                BackPoly.push(Intersection);
            }
            
            // In all three cases, output b to the front side
            FrontPoly.push(b);
        }
        else if (bSide == dim::POINT_BEHIND_PLANE)
        {
            if (aSide == dim::POINT_INFRONTOF_PLANE)
            {
                // Edge (a, b) straddles plane, output intersection point
                C Intersection;
                getLinePlaneIntersection(Plane, a, b, Intersection);
                
                //if (Plane.getPointRelation(Intersection) != dim::POINT_ON_PLANE)
                //    return false;
                
                FrontPoly.push(Intersection);
                BackPoly.push(Intersection);
            }
            else if (aSide == dim::POINT_ON_PLANE)
            {
                // Output a when edge (a, b) goes from ‘on’ to ‘behind’ plane
                BackPoly.push(a);
            }
            
            // In all three cases, output b to the back side
            BackPoly.push(b);
        }
        else
        {
            // b is on the plane. In all three cases output b to the front side
            FrontPoly.push(b);
            
            // In one case, also output b to back side
            if (aSide == dim::POINT_BEHIND_PLANE)
                BackPoly.push(b);
        }
        
        // Keep b as the starting point of the next edge
        a = b;
        aSide = bSide;
    }
    
    return true;
}

} // /namespace CollisionLibrary


} // /namespace math

} // /namespace sp


#endif



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