diff options
425 files changed, 618 insertions, 17751 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 1387ab6..b1cb04b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,11 @@ cmake_minimum_required(VERSION 3.20) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_EXTENSIONS Yes) project(Starshatter) -set(WINDOWSSDK_LIBPATH "C:/Program Files (x86)/Windows Kits/10/Lib/10.0.19041.0/um/x86" CACHE FILEPATH "Path to Windows SDK libraries") -set(WINDOWSSDK_PATH "C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/um" CACHE FILEPATH "Path to Windows SDK header files") +if(MSVC) + set(WINDOWSSDK_LIBPATH "C:/Program Files (x86)/Windows Kits/10/Lib/10.0.19041.0" CACHE FILEPATH "Path to a versioned lib directory of selected Windows SDK") + set(WINDOWSSDK_PATH "C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0" CACHE FILEPATH "Path to a versioned include directory of selected Windows SDK") +endif() add_subdirectory(Datafile) # /Doc contains various documentation and pre-generated Doxygen docs. add_subdirectory(FoundationEx) diff --git a/FoundationEx/Dictionary.h b/FoundationEx/Dictionary.h index 8a8c49d..cfbaab9 100644 --- a/FoundationEx/Dictionary.h +++ b/FoundationEx/Dictionary.h @@ -121,5 +121,5 @@ public: // +-------------------------------------------------------------------+ #include "Dictionary.inl" -#endif Dictionary_h +#endif // Dictionary_h diff --git a/FoundationEx/List.h b/FoundationEx/List.h index 13a48cd..8f31296 100644 --- a/FoundationEx/List.h +++ b/FoundationEx/List.h @@ -127,5 +127,5 @@ private: }; #include "List.inl" -#endif List_h +#endif // List_h diff --git a/FoundationEx/MemDebug.cpp b/FoundationEx/MemDebug.cpp index 4f3174f..060df5a 100644 --- a/FoundationEx/MemDebug.cpp +++ b/FoundationEx/MemDebug.cpp @@ -89,11 +89,21 @@ void __cdecl operator delete(void* p, const char*, int) #ifndef _DEBUG +void* __cdecl operator new[](unsigned int s, const char*, int) +{ + return ::operator new[](s); +} + void* __cdecl operator new(unsigned int s, const char*, int) { return ::operator new(s); } +void __cdecl operator delete[](void* p, const char*, int) +{ + ::operator delete[](p); +} + void __cdecl operator delete(void* p, const char*, int) { ::operator delete(p); @@ -104,6 +114,11 @@ void __cdecl operator delete(void* p, const char*, int) // No definitions for the following: //void* __cdecl operator new(unsigned int, int, const char*, int) {} +void* __cdecl operator new[](unsigned int s, const char*, int) +{ + return ::operator new[](s); +} + void* __cdecl operator new(unsigned int s, const char* f, int l) { return ::operator new(s, 1, f, l); @@ -114,14 +129,19 @@ void* __cdecl operator new(unsigned int s) return ::operator new(s, 1, __FILE__, __LINE__); } +void __cdecl operator delete[](void* p, const char*, int) +{ + ::operator delete[](p); +} + void __cdecl operator delete(void* p, const char*, int) { ::operator delete(p); } -#endif _DEBUG +#endif // _DEBUG -#endif FOUNDATION_USE_MFC +#endif // FOUNDATION_USE_MFC static void heapdump() { diff --git a/FoundationEx/MemDebug.h b/FoundationEx/MemDebug.h index 0bd63da..bcf217f 100644 --- a/FoundationEx/MemDebug.h +++ b/FoundationEx/MemDebug.h @@ -51,12 +51,16 @@ #ifndef _DEBUG +void* __cdecl operator new[](unsigned int, const char*, int); void* __cdecl operator new(unsigned int s, const char*, int); +void __cdecl operator delete[](void* p, const char*, int); void __cdecl operator delete(void* p, const char*, int); #else +void* __cdecl operator new[](unsigned int, const char*, int); void* __cdecl operator new(unsigned int s, const char*, int); +void __cdecl operator delete[](void* p, const char*, int); void __cdecl operator delete(void* p, const char*, int); #endif @@ -89,24 +93,30 @@ public: #ifndef _DEBUG +void* __cdecl operator new[](unsigned int, const char*, int); void* __cdecl operator new(unsigned int s, const char*, int); +void __cdecl operator delete[](void* p, const char*, int); void __cdecl operator delete(void* p, const char*, int); #else /*_CRTIMP*/ +void* __cdecl operator new[](unsigned int, const char*, int); + void* __cdecl operator new(unsigned int, int, const char*, int); void* __cdecl operator new(unsigned int s, const char* f, int l); void* __cdecl operator new(unsigned int s); +void __cdecl operator delete[](void* p, const char*, int); + void __cdecl operator delete(void* p, const char*, int); -#endif _DEBUG +#endif // _DEBUG // +--------------------------------------------------------------------+ -#endif FOUNDATION_USE_MFC +#endif // FOUNDATION_USE_MFC -#endif MemDebug_h +#endif // MemDebug_h diff --git a/FoundationEx/Text.h b/FoundationEx/Text.h index ee946f8..170eafe 100644 --- a/FoundationEx/Text.h +++ b/FoundationEx/Text.h @@ -214,4 +214,4 @@ inline Text operator+( char* l, const Text& r) { return Text(l) + r; } // +-------------------------------------------------------------------+ -#endif Text_h +#endif // Text_h diff --git a/FoundationEx/ThreadSync.h b/FoundationEx/ThreadSync.h index 7bf66c0..cfe7a4e 100644 --- a/FoundationEx/ThreadSync.h +++ b/FoundationEx/ThreadSync.h @@ -78,4 +78,4 @@ private: ThreadSync& sync; }; -#endif ThreadSync_h +#endif // ThreadSync_h diff --git a/Magic2/CMakeLists.txt b/Magic2/CMakeLists.txt index 4753252..3bf0404 100644 --- a/Magic2/CMakeLists.txt +++ b/Magic2/CMakeLists.txt @@ -36,7 +36,7 @@ target_include_directories( Magic2 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} PUBLIC $ENV{DXSDK_DIR}/Include - PUBLIC ${WINDOWSSDK_PATH} # FIXME + PUBLIC ${WINDOWSSDK_PATH}/um # FIXME ) target_precompile_headers( Magic2 diff --git a/NetEx/CMakeLists.txt b/NetEx/CMakeLists.txt index ccb0f01..5bce174 100644 --- a/NetEx/CMakeLists.txt +++ b/NetEx/CMakeLists.txt @@ -17,13 +17,18 @@ add_library( NetServer.cpp NetSock.cpp ) -set(WINDOWSSDK_PATH "C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/um") target_include_directories( NetEx PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} - PUBLIC ${WINDOWSSDK_PATH} # FIXME ) target_link_libraries( NetEx PUBLIC FoundationEx ) +if(MSVC) + target_include_directories( + NetEx + PUBLIC ${WINDOWSSDK_PATH}/um + PUBLIC ${WINDOWSSDK_PATH}/shared + ) +endif() diff --git a/NetEx/HttpClient.h b/NetEx/HttpClient.h index e9b84b9..54c5f4e 100644 --- a/NetEx/HttpClient.h +++ b/NetEx/HttpClient.h @@ -64,4 +64,4 @@ protected: }; -#endif HttpClient_h
\ No newline at end of file +#endif // HttpClient_h diff --git a/NetEx/HttpServer.h b/NetEx/HttpServer.h index fb74fbc..9101944 100644 --- a/NetEx/HttpServer.h +++ b/NetEx/HttpServer.h @@ -238,4 +238,4 @@ private: }; -#endif HttpServer_h
\ No newline at end of file +#endif // HttpServer_h diff --git a/NetEx/HttpServlet.h b/NetEx/HttpServlet.h index e209671..3b94320 100644 --- a/NetEx/HttpServlet.h +++ b/NetEx/HttpServlet.h @@ -106,4 +106,4 @@ protected: }; -#endif HttpServlet_h
\ No newline at end of file +#endif // HttpServlet_h diff --git a/NetEx/HttpServletExec.h b/NetEx/HttpServletExec.h index 3ae1be1..168b9d8 100644 --- a/NetEx/HttpServletExec.h +++ b/NetEx/HttpServletExec.h @@ -78,4 +78,4 @@ protected: bool exec_shutdown; }; -#endif HttpServletExec_h
\ No newline at end of file +#endif // HttpServletExec_h diff --git a/NetEx/NetAddr.h b/NetEx/NetAddr.h index 32e01c9..c0059d7 100644 --- a/NetEx/NetAddr.h +++ b/NetEx/NetAddr.h @@ -80,4 +80,4 @@ private: }; -#endif NetAddr_h
\ No newline at end of file +#endif // NetAddr_h diff --git a/NetEx/NetClient.h b/NetEx/NetClient.h index 932847c..74ea329 100644 --- a/NetEx/NetClient.h +++ b/NetEx/NetClient.h @@ -124,4 +124,4 @@ public: }; -#endif NetClient_h
\ No newline at end of file +#endif // NetClient_h diff --git a/NetEx/NetGram.h b/NetEx/NetGram.h index d1831b4..9626f86 100644 --- a/NetEx/NetGram.h +++ b/NetEx/NetGram.h @@ -100,4 +100,4 @@ protected: }; -#endif NetGram_h +#endif // NetGram_h diff --git a/NetEx/NetHost.h b/NetEx/NetHost.h index cf6c255..b81ce2f 100644 --- a/NetEx/NetHost.h +++ b/NetEx/NetHost.h @@ -71,4 +71,4 @@ private: }; -#endif // NET_HOST_H
\ No newline at end of file +#endif // NET_HOST_H diff --git a/NetEx/NetLayer.h b/NetEx/NetLayer.h index 49c884e..d2a9528 100644 --- a/NetEx/NetLayer.h +++ b/NetEx/NetLayer.h @@ -67,4 +67,4 @@ private: }; -#endif NetLayer_h
\ No newline at end of file +#endif // NetLayer_h diff --git a/NetEx/NetLink.h b/NetEx/NetLink.h index c39a32e..1b861a0 100644 --- a/NetEx/NetLink.h +++ b/NetEx/NetLink.h @@ -134,4 +134,4 @@ protected: }; -#endif NetLink_h
\ No newline at end of file +#endif // NetLink_h diff --git a/NetEx/NetMsg.h b/NetEx/NetMsg.h index 072886b..e0c6d1b 100644 --- a/NetEx/NetMsg.h +++ b/NetEx/NetMsg.h @@ -102,4 +102,5 @@ struct NetMsgMultipart { // +-------------------------------------------------------------------+ -#endif NetMsg_h + +#endif // NetMsg_h diff --git a/NetEx/NetPeer.h b/NetEx/NetPeer.h index 4849f2f..c48b69b 100644 --- a/NetEx/NetPeer.h +++ b/NetEx/NetPeer.h @@ -119,4 +119,4 @@ private: }; -#endif NetPeer_h
\ No newline at end of file +#endif // NetPeer_h diff --git a/NetEx/NetServer.h b/NetEx/NetServer.h index f0b261f..a2ce126 100644 --- a/NetEx/NetServer.h +++ b/NetEx/NetServer.h @@ -86,4 +86,4 @@ protected: }; -#endif NetServer_h
\ No newline at end of file +#endif // NetServer_h diff --git a/NetEx/NetSock.h b/NetEx/NetSock.h index 00444f0..b3f71f4 100644 --- a/NetEx/NetSock.h +++ b/NetEx/NetSock.h @@ -94,4 +94,4 @@ private: }; -#endif NetSock_h
\ No newline at end of file +#endif // NetSock_h diff --git a/Opcode/CMakeLists.txt b/Opcode/CMakeLists.txt index e60d33c..6010c50 100644 --- a/Opcode/CMakeLists.txt +++ b/Opcode/CMakeLists.txt @@ -42,13 +42,14 @@ add_library( ) target_include_directories( Opcode - PRIVATE . + PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ) target_precompile_headers( Opcode - PRIVATE StdAfx.h + PUBLIC StdAfx.h ) target_compile_definitions( Opcode - PUBLIC OPCODE_EXPORTS + PRIVATE OPCODE_EXPORTS + PUBLIC _ALLOW_KEYWORD_MACROS ) diff --git a/Opcode/Ice/IceAABB.cpp b/Opcode/Ice/IceAABB.cpp index 149211c..2e3288b 100644 --- a/Opcode/Ice/IceAABB.cpp +++ b/Opcode/Ice/IceAABB.cpp @@ -100,7 +100,7 @@ bool AABB::IsInside(const AABB& box) const * \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::ComputePlanes(Plane* planes) const
+bool AABB::ComputePlanes(IcePlane* planes) const
{
// Checkings
if(!planes) return false;
diff --git a/Opcode/Ice/IceAABB.h b/Opcode/Ice/IceAABB.h index 2c2ce79..1ef671b 100644 --- a/Opcode/Ice/IceAABB.h +++ b/Opcode/Ice/IceAABB.h @@ -23,7 +23,7 @@ const sbyte* ComputeOutline(const IcePoint& local_eye, sdword& num) const; \
float ComputeBoxArea(const IcePoint& eye, const Matrix4x4& mat, float width, float height, sdword& num) const; \
bool IsInside(const AABB& box) const; \
- bool ComputePlanes(Plane* planes) const; \
+ bool ComputePlanes(IcePlane* planes) const; \
bool ComputePoints(IcePoint* pts) const; \
const IcePoint* GetVertexNormals() const; \
const udword* GetEdges() const; \
diff --git a/Opcode/Ice/IceContainer.cpp b/Opcode/Ice/IceContainer.cpp index e2c42d1..552d051 100644 --- a/Opcode/Ice/IceContainer.cpp +++ b/Opcode/Ice/IceContainer.cpp @@ -28,9 +28,11 @@ using namespace IceCore; // Static members
#ifdef CONTAINER_STATS
+#ifdef OPCODE_EXPORTS
udword Container::mNbContainers = 0;
udword Container::mUsedRam = 0;
#endif
+#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
@@ -343,3 +345,13 @@ void Container::operator=(const Container& object) CopyMemory(mEntries, object.GetEntries(), mMaxNbEntries*sizeof(udword));
mCurNbEntries = mMaxNbEntries;
}
+
+udword Container::GetNbContainers() const
+{
+ return mNbContainers;
+}
+
+udword Container::GetTotalBytes() const
+{
+ return mUsedRam;
+}
diff --git a/Opcode/Ice/IceContainer.h b/Opcode/Ice/IceContainer.h index 9f06ada..2660cc8 100644 --- a/Opcode/Ice/IceContainer.h +++ b/Opcode/Ice/IceContainer.h @@ -192,8 +192,8 @@ void operator = (const Container& object);
#ifdef CONTAINER_STATS
- inline_ udword GetNbContainers() const { return mNbContainers; }
- inline_ udword GetTotalBytes() const { return mUsedRam; }
+ udword GetNbContainers() const;
+ udword GetTotalBytes() const;
private:
static udword mNbContainers; //!< Number of containers around
diff --git a/Opcode/Ice/IceFPU.h b/Opcode/Ice/IceFPU.h index 9e57960..18ad7ae 100644 --- a/Opcode/Ice/IceFPU.h +++ b/Opcode/Ice/IceFPU.h @@ -12,6 +12,9 @@ #ifndef __ICEFPU_H__
#define __ICEFPU_H__
+ #include <algorithm>
+ #include <cmath>
+
#define SIGN_BITMASK 0x80000000
//! Integer representation of a floating-point value.
@@ -41,16 +44,7 @@ //! Fast square root for floating-point values.
inline_ float FastSqrt(float square)
{
- float retval;
-
- __asm {
- mov eax, square
- sub eax, 0x3F800000
- sar eax, 1
- add eax, 0x3F800000
- mov [retval], eax
- }
- return retval;
+ return std::sqrt(square);
}
//! Saturates positive to zero.
@@ -178,102 +172,28 @@ return x*x < epsilon;
}
- #define FCOMI_ST0 _asm _emit 0xdb _asm _emit 0xf0
- #define FCOMIP_ST0 _asm _emit 0xdf _asm _emit 0xf0
- #define FCMOVB_ST0 _asm _emit 0xda _asm _emit 0xc0
- #define FCMOVNB_ST0 _asm _emit 0xdb _asm _emit 0xc0
-
- #define FCOMI_ST1 _asm _emit 0xdb _asm _emit 0xf1
- #define FCOMIP_ST1 _asm _emit 0xdf _asm _emit 0xf1
- #define FCMOVB_ST1 _asm _emit 0xda _asm _emit 0xc1
- #define FCMOVNB_ST1 _asm _emit 0xdb _asm _emit 0xc1
-
- #define FCOMI_ST2 _asm _emit 0xdb _asm _emit 0xf2
- #define FCOMIP_ST2 _asm _emit 0xdf _asm _emit 0xf2
- #define FCMOVB_ST2 _asm _emit 0xda _asm _emit 0xc2
- #define FCMOVNB_ST2 _asm _emit 0xdb _asm _emit 0xc2
-
- #define FCOMI_ST3 _asm _emit 0xdb _asm _emit 0xf3
- #define FCOMIP_ST3 _asm _emit 0xdf _asm _emit 0xf3
- #define FCMOVB_ST3 _asm _emit 0xda _asm _emit 0xc3
- #define FCMOVNB_ST3 _asm _emit 0xdb _asm _emit 0xc3
-
- #define FCOMI_ST4 _asm _emit 0xdb _asm _emit 0xf4
- #define FCOMIP_ST4 _asm _emit 0xdf _asm _emit 0xf4
- #define FCMOVB_ST4 _asm _emit 0xda _asm _emit 0xc4
- #define FCMOVNB_ST4 _asm _emit 0xdb _asm _emit 0xc4
-
- #define FCOMI_ST5 _asm _emit 0xdb _asm _emit 0xf5
- #define FCOMIP_ST5 _asm _emit 0xdf _asm _emit 0xf5
- #define FCMOVB_ST5 _asm _emit 0xda _asm _emit 0xc5
- #define FCMOVNB_ST5 _asm _emit 0xdb _asm _emit 0xc5
-
- #define FCOMI_ST6 _asm _emit 0xdb _asm _emit 0xf6
- #define FCOMIP_ST6 _asm _emit 0xdf _asm _emit 0xf6
- #define FCMOVB_ST6 _asm _emit 0xda _asm _emit 0xc6
- #define FCMOVNB_ST6 _asm _emit 0xdb _asm _emit 0xc6
-
- #define FCOMI_ST7 _asm _emit 0xdb _asm _emit 0xf7
- #define FCOMIP_ST7 _asm _emit 0xdf _asm _emit 0xf7
- #define FCMOVB_ST7 _asm _emit 0xda _asm _emit 0xc7
- #define FCMOVNB_ST7 _asm _emit 0xdb _asm _emit 0xc7
-
//! A global function to find MAX(a,b) using FCOMI/FCMOV
inline_ float FCMax2(float a, float b)
{
- float Res;
- _asm fld [a]
- _asm fld [b]
- FCOMI_ST1
- FCMOVB_ST1
- _asm fstp [Res]
- _asm fcomp
- return Res;
+ return std::max(a, b);
}
//! A global function to find MIN(a,b) using FCOMI/FCMOV
inline_ float FCMin2(float a, float b)
{
- float Res;
- _asm fld [a]
- _asm fld [b]
- FCOMI_ST1
- FCMOVNB_ST1
- _asm fstp [Res]
- _asm fcomp
- return Res;
+ return std::min(a, b);
}
//! A global function to find MAX(a,b,c) using FCOMI/FCMOV
inline_ float FCMax3(float a, float b, float c)
{
- float Res;
- _asm fld [a]
- _asm fld [b]
- _asm fld [c]
- FCOMI_ST1
- FCMOVB_ST1
- FCOMI_ST2
- FCMOVB_ST2
- _asm fstp [Res]
- _asm fcompp
- return Res;
+ return std::max(std::max(a, b), c);
}
//! A global function to find MIN(a,b,c) using FCOMI/FCMOV
inline_ float FCMin3(float a, float b, float c)
{
- float Res;
- _asm fld [a]
- _asm fld [b]
- _asm fld [c]
- FCOMI_ST1
- FCMOVNB_ST1
- FCOMI_ST2
- FCMOVNB_ST2
- _asm fstp [Res]
- _asm fcompp
- return Res;
+ return std::min(std::min(a, b), c);
}
inline_ int ConvertToSortable(float f)
diff --git a/Opcode/Ice/IceIndexedTriangle.cpp b/Opcode/Ice/IceIndexedTriangle.cpp index d680f24..ea32362 100644 --- a/Opcode/Ice/IceIndexedTriangle.cpp +++ b/Opcode/Ice/IceIndexedTriangle.cpp @@ -202,7 +202,7 @@ bool IndexedTriangle::IsVisible(const IcePoint* verts, const IcePoint& source) c return (Normal | source) >= 0.0f;
// Same as:
-// Plane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
+// IcePlane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
// return PL.Distance(source) > PL.d;
}
@@ -234,7 +234,7 @@ bool IndexedTriangle::BackfaceCulling(const IcePoint* verts, const IcePoint& sou return (Normal | (source - p0)) >= 0.0f;
// Same as: (but a bit faster)
-// Plane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
+// IcePlane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
// return PL.Distance(source)>0.0f;
}
diff --git a/Opcode/Ice/IceIndexedTriangle.h b/Opcode/Ice/IceIndexedTriangle.h index 5dc39ea..842eea2 100644 --- a/Opcode/Ice/IceIndexedTriangle.h +++ b/Opcode/Ice/IceIndexedTriangle.h @@ -12,9 +12,6 @@ #ifndef __ICEINDEXEDTRIANGLE_H__
#define __ICEINDEXEDTRIANGLE_H__
- // Forward declarations
- enum CubeIndex;
-
// An indexed triangle class.
class ICEMATHS_API IndexedTriangle
{
@@ -60,9 +57,8 @@ float MaxEdgeLength(const IcePoint* verts) const;
void ComputePoint(const IcePoint* verts, float u, float v, IcePoint& pt, udword* nearvtx=null) const;
float Angle(const IndexedTriangle& tri, const IcePoint* verts) const;
- inline_ Plane PlaneEquation(const IcePoint* verts) const { return Plane(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]); }
+ inline_ IcePlane PlaneEquation(const IcePoint* verts) const { return IcePlane(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]); }
bool Equal(const IndexedTriangle& tri) const;
- CubeIndex ComputeCubeIndex(const IcePoint* verts) const;
};
#endif // __ICEINDEXEDTRIANGLE_H__
diff --git a/Opcode/Ice/IceLSS.h b/Opcode/Ice/IceLSS.h index 8c2c154..8a26823 100644 --- a/Opcode/Ice/IceLSS.h +++ b/Opcode/Ice/IceLSS.h @@ -12,13 +12,13 @@ #ifndef __ICELSS_H__
#define __ICELSS_H__
- class ICEMATHS_API LSS : public Segment
+ class ICEMATHS_API LSS : public IceSegment
{
public:
//! Constructor
inline_ LSS() {}
//! Constructor
- inline_ LSS(const Segment& seg, float radius) : Segment(seg), mRadius(radius) {}
+ inline_ LSS(const IceSegment& seg, float radius) : IceSegment(seg), mRadius(radius) {}
//! Destructor
inline_ ~LSS() {}
diff --git a/Opcode/Ice/IceMemoryMacros.h b/Opcode/Ice/IceMemoryMacros.h index 490ecd1..346345b 100644 --- a/Opcode/Ice/IceMemoryMacros.h +++ b/Opcode/Ice/IceMemoryMacros.h @@ -47,23 +47,7 @@ //! \warning writes nb*4 bytes !
inline_ void StoreDwords(udword* dest, udword nb, udword value)
{
- // The asm code below **SHOULD** be equivalent to one of those C versions
- // or the other if your compiled is good: (checked on VC++ 6.0)
- //
- // 1) while(nb--) *dest++ = value;
- //
- // 2) for(udword i=0;i<nb;i++) dest[i] = value;
- //
- _asm push eax
- _asm push ecx
- _asm push edi
- _asm mov edi, dest
- _asm mov ecx, nb
- _asm mov eax, value
- _asm rep stosd
- _asm pop edi
- _asm pop ecx
- _asm pop eax
+ while (nb--) *dest++ = value;
}
//! Copies a buffer.
@@ -94,7 +78,7 @@ #define SAFE_DESTRUCT(x) if (x) { (x)->SelfDestruct(); (x) = null; } //!< Safe ICE-style release
#ifdef __ICEERROR_H__
- #define CHECKALLOC(x) if(!x) return SetIceError("Out of memory.", EC_OUT_OF_MEMORY); //!< Standard alloc checking. HANDLE WITH CARE.
+ #define CHECKALLOC(x) if(!x) return SetIceError;; // ("Out of memory.", EC_OUT_OF_MEMORY); //!< Standard alloc checking. HANDLE WITH CARE.
#else
#define CHECKALLOC(x) if(!x) return false;
#endif
diff --git a/Opcode/Ice/IceOBB.cpp b/Opcode/Ice/IceOBB.cpp index 439c58c..5a986e8 100644 --- a/Opcode/Ice/IceOBB.cpp +++ b/Opcode/Ice/IceOBB.cpp @@ -79,7 +79,7 @@ void OBB::Create(const AABB& aabb, const Matrix4x4& mat) * \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool OBB::ComputePlanes(Plane* planes) const
+bool OBB::ComputePlanes(IcePlane* planes) const
{
// Checkings
if(!planes) return false;
diff --git a/Opcode/Ice/IceOBB.h b/Opcode/Ice/IceOBB.h index 2badb18..9c1711d 100644 --- a/Opcode/Ice/IceOBB.h +++ b/Opcode/Ice/IceOBB.h @@ -94,7 +94,7 @@ * \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool ComputePlanes(Plane* planes) const;
+ bool ComputePlanes(IcePlane* planes) const;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
diff --git a/Opcode/Ice/IcePlane.cpp b/Opcode/Ice/IcePlane.cpp index cd4758c..15e907c 100644 --- a/Opcode/Ice/IcePlane.cpp +++ b/Opcode/Ice/IcePlane.cpp @@ -9,8 +9,8 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
- * Plane class.
- * \class Plane
+ * IcePlane class.
+ * \class IcePlane
* \author Pierre Terdiman
* \version 1.0
*/
@@ -31,7 +31,7 @@ using namespace IceMaths; * \return Self-reference
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Plane& Plane::Set(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2)
+IcePlane& IcePlane::Set(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2)
{
IcePoint Edge0 = p1 - p0;
IcePoint Edge1 = p2 - p0;
diff --git a/Opcode/Ice/IcePlane.h b/Opcode/Ice/IcePlane.h index d514e68..1a447ce 100644 --- a/Opcode/Ice/IcePlane.h +++ b/Opcode/Ice/IcePlane.h @@ -14,28 +14,28 @@ #define PLANE_EPSILON (1.0e-7f)
- class ICEMATHS_API Plane
+ class ICEMATHS_API IcePlane
{
public:
//! Constructor
- inline_ Plane() { }
+ inline_ IcePlane() { }
//! Constructor from a normal and a distance
- inline_ Plane(float nx, float ny, float nz, float d) { Set(nx, ny, nz, d); }
+ inline_ IcePlane(float nx, float ny, float nz, float d) { Set(nx, ny, nz, d); }
//! Constructor from a point on the plane and a normal
- inline_ Plane(const IcePoint& p, const IcePoint& n) { Set(p, n); }
+ inline_ IcePlane(const IcePoint& p, const IcePoint& n) { Set(p, n); }
//! Constructor from three points
- inline_ Plane(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2) { Set(p0, p1, p2); }
+ inline_ IcePlane(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2) { Set(p0, p1, p2); }
//! Constructor from a normal and a distance
- inline_ Plane(const IcePoint& _n, float _d) { n = _n; d = _d; }
+ inline_ IcePlane(const IcePoint& _n, float _d) { n = _n; d = _d; }
//! Copy constructor
- inline_ Plane(const Plane& plane) : n(plane.n), d(plane.d) { }
+ inline_ IcePlane(const IcePlane& plane) : n(plane.n), d(plane.d) { }
//! Destructor
- inline_ ~Plane() { }
+ inline_ ~IcePlane() { }
- inline_ Plane& Zero() { n.Zero(); d = 0.0f; return *this; }
- inline_ Plane& Set(float nx, float ny, float nz, float _d) { n.Set(nx, ny, nz); d = _d; return *this; }
- inline_ Plane& Set(const IcePoint& p, const IcePoint& _n) { n = _n; d = - p | _n; return *this; }
- Plane& Set(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2);
+ inline_ IcePlane& Zero() { n.Zero(); d = 0.0f; return *this; }
+ inline_ IcePlane& Set(float nx, float ny, float nz, float _d) { n.Set(nx, ny, nz); d = _d; return *this; }
+ inline_ IcePlane& Set(const IcePoint& p, const IcePoint& _n) { n = _n; d = - p | _n; return *this; }
+ IcePlane& Set(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2);
inline_ float Distance(const IcePoint& p) const { return (p | n) + d; }
inline_ bool Belongs(const IcePoint& p) const { return fabsf(Distance(p)) < PLANE_EPSILON; }
@@ -58,14 +58,14 @@ inline_ operator HPoint() const { return HPoint(n, d); }
// Arithmetic operators
- inline_ Plane operator*(const Matrix4x4& m) const
+ inline_ IcePlane operator*(const Matrix4x4& m) const
{
// Old code from Irion. Kept for reference.
- Plane Ret(*this);
+ IcePlane Ret(*this);
return Ret *= m;
}
- inline_ Plane& operator*=(const Matrix4x4& m)
+ inline_ IcePlane& operator*=(const Matrix4x4& m)
{
// Old code from Irion. Kept for reference.
IcePoint n2 = HPoint(n, 0.0f) * m;
@@ -77,14 +77,14 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
- * Transforms a plane by a 4x4 matrix. Same as Plane * Matrix4x4 operator, but faster.
+ * Transforms a plane by a 4x4 matrix. Same as IcePlane * Matrix4x4 operator, but faster.
* \param transformed [out] transformed plane
* \param plane [in] source plane
* \param transform [in] transform matrix
* \warning the plane normal must be unit-length
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void TransformPlane(Plane& transformed, const Plane& plane, const Matrix4x4& transform)
+ inline_ void TransformPlane(IcePlane& transformed, const IcePlane& plane, const Matrix4x4& transform)
{
// Rotate the normal using the rotation part of the 4x4 matrix
transformed.n = plane.n * Matrix3x3(transform);
@@ -95,13 +95,13 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
- * Transforms a plane by a 4x4 matrix. Same as Plane * Matrix4x4 operator, but faster.
+ * Transforms a plane by a 4x4 matrix. Same as IcePlane * Matrix4x4 operator, but faster.
* \param plane [in/out] source plane (transformed on return)
* \param transform [in] transform matrix
* \warning the plane normal must be unit-length
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void TransformPlane(Plane& plane, const Matrix4x4& transform)
+ inline_ void TransformPlane(IcePlane& plane, const Matrix4x4& transform)
{
// Rotate the normal using the rotation part of the 4x4 matrix
plane.n *= Matrix3x3(transform);
diff --git a/Opcode/Ice/IcePoint.cpp b/Opcode/Ice/IcePoint.cpp index 717fc53..8bf2d40 100644 --- a/Opcode/Ice/IcePoint.cpp +++ b/Opcode/Ice/IcePoint.cpp @@ -106,7 +106,7 @@ IcePoint& IcePoint::Refract(const IcePoint& eye, const IcePoint& n, float refrac return *this;
}
-IcePoint& IcePoint::ProjectToPlane(const Plane& p)
+IcePoint& IcePoint::ProjectToPlane(const IcePlane& p)
{
*this-= (p.d + (*this|p.n))*p.n;
return *this;
diff --git a/Opcode/Ice/IcePoint.h b/Opcode/Ice/IcePoint.h index 7f55a27..bb06684 100644 --- a/Opcode/Ice/IcePoint.h +++ b/Opcode/Ice/IcePoint.h @@ -14,7 +14,7 @@ // Forward declarations
class HPoint;
- class Plane;
+ class IcePlane;
class Matrix3x3;
class Matrix4x4;
@@ -371,13 +371,13 @@ IcePoint& Refract(const IcePoint& eye, const IcePoint& n, float refractindex, IcePoint& refracted);
//! Projects the IcePoint onto a plane
- IcePoint& ProjectToPlane(const Plane& p);
+ IcePoint& ProjectToPlane(const IcePlane& p);
//! Projects the IcePoint onto the screen
void ProjectToScreen(float halfrenderwidth, float halfrenderheight, const Matrix4x4& mat, HPoint& projected) const;
//! Unfolds the IcePoint onto a plane according to edge(a,b)
- IcePoint& Unfold(Plane& p, IcePoint& a, IcePoint& b);
+ IcePoint& Unfold(IcePlane& p, IcePoint& a, IcePoint& b);
//! Hash function from Ville Miettinen
inline_ udword GetHashValue() const
diff --git a/Opcode/Ice/IceSegment.cpp b/Opcode/Ice/IceSegment.cpp index f8d1553..0eede40 100644 --- a/Opcode/Ice/IceSegment.cpp +++ b/Opcode/Ice/IceSegment.cpp @@ -9,12 +9,12 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
- * Segment class.
+ * IceSegment class.
* A segment is defined by S(t) = mP0 * (1 - t) + mP1 * t, with 0 <= t <= 1
* Alternatively, a segment is S(t) = Origin + t * Direction for 0 <= t <= 1.
* Direction is not necessarily unit length. The end points are Origin = mP0 and Origin + Direction = mP1.
*
- * \class Segment
+ * \class IceSegment
* \author Pierre Terdiman
* \version 1.0
*/
@@ -26,7 +26,7 @@ using namespace IceMaths;
-float Segment::SquareDistance(const IcePoint& Point, float* t) const
+float IceSegment::SquareDistance(const IcePoint& Point, float* t) const
{
IcePoint Diff = Point - mP0;
IcePoint Dir = mP1 - mP0;
diff --git a/Opcode/Ice/IceSegment.h b/Opcode/Ice/IceSegment.h index e3ce8ab..d2b7f07 100644 --- a/Opcode/Ice/IceSegment.h +++ b/Opcode/Ice/IceSegment.h @@ -12,17 +12,17 @@ #ifndef __ICESEGMENT_H__
#define __ICESEGMENT_H__
- class ICEMATHS_API Segment
+ class ICEMATHS_API IceSegment
{
public:
//! Constructor
- inline_ Segment() {}
+ inline_ IceSegment() {}
//! Constructor
- inline_ Segment(const IcePoint& p0, const IcePoint& p1) : mP0(p0), mP1(p1) {}
+ inline_ IceSegment(const IcePoint& p0, const IcePoint& p1) : mP0(p0), mP1(p1) {}
//! Copy constructor
- inline_ Segment(const Segment& seg) : mP0(seg.mP0), mP1(seg.mP1) {}
+ inline_ IceSegment(const IceSegment& seg) : mP0(seg.mP0), mP1(seg.mP1) {}
//! Destructor
- inline_ ~Segment() {}
+ inline_ ~IceSegment() {}
inline_ const IcePoint& GetOrigin() const { return mP0; }
inline_ IcePoint ComputeDirection() const { return mP1 - mP0; }
diff --git a/Opcode/Ice/IceTriangle.cpp b/Opcode/Ice/IceTriangle.cpp index 69a858f..8a0a4b6 100644 --- a/Opcode/Ice/IceTriangle.cpp +++ b/Opcode/Ice/IceTriangle.cpp @@ -24,7 +24,7 @@ using namespace IceMaths; */
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static sdword VPlaneSideEps(const IcePoint& v, const Plane& plane, float epsilon)
+static sdword VPlaneSideEps(const IcePoint& v, const IcePlane& plane, float epsilon)
{
// Compute distance from current vertex to the plane
float Dist = plane.Distance(v);
@@ -132,7 +132,7 @@ void Triangle::Center(IcePoint& center) const center = (p0 + p1 + p2)*INV3;
}
-PartVal Triangle::TestAgainstPlane(const Plane& plane, float epsilon) const
+PartVal Triangle::TestAgainstPlane(const IcePlane& plane, float epsilon) const
{
bool Pos = false, Neg = false;
diff --git a/Opcode/Ice/IceTriangle.h b/Opcode/Ice/IceTriangle.h index 13eca37..c5c1fde 100644 --- a/Opcode/Ice/IceTriangle.h +++ b/Opcode/Ice/IceTriangle.h @@ -54,9 +54,9 @@ void Normal(IcePoint& normal) const;
void DenormalizedNormal(IcePoint& normal) const;
void Center(IcePoint& center) const;
- inline_ Plane PlaneEquation() const { return Plane(mVerts[0], mVerts[1], mVerts[2]); }
+ inline_ IcePlane PlaneEquation() const { return IcePlane(mVerts[0], mVerts[1], mVerts[2]); }
- PartVal TestAgainstPlane(const Plane& plane, float epsilon) const;
+ PartVal TestAgainstPlane(const IcePlane& plane, float epsilon) const;
// float Distance(Point& cp, Point& cq, Tri& tri);
void ComputeMoment(Moment& m);
float MinEdgeLength() const;
diff --git a/Opcode/Ice/IceUtils.h b/Opcode/Ice/IceUtils.h index 0e6161e..9c1e045 100644 --- a/Opcode/Ice/IceUtils.h +++ b/Opcode/Ice/IceUtils.h @@ -204,7 +204,7 @@ //! TO BE DOCUMENTED
#define OFFSET_OF(Class, Member) (size_t)&(((Class*)0)->Member)
//! TO BE DOCUMENTED
- #define ARRAYSIZE(p) (sizeof(p)/sizeof(p[0]))
+ #define ICEARRAYSIZE(p) (sizeof(p)/sizeof(p[0]))
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
diff --git a/Opcode/OPC_LSSAABBOverlap.h b/Opcode/OPC_LSSAABBOverlap.h index 0b03dbd..43a2da2 100644 --- a/Opcode/OPC_LSSAABBOverlap.h +++ b/Opcode/OPC_LSSAABBOverlap.h @@ -499,7 +499,7 @@ static float SqrDistance(const Ray& rkLine, const IcePoint& center, const IcePoi return fSqrDistance;
}
-inline_ float OPC_SegmentOBBSqrDist(const Segment& segment, const IcePoint& c0, const IcePoint& e0)
+inline_ float OPC_SegmentOBBSqrDist(const IceSegment& segment, const IcePoint& c0, const IcePoint& e0)
{
float fLP;
float fSqrDistance = SqrDistance(Ray(segment.GetOrigin(), segment.ComputeDirection()), c0, e0, &fLP);
diff --git a/Opcode/OPC_LSSCollider.h b/Opcode/OPC_LSSCollider.h index b5f07dc..a533419 100644 --- a/Opcode/OPC_LSSCollider.h +++ b/Opcode/OPC_LSSCollider.h @@ -64,7 +64,7 @@ bool Collide(LSSCache& cache, const LSS& lss, const AABBTree* tree);
protected:
// LSS in model space
- Segment mSeg; //!< Segment
+ IceSegment mSeg; //!< IceSegment
float mRadius2; //!< LSS radius squared
// Internal methods
void _Collide(const AABBCollisionNode* node);
diff --git a/Opcode/OPC_LSSTriOverlap.h b/Opcode/OPC_LSSTriOverlap.h index b60ab88..39c9df8 100644 --- a/Opcode/OPC_LSSTriOverlap.h +++ b/Opcode/OPC_LSSTriOverlap.h @@ -150,7 +150,7 @@ static float OPC_PointTriangleSqrDist(const IcePoint& Point, const IcePoint& p0, return fabsf(fSqrDist);
}
-static float OPC_SegmentSegmentSqrDist(const Segment& rkSeg0, const Segment& rkSeg1)
+static float OPC_SegmentSegmentSqrDist(const IceSegment& rkSeg0, const IceSegment& rkSeg1)
{
// Hook
IcePoint rkSeg0Direction = rkSeg0.ComputeDirection();
@@ -347,12 +347,12 @@ static float OPC_SegmentSegmentSqrDist(const Segment& rkSeg0, const Segment& rkS return fabsf(fSqrDist);
}
-inline_ float OPC_SegmentRaySqrDist(const Segment& rkSeg0, const Ray& rkSeg1)
+inline_ float OPC_SegmentRaySqrDist(const IceSegment& rkSeg0, const Ray& rkSeg1)
{
- return OPC_SegmentSegmentSqrDist(rkSeg0, Segment(rkSeg1.mOrig, rkSeg1.mOrig + rkSeg1.mDir));
+ return OPC_SegmentSegmentSqrDist(rkSeg0, IceSegment(rkSeg1.mOrig, rkSeg1.mOrig + rkSeg1.mDir));
}
-static float OPC_SegmentTriangleSqrDist(const Segment& segment, const IcePoint& p0, const IcePoint& p1, const IcePoint& p2)
+static float OPC_SegmentTriangleSqrDist(const IceSegment& segment, const IcePoint& p0, const IcePoint& p1, const IcePoint& p2)
{
// Hook
const IcePoint TriEdge0 = p1 - p0;
diff --git a/Opcode/OPC_MeshInterface.cpp b/Opcode/OPC_MeshInterface.cpp index e47451e..bfd7180 100644 --- a/Opcode/OPC_MeshInterface.cpp +++ b/Opcode/OPC_MeshInterface.cpp @@ -227,7 +227,7 @@ bool MeshInterface::SetCallback(RequestCallback callback, void* user_data) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool MeshInterface::SetPointers(const IndexedTriangle* tris, const IcePoint* verts)
{
- if(!tris || !verts) return SetIceError("MeshInterface::SetPointers: pointer is null", null);
+ if (!tris || !verts) return SetIceError; // ("MeshInterface::SetPointers: pointer is null", null);
mTris = tris;
mVerts = verts;
@@ -244,8 +244,8 @@ bool MeshInterface::SetPointers(const IndexedTriangle* tris, const IcePoint* ver ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool MeshInterface::SetStrides(udword tri_stride, udword vertex_stride)
{
- if(tri_stride<sizeof(IndexedTriangle)) return SetIceError("MeshInterface::SetStrides: invalid triangle stride", null);
- if(vertex_stride<sizeof(IcePoint)) return SetIceError("MeshInterface::SetStrides: invalid vertex stride", null);
+ if (tri_stride < sizeof(IndexedTriangle)) return SetIceError; // ("MeshInterface::SetStrides: invalid triangle stride", null);
+ if (vertex_stride < sizeof(IcePoint)) return SetIceError; // ("MeshInterface::SetStrides: invalid vertex stride", null);
mTriStride = tri_stride;
mVertexStride = vertex_stride;
diff --git a/Opcode/OPC_MeshInterface.h b/Opcode/OPC_MeshInterface.h index 7770b40..f14d536 100644 --- a/Opcode/OPC_MeshInterface.h +++ b/Opcode/OPC_MeshInterface.h @@ -142,7 +142,7 @@ * \return true if success
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool RemapClient(udword nb_indices, const udword* permutation) const;
+ bool RemapClient(udword nb_indices, const udword* permutation) const;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
diff --git a/Opcode/OPC_Model.cpp b/Opcode/OPC_Model.cpp index 0616c4d..b713dbb 100644 --- a/Opcode/OPC_Model.cpp +++ b/Opcode/OPC_Model.cpp @@ -142,7 +142,7 @@ bool Model::Build(const OPCODECREATE& create) if(!create.mIMesh || !create.mIMesh->IsValid()) return false;
// For this model, we only support complete trees
- if(create.mSettings.mLimit!=1) return SetIceError("OPCODE WARNING: supports complete trees only! Use mLimit = 1.\n", null);
+ if (create.mSettings.mLimit != 1) return SetIceError; // ("OPCODE WARNING: supports complete trees only! Use mLimit = 1.\n", null);
// Look for degenerate faces.
udword NbDegenerate = create.mIMesh->CheckTopology();
diff --git a/Opcode/OPC_PlanesAABBOverlap.h b/Opcode/OPC_PlanesAABBOverlap.h index 80b8bce..27d0055 100644 --- a/Opcode/OPC_PlanesAABBOverlap.h +++ b/Opcode/OPC_PlanesAABBOverlap.h @@ -16,7 +16,7 @@ inline_ BOOL PlanesCollider::PlanesAABBOverlap(const IcePoint& center, const Ice // Stats
mNbVolumeBVTests++;
- const Plane* p = mPlanes;
+ const IcePlane* p = mPlanes;
// Evaluate through all active frustum planes. We determine the relation
// between the AABB and a plane by using the concept of "near" and "far"
diff --git a/Opcode/OPC_PlanesCollider.cpp b/Opcode/OPC_PlanesCollider.cpp index b8ada6f..ef0088e 100644 --- a/Opcode/OPC_PlanesCollider.cpp +++ b/Opcode/OPC_PlanesCollider.cpp @@ -100,7 +100,7 @@ const char* PlanesCollider::ValidateSettings() * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool PlanesCollider::Collide(PlanesCache& cache, const Plane* planes, udword nb_planes, const Model& model, const Matrix4x4* worldm)
+bool PlanesCollider::Collide(PlanesCache& cache, const IcePlane* planes, udword nb_planes, const Model& model, const Matrix4x4* worldm)
{
// Checkings
if(!Setup(&model)) return false;
@@ -174,7 +174,7 @@ bool PlanesCollider::Collide(PlanesCache& cache, const Plane* planes, udword nb_ * \warning SCALE NOT SUPPORTED. The matrix must contain rotation & translation parts only.
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BOOL PlanesCollider::InitQuery(PlanesCache& cache, const Plane* planes, udword nb_planes, const Matrix4x4* worldm)
+BOOL PlanesCollider::InitQuery(PlanesCache& cache, const IcePlane* planes, udword nb_planes, const Matrix4x4* worldm)
{
// 1) Call the base method
VolumeCollider::InitQuery();
@@ -183,7 +183,7 @@ BOOL PlanesCollider::InitQuery(PlanesCache& cache, const Plane* planes, udword n if(nb_planes>mNbPlanes)
{
DELETEARRAY(mPlanes);
- mPlanes = new Plane[nb_planes];
+ mPlanes = new IcePlane[nb_planes];
}
mNbPlanes = nb_planes;
@@ -195,7 +195,7 @@ BOOL PlanesCollider::InitQuery(PlanesCache& cache, const Plane* planes, udword n // for(udword i=0;i<nb_planes;i++) mPlanes[i] = planes[i] * InvWorldM;
for(udword i=0;i<nb_planes;i++) TransformPlane(mPlanes[i], planes[i], InvWorldM);
}
- else CopyMemory(mPlanes, planes, nb_planes*sizeof(Plane));
+ else CopyMemory(mPlanes, planes, nb_planes*sizeof(IcePlane));
// 3) Setup destination pointer
mTouchedPrimitives = &cache.TouchedPrimitives;
@@ -523,7 +523,7 @@ HybridPlanesCollider::~HybridPlanesCollider() {
}
-bool HybridPlanesCollider::Collide(PlanesCache& cache, const Plane* planes, udword nb_planes, const HybridModel& model, const Matrix4x4* worldm)
+bool HybridPlanesCollider::Collide(PlanesCache& cache, const IcePlane* planes, udword nb_planes, const HybridModel& model, const Matrix4x4* worldm)
{
// We don't want primitive tests here!
mFlags |= OPC_NO_PRIMITIVE_TESTS;
diff --git a/Opcode/OPC_PlanesCollider.h b/Opcode/OPC_PlanesCollider.h index 5fea18d..5a0af9f 100644 --- a/Opcode/OPC_PlanesCollider.h +++ b/Opcode/OPC_PlanesCollider.h @@ -50,12 +50,12 @@ * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool Collide(PlanesCache& cache, const Plane* planes, udword nb_planes, const Model& model, const Matrix4x4* worldm=null);
+ bool Collide(PlanesCache& cache, const IcePlane* planes, udword nb_planes, const Model& model, const Matrix4x4* worldm=null);
// Mutant box-with-planes collision queries
inline_ bool Collide(PlanesCache& cache, const OBB& box, const Model& model, const Matrix4x4* worldb=null, const Matrix4x4* worldm=null)
{
- Plane PL[6];
+ IcePlane PL[6];
if(worldb)
{
@@ -87,7 +87,7 @@ protected:
// Planes in model space
udword mNbPlanes;
- Plane* mPlanes;
+ IcePlane* mPlanes;
// Leaf description
VertexPointers mVP;
// Internal methods
@@ -103,7 +103,7 @@ inline_ BOOL PlanesAABBOverlap(const IcePoint& center, const IcePoint& extents, udword& out_clip_mask, udword in_clip_mask);
inline_ BOOL PlanesTriOverlap(udword in_clip_mask);
// Init methods
- BOOL InitQuery(PlanesCache& cache, const Plane* planes, udword nb_planes, const Matrix4x4* worldm=null);
+ BOOL InitQuery(PlanesCache& cache, const IcePlane* planes, udword nb_planes, const Matrix4x4* worldm=null);
};
class OPCODE_API HybridPlanesCollider : public PlanesCollider
@@ -113,7 +113,7 @@ HybridPlanesCollider();
virtual ~HybridPlanesCollider();
- bool Collide(PlanesCache& cache, const Plane* planes, udword nb_planes, const HybridModel& model, const Matrix4x4* worldm=null);
+ bool Collide(PlanesCache& cache, const IcePlane* planes, udword nb_planes, const HybridModel& model, const Matrix4x4* worldm=null);
protected:
Container mTouchedBoxes;
};
diff --git a/Opcode/OPC_PlanesTriOverlap.h b/Opcode/OPC_PlanesTriOverlap.h index 7667cbc..cdd6ff8 100644 --- a/Opcode/OPC_PlanesTriOverlap.h +++ b/Opcode/OPC_PlanesTriOverlap.h @@ -11,7 +11,7 @@ inline_ BOOL PlanesCollider::PlanesTriOverlap(udword in_clip_mask) // Stats
mNbVolumePrimTests++;
- const Plane* p = mPlanes;
+ const IcePlane* p = mPlanes;
udword Mask = 1;
while(Mask<=in_clip_mask)
diff --git a/Opcode/OPC_RayAABBOverlap.h b/Opcode/OPC_RayAABBOverlap.h index b64661f..f9f6834 100644 --- a/Opcode/OPC_RayAABBOverlap.h +++ b/Opcode/OPC_RayAABBOverlap.h @@ -6,7 +6,7 @@ ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
- * Computes a segment-AABB overlap test using the separating axis theorem. Segment is cached within the class.
+ * Computes a segment-AABB overlap test using the separating axis theorem. IceSegment is cached within the class.
* \param center [in] AABB center
* \param extents [in] AABB extents
* \return true on overlap
diff --git a/Opcode/OPC_RayCollider.cpp b/Opcode/OPC_RayCollider.cpp index 875ae12..c0389f6 100644 --- a/Opcode/OPC_RayCollider.cpp +++ b/Opcode/OPC_RayCollider.cpp @@ -412,7 +412,7 @@ BOOL RayCollider::InitQuery(const Ray& world_ray, const Matrix4x4* world, udword }
#else
// New code
- // We handle both Segment/ray queries with the same segment code, and a possible infinite limit
+ // We handle both IceSegment/ray queries with the same segment code, and a possible infinite limit
SEGMENT_PRIM(*face_id, OPC_TEMPORAL_CONTACT)
// Return immediately if possible
@@ -423,7 +423,7 @@ BOOL RayCollider::InitQuery(const Ray& world_ray, const Matrix4x4* world, udword // Precompute data (moved after temporal coherence since only needed for ray-AABB)
if(IR(mMaxDist)!=IEEE_MAX_FLOAT)
{
- // For Segment-AABB overlap
+ // For IceSegment-AABB overlap
mData = 0.5f * mDir * mMaxDist;
mData2 = mOrigin + mData;
@@ -492,7 +492,7 @@ bool RayCollider::Collide(const Ray& world_ray, const AABBTree* tree, Container& ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RayCollider::_SegmentStab(const AABBCollisionNode* node)
{
- // Perform Segment-AABB overlap test
+ // Perform IceSegment-AABB overlap test
if(!SegmentAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents)) return;
if(node->IsLeaf())
@@ -522,7 +522,7 @@ void RayCollider::_SegmentStab(const AABBQuantizedNode* node) const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
- // Perform Segment-AABB overlap test
+ // Perform IceSegment-AABB overlap test
if(!SegmentAABBOverlap(Center, Extents)) return;
if(node->IsLeaf())
@@ -547,7 +547,7 @@ void RayCollider::_SegmentStab(const AABBQuantizedNode* node) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RayCollider::_SegmentStab(const AABBNoLeafNode* node)
{
- // Perform Segment-AABB overlap test
+ // Perform IceSegment-AABB overlap test
if(!SegmentAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents)) return;
if(node->HasPosLeaf())
@@ -578,7 +578,7 @@ void RayCollider::_SegmentStab(const AABBQuantizedNoLeafNode* node) const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
- // Perform Segment-AABB overlap test
+ // Perform IceSegment-AABB overlap test
if(!SegmentAABBOverlap(Center, Extents)) return;
if(node->HasPosLeaf())
diff --git a/Opcode/OPC_TriTriOverlap.h b/Opcode/OPC_TriTriOverlap.h index ccc8161..1789566 100644 --- a/Opcode/OPC_TriTriOverlap.h +++ b/Opcode/OPC_TriTriOverlap.h @@ -11,7 +11,7 @@ b=c; \
}
-//! Edge to edge test based on Franlin Antonio's gem: "Faster Line Segment Intersection", in Graphics Gems III, pp. 199-202
+//! Edge to edge test based on Franlin Antonio's gem: "Faster Line IceSegment Intersection", in Graphics Gems III, pp. 199-202
#define EDGE_EDGE_TEST(V0, U0, U1) \
Bx = U0[i0] - U1[i0]; \
By = U0[i1] - U1[i1]; \
@@ -186,7 +186,7 @@ inline_ BOOL AABBTreeCollider::TriTriOverlap(const IcePoint& V0, const IcePoint& IcePoint E2 = V2 - V0;
const IcePoint N1 = E1 ^ E2;
const float d1 =-N1 | V0;
- // Plane equation 1: N1.X+d1=0
+ // IcePlane equation 1: N1.X+d1=0
// Put U0,U1,U2 into plane equation 1 to compute signed distances to the plane
float du0 = (N1|U0) + d1;
diff --git a/Opcode/Opcode.h b/Opcode/Opcode.h index ca29a91..33b0c5c 100644 --- a/Opcode/Opcode.h +++ b/Opcode/Opcode.h @@ -21,32 +21,11 @@ #define __OPCODE_H__
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Compilation messages
-#if defined(OPCODE_EXPORTS)
- #pragma message("Compiling OPCODE")
-#elif !defined(OPCODE_EXPORTS)
- #pragma message("Using OPCODE")
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- // Automatic linking
- #ifndef BAN_OPCODE_AUTOLINK
- #ifdef _DEBUG
- #pragma comment(lib, "Opcode_D.lib")
- #else
- #pragma comment(lib, "Opcode.lib")
- #endif
- #endif
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Preprocessor
-#ifndef ICE_NO_DLL
- #ifdef OPCODE_EXPORTS
- #define OPCODE_API __declspec(dllexport)
- #else
- #define OPCODE_API __declspec(dllimport)
- #endif
+#ifdef OPCODE_EXPORTS
+ #define OPCODE_API __declspec(dllexport)
#else
- #define OPCODE_API
+ #define OPCODE_API __declspec(dllimport)
#endif
#include "OPC_IceHook.h"
diff --git a/Opcode/OpcodeLib/Ice/IceAABB.cpp b/Opcode/OpcodeLib/Ice/IceAABB.cpp deleted file mode 100644 index 2e3288b..0000000 --- a/Opcode/OpcodeLib/Ice/IceAABB.cpp +++ /dev/null @@ -1,405 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains AABB-related code.
- * \file IceAABB.cpp
- * \author Pierre Terdiman
- * \date January, 29, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * AABB class.
- * \class AABB
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the sum of two AABBs.
- * \param aabb [in] the other AABB
- * \return Self-Reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABB& AABB::Add(const AABB& aabb)
-{
- // Compute new min & max values
- IcePoint Min; GetMin(Min);
- IcePoint Tmp; aabb.GetMin(Tmp);
- Min.Min(Tmp);
-
- IcePoint Max; GetMax(Max);
- aabb.GetMax(Tmp);
- Max.Max(Tmp);
-
- // Update this
- SetMinMax(Min, Max);
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Makes a cube from the AABB.
- * \param cube [out] the cube AABB
- * \return cube edge length
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABB::MakeCube(AABB& cube) const
-{
- IcePoint Ext; GetExtents(Ext);
- float Max = Ext.Max();
-
- IcePoint Cnt; GetCenter(Cnt);
- cube.SetCenterExtents(Cnt, IcePoint(Max, Max, Max));
- return Max;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Makes a sphere from the AABB.
- * \param sphere [out] sphere containing the AABB
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABB::MakeSphere(Sphere& sphere) const
-{
- GetExtents(sphere.mCenter);
- sphere.mRadius = sphere.mCenter.Magnitude() * 1.00001f; // To make sure sphere::Contains(*this) succeeds
- GetCenter(sphere.mCenter);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks a box is inside another box.
- * \param box [in] the other AABB
- * \return true if current box is inside input box
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::IsInside(const AABB& box) const
-{
- if(box.GetMin(0)>GetMin(0)) return false;
- if(box.GetMin(1)>GetMin(1)) return false;
- if(box.GetMin(2)>GetMin(2)) return false;
- if(box.GetMax(0)<GetMax(0)) return false;
- if(box.GetMax(1)<GetMax(1)) return false;
- if(box.GetMax(2)<GetMax(2)) return false;
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the AABB planes.
- * \param planes [out] 6 planes surrounding the box
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::ComputePlanes(IcePlane* planes) const
-{
- // Checkings
- if(!planes) return false;
-
- IcePoint Center, Extents;
- GetCenter(Center);
- GetExtents(Extents);
-
- // Writes normals
- planes[0].n = IcePoint(1.0f, 0.0f, 0.0f);
- planes[1].n = IcePoint(-1.0f, 0.0f, 0.0f);
- planes[2].n = IcePoint(0.0f, 1.0f, 0.0f);
- planes[3].n = IcePoint(0.0f, -1.0f, 0.0f);
- planes[4].n = IcePoint(0.0f, 0.0f, 1.0f);
- planes[5].n = IcePoint(0.0f, 0.0f, -1.0f);
-
- // Compute a point on each plane
- IcePoint p0 = IcePoint(Center.x+Extents.x, Center.y, Center.z);
- IcePoint p1 = IcePoint(Center.x-Extents.x, Center.y, Center.z);
- IcePoint p2 = IcePoint(Center.x, Center.y+Extents.y, Center.z);
- IcePoint p3 = IcePoint(Center.x, Center.y-Extents.y, Center.z);
- IcePoint p4 = IcePoint(Center.x, Center.y, Center.z+Extents.z);
- IcePoint p5 = IcePoint(Center.x, Center.y, Center.z-Extents.z);
-
- // Compute d
- planes[0].d = -(planes[0].n|p0);
- planes[1].d = -(planes[1].n|p1);
- planes[2].d = -(planes[2].n|p2);
- planes[3].d = -(planes[3].n|p3);
- planes[4].d = -(planes[4].n|p4);
- planes[5].d = -(planes[5].n|p5);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the aabb points.
- * \param pts [out] 8 box points
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABB::ComputePoints(IcePoint* pts) const
-{
- // Checkings
- if(!pts) return false;
-
- // Get box corners
- IcePoint min; GetMin(min);
- IcePoint max; GetMax(max);
-
- // 7+------+6 0 = ---
- // /| /| 1 = +--
- // / | / | 2 = ++-
- // / 4+---/--+5 3 = -+-
- // 3+------+2 / y z 4 = --+
- // | / | / | / 5 = +-+
- // |/ |/ |/ 6 = +++
- // 0+------+1 *---x 7 = -++
-
- // Generate 8 corners of the bbox
- pts[0] = IcePoint(min.x, min.y, min.z);
- pts[1] = IcePoint(max.x, min.y, min.z);
- pts[2] = IcePoint(max.x, max.y, min.z);
- pts[3] = IcePoint(min.x, max.y, min.z);
- pts[4] = IcePoint(min.x, min.y, max.z);
- pts[5] = IcePoint(max.x, min.y, max.z);
- pts[6] = IcePoint(max.x, max.y, max.z);
- pts[7] = IcePoint(min.x, max.y, max.z);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets vertex normals.
- * \param pts [out] 8 box points
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const IcePoint* AABB::GetVertexNormals() const
-{
- static float VertexNormals[] =
- {
- -INVSQRT3, -INVSQRT3, -INVSQRT3,
- INVSQRT3, -INVSQRT3, -INVSQRT3,
- INVSQRT3, INVSQRT3, -INVSQRT3,
- -INVSQRT3, INVSQRT3, -INVSQRT3,
- -INVSQRT3, -INVSQRT3, INVSQRT3,
- INVSQRT3, -INVSQRT3, INVSQRT3,
- INVSQRT3, INVSQRT3, INVSQRT3,
- -INVSQRT3, INVSQRT3, INVSQRT3
- };
- return (const IcePoint*)VertexNormals;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns edges.
- * \return 24 indices (12 edges) indexing the list returned by ComputePoints()
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const udword* AABB::GetEdges() const
-{
- static udword Indices[] = {
- 0, 1, 1, 2, 2, 3, 3, 0,
- 7, 6, 6, 5, 5, 4, 4, 7,
- 1, 5, 6, 2,
- 3, 7, 4, 0
- };
- return Indices;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns edge normals.
- * \return edge normals in local space
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const IcePoint* AABB::GetEdgeNormals() const
-{
- static float EdgeNormals[] =
- {
- 0, -INVSQRT2, -INVSQRT2, // 0-1
- INVSQRT2, 0, -INVSQRT2, // 1-2
- 0, INVSQRT2, -INVSQRT2, // 2-3
- -INVSQRT2, 0, -INVSQRT2, // 3-0
-
- 0, INVSQRT2, INVSQRT2, // 7-6
- INVSQRT2, 0, INVSQRT2, // 6-5
- 0, -INVSQRT2, INVSQRT2, // 5-4
- -INVSQRT2, 0, INVSQRT2, // 4-7
-
- INVSQRT2, -INVSQRT2, 0, // 1-5
- INVSQRT2, INVSQRT2, 0, // 6-2
- -INVSQRT2, INVSQRT2, 0, // 3-7
- -INVSQRT2, -INVSQRT2, 0 // 4-0
- };
- return (const IcePoint*)EdgeNormals;
-}
-
-// ===========================================================================
-// (C) 1996-98 Vienna University of Technology
-// ===========================================================================
-// NAME: bboxarea
-// TYPE: c++ code
-// PROJECT: Bounding Box Area
-// CONTENT: Computes area of 2D projection of 3D oriented bounding box
-// VERSION: 1.0
-// ===========================================================================
-// AUTHORS: ds Dieter Schmalstieg
-// ep Erik Pojar
-// ===========================================================================
-// HISTORY:
-//
-// 19-sep-99 15:23:03 ds last modification
-// 01-dec-98 15:23:03 ep created
-// ===========================================================================
-
-//----------------------------------------------------------------------------
-// SAMPLE CODE STARTS HERE
-//----------------------------------------------------------------------------
-
-// NOTE: This sample program requires OPEN INVENTOR!
-
-//indexlist: this table stores the 64 possible cases of classification of
-//the eyepoint with respect to the 6 defining planes of the bbox (2^6=64)
-//only 26 (3^3-1, where 1 is "inside" cube) of these cases are valid.
-//the first 6 numbers in each row are the indices of the bbox vertices that
-//form the outline of which we want to compute the area (counterclockwise
-//ordering), the 7th entry means the number of vertices in the outline.
-//there are 6 cases with a single face and and a 4-vertex outline, and
-//20 cases with 2 or 3 faces and a 6-vertex outline. a value of 0 indicates
-//an invalid case.
-
-
-// Original list was made of 7 items, I added an 8th element:
-// - to padd on a cache line
-// - to repeat the first entry to avoid modulos
-//
-// I also replaced original ints with sbytes.
-
-static const sbyte gIndexList[64][8] =
-{
- {-1,-1,-1,-1,-1,-1,-1, 0}, // 0 inside
- { 0, 4, 7, 3, 0,-1,-1, 4}, // 1 left
- { 1, 2, 6, 5, 1,-1,-1, 4}, // 2 right
- {-1,-1,-1,-1,-1,-1,-1, 0}, // 3 -
- { 0, 1, 5, 4, 0,-1,-1, 4}, // 4 bottom
- { 0, 1, 5, 4, 7, 3, 0, 6}, // 5 bottom, left
- { 0, 1, 2, 6, 5, 4, 0, 6}, // 6 bottom, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, // 7 -
- { 2, 3, 7, 6, 2,-1,-1, 4}, // 8 top
- { 0, 4, 7, 6, 2, 3, 0, 6}, // 9 top, left
- { 1, 2, 3, 7, 6, 5, 1, 6}, //10 top, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //11 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //12 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //13 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //14 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //15 -
- { 0, 3, 2, 1, 0,-1,-1, 4}, //16 front
- { 0, 4, 7, 3, 2, 1, 0, 6}, //17 front, left
- { 0, 3, 2, 6, 5, 1, 0, 6}, //18 front, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //19 -
- { 0, 3, 2, 1, 5, 4, 0, 6}, //20 front, bottom
- { 1, 5, 4, 7, 3, 2, 1, 6}, //21 front, bottom, left
- { 0, 3, 2, 6, 5, 4, 0, 6}, //22 front, bottom, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //23 -
- { 0, 3, 7, 6, 2, 1, 0, 6}, //24 front, top
- { 0, 4, 7, 6, 2, 1, 0, 6}, //25 front, top, left
- { 0, 3, 7, 6, 5, 1, 0, 6}, //26 front, top, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //27 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //28 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //29 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //30 -
- {-1,-1,-1,-1,-1,-1,-1, 0}, //31 -
- { 4, 5, 6, 7, 4,-1,-1, 4}, //32 back
- { 0, 4, 5, 6, 7, 3, 0, 6}, //33 back, left
- { 1, 2, 6, 7, 4, 5, 1, 6}, //34 back, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //35 -
- { 0, 1, 5, 6, 7, 4, 0, 6}, //36 back, bottom
- { 0, 1, 5, 6, 7, 3, 0, 6}, //37 back, bottom, left
- { 0, 1, 2, 6, 7, 4, 0, 6}, //38 back, bottom, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //39 -
- { 2, 3, 7, 4, 5, 6, 2, 6}, //40 back, top
- { 0, 4, 5, 6, 2, 3, 0, 6}, //41 back, top, left
- { 1, 2, 3, 7, 4, 5, 1, 6}, //42 back, top, right
- {-1,-1,-1,-1,-1,-1,-1, 0}, //43 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //44 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //45 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //46 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //47 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //48 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //49 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //50 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //51 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //52 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //53 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //54 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //55 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //56 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //57 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //58 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //59 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //60 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //61 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0}, //62 invalid
- {-1,-1,-1,-1,-1,-1,-1, 0} //63 invalid
-};
-
-const sbyte* AABB::ComputeOutline(const IcePoint& local_eye, sdword& num) const
-{
- // Get box corners
- IcePoint min; GetMin(min);
- IcePoint max; GetMax(max);
-
- // Compute 6-bit code to classify eye with respect to the 6 defining planes of the bbox
- int pos = ((local_eye.x < min.x) ? 1 : 0) // 1 = left
- + ((local_eye.x > max.x) ? 2 : 0) // 2 = right
- + ((local_eye.y < min.y) ? 4 : 0) // 4 = bottom
- + ((local_eye.y > max.y) ? 8 : 0) // 8 = top
- + ((local_eye.z < min.z) ? 16 : 0) // 16 = front
- + ((local_eye.z > max.z) ? 32 : 0); // 32 = back
-
- // Look up number of vertices in outline
- num = (sdword)gIndexList[pos][7];
- // Zero indicates invalid case
- if(!num) return null;
-
- return &gIndexList[pos][0];
-}
-
-// calculateBoxArea: computes the screen-projected 2D area of an oriented 3D bounding box
-
-//const IcePoint& eye, //eye point (in bbox object coordinates)
-//const AABB& box, //3d bbox
-//const Matrix4x4& mat, //free transformation for bbox
-//float width, float height, int& num)
-float AABB::ComputeBoxArea(const IcePoint& eye, const Matrix4x4& mat, float width, float height, sdword& num) const
-{
- const sbyte* Outline = ComputeOutline(eye, num);
- if(!Outline) return -1.0f;
-
- // Compute box vertices
- IcePoint vertexBox[8], dst[8];
- ComputePoints(vertexBox);
-
- // Transform all outline corners into 2D screen space
- for(sdword i=0;i<num;i++)
- {
- HPoint Projected;
- vertexBox[Outline[i]].ProjectToScreen(width, height, mat, Projected);
- dst[i] = Projected;
- }
-
- float Sum = (dst[num-1][0] - dst[0][0]) * (dst[num-1][1] + dst[0][1]);
-
- for(int i=0; i<num-1; i++)
- Sum += (dst[i][0] - dst[i+1][0]) * (dst[i][1] + dst[i+1][1]);
-
- return Sum * 0.5f; //return computed value corrected by 0.5
-}
diff --git a/Opcode/OpcodeLib/Ice/IceAABB.h b/Opcode/OpcodeLib/Ice/IceAABB.h deleted file mode 100644 index caf8a80..0000000 --- a/Opcode/OpcodeLib/Ice/IceAABB.h +++ /dev/null @@ -1,505 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains AABB-related code. (axis-aligned bounding box)
- * \file IceAABB.h
- * \author Pierre Terdiman
- * \date January, 13, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEAABB_H__
-#define __ICEAABB_H__
-
- // Forward declarations
- class Sphere;
-
-//! Declarations of type-independent methods (most of them implemented in the .cpp)
-#define AABB_COMMON_METHODS \
- AABB& Add(const AABB& aabb); \
- float MakeCube(AABB& cube) const; \
- void MakeSphere(Sphere& sphere) const; \
- const sbyte* ComputeOutline(const IcePoint& local_eye, sdword& num) const; \
- float ComputeBoxArea(const IcePoint& eye, const Matrix4x4& mat, float width, float height, sdword& num) const; \
- bool IsInside(const AABB& box) const; \
- bool ComputePlanes(IcePlane* planes) const; \
- bool ComputePoints(IcePoint* pts) const; \
- const IcePoint* GetVertexNormals() const; \
- const udword* GetEdges() const; \
- const IcePoint* GetEdgeNormals() const; \
- inline_ BOOL ContainsPoint(const IcePoint& p) const \
- { \
- if(p.x > GetMax(0) || p.x < GetMin(0)) return FALSE; \
- if(p.y > GetMax(1) || p.y < GetMin(1)) return FALSE; \
- if(p.z > GetMax(2) || p.z < GetMin(2)) return FALSE; \
- return TRUE; \
- }
-
- enum AABBType
- {
- AABB_RENDER = 0, //!< AABB used for rendering. Not visible == not rendered.
- AABB_UPDATE = 1, //!< AABB used for dynamic updates. Not visible == not updated.
-
- AABB_FORCE_DWORD = 0x7fffffff,
- };
-
-#ifdef USE_MINMAX
-
- struct ICEMATHS_API ShadowAABB
- {
- IcePoint mMin;
- IcePoint mMax;
- };
-
- class ICEMATHS_API AABB
- {
- public:
- //! Constructor
- inline_ AABB() {}
- //! Destructor
- inline_ ~AABB() {}
-
- //! Type-independent methods
- AABB_COMMON_METHODS;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an AABB from min & max vectors.
- * \param min [in] the min point
- * \param max [in] the max point
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetMinMax(const IcePoint& min, const IcePoint& max) { mMin = min; mMax = max; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an AABB from center & extents vectors.
- * \param c [in] the center point
- * \param e [in] the extents vector
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetCenterExtents(const IcePoint& c, const IcePoint& e) { mMin = c - e; mMax = c + e; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an empty AABB.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetEmpty() { IcePoint p(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT); mMin = -p; mMax = p;}
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups a point AABB.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetPoint(const IcePoint& pt) { mMin = mMax = pt; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the size of the AABB. The size is defined as the longest extent.
- * \return the size of the AABB
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- float GetSize() const { IcePoint e; GetExtents(e); return e.Max(); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Extends the AABB.
- * \param p [in] the next point
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void Extend(const IcePoint& p)
- {
- if(p.x > mMax.x) mMax.x = p.x;
- if(p.x < mMin.x) mMin.x = p.x;
-
- if(p.y > mMax.y) mMax.y = p.y;
- if(p.y < mMin.y) mMin.y = p.y;
-
- if(p.z > mMax.z) mMax.z = p.z;
- if(p.z < mMin.z) mMin.z = p.z;
- }
- // Data access
-
- //! Get min point of the box
- inline_ void GetMin(IcePoint& min) const { min = mMin; }
- //! Get max point of the box
- inline_ void GetMax(IcePoint& max) const { max = mMax; }
-
- //! Get component of the box's min point along a given axis
- inline_ float GetMin(udword axis) const { return mMin[axis]; }
- //! Get component of the box's max point along a given axis
- inline_ float GetMax(udword axis) const { return mMax[axis]; }
-
- //! Get box center
- inline_ void GetCenter(IcePoint& center) const { center = (mMax + mMin)*0.5f; }
- //! Get box extents
- inline_ void GetExtents(IcePoint& extents) const { extents = (mMax - mMin)*0.5f; }
-
- //! Get component of the box's center along a given axis
- inline_ float GetCenter(udword axis) const { return (mMax[axis] + mMin[axis])*0.5f; }
- //! Get component of the box's extents along a given axis
- inline_ float GetExtents(udword axis) const { return (mMax[axis] - mMin[axis])*0.5f; }
-
- //! Get box diagonal
- inline_ void GetDiagonal(IcePoint& diagonal) const { diagonal = mMax - mMin; }
- inline_ float GetWidth() const { return mMax.x - mMin.x; }
- inline_ float GetHeight() const { return mMax.y - mMin.y; }
- inline_ float GetDepth() const { return mMax.z - mMin.z; }
-
- //! Volume
- inline_ float GetVolume() const { return GetWidth() * GetHeight() * GetDepth(); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the intersection between two AABBs.
- * \param a [in] the other AABB
- * \return true on intersection
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL Intersect(const AABB& a) const
- {
- if(mMax.x < a.mMin.x
- || a.mMax.x < mMin.x
- || mMax.y < a.mMin.y
- || a.mMax.y < mMin.y
- || mMax.z < a.mMin.z
- || a.mMax.z < mMin.z) return FALSE;
-
- return TRUE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the 1D-intersection between two AABBs, on a given axis.
- * \param a [in] the other AABB
- * \param axis [in] the axis (0, 1, 2)
- * \return true on intersection
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL Intersect(const AABB& a, udword axis) const
- {
- if(mMax[axis] < a.mMin[axis] || a.mMax[axis] < mMin[axis]) return FALSE;
- return TRUE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Recomputes the AABB after an arbitrary transform by a 4x4 matrix.
- * Original code by Charles Bloom on the GD-Algorithm list. (I slightly modified it)
- * \param mtx [in] the transform matrix
- * \param aabb [out] the transformed AABB [can be *this]
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void Rotate(const Matrix4x4& mtx, AABB& aabb) const
- {
- // The three edges transformed: you can efficiently transform an X-only vector
- // by just getting the "X" column of the matrix
- IcePoint vx,vy,vz;
- mtx.GetRow(0, vx); vx *= (mMax.x - mMin.x);
- mtx.GetRow(1, vy); vy *= (mMax.y - mMin.y);
- mtx.GetRow(2, vz); vz *= (mMax.z - mMin.z);
-
- // Transform the min point
- aabb.mMin = aabb.mMax = mMin * mtx;
-
- // Take the transformed min & axes and find new extents
- // Using CPU code in the right place is faster...
- if(IS_NEGATIVE_FLOAT(vx.x)) aabb.mMin.x += vx.x; else aabb.mMax.x += vx.x;
- if(IS_NEGATIVE_FLOAT(vx.y)) aabb.mMin.y += vx.y; else aabb.mMax.y += vx.y;
- if(IS_NEGATIVE_FLOAT(vx.z)) aabb.mMin.z += vx.z; else aabb.mMax.z += vx.z;
- if(IS_NEGATIVE_FLOAT(vy.x)) aabb.mMin.x += vy.x; else aabb.mMax.x += vy.x;
- if(IS_NEGATIVE_FLOAT(vy.y)) aabb.mMin.y += vy.y; else aabb.mMax.y += vy.y;
- if(IS_NEGATIVE_FLOAT(vy.z)) aabb.mMin.z += vy.z; else aabb.mMax.z += vy.z;
- if(IS_NEGATIVE_FLOAT(vz.x)) aabb.mMin.x += vz.x; else aabb.mMax.x += vz.x;
- if(IS_NEGATIVE_FLOAT(vz.y)) aabb.mMin.y += vz.y; else aabb.mMax.y += vz.y;
- if(IS_NEGATIVE_FLOAT(vz.z)) aabb.mMin.z += vz.z; else aabb.mMax.z += vz.z;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the AABB is valid.
- * \return true if the box is valid
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL IsValid() const
- {
- // Consistency condition for (Min, Max) boxes: min < max
- if(mMin.x > mMax.x) return FALSE;
- if(mMin.y > mMax.y) return FALSE;
- if(mMin.z > mMax.z) return FALSE;
- return TRUE;
- }
-
- //! Operator for AABB *= float. Scales the extents, keeps same center.
- inline_ AABB& operator*=(float s)
- {
- IcePoint Center; GetCenter(Center);
- IcePoint Extents; GetExtents(Extents);
- SetCenterExtents(Center, Extents * s);
- return *this;
- }
-
- //! Operator for AABB /= float. Scales the extents, keeps same center.
- inline_ AABB& operator/=(float s)
- {
- IcePoint Center; GetCenter(Center);
- IcePoint Extents; GetExtents(Extents);
- SetCenterExtents(Center, Extents / s);
- return *this;
- }
-
- //! Operator for AABB += IcePoint. Translates the box.
- inline_ AABB& operator+=(const IcePoint& trans)
- {
- mMin+=trans;
- mMax+=trans;
- return *this;
- }
- private:
- IcePoint mMin; //!< Min point
- IcePoint mMax; //!< Max point
- };
-
-#else
-
- class ICEMATHS_API AABB
- {
- public:
- //! Constructor
- inline_ AABB() {}
- //! Destructor
- inline_ ~AABB() {}
-
- //! Type-independent methods
- AABB_COMMON_METHODS;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an AABB from min & max vectors.
- * \param min [in] the min point
- * \param max [in] the max point
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetMinMax(const IcePoint& min, const IcePoint& max) { mCenter = (max + min)*0.5f; mExtents = (max - min)*0.5f; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an AABB from center & extents vectors.
- * \param c [in] the center point
- * \param e [in] the extents vector
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetCenterExtents(const IcePoint& c, const IcePoint& e) { mCenter = c; mExtents = e; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an empty AABB.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetEmpty() { mCenter.Zero(); mExtents.Set(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);}
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups a point AABB.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetPoint(const IcePoint& pt) { mCenter = pt; mExtents.Zero(); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the size of the AABB. The size is defined as the longest extent.
- * \return the size of the AABB
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- float GetSize() const { return mExtents.Max(); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Extends the AABB.
- * \param p [in] the next point
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void Extend(const IcePoint& p)
- {
- IcePoint Max = mCenter + mExtents;
- IcePoint Min = mCenter - mExtents;
-
- if(p.x > Max.x) Max.x = p.x;
- if(p.x < Min.x) Min.x = p.x;
-
- if(p.y > Max.y) Max.y = p.y;
- if(p.y < Min.y) Min.y = p.y;
-
- if(p.z > Max.z) Max.z = p.z;
- if(p.z < Min.z) Min.z = p.z;
-
- SetMinMax(Min, Max);
- }
- // Data access
-
- //! Get min point of the box
- inline_ void GetMin(IcePoint& min) const { min = mCenter - mExtents; }
- //! Get max point of the box
- inline_ void GetMax(IcePoint& max) const { max = mCenter + mExtents; }
-
- //! Get component of the box's min point along a given axis
- inline_ float GetMin(udword axis) const { return mCenter[axis] - mExtents[axis]; }
- //! Get component of the box's max point along a given axis
- inline_ float GetMax(udword axis) const { return mCenter[axis] + mExtents[axis]; }
-
- //! Get box center
- inline_ void GetCenter(IcePoint& center) const { center = mCenter; }
- //! Get box extents
- inline_ void GetExtents(IcePoint& extents) const { extents = mExtents; }
-
- //! Get component of the box's center along a given axis
- inline_ float GetCenter(udword axis) const { return mCenter[axis]; }
- //! Get component of the box's extents along a given axis
- inline_ float GetExtents(udword axis) const { return mExtents[axis]; }
-
- //! Get box diagonal
- inline_ void GetDiagonal(IcePoint& diagonal) const { diagonal = mExtents * 2.0f; }
- inline_ float GetWidth() const { return mExtents.x * 2.0f; }
- inline_ float GetHeight() const { return mExtents.y * 2.0f; }
- inline_ float GetDepth() const { return mExtents.z * 2.0f; }
-
- //! Volume
- inline_ float GetVolume() const { return mExtents.x * mExtents.y * mExtents.z * 8.0f; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the intersection between two AABBs.
- * \param a [in] the other AABB
- * \return true on intersection
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL Intersect(const AABB& a) const
- {
- float tx = mCenter.x - a.mCenter.x; float ex = a.mExtents.x + mExtents.x; if(AIR(tx) > IR(ex)) return FALSE;
- float ty = mCenter.y - a.mCenter.y; float ey = a.mExtents.y + mExtents.y; if(AIR(ty) > IR(ey)) return FALSE;
- float tz = mCenter.z - a.mCenter.z; float ez = a.mExtents.z + mExtents.z; if(AIR(tz) > IR(ez)) return FALSE;
- return TRUE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * The standard intersection method from Gamasutra. Just here to check its speed against the one above.
- * \param a [in] the other AABB
- * \return true on intersection
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool GomezIntersect(const AABB& a)
- {
- IcePoint T = mCenter - a.mCenter; // Vector from A to B
- return ((fabsf(T.x) <= (a.mExtents.x + mExtents.x))
- && (fabsf(T.y) <= (a.mExtents.y + mExtents.y))
- && (fabsf(T.z) <= (a.mExtents.z + mExtents.z)));
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the 1D-intersection between two AABBs, on a given axis.
- * \param a [in] the other AABB
- * \param axis [in] the axis (0, 1, 2)
- * \return true on intersection
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL Intersect(const AABB& a, udword axis) const
- {
- float t = mCenter[axis] - a.mCenter[axis];
- float e = a.mExtents[axis] + mExtents[axis];
- if(AIR(t) > IR(e)) return FALSE;
- return TRUE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Recomputes the AABB after an arbitrary transform by a 4x4 matrix.
- * \param mtx [in] the transform matrix
- * \param aabb [out] the transformed AABB [can be *this]
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void Rotate(const Matrix4x4& mtx, AABB& aabb) const
- {
- // Compute new center
- aabb.mCenter = mCenter * mtx;
-
- // Compute new extents. FPU code & CPU code have been interleaved for improved performance.
- IcePoint Ex(mtx.m[0][0] * mExtents.x, mtx.m[0][1] * mExtents.x, mtx.m[0][2] * mExtents.x);
- IR(Ex.x)&=0x7fffffff; IR(Ex.y)&=0x7fffffff; IR(Ex.z)&=0x7fffffff;
-
- IcePoint Ey(mtx.m[1][0] * mExtents.y, mtx.m[1][1] * mExtents.y, mtx.m[1][2] * mExtents.y);
- IR(Ey.x)&=0x7fffffff; IR(Ey.y)&=0x7fffffff; IR(Ey.z)&=0x7fffffff;
-
- IcePoint Ez(mtx.m[2][0] * mExtents.z, mtx.m[2][1] * mExtents.z, mtx.m[2][2] * mExtents.z);
- IR(Ez.x)&=0x7fffffff; IR(Ez.y)&=0x7fffffff; IR(Ez.z)&=0x7fffffff;
-
- aabb.mExtents.x = Ex.x + Ey.x + Ez.x;
- aabb.mExtents.y = Ex.y + Ey.y + Ez.y;
- aabb.mExtents.z = Ex.z + Ey.z + Ez.z;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the AABB is valid.
- * \return true if the box is valid
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL IsValid() const
- {
- // Consistency condition for (Center, Extents) boxes: Extents >= 0
- if(IS_NEGATIVE_FLOAT(mExtents.x)) return FALSE;
- if(IS_NEGATIVE_FLOAT(mExtents.y)) return FALSE;
- if(IS_NEGATIVE_FLOAT(mExtents.z)) return FALSE;
- return TRUE;
- }
-
- //! Operator for AABB *= float. Scales the extents, keeps same center.
- inline_ AABB& operator*=(float s) { mExtents*=s; return *this; }
-
- //! Operator for AABB /= float. Scales the extents, keeps same center.
- inline_ AABB& operator/=(float s) { mExtents/=s; return *this; }
-
- //! Operator for AABB += IcePoint. Translates the box.
- inline_ AABB& operator+=(const IcePoint& trans)
- {
- mCenter+=trans;
- return *this;
- }
- private:
- IcePoint mCenter; //!< AABB Center
- IcePoint mExtents; //!< x, y and z extents
- };
-
-#endif
-
- inline_ void ComputeMinMax(const IcePoint& p, IcePoint& min, IcePoint& max)
- {
- if(p.x > max.x) max.x = p.x;
- if(p.x < min.x) min.x = p.x;
-
- if(p.y > max.y) max.y = p.y;
- if(p.y < min.y) min.y = p.y;
-
- if(p.z > max.z) max.z = p.z;
- if(p.z < min.z) min.z = p.z;
- }
-
- inline_ void ComputeAABB(AABB& aabb, const IcePoint* list, udword nb_pts)
- {
- if(list)
- {
- IcePoint Maxi(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
- IcePoint Mini(MAX_FLOAT, MAX_FLOAT, MAX_FLOAT);
- while(nb_pts--)
- {
-// _prefetch(list+1); // off by one ?
- ComputeMinMax(*list++, Mini, Maxi);
- }
- aabb.SetMinMax(Mini, Maxi);
- }
- }
-
-#endif // __ICEAABB_H__
diff --git a/Opcode/OpcodeLib/Ice/IceAxes.h b/Opcode/OpcodeLib/Ice/IceAxes.h deleted file mode 100644 index 39004a9..0000000 --- a/Opcode/OpcodeLib/Ice/IceAxes.h +++ /dev/null @@ -1,54 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains axes definition.
- * \file IceAxes.h
- * \author Pierre Terdiman
- * \date January, 29, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEAXES_H__
-#define __ICEAXES_H__
-
- enum PointComponent
- {
- _X = 0,
- _Y = 1,
- _Z = 2,
- _W = 3,
-
- _FORCE_DWORD = 0x7fffffff
- };
-
- enum AxisOrder
- {
- AXES_XYZ = (_X)|(_Y<<2)|(_Z<<4),
- AXES_XZY = (_X)|(_Z<<2)|(_Y<<4),
- AXES_YXZ = (_Y)|(_X<<2)|(_Z<<4),
- AXES_YZX = (_Y)|(_Z<<2)|(_X<<4),
- AXES_ZXY = (_Z)|(_X<<2)|(_Y<<4),
- AXES_ZYX = (_Z)|(_Y<<2)|(_X<<4),
-
- AXES_FORCE_DWORD = 0x7fffffff
- };
-
- class ICEMATHS_API Axes
- {
- public:
-
- inline_ Axes(AxisOrder order)
- {
- mAxis0 = (order ) & 3;
- mAxis1 = (order>>2) & 3;
- mAxis2 = (order>>4) & 3;
- }
- inline_ ~Axes() {}
-
- udword mAxis0;
- udword mAxis1;
- udword mAxis2;
- };
-
-#endif // __ICEAXES_H__
diff --git a/Opcode/OpcodeLib/Ice/IceBoundingSphere.h b/Opcode/OpcodeLib/Ice/IceBoundingSphere.h deleted file mode 100644 index 43329e6..0000000 --- a/Opcode/OpcodeLib/Ice/IceBoundingSphere.h +++ /dev/null @@ -1,142 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code to compute the minimal bounding sphere.
- * \file IceBoundingSphere.h
- * \author Pierre Terdiman
- * \date January, 29, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEBOUNDINGSPHERE_H__
-#define __ICEBOUNDINGSPHERE_H__
-
- enum BSphereMethod
- {
- BS_NONE,
- BS_GEMS,
- BS_MINIBALL,
-
- BS_FORCE_DWORD = 0x7fffffff
- };
-
- class ICEMATHS_API Sphere
- {
- public:
- //! Constructor
- inline_ Sphere() {}
- //! Constructor
- inline_ Sphere(const IcePoint& center, float radius) : mCenter(center), mRadius(radius) {}
- //! Constructor
- Sphere(udword nb_verts, const IcePoint* verts);
- //! Copy constructor
- inline_ Sphere(const Sphere& sphere) : mCenter(sphere.mCenter), mRadius(sphere.mRadius) {}
- //! Destructor
- inline_ ~Sphere() {}
-
- BSphereMethod Compute(udword nb_verts, const IcePoint* verts);
- bool FastCompute(udword nb_verts, const IcePoint* verts);
-
- // Access methods
- inline_ const IcePoint& GetCenter() const { return mCenter; }
- inline_ float GetRadius() const { return mRadius; }
-
- inline_ const IcePoint& Center() const { return mCenter; }
- inline_ float Radius() const { return mRadius; }
-
- inline_ Sphere& Set(const IcePoint& center, float radius) { mCenter = center; mRadius = radius; return *this; }
- inline_ Sphere& SetCenter(const IcePoint& center) { mCenter = center; return *this; }
- inline_ Sphere& SetRadius(float radius) { mRadius = radius; return *this; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if a point is contained within the sphere.
- * \param p [in] the point to test
- * \return true if inside the sphere
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool Contains(const IcePoint& p) const
- {
- return mCenter.SquareDistance(p) <= mRadius*mRadius;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if a sphere is contained within the sphere.
- * \param sphere [in] the sphere to test
- * \return true if inside the sphere
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool Contains(const Sphere& sphere) const
- {
- // If our radius is the smallest, we can't possibly contain the other sphere
- if(mRadius < sphere.mRadius) return false;
- // So r is always positive or null now
- float r = mRadius - sphere.mRadius;
- return mCenter.SquareDistance(sphere.mCenter) <= r*r;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if a box is contained within the sphere.
- * \param aabb [in] the box to test
- * \return true if inside the sphere
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL Contains(const AABB& aabb) const
- {
- // I assume if all 8 box vertices are inside the sphere, so does the whole box.
- // Sounds ok but maybe there's a better way?
- float R2 = mRadius * mRadius;
-#ifdef USE_MIN_MAX
- const IcePoint& Max = ((ShadowAABB&)&aabb).mMax;
- const IcePoint& Min = ((ShadowAABB&)&aabb).mMin;
-#else
- IcePoint Max; aabb.GetMax(Max);
- IcePoint Min; aabb.GetMin(Min);
-#endif
- IcePoint p;
- p.x=Max.x; p.y=Max.y; p.z=Max.z; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Min.x; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Max.x; p.y=Min.y; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Min.x; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Max.x; p.y=Max.y; p.z=Min.z; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Min.x; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Max.x; p.y=Min.y; if(mCenter.SquareDistance(p)>=R2) return FALSE;
- p.x=Min.x; if(mCenter.SquareDistance(p)>=R2) return FALSE;
-
- return TRUE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if the sphere intersects another sphere
- * \param sphere [in] the other sphere
- * \return true if spheres overlap
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool Intersect(const Sphere& sphere) const
- {
- float r = mRadius + sphere.mRadius;
- return mCenter.SquareDistance(sphere.mCenter) <= r*r;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the sphere is valid.
- * \return true if the box is valid
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL IsValid() const
- {
- // Consistency condition for spheres: Radius >= 0.0f
- if(mRadius < 0.0f) return FALSE;
- return TRUE;
- }
- public:
- IcePoint mCenter; //!< Sphere center
- float mRadius; //!< Sphere radius
- };
-
-#endif // __ICEBOUNDINGSPHERE_H__
diff --git a/Opcode/OpcodeLib/Ice/IceContainer.cpp b/Opcode/OpcodeLib/Ice/IceContainer.cpp deleted file mode 100644 index e2c42d1..0000000 --- a/Opcode/OpcodeLib/Ice/IceContainer.cpp +++ /dev/null @@ -1,345 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a simple container class.
- * \file IceContainer.cpp
- * \author Pierre Terdiman
- * \date February, 5, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a list of 32-bits values.
- * Use this class when you need to store an unknown number of values. The list is automatically
- * resized and can contains 32-bits entities (dwords or floats)
- *
- * \class Container
- * \author Pierre Terdiman
- * \version 1.0
- * \date 08.15.98
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceCore;
-
-// Static members
-#ifdef CONTAINER_STATS
-udword Container::mNbContainers = 0;
-udword Container::mUsedRam = 0;
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor. No entries allocated there.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container::Container() : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(2.0f)
-{
-#ifdef CONTAINER_STATS
- mNbContainers++;
- mUsedRam+=sizeof(Container);
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor. Also allocates a given number of entries.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container::Container(udword size, float growth_factor) : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(growth_factor)
-{
-#ifdef CONTAINER_STATS
- mNbContainers++;
- mUsedRam+=sizeof(Container);
-#endif
- SetSize(size);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Copy constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container::Container(const Container& object) : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(2.0f)
-{
-#ifdef CONTAINER_STATS
- mNbContainers++;
- mUsedRam+=sizeof(Container);
-#endif
- *this = object;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor. Frees everything and leaves.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container::~Container()
-{
- Empty();
-#ifdef CONTAINER_STATS
- mNbContainers--;
- mUsedRam-=GetUsedRam();
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Clears the container. All stored values are deleted, and it frees used ram.
- * \see Reset()
- * \return Self-Reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container& Container::Empty()
-{
-#ifdef CONTAINER_STATS
- mUsedRam-=mMaxNbEntries*sizeof(udword);
-#endif
- DELETEARRAY(mEntries);
- mCurNbEntries = mMaxNbEntries = 0;
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Resizes the container.
- * \param needed [in] assume the container can be added at least "needed" values
- * \return true if success.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Container::Resize(udword needed)
-{
-#ifdef CONTAINER_STATS
- // Subtract previous amount of bytes
- mUsedRam-=mMaxNbEntries*sizeof(udword);
-#endif
-
- // Get more entries
- mMaxNbEntries = mMaxNbEntries ? udword(float(mMaxNbEntries)*mGrowthFactor) : 2; // Default nb Entries = 2
- if(mMaxNbEntries<mCurNbEntries + needed) mMaxNbEntries = mCurNbEntries + needed;
-
- // Get some bytes for new entries
- udword* NewEntries = new udword[mMaxNbEntries];
- CHECKALLOC(NewEntries);
-
-#ifdef CONTAINER_STATS
- // Add current amount of bytes
- mUsedRam+=mMaxNbEntries*sizeof(udword);
-#endif
-
- // Copy old data if needed
- if(mCurNbEntries) CopyMemory(NewEntries, mEntries, mCurNbEntries*sizeof(udword));
-
- // Delete old data
- DELETEARRAY(mEntries);
-
- // Assign new pointer
- mEntries = NewEntries;
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Sets the initial size of the container. If it already contains something, it's discarded.
- * \param nb [in] Number of entries
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Container::SetSize(udword nb)
-{
- // Make sure it's empty
- Empty();
-
- // Checkings
- if(!nb) return false;
-
- // Initialize for nb entries
- mMaxNbEntries = nb;
-
- // Get some bytes for new entries
- mEntries = new udword[mMaxNbEntries];
- CHECKALLOC(mEntries);
-
-#ifdef CONTAINER_STATS
- // Add current amount of bytes
- mUsedRam+=mMaxNbEntries*sizeof(udword);
-#endif
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the container and get rid of unused bytes.
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Container::Refit()
-{
-#ifdef CONTAINER_STATS
- // Subtract previous amount of bytes
- mUsedRam-=mMaxNbEntries*sizeof(udword);
-#endif
-
- // Get just enough entries
- mMaxNbEntries = mCurNbEntries;
- if(!mMaxNbEntries) return false;
-
- // Get just enough bytes
- udword* NewEntries = new udword[mMaxNbEntries];
- CHECKALLOC(NewEntries);
-
-#ifdef CONTAINER_STATS
- // Add current amount of bytes
- mUsedRam+=mMaxNbEntries*sizeof(udword);
-#endif
-
- // Copy old data
- CopyMemory(NewEntries, mEntries, mCurNbEntries*sizeof(udword));
-
- // Delete old data
- DELETEARRAY(mEntries);
-
- // Assign new pointer
- mEntries = NewEntries;
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks whether the container already contains a given value.
- * \param entry [in] the value to look for in the container
- * \param location [out] a possible pointer to store the entry location
- * \see Add(udword entry)
- * \see Add(float entry)
- * \see Empty()
- * \return true if the value has been found in the container, else false.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Container::Contains(udword entry, udword* location) const
-{
- // Look for the entry
- for(udword i=0;i<mCurNbEntries;i++)
- {
- if(mEntries[i]==entry)
- {
- if(location) *location = i;
- return true;
- }
- }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Deletes an entry. If the container contains such an entry, it's removed.
- * \param entry [in] the value to delete.
- * \return true if the value has been found in the container, else false.
- * \warning This method is arbitrary slow (O(n)) and should be used carefully. Insertion order is not preserved.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Container::Delete(udword entry)
-{
- // Look for the entry
- for(udword i=0;i<mCurNbEntries;i++)
- {
- if(mEntries[i]==entry)
- {
- // Entry has been found at index i. The strategy is to copy the last current entry at index i, and decrement the current number of entries.
- DeleteIndex(i);
- return true;
- }
- }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Deletes an entry, preserving the insertion order. If the container contains such an entry, it's removed.
- * \param entry [in] the value to delete.
- * \return true if the value has been found in the container, else false.
- * \warning This method is arbitrary slow (O(n)) and should be used carefully.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Container::DeleteKeepingOrder(udword entry)
-{
- // Look for the entry
- for(udword i=0;i<mCurNbEntries;i++)
- {
- if(mEntries[i]==entry)
- {
- // Entry has been found at index i.
- // Shift entries to preserve order. You really should use a linked list instead.
- mCurNbEntries--;
- for(udword j=i;j<mCurNbEntries;j++)
- {
- mEntries[j] = mEntries[j+1];
- }
- return true;
- }
- }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the next entry, starting from input one.
- * \param entry [in/out] On input, the entry to look for. On output, the next entry
- * \param find_mode [in] wrap/clamp
- * \return Self-Reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container& Container::FindNext(udword& entry, FindMode find_mode)
-{
- udword Location;
- if(Contains(entry, &Location))
- {
- Location++;
- if(Location==mCurNbEntries) Location = find_mode==FIND_WRAP ? 0 : mCurNbEntries-1;
- entry = mEntries[Location];
- }
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the previous entry, starting from input one.
- * \param entry [in/out] On input, the entry to look for. On output, the previous entry
- * \param find_mode [in] wrap/clamp
- * \return Self-Reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Container& Container::FindPrev(udword& entry, FindMode find_mode)
-{
- udword Location;
- if(Contains(entry, &Location))
- {
- Location--;
- if(Location==0xffffffff) Location = find_mode==FIND_WRAP ? mCurNbEntries-1 : 0;
- entry = mEntries[Location];
- }
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the ram used by the container.
- * \return the ram used in bytes.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword Container::GetUsedRam() const
-{
- return sizeof(Container) + mMaxNbEntries * sizeof(udword);
-}
-
-void Container::operator=(const Container& object)
-{
- SetSize(object.GetNbEntries());
- CopyMemory(mEntries, object.GetEntries(), mMaxNbEntries*sizeof(udword));
- mCurNbEntries = mMaxNbEntries;
-}
diff --git a/Opcode/OpcodeLib/Ice/IceContainer.h b/Opcode/OpcodeLib/Ice/IceContainer.h deleted file mode 100644 index 9f06ada..0000000 --- a/Opcode/OpcodeLib/Ice/IceContainer.h +++ /dev/null @@ -1,212 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a simple container class.
- * \file IceContainer.h
- * \author Pierre Terdiman
- * \date February, 5, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICECONTAINER_H__
-#define __ICECONTAINER_H__
-
- #define CONTAINER_STATS
-
- enum FindMode
- {
- FIND_CLAMP,
- FIND_WRAP,
-
- FIND_FORCE_DWORD = 0x7fffffff
- };
-
- class ICECORE_API Container
- {
- public:
- // Constructor / Destructor
- Container();
- Container(const Container& object);
- Container(udword size, float growth_factor);
- ~Container();
- // Management
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * A O(1) method to add a value in the container. The container is automatically resized if needed.
- * The method is inline, not the resize. The call overhead happens on resizes only, which is not a problem since the resizing operation
- * costs a lot more than the call overhead...
- *
- * \param entry [in] a udword to store in the container
- * \see Add(float entry)
- * \see Empty()
- * \see Contains(udword entry)
- * \return Self-Reference
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ Container& Add(udword entry)
- {
- // Resize if needed
- if(mCurNbEntries==mMaxNbEntries) Resize();
-
- // Add new entry
- mEntries[mCurNbEntries++] = entry;
- return *this;
- }
-
- inline_ Container& Add(const udword* entries, udword nb)
- {
- // Resize if needed
- if(mCurNbEntries+nb>mMaxNbEntries) Resize(nb);
-
- // Add new entry
- CopyMemory(&mEntries[mCurNbEntries], entries, nb*sizeof(udword));
- mCurNbEntries+=nb;
- return *this;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * A O(1) method to add a value in the container. The container is automatically resized if needed.
- * The method is inline, not the resize. The call overhead happens on resizes only, which is not a problem since the resizing operation
- * costs a lot more than the call overhead...
- *
- * \param entry [in] a float to store in the container
- * \see Add(udword entry)
- * \see Empty()
- * \see Contains(udword entry)
- * \return Self-Reference
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ Container& Add(float entry)
- {
- // Resize if needed
- if(mCurNbEntries==mMaxNbEntries) Resize();
-
- // Add new entry
- mEntries[mCurNbEntries++] = IR(entry);
- return *this;
- }
-
- inline_ Container& Add(const float* entries, udword nb)
- {
- // Resize if needed
- if(mCurNbEntries+nb>mMaxNbEntries) Resize(nb);
-
- // Add new entry
- CopyMemory(&mEntries[mCurNbEntries], entries, nb*sizeof(float));
- mCurNbEntries+=nb;
- return *this;
- }
-
- //! Add unique [slow]
- inline_ Container& AddUnique(udword entry)
- {
- if(!Contains(entry)) Add(entry);
- return *this;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Clears the container. All stored values are deleted, and it frees used ram.
- * \see Reset()
- * \return Self-Reference
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- Container& Empty();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Resets the container. Stored values are discarded but the buffer is kept so that further calls don't need resizing again.
- * That's a kind of temporal coherence.
- * \see Empty()
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void Reset()
- {
- // Avoid the write if possible
- // ### CMOV
- if(mCurNbEntries) mCurNbEntries = 0;
- }
-
- // HANDLE WITH CARE
- inline_ void ForceSize(udword size)
- {
- mCurNbEntries = size;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Sets the initial size of the container. If it already contains something, it's discarded.
- * \param nb [in] Number of entries
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool SetSize(udword nb);
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Refits the container and get rid of unused bytes.
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool Refit();
-
- // Checks whether the container already contains a given value.
- bool Contains(udword entry, udword* location=null) const;
- // Deletes an entry - doesn't preserve insertion order.
- bool Delete(udword entry);
- // Deletes an entry - does preserve insertion order.
- bool DeleteKeepingOrder(udword entry);
- //! Deletes the very last entry.
- inline_ void DeleteLastEntry() { if(mCurNbEntries) mCurNbEntries--; }
- //! Deletes the entry whose index is given
- inline_ void DeleteIndex(udword index) { mEntries[index] = mEntries[--mCurNbEntries]; }
-
- // Helpers
- Container& FindNext(udword& entry, FindMode find_mode=FIND_CLAMP);
- Container& FindPrev(udword& entry, FindMode find_mode=FIND_CLAMP);
- // Data access.
- inline_ udword GetNbEntries() const { return mCurNbEntries; } //!< Returns the current number of entries.
- inline_ udword GetEntry(udword i) const { return mEntries[i]; } //!< Returns ith entry
- inline_ udword* GetEntries() const { return mEntries; } //!< Returns the list of entries.
-
- inline_ udword GetFirst() const { return mEntries[0]; }
- inline_ udword GetLast() const { return mEntries[mCurNbEntries-1]; }
-
- // Growth control
- inline_ float GetGrowthFactor() const { return mGrowthFactor; } //!< Returns the growth factor
- inline_ void SetGrowthFactor(float growth) { mGrowthFactor = growth; } //!< Sets the growth factor
- inline_ bool IsFull() const { return mCurNbEntries==mMaxNbEntries; } //!< Checks the container is full
- inline_ BOOL IsNotEmpty() const { return mCurNbEntries; } //!< Checks the container is empty
-
- //! Read-access as an array
- inline_ udword operator[](udword i) const { ASSERT(i>=0 && i<mCurNbEntries); return mEntries[i]; }
- //! Write-access as an array
- inline_ udword& operator[](udword i) { ASSERT(i>=0 && i<mCurNbEntries); return mEntries[i]; }
-
- // Stats
- udword GetUsedRam() const;
-
- //! Operator for "Container A = Container B"
- void operator = (const Container& object);
-
-#ifdef CONTAINER_STATS
- inline_ udword GetNbContainers() const { return mNbContainers; }
- inline_ udword GetTotalBytes() const { return mUsedRam; }
- private:
-
- static udword mNbContainers; //!< Number of containers around
- static udword mUsedRam; //!< Amount of bytes used by containers in the system
-#endif
- private:
- // Resizing
- bool Resize(udword needed=1);
- // Data
- udword mMaxNbEntries; //!< Maximum possible number of entries
- udword mCurNbEntries; //!< Current number of entries
- udword* mEntries; //!< List of entries
- float mGrowthFactor; //!< Resize: new number of entries = old number * mGrowthFactor
- };
-
-#endif // __ICECONTAINER_H__
diff --git a/Opcode/OpcodeLib/Ice/IceFPU.h b/Opcode/OpcodeLib/Ice/IceFPU.h deleted file mode 100644 index 9e57960..0000000 --- a/Opcode/OpcodeLib/Ice/IceFPU.h +++ /dev/null @@ -1,317 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains FPU related code.
- * \file IceFPU.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEFPU_H__
-#define __ICEFPU_H__
-
- #define SIGN_BITMASK 0x80000000
-
- //! Integer representation of a floating-point value.
- #define IR(x) ((udword&)(x))
-
- //! Signed integer representation of a floating-point value.
- #define SIR(x) ((sdword&)(x))
-
- //! Absolute integer representation of a floating-point value
- #define AIR(x) (IR(x)&0x7fffffff)
-
- //! Floating-point representation of an integer value.
- #define FR(x) ((float&)(x))
-
- //! Integer-based comparison of a floating point value.
- //! Don't use it blindly, it can be faster or slower than the FPU comparison, depends on the context.
- #define IS_NEGATIVE_FLOAT(x) (IR(x)&0x80000000)
-
- //! Fast fabs for floating-point values. It just clears the sign bit.
- //! Don't use it blindy, it can be faster or slower than the FPU comparison, depends on the context.
- inline_ float FastFabs(float x)
- {
- udword FloatBits = IR(x)&0x7fffffff;
- return FR(FloatBits);
- }
-
- //! Fast square root for floating-point values.
- inline_ float FastSqrt(float square)
- {
- float retval;
-
- __asm {
- mov eax, square
- sub eax, 0x3F800000
- sar eax, 1
- add eax, 0x3F800000
- mov [retval], eax
- }
- return retval;
- }
-
- //! Saturates positive to zero.
- inline_ float fsat(float f)
- {
- udword y = (udword&)f & ~((sdword&)f >>31);
- return (float&)y;
- }
-
- //! Computes 1.0f / sqrtf(x).
- inline_ float frsqrt(float f)
- {
- float x = f * 0.5f;
- udword y = 0x5f3759df - ((udword&)f >> 1);
- // Iteration...
- (float&)y = (float&)y * ( 1.5f - ( x * (float&)y * (float&)y ) );
- // Result
- return (float&)y;
- }
-
- //! Computes 1.0f / sqrtf(x). Comes from NVIDIA.
- inline_ float InvSqrt(const float& x)
- {
- udword tmp = (udword(IEEE_1_0 << 1) + IEEE_1_0 - *(udword*)&x) >> 1;
- float y = *(float*)&tmp;
- return y * (1.47f - 0.47f * x * y * y);
- }
-
- //! Computes 1.0f / sqrtf(x). Comes from Quake3. Looks like the first one I had above.
- //! See http://www.magic-software.com/3DGEDInvSqrt.html
- inline_ float RSqrt(float number)
- {
- long i;
- float x2, y;
- const float threehalfs = 1.5f;
-
- x2 = number * 0.5f;
- y = number;
- i = * (long *) &y;
- i = 0x5f3759df - (i >> 1);
- y = * (float *) &i;
- y = y * (threehalfs - (x2 * y * y));
-
- return y;
- }
-
- //! TO BE DOCUMENTED
- inline_ float fsqrt(float f)
- {
- udword y = ( ( (sdword&)f - 0x3f800000 ) >> 1 ) + 0x3f800000;
- // Iteration...?
- // (float&)y = (3.0f - ((float&)y * (float&)y) / f) * (float&)y * 0.5f;
- // Result
- return (float&)y;
- }
-
- //! Returns the float ranged espilon value.
- inline_ float fepsilon(float f)
- {
- udword b = (udword&)f & 0xff800000;
- udword a = b | 0x00000001;
- (float&)a -= (float&)b;
- // Result
- return (float&)a;
- }
-
- //! Is the float valid ?
- inline_ bool IsNAN(float value) { return (IR(value)&0x7f800000) == 0x7f800000; }
- inline_ bool IsIndeterminate(float value) { return IR(value) == 0xffc00000; }
- inline_ bool IsPlusInf(float value) { return IR(value) == 0x7f800000; }
- inline_ bool IsMinusInf(float value) { return IR(value) == 0xff800000; }
-
- inline_ bool IsValidFloat(float value)
- {
- if(IsNAN(value)) return false;
- if(IsIndeterminate(value)) return false;
- if(IsPlusInf(value)) return false;
- if(IsMinusInf(value)) return false;
- return true;
- }
-
- #define CHECK_VALID_FLOAT(x) ASSERT(IsValidFloat(x));
-
-/*
- //! FPU precision setting function.
- inline_ void SetFPU()
- {
- // This function evaluates whether the floating-point
- // control word is set to single precision/round to nearest/
- // exceptions disabled. If these conditions don't hold, the
- // function changes the control word to set them and returns
- // TRUE, putting the old control word value in the passback
- // location pointed to by pwOldCW.
- {
- uword wTemp, wSave;
-
- __asm fstcw wSave
- if (wSave & 0x300 || // Not single mode
- 0x3f != (wSave & 0x3f) || // Exceptions enabled
- wSave & 0xC00) // Not round to nearest mode
- {
- __asm
- {
- mov ax, wSave
- and ax, not 300h ;; single mode
- or ax, 3fh ;; disable all exceptions
- and ax, not 0xC00 ;; round to nearest mode
- mov wTemp, ax
- fldcw wTemp
- }
- }
- }
- }
-*/
- //! This function computes the slowest possible floating-point value (you can also directly use FLT_EPSILON)
- inline_ float ComputeFloatEpsilon()
- {
- float f = 1.0f;
- ((udword&)f)^=1;
- return f - 1.0f; // You can check it's the same as FLT_EPSILON
- }
-
- inline_ bool IsFloatZero(float x, float epsilon=1e-6f)
- {
- return x*x < epsilon;
- }
-
- #define FCOMI_ST0 _asm _emit 0xdb _asm _emit 0xf0
- #define FCOMIP_ST0 _asm _emit 0xdf _asm _emit 0xf0
- #define FCMOVB_ST0 _asm _emit 0xda _asm _emit 0xc0
- #define FCMOVNB_ST0 _asm _emit 0xdb _asm _emit 0xc0
-
- #define FCOMI_ST1 _asm _emit 0xdb _asm _emit 0xf1
- #define FCOMIP_ST1 _asm _emit 0xdf _asm _emit 0xf1
- #define FCMOVB_ST1 _asm _emit 0xda _asm _emit 0xc1
- #define FCMOVNB_ST1 _asm _emit 0xdb _asm _emit 0xc1
-
- #define FCOMI_ST2 _asm _emit 0xdb _asm _emit 0xf2
- #define FCOMIP_ST2 _asm _emit 0xdf _asm _emit 0xf2
- #define FCMOVB_ST2 _asm _emit 0xda _asm _emit 0xc2
- #define FCMOVNB_ST2 _asm _emit 0xdb _asm _emit 0xc2
-
- #define FCOMI_ST3 _asm _emit 0xdb _asm _emit 0xf3
- #define FCOMIP_ST3 _asm _emit 0xdf _asm _emit 0xf3
- #define FCMOVB_ST3 _asm _emit 0xda _asm _emit 0xc3
- #define FCMOVNB_ST3 _asm _emit 0xdb _asm _emit 0xc3
-
- #define FCOMI_ST4 _asm _emit 0xdb _asm _emit 0xf4
- #define FCOMIP_ST4 _asm _emit 0xdf _asm _emit 0xf4
- #define FCMOVB_ST4 _asm _emit 0xda _asm _emit 0xc4
- #define FCMOVNB_ST4 _asm _emit 0xdb _asm _emit 0xc4
-
- #define FCOMI_ST5 _asm _emit 0xdb _asm _emit 0xf5
- #define FCOMIP_ST5 _asm _emit 0xdf _asm _emit 0xf5
- #define FCMOVB_ST5 _asm _emit 0xda _asm _emit 0xc5
- #define FCMOVNB_ST5 _asm _emit 0xdb _asm _emit 0xc5
-
- #define FCOMI_ST6 _asm _emit 0xdb _asm _emit 0xf6
- #define FCOMIP_ST6 _asm _emit 0xdf _asm _emit 0xf6
- #define FCMOVB_ST6 _asm _emit 0xda _asm _emit 0xc6
- #define FCMOVNB_ST6 _asm _emit 0xdb _asm _emit 0xc6
-
- #define FCOMI_ST7 _asm _emit 0xdb _asm _emit 0xf7
- #define FCOMIP_ST7 _asm _emit 0xdf _asm _emit 0xf7
- #define FCMOVB_ST7 _asm _emit 0xda _asm _emit 0xc7
- #define FCMOVNB_ST7 _asm _emit 0xdb _asm _emit 0xc7
-
- //! A global function to find MAX(a,b) using FCOMI/FCMOV
- inline_ float FCMax2(float a, float b)
- {
- float Res;
- _asm fld [a]
- _asm fld [b]
- FCOMI_ST1
- FCMOVB_ST1
- _asm fstp [Res]
- _asm fcomp
- return Res;
- }
-
- //! A global function to find MIN(a,b) using FCOMI/FCMOV
- inline_ float FCMin2(float a, float b)
- {
- float Res;
- _asm fld [a]
- _asm fld [b]
- FCOMI_ST1
- FCMOVNB_ST1
- _asm fstp [Res]
- _asm fcomp
- return Res;
- }
-
- //! A global function to find MAX(a,b,c) using FCOMI/FCMOV
- inline_ float FCMax3(float a, float b, float c)
- {
- float Res;
- _asm fld [a]
- _asm fld [b]
- _asm fld [c]
- FCOMI_ST1
- FCMOVB_ST1
- FCOMI_ST2
- FCMOVB_ST2
- _asm fstp [Res]
- _asm fcompp
- return Res;
- }
-
- //! A global function to find MIN(a,b,c) using FCOMI/FCMOV
- inline_ float FCMin3(float a, float b, float c)
- {
- float Res;
- _asm fld [a]
- _asm fld [b]
- _asm fld [c]
- FCOMI_ST1
- FCMOVNB_ST1
- FCOMI_ST2
- FCMOVNB_ST2
- _asm fstp [Res]
- _asm fcompp
- return Res;
- }
-
- inline_ int ConvertToSortable(float f)
- {
- int& Fi = (int&)f;
- int Fmask = (Fi>>31);
- Fi ^= Fmask;
- Fmask &= ~(1<<31);
- Fi -= Fmask;
- return Fi;
- }
-
- enum FPUMode
- {
- FPU_FLOOR = 0,
- FPU_CEIL = 1,
- FPU_BEST = 2,
-
- FPU_FORCE_DWORD = 0x7fffffff
- };
-
- FUNCTION ICECORE_API FPUMode GetFPUMode();
- FUNCTION ICECORE_API void SaveFPU();
- FUNCTION ICECORE_API void RestoreFPU();
- FUNCTION ICECORE_API void SetFPUFloorMode();
- FUNCTION ICECORE_API void SetFPUCeilMode();
- FUNCTION ICECORE_API void SetFPUBestMode();
-
- FUNCTION ICECORE_API void SetFPUPrecision24();
- FUNCTION ICECORE_API void SetFPUPrecision53();
- FUNCTION ICECORE_API void SetFPUPrecision64();
- FUNCTION ICECORE_API void SetFPURoundingChop();
- FUNCTION ICECORE_API void SetFPURoundingUp();
- FUNCTION ICECORE_API void SetFPURoundingDown();
- FUNCTION ICECORE_API void SetFPURoundingNear();
-
- FUNCTION ICECORE_API int intChop(const float& f);
- FUNCTION ICECORE_API int intFloor(const float& f);
- FUNCTION ICECORE_API int intCeil(const float& f);
-
-#endif // __ICEFPU_H__
diff --git a/Opcode/OpcodeLib/Ice/IceHPoint.cpp b/Opcode/OpcodeLib/Ice/IceHPoint.cpp deleted file mode 100644 index 2074543..0000000 --- a/Opcode/OpcodeLib/Ice/IceHPoint.cpp +++ /dev/null @@ -1,70 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for homogeneous points.
- * \file IceHPoint.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Homogeneous point.
- *
- * Use it:
- * - for clipping in homogeneous space (standard way)
- * - to differentiate between points (w=1) and vectors (w=0).
- * - in some cases you can also use it instead of IcePoint for padding reasons.
- *
- * \class HPoint
- * \author Pierre Terdiman
- * \version 1.0
- * \warning No cross-product in 4D.
- * \warning HPoint *= Matrix3x3 doesn't exist, the matrix is first casted to a 4x4
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// IcePoint Mul = HPoint * Matrix3x3;
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-IcePoint HPoint::operator*(const Matrix3x3& mat) const
-{
- return IcePoint(
- x * mat.m[0][0] + y * mat.m[1][0] + z * mat.m[2][0],
- x * mat.m[0][1] + y * mat.m[1][1] + z * mat.m[2][1],
- x * mat.m[0][2] + y * mat.m[1][2] + z * mat.m[2][2] );
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// HPoint Mul = HPoint * Matrix4x4;
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HPoint HPoint::operator*(const Matrix4x4& mat) const
-{
- return HPoint(
- x * mat.m[0][0] + y * mat.m[1][0] + z * mat.m[2][0] + w * mat.m[3][0],
- x * mat.m[0][1] + y * mat.m[1][1] + z * mat.m[2][1] + w * mat.m[3][1],
- x * mat.m[0][2] + y * mat.m[1][2] + z * mat.m[2][2] + w * mat.m[3][2],
- x * mat.m[0][3] + y * mat.m[1][3] + z * mat.m[2][3] + w * mat.m[3][3]);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// HPoint *= Matrix4x4
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HPoint& HPoint::operator*=(const Matrix4x4& mat)
-{
- float xp = x * mat.m[0][0] + y * mat.m[1][0] + z * mat.m[2][0] + w * mat.m[3][0];
- float yp = x * mat.m[0][1] + y * mat.m[1][1] + z * mat.m[2][1] + w * mat.m[3][1];
- float zp = x * mat.m[0][2] + y * mat.m[1][2] + z * mat.m[2][2] + w * mat.m[3][2];
- float wp = x * mat.m[0][3] + y * mat.m[1][3] + z * mat.m[2][3] + w * mat.m[3][3];
-
- x = xp; y = yp; z = zp; w = wp;
-
- return *this;
-}
-
diff --git a/Opcode/OpcodeLib/Ice/IceHPoint.h b/Opcode/OpcodeLib/Ice/IceHPoint.h deleted file mode 100644 index 461c39b..0000000 --- a/Opcode/OpcodeLib/Ice/IceHPoint.h +++ /dev/null @@ -1,157 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for homogeneous points.
- * \file IceHPoint.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEHPOINT_H__
-#define __ICEHPOINT_H__
-
- class ICEMATHS_API HPoint : public IcePoint
- {
- public:
-
- //! Empty constructor
- inline_ HPoint() {}
- //! Constructor from floats
- inline_ HPoint(float _x, float _y, float _z, float _w=0.0f) : IcePoint(_x, _y, _z), w(_w) {}
- //! Constructor from array
- inline_ HPoint(const float f[4]) : IcePoint(f), w(f[3]) {}
- //! Constructor from a IcePoint
- inline_ HPoint(const IcePoint& p, float _w=0.0f) : IcePoint(p), w(_w) {}
- //! Destructor
- inline_ ~HPoint() {}
-
- //! Clear the point
- inline_ HPoint& Zero() { x = y = z = w = 0.0f; return *this; }
-
- //! Assignment from values
- inline_ HPoint& Set(float _x, float _y, float _z, float _w ) { x = _x; y = _y; z = _z; w = _w; return *this; }
- //! Assignment from array
- inline_ HPoint& Set(const float f[4]) { x = f[_X]; y = f[_Y]; z = f[_Z]; w = f[_W]; return *this; }
- //! Assignment from another h-point
- inline_ HPoint& Set(const HPoint& src) { x = src.x; y = src.y; z = src.z; w = src.w; return *this; }
-
- //! Add a vector
- inline_ HPoint& Add(float _x, float _y, float _z, float _w ) { x += _x; y += _y; z += _z; w += _w; return *this; }
- //! Add a vector
- inline_ HPoint& Add(const float f[4]) { x += f[_X]; y += f[_Y]; z += f[_Z]; w += f[_W]; return *this; }
-
- //! Subtract a vector
- inline_ HPoint& Sub(float _x, float _y, float _z, float _w ) { x -= _x; y -= _y; z -= _z; w -= _w; return *this; }
- //! Subtract a vector
- inline_ HPoint& Sub(const float f[4]) { x -= f[_X]; y -= f[_Y]; z -= f[_Z]; w -= f[_W]; return *this; }
-
- //! Multiplies by a scalar
- inline_ HPoint& Mul(float s) { x *= s; y *= s; z *= s; w *= s; return *this; }
-
- //! Returns MIN(x, y, z, w);
- float Min() const { return MIN(x, MIN(y, MIN(z, w))); }
- //! Returns MAX(x, y, z, w);
- float Max() const { return MAX(x, MAX(y, MAX(z, w))); }
- //! Sets each element to be componentwise minimum
- HPoint& Min(const HPoint& p) { x = MIN(x, p.x); y = MIN(y, p.y); z = MIN(z, p.z); w = MIN(w, p.w); return *this; }
- //! Sets each element to be componentwise maximum
- HPoint& Max(const HPoint& p) { x = MAX(x, p.x); y = MAX(y, p.y); z = MAX(z, p.z); w = MAX(w, p.w); return *this; }
-
- //! Computes square magnitude
- inline_ float SquareMagnitude() const { return x*x + y*y + z*z + w*w; }
- //! Computes magnitude
- inline_ float Magnitude() const { return sqrtf(x*x + y*y + z*z + w*w); }
-
- //! Normalize the vector
- inline_ HPoint& Normalize()
- {
- float M = Magnitude();
- if(M)
- {
- M = 1.0f / M;
- x *= M;
- y *= M;
- z *= M;
- w *= M;
- }
- return *this;
- }
-
- // Arithmetic operators
- //! Operator for HPoint Negate = - HPoint;
- inline_ HPoint operator-() const { return HPoint(-x, -y, -z, -w); }
-
- //! Operator for HPoint Plus = HPoint + HPoint;
- inline_ HPoint operator+(const HPoint& p) const { return HPoint(x + p.x, y + p.y, z + p.z, w + p.w); }
- //! Operator for HPoint Minus = HPoint - HPoint;
- inline_ HPoint operator-(const HPoint& p) const { return HPoint(x - p.x, y - p.y, z - p.z, w - p.w); }
-
- //! Operator for HPoint Mul = HPoint * HPoint;
- inline_ HPoint operator*(const HPoint& p) const { return HPoint(x * p.x, y * p.y, z * p.z, w * p.w); }
- //! Operator for HPoint Scale = HPoint * float;
- inline_ HPoint operator*(float s) const { return HPoint(x * s, y * s, z * s, w * s); }
- //! Operator for HPoint Scale = float * HPoint;
- inline_ friend HPoint operator*(float s, const HPoint& p) { return HPoint(s * p.x, s * p.y, s * p.z, s * p.w); }
-
- //! Operator for HPoint Div = HPoint / HPoint;
- inline_ HPoint operator/(const HPoint& p) const { return HPoint(x / p.x, y / p.y, z / p.z, w / p.w); }
- //! Operator for HPoint Scale = HPoint / float;
- inline_ HPoint operator/(float s) const { s = 1.0f / s; return HPoint(x * s, y * s, z * s, w * s); }
- //! Operator for HPoint Scale = float / HPoint;
- inline_ friend HPoint operator/(float s, const HPoint& p) { return HPoint(s / p.x, s / p.y, s / p.z, s / p.w); }
-
- //! Operator for float DotProd = HPoint | HPoint;
- inline_ float operator|(const HPoint& p) const { return x*p.x + y*p.y + z*p.z + w*p.w; }
- // No cross-product in 4D
-
- //! Operator for HPoint += HPoint;
- inline_ HPoint& operator+=(const HPoint& p) { x += p.x; y += p.y; z += p.z; w += p.w; return *this; }
- //! Operator for HPoint += float;
- inline_ HPoint& operator+=(float s) { x += s; y += s; z += s; w += s; return *this; }
-
- //! Operator for HPoint -= HPoint;
- inline_ HPoint& operator-=(const HPoint& p) { x -= p.x; y -= p.y; z -= p.z; w -= p.w; return *this; }
- //! Operator for HPoint -= float;
- inline_ HPoint& operator-=(float s) { x -= s; y -= s; z -= s; w -= s; return *this; }
-
- //! Operator for HPoint *= HPoint;
- inline_ HPoint& operator*=(const HPoint& p) { x *= p.x; y *= p.y; z *= p.z; w *= p.w; return *this; }
- //! Operator for HPoint *= float;
- inline_ HPoint& operator*=(float s) { x*=s; y*=s; z*=s; w*=s; return *this; }
-
- //! Operator for HPoint /= HPoint;
- inline_ HPoint& operator/=(const HPoint& p) { x /= p.x; y /= p.y; z /= p.z; w /= p.w; return *this; }
- //! Operator for HPoint /= float;
- inline_ HPoint& operator/=(float s) { s = 1.0f / s; x*=s; y*=s; z*=s; w*=s; return *this; }
-
- // Arithmetic operators
-
- //! Operator for IcePoint Mul = HPoint * Matrix3x3;
- IcePoint operator*(const Matrix3x3& mat) const;
- //! Operator for HPoint Mul = HPoint * Matrix4x4;
- HPoint operator*(const Matrix4x4& mat) const;
-
- // HPoint *= Matrix3x3 doesn't exist, the matrix is first casted to a 4x4
- //! Operator for HPoint *= Matrix4x4
- HPoint& operator*=(const Matrix4x4& mat);
-
- // Logical operators
-
- //! Operator for "if(HPoint==HPoint)"
- inline_ bool operator==(const HPoint& p) const { return ( (x==p.x)&&(y==p.y)&&(z==p.z)&&(w==p.w)); }
- //! Operator for "if(HPoint!=HPoint)"
- inline_ bool operator!=(const HPoint& p) const { return ( (x!=p.x)||(y!=p.y)||(z!=p.z)||(w!=p.w)); }
-
- // Cast operators
-
- //! Cast a HPoint to a IcePoint. w is discarded.
- inline_ operator IcePoint() const { return IcePoint(x, y, z); }
-
- public:
- float w;
- };
-
-#endif // __ICEHPOINT_H__
-
diff --git a/Opcode/OpcodeLib/Ice/IceIndexedTriangle.cpp b/Opcode/OpcodeLib/Ice/IceIndexedTriangle.cpp deleted file mode 100644 index ea32362..0000000 --- a/Opcode/OpcodeLib/Ice/IceIndexedTriangle.cpp +++ /dev/null @@ -1,548 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a handy indexed triangle class.
- * \file IceIndexedTriangle.cpp
- * \author Pierre Terdiman
- * \date January, 17, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains an indexed triangle class.
- *
- * \class Triangle
- * \author Pierre Terdiman
- * \version 1.0
- * \date 08.15.98
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Flips the winding order.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::Flip()
-{
- Swap(mVRef[1], mVRef[2]);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle area.
- * \param verts [in] the list of indexed vertices
- * \return the area
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::Area(const IcePoint* verts) const
-{
- if(!verts) return 0.0f;
- const IcePoint& p0 = verts[0];
- const IcePoint& p1 = verts[1];
- const IcePoint& p2 = verts[2];
- return ((p0-p1)^(p0-p2)).Magnitude() * 0.5f;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle perimeter.
- * \param verts [in] the list of indexed vertices
- * \return the perimeter
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::Perimeter(const IcePoint* verts) const
-{
- if(!verts) return 0.0f;
- const IcePoint& p0 = verts[0];
- const IcePoint& p1 = verts[1];
- const IcePoint& p2 = verts[2];
- return p0.Distance(p1)
- + p0.Distance(p2)
- + p1.Distance(p2);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle compacity.
- * \param verts [in] the list of indexed vertices
- * \return the compacity
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::Compacity(const IcePoint* verts) const
-{
- if(!verts) return 0.0f;
- float P = Perimeter(verts);
- if(P==0.0f) return 0.0f;
- return (4.0f*PI*Area(verts)/(P*P));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle normal.
- * \param verts [in] the list of indexed vertices
- * \param normal [out] the computed normal
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::Normal(const IcePoint* verts, IcePoint& normal) const
-{
- if(!verts) return;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
- normal = ((p2-p1)^(p0-p1)).Normalize();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle denormalized normal.
- * \param verts [in] the list of indexed vertices
- * \param normal [out] the computed normal
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::DenormalizedNormal(const IcePoint* verts, IcePoint& normal) const
-{
- if(!verts) return;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
- normal = ((p2-p1)^(p0-p1));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle center.
- * \param verts [in] the list of indexed vertices
- * \param center [out] the computed center
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::Center(const IcePoint* verts, IcePoint& center) const
-{
- if(!verts) return;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
- center = (p0+p1+p2)*INV3;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the centered normal
- * \param verts [in] the list of indexed vertices
- * \param normal [out] the computed centered normal
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::CenteredNormal(const IcePoint* verts, IcePoint& normal) const
-{
- if(!verts) return;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
- IcePoint Center = (p0+p1+p2)*INV3;
- normal = Center + ((p2-p1)^(p0-p1)).Normalize();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes a random point within the triangle.
- * \param verts [in] the list of indexed vertices
- * \param normal [out] the computed centered normal
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::RandomPoint(const IcePoint* verts, IcePoint& random) const
-{
- if(!verts) return;
-
- // Random barycentric coords
- float Alpha = UnitRandomFloat();
- float Beta = UnitRandomFloat();
- float Gamma = UnitRandomFloat();
- float OneOverTotal = 1.0f / (Alpha + Beta + Gamma);
- Alpha *= OneOverTotal;
- Beta *= OneOverTotal;
- Gamma *= OneOverTotal;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
- random = Alpha*p0 + Beta*p1 + Gamma*p2;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes backface culling.
- * \param verts [in] the list of indexed vertices
- * \param source [in] source point (in local space) from which culling must be computed
- * \return true if the triangle is visible from the source point
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::IsVisible(const IcePoint* verts, const IcePoint& source) const
-{
- // Checkings
- if(!verts) return false;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
-
- // Compute denormalized normal
- IcePoint Normal = (p2 - p1)^(p0 - p1);
-
- // Backface culling
- return (Normal | source) >= 0.0f;
-
-// Same as:
-// IcePlane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
-// return PL.Distance(source) > PL.d;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes backface culling.
- * \param verts [in] the list of indexed vertices
- * \param source [in] source point (in local space) from which culling must be computed
- * \return true if the triangle is visible from the source point
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::BackfaceCulling(const IcePoint* verts, const IcePoint& source) const
-{
- // Checkings
- if(!verts) return false;
-
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
-
- // Compute base
-// IcePoint Base = (p0 + p1 + p2)*INV3;
-
- // Compute denormalized normal
- IcePoint Normal = (p2 - p1)^(p0 - p1);
-
- // Backface culling
-// return (Normal | (source - Base)) >= 0.0f;
- return (Normal | (source - p0)) >= 0.0f;
-
-// Same as: (but a bit faster)
-// IcePlane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]);
-// return PL.Distance(source)>0.0f;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the occlusion potential of the triangle.
- * \param verts [in] the list of indexed vertices
- * \param source [in] source point (in local space) from which occlusion potential must be computed
- * \return the occlusion potential
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::ComputeOcclusionPotential(const IcePoint* verts, const IcePoint& view) const
-{
- if(!verts) return 0.0f;
- // Occlusion potential: -(A * (N|V) / d^2)
- // A = polygon area
- // N = polygon normal
- // V = view vector
- // d = distance viewpoint-center of polygon
-
- float A = Area(verts);
- IcePoint N; Normal(verts, N);
- IcePoint C; Center(verts, C);
- float d = view.Distance(C);
- return -(A*(N|view))/(d*d);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Replaces a vertex reference with another one.
- * \param oldref [in] the vertex reference to replace
- * \param newref [in] the new vertex reference
- * \return true if success, else false if the input vertex reference doesn't belong to the triangle
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::ReplaceVertex(udword oldref, udword newref)
-{
- if(mVRef[0]==oldref) { mVRef[0] = newref; return true; }
- else if(mVRef[1]==oldref) { mVRef[1] = newref; return true; }
- else if(mVRef[2]==oldref) { mVRef[2] = newref; return true; }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks whether the triangle is degenerate or not. A degenerate triangle has two common vertex references. This is a zero-area triangle.
- * \return true if the triangle is degenerate
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::IsDegenerate() const
-{
- if(mVRef[0]==mVRef[1]) return true;
- if(mVRef[1]==mVRef[2]) return true;
- if(mVRef[2]==mVRef[0]) return true;
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks whether the input vertex reference belongs to the triangle or not.
- * \param ref [in] the vertex reference to look for
- * \return true if the triangle contains the vertex reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::HasVertex(udword ref) const
-{
- if(mVRef[0]==ref) return true;
- if(mVRef[1]==ref) return true;
- if(mVRef[2]==ref) return true;
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks whether the input vertex reference belongs to the triangle or not.
- * \param ref [in] the vertex reference to look for
- * \param index [out] the corresponding index in the triangle
- * \return true if the triangle contains the vertex reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::HasVertex(udword ref, udword* index) const
-{
- if(mVRef[0]==ref) { *index = 0; return true; }
- if(mVRef[1]==ref) { *index = 1; return true; }
- if(mVRef[2]==ref) { *index = 2; return true; }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Finds an edge in a tri, given two vertex references.
- * \param vref0 [in] the edge's first vertex reference
- * \param vref1 [in] the edge's second vertex reference
- * \return the edge number between 0 and 2, or 0xff if input refs are wrong.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-ubyte IndexedTriangle::FindEdge(udword vref0, udword vref1) const
-{
- if(mVRef[0]==vref0 && mVRef[1]==vref1) return 0;
- else if(mVRef[0]==vref1 && mVRef[1]==vref0) return 0;
- else if(mVRef[0]==vref0 && mVRef[2]==vref1) return 1;
- else if(mVRef[0]==vref1 && mVRef[2]==vref0) return 1;
- else if(mVRef[1]==vref0 && mVRef[2]==vref1) return 2;
- else if(mVRef[1]==vref1 && mVRef[2]==vref0) return 2;
- return 0xff;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the last reference given the first two.
- * \param vref0 [in] the first vertex reference
- * \param vref1 [in] the second vertex reference
- * \return the last reference, or INVALID_ID if input refs are wrong.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword IndexedTriangle::OppositeVertex(udword vref0, udword vref1) const
-{
- if(mVRef[0]==vref0 && mVRef[1]==vref1) return mVRef[2];
- else if(mVRef[0]==vref1 && mVRef[1]==vref0) return mVRef[2];
- else if(mVRef[0]==vref0 && mVRef[2]==vref1) return mVRef[1];
- else if(mVRef[0]==vref1 && mVRef[2]==vref0) return mVRef[1];
- else if(mVRef[1]==vref0 && mVRef[2]==vref1) return mVRef[0];
- else if(mVRef[1]==vref1 && mVRef[2]==vref0) return mVRef[0];
- return INVALID_ID;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the three sorted vertex references according to an edge number.
- * edgenb = 0 => edge 0-1, returns references 0, 1, 2
- * edgenb = 1 => edge 0-2, returns references 0, 2, 1
- * edgenb = 2 => edge 1-2, returns references 1, 2, 0
- *
- * \param edgenb [in] the edge number, 0, 1 or 2
- * \param vref0 [out] the returned first vertex reference
- * \param vref1 [out] the returned second vertex reference
- * \param vref2 [out] the returned third vertex reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::GetVRefs(ubyte edgenb, udword& vref0, udword& vref1, udword& vref2) const
-{
- if(edgenb==0)
- {
- vref0 = mVRef[0];
- vref1 = mVRef[1];
- vref2 = mVRef[2];
- }
- else if(edgenb==1)
- {
- vref0 = mVRef[0];
- vref1 = mVRef[2];
- vref2 = mVRef[1];
- }
- else if(edgenb==2)
- {
- vref0 = mVRef[1];
- vref1 = mVRef[2];
- vref2 = mVRef[0];
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle's smallest edge length.
- * \param verts [in] the list of indexed vertices
- * \return the smallest edge length
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::MinEdgeLength(const IcePoint* verts) const
-{
- if(!verts) return 0.0f;
-
- float Min = MAX_FLOAT;
- float Length01 = verts[0].Distance(verts[1]);
- float Length02 = verts[0].Distance(verts[2]);
- float Length12 = verts[1].Distance(verts[2]);
- if(Length01 < Min) Min = Length01;
- if(Length02 < Min) Min = Length02;
- if(Length12 < Min) Min = Length12;
- return Min;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle's largest edge length.
- * \param verts [in] the list of indexed vertices
- * \return the largest edge length
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::MaxEdgeLength(const IcePoint* verts) const
-{
- if(!verts) return 0.0f;
-
- float Max = MIN_FLOAT;
- float Length01 = verts[0].Distance(verts[1]);
- float Length02 = verts[0].Distance(verts[2]);
- float Length12 = verts[1].Distance(verts[2]);
- if(Length01 > Max) Max = Length01;
- if(Length02 > Max) Max = Length02;
- if(Length12 > Max) Max = Length12;
- return Max;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes a point on the triangle according to the stabbing information.
- * \param verts [in] the list of indexed vertices
- * \param u,v [in] point's barycentric coordinates
- * \param pt [out] point on triangle
- * \param nearvtx [out] index of nearest vertex
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void IndexedTriangle::ComputePoint(const IcePoint* verts, float u, float v, IcePoint& pt, udword* nearvtx) const
-{
- // Checkings
- if(!verts) return;
-
- // Get face in local or global space
- const IcePoint& p0 = verts[mVRef[0]];
- const IcePoint& p1 = verts[mVRef[1]];
- const IcePoint& p2 = verts[mVRef[2]];
-
- // Compute point coordinates
- pt = (1.0f - u - v)*p0 + u*p1 + v*p2;
-
- // Compute nearest vertex if needed
- if(nearvtx)
- {
- // Compute distance vector
- IcePoint d(p0.SquareDistance(pt), // Distance^2 from vertex 0 to point on the face
- p1.SquareDistance(pt), // Distance^2 from vertex 1 to point on the face
- p2.SquareDistance(pt)); // Distance^2 from vertex 2 to point on the face
-
- // Get smallest distance
- *nearvtx = mVRef[d.SmallestAxis()];
- }
-}
-
- //**************************************
- // Angle between two vectors (in radians)
- // we use this formula
- // uv = |u||v| cos(u,v)
- // u ^ v = w
- // |w| = |u||v| |sin(u,v)|
- //**************************************
- float Angle(const IcePoint& u, const IcePoint& v)
- {
- float NormU = u.Magnitude(); // |u|
- float NormV = v.Magnitude(); // |v|
- float Product = NormU*NormV; // |u||v|
- if(Product==0.0f) return 0.0f;
- float OneOverProduct = 1.0f / Product;
-
- // Cosinus
- float Cosinus = (u|v) * OneOverProduct;
-
- // Sinus
- IcePoint w = u^v;
- float NormW = w.Magnitude();
-
- float AbsSinus = NormW * OneOverProduct;
-
- // Remove degeneracy
- if(AbsSinus > 1.0f) AbsSinus = 1.0f;
- if(AbsSinus < -1.0f) AbsSinus = -1.0f;
-
- if(Cosinus>=0.0f) return asinf(AbsSinus);
- else return (PI-asinf(AbsSinus));
- }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the angle between two triangles.
- * \param tri [in] the other triangle
- * \param verts [in] the list of indexed vertices
- * \return the angle in radians
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float IndexedTriangle::Angle(const IndexedTriangle& tri, const IcePoint* verts) const
-{
- // Checkings
- if(!verts) return 0.0f;
-
- // Compute face normals
- IcePoint n0, n1;
- Normal(verts, n0);
- tri.Normal(verts, n1);
-
- // Compute angle
- float dp = n0|n1;
- if(dp>1.0f) return 0.0f;
- if(dp<-1.0f) return PI;
- return acosf(dp);
-
-// return ::Angle(n0,n1);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks a triangle is the same as another one.
- * \param tri [in] the other triangle
- * \return true if same triangle
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool IndexedTriangle::Equal(const IndexedTriangle& tri) const
-{
- // Test all vertex references
- return (HasVertex(tri.mVRef[0]) &&
- HasVertex(tri.mVRef[1]) &&
- HasVertex(tri.mVRef[2]));
-}
diff --git a/Opcode/OpcodeLib/Ice/IceIndexedTriangle.h b/Opcode/OpcodeLib/Ice/IceIndexedTriangle.h deleted file mode 100644 index 2cffa92..0000000 --- a/Opcode/OpcodeLib/Ice/IceIndexedTriangle.h +++ /dev/null @@ -1,68 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a handy indexed triangle class.
- * \file IceIndexedTriangle.h
- * \author Pierre Terdiman
- * \date January, 17, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEINDEXEDTRIANGLE_H__
-#define __ICEINDEXEDTRIANGLE_H__
-
- // Forward declarations
- enum CubeIndex;
-
- // An indexed triangle class.
- class ICEMATHS_API IndexedTriangle
- {
- public:
- //! Constructor
- inline_ IndexedTriangle() {}
- //! Constructor
- inline_ IndexedTriangle(udword r0, udword r1, udword r2) { mVRef[0]=r0; mVRef[1]=r1; mVRef[2]=r2; }
- //! Copy constructor
- inline_ IndexedTriangle(const IndexedTriangle& triangle)
- {
- mVRef[0] = triangle.mVRef[0];
- mVRef[1] = triangle.mVRef[1];
- mVRef[2] = triangle.mVRef[2];
- }
- //! Destructor
- inline_ ~IndexedTriangle() {}
- //! Vertex-references
- udword mVRef[3];
-
- // Methods
- void Flip();
- float Area(const IcePoint* verts) const;
- float Perimeter(const IcePoint* verts) const;
- float Compacity(const IcePoint* verts) const;
- void Normal(const IcePoint* verts, IcePoint& normal) const;
- void DenormalizedNormal(const IcePoint* verts, IcePoint& normal) const;
- void Center(const IcePoint* verts, IcePoint& center) const;
- void CenteredNormal(const IcePoint* verts, IcePoint& normal) const;
- void RandomPoint(const IcePoint* verts, IcePoint& random) const;
- bool IsVisible(const IcePoint* verts, const IcePoint& source) const;
- bool BackfaceCulling(const IcePoint* verts, const IcePoint& source) const;
- float ComputeOcclusionPotential(const IcePoint* verts, const IcePoint& view) const;
- bool ReplaceVertex(udword oldref, udword newref);
- bool IsDegenerate() const;
- bool HasVertex(udword ref) const;
- bool HasVertex(udword ref, udword* index) const;
- ubyte FindEdge(udword vref0, udword vref1) const;
- udword OppositeVertex(udword vref0, udword vref1) const;
- inline_ udword OppositeVertex(ubyte edgenb) const { return mVRef[2-edgenb]; }
- void GetVRefs(ubyte edgenb, udword& vref0, udword& vref1, udword& vref2) const;
- float MinEdgeLength(const IcePoint* verts) const;
- float MaxEdgeLength(const IcePoint* verts) const;
- void ComputePoint(const IcePoint* verts, float u, float v, IcePoint& pt, udword* nearvtx=null) const;
- float Angle(const IndexedTriangle& tri, const IcePoint* verts) const;
- inline_ IcePlane PlaneEquation(const IcePoint* verts) const { return IcePlane(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]); }
- bool Equal(const IndexedTriangle& tri) const;
- CubeIndex ComputeCubeIndex(const IcePoint* verts) const;
- };
-
-#endif // __ICEINDEXEDTRIANGLE_H__
diff --git a/Opcode/OpcodeLib/Ice/IceLSS.h b/Opcode/OpcodeLib/Ice/IceLSS.h deleted file mode 100644 index 7fe5b59..0000000 --- a/Opcode/OpcodeLib/Ice/IceLSS.h +++ /dev/null @@ -1,75 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for line-swept spheres.
- * \file IceLSS.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICELSS_H__
-#define __ICELSS_H__
-
- class ICEMATHS_API LSS : public IceSegment
- {
- public:
- //! Constructor
- inline_ LSS() {}
- //! Constructor
- inline_ LSS(const IceSegment& seg, float radius) : IceSegment(seg), mRadius(radius) {}
- //! Destructor
- inline_ ~LSS() {}
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes an OBB surrounding the LSS.
- * \param box [out] the OBB
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void ComputeOBB(OBB& box);
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if a point is contained within the LSS.
- * \param pt [in] the point to test
- * \return true if inside the LSS
- * \warning point and LSS must be in same space
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool Contains(const IcePoint& pt) const { return SquareDistance(pt) <= mRadius*mRadius; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if a sphere is contained within the LSS.
- * \param sphere [in] the sphere to test
- * \return true if inside the LSS
- * \warning sphere and LSS must be in same space
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool Contains(const Sphere& sphere)
- {
- float d = mRadius - sphere.mRadius;
- if(d>=0.0f) return SquareDistance(sphere.mCenter) <= d*d;
- else return false;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if an LSS is contained within the LSS.
- * \param lss [in] the LSS to test
- * \return true if inside the LSS
- * \warning both LSS must be in same space
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool Contains(const LSS& lss)
- {
- // We check the LSS contains the two spheres at the start and end of the sweep
- return Contains(Sphere(lss.mP0, lss.mRadius)) && Contains(Sphere(lss.mP0, lss.mRadius));
- }
-
- float mRadius; //!< Sphere radius
- };
-
-#endif // __ICELSS_H__
diff --git a/Opcode/OpcodeLib/Ice/IceMatrix3x3.cpp b/Opcode/OpcodeLib/Ice/IceMatrix3x3.cpp deleted file mode 100644 index 189d39d..0000000 --- a/Opcode/OpcodeLib/Ice/IceMatrix3x3.cpp +++ /dev/null @@ -1,48 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for 3x3 matrices.
- * \file IceMatrix3x3.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * 3x3 matrix.
- * DirectX-compliant, ie row-column order, ie m[Row][Col].
- * Same as:
- * m11 m12 m13 first row.
- * m21 m22 m23 second row.
- * m31 m32 m33 third row.
- * Stored in memory as m11 m12 m13 m21...
- *
- * Multiplication rules:
- *
- * [x'y'z'] = [xyz][M]
- *
- * x' = x*m11 + y*m21 + z*m31
- * y' = x*m12 + y*m22 + z*m32
- * z' = x*m13 + y*m23 + z*m33
- *
- * \class Matrix3x3
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-// Cast operator
-Matrix3x3::operator Matrix4x4() const
-{
- return Matrix4x4(
- m[0][0], m[0][1], m[0][2], 0.0f,
- m[1][0], m[1][1], m[1][2], 0.0f,
- m[2][0], m[2][1], m[2][2], 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f);
-}
diff --git a/Opcode/OpcodeLib/Ice/IceMatrix3x3.h b/Opcode/OpcodeLib/Ice/IceMatrix3x3.h deleted file mode 100644 index 07f5759..0000000 --- a/Opcode/OpcodeLib/Ice/IceMatrix3x3.h +++ /dev/null @@ -1,496 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for 3x3 matrices.
- * \file IceMatrix3x3.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEMATRIX3X3_H__
-#define __ICEMATRIX3X3_H__
-
- // Forward declarations
- class Quat;
-
- #define MATRIX3X3_EPSILON (1.0e-7f)
-
- class ICEMATHS_API Matrix3x3
- {
- public:
- //! Empty constructor
- inline_ Matrix3x3() {}
- //! Constructor from 9 values
- inline_ Matrix3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
- {
- m[0][0] = m00; m[0][1] = m01; m[0][2] = m02;
- m[1][0] = m10; m[1][1] = m11; m[1][2] = m12;
- m[2][0] = m20; m[2][1] = m21; m[2][2] = m22;
- }
- //! Copy constructor
- inline_ Matrix3x3(const Matrix3x3& mat) { CopyMemory(m, &mat.m, 9*sizeof(float)); }
- //! Destructor
- inline_ ~Matrix3x3() {}
-
- //! Assign values
- inline_ void Set(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
- {
- m[0][0] = m00; m[0][1] = m01; m[0][2] = m02;
- m[1][0] = m10; m[1][1] = m11; m[1][2] = m12;
- m[2][0] = m20; m[2][1] = m21; m[2][2] = m22;
- }
-
- //! Sets the scale from a IcePoint. The point is put on the diagonal.
- inline_ void SetScale(const IcePoint& p) { m[0][0] = p.x; m[1][1] = p.y; m[2][2] = p.z; }
-
- //! Sets the scale from floats. Values are put on the diagonal.
- inline_ void SetScale(float sx, float sy, float sz) { m[0][0] = sx; m[1][1] = sy; m[2][2] = sz; }
-
- //! Scales from a IcePoint. Each row is multiplied by a component.
- inline_ void Scale(const IcePoint& p)
- {
- m[0][0] *= p.x; m[0][1] *= p.x; m[0][2] *= p.x;
- m[1][0] *= p.y; m[1][1] *= p.y; m[1][2] *= p.y;
- m[2][0] *= p.z; m[2][1] *= p.z; m[2][2] *= p.z;
- }
-
- //! Scales from floats. Each row is multiplied by a value.
- inline_ void Scale(float sx, float sy, float sz)
- {
- m[0][0] *= sx; m[0][1] *= sx; m[0][2] *= sx;
- m[1][0] *= sy; m[1][1] *= sy; m[1][2] *= sy;
- m[2][0] *= sz; m[2][1] *= sz; m[2][2] *= sz;
- }
-
- //! Copy from a Matrix3x3
- inline_ void Copy(const Matrix3x3& source) { CopyMemory(m, source.m, 9*sizeof(float)); }
-
- // Row-column access
- //! Returns a row.
- inline_ void GetRow(const udword r, IcePoint& p) const { p.x = m[r][0]; p.y = m[r][1]; p.z = m[r][2]; }
- //! Returns a row.
- inline_ const IcePoint& GetRow(const udword r) const { return *(const IcePoint*)&m[r][0]; }
- //! Returns a row.
- inline_ IcePoint& GetRow(const udword r) { return *(IcePoint*)&m[r][0]; }
- //! Sets a row.
- inline_ void SetRow(const udword r, const IcePoint& p) { m[r][0] = p.x; m[r][1] = p.y; m[r][2] = p.z; }
- //! Returns a column.
- inline_ void GetCol(const udword c, IcePoint& p) const { p.x = m[0][c]; p.y = m[1][c]; p.z = m[2][c]; }
- //! Sets a column.
- inline_ void SetCol(const udword c, const IcePoint& p) { m[0][c] = p.x; m[1][c] = p.y; m[2][c] = p.z; }
-
- //! Computes the trace. The trace is the sum of the 3 diagonal components.
- inline_ float Trace() const { return m[0][0] + m[1][1] + m[2][2]; }
- //! Clears the matrix.
- inline_ void Zero() { ZeroMemory(&m, sizeof(m)); }
- //! Sets the identity matrix.
- inline_ void Identity() { Zero(); m[0][0] = m[1][1] = m[2][2] = 1.0f; }
- //! Checks for identity
- inline_ bool IsIdentity() const
- {
- if(IR(m[0][0])!=IEEE_1_0) return false;
- if(IR(m[0][1])!=0) return false;
- if(IR(m[0][2])!=0) return false;
-
- if(IR(m[1][0])!=0) return false;
- if(IR(m[1][1])!=IEEE_1_0) return false;
- if(IR(m[1][2])!=0) return false;
-
- if(IR(m[2][0])!=0) return false;
- if(IR(m[2][1])!=0) return false;
- if(IR(m[2][2])!=IEEE_1_0) return false;
-
- return true;
- }
-
- //! Checks matrix validity
- inline_ BOOL IsValid() const
- {
- for(udword j=0;j<3;j++)
- {
- for(udword i=0;i<3;i++)
- {
- if(!IsValidFloat(m[j][i])) return FALSE;
- }
- }
- return TRUE;
- }
-
- //! Makes a skew-symmetric matrix (a.k.a. Star(*) Matrix)
- //! [ 0.0 -a.z a.y ]
- //! [ a.z 0.0 -a.x ]
- //! [ -a.y a.x 0.0 ]
- //! This is also called a "cross matrix" since for any vectors A and B,
- //! A^B = Skew(A) * B = - B * Skew(A);
- inline_ void SkewSymmetric(const IcePoint& a)
- {
- m[0][0] = 0.0f;
- m[0][1] = -a.z;
- m[0][2] = a.y;
-
- m[1][0] = a.z;
- m[1][1] = 0.0f;
- m[1][2] = -a.x;
-
- m[2][0] = -a.y;
- m[2][1] = a.x;
- m[2][2] = 0.0f;
- }
-
- //! Negates the matrix
- inline_ void Neg()
- {
- m[0][0] = -m[0][0]; m[0][1] = -m[0][1]; m[0][2] = -m[0][2];
- m[1][0] = -m[1][0]; m[1][1] = -m[1][1]; m[1][2] = -m[1][2];
- m[2][0] = -m[2][0]; m[2][1] = -m[2][1]; m[2][2] = -m[2][2];
- }
-
- //! Neg from another matrix
- inline_ void Neg(const Matrix3x3& mat)
- {
- m[0][0] = -mat.m[0][0]; m[0][1] = -mat.m[0][1]; m[0][2] = -mat.m[0][2];
- m[1][0] = -mat.m[1][0]; m[1][1] = -mat.m[1][1]; m[1][2] = -mat.m[1][2];
- m[2][0] = -mat.m[2][0]; m[2][1] = -mat.m[2][1]; m[2][2] = -mat.m[2][2];
- }
-
- //! Add another matrix
- inline_ void Add(const Matrix3x3& mat)
- {
- m[0][0] += mat.m[0][0]; m[0][1] += mat.m[0][1]; m[0][2] += mat.m[0][2];
- m[1][0] += mat.m[1][0]; m[1][1] += mat.m[1][1]; m[1][2] += mat.m[1][2];
- m[2][0] += mat.m[2][0]; m[2][1] += mat.m[2][1]; m[2][2] += mat.m[2][2];
- }
-
- //! Sub another matrix
- inline_ void Sub(const Matrix3x3& mat)
- {
- m[0][0] -= mat.m[0][0]; m[0][1] -= mat.m[0][1]; m[0][2] -= mat.m[0][2];
- m[1][0] -= mat.m[1][0]; m[1][1] -= mat.m[1][1]; m[1][2] -= mat.m[1][2];
- m[2][0] -= mat.m[2][0]; m[2][1] -= mat.m[2][1]; m[2][2] -= mat.m[2][2];
- }
- //! Mac
- inline_ void Mac(const Matrix3x3& a, const Matrix3x3& b, float s)
- {
- m[0][0] = a.m[0][0] + b.m[0][0] * s;
- m[0][1] = a.m[0][1] + b.m[0][1] * s;
- m[0][2] = a.m[0][2] + b.m[0][2] * s;
-
- m[1][0] = a.m[1][0] + b.m[1][0] * s;
- m[1][1] = a.m[1][1] + b.m[1][1] * s;
- m[1][2] = a.m[1][2] + b.m[1][2] * s;
-
- m[2][0] = a.m[2][0] + b.m[2][0] * s;
- m[2][1] = a.m[2][1] + b.m[2][1] * s;
- m[2][2] = a.m[2][2] + b.m[2][2] * s;
- }
- //! Mac
- inline_ void Mac(const Matrix3x3& a, float s)
- {
- m[0][0] += a.m[0][0] * s; m[0][1] += a.m[0][1] * s; m[0][2] += a.m[0][2] * s;
- m[1][0] += a.m[1][0] * s; m[1][1] += a.m[1][1] * s; m[1][2] += a.m[1][2] * s;
- m[2][0] += a.m[2][0] * s; m[2][1] += a.m[2][1] * s; m[2][2] += a.m[2][2] * s;
- }
-
- //! this = A * s
- inline_ void Mult(const Matrix3x3& a, float s)
- {
- m[0][0] = a.m[0][0] * s; m[0][1] = a.m[0][1] * s; m[0][2] = a.m[0][2] * s;
- m[1][0] = a.m[1][0] * s; m[1][1] = a.m[1][1] * s; m[1][2] = a.m[1][2] * s;
- m[2][0] = a.m[2][0] * s; m[2][1] = a.m[2][1] * s; m[2][2] = a.m[2][2] * s;
- }
-
- inline_ void Add(const Matrix3x3& a, const Matrix3x3& b)
- {
- m[0][0] = a.m[0][0] + b.m[0][0]; m[0][1] = a.m[0][1] + b.m[0][1]; m[0][2] = a.m[0][2] + b.m[0][2];
- m[1][0] = a.m[1][0] + b.m[1][0]; m[1][1] = a.m[1][1] + b.m[1][1]; m[1][2] = a.m[1][2] + b.m[1][2];
- m[2][0] = a.m[2][0] + b.m[2][0]; m[2][1] = a.m[2][1] + b.m[2][1]; m[2][2] = a.m[2][2] + b.m[2][2];
- }
-
- inline_ void Sub(const Matrix3x3& a, const Matrix3x3& b)
- {
- m[0][0] = a.m[0][0] - b.m[0][0]; m[0][1] = a.m[0][1] - b.m[0][1]; m[0][2] = a.m[0][2] - b.m[0][2];
- m[1][0] = a.m[1][0] - b.m[1][0]; m[1][1] = a.m[1][1] - b.m[1][1]; m[1][2] = a.m[1][2] - b.m[1][2];
- m[2][0] = a.m[2][0] - b.m[2][0]; m[2][1] = a.m[2][1] - b.m[2][1]; m[2][2] = a.m[2][2] - b.m[2][2];
- }
-
- //! this = a * b
- inline_ void Mult(const Matrix3x3& a, const Matrix3x3& b)
- {
- m[0][0] = a.m[0][0] * b.m[0][0] + a.m[0][1] * b.m[1][0] + a.m[0][2] * b.m[2][0];
- m[0][1] = a.m[0][0] * b.m[0][1] + a.m[0][1] * b.m[1][1] + a.m[0][2] * b.m[2][1];
- m[0][2] = a.m[0][0] * b.m[0][2] + a.m[0][1] * b.m[1][2] + a.m[0][2] * b.m[2][2];
- m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[1][0] + a.m[1][2] * b.m[2][0];
- m[1][1] = a.m[1][0] * b.m[0][1] + a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[2][1];
- m[1][2] = a.m[1][0] * b.m[0][2] + a.m[1][1] * b.m[1][2] + a.m[1][2] * b.m[2][2];
- m[2][0] = a.m[2][0] * b.m[0][0] + a.m[2][1] * b.m[1][0] + a.m[2][2] * b.m[2][0];
- m[2][1] = a.m[2][0] * b.m[0][1] + a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[2][1];
- m[2][2] = a.m[2][0] * b.m[0][2] + a.m[2][1] * b.m[1][2] + a.m[2][2] * b.m[2][2];
- }
-
- //! this = transpose(a) * b
- inline_ void MultAtB(const Matrix3x3& a, const Matrix3x3& b)
- {
- m[0][0] = a.m[0][0] * b.m[0][0] + a.m[1][0] * b.m[1][0] + a.m[2][0] * b.m[2][0];
- m[0][1] = a.m[0][0] * b.m[0][1] + a.m[1][0] * b.m[1][1] + a.m[2][0] * b.m[2][1];
- m[0][2] = a.m[0][0] * b.m[0][2] + a.m[1][0] * b.m[1][2] + a.m[2][0] * b.m[2][2];
- m[1][0] = a.m[0][1] * b.m[0][0] + a.m[1][1] * b.m[1][0] + a.m[2][1] * b.m[2][0];
- m[1][1] = a.m[0][1] * b.m[0][1] + a.m[1][1] * b.m[1][1] + a.m[2][1] * b.m[2][1];
- m[1][2] = a.m[0][1] * b.m[0][2] + a.m[1][1] * b.m[1][2] + a.m[2][1] * b.m[2][2];
- m[2][0] = a.m[0][2] * b.m[0][0] + a.m[1][2] * b.m[1][0] + a.m[2][2] * b.m[2][0];
- m[2][1] = a.m[0][2] * b.m[0][1] + a.m[1][2] * b.m[1][1] + a.m[2][2] * b.m[2][1];
- m[2][2] = a.m[0][2] * b.m[0][2] + a.m[1][2] * b.m[1][2] + a.m[2][2] * b.m[2][2];
- }
-
- //! this = a * transpose(b)
- inline_ void MultABt(const Matrix3x3& a, const Matrix3x3& b)
- {
- m[0][0] = a.m[0][0] * b.m[0][0] + a.m[0][1] * b.m[0][1] + a.m[0][2] * b.m[0][2];
- m[0][1] = a.m[0][0] * b.m[1][0] + a.m[0][1] * b.m[1][1] + a.m[0][2] * b.m[1][2];
- m[0][2] = a.m[0][0] * b.m[2][0] + a.m[0][1] * b.m[2][1] + a.m[0][2] * b.m[2][2];
- m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[0][1] + a.m[1][2] * b.m[0][2];
- m[1][1] = a.m[1][0] * b.m[1][0] + a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[1][2];
- m[1][2] = a.m[1][0] * b.m[2][0] + a.m[1][1] * b.m[2][1] + a.m[1][2] * b.m[2][2];
- m[2][0] = a.m[2][0] * b.m[0][0] + a.m[2][1] * b.m[0][1] + a.m[2][2] * b.m[0][2];
- m[2][1] = a.m[2][0] * b.m[1][0] + a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[1][2];
- m[2][2] = a.m[2][0] * b.m[2][0] + a.m[2][1] * b.m[2][1] + a.m[2][2] * b.m[2][2];
- }
-
- //! Makes a rotation matrix mapping vector "from" to vector "to".
- Matrix3x3& FromTo(const IcePoint& from, const IcePoint& to);
-
- //! Set a rotation matrix around the X axis.
- //! 1 0 0
- //! RX = 0 cx sx
- //! 0 -sx cx
- void RotX(float angle);
- //! Set a rotation matrix around the Y axis.
- //! cy 0 -sy
- //! RY = 0 1 0
- //! sy 0 cy
- void RotY(float angle);
- //! Set a rotation matrix around the Z axis.
- //! cz sz 0
- //! RZ = -sz cz 0
- //! 0 0 1
- void RotZ(float angle);
- //! cy sx.sy -sy.cx
- //! RY.RX 0 cx sx
- //! sy -sx.cy cx.cy
- void RotYX(float y, float x);
-
- //! Make a rotation matrix about an arbitrary axis
- Matrix3x3& Rot(float angle, const IcePoint& axis);
-
- //! Transpose the matrix.
- void Transpose()
- {
- IR(m[1][0]) ^= IR(m[0][1]); IR(m[0][1]) ^= IR(m[1][0]); IR(m[1][0]) ^= IR(m[0][1]);
- IR(m[2][0]) ^= IR(m[0][2]); IR(m[0][2]) ^= IR(m[2][0]); IR(m[2][0]) ^= IR(m[0][2]);
- IR(m[2][1]) ^= IR(m[1][2]); IR(m[1][2]) ^= IR(m[2][1]); IR(m[2][1]) ^= IR(m[1][2]);
- }
-
- //! this = Transpose(a)
- void Transpose(const Matrix3x3& a)
- {
- m[0][0] = a.m[0][0]; m[0][1] = a.m[1][0]; m[0][2] = a.m[2][0];
- m[1][0] = a.m[0][1]; m[1][1] = a.m[1][1]; m[1][2] = a.m[2][1];
- m[2][0] = a.m[0][2]; m[2][1] = a.m[1][2]; m[2][2] = a.m[2][2];
- }
-
- //! Compute the determinant of the matrix. We use the rule of Sarrus.
- float Determinant() const
- {
- return (m[0][0]*m[1][1]*m[2][2] + m[0][1]*m[1][2]*m[2][0] + m[0][2]*m[1][0]*m[2][1])
- - (m[2][0]*m[1][1]*m[0][2] + m[2][1]*m[1][2]*m[0][0] + m[2][2]*m[1][0]*m[0][1]);
- }
-/*
- //! Compute a cofactor. Used for matrix inversion.
- float CoFactor(ubyte row, ubyte column) const
- {
- static sdword gIndex[3+2] = { 0, 1, 2, 0, 1 };
- return (m[gIndex[row+1]][gIndex[column+1]]*m[gIndex[row+2]][gIndex[column+2]] - m[gIndex[row+2]][gIndex[column+1]]*m[gIndex[row+1]][gIndex[column+2]]);
- }
-*/
- //! Invert the matrix. Determinant must be different from zero, else matrix can't be inverted.
- Matrix3x3& Invert()
- {
- float Det = Determinant(); // Must be !=0
- float OneOverDet = 1.0f / Det;
-
- Matrix3x3 Temp;
- Temp.m[0][0] = +(m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDet;
- Temp.m[1][0] = -(m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDet;
- Temp.m[2][0] = +(m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDet;
- Temp.m[0][1] = -(m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDet;
- Temp.m[1][1] = +(m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDet;
- Temp.m[2][1] = -(m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDet;
- Temp.m[0][2] = +(m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDet;
- Temp.m[1][2] = -(m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDet;
- Temp.m[2][2] = +(m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDet;
-
- *this = Temp;
-
- return *this;
- }
-
- Matrix3x3& Normalize();
-
- //! this = exp(a)
- Matrix3x3& Exp(const Matrix3x3& a);
-
-void FromQuat(const Quat &q);
-void FromQuatL2(const Quat &q, float l2);
-
- // Arithmetic operators
- //! Operator for Matrix3x3 Plus = Matrix3x3 + Matrix3x3;
- inline_ Matrix3x3 operator+(const Matrix3x3& mat) const
- {
- return Matrix3x3(
- m[0][0] + mat.m[0][0], m[0][1] + mat.m[0][1], m[0][2] + mat.m[0][2],
- m[1][0] + mat.m[1][0], m[1][1] + mat.m[1][1], m[1][2] + mat.m[1][2],
- m[2][0] + mat.m[2][0], m[2][1] + mat.m[2][1], m[2][2] + mat.m[2][2]);
- }
-
- //! Operator for Matrix3x3 Minus = Matrix3x3 - Matrix3x3;
- inline_ Matrix3x3 operator-(const Matrix3x3& mat) const
- {
- return Matrix3x3(
- m[0][0] - mat.m[0][0], m[0][1] - mat.m[0][1], m[0][2] - mat.m[0][2],
- m[1][0] - mat.m[1][0], m[1][1] - mat.m[1][1], m[1][2] - mat.m[1][2],
- m[2][0] - mat.m[2][0], m[2][1] - mat.m[2][1], m[2][2] - mat.m[2][2]);
- }
-
- //! Operator for Matrix3x3 Mul = Matrix3x3 * Matrix3x3;
- inline_ Matrix3x3 operator*(const Matrix3x3& mat) const
- {
- return Matrix3x3(
- m[0][0]*mat.m[0][0] + m[0][1]*mat.m[1][0] + m[0][2]*mat.m[2][0],
- m[0][0]*mat.m[0][1] + m[0][1]*mat.m[1][1] + m[0][2]*mat.m[2][1],
- m[0][0]*mat.m[0][2] + m[0][1]*mat.m[1][2] + m[0][2]*mat.m[2][2],
-
- m[1][0]*mat.m[0][0] + m[1][1]*mat.m[1][0] + m[1][2]*mat.m[2][0],
- m[1][0]*mat.m[0][1] + m[1][1]*mat.m[1][1] + m[1][2]*mat.m[2][1],
- m[1][0]*mat.m[0][2] + m[1][1]*mat.m[1][2] + m[1][2]*mat.m[2][2],
-
- m[2][0]*mat.m[0][0] + m[2][1]*mat.m[1][0] + m[2][2]*mat.m[2][0],
- m[2][0]*mat.m[0][1] + m[2][1]*mat.m[1][1] + m[2][2]*mat.m[2][1],
- m[2][0]*mat.m[0][2] + m[2][1]*mat.m[1][2] + m[2][2]*mat.m[2][2]);
- }
-
- //! Operator for IcePoint Mul = Matrix3x3 * IcePoint;
- inline_ IcePoint operator*(const IcePoint& v) const { return IcePoint(GetRow(0)|v, GetRow(1)|v, GetRow(2)|v); }
-
- //! Operator for Matrix3x3 Mul = Matrix3x3 * float;
- inline_ Matrix3x3 operator*(float s) const
- {
- return Matrix3x3(
- m[0][0]*s, m[0][1]*s, m[0][2]*s,
- m[1][0]*s, m[1][1]*s, m[1][2]*s,
- m[2][0]*s, m[2][1]*s, m[2][2]*s);
- }
-
- //! Operator for Matrix3x3 Mul = float * Matrix3x3;
- inline_ friend Matrix3x3 operator*(float s, const Matrix3x3& mat)
- {
- return Matrix3x3(
- s*mat.m[0][0], s*mat.m[0][1], s*mat.m[0][2],
- s*mat.m[1][0], s*mat.m[1][1], s*mat.m[1][2],
- s*mat.m[2][0], s*mat.m[2][1], s*mat.m[2][2]);
- }
-
- //! Operator for Matrix3x3 Div = Matrix3x3 / float;
- inline_ Matrix3x3 operator/(float s) const
- {
- if (s) s = 1.0f / s;
- return Matrix3x3(
- m[0][0]*s, m[0][1]*s, m[0][2]*s,
- m[1][0]*s, m[1][1]*s, m[1][2]*s,
- m[2][0]*s, m[2][1]*s, m[2][2]*s);
- }
-
- //! Operator for Matrix3x3 Div = float / Matrix3x3;
- inline_ friend Matrix3x3 operator/(float s, const Matrix3x3& mat)
- {
- return Matrix3x3(
- s/mat.m[0][0], s/mat.m[0][1], s/mat.m[0][2],
- s/mat.m[1][0], s/mat.m[1][1], s/mat.m[1][2],
- s/mat.m[2][0], s/mat.m[2][1], s/mat.m[2][2]);
- }
-
- //! Operator for Matrix3x3 += Matrix3x3
- inline_ Matrix3x3& operator+=(const Matrix3x3& mat)
- {
- m[0][0] += mat.m[0][0]; m[0][1] += mat.m[0][1]; m[0][2] += mat.m[0][2];
- m[1][0] += mat.m[1][0]; m[1][1] += mat.m[1][1]; m[1][2] += mat.m[1][2];
- m[2][0] += mat.m[2][0]; m[2][1] += mat.m[2][1]; m[2][2] += mat.m[2][2];
- return *this;
- }
-
- //! Operator for Matrix3x3 -= Matrix3x3
- inline_ Matrix3x3& operator-=(const Matrix3x3& mat)
- {
- m[0][0] -= mat.m[0][0]; m[0][1] -= mat.m[0][1]; m[0][2] -= mat.m[0][2];
- m[1][0] -= mat.m[1][0]; m[1][1] -= mat.m[1][1]; m[1][2] -= mat.m[1][2];
- m[2][0] -= mat.m[2][0]; m[2][1] -= mat.m[2][1]; m[2][2] -= mat.m[2][2];
- return *this;
- }
-
- //! Operator for Matrix3x3 *= Matrix3x3
- inline_ Matrix3x3& operator*=(const Matrix3x3& mat)
- {
- IcePoint TempRow;
-
- GetRow(0, TempRow);
- m[0][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
- m[0][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
- m[0][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
-
- GetRow(1, TempRow);
- m[1][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
- m[1][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
- m[1][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
-
- GetRow(2, TempRow);
- m[2][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
- m[2][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
- m[2][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
- return *this;
- }
-
- //! Operator for Matrix3x3 *= float
- inline_ Matrix3x3& operator*=(float s)
- {
- m[0][0] *= s; m[0][1] *= s; m[0][2] *= s;
- m[1][0] *= s; m[1][1] *= s; m[1][2] *= s;
- m[2][0] *= s; m[2][1] *= s; m[2][2] *= s;
- return *this;
- }
-
- //! Operator for Matrix3x3 /= float
- inline_ Matrix3x3& operator/=(float s)
- {
- if (s) s = 1.0f / s;
- m[0][0] *= s; m[0][1] *= s; m[0][2] *= s;
- m[1][0] *= s; m[1][1] *= s; m[1][2] *= s;
- m[2][0] *= s; m[2][1] *= s; m[2][2] *= s;
- return *this;
- }
-
- // Cast operators
- //! Cast a Matrix3x3 to a Matrix4x4.
- operator Matrix4x4() const;
- //! Cast a Matrix3x3 to a Quat.
- operator Quat() const;
-
- inline_ const IcePoint& operator[](int row) const { return *(const IcePoint*)&m[row][0]; }
- inline_ IcePoint& operator[](int row) { return *(IcePoint*)&m[row][0]; }
-
- public:
-
- float m[3][3];
- };
-
-#endif // __ICEMATRIX3X3_H__
-
diff --git a/Opcode/OpcodeLib/Ice/IceMatrix4x4.cpp b/Opcode/OpcodeLib/Ice/IceMatrix4x4.cpp deleted file mode 100644 index 4c539c9..0000000 --- a/Opcode/OpcodeLib/Ice/IceMatrix4x4.cpp +++ /dev/null @@ -1,135 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for 4x4 matrices.
- * \file IceMatrix4x4.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * 4x4 matrix.
- * DirectX-compliant, ie row-column order, ie m[Row][Col].
- * Same as:
- * m11 m12 m13 m14 first row.
- * m21 m22 m23 m24 second row.
- * m31 m32 m33 m34 third row.
- * m41 m42 m43 m44 fourth row.
- * Translation is (m41, m42, m43), (m14, m24, m34, m44) = (0, 0, 0, 1).
- * Stored in memory as m11 m12 m13 m14 m21...
- *
- * Multiplication rules:
- *
- * [x'y'z'1] = [xyz1][M]
- *
- * x' = x*m11 + y*m21 + z*m31 + m41
- * y' = x*m12 + y*m22 + z*m32 + m42
- * z' = x*m13 + y*m23 + z*m33 + m43
- * 1' = 0 + 0 + 0 + m44
- *
- * \class Matrix4x4
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Inverts a PR matrix. (which only contains a rotation and a translation)
- * This is faster and less subject to FPU errors than the generic inversion code.
- *
- * \relates Matrix4x4
- * \fn InvertPRMatrix(Matrix4x4& dest, const Matrix4x4& src)
- * \param dest [out] destination matrix
- * \param src [in] source matrix
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-ICEMATHS_API void IceMaths::InvertPRMatrix(Matrix4x4& dest, const Matrix4x4& src)
-{
- dest.m[0][0] = src.m[0][0];
- dest.m[1][0] = src.m[0][1];
- dest.m[2][0] = src.m[0][2];
- dest.m[3][0] = -(src.m[3][0]*src.m[0][0] + src.m[3][1]*src.m[0][1] + src.m[3][2]*src.m[0][2]);
-
- dest.m[0][1] = src.m[1][0];
- dest.m[1][1] = src.m[1][1];
- dest.m[2][1] = src.m[1][2];
- dest.m[3][1] = -(src.m[3][0]*src.m[1][0] + src.m[3][1]*src.m[1][1] + src.m[3][2]*src.m[1][2]);
-
- dest.m[0][2] = src.m[2][0];
- dest.m[1][2] = src.m[2][1];
- dest.m[2][2] = src.m[2][2];
- dest.m[3][2] = -(src.m[3][0]*src.m[2][0] + src.m[3][1]*src.m[2][1] + src.m[3][2]*src.m[2][2]);
-
- dest.m[0][3] = 0.0f;
- dest.m[1][3] = 0.0f;
- dest.m[2][3] = 0.0f;
- dest.m[3][3] = 1.0f;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Compute the cofactor of the Matrix at a specified location
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Matrix4x4::CoFactor(udword row, udword col) const
-{
- return (( m[(row+1)&3][(col+1)&3]*m[(row+2)&3][(col+2)&3]*m[(row+3)&3][(col+3)&3] +
- m[(row+1)&3][(col+2)&3]*m[(row+2)&3][(col+3)&3]*m[(row+3)&3][(col+1)&3] +
- m[(row+1)&3][(col+3)&3]*m[(row+2)&3][(col+1)&3]*m[(row+3)&3][(col+2)&3])
- - (m[(row+3)&3][(col+1)&3]*m[(row+2)&3][(col+2)&3]*m[(row+1)&3][(col+3)&3] +
- m[(row+3)&3][(col+2)&3]*m[(row+2)&3][(col+3)&3]*m[(row+1)&3][(col+1)&3] +
- m[(row+3)&3][(col+3)&3]*m[(row+2)&3][(col+1)&3]*m[(row+1)&3][(col+2)&3])) * ((row + col) & 1 ? -1.0f : +1.0f);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Compute the determinant of the Matrix
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Matrix4x4::Determinant() const
-{
- return m[0][0] * CoFactor(0, 0) +
- m[0][1] * CoFactor(0, 1) +
- m[0][2] * CoFactor(0, 2) +
- m[0][3] * CoFactor(0, 3);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Compute the inverse of the matrix
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Matrix4x4& Matrix4x4::Invert()
-{
- float Det = Determinant();
- Matrix4x4 Temp;
-
- if(fabsf(Det) < MATRIX4X4_EPSILON)
- return *this; // The matrix is not invertible! Singular case!
-
- float IDet = 1.0f / Det;
-
- Temp.m[0][0] = CoFactor(0,0) * IDet;
- Temp.m[1][0] = CoFactor(0,1) * IDet;
- Temp.m[2][0] = CoFactor(0,2) * IDet;
- Temp.m[3][0] = CoFactor(0,3) * IDet;
- Temp.m[0][1] = CoFactor(1,0) * IDet;
- Temp.m[1][1] = CoFactor(1,1) * IDet;
- Temp.m[2][1] = CoFactor(1,2) * IDet;
- Temp.m[3][1] = CoFactor(1,3) * IDet;
- Temp.m[0][2] = CoFactor(2,0) * IDet;
- Temp.m[1][2] = CoFactor(2,1) * IDet;
- Temp.m[2][2] = CoFactor(2,2) * IDet;
- Temp.m[3][2] = CoFactor(2,3) * IDet;
- Temp.m[0][3] = CoFactor(3,0) * IDet;
- Temp.m[1][3] = CoFactor(3,1) * IDet;
- Temp.m[2][3] = CoFactor(3,2) * IDet;
- Temp.m[3][3] = CoFactor(3,3) * IDet;
-
- *this = Temp;
-
- return *this;
-}
-
diff --git a/Opcode/OpcodeLib/Ice/IceMatrix4x4.h b/Opcode/OpcodeLib/Ice/IceMatrix4x4.h deleted file mode 100644 index f7658da..0000000 --- a/Opcode/OpcodeLib/Ice/IceMatrix4x4.h +++ /dev/null @@ -1,455 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for 4x4 matrices.
- * \file IceMatrix4x4.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEMATRIX4X4_H__
-#define __ICEMATRIX4X4_H__
-
- // Forward declarations
- class PRS;
- class PR;
-
- #define MATRIX4X4_EPSILON (1.0e-7f)
-
- class ICEMATHS_API Matrix4x4
- {
-// void LUBackwardSubstitution( sdword *indx, float* b );
-// void LUDecomposition( sdword* indx, float* d );
-
- public:
- //! Empty constructor.
- inline_ Matrix4x4() {}
- //! Constructor from 16 values
- inline_ Matrix4x4( float m00, float m01, float m02, float m03,
- float m10, float m11, float m12, float m13,
- float m20, float m21, float m22, float m23,
- float m30, float m31, float m32, float m33)
- {
- m[0][0] = m00; m[0][1] = m01; m[0][2] = m02; m[0][3] = m03;
- m[1][0] = m10; m[1][1] = m11; m[1][2] = m12; m[1][3] = m13;
- m[2][0] = m20; m[2][1] = m21; m[2][2] = m22; m[2][3] = m23;
- m[3][0] = m30; m[3][1] = m31; m[3][2] = m32; m[3][3] = m33;
- }
- //! Copy constructor
- inline_ Matrix4x4(const Matrix4x4& mat) { CopyMemory(m, &mat.m, 16*sizeof(float)); }
- //! Destructor.
- inline_ ~Matrix4x4() {}
-
- //! Assign values (rotation only)
- inline_ Matrix4x4& Set( float m00, float m01, float m02,
- float m10, float m11, float m12,
- float m20, float m21, float m22)
- {
- m[0][0] = m00; m[0][1] = m01; m[0][2] = m02;
- m[1][0] = m10; m[1][1] = m11; m[1][2] = m12;
- m[2][0] = m20; m[2][1] = m21; m[2][2] = m22;
- return *this;
- }
- //! Assign values
- inline_ Matrix4x4& Set( float m00, float m01, float m02, float m03,
- float m10, float m11, float m12, float m13,
- float m20, float m21, float m22, float m23,
- float m30, float m31, float m32, float m33)
- {
- m[0][0] = m00; m[0][1] = m01; m[0][2] = m02; m[0][3] = m03;
- m[1][0] = m10; m[1][1] = m11; m[1][2] = m12; m[1][3] = m13;
- m[2][0] = m20; m[2][1] = m21; m[2][2] = m22; m[2][3] = m23;
- m[3][0] = m30; m[3][1] = m31; m[3][2] = m32; m[3][3] = m33;
- return *this;
- }
-
- //! Copy from a Matrix4x4
- inline_ void Copy(const Matrix4x4& source) { CopyMemory(m, source.m, 16*sizeof(float)); }
-
- // Row-column access
- //! Returns a row.
- inline_ void GetRow(const udword r, HPoint& p) const { p.x=m[r][0]; p.y=m[r][1]; p.z=m[r][2]; p.w=m[r][3]; }
- //! Returns a row.
- inline_ void GetRow(const udword r, IcePoint& p) const { p.x=m[r][0]; p.y=m[r][1]; p.z=m[r][2]; }
- //! Returns a row.
- inline_ const HPoint& GetRow(const udword r) const { return *(const HPoint*)&m[r][0]; }
- //! Returns a row.
- inline_ HPoint& GetRow(const udword r) { return *(HPoint*)&m[r][0]; }
- //! Sets a row.
- inline_ void SetRow(const udword r, const HPoint& p) { m[r][0]=p.x; m[r][1]=p.y; m[r][2]=p.z; m[r][3]=p.w; }
- //! Sets a row.
- inline_ void SetRow(const udword r, const IcePoint& p) { m[r][0]=p.x; m[r][1]=p.y; m[r][2]=p.z; m[r][3]= (r!=3) ? 0.0f : 1.0f; }
- //! Returns a column.
- inline_ void GetCol(const udword c, HPoint& p) const { p.x=m[0][c]; p.y=m[1][c]; p.z=m[2][c]; p.w=m[3][c]; }
- //! Returns a column.
- inline_ void GetCol(const udword c, IcePoint& p) const { p.x=m[0][c]; p.y=m[1][c]; p.z=m[2][c]; }
- //! Sets a column.
- inline_ void SetCol(const udword c, const HPoint& p) { m[0][c]=p.x; m[1][c]=p.y; m[2][c]=p.z; m[3][c]=p.w; }
- //! Sets a column.
- inline_ void SetCol(const udword c, const IcePoint& p) { m[0][c]=p.x; m[1][c]=p.y; m[2][c]=p.z; m[3][c]= (c!=3) ? 0.0f : 1.0f; }
-
- // Translation
- //! Returns the translation part of the matrix.
- inline_ const HPoint& GetTrans() const { return GetRow(3); }
- //! Gets the translation part of the matrix
- inline_ void GetTrans(IcePoint& p) const { p.x=m[3][0]; p.y=m[3][1]; p.z=m[3][2]; }
- //! Sets the translation part of the matrix, from a IcePoint.
- inline_ void SetTrans(const IcePoint& p) { m[3][0]=p.x; m[3][1]=p.y; m[3][2]=p.z; }
- //! Sets the translation part of the matrix, from a HPoint.
- inline_ void SetTrans(const HPoint& p) { m[3][0]=p.x; m[3][1]=p.y; m[3][2]=p.z; m[3][3]=p.w; }
- //! Sets the translation part of the matrix, from floats.
- inline_ void SetTrans(float tx, float ty, float tz) { m[3][0]=tx; m[3][1]=ty; m[3][2]=tz; }
-
- // Scale
- //! Sets the scale from a IcePoint. The point is put on the diagonal.
- inline_ void SetScale(const IcePoint& p) { m[0][0]=p.x; m[1][1]=p.y; m[2][2]=p.z; }
- //! Sets the scale from floats. Values are put on the diagonal.
- inline_ void SetScale(float sx, float sy, float sz) { m[0][0]=sx; m[1][1]=sy; m[2][2]=sz; }
- //! Scales from a IcePoint. Each row is multiplied by a component.
- void Scale(const IcePoint& p)
- {
- m[0][0] *= p.x; m[1][0] *= p.y; m[2][0] *= p.z;
- m[0][1] *= p.x; m[1][1] *= p.y; m[2][1] *= p.z;
- m[0][2] *= p.x; m[1][2] *= p.y; m[2][2] *= p.z;
- }
- //! Scales from floats. Each row is multiplied by a value.
- void Scale(float sx, float sy, float sz)
- {
- m[0][0] *= sx; m[1][0] *= sy; m[2][0] *= sz;
- m[0][1] *= sx; m[1][1] *= sy; m[2][1] *= sz;
- m[0][2] *= sx; m[1][2] *= sy; m[2][2] *= sz;
- }
-/*
- //! Returns a row.
- inline_ HPoint GetRow(const udword row) const { return mRow[row]; }
- //! Sets a row.
- inline_ Matrix4x4& SetRow(const udword row, const HPoint& p) { mRow[row] = p; return *this; }
- //! Sets a row.
- Matrix4x4& SetRow(const udword row, const IcePoint& p)
- {
- m[row][0] = p.x;
- m[row][1] = p.y;
- m[row][2] = p.z;
- m[row][3] = (row != 3) ? 0.0f : 1.0f;
- return *this;
- }
- //! Returns a column.
- HPoint GetCol(const udword col) const
- {
- HPoint Res;
- Res.x = m[0][col];
- Res.y = m[1][col];
- Res.z = m[2][col];
- Res.w = m[3][col];
- return Res;
- }
- //! Sets a column.
- Matrix4x4& SetCol(const udword col, const HPoint& p)
- {
- m[0][col] = p.x;
- m[1][col] = p.y;
- m[2][col] = p.z;
- m[3][col] = p.w;
- return *this;
- }
- //! Sets a column.
- Matrix4x4& SetCol(const udword col, const IcePoint& p)
- {
- m[0][col] = p.x;
- m[1][col] = p.y;
- m[2][col] = p.z;
- m[3][col] = (col != 3) ? 0.0f : 1.0f;
- return *this;
- }
-*/
- //! Computes the trace. The trace is the sum of the 4 diagonal components.
- inline_ float Trace() const { return m[0][0] + m[1][1] + m[2][2] + m[3][3]; }
- //! Computes the trace of the upper 3x3 matrix.
- inline_ float Trace3x3() const { return m[0][0] + m[1][1] + m[2][2]; }
- //! Clears the matrix.
- inline_ void Zero() { ZeroMemory(&m, sizeof(m)); }
- //! Sets the identity matrix.
- inline_ void Identity() { Zero(); m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1.0f; }
- //! Checks for identity
- inline_ bool IsIdentity() const
- {
- if(IR(m[0][0])!=IEEE_1_0) return false;
- if(IR(m[0][1])!=0) return false;
- if(IR(m[0][2])!=0) return false;
- if(IR(m[0][3])!=0) return false;
-
- if(IR(m[1][0])!=0) return false;
- if(IR(m[1][1])!=IEEE_1_0) return false;
- if(IR(m[1][2])!=0) return false;
- if(IR(m[1][3])!=0) return false;
-
- if(IR(m[2][0])!=0) return false;
- if(IR(m[2][1])!=0) return false;
- if(IR(m[2][2])!=IEEE_1_0) return false;
- if(IR(m[2][3])!=0) return false;
-
- if(IR(m[3][0])!=0) return false;
- if(IR(m[3][1])!=0) return false;
- if(IR(m[3][2])!=0) return false;
- if(IR(m[3][3])!=IEEE_1_0) return false;
- return true;
- }
-
- //! Checks matrix validity
- inline_ BOOL IsValid() const
- {
- for(udword j=0;j<4;j++)
- {
- for(udword i=0;i<4;i++)
- {
- if(!IsValidFloat(m[j][i])) return FALSE;
- }
- }
- return TRUE;
- }
-
- //! Sets a rotation matrix around the X axis.
- void RotX(float angle) { float Cos = cosf(angle), Sin = sinf(angle); Identity(); m[1][1] = m[2][2] = Cos; m[2][1] = -Sin; m[1][2] = Sin; }
- //! Sets a rotation matrix around the Y axis.
- void RotY(float angle) { float Cos = cosf(angle), Sin = sinf(angle); Identity(); m[0][0] = m[2][2] = Cos; m[2][0] = Sin; m[0][2] = -Sin; }
- //! Sets a rotation matrix around the Z axis.
- void RotZ(float angle) { float Cos = cosf(angle), Sin = sinf(angle); Identity(); m[0][0] = m[1][1] = Cos; m[1][0] = -Sin; m[0][1] = Sin; }
-
- //! Makes a rotation matrix about an arbitrary axis
- Matrix4x4& Rot(float angle, IcePoint& p1, IcePoint& p2);
-
- //! Transposes the matrix.
- void Transpose()
- {
- IR(m[1][0]) ^= IR(m[0][1]); IR(m[0][1]) ^= IR(m[1][0]); IR(m[1][0]) ^= IR(m[0][1]);
- IR(m[2][0]) ^= IR(m[0][2]); IR(m[0][2]) ^= IR(m[2][0]); IR(m[2][0]) ^= IR(m[0][2]);
- IR(m[3][0]) ^= IR(m[0][3]); IR(m[0][3]) ^= IR(m[3][0]); IR(m[3][0]) ^= IR(m[0][3]);
- IR(m[1][2]) ^= IR(m[2][1]); IR(m[2][1]) ^= IR(m[1][2]); IR(m[1][2]) ^= IR(m[2][1]);
- IR(m[1][3]) ^= IR(m[3][1]); IR(m[3][1]) ^= IR(m[1][3]); IR(m[1][3]) ^= IR(m[3][1]);
- IR(m[2][3]) ^= IR(m[3][2]); IR(m[3][2]) ^= IR(m[2][3]); IR(m[2][3]) ^= IR(m[3][2]);
- }
-
- //! Computes a cofactor. Used for matrix inversion.
- float CoFactor(udword row, udword col) const;
- //! Computes the determinant of the matrix.
- float Determinant() const;
- //! Inverts the matrix. Determinant must be different from zero, else matrix can't be inverted.
- Matrix4x4& Invert();
-// Matrix& ComputeAxisMatrix(IcePoint& axis, float angle);
-
- // Cast operators
- //! Casts a Matrix4x4 to a Matrix3x3.
- inline_ operator Matrix3x3() const
- {
- return Matrix3x3(
- m[0][0], m[0][1], m[0][2],
- m[1][0], m[1][1], m[1][2],
- m[2][0], m[2][1], m[2][2]);
- }
- //! Casts a Matrix4x4 to a Quat.
- operator Quat() const;
- //! Casts a Matrix4x4 to a PR.
- operator PR() const;
-
- // Arithmetic operators
- //! Operator for Matrix4x4 Plus = Matrix4x4 + Matrix4x4;
- inline_ Matrix4x4 operator+(const Matrix4x4& mat) const
- {
- return Matrix4x4(
- m[0][0]+mat.m[0][0], m[0][1]+mat.m[0][1], m[0][2]+mat.m[0][2], m[0][3]+mat.m[0][3],
- m[1][0]+mat.m[1][0], m[1][1]+mat.m[1][1], m[1][2]+mat.m[1][2], m[1][3]+mat.m[1][3],
- m[2][0]+mat.m[2][0], m[2][1]+mat.m[2][1], m[2][2]+mat.m[2][2], m[2][3]+mat.m[2][3],
- m[3][0]+mat.m[3][0], m[3][1]+mat.m[3][1], m[3][2]+mat.m[3][2], m[3][3]+mat.m[3][3]);
- }
-
- //! Operator for Matrix4x4 Minus = Matrix4x4 - Matrix4x4;
- inline_ Matrix4x4 operator-(const Matrix4x4& mat) const
- {
- return Matrix4x4(
- m[0][0]-mat.m[0][0], m[0][1]-mat.m[0][1], m[0][2]-mat.m[0][2], m[0][3]-mat.m[0][3],
- m[1][0]-mat.m[1][0], m[1][1]-mat.m[1][1], m[1][2]-mat.m[1][2], m[1][3]-mat.m[1][3],
- m[2][0]-mat.m[2][0], m[2][1]-mat.m[2][1], m[2][2]-mat.m[2][2], m[2][3]-mat.m[2][3],
- m[3][0]-mat.m[3][0], m[3][1]-mat.m[3][1], m[3][2]-mat.m[3][2], m[3][3]-mat.m[3][3]);
- }
-
- //! Operator for Matrix4x4 Mul = Matrix4x4 * Matrix4x4;
- inline_ Matrix4x4 operator*(const Matrix4x4& mat) const
- {
- return Matrix4x4(
- m[0][0]*mat.m[0][0] + m[0][1]*mat.m[1][0] + m[0][2]*mat.m[2][0] + m[0][3]*mat.m[3][0],
- m[0][0]*mat.m[0][1] + m[0][1]*mat.m[1][1] + m[0][2]*mat.m[2][1] + m[0][3]*mat.m[3][1],
- m[0][0]*mat.m[0][2] + m[0][1]*mat.m[1][2] + m[0][2]*mat.m[2][2] + m[0][3]*mat.m[3][2],
- m[0][0]*mat.m[0][3] + m[0][1]*mat.m[1][3] + m[0][2]*mat.m[2][3] + m[0][3]*mat.m[3][3],
-
- m[1][0]*mat.m[0][0] + m[1][1]*mat.m[1][0] + m[1][2]*mat.m[2][0] + m[1][3]*mat.m[3][0],
- m[1][0]*mat.m[0][1] + m[1][1]*mat.m[1][1] + m[1][2]*mat.m[2][1] + m[1][3]*mat.m[3][1],
- m[1][0]*mat.m[0][2] + m[1][1]*mat.m[1][2] + m[1][2]*mat.m[2][2] + m[1][3]*mat.m[3][2],
- m[1][0]*mat.m[0][3] + m[1][1]*mat.m[1][3] + m[1][2]*mat.m[2][3] + m[1][3]*mat.m[3][3],
-
- m[2][0]*mat.m[0][0] + m[2][1]*mat.m[1][0] + m[2][2]*mat.m[2][0] + m[2][3]*mat.m[3][0],
- m[2][0]*mat.m[0][1] + m[2][1]*mat.m[1][1] + m[2][2]*mat.m[2][1] + m[2][3]*mat.m[3][1],
- m[2][0]*mat.m[0][2] + m[2][1]*mat.m[1][2] + m[2][2]*mat.m[2][2] + m[2][3]*mat.m[3][2],
- m[2][0]*mat.m[0][3] + m[2][1]*mat.m[1][3] + m[2][2]*mat.m[2][3] + m[2][3]*mat.m[3][3],
-
- m[3][0]*mat.m[0][0] + m[3][1]*mat.m[1][0] + m[3][2]*mat.m[2][0] + m[3][3]*mat.m[3][0],
- m[3][0]*mat.m[0][1] + m[3][1]*mat.m[1][1] + m[3][2]*mat.m[2][1] + m[3][3]*mat.m[3][1],
- m[3][0]*mat.m[0][2] + m[3][1]*mat.m[1][2] + m[3][2]*mat.m[2][2] + m[3][3]*mat.m[3][2],
- m[3][0]*mat.m[0][3] + m[3][1]*mat.m[1][3] + m[3][2]*mat.m[2][3] + m[3][3]*mat.m[3][3]);
- }
-
- //! Operator for HPoint Mul = Matrix4x4 * HPoint;
- inline_ HPoint operator*(const HPoint& v) const { return HPoint(GetRow(0)|v, GetRow(1)|v, GetRow(2)|v, GetRow(3)|v); }
-
- //! Operator for IcePoint Mul = Matrix4x4 * IcePoint;
- inline_ IcePoint operator*(const IcePoint& v) const
- {
- return IcePoint( m[0][0]*v.x + m[0][1]*v.y + m[0][2]*v.z + m[0][3],
- m[1][0]*v.x + m[1][1]*v.y + m[1][2]*v.z + m[1][3],
- m[2][0]*v.x + m[2][1]*v.y + m[2][2]*v.z + m[2][3] );
- }
-
- //! Operator for Matrix4x4 Scale = Matrix4x4 * float;
- inline_ Matrix4x4 operator*(float s) const
- {
- return Matrix4x4(
- m[0][0]*s, m[0][1]*s, m[0][2]*s, m[0][3]*s,
- m[1][0]*s, m[1][1]*s, m[1][2]*s, m[1][3]*s,
- m[2][0]*s, m[2][1]*s, m[2][2]*s, m[2][3]*s,
- m[3][0]*s, m[3][1]*s, m[3][2]*s, m[3][3]*s);
- }
-
- //! Operator for Matrix4x4 Scale = float * Matrix4x4;
- inline_ friend Matrix4x4 operator*(float s, const Matrix4x4& mat)
- {
- return Matrix4x4(
- s*mat.m[0][0], s*mat.m[0][1], s*mat.m[0][2], s*mat.m[0][3],
- s*mat.m[1][0], s*mat.m[1][1], s*mat.m[1][2], s*mat.m[1][3],
- s*mat.m[2][0], s*mat.m[2][1], s*mat.m[2][2], s*mat.m[2][3],
- s*mat.m[3][0], s*mat.m[3][1], s*mat.m[3][2], s*mat.m[3][3]);
- }
-
- //! Operator for Matrix4x4 Div = Matrix4x4 / float;
- inline_ Matrix4x4 operator/(float s) const
- {
- if(s) s = 1.0f / s;
-
- return Matrix4x4(
- m[0][0]*s, m[0][1]*s, m[0][2]*s, m[0][3]*s,
- m[1][0]*s, m[1][1]*s, m[1][2]*s, m[1][3]*s,
- m[2][0]*s, m[2][1]*s, m[2][2]*s, m[2][3]*s,
- m[3][0]*s, m[3][1]*s, m[3][2]*s, m[3][3]*s);
- }
-
- //! Operator for Matrix4x4 Div = float / Matrix4x4;
- inline_ friend Matrix4x4 operator/(float s, const Matrix4x4& mat)
- {
- return Matrix4x4(
- s/mat.m[0][0], s/mat.m[0][1], s/mat.m[0][2], s/mat.m[0][3],
- s/mat.m[1][0], s/mat.m[1][1], s/mat.m[1][2], s/mat.m[1][3],
- s/mat.m[2][0], s/mat.m[2][1], s/mat.m[2][2], s/mat.m[2][3],
- s/mat.m[3][0], s/mat.m[3][1], s/mat.m[3][2], s/mat.m[3][3]);
- }
-
- //! Operator for Matrix4x4 += Matrix4x4;
- inline_ Matrix4x4& operator+=(const Matrix4x4& mat)
- {
- m[0][0]+=mat.m[0][0]; m[0][1]+=mat.m[0][1]; m[0][2]+=mat.m[0][2]; m[0][3]+=mat.m[0][3];
- m[1][0]+=mat.m[1][0]; m[1][1]+=mat.m[1][1]; m[1][2]+=mat.m[1][2]; m[1][3]+=mat.m[1][3];
- m[2][0]+=mat.m[2][0]; m[2][1]+=mat.m[2][1]; m[2][2]+=mat.m[2][2]; m[2][3]+=mat.m[2][3];
- m[3][0]+=mat.m[3][0]; m[3][1]+=mat.m[3][1]; m[3][2]+=mat.m[3][2]; m[3][3]+=mat.m[3][3];
- return *this;
- }
-
- //! Operator for Matrix4x4 -= Matrix4x4;
- inline_ Matrix4x4& operator-=(const Matrix4x4& mat)
- {
- m[0][0]-=mat.m[0][0]; m[0][1]-=mat.m[0][1]; m[0][2]-=mat.m[0][2]; m[0][3]-=mat.m[0][3];
- m[1][0]-=mat.m[1][0]; m[1][1]-=mat.m[1][1]; m[1][2]-=mat.m[1][2]; m[1][3]-=mat.m[1][3];
- m[2][0]-=mat.m[2][0]; m[2][1]-=mat.m[2][1]; m[2][2]-=mat.m[2][2]; m[2][3]-=mat.m[2][3];
- m[3][0]-=mat.m[3][0]; m[3][1]-=mat.m[3][1]; m[3][2]-=mat.m[3][2]; m[3][3]-=mat.m[3][3];
- return *this;
- }
-
- //! Operator for Matrix4x4 *= Matrix4x4;
- Matrix4x4& operator*=(const Matrix4x4& mat)
- {
- HPoint TempRow;
-
- GetRow(0, TempRow);
- m[0][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0] + TempRow.w*mat.m[3][0];
- m[0][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1] + TempRow.w*mat.m[3][1];
- m[0][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2] + TempRow.w*mat.m[3][2];
- m[0][3] = TempRow.x*mat.m[0][3] + TempRow.y*mat.m[1][3] + TempRow.z*mat.m[2][3] + TempRow.w*mat.m[3][3];
-
- GetRow(1, TempRow);
- m[1][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0] + TempRow.w*mat.m[3][0];
- m[1][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1] + TempRow.w*mat.m[3][1];
- m[1][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2] + TempRow.w*mat.m[3][2];
- m[1][3] = TempRow.x*mat.m[0][3] + TempRow.y*mat.m[1][3] + TempRow.z*mat.m[2][3] + TempRow.w*mat.m[3][3];
-
- GetRow(2, TempRow);
- m[2][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0] + TempRow.w*mat.m[3][0];
- m[2][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1] + TempRow.w*mat.m[3][1];
- m[2][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2] + TempRow.w*mat.m[3][2];
- m[2][3] = TempRow.x*mat.m[0][3] + TempRow.y*mat.m[1][3] + TempRow.z*mat.m[2][3] + TempRow.w*mat.m[3][3];
-
- GetRow(3, TempRow);
- m[3][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0] + TempRow.w*mat.m[3][0];
- m[3][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1] + TempRow.w*mat.m[3][1];
- m[3][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2] + TempRow.w*mat.m[3][2];
- m[3][3] = TempRow.x*mat.m[0][3] + TempRow.y*mat.m[1][3] + TempRow.z*mat.m[2][3] + TempRow.w*mat.m[3][3];
-
- return *this;
- }
-
- //! Operator for Matrix4x4 *= float;
- inline_ Matrix4x4& operator*=(float s)
- {
- m[0][0]*=s; m[0][1]*=s; m[0][2]*=s; m[0][3]*=s;
- m[1][0]*=s; m[1][1]*=s; m[1][2]*=s; m[1][3]*=s;
- m[2][0]*=s; m[2][1]*=s; m[2][2]*=s; m[2][3]*=s;
- m[3][0]*=s; m[3][1]*=s; m[3][2]*=s; m[3][3]*=s;
- return *this;
- }
-
- //! Operator for Matrix4x4 /= float;
- inline_ Matrix4x4& operator/=(float s)
- {
- if(s) s = 1.0f / s;
- m[0][0]*=s; m[0][1]*=s; m[0][2]*=s; m[0][3]*=s;
- m[1][0]*=s; m[1][1]*=s; m[1][2]*=s; m[1][3]*=s;
- m[2][0]*=s; m[2][1]*=s; m[2][2]*=s; m[2][3]*=s;
- m[3][0]*=s; m[3][1]*=s; m[3][2]*=s; m[3][3]*=s;
- return *this;
- }
-
- inline_ const HPoint& operator[](int row) const { return *(const HPoint*)&m[row][0]; }
- inline_ HPoint& operator[](int row) { return *(HPoint*)&m[row][0]; }
-
- public:
-
- float m[4][4];
- };
-
- //! Quickly rotates & translates a vector, using the 4x3 part of a 4x4 matrix
- inline_ void TransformPoint4x3(IcePoint& dest, const IcePoint& source, const Matrix4x4& rot)
- {
- dest.x = rot.m[3][0] + source.x * rot.m[0][0] + source.y * rot.m[1][0] + source.z * rot.m[2][0];
- dest.y = rot.m[3][1] + source.x * rot.m[0][1] + source.y * rot.m[1][1] + source.z * rot.m[2][1];
- dest.z = rot.m[3][2] + source.x * rot.m[0][2] + source.y * rot.m[1][2] + source.z * rot.m[2][2];
- }
-
- //! Quickly rotates a vector, using the 3x3 part of a 4x4 matrix
- inline_ void TransformPoint3x3(IcePoint& dest, const IcePoint& source, const Matrix4x4& rot)
- {
- dest.x = source.x * rot.m[0][0] + source.y * rot.m[1][0] + source.z * rot.m[2][0];
- dest.y = source.x * rot.m[0][1] + source.y * rot.m[1][1] + source.z * rot.m[2][1];
- dest.z = source.x * rot.m[0][2] + source.y * rot.m[1][2] + source.z * rot.m[2][2];
- }
-
- ICEMATHS_API void InvertPRMatrix(Matrix4x4& dest, const Matrix4x4& src);
-
-#endif // __ICEMATRIX4X4_H__
-
diff --git a/Opcode/OpcodeLib/Ice/IceMemoryMacros.h b/Opcode/OpcodeLib/Ice/IceMemoryMacros.h deleted file mode 100644 index 490ecd1..0000000 --- a/Opcode/OpcodeLib/Ice/IceMemoryMacros.h +++ /dev/null @@ -1,105 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains all memory macros.
- * \file IceMemoryMacros.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEMEMORYMACROS_H__
-#define __ICEMEMORYMACROS_H__
-
-#undef ZeroMemory
-#undef CopyMemory
-#undef MoveMemory
-#undef FillMemory
-
- //! Clears a buffer.
- //! \param addr [in] buffer address
- //! \param size [in] buffer length
- //! \see FillMemory
- //! \see StoreDwords
- //! \see CopyMemory
- //! \see MoveMemory
- inline_ void ZeroMemory(void* addr, udword size) { memset(addr, 0, size); }
-
- //! Fills a buffer with a given byte.
- //! \param addr [in] buffer address
- //! \param size [in] buffer length
- //! \param val [in] the byte value
- //! \see StoreDwords
- //! \see ZeroMemory
- //! \see CopyMemory
- //! \see MoveMemory
- inline_ void FillMemory(void* dest, udword size, ubyte val) { memset(dest, val, size); }
-
- //! Fills a buffer with a given dword.
- //! \param addr [in] buffer address
- //! \param nb [in] number of dwords to write
- //! \param value [in] the dword value
- //! \see FillMemory
- //! \see ZeroMemory
- //! \see CopyMemory
- //! \see MoveMemory
- //! \warning writes nb*4 bytes !
- inline_ void StoreDwords(udword* dest, udword nb, udword value)
- {
- // The asm code below **SHOULD** be equivalent to one of those C versions
- // or the other if your compiled is good: (checked on VC++ 6.0)
- //
- // 1) while(nb--) *dest++ = value;
- //
- // 2) for(udword i=0;i<nb;i++) dest[i] = value;
- //
- _asm push eax
- _asm push ecx
- _asm push edi
- _asm mov edi, dest
- _asm mov ecx, nb
- _asm mov eax, value
- _asm rep stosd
- _asm pop edi
- _asm pop ecx
- _asm pop eax
- }
-
- //! Copies a buffer.
- //! \param addr [in] destination buffer address
- //! \param addr [in] source buffer address
- //! \param size [in] buffer length
- //! \see ZeroMemory
- //! \see FillMemory
- //! \see StoreDwords
- //! \see MoveMemory
- inline_ void CopyMemory(void* dest, const void* src, udword size) { memcpy(dest, src, size); }
-
- //! Moves a buffer.
- //! \param addr [in] destination buffer address
- //! \param addr [in] source buffer address
- //! \param size [in] buffer length
- //! \see ZeroMemory
- //! \see FillMemory
- //! \see StoreDwords
- //! \see CopyMemory
- inline_ void MoveMemory(void* dest, const void* src, udword size) { memmove(dest, src, size); }
-
- #define SIZEOFOBJECT sizeof(*this) //!< Gives the size of current object. Avoid some mistakes (e.g. "sizeof(this)").
- //#define CLEAROBJECT { memset(this, 0, SIZEOFOBJECT); } //!< Clears current object. Laziness is my business. HANDLE WITH CARE.
- #define DELETESINGLE(x) if (x) { delete x; x = null; } //!< Deletes an instance of a class.
- #define DELETEARRAY(x) if (x) { delete []x; x = null; } //!< Deletes an array.
- #define SAFE_RELEASE(x) if (x) { (x)->Release(); (x) = null; } //!< Safe D3D-style release
- #define SAFE_DESTRUCT(x) if (x) { (x)->SelfDestruct(); (x) = null; } //!< Safe ICE-style release
-
-#ifdef __ICEERROR_H__
- #define CHECKALLOC(x) if(!x) return SetIceError("Out of memory.", EC_OUT_OF_MEMORY); //!< Standard alloc checking. HANDLE WITH CARE.
-#else
- #define CHECKALLOC(x) if(!x) return false;
-#endif
-
- //! Standard allocation cycle
- #define SAFE_ALLOC(ptr, type, count) DELETEARRAY(ptr); ptr = new type[count]; CHECKALLOC(ptr);
-
-#endif // __ICEMEMORYMACROS_H__
diff --git a/Opcode/OpcodeLib/Ice/IceOBB.cpp b/Opcode/OpcodeLib/Ice/IceOBB.cpp deleted file mode 100644 index 5a986e8..0000000 --- a/Opcode/OpcodeLib/Ice/IceOBB.cpp +++ /dev/null @@ -1,323 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains OBB-related code.
- * \file IceOBB.cpp
- * \author Pierre Terdiman
- * \date January, 29, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * An Oriented Bounding Box (OBB).
- * \class OBB
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Tests if a point is contained within the OBB.
- * \param p [in] the world point to test
- * \return true if inside the OBB
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool OBB::ContainsPoint(const IcePoint& p) const
-{
- // IcePoint in OBB test using lazy evaluation and early exits
-
- // Translate to box space
- IcePoint RelPoint = p - mCenter;
-
- // IcePoint * mRot maps from box space to world space
- // mRot * IcePoint maps from world space to box space (what we need here)
-
- float f = mRot.m[0][0] * RelPoint.x + mRot.m[0][1] * RelPoint.y + mRot.m[0][2] * RelPoint.z;
- if(f >= mExtents.x || f <= -mExtents.x) return false;
-
- f = mRot.m[1][0] * RelPoint.x + mRot.m[1][1] * RelPoint.y + mRot.m[1][2] * RelPoint.z;
- if(f >= mExtents.y || f <= -mExtents.y) return false;
-
- f = mRot.m[2][0] * RelPoint.x + mRot.m[2][1] * RelPoint.y + mRot.m[2][2] * RelPoint.z;
- if(f >= mExtents.z || f <= -mExtents.z) return false;
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds an OBB from an AABB and a world transform.
- * \param aabb [in] the aabb
- * \param mat [in] the world transform
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBB::Create(const AABB& aabb, const Matrix4x4& mat)
-{
- // Note: must be coherent with Rotate()
-
- aabb.GetCenter(mCenter);
- aabb.GetExtents(mExtents);
- // Here we have the same as OBB::Rotate(mat) where the obb is (mCenter, mExtents, Identity).
-
- // So following what's done in Rotate:
- // - x-form the center
- mCenter *= mat;
- // - combine rotation with identity, i.e. just use given matrix
- mRot = mat;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the obb planes.
- * \param planes [out] 6 box planes
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool OBB::ComputePlanes(IcePlane* planes) const
-{
- // Checkings
- if(!planes) return false;
-
- IcePoint Axis0 = mRot[0];
- IcePoint Axis1 = mRot[1];
- IcePoint Axis2 = mRot[2];
-
- // Writes normals
- planes[0].n = Axis0;
- planes[1].n = -Axis0;
- planes[2].n = Axis1;
- planes[3].n = -Axis1;
- planes[4].n = Axis2;
- planes[5].n = -Axis2;
-
- // Compute a point on each plane
- IcePoint p0 = mCenter + Axis0 * mExtents.x;
- IcePoint p1 = mCenter - Axis0 * mExtents.x;
- IcePoint p2 = mCenter + Axis1 * mExtents.y;
- IcePoint p3 = mCenter - Axis1 * mExtents.y;
- IcePoint p4 = mCenter + Axis2 * mExtents.z;
- IcePoint p5 = mCenter - Axis2 * mExtents.z;
-
- // Compute d
- planes[0].d = -(planes[0].n|p0);
- planes[1].d = -(planes[1].n|p1);
- planes[2].d = -(planes[2].n|p2);
- planes[3].d = -(planes[3].n|p3);
- planes[4].d = -(planes[4].n|p4);
- planes[5].d = -(planes[5].n|p5);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the obb points.
- * \param pts [out] 8 box points
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool OBB::ComputePoints(IcePoint* pts) const
-{
- // Checkings
- if(!pts) return false;
-
- IcePoint Axis0 = mRot[0];
- IcePoint Axis1 = mRot[1];
- IcePoint Axis2 = mRot[2];
-
- Axis0 *= mExtents.x;
- Axis1 *= mExtents.y;
- Axis2 *= mExtents.z;
-
- // 7+------+6 0 = ---
- // /| /| 1 = +--
- // / | / | 2 = ++-
- // / 4+---/--+5 3 = -+-
- // 3+------+2 / y z 4 = --+
- // | / | / | / 5 = +-+
- // |/ |/ |/ 6 = +++
- // 0+------+1 *---x 7 = -++
-
- pts[0] = mCenter - Axis0 - Axis1 - Axis2;
- pts[1] = mCenter + Axis0 - Axis1 - Axis2;
- pts[2] = mCenter + Axis0 + Axis1 - Axis2;
- pts[3] = mCenter - Axis0 + Axis1 - Axis2;
- pts[4] = mCenter - Axis0 - Axis1 + Axis2;
- pts[5] = mCenter + Axis0 - Axis1 + Axis2;
- pts[6] = mCenter + Axis0 + Axis1 + Axis2;
- pts[7] = mCenter - Axis0 + Axis1 + Axis2;
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes vertex normals.
- * \param pts [out] 8 box points
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool OBB::ComputeVertexNormals(IcePoint* pts) const
-{
- static float VertexNormals[] =
- {
- -INVSQRT3, -INVSQRT3, -INVSQRT3,
- INVSQRT3, -INVSQRT3, -INVSQRT3,
- INVSQRT3, INVSQRT3, -INVSQRT3,
- -INVSQRT3, INVSQRT3, -INVSQRT3,
- -INVSQRT3, -INVSQRT3, INVSQRT3,
- INVSQRT3, -INVSQRT3, INVSQRT3,
- INVSQRT3, INVSQRT3, INVSQRT3,
- -INVSQRT3, INVSQRT3, INVSQRT3
- };
-
- if(!pts) return false;
-
- const IcePoint* VN = (const IcePoint*)VertexNormals;
- for(udword i=0;i<8;i++)
- {
- pts[i] = VN[i] * mRot;
- }
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns edges.
- * \return 24 indices (12 edges) indexing the list returned by ComputePoints()
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const udword* OBB::GetEdges() const
-{
- static udword Indices[] = {
- 0, 1, 1, 2, 2, 3, 3, 0,
- 7, 6, 6, 5, 5, 4, 4, 7,
- 1, 5, 6, 2,
- 3, 7, 4, 0
- };
- return Indices;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns local edge normals.
- * \return edge normals in local space
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const IcePoint* OBB::GetLocalEdgeNormals() const
-{
- static float EdgeNormals[] =
- {
- 0, -INVSQRT2, -INVSQRT2, // 0-1
- INVSQRT2, 0, -INVSQRT2, // 1-2
- 0, INVSQRT2, -INVSQRT2, // 2-3
- -INVSQRT2, 0, -INVSQRT2, // 3-0
-
- 0, INVSQRT2, INVSQRT2, // 7-6
- INVSQRT2, 0, INVSQRT2, // 6-5
- 0, -INVSQRT2, INVSQRT2, // 5-4
- -INVSQRT2, 0, INVSQRT2, // 4-7
-
- INVSQRT2, -INVSQRT2, 0, // 1-5
- INVSQRT2, INVSQRT2, 0, // 6-2
- -INVSQRT2, INVSQRT2, 0, // 3-7
- -INVSQRT2, -INVSQRT2, 0 // 4-0
- };
- return (const IcePoint*)EdgeNormals;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns world edge normal
- * \param edge_index [in] 0 <= edge index < 12
- * \param world_normal [out] edge normal in world space
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBB::ComputeWorldEdgeNormal(udword edge_index, IcePoint& world_normal) const
-{
- ASSERT(edge_index<12);
- world_normal = GetLocalEdgeNormals()[edge_index] * mRot;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes an LSS surrounding the OBB.
- * \param lss [out] the LSS
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBB::ComputeLSS(LSS& lss) const
-{
- IcePoint Axis0 = mRot[0];
- IcePoint Axis1 = mRot[1];
- IcePoint Axis2 = mRot[2];
-
- switch(mExtents.LargestAxis())
- {
- case 0:
- lss.mRadius = (mExtents.y + mExtents.z)*0.5f;
- lss.mP0 = mCenter + Axis0 * (mExtents.x - lss.mRadius);
- lss.mP1 = mCenter - Axis0 * (mExtents.x - lss.mRadius);
- break;
- case 1:
- lss.mRadius = (mExtents.x + mExtents.z)*0.5f;
- lss.mP0 = mCenter + Axis1 * (mExtents.y - lss.mRadius);
- lss.mP1 = mCenter - Axis1 * (mExtents.y - lss.mRadius);
- break;
- case 2:
- lss.mRadius = (mExtents.x + mExtents.y)*0.5f;
- lss.mP0 = mCenter + Axis2 * (mExtents.z - lss.mRadius);
- lss.mP1 = mCenter - Axis2 * (mExtents.z - lss.mRadius);
- break;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks the OBB is inside another OBB.
- * \param box [in] the other OBB
- * \return TRUE if we're inside the other box
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BOOL OBB::IsInside(const OBB& box) const
-{
- // Make a 4x4 from the box & inverse it
- Matrix4x4 M0Inv;
- {
- Matrix4x4 M0 = box.mRot;
- M0.SetTrans(box.mCenter);
- InvertPRMatrix(M0Inv, M0);
- }
-
- // With our inversed 4x4, create box1 in space of box0
- OBB _1in0;
- Rotate(M0Inv, _1in0);
-
- // This should cancel out box0's rotation, i.e. it's now an AABB.
- // => Center(0,0,0), Rot(identity)
-
- // The two boxes are in the same space so now we can compare them.
-
- // Create the AABB of (box1 in space of box0)
- const Matrix3x3& mtx = _1in0.mRot;
-
- float f = fabsf(mtx.m[0][0] * mExtents.x) + fabsf(mtx.m[1][0] * mExtents.y) + fabsf(mtx.m[2][0] * mExtents.z) - box.mExtents.x;
- if(f > _1in0.mCenter.x) return FALSE;
- if(-f < _1in0.mCenter.x) return FALSE;
-
- f = fabsf(mtx.m[0][1] * mExtents.x) + fabsf(mtx.m[1][1] * mExtents.y) + fabsf(mtx.m[2][1] * mExtents.z) - box.mExtents.y;
- if(f > _1in0.mCenter.y) return FALSE;
- if(-f < _1in0.mCenter.y) return FALSE;
-
- f = fabsf(mtx.m[0][2] * mExtents.x) + fabsf(mtx.m[1][2] * mExtents.y) + fabsf(mtx.m[2][2] * mExtents.z) - box.mExtents.z;
- if(f > _1in0.mCenter.z) return FALSE;
- if(-f < _1in0.mCenter.z) return FALSE;
-
- return TRUE;
-}
diff --git a/Opcode/OpcodeLib/Ice/IceOBB.h b/Opcode/OpcodeLib/Ice/IceOBB.h deleted file mode 100644 index 249e76a..0000000 --- a/Opcode/OpcodeLib/Ice/IceOBB.h +++ /dev/null @@ -1,177 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains OBB-related code. (oriented bounding box)
- * \file IceOBB.h
- * \author Pierre Terdiman
- * \date January, 13, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEOBB_H__
-#define __ICEOBB_H__
-
- // Forward declarations
- class LSS;
-
- class ICEMATHS_API OBB
- {
- public:
- //! Constructor
- inline_ OBB() {}
- //! Constructor
- inline_ OBB(const IcePoint& center, const IcePoint& extents, const Matrix3x3& rot) : mCenter(center), mExtents(extents), mRot(rot) {}
- //! Destructor
- inline_ ~OBB() {}
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an empty OBB.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void SetEmpty()
- {
- mCenter.Zero();
- mExtents.Set(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
- mRot.Identity();
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Tests if a point is contained within the OBB.
- * \param p [in] the world point to test
- * \return true if inside the OBB
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool ContainsPoint(const IcePoint& p) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Builds an OBB from an AABB and a world transform.
- * \param aabb [in] the aabb
- * \param mat [in] the world transform
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void Create(const AABB& aabb, const Matrix4x4& mat);
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Recomputes the OBB after an arbitrary transform by a 4x4 matrix.
- * \param mtx [in] the transform matrix
- * \param obb [out] the transformed OBB
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void Rotate(const Matrix4x4& mtx, OBB& obb) const
- {
- // The extents remain constant
- obb.mExtents = mExtents;
- // The center gets x-formed
- obb.mCenter = mCenter * mtx;
- // Combine rotations
- obb.mRot = mRot * Matrix3x3(mtx);
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the OBB is valid.
- * \return true if the box is valid
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL IsValid() const
- {
- // Consistency condition for (Center, Extents) boxes: Extents >= 0.0f
- if(mExtents.x < 0.0f) return FALSE;
- if(mExtents.y < 0.0f) return FALSE;
- if(mExtents.z < 0.0f) return FALSE;
- return TRUE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the obb planes.
- * \param planes [out] 6 box planes
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool ComputePlanes(IcePlane* planes) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the obb points.
- * \param pts [out] 8 box points
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool ComputePoints(IcePoint* pts) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes vertex normals.
- * \param pts [out] 8 box points
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool ComputeVertexNormals(IcePoint* pts) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Returns edges.
- * \return 24 indices (12 edges) indexing the list returned by ComputePoints()
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- const udword* GetEdges() const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Returns local edge normals.
- * \return edge normals in local space
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- const IcePoint* GetLocalEdgeNormals() const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Returns world edge normal
- * \param edge_index [in] 0 <= edge index < 12
- * \param world_normal [out] edge normal in world space
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void ComputeWorldEdgeNormal(udword edge_index, IcePoint& world_normal) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes an LSS surrounding the OBB.
- * \param lss [out] the LSS
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- void ComputeLSS(LSS& lss) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the OBB is inside another OBB.
- * \param box [in] the other OBB
- * \return TRUE if we're inside the other box
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- BOOL IsInside(const OBB& box) const;
-
- inline_ const IcePoint& GetCenter() const { return mCenter; }
- inline_ const IcePoint& GetExtents() const { return mExtents; }
- inline_ const Matrix3x3& GetRot() const { return mRot; }
-
- inline_ void GetRotatedExtents(Matrix3x3& extents) const
- {
- extents = mRot;
- extents.Scale(mExtents);
- }
-
- IcePoint mCenter; //!< B for Box
- IcePoint mExtents; //!< B for Bounding
- Matrix3x3 mRot; //!< O for Oriented
-
- // Orientation is stored in row-major format,
- // i.e. rows = eigen vectors of the covariance matrix
- };
-
-#endif // __ICEOBB_H__
diff --git a/Opcode/OpcodeLib/Ice/IcePairs.h b/Opcode/OpcodeLib/Ice/IcePairs.h deleted file mode 100644 index 35e3a07..0000000 --- a/Opcode/OpcodeLib/Ice/IcePairs.h +++ /dev/null @@ -1,45 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a simple pair class.
- * \file IcePairs.h
- * \author Pierre Terdiman
- * \date January, 13, 2003
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEPAIRS_H__
-#define __ICEPAIRS_H__
-
- //! A generic couple structure
- struct ICECORE_API Pair
- {
- inline_ Pair() {}
- inline_ Pair(udword i0, udword i1) : id0(i0), id1(i1) {}
-
- udword id0; //!< First index of the pair
- udword id1; //!< Second index of the pair
- };
-
- class ICECORE_API Pairs : private Container
- {
- public:
- // Constructor / Destructor
- Pairs() {}
- ~Pairs() {}
-
- inline_ udword GetNbPairs() const { return GetNbEntries()>>1; }
- inline_ const Pair* GetPairs() const { return (const Pair*)GetEntries(); }
- inline_ const Pair* GetPair(udword i) const { return (const Pair*)&GetEntries()[i+i]; }
-
- inline_ BOOL HasPairs() const { return IsNotEmpty(); }
-
- inline_ void ResetPairs() { Reset(); }
- inline_ void DeleteLastPair() { DeleteLastEntry(); DeleteLastEntry(); }
-
- inline_ void AddPair(const Pair& p) { Add(p.id0).Add(p.id1); }
- inline_ void AddPair(udword id0, udword id1) { Add(id0).Add(id1); }
- };
-
-#endif // __ICEPAIRS_H__
diff --git a/Opcode/OpcodeLib/Ice/IcePlane.cpp b/Opcode/OpcodeLib/Ice/IcePlane.cpp deleted file mode 100644 index 1890f1c..0000000 --- a/Opcode/OpcodeLib/Ice/IcePlane.cpp +++ /dev/null @@ -1,45 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for planes.
- * \file IcePlane.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * IcePlane class.
- * \class IcePlane
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the plane equation from 3 points.
- * \param p0 [in] first point
- * \param p1 [in] second point
- * \param p2 [in] third point
- * \return Self-reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-IcePlane& IcePlane::Set(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2)
-{
- IcePoint Edge0 = p1 - p0;
- IcePoint Edge1 = p2 - p0;
-
- n = Edge0 ^ Edge1;
- n.Normalize();
-
- d = -(p0 | n);
-
- return *this;
-}
diff --git a/Opcode/OpcodeLib/Ice/IcePlane.h b/Opcode/OpcodeLib/Ice/IcePlane.h deleted file mode 100644 index 1a447ce..0000000 --- a/Opcode/OpcodeLib/Ice/IcePlane.h +++ /dev/null @@ -1,113 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for planes.
- * \file IcePlane.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEPLANE_H__
-#define __ICEPLANE_H__
-
- #define PLANE_EPSILON (1.0e-7f)
-
- class ICEMATHS_API IcePlane
- {
- public:
- //! Constructor
- inline_ IcePlane() { }
- //! Constructor from a normal and a distance
- inline_ IcePlane(float nx, float ny, float nz, float d) { Set(nx, ny, nz, d); }
- //! Constructor from a point on the plane and a normal
- inline_ IcePlane(const IcePoint& p, const IcePoint& n) { Set(p, n); }
- //! Constructor from three points
- inline_ IcePlane(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2) { Set(p0, p1, p2); }
- //! Constructor from a normal and a distance
- inline_ IcePlane(const IcePoint& _n, float _d) { n = _n; d = _d; }
- //! Copy constructor
- inline_ IcePlane(const IcePlane& plane) : n(plane.n), d(plane.d) { }
- //! Destructor
- inline_ ~IcePlane() { }
-
- inline_ IcePlane& Zero() { n.Zero(); d = 0.0f; return *this; }
- inline_ IcePlane& Set(float nx, float ny, float nz, float _d) { n.Set(nx, ny, nz); d = _d; return *this; }
- inline_ IcePlane& Set(const IcePoint& p, const IcePoint& _n) { n = _n; d = - p | _n; return *this; }
- IcePlane& Set(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2);
-
- inline_ float Distance(const IcePoint& p) const { return (p | n) + d; }
- inline_ bool Belongs(const IcePoint& p) const { return fabsf(Distance(p)) < PLANE_EPSILON; }
-
- inline_ void Normalize()
- {
- float Denom = 1.0f / n.Magnitude();
- n.x *= Denom;
- n.y *= Denom;
- n.z *= Denom;
- d *= Denom;
- }
- public:
- // Members
- IcePoint n; //!< The normal to the plane
- float d; //!< The distance from the origin
-
- // Cast operators
- inline_ operator IcePoint() const { return n; }
- inline_ operator HPoint() const { return HPoint(n, d); }
-
- // Arithmetic operators
- inline_ IcePlane operator*(const Matrix4x4& m) const
- {
- // Old code from Irion. Kept for reference.
- IcePlane Ret(*this);
- return Ret *= m;
- }
-
- inline_ IcePlane& operator*=(const Matrix4x4& m)
- {
- // Old code from Irion. Kept for reference.
- IcePoint n2 = HPoint(n, 0.0f) * m;
- d = -((IcePoint) (HPoint( -d*n, 1.0f ) * m) | n2);
- n = n2;
- return *this;
- }
- };
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Transforms a plane by a 4x4 matrix. Same as IcePlane * Matrix4x4 operator, but faster.
- * \param transformed [out] transformed plane
- * \param plane [in] source plane
- * \param transform [in] transform matrix
- * \warning the plane normal must be unit-length
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void TransformPlane(IcePlane& transformed, const IcePlane& plane, const Matrix4x4& transform)
- {
- // Rotate the normal using the rotation part of the 4x4 matrix
- transformed.n = plane.n * Matrix3x3(transform);
-
- // Compute new d
- transformed.d = plane.d - (IcePoint(transform.GetTrans())|transformed.n);
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Transforms a plane by a 4x4 matrix. Same as IcePlane * Matrix4x4 operator, but faster.
- * \param plane [in/out] source plane (transformed on return)
- * \param transform [in] transform matrix
- * \warning the plane normal must be unit-length
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void TransformPlane(IcePlane& plane, const Matrix4x4& transform)
- {
- // Rotate the normal using the rotation part of the 4x4 matrix
- plane.n *= Matrix3x3(transform);
-
- // Compute new d
- plane.d -= IcePoint(transform.GetTrans())|plane.n;
- }
-
-#endif // __ICEPLANE_H__
diff --git a/Opcode/OpcodeLib/Ice/IcePoint.cpp b/Opcode/OpcodeLib/Ice/IcePoint.cpp deleted file mode 100644 index 8615f4e..0000000 --- a/Opcode/OpcodeLib/Ice/IcePoint.cpp +++ /dev/null @@ -1,193 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for 3D vectors.
- * \file IcePoint.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * 3D point.
- *
- * The name is "IcePoint" instead of "Vector" since a vector is N-dimensional, whereas a point is an implicit "vector of dimension 3".
- * So the choice was between "IcePoint" and "Vector3", the first one looked better (IMHO).
- *
- * Some people, then, use a typedef to handle both points & vectors using the same class: typedef IcePoint Vector3;
- * This is bad since it opens the door to a lot of confusion while reading the code. I know it may sounds weird but check this out:
- *
- * \code
- * IcePoint P0,P1 = some 3D points;
- * IcePoint Delta = P1 - P0;
- * \endcode
- *
- * This compiles fine, although you should have written:
- *
- * \code
- * IcePoint P0,P1 = some 3D points;
- * Vector3 Delta = P1 - P0;
- * \endcode
- *
- * Subtle things like this are not caught at compile-time, and when you find one in the code, you never know whether it's a mistake
- * from the author or something you don't get.
- *
- * One way to handle it at compile-time would be to use different classes for IcePoint & Vector3, only overloading operator "-" for vectors.
- * But then, you get a lot of redundant code in thoses classes, and basically it's really a lot of useless work.
- *
- * Another way would be to use homogeneous points: w=1 for points, w=0 for vectors. That's why the HPoint class exists. Now, to store
- * your model's vertices and in most cases, you really want to use Points to save ram.
- *
- * \class IcePoint
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates a positive unit random vector.
- * \return Self-reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-IcePoint& IcePoint::PositiveUnitRandomVector()
-{
- x = UnitRandomFloat();
- y = UnitRandomFloat();
- z = UnitRandomFloat();
- Normalize();
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates a unit random vector.
- * \return Self-reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-IcePoint& IcePoint::UnitRandomVector()
-{
- x = UnitRandomFloat() - 0.5f;
- y = UnitRandomFloat() - 0.5f;
- z = UnitRandomFloat() - 0.5f;
- Normalize();
- return *this;
-}
-
-// Cast operator
-// WARNING: not inlined
-IcePoint::operator HPoint() const { return HPoint(x, y, z, 0.0f); }
-
-IcePoint& IcePoint::Refract(const IcePoint& eye, const IcePoint& n, float refractindex, IcePoint& refracted)
-{
- // IcePoint EyePt = eye position
- // IcePoint p = current vertex
- // IcePoint n = vertex normal
- // IcePoint rv = refracted vector
- // Eye vector - doesn't need to be normalized
- IcePoint Env;
- Env.x = eye.x - x;
- Env.y = eye.y - y;
- Env.z = eye.z - z;
-
- float NDotE = n|Env;
- float NDotN = n|n;
- NDotE /= refractindex;
-
- // Refracted vector
- refracted = n*NDotE - Env*NDotN;
-
- return *this;
-}
-
-IcePoint& IcePoint::ProjectToPlane(const IcePlane& p)
-{
- *this-= (p.d + (*this|p.n))*p.n;
- return *this;
-}
-
-void IcePoint::ProjectToScreen(float halfrenderwidth, float halfrenderheight, const Matrix4x4& mat, HPoint& projected) const
-{
- projected = HPoint(x, y, z, 1.0f) * mat;
- projected.w = 1.0f / projected.w;
-
- projected.x*=projected.w;
- projected.y*=projected.w;
- projected.z*=projected.w;
-
- projected.x *= halfrenderwidth; projected.x += halfrenderwidth;
- projected.y *= -halfrenderheight; projected.y += halfrenderheight;
-}
-
-void IcePoint::SetNotUsed()
-{
- // We use a particular integer pattern : 0xffffffff everywhere. This is a NAN.
- IR(x) = 0xffffffff;
- IR(y) = 0xffffffff;
- IR(z) = 0xffffffff;
-}
-
-BOOL IcePoint::IsNotUsed() const
-{
- if(IR(x)!=0xffffffff) return FALSE;
- if(IR(y)!=0xffffffff) return FALSE;
- if(IR(z)!=0xffffffff) return FALSE;
- return TRUE;
-}
-
-IcePoint& IcePoint::Mult(const Matrix3x3& mat, const IcePoint& a)
-{
- x = a.x * mat.m[0][0] + a.y * mat.m[0][1] + a.z * mat.m[0][2];
- y = a.x * mat.m[1][0] + a.y * mat.m[1][1] + a.z * mat.m[1][2];
- z = a.x * mat.m[2][0] + a.y * mat.m[2][1] + a.z * mat.m[2][2];
- return *this;
-}
-
-IcePoint& IcePoint::Mult2(const Matrix3x3& mat1, const IcePoint& a1, const Matrix3x3& mat2, const IcePoint& a2)
-{
- x = a1.x * mat1.m[0][0] + a1.y * mat1.m[0][1] + a1.z * mat1.m[0][2] + a2.x * mat2.m[0][0] + a2.y * mat2.m[0][1] + a2.z * mat2.m[0][2];
- y = a1.x * mat1.m[1][0] + a1.y * mat1.m[1][1] + a1.z * mat1.m[1][2] + a2.x * mat2.m[1][0] + a2.y * mat2.m[1][1] + a2.z * mat2.m[1][2];
- z = a1.x * mat1.m[2][0] + a1.y * mat1.m[2][1] + a1.z * mat1.m[2][2] + a2.x * mat2.m[2][0] + a2.y * mat2.m[2][1] + a2.z * mat2.m[2][2];
- return *this;
-}
-
-IcePoint& IcePoint::Mac(const Matrix3x3& mat, const IcePoint& a)
-{
- x += a.x * mat.m[0][0] + a.y * mat.m[0][1] + a.z * mat.m[0][2];
- y += a.x * mat.m[1][0] + a.y * mat.m[1][1] + a.z * mat.m[1][2];
- z += a.x * mat.m[2][0] + a.y * mat.m[2][1] + a.z * mat.m[2][2];
- return *this;
-}
-
-IcePoint& IcePoint::TransMult(const Matrix3x3& mat, const IcePoint& a)
-{
- x = a.x * mat.m[0][0] + a.y * mat.m[1][0] + a.z * mat.m[2][0];
- y = a.x * mat.m[0][1] + a.y * mat.m[1][1] + a.z * mat.m[2][1];
- z = a.x * mat.m[0][2] + a.y * mat.m[1][2] + a.z * mat.m[2][2];
- return *this;
-}
-
-IcePoint& IcePoint::Transform(const IcePoint& r, const Matrix3x3& rotpos, const IcePoint& linpos)
-{
- x = r.x * rotpos.m[0][0] + r.y * rotpos.m[0][1] + r.z * rotpos.m[0][2] + linpos.x;
- y = r.x * rotpos.m[1][0] + r.y * rotpos.m[1][1] + r.z * rotpos.m[1][2] + linpos.y;
- z = r.x * rotpos.m[2][0] + r.y * rotpos.m[2][1] + r.z * rotpos.m[2][2] + linpos.z;
- return *this;
-}
-
-IcePoint& IcePoint::InvTransform(const IcePoint& r, const Matrix3x3& rotpos, const IcePoint& linpos)
-{
- float sx = r.x - linpos.x;
- float sy = r.y - linpos.y;
- float sz = r.z - linpos.z;
- x = sx * rotpos.m[0][0] + sy * rotpos.m[1][0] + sz * rotpos.m[2][0];
- y = sx * rotpos.m[0][1] + sy * rotpos.m[1][1] + sz * rotpos.m[2][1];
- z = sx * rotpos.m[0][2] + sy * rotpos.m[1][2] + sz * rotpos.m[2][2];
- return *this;
-}
diff --git a/Opcode/OpcodeLib/Ice/IcePoint.h b/Opcode/OpcodeLib/Ice/IcePoint.h deleted file mode 100644 index 6b67409..0000000 --- a/Opcode/OpcodeLib/Ice/IcePoint.h +++ /dev/null @@ -1,528 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for 3D vectors.
- * \file IcePoint.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEPOINT_H__
-#define __ICEPOINT_H__
-
- // Forward declarations
- class HPoint;
- class IcePlane;
- class Matrix3x3;
- class Matrix4x4;
-
- #define CROSS2D(a, b) (a.x*b.y - b.x*a.y)
-
- const float EPSILON2 = 1.0e-20f;
-
- class ICEMATHS_API IcePoint
- {
- public:
-
- //! Empty constructor
- inline_ IcePoint() {}
- //! Constructor from a single float
-// inline_ IcePoint(float val) : x(val), y(val), z(val) {}
-// Removed since it introduced the nasty "IcePoint T = *Matrix4x4.GetTrans();" bug.......
- //! Constructor from floats
- inline_ IcePoint(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {}
- //! Constructor from array
- inline_ IcePoint(const float f[3]) : x(f[_X]), y(f[_Y]), z(f[_Z]) {}
- //! Copy constructor
- inline_ IcePoint(const IcePoint& p) : x(p.x), y(p.y), z(p.z) {}
- //! Destructor
- inline_ ~IcePoint() {}
-
- //! Clears the vector
- inline_ IcePoint& Zero() { x = y = z = 0.0f; return *this; }
-
- //! + infinity
- inline_ IcePoint& SetPlusInfinity() { x = y = z = MAX_FLOAT; return *this; }
- //! - infinity
- inline_ IcePoint& SetMinusInfinity() { x = y = z = MIN_FLOAT; return *this; }
-
- //! Sets positive unit random vector
- IcePoint& PositiveUnitRandomVector();
- //! Sets unit random vector
- IcePoint& UnitRandomVector();
-
- //! Assignment from values
- inline_ IcePoint& Set(float _x, float _y, float _z) { x = _x; y = _y; z = _z; return *this; }
- //! Assignment from array
- inline_ IcePoint& Set(const float f[3]) { x = f[_X]; y = f[_Y]; z = f[_Z]; return *this; }
- //! Assignment from another point
- inline_ IcePoint& Set(const IcePoint& src) { x = src.x; y = src.y; z = src.z; return *this; }
-
- //! Adds a vector
- inline_ IcePoint& Add(const IcePoint& p) { x += p.x; y += p.y; z += p.z; return *this; }
- //! Adds a vector
- inline_ IcePoint& Add(float _x, float _y, float _z) { x += _x; y += _y; z += _z; return *this; }
- //! Adds a vector
- inline_ IcePoint& Add(const float f[3]) { x += f[_X]; y += f[_Y]; z += f[_Z]; return *this; }
- //! Adds vectors
- inline_ IcePoint& Add(const IcePoint& p, const IcePoint& q) { x = p.x+q.x; y = p.y+q.y; z = p.z+q.z; return *this; }
-
- //! Subtracts a vector
- inline_ IcePoint& Sub(const IcePoint& p) { x -= p.x; y -= p.y; z -= p.z; return *this; }
- //! Subtracts a vector
- inline_ IcePoint& Sub(float _x, float _y, float _z) { x -= _x; y -= _y; z -= _z; return *this; }
- //! Subtracts a vector
- inline_ IcePoint& Sub(const float f[3]) { x -= f[_X]; y -= f[_Y]; z -= f[_Z]; return *this; }
- //! Subtracts vectors
- inline_ IcePoint& Sub(const IcePoint& p, const IcePoint& q) { x = p.x-q.x; y = p.y-q.y; z = p.z-q.z; return *this; }
-
- //! this = -this
- inline_ IcePoint& Neg() { x = -x; y = -y; z = -z; return *this; }
- //! this = -a
- inline_ IcePoint& Neg(const IcePoint& a) { x = -a.x; y = -a.y; z = -a.z; return *this; }
-
- //! Multiplies by a scalar
- inline_ IcePoint& Mult(float s) { x *= s; y *= s; z *= s; return *this; }
-
- //! this = a * scalar
- inline_ IcePoint& Mult(const IcePoint& a, float scalar)
- {
- x = a.x * scalar;
- y = a.y * scalar;
- z = a.z * scalar;
- return *this;
- }
-
- //! this = a + b * scalar
- inline_ IcePoint& Mac(const IcePoint& a, const IcePoint& b, float scalar)
- {
- x = a.x + b.x * scalar;
- y = a.y + b.y * scalar;
- z = a.z + b.z * scalar;
- return *this;
- }
-
- //! this = this + a * scalar
- inline_ IcePoint& Mac(const IcePoint& a, float scalar)
- {
- x += a.x * scalar;
- y += a.y * scalar;
- z += a.z * scalar;
- return *this;
- }
-
- //! this = a - b * scalar
- inline_ IcePoint& Msc(const IcePoint& a, const IcePoint& b, float scalar)
- {
- x = a.x - b.x * scalar;
- y = a.y - b.y * scalar;
- z = a.z - b.z * scalar;
- return *this;
- }
-
- //! this = this - a * scalar
- inline_ IcePoint& Msc(const IcePoint& a, float scalar)
- {
- x -= a.x * scalar;
- y -= a.y * scalar;
- z -= a.z * scalar;
- return *this;
- }
-
- //! this = a + b * scalarb + c * scalarc
- inline_ IcePoint& Mac2(const IcePoint& a, const IcePoint& b, float scalarb, const IcePoint& c, float scalarc)
- {
- x = a.x + b.x * scalarb + c.x * scalarc;
- y = a.y + b.y * scalarb + c.y * scalarc;
- z = a.z + b.z * scalarb + c.z * scalarc;
- return *this;
- }
-
- //! this = a - b * scalarb - c * scalarc
- inline_ IcePoint& Msc2(const IcePoint& a, const IcePoint& b, float scalarb, const IcePoint& c, float scalarc)
- {
- x = a.x - b.x * scalarb - c.x * scalarc;
- y = a.y - b.y * scalarb - c.y * scalarc;
- z = a.z - b.z * scalarb - c.z * scalarc;
- return *this;
- }
-
- //! this = mat * a
- inline_ IcePoint& Mult(const Matrix3x3& mat, const IcePoint& a);
-
- //! this = mat1 * a1 + mat2 * a2
- inline_ IcePoint& Mult2(const Matrix3x3& mat1, const IcePoint& a1, const Matrix3x3& mat2, const IcePoint& a2);
-
- //! this = this + mat * a
- inline_ IcePoint& Mac(const Matrix3x3& mat, const IcePoint& a);
-
- //! this = transpose(mat) * a
- inline_ IcePoint& TransMult(const Matrix3x3& mat, const IcePoint& a);
-
- //! Linear interpolate between two vectors: this = a + t * (b - a)
- inline_ IcePoint& Lerp(const IcePoint& a, const IcePoint& b, float t)
- {
- x = a.x + t * (b.x - a.x);
- y = a.y + t * (b.y - a.y);
- z = a.z + t * (b.z - a.z);
- return *this;
- }
-
- //! Hermite interpolate between p1 and p2. p0 and p3 are used for finding gradient at p1 and p2.
- //! this = p0 * (2t^2 - t^3 - t)/2
- //! + p1 * (3t^3 - 5t^2 + 2)/2
- //! + p2 * (4t^2 - 3t^3 + t)/2
- //! + p3 * (t^3 - t^2)/2
- inline_ IcePoint& Herp(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2, const IcePoint& p3, float t)
- {
- float t2 = t * t;
- float t3 = t2 * t;
- float kp0 = (2.0f * t2 - t3 - t) * 0.5f;
- float kp1 = (3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f;
- float kp2 = (4.0f * t2 - 3.0f * t3 + t) * 0.5f;
- float kp3 = (t3 - t2) * 0.5f;
- x = p0.x * kp0 + p1.x * kp1 + p2.x * kp2 + p3.x * kp3;
- y = p0.y * kp0 + p1.y * kp1 + p2.y * kp2 + p3.y * kp3;
- z = p0.z * kp0 + p1.z * kp1 + p2.z * kp2 + p3.z * kp3;
- return *this;
- }
-
- //! this = rotpos * r + linpos
- inline_ IcePoint& Transform(const IcePoint& r, const Matrix3x3& rotpos, const IcePoint& linpos);
-
- //! this = trans(rotpos) * (r - linpos)
- inline_ IcePoint& InvTransform(const IcePoint& r, const Matrix3x3& rotpos, const IcePoint& linpos);
-
- //! Returns MIN(x, y, z);
- inline_ float Min() const { return MIN(x, MIN(y, z)); }
- //! Returns MAX(x, y, z);
- inline_ float Max() const { return MAX(x, MAX(y, z)); }
- //! Sets each element to be componentwise minimum
- inline_ IcePoint& Min(const IcePoint& p) { x = MIN(x, p.x); y = MIN(y, p.y); z = MIN(z, p.z); return *this; }
- //! Sets each element to be componentwise maximum
- inline_ IcePoint& Max(const IcePoint& p) { x = MAX(x, p.x); y = MAX(y, p.y); z = MAX(z, p.z); return *this; }
-
- //! Clamps each element
- inline_ IcePoint& Clamp(float min, float max)
- {
- if(x<min) x=min; if(x>max) x=max;
- if(y<min) y=min; if(y>max) y=max;
- if(z<min) z=min; if(z>max) z=max;
- return *this;
- }
-
- //! Computes square magnitude
- inline_ float SquareMagnitude() const { return x*x + y*y + z*z; }
- //! Computes magnitude
- inline_ float Magnitude() const { return sqrtf(x*x + y*y + z*z); }
- //! Computes volume
- inline_ float Volume() const { return x * y * z; }
-
- //! Checks the point is near zero
- inline_ bool ApproxZero() const { return SquareMagnitude() < EPSILON2; }
-
- //! Tests for exact zero vector
- inline_ BOOL IsZero() const
- {
- if(IR(x) || IR(y) || IR(z)) return FALSE;
- return TRUE;
- }
-
- //! Checks point validity
- inline_ BOOL IsValid() const
- {
- if(!IsValidFloat(x)) return FALSE;
- if(!IsValidFloat(y)) return FALSE;
- if(!IsValidFloat(z)) return FALSE;
- return TRUE;
- }
-
- //! Slighty moves the point
- void Tweak(udword coord_mask, udword tweak_mask)
- {
- if(coord_mask&1) { udword Dummy = IR(x); Dummy^=tweak_mask; x = FR(Dummy); }
- if(coord_mask&2) { udword Dummy = IR(y); Dummy^=tweak_mask; y = FR(Dummy); }
- if(coord_mask&4) { udword Dummy = IR(z); Dummy^=tweak_mask; z = FR(Dummy); }
- }
-
- #define TWEAKMASK 0x3fffff
- #define TWEAKNOTMASK ~TWEAKMASK
- //! Slighty moves the point out
- inline_ void TweakBigger()
- {
- udword Dummy = (IR(x)&TWEAKNOTMASK); if(!IS_NEGATIVE_FLOAT(x)) Dummy+=TWEAKMASK+1; x = FR(Dummy);
- Dummy = (IR(y)&TWEAKNOTMASK); if(!IS_NEGATIVE_FLOAT(y)) Dummy+=TWEAKMASK+1; y = FR(Dummy);
- Dummy = (IR(z)&TWEAKNOTMASK); if(!IS_NEGATIVE_FLOAT(z)) Dummy+=TWEAKMASK+1; z = FR(Dummy);
- }
-
- //! Slighty moves the point in
- inline_ void TweakSmaller()
- {
- udword Dummy = (IR(x)&TWEAKNOTMASK); if(IS_NEGATIVE_FLOAT(x)) Dummy+=TWEAKMASK+1; x = FR(Dummy);
- Dummy = (IR(y)&TWEAKNOTMASK); if(IS_NEGATIVE_FLOAT(y)) Dummy+=TWEAKMASK+1; y = FR(Dummy);
- Dummy = (IR(z)&TWEAKNOTMASK); if(IS_NEGATIVE_FLOAT(z)) Dummy+=TWEAKMASK+1; z = FR(Dummy);
- }
-
- //! Normalizes the vector
- inline_ IcePoint& Normalize()
- {
- float M = x*x + y*y + z*z;
- if(M)
- {
- M = 1.0f / sqrtf(M);
- x *= M;
- y *= M;
- z *= M;
- }
- return *this;
- }
-
- //! Sets vector length
- inline_ IcePoint& SetLength(float length)
- {
- float NewLength = length / Magnitude();
- x *= NewLength;
- y *= NewLength;
- z *= NewLength;
- return *this;
- }
-
- //! Clamps vector length
- inline_ IcePoint& ClampLength(float limit_length)
- {
- if(limit_length>=0.0f) // Magnitude must be positive
- {
- float CurrentSquareLength = SquareMagnitude();
-
- if(CurrentSquareLength > limit_length * limit_length)
- {
- float Coeff = limit_length / sqrtf(CurrentSquareLength);
- x *= Coeff;
- y *= Coeff;
- z *= Coeff;
- }
- }
- return *this;
- }
-
- //! Computes distance to another point
- inline_ float Distance(const IcePoint& b) const
- {
- return sqrtf((x - b.x)*(x - b.x) + (y - b.y)*(y - b.y) + (z - b.z)*(z - b.z));
- }
-
- //! Computes square distance to another point
- inline_ float SquareDistance(const IcePoint& b) const
- {
- return ((x - b.x)*(x - b.x) + (y - b.y)*(y - b.y) + (z - b.z)*(z - b.z));
- }
-
- //! Dot product dp = this|a
- inline_ float Dot(const IcePoint& p) const { return p.x * x + p.y * y + p.z * z; }
-
- //! Cross product this = a x b
- inline_ IcePoint& Cross(const IcePoint& a, const IcePoint& b)
- {
- x = a.y * b.z - a.z * b.y;
- y = a.z * b.x - a.x * b.z;
- z = a.x * b.y - a.y * b.x;
- return *this;
- }
-
- //! Vector code ( bitmask = sign(z) | sign(y) | sign(x) )
- inline_ udword VectorCode() const
- {
- return (IR(x)>>31) | ((IR(y)&SIGN_BITMASK)>>30) | ((IR(z)&SIGN_BITMASK)>>29);
- }
-
- //! Returns largest axis
- inline_ PointComponent LargestAxis() const
- {
- const float* Vals = &x;
- PointComponent m = _X;
- if(Vals[_Y] > Vals[m]) m = _Y;
- if(Vals[_Z] > Vals[m]) m = _Z;
- return m;
- }
-
- //! Returns closest axis
- inline_ PointComponent ClosestAxis() const
- {
- const float* Vals = &x;
- PointComponent m = _X;
- if(AIR(Vals[_Y]) > AIR(Vals[m])) m = _Y;
- if(AIR(Vals[_Z]) > AIR(Vals[m])) m = _Z;
- return m;
- }
-
- //! Returns smallest axis
- inline_ PointComponent SmallestAxis() const
- {
- const float* Vals = &x;
- PointComponent m = _X;
- if(Vals[_Y] < Vals[m]) m = _Y;
- if(Vals[_Z] < Vals[m]) m = _Z;
- return m;
- }
-
- //! Refracts the point
- IcePoint& Refract(const IcePoint& eye, const IcePoint& n, float refractindex, IcePoint& refracted);
-
- //! Projects the point onto a plane
- IcePoint& ProjectToPlane(const IcePlane& p);
-
- //! Projects the point onto the screen
- void ProjectToScreen(float halfrenderwidth, float halfrenderheight, const Matrix4x4& mat, HPoint& projected) const;
-
- //! Unfolds the point onto a plane according to edge(a,b)
- IcePoint& Unfold(IcePlane& p, IcePoint& a, IcePoint& b);
-
- //! Hash function from Ville Miettinen
- inline_ udword GetHashValue() const
- {
- const udword* h = (const udword*)(this);
- udword f = (h[0]+h[1]*11-(h[2]*17)) & 0x7fffffff; // avoid problems with +-0
- return (f>>22)^(f>>12)^(f);
- }
-
- //! Stuff magic values in the point, marking it as explicitely not used.
- void SetNotUsed();
- //! Checks the point is marked as not used
- BOOL IsNotUsed() const;
-
- // Arithmetic operators
-
- //! Unary operator for IcePoint Negate = - IcePoint
- inline_ IcePoint operator-() const { return IcePoint(-x, -y, -z); }
-
- //! Operator for IcePoint Plus = IcePoint + IcePoint.
- inline_ IcePoint operator+(const IcePoint& p) const { return IcePoint(x + p.x, y + p.y, z + p.z); }
- //! Operator for IcePoint Minus = IcePoint - IcePoint.
- inline_ IcePoint operator-(const IcePoint& p) const { return IcePoint(x - p.x, y - p.y, z - p.z); }
-
- //! Operator for IcePoint Mul = IcePoint * IcePoint.
- inline_ IcePoint operator*(const IcePoint& p) const { return IcePoint(x * p.x, y * p.y, z * p.z); }
- //! Operator for IcePoint Scale = IcePoint * float.
- inline_ IcePoint operator*(float s) const { return IcePoint(x * s, y * s, z * s ); }
- //! Operator for IcePoint Scale = float * IcePoint.
- inline_ friend IcePoint operator*(float s, const IcePoint& p) { return IcePoint(s * p.x, s * p.y, s * p.z); }
-
- //! Operator for IcePoint Div = IcePoint / IcePoint.
- inline_ IcePoint operator/(const IcePoint& p) const { return IcePoint(x / p.x, y / p.y, z / p.z); }
- //! Operator for IcePoint Scale = IcePoint / float.
- inline_ IcePoint operator/(float s) const { s = 1.0f / s; return IcePoint(x * s, y * s, z * s); }
- //! Operator for IcePoint Scale = float / IcePoint.
- inline_ friend IcePoint operator/(float s, const IcePoint& p) { return IcePoint(s / p.x, s / p.y, s / p.z); }
-
- //! Operator for float DotProd = IcePoint | IcePoint.
- inline_ float operator|(const IcePoint& p) const { return x*p.x + y*p.y + z*p.z; }
- //! Operator for IcePoint VecProd = IcePoint ^ IcePoint.
- inline_ IcePoint operator^(const IcePoint& p) const
- {
- return IcePoint(
- y * p.z - z * p.y,
- z * p.x - x * p.z,
- x * p.y - y * p.x );
- }
-
- //! Operator for IcePoint += IcePoint.
- inline_ IcePoint& operator+=(const IcePoint& p) { x += p.x; y += p.y; z += p.z; return *this; }
- //! Operator for IcePoint += float.
- inline_ IcePoint& operator+=(float s) { x += s; y += s; z += s; return *this; }
-
- //! Operator for IcePoint -= IcePoint.
- inline_ IcePoint& operator-=(const IcePoint& p) { x -= p.x; y -= p.y; z -= p.z; return *this; }
- //! Operator for IcePoint -= float.
- inline_ IcePoint& operator-=(float s) { x -= s; y -= s; z -= s; return *this; }
-
- //! Operator for IcePoint *= IcePoint.
- inline_ IcePoint& operator*=(const IcePoint& p) { x *= p.x; y *= p.y; z *= p.z; return *this; }
- //! Operator for IcePoint *= float.
- inline_ IcePoint& operator*=(float s) { x *= s; y *= s; z *= s; return *this; }
-
- //! Operator for IcePoint /= IcePoint.
- inline_ IcePoint& operator/=(const IcePoint& p) { x /= p.x; y /= p.y; z /= p.z; return *this; }
- //! Operator for IcePoint /= float.
- inline_ IcePoint& operator/=(float s) { s = 1.0f/s; x *= s; y *= s; z *= s; return *this; }
-
- // Logical operators
-
- //! Operator for "if(IcePoint==IcePoint)"
- inline_ bool operator==(const IcePoint& p) const { return ( (IR(x)==IR(p.x))&&(IR(y)==IR(p.y))&&(IR(z)==IR(p.z))); }
- //! Operator for "if(IcePoint!=IcePoint)"
- inline_ bool operator!=(const IcePoint& p) const { return ( (IR(x)!=IR(p.x))||(IR(y)!=IR(p.y))||(IR(z)!=IR(p.z))); }
-
- // Arithmetic operators
-
- //! Operator for IcePoint Mul = IcePoint * Matrix3x3.
- inline_ IcePoint operator*(const Matrix3x3& mat) const
- {
- class ShadowMatrix3x3{ public: float m[3][3]; }; // To allow inlining
- const ShadowMatrix3x3* Mat = (const ShadowMatrix3x3*)&mat;
-
- return IcePoint(
- x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0],
- x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1],
- x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2] );
- }
-
- //! Operator for IcePoint Mul = IcePoint * Matrix4x4.
- inline_ IcePoint operator*(const Matrix4x4& mat) const
- {
- class ShadowMatrix4x4{ public: float m[4][4]; }; // To allow inlining
- const ShadowMatrix4x4* Mat = (const ShadowMatrix4x4*)&mat;
-
- return IcePoint(
- x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0] + Mat->m[3][0],
- x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1] + Mat->m[3][1],
- x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2] + Mat->m[3][2]);
- }
-
- //! Operator for IcePoint *= Matrix3x3.
- inline_ IcePoint& operator*=(const Matrix3x3& mat)
- {
- class ShadowMatrix3x3{ public: float m[3][3]; }; // To allow inlining
- const ShadowMatrix3x3* Mat = (const ShadowMatrix3x3*)&mat;
-
- float xp = x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0];
- float yp = x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1];
- float zp = x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2];
-
- x = xp; y = yp; z = zp;
-
- return *this;
- }
-
- //! Operator for IcePoint *= Matrix4x4.
- inline_ IcePoint& operator*=(const Matrix4x4& mat)
- {
- class ShadowMatrix4x4{ public: float m[4][4]; }; // To allow inlining
- const ShadowMatrix4x4* Mat = (const ShadowMatrix4x4*)&mat;
-
- float xp = x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0] + Mat->m[3][0];
- float yp = x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1] + Mat->m[3][1];
- float zp = x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2] + Mat->m[3][2];
-
- x = xp; y = yp; z = zp;
-
- return *this;
- }
-
- // Cast operators
-
- //! Cast a IcePoint to a HPoint. w is set to zero.
- operator HPoint() const;
-
- inline_ operator const float*() const { return &x; }
- inline_ operator float*() { return &x; }
-
- public:
- float x, y, z;
- };
-
- FUNCTION ICEMATHS_API void Normalize1(IcePoint& a);
- FUNCTION ICEMATHS_API void Normalize2(IcePoint& a);
-
-#endif //__ICEPOINT_H__
diff --git a/Opcode/OpcodeLib/Ice/IcePreprocessor.h b/Opcode/OpcodeLib/Ice/IcePreprocessor.h deleted file mode 100644 index bb0ef7b..0000000 --- a/Opcode/OpcodeLib/Ice/IcePreprocessor.h +++ /dev/null @@ -1,128 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains preprocessor stuff. This should be the first included header.
- * \file IcePreprocessor.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEPREPROCESSOR_H__
-#define __ICEPREPROCESSOR_H__
-
- // Check platform
- #if defined( _WIN32 ) || defined( WIN32 )
- #pragma message("Compiling on Windows...")
- #define PLATFORM_WINDOWS
- #else
- #pragma message("Compiling on unknown platform...")
- #endif
-
- // Check compiler
- #if defined(_MSC_VER)
- #pragma message("Compiling with VC++...")
- #define COMPILER_VISUAL_CPP
- #else
- #pragma message("Compiling with unknown compiler...")
- #endif
-
- // Check compiler options. If this file is included in user-apps, this
- // shouldn't be needed, so that they can use what they like best.
- #ifndef ICE_DONT_CHECK_COMPILER_OPTIONS
- #ifdef COMPILER_VISUAL_CPP
- #if defined(_CHAR_UNSIGNED)
- #endif
-
- #if defined(_CPPRTTI)
- #error Please disable RTTI...
- #endif
-
- #if defined(_CPPUNWIND)
- #error Please disable exceptions...
- #endif
-
- #if defined(_MT)
- // Multithreading
- #endif
- #endif
- #endif
-
- // Check debug mode
- #ifdef DEBUG // May be defined instead of _DEBUG. Let's fix it.
- #ifndef _DEBUG
- #define _DEBUG
- #endif
- #endif
-
- #ifdef _DEBUG
- // Here you may define items for debug builds
- #endif
-
- #ifndef THIS_FILE
- #define THIS_FILE __FILE__
- #endif
-
- #ifndef ICE_NO_DLL
- #ifdef ICECORE_EXPORTS
- #define ICECORE_API __declspec(dllexport)
- #else
- #define ICECORE_API __declspec(dllimport)
- #endif
- #else
- #define ICECORE_API
- #endif
-
- // Don't override new/delete
-// #define DEFAULT_NEWDELETE
- #define DONT_TRACK_MEMORY_LEAKS
-
- #define FUNCTION extern "C"
-
- // Cosmetic stuff [mainly useful with multiple inheritance]
- #define override(base_class) virtual
-
- // Our own inline keyword, so that:
- // - we can switch to __forceinline to check it's really better or not
- // - we can remove __forceinline if the compiler doesn't support it
-// #define inline_ __forceinline
-// #define inline_ inline
-
- // Contributed by Bruce Mitchener
- #if defined(COMPILER_VISUAL_CPP)
- #define inline_ __forceinline
-// #define inline_ inline
- #elif defined(__GNUC__) && __GNUC__ < 3
- #define inline_ inline
- #elif defined(__GNUC__)
- #define inline_ inline __attribute__ ((always_inline))
- #else
- #define inline_ inline
- #endif
-
- // Down the hatch
- #pragma inline_depth( 255 )
-
- #ifdef COMPILER_VISUAL_CPP
- #pragma intrinsic(memcmp)
- #pragma intrinsic(memcpy)
- #pragma intrinsic(memset)
- #pragma intrinsic(strcat)
- #pragma intrinsic(strcmp)
- #pragma intrinsic(strcpy)
- #pragma intrinsic(strlen)
- #pragma intrinsic(abs)
- #pragma intrinsic(labs)
- #endif
-
- // ANSI compliance
- #ifdef _DEBUG
- // Remove painful warning in debug
- inline_ bool __False__(){ return false; }
- #define for if(__False__()){} else for
- #else
- #define for if(0){} else for
- #endif
-
-#endif // __ICEPREPROCESSOR_H__
diff --git a/Opcode/OpcodeLib/Ice/IceRandom.cpp b/Opcode/OpcodeLib/Ice/IceRandom.cpp deleted file mode 100644 index 0139be6..0000000 --- a/Opcode/OpcodeLib/Ice/IceRandom.cpp +++ /dev/null @@ -1,35 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for random generators.
- * \file IceRandom.cpp
- * \author Pierre Terdiman
- * \date August, 9, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceCore;
-
-void IceCore:: SRand(udword seed)
-{
- srand(seed);
-}
-
-udword IceCore::Rand()
-{
- return rand();
-}
-
-
-static BasicRandom gRandomGenerator(42);
-
-udword IceCore::GetRandomIndex(udword max_index)
-{
- // We don't use rand() since it's limited to RAND_MAX
- udword Index = gRandomGenerator.Randomize();
- return Index % max_index;
-}
-
diff --git a/Opcode/OpcodeLib/Ice/IceRandom.h b/Opcode/OpcodeLib/Ice/IceRandom.h deleted file mode 100644 index 3584769..0000000 --- a/Opcode/OpcodeLib/Ice/IceRandom.h +++ /dev/null @@ -1,42 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for random generators.
- * \file IceRandom.h
- * \author Pierre Terdiman
- * \date August, 9, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICERANDOM_H__
-#define __ICERANDOM_H__
-
- FUNCTION ICECORE_API void SRand(udword seed);
- FUNCTION ICECORE_API udword Rand();
-
- //! Returns a unit random floating-point value
- inline_ float UnitRandomFloat() { return float(Rand()) * ONE_OVER_RAND_MAX; }
-
- //! Returns a random index so that 0<= index < max_index
- ICECORE_API udword GetRandomIndex(udword max_index);
-
- class ICECORE_API BasicRandom
- {
- public:
-
- //! Constructor
- inline_ BasicRandom(udword seed=0) : mRnd(seed) {}
- //! Destructor
- inline_ ~BasicRandom() {}
-
- inline_ void SetSeed(udword seed) { mRnd = seed; }
- inline_ udword GetCurrentValue() const { return mRnd; }
- inline_ udword Randomize() { mRnd = mRnd * 2147001325 + 715136305; return mRnd; }
-
- private:
- udword mRnd;
- };
-
-#endif // __ICERANDOM_H__
-
diff --git a/Opcode/OpcodeLib/Ice/IceRay.cpp b/Opcode/OpcodeLib/Ice/IceRay.cpp deleted file mode 100644 index 20970ac..0000000 --- a/Opcode/OpcodeLib/Ice/IceRay.cpp +++ /dev/null @@ -1,84 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for rays.
- * \file IceRay.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Ray class.
- * A ray is a half-line P(t) = mOrig + mDir * t, with 0 <= t <= +infinity
- * \class Ray
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/*
- O = Origin = impact point
- i = normalized vector along the x axis
- j = normalized vector along the y axis = actually the normal vector in O
- D = Direction vector, norm |D| = 1
- N = Projection of D on y axis, norm |N| = normal reaction
- T = Projection of D on x axis, norm |T| = tangential reaction
- R = Reflexion vector
-
- ^y
- |
- |
- |
- _ _ _| _ _ _
- * * *|
- \ | /
- \ |N / |
- R\ | /D
- \ | / |
- \ | /
- _________\|/______*_______>x
- O T
-
- Let define theta = angle between D and N. Then cos(theta) = |N| / |D| = |N| since D is normalized.
-
- j|D = |j|*|D|*cos(theta) => |N| = j|D
-
- Then we simply have:
-
- D = N + T
-
- To compute tangential reaction :
-
- T = D - N
-
- To compute reflexion vector :
-
- R = N - T = N - (D-N) = 2*N - D
-*/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-float Ray::SquareDistance(const IcePoint& point, float* t) const
-{
- IcePoint Diff = point - mOrig;
- float fT = Diff | mDir;
-
- if(fT<=0.0f)
- {
- fT = 0.0f;
- }
- else
- {
- fT /= mDir.SquareMagnitude();
- Diff -= fT*mDir;
- }
-
- if(t) *t = fT;
-
- return Diff.SquareMagnitude();
-}
diff --git a/Opcode/OpcodeLib/Ice/IceRay.h b/Opcode/OpcodeLib/Ice/IceRay.h deleted file mode 100644 index c40552b..0000000 --- a/Opcode/OpcodeLib/Ice/IceRay.h +++ /dev/null @@ -1,98 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for rays.
- * \file IceRay.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICERAY_H__
-#define __ICERAY_H__
-
- class ICEMATHS_API Ray
- {
- public:
- //! Constructor
- inline_ Ray() {}
- //! Constructor
- inline_ Ray(const IcePoint& orig, const IcePoint& dir) : mOrig(orig), mDir(dir) {}
- //! Copy constructor
- inline_ Ray(const Ray& ray) : mOrig(ray.mOrig), mDir(ray.mDir) {}
- //! Destructor
- inline_ ~Ray() {}
-
- float SquareDistance(const IcePoint& point, float* t=null) const;
- inline_ float Distance(const IcePoint& point, float* t=null) const { return sqrtf(SquareDistance(point, t)); }
-
- IcePoint mOrig; //!< Ray origin
- IcePoint mDir; //!< Normalized direction
- };
-
- inline_ void ComputeReflexionVector(IcePoint& reflected, const IcePoint& incoming_dir, const IcePoint& outward_normal)
- {
- reflected = incoming_dir - outward_normal * 2.0f * (incoming_dir|outward_normal);
- }
-
- inline_ void ComputeReflexionVector(IcePoint& reflected, const IcePoint& source, const IcePoint& impact, const IcePoint& normal)
- {
- IcePoint V = impact - source;
- reflected = V - normal * 2.0f * (V|normal);
- }
-
- inline_ void DecomposeVector(IcePoint& normal_compo, IcePoint& tangent_compo, const IcePoint& outward_dir, const IcePoint& outward_normal)
- {
- normal_compo = outward_normal * (outward_dir|outward_normal);
- tangent_compo = outward_dir - normal_compo;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Transforms a direction vector from world space to local space
- * \param local_dir [out] direction vector in local space
- * \param world_dir [in] direction vector in world space
- * \param world [in] world transform
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void ComputeLocalDirection(IcePoint& local_dir, const IcePoint& world_dir, const Matrix4x4& world)
- {
- // Get world direction back in local space
-// Matrix3x3 InvWorld = world;
-// local_dir = InvWorld * world_dir;
- local_dir = Matrix3x3(world) * world_dir;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Transforms a position vector from world space to local space
- * \param local_pt [out] position vector in local space
- * \param world_pt [in] position vector in world space
- * \param world [in] world transform
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void ComputeLocalPoint(IcePoint& local_pt, const IcePoint& world_pt, const Matrix4x4& world)
- {
- // Get world vertex back in local space
- Matrix4x4 InvWorld = world;
- InvWorld.Invert();
- local_pt = world_pt * InvWorld;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Transforms a ray from world space to local space
- * \param local_ray [out] ray in local space
- * \param world_ray [in] ray in world space
- * \param world [in] world transform
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void ComputeLocalRay(Ray& local_ray, const Ray& world_ray, const Matrix4x4& world)
- {
- // Get world ray back in local space
- ComputeLocalDirection(local_ray.mDir, world_ray.mDir, world);
- ComputeLocalPoint(local_ray.mOrig, world_ray.mOrig, world);
- }
-
-#endif // __ICERAY_H__
diff --git a/Opcode/OpcodeLib/Ice/IceRevisitedRadix.cpp b/Opcode/OpcodeLib/Ice/IceRevisitedRadix.cpp deleted file mode 100644 index f55b0cf..0000000 --- a/Opcode/OpcodeLib/Ice/IceRevisitedRadix.cpp +++ /dev/null @@ -1,520 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains source code from the article "Radix Sort Revisited".
- * \file IceRevisitedRadix.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Revisited Radix Sort.
- * This is my new radix routine:
- * - it uses indices and doesn't recopy the values anymore, hence wasting less ram
- * - it creates all the histograms in one run instead of four
- * - it sorts words faster than dwords and bytes faster than words
- * - it correctly sorts negative floating-point values by patching the offsets
- * - it automatically takes advantage of temporal coherence
- * - multiple keys support is a side effect of temporal coherence
- * - it may be worth recoding in asm... (mainly to use FCOMI, FCMOV, etc) [it's probably memory-bound anyway]
- *
- * History:
- * - 08.15.98: very first version
- * - 04.04.00: recoded for the radix article
- * - 12.xx.00: code lifting
- * - 09.18.01: faster CHECK_PASS_VALIDITY thanks to Mark D. Shattuck (who provided other tips, not included here)
- * - 10.11.01: added local ram support
- * - 01.20.02: bugfix! In very particular cases the last pass was skipped in the float code-path, leading to incorrect sorting......
- * - 01.02.02: - "mIndices" renamed => "mRanks". That's a rank sorter after all.
- * - ranks are not "reset" anymore, but implicit on first calls
- * - 07.05.02: - offsets rewritten with one less indirection.
- * - 11.03.02: - "bool" replaced with RadixHint enum
- *
- * \class RadixSort
- * \author Pierre Terdiman
- * \version 1.4
- * \date August, 15, 1998
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/*
-To do:
- - add an offset parameter between two input values (avoid some data recopy sometimes)
- - unroll ? asm ?
- - 11 bits trick & 3 passes as Michael did
- - prefetch stuff the day I have a P3
- - make a version with 16-bits indices ?
-*/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceCore;
-
-#define INVALIDATE_RANKS mCurrentSize|=0x80000000
-#define VALIDATE_RANKS mCurrentSize&=0x7fffffff
-#define CURRENT_SIZE (mCurrentSize&0x7fffffff)
-#define INVALID_RANKS (mCurrentSize&0x80000000)
-
-#define CHECK_RESIZE(n) \
- if(n!=mPreviousSize) \
- { \
- if(n>mCurrentSize) Resize(n); \
- else ResetRanks(); \
- mPreviousSize = n; \
- }
-
-#define CREATE_HISTOGRAMS(type, buffer) \
- /* Clear counters/histograms */ \
- ZeroMemory(mHistogram, 256*4*sizeof(udword)); \
- \
- /* Prepare to count */ \
- ubyte* p = (ubyte*)input; \
- ubyte* pe = &p[nb*4]; \
- udword* h0= &mHistogram[0]; /* Histogram for first pass (LSB) */ \
- udword* h1= &mHistogram[256]; /* Histogram for second pass */ \
- udword* h2= &mHistogram[512]; /* Histogram for third pass */ \
- udword* h3= &mHistogram[768]; /* Histogram for last pass (MSB) */ \
- \
- bool AlreadySorted = true; /* Optimism... */ \
- \
- if(INVALID_RANKS) \
- { \
- /* Prepare for temporal coherence */ \
- type* Running = (type*)buffer; \
- type PrevVal = *Running; \
- \
- while(p!=pe) \
- { \
- /* Read input buffer in previous sorted order */ \
- type Val = *Running++; \
- /* Check whether already sorted or not */ \
- if(Val<PrevVal) { AlreadySorted = false; break; } /* Early out */ \
- /* Update for next iteration */ \
- PrevVal = Val; \
- \
- /* Create histograms */ \
- h0[*p++]++; h1[*p++]++; h2[*p++]++; h3[*p++]++; \
- } \
- \
- /* If all input values are already sorted, we just have to return and leave the */ \
- /* previous list unchanged. That way the routine may take advantage of temporal */ \
- /* coherence, for example when used to sort transparent faces. */ \
- if(AlreadySorted) \
- { \
- mNbHits++; \
- for(udword i=0;i<nb;i++) mRanks[i] = i; \
- return *this; \
- } \
- } \
- else \
- { \
- /* Prepare for temporal coherence */ \
- udword* Indices = mRanks; \
- type PrevVal = (type)buffer[*Indices]; \
- \
- while(p!=pe) \
- { \
- /* Read input buffer in previous sorted order */ \
- type Val = (type)buffer[*Indices++]; \
- /* Check whether already sorted or not */ \
- if(Val<PrevVal) { AlreadySorted = false; break; } /* Early out */ \
- /* Update for next iteration */ \
- PrevVal = Val; \
- \
- /* Create histograms */ \
- h0[*p++]++; h1[*p++]++; h2[*p++]++; h3[*p++]++; \
- } \
- \
- /* If all input values are already sorted, we just have to return and leave the */ \
- /* previous list unchanged. That way the routine may take advantage of temporal */ \
- /* coherence, for example when used to sort transparent faces. */ \
- if(AlreadySorted) { mNbHits++; return *this; } \
- } \
- \
- /* Else there has been an early out and we must finish computing the histograms */ \
- while(p!=pe) \
- { \
- /* Create histograms without the previous overhead */ \
- h0[*p++]++; h1[*p++]++; h2[*p++]++; h3[*p++]++; \
- }
-
-#define CHECK_PASS_VALIDITY(pass) \
- /* Shortcut to current counters */ \
- udword* CurCount = &mHistogram[pass<<8]; \
- \
- /* Reset flag. The sorting pass is supposed to be performed. (default) */ \
- bool PerformPass = true; \
- \
- /* Check pass validity */ \
- \
- /* If all values have the same byte, sorting is useless. */ \
- /* It may happen when sorting bytes or words instead of dwords. */ \
- /* This routine actually sorts words faster than dwords, and bytes */ \
- /* faster than words. Standard running time (O(4*n))is reduced to O(2*n) */ \
- /* for words and O(n) for bytes. Running time for floats depends on actual values... */ \
- \
- /* Get first byte */ \
- ubyte UniqueVal = *(((ubyte*)input)+pass); \
- \
- /* Check that byte's counter */ \
- if(CurCount[UniqueVal]==nb) PerformPass=false;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-RadixSort::RadixSort() : mRanks(null), mRanks2(null), mCurrentSize(0), mTotalCalls(0), mNbHits(0)
-{
-#ifndef RADIX_LOCAL_RAM
- // Allocate input-independent ram
- mHistogram = new udword[256*4];
- mOffset = new udword[256];
-#endif
- // Initialize indices
- INVALIDATE_RANKS;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-RadixSort::~RadixSort()
-{
- // Release everything
-#ifndef RADIX_LOCAL_RAM
- DELETEARRAY(mOffset);
- DELETEARRAY(mHistogram);
-#endif
- DELETEARRAY(mRanks2);
- DELETEARRAY(mRanks);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Resizes the inner lists.
- * \param nb [in] new size (number of dwords)
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool RadixSort::Resize(udword nb)
-{
- // Free previously used ram
- DELETEARRAY(mRanks2);
- DELETEARRAY(mRanks);
-
- // Get some fresh one
- mRanks = new udword[nb]; CHECKALLOC(mRanks);
- mRanks2 = new udword[nb]; CHECKALLOC(mRanks2);
-
- return true;
-}
-
-inline_ void RadixSort::CheckResize(udword nb)
-{
- udword CurSize = CURRENT_SIZE;
- if(nb!=CurSize)
- {
- if(nb>CurSize) Resize(nb);
- mCurrentSize = nb;
- INVALIDATE_RANKS;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Main sort routine.
- * This one is for integer values. After the call, mRanks contains a list of indices in sorted order, i.e. in the order you may process your data.
- * \param input [in] a list of integer values to sort
- * \param nb [in] number of values to sort, must be < 2^31
- * \param hint [in] RADIX_SIGNED to handle negative values, RADIX_UNSIGNED if you know your input buffer only contains positive values
- * \return Self-Reference
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-RadixSort& RadixSort::Sort(const udword* input, udword nb, RadixHint hint)
-{
- // Checkings
- if(!input || !nb || nb&0x80000000) return *this;
-
- // Stats
- mTotalCalls++;
-
- // Resize lists if needed
- CheckResize(nb);
-
-#ifdef RADIX_LOCAL_RAM
- // Allocate histograms & offsets on the stack
- udword mHistogram[256*4];
-// udword mOffset[256];
- udword* mLink[256];
-#endif
-
- // Create histograms (counters). Counters for all passes are created in one run.
- // Pros: read input buffer once instead of four times
- // Cons: mHistogram is 4Kb instead of 1Kb
- // We must take care of signed/unsigned values for temporal coherence.... I just
- // have 2 code paths even if just a single opcode changes. Self-modifying code, someone?
- if(hint==RADIX_UNSIGNED) { CREATE_HISTOGRAMS(udword, input); }
- else { CREATE_HISTOGRAMS(sdword, input); }
-
- // Compute #negative values involved if needed
- udword NbNegativeValues = 0;
- if(hint==RADIX_SIGNED)
- {
- // An efficient way to compute the number of negatives values we'll have to deal with is simply to sum the 128
- // last values of the last histogram. Last histogram because that's the one for the Most Significant Byte,
- // responsible for the sign. 128 last values because the 128 first ones are related to positive numbers.
- udword* h3= &mHistogram[768];
- for(udword i=128;i<256;i++) NbNegativeValues += h3[i]; // 768 for last histogram, 128 for negative part
- }
-
- // Radix sort, j is the pass number (0=LSB, 3=MSB)
- for(udword j=0;j<4;j++)
- {
- CHECK_PASS_VALIDITY(j);
-
- // Sometimes the fourth (negative) pass is skipped because all numbers are negative and the MSB is 0xFF (for example). This is
- // not a problem, numbers are correctly sorted anyway.
- if(PerformPass)
- {
- // Should we care about negative values?
- if(j!=3 || hint==RADIX_UNSIGNED)
- {
- // Here we deal with positive values only
-
- // Create offsets
-// mOffset[0] = 0;
-// for(udword i=1;i<256;i++) mOffset[i] = mOffset[i-1] + CurCount[i-1];
- mLink[0] = mRanks2;
- for(udword i=1;i<256;i++) mLink[i] = mLink[i-1] + CurCount[i-1];
- }
- else
- {
- // This is a special case to correctly handle negative integers. They're sorted in the right order but at the wrong place.
-
- // Create biased offsets, in order for negative numbers to be sorted as well
-// mOffset[0] = NbNegativeValues; // First positive number takes place after the negative ones
- mLink[0] = &mRanks2[NbNegativeValues]; // First positive number takes place after the negative ones
-// for(udword i=1;i<128;i++) mOffset[i] = mOffset[i-1] + CurCount[i-1]; // 1 to 128 for positive numbers
- for(udword i=1;i<128;i++) mLink[i] = mLink[i-1] + CurCount[i-1]; // 1 to 128 for positive numbers
-
- // Fixing the wrong place for negative values
-// mOffset[128] = 0;
- mLink[128] = mRanks2;
-// for(i=129;i<256;i++) mOffset[i] = mOffset[i-1] + CurCount[i-1];
- for(udword i=129;i<256;i++) mLink[i] = mLink[i-1] + CurCount[i-1];
- }
-
- // Perform Radix Sort
- ubyte* InputBytes = (ubyte*)input;
- InputBytes += j;
- if(INVALID_RANKS)
- {
-// for(udword i=0;i<nb;i++) mRanks2[mOffset[InputBytes[i<<2]]++] = i;
- for(udword i=0;i<nb;i++) *mLink[InputBytes[i<<2]]++ = i;
- VALIDATE_RANKS;
- }
- else
- {
- udword* Indices = mRanks;
- udword* IndicesEnd = &mRanks[nb];
- while(Indices!=IndicesEnd)
- {
- udword id = *Indices++;
-// mRanks2[mOffset[InputBytes[id<<2]]++] = id;
- *mLink[InputBytes[id<<2]]++ = id;
- }
- }
-
- // Swap pointers for next pass. Valid indices - the most recent ones - are in mRanks after the swap.
- udword* Tmp = mRanks; mRanks = mRanks2; mRanks2 = Tmp;
- }
- }
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Main sort routine.
- * This one is for floating-point values. After the call, mRanks contains a list of indices in sorted order, i.e. in the order you may process your data.
- * \param input [in] a list of floating-point values to sort
- * \param nb [in] number of values to sort, must be < 2^31
- * \return Self-Reference
- * \warning only sorts IEEE floating-point values
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-RadixSort& RadixSort::Sort(const float* input2, udword nb)
-{
- // Checkings
- if(!input2 || !nb || nb&0x80000000) return *this;
-
- // Stats
- mTotalCalls++;
-
- udword* input = (udword*)input2;
-
- // Resize lists if needed
- CheckResize(nb);
-
-#ifdef RADIX_LOCAL_RAM
- // Allocate histograms & offsets on the stack
- udword mHistogram[256*4];
-// udword mOffset[256];
- udword* mLink[256];
-#endif
-
- // Create histograms (counters). Counters for all passes are created in one run.
- // Pros: read input buffer once instead of four times
- // Cons: mHistogram is 4Kb instead of 1Kb
- // Floating-point values are always supposed to be signed values, so there's only one code path there.
- // Please note the floating point comparison needed for temporal coherence! Although the resulting asm code
- // is dreadful, this is surprisingly not such a performance hit - well, I suppose that's a big one on first
- // generation Pentiums....We can't make comparison on integer representations because, as Chris said, it just
- // wouldn't work with mixed positive/negative values....
- { CREATE_HISTOGRAMS(float, input2); }
-
- // Compute #negative values involved if needed
- udword NbNegativeValues = 0;
- // An efficient way to compute the number of negatives values we'll have to deal with is simply to sum the 128
- // last values of the last histogram. Last histogram because that's the one for the Most Significant Byte,
- // responsible for the sign. 128 last values because the 128 first ones are related to positive numbers.
- udword* h3= &mHistogram[768];
- for(udword i=128;i<256;i++) NbNegativeValues += h3[i]; // 768 for last histogram, 128 for negative part
-
- // Radix sort, j is the pass number (0=LSB, 3=MSB)
- for(udword j=0;j<4;j++)
- {
- // Should we care about negative values?
- if(j!=3)
- {
- // Here we deal with positive values only
- CHECK_PASS_VALIDITY(j);
-
- if(PerformPass)
- {
- // Create offsets
-// mOffset[0] = 0;
- mLink[0] = mRanks2;
-// for(udword i=1;i<256;i++) mOffset[i] = mOffset[i-1] + CurCount[i-1];
- for(udword i=1;i<256;i++) mLink[i] = mLink[i-1] + CurCount[i-1];
-
- // Perform Radix Sort
- ubyte* InputBytes = (ubyte*)input;
- InputBytes += j;
- if(INVALID_RANKS)
- {
-// for(i=0;i<nb;i++) mRanks2[mOffset[InputBytes[i<<2]]++] = i;
- for(udword i=0;i<nb;i++) *mLink[InputBytes[i<<2]]++ = i;
- VALIDATE_RANKS;
- }
- else
- {
- udword* Indices = mRanks;
- udword* IndicesEnd = &mRanks[nb];
- while(Indices!=IndicesEnd)
- {
- udword id = *Indices++;
-// mRanks2[mOffset[InputBytes[id<<2]]++] = id;
- *mLink[InputBytes[id<<2]]++ = id;
- }
- }
-
- // Swap pointers for next pass. Valid indices - the most recent ones - are in mRanks after the swap.
- udword* Tmp = mRanks; mRanks = mRanks2; mRanks2 = Tmp;
- }
- }
- else
- {
- // This is a special case to correctly handle negative values
- CHECK_PASS_VALIDITY(j);
-
- if(PerformPass)
- {
- // Create biased offsets, in order for negative numbers to be sorted as well
-// mOffset[0] = NbNegativeValues; // First positive number takes place after the negative ones
- mLink[0] = &mRanks2[NbNegativeValues]; // First positive number takes place after the negative ones
-// for(udword i=1;i<128;i++) mOffset[i] = mOffset[i-1] + CurCount[i-1]; // 1 to 128 for positive numbers
- for(udword i=1;i<128;i++) mLink[i] = mLink[i-1] + CurCount[i-1]; // 1 to 128 for positive numbers
-
- // We must reverse the sorting order for negative numbers!
-// mOffset[255] = 0;
- mLink[255] = mRanks2;
-// for(i=0;i<127;i++) mOffset[254-i] = mOffset[255-i] + CurCount[255-i]; // Fixing the wrong order for negative values
- for(udword i=0;i<127;i++) mLink[254-i] = mLink[255-i] + CurCount[255-i]; // Fixing the wrong order for negative values
-// for(i=128;i<256;i++) mOffset[i] += CurCount[i]; // Fixing the wrong place for negative values
- for(udword i=128;i<256;i++) mLink[i] += CurCount[i]; // Fixing the wrong place for negative values
-
- // Perform Radix Sort
- if(INVALID_RANKS)
- {
- for(udword i=0;i<nb;i++)
- {
- udword Radix = input[i]>>24; // Radix byte, same as above. AND is useless here (udword).
- // ### cmp to be killed. Not good. Later.
-// if(Radix<128) mRanks2[mOffset[Radix]++] = i; // Number is positive, same as above
-// else mRanks2[--mOffset[Radix]] = i; // Number is negative, flip the sorting order
- if(Radix<128) *mLink[Radix]++ = i; // Number is positive, same as above
- else *(--mLink[Radix]) = i; // Number is negative, flip the sorting order
- }
- VALIDATE_RANKS;
- }
- else
- {
- for(udword i=0;i<nb;i++)
- {
- udword Radix = input[mRanks[i]]>>24; // Radix byte, same as above. AND is useless here (udword).
- // ### cmp to be killed. Not good. Later.
-// if(Radix<128) mRanks2[mOffset[Radix]++] = mRanks[i]; // Number is positive, same as above
-// else mRanks2[--mOffset[Radix]] = mRanks[i]; // Number is negative, flip the sorting order
- if(Radix<128) *mLink[Radix]++ = mRanks[i]; // Number is positive, same as above
- else *(--mLink[Radix]) = mRanks[i]; // Number is negative, flip the sorting order
- }
- }
- // Swap pointers for next pass. Valid indices - the most recent ones - are in mRanks after the swap.
- udword* Tmp = mRanks; mRanks = mRanks2; mRanks2 = Tmp;
- }
- else
- {
- // The pass is useless, yet we still have to reverse the order of current list if all values are negative.
- if(UniqueVal>=128)
- {
- if(INVALID_RANKS)
- {
- // ###Possible?
- for(udword i=0;i<nb;i++) mRanks2[i] = nb-i-1;
- VALIDATE_RANKS;
- }
- else
- {
- for(udword i=0;i<nb;i++) mRanks2[i] = mRanks[nb-i-1];
- }
-
- // Swap pointers for next pass. Valid indices - the most recent ones - are in mRanks after the swap.
- udword* Tmp = mRanks; mRanks = mRanks2; mRanks2 = Tmp;
- }
- }
- }
- }
- return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the ram used.
- * \return memory used in bytes
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword RadixSort::GetUsedRam() const
-{
- udword UsedRam = sizeof(RadixSort);
-#ifndef RADIX_LOCAL_RAM
- UsedRam += 256*4*sizeof(udword); // Histograms
- UsedRam += 256*sizeof(udword); // Offsets
-#endif
- UsedRam += 2*CURRENT_SIZE*sizeof(udword); // 2 lists of indices
- return UsedRam;
-}
diff --git a/Opcode/OpcodeLib/Ice/IceRevisitedRadix.h b/Opcode/OpcodeLib/Ice/IceRevisitedRadix.h deleted file mode 100644 index ec2f6b1..0000000 --- a/Opcode/OpcodeLib/Ice/IceRevisitedRadix.h +++ /dev/null @@ -1,65 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains source code from the article "Radix Sort Revisited".
- * \file IceRevisitedRadix.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICERADIXSORT_H__
-#define __ICERADIXSORT_H__
-
- //! Allocate histograms & offsets locally
- #define RADIX_LOCAL_RAM
-
- enum RadixHint
- {
- RADIX_SIGNED, //!< Input values are signed
- RADIX_UNSIGNED, //!< Input values are unsigned
-
- RADIX_FORCE_DWORD = 0x7fffffff
- };
-
- class ICECORE_API RadixSort
- {
- public:
- // Constructor/Destructor
- RadixSort();
- ~RadixSort();
- // Sorting methods
- RadixSort& Sort(const udword* input, udword nb, RadixHint hint=RADIX_SIGNED);
- RadixSort& Sort(const float* input, udword nb);
-
- //! Access to results. mRanks is a list of indices in sorted order, i.e. in the order you may further process your data
- inline_ const udword* GetRanks() const { return mRanks; }
-
- //! mIndices2 gets trashed on calling the sort routine, but otherwise you can recycle it the way you want.
- inline_ udword* GetRecyclable() const { return mRanks2; }
-
- // Stats
- udword GetUsedRam() const;
- //! Returns the total number of calls to the radix sorter.
- inline_ udword GetNbTotalCalls() const { return mTotalCalls; }
- //! Returns the number of eraly exits due to temporal coherence.
- inline_ udword GetNbHits() const { return mNbHits; }
-
- private:
-#ifndef RADIX_LOCAL_RAM
- udword* mHistogram; //!< Counters for each byte
- udword* mOffset; //!< Offsets (nearly a cumulative distribution function)
-#endif
- udword mCurrentSize; //!< Current size of the indices list
- udword* mRanks; //!< Two lists, swapped each pass
- udword* mRanks2;
- // Stats
- udword mTotalCalls; //!< Total number of calls to the sort routine
- udword mNbHits; //!< Number of early exits due to coherence
- // Internal methods
- void CheckResize(udword nb);
- bool Resize(udword nb);
- };
-
-#endif // __ICERADIXSORT_H__
diff --git a/Opcode/OpcodeLib/Ice/IceSegment.cpp b/Opcode/OpcodeLib/Ice/IceSegment.cpp deleted file mode 100644 index ae99384..0000000 --- a/Opcode/OpcodeLib/Ice/IceSegment.cpp +++ /dev/null @@ -1,57 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for segments.
- * \file IceSegment.cpp
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * IceSegment class.
- * A segment is defined by S(t) = mP0 * (1 - t) + mP1 * t, with 0 <= t <= 1
- * Alternatively, a segment is S(t) = Origin + t * Direction for 0 <= t <= 1.
- * Direction is not necessarily unit length. The end points are Origin = mP0 and Origin + Direction = mP1.
- *
- * \class IceSegment
- * \author Pierre Terdiman
- * \version 1.0
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-float IceSegment::SquareDistance(const IcePoint& point, float* t) const
-{
- IcePoint Diff = point - mP0;
- IcePoint Dir = mP1 - mP0;
- float fT = Diff | Dir;
-
- if(fT<=0.0f)
- {
- fT = 0.0f;
- }
- else
- {
- float SqrLen= Dir.SquareMagnitude();
- if(fT>=SqrLen)
- {
- fT = 1.0f;
- Diff -= Dir;
- }
- else
- {
- fT /= SqrLen;
- Diff -= fT*Dir;
- }
- }
-
- if(t) *t = fT;
-
- return Diff.SquareMagnitude();
-}
diff --git a/Opcode/OpcodeLib/Ice/IceSegment.h b/Opcode/OpcodeLib/Ice/IceSegment.h deleted file mode 100644 index 1ddaa1a..0000000 --- a/Opcode/OpcodeLib/Ice/IceSegment.h +++ /dev/null @@ -1,55 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for segments.
- * \file IceSegment.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICESEGMENT_H__
-#define __ICESEGMENT_H__
-
- class ICEMATHS_API IceSegment
- {
- public:
- //! Constructor
- inline_ IceSegment() {}
- //! Constructor
- inline_ IceSegment(const IcePoint& p0, const IcePoint& p1) : mP0(p0), mP1(p1) {}
- //! Copy constructor
- inline_ IceSegment(const IceSegment& seg) : mP0(seg.mP0), mP1(seg.mP1) {}
- //! Destructor
- inline_ ~IceSegment() {}
-
- inline_ const IcePoint& GetOrigin() const { return mP0; }
- inline_ IcePoint ComputeDirection() const { return mP1 - mP0; }
- inline_ void ComputeDirection(IcePoint& dir) const { dir = mP1 - mP0; }
- inline_ float ComputeLength() const { return mP1.Distance(mP0); }
- inline_ float ComputeSquareLength() const { return mP1.SquareDistance(mP0); }
-
- inline_ void SetOriginDirection(const IcePoint& origin, const IcePoint& direction)
- {
- mP0 = mP1 = origin;
- mP1 += direction;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes a point on the segment
- * \param pt [out] point on segment
- * \param t [in] point's parameter [t=0 => pt = mP0, t=1 => pt = mP1]
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void ComputePoint(IcePoint& pt, float t) const { pt = mP0 + t * (mP1 - mP0); }
-
- float SquareDistance(const IcePoint& point, float* t=null) const;
- inline_ float Distance(const IcePoint& point, float* t=null) const { return sqrtf(SquareDistance(point, t)); }
-
- IcePoint mP0; //!< Start of segment
- IcePoint mP1; //!< End of segment
- };
-
-#endif // __ICESEGMENT_H__
diff --git a/Opcode/OpcodeLib/Ice/IceTriangle.cpp b/Opcode/OpcodeLib/Ice/IceTriangle.cpp deleted file mode 100644 index 0b8c6d5..0000000 --- a/Opcode/OpcodeLib/Ice/IceTriangle.cpp +++ /dev/null @@ -1,286 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a handy triangle class.
- * \file IceTriangle.cpp
- * \author Pierre Terdiman
- * \date January, 17, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceMaths;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a triangle class.
- *
- * \class Tri
- * \author Pierre Terdiman
- * \version 1.0
- * \date 08.15.98
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static sdword VPlaneSideEps(const IcePoint& v, const IcePlane& plane, float epsilon)
-{
- // Compute distance from current vertex to the plane
- float Dist = plane.Distance(v);
- // Compute side:
- // 1 = the vertex is on the positive side of the plane
- // -1 = the vertex is on the negative side of the plane
- // 0 = the vertex is on the plane (within epsilon)
- return Dist > epsilon ? 1 : Dist < -epsilon ? -1 : 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Flips the winding order.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Triangle::Flip()
-{
- IcePoint Tmp = mVerts[1];
- mVerts[1] = mVerts[2];
- mVerts[2] = Tmp;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle area.
- * \return the area
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Triangle::Area() const
-{
- const IcePoint& p0 = mVerts[0];
- const IcePoint& p1 = mVerts[1];
- const IcePoint& p2 = mVerts[2];
- return ((p0 - p1)^(p0 - p2)).Magnitude() * 0.5f;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle perimeter.
- * \return the perimeter
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Triangle::Perimeter() const
-{
- const IcePoint& p0 = mVerts[0];
- const IcePoint& p1 = mVerts[1];
- const IcePoint& p2 = mVerts[2];
- return p0.Distance(p1)
- + p0.Distance(p2)
- + p1.Distance(p2);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle compacity.
- * \return the compacity
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Triangle::Compacity() const
-{
- float P = Perimeter();
- if(P==0.0f) return 0.0f;
- return (4.0f*PI*Area()/(P*P));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle normal.
- * \param normal [out] the computed normal
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Triangle::Normal(IcePoint& normal) const
-{
- const IcePoint& p0 = mVerts[0];
- const IcePoint& p1 = mVerts[1];
- const IcePoint& p2 = mVerts[2];
- normal = ((p0 - p1)^(p0 - p2)).Normalize();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle denormalized normal.
- * \param normal [out] the computed normal
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Triangle::DenormalizedNormal(IcePoint& normal) const
-{
- const IcePoint& p0 = mVerts[0];
- const IcePoint& p1 = mVerts[1];
- const IcePoint& p2 = mVerts[2];
- normal = ((p0 - p1)^(p0 - p2));
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle center.
- * \param center [out] the computed center
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Triangle::Center(IcePoint& center) const
-{
- const IcePoint& p0 = mVerts[0];
- const IcePoint& p1 = mVerts[1];
- const IcePoint& p2 = mVerts[2];
- center = (p0 + p1 + p2)*INV3;
-}
-
-PartVal Triangle::TestAgainstPlane(const IcePlane& plane, float epsilon) const
-{
- bool Pos = false, Neg = false;
-
- // Loop through all vertices
- for(udword i=0;i<3;i++)
- {
- // Compute side:
- sdword Side = VPlaneSideEps(mVerts[i], plane, epsilon);
-
- if (Side < 0) Neg = true;
- else if (Side > 0) Pos = true;
- }
-
- if (!Pos && !Neg) return TRI_ON_PLANE;
- else if (Pos && Neg) return TRI_INTERSECT;
- else if (Pos && !Neg) return TRI_PLUS_SPACE;
- else if (!Pos && Neg) return TRI_MINUS_SPACE;
-
- // What?!
- return TRI_FORCEDWORD;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle moment.
- * \param m [out] the moment
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
-void Triangle::ComputeMoment(Moment& m)
-{
- // Compute the area of the triangle
- m.mArea = Area();
-
- // Compute the centroid
- Center(m.mCentroid);
-
- // Second-order components. Handle zero-area faces.
- IcePoint& p = mVerts[0];
- IcePoint& q = mVerts[1];
- IcePoint& r = mVerts[2];
- if(m.mArea==0.0f)
- {
- // This triangle has zero area. The second order components would be eliminated with the usual formula, so, for the
- // sake of robustness we use an alternative form. These are the centroid and second-order components of the triangle's vertices.
- m.mCovariance.m[0][0] = (p.x*p.x + q.x*q.x + r.x*r.x);
- m.mCovariance.m[0][1] = (p.x*p.y + q.x*q.y + r.x*r.y);
- m.mCovariance.m[0][2] = (p.x*p.z + q.x*q.z + r.x*r.z);
- m.mCovariance.m[1][1] = (p.y*p.y + q.y*q.y + r.y*r.y);
- m.mCovariance.m[1][2] = (p.y*p.z + q.y*q.z + r.y*r.z);
- m.mCovariance.m[2][2] = (p.z*p.z + q.z*q.z + r.z*r.z);
- m.mCovariance.m[2][1] = m.mCovariance.m[1][2];
- m.mCovariance.m[1][0] = m.mCovariance.m[0][1];
- m.mCovariance.m[2][0] = m.mCovariance.m[0][2];
- }
- else
- {
- const float OneOverTwelve = 1.0f / 12.0f;
- m.mCovariance.m[0][0] = m.mArea * (9.0f * m.mCentroid.x*m.mCentroid.x + p.x*p.x + q.x*q.x + r.x*r.x) * OneOverTwelve;
- m.mCovariance.m[0][1] = m.mArea * (9.0f * m.mCentroid.x*m.mCentroid.y + p.x*p.y + q.x*q.y + r.x*r.y) * OneOverTwelve;
- m.mCovariance.m[1][1] = m.mArea * (9.0f * m.mCentroid.y*m.mCentroid.y + p.y*p.y + q.y*q.y + r.y*r.y) * OneOverTwelve;
- m.mCovariance.m[0][2] = m.mArea * (9.0f * m.mCentroid.x*m.mCentroid.z + p.x*p.z + q.x*q.z + r.x*r.z) * OneOverTwelve;
- m.mCovariance.m[1][2] = m.mArea * (9.0f * m.mCentroid.y*m.mCentroid.z + p.y*p.z + q.y*q.z + r.y*r.z) * OneOverTwelve;
- m.mCovariance.m[2][2] = m.mArea * (9.0f * m.mCentroid.z*m.mCentroid.z + p.z*p.z + q.z*q.z + r.z*r.z) * OneOverTwelve;
- m.mCovariance.m[2][1] = m.mCovariance.m[1][2];
- m.mCovariance.m[1][0] = m.mCovariance.m[0][1];
- m.mCovariance.m[2][0] = m.mCovariance.m[0][2];
- }
-}
-*/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle's smallest edge length.
- * \return the smallest edge length
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Triangle::MinEdgeLength() const
-{
- float Min = MAX_FLOAT;
- float Length01 = mVerts[0].Distance(mVerts[1]);
- float Length02 = mVerts[0].Distance(mVerts[2]);
- float Length12 = mVerts[1].Distance(mVerts[2]);
- if(Length01 < Min) Min = Length01;
- if(Length02 < Min) Min = Length02;
- if(Length12 < Min) Min = Length12;
- return Min;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the triangle's largest edge length.
- * \return the largest edge length
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float Triangle::MaxEdgeLength() const
-{
- float Max = MIN_FLOAT;
- float Length01 = mVerts[0].Distance(mVerts[1]);
- float Length02 = mVerts[0].Distance(mVerts[2]);
- float Length12 = mVerts[1].Distance(mVerts[2]);
- if(Length01 > Max) Max = Length01;
- if(Length02 > Max) Max = Length02;
- if(Length12 > Max) Max = Length12;
- return Max;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes a point on the triangle according to the stabbing information.
- * \param u,v [in] point's barycentric coordinates
- * \param pt [out] point on triangle
- * \param nearvtx [out] index of nearest vertex
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Triangle::ComputePoint(float u, float v, IcePoint& pt, udword* nearvtx) const
-{
- // Compute point coordinates
- pt = (1.0f - u - v)*mVerts[0] + u*mVerts[1] + v*mVerts[2];
-
- // Compute nearest vertex if needed
- if(nearvtx)
- {
- // Compute distance vector
- IcePoint d(mVerts[0].SquareDistance(pt), // Distance^2 from vertex 0 to point on the face
- mVerts[1].SquareDistance(pt), // Distance^2 from vertex 1 to point on the face
- mVerts[2].SquareDistance(pt)); // Distance^2 from vertex 2 to point on the face
-
- // Get smallest distance
- *nearvtx = d.SmallestAxis();
- }
-}
-
-void Triangle::Inflate(float fat_coeff, bool constant_border)
-{
- // Compute triangle center
- IcePoint TriangleCenter;
- Center(TriangleCenter);
-
- // Don't normalize?
- // Normalize => add a constant border, regardless of triangle size
- // Don't => add more to big triangles
- for(udword i=0;i<3;i++)
- {
- IcePoint v = mVerts[i] - TriangleCenter;
-
- if(constant_border) v.Normalize();
-
- mVerts[i] += v * fat_coeff;
- }
-}
diff --git a/Opcode/OpcodeLib/Ice/IceTriangle.h b/Opcode/OpcodeLib/Ice/IceTriangle.h deleted file mode 100644 index c6a9a87..0000000 --- a/Opcode/OpcodeLib/Ice/IceTriangle.h +++ /dev/null @@ -1,68 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a handy triangle class.
- * \file IceTriangle.h
- * \author Pierre Terdiman
- * \date January, 17, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICETRIANGLE_H__
-#define __ICETRIANGLE_H__
-
- // Forward declarations
- class Moment;
-
- // Partitioning values
- enum PartVal
- {
- TRI_MINUS_SPACE = 0, //!< Triangle is in the negative space
- TRI_PLUS_SPACE = 1, //!< Triangle is in the positive space
- TRI_INTERSECT = 2, //!< Triangle intersects plane
- TRI_ON_PLANE = 3, //!< Triangle and plane are coplanar
-
- TRI_FORCEDWORD = 0x7fffffff
- };
-
- // A triangle class.
- class ICEMATHS_API Triangle
- {
- public:
- //! Constructor
- inline_ Triangle() {}
- //! Constructor
- inline_ Triangle(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2) { mVerts[0]=p0; mVerts[1]=p1; mVerts[2]=p2; }
- //! Copy constructor
- inline_ Triangle(const Triangle& triangle)
- {
- mVerts[0] = triangle.mVerts[0];
- mVerts[1] = triangle.mVerts[1];
- mVerts[2] = triangle.mVerts[2];
- }
- //! Destructor
- inline_ ~Triangle() {}
- //! Vertices
- IcePoint mVerts[3];
-
- // Methods
- void Flip();
- float Area() const;
- float Perimeter() const;
- float Compacity() const;
- void Normal(IcePoint& normal) const;
- void DenormalizedNormal(IcePoint& normal) const;
- void Center(IcePoint& center) const;
- inline_ IcePlane PlaneEquation() const { return IcePlane(mVerts[0], mVerts[1], mVerts[2]); }
-
- PartVal TestAgainstPlane(const IcePlane& plane, float epsilon) const;
-// float Distance(IcePoint& cp, IcePoint& cq, Tri& tri);
- void ComputeMoment(Moment& m);
- float MinEdgeLength() const;
- float MaxEdgeLength() const;
- void ComputePoint(float u, float v, IcePoint& pt, udword* nearvtx=null) const;
- void Inflate(float fat_coeff, bool constant_border);
- };
-
-#endif // __ICETRIANGLE_H__
diff --git a/Opcode/OpcodeLib/Ice/IceTrilist.h b/Opcode/OpcodeLib/Ice/IceTrilist.h deleted file mode 100644 index d5f7c70..0000000 --- a/Opcode/OpcodeLib/Ice/IceTrilist.h +++ /dev/null @@ -1,61 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a triangle container.
- * \file IceTrilist.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICETRILIST_H__
-#define __ICETRILIST_H__
-
- class ICEMATHS_API TriList : public Container
- {
- public:
- // Constructor / Destructor
- TriList() {}
- ~TriList() {}
-
- inline_ udword GetNbTriangles() const { return GetNbEntries()/9; }
- inline_ Triangle* GetTriangles() const { return (Triangle*)GetEntries(); }
-
- void AddTri(const Triangle& tri)
- {
- Add(tri.mVerts[0].x).Add(tri.mVerts[0].y).Add(tri.mVerts[0].z);
- Add(tri.mVerts[1].x).Add(tri.mVerts[1].y).Add(tri.mVerts[1].z);
- Add(tri.mVerts[2].x).Add(tri.mVerts[2].y).Add(tri.mVerts[2].z);
- }
-
- void AddTri(const IcePoint& p0, const IcePoint& p1, const IcePoint& p2)
- {
- Add(p0.x).Add(p0.y).Add(p0.z);
- Add(p1.x).Add(p1.y).Add(p1.z);
- Add(p2.x).Add(p2.y).Add(p2.z);
- }
- };
-
- class ICEMATHS_API TriangleList : public Container
- {
- public:
- // Constructor / Destructor
- TriangleList() {}
- ~TriangleList() {}
-
- inline_ udword GetNbTriangles() const { return GetNbEntries()/3; }
- inline_ IndexedTriangle* GetTriangles() const { return (IndexedTriangle*)GetEntries();}
-
- void AddTriangle(const IndexedTriangle& tri)
- {
- Add(tri.mVRef[0]).Add(tri.mVRef[1]).Add(tri.mVRef[2]);
- }
-
- void AddTriangle(udword vref0, udword vref1, udword vref2)
- {
- Add(vref0).Add(vref1).Add(vref2);
- }
- };
-
-#endif //__ICETRILIST_H__
diff --git a/Opcode/OpcodeLib/Ice/IceTypes.h b/Opcode/OpcodeLib/Ice/IceTypes.h deleted file mode 100644 index dac0a71..0000000 --- a/Opcode/OpcodeLib/Ice/IceTypes.h +++ /dev/null @@ -1,157 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains custom types.
- * \file IceTypes.h
- * \author Pierre Terdiman
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICETYPES_H__
-#define __ICETYPES_H__
-
- #define USE_HANDLE_MANAGER
-
- // Constants
- #define PI 3.1415926535897932384626433832795028841971693993751f //!< PI
- #define HALFPI 1.57079632679489661923f //!< 0.5 * PI
- #define TWOPI 6.28318530717958647692f //!< 2.0 * PI
- #define INVPI 0.31830988618379067154f //!< 1.0 / PI
-
- #define RADTODEG 57.2957795130823208768f //!< 180.0 / PI, convert radians to degrees
- #define DEGTORAD 0.01745329251994329577f //!< PI / 180.0, convert degrees to radians
-
- #define EXP 2.71828182845904523536f //!< e
- #define INVLOG2 3.32192809488736234787f //!< 1.0 / log10(2)
- #define LN2 0.693147180559945f //!< ln(2)
- #define INVLN2 1.44269504089f //!< 1.0f / ln(2)
-
- #define INV3 0.33333333333333333333f //!< 1/3
- #define INV6 0.16666666666666666666f //!< 1/6
- #define INV7 0.14285714285714285714f //!< 1/7
- #define INV9 0.11111111111111111111f //!< 1/9
- #define INV255 0.00392156862745098039f //!< 1/255
-
- #define SQRT2 1.41421356237f //!< sqrt(2)
- #define INVSQRT2 0.707106781188f //!< 1 / sqrt(2)
-
- #define SQRT3 1.73205080757f //!< sqrt(3)
- #define INVSQRT3 0.577350269189f //!< 1 / sqrt(3)
-
- #define null 0 //!< our own NULL pointer
-
- // Custom types used in ICE
- typedef signed char sbyte; //!< sizeof(sbyte) must be 1
- typedef unsigned char ubyte; //!< sizeof(ubyte) must be 1
- typedef signed short sword; //!< sizeof(sword) must be 2
- typedef unsigned short uword; //!< sizeof(uword) must be 2
- typedef signed int sdword; //!< sizeof(sdword) must be 4
- typedef unsigned int udword; //!< sizeof(udword) must be 4
- typedef signed __int64 sqword; //!< sizeof(sqword) must be 8
- typedef unsigned __int64 uqword; //!< sizeof(uqword) must be 8
- typedef float float32; //!< sizeof(float32) must be 4
- typedef double float64; //!< sizeof(float64) must be 4
-
- ICE_COMPILE_TIME_ASSERT(sizeof(bool)==1); // ...otherwise things might fail with VC++ 4.2 !
- ICE_COMPILE_TIME_ASSERT(sizeof(ubyte)==1);
- ICE_COMPILE_TIME_ASSERT(sizeof(sbyte)==1);
- ICE_COMPILE_TIME_ASSERT(sizeof(sword)==2);
- ICE_COMPILE_TIME_ASSERT(sizeof(uword)==2);
- ICE_COMPILE_TIME_ASSERT(sizeof(udword)==4);
- ICE_COMPILE_TIME_ASSERT(sizeof(sdword)==4);
- ICE_COMPILE_TIME_ASSERT(sizeof(uqword)==8);
- ICE_COMPILE_TIME_ASSERT(sizeof(sqword)==8);
-
- //! TO BE DOCUMENTED
- #define DECLARE_ICE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
-
- typedef udword DynID; //!< Dynamic identifier
-#ifdef USE_HANDLE_MANAGER
- typedef udword KID; //!< Kernel ID
-// DECLARE_ICE_HANDLE(KID);
-#else
- typedef uword KID; //!< Kernel ID
-#endif
- typedef udword RTYPE; //!< Relationship-type (!) between owners and references
- #define INVALID_ID 0xffffffff //!< Invalid dword ID (counterpart of null pointers)
-#ifdef USE_HANDLE_MANAGER
- #define INVALID_KID 0xffffffff //!< Invalid Kernel ID
-#else
- #define INVALID_KID 0xffff //!< Invalid Kernel ID
-#endif
- #define INVALID_NUMBER 0xDEADBEEF //!< Standard junk value
-
- // Define BOOL if needed
- #ifndef BOOL
- typedef int BOOL; //!< Another boolean type.
- #endif
-
- //! Union of a float and a sdword
- typedef union {
- float f; //!< The float
- sdword d; //!< The integer
- }scell;
-
- //! Union of a float and a udword
- typedef union {
- float f; //!< The float
- udword d; //!< The integer
- }ucell;
-
- // Type ranges
- #define MAX_SBYTE 0x7f //!< max possible sbyte value
- #define MIN_SBYTE 0x80 //!< min possible sbyte value
- #define MAX_UBYTE 0xff //!< max possible ubyte value
- #define MIN_UBYTE 0x00 //!< min possible ubyte value
- #define MAX_SWORD 0x7fff //!< max possible sword value
- #define MIN_SWORD 0x8000 //!< min possible sword value
- #define MAX_UWORD 0xffff //!< max possible uword value
- #define MIN_UWORD 0x0000 //!< min possible uword value
- #define MAX_SDWORD 0x7fffffff //!< max possible sdword value
- #define MIN_SDWORD 0x80000000 //!< min possible sdword value
- #define MAX_UDWORD 0xffffffff //!< max possible udword value
- #define MIN_UDWORD 0x00000000 //!< min possible udword value
- #define MAX_FLOAT FLT_MAX //!< max possible float value
- #define MIN_FLOAT (-FLT_MAX) //!< min possible loat value
- #define IEEE_1_0 0x3f800000 //!< integer representation of 1.0
- #define IEEE_255_0 0x437f0000 //!< integer representation of 255.0
- #define IEEE_MAX_FLOAT 0x7f7fffff //!< integer representation of MAX_FLOAT
- #define IEEE_MIN_FLOAT 0xff7fffff //!< integer representation of MIN_FLOAT
- #define IEEE_UNDERFLOW_LIMIT 0x1a000000
-
- #define ONE_OVER_RAND_MAX (1.0f / float(RAND_MAX)) //!< Inverse of the max possible value returned by rand()
-
- typedef int (__stdcall* PROC)(); //!< A standard procedure call.
- typedef bool (*ENUMERATION)(udword value, udword param, udword context); //!< ICE standard enumeration call
- typedef void** VTABLE; //!< A V-Table.
-
- #undef MIN
- #undef MAX
- #define MIN(a, b) ((a) < (b) ? (a) : (b)) //!< Returns the min value between a and b
- #define MAX(a, b) ((a) > (b) ? (a) : (b)) //!< Returns the max value between a and b
- #define MAXMAX(a,b,c) ((a) > (b) ? MAX (a,c) : MAX (b,c)) //!< Returns the max value between a, b and c
-
- template<class T> inline_ const T& TMin (const T& a, const T& b) { return b < a ? b : a; }
- template<class T> inline_ const T& TMax (const T& a, const T& b) { return a < b ? b : a; }
- template<class T> inline_ void TSetMin (T& a, const T& b) { if(a>b) a = b; }
- template<class T> inline_ void TSetMax (T& a, const T& b) { if(a<b) a = b; }
-
- #define SQR(x) ((x)*(x)) //!< Returns x square
- #define CUBE(x) ((x)*(x)*(x)) //!< Returns x cube
-
- #define AND & //!< ...
- #define OR | //!< ...
- #define XOR ^ //!< ...
-
- #define QUADRAT(x) ((x)*(x)) //!< Returns x square
-
-#ifdef _WIN32
-# define srand48(x) srand((unsigned int) (x))
-# define srandom(x) srand((unsigned int) (x))
-# define random() ((double) rand())
-# define drand48() ((double) (((double) rand()) / ((double) RAND_MAX)))
-#endif
-
-#endif // __ICETYPES_H__
diff --git a/Opcode/OpcodeLib/Ice/IceUtils.cpp b/Opcode/OpcodeLib/Ice/IceUtils.cpp deleted file mode 100644 index d877203..0000000 --- a/Opcode/OpcodeLib/Ice/IceUtils.cpp +++ /dev/null @@ -1,39 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains misc. useful macros & defines.
- * \file IceUtils.cpp
- * \author Pierre Terdiman (collected from various sources)
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace IceCore;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Returns the alignment of the input address.
- * \fn Alignment()
- * \param address [in] address to check
- * \return the best alignment (e.g. 1 for odd addresses, etc)
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword IceCore::Alignment(udword address)
-{
- // Returns 0 for null addresses
- if(!address) return 0;
-
- // Test all bits
- udword Align = 1;
- for(udword i=1;i<32;i++)
- {
- // Returns as soon as the alignment is broken
- if(address&Align) return Align;
- Align<<=1;
- }
- // Here all bits are null, except the highest one (else the address would be null)
- return Align;
-}
diff --git a/Opcode/OpcodeLib/Ice/IceUtils.h b/Opcode/OpcodeLib/Ice/IceUtils.h deleted file mode 100644 index 0e52bb7..0000000 --- a/Opcode/OpcodeLib/Ice/IceUtils.h +++ /dev/null @@ -1,256 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains misc. useful macros & defines.
- * \file IceUtils.h
- * \author Pierre Terdiman (collected from various sources)
- * \date April, 4, 2000
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __ICEUTILS_H__
-#define __ICEUTILS_H__
-
- #define START_RUNONCE { static bool __RunOnce__ = false; if(!__RunOnce__){
- #define END_RUNONCE __RunOnce__ = true;}}
-
- //! Reverse all the bits in a 32 bit word (from Steve Baker's Cute Code Collection)
- //! (each line can be done in any order.
- inline_ void ReverseBits(udword& n)
- {
- n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa);
- n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc);
- n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0);
- n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00);
- n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000);
- // Etc for larger intergers (64 bits in Java)
- // NOTE: the >> operation must be unsigned! (>>> in java)
- }
-
- //! Count the number of '1' bits in a 32 bit word (from Steve Baker's Cute Code Collection)
- inline_ udword CountBits(udword n)
- {
- // This relies of the fact that the count of n bits can NOT overflow
- // an n bit interger. EG: 1 bit count takes a 1 bit interger, 2 bit counts
- // 2 bit interger, 3 bit count requires only a 2 bit interger.
- // So we add all bit pairs, then each nible, then each byte etc...
- n = (n & 0x55555555) + ((n & 0xaaaaaaaa) >> 1);
- n = (n & 0x33333333) + ((n & 0xcccccccc) >> 2);
- n = (n & 0x0f0f0f0f) + ((n & 0xf0f0f0f0) >> 4);
- n = (n & 0x00ff00ff) + ((n & 0xff00ff00) >> 8);
- n = (n & 0x0000ffff) + ((n & 0xffff0000) >> 16);
- // Etc for larger intergers (64 bits in Java)
- // NOTE: the >> operation must be unsigned! (>>> in java)
- return n;
- }
-
- //! Even faster?
- inline_ udword CountBits2(udword bits)
- {
- bits = bits - ((bits >> 1) & 0x55555555);
- bits = ((bits >> 2) & 0x33333333) + (bits & 0x33333333);
- bits = ((bits >> 4) + bits) & 0x0F0F0F0F;
- return (bits * 0x01010101) >> 24;
- }
-
- //! Spread out bits. EG 00001111 -> 0101010101
- //! 00001010 -> 0100010000
- //! This is used to interleve to intergers to produce a `Morten Key'
- //! used in Space Filling Curves (See DrDobbs Journal, July 1999)
- //! Order is important.
- inline_ void SpreadBits(udword& n)
- {
- n = ( n & 0x0000ffff) | (( n & 0xffff0000) << 16);
- n = ( n & 0x000000ff) | (( n & 0x0000ff00) << 8);
- n = ( n & 0x000f000f) | (( n & 0x00f000f0) << 4);
- n = ( n & 0x03030303) | (( n & 0x0c0c0c0c) << 2);
- n = ( n & 0x11111111) | (( n & 0x22222222) << 1);
- }
-
- // Next Largest Power of 2
- // Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm
- // that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with
- // the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next
- // largest power of 2. For a 32-bit value:
- inline_ udword nlpo2(udword x)
- {
- x |= (x >> 1);
- x |= (x >> 2);
- x |= (x >> 4);
- x |= (x >> 8);
- x |= (x >> 16);
- return x+1;
- }
-
- //! Test to see if a number is an exact power of two (from Steve Baker's Cute Code Collection)
- inline_ bool IsPowerOfTwo(udword n) { return ((n&(n-1))==0); }
-
- //! Zero the least significant '1' bit in a word. (from Steve Baker's Cute Code Collection)
- inline_ void ZeroLeastSetBit(udword& n) { n&=(n-1); }
-
- //! Set the least significant N bits in a word. (from Steve Baker's Cute Code Collection)
- inline_ void SetLeastNBits(udword& x, udword n) { x|=~(~0<<n); }
-
- //! Classic XOR swap (from Steve Baker's Cute Code Collection)
- //! x ^= y; /* x' = (x^y) */
- //! y ^= x; /* y' = (y^(x^y)) = x */
- //! x ^= y; /* x' = (x^y)^x = y */
- inline_ void Swap(udword& x, udword& y) { x ^= y; y ^= x; x ^= y; }
-
- //! Little/Big endian (from Steve Baker's Cute Code Collection)
- //!
- //! Extra comments by Kenny Hoff:
- //! Determines the byte-ordering of the current machine (little or big endian)
- //! by setting an integer value to 1 (so least significant bit is now 1); take
- //! the address of the int and cast to a byte pointer (treat integer as an
- //! array of four bytes); check the value of the first byte (must be 0 or 1).
- //! If the value is 1, then the first byte least significant byte and this
- //! implies LITTLE endian. If the value is 0, the first byte is the most
- //! significant byte, BIG endian. Examples:
- //! integer 1 on BIG endian: 00000000 00000000 00000000 00000001
- //! integer 1 on LITTLE endian: 00000001 00000000 00000000 00000000
- //!---------------------------------------------------------------------------
- //! int IsLittleEndian() { int x=1; return ( ((char*)(&x))[0] ); }
- inline_ char LittleEndian() { int i = 1; return *((char*)&i); }
-
- //!< Alternative abs function
- inline_ udword abs_(sdword x) { sdword y= x >> 31; return (x^y)-y; }
-
- //!< Alternative min function
- inline_ sdword min_(sdword a, sdword b) { sdword delta = b-a; return a + (delta&(delta>>31)); }
-
- // Determine if one of the bytes in a 4 byte word is zero
- inline_ BOOL HasNullByte(udword x) { return ((x + 0xfefefeff) & (~x) & 0x80808080); }
-
- // To find the smallest 1 bit in a word EG: ~~~~~~10---0 => 0----010---0
- inline_ udword LowestOneBit(udword w) { return ((w) & (~(w)+1)); }
-// inline_ udword LowestOneBit_(udword w) { return ((w) & (-(w))); }
-
- // Most Significant 1 Bit
- // Given a binary integer value x, the most significant 1 bit (highest numbered element of a bit set)
- // can be computed using a SWAR algorithm that recursively "folds" the upper bits into the lower bits.
- // This process yields a bit vector with the same most significant 1 as x, but all 1's below it.
- // Bitwise AND of the original value with the complement of the "folded" value shifted down by one
- // yields the most significant bit. For a 32-bit value:
- inline_ udword msb32(udword x)
- {
- x |= (x >> 1);
- x |= (x >> 2);
- x |= (x >> 4);
- x |= (x >> 8);
- x |= (x >> 16);
- return (x & ~(x >> 1));
- }
-
- /*
- "Just call it repeatedly with various input values and always with the same variable as "memory".
- The sharpness determines the degree of filtering, where 0 completely filters out the input, and 1
- does no filtering at all.
-
- I seem to recall from college that this is called an IIR (Infinite Impulse Response) filter. As opposed
- to the more typical FIR (Finite Impulse Response).
-
- Also, I'd say that you can make more intelligent and interesting filters than this, for example filters
- that remove wrong responses from the mouse because it's being moved too fast. You'd want such a filter
- to be applied before this one, of course."
-
- (JCAB on Flipcode)
- */
- inline_ float FeedbackFilter(float val, float& memory, float sharpness)
- {
- ASSERT(sharpness>=0.0f && sharpness<=1.0f && "Invalid sharpness value in feedback filter");
- if(sharpness<0.0f) sharpness = 0.0f;
- else if(sharpness>1.0f) sharpness = 1.0f;
- return memory = val * sharpness + memory * (1.0f - sharpness);
- }
-
- //! If you can guarantee that your input domain (i.e. value of x) is slightly
- //! limited (abs(x) must be < ((1<<31u)-32767)), then you can use the
- //! following code to clamp the resulting value into [-32768,+32767] range:
- inline_ int ClampToInt16(int x)
- {
-// ASSERT(abs(x) < (int)((1<<31u)-32767));
-
- int delta = 32767 - x;
- x += (delta>>31) & delta;
- delta = x + 32768;
- x -= (delta>>31) & delta;
- return x;
- }
-
- // Generic functions
- template<class Type> inline_ void TSwap(Type& a, Type& b) { const Type c = a; a = b; b = c; }
- template<class Type> inline_ Type TClamp(const Type& x, const Type& lo, const Type& hi) { return ((x<lo) ? lo : (x>hi) ? hi : x); }
-
- template<class Type> inline_ void TSort(Type& a, Type& b)
- {
- if(a>b) TSwap(a, b);
- }
-
- template<class Type> inline_ void TSort(Type& a, Type& b, Type& c)
- {
- if(a>b) TSwap(a, b);
- if(b>c) TSwap(b, c);
- if(a>b) TSwap(a, b);
- if(b>c) TSwap(b, c);
- }
-
- // Prevent nasty user-manipulations (strategy borrowed from Charles Bloom)
-// #define PREVENT_COPY(curclass) void operator = (const curclass& object) { ASSERT(!"Bad use of operator ="); }
- // ... actually this is better !
- #define PREVENT_COPY(cur_class) private: cur_class(const cur_class& object); cur_class& operator=(const cur_class& object);
-
- //! TO BE DOCUMENTED
- #define OFFSET_OF(Class, Member) (size_t)&(((Class*)0)->Member)
- //! TO BE DOCUMENTED
- //#define ARRAYSIZE(p) (sizeof(p)/sizeof(p[0]))
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Returns the alignment of the input address.
- * \fn Alignment()
- * \param address [in] address to check
- * \return the best alignment (e.g. 1 for odd addresses, etc)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- FUNCTION ICECORE_API udword Alignment(udword address);
-
- #define IS_ALIGNED_2(x) ((x&1)==0)
- #define IS_ALIGNED_4(x) ((x&3)==0)
- #define IS_ALIGNED_8(x) ((x&7)==0)
-
- inline_ void _prefetch(void const* ptr) { (void)*(char const volatile *)ptr; }
-
- // Compute implicit coords from an index:
- // The idea is to get back 2D coords from a 1D index.
- // For example:
- //
- // 0 1 2 ... nbu-1
- // nbu nbu+1 i ...
- //
- // We have i, we're looking for the equivalent (u=2, v=1) location.
- // i = u + v*nbu
- // <=> i/nbu = u/nbu + v
- // Since 0 <= u < nbu, u/nbu = 0 (integer)
- // Hence: v = i/nbu
- // Then we simply put it back in the original equation to compute u = i - v*nbu
- inline_ void Compute2DCoords(udword& u, udword& v, udword i, udword nbu)
- {
- v = i / nbu;
- u = i - (v * nbu);
- }
-
- // In 3D: i = u + v*nbu + w*nbu*nbv
- // <=> i/(nbu*nbv) = u/(nbu*nbv) + v/nbv + w
- // u/(nbu*nbv) is null since u/nbu was null already.
- // v/nbv is null as well for the same reason.
- // Hence w = i/(nbu*nbv)
- // Then we're left with a 2D problem: i' = i - w*nbu*nbv = u + v*nbu
- inline_ void Compute3DCoords(udword& u, udword& v, udword& w, udword i, udword nbu, udword nbu_nbv)
- {
- w = i / (nbu_nbv);
- Compute2DCoords(u, v, i - (w * nbu_nbv), nbu);
- }
-
-#endif // __ICEUTILS_H__
diff --git a/Opcode/OpcodeLib/OPC_AABBCollider.cpp b/Opcode/OpcodeLib/OPC_AABBCollider.cpp deleted file mode 100644 index fe87d24..0000000 --- a/Opcode/OpcodeLib/OPC_AABBCollider.cpp +++ /dev/null @@ -1,696 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for an AABB collider.
- * \file OPC_AABBCollider.cpp
- * \author Pierre Terdiman
- * \date January, 1st, 2002
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains an AABB-vs-tree collider.
- *
- * \class AABBCollider
- * \author Pierre Terdiman
- * \version 1.3
- * \date January, 1st, 2002
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-#include "OPC_BoxBoxOverlap.h"
-#include "OPC_TriBoxOverlap.h"
-
-#define SET_CONTACT(prim_index, flag) \
- /* Set contact status */ \
- mFlags |= flag; \
- mTouchedPrimitives->Add(prim_index);
-
-//! AABB-triangle test
-#define AABB_PRIM(prim_index, flag) \
- /* Request vertices from the app */ \
- VertexPointers VP; mIMesh->GetTriangle(VP, prim_index);\
- mLeafVerts[0] = *VP.Vertex[0]; \
- mLeafVerts[1] = *VP.Vertex[1]; \
- mLeafVerts[2] = *VP.Vertex[2]; \
- /* Perform triangle-box overlap test */ \
- if(TriBoxOverlap()) \
- { \
- SET_CONTACT(prim_index, flag) \
- }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBCollider::AABBCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBCollider::~AABBCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Generic collision query for generic OPCODE models. After the call, access the results:
- * - with GetContactStatus()
- * - with GetNbTouchedPrimitives()
- * - with GetTouchedPrimitives()
- *
- * \param cache [in/out] a box cache
- * \param box [in] collision AABB in world space
- * \param model [in] Opcode model to collide with
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBCollider::Collide(AABBCache& cache, const CollisionAABB& box, const Model& model)
-{
- // Checkings
- if(!Setup(&model)) return false;
-
- // Init collision query
- if(InitQuery(cache, box)) return true;
-
- if(!model.HasLeafNodes())
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- else
- {
- const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- }
- else
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- else
- {
- const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- }
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Initializes a collision query :
- * - reset stats & contact status
- * - check temporal coherence
- *
- * \param cache [in/out] a box cache
- * \param box [in] AABB in world space
- * \return TRUE if we can return immediately
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BOOL AABBCollider::InitQuery(AABBCache& cache, const CollisionAABB& box)
-{
- // 1) Call the base method
- VolumeCollider::InitQuery();
-
- // 2) Keep track of the query box
- mBox = box;
-
- // 3) Setup destination pointer
- mTouchedPrimitives = &cache.TouchedPrimitives;
-
- // 4) Special case: 1-triangle meshes [Opcode 1.3]
- if(mCurrentModel && mCurrentModel->HasSingleNode())
- {
- if(!SkipPrimitiveTests())
- {
- // We simply perform the BV-Prim overlap test each time. We assume single triangle has index 0.
- mTouchedPrimitives->Reset();
-
- // Perform overlap test between the unique triangle and the box (and set contact status if needed)
- AABB_PRIM(udword(0), OPC_CONTACT)
-
- // Return immediately regardless of status
- return TRUE;
- }
- }
-
- // 5) Check temporal coherence :
- if(TemporalCoherenceEnabled())
- {
- // Here we use temporal coherence
- // => check results from previous frame before performing the collision query
- if(FirstContactEnabled())
- {
- // We're only interested in the first contact found => test the unique previously touched face
- if(mTouchedPrimitives->GetNbEntries())
- {
- // Get index of previously touched face = the first entry in the array
- udword PreviouslyTouchedFace = mTouchedPrimitives->GetEntry(0);
-
- // Then reset the array:
- // - if the overlap test below is successful, the index we'll get added back anyway
- // - if it isn't, then the array should be reset anyway for the normal query
- mTouchedPrimitives->Reset();
-
- // Perform overlap test between the cached triangle and the box (and set contact status if needed)
- AABB_PRIM(PreviouslyTouchedFace, OPC_TEMPORAL_CONTACT)
-
- // Return immediately if possible
- if(GetContactStatus()) return TRUE;
- }
- // else no face has been touched during previous query
- // => we'll have to perform a normal query
- }
- else
- {
- // We're interested in all contacts =>test the new real box N(ew) against the previous fat box P(revious):
- if(IsCacheValid(cache) && mBox.IsInside(cache.FatBox))
- {
- // - if N is included in P, return previous list
- // => we simply leave the list (mTouchedFaces) unchanged
-
- // Set contact status if needed
- if(mTouchedPrimitives->GetNbEntries()) mFlags |= OPC_TEMPORAL_CONTACT;
-
- // In any case we don't need to do a query
- return TRUE;
- }
- else
- {
- // - else do the query using a fat N
-
- // Reset cache since we'll about to perform a real query
- mTouchedPrimitives->Reset();
-
- // Make a fat box so that coherence will work for subsequent frames
- mBox.mExtents *= cache.FatCoeff;
-
- // Update cache with query data (signature for cached faces)
- cache.FatBox = mBox;
- }
- }
- }
- else
- {
- // Here we don't use temporal coherence => do a normal query
- mTouchedPrimitives->Reset();
- }
-
- // 5) Precompute min & max bounds if needed
- mMin = box.mCenter - box.mExtents;
- mMax = box.mCenter + box.mExtents;
-
- return FALSE;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Collision query for vanilla AABB trees.
- * \param cache [in/out] a box cache
- * \param box [in] collision AABB in world space
- * \param tree [in] AABB tree
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBCollider::Collide(AABBCache& cache, const CollisionAABB& box, const AABBTree* tree)
-{
- // This is typically called for a scene tree, full of -AABBs-, not full of triangles.
- // So we don't really have "primitives" to deal with. Hence it doesn't work with
- // "FirstContact" + "TemporalCoherence".
- ASSERT( !(FirstContactEnabled() && TemporalCoherenceEnabled()) );
-
- // Checkings
- if(!tree) return false;
-
- // Init collision query
- if(InitQuery(cache, box)) return true;
-
- // Perform collision query
- _Collide(tree);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks the AABB completely contains the box. In which case we can end the query sooner.
- * \param bc [in] box center
- * \param be [in] box extents
- * \return true if the AABB contains the whole box
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL AABBCollider::AABBContainsBox(const IcePoint& bc, const IcePoint& be)
-{
- if(mMin.x > bc.x - be.x) return FALSE;
- if(mMin.y > bc.y - be.y) return FALSE;
- if(mMin.z > bc.z - be.z) return FALSE;
-
- if(mMax.x < bc.x + be.x) return FALSE;
- if(mMax.y < bc.y + be.y) return FALSE;
- if(mMax.z < bc.z + be.z) return FALSE;
-
- return TRUE;
-}
-
-#define TEST_BOX_IN_AABB(center, extents) \
- if(AABBContainsBox(center, extents)) \
- { \
- /* Set contact status */ \
- mFlags |= OPC_CONTACT; \
- _Dump(node); \
- return; \
- }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for normal AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_Collide(const AABBCollisionNode* node)
-{
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_AABB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->IsLeaf())
- {
- AABB_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- _Collide(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for normal AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_CollideNoPrimitiveTest(const AABBCollisionNode* node)
-{
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_AABB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->IsLeaf())
- {
- SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- _CollideNoPrimitiveTest(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_Collide(const AABBQuantizedNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_AABB(Center, Extents)
-
- if(node->IsLeaf())
- {
- AABB_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- _Collide(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_CollideNoPrimitiveTest(const AABBQuantizedNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_AABB(Center, Extents)
-
- if(node->IsLeaf())
- {
- SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- _CollideNoPrimitiveTest(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_Collide(const AABBNoLeafNode* node)
-{
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_AABB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->HasPosLeaf()) { AABB_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { AABB_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for no-leaf AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_CollideNoPrimitiveTest(const AABBNoLeafNode* node)
-{
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_AABB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->HasPosLeaf()) { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_Collide(const AABBQuantizedNoLeafNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_AABB(Center, Extents)
-
- if(node->HasPosLeaf()) { AABB_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { AABB_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized no-leaf AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_CollideNoPrimitiveTest(const AABBQuantizedNoLeafNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform AABB-AABB overlap test
- if(!AABBAABBOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_AABB(Center, Extents)
-
- if(node->HasPosLeaf()) { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for vanilla AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBCollider::_Collide(const AABBTreeNode* node)
-{
- // Perform AABB-AABB overlap test
- IcePoint Center, Extents;
- node->GetAABB()->GetCenter(Center);
- node->GetAABB()->GetExtents(Extents);
- if(!AABBAABBOverlap(Center, Extents)) return;
-
- if(node->IsLeaf() || AABBContainsBox(Center, Extents))
- {
- mFlags |= OPC_CONTACT;
- mTouchedPrimitives->Add(node->GetPrimitives(), node->GetNbPrimitives());
- }
- else
- {
- _Collide(node->GetPos());
- _Collide(node->GetNeg());
- }
-}
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HybridAABBCollider::HybridAABBCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HybridAABBCollider::~HybridAABBCollider()
-{
-}
-
-bool HybridAABBCollider::Collide(AABBCache& cache, const CollisionAABB& box, const HybridModel& model)
-{
- // We don't want primitive tests here!
- mFlags |= OPC_NO_PRIMITIVE_TESTS;
-
- // Checkings
- if(!Setup(&model)) return false;
-
- // Init collision query
- if(InitQuery(cache, box)) return true;
-
- // Special case for 1-leaf trees
- if(mCurrentModel && mCurrentModel->HasSingleNode())
- {
- // Here we're supposed to perform a normal query, except our tree has a single node, i.e. just a few triangles
- udword Nb = mIMesh->GetNbTriangles();
-
- // Loop through all triangles
- for(udword i=0;i<Nb;i++)
- {
- AABB_PRIM(i, OPC_CONTACT)
- }
- return true;
- }
-
- // Override destination array since we're only going to get leaf boxes here
- mTouchedBoxes.Reset();
- mTouchedPrimitives = &mTouchedBoxes;
-
- // Now, do the actual query against leaf boxes
- if(!model.HasLeafNodes())
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- else
- {
- const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- }
- else
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- else
- {
- const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- }
-
- // We only have a list of boxes so far
- if(GetContactStatus())
- {
- // Reset contact status, since it currently only reflects collisions with leaf boxes
- Collider::InitQuery();
-
- // Change dest container so that we can use built-in overlap tests and get collided primitives
- cache.TouchedPrimitives.Reset();
- mTouchedPrimitives = &cache.TouchedPrimitives;
-
- // Read touched leaf boxes
- udword Nb = mTouchedBoxes.GetNbEntries();
- const udword* Touched = mTouchedBoxes.GetEntries();
-
- const LeafTriangles* LT = model.GetLeafTriangles();
- const udword* Indices = model.GetIndices();
-
- // Loop through touched leaves
- while(Nb--)
- {
- const LeafTriangles& CurrentLeaf = LT[*Touched++];
-
- // Each leaf box has a set of triangles
- udword NbTris = CurrentLeaf.GetNbTriangles();
- if(Indices)
- {
- const udword* T = &Indices[CurrentLeaf.GetTriangleIndex()];
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- udword TriangleIndex = *T++;
- AABB_PRIM(TriangleIndex, OPC_CONTACT)
- }
- }
- else
- {
- udword BaseIndex = CurrentLeaf.GetTriangleIndex();
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- udword TriangleIndex = BaseIndex++;
- AABB_PRIM(TriangleIndex, OPC_CONTACT)
- }
- }
- }
- }
-
- return true;
-}
diff --git a/Opcode/OpcodeLib/OPC_AABBCollider.h b/Opcode/OpcodeLib/OPC_AABBCollider.h deleted file mode 100644 index 9a86948..0000000 --- a/Opcode/OpcodeLib/OPC_AABBCollider.h +++ /dev/null @@ -1,97 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for an AABB collider.
- * \file OPC_AABBCollider.h
- * \author Pierre Terdiman
- * \date January, 1st, 2002
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_AABBCOLLIDER_H__
-#define __OPC_AABBCOLLIDER_H__
-
- struct OPCODE_API AABBCache : VolumeCache
- {
- AABBCache() : FatCoeff(1.1f)
- {
- FatBox.mCenter.Zero();
- FatBox.mExtents.Zero();
- }
-
- // Cached faces signature
- CollisionAABB FatBox; //!< Box used when performing the query resulting in cached faces
- // User settings
- float FatCoeff; //!< mRadius2 multiplier used to create a fat sphere
- };
-
- class OPCODE_API AABBCollider : public VolumeCollider
- {
- public:
- // Constructor / Destructor
- AABBCollider();
- virtual ~AABBCollider();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Generic collision query for generic OPCODE models. After the call, access the results:
- * - with GetContactStatus()
- * - with GetNbTouchedPrimitives()
- * - with GetTouchedPrimitives()
- *
- * \param cache [in/out] a box cache
- * \param box [in] collision AABB in world space
- * \param model [in] Opcode model to collide with
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool Collide(AABBCache& cache, const CollisionAABB& box, const Model& model);
- //
- bool Collide(AABBCache& cache, const CollisionAABB& box, const AABBTree* tree);
- protected:
- CollisionAABB mBox; //!< Query box in (center, extents) form
- IcePoint mMin; //!< Query box min point
- IcePoint mMax; //!< Query box max point
- // Leaf description
- IcePoint mLeafVerts[3]; //!< Triangle vertices
- // Internal methods
- void _Collide(const AABBCollisionNode* node);
- void _Collide(const AABBNoLeafNode* node);
- void _Collide(const AABBQuantizedNode* node);
- void _Collide(const AABBQuantizedNoLeafNode* node);
- void _Collide(const AABBTreeNode* node);
- void _CollideNoPrimitiveTest(const AABBCollisionNode* node);
- void _CollideNoPrimitiveTest(const AABBNoLeafNode* node);
- void _CollideNoPrimitiveTest(const AABBQuantizedNode* node);
- void _CollideNoPrimitiveTest(const AABBQuantizedNoLeafNode* node);
- // Overlap tests
- inline_ BOOL AABBContainsBox(const IcePoint& bc, const IcePoint& be);
- inline_ BOOL AABBAABBOverlap(const IcePoint& b, const IcePoint& Pb);
- inline_ BOOL TriBoxOverlap();
- // Init methods
- BOOL InitQuery(AABBCache& cache, const CollisionAABB& box);
- };
-
- class OPCODE_API HybridAABBCollider : public AABBCollider
- {
- public:
- // Constructor / Destructor
- HybridAABBCollider();
- virtual ~HybridAABBCollider();
-
- bool Collide(AABBCache& cache, const CollisionAABB& box, const HybridModel& model);
- protected:
- Container mTouchedBoxes;
- };
-
-#endif // __OPC_AABBCOLLIDER_H__
diff --git a/Opcode/OpcodeLib/OPC_AABBTree.cpp b/Opcode/OpcodeLib/OPC_AABBTree.cpp deleted file mode 100644 index e7ac631..0000000 --- a/Opcode/OpcodeLib/OPC_AABBTree.cpp +++ /dev/null @@ -1,573 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a versatile AABB tree.
- * \file OPC_AABBTree.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a generic AABB tree node.
- *
- * \class AABBTreeNode
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a generic AABB tree.
- * This is a vanilla AABB tree, without any particular optimization. It contains anonymous references to
- * user-provided primitives, which can theoretically be anything - triangles, boxes, etc. Each primitive
- * is surrounded by an AABB, regardless of the primitive's nature. When the primitive is a triangle, the
- * resulting tree can be converted into an optimized tree. If the primitive is a box, the resulting tree
- * can be used for culling - VFC or occlusion -, assuming you cull on a mesh-by-mesh basis (modern way).
- *
- * \class AABBTree
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBTreeNode::AABBTreeNode() :
- mPos (null),
-#ifndef OPC_NO_NEG_VANILLA_TREE
- mNeg (null),
-#endif
- mNbPrimitives (0),
- mNodePrimitives (null)
-{
-#ifdef OPC_USE_TREE_COHERENCE
- mBitmask = 0;
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBTreeNode::~AABBTreeNode()
-{
- // Opcode 1.3:
- const AABBTreeNode* Pos = GetPos();
- const AABBTreeNode* Neg = GetNeg();
-#ifndef OPC_NO_NEG_VANILLA_TREE
- if(!(mPos&1)) DELETESINGLE(Pos);
- if(!(mNeg&1)) DELETESINGLE(Neg);
-#else
- if(!(mPos&1)) DELETEARRAY(Pos);
-#endif
- mNodePrimitives = null; // This was just a shortcut to the global list => no release
- mNbPrimitives = 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Splits the node along a given axis.
- * The list of indices is reorganized according to the split values.
- * \param axis [in] splitting axis index
- * \param builder [in] the tree builder
- * \return the number of primitives assigned to the first child
- * \warning this method reorganizes the internal list of primitives
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword AABBTreeNode::Split(udword axis, AABBTreeBuilder* builder)
-{
- // Get node split value
- float SplitValue = builder->GetSplittingValue(mNodePrimitives, mNbPrimitives, mBV, axis);
-
- udword NbPos = 0;
- // Loop through all node-related primitives. Their indices range from mNodePrimitives[0] to mNodePrimitives[mNbPrimitives-1].
- // Those indices map the global list in the tree builder.
- for(udword i=0;i<mNbPrimitives;i++)
- {
- // Get index in global list
- udword Index = mNodePrimitives[i];
-
- // Test against the splitting value. The primitive value is tested against the enclosing-box center.
- // [We only need an approximate partition of the enclosing box here.]
- float PrimitiveValue = builder->GetSplittingValue(Index, axis);
-
- // Reorganize the list of indices in this order: positive - negative.
- if(PrimitiveValue > SplitValue)
- {
- // Swap entries
- udword Tmp = mNodePrimitives[i];
- mNodePrimitives[i] = mNodePrimitives[NbPos];
- mNodePrimitives[NbPos] = Tmp;
- // Count primitives assigned to positive space
- NbPos++;
- }
- }
- return NbPos;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Subdivides the node.
- *
- * N
- * / \
- * / \
- * N/2 N/2
- * / \ / \
- * N/4 N/4 N/4 N/4
- * (etc)
- *
- * A well-balanced tree should have a O(log n) depth.
- * A degenerate tree would have a O(n) depth.
- * Note a perfectly-balanced tree is not well-suited to collision detection anyway.
- *
- * \param builder [in] the tree builder
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeNode::Subdivide(AABBTreeBuilder* builder)
-{
- // Checkings
- if(!builder) return false;
-
- // Stop subdividing if we reach a leaf node. This is always performed here,
- // else we could end in trouble if user overrides this.
- if(mNbPrimitives==1) return true;
-
- // Let the user validate the subdivision
- if(!builder->ValidateSubdivision(mNodePrimitives, mNbPrimitives, mBV)) return true;
-
- bool ValidSplit = true; // Optimism...
- udword NbPos;
- if(builder->mSettings.mRules & SPLIT_LARGEST_AXIS)
- {
- // Find the largest axis to split along
- IcePoint Extents; mBV.GetExtents(Extents); // Box extents
- udword Axis = Extents.LargestAxis(); // Index of largest axis
-
- // Split along the axis
- NbPos = Split(Axis, builder);
-
- // Check split validity
- if(!NbPos || NbPos==mNbPrimitives) ValidSplit = false;
- }
- else if(builder->mSettings.mRules & SPLIT_SPLATTER_POINTS)
- {
- // Compute the means
- IcePoint Means(0.0f, 0.0f, 0.0f);
- for(udword i=0;i<mNbPrimitives;i++)
- {
- udword Index = mNodePrimitives[i];
- Means.x+=builder->GetSplittingValue(Index, 0);
- Means.y+=builder->GetSplittingValue(Index, 1);
- Means.z+=builder->GetSplittingValue(Index, 2);
- }
- Means/=float(mNbPrimitives);
-
- // Compute variances
- IcePoint Vars(0.0f, 0.0f, 0.0f);
- for(udword i=0;i<mNbPrimitives;i++)
- {
- udword Index = mNodePrimitives[i];
- float Cx = builder->GetSplittingValue(Index, 0);
- float Cy = builder->GetSplittingValue(Index, 1);
- float Cz = builder->GetSplittingValue(Index, 2);
- Vars.x += (Cx - Means.x)*(Cx - Means.x);
- Vars.y += (Cy - Means.y)*(Cy - Means.y);
- Vars.z += (Cz - Means.z)*(Cz - Means.z);
- }
- Vars/=float(mNbPrimitives-1);
-
- // Choose axis with greatest variance
- udword Axis = Vars.LargestAxis();
-
- // Split along the axis
- NbPos = Split(Axis, builder);
-
- // Check split validity
- if(!NbPos || NbPos==mNbPrimitives) ValidSplit = false;
- }
- else if(builder->mSettings.mRules & SPLIT_BALANCED)
- {
- // Test 3 axis, take the best
- float Results[3];
- NbPos = Split(0, builder); Results[0] = float(NbPos)/float(mNbPrimitives);
- NbPos = Split(1, builder); Results[1] = float(NbPos)/float(mNbPrimitives);
- NbPos = Split(2, builder); Results[2] = float(NbPos)/float(mNbPrimitives);
- Results[0]-=0.5f; Results[0]*=Results[0];
- Results[1]-=0.5f; Results[1]*=Results[1];
- Results[2]-=0.5f; Results[2]*=Results[2];
- udword Min=0;
- if(Results[1]<Results[Min]) Min = 1;
- if(Results[2]<Results[Min]) Min = 2;
-
- // Split along the axis
- NbPos = Split(Min, builder);
-
- // Check split validity
- if(!NbPos || NbPos==mNbPrimitives) ValidSplit = false;
- }
- else if(builder->mSettings.mRules & SPLIT_BEST_AXIS)
- {
- // Test largest, then middle, then smallest axis...
-
- // Sort axis
- IcePoint Extents; mBV.GetExtents(Extents); // Box extents
- udword SortedAxis[] = { 0, 1, 2 };
- float* Keys = (float*)&Extents.x;
- for(udword j=0;j<3;j++)
- {
- for(udword i=0;i<2;i++)
- {
- if(Keys[SortedAxis[i]]<Keys[SortedAxis[i+1]])
- {
- udword Tmp = SortedAxis[i];
- SortedAxis[i] = SortedAxis[i+1];
- SortedAxis[i+1] = Tmp;
- }
- }
- }
-
- // Find the largest axis to split along
- udword CurAxis = 0;
- ValidSplit = false;
- while(!ValidSplit && CurAxis!=3)
- {
- NbPos = Split(SortedAxis[CurAxis], builder);
- // Check the subdivision has been successful
- if(!NbPos || NbPos==mNbPrimitives) CurAxis++;
- else ValidSplit = true;
- }
- }
- else if(builder->mSettings.mRules & SPLIT_FIFTY)
- {
- // Don't even bother splitting (mainly a performance test)
- NbPos = mNbPrimitives>>1;
- }
- else return false; // Unknown splitting rules
-
- // Check the subdivision has been successful
- if(!ValidSplit)
- {
- // Here, all boxes lie in the same sub-space. Two strategies:
- // - if the tree *must* be complete, make an arbitrary 50-50 split
- // - else stop subdividing
-// if(builder->mSettings.mRules&SPLIT_COMPLETE)
- if(builder->mSettings.mLimit==1)
- {
- builder->IncreaseNbInvalidSplits();
- NbPos = mNbPrimitives>>1;
- }
- else return true;
- }
-
- // Now create children and assign their pointers.
- if(builder->mNodeBase)
- {
- // We use a pre-allocated linear pool for complete trees [Opcode 1.3]
- AABBTreeNode* Pool = (AABBTreeNode*)builder->mNodeBase;
- udword Count = builder->GetCount() - 1; // Count begins to 1...
- // Set last bit to tell it shouldn't be freed ### pretty ugly, find a better way. Maybe one bit in mNbPrimitives
- ASSERT(!(udword(&Pool[Count+0])&1));
- ASSERT(!(udword(&Pool[Count+1])&1));
- mPos = udword(&Pool[Count+0])|1;
-#ifndef OPC_NO_NEG_VANILLA_TREE
- mNeg = udword(&Pool[Count+1])|1;
-#endif
- }
- else
- {
- // Non-complete trees and/or Opcode 1.2 allocate nodes on-the-fly
-#ifndef OPC_NO_NEG_VANILLA_TREE
- mPos = (udword)new AABBTreeNode; CHECKALLOC(mPos);
- mNeg = (udword)new AABBTreeNode; CHECKALLOC(mNeg);
-#else
- AABBTreeNode* PosNeg = new AABBTreeNode[2];
- CHECKALLOC(PosNeg);
- mPos = (udword)PosNeg;
-#endif
- }
-
- // Update stats
- builder->IncreaseCount(2);
-
- // Assign children
- AABBTreeNode* Pos = (AABBTreeNode*)GetPos();
- AABBTreeNode* Neg = (AABBTreeNode*)GetNeg();
- Pos->mNodePrimitives = &mNodePrimitives[0];
- Pos->mNbPrimitives = NbPos;
- Neg->mNodePrimitives = &mNodePrimitives[NbPos];
- Neg->mNbPrimitives = mNbPrimitives - NbPos;
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive hierarchy building in a top-down fashion.
- * \param builder [in] the tree builder
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeNode::_BuildHierarchy(AABBTreeBuilder* builder)
-{
- // 1) Compute the global box for current node. The box is stored in mBV.
- builder->ComputeGlobalBox(mNodePrimitives, mNbPrimitives, mBV);
-
- // 2) Subdivide current node
- Subdivide(builder);
-
- // 3) Recurse
- AABBTreeNode* Pos = (AABBTreeNode*)GetPos();
- AABBTreeNode* Neg = (AABBTreeNode*)GetNeg();
- if(Pos) Pos->_BuildHierarchy(builder);
- if(Neg) Neg->_BuildHierarchy(builder);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the tree (top-down).
- * \param builder [in] the tree builder
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeNode::_Refit(AABBTreeBuilder* builder)
-{
- // 1) Recompute the new global box for current node
- builder->ComputeGlobalBox(mNodePrimitives, mNbPrimitives, mBV);
-
- // 2) Recurse
- AABBTreeNode* Pos = (AABBTreeNode*)GetPos();
- AABBTreeNode* Neg = (AABBTreeNode*)GetNeg();
- if(Pos) Pos->_Refit(builder);
- if(Neg) Neg->_Refit(builder);
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBTree::AABBTree() : mIndices(null), mTotalNbNodes(0), mPool(null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBTree::~AABBTree()
-{
- Release();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Releases the tree.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTree::Release()
-{
- DELETEARRAY(mPool);
- DELETEARRAY(mIndices);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds a generic AABB tree from a tree builder.
- * \param builder [in] the tree builder
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTree::Build(AABBTreeBuilder* builder)
-{
- // Checkings
- if(!builder || !builder->mNbPrimitives) return false;
-
- // Release previous tree
- Release();
-
- // Init stats
- builder->SetCount(1);
- builder->SetNbInvalidSplits(0);
-
- // Initialize indices. This list will be modified during build.
- mIndices = new udword[builder->mNbPrimitives];
- CHECKALLOC(mIndices);
- // Identity permutation
- for(udword i=0;i<builder->mNbPrimitives;i++) mIndices[i] = i;
-
- // Setup initial node. Here we have a complete permutation of the app's primitives.
- mNodePrimitives = mIndices;
- mNbPrimitives = builder->mNbPrimitives;
-
- // Use a linear array for complete trees (since we can predict the final number of nodes) [Opcode 1.3]
-// if(builder->mRules&SPLIT_COMPLETE)
- if(builder->mSettings.mLimit==1)
- {
- // Allocate a pool of nodes
- mPool = new AABBTreeNode[builder->mNbPrimitives*2 - 1];
-
- builder->mNodeBase = mPool; // ### ugly !
- }
-
- // Build the hierarchy
- _BuildHierarchy(builder);
-
- // Get back total number of nodes
- mTotalNbNodes = builder->GetCount();
-
- // For complete trees, check the correct number of nodes has been created [Opcode 1.3]
- if(mPool) ASSERT(mTotalNbNodes==builder->mNbPrimitives*2 - 1);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the depth of the tree.
- * A well-balanced tree should have a log(n) depth. A degenerate tree O(n) depth.
- * \return depth of the tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword AABBTree::ComputeDepth() const
-{
- return Walk(null, null); // Use the walking code without callback
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Walks the tree, calling the user back for each node.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword AABBTree::Walk(WalkingCallback callback, void* user_data) const
-{
- // Call it without callback to compute max depth
- udword MaxDepth = 0;
- udword CurrentDepth = 0;
-
- struct Local
- {
- static void _Walk(const AABBTreeNode* current_node, udword& max_depth, udword& current_depth, WalkingCallback callback, void* user_data)
- {
- // Checkings
- if(!current_node) return;
- // Entering a new node => increase depth
- current_depth++;
- // Keep track of max depth
- if(current_depth>max_depth) max_depth = current_depth;
-
- // Callback
- if(callback && !(callback)(current_node, current_depth, user_data)) return;
-
- // Recurse
- if(current_node->GetPos()) { _Walk(current_node->GetPos(), max_depth, current_depth, callback, user_data); current_depth--; }
- if(current_node->GetNeg()) { _Walk(current_node->GetNeg(), max_depth, current_depth, callback, user_data); current_depth--; }
- }
- };
- Local::_Walk(this, MaxDepth, CurrentDepth, callback, user_data);
- return MaxDepth;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the tree in a top-down way.
- * \param builder [in] the tree builder
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTree::Refit(AABBTreeBuilder* builder)
-{
- if(!builder) return false;
- _Refit(builder);
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the tree in a bottom-up way.
- * \param builder [in] the tree builder
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTree::Refit2(AABBTreeBuilder* builder)
-{
- // Checkings
- if(!builder) return false;
-
- ASSERT(mPool);
-
- // Bottom-up update
- IcePoint Min,Max;
- IcePoint Min_,Max_;
- udword Index = mTotalNbNodes;
- while(Index--)
- {
- AABBTreeNode& Current = mPool[Index];
-
- if(Current.IsLeaf())
- {
- builder->ComputeGlobalBox(Current.GetPrimitives(), Current.GetNbPrimitives(), *(AABB*)Current.GetAABB());
- }
- else
- {
- Current.GetPos()->GetAABB()->GetMin(Min);
- Current.GetPos()->GetAABB()->GetMax(Max);
-
- Current.GetNeg()->GetAABB()->GetMin(Min_);
- Current.GetNeg()->GetAABB()->GetMax(Max_);
-
- Min.Min(Min_);
- Max.Max(Max_);
-
- ((AABB*)Current.GetAABB())->SetMinMax(Min, Max);
- }
- }
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the number of bytes used by the tree.
- * \return number of bytes used
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword AABBTree::GetUsedBytes() const
-{
- udword TotalSize = mTotalNbNodes*GetNodeSize();
- if(mIndices) TotalSize+=mNbPrimitives*sizeof(udword);
- return TotalSize;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks the tree is a complete tree or not.
- * A complete tree is made of 2*N-1 nodes, where N is the number of primitives in the tree.
- * \return true for complete trees
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTree::IsComplete() const
-{
- return (GetNbNodes()==GetNbPrimitives()*2-1);
-}
diff --git a/Opcode/OpcodeLib/OPC_AABBTree.h b/Opcode/OpcodeLib/OPC_AABBTree.h deleted file mode 100644 index 377fbcb..0000000 --- a/Opcode/OpcodeLib/OPC_AABBTree.h +++ /dev/null @@ -1,137 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a versatile AABB tree.
- * \file OPC_AABBTree.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_AABBTREE_H__
-#define __OPC_AABBTREE_H__
-
-#ifdef OPC_NO_NEG_VANILLA_TREE
- //! TO BE DOCUMENTED
- #define IMPLEMENT_TREE(base_class, volume) \
- public: \
- /* Constructor / Destructor */ \
- base_class(); \
- ~base_class(); \
- /* Data access */ \
- inline_ const volume* Get##volume() const { return &mBV; } \
- /* Clear the last bit */ \
- inline_ const base_class* GetPos() const { return (const base_class*)(mPos&~1); } \
- inline_ const base_class* GetNeg() const { const base_class* P = GetPos(); return P ? P+1 : null;} \
- \
- /* We don't need to test both nodes since we can't have one without the other */ \
- inline_ bool IsLeaf() const { return !GetPos(); } \
- \
- /* Stats */ \
- inline_ udword GetNodeSize() const { return SIZEOFOBJECT; } \
- protected: \
- /* Tree-independent data */ \
- /* Following data always belong to the BV-tree, regardless of what the tree actually contains.*/ \
- /* Whatever happens we need the two children and the enclosing volume.*/ \
- volume mBV; /* Global bounding-volume enclosing all the node-related primitives */ \
- udword mPos; /* "Positive" & "Negative" children */
-#else
- //! TO BE DOCUMENTED
- #define IMPLEMENT_TREE(base_class, volume) \
- public: \
- /* Constructor / Destructor */ \
- base_class(); \
- ~base_class(); \
- /* Data access */ \
- inline_ const volume* Get##volume() const { return &mBV; } \
- /* Clear the last bit */ \
- inline_ const base_class* GetPos() const { return (const base_class*)(mPos&~1); } \
- inline_ const base_class* GetNeg() const { return (const base_class*)(mNeg&~1); } \
- \
-/* inline_ bool IsLeaf() const { return (!GetPos() && !GetNeg()); } */ \
- /* We don't need to test both nodes since we can't have one without the other */ \
- inline_ bool IsLeaf() const { return !GetPos(); } \
- \
- /* Stats */ \
- inline_ udword GetNodeSize() const { return SIZEOFOBJECT; } \
- protected: \
- /* Tree-independent data */ \
- /* Following data always belong to the BV-tree, regardless of what the tree actually contains.*/ \
- /* Whatever happens we need the two children and the enclosing volume.*/ \
- volume mBV; /* Global bounding-volume enclosing all the node-related primitives */ \
- udword mPos; /* "Positive" child */ \
- udword mNeg; /* "Negative" child */
-#endif
-
- typedef void (*CullingCallback) (udword nb_primitives, udword* node_primitives, BOOL need_clipping, void* user_data);
-
- class OPCODE_API AABBTreeNode
- {
- IMPLEMENT_TREE(AABBTreeNode, AABB)
- public:
- // Data access
- inline_ const udword* GetPrimitives() const { return mNodePrimitives; }
- inline_ udword GetNbPrimitives() const { return mNbPrimitives; }
-
- protected:
- // Tree-dependent data
- udword* mNodePrimitives; //!< Node-related primitives (shortcut to a position in mIndices below)
- udword mNbPrimitives; //!< Number of primitives for this node
- // Internal methods
- udword Split(udword axis, AABBTreeBuilder* builder);
- bool Subdivide(AABBTreeBuilder* builder);
- void _BuildHierarchy(AABBTreeBuilder* builder);
- void _Refit(AABBTreeBuilder* builder);
- };
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * User-callback, called for each node by the walking code.
- * \param current [in] current node
- * \param depth [in] current node's depth
- * \param user_data [in] user-defined data
- * \return true to recurse through children, else false to bypass them
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- typedef bool (*WalkingCallback) (const AABBTreeNode* current, udword depth, void* user_data);
-
- class OPCODE_API AABBTree : public AABBTreeNode
- {
- public:
- // Constructor / Destructor
- AABBTree();
- ~AABBTree();
- // Build
- bool Build(AABBTreeBuilder* builder);
- void Release();
-
- // Data access
- inline_ const udword* GetIndices() const { return mIndices; } //!< Catch the indices
- inline_ udword GetNbNodes() const { return mTotalNbNodes; } //!< Catch the number of nodes
-
- // Infos
- bool IsComplete() const;
- // Stats
- udword ComputeDepth() const;
- udword GetUsedBytes() const;
- udword Walk(WalkingCallback callback, void* user_data) const;
-
- bool Refit(AABBTreeBuilder* builder);
- bool Refit2(AABBTreeBuilder* builder);
- private:
- udword* mIndices; //!< Indices in the app list. Indices are reorganized during build (permutation).
- AABBTreeNode* mPool; //!< Linear pool of nodes for complete trees. Null otherwise. [Opcode 1.3]
- // Stats
- udword mTotalNbNodes; //!< Number of nodes in the tree.
- };
-
-#endif // __OPC_AABBTREE_H__
diff --git a/Opcode/OpcodeLib/OPC_BaseModel.cpp b/Opcode/OpcodeLib/OPC_BaseModel.cpp deleted file mode 100644 index 4e15809..0000000 --- a/Opcode/OpcodeLib/OPC_BaseModel.cpp +++ /dev/null @@ -1,138 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains base model interface.
- * \file OPC_BaseModel.cpp
- * \author Pierre Terdiman
- * \date May, 18, 2003
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * The base class for collision models.
- *
- * \class BaseModel
- * \author Pierre Terdiman
- * \version 1.3
- * \date May, 18, 2003
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-OPCODECREATE::OPCODECREATE()
-{
- mIMesh = null;
- mSettings.mRules = SPLIT_SPLATTER_POINTS | SPLIT_GEOM_CENTER;
- mSettings.mLimit = 1; // Mandatory for complete trees
- mNoLeaf = true;
- mQuantized = true;
-#ifdef __MESHMERIZER_H__
- mCollisionHull = false;
-#endif // __MESHMERIZER_H__
- mKeepOriginal = false;
- mCanRemap = false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BaseModel::BaseModel() : mIMesh(null), mModelCode(0), mSource(null), mTree(null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BaseModel::~BaseModel()
-{
- ReleaseBase();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Releases everything.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void BaseModel::ReleaseBase()
-{
- DELETESINGLE(mSource);
- DELETESINGLE(mTree);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Creates an optimized tree according to user-settings, and setups mModelCode.
- * \param no_leaf [in] true for "no leaf" tree
- * \param quantized [in] true for quantized tree
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool BaseModel::CreateTree(bool no_leaf, bool quantized)
-{
- DELETESINGLE(mTree);
-
- // Setup model code
- if(no_leaf) mModelCode |= OPC_NO_LEAF;
- else mModelCode &= ~OPC_NO_LEAF;
-
- if(quantized) mModelCode |= OPC_QUANTIZED;
- else mModelCode &= ~OPC_QUANTIZED;
-
- // Create the correct class
- if(mModelCode & OPC_NO_LEAF)
- {
- if(mModelCode & OPC_QUANTIZED) mTree = new AABBQuantizedNoLeafTree;
- else mTree = new AABBNoLeafTree;
- }
- else
- {
- if(mModelCode & OPC_QUANTIZED) mTree = new AABBQuantizedTree;
- else mTree = new AABBCollisionTree;
- }
- CHECKALLOC(mTree);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the collision model. This can be used to handle dynamic meshes. Usage is:
- * 1. modify your mesh vertices (keep the topology constant!)
- * 2. refit the tree (call this method)
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool BaseModel::Refit()
-{
- // Refit the optimized tree
- return mTree->Refit(mIMesh);
-
-// Old code kept for reference : refit the source tree then rebuild !
-// if(!mSource) return false;
-// // Ouch...
-// mSource->Refit(&mTB);
-// // Ouch...
-// return mTree->Build(mSource);
-}
diff --git a/Opcode/OpcodeLib/OPC_BaseModel.h b/Opcode/OpcodeLib/OPC_BaseModel.h deleted file mode 100644 index 15fc423..0000000 --- a/Opcode/OpcodeLib/OPC_BaseModel.h +++ /dev/null @@ -1,175 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains base model interface.
- * \file OPC_BaseModel.h
- * \author Pierre Terdiman
- * \date May, 18, 2003
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_BASEMODEL_H__
-#define __OPC_BASEMODEL_H__
-
- //! Model creation structure
- struct OPCODE_API OPCODECREATE
- {
- //! Constructor
- OPCODECREATE();
-
- MeshInterface* mIMesh; //!< Mesh interface (access to triangles & vertices) (*)
- BuildSettings mSettings; //!< Builder's settings
- bool mNoLeaf; //!< true => discard leaf nodes (else use a normal tree)
- bool mQuantized; //!< true => quantize the tree (else use a normal tree)
-#ifdef __MESHMERIZER_H__
- bool mCollisionHull; //!< true => use convex hull + GJK
-#endif // __MESHMERIZER_H__
- bool mKeepOriginal; //!< true => keep a copy of the original tree (debug purpose)
- bool mCanRemap; //!< true => allows OPCODE to reorganize client arrays
-
- // (*) This pointer is saved internally and used by OPCODE until collision structures are released,
- // so beware of the object's lifetime.
- };
-
- enum ModelFlag
- {
- OPC_QUANTIZED = (1<<0), //!< Compressed/uncompressed tree
- OPC_NO_LEAF = (1<<1), //!< Leaf/NoLeaf tree
- OPC_SINGLE_NODE = (1<<2) //!< Special case for 1-node models
- };
-
- class OPCODE_API BaseModel
- {
- public:
- // Constructor/Destructor
- BaseModel();
- virtual ~BaseModel();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Builds a collision model.
- * \param create [in] model creation structure
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual bool Build(const OPCODECREATE& create) = 0;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the number of bytes used by the tree.
- * \return amount of bytes used
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual udword GetUsedBytes() const = 0;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Refits the collision model. This can be used to handle dynamic meshes. Usage is:
- * 1. modify your mesh vertices (keep the topology constant!)
- * 2. refit the tree (call this method)
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual bool Refit();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the source tree.
- * \return generic tree
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const AABBTree* GetSourceTree() const { return mSource; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the tree.
- * \return the collision tree
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const AABBOptimizedTree* GetTree() const { return mTree; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the tree.
- * \return the collision tree
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ AABBOptimizedTree* GetTree() { return mTree; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the number of nodes in the tree.
- * Should be 2*N-1 for normal trees and N-1 for optimized ones.
- * \return number of nodes
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbNodes() const { return mTree->GetNbNodes(); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks whether the tree has leaf nodes or not.
- * \return true if the tree has leaf nodes (normal tree), else false (optimized tree)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL HasLeafNodes() const { return !(mModelCode & OPC_NO_LEAF); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks whether the tree is quantized or not.
- * \return true if the tree is quantized
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL IsQuantized() const { return mModelCode & OPC_QUANTIZED; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks whether the model has a single node or not. This special case must be handled separately.
- * \return true if the model has only 1 node
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL HasSingleNode() const { return mModelCode & OPC_SINGLE_NODE; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the model's code.
- * \return model's code
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetModelCode() const { return mModelCode; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the mesh interface.
- * \return mesh interface
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const MeshInterface* GetMeshInterface() const { return mIMesh; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Sets the mesh interface.
- * \param imesh [in] mesh interface
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetMeshInterface(const MeshInterface* imesh) { mIMesh = imesh; }
-
- protected:
- const MeshInterface* mIMesh; //!< User-defined mesh interface
- udword mModelCode; //!< Model code = combination of ModelFlag(s)
- AABBTree* mSource; //!< Original source tree
- AABBOptimizedTree* mTree; //!< Optimized tree owned by the model
- // Internal methods
- void ReleaseBase();
- bool CreateTree(bool no_leaf, bool quantized);
- };
-
-#endif //__OPC_BASEMODEL_H__
\ No newline at end of file diff --git a/Opcode/OpcodeLib/OPC_BoxBoxOverlap.h b/Opcode/OpcodeLib/OPC_BoxBoxOverlap.h deleted file mode 100644 index fd39dbb..0000000 --- a/Opcode/OpcodeLib/OPC_BoxBoxOverlap.h +++ /dev/null @@ -1,122 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * OBB-OBB overlap test using the separating axis theorem.
- * - original code by Gomez / Gamasutra (similar to Gottschalk's one in RAPID)
- * - optimized for AABB trees by computing the rotation matrix once (SOLID-fashion)
- * - the fabs matrix is precomputed as well and epsilon-tweaked (RAPID-style, we found this almost mandatory)
- * - Class III axes can be disabled... (SOLID & Intel fashion)
- * - ...or enabled to perform some profiling
- * - CPU comparisons used when appropriate
- * - lazy evaluation sometimes saves some work in case of early exits (unlike SOLID)
- *
- * \param ea [in] extents from box A
- * \param ca [in] center from box A
- * \param eb [in] extents from box B
- * \param cb [in] center from box B
- * \return true if boxes overlap
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL AABBTreeCollider::BoxBoxOverlap(const IcePoint& ea, const IcePoint& ca, const IcePoint& eb, const IcePoint& cb)
-{
- // Stats
- mNbBVBVTests++;
-
- float t,t2;
-
- // Class I : A's basis vectors
- float Tx = (mR1to0.m[0][0]*cb.x + mR1to0.m[1][0]*cb.y + mR1to0.m[2][0]*cb.z) + mT1to0.x - ca.x;
- t = ea.x + eb.x*mAR.m[0][0] + eb.y*mAR.m[1][0] + eb.z*mAR.m[2][0];
- if(GREATER(Tx, t)) return FALSE;
-
- float Ty = (mR1to0.m[0][1]*cb.x + mR1to0.m[1][1]*cb.y + mR1to0.m[2][1]*cb.z) + mT1to0.y - ca.y;
- t = ea.y + eb.x*mAR.m[0][1] + eb.y*mAR.m[1][1] + eb.z*mAR.m[2][1];
- if(GREATER(Ty, t)) return FALSE;
-
- float Tz = (mR1to0.m[0][2]*cb.x + mR1to0.m[1][2]*cb.y + mR1to0.m[2][2]*cb.z) + mT1to0.z - ca.z;
- t = ea.z + eb.x*mAR.m[0][2] + eb.y*mAR.m[1][2] + eb.z*mAR.m[2][2];
- if(GREATER(Tz, t)) return FALSE;
-
- // Class II : B's basis vectors
- t = Tx*mR1to0.m[0][0] + Ty*mR1to0.m[0][1] + Tz*mR1to0.m[0][2]; t2 = ea.x*mAR.m[0][0] + ea.y*mAR.m[0][1] + ea.z*mAR.m[0][2] + eb.x;
- if(GREATER(t, t2)) return FALSE;
-
- t = Tx*mR1to0.m[1][0] + Ty*mR1to0.m[1][1] + Tz*mR1to0.m[1][2]; t2 = ea.x*mAR.m[1][0] + ea.y*mAR.m[1][1] + ea.z*mAR.m[1][2] + eb.y;
- if(GREATER(t, t2)) return FALSE;
-
- t = Tx*mR1to0.m[2][0] + Ty*mR1to0.m[2][1] + Tz*mR1to0.m[2][2]; t2 = ea.x*mAR.m[2][0] + ea.y*mAR.m[2][1] + ea.z*mAR.m[2][2] + eb.z;
- if(GREATER(t, t2)) return FALSE;
-
- // Class III : 9 cross products
- // Cool trick: always perform the full test for first level, regardless of settings.
- // That way pathological cases (such as the pencils scene) are quickly rejected anyway !
- if(mFullBoxBoxTest || mNbBVBVTests==1)
- {
- t = Tz*mR1to0.m[0][1] - Ty*mR1to0.m[0][2]; t2 = ea.y*mAR.m[0][2] + ea.z*mAR.m[0][1] + eb.y*mAR.m[2][0] + eb.z*mAR.m[1][0]; if(GREATER(t, t2)) return FALSE; // L = A0 x B0
- t = Tz*mR1to0.m[1][1] - Ty*mR1to0.m[1][2]; t2 = ea.y*mAR.m[1][2] + ea.z*mAR.m[1][1] + eb.x*mAR.m[2][0] + eb.z*mAR.m[0][0]; if(GREATER(t, t2)) return FALSE; // L = A0 x B1
- t = Tz*mR1to0.m[2][1] - Ty*mR1to0.m[2][2]; t2 = ea.y*mAR.m[2][2] + ea.z*mAR.m[2][1] + eb.x*mAR.m[1][0] + eb.y*mAR.m[0][0]; if(GREATER(t, t2)) return FALSE; // L = A0 x B2
- t = Tx*mR1to0.m[0][2] - Tz*mR1to0.m[0][0]; t2 = ea.x*mAR.m[0][2] + ea.z*mAR.m[0][0] + eb.y*mAR.m[2][1] + eb.z*mAR.m[1][1]; if(GREATER(t, t2)) return FALSE; // L = A1 x B0
- t = Tx*mR1to0.m[1][2] - Tz*mR1to0.m[1][0]; t2 = ea.x*mAR.m[1][2] + ea.z*mAR.m[1][0] + eb.x*mAR.m[2][1] + eb.z*mAR.m[0][1]; if(GREATER(t, t2)) return FALSE; // L = A1 x B1
- t = Tx*mR1to0.m[2][2] - Tz*mR1to0.m[2][0]; t2 = ea.x*mAR.m[2][2] + ea.z*mAR.m[2][0] + eb.x*mAR.m[1][1] + eb.y*mAR.m[0][1]; if(GREATER(t, t2)) return FALSE; // L = A1 x B2
- t = Ty*mR1to0.m[0][0] - Tx*mR1to0.m[0][1]; t2 = ea.x*mAR.m[0][1] + ea.y*mAR.m[0][0] + eb.y*mAR.m[2][2] + eb.z*mAR.m[1][2]; if(GREATER(t, t2)) return FALSE; // L = A2 x B0
- t = Ty*mR1to0.m[1][0] - Tx*mR1to0.m[1][1]; t2 = ea.x*mAR.m[1][1] + ea.y*mAR.m[1][0] + eb.x*mAR.m[2][2] + eb.z*mAR.m[0][2]; if(GREATER(t, t2)) return FALSE; // L = A2 x B1
- t = Ty*mR1to0.m[2][0] - Tx*mR1to0.m[2][1]; t2 = ea.x*mAR.m[2][1] + ea.y*mAR.m[2][0] + eb.x*mAR.m[1][2] + eb.y*mAR.m[0][2]; if(GREATER(t, t2)) return FALSE; // L = A2 x B2
- }
- return TRUE;
-}
-
-//! A dedicated version when one box is constant
-inline_ BOOL OBBCollider::BoxBoxOverlap(const IcePoint& extents, const IcePoint& center)
-{
- // Stats
- mNbVolumeBVTests++;
-
- float t,t2;
-
- // Class I : A's basis vectors
- float Tx = mTBoxToModel.x - center.x; t = extents.x + mBBx1; if(GREATER(Tx, t)) return FALSE;
- float Ty = mTBoxToModel.y - center.y; t = extents.y + mBBy1; if(GREATER(Ty, t)) return FALSE;
- float Tz = mTBoxToModel.z - center.z; t = extents.z + mBBz1; if(GREATER(Tz, t)) return FALSE;
-
- // Class II : B's basis vectors
- t = Tx*mRBoxToModel.m[0][0] + Ty*mRBoxToModel.m[0][1] + Tz*mRBoxToModel.m[0][2];
- t2 = extents.x*mAR.m[0][0] + extents.y*mAR.m[0][1] + extents.z*mAR.m[0][2] + mBoxExtents.x;
- if(GREATER(t, t2)) return FALSE;
-
- t = Tx*mRBoxToModel.m[1][0] + Ty*mRBoxToModel.m[1][1] + Tz*mRBoxToModel.m[1][2];
- t2 = extents.x*mAR.m[1][0] + extents.y*mAR.m[1][1] + extents.z*mAR.m[1][2] + mBoxExtents.y;
- if(GREATER(t, t2)) return FALSE;
-
- t = Tx*mRBoxToModel.m[2][0] + Ty*mRBoxToModel.m[2][1] + Tz*mRBoxToModel.m[2][2];
- t2 = extents.x*mAR.m[2][0] + extents.y*mAR.m[2][1] + extents.z*mAR.m[2][2] + mBoxExtents.z;
- if(GREATER(t, t2)) return FALSE;
-
- // Class III : 9 cross products
- // Cool trick: always perform the full test for first level, regardless of settings.
- // That way pathological cases (such as the pencils scene) are quickly rejected anyway !
- if(mFullBoxBoxTest || mNbVolumeBVTests==1)
- {
- t = Tz*mRBoxToModel.m[0][1] - Ty*mRBoxToModel.m[0][2]; t2 = extents.y*mAR.m[0][2] + extents.z*mAR.m[0][1] + mBB_1; if(GREATER(t, t2)) return FALSE; // L = A0 x B0
- t = Tz*mRBoxToModel.m[1][1] - Ty*mRBoxToModel.m[1][2]; t2 = extents.y*mAR.m[1][2] + extents.z*mAR.m[1][1] + mBB_2; if(GREATER(t, t2)) return FALSE; // L = A0 x B1
- t = Tz*mRBoxToModel.m[2][1] - Ty*mRBoxToModel.m[2][2]; t2 = extents.y*mAR.m[2][2] + extents.z*mAR.m[2][1] + mBB_3; if(GREATER(t, t2)) return FALSE; // L = A0 x B2
- t = Tx*mRBoxToModel.m[0][2] - Tz*mRBoxToModel.m[0][0]; t2 = extents.x*mAR.m[0][2] + extents.z*mAR.m[0][0] + mBB_4; if(GREATER(t, t2)) return FALSE; // L = A1 x B0
- t = Tx*mRBoxToModel.m[1][2] - Tz*mRBoxToModel.m[1][0]; t2 = extents.x*mAR.m[1][2] + extents.z*mAR.m[1][0] + mBB_5; if(GREATER(t, t2)) return FALSE; // L = A1 x B1
- t = Tx*mRBoxToModel.m[2][2] - Tz*mRBoxToModel.m[2][0]; t2 = extents.x*mAR.m[2][2] + extents.z*mAR.m[2][0] + mBB_6; if(GREATER(t, t2)) return FALSE; // L = A1 x B2
- t = Ty*mRBoxToModel.m[0][0] - Tx*mRBoxToModel.m[0][1]; t2 = extents.x*mAR.m[0][1] + extents.y*mAR.m[0][0] + mBB_7; if(GREATER(t, t2)) return FALSE; // L = A2 x B0
- t = Ty*mRBoxToModel.m[1][0] - Tx*mRBoxToModel.m[1][1]; t2 = extents.x*mAR.m[1][1] + extents.y*mAR.m[1][0] + mBB_8; if(GREATER(t, t2)) return FALSE; // L = A2 x B1
- t = Ty*mRBoxToModel.m[2][0] - Tx*mRBoxToModel.m[2][1]; t2 = extents.x*mAR.m[2][1] + extents.y*mAR.m[2][0] + mBB_9; if(GREATER(t, t2)) return FALSE; // L = A2 x B2
- }
- return TRUE;
-}
-
-//! A special version for 2 axis-aligned boxes
-inline_ BOOL AABBCollider::AABBAABBOverlap(const IcePoint& extents, const IcePoint& center)
-{
- // Stats
- mNbVolumeBVTests++;
-
- float tx = mBox.mCenter.x - center.x; float ex = extents.x + mBox.mExtents.x; if(GREATER(tx, ex)) return FALSE;
- float ty = mBox.mCenter.y - center.y; float ey = extents.y + mBox.mExtents.y; if(GREATER(ty, ey)) return FALSE;
- float tz = mBox.mCenter.z - center.z; float ez = extents.z + mBox.mExtents.z; if(GREATER(tz, ez)) return FALSE;
-
- return TRUE;
-}
diff --git a/Opcode/OpcodeLib/OPC_Collider.cpp b/Opcode/OpcodeLib/OPC_Collider.cpp deleted file mode 100644 index bb9663d..0000000 --- a/Opcode/OpcodeLib/OPC_Collider.cpp +++ /dev/null @@ -1,54 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains base collider class.
- * \file OPC_Collider.cpp
- * \author Pierre Terdiman
- * \date June, 2, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains the abstract class for colliders.
- *
- * \class Collider
- * \author Pierre Terdiman
- * \version 1.3
- * \date June, 2, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Collider::Collider() :
- mFlags (0),
- mCurrentModel (null),
- mIMesh (null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Collider::~Collider()
-{
-}
diff --git a/Opcode/OpcodeLib/OPC_Collider.h b/Opcode/OpcodeLib/OPC_Collider.h deleted file mode 100644 index 4495093..0000000 --- a/Opcode/OpcodeLib/OPC_Collider.h +++ /dev/null @@ -1,176 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains base collider class.
- * \file OPC_Collider.h
- * \author Pierre Terdiman
- * \date June, 2, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_COLLIDER_H__
-#define __OPC_COLLIDER_H__
-
- enum CollisionFlag
- {
- OPC_FIRST_CONTACT = (1<<0), //!< Report all contacts (false) or only first one (true)
- OPC_TEMPORAL_COHERENCE = (1<<1), //!< Use temporal coherence or not
- OPC_CONTACT = (1<<2), //!< Final contact status after a collision query
- OPC_TEMPORAL_HIT = (1<<3), //!< There has been an early exit due to temporal coherence
- OPC_NO_PRIMITIVE_TESTS = (1<<4), //!< Keep or discard primitive-bv tests in leaf nodes (volume-mesh queries)
-
- OPC_CONTACT_FOUND = OPC_FIRST_CONTACT | OPC_CONTACT,
- OPC_TEMPORAL_CONTACT = OPC_TEMPORAL_HIT | OPC_CONTACT,
-
- OPC_FORCE_DWORD = 0x7fffffff
- };
-
- class OPCODE_API Collider
- {
- public:
- // Constructor / Destructor
- Collider();
- virtual ~Collider();
-
- // Collision report
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the last collision status after a collision query.
- * \return true if a collision occured
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL GetContactStatus() const { return mFlags & OPC_CONTACT; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the "first contact" mode.
- * \return true if "first contact" mode is on
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL FirstContactEnabled() const { return mFlags & OPC_FIRST_CONTACT; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the temporal coherence mode.
- * \return true if temporal coherence is on
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL TemporalCoherenceEnabled() const { return mFlags & OPC_TEMPORAL_COHERENCE; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks a first contact has already been found.
- * \return true if a first contact has been found and we can stop a query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL ContactFound() const { return (mFlags&OPC_CONTACT_FOUND)==OPC_CONTACT_FOUND; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks there's been an early exit due to temporal coherence;
- * \return true if a temporal hit has occured
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL TemporalHit() const { return mFlags & OPC_TEMPORAL_HIT; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks primitive tests are enabled;
- * \return true if primitive tests must be skipped
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL SkipPrimitiveTests() const { return mFlags & OPC_NO_PRIMITIVE_TESTS; }
-
- // Settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Reports all contacts (false) or first contact only (true)
- * \param flag [in] true for first contact, false for all contacts
- * \see SetTemporalCoherence(bool flag)
- * \see ValidateSettings()
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetFirstContact(bool flag)
- {
- if(flag) mFlags |= OPC_FIRST_CONTACT;
- else mFlags &= ~OPC_FIRST_CONTACT;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Enable/disable temporal coherence.
- * \param flag [in] true to enable temporal coherence, false to discard it
- * \see SetFirstContact(bool flag)
- * \see ValidateSettings()
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetTemporalCoherence(bool flag)
- {
- if(flag) mFlags |= OPC_TEMPORAL_COHERENCE;
- else mFlags &= ~OPC_TEMPORAL_COHERENCE;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Enable/disable primitive tests.
- * \param flag [in] true to enable primitive tests, false to discard them
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetPrimitiveTests(bool flag)
- {
- if(!flag) mFlags |= OPC_NO_PRIMITIVE_TESTS;
- else mFlags &= ~OPC_NO_PRIMITIVE_TESTS;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Validates current settings. You should call this method after all the settings / callbacks have been defined for a collider.
- * \return null if everything is ok, else a string describing the problem
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual const char* ValidateSettings() = 0;
-
- protected:
- udword mFlags; //!< Bit flags
- const BaseModel* mCurrentModel; //!< Current model for collision query (owner of touched faces)
- // User mesh interface
- const MeshInterface* mIMesh; //!< User-defined mesh interface
-
- // Internal methods
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups current collision model
- * \param model [in] current collision model
- * \return TRUE if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL Setup(const BaseModel* model)
- {
- // Keep track of current model
- mCurrentModel = model;
- if(!mCurrentModel) return FALSE;
-
- mIMesh = model->GetMeshInterface();
- return mIMesh!=null;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Initializes a query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual inline_ void InitQuery() { mFlags &= ~OPC_TEMPORAL_CONTACT; }
- };
-
-#endif // __OPC_COLLIDER_H__
diff --git a/Opcode/OpcodeLib/OPC_Common.cpp b/Opcode/OpcodeLib/OPC_Common.cpp deleted file mode 100644 index 839186b..0000000 --- a/Opcode/OpcodeLib/OPC_Common.cpp +++ /dev/null @@ -1,48 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains common classes & defs used in OPCODE.
- * \file OPC_Common.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * An AABB dedicated to collision detection.
- * We don't use the generic AABB class included in ICE, since it can be a Min/Max or a Center/Extents one (depends
- * on compilation flags). Since the Center/Extents model is more efficient in collision detection, it was worth
- * using an extra special class.
- *
- * \class CollisionAABB
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A quantized AABB.
- * Center/Extent model, using 16-bits integers.
- *
- * \class QuantizedAABB
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
diff --git a/Opcode/OpcodeLib/OPC_Common.h b/Opcode/OpcodeLib/OPC_Common.h deleted file mode 100644 index 3c39ea3..0000000 --- a/Opcode/OpcodeLib/OPC_Common.h +++ /dev/null @@ -1,101 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains common classes & defs used in OPCODE.
- * \file OPC_Common.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_COMMON_H__
-#define __OPC_COMMON_H__
-
-// [GOTTFRIED]: Just a small change for readability.
-#ifdef OPC_CPU_COMPARE
- #define GREATER(x, y) AIR(x) > IR(y)
-#else
- #define GREATER(x, y) fabsf(x) > (y)
-#endif
-
- class OPCODE_API CollisionAABB
- {
- public:
- //! Constructor
- inline_ CollisionAABB() {}
- //! Constructor
- inline_ CollisionAABB(const AABB& b) { b.GetCenter(mCenter); b.GetExtents(mExtents); }
- //! Destructor
- inline_ ~CollisionAABB() {}
-
- //! Get min point of the box
- inline_ void GetMin(IcePoint& min) const { min = mCenter - mExtents; }
- //! Get max point of the box
- inline_ void GetMax(IcePoint& max) const { max = mCenter + mExtents; }
-
- //! Get component of the box's min point along a given axis
- inline_ float GetMin(udword axis) const { return mCenter[axis] - mExtents[axis]; }
- //! Get component of the box's max point along a given axis
- inline_ float GetMax(udword axis) const { return mCenter[axis] + mExtents[axis]; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Setups an AABB from min & max vectors.
- * \param min [in] the min point
- * \param max [in] the max point
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetMinMax(const IcePoint& min, const IcePoint& max) { mCenter = (max + min)*0.5f; mExtents = (max - min)*0.5f; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks a box is inside another box.
- * \param box [in] the other box
- * \return true if current box is inside input box
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ BOOL IsInside(const CollisionAABB& box) const
- {
- if(box.GetMin(0)>GetMin(0)) return FALSE;
- if(box.GetMin(1)>GetMin(1)) return FALSE;
- if(box.GetMin(2)>GetMin(2)) return FALSE;
- if(box.GetMax(0)<GetMax(0)) return FALSE;
- if(box.GetMax(1)<GetMax(1)) return FALSE;
- if(box.GetMax(2)<GetMax(2)) return FALSE;
- return TRUE;
- }
-
- IcePoint mCenter; //!< Box center
- IcePoint mExtents; //!< Box extents
- };
-
- class OPCODE_API QuantizedAABB
- {
- public:
- //! Constructor
- inline_ QuantizedAABB() {}
- //! Destructor
- inline_ ~QuantizedAABB() {}
-
- sword mCenter[3]; //!< Quantized center
- uword mExtents[3]; //!< Quantized extents
- };
-
- //! Quickly rotates & translates a vector
- inline_ void TransformPoint(IcePoint& dest, const IcePoint& source, const Matrix3x3& rot, const IcePoint& trans)
- {
- dest.x = trans.x + source.x * rot.m[0][0] + source.y * rot.m[1][0] + source.z * rot.m[2][0];
- dest.y = trans.y + source.x * rot.m[0][1] + source.y * rot.m[1][1] + source.z * rot.m[2][1];
- dest.z = trans.z + source.x * rot.m[0][2] + source.y * rot.m[1][2] + source.z * rot.m[2][2];
- }
-
-#endif //__OPC_COMMON_H__
\ No newline at end of file diff --git a/Opcode/OpcodeLib/OPC_HybridModel.cpp b/Opcode/OpcodeLib/OPC_HybridModel.cpp deleted file mode 100644 index 0793e5e..0000000 --- a/Opcode/OpcodeLib/OPC_HybridModel.cpp +++ /dev/null @@ -1,466 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for hybrid models.
- * \file OPC_HybridModel.cpp
- * \author Pierre Terdiman
- * \date May, 18, 2003
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * An hybrid collision model.
- *
- * The problem :
- *
- * Opcode really shines for mesh-mesh collision, especially when meshes are deeply overlapping
- * (it typically outperforms RAPID in those cases).
- *
- * Unfortunately this is not the typical scenario in games.
- *
- * For close-proximity cases, especially for volume-mesh queries, it's relatively easy to run faster
- * than Opcode, that suffers from a relatively high setup time.
- *
- * In particular, Opcode's "vanilla" trees in those cases -can- run faster. They can also use -less-
- * memory than the optimized ones, when you let the system stop at ~10 triangles / leaf for example
- * (i.e. when you don't use "complete" trees). However, those trees tend to fragment memory quite a
- * lot, increasing cache misses : since they're not "complete", we can't predict the final number of
- * nodes and we have to allocate nodes on-the-fly. For the same reasons we can't use Opcode's "optimized"
- * trees here, since they rely on a known layout to perform the "optimization".
- *
- * Hybrid trees :
- *
- * Hybrid trees try to combine best of both worlds :
- *
- * - they use a maximum limit of 16 triangles/leaf. "16" is used so that we'll be able to save the
- * number of triangles using 4 bits only.
- *
- * - they're still "complete" trees thanks to a two-passes building phase. First we create a "vanilla"
- * AABB-tree with Opcode, limited to 16 triangles/leaf. Then we create a *second* vanilla tree, this
- * time using the leaves of the first one. The trick is : this second tree is now "complete"... so we
- * can further transform it into an Opcode's optimized tree.
- *
- * - then we run the collision queries on that standard Opcode tree. The only difference is that leaf
- * nodes contain indices to leaf nodes of another tree. Also, we have to skip all primitive tests in
- * Opcode optimized trees, since our leaves don't contain triangles anymore.
- *
- * - finally, for each collided leaf, we simply loop through 16 triangles max, and collide them with
- * the bounding volume used in the query (we only support volume-vs-mesh queries here, not mesh-vs-mesh)
- *
- * All of that is wrapped in this "hybrid model" that contains the minimal data required for this to work.
- * It's a mix between old "vanilla" trees, and old "optimized" trees.
- *
- * Extra advantages:
- *
- * - If we use them for dynamic models, we're left with a very small number of leaf nodes to refit. It
- * might be a bit faster since we have less nodes to write back.
- *
- * - In rigid body simulation, using temporal coherence and sleeping objects greatly reduce the actual
- * influence of one tree over another (i.e. the speed difference is often invisible). So memory is really
- * the key element to consider, and in this regard hybrid trees are just better.
- *
- * Information to take home:
- * - they use less ram
- * - they're not slower (they're faster or slower depending on cases, overall there's no significant
- * difference *as long as objects don't interpenetrate too much* - in which case Opcode's optimized trees
- * are still notably faster)
- *
- * \class HybridModel
- * \author Pierre Terdiman
- * \version 1.3
- * \date May, 18, 2003
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HybridModel::HybridModel() :
- mNbLeaves (0),
- mNbPrimitives (0),
- mTriangles (null),
- mIndices (null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HybridModel::~HybridModel()
-{
- Release();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Releases everything.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void HybridModel::Release()
-{
- ReleaseBase();
- DELETEARRAY(mIndices);
- DELETEARRAY(mTriangles);
- mNbLeaves = 0;
- mNbPrimitives = 0;
-}
-
- struct Internal
- {
- Internal()
- {
- mNbLeaves = 0;
- mLeaves = null;
- mTriangles = null;
- mBase = null;
- }
- ~Internal()
- {
- DELETEARRAY(mLeaves);
- }
-
- udword mNbLeaves;
- AABB* mLeaves;
- LeafTriangles* mTriangles;
- const udword* mBase;
- };
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds a collision model.
- * \param create [in] model creation structure
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool HybridModel::Build(const OPCODECREATE& create)
-{
- // 1) Checkings
- if(!create.mIMesh || !create.mIMesh->IsValid()) return false;
-
- // Look for degenerate faces.
- udword NbDegenerate = create.mIMesh->CheckTopology();
- if(NbDegenerate) Log("OPCODE WARNING: found %d degenerate faces in model! Collision might report wrong results!\n", NbDegenerate);
- // We continue nonetheless....
-
- Release(); // Make sure previous tree has been discarded
-
- // 1-1) Setup mesh interface automatically
- SetMeshInterface(create.mIMesh);
-
- bool Status = false;
- AABBTree* LeafTree = null;
- Internal Data;
-
- // 2) Build a generic AABB Tree.
- mSource = new AABBTree;
- CHECKALLOC(mSource);
-
- // 2-1) Setup a builder. Our primitives here are triangles from input mesh,
- // so we use an AABBTreeOfTrianglesBuilder.....
- {
- AABBTreeOfTrianglesBuilder TB;
- TB.mIMesh = create.mIMesh;
- TB.mNbPrimitives = create.mIMesh->GetNbTriangles();
- TB.mSettings = create.mSettings;
- TB.mSettings.mLimit = 16; // ### Hardcoded, but maybe we could let the user choose 8 / 16 / 32 ...
- if(!mSource->Build(&TB)) goto FreeAndExit;
- }
-
- // 2-2) Here's the trick : create *another* AABB tree using the leaves of the first one (which are boxes, this time)
- struct Local
- {
- // A callback to count leaf nodes
- static bool CountLeaves(const AABBTreeNode* current, udword depth, void* user_data)
- {
- if(current->IsLeaf())
- {
- Internal* Data = (Internal*)user_data;
- Data->mNbLeaves++;
- }
- return true;
- }
-
- // A callback to setup leaf nodes in our internal structures
- static bool SetupLeafData(const AABBTreeNode* current, udword depth, void* user_data)
- {
- if(current->IsLeaf())
- {
- Internal* Data = (Internal*)user_data;
-
- // Get current leaf's box
- Data->mLeaves[Data->mNbLeaves] = *current->GetAABB();
-
- // Setup leaf data
- udword Index = (udword(current->GetPrimitives()) - udword(Data->mBase))/sizeof(udword);
- Data->mTriangles[Data->mNbLeaves].SetData(current->GetNbPrimitives(), Index);
-
- Data->mNbLeaves++;
- }
- return true;
- }
- };
-
- // Walk the tree & count number of leaves
- Data.mNbLeaves = 0;
- mSource->Walk(Local::CountLeaves, &Data);
- mNbLeaves = Data.mNbLeaves; // Keep track of it
-
- // Special case for 1-leaf meshes
- if(mNbLeaves==1)
- {
- mModelCode |= OPC_SINGLE_NODE;
- Status = true;
- goto FreeAndExit;
- }
-
- // Allocate our structures
- Data.mLeaves = new AABB[Data.mNbLeaves]; CHECKALLOC(Data.mLeaves);
- mTriangles = new LeafTriangles[Data.mNbLeaves]; CHECKALLOC(mTriangles);
-
- // Walk the tree again & setup leaf data
- Data.mTriangles = mTriangles;
- Data.mBase = mSource->GetIndices();
- Data.mNbLeaves = 0; // Reset for incoming walk
- mSource->Walk(Local::SetupLeafData, &Data);
-
- // Handle source indices
- {
- bool MustKeepIndices = true;
- if(create.mCanRemap)
- {
- // We try to get rid of source indices (saving more ram!) by reorganizing triangle arrays...
- // Remap can fail when we use callbacks => keep track of indices in that case (it still
- // works, only using more memory)
- if(create.mIMesh->RemapClient(mSource->GetNbPrimitives(), mSource->GetIndices()))
- {
- MustKeepIndices = false;
- }
- }
-
- if(MustKeepIndices)
- {
- // Keep track of source indices (from vanilla tree)
- mNbPrimitives = mSource->GetNbPrimitives();
- mIndices = new udword[mNbPrimitives];
- CopyMemory(mIndices, mSource->GetIndices(), mNbPrimitives*sizeof(udword));
- }
- }
-
- // Now, create our optimized tree using previous leaf nodes
- LeafTree = new AABBTree;
- CHECKALLOC(LeafTree);
- {
- AABBTreeOfAABBsBuilder TB; // Now using boxes !
- TB.mSettings = create.mSettings;
- TB.mSettings.mLimit = 1; // We now want a complete tree so that we can "optimize" it
- TB.mNbPrimitives = Data.mNbLeaves;
- TB.mAABBArray = Data.mLeaves;
- if(!LeafTree->Build(&TB)) goto FreeAndExit;
- }
-
- // 3) Create an optimized tree according to user-settings
- if(!CreateTree(create.mNoLeaf, create.mQuantized)) goto FreeAndExit;
-
- // 3-2) Create optimized tree
- if(!mTree->Build(LeafTree)) goto FreeAndExit;
-
- // Finally ok...
- Status = true;
-
-FreeAndExit: // Allow me this one...
- DELETESINGLE(LeafTree);
-
- // 3-3) Delete generic tree if needed
- if(!create.mKeepOriginal) DELETESINGLE(mSource);
-
- return Status;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the number of bytes used by the tree.
- * \return amount of bytes used
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword HybridModel::GetUsedBytes() const
-{
- udword UsedBytes = 0;
- if(mTree) UsedBytes += mTree->GetUsedBytes();
- if(mIndices) UsedBytes += mNbPrimitives * sizeof(udword); // mIndices
- if(mTriangles) UsedBytes += mNbLeaves * sizeof(LeafTriangles); // mTriangles
- return UsedBytes;
-}
-
-inline_ void ComputeMinMax(IcePoint& min, IcePoint& max, const VertexPointers& vp)
-{
- // Compute triangle's AABB = a leaf box
-#ifdef OPC_USE_FCOMI // a 15% speedup on my machine, not much
- min.x = FCMin3(vp.Vertex[0]->x, vp.Vertex[1]->x, vp.Vertex[2]->x);
- max.x = FCMax3(vp.Vertex[0]->x, vp.Vertex[1]->x, vp.Vertex[2]->x);
-
- min.y = FCMin3(vp.Vertex[0]->y, vp.Vertex[1]->y, vp.Vertex[2]->y);
- max.y = FCMax3(vp.Vertex[0]->y, vp.Vertex[1]->y, vp.Vertex[2]->y);
-
- min.z = FCMin3(vp.Vertex[0]->z, vp.Vertex[1]->z, vp.Vertex[2]->z);
- max.z = FCMax3(vp.Vertex[0]->z, vp.Vertex[1]->z, vp.Vertex[2]->z);
-#else
- min = *vp.Vertex[0];
- max = *vp.Vertex[0];
- min.Min(*vp.Vertex[1]);
- max.Max(*vp.Vertex[1]);
- min.Min(*vp.Vertex[2]);
- max.Max(*vp.Vertex[2]);
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the collision model. This can be used to handle dynamic meshes. Usage is:
- * 1. modify your mesh vertices (keep the topology constant!)
- * 2. refit the tree (call this method)
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool HybridModel::Refit()
-{
- if(!mIMesh) return false;
- if(!mTree) return false;
-
- if(IsQuantized()) return false;
- if(HasLeafNodes()) return false;
-
- const LeafTriangles* LT = GetLeafTriangles();
- const udword* Indices = GetIndices();
-
- // Bottom-up update
- VertexPointers VP;
- IcePoint Min,Max;
- IcePoint Min_,Max_;
- udword Index = mTree->GetNbNodes();
- AABBNoLeafNode* Nodes = (AABBNoLeafNode*)((AABBNoLeafTree*)mTree)->GetNodes();
- while(Index--)
- {
- AABBNoLeafNode& Current = Nodes[Index];
-
- if(Current.HasPosLeaf())
- {
- const LeafTriangles& CurrentLeaf = LT[Current.GetPosPrimitive()];
-
- Min.SetPlusInfinity();
- Max.SetMinusInfinity();
-
- IcePoint TmpMin, TmpMax;
-
- // Each leaf box has a set of triangles
- udword NbTris = CurrentLeaf.GetNbTriangles();
- if(Indices)
- {
- const udword* T = &Indices[CurrentLeaf.GetTriangleIndex()];
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- mIMesh->GetTriangle(VP, *T++);
- ComputeMinMax(TmpMin, TmpMax, VP);
- Min.Min(TmpMin);
- Max.Max(TmpMax);
- }
- }
- else
- {
- udword BaseIndex = CurrentLeaf.GetTriangleIndex();
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- mIMesh->GetTriangle(VP, BaseIndex++);
- ComputeMinMax(TmpMin, TmpMax, VP);
- Min.Min(TmpMin);
- Max.Max(TmpMax);
- }
- }
- }
- else
- {
- const CollisionAABB& CurrentBox = Current.GetPos()->mAABB;
- CurrentBox.GetMin(Min);
- CurrentBox.GetMax(Max);
- }
-
- if(Current.HasNegLeaf())
- {
- const LeafTriangles& CurrentLeaf = LT[Current.GetNegPrimitive()];
-
- Min_.SetPlusInfinity();
- Max_.SetMinusInfinity();
-
- IcePoint TmpMin, TmpMax;
-
- // Each leaf box has a set of triangles
- udword NbTris = CurrentLeaf.GetNbTriangles();
- if(Indices)
- {
- const udword* T = &Indices[CurrentLeaf.GetTriangleIndex()];
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- mIMesh->GetTriangle(VP, *T++);
- ComputeMinMax(TmpMin, TmpMax, VP);
- Min_.Min(TmpMin);
- Max_.Max(TmpMax);
- }
- }
- else
- {
- udword BaseIndex = CurrentLeaf.GetTriangleIndex();
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- mIMesh->GetTriangle(VP, BaseIndex++);
- ComputeMinMax(TmpMin, TmpMax, VP);
- Min_.Min(TmpMin);
- Max_.Max(TmpMax);
- }
- }
- }
- else
- {
- const CollisionAABB& CurrentBox = Current.GetNeg()->mAABB;
- CurrentBox.GetMin(Min_);
- CurrentBox.GetMax(Max_);
- }
-#ifdef OPC_USE_FCOMI
- Min.x = FCMin2(Min.x, Min_.x);
- Max.x = FCMax2(Max.x, Max_.x);
- Min.y = FCMin2(Min.y, Min_.y);
- Max.y = FCMax2(Max.y, Max_.y);
- Min.z = FCMin2(Min.z, Min_.z);
- Max.z = FCMax2(Max.z, Max_.z);
-#else
- Min.Min(Min_);
- Max.Max(Max_);
-#endif
- Current.mAABB.SetMinMax(Min, Max);
- }
- return true;
-}
diff --git a/Opcode/OpcodeLib/OPC_HybridModel.h b/Opcode/OpcodeLib/OPC_HybridModel.h deleted file mode 100644 index 7833a94..0000000 --- a/Opcode/OpcodeLib/OPC_HybridModel.h +++ /dev/null @@ -1,106 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for hybrid models.
- * \file OPC_HybridModel.h
- * \author Pierre Terdiman
- * \date May, 18, 2003
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_HYBRIDMODEL_H__
-#define __OPC_HYBRIDMODEL_H__
-
- //! Leaf descriptor
- struct LeafTriangles
- {
- udword Data; //!< Packed data
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets number of triangles in the leaf.
- * \return number of triangles N, with 0 < N <= 16
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbTriangles() const { return (Data & 15)+1; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets triangle index for this leaf. Indexed model's array of indices retrieved with HybridModel::GetIndices()
- * \return triangle index
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetTriangleIndex() const { return Data>>4; }
- inline_ void SetData(udword nb, udword index) { ASSERT(nb>0 && nb<=16); nb--; Data = (index<<4)|(nb&15); }
- };
-
- class OPCODE_API HybridModel : public BaseModel
- {
- public:
- // Constructor/Destructor
- HybridModel();
- virtual ~HybridModel();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Builds a collision model.
- * \param create [in] model creation structure
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(BaseModel) bool Build(const OPCODECREATE& create);
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the number of bytes used by the tree.
- * \return amount of bytes used
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(BaseModel) udword GetUsedBytes() const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Refits the collision model. This can be used to handle dynamic meshes. Usage is:
- * 1. modify your mesh vertices (keep the topology constant!)
- * 2. refit the tree (call this method)
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(BaseModel) bool Refit();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets array of triangles.
- * \return array of triangles
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const LeafTriangles* GetLeafTriangles() const { return mTriangles; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets array of indices.
- * \return array of indices
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const udword* GetIndices() const { return mIndices; }
-
- private:
- udword mNbLeaves; //!< Number of leaf nodes in the model
- LeafTriangles* mTriangles; //!< Array of mNbLeaves leaf descriptors
- udword mNbPrimitives; //!< Number of primitives in the model
- udword* mIndices; //!< Array of primitive indices
-
- // Internal methods
- void Release();
- };
-
-#endif // __OPC_HYBRIDMODEL_H__
diff --git a/Opcode/OpcodeLib/OPC_IceHook.h b/Opcode/OpcodeLib/OPC_IceHook.h deleted file mode 100644 index 8b97eaa..0000000 --- a/Opcode/OpcodeLib/OPC_IceHook.h +++ /dev/null @@ -1,70 +0,0 @@ -
-// Should be included by Opcode.h if needed
-
- #define ICE_DONT_CHECK_COMPILER_OPTIONS
-
- // From Windows...
- typedef int BOOL;
- #ifndef FALSE
- #define FALSE 0
- #endif
-
- #ifndef TRUE
- #define TRUE 1
- #endif
-
- #include <stdio.h>
- #include <stdlib.h>
- #include <assert.h>
- #include <string.h>
- #include <float.h>
- #include <Math.h>
-
- #ifndef ASSERT
- #define ASSERT(exp) {}
- #endif
- #define ICE_COMPILE_TIME_ASSERT(exp) extern char ICE_Dummy[ (exp) ? 1 : -1 ]
-
- #define Log {}
- #define SetIceError false
- #define EC_OUTOFMEMORY "Out of memory"
-
- #include ".\Ice\IcePreprocessor.h"
-
- #undef ICECORE_API
- #define ICECORE_API OPCODE_API
-
- #include ".\Ice\IceTypes.h"
- #include ".\Ice\IceFPU.h"
- #include ".\Ice\IceMemoryMacros.h"
-
- namespace IceCore
- {
- #include ".\Ice\IceUtils.h"
- #include ".\Ice\IceContainer.h"
- #include ".\Ice\IcePairs.h"
- #include ".\Ice\IceRevisitedRadix.h"
- #include ".\Ice\IceRandom.h"
- }
- using namespace IceCore;
-
- #define ICEMATHS_API OPCODE_API
- namespace IceMaths
- {
- #include ".\Ice\IceAxes.h"
- #include ".\Ice\IcePoint.h"
- #include ".\Ice\IceHPoint.h"
- #include ".\Ice\IceMatrix3x3.h"
- #include ".\Ice\IceMatrix4x4.h"
- #include ".\Ice\IcePlane.h"
- #include ".\Ice\IceRay.h"
- #include ".\Ice\IceIndexedTriangle.h"
- #include ".\Ice\IceTriangle.h"
- #include ".\Ice\IceTriList.h"
- #include ".\Ice\IceAABB.h"
- #include ".\Ice\IceOBB.h"
- #include ".\Ice\IceBoundingSphere.h"
- #include ".\Ice\IceSegment.h"
- #include ".\Ice\IceLSS.h"
- }
- using namespace IceMaths;
diff --git a/Opcode/OpcodeLib/OPC_MeshInterface.cpp b/Opcode/OpcodeLib/OPC_MeshInterface.cpp deleted file mode 100644 index 9f45c25..0000000 --- a/Opcode/OpcodeLib/OPC_MeshInterface.cpp +++ /dev/null @@ -1,299 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a mesh interface.
- * \file OPC_MeshInterface.cpp
- * \author Pierre Terdiman
- * \date November, 27, 2002
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * This structure holds 3 vertex-pointers. It's mainly used by collision callbacks so that the app doesn't have
- * to return 3 vertices to OPCODE (36 bytes) but only 3 pointers (12 bytes). It seems better but I never profiled
- * the alternative.
- *
- * \class VertexPointers
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * This class is an interface between us and user-defined meshes. Meshes can be defined in a lot of ways, and here we
- * try to support most of them.
- *
- * Basically you have two options:
- * - callbacks, if OPC_USE_CALLBACKS is defined in OPC_Settings.h.
- * - else pointers.
- *
- * If using pointers, you can also use strides or not. Strides are used when OPC_USE_STRIDE is defined.
- *
- *
- * CALLBACKS:
- *
- * Using callbacks is the most generic way to feed OPCODE with your meshes. Indeed, you just have to give
- * access to three vertices at the end of the day. It's up to you to fetch them from your database, using
- * whatever method you want. Hence your meshes can lie in system memory or AGP, be indexed or not, use 16
- * or 32-bits indices, you can decompress them on-the-fly if needed, etc. On the other hand, a callback is
- * called each time OPCODE needs access to a particular triangle, so there might be a slight overhead.
- *
- * To make things clear: geometry & topology are NOT stored in the collision system,
- * in order to save some ram. So, when the system needs them to perform accurate intersection
- * tests, you're requested to provide the triangle-vertices corresponding to a given face index.
- *
- * Ex:
- *
- * \code
- * static void ColCallback(udword triangle_index, VertexPointers& triangle, udword user_data)
- * {
- * // Get back Mesh0 or Mesh1 (you also can use 2 different callbacks)
- * Mesh* MyMesh = (Mesh*)user_data;
- * // Get correct triangle in the app-controlled database
- * const Triangle* Tri = MyMesh->GetTriangle(triangle_index);
- * // Setup pointers to vertices for the collision system
- * triangle.Vertex[0] = MyMesh->GetVertex(Tri->mVRef[0]);
- * triangle.Vertex[1] = MyMesh->GetVertex(Tri->mVRef[1]);
- * triangle.Vertex[2] = MyMesh->GetVertex(Tri->mVRef[2]);
- * }
- *
- * // Setup callbacks
- * MeshInterface0->SetCallback(ColCallback, udword(Mesh0));
- * MeshInterface1->SetCallback(ColCallback, udword(Mesh1));
- * \endcode
- *
- * Of course, you should make this callback as fast as possible. And you're also not supposed
- * to modify the geometry *after* the collision trees have been built. The alternative was to
- * store the geometry & topology in the collision system as well (as in RAPID) but we have found
- * this approach to waste a lot of ram in many cases.
- *
- *
- * POINTERS:
- *
- * If you're internally using the following canonical structures:
- * - a vertex made of three 32-bits floating point values
- * - a triangle made of three 32-bits integer vertex references
- * ...then you may want to use pointers instead of callbacks. This is the same, except OPCODE will directly
- * use provided pointers to access the topology and geometry, without using a callback. It might be faster,
- * but probably not as safe. Pointers have been introduced in OPCODE 1.2.
- *
- * Ex:
- *
- * \code
- * // Setup pointers
- * MeshInterface0->SetPointers(Mesh0->GetFaces(), Mesh0->GetVerts());
- * MeshInterface1->SetPointers(Mesh1->GetFaces(), Mesh1->GetVerts());
- * \endcode
- *
- *
- * STRIDES:
- *
- * If your vertices are D3D-like entities interleaving a position, a normal and/or texture coordinates
- * (i.e. if your vertices are FVFs), you might want to use a vertex stride to skip extra data OPCODE
- * doesn't need. Using a stride shouldn't be notably slower than not using it, but it might increase
- * cache misses. Please also note that you *shouldn't* read from AGP or video-memory buffers !
- *
- *
- * In any case, compilation flags are here to select callbacks/pointers/strides at compile time, so
- * choose what's best for your application. All of this has been wrapped into this MeshInterface.
- *
- * \class MeshInterface
- * \author Pierre Terdiman
- * \version 1.3
- * \date November, 27, 2002
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-MeshInterface::MeshInterface() :
-#ifdef OPC_USE_CALLBACKS
- mUserData (null),
- mObjCallback (null),
-#else
- mTris (null),
- mVerts (null),
- #ifdef OPC_USE_STRIDE
- mTriStride (sizeof(IndexedTriangle)),
- mVertexStride (sizeof(IcePoint)),
- #endif
-#endif
- mNbTris (0),
- mNbVerts (0)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-MeshInterface::~MeshInterface()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks the mesh interface is valid, i.e. things have been setup correctly.
- * \return true if valid
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool MeshInterface::IsValid() const
-{
- if(!mNbTris || !mNbVerts) return false;
-#ifdef OPC_USE_CALLBACKS
- if(!mObjCallback) return false;
-#else
- if(!mTris || !mVerts) return false;
-#endif
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks the mesh itself is valid.
- * Currently we only look for degenerate faces.
- * \return number of degenerate faces
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword MeshInterface::CheckTopology() const
-{
- // Check topology. If the model contains degenerate faces, collision report can be wrong in some cases.
- // e.g. it happens with the standard MAX teapot. So clean your meshes first... If you don't have a mesh cleaner
- // you can try this: www.codercorner.com/Consolidation.zip
-
- udword NbDegenerate = 0;
-
- VertexPointers VP;
-
- // Using callbacks, we don't have access to vertex indices. Nevertheless we still can check for
- // redundant vertex pointers, which cover all possibilities (callbacks/pointers/strides).
- for(udword i=0;i<mNbTris;i++)
- {
- GetTriangle(VP, i);
-
- if( (VP.Vertex[0]==VP.Vertex[1])
- || (VP.Vertex[1]==VP.Vertex[2])
- || (VP.Vertex[2]==VP.Vertex[0])) NbDegenerate++;
- }
-
- return NbDegenerate;
-}
-
-#ifdef OPC_USE_CALLBACKS
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Callback control: setups object callback. Must provide triangle-vertices for a given triangle index.
- * \param callback [in] user-defined callback
- * \param user_data [in] user-defined data
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool MeshInterface::SetCallback(RequestCallback callback, void* user_data)
-{
- if(!callback) return SetIceError("MeshInterface::SetCallback: callback pointer is null");
-
- mObjCallback = callback;
- mUserData = user_data;
- return true;
-}
-#else
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Pointers control: setups object pointers. Must provide access to faces and vertices for a given object.
- * \param tris [in] pointer to triangles
- * \param verts [in] pointer to vertices
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool MeshInterface::SetPointers(const IndexedTriangle* tris, const IcePoint* verts)
-{
- if(!tris || !verts) return SetIceError("MeshInterface::SetPointers: pointer is null", null);
-
- mTris = tris;
- mVerts = verts;
- return true;
-}
-#ifdef OPC_USE_STRIDE
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Strides control
- * \param tri_stride [in] size of a triangle in bytes. The first sizeof(IndexedTriangle) bytes are used to get vertex indices.
- * \param vertex_stride [in] size of a vertex in bytes. The first sizeof(IcePoint) bytes are used to get vertex position.
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool MeshInterface::SetStrides(udword tri_stride, udword vertex_stride)
-{
- if(tri_stride<sizeof(IndexedTriangle)) return SetIceError("MeshInterface::SetStrides: invalid triangle stride", null);
- if(vertex_stride<sizeof(IcePoint)) return SetIceError("MeshInterface::SetStrides: invalid vertex stride", null);
-
- mTriStride = tri_stride;
- mVertexStride = vertex_stride;
- return true;
-}
-#endif
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Remaps client's mesh according to a permutation.
- * \param nb_indices [in] number of indices in the permutation (will be checked against number of triangles)
- * \param permutation [in] list of triangle indices
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool MeshInterface::RemapClient(udword nb_indices, const udword* permutation) const
-{
- // Checkings
- if(!nb_indices || !permutation) return false;
- if(nb_indices!=mNbTris) return false;
-
-#ifdef OPC_USE_CALLBACKS
- // We can't really do that using callbacks
- return false;
-#else
- IndexedTriangle* Tmp = new IndexedTriangle[mNbTris];
- CHECKALLOC(Tmp);
-
- #ifdef OPC_USE_STRIDE
- udword Stride = mTriStride;
- #else
- udword Stride = sizeof(IndexedTriangle);
- #endif
-
- for(udword i=0;i<mNbTris;i++)
- {
- const IndexedTriangle* T = (const IndexedTriangle*)(((ubyte*)mTris) + i * Stride);
- Tmp[i] = *T;
- }
-
- for(udword i=0;i<mNbTris;i++)
- {
- IndexedTriangle* T = (IndexedTriangle*)(((ubyte*)mTris) + i * Stride);
- *T = Tmp[permutation[i]];
- }
-
- DELETEARRAY(Tmp);
-#endif
- return true;
-}
diff --git a/Opcode/OpcodeLib/OPC_MeshInterface.h b/Opcode/OpcodeLib/OPC_MeshInterface.h deleted file mode 100644 index 7770b40..0000000 --- a/Opcode/OpcodeLib/OPC_MeshInterface.h +++ /dev/null @@ -1,182 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a mesh interface.
- * \file OPC_MeshInterface.h
- * \author Pierre Terdiman
- * \date November, 27, 2002
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_MESHINTERFACE_H__
-#define __OPC_MESHINTERFACE_H__
-
- struct VertexPointers
- {
- const IcePoint* Vertex[3];
-
- bool BackfaceCulling(const IcePoint& source)
- {
- const IcePoint& p0 = *Vertex[0];
- const IcePoint& p1 = *Vertex[1];
- const IcePoint& p2 = *Vertex[2];
-
- // Compute normal direction
- IcePoint Normal = (p2 - p1)^(p0 - p1);
-
- // Backface culling
- return (Normal | (source - p0)) >= 0.0f;
- }
- };
-
-#ifdef OPC_USE_CALLBACKS
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * User-callback, called by OPCODE to request vertices from the app.
- * \param triangle_index [in] face index for which the system is requesting the vertices
- * \param triangle [out] triangle's vertices (must be provided by the user)
- * \param user_data [in] user-defined data from SetCallback()
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- typedef void (*RequestCallback) (udword triangle_index, VertexPointers& triangle, void* user_data);
-#endif
-
- class OPCODE_API MeshInterface
- {
- public:
- // Constructor / Destructor
- MeshInterface();
- ~MeshInterface();
- // Common settings
- inline_ udword GetNbTriangles() const { return mNbTris; }
- inline_ udword GetNbVertices() const { return mNbVerts; }
- inline_ void SetNbTriangles(udword nb) { mNbTris = nb; }
- inline_ void SetNbVertices(udword nb) { mNbVerts = nb; }
-
-#ifdef OPC_USE_CALLBACKS
- // Callback settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Callback control: setups object callback. Must provide triangle-vertices for a given triangle index.
- * \param callback [in] user-defined callback
- * \param user_data [in] user-defined data
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool SetCallback(RequestCallback callback, void* user_data);
- inline_ void* GetUserData() const { return mUserData; }
- inline_ RequestCallback GetCallback() const { return mObjCallback; }
-#else
- // Pointers settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Pointers control: setups object pointers. Must provide access to faces and vertices for a given object.
- * \param tris [in] pointer to triangles
- * \param verts [in] pointer to vertices
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool SetPointers(const IndexedTriangle* tris, const IcePoint* verts);
- inline_ const IndexedTriangle* GetTris() const { return mTris; }
- inline_ const IcePoint* GetVerts() const { return mVerts; }
-
- #ifdef OPC_USE_STRIDE
- // Strides settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Strides control
- * \param tri_stride [in] size of a triangle in bytes. The first sizeof(IndexedTriangle) bytes are used to get vertex indices.
- * \param vertex_stride [in] size of a vertex in bytes. The first sizeof(IcePoint) bytes are used to get vertex position.
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(IcePoint));
- inline_ udword GetTriStride() const { return mTriStride; }
- inline_ udword GetVertexStride() const { return mVertexStride; }
- #endif
-#endif
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Fetches a triangle given a triangle index.
- * \param vp [out] required triangle's vertex pointers
- * \param index [in] triangle index
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void GetTriangle(VertexPointers& vp, udword index) const
- {
-#ifdef OPC_USE_CALLBACKS
- (mObjCallback)(index, vp, mUserData);
-#else
- #ifdef OPC_USE_STRIDE
- const IndexedTriangle* T = (const IndexedTriangle*)(((ubyte*)mTris) + index * mTriStride);
- vp.Vertex[0] = (const IcePoint*)(((ubyte*)mVerts) + T->mVRef[0] * mVertexStride);
- vp.Vertex[1] = (const IcePoint*)(((ubyte*)mVerts) + T->mVRef[1] * mVertexStride);
- vp.Vertex[2] = (const IcePoint*)(((ubyte*)mVerts) + T->mVRef[2] * mVertexStride);
- #else
- const IndexedTriangle* T = &mTris[index];
- vp.Vertex[0] = &mVerts[T->mVRef[0]];
- vp.Vertex[1] = &mVerts[T->mVRef[1]];
- vp.Vertex[2] = &mVerts[T->mVRef[2]];
- #endif
-#endif
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Remaps client's mesh according to a permutation.
- * \param nb_indices [in] number of indices in the permutation (will be checked against number of triangles)
- * \param permutation [in] list of triangle indices
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ bool RemapClient(udword nb_indices, const udword* permutation) const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the mesh interface is valid, i.e. things have been setup correctly.
- * \return true if valid
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool IsValid() const;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Checks the mesh itself is valid.
- * Currently we only look for degenerate faces.
- * \return number of degenerate faces
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- udword CheckTopology() const;
- private:
-
- udword mNbTris; //!< Number of triangles in the input model
- udword mNbVerts; //!< Number of vertices in the input model
-#ifdef OPC_USE_CALLBACKS
- // User callback
- void* mUserData; //!< User-defined data sent to callback
- RequestCallback mObjCallback; //!< Object callback
-#else
- // User pointers
- const IndexedTriangle* mTris; //!< Array of indexed triangles
- const IcePoint* mVerts; //!< Array of vertices
- #ifdef OPC_USE_STRIDE
- udword mTriStride; //!< Possible triangle stride in bytes [Opcode 1.3]
- udword mVertexStride; //!< Possible vertex stride in bytes [Opcode 1.3]
- #endif
-#endif
- };
-
-#endif //__OPC_MESHINTERFACE_H__
\ No newline at end of file diff --git a/Opcode/OpcodeLib/OPC_Model.cpp b/Opcode/OpcodeLib/OPC_Model.cpp deleted file mode 100644 index 0616c4d..0000000 --- a/Opcode/OpcodeLib/OPC_Model.cpp +++ /dev/null @@ -1,222 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for OPCODE models.
- * \file OPC_Model.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * The main collision wrapper, for all trees. Supported trees are:
- * - Normal trees (2*N-1 nodes, full size)
- * - No-leaf trees (N-1 nodes, full size)
- * - Quantized trees (2*N-1 nodes, half size)
- * - Quantized no-leaf trees (N-1 nodes, half size)
- *
- * Usage:
- *
- * 1) Create a static mesh interface using callbacks or pointers. (see OPC_MeshInterface.cpp).
- * Keep it around in your app, since a pointer to this interface is saved internally and
- * used until you release the collision structures.
- *
- * 2) Build a Model using a creation structure:
- *
- * \code
- * Model Sample;
- *
- * OPCODECREATE OPCC;
- * OPCC.IMesh = ...;
- * OPCC.Rules = ...;
- * OPCC.NoLeaf = ...;
- * OPCC.Quantized = ...;
- * OPCC.KeepOriginal = ...;
- * bool Status = Sample.Build(OPCC);
- * \endcode
- *
- * 3) Create a tree collider and set it up:
- *
- * \code
- * AABBTreeCollider TC;
- * TC.SetFirstContact(...);
- * TC.SetFullBoxBoxTest(...);
- * TC.SetFullPrimBoxTest(...);
- * TC.SetTemporalCoherence(...);
- * \endcode
- *
- * 4) Perform a collision query
- *
- * \code
- * // Setup cache
- * static BVTCache ColCache;
- * ColCache.Model0 = &Model0;
- * ColCache.Model1 = &Model1;
- *
- * // Collision query
- * bool IsOk = TC.Collide(ColCache, World0, World1);
- *
- * // Get collision status => if true, objects overlap
- * BOOL Status = TC.GetContactStatus();
- *
- * // Number of colliding pairs and list of pairs
- * udword NbPairs = TC.GetNbPairs();
- * const Pair* p = TC.GetPairs()
- * \endcode
- *
- * 5) Stats
- *
- * \code
- * Model0.GetUsedBytes() = number of bytes used for this collision tree
- * TC.GetNbBVBVTests() = number of BV-BV overlap tests performed during last query
- * TC.GetNbPrimPrimTests() = number of Triangle-Triangle overlap tests performed during last query
- * TC.GetNbBVPrimTests() = number of Triangle-BV overlap tests performed during last query
- * \endcode
- *
- * \class Model
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Model::Model()
-{
-#ifdef __MESHMERIZER_H__ // Collision hulls only supported within ICE !
- mHull = null;
-#endif // __MESHMERIZER_H__
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-Model::~Model()
-{
- Release();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Releases the model.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Model::Release()
-{
- ReleaseBase();
-#ifdef __MESHMERIZER_H__ // Collision hulls only supported within ICE !
- DELETESINGLE(mHull);
-#endif // __MESHMERIZER_H__
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds a collision model.
- * \param create [in] model creation structure
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool Model::Build(const OPCODECREATE& create)
-{
- // 1) Checkings
- if(!create.mIMesh || !create.mIMesh->IsValid()) return false;
-
- // For this model, we only support complete trees
- if(create.mSettings.mLimit!=1) return SetIceError("OPCODE WARNING: supports complete trees only! Use mLimit = 1.\n", null);
-
- // Look for degenerate faces.
- udword NbDegenerate = create.mIMesh->CheckTopology();
- if(NbDegenerate) Log("OPCODE WARNING: found %d degenerate faces in model! Collision might report wrong results!\n", NbDegenerate);
- // We continue nonetheless....
-
- Release(); // Make sure previous tree has been discarded [Opcode 1.3, thanks Adam]
-
- // 1-1) Setup mesh interface automatically [Opcode 1.3]
- SetMeshInterface(create.mIMesh);
-
- // Special case for 1-triangle meshes [Opcode 1.3]
- udword NbTris = create.mIMesh->GetNbTriangles();
- if(NbTris==1)
- {
- // We don't need to actually create a tree here, since we'll only have a single triangle to deal with anyway.
- // It's a waste to use a "model" for this but at least it will work.
- mModelCode |= OPC_SINGLE_NODE;
- return true;
- }
-
- // 2) Build a generic AABB Tree.
- mSource = new AABBTree;
- CHECKALLOC(mSource);
-
- // 2-1) Setup a builder. Our primitives here are triangles from input mesh,
- // so we use an AABBTreeOfTrianglesBuilder.....
- {
- AABBTreeOfTrianglesBuilder TB;
- TB.mIMesh = create.mIMesh;
- TB.mSettings = create.mSettings;
- TB.mNbPrimitives = NbTris;
- if(!mSource->Build(&TB)) return false;
- }
-
- // 3) Create an optimized tree according to user-settings
- if(!CreateTree(create.mNoLeaf, create.mQuantized)) return false;
-
- // 3-2) Create optimized tree
- if(!mTree->Build(mSource)) return false;
-
- // 3-3) Delete generic tree if needed
- if(!create.mKeepOriginal) DELETESINGLE(mSource);
-
-#ifdef __MESHMERIZER_H__
- // 4) Convex hull
- if(create.mCollisionHull)
- {
- // Create hull
- mHull = new CollisionHull;
- CHECKALLOC(mHull);
-
- CONVEXHULLCREATE CHC;
- // ### doesn't work with strides
- CHC.NbVerts = create.mIMesh->GetNbVertices();
- CHC.Vertices = create.mIMesh->GetVerts();
- CHC.UnifyNormals = true;
- CHC.ReduceVertices = true;
- CHC.WordFaces = false;
- mHull->Compute(CHC);
- }
-#endif // __MESHMERIZER_H__
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Gets the number of bytes used by the tree.
- * \return amount of bytes used
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-udword Model::GetUsedBytes() const
-{
- if(!mTree) return 0;
- return mTree->GetUsedBytes();
-}
diff --git a/Opcode/OpcodeLib/OPC_Model.h b/Opcode/OpcodeLib/OPC_Model.h deleted file mode 100644 index 1d7e1e4..0000000 --- a/Opcode/OpcodeLib/OPC_Model.h +++ /dev/null @@ -1,65 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for OPCODE models.
- * \file OPC_Model.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_MODEL_H__
-#define __OPC_MODEL_H__
-
- class OPCODE_API Model : public BaseModel
- {
- public:
- // Constructor/Destructor
- Model();
- virtual ~Model();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Builds a collision model.
- * \param create [in] model creation structure
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(BaseModel) bool Build(const OPCODECREATE& create);
-
-#ifdef __MESHMERIZER_H__
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the collision hull.
- * \return the collision hull if it exists
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const CollisionHull* GetHull() const { return mHull; }
-#endif // __MESHMERIZER_H__
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the number of bytes used by the tree.
- * \return amount of bytes used
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(BaseModel) udword GetUsedBytes() const;
-
- private:
-#ifdef __MESHMERIZER_H__
- CollisionHull* mHull; //!< Possible convex hull
-#endif // __MESHMERIZER_H__
- // Internal methods
- void Release();
- };
-
-#endif //__OPC_MODEL_H__
\ No newline at end of file diff --git a/Opcode/OpcodeLib/OPC_OBBCollider.cpp b/Opcode/OpcodeLib/OPC_OBBCollider.cpp deleted file mode 100644 index 1dc343d..0000000 --- a/Opcode/OpcodeLib/OPC_OBBCollider.cpp +++ /dev/null @@ -1,767 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for an OBB collider.
- * \file OPC_OBBCollider.cpp
- * \author Pierre Terdiman
- * \date January, 1st, 2002
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains an OBB-vs-tree collider.
- *
- * \class OBBCollider
- * \author Pierre Terdiman
- * \version 1.3
- * \date January, 1st, 2002
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-#include "OPC_BoxBoxOverlap.h"
-#include "OPC_TriBoxOverlap.h"
-
-#define SET_CONTACT(prim_index, flag) \
- /* Set contact status */ \
- mFlags |= flag; \
- mTouchedPrimitives->Add(prim_index);
-
-//! OBB-triangle test
-#define OBB_PRIM(prim_index, flag) \
- /* Request vertices from the app */ \
- VertexPointers VP; mIMesh->GetTriangle(VP, prim_index); \
- /* Transform them in a common space */ \
- TransformPoint(mLeafVerts[0], *VP.Vertex[0], mRModelToBox, mTModelToBox); \
- TransformPoint(mLeafVerts[1], *VP.Vertex[1], mRModelToBox, mTModelToBox); \
- TransformPoint(mLeafVerts[2], *VP.Vertex[2], mRModelToBox, mTModelToBox); \
- /* Perform triangle-box overlap test */ \
- if(TriBoxOverlap()) \
- { \
- SET_CONTACT(prim_index, flag) \
- }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-OBBCollider::OBBCollider() : mFullBoxBoxTest(true)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-OBBCollider::~OBBCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Validates current settings. You should call this method after all the settings and callbacks have been defined.
- * \return null if everything is ok, else a string describing the problem
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const char* OBBCollider::ValidateSettings()
-{
- if(TemporalCoherenceEnabled() && !FirstContactEnabled()) return "Temporal coherence only works with ""First contact"" mode!";
-
- return VolumeCollider::ValidateSettings();
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Generic collision query for generic OPCODE models. After the call, access the results:
- * - with GetContactStatus()
- * - with GetNbTouchedPrimitives()
- * - with GetTouchedPrimitives()
- *
- * \param cache [in/out] a box cache
- * \param box [in] collision OBB in local space
- * \param model [in] Opcode model to collide with
- * \param worldb [in] OBB's world matrix, or null
- * \param worldm [in] model's world matrix, or null
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool OBBCollider::Collide(OBBCache& cache, const OBB& box, const Model& model, const Matrix4x4* worldb, const Matrix4x4* worldm)
-{
- // Checkings
- if(!Setup(&model)) return false;
-
- // Init collision query
- if(InitQuery(cache, box, worldb, worldm)) return true;
-
- if(!model.HasLeafNodes())
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- else
- {
- const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- }
- else
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- else
- {
- const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
-
- // Perform collision query
- if(SkipPrimitiveTests()) _CollideNoPrimitiveTest(Tree->GetNodes());
- else _Collide(Tree->GetNodes());
- }
- }
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Initializes a collision query :
- * - reset stats & contact status
- * - setup matrices
- * - check temporal coherence
- *
- * \param cache [in/out] a box cache
- * \param box [in] obb in local space
- * \param worldb [in] obb's world matrix, or null
- * \param worldm [in] model's world matrix, or null
- * \return TRUE if we can return immediately
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BOOL OBBCollider::InitQuery(OBBCache& cache, const OBB& box, const Matrix4x4* worldb, const Matrix4x4* worldm)
-{
- // 1) Call the base method
- VolumeCollider::InitQuery();
-
- // 2) Compute obb in world space
- mBoxExtents = box.mExtents;
-
- Matrix4x4 WorldB;
-
- if(worldb)
- {
- WorldB = Matrix4x4( box.mRot * Matrix3x3(*worldb) );
- WorldB.SetTrans(box.mCenter * *worldb);
- }
- else
- {
- WorldB = box.mRot;
- WorldB.SetTrans(box.mCenter);
- }
-
- // Setup matrices
- Matrix4x4 InvWorldB;
- InvertPRMatrix(InvWorldB, WorldB);
-
- if(worldm)
- {
- Matrix4x4 InvWorldM;
- InvertPRMatrix(InvWorldM, *worldm);
-
- Matrix4x4 WorldBtoM = WorldB * InvWorldM;
- Matrix4x4 WorldMtoB = *worldm * InvWorldB;
-
- mRModelToBox = WorldMtoB; WorldMtoB.GetTrans(mTModelToBox);
- mRBoxToModel = WorldBtoM; WorldBtoM.GetTrans(mTBoxToModel);
- }
- else
- {
- mRModelToBox = InvWorldB; InvWorldB.GetTrans(mTModelToBox);
- mRBoxToModel = WorldB; WorldB.GetTrans(mTBoxToModel);
- }
-
- // 3) Setup destination pointer
- mTouchedPrimitives = &cache.TouchedPrimitives;
-
- // 4) Special case: 1-triangle meshes [Opcode 1.3]
- if(mCurrentModel && mCurrentModel->HasSingleNode())
- {
- if(!SkipPrimitiveTests())
- {
- // We simply perform the BV-Prim overlap test each time. We assume single triangle has index 0.
- mTouchedPrimitives->Reset();
-
- // Perform overlap test between the unique triangle and the box (and set contact status if needed)
- OBB_PRIM(udword(0), OPC_CONTACT)
-
- // Return immediately regardless of status
- return TRUE;
- }
- }
-
- // 5) Check temporal coherence:
- if(TemporalCoherenceEnabled())
- {
- // Here we use temporal coherence
- // => check results from previous frame before performing the collision query
- if(FirstContactEnabled())
- {
- // We're only interested in the first contact found => test the unique previously touched face
- if(mTouchedPrimitives->GetNbEntries())
- {
- // Get index of previously touched face = the first entry in the array
- udword PreviouslyTouchedFace = mTouchedPrimitives->GetEntry(0);
-
- // Then reset the array:
- // - if the overlap test below is successful, the index we'll get added back anyway
- // - if it isn't, then the array should be reset anyway for the normal query
- mTouchedPrimitives->Reset();
-
- // Perform overlap test between the cached triangle and the box (and set contact status if needed)
- OBB_PRIM(PreviouslyTouchedFace, OPC_TEMPORAL_CONTACT)
-
- // Return immediately if possible
- if(GetContactStatus()) return TRUE;
- }
- // else no face has been touched during previous query
- // => we'll have to perform a normal query
- }
- else
- {
- // ### rewrite this
- OBB TestBox(mTBoxToModel, mBoxExtents, mRBoxToModel);
-
- // We're interested in all contacts =>test the new real box N(ew) against the previous fat box P(revious):
- if(IsCacheValid(cache) && TestBox.IsInside(cache.FatBox))
- {
- // - if N is included in P, return previous list
- // => we simply leave the list (mTouchedFaces) unchanged
-
- // Set contact status if needed
- if(mTouchedPrimitives->GetNbEntries()) mFlags |= OPC_TEMPORAL_CONTACT;
-
- // In any case we don't need to do a query
- return TRUE;
- }
- else
- {
- // - else do the query using a fat N
-
- // Reset cache since we'll about to perform a real query
- mTouchedPrimitives->Reset();
-
- // Make a fat box so that coherence will work for subsequent frames
- TestBox.mExtents *= cache.FatCoeff;
- mBoxExtents *= cache.FatCoeff;
-
- // Update cache with query data (signature for cached faces)
- cache.FatBox = TestBox;
- }
- }
- }
- else
- {
- // Here we don't use temporal coherence => do a normal query
- mTouchedPrimitives->Reset();
- }
-
- // Now we can precompute box-box data
-
- // Precompute absolute box-to-model rotation matrix
- for(udword i=0;i<3;i++)
- {
- for(udword j=0;j<3;j++)
- {
- // Epsilon value prevents floating-point inaccuracies (strategy borrowed from RAPID)
- mAR.m[i][j] = 1e-6f + fabsf(mRBoxToModel.m[i][j]);
- }
- }
-
- // Precompute bounds for box-in-box test
- mB0 = mBoxExtents - mTModelToBox;
- mB1 = - mBoxExtents - mTModelToBox;
-
- // Precompute box-box data - Courtesy of Erwin de Vries
- mBBx1 = mBoxExtents.x*mAR.m[0][0] + mBoxExtents.y*mAR.m[1][0] + mBoxExtents.z*mAR.m[2][0];
- mBBy1 = mBoxExtents.x*mAR.m[0][1] + mBoxExtents.y*mAR.m[1][1] + mBoxExtents.z*mAR.m[2][1];
- mBBz1 = mBoxExtents.x*mAR.m[0][2] + mBoxExtents.y*mAR.m[1][2] + mBoxExtents.z*mAR.m[2][2];
-
- mBB_1 = mBoxExtents.y*mAR.m[2][0] + mBoxExtents.z*mAR.m[1][0];
- mBB_2 = mBoxExtents.x*mAR.m[2][0] + mBoxExtents.z*mAR.m[0][0];
- mBB_3 = mBoxExtents.x*mAR.m[1][0] + mBoxExtents.y*mAR.m[0][0];
- mBB_4 = mBoxExtents.y*mAR.m[2][1] + mBoxExtents.z*mAR.m[1][1];
- mBB_5 = mBoxExtents.x*mAR.m[2][1] + mBoxExtents.z*mAR.m[0][1];
- mBB_6 = mBoxExtents.x*mAR.m[1][1] + mBoxExtents.y*mAR.m[0][1];
- mBB_7 = mBoxExtents.y*mAR.m[2][2] + mBoxExtents.z*mAR.m[1][2];
- mBB_8 = mBoxExtents.x*mAR.m[2][2] + mBoxExtents.z*mAR.m[0][2];
- mBB_9 = mBoxExtents.x*mAR.m[1][2] + mBoxExtents.y*mAR.m[0][2];
-
- return FALSE;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Checks the OBB completely contains the box. In which case we can end the query sooner.
- * \param bc [in] box center
- * \param be [in] box extents
- * \return true if the OBB contains the whole box
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL OBBCollider::OBBContainsBox(const IcePoint& bc, const IcePoint& be)
-{
- // I assume if all 8 box vertices are inside the OBB, so does the whole box.
- // Sounds ok but maybe there's a better way?
-/*
-#define TEST_PT(a,b,c) \
- p.x=a; p.y=b; p.z=c; p+=bc; \
- f = p.x * mRModelToBox.m[0][0] + p.y * mRModelToBox.m[1][0] + p.z * mRModelToBox.m[2][0]; if(f>mB0.x || f<mB1.x) return FALSE;\
- f = p.x * mRModelToBox.m[0][1] + p.y * mRModelToBox.m[1][1] + p.z * mRModelToBox.m[2][1]; if(f>mB0.y || f<mB1.y) return FALSE;\
- f = p.x * mRModelToBox.m[0][2] + p.y * mRModelToBox.m[1][2] + p.z * mRModelToBox.m[2][2]; if(f>mB0.z || f<mB1.z) return FALSE;
-
- IcePoint p;
- float f;
-
- TEST_PT(be.x, be.y, be.z)
- TEST_PT(-be.x, be.y, be.z)
- TEST_PT(be.x, -be.y, be.z)
- TEST_PT(-be.x, -be.y, be.z)
- TEST_PT(be.x, be.y, -be.z)
- TEST_PT(-be.x, be.y, -be.z)
- TEST_PT(be.x, -be.y, -be.z)
- TEST_PT(-be.x, -be.y, -be.z)
-
- return TRUE;
-*/
-
- // Yes there is:
- // - compute model-box's AABB in OBB space
- // - test AABB-in-AABB
- float NCx = bc.x * mRModelToBox.m[0][0] + bc.y * mRModelToBox.m[1][0] + bc.z * mRModelToBox.m[2][0];
- float NEx = fabsf(mRModelToBox.m[0][0] * be.x) + fabsf(mRModelToBox.m[1][0] * be.y) + fabsf(mRModelToBox.m[2][0] * be.z);
-
- if(mB0.x < NCx+NEx) return FALSE;
- if(mB1.x > NCx-NEx) return FALSE;
-
- float NCy = bc.x * mRModelToBox.m[0][1] + bc.y * mRModelToBox.m[1][1] + bc.z * mRModelToBox.m[2][1];
- float NEy = fabsf(mRModelToBox.m[0][1] * be.x) + fabsf(mRModelToBox.m[1][1] * be.y) + fabsf(mRModelToBox.m[2][1] * be.z);
-
- if(mB0.y < NCy+NEy) return FALSE;
- if(mB1.y > NCy-NEy) return FALSE;
-
- float NCz = bc.x * mRModelToBox.m[0][2] + bc.y * mRModelToBox.m[1][2] + bc.z * mRModelToBox.m[2][2];
- float NEz = fabsf(mRModelToBox.m[0][2] * be.x) + fabsf(mRModelToBox.m[1][2] * be.y) + fabsf(mRModelToBox.m[2][2] * be.z);
-
- if(mB0.z < NCz+NEz) return FALSE;
- if(mB1.z > NCz-NEz) return FALSE;
-
- return TRUE;
-}
-
-#define TEST_BOX_IN_OBB(center, extents) \
- if(OBBContainsBox(center, extents)) \
- { \
- /* Set contact status */ \
- mFlags |= OPC_CONTACT; \
- _Dump(node); \
- return; \
- }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for normal AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_Collide(const AABBCollisionNode* node)
-{
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->IsLeaf())
- {
- OBB_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- _Collide(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for normal AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_CollideNoPrimitiveTest(const AABBCollisionNode* node)
-{
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->IsLeaf())
- {
- SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- _CollideNoPrimitiveTest(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_Collide(const AABBQuantizedNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_OBB(Center, Extents)
-
- if(node->IsLeaf())
- {
- OBB_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- _Collide(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_CollideNoPrimitiveTest(const AABBQuantizedNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_OBB(Center, Extents)
-
- if(node->IsLeaf())
- {
- SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- _CollideNoPrimitiveTest(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_Collide(const AABBNoLeafNode* node)
-{
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->HasPosLeaf()) { OBB_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { OBB_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for no-leaf AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_CollideNoPrimitiveTest(const AABBNoLeafNode* node)
-{
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter)) return;
-
- TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)
-
- if(node->HasPosLeaf()) { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_Collide(const AABBQuantizedNoLeafNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_OBB(Center, Extents)
-
- if(node->HasPosLeaf()) { OBB_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { OBB_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
- else _Collide(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized no-leaf AABB trees, without primitive tests.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void OBBCollider::_CollideNoPrimitiveTest(const AABBQuantizedNoLeafNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform OBB-AABB overlap test
- if(!BoxBoxOverlap(Extents, Center)) return;
-
- TEST_BOX_IN_OBB(Center, Extents)
-
- if(node->HasPosLeaf()) { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf()) { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
- else _CollideNoPrimitiveTest(node->GetNeg());
-}
-
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HybridOBBCollider::HybridOBBCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-HybridOBBCollider::~HybridOBBCollider()
-{
-}
-
-bool HybridOBBCollider::Collide(OBBCache& cache, const OBB& box, const HybridModel& model, const Matrix4x4* worldb, const Matrix4x4* worldm)
-{
- // We don't want primitive tests here!
- mFlags |= OPC_NO_PRIMITIVE_TESTS;
-
- // Checkings
- if(!Setup(&model)) return false;
-
- // Init collision query
- if(InitQuery(cache, box, worldb, worldm)) return true;
-
- // Special case for 1-leaf trees
- if(mCurrentModel && mCurrentModel->HasSingleNode())
- {
- // Here we're supposed to perform a normal query, except our tree has a single node, i.e. just a few triangles
- udword Nb = mIMesh->GetNbTriangles();
-
- // Loop through all triangles
- for(udword i=0;i<Nb;i++)
- {
- OBB_PRIM(i, OPC_CONTACT)
- }
- return true;
- }
-
- // Override destination array since we're only going to get leaf boxes here
- mTouchedBoxes.Reset();
- mTouchedPrimitives = &mTouchedBoxes;
-
- // Now, do the actual query against leaf boxes
- if(!model.HasLeafNodes())
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- else
- {
- const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- }
- else
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- else
- {
- const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
-
- // Perform collision query - we don't want primitive tests here!
- _CollideNoPrimitiveTest(Tree->GetNodes());
- }
- }
-
- // We only have a list of boxes so far
- if(GetContactStatus())
- {
- // Reset contact status, since it currently only reflects collisions with leaf boxes
- Collider::InitQuery();
-
- // Change dest container so that we can use built-in overlap tests and get collided primitives
- cache.TouchedPrimitives.Reset();
- mTouchedPrimitives = &cache.TouchedPrimitives;
-
- // Read touched leaf boxes
- udword Nb = mTouchedBoxes.GetNbEntries();
- const udword* Touched = mTouchedBoxes.GetEntries();
-
- const LeafTriangles* LT = model.GetLeafTriangles();
- const udword* Indices = model.GetIndices();
-
- // Loop through touched leaves
- while(Nb--)
- {
- const LeafTriangles& CurrentLeaf = LT[*Touched++];
-
- // Each leaf box has a set of triangles
- udword NbTris = CurrentLeaf.GetNbTriangles();
- if(Indices)
- {
- const udword* T = &Indices[CurrentLeaf.GetTriangleIndex()];
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- udword TriangleIndex = *T++;
- OBB_PRIM(TriangleIndex, OPC_CONTACT)
- }
- }
- else
- {
- udword BaseIndex = CurrentLeaf.GetTriangleIndex();
-
- // Loop through triangles and test each of them
- while(NbTris--)
- {
- udword TriangleIndex = BaseIndex++;
- OBB_PRIM(TriangleIndex, OPC_CONTACT)
- }
- }
- }
- }
-
- return true;
-}
diff --git a/Opcode/OpcodeLib/OPC_OBBCollider.h b/Opcode/OpcodeLib/OPC_OBBCollider.h deleted file mode 100644 index 0601b20..0000000 --- a/Opcode/OpcodeLib/OPC_OBBCollider.h +++ /dev/null @@ -1,142 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for an OBB collider.
- * \file OPC_OBBCollider.h
- * \author Pierre Terdiman
- * \date January, 1st, 2002
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_OBBCOLLIDER_H__
-#define __OPC_OBBCOLLIDER_H__
-
- struct OPCODE_API OBBCache : VolumeCache
- {
- OBBCache() : FatCoeff(1.1f)
- {
- FatBox.mCenter.Zero();
- FatBox.mExtents.Zero();
- FatBox.mRot.Identity();
- }
-
- // Cached faces signature
- OBB FatBox; //!< Box used when performing the query resulting in cached faces
- // User settings
- float FatCoeff; //!< extents multiplier used to create a fat box
- };
-
- class OPCODE_API OBBCollider : public VolumeCollider
- {
- public:
- // Constructor / Destructor
- OBBCollider();
- virtual ~OBBCollider();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Generic collision query for generic OPCODE models. After the call, access the results:
- * - with GetContactStatus()
- * - with GetNbTouchedPrimitives()
- * - with GetTouchedPrimitives()
- *
- * \param cache [in/out] a box cache
- * \param box [in] collision OBB in local space
- * \param model [in] Opcode model to collide with
- * \param worldb [in] OBB's world matrix, or null
- * \param worldm [in] model's world matrix, or null
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool Collide(OBBCache& cache, const OBB& box, const Model& model, const Matrix4x4* worldb=null, const Matrix4x4* worldm=null);
-
- // Settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: select between full box-box tests or "SAT-lite" tests (where Class III axes are discarded)
- * \param flag [in] true for full tests, false for coarse tests
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetFullBoxBoxTest(bool flag) { mFullBoxBoxTest = flag; }
-
- // Settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Validates current settings. You should call this method after all the settings and callbacks have been defined for a collider.
- * \return null if everything is ok, else a string describing the problem
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(Collider) const char* ValidateSettings();
-
- protected:
- // Precomputed data
- Matrix3x3 mAR; //!< Absolute rotation matrix
- Matrix3x3 mRModelToBox; //!< Rotation from model space to obb space
- Matrix3x3 mRBoxToModel; //!< Rotation from obb space to model space
- IcePoint mTModelToBox; //!< Translation from model space to obb space
- IcePoint mTBoxToModel; //!< Translation from obb space to model space
-
- IcePoint mBoxExtents;
- IcePoint mB0; //!< - mTModelToBox + mBoxExtents
- IcePoint mB1; //!< - mTModelToBox - mBoxExtents
-
- float mBBx1;
- float mBBy1;
- float mBBz1;
-
- float mBB_1;
- float mBB_2;
- float mBB_3;
- float mBB_4;
- float mBB_5;
- float mBB_6;
- float mBB_7;
- float mBB_8;
- float mBB_9;
-
- // Leaf description
- IcePoint mLeafVerts[3]; //!< Triangle vertices
- // Settings
- bool mFullBoxBoxTest; //!< Perform full BV-BV tests (true) or SAT-lite tests (false)
- // Internal methods
- void _Collide(const AABBCollisionNode* node);
- void _Collide(const AABBNoLeafNode* node);
- void _Collide(const AABBQuantizedNode* node);
- void _Collide(const AABBQuantizedNoLeafNode* node);
- void _CollideNoPrimitiveTest(const AABBCollisionNode* node);
- void _CollideNoPrimitiveTest(const AABBNoLeafNode* node);
- void _CollideNoPrimitiveTest(const AABBQuantizedNode* node);
- void _CollideNoPrimitiveTest(const AABBQuantizedNoLeafNode* node);
- // Overlap tests
- inline_ BOOL OBBContainsBox(const IcePoint& bc, const IcePoint& be);
- inline_ BOOL BoxBoxOverlap(const IcePoint& extents, const IcePoint& center);
- inline_ BOOL TriBoxOverlap();
- // Init methods
- BOOL InitQuery(OBBCache& cache, const OBB& box, const Matrix4x4* worldb=null, const Matrix4x4* worldm=null);
- };
-
- class OPCODE_API HybridOBBCollider : public OBBCollider
- {
- public:
- // Constructor / Destructor
- HybridOBBCollider();
- virtual ~HybridOBBCollider();
-
- bool Collide(OBBCache& cache, const OBB& box, const HybridModel& model, const Matrix4x4* worldb=null, const Matrix4x4* worldm=null);
- protected:
- Container mTouchedBoxes;
- };
-
-#endif // __OPC_OBBCOLLIDER_H__
diff --git a/Opcode/OpcodeLib/OPC_OptimizedTree.cpp b/Opcode/OpcodeLib/OPC_OptimizedTree.cpp deleted file mode 100644 index e2abe60..0000000 --- a/Opcode/OpcodeLib/OPC_OptimizedTree.cpp +++ /dev/null @@ -1,782 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for optimized trees. Implements 4 trees:
- * - normal
- * - no leaf
- * - quantized
- * - no leaf / quantized
- *
- * \file OPC_OptimizedTree.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A standard AABB tree.
- *
- * \class AABBCollisionTree
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A no-leaf AABB tree.
- *
- * \class AABBNoLeafTree
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A quantized AABB tree.
- *
- * \class AABBQuantizedTree
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A quantized no-leaf AABB tree.
- *
- * \class AABBQuantizedNoLeafTree
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-//! Compilation flag:
-//! - true to fix quantized boxes (i.e. make sure they enclose the original ones)
-//! - false to see the effects of quantization errors (faster, but wrong results in some cases)
-static bool gFixQuantized = true;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds an implicit tree from a standard one. An implicit tree is a complete tree (2*N-1 nodes) whose negative
- * box pointers and primitive pointers have been made implicit, hence packing 3 pointers in one.
- *
- * Layout for implicit trees:
- * Node:
- * - box
- * - data (32-bits value)
- *
- * if data's LSB = 1 => remaining bits are a primitive pointer
- * else remaining bits are a P-node pointer, and N = P + 1
- *
- * \relates AABBCollisionNode
- * \fn _BuildCollisionTree(AABBCollisionNode* linear, const udword box_id, udword& current_id, const AABBTreeNode* current_node)
- * \param linear [in] base address of destination nodes
- * \param box_id [in] index of destination node
- * \param current_id [in] current running index
- * \param current_node [in] current node from input tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static void _BuildCollisionTree(AABBCollisionNode* linear, const udword box_id, udword& current_id, const AABBTreeNode* current_node)
-{
- // Current node from input tree is "current_node". Must be flattened into "linear[boxid]".
-
- // Store the AABB
- current_node->GetAABB()->GetCenter(linear[box_id].mAABB.mCenter);
- current_node->GetAABB()->GetExtents(linear[box_id].mAABB.mExtents);
- // Store remaining info
- if(current_node->IsLeaf())
- {
- // The input tree must be complete => i.e. one primitive/leaf
- ASSERT(current_node->GetNbPrimitives()==1);
- // Get the primitive index from the input tree
- udword PrimitiveIndex = current_node->GetPrimitives()[0];
- // Setup box data as the primitive index, marked as leaf
- linear[box_id].mData = (PrimitiveIndex<<1)|1;
- }
- else
- {
- // To make the negative one implicit, we must store P and N in successive order
- udword PosID = current_id++; // Get a new id for positive child
- udword NegID = current_id++; // Get a new id for negative child
- // Setup box data as the forthcoming new P pointer
- linear[box_id].mData = (udword)&linear[PosID];
- // Make sure it's not marked as leaf
- ASSERT(!(linear[box_id].mData&1));
- // Recurse with new IDs
- _BuildCollisionTree(linear, PosID, current_id, current_node->GetPos());
- _BuildCollisionTree(linear, NegID, current_id, current_node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds a "no-leaf" tree from a standard one. This is a tree whose leaf nodes have been removed.
- *
- * Layout for no-leaf trees:
- *
- * Node:
- * - box
- * - P pointer => a node (LSB=0) or a primitive (LSB=1)
- * - N pointer => a node (LSB=0) or a primitive (LSB=1)
- *
- * \relates AABBNoLeafNode
- * \fn _BuildNoLeafTree(AABBNoLeafNode* linear, const udword box_id, udword& current_id, const AABBTreeNode* current_node)
- * \param linear [in] base address of destination nodes
- * \param box_id [in] index of destination node
- * \param current_id [in] current running index
- * \param current_node [in] current node from input tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static void _BuildNoLeafTree(AABBNoLeafNode* linear, const udword box_id, udword& current_id, const AABBTreeNode* current_node)
-{
- const AABBTreeNode* P = current_node->GetPos();
- const AABBTreeNode* N = current_node->GetNeg();
- // Leaf nodes here?!
- ASSERT(P);
- ASSERT(N);
- // Internal node => keep the box
- current_node->GetAABB()->GetCenter(linear[box_id].mAABB.mCenter);
- current_node->GetAABB()->GetExtents(linear[box_id].mAABB.mExtents);
-
- if(P->IsLeaf())
- {
- // The input tree must be complete => i.e. one primitive/leaf
- ASSERT(P->GetNbPrimitives()==1);
- // Get the primitive index from the input tree
- udword PrimitiveIndex = P->GetPrimitives()[0];
- // Setup prev box data as the primitive index, marked as leaf
- linear[box_id].mPosData = (PrimitiveIndex<<1)|1;
- }
- else
- {
- // Get a new id for positive child
- udword PosID = current_id++;
- // Setup box data
- linear[box_id].mPosData = (udword)&linear[PosID];
- // Make sure it's not marked as leaf
- ASSERT(!(linear[box_id].mPosData&1));
- // Recurse
- _BuildNoLeafTree(linear, PosID, current_id, P);
- }
-
- if(N->IsLeaf())
- {
- // The input tree must be complete => i.e. one primitive/leaf
- ASSERT(N->GetNbPrimitives()==1);
- // Get the primitive index from the input tree
- udword PrimitiveIndex = N->GetPrimitives()[0];
- // Setup prev box data as the primitive index, marked as leaf
- linear[box_id].mNegData = (PrimitiveIndex<<1)|1;
- }
- else
- {
- // Get a new id for negative child
- udword NegID = current_id++;
- // Setup box data
- linear[box_id].mNegData = (udword)&linear[NegID];
- // Make sure it's not marked as leaf
- ASSERT(!(linear[box_id].mNegData&1));
- // Recurse
- _BuildNoLeafTree(linear, NegID, current_id, N);
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBCollisionTree::AABBCollisionTree() : mNodes(null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBCollisionTree::~AABBCollisionTree()
-{
- DELETEARRAY(mNodes);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds the collision tree from a generic AABB tree.
- * \param tree [in] generic AABB tree
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBCollisionTree::Build(AABBTree* tree)
-{
- // Checkings
- if(!tree) return false;
- // Check the input tree is complete
- udword NbTriangles = tree->GetNbPrimitives();
- udword NbNodes = tree->GetNbNodes();
- if(NbNodes!=NbTriangles*2-1) return false;
-
- // Get nodes
- if(mNbNodes!=NbNodes) // Same number of nodes => keep moving
- {
- mNbNodes = NbNodes;
- DELETEARRAY(mNodes);
- mNodes = new AABBCollisionNode[mNbNodes];
- CHECKALLOC(mNodes);
- }
-
- // Build the tree
- udword CurID = 1;
- _BuildCollisionTree(mNodes, 0, CurID, tree);
- ASSERT(CurID==mNbNodes);
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the collision tree after vertices have been modified.
- * \param mesh_interface [in] mesh interface for current model
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBCollisionTree::Refit(const MeshInterface* mesh_interface)
-{
- ASSERT(!"Not implemented since AABBCollisionTrees have twice as more nodes to refit as AABBNoLeafTrees!");
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Walks the tree and call the user back for each node.
- * \param callback [in] walking callback
- * \param user_data [in] callback's user data
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBCollisionTree::Walk(GenericWalkingCallback callback, void* user_data) const
-{
- if(!callback) return false;
-
- struct Local
- {
- static void _Walk(const AABBCollisionNode* current_node, GenericWalkingCallback callback, void* user_data)
- {
- if(!current_node || !(callback)(current_node, user_data)) return;
-
- if(!current_node->IsLeaf())
- {
- _Walk(current_node->GetPos(), callback, user_data);
- _Walk(current_node->GetNeg(), callback, user_data);
- }
- }
- };
- Local::_Walk(mNodes, callback, user_data);
- return true;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBNoLeafTree::AABBNoLeafTree() : mNodes(null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBNoLeafTree::~AABBNoLeafTree()
-{
- DELETEARRAY(mNodes);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds the collision tree from a generic AABB tree.
- * \param tree [in] generic AABB tree
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBNoLeafTree::Build(AABBTree* tree)
-{
- // Checkings
- if(!tree) return false;
- // Check the input tree is complete
- udword NbTriangles = tree->GetNbPrimitives();
- udword NbNodes = tree->GetNbNodes();
- if(NbNodes!=NbTriangles*2-1) return false;
-
- // Get nodes
- if(mNbNodes!=NbTriangles-1) // Same number of nodes => keep moving
- {
- mNbNodes = NbTriangles-1;
- DELETEARRAY(mNodes);
- mNodes = new AABBNoLeafNode[mNbNodes];
- CHECKALLOC(mNodes);
- }
-
- // Build the tree
- udword CurID = 1;
- _BuildNoLeafTree(mNodes, 0, CurID, tree);
- ASSERT(CurID==mNbNodes);
-
- return true;
-}
-
-inline_ void ComputeMinMax(IcePoint& min, IcePoint& max, const VertexPointers& vp)
-{
- // Compute triangle's AABB = a leaf box
-#ifdef OPC_USE_FCOMI // a 15% speedup on my machine, not much
- min.x = FCMin3(vp.Vertex[0]->x, vp.Vertex[1]->x, vp.Vertex[2]->x);
- max.x = FCMax3(vp.Vertex[0]->x, vp.Vertex[1]->x, vp.Vertex[2]->x);
-
- min.y = FCMin3(vp.Vertex[0]->y, vp.Vertex[1]->y, vp.Vertex[2]->y);
- max.y = FCMax3(vp.Vertex[0]->y, vp.Vertex[1]->y, vp.Vertex[2]->y);
-
- min.z = FCMin3(vp.Vertex[0]->z, vp.Vertex[1]->z, vp.Vertex[2]->z);
- max.z = FCMax3(vp.Vertex[0]->z, vp.Vertex[1]->z, vp.Vertex[2]->z);
-#else
- min = *vp.Vertex[0];
- max = *vp.Vertex[0];
- min.Min(*vp.Vertex[1]);
- max.Max(*vp.Vertex[1]);
- min.Min(*vp.Vertex[2]);
- max.Max(*vp.Vertex[2]);
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the collision tree after vertices have been modified.
- * \param mesh_interface [in] mesh interface for current model
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBNoLeafTree::Refit(const MeshInterface* mesh_interface)
-{
- // Checkings
- if(!mesh_interface) return false;
-
- // Bottom-up update
- VertexPointers VP;
- IcePoint Min,Max;
- IcePoint Min_,Max_;
- udword Index = mNbNodes;
- while(Index--)
- {
- AABBNoLeafNode& Current = mNodes[Index];
-
- if(Current.HasPosLeaf())
- {
- mesh_interface->GetTriangle(VP, Current.GetPosPrimitive());
- ComputeMinMax(Min, Max, VP);
- }
- else
- {
- const CollisionAABB& CurrentBox = Current.GetPos()->mAABB;
- CurrentBox.GetMin(Min);
- CurrentBox.GetMax(Max);
- }
-
- if(Current.HasNegLeaf())
- {
- mesh_interface->GetTriangle(VP, Current.GetNegPrimitive());
- ComputeMinMax(Min_, Max_, VP);
- }
- else
- {
- const CollisionAABB& CurrentBox = Current.GetNeg()->mAABB;
- CurrentBox.GetMin(Min_);
- CurrentBox.GetMax(Max_);
- }
-#ifdef OPC_USE_FCOMI
- Min.x = FCMin2(Min.x, Min_.x);
- Max.x = FCMax2(Max.x, Max_.x);
- Min.y = FCMin2(Min.y, Min_.y);
- Max.y = FCMax2(Max.y, Max_.y);
- Min.z = FCMin2(Min.z, Min_.z);
- Max.z = FCMax2(Max.z, Max_.z);
-#else
- Min.Min(Min_);
- Max.Max(Max_);
-#endif
- Current.mAABB.SetMinMax(Min, Max);
- }
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Walks the tree and call the user back for each node.
- * \param callback [in] walking callback
- * \param user_data [in] callback's user data
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBNoLeafTree::Walk(GenericWalkingCallback callback, void* user_data) const
-{
- if(!callback) return false;
-
- struct Local
- {
- static void _Walk(const AABBNoLeafNode* current_node, GenericWalkingCallback callback, void* user_data)
- {
- if(!current_node || !(callback)(current_node, user_data)) return;
-
- if(!current_node->HasPosLeaf()) _Walk(current_node->GetPos(), callback, user_data);
- if(!current_node->HasNegLeaf()) _Walk(current_node->GetNeg(), callback, user_data);
- }
- };
- Local::_Walk(mNodes, callback, user_data);
- return true;
-}
-
-// Quantization notes:
-// - We could use the highest bits of mData to store some more quantized bits. Dequantization code
-// would be slightly more complex, but number of overlap tests would be reduced (and anyhow those
-// bits are currently wasted). Of course it's not possible if we move to 16 bits mData.
-// - Something like "16 bits floats" could be tested, to bypass the int-to-float conversion.
-// - A dedicated BV-BV test could be used, dequantizing while testing for overlap. (i.e. it's some
-// lazy-dequantization which may save some work in case of early exits). At the very least some
-// muls could be saved by precomputing several more matrices. But maybe not worth the pain.
-// - Do we need to dequantize anyway? Not doing the extents-related muls only implies the box has
-// been scaled, for example.
-// - The deeper we move into the hierarchy, the smaller the extents should be. May not need a fixed
-// number of quantization bits. Even better, could probably be best delta-encoded.
-
-
-// Find max values. Some people asked why I wasn't simply using the first node. Well, I can't.
-// I'm not looking for (min, max) values like in a standard AABB, I'm looking for the extremal
-// centers/extents in order to quantize them. The first node would only give a single center and
-// a single extents. While extents would be the biggest, the center wouldn't.
-#define FIND_MAX_VALUES \
- /* Get max values */ \
- IcePoint CMax(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT); \
- IcePoint EMax(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT); \
- for(udword i=0;i<mNbNodes;i++) \
- { \
- if(fabsf(Nodes[i].mAABB.mCenter.x)>CMax.x) CMax.x = fabsf(Nodes[i].mAABB.mCenter.x); \
- if(fabsf(Nodes[i].mAABB.mCenter.y)>CMax.y) CMax.y = fabsf(Nodes[i].mAABB.mCenter.y); \
- if(fabsf(Nodes[i].mAABB.mCenter.z)>CMax.z) CMax.z = fabsf(Nodes[i].mAABB.mCenter.z); \
- if(fabsf(Nodes[i].mAABB.mExtents.x)>EMax.x) EMax.x = fabsf(Nodes[i].mAABB.mExtents.x); \
- if(fabsf(Nodes[i].mAABB.mExtents.y)>EMax.y) EMax.y = fabsf(Nodes[i].mAABB.mExtents.y); \
- if(fabsf(Nodes[i].mAABB.mExtents.z)>EMax.z) EMax.z = fabsf(Nodes[i].mAABB.mExtents.z); \
- }
-
-#define INIT_QUANTIZATION \
- udword nbc=15; /* Keep one bit for sign */ \
- udword nbe=15; /* Keep one bit for fix */ \
- if(!gFixQuantized) nbe++; \
- \
- /* Compute quantization coeffs */ \
- IcePoint CQuantCoeff, EQuantCoeff; \
- CQuantCoeff.x = CMax.x!=0.0f ? float((1<<nbc)-1)/CMax.x : 0.0f; \
- CQuantCoeff.y = CMax.y!=0.0f ? float((1<<nbc)-1)/CMax.y : 0.0f; \
- CQuantCoeff.z = CMax.z!=0.0f ? float((1<<nbc)-1)/CMax.z : 0.0f; \
- EQuantCoeff.x = EMax.x!=0.0f ? float((1<<nbe)-1)/EMax.x : 0.0f; \
- EQuantCoeff.y = EMax.y!=0.0f ? float((1<<nbe)-1)/EMax.y : 0.0f; \
- EQuantCoeff.z = EMax.z!=0.0f ? float((1<<nbe)-1)/EMax.z : 0.0f; \
- /* Compute and save dequantization coeffs */ \
- mCenterCoeff.x = CQuantCoeff.x!=0.0f ? 1.0f / CQuantCoeff.x : 0.0f; \
- mCenterCoeff.y = CQuantCoeff.y!=0.0f ? 1.0f / CQuantCoeff.y : 0.0f; \
- mCenterCoeff.z = CQuantCoeff.z!=0.0f ? 1.0f / CQuantCoeff.z : 0.0f; \
- mExtentsCoeff.x = EQuantCoeff.x!=0.0f ? 1.0f / EQuantCoeff.x : 0.0f; \
- mExtentsCoeff.y = EQuantCoeff.y!=0.0f ? 1.0f / EQuantCoeff.y : 0.0f; \
- mExtentsCoeff.z = EQuantCoeff.z!=0.0f ? 1.0f / EQuantCoeff.z : 0.0f; \
-
-#define PERFORM_QUANTIZATION \
- /* Quantize */ \
- mNodes[i].mAABB.mCenter[0] = sword(Nodes[i].mAABB.mCenter.x * CQuantCoeff.x); \
- mNodes[i].mAABB.mCenter[1] = sword(Nodes[i].mAABB.mCenter.y * CQuantCoeff.y); \
- mNodes[i].mAABB.mCenter[2] = sword(Nodes[i].mAABB.mCenter.z * CQuantCoeff.z); \
- mNodes[i].mAABB.mExtents[0] = uword(Nodes[i].mAABB.mExtents.x * EQuantCoeff.x); \
- mNodes[i].mAABB.mExtents[1] = uword(Nodes[i].mAABB.mExtents.y * EQuantCoeff.y); \
- mNodes[i].mAABB.mExtents[2] = uword(Nodes[i].mAABB.mExtents.z * EQuantCoeff.z); \
- /* Fix quantized boxes */ \
- if(gFixQuantized) \
- { \
- /* Make sure the quantized box is still valid */ \
- IcePoint Max = Nodes[i].mAABB.mCenter + Nodes[i].mAABB.mExtents; \
- IcePoint Min = Nodes[i].mAABB.mCenter - Nodes[i].mAABB.mExtents; \
- /* For each axis */ \
- for(udword j=0;j<3;j++) \
- { /* Dequantize the box center */ \
- float qc = float(mNodes[i].mAABB.mCenter[j]) * mCenterCoeff[j]; \
- bool FixMe=true; \
- do \
- { /* Dequantize the box extent */ \
- float qe = float(mNodes[i].mAABB.mExtents[j]) * mExtentsCoeff[j]; \
- /* Compare real & dequantized values */ \
- if(qc+qe<Max[j] || qc-qe>Min[j]) mNodes[i].mAABB.mExtents[j]++; \
- else FixMe=false; \
- /* Prevent wrapping */ \
- if(!mNodes[i].mAABB.mExtents[j]) \
- { \
- mNodes[i].mAABB.mExtents[j]=0xffff; \
- FixMe=false; \
- } \
- }while(FixMe); \
- } \
- }
-
-#define REMAP_DATA(member) \
- /* Fix data */ \
- Data = Nodes[i].member; \
- if(!(Data&1)) \
- { \
- /* Compute box number */ \
- udword Nb = (Data - udword(Nodes))/Nodes[i].GetNodeSize(); \
- Data = udword(&mNodes[Nb]); \
- } \
- /* ...remapped */ \
- mNodes[i].member = Data;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBQuantizedTree::AABBQuantizedTree() : mNodes(null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBQuantizedTree::~AABBQuantizedTree()
-{
- DELETEARRAY(mNodes);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds the collision tree from a generic AABB tree.
- * \param tree [in] generic AABB tree
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBQuantizedTree::Build(AABBTree* tree)
-{
- // Checkings
- if(!tree) return false;
- // Check the input tree is complete
- udword NbTriangles = tree->GetNbPrimitives();
- udword NbNodes = tree->GetNbNodes();
- if(NbNodes!=NbTriangles*2-1) return false;
-
- // Get nodes
- mNbNodes = NbNodes;
- DELETEARRAY(mNodes);
- AABBCollisionNode* Nodes = new AABBCollisionNode[mNbNodes];
- CHECKALLOC(Nodes);
-
- // Build the tree
- udword CurID = 1;
- _BuildCollisionTree(Nodes, 0, CurID, tree);
-
- // Quantize
- {
- mNodes = new AABBQuantizedNode[mNbNodes];
- CHECKALLOC(mNodes);
-
- // Get max values
- FIND_MAX_VALUES
-
- // Quantization
- INIT_QUANTIZATION
-
- // Quantize
- udword Data;
- for(udword i=0;i<mNbNodes;i++)
- {
- PERFORM_QUANTIZATION
- REMAP_DATA(mData)
- }
-
- DELETEARRAY(Nodes);
- }
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the collision tree after vertices have been modified.
- * \param mesh_interface [in] mesh interface for current model
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBQuantizedTree::Refit(const MeshInterface* mesh_interface)
-{
- ASSERT(!"Not implemented since requantizing is painful !");
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Walks the tree and call the user back for each node.
- * \param callback [in] walking callback
- * \param user_data [in] callback's user data
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBQuantizedTree::Walk(GenericWalkingCallback callback, void* user_data) const
-{
- if(!callback) return false;
-
- struct Local
- {
- static void _Walk(const AABBQuantizedNode* current_node, GenericWalkingCallback callback, void* user_data)
- {
- if(!current_node || !(callback)(current_node, user_data)) return;
-
- if(!current_node->IsLeaf())
- {
- _Walk(current_node->GetPos(), callback, user_data);
- _Walk(current_node->GetNeg(), callback, user_data);
- }
- }
- };
- Local::_Walk(mNodes, callback, user_data);
- return true;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBQuantizedNoLeafTree::AABBQuantizedNoLeafTree() : mNodes(null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBQuantizedNoLeafTree::~AABBQuantizedNoLeafTree()
-{
- DELETEARRAY(mNodes);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Builds the collision tree from a generic AABB tree.
- * \param tree [in] generic AABB tree
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBQuantizedNoLeafTree::Build(AABBTree* tree)
-{
- // Checkings
- if(!tree) return false;
- // Check the input tree is complete
- udword NbTriangles = tree->GetNbPrimitives();
- udword NbNodes = tree->GetNbNodes();
- if(NbNodes!=NbTriangles*2-1) return false;
-
- // Get nodes
- mNbNodes = NbTriangles-1;
- DELETEARRAY(mNodes);
- AABBNoLeafNode* Nodes = new AABBNoLeafNode[mNbNodes];
- CHECKALLOC(Nodes);
-
- // Build the tree
- udword CurID = 1;
- _BuildNoLeafTree(Nodes, 0, CurID, tree);
- ASSERT(CurID==mNbNodes);
-
- // Quantize
- {
- mNodes = new AABBQuantizedNoLeafNode[mNbNodes];
- CHECKALLOC(mNodes);
-
- // Get max values
- FIND_MAX_VALUES
-
- // Quantization
- INIT_QUANTIZATION
-
- // Quantize
- udword Data;
- for(udword i=0;i<mNbNodes;i++)
- {
- PERFORM_QUANTIZATION
- REMAP_DATA(mPosData)
- REMAP_DATA(mNegData)
- }
-
- DELETEARRAY(Nodes);
- }
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Refits the collision tree after vertices have been modified.
- * \param mesh_interface [in] mesh interface for current model
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBQuantizedNoLeafTree::Refit(const MeshInterface* mesh_interface)
-{
- ASSERT(!"Not implemented since requantizing is painful !");
- return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Walks the tree and call the user back for each node.
- * \param callback [in] walking callback
- * \param user_data [in] callback's user data
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBQuantizedNoLeafTree::Walk(GenericWalkingCallback callback, void* user_data) const
-{
- if(!callback) return false;
-
- struct Local
- {
- static void _Walk(const AABBQuantizedNoLeafNode* current_node, GenericWalkingCallback callback, void* user_data)
- {
- if(!current_node || !(callback)(current_node, user_data)) return;
-
- if(!current_node->HasPosLeaf()) _Walk(current_node->GetPos(), callback, user_data);
- if(!current_node->HasNegLeaf()) _Walk(current_node->GetNeg(), callback, user_data);
- }
- };
- Local::_Walk(mNodes, callback, user_data);
- return true;
-}
diff --git a/Opcode/OpcodeLib/OPC_OptimizedTree.h b/Opcode/OpcodeLib/OPC_OptimizedTree.h deleted file mode 100644 index cda2959..0000000 --- a/Opcode/OpcodeLib/OPC_OptimizedTree.h +++ /dev/null @@ -1,206 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for optimized trees.
- * \file OPC_OptimizedTree.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_OPTIMIZEDTREE_H__
-#define __OPC_OPTIMIZEDTREE_H__
-
- //! Common interface for a node of an implicit tree
- #define IMPLEMENT_IMPLICIT_NODE(base_class, volume) \
- public: \
- /* Constructor / Destructor */ \
- inline_ base_class() : mData(0) {} \
- inline_ ~base_class() {} \
- /* Leaf test */ \
- inline_ BOOL IsLeaf() const { return mData&1; } \
- /* Data access */ \
- inline_ const base_class* GetPos() const { return (base_class*)mData; } \
- inline_ const base_class* GetNeg() const { return ((base_class*)mData)+1; } \
- inline_ udword GetPrimitive() const { return (mData>>1); } \
- /* Stats */ \
- inline_ udword GetNodeSize() const { return SIZEOFOBJECT; } \
- \
- volume mAABB; \
- udword mData;
-
- //! Common interface for a node of a no-leaf tree
- #define IMPLEMENT_NOLEAF_NODE(base_class, volume) \
- public: \
- /* Constructor / Destructor */ \
- inline_ base_class() : mPosData(0), mNegData(0) {} \
- inline_ ~base_class() {} \
- /* Leaf tests */ \
- inline_ BOOL HasPosLeaf() const { return mPosData&1; } \
- inline_ BOOL HasNegLeaf() const { return mNegData&1; } \
- /* Data access */ \
- inline_ const base_class* GetPos() const { return (base_class*)mPosData; } \
- inline_ const base_class* GetNeg() const { return (base_class*)mNegData; } \
- inline_ udword GetPosPrimitive() const { return (mPosData>>1); } \
- inline_ udword GetNegPrimitive() const { return (mNegData>>1); } \
- /* Stats */ \
- inline_ udword GetNodeSize() const { return SIZEOFOBJECT; } \
- \
- volume mAABB; \
- udword mPosData; \
- udword mNegData;
-
- class OPCODE_API AABBCollisionNode
- {
- IMPLEMENT_IMPLICIT_NODE(AABBCollisionNode, CollisionAABB)
-
- inline_ float GetVolume() const { return mAABB.mExtents.x * mAABB.mExtents.y * mAABB.mExtents.z; }
- inline_ float GetSize() const { return mAABB.mExtents.SquareMagnitude(); }
- inline_ udword GetRadius() const
- {
- udword* Bits = (udword*)&mAABB.mExtents.x;
- udword Max = Bits[0];
- if(Bits[1]>Max) Max = Bits[1];
- if(Bits[2]>Max) Max = Bits[2];
- return Max;
- }
-
- // NB: using the square-magnitude or the true volume of the box, seems to yield better results
- // (assuming UNC-like informed traversal methods). I borrowed this idea from PQP. The usual "size"
- // otherwise, is the largest box extent. In SOLID that extent is computed on-the-fly each time it's
- // needed (the best approach IMHO). In RAPID the rotation matrix is permuted so that Extent[0] is
- // always the greatest, which saves looking for it at runtime. On the other hand, it yields matrices
- // whose determinant is not 1, i.e. you can't encode them anymore as unit quaternions. Not a very
- // good strategy.
- };
-
- class OPCODE_API AABBQuantizedNode
- {
- IMPLEMENT_IMPLICIT_NODE(AABBQuantizedNode, QuantizedAABB)
-
- inline_ uword GetSize() const
- {
- const uword* Bits = mAABB.mExtents;
- uword Max = Bits[0];
- if(Bits[1]>Max) Max = Bits[1];
- if(Bits[2]>Max) Max = Bits[2];
- return Max;
- }
- // NB: for quantized nodes I don't feel like computing a square-magnitude with integers all
- // over the place.......!
- };
-
- class OPCODE_API AABBNoLeafNode
- {
- IMPLEMENT_NOLEAF_NODE(AABBNoLeafNode, CollisionAABB)
- };
-
- class OPCODE_API AABBQuantizedNoLeafNode
- {
- IMPLEMENT_NOLEAF_NODE(AABBQuantizedNoLeafNode, QuantizedAABB)
- };
-
- //! Common interface for a collision tree
- #define IMPLEMENT_COLLISION_TREE(base_class, node) \
- public: \
- /* Constructor / Destructor */ \
- base_class(); \
- virtual ~base_class(); \
- /* Builds from a standard tree */ \
- override(AABBOptimizedTree) bool Build(AABBTree* tree); \
- /* Refits the tree */ \
- override(AABBOptimizedTree) bool Refit(const MeshInterface* mesh_interface); \
- /* Walks the tree */ \
- override(AABBOptimizedTree) bool Walk(GenericWalkingCallback callback, void* user_data) const; \
- /* Data access */ \
- inline_ const node* GetNodes() const { return mNodes; } \
- /* Stats */ \
- override(AABBOptimizedTree) udword GetUsedBytes() const { return mNbNodes*sizeof(node); } \
- private: \
- node* mNodes;
-
- typedef bool (*GenericWalkingCallback) (const void* current, void* user_data);
-
- class OPCODE_API AABBOptimizedTree
- {
- public:
- // Constructor / Destructor
- AABBOptimizedTree() :
- mNbNodes (0)
- {}
- virtual ~AABBOptimizedTree() {}
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Builds the collision tree from a generic AABB tree.
- * \param tree [in] generic AABB tree
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual bool Build(AABBTree* tree) = 0;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Refits the collision tree after vertices have been modified.
- * \param mesh_interface [in] mesh interface for current model
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual bool Refit(const MeshInterface* mesh_interface) = 0;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Walks the tree and call the user back for each node.
- * \param callback [in] walking callback
- * \param user_data [in] callback's user data
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual bool Walk(GenericWalkingCallback callback, void* user_data) const = 0;
-
- // Data access
- virtual udword GetUsedBytes() const = 0;
- inline_ udword GetNbNodes() const { return mNbNodes; }
-
- protected:
- udword mNbNodes;
- };
-
- class OPCODE_API AABBCollisionTree : public AABBOptimizedTree
- {
- IMPLEMENT_COLLISION_TREE(AABBCollisionTree, AABBCollisionNode)
- };
-
- class OPCODE_API AABBNoLeafTree : public AABBOptimizedTree
- {
- IMPLEMENT_COLLISION_TREE(AABBNoLeafTree, AABBNoLeafNode)
- };
-
- class OPCODE_API AABBQuantizedTree : public AABBOptimizedTree
- {
- IMPLEMENT_COLLISION_TREE(AABBQuantizedTree, AABBQuantizedNode)
-
- public:
- IcePoint mCenterCoeff;
- IcePoint mExtentsCoeff;
- };
-
- class OPCODE_API AABBQuantizedNoLeafTree : public AABBOptimizedTree
- {
- IMPLEMENT_COLLISION_TREE(AABBQuantizedNoLeafTree, AABBQuantizedNoLeafNode)
-
- public:
- IcePoint mCenterCoeff;
- IcePoint mExtentsCoeff;
- };
-
-#endif // __OPC_OPTIMIZEDTREE_H__
diff --git a/Opcode/OpcodeLib/OPC_RayAABBOverlap.h b/Opcode/OpcodeLib/OPC_RayAABBOverlap.h deleted file mode 100644 index 3929a1f..0000000 --- a/Opcode/OpcodeLib/OPC_RayAABBOverlap.h +++ /dev/null @@ -1,63 +0,0 @@ -// Opcode 1.1: ray-AABB overlap tests based on Woo's code
-// Opcode 1.2: ray-AABB overlap tests based on the separating axis theorem
-//
-// The point of intersection is not computed anymore. The distance to impact is not needed anymore
-// since we now have two different queries for segments or rays.
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes a segment-AABB overlap test using the separating axis theorem. Segment is cached within the class.
- * \param center [in] AABB center
- * \param extents [in] AABB extents
- * \return true on overlap
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL RayCollider::SegmentAABBOverlap(const IcePoint& center, const IcePoint& extents)
-{
- // Stats
- mNbRayBVTests++;
-
- float Dx = mData2.x - center.x; if(fabsf(Dx) > extents.x + mFDir.x) return FALSE;
- float Dy = mData2.y - center.y; if(fabsf(Dy) > extents.y + mFDir.y) return FALSE;
- float Dz = mData2.z - center.z; if(fabsf(Dz) > extents.z + mFDir.z) return FALSE;
-
- float f;
- f = mData.y * Dz - mData.z * Dy; if(fabsf(f) > extents.y*mFDir.z + extents.z*mFDir.y) return FALSE;
- f = mData.z * Dx - mData.x * Dz; if(fabsf(f) > extents.x*mFDir.z + extents.z*mFDir.x) return FALSE;
- f = mData.x * Dy - mData.y * Dx; if(fabsf(f) > extents.x*mFDir.y + extents.y*mFDir.x) return FALSE;
-
- return TRUE;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes a ray-AABB overlap test using the separating axis theorem. Ray is cached within the class.
- * \param center [in] AABB center
- * \param extents [in] AABB extents
- * \return true on overlap
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL RayCollider::RayAABBOverlap(const IcePoint& center, const IcePoint& extents)
-{
- // Stats
- mNbRayBVTests++;
-
-// float Dx = mOrigin.x - center.x; if(fabsf(Dx) > extents.x && Dx*mDir.x>=0.0f) return FALSE;
-// float Dy = mOrigin.y - center.y; if(fabsf(Dy) > extents.y && Dy*mDir.y>=0.0f) return FALSE;
-// float Dz = mOrigin.z - center.z; if(fabsf(Dz) > extents.z && Dz*mDir.z>=0.0f) return FALSE;
-
- float Dx = mOrigin.x - center.x; if(GREATER(Dx, extents.x) && Dx*mDir.x>=0.0f) return FALSE;
- float Dy = mOrigin.y - center.y; if(GREATER(Dy, extents.y) && Dy*mDir.y>=0.0f) return FALSE;
- float Dz = mOrigin.z - center.z; if(GREATER(Dz, extents.z) && Dz*mDir.z>=0.0f) return FALSE;
-
-// float Dx = mOrigin.x - center.x; if(GREATER(Dx, extents.x) && ((SIR(Dx)-1)^SIR(mDir.x))>=0.0f) return FALSE;
-// float Dy = mOrigin.y - center.y; if(GREATER(Dy, extents.y) && ((SIR(Dy)-1)^SIR(mDir.y))>=0.0f) return FALSE;
-// float Dz = mOrigin.z - center.z; if(GREATER(Dz, extents.z) && ((SIR(Dz)-1)^SIR(mDir.z))>=0.0f) return FALSE;
-
- float f;
- f = mDir.y * Dz - mDir.z * Dy; if(fabsf(f) > extents.y*mFDir.z + extents.z*mFDir.y) return FALSE;
- f = mDir.z * Dx - mDir.x * Dz; if(fabsf(f) > extents.x*mFDir.z + extents.z*mFDir.x) return FALSE;
- f = mDir.x * Dy - mDir.y * Dx; if(fabsf(f) > extents.x*mFDir.y + extents.y*mFDir.x) return FALSE;
-
- return TRUE;
-}
diff --git a/Opcode/OpcodeLib/OPC_RayCollider.cpp b/Opcode/OpcodeLib/OPC_RayCollider.cpp deleted file mode 100644 index b535bb7..0000000 --- a/Opcode/OpcodeLib/OPC_RayCollider.cpp +++ /dev/null @@ -1,762 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a ray collider.
- * \file OPC_RayCollider.cpp
- * \author Pierre Terdiman
- * \date June, 2, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains a ray-vs-tree collider.
- * This class performs a stabbing query on an AABB tree, i.e. does a ray-mesh collision.
- *
- * HIGHER DISTANCE BOUND:
- *
- * If P0 and P1 are two 3D points, let's define:
- * - d = distance between P0 and P1
- * - Origin = P0
- * - Direction = (P1 - P0) / d = normalized direction vector
- * - A parameter t such as a point P on the line (P0,P1) is P = Origin + t * Direction
- * - t = 0 --> P = P0
- * - t = d --> P = P1
- *
- * Then we can define a general "ray" as:
- *
- * struct Ray
- * {
- * IcePoint Origin;
- * IcePoint Direction;
- * };
- *
- * But it actually maps three different things:
- * - a segment, when 0 <= t <= d
- * - a half-line, when 0 <= t < +infinity, or -infinity < t <= d
- * - a line, when -infinity < t < +infinity
- *
- * In Opcode, we support segment queries, which yield half-line queries by setting d = +infinity.
- * We don't support line-queries. If you need them, shift the origin along the ray by an appropriate margin.
- *
- * In short, the lower bound is always 0, and you can setup the higher bound "d" with RayCollider::SetMaxDist().
- *
- * Query |segment |half-line |line
- * --------|-------------------|---------------|----------------
- * Usages |-shadow feelers |-raytracing |-
- * |-sweep tests |-in/out tests |
- *
- * FIRST CONTACT:
- *
- * - You can setup "first contact" mode or "all contacts" mode with RayCollider::SetFirstContact().
- * - In "first contact" mode we return as soon as the ray hits one face. If can be useful e.g. for shadow feelers, where
- * you want to know whether the path to the light is free or not (a boolean answer is enough).
- * - In "all contacts" mode we return all faces hit by the ray.
- *
- * TEMPORAL COHERENCE:
- *
- * - You can enable or disable temporal coherence with RayCollider::SetTemporalCoherence().
- * - It currently only works in "first contact" mode.
- * - If temporal coherence is enabled, the previously hit triangle is cached during the first query. Then, next queries
- * start by colliding the ray against the cached triangle. If they still collide, we return immediately.
- *
- * CLOSEST HIT:
- *
- * - You can enable or disable "closest hit" with RayCollider::SetClosestHit().
- * - It currently only works in "all contacts" mode.
- * - If closest hit is enabled, faces are sorted by distance on-the-fly and the closest one only is reported.
- *
- * BACKFACE CULLING:
- *
- * - You can enable or disable backface culling with RayCollider::SetCulling().
- * - If culling is enabled, ray will not hit back faces (only front faces).
- *
- *
- *
- * \class RayCollider
- * \author Pierre Terdiman
- * \version 1.3
- * \date June, 2, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * This class describes a face hit by a ray or segment.
- * This is a particular class dedicated to stabbing queries.
- *
- * \class CollisionFace
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * This class is a dedicated collection of CollisionFace.
- *
- * \class CollisionFaces
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-#include "OPC_RayAABBOverlap.h"
-#include "OPC_RayTriOverlap.h"
-
-#define SET_CONTACT(prim_index, flag) \
- mNbIntersections++; \
- /* Set contact status */ \
- mFlags |= flag; \
- /* In any case the contact has been found and recorded in mStabbedFace */ \
- mStabbedFace.mFaceID = prim_index;
-
-#ifdef OPC_RAYHIT_CALLBACK
-
- #define HANDLE_CONTACT(prim_index, flag) \
- SET_CONTACT(prim_index, flag) \
- \
- if(mHitCallback) (mHitCallback)(mStabbedFace, mUserData);
-
- #define UPDATE_CACHE \
- if(cache && GetContactStatus()) \
- { \
- *cache = mStabbedFace.mFaceID; \
- }
-#else
-
- #define HANDLE_CONTACT(prim_index, flag) \
- SET_CONTACT(prim_index, flag) \
- \
- /* Now we can also record it in mStabbedFaces if available */ \
- if(mStabbedFaces) \
- { \
- /* If we want all faces or if that's the first one we hit */ \
- if(!mClosestHit || !mStabbedFaces->GetNbFaces()) \
- { \
- mStabbedFaces->AddFace(mStabbedFace); \
- } \
- else \
- { \
- /* We only keep closest hit */ \
- CollisionFace* Current = const_cast<CollisionFace*>(mStabbedFaces->GetFaces()); \
- if(Current && mStabbedFace.mDistance<Current->mDistance) \
- { \
- *Current = mStabbedFace; \
- } \
- } \
- }
-
- #define UPDATE_CACHE \
- if(cache && GetContactStatus() && mStabbedFaces) \
- { \
- const CollisionFace* Current = mStabbedFaces->GetFaces(); \
- if(Current) *cache = Current->mFaceID; \
- else *cache = INVALID_ID; \
- }
-#endif
-
-#define SEGMENT_PRIM(prim_index, flag) \
- /* Request vertices from the app */ \
- VertexPointers VP; mIMesh->GetTriangle(VP, prim_index); \
- \
- /* Perform ray-tri overlap test and return */ \
- if(RayTriOverlap(*VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2])) \
- { \
- /* Intersection point is valid if dist < segment's length */ \
- /* We know dist>0 so we can use integers */ \
- if(IR(mStabbedFace.mDistance)<IR(mMaxDist)) \
- { \
- HANDLE_CONTACT(prim_index, flag) \
- } \
- }
-
-#define RAY_PRIM(prim_index, flag) \
- /* Request vertices from the app */ \
- VertexPointers VP; mIMesh->GetTriangle(VP, prim_index); \
- \
- /* Perform ray-tri overlap test and return */ \
- if(RayTriOverlap(*VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2])) \
- { \
- HANDLE_CONTACT(prim_index, flag) \
- }
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-RayCollider::RayCollider() :
- mNbRayBVTests (0),
- mNbRayPrimTests (0),
- mNbIntersections (0),
- mCulling (true),
-#ifdef OPC_RAYHIT_CALLBACK
- mHitCallback (null),
- mUserData (0),
-#else
- mClosestHit (false),
- mStabbedFaces (null),
-#endif
- mMaxDist (MAX_FLOAT)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-RayCollider::~RayCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Validates current settings. You should call this method after all the settings and callbacks have been defined.
- * \return null if everything is ok, else a string describing the problem
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const char* RayCollider::ValidateSettings()
-{
- if(mMaxDist<0.0f) return "Higher distance bound must be positive!";
- if(TemporalCoherenceEnabled() && !FirstContactEnabled()) return "Temporal coherence only works with ""First contact"" mode!";
-#ifndef OPC_RAYHIT_CALLBACK
- if(mClosestHit && FirstContactEnabled()) return "Closest hit doesn't work with ""First contact"" mode!";
- if(TemporalCoherenceEnabled() && mClosestHit) return "Temporal coherence can't guarantee to report closest hit!";
-#endif
- if(SkipPrimitiveTests()) return "SkipPrimitiveTests not possible for RayCollider ! (not implemented)";
- return null;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Generic stabbing query for generic OPCODE models. After the call, access the results:
- * - with GetContactStatus()
- * - in the user-provided destination array
- *
- * \param world_ray [in] stabbing ray in world space
- * \param model [in] Opcode model to collide with
- * \param world [in] model's world matrix, or null
- * \param cache [in] a possibly cached face index, or null
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool RayCollider::Collide(const Ray& world_ray, const Model& model, const Matrix4x4* world, udword* cache)
-{
- // Checkings
- if(!Setup(&model)) return false;
-
- // Init collision query
- if(InitQuery(world_ray, world, cache)) return true;
-
- if(!model.HasLeafNodes())
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform stabbing query
- if(IR(mMaxDist)!=IEEE_MAX_FLOAT) _SegmentStab(Tree->GetNodes());
- else _RayStab(Tree->GetNodes());
- }
- else
- {
- const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
-
- // Perform stabbing query
- if(IR(mMaxDist)!=IEEE_MAX_FLOAT) _SegmentStab(Tree->GetNodes());
- else _RayStab(Tree->GetNodes());
- }
- }
- else
- {
- if(model.IsQuantized())
- {
- const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
-
- // Setup dequantization coeffs
- mCenterCoeff = Tree->mCenterCoeff;
- mExtentsCoeff = Tree->mExtentsCoeff;
-
- // Perform stabbing query
- if(IR(mMaxDist)!=IEEE_MAX_FLOAT) _SegmentStab(Tree->GetNodes());
- else _RayStab(Tree->GetNodes());
- }
- else
- {
- const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
-
- // Perform stabbing query
- if(IR(mMaxDist)!=IEEE_MAX_FLOAT) _SegmentStab(Tree->GetNodes());
- else _RayStab(Tree->GetNodes());
- }
- }
-
- // Update cache if needed
- UPDATE_CACHE
- return true;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Initializes a stabbing query :
- * - reset stats & contact status
- * - compute ray in local space
- * - check temporal coherence
- *
- * \param world_ray [in] stabbing ray in world space
- * \param world [in] object's world matrix, or null
- * \param face_id [in] index of previously stabbed triangle
- * \return TRUE if we can return immediately
- * \warning SCALE NOT SUPPORTED. The matrix must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-BOOL RayCollider::InitQuery(const Ray& world_ray, const Matrix4x4* world, udword* face_id)
-{
- // Reset stats & contact status
- Collider::InitQuery();
- mNbRayBVTests = 0;
- mNbRayPrimTests = 0;
- mNbIntersections = 0;
-#ifndef OPC_RAYHIT_CALLBACK
- if(mStabbedFaces) mStabbedFaces->Reset();
-#endif
-
- // Compute ray in local space
- // The (Origin/Dir) form is needed for the ray-triangle test anyway (even for segment tests)
- if(world)
- {
- Matrix3x3 InvWorld = *world;
- mDir = InvWorld * world_ray.mDir;
-
- Matrix4x4 World;
- InvertPRMatrix(World, *world);
- mOrigin = world_ray.mOrig * World;
- }
- else
- {
- mDir = world_ray.mDir;
- mOrigin = world_ray.mOrig;
- }
-
- // 4) Special case: 1-triangle meshes [Opcode 1.3]
- if(mCurrentModel && mCurrentModel->HasSingleNode())
- {
- // We simply perform the BV-Prim overlap test each time. We assume single triangle has index 0.
- if(!SkipPrimitiveTests())
- {
- // Perform overlap test between the unique triangle and the ray (and set contact status if needed)
- SEGMENT_PRIM(udword(0), OPC_CONTACT)
-
- // Return immediately regardless of status
- return TRUE;
- }
- }
-
- // Check temporal coherence :
-
- // Test previously colliding primitives first
- if(TemporalCoherenceEnabled() && FirstContactEnabled() && face_id && *face_id!=INVALID_ID)
- {
-#ifdef OLD_CODE
-#ifndef OPC_RAYHIT_CALLBACK
- if(!mClosestHit)
-#endif
- {
- // Request vertices from the app
- VertexPointers VP;
- mIMesh->GetTriangle(VP, *face_id);
- // Perform ray-cached tri overlap test
- if(RayTriOverlap(*VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2]))
- {
- // Intersection point is valid if:
- // - distance is positive (else it can just be a face behind the orig point)
- // - distance is smaller than a given max distance (useful for shadow feelers)
-// if(mStabbedFace.mDistance>0.0f && mStabbedFace.mDistance<mMaxDist)
- if(IR(mStabbedFace.mDistance)<IR(mMaxDist)) // The other test is already performed in RayTriOverlap
- {
- // Set contact status
- mFlags |= OPC_TEMPORAL_CONTACT;
-
- mStabbedFace.mFaceID = *face_id;
-
-#ifndef OPC_RAYHIT_CALLBACK
- if(mStabbedFaces) mStabbedFaces->AddFace(mStabbedFace);
-#endif
- return TRUE;
- }
- }
- }
-#else
- // New code
- // We handle both Segment/ray queries with the same segment code, and a possible infinite limit
- SEGMENT_PRIM(*face_id, OPC_TEMPORAL_CONTACT)
-
- // Return immediately if possible
- if(GetContactStatus()) return TRUE;
-#endif
- }
-
- // Precompute data (moved after temporal coherence since only needed for ray-AABB)
- if(IR(mMaxDist)!=IEEE_MAX_FLOAT)
- {
- // For Segment-AABB overlap
- mData = 0.5f * mDir * mMaxDist;
- mData2 = mOrigin + mData;
-
- // Precompute mFDir;
- mFDir.x = fabsf(mData.x);
- mFDir.y = fabsf(mData.y);
- mFDir.z = fabsf(mData.z);
- }
- else
- {
- // For Ray-AABB overlap
-// udword x = SIR(mDir.x)-1;
-// udword y = SIR(mDir.y)-1;
-// udword z = SIR(mDir.z)-1;
-// mData.x = FR(x);
-// mData.y = FR(y);
-// mData.z = FR(z);
-
- // Precompute mFDir;
- mFDir.x = fabsf(mDir.x);
- mFDir.y = fabsf(mDir.y);
- mFDir.z = fabsf(mDir.z);
- }
-
- return FALSE;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Stabbing query for vanilla AABB trees.
- * \param world_ray [in] stabbing ray in world space
- * \param tree [in] AABB tree
- * \param box_indices [out] indices of stabbed boxes
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool RayCollider::Collide(const Ray& world_ray, const AABBTree* tree, Container& box_indices)
-{
- // ### bad design here
-
- // This is typically called for a scene tree, full of -AABBs-, not full of triangles.
- // So we don't really have "primitives" to deal with. Hence it doesn't work with
- // "FirstContact" + "TemporalCoherence".
- ASSERT( !(FirstContactEnabled() && TemporalCoherenceEnabled()) );
-
- // Checkings
- if(!tree) return false;
-
- // Init collision query
- // Basically this is only called to initialize precomputed data
- if(InitQuery(world_ray)) return true;
-
- // Perform stabbing query
- if(IR(mMaxDist)!=IEEE_MAX_FLOAT) _SegmentStab(tree, box_indices);
- else _RayStab(tree, box_indices);
-
- return true;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for normal AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_SegmentStab(const AABBCollisionNode* node)
-{
- // Perform Segment-AABB overlap test
- if(!SegmentAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents)) return;
-
- if(node->IsLeaf())
- {
- SEGMENT_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _SegmentStab(node->GetPos());
-
- if(ContactFound()) return;
-
- _SegmentStab(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for quantized AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_SegmentStab(const AABBQuantizedNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform Segment-AABB overlap test
- if(!SegmentAABBOverlap(Center, Extents)) return;
-
- if(node->IsLeaf())
- {
- SEGMENT_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _SegmentStab(node->GetPos());
-
- if(ContactFound()) return;
-
- _SegmentStab(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_SegmentStab(const AABBNoLeafNode* node)
-{
- // Perform Segment-AABB overlap test
- if(!SegmentAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents)) return;
-
- if(node->HasPosLeaf())
- {
- SEGMENT_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
- }
- else _SegmentStab(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf())
- {
- SEGMENT_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
- }
- else _SegmentStab(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for quantized no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_SegmentStab(const AABBQuantizedNoLeafNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform Segment-AABB overlap test
- if(!SegmentAABBOverlap(Center, Extents)) return;
-
- if(node->HasPosLeaf())
- {
- SEGMENT_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
- }
- else _SegmentStab(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf())
- {
- SEGMENT_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
- }
- else _SegmentStab(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for vanilla AABB trees.
- * \param node [in] current collision node
- * \param box_indices [out] indices of stabbed boxes
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_SegmentStab(const AABBTreeNode* node, Container& box_indices)
-{
- // Test the box against the segment
- IcePoint Center, Extents;
- node->GetAABB()->GetCenter(Center);
- node->GetAABB()->GetExtents(Extents);
- if(!SegmentAABBOverlap(Center, Extents)) return;
-
- if(node->IsLeaf())
- {
- box_indices.Add(node->GetPrimitives(), node->GetNbPrimitives());
- }
- else
- {
- _SegmentStab(node->GetPos(), box_indices);
- _SegmentStab(node->GetNeg(), box_indices);
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for normal AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_RayStab(const AABBCollisionNode* node)
-{
- // Perform Ray-AABB overlap test
- if(!RayAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents)) return;
-
- if(node->IsLeaf())
- {
- RAY_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _RayStab(node->GetPos());
-
- if(ContactFound()) return;
-
- _RayStab(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for quantized AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_RayStab(const AABBQuantizedNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform Ray-AABB overlap test
- if(!RayAABBOverlap(Center, Extents)) return;
-
- if(node->IsLeaf())
- {
- RAY_PRIM(node->GetPrimitive(), OPC_CONTACT)
- }
- else
- {
- _RayStab(node->GetPos());
-
- if(ContactFound()) return;
-
- _RayStab(node->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_RayStab(const AABBNoLeafNode* node)
-{
- // Perform Ray-AABB overlap test
- if(!RayAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents)) return;
-
- if(node->HasPosLeaf())
- {
- RAY_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
- }
- else _RayStab(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf())
- {
- RAY_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
- }
- else _RayStab(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for quantized no-leaf AABB trees.
- * \param node [in] current collision node
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_RayStab(const AABBQuantizedNoLeafNode* node)
-{
- // Dequantize box
- const QuantizedAABB& Box = node->mAABB;
- const IcePoint Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
- const IcePoint Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
-
- // Perform Ray-AABB overlap test
- if(!RayAABBOverlap(Center, Extents)) return;
-
- if(node->HasPosLeaf())
- {
- RAY_PRIM(node->GetPosPrimitive(), OPC_CONTACT)
- }
- else _RayStab(node->GetPos());
-
- if(ContactFound()) return;
-
- if(node->HasNegLeaf())
- {
- RAY_PRIM(node->GetNegPrimitive(), OPC_CONTACT)
- }
- else _RayStab(node->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive stabbing query for vanilla AABB trees.
- * \param node [in] current collision node
- * \param box_indices [out] indices of stabbed boxes
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void RayCollider::_RayStab(const AABBTreeNode* node, Container& box_indices)
-{
- // Test the box against the ray
- IcePoint Center, Extents;
- node->GetAABB()->GetCenter(Center);
- node->GetAABB()->GetExtents(Extents);
- if(!RayAABBOverlap(Center, Extents)) return;
-
- if(node->IsLeaf())
- {
- mFlags |= OPC_CONTACT;
- box_indices.Add(node->GetPrimitives(), node->GetNbPrimitives());
- }
- else
- {
- _RayStab(node->GetPos(), box_indices);
- _RayStab(node->GetNeg(), box_indices);
- }
-}
diff --git a/Opcode/OpcodeLib/OPC_RayCollider.h b/Opcode/OpcodeLib/OPC_RayCollider.h deleted file mode 100644 index 64dc2b4..0000000 --- a/Opcode/OpcodeLib/OPC_RayCollider.h +++ /dev/null @@ -1,225 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a ray collider.
- * \file OPC_RayCollider.h
- * \author Pierre Terdiman
- * \date June, 2, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_RAYCOLLIDER_H__
-#define __OPC_RAYCOLLIDER_H__
-
- class OPCODE_API CollisionFace
- {
- public:
- //! Constructor
- inline_ CollisionFace() {}
- //! Destructor
- inline_ ~CollisionFace() {}
-
- udword mFaceID; //!< Index of touched face
- float mDistance; //!< Distance from collider to hitpoint
- float mU, mV; //!< Impact barycentric coordinates
- };
-
- class OPCODE_API CollisionFaces : private Container
- {
- public:
- //! Constructor
- CollisionFaces() {}
- //! Destructor
- ~CollisionFaces() {}
-
- inline_ udword GetNbFaces() const { return GetNbEntries()>>2; }
- inline_ const CollisionFace* GetFaces() const { return (const CollisionFace*)GetEntries(); }
-
- inline_ void Reset() { Container::Reset(); }
-
- inline_ void AddFace(const CollisionFace& face) { Add(face.mFaceID).Add(face.mDistance).Add(face.mU).Add(face.mV); }
- };
-
-#ifdef OPC_RAYHIT_CALLBACK
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * User-callback, called by OPCODE to record a hit.
- * \param hit [in] current hit
- * \param user_data [in] user-defined data from SetCallback()
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- typedef void (*HitCallback) (const CollisionFace& hit, void* user_data);
-#endif
-
- class OPCODE_API RayCollider : public Collider
- {
- public:
- // Constructor / Destructor
- RayCollider();
- virtual ~RayCollider();
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Generic stabbing query for generic OPCODE models. After the call, access the results:
- * - with GetContactStatus()
- * - in the user-provided destination array
- *
- * \param world_ray [in] stabbing ray in world space
- * \param model [in] Opcode model to collide with
- * \param world [in] model's world matrix, or null
- * \param cache [in] a possibly cached face index, or null
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool Collide(const Ray& world_ray, const Model& model, const Matrix4x4* world=null, udword* cache=null);
- //
- bool Collide(const Ray& world_ray, const AABBTree* tree, Container& box_indices);
- // Settings
-
-#ifndef OPC_RAYHIT_CALLBACK
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: enable or disable "closest hit" mode.
- * \param flag [in] true to report closest hit only
- * \see SetCulling(bool flag)
- * \see SetMaxDist(float max_dist)
- * \see SetDestination(StabbedFaces* sf)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetClosestHit(bool flag) { mClosestHit = flag; }
-#endif
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: enable or disable backface culling.
- * \param flag [in] true to enable backface culling
- * \see SetClosestHit(bool flag)
- * \see SetMaxDist(float max_dist)
- * \see SetDestination(StabbedFaces* sf)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetCulling(bool flag) { mCulling = flag; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: sets the higher distance bound.
- * \param max_dist [in] higher distance bound. Default = maximal value, for ray queries (else segment)
- * \see SetClosestHit(bool flag)
- * \see SetCulling(bool flag)
- * \see SetDestination(StabbedFaces* sf)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetMaxDist(float max_dist=MAX_FLOAT) { mMaxDist = max_dist; }
-
-#ifdef OPC_RAYHIT_CALLBACK
- inline_ void SetHitCallback(HitCallback cb) { mHitCallback = cb; }
- inline_ void SetUserData(void* user_data) { mUserData = user_data; }
-#else
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: sets the destination array for stabbed faces.
- * \param cf [in] destination array, filled during queries
- * \see SetClosestHit(bool flag)
- * \see SetCulling(bool flag)
- * \see SetMaxDist(float max_dist)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetDestination(CollisionFaces* cf) { mStabbedFaces = cf; }
-#endif
- // Stats
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of Ray-BV overlap tests after a collision query.
- * \see GetNbRayPrimTests()
- * \see GetNbIntersections()
- * \return the number of Ray-BV tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbRayBVTests() const { return mNbRayBVTests; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of Ray-Triangle overlap tests after a collision query.
- * \see GetNbRayBVTests()
- * \see GetNbIntersections()
- * \return the number of Ray-Triangle tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbRayPrimTests() const { return mNbRayPrimTests; }
-
- // In-out test
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of intersection found after a collision query. Can be used for in/out tests.
- * \see GetNbRayBVTests()
- * \see GetNbRayPrimTests()
- * \return the number of valid intersections during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbIntersections() const { return mNbIntersections; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Validates current settings. You should call this method after all the settings and callbacks have been defined for a collider.
- * \return null if everything is ok, else a string describing the problem
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(Collider) const char* ValidateSettings();
-
- protected:
- // Ray in local space
- IcePoint mOrigin; //!< Ray origin
- IcePoint mDir; //!< Ray direction (normalized)
- IcePoint mFDir; //!< fabsf(mDir)
- IcePoint mData, mData2;
- // Stabbed faces
- CollisionFace mStabbedFace; //!< Current stabbed face
-#ifdef OPC_RAYHIT_CALLBACK
- HitCallback mHitCallback; //!< Callback used to record a hit
- void* mUserData; //!< User-defined data
-#else
- CollisionFaces* mStabbedFaces; //!< List of stabbed faces
-#endif
- // Stats
- udword mNbRayBVTests; //!< Number of Ray-BV tests
- udword mNbRayPrimTests; //!< Number of Ray-Primitive tests
- // In-out test
- udword mNbIntersections; //!< Number of valid intersections
- // Dequantization coeffs
- IcePoint mCenterCoeff;
- IcePoint mExtentsCoeff;
- // Settings
- float mMaxDist; //!< Valid segment on the ray
-#ifndef OPC_RAYHIT_CALLBACK
- bool mClosestHit; //!< Report closest hit only
-#endif
- bool mCulling; //!< Stab culled faces or not
- // Internal methods
- void _SegmentStab(const AABBCollisionNode* node);
- void _SegmentStab(const AABBNoLeafNode* node);
- void _SegmentStab(const AABBQuantizedNode* node);
- void _SegmentStab(const AABBQuantizedNoLeafNode* node);
- void _SegmentStab(const AABBTreeNode* node, Container& box_indices);
- void _RayStab(const AABBCollisionNode* node);
- void _RayStab(const AABBNoLeafNode* node);
- void _RayStab(const AABBQuantizedNode* node);
- void _RayStab(const AABBQuantizedNoLeafNode* node);
- void _RayStab(const AABBTreeNode* node, Container& box_indices);
- // Overlap tests
- inline_ BOOL RayAABBOverlap(const IcePoint& center, const IcePoint& extents);
- inline_ BOOL SegmentAABBOverlap(const IcePoint& center, const IcePoint& extents);
- inline_ BOOL RayTriOverlap(const IcePoint& vert0, const IcePoint& vert1, const IcePoint& vert2);
- // Init methods
- BOOL InitQuery(const Ray& world_ray, const Matrix4x4* world=null, udword* face_id=null);
- };
-
-#endif // __OPC_RAYCOLLIDER_H__
diff --git a/Opcode/OpcodeLib/OPC_RayTriOverlap.h b/Opcode/OpcodeLib/OPC_RayTriOverlap.h deleted file mode 100644 index 6c65df1..0000000 --- a/Opcode/OpcodeLib/OPC_RayTriOverlap.h +++ /dev/null @@ -1,89 +0,0 @@ -#define LOCAL_EPSILON 0.000001f
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes a ray-triangle intersection test.
- * Original code from Tomas Möller's "Fast Minimum Storage Ray-Triangle Intersection".
- * It's been optimized a bit with integer code, and modified to return a non-intersection if distance from
- * ray origin to triangle is negative.
- *
- * \param vert0 [in] triangle vertex
- * \param vert1 [in] triangle vertex
- * \param vert2 [in] triangle vertex
- * \return true on overlap. mStabbedFace is filled with relevant info.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL RayCollider::RayTriOverlap(const IcePoint& vert0, const IcePoint& vert1, const IcePoint& vert2)
-{
- // Stats
- mNbRayPrimTests++;
-
- // Find vectors for two edges sharing vert0
- IcePoint edge1 = vert1 - vert0;
- IcePoint edge2 = vert2 - vert0;
-
- // Begin calculating determinant - also used to calculate U parameter
- IcePoint pvec = mDir^edge2;
-
- // If determinant is near zero, ray lies in plane of triangle
- float det = edge1|pvec;
-
- if(mCulling)
- {
- if(det<LOCAL_EPSILON) return FALSE;
- // From here, det is > 0. So we can use integer cmp.
-
- // Calculate distance from vert0 to ray origin
- IcePoint tvec = mOrigin - vert0;
-
- // Calculate U parameter and test bounds
- mStabbedFace.mU = tvec|pvec;
-// if(IR(u)&0x80000000 || u>det) return FALSE;
- if(IS_NEGATIVE_FLOAT(mStabbedFace.mU) || IR(mStabbedFace.mU)>IR(det)) return FALSE;
-
- // Prepare to test V parameter
- IcePoint qvec = tvec^edge1;
-
- // Calculate V parameter and test bounds
- mStabbedFace.mV = mDir|qvec;
- if(IS_NEGATIVE_FLOAT(mStabbedFace.mV) || mStabbedFace.mU+mStabbedFace.mV>det) return FALSE;
-
- // Calculate t, scale parameters, ray intersects triangle
- mStabbedFace.mDistance = edge2|qvec;
- // Det > 0 so we can early exit here
- // Intersection point is valid if distance is positive (else it can just be a face behind the orig point)
- if(IS_NEGATIVE_FLOAT(mStabbedFace.mDistance)) return FALSE;
- // Else go on
- float OneOverDet = 1.0f / det;
- mStabbedFace.mDistance *= OneOverDet;
- mStabbedFace.mU *= OneOverDet;
- mStabbedFace.mV *= OneOverDet;
- }
- else
- {
- // the non-culling branch
- if(det>-LOCAL_EPSILON && det<LOCAL_EPSILON) return FALSE;
- float OneOverDet = 1.0f / det;
-
- // Calculate distance from vert0 to ray origin
- IcePoint tvec = mOrigin - vert0;
-
- // Calculate U parameter and test bounds
- mStabbedFace.mU = (tvec|pvec) * OneOverDet;
-// if(IR(u)&0x80000000 || u>1.0f) return FALSE;
- if(IS_NEGATIVE_FLOAT(mStabbedFace.mU) || IR(mStabbedFace.mU)>IEEE_1_0) return FALSE;
-
- // prepare to test V parameter
- IcePoint qvec = tvec^edge1;
-
- // Calculate V parameter and test bounds
- mStabbedFace.mV = (mDir|qvec) * OneOverDet;
- if(IS_NEGATIVE_FLOAT(mStabbedFace.mV) || mStabbedFace.mU+mStabbedFace.mV>1.0f) return FALSE;
-
- // Calculate t, ray intersects triangle
- mStabbedFace.mDistance = (edge2|qvec) * OneOverDet;
- // Intersection point is valid if distance is positive (else it can just be a face behind the orig point)
- if(IS_NEGATIVE_FLOAT(mStabbedFace.mDistance)) return FALSE;
- }
- return TRUE;
-}
diff --git a/Opcode/OpcodeLib/OPC_Settings.h b/Opcode/OpcodeLib/OPC_Settings.h deleted file mode 100644 index 8232d9b..0000000 --- a/Opcode/OpcodeLib/OPC_Settings.h +++ /dev/null @@ -1,49 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains compilation flags.
- * \file OPC_Settings.h
- * \author Pierre Terdiman
- * \date May, 12, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_SETTINGS_H__
-#define __OPC_SETTINGS_H__
-
- //! Use CPU comparisons (comment that line to use standard FPU compares)
- #define OPC_CPU_COMPARE
-
- //! Use FCOMI / FCMOV on Pentium-Pro based processors (comment that line to use plain C++)
- #define OPC_USE_FCOMI
-
- //! Use epsilon value in tri-tri overlap test
- #define OPC_TRITRI_EPSILON_TEST
-
- //! Use tree-coherence or not [not implemented yet]
-// #define OPC_USE_TREE_COHERENCE
-
- //! Use callbacks or direct pointers. Using callbacks might be a bit slower (but probably not much)
-// #define OPC_USE_CALLBACKS
-
- //! Support triangle and vertex strides or not. Using strides might be a bit slower (but probably not much)
-// #define OPC_USE_STRIDE
-
- //! Discard negative pointer in vanilla trees
- #define OPC_NO_NEG_VANILLA_TREE
-
- //! Use a callback in the ray collider
- #define OPC_RAYHIT_CALLBACK
-
- // NB: no compilation flag to enable/disable stats since they're actually needed in the box/box overlap test
-
-#endif //__OPC_SETTINGS_H__
\ No newline at end of file diff --git a/Opcode/OpcodeLib/OPC_TreeBuilders.cpp b/Opcode/OpcodeLib/OPC_TreeBuilders.cpp deleted file mode 100644 index fa415db..0000000 --- a/Opcode/OpcodeLib/OPC_TreeBuilders.cpp +++ /dev/null @@ -1,255 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for tree builders.
- * \file OPC_TreeBuilders.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A builder for AABB-trees of vertices.
- *
- * \class AABBTreeOfVerticesBuilder
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A builder for AABB-trees of AABBs.
- *
- * \class AABBTreeOfAABBsBuilder
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * A builder for AABB-trees of triangles.
- *
- * \class AABBTreeOfTrianglesBuilder
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the AABB of a set of primitives.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [out] global AABB enclosing the set of input primitives
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeOfAABBsBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
-{
- // Checkings
- if(!primitives || !nb_prims) return false;
-
- // Initialize global box
- global_box = mAABBArray[primitives[0]];
-
- // Loop through boxes
- for(udword i=1;i<nb_prims;i++)
- {
- // Update global box
- global_box.Add(mAABBArray[primitives[i]]);
- }
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the splitting value along a given axis for a given primitive.
- * \param index [in] index of the primitive to split
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfAABBsBuilder::GetSplittingValue(udword index, udword axis) const
-{
- // For an AABB, the splitting value is the middle of the given axis,
- // i.e. the corresponding component of the center point
- return mAABBArray[index].GetCenter(axis);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the AABB of a set of primitives.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [out] global AABB enclosing the set of input primitives
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeOfTrianglesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
-{
- // Checkings
- if(!primitives || !nb_prims) return false;
-
- // Initialize global box
- IcePoint Min(MAX_FLOAT, MAX_FLOAT, MAX_FLOAT);
- IcePoint Max(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
-
- // Loop through triangles
- VertexPointers VP;
- while(nb_prims--)
- {
- // Get current triangle-vertices
- mIMesh->GetTriangle(VP, *primitives++);
- // Update global box
- Min.Min(*VP.Vertex[0]).Min(*VP.Vertex[1]).Min(*VP.Vertex[2]);
- Max.Max(*VP.Vertex[0]).Max(*VP.Vertex[1]).Max(*VP.Vertex[2]);
- }
- global_box.SetMinMax(Min, Max);
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the splitting value along a given axis for a given primitive.
- * \param index [in] index of the primitive to split
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfTrianglesBuilder::GetSplittingValue(udword index, udword axis) const
-{
-/* // Compute center of triangle
- IcePoint Center;
- mTriList[index].Center(mVerts, Center);
- // Return value
- return Center[axis];*/
-
- // Compute correct component from center of triangle
-// return (mVerts[mTriList[index].mVRef[0]][axis]
-// +mVerts[mTriList[index].mVRef[1]][axis]
-// +mVerts[mTriList[index].mVRef[2]][axis])*INV3;
-
- VertexPointers VP;
- mIMesh->GetTriangle(VP, index);
-
- // Compute correct component from center of triangle
- return ((*VP.Vertex[0])[axis]
- +(*VP.Vertex[1])[axis]
- +(*VP.Vertex[2])[axis])*INV3;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the splitting value along a given axis for a given node.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [in] global AABB enclosing the set of input primitives
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfTrianglesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis) const
-{
- if(mSettings.mRules&SPLIT_GEOM_CENTER)
- {
- // Loop through triangles
- float SplitValue = 0.0f;
- VertexPointers VP;
- for(udword i=0;i<nb_prims;i++)
- {
- // Get current triangle-vertices
- mIMesh->GetTriangle(VP, primitives[i]);
- // Update split value
- SplitValue += (*VP.Vertex[0])[axis];
- SplitValue += (*VP.Vertex[1])[axis];
- SplitValue += (*VP.Vertex[2])[axis];
- }
- return SplitValue / float(nb_prims*3);
- }
- else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the AABB of a set of primitives.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [out] global AABB enclosing the set of input primitives
- * \return true if success
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeOfVerticesBuilder::ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const
-{
- // Checkings
- if(!primitives || !nb_prims) return false;
-
- // Initialize global box
- global_box.SetEmpty();
-
- // Loop through vertices
- for(udword i=0;i<nb_prims;i++)
- {
- // Update global box
- global_box.Extend(mVertexArray[primitives[i]]);
- }
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the splitting value along a given axis for a given primitive.
- * \param index [in] index of the primitive to split
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfVerticesBuilder::GetSplittingValue(udword index, udword axis) const
-{
- // For a vertex, the splitting value is simply the vertex coordinate.
- return mVertexArray[index][axis];
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Computes the splitting value along a given axis for a given node.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [in] global AABB enclosing the set of input primitives
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-float AABBTreeOfVerticesBuilder::GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis) const
-{
- if(mSettings.mRules&SPLIT_GEOM_CENTER)
- {
- // Loop through vertices
- float SplitValue = 0.0f;
- for(udword i=0;i<nb_prims;i++)
- {
- // Update split value
- SplitValue += mVertexArray[primitives[i]][axis];
- }
- return SplitValue / float(nb_prims);
- }
- else return AABBTreeBuilder::GetSplittingValue(primitives, nb_prims, global_box, axis);
-}
diff --git a/Opcode/OpcodeLib/OPC_TreeBuilders.h b/Opcode/OpcodeLib/OPC_TreeBuilders.h deleted file mode 100644 index bfff16a..0000000 --- a/Opcode/OpcodeLib/OPC_TreeBuilders.h +++ /dev/null @@ -1,173 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for tree builders.
- * \file OPC_TreeBuilders.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_TREEBUILDERS_H__
-#define __OPC_TREEBUILDERS_H__
-
- //! Tree splitting rules
- enum SplittingRules
- {
- // Primitive split
- SPLIT_LARGEST_AXIS = (1<<0), //!< Split along the largest axis
- SPLIT_SPLATTER_POINTS = (1<<1), //!< Splatter primitive centers (QuickCD-style)
- SPLIT_BEST_AXIS = (1<<2), //!< Try largest axis, then second, then last
- SPLIT_BALANCED = (1<<3), //!< Try to keep a well-balanced tree
- SPLIT_FIFTY = (1<<4), //!< Arbitrary 50-50 split
- // Node split
- SPLIT_GEOM_CENTER = (1<<5), //!< Split at geometric center (else split in the middle)
- //
- SPLIT_FORCE_DWORD = 0x7fffffff
- };
-
- //! Simple wrapper around build-related settings [Opcode 1.3]
- struct OPCODE_API BuildSettings
- {
- inline_ BuildSettings() : mLimit(1), mRules(SPLIT_FORCE_DWORD) {}
-
- udword mLimit; //!< Limit number of primitives / node. If limit is 1, build a complete tree (2*N-1 nodes)
- udword mRules; //!< Building/Splitting rules (a combination of SplittingRules flags)
- };
-
- class OPCODE_API AABBTreeBuilder
- {
- public:
- //! Constructor
- AABBTreeBuilder() :
- mNbPrimitives(0),
- mNodeBase(null),
- mCount(0),
- mNbInvalidSplits(0) {}
- //! Destructor
- virtual ~AABBTreeBuilder() {}
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the AABB of a set of primitives.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [out] global AABB enclosing the set of input primitives
- * \return true if success
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual bool ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const = 0;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the splitting value along a given axis for a given primitive.
- * \param index [in] index of the primitive to split
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual float GetSplittingValue(udword index, udword axis) const = 0;
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Computes the splitting value along a given axis for a given node.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [in] global AABB enclosing the set of input primitives
- * \param axis [in] axis index (0,1,2)
- * \return splitting value
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual float GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis) const
- {
- // Default split value = middle of the axis (using only the box)
- return global_box.GetCenter(axis);
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Validates node subdivision. This is called each time a node is considered for subdivision, during tree building.
- * \param primitives [in] list of indices of primitives
- * \param nb_prims [in] number of indices
- * \param global_box [in] global AABB enclosing the set of input primitives
- * \return TRUE if the node should be subdivised
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- virtual BOOL ValidateSubdivision(const udword* primitives, udword nb_prims, const AABB& global_box)
- {
- // Check the user-defined limit
- if(nb_prims<=mSettings.mLimit) return FALSE;
-
- return TRUE;
- }
-
- BuildSettings mSettings; //!< Splitting rules & split limit [Opcode 1.3]
- udword mNbPrimitives; //!< Total number of primitives.
- void* mNodeBase; //!< Address of node pool [Opcode 1.3]
- // Stats
- inline_ void SetCount(udword nb) { mCount=nb; }
- inline_ void IncreaseCount(udword nb) { mCount+=nb; }
- inline_ udword GetCount() const { return mCount; }
- inline_ void SetNbInvalidSplits(udword nb) { mNbInvalidSplits=nb; }
- inline_ void IncreaseNbInvalidSplits() { mNbInvalidSplits++; }
- inline_ udword GetNbInvalidSplits() const { return mNbInvalidSplits; }
-
- private:
- udword mCount; //!< Stats: number of nodes created
- udword mNbInvalidSplits; //!< Stats: number of invalid splits
- };
-
- class OPCODE_API AABBTreeOfVerticesBuilder : public AABBTreeBuilder
- {
- public:
- //! Constructor
- AABBTreeOfVerticesBuilder() : mVertexArray(null) {}
- //! Destructor
- virtual ~AABBTreeOfVerticesBuilder() {}
-
- override(AABBTreeBuilder) bool ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const;
- override(AABBTreeBuilder) float GetSplittingValue(udword index, udword axis) const;
- override(AABBTreeBuilder) float GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis) const;
-
- const IcePoint* mVertexArray; //!< Shortcut to an app-controlled array of vertices.
- };
-
- class OPCODE_API AABBTreeOfAABBsBuilder : public AABBTreeBuilder
- {
- public:
- //! Constructor
- AABBTreeOfAABBsBuilder() : mAABBArray(null) {}
- //! Destructor
- virtual ~AABBTreeOfAABBsBuilder() {}
-
- override(AABBTreeBuilder) bool ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const;
- override(AABBTreeBuilder) float GetSplittingValue(udword index, udword axis) const;
-
- const AABB* mAABBArray; //!< Shortcut to an app-controlled array of AABBs.
- };
-
- class OPCODE_API AABBTreeOfTrianglesBuilder : public AABBTreeBuilder
- {
- public:
- //! Constructor
- AABBTreeOfTrianglesBuilder() : mIMesh(null) {}
- //! Destructor
- virtual ~AABBTreeOfTrianglesBuilder() {}
-
- override(AABBTreeBuilder) bool ComputeGlobalBox(const udword* primitives, udword nb_prims, AABB& global_box) const;
- override(AABBTreeBuilder) float GetSplittingValue(udword index, udword axis) const;
- override(AABBTreeBuilder) float GetSplittingValue(const udword* primitives, udword nb_prims, const AABB& global_box, udword axis) const;
-
- const MeshInterface* mIMesh; //!< Shortcut to an app-controlled mesh interface
- };
-
-#endif // __OPC_TREEBUILDERS_H__
diff --git a/Opcode/OpcodeLib/OPC_TreeCollider.cpp b/Opcode/OpcodeLib/OPC_TreeCollider.cpp deleted file mode 100644 index f8c0ca3..0000000 --- a/Opcode/OpcodeLib/OPC_TreeCollider.cpp +++ /dev/null @@ -1,943 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a tree collider.
- * \file OPC_TreeCollider.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains an AABB tree collider.
- * This class performs a collision test between two AABB trees.
- *
- * \class AABBTreeCollider
- * \author Pierre Terdiman
- * \version 1.3
- * \date March, 20, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-#include "OPC_BoxBoxOverlap.h"
-#include "OPC_TriBoxOverlap.h"
-#include "OPC_TriTriOverlap.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBTreeCollider::AABBTreeCollider() :
- mNbBVBVTests (0),
- mNbPrimPrimTests (0),
- mNbBVPrimTests (0),
- mFullBoxBoxTest (true),
- mFullPrimBoxTest (true),
- mIMesh0 (null),
- mIMesh1 (null)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AABBTreeCollider::~AABBTreeCollider()
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Validates current settings. You should call this method after all the settings and callbacks have been defined.
- * \return null if everything is ok, else a string describing the problem
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const char* AABBTreeCollider::ValidateSettings()
-{
- if(TemporalCoherenceEnabled() && !FirstContactEnabled()) return "Temporal coherence only works with ""First contact"" mode!";
- return null;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Generic collision query for generic OPCODE models. After the call, access the results with:
- * - GetContactStatus()
- * - GetNbPairs()
- * - GetPairs()
- *
- * \param cache [in] collision cache for model pointers and a colliding pair of primitives
- * \param world0 [in] world matrix for first object
- * \param world1 [in] world matrix for second object
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeCollider::Collide(BVTCache& cache, const Matrix4x4* world0, const Matrix4x4* world1)
-{
- // Checkings
- if(!cache.Model0 || !cache.Model1) return false;
- if(cache.Model0->HasLeafNodes()!=cache.Model1->HasLeafNodes()) return false;
- if(cache.Model0->IsQuantized()!=cache.Model1->IsQuantized()) return false;
-
- /*
-
- Rules:
- - perform hull test
- - when hulls collide, disable hull test
- - if meshes overlap, reset countdown
- - if countdown reaches 0, enable hull test
-
- */
-
-#ifdef __MESHMERIZER_H__
- // Handle hulls
- if(cache.HullTest)
- {
- if(cache.Model0->GetHull() && cache.Model1->GetHull())
- {
- struct Local
- {
- static IcePoint* SVCallback(const IcePoint& sv, udword& previndex, udword user_data)
- {
- CollisionHull* Hull = (CollisionHull*)user_data;
- previndex = Hull->ComputeSupportingVertex(sv, previndex);
- return (IcePoint*)&Hull->GetVerts()[previndex];
- }
- };
-
- bool Collide;
-
- if(0)
- {
- static GJKEngine GJK;
- static bool GJKInitDone=false;
- if(!GJKInitDone)
- {
- GJK.Enable(GJK_BACKUP_PROCEDURE);
- GJK.Enable(GJK_DEGENERATE);
- GJK.Enable(GJK_HILLCLIMBING);
- GJKInitDone = true;
- }
- GJK.SetCallbackObj0(Local::SVCallback);
- GJK.SetCallbackObj1(Local::SVCallback);
- GJK.SetUserData0(udword(cache.Model0->GetHull()));
- GJK.SetUserData1(udword(cache.Model1->GetHull()));
- Collide = GJK.Collide(*world0, *world1, &cache.SepVector);
- }
- else
- {
- static SVEngine SVE;
- SVE.SetCallbackObj0(Local::SVCallback);
- SVE.SetCallbackObj1(Local::SVCallback);
- SVE.SetUserData0(udword(cache.Model0->GetHull()));
- SVE.SetUserData1(udword(cache.Model1->GetHull()));
- Collide = SVE.Collide(*world0, *world1, &cache.SepVector);
- }
-
- if(!Collide)
- {
- // Reset stats & contact status
- mFlags &= ~OPC_CONTACT;
- mNbBVBVTests = 0;
- mNbPrimPrimTests = 0;
- mNbBVPrimTests = 0;
- mPairs.Reset();
- return true;
- }
- }
- }
-
- // Here, hulls collide
- cache.HullTest = false;
-#endif // __MESHMERIZER_H__
-
- // Checkings
- if(!Setup(cache.Model0->GetMeshInterface(), cache.Model1->GetMeshInterface())) return false;
-
- // Simple double-dispatch
- bool Status;
- if(!cache.Model0->HasLeafNodes())
- {
- if(cache.Model0->IsQuantized())
- {
- const AABBQuantizedNoLeafTree* T0 = (const AABBQuantizedNoLeafTree*)cache.Model0->GetTree();
- const AABBQuantizedNoLeafTree* T1 = (const AABBQuantizedNoLeafTree*)cache.Model1->GetTree();
- Status = Collide(T0, T1, world0, world1, &cache);
- }
- else
- {
- const AABBNoLeafTree* T0 = (const AABBNoLeafTree*)cache.Model0->GetTree();
- const AABBNoLeafTree* T1 = (const AABBNoLeafTree*)cache.Model1->GetTree();
- Status = Collide(T0, T1, world0, world1, &cache);
- }
- }
- else
- {
- if(cache.Model0->IsQuantized())
- {
- const AABBQuantizedTree* T0 = (const AABBQuantizedTree*)cache.Model0->GetTree();
- const AABBQuantizedTree* T1 = (const AABBQuantizedTree*)cache.Model1->GetTree();
- Status = Collide(T0, T1, world0, world1, &cache);
- }
- else
- {
- const AABBCollisionTree* T0 = (const AABBCollisionTree*)cache.Model0->GetTree();
- const AABBCollisionTree* T1 = (const AABBCollisionTree*)cache.Model1->GetTree();
- Status = Collide(T0, T1, world0, world1, &cache);
- }
- }
-
-#ifdef __MESHMERIZER_H__
- if(Status)
- {
- // Reset counter as long as overlap occurs
- if(GetContactStatus()) cache.ResetCountDown();
-
- // Enable hull test again when counter reaches zero
- cache.CountDown--;
- if(!cache.CountDown)
- {
- cache.ResetCountDown();
- cache.HullTest = true;
- }
- }
-#endif
- return Status;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Initializes a collision query :
- * - reset stats & contact status
- * - setup matrices
- *
- * \param world0 [in] world matrix for first object
- * \param world1 [in] world matrix for second object
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::InitQuery(const Matrix4x4* world0, const Matrix4x4* world1)
-{
- // Reset stats & contact status
- Collider::InitQuery();
- mNbBVBVTests = 0;
- mNbPrimPrimTests = 0;
- mNbBVPrimTests = 0;
- mPairs.Reset();
-
- // Setup matrices
- Matrix4x4 InvWorld0, InvWorld1;
- if(world0) InvertPRMatrix(InvWorld0, *world0);
- else InvWorld0.Identity();
-
- if(world1) InvertPRMatrix(InvWorld1, *world1);
- else InvWorld1.Identity();
-
- Matrix4x4 World0to1 = world0 ? (*world0 * InvWorld1) : InvWorld1;
- Matrix4x4 World1to0 = world1 ? (*world1 * InvWorld0) : InvWorld0;
-
- mR0to1 = World0to1; World0to1.GetTrans(mT0to1);
- mR1to0 = World1to0; World1to0.GetTrans(mT1to0);
-
- // Precompute absolute 1-to-0 rotation matrix
- for(udword i=0;i<3;i++)
- {
- for(udword j=0;j<3;j++)
- {
- // Epsilon value prevents floating-point inaccuracies (strategy borrowed from RAPID)
- mAR.m[i][j] = 1e-6f + fabsf(mR1to0.m[i][j]);
- }
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Takes advantage of temporal coherence.
- * \param cache [in] cache for a pair of previously colliding primitives
- * \return true if we can return immediately
- * \warning only works for "First Contact" mode
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeCollider::CheckTemporalCoherence(Pair* cache)
-{
- // Checkings
- if(!cache) return false;
-
- // Test previously colliding primitives first
- if(TemporalCoherenceEnabled() && FirstContactEnabled())
- {
- PrimTest(cache->id0, cache->id1);
- if(GetContactStatus()) return true;
- }
- return false;
-}
-
-#define UPDATE_CACHE \
- if(cache && GetContactStatus()) \
- { \
- cache->id0 = mPairs.GetEntry(0); \
- cache->id1 = mPairs.GetEntry(1); \
- }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Collision query for normal AABB trees.
- * \param tree0 [in] AABB tree from first object
- * \param tree1 [in] AABB tree from second object
- * \param world0 [in] world matrix for first object
- * \param world1 [in] world matrix for second object
- * \param cache [in/out] cache for a pair of previously colliding primitives
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeCollider::Collide(const AABBCollisionTree* tree0, const AABBCollisionTree* tree1, const Matrix4x4* world0, const Matrix4x4* world1, Pair* cache)
-{
- // Init collision query
- InitQuery(world0, world1);
-
- // Check previous state
- if(CheckTemporalCoherence(cache)) return true;
-
- // Perform collision query
- _Collide(tree0->GetNodes(), tree1->GetNodes());
-
- UPDATE_CACHE
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Collision query for no-leaf AABB trees.
- * \param tree0 [in] AABB tree from first object
- * \param tree1 [in] AABB tree from second object
- * \param world0 [in] world matrix for first object
- * \param world1 [in] world matrix for second object
- * \param cache [in/out] cache for a pair of previously colliding primitives
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeCollider::Collide(const AABBNoLeafTree* tree0, const AABBNoLeafTree* tree1, const Matrix4x4* world0, const Matrix4x4* world1, Pair* cache)
-{
- // Init collision query
- InitQuery(world0, world1);
-
- // Check previous state
- if(CheckTemporalCoherence(cache)) return true;
-
- // Perform collision query
- _Collide(tree0->GetNodes(), tree1->GetNodes());
-
- UPDATE_CACHE
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Collision query for quantized AABB trees.
- * \param tree0 [in] AABB tree from first object
- * \param tree1 [in] AABB tree from second object
- * \param world0 [in] world matrix for first object
- * \param world1 [in] world matrix for second object
- * \param cache [in/out] cache for a pair of previously colliding primitives
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeCollider::Collide(const AABBQuantizedTree* tree0, const AABBQuantizedTree* tree1, const Matrix4x4* world0, const Matrix4x4* world1, Pair* cache)
-{
- // Init collision query
- InitQuery(world0, world1);
-
- // Check previous state
- if(CheckTemporalCoherence(cache)) return true;
-
- // Setup dequantization coeffs
- mCenterCoeff0 = tree0->mCenterCoeff;
- mExtentsCoeff0 = tree0->mExtentsCoeff;
- mCenterCoeff1 = tree1->mCenterCoeff;
- mExtentsCoeff1 = tree1->mExtentsCoeff;
-
- // Dequantize box A
- const AABBQuantizedNode* N0 = tree0->GetNodes();
- const IcePoint a(float(N0->mAABB.mExtents[0]) * mExtentsCoeff0.x, float(N0->mAABB.mExtents[1]) * mExtentsCoeff0.y, float(N0->mAABB.mExtents[2]) * mExtentsCoeff0.z);
- const IcePoint Pa(float(N0->mAABB.mCenter[0]) * mCenterCoeff0.x, float(N0->mAABB.mCenter[1]) * mCenterCoeff0.y, float(N0->mAABB.mCenter[2]) * mCenterCoeff0.z);
- // Dequantize box B
- const AABBQuantizedNode* N1 = tree1->GetNodes();
- const IcePoint b(float(N1->mAABB.mExtents[0]) * mExtentsCoeff1.x, float(N1->mAABB.mExtents[1]) * mExtentsCoeff1.y, float(N1->mAABB.mExtents[2]) * mExtentsCoeff1.z);
- const IcePoint Pb(float(N1->mAABB.mCenter[0]) * mCenterCoeff1.x, float(N1->mAABB.mCenter[1]) * mCenterCoeff1.y, float(N1->mAABB.mCenter[2]) * mCenterCoeff1.z);
-
- // Perform collision query
- _Collide(N0, N1, a, Pa, b, Pb);
-
- UPDATE_CACHE
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Collision query for quantized no-leaf AABB trees.
- * \param tree0 [in] AABB tree from first object
- * \param tree1 [in] AABB tree from second object
- * \param world0 [in] world matrix for first object
- * \param world1 [in] world matrix for second object
- * \param cache [in/out] cache for a pair of previously colliding primitives
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-bool AABBTreeCollider::Collide(const AABBQuantizedNoLeafTree* tree0, const AABBQuantizedNoLeafTree* tree1, const Matrix4x4* world0, const Matrix4x4* world1, Pair* cache)
-{
- // Init collision query
- InitQuery(world0, world1);
-
- // Check previous state
- if(CheckTemporalCoherence(cache)) return true;
-
- // Setup dequantization coeffs
- mCenterCoeff0 = tree0->mCenterCoeff;
- mExtentsCoeff0 = tree0->mExtentsCoeff;
- mCenterCoeff1 = tree1->mCenterCoeff;
- mExtentsCoeff1 = tree1->mExtentsCoeff;
-
- // Perform collision query
- _Collide(tree0->GetNodes(), tree1->GetNodes());
-
- UPDATE_CACHE
-
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Standard trees
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-// The normal AABB tree can use 2 different descent rules (with different performances)
-//#define ORIGINAL_CODE //!< UNC-like descent rules
-#define ALTERNATIVE_CODE //!< Alternative descent rules
-
-#ifdef ORIGINAL_CODE
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for normal AABB trees.
- * \param b0 [in] collision node from first tree
- * \param b1 [in] collision node from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_Collide(const AABBCollisionNode* b0, const AABBCollisionNode* b1)
-{
- // Perform BV-BV overlap test
- if(!BoxBoxOverlap(b0->mAABB.mExtents, b0->mAABB.mCenter, b1->mAABB.mExtents, b1->mAABB.mCenter)) return;
-
- if(b0->IsLeaf() && b1->IsLeaf()) { PrimTest(b0->GetPrimitive(), b1->GetPrimitive()); return; }
-
- if(b1->IsLeaf() || (!b0->IsLeaf() && (b0->GetSize() > b1->GetSize())))
- {
- _Collide(b0->GetNeg(), b1);
- if(ContactFound()) return;
- _Collide(b0->GetPos(), b1);
- }
- else
- {
- _Collide(b0, b1->GetNeg());
- if(ContactFound()) return;
- _Collide(b0, b1->GetPos());
- }
-}
-#endif
-
-#ifdef ALTERNATIVE_CODE
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for normal AABB trees.
- * \param b0 [in] collision node from first tree
- * \param b1 [in] collision node from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_Collide(const AABBCollisionNode* b0, const AABBCollisionNode* b1)
-{
- // Perform BV-BV overlap test
- if(!BoxBoxOverlap(b0->mAABB.mExtents, b0->mAABB.mCenter, b1->mAABB.mExtents, b1->mAABB.mCenter))
- {
- return;
- }
-
- if(b0->IsLeaf())
- {
- if(b1->IsLeaf())
- {
- PrimTest(b0->GetPrimitive(), b1->GetPrimitive());
- }
- else
- {
- _Collide(b0, b1->GetNeg());
- if(ContactFound()) return;
- _Collide(b0, b1->GetPos());
- }
- }
- else if(b1->IsLeaf())
- {
- _Collide(b0->GetNeg(), b1);
- if(ContactFound()) return;
- _Collide(b0->GetPos(), b1);
- }
- else
- {
- _Collide(b0->GetNeg(), b1->GetNeg());
- if(ContactFound()) return;
- _Collide(b0->GetNeg(), b1->GetPos());
- if(ContactFound()) return;
- _Collide(b0->GetPos(), b1->GetNeg());
- if(ContactFound()) return;
- _Collide(b0->GetPos(), b1->GetPos());
- }
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// No-leaf trees
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Leaf-leaf test for two primitive indices.
- * \param id0 [in] index from first leaf-triangle
- * \param id1 [in] index from second leaf-triangle
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::PrimTest(udword id0, udword id1)
-{
- // Request vertices from the app
- VertexPointers VP0;
- VertexPointers VP1;
- mIMesh0->GetTriangle(VP0, id0);
- mIMesh1->GetTriangle(VP1, id1);
-
- // Transform from space 1 to space 0
- IcePoint u0,u1,u2;
- TransformPoint(u0, *VP1.Vertex[0], mR1to0, mT1to0);
- TransformPoint(u1, *VP1.Vertex[1], mR1to0, mT1to0);
- TransformPoint(u2, *VP1.Vertex[2], mR1to0, mT1to0);
-
- // Perform triangle-triangle overlap test
- if(TriTriOverlap(*VP0.Vertex[0], *VP0.Vertex[1], *VP0.Vertex[2], u0, u1, u2))
- {
- // Keep track of colliding pairs
- mPairs.Add(id0).Add(id1);
- // Set contact status
- mFlags |= OPC_CONTACT;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Leaf-leaf test for a previously fetched triangle from tree A (in B's space) and a new leaf from B.
- * \param id1 [in] leaf-triangle index from tree B
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ void AABBTreeCollider::PrimTestTriIndex(udword id1)
-{
- // Request vertices from the app
- VertexPointers VP;
- mIMesh1->GetTriangle(VP, id1);
-
- // Perform triangle-triangle overlap test
- if(TriTriOverlap(mLeafVerts[0], mLeafVerts[1], mLeafVerts[2], *VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2]))
- {
- // Keep track of colliding pairs
- mPairs.Add(mLeafIndex).Add(id1);
- // Set contact status
- mFlags |= OPC_CONTACT;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Leaf-leaf test for a previously fetched triangle from tree B (in A's space) and a new leaf from A.
- * \param id0 [in] leaf-triangle index from tree A
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ void AABBTreeCollider::PrimTestIndexTri(udword id0)
-{
- // Request vertices from the app
- VertexPointers VP;
- mIMesh0->GetTriangle(VP, id0);
-
- // Perform triangle-triangle overlap test
- if(TriTriOverlap(mLeafVerts[0], mLeafVerts[1], mLeafVerts[2], *VP.Vertex[0], *VP.Vertex[1], *VP.Vertex[2]))
- {
- // Keep track of colliding pairs
- mPairs.Add(id0).Add(mLeafIndex);
- // Set contact status
- mFlags |= OPC_CONTACT;
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision of a leaf node from A and a branch from B.
- * \param b [in] collision node from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_CollideTriBox(const AABBNoLeafNode* b)
-{
- // Perform triangle-box overlap test
- if(!TriBoxOverlap(b->mAABB.mCenter, b->mAABB.mExtents)) return;
-
- // Keep same triangle, deal with first child
- if(b->HasPosLeaf()) PrimTestTriIndex(b->GetPosPrimitive());
- else _CollideTriBox(b->GetPos());
-
- if(ContactFound()) return;
-
- // Keep same triangle, deal with second child
- if(b->HasNegLeaf()) PrimTestTriIndex(b->GetNegPrimitive());
- else _CollideTriBox(b->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision of a leaf node from B and a branch from A.
- * \param b [in] collision node from first tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_CollideBoxTri(const AABBNoLeafNode* b)
-{
- // Perform triangle-box overlap test
- if(!TriBoxOverlap(b->mAABB.mCenter, b->mAABB.mExtents)) return;
-
- // Keep same triangle, deal with first child
- if(b->HasPosLeaf()) PrimTestIndexTri(b->GetPosPrimitive());
- else _CollideBoxTri(b->GetPos());
-
- if(ContactFound()) return;
-
- // Keep same triangle, deal with second child
- if(b->HasNegLeaf()) PrimTestIndexTri(b->GetNegPrimitive());
- else _CollideBoxTri(b->GetNeg());
-}
-
-//! Request triangle vertices from the app and transform them
-#define FETCH_LEAF(prim_index, imesh, rot, trans) \
- mLeafIndex = prim_index; \
- /* Request vertices from the app */ \
- VertexPointers VP; imesh->GetTriangle(VP, mLeafIndex); \
- /* Transform them in a common space */ \
- TransformPoint(mLeafVerts[0], *VP.Vertex[0], rot, trans); \
- TransformPoint(mLeafVerts[1], *VP.Vertex[1], rot, trans); \
- TransformPoint(mLeafVerts[2], *VP.Vertex[2], rot, trans);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for no-leaf AABB trees.
- * \param a [in] collision node from first tree
- * \param b [in] collision node from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_Collide(const AABBNoLeafNode* a, const AABBNoLeafNode* b)
-{
- // Perform BV-BV overlap test
- if(!BoxBoxOverlap(a->mAABB.mExtents, a->mAABB.mCenter, b->mAABB.mExtents, b->mAABB.mCenter)) return;
-
- // Catch leaf status
- BOOL BHasPosLeaf = b->HasPosLeaf();
- BOOL BHasNegLeaf = b->HasNegLeaf();
-
- if(a->HasPosLeaf())
- {
- FETCH_LEAF(a->GetPosPrimitive(), mIMesh0, mR0to1, mT0to1)
-
- if(BHasPosLeaf) PrimTestTriIndex(b->GetPosPrimitive());
- else _CollideTriBox(b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf) PrimTestTriIndex(b->GetNegPrimitive());
- else _CollideTriBox(b->GetNeg());
- }
- else
- {
- if(BHasPosLeaf)
- {
- FETCH_LEAF(b->GetPosPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetPos());
- }
- else _Collide(a->GetPos(), b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf)
- {
- FETCH_LEAF(b->GetNegPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetPos());
- }
- else _Collide(a->GetPos(), b->GetNeg());
- }
-
- if(ContactFound()) return;
-
- if(a->HasNegLeaf())
- {
- FETCH_LEAF(a->GetNegPrimitive(), mIMesh0, mR0to1, mT0to1)
-
- if(BHasPosLeaf) PrimTestTriIndex(b->GetPosPrimitive());
- else _CollideTriBox(b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf) PrimTestTriIndex(b->GetNegPrimitive());
- else _CollideTriBox(b->GetNeg());
- }
- else
- {
- if(BHasPosLeaf)
- {
- // ### That leaf has possibly already been fetched
- FETCH_LEAF(b->GetPosPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetNeg());
- }
- else _Collide(a->GetNeg(), b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf)
- {
- // ### That leaf has possibly already been fetched
- FETCH_LEAF(b->GetNegPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetNeg());
- }
- else _Collide(a->GetNeg(), b->GetNeg());
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Quantized trees
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized AABB trees.
- * \param b0 [in] collision node from first tree
- * \param b1 [in] collision node from second tree
- * \param a [in] extent from box A
- * \param Pa [in] center from box A
- * \param b [in] extent from box B
- * \param Pb [in] center from box B
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_Collide(const AABBQuantizedNode* b0, const AABBQuantizedNode* b1, const IcePoint& a, const IcePoint& Pa, const IcePoint& b, const IcePoint& Pb)
-{
- // Perform BV-BV overlap test
- if(!BoxBoxOverlap(a, Pa, b, Pb)) return;
-
- if(b0->IsLeaf() && b1->IsLeaf()) { PrimTest(b0->GetPrimitive(), b1->GetPrimitive()); return; }
-
- if(b1->IsLeaf() || (!b0->IsLeaf() && (b0->GetSize() > b1->GetSize())))
- {
- // Dequantize box
- const QuantizedAABB* Box = &b0->GetNeg()->mAABB;
- const IcePoint negPa(float(Box->mCenter[0]) * mCenterCoeff0.x, float(Box->mCenter[1]) * mCenterCoeff0.y, float(Box->mCenter[2]) * mCenterCoeff0.z);
- const IcePoint nega(float(Box->mExtents[0]) * mExtentsCoeff0.x, float(Box->mExtents[1]) * mExtentsCoeff0.y, float(Box->mExtents[2]) * mExtentsCoeff0.z);
- _Collide(b0->GetNeg(), b1, nega, negPa, b, Pb);
-
- if(ContactFound()) return;
-
- // Dequantize box
- Box = &b0->GetPos()->mAABB;
- const IcePoint posPa(float(Box->mCenter[0]) * mCenterCoeff0.x, float(Box->mCenter[1]) * mCenterCoeff0.y, float(Box->mCenter[2]) * mCenterCoeff0.z);
- const IcePoint posa(float(Box->mExtents[0]) * mExtentsCoeff0.x, float(Box->mExtents[1]) * mExtentsCoeff0.y, float(Box->mExtents[2]) * mExtentsCoeff0.z);
- _Collide(b0->GetPos(), b1, posa, posPa, b, Pb);
- }
- else
- {
- // Dequantize box
- const QuantizedAABB* Box = &b1->GetNeg()->mAABB;
- const IcePoint negPb(float(Box->mCenter[0]) * mCenterCoeff1.x, float(Box->mCenter[1]) * mCenterCoeff1.y, float(Box->mCenter[2]) * mCenterCoeff1.z);
- const IcePoint negb(float(Box->mExtents[0]) * mExtentsCoeff1.x, float(Box->mExtents[1]) * mExtentsCoeff1.y, float(Box->mExtents[2]) * mExtentsCoeff1.z);
- _Collide(b0, b1->GetNeg(), a, Pa, negb, negPb);
-
- if(ContactFound()) return;
-
- // Dequantize box
- Box = &b1->GetPos()->mAABB;
- const IcePoint posPb(float(Box->mCenter[0]) * mCenterCoeff1.x, float(Box->mCenter[1]) * mCenterCoeff1.y, float(Box->mCenter[2]) * mCenterCoeff1.z);
- const IcePoint posb(float(Box->mExtents[0]) * mExtentsCoeff1.x, float(Box->mExtents[1]) * mExtentsCoeff1.y, float(Box->mExtents[2]) * mExtentsCoeff1.z);
- _Collide(b0, b1->GetPos(), a, Pa, posb, posPb);
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Quantized no-leaf trees
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision of a leaf node from A and a quantized branch from B.
- * \param leaf [in] leaf triangle from first tree
- * \param b [in] collision node from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_CollideTriBox(const AABBQuantizedNoLeafNode* b)
-{
- // Dequantize box
- const QuantizedAABB* bb = &b->mAABB;
- const IcePoint Pb(float(bb->mCenter[0]) * mCenterCoeff1.x, float(bb->mCenter[1]) * mCenterCoeff1.y, float(bb->mCenter[2]) * mCenterCoeff1.z);
- const IcePoint eb(float(bb->mExtents[0]) * mExtentsCoeff1.x, float(bb->mExtents[1]) * mExtentsCoeff1.y, float(bb->mExtents[2]) * mExtentsCoeff1.z);
-
- // Perform triangle-box overlap test
- if(!TriBoxOverlap(Pb, eb)) return;
-
- if(b->HasPosLeaf()) PrimTestTriIndex(b->GetPosPrimitive());
- else _CollideTriBox(b->GetPos());
-
- if(ContactFound()) return;
-
- if(b->HasNegLeaf()) PrimTestTriIndex(b->GetNegPrimitive());
- else _CollideTriBox(b->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision of a leaf node from B and a quantized branch from A.
- * \param b [in] collision node from first tree
- * \param leaf [in] leaf triangle from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_CollideBoxTri(const AABBQuantizedNoLeafNode* b)
-{
- // Dequantize box
- const QuantizedAABB* bb = &b->mAABB;
- const IcePoint Pa(float(bb->mCenter[0]) * mCenterCoeff0.x, float(bb->mCenter[1]) * mCenterCoeff0.y, float(bb->mCenter[2]) * mCenterCoeff0.z);
- const IcePoint ea(float(bb->mExtents[0]) * mExtentsCoeff0.x, float(bb->mExtents[1]) * mExtentsCoeff0.y, float(bb->mExtents[2]) * mExtentsCoeff0.z);
-
- // Perform triangle-box overlap test
- if(!TriBoxOverlap(Pa, ea)) return;
-
- if(b->HasPosLeaf()) PrimTestIndexTri(b->GetPosPrimitive());
- else _CollideBoxTri(b->GetPos());
-
- if(ContactFound()) return;
-
- if(b->HasNegLeaf()) PrimTestIndexTri(b->GetNegPrimitive());
- else _CollideBoxTri(b->GetNeg());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Recursive collision query for quantized no-leaf AABB trees.
- * \param a [in] collision node from first tree
- * \param b [in] collision node from second tree
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void AABBTreeCollider::_Collide(const AABBQuantizedNoLeafNode* a, const AABBQuantizedNoLeafNode* b)
-{
- // Dequantize box A
- const QuantizedAABB* ab = &a->mAABB;
- const IcePoint Pa(float(ab->mCenter[0]) * mCenterCoeff0.x, float(ab->mCenter[1]) * mCenterCoeff0.y, float(ab->mCenter[2]) * mCenterCoeff0.z);
- const IcePoint ea(float(ab->mExtents[0]) * mExtentsCoeff0.x, float(ab->mExtents[1]) * mExtentsCoeff0.y, float(ab->mExtents[2]) * mExtentsCoeff0.z);
- // Dequantize box B
- const QuantizedAABB* bb = &b->mAABB;
- const IcePoint Pb(float(bb->mCenter[0]) * mCenterCoeff1.x, float(bb->mCenter[1]) * mCenterCoeff1.y, float(bb->mCenter[2]) * mCenterCoeff1.z);
- const IcePoint eb(float(bb->mExtents[0]) * mExtentsCoeff1.x, float(bb->mExtents[1]) * mExtentsCoeff1.y, float(bb->mExtents[2]) * mExtentsCoeff1.z);
-
- // Perform BV-BV overlap test
- if(!BoxBoxOverlap(ea, Pa, eb, Pb)) return;
-
- // Catch leaf status
- BOOL BHasPosLeaf = b->HasPosLeaf();
- BOOL BHasNegLeaf = b->HasNegLeaf();
-
- if(a->HasPosLeaf())
- {
- FETCH_LEAF(a->GetPosPrimitive(), mIMesh0, mR0to1, mT0to1)
-
- if(BHasPosLeaf) PrimTestTriIndex(b->GetPosPrimitive());
- else _CollideTriBox(b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf) PrimTestTriIndex(b->GetNegPrimitive());
- else _CollideTriBox(b->GetNeg());
- }
- else
- {
- if(BHasPosLeaf)
- {
- FETCH_LEAF(b->GetPosPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetPos());
- }
- else _Collide(a->GetPos(), b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf)
- {
- FETCH_LEAF(b->GetNegPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetPos());
- }
- else _Collide(a->GetPos(), b->GetNeg());
- }
-
- if(ContactFound()) return;
-
- if(a->HasNegLeaf())
- {
- FETCH_LEAF(a->GetNegPrimitive(), mIMesh0, mR0to1, mT0to1)
-
- if(BHasPosLeaf) PrimTestTriIndex(b->GetPosPrimitive());
- else _CollideTriBox(b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf) PrimTestTriIndex(b->GetNegPrimitive());
- else _CollideTriBox(b->GetNeg());
- }
- else
- {
- if(BHasPosLeaf)
- {
- // ### That leaf has possibly already been fetched
- FETCH_LEAF(b->GetPosPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetNeg());
- }
- else _Collide(a->GetNeg(), b->GetPos());
-
- if(ContactFound()) return;
-
- if(BHasNegLeaf)
- {
- // ### That leaf has possibly already been fetched
- FETCH_LEAF(b->GetNegPrimitive(), mIMesh1, mR1to0, mT1to0)
-
- _CollideBoxTri(a->GetNeg());
- }
- else _Collide(a->GetNeg(), b->GetNeg());
- }
-}
diff --git a/Opcode/OpcodeLib/OPC_TreeCollider.h b/Opcode/OpcodeLib/OPC_TreeCollider.h deleted file mode 100644 index ce58ff8..0000000 --- a/Opcode/OpcodeLib/OPC_TreeCollider.h +++ /dev/null @@ -1,244 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains code for a tree collider.
- * \file OPC_TreeCollider.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_TREECOLLIDER_H__
-#define __OPC_TREECOLLIDER_H__
-
- //! This structure holds cached information used by the algorithm.
- //! Two model pointers and two colliding primitives are cached. Model pointers are assigned
- //! to their respective meshes, and the pair of colliding primitives is used for temporal
- //! coherence. That is, in case temporal coherence is enabled, those two primitives are
- //! tested for overlap before everything else. If they still collide, we're done before
- //! even entering the recursive collision code.
- struct OPCODE_API BVTCache : Pair
- {
- //! Constructor
- inline_ BVTCache()
- {
- ResetCache();
- ResetCountDown();
- }
-
- void ResetCache()
- {
- Model0 = null;
- Model1 = null;
- id0 = 0;
- id1 = 1;
-#ifdef __MESHMERIZER_H__ // Collision hulls only supported within ICE !
- HullTest = true;
- SepVector.pid = 0;
- SepVector.qid = 0;
- SepVector.SV = IcePoint(1.0f, 0.0f, 0.0f);
-#endif // __MESHMERIZER_H__
- }
-
- inline_ void ResetCountDown()
- {
-#ifdef __MESHMERIZER_H__ // Collision hulls only supported within ICE !
- CountDown = 50;
-#endif // __MESHMERIZER_H__
- }
-
- const Model* Model0; //!< Model for first object
- const Model* Model1; //!< Model for second object
-
-#ifdef __MESHMERIZER_H__ // Collision hulls only supported within ICE !
- SVCache SepVector;
- udword CountDown;
- bool HullTest;
-#endif // __MESHMERIZER_H__
- };
-
- class OPCODE_API AABBTreeCollider : public Collider
- {
- public:
- // Constructor / Destructor
- AABBTreeCollider();
- virtual ~AABBTreeCollider();
- // Generic collision query
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Generic collision query for generic OPCODE models. After the call, access the results with:
- * - GetContactStatus()
- * - GetNbPairs()
- * - GetPairs()
- *
- * \param cache [in] collision cache for model pointers and a colliding pair of primitives
- * \param world0 [in] world matrix for first object, or null
- * \param world1 [in] world matrix for second object, or null
- * \return true if success
- * \warning SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- bool Collide(BVTCache& cache, const Matrix4x4* world0=null, const Matrix4x4* world1=null);
-
- // Collision queries
- bool Collide(const AABBCollisionTree* tree0, const AABBCollisionTree* tree1, const Matrix4x4* world0=null, const Matrix4x4* world1=null, Pair* cache=null);
- bool Collide(const AABBNoLeafTree* tree0, const AABBNoLeafTree* tree1, const Matrix4x4* world0=null, const Matrix4x4* world1=null, Pair* cache=null);
- bool Collide(const AABBQuantizedTree* tree0, const AABBQuantizedTree* tree1, const Matrix4x4* world0=null, const Matrix4x4* world1=null, Pair* cache=null);
- bool Collide(const AABBQuantizedNoLeafTree* tree0, const AABBQuantizedNoLeafTree* tree1, const Matrix4x4* world0=null, const Matrix4x4* world1=null, Pair* cache=null);
- // Settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: selects between full box-box tests or "SAT-lite" tests (where Class III axes are discarded)
- * \param flag [in] true for full tests, false for coarse tests
- * \see SetFullPrimBoxTest(bool flag)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetFullBoxBoxTest(bool flag) { mFullBoxBoxTest = flag; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Settings: selects between full triangle-box tests or "SAT-lite" tests (where Class III axes are discarded)
- * \param flag [in] true for full tests, false for coarse tests
- * \see SetFullBoxBoxTest(bool flag)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ void SetFullPrimBoxTest(bool flag) { mFullPrimBoxTest = flag; }
-
- // Stats
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of BV-BV overlap tests after a collision query.
- * \see GetNbPrimPrimTests()
- * \see GetNbBVPrimTests()
- * \return the number of BV-BV tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbBVBVTests() const { return mNbBVBVTests; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of Triangle-Triangle overlap tests after a collision query.
- * \see GetNbBVBVTests()
- * \see GetNbBVPrimTests()
- * \return the number of Triangle-Triangle tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbPrimPrimTests() const { return mNbPrimPrimTests; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of BV-Triangle overlap tests after a collision query.
- * \see GetNbBVBVTests()
- * \see GetNbPrimPrimTests()
- * \return the number of BV-Triangle tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbBVPrimTests() const { return mNbBVPrimTests; }
-
- // Data access
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the number of contacts after a collision query.
- * \see GetContactStatus()
- * \see GetPairs()
- * \return the number of contacts / colliding pairs.
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbPairs() const { return mPairs.GetNbEntries()>>1; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the pairs of colliding triangles after a collision query.
- * \see GetContactStatus()
- * \see GetNbPairs()
- * \return the list of colliding pairs (triangle indices)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const Pair* GetPairs() const { return (const Pair*)mPairs.GetEntries(); }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Validates current settings. You should call this method after all the settings and callbacks have been defined for a collider.
- * \return null if everything is ok, else a string describing the problem
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(Collider) const char* ValidateSettings();
-
- protected:
- // Colliding pairs
- Container mPairs; //!< Pairs of colliding primitives
- // User mesh interfaces
- const MeshInterface* mIMesh0; //!< User-defined mesh interface for object0
- const MeshInterface* mIMesh1; //!< User-defined mesh interface for object1
- // Stats
- udword mNbBVBVTests; //!< Number of BV-BV tests
- udword mNbPrimPrimTests; //!< Number of Primitive-Primitive tests
- udword mNbBVPrimTests; //!< Number of BV-Primitive tests
- // Precomputed data
- Matrix3x3 mAR; //!< Absolute rotation matrix
- Matrix3x3 mR0to1; //!< Rotation from object0 to object1
- Matrix3x3 mR1to0; //!< Rotation from object1 to object0
- IcePoint mT0to1; //!< Translation from object0 to object1
- IcePoint mT1to0; //!< Translation from object1 to object0
- // Dequantization coeffs
- IcePoint mCenterCoeff0;
- IcePoint mExtentsCoeff0;
- IcePoint mCenterCoeff1;
- IcePoint mExtentsCoeff1;
- // Leaf description
- IcePoint mLeafVerts[3]; //!< Triangle vertices
- udword mLeafIndex; //!< Triangle index
- // Settings
- bool mFullBoxBoxTest; //!< Perform full BV-BV tests (true) or SAT-lite tests (false)
- bool mFullPrimBoxTest; //!< Perform full Primitive-BV tests (true) or SAT-lite tests (false)
- // Internal methods
-
- // Standard AABB trees
- void _Collide(const AABBCollisionNode* b0, const AABBCollisionNode* b1);
- // Quantized AABB trees
- void _Collide(const AABBQuantizedNode* b0, const AABBQuantizedNode* b1, const IcePoint& a, const IcePoint& Pa, const IcePoint& b, const IcePoint& Pb);
- // No-leaf AABB trees
- void _CollideTriBox(const AABBNoLeafNode* b);
- void _CollideBoxTri(const AABBNoLeafNode* b);
- void _Collide(const AABBNoLeafNode* a, const AABBNoLeafNode* b);
- // Quantized no-leaf AABB trees
- void _CollideTriBox(const AABBQuantizedNoLeafNode* b);
- void _CollideBoxTri(const AABBQuantizedNoLeafNode* b);
- void _Collide(const AABBQuantizedNoLeafNode* a, const AABBQuantizedNoLeafNode* b);
- // Overlap tests
- void PrimTest(udword id0, udword id1);
- inline_ void PrimTestTriIndex(udword id1);
- inline_ void PrimTestIndexTri(udword id0);
-
- inline_ BOOL BoxBoxOverlap(const IcePoint& ea, const IcePoint& ca, const IcePoint& eb, const IcePoint& cb);
- inline_ BOOL TriBoxOverlap(const IcePoint& center, const IcePoint& extents);
- inline_ BOOL TriTriOverlap(const IcePoint& V0, const IcePoint& V1, const IcePoint& V2, const IcePoint& U0, const IcePoint& U1, const IcePoint& U2);
- // Init methods
- void InitQuery(const Matrix4x4* world0=null, const Matrix4x4* world1=null);
- bool CheckTemporalCoherence(Pair* cache);
-
- inline_ BOOL Setup(const MeshInterface* mi0, const MeshInterface* mi1)
- {
- mIMesh0 = mi0;
- mIMesh1 = mi1;
-
- if(!mIMesh0 || !mIMesh1) return FALSE;
-
- return TRUE;
- }
- };
-
-#endif // __OPC_TREECOLLIDER_H__
diff --git a/Opcode/OpcodeLib/OPC_TriBoxOverlap.h b/Opcode/OpcodeLib/OPC_TriBoxOverlap.h deleted file mode 100644 index 662a127..0000000 --- a/Opcode/OpcodeLib/OPC_TriBoxOverlap.h +++ /dev/null @@ -1,339 +0,0 @@ -
-//! This macro quickly finds the min & max values among 3 variables
-#define FINDMINMAX(x0, x1, x2, min, max) \
- min = max = x0; \
- if(x1<min) min=x1; \
- if(x1>max) max=x1; \
- if(x2<min) min=x2; \
- if(x2>max) max=x2;
-
-//! TO BE DOCUMENTED
-inline_ BOOL planeBoxOverlap(const IcePoint& normal, const float d, const IcePoint& maxbox)
-{
- IcePoint vmin, vmax;
- for(udword q=0;q<=2;q++)
- {
- if(normal[q]>0.0f) { vmin[q]=-maxbox[q]; vmax[q]=maxbox[q]; }
- else { vmin[q]=maxbox[q]; vmax[q]=-maxbox[q]; }
- }
- if((normal|vmin)+d>0.0f) return FALSE;
- if((normal|vmax)+d>=0.0f) return TRUE;
-
- return FALSE;
-}
-
-//! TO BE DOCUMENTED
-#define AXISTEST_X01(a, b, fa, fb) \
- min = a*v0.y - b*v0.z; \
- max = a*v2.y - b*v2.z; \
- if(min>max) {const float tmp=max; max=min; min=tmp; } \
- rad = fa * extents.y + fb * extents.z; \
- if(min>rad || max<-rad) return FALSE;
-
-//! TO BE DOCUMENTED
-#define AXISTEST_X2(a, b, fa, fb) \
- min = a*v0.y - b*v0.z; \
- max = a*v1.y - b*v1.z; \
- if(min>max) {const float tmp=max; max=min; min=tmp; } \
- rad = fa * extents.y + fb * extents.z; \
- if(min>rad || max<-rad) return FALSE;
-
-//! TO BE DOCUMENTED
-#define AXISTEST_Y02(a, b, fa, fb) \
- min = b*v0.z - a*v0.x; \
- max = b*v2.z - a*v2.x; \
- if(min>max) {const float tmp=max; max=min; min=tmp; } \
- rad = fa * extents.x + fb * extents.z; \
- if(min>rad || max<-rad) return FALSE;
-
-//! TO BE DOCUMENTED
-#define AXISTEST_Y1(a, b, fa, fb) \
- min = b*v0.z - a*v0.x; \
- max = b*v1.z - a*v1.x; \
- if(min>max) {const float tmp=max; max=min; min=tmp; } \
- rad = fa * extents.x + fb * extents.z; \
- if(min>rad || max<-rad) return FALSE;
-
-//! TO BE DOCUMENTED
-#define AXISTEST_Z12(a, b, fa, fb) \
- min = a*v1.x - b*v1.y; \
- max = a*v2.x - b*v2.y; \
- if(min>max) {const float tmp=max; max=min; min=tmp; } \
- rad = fa * extents.x + fb * extents.y; \
- if(min>rad || max<-rad) return FALSE;
-
-//! TO BE DOCUMENTED
-#define AXISTEST_Z0(a, b, fa, fb) \
- min = a*v0.x - b*v0.y; \
- max = a*v1.x - b*v1.y; \
- if(min>max) {const float tmp=max; max=min; min=tmp; } \
- rad = fa * extents.x + fb * extents.y; \
- if(min>rad || max<-rad) return FALSE;
-
-// compute triangle edges
-// - edges lazy evaluated to take advantage of early exits
-// - fabs precomputed (half less work, possible since extents are always >0)
-// - customized macros to take advantage of the null component
-// - axis vector discarded, possibly saves useless movs
-#define IMPLEMENT_CLASS3_TESTS \
- float rad; \
- float min, max; \
- \
- const float fey0 = fabsf(e0.y); \
- const float fez0 = fabsf(e0.z); \
- AXISTEST_X01(e0.z, e0.y, fez0, fey0); \
- const float fex0 = fabsf(e0.x); \
- AXISTEST_Y02(e0.z, e0.x, fez0, fex0); \
- AXISTEST_Z12(e0.y, e0.x, fey0, fex0); \
- \
- const float fey1 = fabsf(e1.y); \
- const float fez1 = fabsf(e1.z); \
- AXISTEST_X01(e1.z, e1.y, fez1, fey1); \
- const float fex1 = fabsf(e1.x); \
- AXISTEST_Y02(e1.z, e1.x, fez1, fex1); \
- AXISTEST_Z0(e1.y, e1.x, fey1, fex1); \
- \
- const IcePoint e2 = mLeafVerts[0] - mLeafVerts[2]; \
- const float fey2 = fabsf(e2.y); \
- const float fez2 = fabsf(e2.z); \
- AXISTEST_X2(e2.z, e2.y, fez2, fey2); \
- const float fex2 = fabsf(e2.x); \
- AXISTEST_Y1(e2.z, e2.x, fez2, fex2); \
- AXISTEST_Z12(e2.y, e2.x, fey2, fex2);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Triangle-Box overlap test using the separating axis theorem.
- * This is the code from Tomas Möller, a bit optimized:
- * - with some more lazy evaluation (faster path on PC)
- * - with a tiny bit of assembly
- * - with "SAT-lite" applied if needed
- * - and perhaps with some more minor modifs...
- *
- * \param center [in] box center
- * \param extents [in] box extents
- * \return true if triangle & box overlap
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL AABBTreeCollider::TriBoxOverlap(const IcePoint& center, const IcePoint& extents)
-{
- // Stats
- mNbBVPrimTests++;
-
- // use separating axis theorem to test overlap between triangle and box
- // need to test for overlap in these directions:
- // 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle
- // we do not even need to test these)
- // 2) normal of the triangle
- // 3) crossproduct(edge from tri, {x,y,z}-directin)
- // this gives 3x3=9 more tests
-
- // move everything so that the boxcenter is in (0,0,0)
- IcePoint v0, v1, v2;
- v0.x = mLeafVerts[0].x - center.x;
- v1.x = mLeafVerts[1].x - center.x;
- v2.x = mLeafVerts[2].x - center.x;
-
- // First, test overlap in the {x,y,z}-directions
-#ifdef OPC_USE_FCOMI
- // find min, max of the triangle in x-direction, and test for overlap in X
- if(FCMin3(v0.x, v1.x, v2.x)>extents.x) return FALSE;
- if(FCMax3(v0.x, v1.x, v2.x)<-extents.x) return FALSE;
-
- // same for Y
- v0.y = mLeafVerts[0].y - center.y;
- v1.y = mLeafVerts[1].y - center.y;
- v2.y = mLeafVerts[2].y - center.y;
-
- if(FCMin3(v0.y, v1.y, v2.y)>extents.y) return FALSE;
- if(FCMax3(v0.y, v1.y, v2.y)<-extents.y) return FALSE;
-
- // same for Z
- v0.z = mLeafVerts[0].z - center.z;
- v1.z = mLeafVerts[1].z - center.z;
- v2.z = mLeafVerts[2].z - center.z;
-
- if(FCMin3(v0.z, v1.z, v2.z)>extents.z) return FALSE;
- if(FCMax3(v0.z, v1.z, v2.z)<-extents.z) return FALSE;
-#else
- float min,max;
- // Find min, max of the triangle in x-direction, and test for overlap in X
- FINDMINMAX(v0.x, v1.x, v2.x, min, max);
- if(min>extents.x || max<-extents.x) return FALSE;
-
- // Same for Y
- v0.y = mLeafVerts[0].y - center.y;
- v1.y = mLeafVerts[1].y - center.y;
- v2.y = mLeafVerts[2].y - center.y;
-
- FINDMINMAX(v0.y, v1.y, v2.y, min, max);
- if(min>extents.y || max<-extents.y) return FALSE;
-
- // Same for Z
- v0.z = mLeafVerts[0].z - center.z;
- v1.z = mLeafVerts[1].z - center.z;
- v2.z = mLeafVerts[2].z - center.z;
-
- FINDMINMAX(v0.z, v1.z, v2.z, min, max);
- if(min>extents.z || max<-extents.z) return FALSE;
-#endif
- // 2) Test if the box intersects the plane of the triangle
- // compute plane equation of triangle: normal*x+d=0
- // ### could be precomputed since we use the same leaf triangle several times
- const IcePoint e0 = v1 - v0;
- const IcePoint e1 = v2 - v1;
- const IcePoint normal = e0 ^ e1;
- const float d = -normal|v0;
- if(!planeBoxOverlap(normal, d, extents)) return FALSE;
-
- // 3) "Class III" tests
- if(mFullPrimBoxTest)
- {
- IMPLEMENT_CLASS3_TESTS
- }
- return TRUE;
-}
-
-//! A dedicated version where the box is constant
-inline_ BOOL OBBCollider::TriBoxOverlap()
-{
- // Stats
- mNbVolumePrimTests++;
-
- // Hook
- const IcePoint& extents = mBoxExtents;
- const IcePoint& v0 = mLeafVerts[0];
- const IcePoint& v1 = mLeafVerts[1];
- const IcePoint& v2 = mLeafVerts[2];
-
- // use separating axis theorem to test overlap between triangle and box
- // need to test for overlap in these directions:
- // 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle
- // we do not even need to test these)
- // 2) normal of the triangle
- // 3) crossproduct(edge from tri, {x,y,z}-directin)
- // this gives 3x3=9 more tests
-
- // Box center is already in (0,0,0)
-
- // First, test overlap in the {x,y,z}-directions
-#ifdef OPC_USE_FCOMI
- // find min, max of the triangle in x-direction, and test for overlap in X
- if(FCMin3(v0.x, v1.x, v2.x)>mBoxExtents.x) return FALSE;
- if(FCMax3(v0.x, v1.x, v2.x)<-mBoxExtents.x) return FALSE;
-
- if(FCMin3(v0.y, v1.y, v2.y)>mBoxExtents.y) return FALSE;
- if(FCMax3(v0.y, v1.y, v2.y)<-mBoxExtents.y) return FALSE;
-
- if(FCMin3(v0.z, v1.z, v2.z)>mBoxExtents.z) return FALSE;
- if(FCMax3(v0.z, v1.z, v2.z)<-mBoxExtents.z) return FALSE;
-#else
- float min,max;
- // Find min, max of the triangle in x-direction, and test for overlap in X
- FINDMINMAX(v0.x, v1.x, v2.x, min, max);
- if(min>mBoxExtents.x || max<-mBoxExtents.x) return FALSE;
-
- FINDMINMAX(v0.y, v1.y, v2.y, min, max);
- if(min>mBoxExtents.y || max<-mBoxExtents.y) return FALSE;
-
- FINDMINMAX(v0.z, v1.z, v2.z, min, max);
- if(min>mBoxExtents.z || max<-mBoxExtents.z) return FALSE;
-#endif
- // 2) Test if the box intersects the plane of the triangle
- // compute plane equation of triangle: normal*x+d=0
- // ### could be precomputed since we use the same leaf triangle several times
- const IcePoint e0 = v1 - v0;
- const IcePoint e1 = v2 - v1;
- const IcePoint normal = e0 ^ e1;
- const float d = -normal|v0;
- if(!planeBoxOverlap(normal, d, mBoxExtents)) return FALSE;
-
- // 3) "Class III" tests - here we always do full tests since the box is a primitive (not a BV)
- {
- IMPLEMENT_CLASS3_TESTS
- }
- return TRUE;
-}
-
-//! ...and another one, jeez
-inline_ BOOL AABBCollider::TriBoxOverlap()
-{
- // Stats
- mNbVolumePrimTests++;
-
- // Hook
- const IcePoint& center = mBox.mCenter;
- const IcePoint& extents = mBox.mExtents;
-
- // use separating axis theorem to test overlap between triangle and box
- // need to test for overlap in these directions:
- // 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle
- // we do not even need to test these)
- // 2) normal of the triangle
- // 3) crossproduct(edge from tri, {x,y,z}-directin)
- // this gives 3x3=9 more tests
-
- // move everything so that the boxcenter is in (0,0,0)
- IcePoint v0, v1, v2;
- v0.x = mLeafVerts[0].x - center.x;
- v1.x = mLeafVerts[1].x - center.x;
- v2.x = mLeafVerts[2].x - center.x;
-
- // First, test overlap in the {x,y,z}-directions
-#ifdef OPC_USE_FCOMI
- // find min, max of the triangle in x-direction, and test for overlap in X
- if(FCMin3(v0.x, v1.x, v2.x)>extents.x) return FALSE;
- if(FCMax3(v0.x, v1.x, v2.x)<-extents.x) return FALSE;
-
- // same for Y
- v0.y = mLeafVerts[0].y - center.y;
- v1.y = mLeafVerts[1].y - center.y;
- v2.y = mLeafVerts[2].y - center.y;
-
- if(FCMin3(v0.y, v1.y, v2.y)>extents.y) return FALSE;
- if(FCMax3(v0.y, v1.y, v2.y)<-extents.y) return FALSE;
-
- // same for Z
- v0.z = mLeafVerts[0].z - center.z;
- v1.z = mLeafVerts[1].z - center.z;
- v2.z = mLeafVerts[2].z - center.z;
-
- if(FCMin3(v0.z, v1.z, v2.z)>extents.z) return FALSE;
- if(FCMax3(v0.z, v1.z, v2.z)<-extents.z) return FALSE;
-#else
- float min,max;
- // Find min, max of the triangle in x-direction, and test for overlap in X
- FINDMINMAX(v0.x, v1.x, v2.x, min, max);
- if(min>extents.x || max<-extents.x) return FALSE;
-
- // Same for Y
- v0.y = mLeafVerts[0].y - center.y;
- v1.y = mLeafVerts[1].y - center.y;
- v2.y = mLeafVerts[2].y - center.y;
-
- FINDMINMAX(v0.y, v1.y, v2.y, min, max);
- if(min>extents.y || max<-extents.y) return FALSE;
-
- // Same for Z
- v0.z = mLeafVerts[0].z - center.z;
- v1.z = mLeafVerts[1].z - center.z;
- v2.z = mLeafVerts[2].z - center.z;
-
- FINDMINMAX(v0.z, v1.z, v2.z, min, max);
- if(min>extents.z || max<-extents.z) return FALSE;
-#endif
- // 2) Test if the box intersects the plane of the triangle
- // compute plane equation of triangle: normal*x+d=0
- // ### could be precomputed since we use the same leaf triangle several times
- const IcePoint e0 = v1 - v0;
- const IcePoint e1 = v2 - v1;
- const IcePoint normal = e0 ^ e1;
- const float d = -normal|v0;
- if(!planeBoxOverlap(normal, d, extents)) return FALSE;
-
- // 3) "Class III" tests - here we always do full tests since the box is a primitive (not a BV)
- {
- IMPLEMENT_CLASS3_TESTS
- }
- return TRUE;
-}
diff --git a/Opcode/OpcodeLib/OPC_TriTriOverlap.h b/Opcode/OpcodeLib/OPC_TriTriOverlap.h deleted file mode 100644 index ccc8161..0000000 --- a/Opcode/OpcodeLib/OPC_TriTriOverlap.h +++ /dev/null @@ -1,279 +0,0 @@ -
-//! if OPC_TRITRI_EPSILON_TEST is true then we do a check (if |dv|<EPSILON then dv=0.0;) else no check is done (which is less robust, but faster)
-#define LOCAL_EPSILON 0.000001f
-
-//! sort so that a<=b
-#define SORT(a,b) \
- if(a>b) \
- { \
- const float c=a; \
- a=b; \
- b=c; \
- }
-
-//! Edge to edge test based on Franlin Antonio's gem: "Faster Line Segment Intersection", in Graphics Gems III, pp. 199-202
-#define EDGE_EDGE_TEST(V0, U0, U1) \
- Bx = U0[i0] - U1[i0]; \
- By = U0[i1] - U1[i1]; \
- Cx = V0[i0] - U0[i0]; \
- Cy = V0[i1] - U0[i1]; \
- f = Ay*Bx - Ax*By; \
- d = By*Cx - Bx*Cy; \
- if((f>0.0f && d>=0.0f && d<=f) || (f<0.0f && d<=0.0f && d>=f)) \
- { \
- const float e=Ax*Cy - Ay*Cx; \
- if(f>0.0f) \
- { \
- if(e>=0.0f && e<=f) return TRUE; \
- } \
- else \
- { \
- if(e<=0.0f && e>=f) return TRUE; \
- } \
- }
-
-//! TO BE DOCUMENTED
-#define EDGE_AGAINST_TRI_EDGES(V0, V1, U0, U1, U2) \
-{ \
- float Bx,By,Cx,Cy,d,f; \
- const float Ax = V1[i0] - V0[i0]; \
- const float Ay = V1[i1] - V0[i1]; \
- /* test edge U0,U1 against V0,V1 */ \
- EDGE_EDGE_TEST(V0, U0, U1); \
- /* test edge U1,U2 against V0,V1 */ \
- EDGE_EDGE_TEST(V0, U1, U2); \
- /* test edge U2,U1 against V0,V1 */ \
- EDGE_EDGE_TEST(V0, U2, U0); \
-}
-
-//! TO BE DOCUMENTED
-#define POINT_IN_TRI(V0, U0, U1, U2) \
-{ \
- /* is T1 completly inside T2? */ \
- /* check if V0 is inside tri(U0,U1,U2) */ \
- float a = U1[i1] - U0[i1]; \
- float b = -(U1[i0] - U0[i0]); \
- float c = -a*U0[i0] - b*U0[i1]; \
- float d0 = a*V0[i0] + b*V0[i1] + c; \
- \
- a = U2[i1] - U1[i1]; \
- b = -(U2[i0] - U1[i0]); \
- c = -a*U1[i0] - b*U1[i1]; \
- const float d1 = a*V0[i0] + b*V0[i1] + c; \
- \
- a = U0[i1] - U2[i1]; \
- b = -(U0[i0] - U2[i0]); \
- c = -a*U2[i0] - b*U2[i1]; \
- const float d2 = a*V0[i0] + b*V0[i1] + c; \
- if(d0*d1>0.0f) \
- { \
- if(d0*d2>0.0f) return TRUE; \
- } \
-}
-
-//! TO BE DOCUMENTED
-BOOL CoplanarTriTri(const IcePoint& n, const IcePoint& v0, const IcePoint& v1, const IcePoint& v2, const IcePoint& u0, const IcePoint& u1, const IcePoint& u2)
-{
- float A[3];
- short i0,i1;
- /* first project onto an axis-aligned plane, that maximizes the area */
- /* of the triangles, compute indices: i0,i1. */
- A[0] = fabsf(n[0]);
- A[1] = fabsf(n[1]);
- A[2] = fabsf(n[2]);
- if(A[0]>A[1])
- {
- if(A[0]>A[2])
- {
- i0=1; /* A[0] is greatest */
- i1=2;
- }
- else
- {
- i0=0; /* A[2] is greatest */
- i1=1;
- }
- }
- else /* A[0]<=A[1] */
- {
- if(A[2]>A[1])
- {
- i0=0; /* A[2] is greatest */
- i1=1;
- }
- else
- {
- i0=0; /* A[1] is greatest */
- i1=2;
- }
- }
-
- /* test all edges of triangle 1 against the edges of triangle 2 */
- EDGE_AGAINST_TRI_EDGES(v0, v1, u0, u1, u2);
- EDGE_AGAINST_TRI_EDGES(v1, v2, u0, u1, u2);
- EDGE_AGAINST_TRI_EDGES(v2, v0, u0, u1, u2);
-
- /* finally, test if tri1 is totally contained in tri2 or vice versa */
- POINT_IN_TRI(v0, u0, u1, u2);
- POINT_IN_TRI(u0, v0, v1, v2);
-
- return FALSE;
-}
-
-//! TO BE DOCUMENTED
-#define NEWCOMPUTE_INTERVALS(VV0, VV1, VV2, D0, D1, D2, D0D1, D0D2, A, B, C, X0, X1) \
-{ \
- if(D0D1>0.0f) \
- { \
- /* here we know that D0D2<=0.0 */ \
- /* that is D0, D1 are on the same side, D2 on the other or on the plane */ \
- A=VV2; B=(VV0 - VV2)*D2; C=(VV1 - VV2)*D2; X0=D2 - D0; X1=D2 - D1; \
- } \
- else if(D0D2>0.0f) \
- { \
- /* here we know that d0d1<=0.0 */ \
- A=VV1; B=(VV0 - VV1)*D1; C=(VV2 - VV1)*D1; X0=D1 - D0; X1=D1 - D2; \
- } \
- else if(D1*D2>0.0f || D0!=0.0f) \
- { \
- /* here we know that d0d1<=0.0 or that D0!=0.0 */ \
- A=VV0; B=(VV1 - VV0)*D0; C=(VV2 - VV0)*D0; X0=D0 - D1; X1=D0 - D2; \
- } \
- else if(D1!=0.0f) \
- { \
- A=VV1; B=(VV0 - VV1)*D1; C=(VV2 - VV1)*D1; X0=D1 - D0; X1=D1 - D2; \
- } \
- else if(D2!=0.0f) \
- { \
- A=VV2; B=(VV0 - VV2)*D2; C=(VV1 - VV2)*D2; X0=D2 - D0; X1=D2 - D1; \
- } \
- else \
- { \
- /* triangles are coplanar */ \
- return CoplanarTriTri(N1, V0, V1, V2, U0, U1, U2); \
- } \
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Triangle/triangle intersection test routine,
- * by Tomas Moller, 1997.
- * See article "A Fast Triangle-Triangle Intersection Test",
- * Journal of Graphics Tools, 2(2), 1997
- *
- * Updated June 1999: removed the divisions -- a little faster now!
- * Updated October 1999: added {} to CROSS and SUB macros
- *
- * int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3],
- * float U0[3],float U1[3],float U2[3])
- *
- * \param V0 [in] triangle 0, vertex 0
- * \param V1 [in] triangle 0, vertex 1
- * \param V2 [in] triangle 0, vertex 2
- * \param U0 [in] triangle 1, vertex 0
- * \param U1 [in] triangle 1, vertex 1
- * \param U2 [in] triangle 1, vertex 2
- * \return true if triangles overlap
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-inline_ BOOL AABBTreeCollider::TriTriOverlap(const IcePoint& V0, const IcePoint& V1, const IcePoint& V2, const IcePoint& U0, const IcePoint& U1, const IcePoint& U2)
-{
- // Stats
- mNbPrimPrimTests++;
-
- // Compute plane equation of triangle(V0,V1,V2)
- IcePoint E1 = V1 - V0;
- IcePoint E2 = V2 - V0;
- const IcePoint N1 = E1 ^ E2;
- const float d1 =-N1 | V0;
- // Plane equation 1: N1.X+d1=0
-
- // Put U0,U1,U2 into plane equation 1 to compute signed distances to the plane
- float du0 = (N1|U0) + d1;
- float du1 = (N1|U1) + d1;
- float du2 = (N1|U2) + d1;
-
- // Coplanarity robustness check
-#ifdef OPC_TRITRI_EPSILON_TEST
- if(fabsf(du0)<LOCAL_EPSILON) du0 = 0.0f;
- if(fabsf(du1)<LOCAL_EPSILON) du1 = 0.0f;
- if(fabsf(du2)<LOCAL_EPSILON) du2 = 0.0f;
-#endif
- const float du0du1 = du0 * du1;
- const float du0du2 = du0 * du2;
-
- if(du0du1>0.0f && du0du2>0.0f) // same sign on all of them + not equal 0 ?
- return FALSE; // no intersection occurs
-
- // Compute plane of triangle (U0,U1,U2)
- E1 = U1 - U0;
- E2 = U2 - U0;
- const IcePoint N2 = E1 ^ E2;
- const float d2=-N2 | U0;
- // plane equation 2: N2.X+d2=0
-
- // put V0,V1,V2 into plane equation 2
- float dv0 = (N2|V0) + d2;
- float dv1 = (N2|V1) + d2;
- float dv2 = (N2|V2) + d2;
-
-#ifdef OPC_TRITRI_EPSILON_TEST
- if(fabsf(dv0)<LOCAL_EPSILON) dv0 = 0.0f;
- if(fabsf(dv1)<LOCAL_EPSILON) dv1 = 0.0f;
- if(fabsf(dv2)<LOCAL_EPSILON) dv2 = 0.0f;
-#endif
-
- const float dv0dv1 = dv0 * dv1;
- const float dv0dv2 = dv0 * dv2;
-
- if(dv0dv1>0.0f && dv0dv2>0.0f) // same sign on all of them + not equal 0 ?
- return FALSE; // no intersection occurs
-
- // Compute direction of intersection line
- const IcePoint D = N1^N2;
-
- // Compute and index to the largest component of D
- float max=fabsf(D[0]);
- short index=0;
- float bb=fabsf(D[1]);
- float cc=fabsf(D[2]);
- if(bb>max) max=bb,index=1;
- if(cc>max) max=cc,index=2;
-
- // This is the simplified projection onto L
- const float vp0 = V0[index];
- const float vp1 = V1[index];
- const float vp2 = V2[index];
-
- const float up0 = U0[index];
- const float up1 = U1[index];
- const float up2 = U2[index];
-
- // Compute interval for triangle 1
- float a,b,c,x0,x1;
- NEWCOMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,a,b,c,x0,x1);
-
- // Compute interval for triangle 2
- float d,e,f,y0,y1;
- NEWCOMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,d,e,f,y0,y1);
-
- const float xx=x0*x1;
- const float yy=y0*y1;
- const float xxyy=xx*yy;
-
- float isect1[2], isect2[2];
-
- float tmp=a*xxyy;
- isect1[0]=tmp+b*x1*yy;
- isect1[1]=tmp+c*x0*yy;
-
- tmp=d*xxyy;
- isect2[0]=tmp+e*xx*y1;
- isect2[1]=tmp+f*xx*y0;
-
- SORT(isect1[0],isect1[1]);
- SORT(isect2[0],isect2[1]);
-
- if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return FALSE;
- return TRUE;
-}
diff --git a/Opcode/OpcodeLib/OPC_VolumeCollider.cpp b/Opcode/OpcodeLib/OPC_VolumeCollider.cpp deleted file mode 100644 index 70fc292..0000000 --- a/Opcode/OpcodeLib/OPC_VolumeCollider.cpp +++ /dev/null @@ -1,103 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains base volume collider class.
- * \file OPC_VolumeCollider.cpp
- * \author Pierre Terdiman
- * \date June, 2, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains the abstract class for volume colliders.
- *
- * \class VolumeCollider
- * \author Pierre Terdiman
- * \version 1.3
- * \date June, 2, 2001
-*/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-using namespace Opcode;
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Constructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-VolumeCollider::VolumeCollider() :
- mTouchedPrimitives (null),
- mNbVolumeBVTests (0),
- mNbVolumePrimTests (0)
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Destructor.
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-VolumeCollider::~VolumeCollider()
-{
- mTouchedPrimitives = null;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Validates current settings. You should call this method after all the settings / callbacks have been defined for a collider.
- * \return null if everything is ok, else a string describing the problem
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const char* VolumeCollider::ValidateSettings()
-{
- return null;
-}
-
-// Pretty dumb way to dump - to do better - one day...
-
-#define IMPLEMENT_NOLEAFDUMP(type) \
-void VolumeCollider::_Dump(const type* node) \
-{ \
- if(node->HasPosLeaf()) mTouchedPrimitives->Add(node->GetPosPrimitive()); \
- else _Dump(node->GetPos()); \
- \
- if(ContactFound()) return; \
- \
- if(node->HasNegLeaf()) mTouchedPrimitives->Add(node->GetNegPrimitive()); \
- else _Dump(node->GetNeg()); \
-}
-
-#define IMPLEMENT_LEAFDUMP(type) \
-void VolumeCollider::_Dump(const type* node) \
-{ \
- if(node->IsLeaf()) \
- { \
- mTouchedPrimitives->Add(node->GetPrimitive()); \
- } \
- else \
- { \
- _Dump(node->GetPos()); \
- \
- if(ContactFound()) return; \
- \
- _Dump(node->GetNeg()); \
- } \
-}
-
-IMPLEMENT_NOLEAFDUMP(AABBNoLeafNode)
-IMPLEMENT_NOLEAFDUMP(AABBQuantizedNoLeafNode)
-
-IMPLEMENT_LEAFDUMP(AABBCollisionNode)
-IMPLEMENT_LEAFDUMP(AABBQuantizedNode)
diff --git a/Opcode/OpcodeLib/OPC_VolumeCollider.h b/Opcode/OpcodeLib/OPC_VolumeCollider.h deleted file mode 100644 index 5c39ea3..0000000 --- a/Opcode/OpcodeLib/OPC_VolumeCollider.h +++ /dev/null @@ -1,138 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Contains base volume collider class.
- * \file OPC_VolumeCollider.h
- * \author Pierre Terdiman
- * \date June, 2, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPC_VOLUMECOLLIDER_H__
-#define __OPC_VOLUMECOLLIDER_H__
-
- struct OPCODE_API VolumeCache
- {
- VolumeCache() : Model(null) {}
- ~VolumeCache() {}
-
- Container TouchedPrimitives; //!< Indices of touched primitives
- const BaseModel* Model; //!< Owner
- };
-
- class OPCODE_API VolumeCollider : public Collider
- {
- public:
- // Constructor / Destructor
- VolumeCollider();
- virtual ~VolumeCollider() = 0;
-
- // Collision report
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the number of touched primitives after a collision query.
- * \see GetContactStatus()
- * \see GetTouchedPrimitives()
- * \return the number of touched primitives
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbTouchedPrimitives() const { return mTouchedPrimitives ? mTouchedPrimitives->GetNbEntries() : 0; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Gets the list of touched primitives after a collision query.
- * \see GetContactStatus()
- * \see GetNbTouchedPrimitives()
- * \return the list of touched primitives (primitive indices)
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ const udword* GetTouchedPrimitives() const { return mTouchedPrimitives ? mTouchedPrimitives->GetEntries() : null; }
-
- // Stats
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of Volume-BV overlap tests after a collision query.
- * \see GetNbVolumePrimTests()
- * \return the number of Volume-BV tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbVolumeBVTests() const { return mNbVolumeBVTests; }
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Stats: gets the number of Volume-Triangle overlap tests after a collision query.
- * \see GetNbVolumeBVTests()
- * \return the number of Volume-Triangle tests performed during last query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- inline_ udword GetNbVolumePrimTests() const { return mNbVolumePrimTests; }
-
- // Settings
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Validates current settings. You should call this method after all the settings / callbacks have been defined for a collider.
- * \return null if everything is ok, else a string describing the problem
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(Collider) const char* ValidateSettings();
-
- protected:
- // Touched primitives
- Container* mTouchedPrimitives; //!< List of touched primitives
-
- // Dequantization coeffs
- IcePoint mCenterCoeff;
- IcePoint mExtentsCoeff;
- // Stats
- udword mNbVolumeBVTests; //!< Number of Volume-BV tests
- udword mNbVolumePrimTests; //!< Number of Volume-Primitive tests
- // Internal methods
- void _Dump(const AABBCollisionNode* node);
- void _Dump(const AABBNoLeafNode* node);
- void _Dump(const AABBQuantizedNode* node);
- void _Dump(const AABBQuantizedNoLeafNode* node);
-
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- /**
- * Initializes a query
- */
- ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- override(Collider) inline_ void InitQuery()
- {
- // Reset stats & contact status
- mNbVolumeBVTests = 0;
- mNbVolumePrimTests = 0;
- Collider::InitQuery();
- }
-
- inline_ BOOL IsCacheValid(VolumeCache& cache)
- {
- // We're going to do a volume-vs-model query.
- if(cache.Model!=mCurrentModel)
- {
- // Cached list was for another model so we can't keep it
- // Keep track of new owner and reset cache
- cache.Model = mCurrentModel;
- return FALSE;
- }
- else
- {
- // Same models, no problem
- return TRUE;
- }
- }
- };
-
-#endif // __OPC_VOLUMECOLLIDER_H__
diff --git a/Opcode/OpcodeLib/Opcode.cpp b/Opcode/OpcodeLib/Opcode.cpp deleted file mode 100644 index 72d6b47..0000000 --- a/Opcode/OpcodeLib/Opcode.cpp +++ /dev/null @@ -1,65 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Main file for Opcode.dll.
- * \file Opcode.cpp
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/*
- Finding a good name is difficult!
- Here's the draft for this lib.... Spooky, uh?
-
- VOID? Very Optimized Interference Detection
- ZOID? Zappy's Optimized Interference Detection
- CID? Custom/Clever Interference Detection
- AID / ACID! Accurate Interference Detection
- QUID? Quick Interference Detection
- RIDE? Realtime Interference DEtection
- WIDE? Wicked Interference DEtection (....)
- GUID!
- KID ! k-dop interference detection :)
- OPCODE! OPtimized COllision DEtection
-*/
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Precompiled Header
-#include "Stdafx.h"
-
-bool Opcode::InitOpcode()
-{
- Log("// Initializing OPCODE\n\n");
-// LogAPIInfo();
- return true;
-}
-
-void ReleasePruningSorters();
-bool Opcode::CloseOpcode()
-{
- Log("// Closing OPCODE\n\n");
-
- ReleasePruningSorters();
-
- return true;
-}
-
-#ifdef ICE_MAIN
-
-void ModuleAttach(HINSTANCE hinstance)
-{
-}
-
-void ModuleDetach()
-{
-}
-
-#endif
\ No newline at end of file diff --git a/Opcode/OpcodeLib/Opcode.h b/Opcode/OpcodeLib/Opcode.h deleted file mode 100644 index 6078565..0000000 --- a/Opcode/OpcodeLib/Opcode.h +++ /dev/null @@ -1,64 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/**
- * Main file for Opcode.dll.
- * \file Opcode.h
- * \author Pierre Terdiman
- * \date March, 20, 2001
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Include Guard
-#ifndef __OPCODE_H__
-#define __OPCODE_H__
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Compilation messages
-#define OPCODE_API
-
- #include "OPC_IceHook.h"
-
- namespace Opcode
- {
- // Bulk-of-the-work
- #include "OPC_Settings.h"
- #include "OPC_Common.h"
- #include "OPC_MeshInterface.h"
- // Builders
- #include "OPC_TreeBuilders.h"
- // Trees
- #include "OPC_AABBTree.h"
- #include "OPC_OptimizedTree.h"
- // Models
- #include "OPC_BaseModel.h"
- #include "OPC_Model.h"
- #include "OPC_HybridModel.h"
- // Colliders
- #include "OPC_Collider.h"
- #include "OPC_VolumeCollider.h"
- #include "OPC_TreeCollider.h"
- #include "OPC_RayCollider.h"
- //#include "OPC_SphereCollider.h"
- #include "OPC_OBBCollider.h"
- #include "OPC_AABBCollider.h"
- //#include "OPC_LSSCollider.h"
- //#include "OPC_PlanesCollider.h"
- // Usages
- //#include "OPC_Picking.h"
- // Sweep-and-prune
- //#include "OPC_BoxPruning.h"
- //#include "OPC_SweepAndPrune.h"
-
- FUNCTION OPCODE_API bool InitOpcode();
- FUNCTION OPCODE_API bool CloseOpcode();
- }
-
-#endif // __OPCODE_H__
diff --git a/Opcode/OpcodeLib/Readme.txt b/Opcode/OpcodeLib/Readme.txt deleted file mode 100644 index c18bef1..0000000 --- a/Opcode/OpcodeLib/Readme.txt +++ /dev/null @@ -1,24 +0,0 @@ -========================================================================
- STATIC LIBRARY : OpcodeLib
-========================================================================
-
-
-AppWizard has created this OpcodeLib library for you.
-
-This file contains a summary of what you will find in each of the files that
-make up your OpcodeLib application.
-
-/////////////////////////////////////////////////////////////////////////////
-
-StdAfx.h, StdAfx.cpp
- These files are used to build a precompiled header (PCH) file
- named OpcodeLib.pch and a precompiled types file named StdAfx.obj.
-
-/////////////////////////////////////////////////////////////////////////////
-Other notes:
-
-AppWizard uses "TODO:" to indicate parts of the source code you
-should add to or customize.
-
-
-/////////////////////////////////////////////////////////////////////////////
diff --git a/Opcode/OpcodeLib/StdAfx.cpp b/Opcode/OpcodeLib/StdAfx.cpp deleted file mode 100644 index c9b75bb..0000000 --- a/Opcode/OpcodeLib/StdAfx.cpp +++ /dev/null @@ -1,10 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-//#define ICE_MAIN
-#include "Stdafx.h"
diff --git a/Opcode/OpcodeLib/StdAfx.h b/Opcode/OpcodeLib/StdAfx.h deleted file mode 100644 index 9988c25..0000000 --- a/Opcode/OpcodeLib/StdAfx.h +++ /dev/null @@ -1,24 +0,0 @@ -///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*
- * OPCODE - Optimized Collision Detection
- * Copyright (C) 2001 Pierre Terdiman
- * Homepage: http://www.codercorner.com/Opcode.htm
- */
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if !defined(AFX_STDAFX_H__EFB95044_1D31_11D5_8B0F_0050BAC83302__INCLUDED_)
-#define AFX_STDAFX_H__EFB95044_1D31_11D5_8B0F_0050BAC83302__INCLUDED_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif // _MSC_VER > 1000
-
-// Insert your headers here
-#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
-
-#include "Opcode.h"
-
-//{{AFX_INSERT_LOCATION}}
-// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
-
-#endif // !defined(AFX_STDAFX_H__EFB95044_1D31_11D5_8B0F_0050BAC83302__INCLUDED_)
diff --git a/Stars45/ActiveWindow.h b/Stars45/ActiveWindow.h index 2585e54..37c3d28 100644 --- a/Stars45/ActiveWindow.h +++ b/Stars45/ActiveWindow.h @@ -345,5 +345,5 @@ protected: #define UNREGISTER_CLIENT(eid, ctrl, cname)\ if (ctrl) ctrl->UnregisterClient(eid, this); -#endif ActiveWindow_h +#endif // ActiveWindow_h diff --git a/Stars45/Archive.h b/Stars45/Archive.h index 5818cf6..d56ad63 100644 --- a/Stars45/Archive.h +++ b/Stars45/Archive.h @@ -111,4 +111,4 @@ private: DWORD nblocks; }; -#endif Archive_h +#endif // Archive_h diff --git a/Stars45/Asteroid.h b/Stars45/Asteroid.h index 677aa8f..d79006d 100644 --- a/Stars45/Asteroid.h +++ b/Stars45/Asteroid.h @@ -55,5 +55,5 @@ public: static void Close(); }; -#endif Asteroid_h +#endif // Asteroid_h diff --git a/Stars45/AudDlg.h b/Stars45/AudDlg.h index 6e8628a..a360fcb 100644 --- a/Stars45/AudDlg.h +++ b/Stars45/AudDlg.h @@ -99,5 +99,5 @@ protected: bool closed; }; -#endif AudDlg_h +#endif // AudDlg_h diff --git a/Stars45/AudioConfig.h b/Stars45/AudioConfig.h index a4ba339..6ceec93 100644 --- a/Stars45/AudioConfig.h +++ b/Stars45/AudioConfig.h @@ -91,5 +91,5 @@ protected: bool training; }; -#endif AudioConfig_h +#endif // AudioConfig_h diff --git a/Stars45/AviFile.h b/Stars45/AviFile.h index 93de964..34de68c 100644 --- a/Stars45/AviFile.h +++ b/Stars45/AviFile.h @@ -84,4 +84,4 @@ private: // +--------------------------------------------------------------------+ -#endif AviFile_h +#endif // AviFile_h diff --git a/Stars45/AwardDlg.h b/Stars45/AwardDlg.h index adca746..c25b2da 100644 --- a/Stars45/AwardDlg.h +++ b/Stars45/AwardDlg.h @@ -79,5 +79,5 @@ protected: bool exit_latch; }; -#endif AwardDlg_h +#endif // AwardDlg_h diff --git a/Stars45/AwardShowDlg.h b/Stars45/AwardShowDlg.h index 522fec2..ccee315 100644 --- a/Stars45/AwardShowDlg.h +++ b/Stars45/AwardShowDlg.h @@ -83,5 +83,5 @@ protected: int medal; }; -#endif AwardShowDlg_h +#endif // AwardShowDlg_h diff --git a/Stars45/BaseScreen.h b/Stars45/BaseScreen.h index 0febb2a..5ca10fe 100644 --- a/Stars45/BaseScreen.h +++ b/Stars45/BaseScreen.h @@ -103,5 +103,5 @@ public: // +--------------------------------------------------------------------+ -#endif BaseScreen_h +#endif // BaseScreen_h diff --git a/Stars45/Bitmap.h b/Stars45/Bitmap.h index af9b6cb..654bb34 100644 --- a/Stars45/Bitmap.h +++ b/Stars45/Bitmap.h @@ -144,5 +144,5 @@ protected: char filename[64]; }; -#endif Bitmap_h +#endif // Bitmap_h diff --git a/Stars45/Bmp.h b/Stars45/Bmp.h index 4901d65..9f54621 100644 --- a/Stars45/Bmp.h +++ b/Stars45/Bmp.h @@ -97,4 +97,4 @@ struct BmpImage // +--------------------------------------------------------------------+ -#endif BMP_H +#endif // BMP_H diff --git a/Stars45/Bolt.h b/Stars45/Bolt.h index 9df4eb7..d831f36 100644 --- a/Stars45/Bolt.h +++ b/Stars45/Bolt.h @@ -85,5 +85,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Bolt_h +#endif // Bolt_h diff --git a/Stars45/Button.h b/Stars45/Button.h index 16c71df..20e4430 100644 --- a/Stars45/Button.h +++ b/Stars45/Button.h @@ -141,5 +141,5 @@ protected: Bitmap* transition_image; // state = 2 (if sticky) }; -#endif Button_h +#endif // Button_h diff --git a/Stars45/CMakeLists.txt b/Stars45/CMakeLists.txt index be5c744..65d7671 100644 --- a/Stars45/CMakeLists.txt +++ b/Stars45/CMakeLists.txt @@ -279,13 +279,6 @@ add_executable( target_include_directories( Stars45 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} - PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../Opcode/OpcodeLib # FIXME: Opcode is badly injured. - PUBLIC $ENV{DXSDK_DIR}/Include - PUBLIC ${WINDOWSSDK_PATH} # FIXME: Resolve this with a Find module or even find out why is going wrong - most sources say that it should be guaranteed. - ) -target_precompile_headers( - Stars45 - PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../Opcode/OpcodeLib/StdAfx.h ) target_link_libraries( Stars45 @@ -296,19 +289,44 @@ target_link_libraries( PUBLIC Vorbis::vorbisfile PUBLIC Ogg::ogg PUBLIC Png::png - PUBLIC Opcode # FIXME: Add opcode to a namespace. - PUBLIC ${WINDOWSSDK_LIBPATH}/Ws2_32.lib - PUBLIC ${WINDOWSSDK_LIBPATH}/Vfw32.lib - PUBLIC ${WINDOWSSDK_LIBPATH}/wsock32.lib - PUBLIC ${WINDOWSSDK_LIBPATH}/winmm.lib - PUBLIC ${WINDOWSSDK_LIBPATH}/version.lib - PUBLIC $ENV{DXSDK_DIR}/Lib/x86/dinput8.lib - PUBLIC $ENV{DXSDK_DIR}/Lib/x86/dsound.lib - PUBLIC $ENV{DXSDK_DIR}/Lib/x86/d3d9.lib - PUBLIC $ENV{DXSDK_DIR}/Lib/x86/d3dx9.lib - PUBLIC $ENV{DXSDK_DIR}/Lib/x86/dxguid.lib + PUBLIC Opcode ) target_compile_definitions( Stars45 PRIVATE _ALLOW_KEYWORD_MACROS ) +if(MSVC) + target_include_directories( + Stars45 + PUBLIC $ENV{DXSDK_DIR}/Include + PUBLIC ${WINDOWSSDK_PATH}/um + PUBLIC ${WINDOWSSDK_PATH}/shared + ) + target_link_libraries( + Stars45 + PUBLIC ${WINDOWSSDK_LIBPATH}/um/x86/Ws2_32.lib + PUBLIC ${WINDOWSSDK_LIBPATH}/um/x86/Vfw32.lib + PUBLIC ${WINDOWSSDK_LIBPATH}/um/x86/wsock32.lib + PUBLIC ${WINDOWSSDK_LIBPATH}/um/x86/winmm.lib + PUBLIC ${WINDOWSSDK_LIBPATH}/um/x86/version.lib + PUBLIC $ENV{DXSDK_DIR}/Lib/x86/dinput8.lib + PUBLIC $ENV{DXSDK_DIR}/Lib/x86/dsound.lib + PUBLIC $ENV{DXSDK_DIR}/Lib/x86/d3d9.lib + PUBLIC $ENV{DXSDK_DIR}/Lib/x86/d3dx9.lib + PUBLIC $ENV{DXSDK_DIR}/Lib/x86/dxguid.lib + ) +else() + target_link_libraries( + Stars45 + PUBLIC -l:libws2_32.a + PUBLIC -l:libvfw32.a + PUBLIC -l:libwsock32.a + PUBLIC -l:libwinmm.a + PUBLIC -l:libversion.a + PUBLIC -l:libdinput8.a + PUBLIC -l:libdsound.a + PUBLIC -l:libd3d9.a + PUBLIC -l:libd3dx9.a + PUBLIC -l:libdxguid.a + ) +endif() diff --git a/Stars45/Callsign.h b/Stars45/Callsign.h index 367b185..0c8b558 100644 --- a/Stars45/Callsign.h +++ b/Stars45/Callsign.h @@ -49,5 +49,5 @@ public: static const char* GetCallsign(int IFF=1); }; -#endif Callsign_h +#endif // Callsign_h diff --git a/Stars45/Camera.h b/Stars45/Camera.h index cd3291a..947f7d6 100644 --- a/Stars45/Camera.h +++ b/Stars45/Camera.h @@ -81,5 +81,5 @@ protected: Matrix orientation; }; -#endif Camera_h +#endif // Camera_h diff --git a/Stars45/CameraDirector.h b/Stars45/CameraDirector.h index ac3a378..f9678c2 100644 --- a/Stars45/CameraDirector.h +++ b/Stars45/CameraDirector.h @@ -176,5 +176,5 @@ protected: static CameraDirector* instance; }; -#endif CameraDirector_h +#endif // CameraDirector_h diff --git a/Stars45/CameraView.h b/Stars45/CameraView.h index 2ab133c..20ba474 100644 --- a/Stars45/CameraView.h +++ b/Stars45/CameraView.h @@ -134,5 +134,5 @@ protected: List<Graphic> graphics; }; -#endif CameraView_h +#endif // CameraView_h diff --git a/Stars45/Campaign.cpp b/Stars45/Campaign.cpp index 499e36a..1b23d14 100644 --- a/Stars45/Campaign.cpp +++ b/Stars45/Campaign.cpp @@ -848,7 +848,7 @@ Campaign::ParseAction(TermStruct* val, const char* filename) int act = 0; int stat = CombatAction::COMPLETE; - bool not = false; + bool _not = false; Combatant* c1 = 0; Combatant* c2 = 0; @@ -870,7 +870,7 @@ Campaign::ParseAction(TermStruct* val, const char* filename) stat = CombatAction::StatusFromName(txt); } else if (pdef2->name()->value() == "not") { - GetDefBool(not, pdef2, filename); + GetDefBool(_not, pdef2, filename); } else if (pdef2->name()->value() == "c1") { @@ -913,7 +913,7 @@ Campaign::ParseAction(TermStruct* val, const char* filename) } if (act) - action->AddRequirement(act, stat, not); + action->AddRequirement(act, stat, _not); else if (gtype) action->AddRequirement(c1, gtype, gid, comp, score, intel); @@ -1871,7 +1871,7 @@ Campaign::SetMissionId(int id) // +--------------------------------------------------------------------+ -double +long double Campaign::Stardate() { return StarSystem::Stardate(); @@ -2058,8 +2058,6 @@ Campaign::CheckPlayerGroup() // +--------------------------------------------------------------------+ -void FPU2Extended(); -void FPURestore(); void Campaign::StartMission() @@ -2070,14 +2068,12 @@ Campaign::StartMission() ::Print("\n\nCampaign Start Mission - %d. '%s'\n", m->Identity(), m->Name()); if (!scripted) { - FPU2Extended(); - - double gtime = (double) Game::GameTime() / 1000.0; - double base = startTime + m->Start() - 15 - gtime; + long double gtime = (long double) Game::GameTime() / 1000.0; + long double base = startTime + m->Start() - 15 - gtime; StarSystem::SetBaseTime(base); - double current_time = Stardate() - startTime; + long double current_time = Stardate() - startTime; char buffer[32]; FormatDayTime(buffer, current_time); @@ -2099,14 +2095,12 @@ Campaign::RollbackMission() if (m) { if (!scripted) { - FPU2Extended(); - - double gtime = (double) Game::GameTime() / 1000.0; - double base = startTime + m->Start() - 60 - gtime; + long double gtime = (long double) Game::GameTime() / 1000.0; + long double base = startTime + m->Start() - 60 - gtime; StarSystem::SetBaseTime(base); - double current_time = Stardate() - startTime; + long double current_time = Stardate() - startTime; ::Print(" mission start: %d\n", m->Start()); ::Print(" current time: %d\n", (int) current_time); } diff --git a/Stars45/Campaign.h b/Stars45/Campaign.h index 4465186..ecfa236 100644 --- a/Stars45/Campaign.h +++ b/Stars45/Campaign.h @@ -213,13 +213,13 @@ public: void SetMissionId(int id); int GetMissionId() const { return mission_id; } Bitmap* GetImage(int n) { return &image[n]; } - double GetTime() const { return time; } - double GetStartTime() const { return startTime; } - void SetStartTime(double t) { startTime = t; } - double GetLoadTime() const { return loadTime; } - void SetLoadTime(double t) { loadTime = t; } - double GetUpdateTime() const { return updateTime; } - void SetUpdateTime(double t) { updateTime = t; } + long double GetTime() const { return time; } + long double GetStartTime() const { return startTime; } + void SetStartTime(long double t) { startTime = t; } + long double GetLoadTime() const { return loadTime; } + void SetLoadTime(long double t) { loadTime = t; } + long double GetUpdateTime() const { return updateTime; } + void SetUpdateTime(long double t) { updateTime = t; } bool InCutscene() const; bool IsDynamic() const; @@ -246,7 +246,7 @@ public: static Campaign* SelectCampaign(const char* name); static Campaign* CreateCustomCampaign(const char* name, const char* path); - static double Stardate(); + static long double Stardate(); protected: void LoadCampaign(DataLoader* loader, bool full=false); @@ -295,12 +295,12 @@ protected: Mission* mission; Mission* net_mission; - double time; - double loadTime; - double startTime; - double updateTime; + long double time; + long double loadTime; + long double startTime; + long double updateTime; int lockout; }; -#endif Campaign_h +#endif // Campaign_h diff --git a/Stars45/CampaignMissionFighter.h b/Stars45/CampaignMissionFighter.h index 84b1906..844d33a 100644 --- a/Stars45/CampaignMissionFighter.h +++ b/Stars45/CampaignMissionFighter.h @@ -141,5 +141,5 @@ protected: int mission_type; }; -#endif CampaignMissionFighter_h +#endif // CampaignMissionFighter_h diff --git a/Stars45/CampaignMissionRequest.h b/Stars45/CampaignMissionRequest.h index a45dd45..a000428 100644 --- a/Stars45/CampaignMissionRequest.h +++ b/Stars45/CampaignMissionRequest.h @@ -104,5 +104,5 @@ private: Text script; }; -#endif CampaignMissionRequest_h +#endif // CampaignMissionRequest_h diff --git a/Stars45/CampaignMissionStarship.h b/Stars45/CampaignMissionStarship.h index 8e0e329..d461378 100644 --- a/Stars45/CampaignMissionStarship.h +++ b/Stars45/CampaignMissionStarship.h @@ -127,5 +127,5 @@ protected: int mission_type; }; -#endif CampaignMissionStarship_h +#endif // CampaignMissionStarship_h diff --git a/Stars45/CampaignPlan.h b/Stars45/CampaignPlan.h index 2cacb3f..6716a79 100644 --- a/Stars45/CampaignPlan.h +++ b/Stars45/CampaignPlan.h @@ -78,5 +78,5 @@ protected: double exec_time; }; -#endif CampaignPlan_h +#endif // CampaignPlan_h diff --git a/Stars45/CampaignPlanAssignment.h b/Stars45/CampaignPlanAssignment.h index 2037477..fe71d77 100644 --- a/Stars45/CampaignPlanAssignment.h +++ b/Stars45/CampaignPlanAssignment.h @@ -70,5 +70,5 @@ protected: virtual void BuildAssetList(const int* pref, List<CombatGroup>& avail, List<CombatGroup>& assets); }; -#endif CampaignPlanAssignment_h +#endif // CampaignPlanAssignment_h diff --git a/Stars45/CampaignPlanEvent.h b/Stars45/CampaignPlanEvent.h index ccbf7b0..2ecd874 100644 --- a/Stars45/CampaignPlanEvent.h +++ b/Stars45/CampaignPlanEvent.h @@ -92,5 +92,5 @@ protected: int event_time; }; -#endif CampaignPlanEvent_h +#endif // CampaignPlanEvent_h diff --git a/Stars45/CampaignPlanMission.h b/Stars45/CampaignPlanMission.h index d61b751..2a43736 100644 --- a/Stars45/CampaignPlanMission.h +++ b/Stars45/CampaignPlanMission.h @@ -78,5 +78,5 @@ protected: int slot; }; -#endif CampaignPlanMission_h +#endif // CampaignPlanMission_h diff --git a/Stars45/CampaignPlanMovement.h b/Stars45/CampaignPlanMovement.h index c2417fc..8a53b25 100644 --- a/Stars45/CampaignPlanMovement.h +++ b/Stars45/CampaignPlanMovement.h @@ -64,5 +64,5 @@ protected: List<CombatUnit> all_units; }; -#endif CampaignPlanMovement_h +#endif // CampaignPlanMovement_h diff --git a/Stars45/CampaignPlanStrategic.h b/Stars45/CampaignPlanStrategic.h index c9c98d2..59e3ae7 100644 --- a/Stars45/CampaignPlanStrategic.h +++ b/Stars45/CampaignPlanStrategic.h @@ -79,5 +79,5 @@ protected: void ResolveZoneMovement(CombatGroup* g); }; -#endif CampaignPlanStrategic_h +#endif // CampaignPlanStrategic_h diff --git a/Stars45/CampaignSaveGame.h b/Stars45/CampaignSaveGame.h index fe8ec3a..b53a918 100644 --- a/Stars45/CampaignSaveGame.h +++ b/Stars45/CampaignSaveGame.h @@ -89,5 +89,5 @@ private: Campaign* campaign; }; -#endif CampaignSaveGame_h +#endif // CampaignSaveGame_h diff --git a/Stars45/CampaignSituationReport.h b/Stars45/CampaignSituationReport.h index a8e8658..55d3658 100644 --- a/Stars45/CampaignSituationReport.h +++ b/Stars45/CampaignSituationReport.h @@ -79,5 +79,5 @@ protected: Text sitrep; }; -#endif CampaignSituationReport_h +#endif // CampaignSituationReport_h diff --git a/Stars45/CarrierAI.h b/Stars45/CarrierAI.h index 9f9bd80..6e7c1a0 100644 --- a/Stars45/CarrierAI.h +++ b/Stars45/CarrierAI.h @@ -84,5 +84,5 @@ protected: // +--------------------------------------------------------------------+ -#endif CarrierAI_h +#endif // CarrierAI_h diff --git a/Stars45/CmdDlg.h b/Stars45/CmdDlg.h index 5709d38..0a97663 100644 --- a/Stars45/CmdDlg.h +++ b/Stars45/CmdDlg.h @@ -103,5 +103,5 @@ protected: int mode; }; -#endif CmdDlg_h +#endif // CmdDlg_h diff --git a/Stars45/CmdForceDlg.h b/Stars45/CmdForceDlg.h index ad9d57f..84613c9 100644 --- a/Stars45/CmdForceDlg.h +++ b/Stars45/CmdForceDlg.h @@ -89,5 +89,5 @@ protected: CombatUnit* current_unit; }; -#endif CmdForceDlg_h +#endif // CmdForceDlg_h diff --git a/Stars45/CmdIntelDlg.h b/Stars45/CmdIntelDlg.h index f0479b2..9d66c04 100644 --- a/Stars45/CmdIntelDlg.h +++ b/Stars45/CmdIntelDlg.h @@ -96,5 +96,5 @@ protected: Text event_scene; }; -#endif CmdIntelDlg_h +#endif // CmdIntelDlg_h diff --git a/Stars45/CmdMissionsDlg.h b/Stars45/CmdMissionsDlg.h index 7d449f9..99ea1ca 100644 --- a/Stars45/CmdMissionsDlg.h +++ b/Stars45/CmdMissionsDlg.h @@ -85,5 +85,5 @@ protected: Mission* mission; }; -#endif CmdMissionsDlg_h +#endif // CmdMissionsDlg_h diff --git a/Stars45/CmdMsgDlg.h b/Stars45/CmdMsgDlg.h index 89c1ab2..9f7592f 100644 --- a/Stars45/CmdMsgDlg.h +++ b/Stars45/CmdMsgDlg.h @@ -74,5 +74,5 @@ protected: bool exit_latch; }; -#endif CmdMsgDlg_h +#endif // CmdMsgDlg_h diff --git a/Stars45/CmdOrdersDlg.h b/Stars45/CmdOrdersDlg.h index 3aafb98..652dcf8 100644 --- a/Stars45/CmdOrdersDlg.h +++ b/Stars45/CmdOrdersDlg.h @@ -76,5 +76,5 @@ protected: Campaign* campaign; }; -#endif CmdOrdersDlg_h +#endif // CmdOrdersDlg_h diff --git a/Stars45/CmdTheaterDlg.h b/Stars45/CmdTheaterDlg.h index 7cd8ff3..d42c7e3 100644 --- a/Stars45/CmdTheaterDlg.h +++ b/Stars45/CmdTheaterDlg.h @@ -82,5 +82,5 @@ protected: Campaign* campaign; }; -#endif CmdTheaterDlg_h +#endif // CmdTheaterDlg_h diff --git a/Stars45/CmdTitleDlg.h b/Stars45/CmdTitleDlg.h index e092a9d..216ebfc 100644 --- a/Stars45/CmdTitleDlg.h +++ b/Stars45/CmdTitleDlg.h @@ -76,5 +76,5 @@ protected: double showTime; }; -#endif CmdTitleDlg_h +#endif // CmdTitleDlg_h diff --git a/Stars45/CmpCompleteDlg.h b/Stars45/CmpCompleteDlg.h index 5716714..c6b36ef 100644 --- a/Stars45/CmpCompleteDlg.h +++ b/Stars45/CmpCompleteDlg.h @@ -70,5 +70,5 @@ protected: CmpnScreen* manager; }; -#endif CmpCompleteDlg_h +#endif // CmpCompleteDlg_h diff --git a/Stars45/CmpFileDlg.h b/Stars45/CmpFileDlg.h index 1d21f7a..7e591b2 100644 --- a/Stars45/CmpFileDlg.h +++ b/Stars45/CmpFileDlg.h @@ -84,5 +84,5 @@ protected: bool exit_latch; }; -#endif CmpFileDlg_h +#endif // CmpFileDlg_h diff --git a/Stars45/CmpLoadDlg.h b/Stars45/CmpLoadDlg.h index 876f13c..3a210ce 100644 --- a/Stars45/CmpLoadDlg.h +++ b/Stars45/CmpLoadDlg.h @@ -66,5 +66,5 @@ protected: DWORD show_time; }; -#endif CmpLoadDlg_h +#endif // CmpLoadDlg_h diff --git a/Stars45/CmpSceneDlg.h b/Stars45/CmpSceneDlg.h index f06d7d8..19fda11 100644 --- a/Stars45/CmpSceneDlg.h +++ b/Stars45/CmpSceneDlg.h @@ -88,5 +88,5 @@ protected: double subtitles_time; }; -#endif CmpSceneDlg_h +#endif // CmpSceneDlg_h diff --git a/Stars45/CmpSelectDlg.h b/Stars45/CmpSelectDlg.h index 10274a7..b227eef 100644 --- a/Stars45/CmpSelectDlg.h +++ b/Stars45/CmpSelectDlg.h @@ -111,5 +111,5 @@ protected: Text select_msg; }; -#endif CmpSelectDlg_h +#endif // CmpSelectDlg_h diff --git a/Stars45/CmpnScreen.h b/Stars45/CmpnScreen.h index 3d557d6..6c589f6 100644 --- a/Stars45/CmpnScreen.h +++ b/Stars45/CmpnScreen.h @@ -157,5 +157,5 @@ private: // +--------------------------------------------------------------------+ -#endif CmpnScreen_h +#endif // CmpnScreen_h diff --git a/Stars45/Color.h b/Stars45/Color.h index 9bca5c9..7788875 100644 --- a/Stars45/Color.h +++ b/Stars45/Color.h @@ -315,5 +315,5 @@ private: inline BYTE Color::IndexedBlend(BYTE dst) const { return ColorIndex::blend_table[dst*256+Index()]; } -#endif Color_h +#endif // Color_h diff --git a/Stars45/CombatAction.cpp b/Stars45/CombatAction.cpp index 15d17a6..ed2fba7 100644 --- a/Stars45/CombatAction.cpp +++ b/Stars45/CombatAction.cpp @@ -108,7 +108,7 @@ CombatAction::IsAvailable() const CombatAction* a = action.value(); if (a->Identity() == r->action) { - if (r->not) { + if (r->_not) { if (a->Status() == r->stat) return false; } @@ -230,9 +230,9 @@ CombatAction::FailAction() // +----------------------------------------------------------------------+ void -CombatAction::AddRequirement(int action, int stat, bool not) +CombatAction::AddRequirement(int action, int stat, bool _not) { - requirements.append(new(__FILE__,__LINE__) CombatActionReq(action, stat, not)); + requirements.append(new(__FILE__,__LINE__) CombatActionReq(action, stat, _not)); } void diff --git a/Stars45/CombatAction.h b/Stars45/CombatAction.h index c247d06..a2af69d 100644 --- a/Stars45/CombatAction.h +++ b/Stars45/CombatAction.h @@ -87,7 +87,7 @@ public: bool IsAvailable() const; void FireAction(); void FailAction(); - void AddRequirement(int action, int stat, bool not = false); + void AddRequirement(int action, int stat, bool _not = false); void AddRequirement(Combatant* c1, Combatant* c2, int comp, int score); void AddRequirement(Combatant* c1, int group_type, int group_id, int comp, int score, int intel=0); static int TypeFromName(const char* n); @@ -200,21 +200,21 @@ public: }; CombatActionReq(int a, int s, bool n = false) - : action(a), stat(s), not(n), c1(0), c2(0), comp(0), score(0), intel(0) { } + : action(a), stat(s), _not(n), c1(0), c2(0), comp(0), score(0), intel(0) { } CombatActionReq(Combatant* a1, Combatant* a2, int comparison, int value) - : action(0), stat(0), not(0), c1(a1), c2(a2), group_type(0), group_id(0), + : action(0), stat(0), _not(0), c1(a1), c2(a2), group_type(0), group_id(0), comp(comparison), score(value), intel(0) { } CombatActionReq(Combatant* a1, int gtype, int gid, int comparison, int value, int intel_level=0) - : action(0), stat(0), not(0), c1(a1), c2(0), group_type(gtype), group_id(gid), + : action(0), stat(0), _not(0), c1(a1), c2(0), group_type(gtype), group_id(gid), comp(comparison), score(value), intel(intel_level) { } static int CompFromName(const char* sym); int action; int stat; - bool not; + bool _not; Combatant* c1; Combatant* c2; @@ -225,5 +225,5 @@ public: int group_id; }; -#endif CombatAction_h +#endif // CombatAction_h diff --git a/Stars45/CombatAssignment.h b/Stars45/CombatAssignment.h index 549a483..a366af4 100644 --- a/Stars45/CombatAssignment.h +++ b/Stars45/CombatAssignment.h @@ -78,4 +78,4 @@ private: }; -#endif CombatAssignment_h +#endif // CombatAssignment_h diff --git a/Stars45/CombatEvent.h b/Stars45/CombatEvent.h index 63eab6f..bbfec99 100644 --- a/Stars45/CombatEvent.h +++ b/Stars45/CombatEvent.h @@ -142,5 +142,5 @@ private: Bitmap image; }; -#endif CombatEvent_h +#endif // CombatEvent_h diff --git a/Stars45/CombatGroup.h b/Stars45/CombatGroup.h index ac6fcb1..7a49c1d 100644 --- a/Stars45/CombatGroup.h +++ b/Stars45/CombatGroup.h @@ -251,5 +251,5 @@ private: Text strategic_direction; }; -#endif CombatGroup_h +#endif // CombatGroup_h diff --git a/Stars45/CombatRoster.h b/Stars45/CombatRoster.h index a7789ff..068ec69 100644 --- a/Stars45/CombatRoster.h +++ b/Stars45/CombatRoster.h @@ -69,4 +69,4 @@ private: }; -#endif CombatRoster_h +#endif // CombatRoster_h diff --git a/Stars45/CombatUnit.h b/Stars45/CombatUnit.h index b80f8dc..6f98227 100644 --- a/Stars45/CombatUnit.h +++ b/Stars45/CombatUnit.h @@ -153,5 +153,5 @@ private: CombatGroup* group; }; -#endif CombatUnit_h +#endif // CombatUnit_h diff --git a/Stars45/CombatZone.h b/Stars45/CombatZone.h index 360a992..b53c844 100644 --- a/Stars45/CombatZone.h +++ b/Stars45/CombatZone.h @@ -123,5 +123,5 @@ private: // +--------------------------------------------------------------------+ -#endif CombatZone_h +#endif // CombatZone_h diff --git a/Stars45/Combatant.h b/Stars45/Combatant.h index 0a73ae6..e3a79be 100644 --- a/Stars45/Combatant.h +++ b/Stars45/Combatant.h @@ -94,4 +94,4 @@ private: }; -#endif Combatant_h +#endif // Combatant_h diff --git a/Stars45/ComboBox.h b/Stars45/ComboBox.h index 4d50c73..145a156 100644 --- a/Stars45/ComboBox.h +++ b/Stars45/ComboBox.h @@ -125,5 +125,5 @@ protected: Color border_color; }; -#endif ComboBox_h +#endif // ComboBox_h diff --git a/Stars45/ComboList.cpp b/Stars45/ComboList.cpp index 4bf35cc..d070b9f 100644 --- a/Stars45/ComboList.cpp +++ b/Stars45/ComboList.cpp @@ -36,6 +36,10 @@ Drop-down list of Buttons class */ +#define NOMINMAX + +#include <algorithm> + #include "MemDebug.h" #include "ComboList.h" #include "ComboBox.h" @@ -168,7 +172,7 @@ ComboList::Draw() // opening: if (scrolling > 0) { - int limit = min(items.size(), max_entries); + int limit = std::min(items.size(), max_entries); if (scroll < limit) { if (limit > 6) diff --git a/Stars45/ComboList.h b/Stars45/ComboList.h index aea08fc..4d01f15 100644 --- a/Stars45/ComboList.h +++ b/Stars45/ComboList.h @@ -112,5 +112,5 @@ protected: Color border_color; }; -#endif ComboList_h +#endif // ComboList_h diff --git a/Stars45/Component.h b/Stars45/Component.h index 3c53093..cff50e8 100644 --- a/Stars45/Component.h +++ b/Stars45/Component.h @@ -120,5 +120,5 @@ protected: System* system; }; -#endif Component_h +#endif // Component_h diff --git a/Stars45/Computer.h b/Stars45/Computer.h index 1eb2f01..a4e23d7 100644 --- a/Stars45/Computer.h +++ b/Stars45/Computer.h @@ -61,5 +61,5 @@ public: protected: }; -#endif Computer_h +#endif // Computer_h diff --git a/Stars45/ConfirmDlg.h b/Stars45/ConfirmDlg.h index 2b1db43..2edfd53 100644 --- a/Stars45/ConfirmDlg.h +++ b/Stars45/ConfirmDlg.h @@ -84,5 +84,5 @@ protected: ActiveWindow* parent_control; }; -#endif ConfirmDlg_h +#endif // ConfirmDlg_h diff --git a/Stars45/Contact.h b/Stars45/Contact.h index f4e4000..aed6354 100644 --- a/Stars45/Contact.h +++ b/Stars45/Contact.h @@ -111,5 +111,5 @@ private: bool probe; // scanned by probe }; -#endif Contact_h +#endif // Contact_h diff --git a/Stars45/ContentBundle.h b/Stars45/ContentBundle.h index d75a817..e7207cf 100644 --- a/Stars45/ContentBundle.h +++ b/Stars45/ContentBundle.h @@ -68,5 +68,5 @@ protected: Dictionary<Text> values; }; -#endif ContentBundle_h +#endif // ContentBundle_h diff --git a/Stars45/CtlDlg.h b/Stars45/CtlDlg.h index 95ab595..b970c53 100644 --- a/Stars45/CtlDlg.h +++ b/Stars45/CtlDlg.h @@ -139,5 +139,5 @@ protected: bool closed; }; -#endif CtlDlg_h +#endif // CtlDlg_h diff --git a/Stars45/D3DXImage.h b/Stars45/D3DXImage.h index b6f689d..dbba149 100644 --- a/Stars45/D3DXImage.h +++ b/Stars45/D3DXImage.h @@ -64,4 +64,4 @@ struct D3DXImage // +--------------------------------------------------------------------+ -#endif D3DXImage_h +#endif // D3DXImage_h diff --git a/Stars45/DataLoader.h b/Stars45/DataLoader.h index ca7b050..d6f2845 100644 --- a/Stars45/DataLoader.h +++ b/Stars45/DataLoader.h @@ -106,5 +106,5 @@ private: // +--------------------------------------------------------------------+ -#endif DataLoader_h +#endif // DataLoader_h diff --git a/Stars45/DebriefDlg.h b/Stars45/DebriefDlg.h index 77923e9..f6a4338 100644 --- a/Stars45/DebriefDlg.h +++ b/Stars45/DebriefDlg.h @@ -101,5 +101,5 @@ protected: Ship* ship; }; -#endif DebriefDlg_h +#endif // DebriefDlg_h diff --git a/Stars45/Debris.h b/Stars45/Debris.h index adf4810..6dc6016 100644 --- a/Stars45/Debris.h +++ b/Stars45/Debris.h @@ -63,5 +63,5 @@ public: virtual double AltitudeAGL() const; }; -#endif Debris_h +#endif // Debris_h diff --git a/Stars45/DetailSet.h b/Stars45/DetailSet.h index 7e8c21b..3648e7f 100644 --- a/Stars45/DetailSet.h +++ b/Stars45/DetailSet.h @@ -93,5 +93,5 @@ protected: // +--------------------------------------------------------------------+ -#endif DetailSet_h +#endif // DetailSet_h diff --git a/Stars45/Director.h b/Stars45/Director.h index 94f635f..d34805d 100644 --- a/Stars45/Director.h +++ b/Stars45/Director.h @@ -64,5 +64,5 @@ public: // +--------------------------------------------------------------------+ -#endif Director_h +#endif // Director_h diff --git a/Stars45/DisplayView.h b/Stars45/DisplayView.h index 08c31b8..3fec85e 100644 --- a/Stars45/DisplayView.h +++ b/Stars45/DisplayView.h @@ -91,5 +91,5 @@ protected: elements; }; -#endif DisplayView_h +#endif // DisplayView_h diff --git a/Stars45/Drive.cpp b/Stars45/Drive.cpp index 8cf6dd0..570721d 100644 --- a/Stars45/Drive.cpp +++ b/Stars45/Drive.cpp @@ -36,6 +36,10 @@ Weapon class */ +#define NOMINMAX + +#include <algorithm> + #include "MemDebug.h" #include "Drive.h" #include "Power.h" @@ -355,7 +359,7 @@ Drive::GetRequest(double seconds) const { if (!power_on) return 0; - double t_factor = max(throttle + 0.5 * augmenter_throttle, 0.3); + double t_factor = std::max(throttle + 0.5 * augmenter_throttle, 0.3); return t_factor * power_level * sink_rate * seconds; } diff --git a/Stars45/Drive.h b/Stars45/Drive.h index 9a99539..5c858cc 100644 --- a/Stars45/Drive.h +++ b/Stars45/Drive.h @@ -113,5 +113,5 @@ protected: bool show_trail; }; -#endif Drive_h +#endif // Drive_h diff --git a/Stars45/DriveSprite.h b/Stars45/DriveSprite.h index a07a726..99b774c 100644 --- a/Stars45/DriveSprite.h +++ b/Stars45/DriveSprite.h @@ -67,5 +67,5 @@ protected: // +--------------------------------------------------------------------+ -#endif DriveSprite_h +#endif // DriveSprite_h diff --git a/Stars45/Drone.h b/Stars45/Drone.h index c4e1126..e4b4893 100644 --- a/Stars45/Drone.h +++ b/Stars45/Drone.h @@ -89,5 +89,5 @@ protected: int probe; }; -#endif Drone_h +#endif // Drone_h diff --git a/Stars45/DropShipAI.h b/Stars45/DropShipAI.h index 13ba5c9..52d480f 100644 --- a/Stars45/DropShipAI.h +++ b/Stars45/DropShipAI.h @@ -67,5 +67,5 @@ protected: // +--------------------------------------------------------------------+ -#endif DropShipAI_h +#endif // DropShipAI_h diff --git a/Stars45/EditBox.h b/Stars45/EditBox.h index ac3186b..add604e 100644 --- a/Stars45/EditBox.h +++ b/Stars45/EditBox.h @@ -112,5 +112,5 @@ protected: Color selected_color; }; -#endif EditBox_h +#endif // EditBox_h diff --git a/Stars45/Element.h b/Stars45/Element.h index 2207d8a..cc2cc00 100644 --- a/Stars45/Element.h +++ b/Stars45/Element.h @@ -192,5 +192,5 @@ protected: int load[16]; }; -#endif Element_h +#endif // Element_h diff --git a/Stars45/Encrypt.h b/Stars45/Encrypt.h index 16cf400..d4336bf 100644 --- a/Stars45/Encrypt.h +++ b/Stars45/Encrypt.h @@ -59,4 +59,4 @@ public: static Text Decode(Text block); }; -#endif Encrypt_h
\ No newline at end of file +#endif // Encrypt_h
\ No newline at end of file diff --git a/Stars45/EngDlg.h b/Stars45/EngDlg.h index cf6d8ed..d191ca1 100644 --- a/Stars45/EngDlg.h +++ b/Stars45/EngDlg.h @@ -126,5 +126,5 @@ protected: Component* selected_component; }; -#endif EngDlg_h +#endif // EngDlg_h diff --git a/Stars45/EventDispatch.h b/Stars45/EventDispatch.h index 08240d0..460c8d5 100644 --- a/Stars45/EventDispatch.h +++ b/Stars45/EventDispatch.h @@ -82,5 +82,5 @@ protected: static EventDispatch* dispatcher; }; -#endif EventDispatch_h +#endif // EventDispatch_h diff --git a/Stars45/EventTarget.h b/Stars45/EventTarget.h index fe8d8ed..909d5da 100644 --- a/Stars45/EventTarget.h +++ b/Stars45/EventTarget.h @@ -79,5 +79,5 @@ public: virtual const char* GetDescription() const { return "EventTarget"; } }; -#endif EventTarget_h +#endif // EventTarget_h diff --git a/Stars45/ExceptionHandler.cpp b/Stars45/ExceptionHandler.cpp index 17519be..6233b7a 100644 --- a/Stars45/ExceptionHandler.cpp +++ b/Stars45/ExceptionHandler.cpp @@ -32,6 +32,9 @@ */ +#define NOMINMAX + +#include <algorithm> #include <windows.h> #include <imagehlp.h> @@ -265,7 +268,7 @@ ExceptionHandler::GetLogicalAddress(void* addr, char* mod_name, int len, DWORD& for (unsigned i = 0; i < pNtHdr->FileHeader.NumberOfSections; i++, pSection++ ) { DWORD sectionStart = pSection->VirtualAddress; DWORD sectionEnd = sectionStart - + max(pSection->SizeOfRawData, pSection->Misc.VirtualSize); + + std::max(pSection->SizeOfRawData, pSection->Misc.VirtualSize); // Is the address in this section??? if ((rva >= sectionStart) && (rva <= sectionEnd)) { diff --git a/Stars45/ExitDlg.h b/Stars45/ExitDlg.h index b780d95..c6e9ab0 100644 --- a/Stars45/ExitDlg.h +++ b/Stars45/ExitDlg.h @@ -80,5 +80,5 @@ protected: bool exit_latch; }; -#endif ExitDlg_h +#endif // ExitDlg_h diff --git a/Stars45/Explosion.h b/Stars45/Explosion.h index 4507f4f..f277131 100644 --- a/Stars45/Explosion.h +++ b/Stars45/Explosion.h @@ -104,5 +104,5 @@ protected: Point mount_rel; }; -#endif Explosion_h +#endif // Explosion_h diff --git a/Stars45/FadeView.h b/Stars45/FadeView.h index 3b49c70..beddff8 100644 --- a/Stars45/FadeView.h +++ b/Stars45/FadeView.h @@ -76,5 +76,5 @@ protected: FadeState state; }; -#endif FadeView_h +#endif // FadeView_h diff --git a/Stars45/Farcaster.h b/Stars45/Farcaster.h index cd4bcbf..05324f5 100644 --- a/Stars45/Farcaster.h +++ b/Stars45/Farcaster.h @@ -112,5 +112,5 @@ protected: // +----------------------------------------------------------------------+ -#endif Farcaster_h +#endif // Farcaster_h diff --git a/Stars45/FighterAI.h b/Stars45/FighterAI.h index 4ac5c1c..9c7a92e 100644 --- a/Stars45/FighterAI.h +++ b/Stars45/FighterAI.h @@ -105,5 +105,5 @@ protected: // +--------------------------------------------------------------------+ -#endif FighterAI_h +#endif // FighterAI_h diff --git a/Stars45/FighterTacticalAI.h b/Stars45/FighterTacticalAI.h index ff6169f..244e269 100644 --- a/Stars45/FighterTacticalAI.h +++ b/Stars45/FighterTacticalAI.h @@ -76,5 +76,5 @@ protected: // +--------------------------------------------------------------------+ -#endif FighterTacticalAI_h +#endif // FighterTacticalAI_h diff --git a/Stars45/FirstTimeDlg.h b/Stars45/FirstTimeDlg.h index 4d0fafa..b6c46de 100644 --- a/Stars45/FirstTimeDlg.h +++ b/Stars45/FirstTimeDlg.h @@ -76,5 +76,5 @@ protected: Button* btn_apply; }; -#endif FirstTimeDlg_h +#endif // FirstTimeDlg_h diff --git a/Stars45/Fix.h b/Stars45/Fix.h index d3aade0..c3aa661 100644 --- a/Stars45/Fix.h +++ b/Stars45/Fix.h @@ -49,14 +49,7 @@ const double fix_sixty_five=65536.0; inline int fast_f2i(double d) { - int i; - - _asm { - fld d - fistp i - } - - return i; + return static_cast<int>(d); } // +--------------------------------------------------------------------+ @@ -73,18 +66,9 @@ public: static const fix five; static const fix ten; - fix() { } - fix(int n) : val(n<<Precision) { } - fix(double d) - { - long ival; - _asm { - fld fix_sixty_five - fmul d - fistp ival - } - val=ival; - } + fix() : val(0) { } + fix(int n) : val(n<<Precision) { } + fix(double d) : val(static_cast<long>(d * fix_sixty_five)) { } fix(const fix& f) : val(f.val) { } // conversion operators: @@ -95,12 +79,7 @@ public: // assignment operators: fix& operator=(const fix& f) { val=f.val; return *this; } fix& operator=(int n) { val=(n<<Precision); return *this; } - fix& operator=(double d) { long ival; - _asm { fld fix_sixty_five - fmul d - fistp ival } - val = ival; - return *this; } + fix& operator=(double d) { val = static_cast<long>(d * fix_sixty_five); return *this; } // comparison operators: int operator==(const fix& f) const { return val==f.val; } @@ -113,48 +92,22 @@ public: // arithmetic operators: fix operator+(const fix& f) const { fix r; r.val = val+f.val; return r; } fix operator-(const fix& f) const { fix r; r.val = val-f.val; return r; } - fix operator*(const fix& f) const { long a=val; long b=f.val; - _asm { - mov eax, a - mov edx, b - imul edx - shrd eax, edx, 16 - mov a, eax - } - fix r; r.val = a; return r; } - fix operator/(const fix& f) const { long a=val; long b=f.val; - _asm { - mov eax, a - mov ebx, b - mov edx, eax - sar edx, 16 - shl eax, 16 - idiv ebx - mov a, eax - } - fix r; r.val = a; return r; } + fix operator*(const fix& f) const { + fix r; + r.val = (val * f.val) >> Precision; + return r; } + fix operator/(const fix& f) const { + fix r; + r.val = (val << Precision) / f.val; + return r; } fix& operator+=(const fix& f) { val+=f.val; return *this; } fix& operator-=(const fix& f) { val-=f.val; return *this; } - fix& operator*=(const fix& f) { long a=val; long b=f.val; - _asm { - mov eax, a - mov edx, b - imul edx - shrd eax, edx, 16 - mov a, eax - } - val=a; return *this; } - fix& operator/=(const fix& f) { long a=val; long b=f.val; - _asm { - mov eax, a - mov ebx, b - mov edx, eax - sar edx, 16 - shl eax, 16 - idiv ebx - mov a, eax - } - val=a; return *this; } + fix& operator*=(const fix& f) { + val = (val * f.val) >> Precision; + return *this; } + fix& operator/=(const fix& f) { + val = (val << Precision) / f.val; + return *this; } fix operator+(int n) const { fix r; r.val = val+(n<<Precision); return r; } fix operator-(int n) const { fix r; r.val = val-(n<<Precision); return r; } @@ -171,10 +124,8 @@ public: fix operator/(double d) const { fix f(d); return (*this)/f; } fix& operator+=(double d) { fix f(d); val+=f.val; return *this; } fix& operator-=(double d) { fix f(d); val-=f.val; return *this; } - fix& operator*=(double d) { int n; _asm { fld d - fistp n } val*=n; return *this; } - fix& operator/=(double d) { int n; _asm { fld d - fistp n } val/=n; return *this; } + fix& operator*=(double d) { val*=static_cast<long>(d); return *this; } + fix& operator/=(double d) { val/=static_cast<long>(d); return *this; } // misc. functions: fix truncate() const { fix r; r.val = val&IntMask; return r; } @@ -184,21 +135,11 @@ public: fix adjust_up() const { fix r; r.val = val+FractMask; return r; } fix adjust_down() const { fix r; r.val = val-FractMask; return r; } - fix muldiv(const fix& num, const fix& den) const - { long a=val, b=num.val, c=den.val; - _asm { - mov eax, a - mov edx, b - mov ebx, c - imul edx - idiv ebx - mov a, eax - } - fix r; r.val = a; return r; } + fix muldiv(const fix& num, const fix& den) const { return (*this) * num / den; } // data: long val; }; -#endif Fix_h +#endif // Fix_h diff --git a/Stars45/FlightComp.h b/Stars45/FlightComp.h index 4b6b7a1..4bad97c 100644 --- a/Stars45/FlightComp.h +++ b/Stars45/FlightComp.h @@ -83,5 +83,5 @@ protected: float trans_z_limit; }; -#endif FLIGHT_COMP_H +#endif // FLIGHT_COMP_H diff --git a/Stars45/FlightDeck.h b/Stars45/FlightDeck.h index 334ff21..f8ead9e 100644 --- a/Stars45/FlightDeck.h +++ b/Stars45/FlightDeck.h @@ -215,5 +215,5 @@ protected: // +----------------------------------------------------------------------+ -#endif FlightDeck_h +#endif // FlightDeck_h diff --git a/Stars45/FlightPlanner.h b/Stars45/FlightPlanner.h index 13bceb9..45b9589 100644 --- a/Stars45/FlightPlanner.h +++ b/Stars45/FlightPlanner.h @@ -71,5 +71,5 @@ public: // +--------------------------------------------------------------------+ -#endif FlightPlanner_h +#endif // FlightPlanner_h diff --git a/Stars45/FltDlg.h b/Stars45/FltDlg.h index 5503fca..14f634a 100644 --- a/Stars45/FltDlg.h +++ b/Stars45/FltDlg.h @@ -101,5 +101,5 @@ protected: int patrol_pattern; }; -#endif FltDlg_h +#endif // FltDlg_h diff --git a/Stars45/Font.h b/Stars45/Font.h index 5944f30..e8005a6 100644 --- a/Stars45/Font.h +++ b/Stars45/Font.h @@ -163,5 +163,5 @@ private: char kern[256][256]; }; -#endif Font_h +#endif // Font_h diff --git a/Stars45/FontMgr.h b/Stars45/FontMgr.h index e143a2b..f42db12 100644 --- a/Stars45/FontMgr.h +++ b/Stars45/FontMgr.h @@ -70,5 +70,5 @@ private: static List<FontItem> fonts; }; -#endif FontMgr_h +#endif // FontMgr_h diff --git a/Stars45/FormDef.h b/Stars45/FormDef.h index 0c86743..702a1f9 100644 --- a/Stars45/FormDef.h +++ b/Stars45/FormDef.h @@ -352,5 +352,5 @@ protected: // +--------------------------------------------------------------------+ -#endif FormDef_h +#endif // FormDef_h diff --git a/Stars45/FormWindow.h b/Stars45/FormWindow.h index fb6576d..f935822 100644 --- a/Stars45/FormWindow.h +++ b/Stars45/FormWindow.h @@ -97,5 +97,5 @@ protected: virtual void CreateDefRichText(CtrlDef& def); }; -#endif FormWindow_h +#endif // FormWindow_h diff --git a/Stars45/FormatUtil.h b/Stars45/FormatUtil.h index f652660..0c717fa 100644 --- a/Stars45/FormatUtil.h +++ b/Stars45/FormatUtil.h @@ -67,5 +67,5 @@ Text FormatTextEscape(const char* msg); // +--------------------------------------------------------------------+ -#endif FormatUtil_h +#endif // FormatUtil_h diff --git a/Stars45/Galaxy.h b/Stars45/Galaxy.h index f8f842c..b3b7594 100644 --- a/Stars45/Galaxy.h +++ b/Stars45/Galaxy.h @@ -94,5 +94,5 @@ protected: List<Star> stars; }; -#endif Galaxy_h +#endif // Galaxy_h diff --git a/Stars45/Game.h b/Stars45/Game.h index c94a273..378fdc6 100644 --- a/Stars45/Game.h +++ b/Stars45/Game.h @@ -240,6 +240,6 @@ protected: // +--------------------------------------------------------------------+ -#endif Game_h +#endif // Game_h diff --git a/Stars45/GameScreen.h b/Stars45/GameScreen.h index a9411ab..2a618e8 100644 --- a/Stars45/GameScreen.h +++ b/Stars45/GameScreen.h @@ -212,5 +212,5 @@ private: // +--------------------------------------------------------------------+ -#endif GameScreen_h +#endif // GameScreen_h diff --git a/Stars45/Geometry.h b/Stars45/Geometry.h index f6b34cf..f8ddcdf 100644 --- a/Stars45/Geometry.h +++ b/Stars45/Geometry.h @@ -324,5 +324,5 @@ int lines_intersect( // +--------------------------------------------------------------------+ -#endif Geometry_h +#endif // Geometry_h diff --git a/Stars45/Graphic.h b/Stars45/Graphic.h index 1417f48..b0e74e9 100644 --- a/Stars45/Graphic.h +++ b/Stars45/Graphic.h @@ -159,5 +159,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Graphic_h +#endif // Graphic_h diff --git a/Stars45/Grid.h b/Stars45/Grid.h index 71e09f0..b56dad2 100644 --- a/Stars45/Grid.h +++ b/Stars45/Grid.h @@ -70,5 +70,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Grid_h +#endif // Grid_h diff --git a/Stars45/GroundAI.h b/Stars45/GroundAI.h index 8e097f2..bad2143 100644 --- a/Stars45/GroundAI.h +++ b/Stars45/GroundAI.h @@ -81,5 +81,5 @@ protected: // +--------------------------------------------------------------------+ -#endif GroundAI_h +#endif // GroundAI_h diff --git a/Stars45/HUDSounds.h b/Stars45/HUDSounds.h index bc970d4..df2a866 100644 --- a/Stars45/HUDSounds.h +++ b/Stars45/HUDSounds.h @@ -66,5 +66,5 @@ public: static void StopSound(int n); }; -#endif HUDSounds_h +#endif // HUDSounds_h diff --git a/Stars45/HUDView.cpp b/Stars45/HUDView.cpp index 392ba3e..4521c06 100644 --- a/Stars45/HUDView.cpp +++ b/Stars45/HUDView.cpp @@ -201,7 +201,7 @@ static int tgt_status = System::NOMINAL; // +--------------------------------------------------------------------+ -static enum TXT { +enum TXT { MAX_CONTACT = 50, TXT_CAUTION_TXT = 0, @@ -1361,7 +1361,10 @@ HUDView::DrawBars() int align = DT_LEFT; if (Game::Paused()) - DrawHUDText(TXT_PAUSED, Game::GetText("HUDView.PAUSED"), Rect(cx-128, cy-60, 256, 12), DT_CENTER); + { + Rect pause_rect = Rect(cx - 128, cy - 60, 256, 12); + DrawHUDText(TXT_PAUSED, Game::GetText("HUDView.PAUSED"), pause_rect, DT_CENTER); + } if (ship) { DrawContactMarkers(); diff --git a/Stars45/HUDView.h b/Stars45/HUDView.h index ad72b92..3e94480 100644 --- a/Stars45/HUDView.h +++ b/Stars45/HUDView.h @@ -238,5 +238,5 @@ struct HUDText { bool hidden; }; -#endif HUDView_h +#endif // HUDView_h diff --git a/Stars45/Hangar.h b/Stars45/Hangar.h index aff96e9..511cef6 100644 --- a/Stars45/Hangar.h +++ b/Stars45/Hangar.h @@ -147,5 +147,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Hangar_h +#endif // Hangar_h diff --git a/Stars45/HardPoint.h b/Stars45/HardPoint.h index 1ba0e1a..eba8f7a 100644 --- a/Stars45/HardPoint.h +++ b/Stars45/HardPoint.h @@ -102,5 +102,5 @@ protected: float hull_factor; }; -#endif HardPoint_h +#endif // HardPoint_h diff --git a/Stars45/Hoop.h b/Stars45/Hoop.h index fe1df73..272f3da 100644 --- a/Stars45/Hoop.h +++ b/Stars45/Hoop.h @@ -65,5 +65,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Hoop_h +#endif // Hoop_h diff --git a/Stars45/ImageBox.h b/Stars45/ImageBox.h index cbfa3c4..8f00bb1 100644 --- a/Stars45/ImageBox.h +++ b/Stars45/ImageBox.h @@ -91,5 +91,5 @@ protected: Rect target_rect; }; -#endif ImageBox_h +#endif // ImageBox_h diff --git a/Stars45/ImgView.h b/Stars45/ImgView.h index 189877c..fa09d96 100644 --- a/Stars45/ImgView.h +++ b/Stars45/ImgView.h @@ -71,5 +71,5 @@ protected: int blend; }; -#endif ImgView_h +#endif // ImgView_h diff --git a/Stars45/Instruction.h b/Stars45/Instruction.h index 410792f..9f3e1dc 100644 --- a/Stars45/Instruction.h +++ b/Stars45/Instruction.h @@ -186,5 +186,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Instruction_h +#endif // Instruction_h diff --git a/Stars45/Intel.h b/Stars45/Intel.h index 611c9d8..542d1cf 100644 --- a/Stars45/Intel.h +++ b/Stars45/Intel.h @@ -57,5 +57,5 @@ public: static const char* NameFromIntel(int intel); }; -#endif Intel_h +#endif // Intel_h diff --git a/Stars45/JoyDlg.h b/Stars45/JoyDlg.h index a4f488f..27ad606 100644 --- a/Stars45/JoyDlg.h +++ b/Stars45/JoyDlg.h @@ -76,5 +76,5 @@ protected: Button* cancel; }; -#endif JoyDlg_h +#endif // JoyDlg_h diff --git a/Stars45/Joystick.cpp b/Stars45/Joystick.cpp index 3d641dd..5a30f8d 100644 --- a/Stars45/Joystick.cpp +++ b/Stars45/Joystick.cpp @@ -65,7 +65,7 @@ static int strikes = 3; static Joystick* joystick = 0; void DirectInputError(const char* msg, HRESULT err); -char* DIErrStr(HRESULT hr); +const char* DIErrStr(HRESULT hr); void ReleaseDirectInput(); // +--------------------------------------------------------------------+ @@ -857,11 +857,12 @@ DirectInputError(const char* msg, HRESULT err) static char errstrbuf[128]; -char* DIErrStr(HRESULT hr) +const char* DIErrStr(HRESULT hr) { - switch (hr) { + auto casted = static_cast<long unsigned int>(hr); + switch (casted) { default: - sprintf_s(errstrbuf, "Unrecognized error value = %08x.", hr); + sprintf_s(errstrbuf, "Unrecognized error value = %08x.", casted); return errstrbuf; case DI_OK: diff --git a/Stars45/Joystick.h b/Stars45/Joystick.h index 263f9a5..64bf552 100644 --- a/Stars45/Joystick.h +++ b/Stars45/Joystick.h @@ -102,5 +102,5 @@ protected: bool inv_axis[4]; }; -#endif Joystick_h +#endif // Joystick_h diff --git a/Stars45/KeyDlg.h b/Stars45/KeyDlg.h index bb464e2..e0ef0f9 100644 --- a/Stars45/KeyDlg.h +++ b/Stars45/KeyDlg.h @@ -85,5 +85,5 @@ protected: ActiveWindow* new_key; }; -#endif KeyDlg_h +#endif // KeyDlg_h diff --git a/Stars45/KeyMap.h b/Stars45/KeyMap.h index 0ec576f..5826ee1 100644 --- a/Stars45/KeyMap.h +++ b/Stars45/KeyMap.h @@ -201,5 +201,5 @@ const int KEY_INC_STARDATE = 120 + KEY_USER_BASE; const int KEY_DEC_STARDATE = 121 + KEY_USER_BASE; /***/ -#endif KeyMap_h +#endif // KeyMap_h diff --git a/Stars45/Keyboard.h b/Stars45/Keyboard.h index 5ce09a3..3afaed0 100644 --- a/Stars45/Keyboard.h +++ b/Stars45/Keyboard.h @@ -94,5 +94,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Keyboard_h +#endif // Keyboard_h diff --git a/Stars45/LandingGear.h b/Stars45/LandingGear.h index 7ead819..d1b578f 100644 --- a/Stars45/LandingGear.h +++ b/Stars45/LandingGear.h @@ -86,5 +86,5 @@ protected: Point end[MAX_GEAR]; }; -#endif LandingGear_h +#endif // LandingGear_h diff --git a/Stars45/Layout.h b/Stars45/Layout.h index 715121b..7e42a08 100644 --- a/Stars45/Layout.h +++ b/Stars45/Layout.h @@ -85,5 +85,5 @@ protected: std::vector<float> row_weights; }; -#endif Layout_h +#endif // Layout_h diff --git a/Stars45/Light.h b/Stars45/Light.h index 8c1bc1b..68bde6c 100644 --- a/Stars45/Light.h +++ b/Stars45/Light.h @@ -116,5 +116,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Light_h +#endif // Light_h diff --git a/Stars45/ListBox.h b/Stars45/ListBox.h index a792017..0523bc8 100644 --- a/Stars45/ListBox.h +++ b/Stars45/ListBox.h @@ -190,5 +190,5 @@ protected: int seln_style; }; -#endif ListBox_h +#endif // ListBox_h diff --git a/Stars45/LoadDlg.h b/Stars45/LoadDlg.h index f77041e..b59ab31 100644 --- a/Stars45/LoadDlg.h +++ b/Stars45/LoadDlg.h @@ -61,5 +61,5 @@ protected: Slider* progress; }; -#endif LoadDlg_h +#endif // LoadDlg_h diff --git a/Stars45/LoadScreen.h b/Stars45/LoadScreen.h index f3e3cbe..6b252d9 100644 --- a/Stars45/LoadScreen.h +++ b/Stars45/LoadScreen.h @@ -84,5 +84,5 @@ private: // +--------------------------------------------------------------------+ -#endif LoadScreen_h +#endif // LoadScreen_h diff --git a/Stars45/Locale_ss.h b/Stars45/Locale_ss.h index 29c12cf..f719304 100644 --- a/Stars45/Locale_ss.h +++ b/Stars45/Locale_ss.h @@ -73,5 +73,5 @@ protected: char variant[8]; }; -#endif Locale_h +#endif // Locale_h diff --git a/Stars45/MCIWave.cpp b/Stars45/MCIWave.cpp index 25bfdad..1424b7d 100644 --- a/Stars45/MCIWave.cpp +++ b/Stars45/MCIWave.cpp @@ -38,6 +38,7 @@ #include "MemDebug.h" #include "Types.h" +#include "Game.h" // +----------------------------------------------------------------------+ @@ -50,11 +51,10 @@ static char ret_str[MCI_MAX_STR]; static char err_str[MCI_MAX_STR]; static MCIERROR mci_err; static MMRESULT wav_err; -extern HWND hwndApp; static int mci_send_string(const char* cmd_str) { - mci_err = mciSendString(cmd_str, ret_str, sizeof(ret_str), hwndApp); + mci_err = mciSendString(cmd_str, ret_str, sizeof(ret_str), Game::GetHWND()); if (mci_err) { if (mciGetErrorString(mci_err, err_str, sizeof(err_str))) Print("Error (%s): '%s'\n", cmd_str, err_str); diff --git a/Stars45/MachineInfo.cpp b/Stars45/MachineInfo.cpp index 6b9e2cd..7485ac3 100644 --- a/Stars45/MachineInfo.cpp +++ b/Stars45/MachineInfo.cpp @@ -36,9 +36,10 @@ Collect and Display Machine, OS, and Driver Information */ +#include <chrono> + #include "MemDebug.h" #include "MachineInfo.h" -#include "Timesnap.h" #define DIRECTINPUT_VERSION 0x0700 @@ -149,16 +150,13 @@ static double SpinWait(double target_time) static double CalcCpuSpeed() { - DWORD clock1 = 0; - DWORD clock2 = 0; - - TIMESNAP(clock1); + const auto before = std::chrono::high_resolution_clock::now(); double seconds = SpinWait(0.1); - TIMESNAP(clock2); - - double clocks = clock2 - clock1; + const auto after = std::chrono::high_resolution_clock::now(); + const std::chrono::duration<double> diff = after - before; + double clocks = diff.count(); return (clocks/seconds); } @@ -682,7 +680,7 @@ static void DescribeDriversNT(const char* sType) HKEY hkWin; char sVideo[256] = ""; char sDriver[256] = ""; - DWORD dwSize = NULL; + DWORD dwSize = 0; // find the pointer to the video driver: if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, diff --git a/Stars45/MachineInfo.h b/Stars45/MachineInfo.h index 26b1223..4424ecd 100644 --- a/Stars45/MachineInfo.h +++ b/Stars45/MachineInfo.h @@ -63,4 +63,4 @@ public: // +--------------------------------------------------------------------+ -#endif MachineInfo_h
\ No newline at end of file +#endif // MachineInfo_h
\ No newline at end of file diff --git a/Stars45/MapView.cpp b/Stars45/MapView.cpp index 7c51089..de7c567 100644 --- a/Stars45/MapView.cpp +++ b/Stars45/MapView.cpp @@ -1911,7 +1911,8 @@ MapView::DrawSystem() sprintf_s(resolution, "%s: %s", Game::GetText("MapView.info.Resolution").data(), r_txt); active_window->SetFont(font); - active_window->DrawText(resolution, -1, Rect(4, 4, rect.w-8, 24), DT_SINGLELINE|DT_RIGHT); + Rect text_rect(4, 4, rect.w - 8, 24); + active_window->DrawText(resolution, -1, text_rect, DT_SINGLELINE|DT_RIGHT); } // +--------------------------------------------------------------------+ @@ -2084,7 +2085,8 @@ MapView::DrawRegion() sprintf_s(resolution, "%s: %s", Game::GetText("MapView.info.Resolution").data(), r_txt); active_window->SetFont(font); - active_window->DrawText(resolution, -1, Rect(4, 4, rect.w-8, 24), DT_SINGLELINE|DT_RIGHT); + Rect text_rect(4, 4, rect.w - 8, 24); + active_window->DrawText(resolution, -1, text_rect, DT_SINGLELINE|DT_RIGHT); } // +--------------------------------------------------------------------+ @@ -2822,12 +2824,14 @@ MapView::DrawCombatGroupSystem(CombatGroup* group, Orbital* rgn, int x1, int x2, case CombatGroup::CARRIER_GROUP: case CombatGroup::BATTLE_GROUP: case CombatGroup::DESTROYER_SQUADRON: + { sprintf_s(txt, "%s '%s'", group->GetShortDescription(), group->Name().data()); active_window->SetFont(font); - active_window->DrawText(txt, 0, Rect(x1, y, x2-x1, 12), a); + Rect text_rect(x1, y, x2 - x1, 12); + active_window->DrawText(txt, 0, text_rect, a); y += 10; break; - + } case CombatGroup::BATTALION: case CombatGroup::STATION: case CombatGroup::STARBASE: @@ -2835,12 +2839,13 @@ MapView::DrawCombatGroupSystem(CombatGroup* group, Orbital* rgn, int x1, int x2, case CombatGroup::MINEFIELD: case CombatGroup::BATTERY: case CombatGroup::MISSILE: - + { active_window->SetFont(font); - active_window->DrawText(group->GetShortDescription(), 0, Rect(x1, y, x2-x1, 12), a); + Rect text_rect(x1, y, x2 - x1, 12); + active_window->DrawText(group->GetShortDescription(), 0, text_rect, a); y += 10; break; - + } default: break; } diff --git a/Stars45/MapView.h b/Stars45/MapView.h index 0c49bd8..e6b2abf 100644 --- a/Stars45/MapView.h +++ b/Stars45/MapView.h @@ -243,5 +243,5 @@ protected: MenuView* menu_view; }; -#endif MapView_h +#endif // MapView_h diff --git a/Stars45/Menu.h b/Stars45/Menu.h index ac142d3..8ce8a94 100644 --- a/Stars45/Menu.h +++ b/Stars45/Menu.h @@ -144,5 +144,5 @@ private: List<Menu> history; }; -#endif Menu_h +#endif // Menu_h diff --git a/Stars45/MenuDlg.h b/Stars45/MenuDlg.h index d00c233..849e530 100644 --- a/Stars45/MenuDlg.h +++ b/Stars45/MenuDlg.h @@ -106,5 +106,5 @@ protected: Campaign* campaign; }; -#endif MenuDlg_h +#endif // MenuDlg_h diff --git a/Stars45/MenuScreen.h b/Stars45/MenuScreen.h index c499784..306ae79 100644 --- a/Stars45/MenuScreen.h +++ b/Stars45/MenuScreen.h @@ -219,5 +219,5 @@ private: // +--------------------------------------------------------------------+ -#endif MenuScreen_h +#endif // MenuScreen_h diff --git a/Stars45/MenuView.h b/Stars45/MenuView.h index 65ac625..669efad 100644 --- a/Stars45/MenuView.h +++ b/Stars45/MenuView.h @@ -97,5 +97,5 @@ protected: Color text_color; }; -#endif MenuView_h +#endif // MenuView_h diff --git a/Stars45/Mfd.cpp b/Stars45/Mfd.cpp index 7c1e704..aaf1d4c 100644 --- a/Stars45/Mfd.cpp +++ b/Stars45/Mfd.cpp @@ -1071,7 +1071,8 @@ MFD::Draw3D() void MFD::DrawMap() { - DrawMFDText(0, Game::GetText("MFD.mode.ground").data(), Rect(rect.x, rect.y, rect.w, 12), DT_CENTER); + Rect text_rect(rect.x, rect.y, rect.w, 12); + DrawMFDText(0, Game::GetText("MFD.mode.ground").data(), text_rect, DT_CENTER); } // +--------------------------------------------------------------------+ diff --git a/Stars45/Mfd.h b/Stars45/Mfd.h index eabb48b..955e69c 100644 --- a/Stars45/Mfd.h +++ b/Stars45/Mfd.h @@ -124,5 +124,5 @@ protected: bool mouse_in; }; -#endif MFD_h +#endif // MFD_h diff --git a/Stars45/Mission.h b/Stars45/Mission.h index b36f662..c8c4738 100644 --- a/Stars45/Mission.h +++ b/Stars45/Mission.h @@ -446,5 +446,5 @@ protected: int fuel[4]; }; -#endif Mission_h +#endif // Mission_h diff --git a/Stars45/MissionEvent.h b/Stars45/MissionEvent.h index ab4ccec..1accd5b 100644 --- a/Stars45/MissionEvent.h +++ b/Stars45/MissionEvent.h @@ -187,5 +187,5 @@ protected: }; -#endif MissionEvent_h +#endif // MissionEvent_h diff --git a/Stars45/MissionTemplate.h b/Stars45/MissionTemplate.h index db748f6..11ec7eb 100644 --- a/Stars45/MissionTemplate.h +++ b/Stars45/MissionTemplate.h @@ -137,5 +137,5 @@ protected: }; -#endif MissionTemplate_h +#endif // MissionTemplate_h diff --git a/Stars45/ModConfig.h b/Stars45/ModConfig.h index c0b7634..03d55ce 100644 --- a/Stars45/ModConfig.h +++ b/Stars45/ModConfig.h @@ -96,4 +96,4 @@ private: List<ModInfo> mods; }; -#endif ModConfig_h
\ No newline at end of file +#endif // ModConfig_h
\ No newline at end of file diff --git a/Stars45/ModDlg.h b/Stars45/ModDlg.h index 350a16f..a6f95e2 100644 --- a/Stars45/ModDlg.h +++ b/Stars45/ModDlg.h @@ -114,5 +114,5 @@ protected: bool changed; }; -#endif ModDlg_h +#endif // ModDlg_h diff --git a/Stars45/ModInfo.h b/Stars45/ModInfo.h index 889ad47..b9512e0 100644 --- a/Stars45/ModInfo.h +++ b/Stars45/ModInfo.h @@ -143,4 +143,4 @@ private: Text path; }; -#endif ModInfo_h
\ No newline at end of file +#endif // ModInfo_h
\ No newline at end of file diff --git a/Stars45/ModInfoDlg.h b/Stars45/ModInfoDlg.h index 6b91199..5ed2e96 100644 --- a/Stars45/ModInfoDlg.h +++ b/Stars45/ModInfoDlg.h @@ -85,5 +85,5 @@ protected: Bitmap bmp_default; }; -#endif ModInfoDlg_h +#endif // ModInfoDlg_h diff --git a/Stars45/MotionController.h b/Stars45/MotionController.h index 69938e3..c46fa23 100644 --- a/Stars45/MotionController.h +++ b/Stars45/MotionController.h @@ -251,5 +251,5 @@ protected: int select; }; -#endif MoCon_h +#endif // MoCon_h diff --git a/Stars45/Mouse.h b/Stars45/Mouse.h index 07bc98f..2eda0a1 100644 --- a/Stars45/Mouse.h +++ b/Stars45/Mouse.h @@ -95,5 +95,5 @@ private: static Window* window; }; -#endif Mouse_h +#endif // Mouse_h diff --git a/Stars45/MouseController.h b/Stars45/MouseController.h index b8bbe5e..6ecb49b 100644 --- a/Stars45/MouseController.h +++ b/Stars45/MouseController.h @@ -90,5 +90,5 @@ protected: int active_key; }; -#endif MouseController_h +#endif // MouseController_h diff --git a/Stars45/MsnDlg.h b/Stars45/MsnDlg.h index b257a03..7deb4d0 100644 --- a/Stars45/MsnDlg.h +++ b/Stars45/MsnDlg.h @@ -93,5 +93,5 @@ protected: int pkg_index; }; -#endif MsnDlg_h +#endif // MsnDlg_h diff --git a/Stars45/MsnEditDlg.h b/Stars45/MsnEditDlg.h index 77e8234..685cdc2 100644 --- a/Stars45/MsnEditDlg.h +++ b/Stars45/MsnEditDlg.h @@ -136,5 +136,5 @@ protected: bool exit_latch; }; -#endif MsnEditDlg_h +#endif // MsnEditDlg_h diff --git a/Stars45/MsnEditNavDlg.h b/Stars45/MsnEditNavDlg.h index a0430c5..4a7e1a1 100644 --- a/Stars45/MsnEditNavDlg.h +++ b/Stars45/MsnEditNavDlg.h @@ -98,5 +98,5 @@ protected: bool exit_latch; }; -#endif MsnEditNavDlg_h +#endif // MsnEditNavDlg_h diff --git a/Stars45/MsnElemDlg.h b/Stars45/MsnElemDlg.h index 99c0060..0f3d634 100644 --- a/Stars45/MsnElemDlg.h +++ b/Stars45/MsnElemDlg.h @@ -119,5 +119,5 @@ protected: bool exit_latch; }; -#endif MsnElemDlg_h +#endif // MsnElemDlg_h diff --git a/Stars45/MsnEventDlg.h b/Stars45/MsnEventDlg.h index e05454c..92c1d49 100644 --- a/Stars45/MsnEventDlg.h +++ b/Stars45/MsnEventDlg.h @@ -106,5 +106,5 @@ protected: MissionEvent* event; }; -#endif MsnEventDlg_h +#endif // MsnEventDlg_h diff --git a/Stars45/MsnNavDlg.h b/Stars45/MsnNavDlg.h index 2dd37bf..5c14a8c 100644 --- a/Stars45/MsnNavDlg.h +++ b/Stars45/MsnNavDlg.h @@ -74,5 +74,5 @@ public: virtual void OnCancel(AWEvent* event); }; -#endif MsnNavDlg_h +#endif // MsnNavDlg_h diff --git a/Stars45/MsnObjDlg.h b/Stars45/MsnObjDlg.h index 228f5ba..1b62435 100644 --- a/Stars45/MsnObjDlg.h +++ b/Stars45/MsnObjDlg.h @@ -88,5 +88,5 @@ protected: ShipSolid* ship; }; -#endif MsnObjDlg_h +#endif // MsnObjDlg_h diff --git a/Stars45/MsnPkgDlg.h b/Stars45/MsnPkgDlg.h index 4bab8fd..8c680b7 100644 --- a/Stars45/MsnPkgDlg.h +++ b/Stars45/MsnPkgDlg.h @@ -86,5 +86,5 @@ protected: ActiveWindow* threat[5]; }; -#endif MsnPkgDlg_h +#endif // MsnPkgDlg_h diff --git a/Stars45/MsnSelectDlg.h b/Stars45/MsnSelectDlg.h index b825a75..c986c2f 100644 --- a/Stars45/MsnSelectDlg.h +++ b/Stars45/MsnSelectDlg.h @@ -101,5 +101,5 @@ protected: bool editable; }; -#endif MsnSelectDlg_h +#endif // MsnSelectDlg_h diff --git a/Stars45/MsnWepDlg.h b/Stars45/MsnWepDlg.h index 9d1a5e6..f8d2a57 100644 --- a/Stars45/MsnWepDlg.h +++ b/Stars45/MsnWepDlg.h @@ -106,5 +106,5 @@ protected: Bitmap led_on; }; -#endif MsnWepDlg_h +#endif // MsnWepDlg_h diff --git a/Stars45/MusicDirector.h b/Stars45/MusicDirector.h index bfdd57b..ec4ed87 100644 --- a/Stars45/MusicDirector.h +++ b/Stars45/MusicDirector.h @@ -135,4 +135,4 @@ protected: ThreadSync sync; }; -#endif MusicDirector_h
\ No newline at end of file +#endif // MusicDirector_h
\ No newline at end of file diff --git a/Stars45/MusicTrack.h b/Stars45/MusicTrack.h index 0e194c8..48e00a7 100644 --- a/Stars45/MusicTrack.h +++ b/Stars45/MusicTrack.h @@ -98,4 +98,4 @@ protected: double fade_time; }; -#endif MusicTrack_h
\ No newline at end of file +#endif // MusicTrack_h
\ No newline at end of file diff --git a/Stars45/NavAI.h b/Stars45/NavAI.h index d920622..ddb0624 100644 --- a/Stars45/NavAI.h +++ b/Stars45/NavAI.h @@ -94,5 +94,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NavAI_h +#endif // NavAI_h diff --git a/Stars45/NavDlg.h b/Stars45/NavDlg.h index 0cd12e5..a37c07a 100644 --- a/Stars45/NavDlg.h +++ b/Stars45/NavDlg.h @@ -139,5 +139,5 @@ protected: bool editor; }; -#endif NavDlg_h +#endif // NavDlg_h diff --git a/Stars45/NavLight.h b/Stars45/NavLight.h index 9431a83..c194d20 100644 --- a/Stars45/NavLight.h +++ b/Stars45/NavLight.h @@ -87,5 +87,5 @@ protected: DWORD offset; }; -#endif NavLight_h +#endif // NavLight_h diff --git a/Stars45/NavSystem.h b/Stars45/NavSystem.h index ccf1c13..ad69dbe 100644 --- a/Stars45/NavSystem.h +++ b/Stars45/NavSystem.h @@ -75,5 +75,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NavSystem_h +#endif // NavSystem_h diff --git a/Stars45/NetAddrDlg.h b/Stars45/NetAddrDlg.h index 5f2607f..8ece063 100644 --- a/Stars45/NetAddrDlg.h +++ b/Stars45/NetAddrDlg.h @@ -80,5 +80,5 @@ protected: EditBox* edt_pass; }; -#endif NetAddrDlg_h +#endif // NetAddrDlg_h diff --git a/Stars45/NetAdminChat.h b/Stars45/NetAdminChat.h index b26e9a9..0793a60 100644 --- a/Stars45/NetAdminChat.h +++ b/Stars45/NetAdminChat.h @@ -54,4 +54,4 @@ public: virtual Text GetContent(); }; -#endif NetAdminChat_h
\ No newline at end of file +#endif // NetAdminChat_h
\ No newline at end of file diff --git a/Stars45/NetAdminServer.h b/Stars45/NetAdminServer.h index b70fbfa..54c8f77 100644 --- a/Stars45/NetAdminServer.h +++ b/Stars45/NetAdminServer.h @@ -112,4 +112,4 @@ protected: NetUser* user; }; -#endif NetAdminServer_h
\ No newline at end of file +#endif // NetAdminServer_h
\ No newline at end of file diff --git a/Stars45/NetAuth.h b/Stars45/NetAuth.h index 1c5ceb7..eb80e3b 100644 --- a/Stars45/NetAuth.h +++ b/Stars45/NetAuth.h @@ -72,4 +72,4 @@ public: // +-------------------------------------------------------------------+ -#endif NetAuth_h
\ No newline at end of file +#endif // NetAuth_h
\ No newline at end of file diff --git a/Stars45/NetBrokerClient.h b/Stars45/NetBrokerClient.h index 86d6922..0d6c728 100644 --- a/Stars45/NetBrokerClient.h +++ b/Stars45/NetBrokerClient.h @@ -64,4 +64,4 @@ protected: }; -#endif NetBrokerClient_h
\ No newline at end of file +#endif // NetBrokerClient_h
\ No newline at end of file diff --git a/Stars45/NetChat.h b/Stars45/NetChat.h index 4cad0f8..41943fd 100644 --- a/Stars45/NetChat.h +++ b/Stars45/NetChat.h @@ -73,4 +73,4 @@ private: // +-------------------------------------------------------------------+ -#endif NetChat_h
\ No newline at end of file +#endif // NetChat_h
\ No newline at end of file diff --git a/Stars45/NetClientConfig.h b/Stars45/NetClientConfig.h index 9865d4f..d55318b 100644 --- a/Stars45/NetClientConfig.h +++ b/Stars45/NetClientConfig.h @@ -94,4 +94,4 @@ private: static NetClientConfig* instance; }; -#endif NetClientConfig_h +#endif // NetClientConfig_h diff --git a/Stars45/NetClientDlg.h b/Stars45/NetClientDlg.h index 0f88557..cbd644c 100644 --- a/Stars45/NetClientDlg.h +++ b/Stars45/NetClientDlg.h @@ -100,5 +100,5 @@ protected: Button* btn_cancel; }; -#endif NetClientDlg_h +#endif // NetClientDlg_h diff --git a/Stars45/NetData.h b/Stars45/NetData.h index 0436f5f..8a3e030 100644 --- a/Stars45/NetData.h +++ b/Stars45/NetData.h @@ -986,5 +986,5 @@ private: // +--------------------------------------------------------------------+ -#endif NetData_h +#endif // NetData_h diff --git a/Stars45/NetFileServlet.h b/Stars45/NetFileServlet.h index 66ab7f6..c2228a2 100644 --- a/Stars45/NetFileServlet.h +++ b/Stars45/NetFileServlet.h @@ -71,4 +71,4 @@ public: virtual bool DoGet(HttpRequest& request, HttpResponse& response); }; -#endif NetFileServlet_h
\ No newline at end of file +#endif // NetFileServlet_h
\ No newline at end of file diff --git a/Stars45/NetGame.h b/Stars45/NetGame.h index abaf905..9ab5585 100644 --- a/Stars45/NetGame.h +++ b/Stars45/NetGame.h @@ -147,5 +147,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetGame_h +#endif // NetGame_h diff --git a/Stars45/NetGameClient.h b/Stars45/NetGameClient.h index 1cc8397..879dee3 100644 --- a/Stars45/NetGameClient.h +++ b/Stars45/NetGameClient.h @@ -107,5 +107,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetGameClient_h +#endif // NetGameClient_h diff --git a/Stars45/NetGameServer.h b/Stars45/NetGameServer.h index afa73ae..b2e2d13 100644 --- a/Stars45/NetGameServer.h +++ b/Stars45/NetGameServer.h @@ -110,5 +110,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetGameServer_h +#endif // NetGameServer_h diff --git a/Stars45/NetLobby.h b/Stars45/NetLobby.h index 8da024d..4b17182 100644 --- a/Stars45/NetLobby.h +++ b/Stars45/NetLobby.h @@ -309,5 +309,5 @@ enum NET_LOBBY_MESSAGES { // +--------------------------------------------------------------------+ -#endif NetLobby_h +#endif // NetLobby_h diff --git a/Stars45/NetLobbyClient.h b/Stars45/NetLobbyClient.h index ae1ad11..54b5cfd 100644 --- a/Stars45/NetLobbyClient.h +++ b/Stars45/NetLobbyClient.h @@ -125,4 +125,4 @@ protected: // +-------------------------------------------------------------------+ -#endif NetLobbyClient_h
\ No newline at end of file +#endif // NetLobbyClient_h
\ No newline at end of file diff --git a/Stars45/NetLobbyDlg.h b/Stars45/NetLobbyDlg.h index 3dd75ef..6d66542 100644 --- a/Stars45/NetLobbyDlg.h +++ b/Stars45/NetLobbyDlg.h @@ -109,5 +109,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetLobbyDlg_h +#endif // NetLobbyDlg_h diff --git a/Stars45/NetLobbyServer.h b/Stars45/NetLobbyServer.h index a2a9803..da2d3f1 100644 --- a/Stars45/NetLobbyServer.h +++ b/Stars45/NetLobbyServer.h @@ -140,4 +140,4 @@ protected: // +-------------------------------------------------------------------+ -#endif NetLobbyServer_h
\ No newline at end of file +#endif // NetLobbyServer_h
\ No newline at end of file diff --git a/Stars45/NetPacket.h b/Stars45/NetPacket.h index 6e0f528..3eb281f 100644 --- a/Stars45/NetPacket.h +++ b/Stars45/NetPacket.h @@ -94,5 +94,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetPacket_h +#endif // NetPacket_h diff --git a/Stars45/NetPassDlg.h b/Stars45/NetPassDlg.h index d5645ca..65c55fd 100644 --- a/Stars45/NetPassDlg.h +++ b/Stars45/NetPassDlg.h @@ -78,5 +78,5 @@ protected: ActiveWindow* lbl_name; }; -#endif NetPassDlg_h +#endif // NetPassDlg_h diff --git a/Stars45/NetPlayer.cpp b/Stars45/NetPlayer.cpp index 1a15527..5bcfccc 100644 --- a/Stars45/NetPlayer.cpp +++ b/Stars45/NetPlayer.cpp @@ -36,6 +36,12 @@ Network Player (Director) class */ +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#include <algorithm> + #include "MemDebug.h" #include "NetPlayer.h" #include "NetGame.h" @@ -446,7 +452,7 @@ NetPlayer::ExecFrame(double seconds) if (ship) { // bleed off the location error: if (loc_error.length() > 0 && bleed_time > 0) { - double fragment = min(seconds / BLEED, bleed_time); + double fragment = std::min(seconds / BLEED, bleed_time); ship->MoveTo(ship->Location() + loc_error * fragment); bleed_time -= fragment; } diff --git a/Stars45/NetPlayer.h b/Stars45/NetPlayer.h index 4de4982..4bed59d 100644 --- a/Stars45/NetPlayer.h +++ b/Stars45/NetPlayer.h @@ -118,5 +118,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetPlayer_h +#endif // NetPlayer_h diff --git a/Stars45/NetServerConfig.h b/Stars45/NetServerConfig.h index 260ea0c..a81c4fd 100644 --- a/Stars45/NetServerConfig.h +++ b/Stars45/NetServerConfig.h @@ -120,4 +120,4 @@ private: static NetServerConfig* instance; }; -#endif NetServerConfig_h +#endif // NetServerConfig_h diff --git a/Stars45/NetServerDlg.h b/Stars45/NetServerDlg.h index 24d095d..c11199b 100644 --- a/Stars45/NetServerDlg.h +++ b/Stars45/NetServerDlg.h @@ -84,5 +84,5 @@ protected: Button* btn_cancel; }; -#endif NetServerDlg_h +#endif // NetServerDlg_h diff --git a/Stars45/NetUnitDlg.h b/Stars45/NetUnitDlg.h index 76f7164..6bda0a5 100644 --- a/Stars45/NetUnitDlg.h +++ b/Stars45/NetUnitDlg.h @@ -113,5 +113,5 @@ protected: // +--------------------------------------------------------------------+ -#endif NetUnitDlg_h +#endif // NetUnitDlg_h diff --git a/Stars45/NetUser.h b/Stars45/NetUser.h index 1aa9cd0..2f86d8e 100644 --- a/Stars45/NetUser.h +++ b/Stars45/NetUser.h @@ -133,4 +133,4 @@ protected: // +-------------------------------------------------------------------+ -#endif NetUser_h
\ No newline at end of file +#endif // NetUser_h
\ No newline at end of file diff --git a/Stars45/NetUtil.h b/Stars45/NetUtil.h index b89c126..210cfce 100644 --- a/Stars45/NetUtil.h +++ b/Stars45/NetUtil.h @@ -77,4 +77,4 @@ public: static void SendSelfDestruct(Ship* ship, double damage); }; -#endif NetUtil_h
\ No newline at end of file +#endif // NetUtil_h
\ No newline at end of file diff --git a/Stars45/OptDlg.h b/Stars45/OptDlg.h index 7a3be9e..b206ffb 100644 --- a/Stars45/OptDlg.h +++ b/Stars45/OptDlg.h @@ -107,5 +107,5 @@ protected: bool closed; }; -#endif OptDlg_h +#endif // OptDlg_h diff --git a/Stars45/ParseUtil.h b/Stars45/ParseUtil.h index b958e6e..3106144 100644 --- a/Stars45/ParseUtil.h +++ b/Stars45/ParseUtil.h @@ -73,4 +73,4 @@ bool GetDefArray(std::vector<float>& array, TermDef* def, const char* file) // +--------------------------------------------------------------------+ -#endif ParseUtil_h +#endif // ParseUtil_h diff --git a/Stars45/Particles.h b/Stars45/Particles.h index ac0bc2b..428daa1 100644 --- a/Stars45/Particles.h +++ b/Stars45/Particles.h @@ -107,4 +107,4 @@ protected: Sprite* point_sprite; }; -#endif Particles_h +#endif // Particles_h diff --git a/Stars45/Physical.h b/Stars45/Physical.h index 623d8b6..a986ed4 100644 --- a/Stars45/Physical.h +++ b/Stars45/Physical.h @@ -225,5 +225,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Physical_h +#endif // Physical_h diff --git a/Stars45/PlanScreen.h b/Stars45/PlanScreen.h index 6b96333..6ca3c39 100644 --- a/Stars45/PlanScreen.h +++ b/Stars45/PlanScreen.h @@ -128,5 +128,5 @@ private: // +--------------------------------------------------------------------+ -#endif PlanScreen_h +#endif // PlanScreen_h diff --git a/Stars45/Player.h b/Stars45/Player.h index 086f781..5f1479e 100644 --- a/Stars45/Player.h +++ b/Stars45/Player.h @@ -208,4 +208,4 @@ protected: AwardInfo* award; }; -#endif Player_h
\ No newline at end of file +#endif // Player_h
\ No newline at end of file diff --git a/Stars45/PlayerDlg.h b/Stars45/PlayerDlg.h index 29c993e..e6c31a7 100644 --- a/Stars45/PlayerDlg.h +++ b/Stars45/PlayerDlg.h @@ -106,5 +106,5 @@ protected: Button* cancel; }; -#endif PlayerDlg_h +#endif // PlayerDlg_h diff --git a/Stars45/PngImage.h b/Stars45/PngImage.h index e457723..09d5b58 100644 --- a/Stars45/PngImage.h +++ b/Stars45/PngImage.h @@ -67,4 +67,4 @@ struct PngImage // +--------------------------------------------------------------------+ -#endif PngImage_h +#endif // PngImage_h diff --git a/Stars45/Polygon.h b/Stars45/Polygon.h index fe9c6af..5efded7 100644 --- a/Stars45/Polygon.h +++ b/Stars45/Polygon.h @@ -179,5 +179,5 @@ struct VertexSet // +--------------------------------------------------------------------+ -#endif Polygon_h +#endif // Polygon_h diff --git a/Stars45/Power.h b/Stars45/Power.h index fadd751..b044aa0 100644 --- a/Stars45/Power.h +++ b/Stars45/Power.h @@ -82,5 +82,5 @@ protected: float requested_power_level; }; -#endif Power_h +#endif // Power_h diff --git a/Stars45/Projector.cpp b/Stars45/Projector.cpp index 6881682..1c2e635 100644 --- a/Stars45/Projector.cpp +++ b/Stars45/Projector.cpp @@ -36,6 +36,12 @@ 3D Projection Camera class */ +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#include <algorithm> + #include "MemDebug.h" #include "Projector.h" @@ -101,7 +107,7 @@ Projector::SetFieldOfView(double fov) xscreenscale = width / fov; yscreenscale = height / fov; - maxscale = max(xscreenscale, yscreenscale); + maxscale = std::max(xscreenscale, yscreenscale); xangle = atan(2.0/fov * maxscale/xscreenscale); yangle = atan(2.0/fov * maxscale/yscreenscale); diff --git a/Stars45/Projector.h b/Stars45/Projector.h index d314ec5..96c2b82 100644 --- a/Stars45/Projector.h +++ b/Stars45/Projector.h @@ -126,5 +126,5 @@ protected: float yclip0, yclip1; }; -#endif Projector_h +#endif // Projector_h diff --git a/Stars45/QuantumFlash.h b/Stars45/QuantumFlash.h index d791370..015a643 100644 --- a/Stars45/QuantumFlash.h +++ b/Stars45/QuantumFlash.h @@ -81,4 +81,4 @@ protected: Matrix orientation; }; -#endif QuantumFlash_h +#endif // QuantumFlash_h diff --git a/Stars45/QuantumView.h b/Stars45/QuantumView.h index 6073d05..f342ba3 100644 --- a/Stars45/QuantumView.h +++ b/Stars45/QuantumView.h @@ -93,5 +93,5 @@ protected: static QuantumView* quantum_view; }; -#endif QuantumView_h +#endif // QuantumView_h diff --git a/Stars45/QuitView.h b/Stars45/QuitView.h index 0068564..a7eb688 100644 --- a/Stars45/QuitView.h +++ b/Stars45/QuitView.h @@ -84,5 +84,5 @@ protected: static QuitView* quit_view; }; -#endif QuitView_h +#endif // QuitView_h diff --git a/Stars45/RLoc.h b/Stars45/RLoc.h index 1803b34..3d68218 100644 --- a/Stars45/RLoc.h +++ b/Stars45/RLoc.h @@ -91,5 +91,5 @@ private: // +--------------------------------------------------------------------+ -#endif RLoc_h +#endif // RLoc_h diff --git a/Stars45/RadioHandler.h b/Stars45/RadioHandler.h index 965d6f5..3fed4ee 100644 --- a/Stars45/RadioHandler.h +++ b/Stars45/RadioHandler.h @@ -73,5 +73,5 @@ protected: // +--------------------------------------------------------------------+ -#endif RadioHandler_h +#endif // RadioHandler_h diff --git a/Stars45/RadioMessage.h b/Stars45/RadioMessage.h index 6ed2bd9..545cec4 100644 --- a/Stars45/RadioMessage.h +++ b/Stars45/RadioMessage.h @@ -175,5 +175,5 @@ protected: // +--------------------------------------------------------------------+ -#endif RadioMessage_h +#endif // RadioMessage_h diff --git a/Stars45/RadioTraffic.h b/Stars45/RadioTraffic.h index 18b854f..ede1510 100644 --- a/Stars45/RadioTraffic.h +++ b/Stars45/RadioTraffic.h @@ -85,5 +85,5 @@ protected: // +--------------------------------------------------------------------+ -#endif RadioTraffic_h +#endif // RadioTraffic_h diff --git a/Stars45/RadioView.h b/Stars45/RadioView.h index 3ddac36..5e38fac 100644 --- a/Stars45/RadioView.h +++ b/Stars45/RadioView.h @@ -107,5 +107,5 @@ protected: static ThreadSync sync; }; -#endif RadioView_h +#endif // RadioView_h diff --git a/Stars45/RadioVox.h b/Stars45/RadioVox.h index e49a25c..971663b 100644 --- a/Stars45/RadioVox.h +++ b/Stars45/RadioVox.h @@ -79,5 +79,5 @@ protected: int channel; }; -#endif RadioVox_h +#endif // RadioVox_h diff --git a/Stars45/Random.h b/Stars45/Random.h index 0c12290..c749a3b 100644 --- a/Stars45/Random.h +++ b/Stars45/Random.h @@ -56,4 +56,4 @@ int RandomShuffle(int count); // +----------------------------------------------------------------------+ -#endif Random_h +#endif // Random_h diff --git a/Stars45/Res.h b/Stars45/Res.h index cc911fb..c73762c 100644 --- a/Stars45/Res.h +++ b/Stars45/Res.h @@ -57,5 +57,5 @@ protected: HANDLE id; }; -#endif Res_h +#endif // Res_h diff --git a/Stars45/RichTextBox.h b/Stars45/RichTextBox.h index 4d382e4..da91218 100644 --- a/Stars45/RichTextBox.h +++ b/Stars45/RichTextBox.h @@ -85,5 +85,5 @@ protected: }; -#endif RichTextBox_h +#endif // RichTextBox_h diff --git a/Stars45/Scene.h b/Stars45/Scene.h index 1c0a894..ebed0de 100644 --- a/Stars45/Scene.h +++ b/Stars45/Scene.h @@ -97,4 +97,4 @@ protected: // +--------------------------------------------------------------------+ -#endif Scene_h +#endif // Scene_h diff --git a/Stars45/Screen.h b/Stars45/Screen.h index d74a759..bd4af55 100644 --- a/Stars45/Screen.h +++ b/Stars45/Screen.h @@ -85,5 +85,5 @@ protected: List<Window> window_list; }; -#endif Screen_h +#endif // Screen_h diff --git a/Stars45/ScrollWindow.h b/Stars45/ScrollWindow.h index a2259c8..7a1a6b0 100644 --- a/Stars45/ScrollWindow.h +++ b/Stars45/ScrollWindow.h @@ -152,5 +152,5 @@ protected: double smooth_offset; }; -#endif ScrollWindow_h +#endif // ScrollWindow_h diff --git a/Stars45/SeekerAI.h b/Stars45/SeekerAI.h index 223d77f..791d09b 100644 --- a/Stars45/SeekerAI.h +++ b/Stars45/SeekerAI.h @@ -93,5 +93,5 @@ protected: // +--------------------------------------------------------------------+ -#endif SeekerAI_h +#endif // SeekerAI_h diff --git a/Stars45/Sensor.h b/Stars45/Sensor.h index c0fa301..6e0e4ef 100644 --- a/Stars45/Sensor.h +++ b/Stars45/Sensor.h @@ -106,5 +106,5 @@ protected: List<Contact> contacts; }; -#endif Sensor_h +#endif // Sensor_h diff --git a/Stars45/Shadow.h b/Stars45/Shadow.h index b6d690c..9f34bbc 100644 --- a/Stars45/Shadow.h +++ b/Stars45/Shadow.h @@ -90,5 +90,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Shadow_h +#endif // Shadow_h diff --git a/Stars45/Shield.h b/Stars45/Shield.h index ac618e5..c70db24 100644 --- a/Stars45/Shield.h +++ b/Stars45/Shield.h @@ -97,5 +97,5 @@ protected: float deflection_cost; }; -#endif Shield_h +#endif // Shield_h diff --git a/Stars45/ShieldRep.h b/Stars45/ShieldRep.h index e7c0990..250861a 100644 --- a/Stars45/ShieldRep.h +++ b/Stars45/ShieldRep.h @@ -68,5 +68,5 @@ protected: bool bubble; }; -#endif ShieldRep_h +#endif // ShieldRep_h diff --git a/Stars45/Ship.h b/Stars45/Ship.h index 0ad48d9..8aebf03 100644 --- a/Stars45/Ship.h +++ b/Stars45/Ship.h @@ -603,5 +603,5 @@ protected: static double friendly_fire_level; }; -#endif Ship_h +#endif // Ship_h diff --git a/Stars45/ShipAI.h b/Stars45/ShipAI.h index d4bb34a..04c8a12 100644 --- a/Stars45/ShipAI.h +++ b/Stars45/ShipAI.h @@ -173,5 +173,5 @@ protected: // +--------------------------------------------------------------------+ -#endif ShipAI_h +#endif // ShipAI_h diff --git a/Stars45/ShipCtrl.h b/Stars45/ShipCtrl.h index 26a33b0..69d4b10 100644 --- a/Stars45/ShipCtrl.h +++ b/Stars45/ShipCtrl.h @@ -79,5 +79,5 @@ protected: bool target_latch; }; -#endif ShipCtrl_h +#endif // ShipCtrl_h diff --git a/Stars45/ShipDesign.h b/Stars45/ShipDesign.h index cec02b5..a35033b 100644 --- a/Stars45/ShipDesign.h +++ b/Stars45/ShipDesign.h @@ -312,5 +312,5 @@ public: // +--------------------------------------------------------------------+ -#endif ShipDesign_h +#endif // ShipDesign_h diff --git a/Stars45/ShipKiller.h b/Stars45/ShipKiller.h index e564943..aeda90b 100644 --- a/Stars45/ShipKiller.h +++ b/Stars45/ShipKiller.h @@ -75,5 +75,5 @@ protected: int exp_index; }; -#endif ShipKiller_h +#endif // ShipKiller_h diff --git a/Stars45/ShipSolid.h b/Stars45/ShipSolid.h index be99068..39389c7 100644 --- a/Stars45/ShipSolid.h +++ b/Stars45/ShipSolid.h @@ -72,5 +72,5 @@ protected: // +--------------------------------------------------------------------+ -#endif ShipSolid_h +#endif // ShipSolid_h diff --git a/Stars45/Shot.h b/Stars45/Shot.h index 4ea013c..f655494 100644 --- a/Stars45/Shot.h +++ b/Stars45/Shot.h @@ -149,5 +149,5 @@ protected: Point origin; }; -#endif Shot_h +#endif // Shot_h diff --git a/Stars45/Sim.h b/Stars45/Sim.h index ddad6a8..1a36d7f 100644 --- a/Stars45/Sim.h +++ b/Stars45/Sim.h @@ -350,5 +350,5 @@ protected: int ai_index; }; -#endif Sim_h +#endif // Sim_h diff --git a/Stars45/SimEvent.h b/Stars45/SimEvent.h index 54773bb..566768b 100644 --- a/Stars45/SimEvent.h +++ b/Stars45/SimEvent.h @@ -183,5 +183,5 @@ private: List<SimEvent> events; }; -#endif SimEvent_h +#endif // SimEvent_h diff --git a/Stars45/SimObject.h b/Stars45/SimObject.h index 93b58cf..0313a1e 100644 --- a/Stars45/SimObject.h +++ b/Stars45/SimObject.h @@ -119,5 +119,5 @@ protected: List<SimObject> observe_list; }; -#endif SimObject_h +#endif // SimObject_h diff --git a/Stars45/Skin.h b/Stars45/Skin.h index 276d9c0..7981900 100644 --- a/Stars45/Skin.h +++ b/Stars45/Skin.h @@ -112,5 +112,5 @@ private: // +--------------------------------------------------------------------+ -#endif Skin_h +#endif // Skin_h diff --git a/Stars45/Sky.h b/Stars45/Sky.h index a7e3e4a..591824c 100644 --- a/Stars45/Sky.h +++ b/Stars45/Sky.h @@ -125,5 +125,5 @@ protected: StarSystem* star_system; }; -#endif Sky_h +#endif // Sky_h diff --git a/Stars45/Slider.h b/Stars45/Slider.h index e1a5347..4008977 100644 --- a/Stars45/Slider.h +++ b/Stars45/Slider.h @@ -127,5 +127,5 @@ protected: int marker[2]; }; -#endif Slider_h +#endif // Slider_h diff --git a/Stars45/Solid.h b/Stars45/Solid.h index ef745ca..87cc5e0 100644 --- a/Stars45/Solid.h +++ b/Stars45/Solid.h @@ -333,5 +333,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Solid_h +#endif // Solid_h diff --git a/Stars45/Sound.h b/Stars45/Sound.h index d4e0374..31460c0 100644 --- a/Stars45/Sound.h +++ b/Stars45/Sound.h @@ -170,5 +170,5 @@ public: virtual void Update(Sound* s) { } }; -#endif Sound_h +#endif // Sound_h diff --git a/Stars45/SoundCard.h b/Stars45/SoundCard.h index 295a6e2..2c98d32 100644 --- a/Stars45/SoundCard.h +++ b/Stars45/SoundCard.h @@ -96,5 +96,5 @@ protected: ThreadSync sync; }; -#endif SoundCard_h +#endif // SoundCard_h diff --git a/Stars45/SoundD3D.h b/Stars45/SoundD3D.h index 3a8e089..ae7b786 100644 --- a/Stars45/SoundD3D.h +++ b/Stars45/SoundD3D.h @@ -182,5 +182,5 @@ protected: DSBUFFERDESC dsbd; }; -#endif SoundD3D_h +#endif // SoundD3D_h diff --git a/Stars45/Sprite.h b/Stars45/Sprite.h index b28b91c..c120b6a 100644 --- a/Stars45/Sprite.h +++ b/Stars45/Sprite.h @@ -110,5 +110,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Sprite_h +#endif // Sprite_h diff --git a/Stars45/StarServer.h b/Stars45/StarServer.h index dc4b504..46d99a1 100644 --- a/Stars45/StarServer.h +++ b/Stars45/StarServer.h @@ -97,4 +97,4 @@ protected: DWORD minutes; }; -#endif StarServer_h +#endif // StarServer_h diff --git a/Stars45/StarSystem.cpp b/Stars45/StarSystem.cpp index 8daed31..3c91f99 100644 --- a/Stars45/StarSystem.cpp +++ b/Stars45/StarSystem.cpp @@ -54,34 +54,17 @@ #include "Scene.h" #include "ParseUtil.h" -const double epoch = 0.5e9; -double StarSystem::stardate = 0; +const long double epoch = 0.5e9; +long double StarSystem::stardate = 0; // +====================================================================+ -static double base_time = 0; +static long double base_time = 0; static WORD oldcw = 0; static WORD fpcw = 0; -void FPU2Extended() +void StarSystem::SetBaseTime(long double t, bool absolute) { - _asm { fstcw oldcw } - fpcw = oldcw | 0x0300; // set 80-bit precision mode - _asm { fldcw fpcw } -} - -void FPURestore() -{ - // well, I don't actually WANT single-precision mode - // so I think I'll just ignore this... - - //_asm { fldcw oldcw } -} - -void StarSystem::SetBaseTime(double t, bool absolute) -{ - FPU2Extended(); - if (absolute) { base_time = t; CalcStardate(); @@ -94,7 +77,7 @@ void StarSystem::SetBaseTime(double t, bool absolute) } } -double StarSystem::GetBaseTime() +long double StarSystem::GetBaseTime() { return base_time; } @@ -111,14 +94,10 @@ void StarSystem::CalcStardate() base_time += epoch; } - FPU2Extended(); - - double gtime = (double) Game::GameTime() / 1000.0; - double sdate = gtime + base_time + epoch; + long double gtime = (long double) Game::GameTime() / 1000.0; + long double sdate = gtime + base_time + epoch; stardate = sdate; - - FPURestore(); } static const double GRAV = 6.673e-11; diff --git a/Stars45/StarSystem.h b/Stars45/StarSystem.h index 75a0abe..90b77df 100644 --- a/Stars45/StarSystem.h +++ b/Stars45/StarSystem.h @@ -102,9 +102,9 @@ public: void SetActiveRegion(OrbitalRegion* rgn); - static void SetBaseTime(double t, bool absolute=false); - static double GetBaseTime(); - static double Stardate() { return stardate; } + static void SetBaseTime(long double t, bool absolute=false); + static long double GetBaseTime(); + static long double Stardate() { return stardate; } static void CalcStardate(); double Radius() const { return radius; } @@ -133,7 +133,7 @@ protected: int affiliation; int seq; Point loc; - static double stardate; + static long double stardate; double radius; bool instantiated; @@ -342,5 +342,5 @@ protected: List<Text> links; }; -#endif StarSystem_h +#endif // StarSystem_h diff --git a/Stars45/Starshatter.h b/Stars45/Starshatter.h index 939b54b..c5aacf6 100644 --- a/Stars45/Starshatter.h +++ b/Stars45/Starshatter.h @@ -246,4 +246,4 @@ protected: Text chat_text; }; -#endif Starshatter_h +#endif // Starshatter_h diff --git a/Stars45/StarshipAI.h b/Stars45/StarshipAI.h index a7eedf0..f7457f3 100644 --- a/Stars45/StarshipAI.h +++ b/Stars45/StarshipAI.h @@ -82,5 +82,5 @@ protected: // +--------------------------------------------------------------------+ -#endif StarshipAI_h +#endif // StarshipAI_h diff --git a/Stars45/StarshipTacticalAI.cpp b/Stars45/StarshipTacticalAI.cpp index 977b86b..e00e8d2 100644 --- a/Stars45/StarshipTacticalAI.cpp +++ b/Stars45/StarshipTacticalAI.cpp @@ -36,6 +36,12 @@ Starship-specific mid-level (tactical) AI */ +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#include <algorithm> + #include "MemDebug.h" #include "StarshipTacticalAI.h" #include "ShipAI.h" @@ -128,7 +134,7 @@ StarshipTacticalAI::FindThreat() continue; if (c_ship && c_ship != ship) { - double basis = max(contact->Range(ship), CELL_SIZE); + double basis = std::max(contact->Range(ship), CELL_SIZE); double ai_value = c_ship->AIValue() / basis; if (c_ship->GetIFF() == ship->GetIFF()) { diff --git a/Stars45/StarshipTacticalAI.h b/Stars45/StarshipTacticalAI.h index b0e7587..2d8231f 100644 --- a/Stars45/StarshipTacticalAI.h +++ b/Stars45/StarshipTacticalAI.h @@ -67,5 +67,5 @@ protected: // +--------------------------------------------------------------------+ -#endif StarshipTacticalAI_h +#endif // StarshipTacticalAI_h diff --git a/Stars45/SteerAI.h b/Stars45/SteerAI.h index 349405e..93dbacd 100644 --- a/Stars45/SteerAI.h +++ b/Stars45/SteerAI.h @@ -145,5 +145,5 @@ protected: // +--------------------------------------------------------------------+ -#endif SteerAI_h +#endif // SteerAI_h diff --git a/Stars45/System.h b/Stars45/System.h index a41712a..62c5b06 100644 --- a/Stars45/System.h +++ b/Stars45/System.h @@ -194,5 +194,5 @@ protected: List<Component> components; }; -#endif System_h +#endif // System_h diff --git a/Stars45/SystemDesign.h b/Stars45/SystemDesign.h index bfe9f93..b1cb8c0 100644 --- a/Stars45/SystemDesign.h +++ b/Stars45/SystemDesign.h @@ -74,5 +74,5 @@ public: // +--------------------------------------------------------------------+ -#endif SystemDesign_h +#endif // SystemDesign_h diff --git a/Stars45/TacRefDlg.h b/Stars45/TacRefDlg.h index a24f932..9495f27 100644 --- a/Stars45/TacRefDlg.h +++ b/Stars45/TacRefDlg.h @@ -121,5 +121,5 @@ protected: int weap_index; }; -#endif TacRefDlg_h +#endif // TacRefDlg_h diff --git a/Stars45/TacticalAI.h b/Stars45/TacticalAI.h index 5a54f69..80b4fda 100644 --- a/Stars45/TacticalAI.h +++ b/Stars45/TacticalAI.h @@ -111,5 +111,5 @@ protected: // +--------------------------------------------------------------------+ -#endif TacticalAI_h +#endif // TacticalAI_h diff --git a/Stars45/TacticalView.h b/Stars45/TacticalView.h index 2124737..8210fef 100644 --- a/Stars45/TacticalView.h +++ b/Stars45/TacticalView.h @@ -140,5 +140,5 @@ protected: static TacticalView* tac_view; }; -#endif TacticalView_h +#endif // TacticalView_h diff --git a/Stars45/Terrain.h b/Stars45/Terrain.h index f591d80..2c69e3c 100644 --- a/Stars45/Terrain.h +++ b/Stars45/Terrain.h @@ -139,5 +139,5 @@ protected: static int detail_level; }; -#endif Terrain_h +#endif // Terrain_h diff --git a/Stars45/TerrainApron.h b/Stars45/TerrainApron.h index 01739e7..7209ab5 100644 --- a/Stars45/TerrainApron.h +++ b/Stars45/TerrainApron.h @@ -91,5 +91,5 @@ protected: }; -#endif TerrainApron_h +#endif // TerrainApron_h diff --git a/Stars45/TerrainClouds.h b/Stars45/TerrainClouds.h index 6349c1f..e99a0ab 100644 --- a/Stars45/TerrainClouds.h +++ b/Stars45/TerrainClouds.h @@ -84,5 +84,5 @@ protected: }; -#endif TerrainClouds_h +#endif // TerrainClouds_h diff --git a/Stars45/TerrainHaze.h b/Stars45/TerrainHaze.h index ea30f9a..373baab 100644 --- a/Stars45/TerrainHaze.h +++ b/Stars45/TerrainHaze.h @@ -66,5 +66,5 @@ protected: TerrainRegion* tregion; }; -#endif TerrainHaze_h +#endif // TerrainHaze_h diff --git a/Stars45/TerrainLayer.h b/Stars45/TerrainLayer.h index 8283d70..f3678ef 100644 --- a/Stars45/TerrainLayer.h +++ b/Stars45/TerrainLayer.h @@ -83,5 +83,5 @@ private: }; -#endif TerrainLayer_h +#endif // TerrainLayer_h diff --git a/Stars45/TerrainPatch.cpp b/Stars45/TerrainPatch.cpp index c9108f6..309d376 100644 --- a/Stars45/TerrainPatch.cpp +++ b/Stars45/TerrainPatch.cpp @@ -930,7 +930,8 @@ TerrainPatch::Render(Video* video, DWORD flags) return; if (water) { - UpdateSurfaceWaves(Vec3(0,0,0)); + Vec3 vec(0, 0, 0); + UpdateSurfaceWaves(vec); Illuminate(scene->Ambient(), scene->Lights()); } else { diff --git a/Stars45/TerrainPatch.h b/Stars45/TerrainPatch.h index a2d3797..51f4080 100644 --- a/Stars45/TerrainPatch.h +++ b/Stars45/TerrainPatch.h @@ -114,5 +114,5 @@ protected: float max_height; }; -#endif TerrainPatch_h +#endif // TerrainPatch_h diff --git a/Stars45/TerrainRegion.h b/Stars45/TerrainRegion.h index 3edd8a0..98230ce 100644 --- a/Stars45/TerrainRegion.h +++ b/Stars45/TerrainRegion.h @@ -146,5 +146,5 @@ protected: List<TerrainLayer> layers; }; -#endif TerrainRegion_h +#endif // TerrainRegion_h diff --git a/Stars45/Thruster.h b/Stars45/Thruster.h index 11184bd..c78a41d 100644 --- a/Stars45/Thruster.h +++ b/Stars45/Thruster.h @@ -117,5 +117,5 @@ protected: List<ThrusterPort> ports; }; -#endif Thruster_h +#endif // Thruster_h diff --git a/Stars45/TimeSnap.h b/Stars45/TimeSnap.h deleted file mode 100644 index a8f77d2..0000000 --- a/Stars45/TimeSnap.h +++ /dev/null @@ -1,50 +0,0 @@ -/* Starshatter OpenSource Distribution - Copyright (c) 1997-2004, Destroyer Studios LLC. - All Rights Reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - * Neither the name "Destroyer Studios" nor the names of its contributors - may be used to endorse or promote products derived from this software - without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE - LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. - - SUBSYSTEM: nGen.lib - FILE: TimeSnap.h - AUTHOR: John DiCamillo - -*/ - -#ifndef TimeSnap_h -#define TimeSnap_h - -// +--------------------------------------------------------------------+ - -#define TIMESNAP(clock) _asm push eax\ - _asm push edx\ - _asm _emit 0x0F\ - _asm _emit 0x31\ - _asm mov clock, eax\ - _asm pop edx\ - _asm pop eax - -// +--------------------------------------------------------------------+ - -#endif TimeSnap_h
\ No newline at end of file diff --git a/Stars45/TrackIR.h b/Stars45/TrackIR.h index 866068f..dbbb588 100644 --- a/Stars45/TrackIR.h +++ b/Stars45/TrackIR.h @@ -73,5 +73,5 @@ protected: double z; // vpn (i think) }; -#endif TrackIR_h +#endif // TrackIR_h diff --git a/Stars45/Trail.h b/Stars45/Trail.h index d2eb260..dc22c42 100644 --- a/Stars45/Trail.h +++ b/Stars45/Trail.h @@ -80,5 +80,5 @@ protected: double last_point_time; }; -#endif Trail_h +#endif // Trail_h diff --git a/Stars45/Types.h b/Stars45/Types.h index 5798536..cec7fae 100644 --- a/Stars45/Types.h +++ b/Stars45/Types.h @@ -86,5 +86,5 @@ // +--------------------------------------------------------------------+ -#endif Types_h +#endif // Types_h diff --git a/Stars45/Universe.h b/Stars45/Universe.h index dae7c58..1c18743 100644 --- a/Stars45/Universe.h +++ b/Stars45/Universe.h @@ -52,5 +52,5 @@ public: virtual void ExecFrame(double seconds) { } }; -#endif Universe_h +#endif // Universe_h diff --git a/Stars45/VidDlg.h b/Stars45/VidDlg.h index 2b22b52..006fec3 100644 --- a/Stars45/VidDlg.h +++ b/Stars45/VidDlg.h @@ -126,5 +126,5 @@ protected: bool closed; }; -#endif VidDlg_h +#endif // VidDlg_h diff --git a/Stars45/Video.h b/Stars45/Video.h index db34bcc..e600a3f 100644 --- a/Stars45/Video.h +++ b/Stars45/Video.h @@ -262,5 +262,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Video_h +#endif // Video_h diff --git a/Stars45/VideoDX9.h b/Stars45/VideoDX9.h index fdc37ff..0cabf13 100644 --- a/Stars45/VideoDX9.h +++ b/Stars45/VideoDX9.h @@ -215,5 +215,5 @@ private: VideoDX9LineVertex* line_verts; }; -#endif VideoDX9_h +#endif // VideoDX9_h diff --git a/Stars45/VideoDX9Enum.h b/Stars45/VideoDX9Enum.h index 80c0b89..99e5c11 100644 --- a/Stars45/VideoDX9Enum.h +++ b/Stars45/VideoDX9Enum.h @@ -205,5 +205,5 @@ struct VideoDX9DeviceCombo // +--------------------------------------------------------------------+ -#endif VideoDX9Enum_h +#endif // VideoDX9Enum_h diff --git a/Stars45/VideoDX9VertexBuffer.h b/Stars45/VideoDX9VertexBuffer.h index 5684dbf..d13943d 100644 --- a/Stars45/VideoDX9VertexBuffer.h +++ b/Stars45/VideoDX9VertexBuffer.h @@ -99,5 +99,5 @@ private: bool is_dynamic; }; -#endif VideoDX9VertexBuffer_h +#endif // VideoDX9VertexBuffer_h diff --git a/Stars45/VideoFactory.h b/Stars45/VideoFactory.h index a24b2e2..62c6fca 100644 --- a/Stars45/VideoFactory.h +++ b/Stars45/VideoFactory.h @@ -62,5 +62,5 @@ private: SoundCard* audio; }; -#endif VideoFactory_h +#endif // VideoFactory_h diff --git a/Stars45/VideoSettings.h b/Stars45/VideoSettings.h index ad03222..a3f3a20 100644 --- a/Stars45/VideoSettings.h +++ b/Stars45/VideoSettings.h @@ -151,5 +151,5 @@ public: float depth_bias; }; -#endif VideoSettings_h +#endif // VideoSettings_h diff --git a/Stars45/View.h b/Stars45/View.h index 3c1eb61..bfa6e63 100644 --- a/Stars45/View.h +++ b/Stars45/View.h @@ -72,5 +72,5 @@ protected: Window* window; }; -#endif View_h +#endif // View_h diff --git a/Stars45/Water.h b/Stars45/Water.h index b4fe4db..9ad5cc1 100644 --- a/Stars45/Water.h +++ b/Stars45/Water.h @@ -74,5 +74,5 @@ protected: // +--------------------------------------------------------------------+ -#endif Water_h +#endif // Water_h diff --git a/Stars45/Wave.h b/Stars45/Wave.h index 058fc27..ae31e05 100644 --- a/Stars45/Wave.h +++ b/Stars45/Wave.h @@ -72,5 +72,5 @@ struct WAVE_DATA // +--------------------------------------------------------------------+ -#endif Wave_h +#endif // Wave_h diff --git a/Stars45/Weapon.h b/Stars45/Weapon.h index b20237a..468d655 100644 --- a/Stars45/Weapon.h +++ b/Stars45/Weapon.h @@ -224,5 +224,5 @@ protected: Shot** beams; }; -#endif Weapon_h +#endif // Weapon_h diff --git a/Stars45/WeaponDesign.h b/Stars45/WeaponDesign.h index 2060728..d4a34f6 100644 --- a/Stars45/WeaponDesign.h +++ b/Stars45/WeaponDesign.h @@ -207,5 +207,5 @@ private: static void LoadDesign(const char* path, const char* filename, bool mod=false); }; -#endif WeaponDesign_h +#endif // WeaponDesign_h diff --git a/Stars45/WeaponGroup.h b/Stars45/WeaponGroup.h index 37092d1..8b379d4 100644 --- a/Stars45/WeaponGroup.h +++ b/Stars45/WeaponGroup.h @@ -126,5 +126,5 @@ protected: float resist; }; -#endif WeaponGroup_h +#endif // WeaponGroup_h diff --git a/Stars45/Weather.h b/Stars45/Weather.h index 882b451..36a253c 100644 --- a/Stars45/Weather.h +++ b/Stars45/Weather.h @@ -87,5 +87,5 @@ protected: }; -#endif Weather_h +#endif // Weather_h diff --git a/Stars45/WebBrowser.h b/Stars45/WebBrowser.h index 4248e06..43b3da6 100644 --- a/Stars45/WebBrowser.h +++ b/Stars45/WebBrowser.h @@ -65,6 +65,6 @@ protected: // +--------------------------------------------------------------------+ -#endif WebBrowser_h +#endif // WebBrowser_h diff --git a/Stars45/WepView.h b/Stars45/WepView.h index e21e933..c6e515d 100644 --- a/Stars45/WepView.h +++ b/Stars45/WepView.h @@ -108,5 +108,5 @@ protected: static WepView* wep_view; }; -#endif WepView_h +#endif // WepView_h diff --git a/Stars45/Window.h b/Stars45/Window.h index 6688b44..04d07f3 100644 --- a/Stars45/Window.h +++ b/Stars45/Window.h @@ -124,5 +124,5 @@ protected: List<View> view_list; }; -#endif Window_h +#endif // Window_h |