DetourCommon.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
// Modified version of Recast/Detour's source file
 
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
 
#ifndef DETOURCOMMON_H
#define DETOURCOMMON_H
 
#include "CoreMinimal.h"
#include "Detour/DetourLargeWorldCoordinates.h"
#include "HAL/PlatformMath.h"
 
// DT_STATS is set from the UE Stats settings
#define DT_STATS STATS
 
 
template<class T> inline void dtSwap(T& a, T& b) { T t = a; a = b; b = t; }
 
template<class T> inline T dtMin(T a, T b) { return a < b ? a : b; }
//@UE BEGIN Adding support for LWCoords. Overloading allows this to be called where one of the parameters is a double and the other a float.
inline dtReal dtMin(dtReal a, dtReal b) { return dtMin<dtReal>(a, b); }
//@UE END Adding support for LWCoords.
 
template<class T> inline T dtMax(T a, T b) { return a > b ? a : b; }
//@UE BEGIN Adding support for LWCoords. Overloading allows this to be called where one of the parameters is a double and the other a float.
inline dtReal dtMax(dtReal a, dtReal b) { return dtMax<dtReal>(a, b); }
//@UE END Adding support for LWCoords.
 
template<class T> inline T dtAbs(T a) { return a < 0 ? -a : a; }
 
template<class T> inline T dtSqr(T a) { return a*a; }
 
template<class T> inline T dtClamp(T v, T mn, T mx) { return v < mn ? mn : (v > mx ? mx : v); }
//@UE BEGIN Adding support for LWCoords. Overloading allows this to be called where one of the parameters is a double and the other a float.
inline dtReal dtClamp(dtReal v, dtReal mn, dtReal mx) { return dtClamp<dtReal>(v, mn, mx); }
//@UE END Adding support for LWCoords.
 
inline float dtFloor(float x)
{
    return floorf(x);
}
 
inline double dtFloor(double x)
{
    return floor(x);
}
 
inline float dtCeil(float x)
{
    return ceilf(x);
}
 
inline double dtCeil(double x)
{
    return ceil(x);
}
 
inline float dtSin(float x)
{
    return sinf(x);
}
 
inline double dtSin(double x)
{
    return sin(x);
}
 
inline float dtCos(float x)
{
    return cosf(x);
}
 
inline double dtCos(double x)
{
    return cos(x);
}
 
inline float dtAtan2(float x, float y)
{
    return atan2f(x, y);
}
 
inline double dtAtan2(double x, double y)
{
    return atan2(x, y);
}
 
inline float dtSqrt(float x)
{
    return sqrtf(x);
}
 
inline double dtSqrt(double x)
{
    return sqrt(x);
}
 
inline float dtfMod(float x, float y)
{
    return fmodf(x, y);
}
 
inline double dtfMod(double x, double y)
{
    return fmod(x, y);
}
 
inline float dtLerp(float a, float b, float t)
{
    return a + (b-a)*t;
}
 
 
inline void dtVcross(dtReal* dest, const dtReal* v1, const dtReal* v2)
{
    dest[0] = v1[1]*v2[2] - v1[2]*v2[1];
    dest[1] = v1[2]*v2[0] - v1[0]*v2[2];
    dest[2] = v1[0]*v2[1] - v1[1]*v2[0]; 
}
 
inline dtReal dtVdot(const dtReal* v1, const dtReal* v2)
{
    return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
}
 
inline void dtVmad(dtReal* dest, const dtReal* v1, const dtReal* v2, const dtReal s)
{
    dest[0] = v1[0]+v2[0]*s;
    dest[1] = v1[1]+v2[1]*s;
    dest[2] = v1[2]+v2[2]*s;
}
 
inline void dtVlerp(dtReal* dest, const dtReal* v1, const dtReal* v2, const dtReal t)
{
    dest[0] = v1[0]+(v2[0]-v1[0])*t;
    dest[1] = v1[1]+(v2[1]-v1[1])*t;
    dest[2] = v1[2]+(v2[2]-v1[2])*t;
}
 
inline void dtVadd(dtReal* dest, const dtReal* v1, const dtReal* v2)
{
    dest[0] = v1[0]+v2[0];
    dest[1] = v1[1]+v2[1];
    dest[2] = v1[2]+v2[2];
}
 
inline void dtVsub(dtReal* dest, const dtReal* v1, const dtReal* v2)
{
    dest[0] = v1[0]-v2[0];
    dest[1] = v1[1]-v2[1];
    dest[2] = v1[2]-v2[2];
}
 
inline void dtVscale(dtReal* dest, const dtReal* v, const dtReal t)
{
    dest[0] = v[0]*t;
    dest[1] = v[1]*t;
    dest[2] = v[2]*t;
}
 
inline void dtVmin(dtReal* mn, const dtReal* v)
{
    mn[0] = dtMin(mn[0], v[0]);
    mn[1] = dtMin(mn[1], v[1]);
    mn[2] = dtMin(mn[2], v[2]);
}
 
inline void dtVmax(dtReal* mx, const dtReal* v)
{
    mx[0] = dtMax(mx[0], v[0]);
    mx[1] = dtMax(mx[1], v[1]);
    mx[2] = dtMax(mx[2], v[2]);
}
 
inline void dtVset(dtReal* dest, const dtReal x, const dtReal y, const dtReal z)
{
    dest[0] = x; dest[1] = y; dest[2] = z;
}
 
inline void dtVcopy(dtReal* dest, const dtReal* a)
{
    dest[0] = a[0];
    dest[1] = a[1];
    dest[2] = a[2];
}
 
inline dtReal dtVlen(const dtReal* v)
{
    return dtSqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
}
 
inline dtReal dtVlenSqr(const dtReal* v)
{
    return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
}
 
inline dtReal dtVdist(const dtReal* v1, const dtReal* v2)
{
    const dtReal dx = v2[0] - v1[0];
    const dtReal dy = v2[1] - v1[1];
    const dtReal dz = v2[2] - v1[2];
    return dtSqrt(dx*dx + dy*dy + dz*dz);
}
 
inline dtReal dtVdistSqr(const dtReal* v1, const dtReal* v2)
{
    const dtReal dx = v2[0] - v1[0];
    const dtReal dy = v2[1] - v1[1];
    const dtReal dz = v2[2] - v1[2];
    return dx*dx + dy*dy + dz*dz;
}
 
inline dtReal dtVdist2D(const dtReal* v1, const dtReal* v2)
{
    const dtReal dx = v2[0] - v1[0];
    const dtReal dz = v2[2] - v1[2];
    return dtSqrt(dx*dx + dz*dz);
}
 
inline dtReal dtVdist2DSqr(const dtReal* v1, const dtReal* v2)
{
    const dtReal dx = v2[0] - v1[0];
    const dtReal dz = v2[2] - v1[2];
    return dx*dx + dz*dz;
}
 
inline void dtVnormalize(dtReal* v)
{
    dtReal d = 1.0f / dtSqrt(dtSqr(v[0]) + dtSqr(v[1]) + dtSqr(v[2]));
    v[0] *= d;
    v[1] *= d;
    v[2] *= d;
}
 
inline bool dtVisEqual(const unsigned short* a, const unsigned short* b)
{
    return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
}
 
inline bool dtVequal(const dtReal* p0, const dtReal* p1)
{
    static const dtReal thr = dtSqr(dtReal(1.)/16384.0f);
    const dtReal d = dtVdistSqr(p0, p1);
    return d < thr;
}
 
inline dtReal dtVdot2D(const dtReal* u, const dtReal* v)
{
    return u[0]*v[0] + u[2]*v[2];
}
 
inline dtReal dtVperp2D(const dtReal* u, const dtReal* v)
{
    return u[2]*v[0] - u[0]*v[2];
}
 
 
inline dtReal dtTriArea2D(const dtReal* a, const dtReal* b, const dtReal* c)
{
    const dtReal abx = b[0] - a[0];
    const dtReal abz = b[2] - a[2];
    const dtReal acx = c[0] - a[0];
    const dtReal acz = c[2] - a[2];
    return acx*abz - abx*acz;
}
 
inline bool dtOverlapQuantBounds(const unsigned short amin[3], const unsigned short amax[3],
                                 const unsigned short bmin[3], const unsigned short bmax[3])
{
    bool overlap = true;
    overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
    overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
    overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
    return overlap;
}
 
inline bool dtOverlapBounds(const dtReal* amin, const dtReal* amax,
                            const dtReal* bmin, const dtReal* bmax)
{
    bool overlap = true;
    overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
    overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
    overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
    return overlap;
}
 
void dtClosestPtPointTriangle(dtReal* closest, const dtReal* p,
                              const dtReal* a, const dtReal* b, const dtReal* c);
 
bool dtClosestHeightPointTriangle(const dtReal* p, const dtReal* a, const dtReal* b, const dtReal* c, dtReal& h);
 
bool dtIntersectSegmentPoly2D(const dtReal* p0, const dtReal* p1,
                              const dtReal* verts, int nverts,
                              dtReal& tmin, dtReal& tmax,
                              int& segMin, int& segMax);
 
bool dtIntersectSegSeg2D(const dtReal* ap, const dtReal* aq,
                         const dtReal* bp, const dtReal* bq,
                         dtReal& s, dtReal& t);
 
bool dtPointInPolygon(const dtReal* pt, const dtReal* verts, const int nverts);
 
bool dtDistancePtPolyEdgesSqr(const dtReal* pt, const dtReal* verts, const int nverts,
                            dtReal* ed, dtReal* et);
 
dtReal dtDistancePtSegSqr2D(const dtReal* pt, const dtReal* p, const dtReal* q, dtReal& t);
dtReal dtDistancePtSegSqr(const dtReal* pt, const dtReal* p, const dtReal* q);
 
void dtCalcPolyCenter(dtReal* tc, const unsigned short* idx, int nidx, const dtReal* verts);
 
bool dtOverlapPolyPoly2D(const dtReal* polya, const int npolya,
                         const dtReal* polyb, const int npolyb);
 
 
inline unsigned int dtNextPow2(unsigned int v)
{
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    v++;
    return v;
}
 
inline unsigned int dtIlog2(unsigned int v)
{
    unsigned int r;
    unsigned int shift;
    r = (v > 0xffff) << 4; v >>= r;
    shift = (v > 0xff) << 3; v >>= shift; r |= shift;
    shift = (v > 0xf) << 2; v >>= shift; r |= shift;
    shift = (v > 0x3) << 1; v >>= shift; r |= shift;
    r |= (v >> 1);
    return r;
}
 
//@UE BEGIN Align to 8 byte boundaries when using double precision
inline int dtAlign(int x) 
{
#if DT_LARGE_WORLD_COORDINATES_DISABLED
    return (x + 3) & ~3; // Align to 4 byte boundary
#else
    return (x + 7) & ~7; // Align to 8 byte boundary
#endif
}
//@UE END
 
inline int dtOppositeTile(int side) { return (side+4) & 0x7; }
 
inline void dtSwapByte(unsigned char* a, unsigned char* b)
{
    unsigned char tmp = *a;
    *a = *b;
    *b = tmp;
}
 
inline void dtSwapEndian(unsigned short* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x+0, x+1);
}
 
inline void dtSwapEndian(short* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x+0, x+1);
}
 
inline void dtSwapEndian(unsigned int* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}
 
inline void dtSwapEndian(int* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}
 
inline void dtSwapEndian(unsigned long long int* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x + 0, x + 7); 
    dtSwapByte(x + 1, x + 6);
    dtSwapByte(x + 2, x + 5);
    dtSwapByte(x + 3, x + 4);
}
 
inline void dtSwapEndian(long long int* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x + 0, x + 7);
    dtSwapByte(x + 1, x + 6);
    dtSwapByte(x + 2, x + 5);
    dtSwapByte(x + 3, x + 4);
}
 
inline void dtSwapEndian(float* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}
 
// @UE BEGIN Adding support for LWCoords.
inline void dtSwapEndian(double* v)
{
    unsigned char* x = (unsigned char*)v;
    dtSwapByte(x + 0, x + 7); dtSwapByte(x + 1, x + 6); dtSwapByte(x + 2, x + 5); dtSwapByte(x + 3, x + 4);
}
//@UE END Adding support for LWCoords.
 
void dtRandomPointInConvexPoly(const dtReal* pts, const int npts, dtReal* areas,
                               const dtReal s, const dtReal t, dtReal* out);
 
// @UE BEGIN
enum dtRotation
{
    DT_ROTATE_0, 
    DT_ROTATE_90, 
    DT_ROTATE_180, 
    DT_ROTATE_270
};
 
dtRotation dtSelectRotation(dtReal rotationDeg);
 
void dtVRot90(dtReal* dest, const dtReal* v, const dtRotation rot);
 
void dtVRot90(unsigned short* dest, const unsigned short* v, const dtRotation rot);
 
void dtRotate90(dtReal* dest, const dtReal* v, const dtReal* center, const dtRotation rot);
 
void dtRotate90(unsigned short* dest, const unsigned short* v, const unsigned short* center, const dtRotation rot);
// @UE END
 
 
#endif // DETOURCOMMON_H
 
 
// This section contains detailed documentation for members that don't have
// a source file. It reduces clutter in the main section of the header.