diff --git a/thirdparty/recastnavigation/License.txt b/thirdparty/recastnavigation/License.txt deleted file mode 100644 index 95f4bfc..0000000 --- a/thirdparty/recastnavigation/License.txt +++ /dev/null @@ -1,18 +0,0 @@ -Copyright (c) 2009 Mikko Mononen memon@inside.org - -This software is provided 'as-is', without any express or implied -warranty. In no event will the authors be held liable for any damages -arising from the use of this software. - -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it -freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not -claim that you wrote the original software. If you use this software -in a product, an acknowledgment in the product documentation would be -appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be -misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. - diff --git a/thirdparty/recastnavigation/Recast/Include/Recast.h b/thirdparty/recastnavigation/Recast/Include/Recast.h deleted file mode 100644 index 9def8fd..0000000 --- a/thirdparty/recastnavigation/Recast/Include/Recast.h +++ /dev/null @@ -1,1336 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#ifndef RECAST_H -#define RECAST_H - -/// The value of PI used by Recast. -static const float RC_PI = 3.14159265f; - -/// Used to ignore unused function parameters and silence any compiler warnings. -template void rcIgnoreUnused(const T&) { } - -/// Recast log categories. -/// @see rcContext -enum rcLogCategory -{ - RC_LOG_PROGRESS = 1, ///< A progress log entry. - RC_LOG_WARNING, ///< A warning log entry. - RC_LOG_ERROR ///< An error log entry. -}; - -/// Recast performance timer categories. -/// @see rcContext -enum rcTimerLabel -{ - /// The user defined total time of the build. - RC_TIMER_TOTAL, - /// A user defined build time. - RC_TIMER_TEMP, - /// The time to rasterize the triangles. (See: #rcRasterizeTriangle) - RC_TIMER_RASTERIZE_TRIANGLES, - /// The time to build the compact heightfield. (See: #rcBuildCompactHeightfield) - RC_TIMER_BUILD_COMPACTHEIGHTFIELD, - /// The total time to build the contours. (See: #rcBuildContours) - RC_TIMER_BUILD_CONTOURS, - /// The time to trace the boundaries of the contours. (See: #rcBuildContours) - RC_TIMER_BUILD_CONTOURS_TRACE, - /// The time to simplify the contours. (See: #rcBuildContours) - RC_TIMER_BUILD_CONTOURS_SIMPLIFY, - /// The time to filter ledge spans. (See: #rcFilterLedgeSpans) - RC_TIMER_FILTER_BORDER, - /// The time to filter low height spans. (See: #rcFilterWalkableLowHeightSpans) - RC_TIMER_FILTER_WALKABLE, - /// The time to apply the median filter. (See: #rcMedianFilterWalkableArea) - RC_TIMER_MEDIAN_AREA, - /// The time to filter low obstacles. (See: #rcFilterLowHangingWalkableObstacles) - RC_TIMER_FILTER_LOW_OBSTACLES, - /// The time to build the polygon mesh. (See: #rcBuildPolyMesh) - RC_TIMER_BUILD_POLYMESH, - /// The time to merge polygon meshes. (See: #rcMergePolyMeshes) - RC_TIMER_MERGE_POLYMESH, - /// The time to erode the walkable area. (See: #rcErodeWalkableArea) - RC_TIMER_ERODE_AREA, - /// The time to mark a box area. (See: #rcMarkBoxArea) - RC_TIMER_MARK_BOX_AREA, - /// The time to mark a cylinder area. (See: #rcMarkCylinderArea) - RC_TIMER_MARK_CYLINDER_AREA, - /// The time to mark a convex polygon area. (See: #rcMarkConvexPolyArea) - RC_TIMER_MARK_CONVEXPOLY_AREA, - /// The total time to build the distance field. (See: #rcBuildDistanceField) - RC_TIMER_BUILD_DISTANCEFIELD, - /// The time to build the distances of the distance field. (See: #rcBuildDistanceField) - RC_TIMER_BUILD_DISTANCEFIELD_DIST, - /// The time to blur the distance field. (See: #rcBuildDistanceField) - RC_TIMER_BUILD_DISTANCEFIELD_BLUR, - /// The total time to build the regions. (See: #rcBuildRegions, #rcBuildRegionsMonotone) - RC_TIMER_BUILD_REGIONS, - /// The total time to apply the watershed algorithm. (See: #rcBuildRegions) - RC_TIMER_BUILD_REGIONS_WATERSHED, - /// The time to expand regions while applying the watershed algorithm. (See: #rcBuildRegions) - RC_TIMER_BUILD_REGIONS_EXPAND, - /// The time to flood regions while applying the watershed algorithm. (See: #rcBuildRegions) - RC_TIMER_BUILD_REGIONS_FLOOD, - /// The time to filter out small regions. (See: #rcBuildRegions, #rcBuildRegionsMonotone) - RC_TIMER_BUILD_REGIONS_FILTER, - /// The time to build heightfield layers. (See: #rcBuildHeightfieldLayers) - RC_TIMER_BUILD_LAYERS, - /// The time to build the polygon mesh detail. (See: #rcBuildPolyMeshDetail) - RC_TIMER_BUILD_POLYMESHDETAIL, - /// The time to merge polygon mesh details. (See: #rcMergePolyMeshDetails) - RC_TIMER_MERGE_POLYMESHDETAIL, - /// The maximum number of timers. (Used for iterating timers.) - RC_MAX_TIMERS -}; - -/// Provides an interface for optional logging and performance tracking of the Recast -/// build process. -/// -/// This class does not provide logging or timer functionality on its -/// own. Both must be provided by a concrete implementation -/// by overriding the protected member functions. Also, this class does not -/// provide an interface for extracting log messages. (Only adding them.) -/// So concrete implementations must provide one. -/// -/// If no logging or timers are required, just pass an instance of this -/// class through the Recast build process. -/// -/// @ingroup recast -class rcContext -{ -public: - /// Constructor. - /// @param[in] state TRUE if the logging and performance timers should be enabled. [Default: true] - inline rcContext(bool state = true) : m_logEnabled(state), m_timerEnabled(state) {} - virtual ~rcContext() {} - - /// Enables or disables logging. - /// @param[in] state TRUE if logging should be enabled. - inline void enableLog(bool state) { m_logEnabled = state; } - - /// Clears all log entries. - inline void resetLog() { if (m_logEnabled) doResetLog(); } - - /// Logs a message. - /// - /// Example: - /// @code - /// // Where ctx is an instance of rcContext and filepath is a char array. - /// ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not load '%s'", filepath); - /// @endcode - /// - /// @param[in] category The category of the message. - /// @param[in] format The message. - void log(const rcLogCategory category, const char* format, ...); - - /// Enables or disables the performance timers. - /// @param[in] state TRUE if timers should be enabled. - inline void enableTimer(bool state) { m_timerEnabled = state; } - - /// Clears all performance timers. (Resets all to unused.) - inline void resetTimers() { if (m_timerEnabled) doResetTimers(); } - - /// Starts the specified performance timer. - /// @param label The category of the timer. - inline void startTimer(const rcTimerLabel label) { if (m_timerEnabled) doStartTimer(label); } - - /// Stops the specified performance timer. - /// @param label The category of the timer. - inline void stopTimer(const rcTimerLabel label) { if (m_timerEnabled) doStopTimer(label); } - - /// Returns the total accumulated time of the specified performance timer. - /// @param label The category of the timer. - /// @return The accumulated time of the timer, or -1 if timers are disabled or the timer has never been started. - inline int getAccumulatedTime(const rcTimerLabel label) const { return m_timerEnabled ? doGetAccumulatedTime(label) : -1; } - -protected: - /// Clears all log entries. - virtual void doResetLog(); - - /// Logs a message. - /// @param[in] category The category of the message. - /// @param[in] msg The formatted message. - /// @param[in] len The length of the formatted message. - virtual void doLog(const rcLogCategory category, const char* msg, const int len) { rcIgnoreUnused(category); rcIgnoreUnused(msg); rcIgnoreUnused(len); } - - /// Clears all timers. (Resets all to unused.) - virtual void doResetTimers() {} - - /// Starts the specified performance timer. - /// @param[in] label The category of timer. - virtual void doStartTimer(const rcTimerLabel label) { rcIgnoreUnused(label); } - - /// Stops the specified performance timer. - /// @param[in] label The category of the timer. - virtual void doStopTimer(const rcTimerLabel label) { rcIgnoreUnused(label); } - - /// Returns the total accumulated time of the specified performance timer. - /// @param[in] label The category of the timer. - /// @return The accumulated time of the timer, or -1 if timers are disabled or the timer has never been started. - virtual int doGetAccumulatedTime(const rcTimerLabel label) const { rcIgnoreUnused(label); return -1; } - - /// True if logging is enabled. - bool m_logEnabled; - - /// True if the performance timers are enabled. - bool m_timerEnabled; -}; - -/// A helper to first start a timer and then stop it when this helper goes out of scope. -/// @see rcContext -class rcScopedTimer -{ -public: - /// Constructs an instance and starts the timer. - /// @param[in] ctx The context to use. - /// @param[in] label The category of the timer. - inline rcScopedTimer(rcContext* ctx, const rcTimerLabel label) : m_ctx(ctx), m_label(label) { m_ctx->startTimer(m_label); } - inline ~rcScopedTimer() { m_ctx->stopTimer(m_label); } - -private: - // Explicitly disabled copy constructor and copy assignment operator. - rcScopedTimer(const rcScopedTimer&); - rcScopedTimer& operator=(const rcScopedTimer&); - - rcContext* const m_ctx; - const rcTimerLabel m_label; -}; - -/// Specifies a configuration to use when performing Recast builds. -/// @ingroup recast -struct rcConfig -{ - /// The width of the field along the x-axis. [Limit: >= 0] [Units: vx] - int width; - - /// The height of the field along the z-axis. [Limit: >= 0] [Units: vx] - int height; - - /// The width/height size of tile's on the xz-plane. [Limit: >= 0] [Units: vx] - int tileSize; - - /// The size of the non-navigable border around the heightfield. [Limit: >=0] [Units: vx] - int borderSize; - - /// The xz-plane cell size to use for fields. [Limit: > 0] [Units: wu] - float cs; - - /// The y-axis cell size to use for fields. [Limit: > 0] [Units: wu] - float ch; - - /// The minimum bounds of the field's AABB. [(x, y, z)] [Units: wu] - float bmin[3]; - - /// The maximum bounds of the field's AABB. [(x, y, z)] [Units: wu] - float bmax[3]; - - /// The maximum slope that is considered walkable. [Limits: 0 <= value < 90] [Units: Degrees] - float walkableSlopeAngle; - - /// Minimum floor to 'ceiling' height that will still allow the floor area to - /// be considered walkable. [Limit: >= 3] [Units: vx] - int walkableHeight; - - /// Maximum ledge height that is considered to still be traversable. [Limit: >=0] [Units: vx] - int walkableClimb; - - /// The distance to erode/shrink the walkable area of the heightfield away from - /// obstructions. [Limit: >=0] [Units: vx] - int walkableRadius; - - /// The maximum allowed length for contour edges along the border of the mesh. [Limit: >=0] [Units: vx] - int maxEdgeLen; - - /// The maximum distance a simplified contour's border edges should deviate - /// the original raw contour. [Limit: >=0] [Units: vx] - float maxSimplificationError; - - /// The minimum number of cells allowed to form isolated island areas. [Limit: >=0] [Units: vx] - int minRegionArea; - - /// Any regions with a span count smaller than this value will, if possible, - /// be merged with larger regions. [Limit: >=0] [Units: vx] - int mergeRegionArea; - - /// The maximum number of vertices allowed for polygons generated during the - /// contour to polygon conversion process. [Limit: >= 3] - int maxVertsPerPoly; - - /// Sets the sampling distance to use when generating the detail mesh. - /// (For height detail only.) [Limits: 0 or >= 0.9] [Units: wu] - float detailSampleDist; - - /// The maximum distance the detail mesh surface should deviate from heightfield - /// data. (For height detail only.) [Limit: >=0] [Units: wu] - float detailSampleMaxError; -}; - -/// Defines the number of bits allocated to rcSpan::smin and rcSpan::smax. -static const int RC_SPAN_HEIGHT_BITS = 13; -/// Defines the maximum value for rcSpan::smin and rcSpan::smax. -static const int RC_SPAN_MAX_HEIGHT = (1 << RC_SPAN_HEIGHT_BITS) - 1; - -/// The number of spans allocated per span spool. -/// @see rcSpanPool -static const int RC_SPANS_PER_POOL = 2048; - -/// Represents a span in a heightfield. -/// @see rcHeightfield -struct rcSpan -{ - unsigned int smin : RC_SPAN_HEIGHT_BITS; ///< The lower limit of the span. [Limit: < #smax] - unsigned int smax : RC_SPAN_HEIGHT_BITS; ///< The upper limit of the span. [Limit: <= #RC_SPAN_MAX_HEIGHT] - unsigned int area : 6; ///< The area id assigned to the span. - rcSpan* next; ///< The next span higher up in column. -}; - -/// A memory pool used for quick allocation of spans within a heightfield. -/// @see rcHeightfield -struct rcSpanPool -{ - rcSpanPool* next; ///< The next span pool. - rcSpan items[RC_SPANS_PER_POOL]; ///< Array of spans in the pool. -}; - -/// A dynamic heightfield representing obstructed space. -/// @ingroup recast -struct rcHeightfield -{ - rcHeightfield(); - ~rcHeightfield(); - - int width; ///< The width of the heightfield. (Along the x-axis in cell units.) - int height; ///< The height of the heightfield. (Along the z-axis in cell units.) - float bmin[3]; ///< The minimum bounds in world space. [(x, y, z)] - float bmax[3]; ///< The maximum bounds in world space. [(x, y, z)] - float cs; ///< The size of each cell. (On the xz-plane.) - float ch; ///< The height of each cell. (The minimum increment along the y-axis.) - rcSpan** spans; ///< Heightfield of spans (width*height). - rcSpanPool* pools; ///< Linked list of span pools. - rcSpan* freelist; ///< The next free span. - -private: - // Explicitly-disabled copy constructor and copy assignment operator. - rcHeightfield(const rcHeightfield&); - rcHeightfield& operator=(const rcHeightfield&); -}; - -/// Provides information on the content of a cell column in a compact heightfield. -struct rcCompactCell -{ - unsigned int index : 24; ///< Index to the first span in the column. - unsigned int count : 8; ///< Number of spans in the column. -}; - -/// Represents a span of unobstructed space within a compact heightfield. -struct rcCompactSpan -{ - unsigned short y; ///< The lower extent of the span. (Measured from the heightfield's base.) - unsigned short reg; ///< The id of the region the span belongs to. (Or zero if not in a region.) - unsigned int con : 24; ///< Packed neighbor connection data. - unsigned int h : 8; ///< The height of the span. (Measured from #y.) -}; - -/// A compact, static heightfield representing unobstructed space. -/// @ingroup recast -struct rcCompactHeightfield -{ - rcCompactHeightfield(); - ~rcCompactHeightfield(); - - int width; ///< The width of the heightfield. (Along the x-axis in cell units.) - int height; ///< The height of the heightfield. (Along the z-axis in cell units.) - int spanCount; ///< The number of spans in the heightfield. - int walkableHeight; ///< The walkable height used during the build of the field. (See: rcConfig::walkableHeight) - int walkableClimb; ///< The walkable climb used during the build of the field. (See: rcConfig::walkableClimb) - int borderSize; ///< The AABB border size used during the build of the field. (See: rcConfig::borderSize) - unsigned short maxDistance; ///< The maximum distance value of any span within the field. - unsigned short maxRegions; ///< The maximum region id of any span within the field. - float bmin[3]; ///< The minimum bounds in world space. [(x, y, z)] - float bmax[3]; ///< The maximum bounds in world space. [(x, y, z)] - float cs; ///< The size of each cell. (On the xz-plane.) - float ch; ///< The height of each cell. (The minimum increment along the y-axis.) - rcCompactCell* cells; ///< Array of cells. [Size: #width*#height] - rcCompactSpan* spans; ///< Array of spans. [Size: #spanCount] - unsigned short* dist; ///< Array containing border distance data. [Size: #spanCount] - unsigned char* areas; ///< Array containing area id data. [Size: #spanCount] - -private: - // Explicitly-disabled copy constructor and copy assignment operator. - rcCompactHeightfield(const rcCompactHeightfield&); - rcCompactHeightfield& operator=(const rcCompactHeightfield&); -}; - -/// Represents a heightfield layer within a layer set. -/// @see rcHeightfieldLayerSet -struct rcHeightfieldLayer -{ - float bmin[3]; ///< The minimum bounds in world space. [(x, y, z)] - float bmax[3]; ///< The maximum bounds in world space. [(x, y, z)] - float cs; ///< The size of each cell. (On the xz-plane.) - float ch; ///< The height of each cell. (The minimum increment along the y-axis.) - int width; ///< The width of the heightfield. (Along the x-axis in cell units.) - int height; ///< The height of the heightfield. (Along the z-axis in cell units.) - int minx; ///< The minimum x-bounds of usable data. - int maxx; ///< The maximum x-bounds of usable data. - int miny; ///< The minimum y-bounds of usable data. (Along the z-axis.) - int maxy; ///< The maximum y-bounds of usable data. (Along the z-axis.) - int hmin; ///< The minimum height bounds of usable data. (Along the y-axis.) - int hmax; ///< The maximum height bounds of usable data. (Along the y-axis.) - unsigned char* heights; ///< The heightfield. [Size: width * height] - unsigned char* areas; ///< Area ids. [Size: Same as #heights] - unsigned char* cons; ///< Packed neighbor connection information. [Size: Same as #heights] -}; - -/// Represents a set of heightfield layers. -/// @ingroup recast -/// @see rcAllocHeightfieldLayerSet, rcFreeHeightfieldLayerSet -struct rcHeightfieldLayerSet -{ - rcHeightfieldLayerSet(); - ~rcHeightfieldLayerSet(); - - rcHeightfieldLayer* layers; ///< The layers in the set. [Size: #nlayers] - int nlayers; ///< The number of layers in the set. - -private: - // Explicitly-disabled copy constructor and copy assignment operator. - rcHeightfieldLayerSet(const rcHeightfieldLayerSet&); - rcHeightfieldLayerSet& operator=(const rcHeightfieldLayerSet&); -}; - -/// Represents a simple, non-overlapping contour in field space. -struct rcContour -{ - int* verts; ///< Simplified contour vertex and connection data. [Size: 4 * #nverts] - int nverts; ///< The number of vertices in the simplified contour. - int* rverts; ///< Raw contour vertex and connection data. [Size: 4 * #nrverts] - int nrverts; ///< The number of vertices in the raw contour. - unsigned short reg; ///< The region id of the contour. - unsigned char area; ///< The area id of the contour. -}; - -/// Represents a group of related contours. -/// @ingroup recast -struct rcContourSet -{ - rcContourSet(); - ~rcContourSet(); - - rcContour* conts; ///< An array of the contours in the set. [Size: #nconts] - int nconts; ///< The number of contours in the set. - float bmin[3]; ///< The minimum bounds in world space. [(x, y, z)] - float bmax[3]; ///< The maximum bounds in world space. [(x, y, z)] - float cs; ///< The size of each cell. (On the xz-plane.) - float ch; ///< The height of each cell. (The minimum increment along the y-axis.) - int width; ///< The width of the set. (Along the x-axis in cell units.) - int height; ///< The height of the set. (Along the z-axis in cell units.) - int borderSize; ///< The AABB border size used to generate the source data from which the contours were derived. - float maxError; ///< The max edge error that this contour set was simplified with. - -private: - // Explicitly-disabled copy constructor and copy assignment operator. - rcContourSet(const rcContourSet&); - rcContourSet& operator=(const rcContourSet&); -}; - -/// Represents a polygon mesh suitable for use in building a navigation mesh. -/// @ingroup recast -struct rcPolyMesh -{ - rcPolyMesh(); - ~rcPolyMesh(); - - unsigned short* verts; ///< The mesh vertices. [Form: (x, y, z) * #nverts] - unsigned short* polys; ///< Polygon and neighbor data. [Length: #maxpolys * 2 * #nvp] - unsigned short* regs; ///< The region id assigned to each polygon. [Length: #maxpolys] - unsigned short* flags; ///< The user defined flags for each polygon. [Length: #maxpolys] - unsigned char* areas; ///< The area id assigned to each polygon. [Length: #maxpolys] - int nverts; ///< The number of vertices. - int npolys; ///< The number of polygons. - int maxpolys; ///< The number of allocated polygons. - int nvp; ///< The maximum number of vertices per polygon. - float bmin[3]; ///< The minimum bounds in world space. [(x, y, z)] - float bmax[3]; ///< The maximum bounds in world space. [(x, y, z)] - float cs; ///< The size of each cell. (On the xz-plane.) - float ch; ///< The height of each cell. (The minimum increment along the y-axis.) - int borderSize; ///< The AABB border size used to generate the source data from which the mesh was derived. - float maxEdgeError; ///< The max error of the polygon edges in the mesh. - -private: - // Explicitly-disabled copy constructor and copy assignment operator. - rcPolyMesh(const rcPolyMesh&); - rcPolyMesh& operator=(const rcPolyMesh&); -}; - -/// Contains triangle meshes that represent detailed height data associated -/// with the polygons in its associated polygon mesh object. -/// @ingroup recast -struct rcPolyMeshDetail -{ - rcPolyMeshDetail(); - - unsigned int* meshes; ///< The sub-mesh data. [Size: 4*#nmeshes] - float* verts; ///< The mesh vertices. [Size: 3*#nverts] - unsigned char* tris; ///< The mesh triangles. [Size: 4*#ntris] - int nmeshes; ///< The number of sub-meshes defined by #meshes. - int nverts; ///< The number of vertices in #verts. - int ntris; ///< The number of triangles in #tris. - -private: - // Explicitly-disabled copy constructor and copy assignment operator. - rcPolyMeshDetail(const rcPolyMeshDetail&); - rcPolyMeshDetail& operator=(const rcPolyMeshDetail&); -}; - -/// @name Allocation Functions -/// Functions used to allocate and de-allocate Recast objects. -/// @see rcAllocSetCustom -/// @{ - -/// Allocates a heightfield object using the Recast allocator. -/// @return A heightfield that is ready for initialization, or null on failure. -/// @ingroup recast -/// @see rcCreateHeightfield, rcFreeHeightField -rcHeightfield* rcAllocHeightfield(); - -/// Frees the specified heightfield object using the Recast allocator. -/// @param[in] heightfield A heightfield allocated using #rcAllocHeightfield -/// @ingroup recast -/// @see rcAllocHeightfield -void rcFreeHeightField(rcHeightfield* heightfield); - -/// Allocates a compact heightfield object using the Recast allocator. -/// @return A compact heightfield that is ready for initialization, or null on failure. -/// @ingroup recast -/// @see rcBuildCompactHeightfield, rcFreeCompactHeightfield -rcCompactHeightfield* rcAllocCompactHeightfield(); - -/// Frees the specified compact heightfield object using the Recast allocator. -/// @param[in] compactHeightfield A compact heightfield allocated using #rcAllocCompactHeightfield -/// @ingroup recast -/// @see rcAllocCompactHeightfield -void rcFreeCompactHeightfield(rcCompactHeightfield* compactHeightfield); - -/// Allocates a heightfield layer set using the Recast allocator. -/// @return A heightfield layer set that is ready for initialization, or null on failure. -/// @ingroup recast -/// @see rcBuildHeightfieldLayers, rcFreeHeightfieldLayerSet -rcHeightfieldLayerSet* rcAllocHeightfieldLayerSet(); - -/// Frees the specified heightfield layer set using the Recast allocator. -/// @param[in] layerSet A heightfield layer set allocated using #rcAllocHeightfieldLayerSet -/// @ingroup recast -/// @see rcAllocHeightfieldLayerSet -void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* layerSet); - -/// Allocates a contour set object using the Recast allocator. -/// @return A contour set that is ready for initialization, or null on failure. -/// @ingroup recast -/// @see rcBuildContours, rcFreeContourSet -rcContourSet* rcAllocContourSet(); - -/// Frees the specified contour set using the Recast allocator. -/// @param[in] contourSet A contour set allocated using #rcAllocContourSet -/// @ingroup recast -/// @see rcAllocContourSet -void rcFreeContourSet(rcContourSet* contourSet); - -/// Allocates a polygon mesh object using the Recast allocator. -/// @return A polygon mesh that is ready for initialization, or null on failure. -/// @ingroup recast -/// @see rcBuildPolyMesh, rcFreePolyMesh -rcPolyMesh* rcAllocPolyMesh(); - -/// Frees the specified polygon mesh using the Recast allocator. -/// @param[in] polyMesh A polygon mesh allocated using #rcAllocPolyMesh -/// @ingroup recast -/// @see rcAllocPolyMesh -void rcFreePolyMesh(rcPolyMesh* polyMesh); - -/// Allocates a detail mesh object using the Recast allocator. -/// @return A detail mesh that is ready for initialization, or null on failure. -/// @ingroup recast -/// @see rcBuildPolyMeshDetail, rcFreePolyMeshDetail -rcPolyMeshDetail* rcAllocPolyMeshDetail(); - -/// Frees the specified detail mesh using the Recast allocator. -/// @param[in] detailMesh A detail mesh allocated using #rcAllocPolyMeshDetail -/// @ingroup recast -/// @see rcAllocPolyMeshDetail -void rcFreePolyMeshDetail(rcPolyMeshDetail* detailMesh); - -/// @} - -/// Heightfield border flag. -/// If a heightfield region ID has this bit set, then the region is a border -/// region and its spans are considered un-walkable. -/// (Used during the region and contour build process.) -/// @see rcCompactSpan::reg -static const unsigned short RC_BORDER_REG = 0x8000; - -/// Polygon touches multiple regions. -/// If a polygon has this region ID it was merged with or created -/// from polygons of different regions during the polymesh -/// build step that removes redundant border vertices. -/// (Used during the polymesh and detail polymesh build processes) -/// @see rcPolyMesh::regs -static const unsigned short RC_MULTIPLE_REGS = 0; - -/// Border vertex flag. -/// If a region ID has this bit set, then the associated element lies on -/// a tile border. If a contour vertex's region ID has this bit set, the -/// vertex will later be removed in order to match the segments and vertices -/// at tile boundaries. -/// (Used during the build process.) -/// @see rcCompactSpan::reg, #rcContour::verts, #rcContour::rverts -static const int RC_BORDER_VERTEX = 0x10000; - -/// Area border flag. -/// If a region ID has this bit set, then the associated element lies on -/// the border of an area. -/// (Used during the region and contour build process.) -/// @see rcCompactSpan::reg, #rcContour::verts, #rcContour::rverts -static const int RC_AREA_BORDER = 0x20000; - -/// Contour build flags. -/// @see rcBuildContours -enum rcBuildContoursFlags -{ - RC_CONTOUR_TESS_WALL_EDGES = 0x01, ///< Tessellate solid (impassable) edges during contour simplification. - RC_CONTOUR_TESS_AREA_EDGES = 0x02 ///< Tessellate edges between areas during contour simplification. -}; - -/// Applied to the region id field of contour vertices in order to extract the region id. -/// The region id field of a vertex may have several flags applied to it. So the -/// fields value can't be used directly. -/// @see rcContour::verts, rcContour::rverts -static const int RC_CONTOUR_REG_MASK = 0xffff; - -/// An value which indicates an invalid index within a mesh. -/// @note This does not necessarily indicate an error. -/// @see rcPolyMesh::polys -static const unsigned short RC_MESH_NULL_IDX = 0xffff; - -/// Represents the null area. -/// When a data element is given this value it is considered to no longer be -/// assigned to a usable area. (E.g. It is un-walkable.) -static const unsigned char RC_NULL_AREA = 0; - -/// The default area id used to indicate a walkable polygon. -/// This is also the maximum allowed area id, and the only non-null area id -/// recognized by some steps in the build process. -static const unsigned char RC_WALKABLE_AREA = 63; - -/// The value returned by #rcGetCon if the specified direction is not connected -/// to another span. (Has no neighbor.) -static const int RC_NOT_CONNECTED = 0x3f; - -/// @name General helper functions -/// @{ - -/// Swaps the values of the two parameters. -/// @param[in,out] a Value A -/// @param[in,out] b Value B -template inline void rcSwap(T& a, T& b) { T t = a; a = b; b = t; } - -/// Returns the minimum of two values. -/// @param[in] a Value A -/// @param[in] b Value B -/// @return The minimum of the two values. -template inline T rcMin(T a, T b) { return a < b ? a : b; } - -/// Returns the maximum of two values. -/// @param[in] a Value A -/// @param[in] b Value B -/// @return The maximum of the two values. -template inline T rcMax(T a, T b) { return a > b ? a : b; } - -/// Returns the absolute value. -/// @param[in] a The value. -/// @return The absolute value of the specified value. -template inline T rcAbs(T a) { return a < 0 ? -a : a; } - -/// Returns the square of the value. -/// @param[in] a The value. -/// @return The square of the value. -template inline T rcSqr(T a) { return a*a; } - -/// Clamps the value to the specified range. -/// @param[in] value The value to clamp. -/// @param[in] minInclusive The minimum permitted return value. -/// @param[in] maxInclusive The maximum permitted return value. -/// @return The value, clamped to the specified range. -template inline T rcClamp(T value, T minInclusive, T maxInclusive) -{ - return value < minInclusive ? minInclusive: (value > maxInclusive ? maxInclusive : value); -} - -/// Returns the square root of the value. -/// @param[in] x The value. -/// @return The square root of the vlaue. -float rcSqrt(float x); - -/// @} -/// @name Vector helper functions. -/// @{ - -/// Derives the cross product of two vectors. (@p v1 x @p v2) -/// @param[out] dest The cross product. [(x, y, z)] -/// @param[in] v1 A Vector [(x, y, z)] -/// @param[in] v2 A vector [(x, y, z)] -inline void rcVcross(float* dest, const float* v1, const float* v2) -{ - dest[0] = v1[1]*v2[2] - v1[2]*v2[1]; - dest[1] = v1[2]*v2[0] - v1[0]*v2[2]; - dest[2] = v1[0]*v2[1] - v1[1]*v2[0]; -} - -/// Derives the dot product of two vectors. (@p v1 . @p v2) -/// @param[in] v1 A Vector [(x, y, z)] -/// @param[in] v2 A vector [(x, y, z)] -/// @return The dot product. -inline float rcVdot(const float* v1, const float* v2) -{ - return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]; -} - -/// Performs a scaled vector addition. (@p v1 + (@p v2 * @p s)) -/// @param[out] dest The result vector. [(x, y, z)] -/// @param[in] v1 The base vector. [(x, y, z)] -/// @param[in] v2 The vector to scale and add to @p v1. [(x, y, z)] -/// @param[in] s The amount to scale @p v2 by before adding to @p v1. -inline void rcVmad(float* dest, const float* v1, const float* v2, const float s) -{ - dest[0] = v1[0]+v2[0]*s; - dest[1] = v1[1]+v2[1]*s; - dest[2] = v1[2]+v2[2]*s; -} - -/// Performs a vector addition. (@p v1 + @p v2) -/// @param[out] dest The result vector. [(x, y, z)] -/// @param[in] v1 The base vector. [(x, y, z)] -/// @param[in] v2 The vector to add to @p v1. [(x, y, z)] -inline void rcVadd(float* dest, const float* v1, const float* v2) -{ - dest[0] = v1[0]+v2[0]; - dest[1] = v1[1]+v2[1]; - dest[2] = v1[2]+v2[2]; -} - -/// Performs a vector subtraction. (@p v1 - @p v2) -/// @param[out] dest The result vector. [(x, y, z)] -/// @param[in] v1 The base vector. [(x, y, z)] -/// @param[in] v2 The vector to subtract from @p v1. [(x, y, z)] -inline void rcVsub(float* dest, const float* v1, const float* v2) -{ - dest[0] = v1[0]-v2[0]; - dest[1] = v1[1]-v2[1]; - dest[2] = v1[2]-v2[2]; -} - -/// Selects the minimum value of each element from the specified vectors. -/// @param[in,out] mn A vector. (Will be updated with the result.) [(x, y, z)] -/// @param[in] v A vector. [(x, y, z)] -inline void rcVmin(float* mn, const float* v) -{ - mn[0] = rcMin(mn[0], v[0]); - mn[1] = rcMin(mn[1], v[1]); - mn[2] = rcMin(mn[2], v[2]); -} - -/// Selects the maximum value of each element from the specified vectors. -/// @param[in,out] mx A vector. (Will be updated with the result.) [(x, y, z)] -/// @param[in] v A vector. [(x, y, z)] -inline void rcVmax(float* mx, const float* v) -{ - mx[0] = rcMax(mx[0], v[0]); - mx[1] = rcMax(mx[1], v[1]); - mx[2] = rcMax(mx[2], v[2]); -} - -/// Performs a vector copy. -/// @param[out] dest The result. [(x, y, z)] -/// @param[in] v The vector to copy. [(x, y, z)] -inline void rcVcopy(float* dest, const float* v) -{ - dest[0] = v[0]; - dest[1] = v[1]; - dest[2] = v[2]; -} - -/// Returns the distance between two points. -/// @param[in] v1 A point. [(x, y, z)] -/// @param[in] v2 A point. [(x, y, z)] -/// @return The distance between the two points. -inline float rcVdist(const float* v1, const float* v2) -{ - float dx = v2[0] - v1[0]; - float dy = v2[1] - v1[1]; - float dz = v2[2] - v1[2]; - return rcSqrt(dx*dx + dy*dy + dz*dz); -} - -/// Returns the square of the distance between two points. -/// @param[in] v1 A point. [(x, y, z)] -/// @param[in] v2 A point. [(x, y, z)] -/// @return The square of the distance between the two points. -inline float rcVdistSqr(const float* v1, const float* v2) -{ - float dx = v2[0] - v1[0]; - float dy = v2[1] - v1[1]; - float dz = v2[2] - v1[2]; - return dx*dx + dy*dy + dz*dz; -} - -/// Normalizes the vector. -/// @param[in,out] v The vector to normalize. [(x, y, z)] -inline void rcVnormalize(float* v) -{ - float d = 1.0f / rcSqrt(rcSqr(v[0]) + rcSqr(v[1]) + rcSqr(v[2])); - v[0] *= d; - v[1] *= d; - v[2] *= d; -} - -/// @} -/// @name Heightfield Functions -/// @see rcHeightfield -/// @{ - -/// Calculates the bounding box of an array of vertices. -/// @ingroup recast -/// @param[in] verts An array of vertices. [(x, y, z) * @p nv] -/// @param[in] numVerts The number of vertices in the @p verts array. -/// @param[out] minBounds The minimum bounds of the AABB. [(x, y, z)] [Units: wu] -/// @param[out] maxBounds The maximum bounds of the AABB. [(x, y, z)] [Units: wu] -void rcCalcBounds(const float* verts, int numVerts, float* minBounds, float* maxBounds); - -/// Calculates the grid size based on the bounding box and grid cell size. -/// @ingroup recast -/// @param[in] minBounds The minimum bounds of the AABB. [(x, y, z)] [Units: wu] -/// @param[in] maxBounds The maximum bounds of the AABB. [(x, y, z)] [Units: wu] -/// @param[in] cellSize The xz-plane cell size. [Limit: > 0] [Units: wu] -/// @param[out] sizeX The width along the x-axis. [Limit: >= 0] [Units: vx] -/// @param[out] sizeZ The height along the z-axis. [Limit: >= 0] [Units: vx] -void rcCalcGridSize(const float* minBounds, const float* maxBounds, float cellSize, int* sizeX, int* sizeZ); - -/// Initializes a new heightfield. -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcAllocHeightfield, rcHeightfield -/// @ingroup recast -/// -/// @param[in,out] context The build context to use during the operation. -/// @param[in,out] heightfield The allocated heightfield to initialize. -/// @param[in] sizeX The width of the field along the x-axis. [Limit: >= 0] [Units: vx] -/// @param[in] sizeZ The height of the field along the z-axis. [Limit: >= 0] [Units: vx] -/// @param[in] minBounds The minimum bounds of the field's AABB. [(x, y, z)] [Units: wu] -/// @param[in] maxBounds The maximum bounds of the field's AABB. [(x, y, z)] [Units: wu] -/// @param[in] cellSize The xz-plane cell size to use for the field. [Limit: > 0] [Units: wu] -/// @param[in] cellHeight The y-axis cell size to use for field. [Limit: > 0] [Units: wu] -/// @returns True if the operation completed successfully. -bool rcCreateHeightfield(rcContext* context, rcHeightfield& heightfield, int sizeX, int sizeZ, - const float* minBounds, const float* maxBounds, - float cellSize, float cellHeight); - -/// Sets the area id of all triangles with a slope below the specified value -/// to #RC_WALKABLE_AREA. -/// -/// Only sets the area id's for the walkable triangles. Does not alter the -/// area id's for un-walkable triangles. -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles -/// -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] walkableSlopeAngle The maximum slope that is considered walkable. -/// [Limits: 0 <= value < 90] [Units: Degrees] -/// @param[in] verts The vertices. [(x, y, z) * @p nv] -/// @param[in] numVerts The number of vertices. -/// @param[in] tris The triangle vertex indices. [(vertA, vertB, vertC) * @p nt] -/// @param[in] numTris The number of triangles. -/// @param[out] triAreaIDs The triangle area ids. [Length: >= @p nt] -void rcMarkWalkableTriangles(rcContext* context, float walkableSlopeAngle, const float* verts, int numVerts, - const int* tris, int numTris, unsigned char* triAreaIDs); - -/// Sets the area id of all triangles with a slope greater than or equal to the specified value to #RC_NULL_AREA. -/// -/// Only sets the area id's for the un-walkable triangles. Does not alter the -/// area id's for walkable triangles. -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles -/// -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] walkableSlopeAngle The maximum slope that is considered walkable. -/// [Limits: 0 <= value < 90] [Units: Degrees] -/// @param[in] verts The vertices. [(x, y, z) * @p nv] -/// @param[in] numVerts The number of vertices. -/// @param[in] tris The triangle vertex indices. [(vertA, vertB, vertC) * @p nt] -/// @param[in] numTris The number of triangles. -/// @param[out] triAreaIDs The triangle area ids. [Length: >= @p nt] -void rcClearUnwalkableTriangles(rcContext* context, float walkableSlopeAngle, const float* verts, int numVerts, - const int* tris, int numTris, unsigned char* triAreaIDs); - -/// Adds a span to the specified heightfield. -/// -/// The span addition can be set to favor flags. If the span is merged to -/// another span and the new @p spanMax is within @p flagMergeThreshold units -/// from the existing span, the span flags are merged. -/// -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in,out] heightfield An initialized heightfield. -/// @param[in] x The column x index where the span is to be added. -/// [Limits: 0 <= value < rcHeightfield::width] -/// @param[in] z The column z index where the span is to be added. -/// [Limits: 0 <= value < rcHeightfield::height] -/// @param[in] spanMin The minimum height of the span. [Limit: < @p spanMax] [Units: vx] -/// @param[in] spanMax The maximum height of the span. [Limit: <= #RC_SPAN_MAX_HEIGHT] [Units: vx] -/// @param[in] areaID The area id of the span. [Limit: <= #RC_WALKABLE_AREA) -/// @param[in] flagMergeThreshold The merge threshold. [Limit: >= 0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcAddSpan(rcContext* context, rcHeightfield& heightfield, - int x, int z, - unsigned short spanMin, unsigned short spanMax, - unsigned char areaID, int flagMergeThreshold); - -/// Rasterizes a single triangle into the specified heightfield. -/// -/// Calling this for each triangle in a mesh is less efficient than calling rcRasterizeTriangles -/// -/// No spans will be added if the triangle does not overlap the heightfield grid. -/// -/// @see rcHeightfield -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] v0 Triangle vertex 0 [(x, y, z)] -/// @param[in] v1 Triangle vertex 1 [(x, y, z)] -/// @param[in] v2 Triangle vertex 2 [(x, y, z)] -/// @param[in] areaID The area id of the triangle. [Limit: <= #RC_WALKABLE_AREA] -/// @param[in,out] heightfield An initialized heightfield. -/// @param[in] flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag. -/// [Limit: >= 0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcRasterizeTriangle(rcContext* context, - const float* v0, const float* v1, const float* v2, - unsigned char areaID, rcHeightfield& heightfield, int flagMergeThreshold = 1); - -/// Rasterizes an indexed triangle mesh into the specified heightfield. -/// -/// Spans will only be added for triangles that overlap the heightfield grid. -/// -/// @see rcHeightfield -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] verts The vertices. [(x, y, z) * @p nv] -/// @param[in] numVerts The number of vertices. (unused) TODO (graham): Remove in next major release -/// @param[in] tris The triangle indices. [(vertA, vertB, vertC) * @p nt] -/// @param[in] triAreaIDs The area id's of the triangles. [Limit: <= #RC_WALKABLE_AREA] [Size: @p nt] -/// @param[in] numTris The number of triangles. -/// @param[in,out] heightfield An initialized heightfield. -/// @param[in] flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag. -/// [Limit: >= 0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcRasterizeTriangles(rcContext* context, - const float* verts, int numVerts, - const int* tris, const unsigned char* triAreaIDs, int numTris, - rcHeightfield& heightfield, int flagMergeThreshold = 1); - -/// Rasterizes an indexed triangle mesh into the specified heightfield. -/// -/// Spans will only be added for triangles that overlap the heightfield grid. -/// -/// @see rcHeightfield -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] verts The vertices. [(x, y, z) * @p nv] -/// @param[in] numVerts The number of vertices. (unused) TODO (graham): Remove in next major release -/// @param[in] tris The triangle indices. [(vertA, vertB, vertC) * @p nt] -/// @param[in] triAreaIDs The area id's of the triangles. [Limit: <= #RC_WALKABLE_AREA] [Size: @p nt] -/// @param[in] numTris The number of triangles. -/// @param[in,out] heightfield An initialized heightfield. -/// @param[in] flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag. -/// [Limit: >= 0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcRasterizeTriangles(rcContext* context, - const float* verts, int numVerts, - const unsigned short* tris, const unsigned char* triAreaIDs, int numTris, - rcHeightfield& heightfield, int flagMergeThreshold = 1); - -/// Rasterizes a triangle list into the specified heightfield. -/// -/// Expects each triangle to be specified as three sequential vertices of 3 floats. -/// -/// Spans will only be added for triangles that overlap the heightfield grid. -/// -/// @see rcHeightfield -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] verts The triangle vertices. [(ax, ay, az, bx, by, bz, cx, by, cx) * @p nt] -/// @param[in] triAreaIDs The area id's of the triangles. [Limit: <= #RC_WALKABLE_AREA] [Size: @p nt] -/// @param[in] numTris The number of triangles. -/// @param[in,out] heightfield An initialized heightfield. -/// @param[in] flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag. -/// [Limit: >= 0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcRasterizeTriangles(rcContext* context, - const float* verts, const unsigned char* triAreaIDs, int numTris, - rcHeightfield& heightfield, int flagMergeThreshold = 1); - -/// Marks non-walkable spans as walkable if their maximum is within @p walkableClimb of a walkable neighbor. -/// -/// Allows the formation of walkable regions that will flow over low lying -/// objects such as curbs, and up structures such as stairways. -/// -/// Two neighboring spans are walkable if: rcAbs(currentSpan.smax - neighborSpan.smax) < waklableClimb -/// -/// @warning Will override the effect of #rcFilterLedgeSpans. So if both filters are used, call -/// #rcFilterLedgeSpans after calling this filter. -/// -/// @see rcHeightfield, rcConfig -/// -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] walkableClimb Maximum ledge height that is considered to still be traversable. -/// [Limit: >=0] [Units: vx] -/// @param[in,out] heightfield A fully built heightfield. (All spans have been added.) -void rcFilterLowHangingWalkableObstacles(rcContext* context, int walkableClimb, rcHeightfield& heightfield); - -/// Marks spans that are ledges as not-walkable. -/// -/// A ledge is a span with one or more neighbors whose maximum is further away than @p walkableClimb -/// from the current span's maximum. -/// This method removes the impact of the overestimation of conservative voxelization -/// so the resulting mesh will not have regions hanging in the air over ledges. -/// -/// A span is a ledge if: rcAbs(currentSpan.smax - neighborSpan.smax) > walkableClimb -/// -/// @see rcHeightfield, rcConfig -/// -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area to -/// be considered walkable. [Limit: >= 3] [Units: vx] -/// @param[in] walkableClimb Maximum ledge height that is considered to still be traversable. -/// [Limit: >=0] [Units: vx] -/// @param[in,out] heightfield A fully built heightfield. (All spans have been added.) -void rcFilterLedgeSpans(rcContext* context, int walkableHeight, int walkableClimb, rcHeightfield& heightfield); - -/// Marks walkable spans as not walkable if the clearance above the span is less than the specified height. -/// -/// For this filter, the clearance above the span is the distance from the span's -/// maximum to the next higher span's minimum. (Same grid column.) -/// -/// @see rcHeightfield, rcConfig -/// @ingroup recast -/// -/// @param[in,out] context The build context to use during the operation. -/// @param[in] walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area to -/// be considered walkable. [Limit: >= 3] [Units: vx] -/// @param[in,out] heightfield A fully built heightfield. (All spans have been added.) -void rcFilterWalkableLowHeightSpans(rcContext* context, int walkableHeight, rcHeightfield& heightfield); - -/// Returns the number of spans contained in the specified heightfield. -/// @ingroup recast -/// @param[in,out] context The build context to use during the operation. -/// @param[in] heightfield An initialized heightfield. -/// @returns The number of spans in the heightfield. -int rcGetHeightFieldSpanCount(rcContext* context, const rcHeightfield& heightfield); - -/// @} -/// @name Compact Heightfield Functions -/// @see rcCompactHeightfield -/// @{ - -/// Builds a compact heightfield representing open space, from a heightfield representing solid space. -/// -/// This is just the beginning of the process of fully building a compact heightfield. -/// Various filters may be applied, then the distance field and regions built. -/// E.g: #rcBuildDistanceField and #rcBuildRegions -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcAllocCompactHeightfield, rcHeightfield, rcCompactHeightfield, rcConfig -/// @ingroup recast -/// -/// @param[in,out] context The build context to use during the operation. -/// @param[in] walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area -/// to be considered walkable. [Limit: >= 3] [Units: vx] -/// @param[in] walkableClimb Maximum ledge height that is considered to still be traversable. -/// [Limit: >=0] [Units: vx] -/// @param[in] heightfield The heightfield to be compacted. -/// @param[out] compactHeightfield The resulting compact heightfield. (Must be pre-allocated.) -/// @returns True if the operation completed successfully. -bool rcBuildCompactHeightfield(rcContext* context, int walkableHeight, int walkableClimb, - const rcHeightfield& heightfield, rcCompactHeightfield& compactHeightfield); - -/// Erodes the walkable area within the heightfield by the specified radius. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] radius The radius of erosion. [Limits: 0 < value < 255] [Units: vx] -/// @param[in,out] chf The populated compact heightfield to erode. -/// @returns True if the operation completed successfully. -bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf); - -/// Applies a median filter to walkable area types (based on area id), removing noise. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in,out] chf A populated compact heightfield. -/// @returns True if the operation completed successfully. -bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf); - -/// Applies an area id to all spans within the specified bounding box. (AABB) -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] bmin The minimum of the bounding box. [(x, y, z)] -/// @param[in] bmax The maximum of the bounding box. [(x, y, z)] -/// @param[in] areaId The area id to apply. [Limit: <= #RC_WALKABLE_AREA] -/// @param[in,out] chf A populated compact heightfield. -void rcMarkBoxArea(rcContext* ctx, const float* bmin, const float* bmax, unsigned char areaId, - rcCompactHeightfield& chf); - -/// Applies the area id to the all spans within the specified convex polygon. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] verts The vertices of the polygon [Fomr: (x, y, z) * @p nverts] -/// @param[in] nverts The number of vertices in the polygon. -/// @param[in] hmin The height of the base of the polygon. -/// @param[in] hmax The height of the top of the polygon. -/// @param[in] areaId The area id to apply. [Limit: <= #RC_WALKABLE_AREA] -/// @param[in,out] chf A populated compact heightfield. -void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts, - const float hmin, const float hmax, unsigned char areaId, - rcCompactHeightfield& chf); - -/// Helper function to offset voncex polygons for rcMarkConvexPolyArea. -/// @ingroup recast -/// @param[in] verts The vertices of the polygon [Form: (x, y, z) * @p nverts] -/// @param[in] nverts The number of vertices in the polygon. -/// @param[in] offset How much to offset the polygon by. [Units: wu] -/// @param[out] outVerts The offset vertices (should hold up to 2 * @p nverts) [Form: (x, y, z) * return value] -/// @param[in] maxOutVerts The max number of vertices that can be stored to @p outVerts. -/// @returns Number of vertices in the offset polygon or 0 if too few vertices in @p outVerts. -int rcOffsetPoly(const float* verts, const int nverts, const float offset, - float* outVerts, const int maxOutVerts); - -/// Applies the area id to all spans within the specified cylinder. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] pos The center of the base of the cylinder. [Form: (x, y, z)] -/// @param[in] r The radius of the cylinder. -/// @param[in] h The height of the cylinder. -/// @param[in] areaId The area id to apply. [Limit: <= #RC_WALKABLE_AREA] -/// @param[in,out] chf A populated compact heightfield. -void rcMarkCylinderArea(rcContext* ctx, const float* pos, - const float r, const float h, unsigned char areaId, - rcCompactHeightfield& chf); - -/// Builds the distance field for the specified compact heightfield. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in,out] chf A populated compact heightfield. -/// @returns True if the operation completed successfully. -bool rcBuildDistanceField(rcContext* ctx, rcCompactHeightfield& chf); - -/// Builds region data for the heightfield using watershed partitioning. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in,out] chf A populated compact heightfield. -/// @param[in] borderSize The size of the non-navigable border around the heightfield. -/// [Limit: >=0] [Units: vx] -/// @param[in] minRegionArea The minimum number of cells allowed to form isolated island areas. -/// [Limit: >=0] [Units: vx]. -/// @param[in] mergeRegionArea Any regions with a span count smaller than this value will, if possible, -/// be merged with larger regions. [Limit: >=0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf, int borderSize, int minRegionArea, int mergeRegionArea); - -/// Builds region data for the heightfield by partitioning the heightfield in non-overlapping layers. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in,out] chf A populated compact heightfield. -/// @param[in] borderSize The size of the non-navigable border around the heightfield. -/// [Limit: >=0] [Units: vx] -/// @param[in] minRegionArea The minimum number of cells allowed to form isolated island areas. -/// [Limit: >=0] [Units: vx]. -/// @returns True if the operation completed successfully. -bool rcBuildLayerRegions(rcContext* ctx, rcCompactHeightfield& chf, int borderSize, int minRegionArea); - -/// Builds region data for the heightfield using simple monotone partitioning. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in,out] chf A populated compact heightfield. -/// @param[in] borderSize The size of the non-navigable border around the heightfield. -/// [Limit: >=0] [Units: vx] -/// @param[in] minRegionArea The minimum number of cells allowed to form isolated island areas. -/// [Limit: >=0] [Units: vx]. -/// @param[in] mergeRegionArea Any regions with a span count smaller than this value will, if possible, -/// be merged with larger regions. [Limit: >=0] [Units: vx] -/// @returns True if the operation completed successfully. -bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, - int borderSize, int minRegionArea, int mergeRegionArea); - -/// Sets the neighbor connection data for the specified direction. -/// @param[in] span The span to update. -/// @param[in] direction The direction to set. [Limits: 0 <= value < 4] -/// @param[in] neighborIndex The index of the neighbor span. -inline void rcSetCon(rcCompactSpan& span, int direction, int neighborIndex) -{ - const unsigned int shift = (unsigned int)direction * 6; - const unsigned int con = span.con; - span.con = (con & ~(0x3f << shift)) | (((unsigned int)neighborIndex & 0x3f) << shift); -} - -/// Gets neighbor connection data for the specified direction. -/// @param[in] span The span to check. -/// @param[in] direction The direction to check. [Limits: 0 <= value < 4] -/// @return The neighbor connection data for the specified direction, or #RC_NOT_CONNECTED if there is no connection. -inline int rcGetCon(const rcCompactSpan& span, int direction) -{ - const unsigned int shift = (unsigned int)direction * 6; - return (span.con >> shift) & 0x3f; -} - -/// Gets the standard width (x-axis) offset for the specified direction. -/// @param[in] direction The direction. [Limits: 0 <= value < 4] -/// @return The width offset to apply to the current cell position to move in the direction. -inline int rcGetDirOffsetX(int direction) -{ - static const int offset[4] = { -1, 0, 1, 0, }; - return offset[direction & 0x03]; -} - -// TODO (graham): Rename this to rcGetDirOffsetZ -/// Gets the standard height (z-axis) offset for the specified direction. -/// @param[in] direction The direction. [Limits: 0 <= value < 4] -/// @return The height offset to apply to the current cell position to move in the direction. -inline int rcGetDirOffsetY(int direction) -{ - static const int offset[4] = { 0, 1, 0, -1 }; - return offset[direction & 0x03]; -} - -/// Gets the direction for the specified offset. One of x and y should be 0. -/// @param[in] offsetX The x offset. [Limits: -1 <= value <= 1] -/// @param[in] offsetZ The z offset. [Limits: -1 <= value <= 1] -/// @return The direction that represents the offset. -inline int rcGetDirForOffset(int offsetX, int offsetZ) -{ - static const int dirs[5] = { 3, 0, -1, 2, 1 }; - return dirs[((offsetZ + 1) << 1) + offsetX]; -} - -/// @} -/// @name Layer, Contour, Polymesh, and Detail Mesh Functions -/// @see rcHeightfieldLayer, rcContourSet, rcPolyMesh, rcPolyMeshDetail -/// @{ - -/// Builds a layer set from the specified compact heightfield. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] chf A fully built compact heightfield. -/// @param[in] borderSize The size of the non-navigable border around the heightfield. [Limit: >=0] -/// [Units: vx] -/// @param[in] walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area -/// to be considered walkable. [Limit: >= 3] [Units: vx] -/// @param[out] lset The resulting layer set. (Must be pre-allocated.) -/// @returns True if the operation completed successfully. -bool rcBuildHeightfieldLayers(rcContext* ctx, const rcCompactHeightfield& chf, - int borderSize, int walkableHeight, - rcHeightfieldLayerSet& lset); - -/// Builds a contour set from the region outlines in the provided compact heightfield. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] chf A fully built compact heightfield. -/// @param[in] maxError The maximum distance a simplified contour's border edges should deviate -/// the original raw contour. [Limit: >=0] [Units: wu] -/// @param[in] maxEdgeLen The maximum allowed length for contour edges along the border of the mesh. -/// [Limit: >=0] [Units: vx] -/// @param[out] cset The resulting contour set. (Must be pre-allocated.) -/// @param[in] buildFlags The build flags. (See: #rcBuildContoursFlags) -/// @returns True if the operation completed successfully. -bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, - float maxError, int maxEdgeLen, - rcContourSet& cset, int buildFlags = RC_CONTOUR_TESS_WALL_EDGES); - -/// Builds a polygon mesh from the provided contours. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] cset A fully built contour set. -/// @param[in] nvp The maximum number of vertices allowed for polygons generated during the -/// contour to polygon conversion process. [Limit: >= 3] -/// @param[out] mesh The resulting polygon mesh. (Must be re-allocated.) -/// @returns True if the operation completed successfully. -bool rcBuildPolyMesh(rcContext* ctx, const rcContourSet& cset, const int nvp, rcPolyMesh& mesh); - -/// Merges multiple polygon meshes into a single mesh. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] meshes An array of polygon meshes to merge. [Size: @p nmeshes] -/// @param[in] nmeshes The number of polygon meshes in the meshes array. -/// @param[in] mesh The resulting polygon mesh. (Must be pre-allocated.) -/// @returns True if the operation completed successfully. -bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, rcPolyMesh& mesh); - -/// Builds a detail mesh from the provided polygon mesh. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] mesh A fully built polygon mesh. -/// @param[in] chf The compact heightfield used to build the polygon mesh. -/// @param[in] sampleDist Sets the distance to use when sampling the heightfield. [Limit: >=0] [Units: wu] -/// @param[in] sampleMaxError The maximum distance the detail mesh surface should deviate from -/// heightfield data. [Limit: >=0] [Units: wu] -/// @param[out] dmesh The resulting detail mesh. (Must be pre-allocated.) -/// @returns True if the operation completed successfully. -bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompactHeightfield& chf, - float sampleDist, float sampleMaxError, - rcPolyMeshDetail& dmesh); - -/// Copies the poly mesh data from src to dst. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] src The source mesh to copy from. -/// @param[out] dst The resulting detail mesh. (Must be pre-allocated, must be empty mesh.) -/// @returns True if the operation completed successfully. -bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst); - -/// Merges multiple detail meshes into a single detail mesh. -/// @ingroup recast -/// @param[in,out] ctx The build context to use during the operation. -/// @param[in] meshes An array of detail meshes to merge. [Size: @p nmeshes] -/// @param[in] nmeshes The number of detail meshes in the meshes array. -/// @param[out] mesh The resulting detail mesh. (Must be pre-allocated.) -/// @returns True if the operation completed successfully. -bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int nmeshes, rcPolyMeshDetail& mesh); - -/// @} - -#endif // RECAST_H - -/////////////////////////////////////////////////////////////////////////// - -// Due to the large amount of detail documentation for this file, -// the content normally located at the end of the header file has been separated -// out to a file in /Docs/Extern. diff --git a/thirdparty/recastnavigation/Recast/Include/RecastAlloc.h b/thirdparty/recastnavigation/Recast/Include/RecastAlloc.h deleted file mode 100644 index 1741de9..0000000 --- a/thirdparty/recastnavigation/Recast/Include/RecastAlloc.h +++ /dev/null @@ -1,372 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#ifndef RECASTALLOC_H -#define RECASTALLOC_H - -#include "RecastAssert.h" - -#include -#include - -/// Provides hint values to the memory allocator on how long the -/// memory is expected to be used. -enum rcAllocHint -{ - RC_ALLOC_PERM, ///< Memory will persist after a function call. - RC_ALLOC_TEMP ///< Memory used temporarily within a function. -}; - -/// A memory allocation function. -// @param[in] size The size, in bytes of memory, to allocate. -// @param[in] rcAllocHint A hint to the allocator on how long the memory is expected to be in use. -// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed. -/// @see rcAllocSetCustom -typedef void* (rcAllocFunc)(size_t size, rcAllocHint hint); - -/// A memory deallocation function. -/// @param[in] ptr A pointer to a memory block previously allocated using #rcAllocFunc. -/// @see rcAllocSetCustom -typedef void (rcFreeFunc)(void* ptr); - -/// Sets the base custom allocation functions to be used by Recast. -/// @param[in] allocFunc The memory allocation function to be used by #rcAlloc -/// @param[in] freeFunc The memory de-allocation function to be used by #rcFree -/// -/// @see rcAlloc, rcFree -void rcAllocSetCustom(rcAllocFunc *allocFunc, rcFreeFunc *freeFunc); - -/// Allocates a memory block. -/// -/// @param[in] size The size, in bytes of memory, to allocate. -/// @param[in] hint A hint to the allocator on how long the memory is expected to be in use. -/// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed. -/// -/// @see rcFree, rcAllocSetCustom -void* rcAlloc(size_t size, rcAllocHint hint); - -/// Deallocates a memory block. If @p ptr is NULL, this does nothing. -/// -/// @warning This function leaves the value of @p ptr unchanged. So it still -/// points to the same (now invalid) location, and not to null. -/// -/// @param[in] ptr A pointer to a memory block previously allocated using #rcAlloc. -/// -/// @see rcAlloc, rcAllocSetCustom -void rcFree(void* ptr); - -/// An implementation of operator new usable for placement new. The default one is part of STL (which we don't use). -/// rcNewTag is a dummy type used to differentiate our operator from the STL one, in case users import both Recast -/// and STL. -struct rcNewTag {}; -inline void* operator new(size_t, const rcNewTag&, void* p) { return p; } -inline void operator delete(void*, const rcNewTag&, void*) {} - -/// Signed to avoid warnnings when comparing to int loop indexes, and common error with comparing to zero. -/// MSVC2010 has a bug where ssize_t is unsigned (!!!). -typedef intptr_t rcSizeType; -#define RC_SIZE_MAX INTPTR_MAX - -/// Macros to hint to the compiler about the likeliest branch. Please add a benchmark that demonstrates a performance -/// improvement before introducing use cases. -#if defined(__GNUC__) || defined(__clang__) -#define rcLikely(x) __builtin_expect((x), true) -#define rcUnlikely(x) __builtin_expect((x), false) -#else -#define rcLikely(x) (x) -#define rcUnlikely(x) (x) -#endif - -/// Variable-sized storage type. Mimics the interface of std::vector with some notable differences: -/// * Uses rcAlloc()/rcFree() to handle storage. -/// * No support for a custom allocator. -/// * Uses signed size instead of size_t to avoid warnings in for loops: "for (int i = 0; i < foo.size(); i++)" -/// * Omits methods of limited utility: insert/erase, (bad performance), at (we don't use exceptions), operator=. -/// * assign() and the pre-sizing constructor follow C++11 semantics -- they don't construct a temporary if no value is provided. -/// * push_back() and resize() support adding values from the current vector. Range-based constructors and assign(begin, end) do not. -/// * No specialization for bool. -template -class rcVectorBase { - rcSizeType m_size; - rcSizeType m_cap; - T* m_data; - // Constructs a T at the give address with either the copy constructor or the default. - static void construct(T* p, const T& v) { ::new(rcNewTag(), (void*)p) T(v); } - static void construct(T* p) { ::new(rcNewTag(), (void*)p) T; } - static void construct_range(T* begin, T* end); - static void construct_range(T* begin, T* end, const T& value); - static void copy_range(T* dst, const T* begin, const T* end); - void destroy_range(rcSizeType begin, rcSizeType end); - // Creates an array of the given size, copies all of this vector's data into it, and returns it. - T* allocate_and_copy(rcSizeType size); - void resize_impl(rcSizeType size, const T* value); - // Requires: min_capacity > m_cap. - rcSizeType get_new_capacity(rcSizeType min_capacity); - public: - typedef rcSizeType size_type; - typedef T value_type; - - rcVectorBase() : m_size(0), m_cap(0), m_data(0) {} - rcVectorBase(const rcVectorBase& other) : m_size(0), m_cap(0), m_data(0) { assign(other.begin(), other.end()); } - explicit rcVectorBase(rcSizeType count) : m_size(0), m_cap(0), m_data(0) { resize(count); } - rcVectorBase(rcSizeType count, const T& value) : m_size(0), m_cap(0), m_data(0) { resize(count, value); } - rcVectorBase(const T* begin, const T* end) : m_size(0), m_cap(0), m_data(0) { assign(begin, end); } - ~rcVectorBase() { destroy_range(0, m_size); rcFree(m_data); } - - // Unlike in std::vector, we return a bool to indicate whether the alloc was successful. - bool reserve(rcSizeType size); - - void assign(rcSizeType count, const T& value) { clear(); resize(count, value); } - void assign(const T* begin, const T* end); - - void resize(rcSizeType size) { resize_impl(size, NULL); } - void resize(rcSizeType size, const T& value) { resize_impl(size, &value); } - // Not implemented as resize(0) because resize requires T to be default-constructible. - void clear() { destroy_range(0, m_size); m_size = 0; } - - void push_back(const T& value); - void pop_back() { rcAssert(m_size > 0); back().~T(); m_size--; } - - rcSizeType size() const { return m_size; } - rcSizeType capacity() const { return m_cap; } - bool empty() const { return size() == 0; } - - const T& operator[](rcSizeType i) const { rcAssert(i >= 0 && i < m_size); return m_data[i]; } - T& operator[](rcSizeType i) { rcAssert(i >= 0 && i < m_size); return m_data[i]; } - - const T& front() const { rcAssert(m_size); return m_data[0]; } - T& front() { rcAssert(m_size); return m_data[0]; } - const T& back() const { rcAssert(m_size); return m_data[m_size - 1]; } - T& back() { rcAssert(m_size); return m_data[m_size - 1]; } - const T* data() const { return m_data; } - T* data() { return m_data; } - - T* begin() { return m_data; } - T* end() { return m_data + m_size; } - const T* begin() const { return m_data; } - const T* end() const { return m_data + m_size; } - - void swap(rcVectorBase& other); - - // Explicitly deleted. - rcVectorBase& operator=(const rcVectorBase& other); -}; - -template -bool rcVectorBase::reserve(rcSizeType count) { - if (count <= m_cap) { - return true; - } - T* new_data = allocate_and_copy(count); - if (!new_data) { - return false; - } - destroy_range(0, m_size); - rcFree(m_data); - m_data = new_data; - m_cap = count; - return true; -} -template -T* rcVectorBase::allocate_and_copy(rcSizeType size) { - rcAssert(RC_SIZE_MAX / static_cast(sizeof(T)) >= size); - T* new_data = static_cast(rcAlloc(sizeof(T) * size, H)); - if (new_data) { - copy_range(new_data, m_data, m_data + m_size); - } - return new_data; -} -template -void rcVectorBase::assign(const T* begin, const T* end) { - clear(); - reserve(end - begin); - m_size = end - begin; - copy_range(m_data, begin, end); -} -template -void rcVectorBase::push_back(const T& value) { - // rcLikely increases performance by ~50% on BM_rcVector_PushPreallocated, - // and by ~2-5% on BM_rcVector_Push. - if (rcLikely(m_size < m_cap)) { - construct(m_data + m_size++, value); - return; - } - - const rcSizeType new_cap = get_new_capacity(m_cap + 1); - T* data = allocate_and_copy(new_cap); - // construct between allocate and destroy+free in case value is - // in this vector. - construct(data + m_size, value); - destroy_range(0, m_size); - m_size++; - m_cap = new_cap; - rcFree(m_data); - m_data = data; -} - -template -rcSizeType rcVectorBase::get_new_capacity(rcSizeType min_capacity) { - rcAssert(min_capacity <= RC_SIZE_MAX); - if (rcUnlikely(m_cap >= RC_SIZE_MAX / 2)) - return RC_SIZE_MAX; - return 2 * m_cap > min_capacity ? 2 * m_cap : min_capacity; -} - -template -void rcVectorBase::resize_impl(rcSizeType size, const T* value) { - if (size < m_size) { - destroy_range(size, m_size); - m_size = size; - } else if (size > m_size) { - if (size <= m_cap) { - if (value) { - construct_range(m_data + m_size, m_data + size, *value); - } else { - construct_range(m_data + m_size, m_data + size); - } - m_size = size; - } else { - const rcSizeType new_cap = get_new_capacity(size); - T* new_data = allocate_and_copy(new_cap); - // We defer deconstructing/freeing old data until after constructing - // new elements in case "value" is there. - if (value) { - construct_range(new_data + m_size, new_data + size, *value); - } else { - construct_range(new_data + m_size, new_data + size); - } - destroy_range(0, m_size); - rcFree(m_data); - m_data = new_data; - m_cap = new_cap; - m_size = size; - } - } -} -template -void rcVectorBase::swap(rcVectorBase& other) { - // TODO: Reorganize headers so we can use rcSwap here. - rcSizeType tmp_cap = other.m_cap; - rcSizeType tmp_size = other.m_size; - T* tmp_data = other.m_data; - - other.m_cap = m_cap; - other.m_size = m_size; - other.m_data = m_data; - - m_cap = tmp_cap; - m_size = tmp_size; - m_data = tmp_data; -} -// static -template -void rcVectorBase::construct_range(T* begin, T* end) { - for (T* p = begin; p < end; p++) { - construct(p); - } -} -// static -template -void rcVectorBase::construct_range(T* begin, T* end, const T& value) { - for (T* p = begin; p < end; p++) { - construct(p, value); - } -} -// static -template -void rcVectorBase::copy_range(T* dst, const T* begin, const T* end) { - for (rcSizeType i = 0 ; i < end - begin; i++) { - construct(dst + i, begin[i]); - } -} -template -void rcVectorBase::destroy_range(rcSizeType begin, rcSizeType end) { - for (rcSizeType i = begin; i < end; i++) { - m_data[i].~T(); - } -} - -template -class rcTempVector : public rcVectorBase { - typedef rcVectorBase Base; -public: - rcTempVector() : Base() {} - explicit rcTempVector(rcSizeType size) : Base(size) {} - rcTempVector(rcSizeType size, const T& value) : Base(size, value) {} - rcTempVector(const rcTempVector& other) : Base(other) {} - rcTempVector(const T* begin, const T* end) : Base(begin, end) {} -}; -template -class rcPermVector : public rcVectorBase { - typedef rcVectorBase Base; -public: - rcPermVector() : Base() {} - explicit rcPermVector(rcSizeType size) : Base(size) {} - rcPermVector(rcSizeType size, const T& value) : Base(size, value) {} - rcPermVector(const rcPermVector& other) : Base(other) {} - rcPermVector(const T* begin, const T* end) : Base(begin, end) {} -}; - - -/// Legacy class. Prefer rcVector. -class rcIntArray -{ - rcTempVector m_impl; -public: - rcIntArray() {} - rcIntArray(int n) : m_impl(n, 0) {} - void push(int item) { m_impl.push_back(item); } - void resize(int size) { m_impl.resize(size); } - void clear() { m_impl.clear(); } - int pop() - { - int v = m_impl.back(); - m_impl.pop_back(); - return v; - } - int size() const { return static_cast(m_impl.size()); } - int& operator[](int index) { return m_impl[index]; } - int operator[](int index) const { return m_impl[index]; } -}; - -/// A simple helper class used to delete an array when it goes out of scope. -/// @note This class is rarely if ever used by the end user. -template class rcScopedDelete -{ - T* ptr; -public: - - /// Constructs an instance with a null pointer. - inline rcScopedDelete() : ptr(0) {} - - /// Constructs an instance with the specified pointer. - /// @param[in] p An pointer to an allocated array. - inline rcScopedDelete(T* p) : ptr(p) {} - inline ~rcScopedDelete() { rcFree(ptr); } - - /// The root array pointer. - /// @return The root array pointer. - inline operator T*() { return ptr; } - -private: - // Explicitly disabled copy constructor and copy assignment operator. - rcScopedDelete(const rcScopedDelete&); - rcScopedDelete& operator=(const rcScopedDelete&); -}; - -#endif diff --git a/thirdparty/recastnavigation/Recast/Include/RecastAssert.h b/thirdparty/recastnavigation/Recast/Include/RecastAssert.h deleted file mode 100644 index 81705bb..0000000 --- a/thirdparty/recastnavigation/Recast/Include/RecastAssert.h +++ /dev/null @@ -1,53 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#ifndef RECASTASSERT_H -#define RECASTASSERT_H - -#ifdef NDEBUG - -// From https://web.archive.org/web/20210117002833/http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert/ -# define rcAssert(x) do { (void)sizeof(x); } while ((void)(__LINE__==-1), false) - -#else - -/// An assertion failure function. -// @param[in] expression asserted expression. -// @param[in] file Filename of the failed assertion. -// @param[in] line Line number of the failed assertion. -/// @see rcAssertFailSetCustom -typedef void (rcAssertFailFunc)(const char* expression, const char* file, int line); - -/// Sets the base custom assertion failure function to be used by Recast. -/// @param[in] assertFailFunc The function to be used in case of failure of #dtAssert -void rcAssertFailSetCustom(rcAssertFailFunc* assertFailFunc); - -/// Gets the base custom assertion failure function to be used by Recast. -rcAssertFailFunc* rcAssertFailGetCustom(); - -# include -# define rcAssert(expression) \ - { \ - rcAssertFailFunc* failFunc = rcAssertFailGetCustom(); \ - if (failFunc == NULL) { assert(expression); } \ - else if (!(expression)) { (*failFunc)(#expression, __FILE__, __LINE__); } \ - } - -#endif - -#endif // RECASTASSERT_H diff --git a/thirdparty/recastnavigation/Recast/Source/Recast.cpp b/thirdparty/recastnavigation/Recast/Source/Recast.cpp deleted file mode 100644 index d75a9f5..0000000 --- a/thirdparty/recastnavigation/Recast/Source/Recast.cpp +++ /dev/null @@ -1,542 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - -#include -#include -#include -#include - -namespace -{ -/// Allocates and constructs an object of the given type, returning a pointer. -/// @param[in] allocLifetime Allocation lifetime hint -template -T* rcNew(const rcAllocHint allocLifetime) -{ - T* ptr = (T*)rcAlloc(sizeof(T), allocLifetime); - ::new(rcNewTag(), (void*)ptr) T(); - return ptr; -} - -/// Destroys and frees an object allocated with rcNew. -/// @param[in] ptr The object pointer to delete. -template -void rcDelete(T* ptr) -{ - if (ptr) - { - ptr->~T(); - rcFree((void*)ptr); - } -} -} // anonymous namespace - -float rcSqrt(float x) -{ - return sqrtf(x); -} - -void rcContext::log(const rcLogCategory category, const char* format, ...) -{ - if (!m_logEnabled) - { - return; - } - static const int MSG_SIZE = 512; - char msg[MSG_SIZE]; - va_list argList; - va_start(argList, format); - int len = vsnprintf(msg, MSG_SIZE, format, argList); - if (len >= MSG_SIZE) - { - len = MSG_SIZE - 1; - msg[MSG_SIZE - 1] = '\0'; - - const char* errorMessage = "Log message was truncated"; - doLog(RC_LOG_ERROR, errorMessage, (int)strlen(errorMessage)); - } - va_end(argList); - doLog(category, msg, len); -} - -void rcContext::doResetLog() -{ - // Defined out of line to fix the weak v-tables warning -} - -rcHeightfield* rcAllocHeightfield() -{ - return rcNew(RC_ALLOC_PERM); -} - -void rcFreeHeightField(rcHeightfield* heightfield) -{ - rcDelete(heightfield); -} - -rcHeightfield::rcHeightfield() -: width() -, height() -, bmin() -, bmax() -, cs() -, ch() -, spans() -, pools() -, freelist() -{ -} - -rcHeightfield::~rcHeightfield() -{ - // Delete span array. - rcFree(spans); - // Delete span pools. - while (pools) - { - rcSpanPool* next = pools->next; - rcFree(pools); - pools = next; - } -} - -rcCompactHeightfield* rcAllocCompactHeightfield() -{ - return rcNew(RC_ALLOC_PERM); -} - -void rcFreeCompactHeightfield(rcCompactHeightfield* compactHeightfield) -{ - rcDelete(compactHeightfield); -} - -rcCompactHeightfield::rcCompactHeightfield() -: width() -, height() -, spanCount() -, walkableHeight() -, walkableClimb() -, borderSize() -, maxDistance() -, maxRegions() -, bmin() -, bmax() -, cs() -, ch() -, cells() -, spans() -, dist() -, areas() -{ -} - -rcCompactHeightfield::~rcCompactHeightfield() -{ - rcFree(cells); - rcFree(spans); - rcFree(dist); - rcFree(areas); -} - -rcHeightfieldLayerSet* rcAllocHeightfieldLayerSet() -{ - return rcNew(RC_ALLOC_PERM); -} - -void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* layerSet) -{ - rcDelete(layerSet); -} - -rcHeightfieldLayerSet::rcHeightfieldLayerSet() -: layers() -, nlayers() -{ -} - -rcHeightfieldLayerSet::~rcHeightfieldLayerSet() -{ - for (int i = 0; i < nlayers; ++i) - { - rcFree(layers[i].heights); - rcFree(layers[i].areas); - rcFree(layers[i].cons); - } - rcFree(layers); -} - - -rcContourSet* rcAllocContourSet() -{ - return rcNew(RC_ALLOC_PERM); -} - -void rcFreeContourSet(rcContourSet* contourSet) -{ - rcDelete(contourSet); -} - -rcContourSet::rcContourSet() -: conts() -, nconts() -, bmin() -, bmax() -, cs() -, ch() -, width() -, height() -, borderSize() -, maxError() -{ -} - -rcContourSet::~rcContourSet() -{ - for (int i = 0; i < nconts; ++i) - { - rcFree(conts[i].verts); - rcFree(conts[i].rverts); - } - rcFree(conts); -} - -rcPolyMesh* rcAllocPolyMesh() -{ - return rcNew(RC_ALLOC_PERM); -} - -void rcFreePolyMesh(rcPolyMesh* polyMesh) -{ - rcDelete(polyMesh); -} - -rcPolyMesh::rcPolyMesh() -: verts() -, polys() -, regs() -, flags() -, areas() -, nverts() -, npolys() -, maxpolys() -, nvp() -, bmin() -, bmax() -, cs() -, ch() -, borderSize() -, maxEdgeError() -{ -} - -rcPolyMesh::~rcPolyMesh() -{ - rcFree(verts); - rcFree(polys); - rcFree(regs); - rcFree(flags); - rcFree(areas); -} - -rcPolyMeshDetail* rcAllocPolyMeshDetail() -{ - return rcNew(RC_ALLOC_PERM); -} - -void rcFreePolyMeshDetail(rcPolyMeshDetail* detailMesh) -{ - if (detailMesh == NULL) - { - return; - } - rcFree(detailMesh->meshes); - rcFree(detailMesh->verts); - rcFree(detailMesh->tris); - rcFree(detailMesh); -} - -rcPolyMeshDetail::rcPolyMeshDetail() -: meshes() -, verts() -, tris() -, nmeshes() -, nverts() -, ntris() -{ -} - -void rcCalcBounds(const float* verts, int numVerts, float* minBounds, float* maxBounds) -{ - // Calculate bounding box. - rcVcopy(minBounds, verts); - rcVcopy(maxBounds, verts); - for (int i = 1; i < numVerts; ++i) - { - const float* v = &verts[i * 3]; - rcVmin(minBounds, v); - rcVmax(maxBounds, v); - } -} - -void rcCalcGridSize(const float* minBounds, const float* maxBounds, const float cellSize, int* sizeX, int* sizeZ) -{ - *sizeX = (int)((maxBounds[0] - minBounds[0]) / cellSize + 0.5f); - *sizeZ = (int)((maxBounds[2] - minBounds[2]) / cellSize + 0.5f); -} - -bool rcCreateHeightfield(rcContext* context, rcHeightfield& heightfield, int sizeX, int sizeZ, - const float* minBounds, const float* maxBounds, - float cellSize, float cellHeight) -{ - rcIgnoreUnused(context); - - heightfield.width = sizeX; - heightfield.height = sizeZ; - rcVcopy(heightfield.bmin, minBounds); - rcVcopy(heightfield.bmax, maxBounds); - heightfield.cs = cellSize; - heightfield.ch = cellHeight; - heightfield.spans = (rcSpan**)rcAlloc(sizeof(rcSpan*) * heightfield.width * heightfield.height, RC_ALLOC_PERM); - if (!heightfield.spans) - { - return false; - } - memset(heightfield.spans, 0, sizeof(rcSpan*) * heightfield.width * heightfield.height); - return true; -} - -static void calcTriNormal(const float* v0, const float* v1, const float* v2, float* faceNormal) -{ - float e0[3], e1[3]; - rcVsub(e0, v1, v0); - rcVsub(e1, v2, v0); - rcVcross(faceNormal, e0, e1); - rcVnormalize(faceNormal); -} - -void rcMarkWalkableTriangles(rcContext* context, const float walkableSlopeAngle, - const float* verts, const int numVerts, - const int* tris, const int numTris, - unsigned char* triAreaIDs) -{ - rcIgnoreUnused(context); - rcIgnoreUnused(numVerts); - - const float walkableThr = cosf(walkableSlopeAngle / 180.0f * RC_PI); - - float norm[3]; - - for (int i = 0; i < numTris; ++i) - { - const int* tri = &tris[i * 3]; - calcTriNormal(&verts[tri[0] * 3], &verts[tri[1] * 3], &verts[tri[2] * 3], norm); - // Check if the face is walkable. - if (norm[1] > walkableThr) - { - triAreaIDs[i] = RC_WALKABLE_AREA; - } - } -} - -void rcClearUnwalkableTriangles(rcContext* context, const float walkableSlopeAngle, - const float* verts, int numVerts, - const int* tris, int numTris, - unsigned char* triAreaIDs) -{ - rcIgnoreUnused(context); - rcIgnoreUnused(numVerts); - - // The minimum Y value for a face normal of a triangle with a walkable slope. - const float walkableLimitY = cosf(walkableSlopeAngle / 180.0f * RC_PI); - - float faceNormal[3]; - for (int i = 0; i < numTris; ++i) - { - const int* tri = &tris[i * 3]; - calcTriNormal(&verts[tri[0] * 3], &verts[tri[1] * 3], &verts[tri[2] * 3], faceNormal); - // Check if the face is walkable. - if (faceNormal[1] <= walkableLimitY) - { - triAreaIDs[i] = RC_NULL_AREA; - } - } -} - -int rcGetHeightFieldSpanCount(rcContext* context, const rcHeightfield& heightfield) -{ - rcIgnoreUnused(context); - - const int numCols = heightfield.width * heightfield.height; - int spanCount = 0; - for (int columnIndex = 0; columnIndex < numCols; ++columnIndex) - { - for (rcSpan* span = heightfield.spans[columnIndex]; span != NULL; span = span->next) - { - if (span->area != RC_NULL_AREA) - { - spanCount++; - } - } - } - return spanCount; -} - -bool rcBuildCompactHeightfield(rcContext* context, const int walkableHeight, const int walkableClimb, - const rcHeightfield& heightfield, rcCompactHeightfield& compactHeightfield) -{ - rcAssert(context); - - rcScopedTimer timer(context, RC_TIMER_BUILD_COMPACTHEIGHTFIELD); - - const int xSize = heightfield.width; - const int zSize = heightfield.height; - const int spanCount = rcGetHeightFieldSpanCount(context, heightfield); - - // Fill in header. - compactHeightfield.width = xSize; - compactHeightfield.height = zSize; - compactHeightfield.spanCount = spanCount; - compactHeightfield.walkableHeight = walkableHeight; - compactHeightfield.walkableClimb = walkableClimb; - compactHeightfield.maxRegions = 0; - rcVcopy(compactHeightfield.bmin, heightfield.bmin); - rcVcopy(compactHeightfield.bmax, heightfield.bmax); - compactHeightfield.bmax[1] += walkableHeight * heightfield.ch; - compactHeightfield.cs = heightfield.cs; - compactHeightfield.ch = heightfield.ch; - compactHeightfield.cells = (rcCompactCell*)rcAlloc(sizeof(rcCompactCell) * xSize * zSize, RC_ALLOC_PERM); - if (!compactHeightfield.cells) - { - context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.cells' (%d)", xSize * zSize); - return false; - } - memset(compactHeightfield.cells, 0, sizeof(rcCompactCell) * xSize * zSize); - compactHeightfield.spans = (rcCompactSpan*)rcAlloc(sizeof(rcCompactSpan) * spanCount, RC_ALLOC_PERM); - if (!compactHeightfield.spans) - { - context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.spans' (%d)", spanCount); - return false; - } - memset(compactHeightfield.spans, 0, sizeof(rcCompactSpan) * spanCount); - compactHeightfield.areas = (unsigned char*)rcAlloc(sizeof(unsigned char) * spanCount, RC_ALLOC_PERM); - if (!compactHeightfield.areas) - { - context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.areas' (%d)", spanCount); - return false; - } - memset(compactHeightfield.areas, RC_NULL_AREA, sizeof(unsigned char) * spanCount); - - const int MAX_HEIGHT = 0xffff; - - // Fill in cells and spans. - int currentCellIndex = 0; - const int numColumns = xSize * zSize; - for (int columnIndex = 0; columnIndex < numColumns; ++columnIndex) - { - const rcSpan* span = heightfield.spans[columnIndex]; - - // If there are no spans at this cell, just leave the data to index=0, count=0. - if (span == NULL) - { - continue; - } - - rcCompactCell& cell = compactHeightfield.cells[columnIndex]; - cell.index = currentCellIndex; - cell.count = 0; - - for (; span != NULL; span = span->next) - { - if (span->area != RC_NULL_AREA) - { - const int bot = (int)span->smax; - const int top = span->next ? (int)span->next->smin : MAX_HEIGHT; - compactHeightfield.spans[currentCellIndex].y = (unsigned short)rcClamp(bot, 0, 0xffff); - compactHeightfield.spans[currentCellIndex].h = (unsigned char)rcClamp(top - bot, 0, 0xff); - compactHeightfield.areas[currentCellIndex] = span->area; - currentCellIndex++; - cell.count++; - } - } - } - - // Find neighbour connections. - const int MAX_LAYERS = RC_NOT_CONNECTED - 1; - int maxLayerIndex = 0; - const int zStride = xSize; // for readability - for (int z = 0; z < zSize; ++z) - { - for (int x = 0; x < xSize; ++x) - { - const rcCompactCell& cell = compactHeightfield.cells[x + z * zStride]; - for (int i = (int)cell.index, ni = (int)(cell.index + cell.count); i < ni; ++i) - { - rcCompactSpan& span = compactHeightfield.spans[i]; - - for (int dir = 0; dir < 4; ++dir) - { - rcSetCon(span, dir, RC_NOT_CONNECTED); - const int neighborX = x + rcGetDirOffsetX(dir); - const int neighborZ = z + rcGetDirOffsetY(dir); - // First check that the neighbour cell is in bounds. - if (neighborX < 0 || neighborZ < 0 || neighborX >= xSize || neighborZ >= zSize) - { - continue; - } - - // Iterate over all neighbour spans and check if any of the is - // accessible from current cell. - const rcCompactCell& neighborCell = compactHeightfield.cells[neighborX + neighborZ * zStride]; - for (int k = (int)neighborCell.index, nk = (int)(neighborCell.index + neighborCell.count); k < nk; ++k) - { - const rcCompactSpan& neighborSpan = compactHeightfield.spans[k]; - const int bot = rcMax(span.y, neighborSpan.y); - const int top = rcMin(span.y + span.h, neighborSpan.y + neighborSpan.h); - - // Check that the gap between the spans is walkable, - // and that the climb height between the gaps is not too high. - if ((top - bot) >= walkableHeight && rcAbs((int)neighborSpan.y - (int)span.y) <= walkableClimb) - { - // Mark direction as walkable. - const int layerIndex = k - (int)neighborCell.index; - if (layerIndex < 0 || layerIndex > MAX_LAYERS) - { - maxLayerIndex = rcMax(maxLayerIndex, layerIndex); - continue; - } - rcSetCon(span, dir, layerIndex); - break; - } - } - } - } - } - } - - if (maxLayerIndex > MAX_LAYERS) - { - context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Heightfield has too many layers %d (max: %d)", - maxLayerIndex, MAX_LAYERS); - } - - return true; -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastAlloc.cpp b/thirdparty/recastnavigation/Recast/Source/RecastAlloc.cpp deleted file mode 100644 index e919daf..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastAlloc.cpp +++ /dev/null @@ -1,51 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include "RecastAlloc.h" - -static void* rcAllocDefault(size_t size, rcAllocHint) -{ - return malloc(size); -} - -static void rcFreeDefault(void *ptr) -{ - free(ptr); -} - -static rcAllocFunc* sRecastAllocFunc = rcAllocDefault; -static rcFreeFunc* sRecastFreeFunc = rcFreeDefault; - -void rcAllocSetCustom(rcAllocFunc* allocFunc, rcFreeFunc* freeFunc) -{ - sRecastAllocFunc = allocFunc ? allocFunc : rcAllocDefault; - sRecastFreeFunc = freeFunc ? freeFunc : rcFreeDefault; -} - -void* rcAlloc(size_t size, rcAllocHint hint) -{ - return sRecastAllocFunc(size, hint); -} - -void rcFree(void* ptr) -{ - if (ptr != NULL) - { - sRecastFreeFunc(ptr); - } -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastArea.cpp b/thirdparty/recastnavigation/Recast/Source/RecastArea.cpp deleted file mode 100644 index 07fb021..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastArea.cpp +++ /dev/null @@ -1,590 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - -/// @par -/// -/// Basically, any spans that are closer to a boundary or obstruction than the specified radius -/// are marked as unwalkable. -/// -/// This method is usually called immediately after the heightfield has been built. -/// -/// @see rcCompactHeightfield, rcBuildCompactHeightfield, rcConfig::walkableRadius -bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf) -{ - rcAssert(ctx); - - const int w = chf.width; - const int h = chf.height; - - rcScopedTimer timer(ctx, RC_TIMER_ERODE_AREA); - - unsigned char* dist = (unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP); - if (!dist) - { - ctx->log(RC_LOG_ERROR, "erodeWalkableArea: Out of memory 'dist' (%d).", chf.spanCount); - return false; - } - - // Init distance. - memset(dist, 0xff, sizeof(unsigned char)*chf.spanCount); - - // Mark boundary cells. - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (chf.areas[i] == RC_NULL_AREA) - { - dist[i] = 0; - } - else - { - const rcCompactSpan& s = chf.spans[i]; - int nc = 0; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int nx = x + rcGetDirOffsetX(dir); - const int ny = y + rcGetDirOffsetY(dir); - const int nidx = (int)chf.cells[nx+ny*w].index + rcGetCon(s, dir); - if (chf.areas[nidx] != RC_NULL_AREA) - { - nc++; - } - } - } - // At least one missing neighbour. - if (nc != 4) - dist[i] = 0; - } - } - } - } - - unsigned char nd; - - // Pass 1 - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - - if (rcGetCon(s, 0) != RC_NOT_CONNECTED) - { - // (-1,0) - const int ax = x + rcGetDirOffsetX(0); - const int ay = y + rcGetDirOffsetY(0); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 0); - const rcCompactSpan& as = chf.spans[ai]; - nd = (unsigned char)rcMin((int)dist[ai]+2, 255); - if (nd < dist[i]) - dist[i] = nd; - - // (-1,-1) - if (rcGetCon(as, 3) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(3); - const int aay = ay + rcGetDirOffsetY(3); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 3); - nd = (unsigned char)rcMin((int)dist[aai]+3, 255); - if (nd < dist[i]) - dist[i] = nd; - } - } - if (rcGetCon(s, 3) != RC_NOT_CONNECTED) - { - // (0,-1) - const int ax = x + rcGetDirOffsetX(3); - const int ay = y + rcGetDirOffsetY(3); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 3); - const rcCompactSpan& as = chf.spans[ai]; - nd = (unsigned char)rcMin((int)dist[ai]+2, 255); - if (nd < dist[i]) - dist[i] = nd; - - // (1,-1) - if (rcGetCon(as, 2) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(2); - const int aay = ay + rcGetDirOffsetY(2); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 2); - nd = (unsigned char)rcMin((int)dist[aai]+3, 255); - if (nd < dist[i]) - dist[i] = nd; - } - } - } - } - } - - // Pass 2 - for (int y = h-1; y >= 0; --y) - { - for (int x = w-1; x >= 0; --x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - - if (rcGetCon(s, 2) != RC_NOT_CONNECTED) - { - // (1,0) - const int ax = x + rcGetDirOffsetX(2); - const int ay = y + rcGetDirOffsetY(2); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 2); - const rcCompactSpan& as = chf.spans[ai]; - nd = (unsigned char)rcMin((int)dist[ai]+2, 255); - if (nd < dist[i]) - dist[i] = nd; - - // (1,1) - if (rcGetCon(as, 1) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(1); - const int aay = ay + rcGetDirOffsetY(1); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 1); - nd = (unsigned char)rcMin((int)dist[aai]+3, 255); - if (nd < dist[i]) - dist[i] = nd; - } - } - if (rcGetCon(s, 1) != RC_NOT_CONNECTED) - { - // (0,1) - const int ax = x + rcGetDirOffsetX(1); - const int ay = y + rcGetDirOffsetY(1); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 1); - const rcCompactSpan& as = chf.spans[ai]; - nd = (unsigned char)rcMin((int)dist[ai]+2, 255); - if (nd < dist[i]) - dist[i] = nd; - - // (-1,1) - if (rcGetCon(as, 0) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(0); - const int aay = ay + rcGetDirOffsetY(0); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 0); - nd = (unsigned char)rcMin((int)dist[aai]+3, 255); - if (nd < dist[i]) - dist[i] = nd; - } - } - } - } - } - - const unsigned char thr = (unsigned char)(radius*2); - for (int i = 0; i < chf.spanCount; ++i) - if (dist[i] < thr) - chf.areas[i] = RC_NULL_AREA; - - rcFree(dist); - - return true; -} - -static void insertSort(unsigned char* a, const int n) -{ - int i, j; - for (i = 1; i < n; i++) - { - const unsigned char value = a[i]; - for (j = i - 1; j >= 0 && a[j] > value; j--) - a[j+1] = a[j]; - a[j+1] = value; - } -} - -/// @par -/// -/// This filter is usually applied after applying area id's using functions -/// such as #rcMarkBoxArea, #rcMarkConvexPolyArea, and #rcMarkCylinderArea. -/// -/// @see rcCompactHeightfield -bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf) -{ - rcAssert(ctx); - - const int w = chf.width; - const int h = chf.height; - - rcScopedTimer timer(ctx, RC_TIMER_MEDIAN_AREA); - - unsigned char* areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP); - if (!areas) - { - ctx->log(RC_LOG_ERROR, "medianFilterWalkableArea: Out of memory 'areas' (%d).", chf.spanCount); - return false; - } - - // Init distance. - memset(areas, 0xff, sizeof(unsigned char)*chf.spanCount); - - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - if (chf.areas[i] == RC_NULL_AREA) - { - areas[i] = chf.areas[i]; - continue; - } - - unsigned char nei[9]; - for (int j = 0; j < 9; ++j) - nei[j] = chf.areas[i]; - - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - if (chf.areas[ai] != RC_NULL_AREA) - nei[dir*2+0] = chf.areas[ai]; - - const rcCompactSpan& as = chf.spans[ai]; - const int dir2 = (dir+1) & 0x3; - if (rcGetCon(as, dir2) != RC_NOT_CONNECTED) - { - const int ax2 = ax + rcGetDirOffsetX(dir2); - const int ay2 = ay + rcGetDirOffsetY(dir2); - const int ai2 = (int)chf.cells[ax2+ay2*w].index + rcGetCon(as, dir2); - if (chf.areas[ai2] != RC_NULL_AREA) - nei[dir*2+1] = chf.areas[ai2]; - } - } - } - insertSort(nei, 9); - areas[i] = nei[4]; - } - } - } - - memcpy(chf.areas, areas, sizeof(unsigned char)*chf.spanCount); - - rcFree(areas); - - return true; -} - -/// @par -/// -/// The value of spacial parameters are in world units. -/// -/// @see rcCompactHeightfield, rcMedianFilterWalkableArea -void rcMarkBoxArea(rcContext* ctx, const float* bmin, const float* bmax, unsigned char areaId, - rcCompactHeightfield& chf) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_MARK_BOX_AREA); - - int minx = (int)((bmin[0]-chf.bmin[0])/chf.cs); - int miny = (int)((bmin[1]-chf.bmin[1])/chf.ch); - int minz = (int)((bmin[2]-chf.bmin[2])/chf.cs); - int maxx = (int)((bmax[0]-chf.bmin[0])/chf.cs); - int maxy = (int)((bmax[1]-chf.bmin[1])/chf.ch); - int maxz = (int)((bmax[2]-chf.bmin[2])/chf.cs); - - if (maxx < 0) return; - if (minx >= chf.width) return; - if (maxz < 0) return; - if (minz >= chf.height) return; - - if (minx < 0) minx = 0; - if (maxx >= chf.width) maxx = chf.width-1; - if (minz < 0) minz = 0; - if (maxz >= chf.height) maxz = chf.height-1; - - for (int z = minz; z <= maxz; ++z) - { - for (int x = minx; x <= maxx; ++x) - { - const rcCompactCell& c = chf.cells[x+z*chf.width]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - rcCompactSpan& s = chf.spans[i]; - if ((int)s.y >= miny && (int)s.y <= maxy) - { - if (chf.areas[i] != RC_NULL_AREA) - chf.areas[i] = areaId; - } - } - } - } -} - - -static int pointInPoly(int nvert, const float* verts, const float* p) -{ - int i, j, c = 0; - for (i = 0, j = nvert-1; i < nvert; j = i++) - { - const float* vi = &verts[i*3]; - const float* vj = &verts[j*3]; - if (((vi[2] > p[2]) != (vj[2] > p[2])) && - (p[0] < (vj[0]-vi[0]) * (p[2]-vi[2]) / (vj[2]-vi[2]) + vi[0]) ) - c = !c; - } - return c; -} - -/// @par -/// -/// The value of spacial parameters are in world units. -/// -/// The y-values of the polygon vertices are ignored. So the polygon is effectively -/// projected onto the xz-plane at @p hmin, then extruded to @p hmax. -/// -/// @see rcCompactHeightfield, rcMedianFilterWalkableArea -void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts, - const float hmin, const float hmax, unsigned char areaId, - rcCompactHeightfield& chf) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_MARK_CONVEXPOLY_AREA); - - float bmin[3], bmax[3]; - rcVcopy(bmin, verts); - rcVcopy(bmax, verts); - for (int i = 1; i < nverts; ++i) - { - rcVmin(bmin, &verts[i*3]); - rcVmax(bmax, &verts[i*3]); - } - bmin[1] = hmin; - bmax[1] = hmax; - - int minx = (int)((bmin[0]-chf.bmin[0])/chf.cs); - int miny = (int)((bmin[1]-chf.bmin[1])/chf.ch); - int minz = (int)((bmin[2]-chf.bmin[2])/chf.cs); - int maxx = (int)((bmax[0]-chf.bmin[0])/chf.cs); - int maxy = (int)((bmax[1]-chf.bmin[1])/chf.ch); - int maxz = (int)((bmax[2]-chf.bmin[2])/chf.cs); - - if (maxx < 0) return; - if (minx >= chf.width) return; - if (maxz < 0) return; - if (minz >= chf.height) return; - - if (minx < 0) minx = 0; - if (maxx >= chf.width) maxx = chf.width-1; - if (minz < 0) minz = 0; - if (maxz >= chf.height) maxz = chf.height-1; - - - // TODO: Optimize. - for (int z = minz; z <= maxz; ++z) - { - for (int x = minx; x <= maxx; ++x) - { - const rcCompactCell& c = chf.cells[x+z*chf.width]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - rcCompactSpan& s = chf.spans[i]; - if (chf.areas[i] == RC_NULL_AREA) - continue; - if ((int)s.y >= miny && (int)s.y <= maxy) - { - float p[3]; - p[0] = chf.bmin[0] + (x+0.5f)*chf.cs; - p[1] = 0; - p[2] = chf.bmin[2] + (z+0.5f)*chf.cs; - - if (pointInPoly(nverts, verts, p)) - { - chf.areas[i] = areaId; - } - } - } - } - } -} - -int rcOffsetPoly(const float* verts, const int nverts, const float offset, - float* outVerts, const int maxOutVerts) -{ - const float MITER_LIMIT = 1.20f; - - int n = 0; - - for (int i = 0; i < nverts; i++) - { - const int a = (i+nverts-1) % nverts; - const int b = i; - const int c = (i+1) % nverts; - const float* va = &verts[a*3]; - const float* vb = &verts[b*3]; - const float* vc = &verts[c*3]; - float dx0 = vb[0] - va[0]; - float dy0 = vb[2] - va[2]; - float d0 = dx0*dx0 + dy0*dy0; - if (d0 > 1e-6f) - { - d0 = 1.0f/rcSqrt(d0); - dx0 *= d0; - dy0 *= d0; - } - float dx1 = vc[0] - vb[0]; - float dy1 = vc[2] - vb[2]; - float d1 = dx1*dx1 + dy1*dy1; - if (d1 > 1e-6f) - { - d1 = 1.0f/rcSqrt(d1); - dx1 *= d1; - dy1 *= d1; - } - const float dlx0 = -dy0; - const float dly0 = dx0; - const float dlx1 = -dy1; - const float dly1 = dx1; - float cross = dx1*dy0 - dx0*dy1; - float dmx = (dlx0 + dlx1) * 0.5f; - float dmy = (dly0 + dly1) * 0.5f; - float dmr2 = dmx*dmx + dmy*dmy; - bool bevel = dmr2 * MITER_LIMIT*MITER_LIMIT < 1.0f; - if (dmr2 > 1e-6f) - { - const float scale = 1.0f / dmr2; - dmx *= scale; - dmy *= scale; - } - - if (bevel && cross < 0.0f) - { - if (n+2 >= maxOutVerts) - return 0; - float d = (1.0f - (dx0*dx1 + dy0*dy1))*0.5f; - outVerts[n*3+0] = vb[0] + (-dlx0+dx0*d)*offset; - outVerts[n*3+1] = vb[1]; - outVerts[n*3+2] = vb[2] + (-dly0+dy0*d)*offset; - n++; - outVerts[n*3+0] = vb[0] + (-dlx1-dx1*d)*offset; - outVerts[n*3+1] = vb[1]; - outVerts[n*3+2] = vb[2] + (-dly1-dy1*d)*offset; - n++; - } - else - { - if (n+1 >= maxOutVerts) - return 0; - outVerts[n*3+0] = vb[0] - dmx*offset; - outVerts[n*3+1] = vb[1]; - outVerts[n*3+2] = vb[2] - dmy*offset; - n++; - } - } - - return n; -} - - -/// @par -/// -/// The value of spacial parameters are in world units. -/// -/// @see rcCompactHeightfield, rcMedianFilterWalkableArea -void rcMarkCylinderArea(rcContext* ctx, const float* pos, - const float r, const float h, unsigned char areaId, - rcCompactHeightfield& chf) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_MARK_CYLINDER_AREA); - - float bmin[3], bmax[3]; - bmin[0] = pos[0] - r; - bmin[1] = pos[1]; - bmin[2] = pos[2] - r; - bmax[0] = pos[0] + r; - bmax[1] = pos[1] + h; - bmax[2] = pos[2] + r; - const float r2 = r*r; - - int minx = (int)((bmin[0]-chf.bmin[0])/chf.cs); - int miny = (int)((bmin[1]-chf.bmin[1])/chf.ch); - int minz = (int)((bmin[2]-chf.bmin[2])/chf.cs); - int maxx = (int)((bmax[0]-chf.bmin[0])/chf.cs); - int maxy = (int)((bmax[1]-chf.bmin[1])/chf.ch); - int maxz = (int)((bmax[2]-chf.bmin[2])/chf.cs); - - if (maxx < 0) return; - if (minx >= chf.width) return; - if (maxz < 0) return; - if (minz >= chf.height) return; - - if (minx < 0) minx = 0; - if (maxx >= chf.width) maxx = chf.width-1; - if (minz < 0) minz = 0; - if (maxz >= chf.height) maxz = chf.height-1; - - - for (int z = minz; z <= maxz; ++z) - { - for (int x = minx; x <= maxx; ++x) - { - const rcCompactCell& c = chf.cells[x+z*chf.width]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - rcCompactSpan& s = chf.spans[i]; - - if (chf.areas[i] == RC_NULL_AREA) - continue; - - if ((int)s.y >= miny && (int)s.y <= maxy) - { - const float sx = chf.bmin[0] + (x+0.5f)*chf.cs; - const float sz = chf.bmin[2] + (z+0.5f)*chf.cs; - const float dx = sx - pos[0]; - const float dz = sz - pos[2]; - - if (dx*dx + dz*dz < r2) - { - chf.areas[i] = areaId; - } - } - } - } - } -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastAssert.cpp b/thirdparty/recastnavigation/Recast/Source/RecastAssert.cpp deleted file mode 100644 index 973b681..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastAssert.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include "RecastAssert.h" - -#ifndef NDEBUG - -static rcAssertFailFunc* sRecastAssertFailFunc = 0; - -void rcAssertFailSetCustom(rcAssertFailFunc* assertFailFunc) -{ - sRecastAssertFailFunc = assertFailFunc; -} - -rcAssertFailFunc* rcAssertFailGetCustom() -{ - return sRecastAssertFailFunc; -} - -#endif diff --git a/thirdparty/recastnavigation/Recast/Source/RecastContour.cpp b/thirdparty/recastnavigation/Recast/Source/RecastContour.cpp deleted file mode 100644 index 5508a98..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastContour.cpp +++ /dev/null @@ -1,1104 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - - -static int getCornerHeight(int x, int y, int i, int dir, - const rcCompactHeightfield& chf, - bool& isBorderVertex) -{ - const rcCompactSpan& s = chf.spans[i]; - int ch = (int)s.y; - int dirp = (dir+1) & 0x3; - - unsigned int regs[4] = {0,0,0,0}; - - // Combine region and area codes in order to prevent - // border vertices which are in between two areas to be removed. - regs[0] = chf.spans[i].reg | (chf.areas[i] << 16); - - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(s, dir); - const rcCompactSpan& as = chf.spans[ai]; - ch = rcMax(ch, (int)as.y); - regs[1] = chf.spans[ai].reg | (chf.areas[ai] << 16); - if (rcGetCon(as, dirp) != RC_NOT_CONNECTED) - { - const int ax2 = ax + rcGetDirOffsetX(dirp); - const int ay2 = ay + rcGetDirOffsetY(dirp); - const int ai2 = (int)chf.cells[ax2+ay2*chf.width].index + rcGetCon(as, dirp); - const rcCompactSpan& as2 = chf.spans[ai2]; - ch = rcMax(ch, (int)as2.y); - regs[2] = chf.spans[ai2].reg | (chf.areas[ai2] << 16); - } - } - if (rcGetCon(s, dirp) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dirp); - const int ay = y + rcGetDirOffsetY(dirp); - const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(s, dirp); - const rcCompactSpan& as = chf.spans[ai]; - ch = rcMax(ch, (int)as.y); - regs[3] = chf.spans[ai].reg | (chf.areas[ai] << 16); - if (rcGetCon(as, dir) != RC_NOT_CONNECTED) - { - const int ax2 = ax + rcGetDirOffsetX(dir); - const int ay2 = ay + rcGetDirOffsetY(dir); - const int ai2 = (int)chf.cells[ax2+ay2*chf.width].index + rcGetCon(as, dir); - const rcCompactSpan& as2 = chf.spans[ai2]; - ch = rcMax(ch, (int)as2.y); - regs[2] = chf.spans[ai2].reg | (chf.areas[ai2] << 16); - } - } - - // Check if the vertex is special edge vertex, these vertices will be removed later. - for (int j = 0; j < 4; ++j) - { - const int a = j; - const int b = (j+1) & 0x3; - const int c = (j+2) & 0x3; - const int d = (j+3) & 0x3; - - // The vertex is a border vertex there are two same exterior cells in a row, - // followed by two interior cells and none of the regions are out of bounds. - const bool twoSameExts = (regs[a] & regs[b] & RC_BORDER_REG) != 0 && regs[a] == regs[b]; - const bool twoInts = ((regs[c] | regs[d]) & RC_BORDER_REG) == 0; - const bool intsSameArea = (regs[c]>>16) == (regs[d]>>16); - const bool noZeros = regs[a] != 0 && regs[b] != 0 && regs[c] != 0 && regs[d] != 0; - if (twoSameExts && twoInts && intsSameArea && noZeros) - { - isBorderVertex = true; - break; - } - } - - return ch; -} - -static void walkContour(int x, int y, int i, - const rcCompactHeightfield& chf, - unsigned char* flags, rcIntArray& points) -{ - // Choose the first non-connected edge - unsigned char dir = 0; - while ((flags[i] & (1 << dir)) == 0) - dir++; - - unsigned char startDir = dir; - int starti = i; - - const unsigned char area = chf.areas[i]; - - int iter = 0; - while (++iter < 40000) - { - if (flags[i] & (1 << dir)) - { - // Choose the edge corner - bool isBorderVertex = false; - bool isAreaBorder = false; - int px = x; - int py = getCornerHeight(x, y, i, dir, chf, isBorderVertex); - int pz = y; - switch(dir) - { - case 0: pz++; break; - case 1: px++; pz++; break; - case 2: px++; break; - } - int r = 0; - const rcCompactSpan& s = chf.spans[i]; - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(s, dir); - r = (int)chf.spans[ai].reg; - if (area != chf.areas[ai]) - isAreaBorder = true; - } - if (isBorderVertex) - r |= RC_BORDER_VERTEX; - if (isAreaBorder) - r |= RC_AREA_BORDER; - points.push(px); - points.push(py); - points.push(pz); - points.push(r); - - flags[i] &= ~(1 << dir); // Remove visited edges - dir = (dir+1) & 0x3; // Rotate CW - } - else - { - int ni = -1; - const int nx = x + rcGetDirOffsetX(dir); - const int ny = y + rcGetDirOffsetY(dir); - const rcCompactSpan& s = chf.spans[i]; - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const rcCompactCell& nc = chf.cells[nx+ny*chf.width]; - ni = (int)nc.index + rcGetCon(s, dir); - } - if (ni == -1) - { - // Should not happen. - return; - } - x = nx; - y = ny; - i = ni; - dir = (dir+3) & 0x3; // Rotate CCW - } - - if (starti == i && startDir == dir) - { - break; - } - } -} - -static float distancePtSeg(const int x, const int z, - const int px, const int pz, - const int qx, const int qz) -{ - float pqx = (float)(qx - px); - float pqz = (float)(qz - pz); - float dx = (float)(x - px); - float dz = (float)(z - pz); - float d = pqx*pqx + pqz*pqz; - float t = pqx*dx + pqz*dz; - if (d > 0) - t /= d; - if (t < 0) - t = 0; - else if (t > 1) - t = 1; - - dx = px + t*pqx - x; - dz = pz + t*pqz - z; - - return dx*dx + dz*dz; -} - -static void simplifyContour(rcIntArray& points, rcIntArray& simplified, - const float maxError, const int maxEdgeLen, const int buildFlags) -{ - // Add initial points. - bool hasConnections = false; - for (int i = 0; i < points.size(); i += 4) - { - if ((points[i+3] & RC_CONTOUR_REG_MASK) != 0) - { - hasConnections = true; - break; - } - } - - if (hasConnections) - { - // The contour has some portals to other regions. - // Add a new point to every location where the region changes. - for (int i = 0, ni = points.size()/4; i < ni; ++i) - { - int ii = (i+1) % ni; - const bool differentRegs = (points[i*4+3] & RC_CONTOUR_REG_MASK) != (points[ii*4+3] & RC_CONTOUR_REG_MASK); - const bool areaBorders = (points[i*4+3] & RC_AREA_BORDER) != (points[ii*4+3] & RC_AREA_BORDER); - if (differentRegs || areaBorders) - { - simplified.push(points[i*4+0]); - simplified.push(points[i*4+1]); - simplified.push(points[i*4+2]); - simplified.push(i); - } - } - } - - if (simplified.size() == 0) - { - // If there is no connections at all, - // create some initial points for the simplification process. - // Find lower-left and upper-right vertices of the contour. - int llx = points[0]; - int lly = points[1]; - int llz = points[2]; - int lli = 0; - int urx = points[0]; - int ury = points[1]; - int urz = points[2]; - int uri = 0; - for (int i = 0; i < points.size(); i += 4) - { - int x = points[i+0]; - int y = points[i+1]; - int z = points[i+2]; - if (x < llx || (x == llx && z < llz)) - { - llx = x; - lly = y; - llz = z; - lli = i/4; - } - if (x > urx || (x == urx && z > urz)) - { - urx = x; - ury = y; - urz = z; - uri = i/4; - } - } - simplified.push(llx); - simplified.push(lly); - simplified.push(llz); - simplified.push(lli); - - simplified.push(urx); - simplified.push(ury); - simplified.push(urz); - simplified.push(uri); - } - - // Add points until all raw points are within - // error tolerance to the simplified shape. - const int pn = points.size()/4; - for (int i = 0; i < simplified.size()/4; ) - { - int ii = (i+1) % (simplified.size()/4); - - int ax = simplified[i*4+0]; - int az = simplified[i*4+2]; - int ai = simplified[i*4+3]; - - int bx = simplified[ii*4+0]; - int bz = simplified[ii*4+2]; - int bi = simplified[ii*4+3]; - - // Find maximum deviation from the segment. - float maxd = 0; - int maxi = -1; - int ci, cinc, endi; - - // Traverse the segment in lexilogical order so that the - // max deviation is calculated similarly when traversing - // opposite segments. - if (bx > ax || (bx == ax && bz > az)) - { - cinc = 1; - ci = (ai+cinc) % pn; - endi = bi; - } - else - { - cinc = pn-1; - ci = (bi+cinc) % pn; - endi = ai; - rcSwap(ax, bx); - rcSwap(az, bz); - } - - // Tessellate only outer edges or edges between areas. - if ((points[ci*4+3] & RC_CONTOUR_REG_MASK) == 0 || - (points[ci*4+3] & RC_AREA_BORDER)) - { - while (ci != endi) - { - float d = distancePtSeg(points[ci*4+0], points[ci*4+2], ax, az, bx, bz); - if (d > maxd) - { - maxd = d; - maxi = ci; - } - ci = (ci+cinc) % pn; - } - } - - - // If the max deviation is larger than accepted error, - // add new point, else continue to next segment. - if (maxi != -1 && maxd > (maxError*maxError)) - { - // Add space for the new point. - simplified.resize(simplified.size()+4); - const int n = simplified.size()/4; - for (int j = n-1; j > i; --j) - { - simplified[j*4+0] = simplified[(j-1)*4+0]; - simplified[j*4+1] = simplified[(j-1)*4+1]; - simplified[j*4+2] = simplified[(j-1)*4+2]; - simplified[j*4+3] = simplified[(j-1)*4+3]; - } - // Add the point. - simplified[(i+1)*4+0] = points[maxi*4+0]; - simplified[(i+1)*4+1] = points[maxi*4+1]; - simplified[(i+1)*4+2] = points[maxi*4+2]; - simplified[(i+1)*4+3] = maxi; - } - else - { - ++i; - } - } - - // Split too long edges. - if (maxEdgeLen > 0 && (buildFlags & (RC_CONTOUR_TESS_WALL_EDGES|RC_CONTOUR_TESS_AREA_EDGES)) != 0) - { - for (int i = 0; i < simplified.size()/4; ) - { - const int ii = (i+1) % (simplified.size()/4); - - const int ax = simplified[i*4+0]; - const int az = simplified[i*4+2]; - const int ai = simplified[i*4+3]; - - const int bx = simplified[ii*4+0]; - const int bz = simplified[ii*4+2]; - const int bi = simplified[ii*4+3]; - - // Find maximum deviation from the segment. - int maxi = -1; - int ci = (ai+1) % pn; - - // Tessellate only outer edges or edges between areas. - bool tess = false; - // Wall edges. - if ((buildFlags & RC_CONTOUR_TESS_WALL_EDGES) && (points[ci*4+3] & RC_CONTOUR_REG_MASK) == 0) - tess = true; - // Edges between areas. - if ((buildFlags & RC_CONTOUR_TESS_AREA_EDGES) && (points[ci*4+3] & RC_AREA_BORDER)) - tess = true; - - if (tess) - { - int dx = bx - ax; - int dz = bz - az; - if (dx*dx + dz*dz > maxEdgeLen*maxEdgeLen) - { - // Round based on the segments in lexilogical order so that the - // max tesselation is consistent regardles in which direction - // segments are traversed. - const int n = bi < ai ? (bi+pn - ai) : (bi - ai); - if (n > 1) - { - if (bx > ax || (bx == ax && bz > az)) - maxi = (ai + n/2) % pn; - else - maxi = (ai + (n+1)/2) % pn; - } - } - } - - // If the max deviation is larger than accepted error, - // add new point, else continue to next segment. - if (maxi != -1) - { - // Add space for the new point. - simplified.resize(simplified.size()+4); - const int n = simplified.size()/4; - for (int j = n-1; j > i; --j) - { - simplified[j*4+0] = simplified[(j-1)*4+0]; - simplified[j*4+1] = simplified[(j-1)*4+1]; - simplified[j*4+2] = simplified[(j-1)*4+2]; - simplified[j*4+3] = simplified[(j-1)*4+3]; - } - // Add the point. - simplified[(i+1)*4+0] = points[maxi*4+0]; - simplified[(i+1)*4+1] = points[maxi*4+1]; - simplified[(i+1)*4+2] = points[maxi*4+2]; - simplified[(i+1)*4+3] = maxi; - } - else - { - ++i; - } - } - } - - for (int i = 0; i < simplified.size()/4; ++i) - { - // The edge vertex flag is take from the current raw point, - // and the neighbour region is take from the next raw point. - const int ai = (simplified[i*4+3]+1) % pn; - const int bi = simplified[i*4+3]; - simplified[i*4+3] = (points[ai*4+3] & (RC_CONTOUR_REG_MASK|RC_AREA_BORDER)) | (points[bi*4+3] & RC_BORDER_VERTEX); - } - -} - -static int calcAreaOfPolygon2D(const int* verts, const int nverts) -{ - int area = 0; - for (int i = 0, j = nverts-1; i < nverts; j=i++) - { - const int* vi = &verts[i*4]; - const int* vj = &verts[j*4]; - area += vi[0] * vj[2] - vj[0] * vi[2]; - } - return (area+1) / 2; -} - -// TODO: these are the same as in RecastMesh.cpp, consider using the same. -// Last time I checked the if version got compiled using cmov, which was a lot faster than module (with idiv). -inline int prev(int i, int n) { return i-1 >= 0 ? i-1 : n-1; } -inline int next(int i, int n) { return i+1 < n ? i+1 : 0; } - -inline int area2(const int* a, const int* b, const int* c) -{ - return (b[0] - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (b[2] - a[2]); -} - -// Exclusive or: true iff exactly one argument is true. -// The arguments are negated to ensure that they are 0/1 -// values. Then the bitwise Xor operator may apply. -// (This idea is due to Michael Baldwin.) -inline bool xorb(bool x, bool y) -{ - return !x ^ !y; -} - -// Returns true iff c is strictly to the left of the directed -// line through a to b. -inline bool left(const int* a, const int* b, const int* c) -{ - return area2(a, b, c) < 0; -} - -inline bool leftOn(const int* a, const int* b, const int* c) -{ - return area2(a, b, c) <= 0; -} - -inline bool collinear(const int* a, const int* b, const int* c) -{ - return area2(a, b, c) == 0; -} - -// Returns true iff ab properly intersects cd: they share -// a point interior to both segments. The properness of the -// intersection is ensured by using strict leftness. -static bool intersectProp(const int* a, const int* b, const int* c, const int* d) -{ - // Eliminate improper cases. - if (collinear(a,b,c) || collinear(a,b,d) || - collinear(c,d,a) || collinear(c,d,b)) - return false; - - return xorb(left(a,b,c), left(a,b,d)) && xorb(left(c,d,a), left(c,d,b)); -} - -// Returns T iff (a,b,c) are collinear and point c lies -// on the closed segement ab. -static bool between(const int* a, const int* b, const int* c) -{ - if (!collinear(a, b, c)) - return false; - // If ab not vertical, check betweenness on x; else on y. - if (a[0] != b[0]) - return ((a[0] <= c[0]) && (c[0] <= b[0])) || ((a[0] >= c[0]) && (c[0] >= b[0])); - else - return ((a[2] <= c[2]) && (c[2] <= b[2])) || ((a[2] >= c[2]) && (c[2] >= b[2])); -} - -// Returns true iff segments ab and cd intersect, properly or improperly. -static bool intersect(const int* a, const int* b, const int* c, const int* d) -{ - if (intersectProp(a, b, c, d)) - return true; - else if (between(a, b, c) || between(a, b, d) || - between(c, d, a) || between(c, d, b)) - return true; - else - return false; -} - -static bool vequal(const int* a, const int* b) -{ - return a[0] == b[0] && a[2] == b[2]; -} - -static bool intersectSegContour(const int* d0, const int* d1, int i, int n, const int* verts) -{ - // For each edge (k,k+1) of P - for (int k = 0; k < n; k++) - { - int k1 = next(k, n); - // Skip edges incident to i. - if (i == k || i == k1) - continue; - const int* p0 = &verts[k * 4]; - const int* p1 = &verts[k1 * 4]; - if (vequal(d0, p0) || vequal(d1, p0) || vequal(d0, p1) || vequal(d1, p1)) - continue; - - if (intersect(d0, d1, p0, p1)) - return true; - } - return false; -} - -static bool inCone(int i, int n, const int* verts, const int* pj) -{ - const int* pi = &verts[i * 4]; - const int* pi1 = &verts[next(i, n) * 4]; - const int* pin1 = &verts[prev(i, n) * 4]; - - // If P[i] is a convex vertex [ i+1 left or on (i-1,i) ]. - if (leftOn(pin1, pi, pi1)) - return left(pi, pj, pin1) && left(pj, pi, pi1); - // Assume (i-1,i,i+1) not collinear. - // else P[i] is reflex. - return !(leftOn(pi, pj, pi1) && leftOn(pj, pi, pin1)); -} - - -static void removeDegenerateSegments(rcIntArray& simplified) -{ - // Remove adjacent vertices which are equal on xz-plane, - // or else the triangulator will get confused. - int npts = simplified.size()/4; - for (int i = 0; i < npts; ++i) - { - int ni = next(i, npts); - - if (vequal(&simplified[i*4], &simplified[ni*4])) - { - // Degenerate segment, remove. - for (int j = i; j < simplified.size()/4-1; ++j) - { - simplified[j*4+0] = simplified[(j+1)*4+0]; - simplified[j*4+1] = simplified[(j+1)*4+1]; - simplified[j*4+2] = simplified[(j+1)*4+2]; - simplified[j*4+3] = simplified[(j+1)*4+3]; - } - simplified.resize(simplified.size()-4); - npts--; - } - } -} - - -static bool mergeContours(rcContour& ca, rcContour& cb, int ia, int ib) -{ - const int maxVerts = ca.nverts + cb.nverts + 2; - int* verts = (int*)rcAlloc(sizeof(int)*maxVerts*4, RC_ALLOC_PERM); - if (!verts) - return false; - - int nv = 0; - - // Copy contour A. - for (int i = 0; i <= ca.nverts; ++i) - { - int* dst = &verts[nv*4]; - const int* src = &ca.verts[((ia+i)%ca.nverts)*4]; - dst[0] = src[0]; - dst[1] = src[1]; - dst[2] = src[2]; - dst[3] = src[3]; - nv++; - } - - // Copy contour B - for (int i = 0; i <= cb.nverts; ++i) - { - int* dst = &verts[nv*4]; - const int* src = &cb.verts[((ib+i)%cb.nverts)*4]; - dst[0] = src[0]; - dst[1] = src[1]; - dst[2] = src[2]; - dst[3] = src[3]; - nv++; - } - - rcFree(ca.verts); - ca.verts = verts; - ca.nverts = nv; - - rcFree(cb.verts); - cb.verts = 0; - cb.nverts = 0; - - return true; -} - -struct rcContourHole -{ - rcContour* contour; - int minx, minz, leftmost; -}; - -struct rcContourRegion -{ - rcContour* outline; - rcContourHole* holes; - int nholes; -}; - -struct rcPotentialDiagonal -{ - int vert; - int dist; -}; - -// Finds the lowest leftmost vertex of a contour. -static void findLeftMostVertex(rcContour* contour, int* minx, int* minz, int* leftmost) -{ - *minx = contour->verts[0]; - *minz = contour->verts[2]; - *leftmost = 0; - for (int i = 1; i < contour->nverts; i++) - { - const int x = contour->verts[i*4+0]; - const int z = contour->verts[i*4+2]; - if (x < *minx || (x == *minx && z < *minz)) - { - *minx = x; - *minz = z; - *leftmost = i; - } - } -} - -static int compareHoles(const void* va, const void* vb) -{ - const rcContourHole* a = (const rcContourHole*)va; - const rcContourHole* b = (const rcContourHole*)vb; - if (a->minx == b->minx) - { - if (a->minz < b->minz) - return -1; - if (a->minz > b->minz) - return 1; - } - else - { - if (a->minx < b->minx) - return -1; - if (a->minx > b->minx) - return 1; - } - return 0; -} - - -static int compareDiagDist(const void* va, const void* vb) -{ - const rcPotentialDiagonal* a = (const rcPotentialDiagonal*)va; - const rcPotentialDiagonal* b = (const rcPotentialDiagonal*)vb; - if (a->dist < b->dist) - return -1; - if (a->dist > b->dist) - return 1; - return 0; -} - - -static void mergeRegionHoles(rcContext* ctx, rcContourRegion& region) -{ - // Sort holes from left to right. - for (int i = 0; i < region.nholes; i++) - findLeftMostVertex(region.holes[i].contour, ®ion.holes[i].minx, ®ion.holes[i].minz, ®ion.holes[i].leftmost); - - qsort(region.holes, region.nholes, sizeof(rcContourHole), compareHoles); - - int maxVerts = region.outline->nverts; - for (int i = 0; i < region.nholes; i++) - maxVerts += region.holes[i].contour->nverts; - - rcScopedDelete diags((rcPotentialDiagonal*)rcAlloc(sizeof(rcPotentialDiagonal)*maxVerts, RC_ALLOC_TEMP)); - if (!diags) - { - ctx->log(RC_LOG_WARNING, "mergeRegionHoles: Failed to allocated diags %d.", maxVerts); - return; - } - - rcContour* outline = region.outline; - - // Merge holes into the outline one by one. - for (int i = 0; i < region.nholes; i++) - { - rcContour* hole = region.holes[i].contour; - - int index = -1; - int bestVertex = region.holes[i].leftmost; - for (int iter = 0; iter < hole->nverts; iter++) - { - // Find potential diagonals. - // The 'best' vertex must be in the cone described by 3 cosequtive vertices of the outline. - // ..o j-1 - // | - // | * best - // | - // j o-----o j+1 - // : - int ndiags = 0; - const int* corner = &hole->verts[bestVertex*4]; - for (int j = 0; j < outline->nverts; j++) - { - if (inCone(j, outline->nverts, outline->verts, corner)) - { - int dx = outline->verts[j*4+0] - corner[0]; - int dz = outline->verts[j*4+2] - corner[2]; - diags[ndiags].vert = j; - diags[ndiags].dist = dx*dx + dz*dz; - ndiags++; - } - } - // Sort potential diagonals by distance, we want to make the connection as short as possible. - qsort(diags, ndiags, sizeof(rcPotentialDiagonal), compareDiagDist); - - // Find a diagonal that is not intersecting the outline not the remaining holes. - index = -1; - for (int j = 0; j < ndiags; j++) - { - const int* pt = &outline->verts[diags[j].vert*4]; - bool intersect = intersectSegContour(pt, corner, diags[i].vert, outline->nverts, outline->verts); - for (int k = i; k < region.nholes && !intersect; k++) - intersect |= intersectSegContour(pt, corner, -1, region.holes[k].contour->nverts, region.holes[k].contour->verts); - if (!intersect) - { - index = diags[j].vert; - break; - } - } - // If found non-intersecting diagonal, stop looking. - if (index != -1) - break; - // All the potential diagonals for the current vertex were intersecting, try next vertex. - bestVertex = (bestVertex + 1) % hole->nverts; - } - - if (index == -1) - { - ctx->log(RC_LOG_WARNING, "mergeHoles: Failed to find merge points for %p and %p.", region.outline, hole); - continue; - } - if (!mergeContours(*region.outline, *hole, index, bestVertex)) - { - ctx->log(RC_LOG_WARNING, "mergeHoles: Failed to merge contours %p and %p.", region.outline, hole); - continue; - } - } -} - - -/// @par -/// -/// The raw contours will match the region outlines exactly. The @p maxError and @p maxEdgeLen -/// parameters control how closely the simplified contours will match the raw contours. -/// -/// Simplified contours are generated such that the vertices for portals between areas match up. -/// (They are considered mandatory vertices.) -/// -/// Setting @p maxEdgeLength to zero will disabled the edge length feature. -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcAllocContourSet, rcCompactHeightfield, rcContourSet, rcConfig -bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, - const float maxError, const int maxEdgeLen, - rcContourSet& cset, const int buildFlags) -{ - rcAssert(ctx); - - const int w = chf.width; - const int h = chf.height; - const int borderSize = chf.borderSize; - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_CONTOURS); - - rcVcopy(cset.bmin, chf.bmin); - rcVcopy(cset.bmax, chf.bmax); - if (borderSize > 0) - { - // If the heightfield was build with bordersize, remove the offset. - const float pad = borderSize*chf.cs; - cset.bmin[0] += pad; - cset.bmin[2] += pad; - cset.bmax[0] -= pad; - cset.bmax[2] -= pad; - } - cset.cs = chf.cs; - cset.ch = chf.ch; - cset.width = chf.width - chf.borderSize*2; - cset.height = chf.height - chf.borderSize*2; - cset.borderSize = chf.borderSize; - cset.maxError = maxError; - - int maxContours = rcMax((int)chf.maxRegions, 8); - cset.conts = (rcContour*)rcAlloc(sizeof(rcContour)*maxContours, RC_ALLOC_PERM); - if (!cset.conts) - return false; - cset.nconts = 0; - - rcScopedDelete flags((unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP)); - if (!flags) - { - ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'flags' (%d).", chf.spanCount); - return false; - } - - ctx->startTimer(RC_TIMER_BUILD_CONTOURS_TRACE); - - // Mark boundaries. - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - unsigned char res = 0; - const rcCompactSpan& s = chf.spans[i]; - if (!chf.spans[i].reg || (chf.spans[i].reg & RC_BORDER_REG)) - { - flags[i] = 0; - continue; - } - for (int dir = 0; dir < 4; ++dir) - { - unsigned short r = 0; - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - r = chf.spans[ai].reg; - } - if (r == chf.spans[i].reg) - res |= (1 << dir); - } - flags[i] = res ^ 0xf; // Inverse, mark non connected edges. - } - } - } - - ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_TRACE); - - rcIntArray verts(256); - rcIntArray simplified(64); - - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (flags[i] == 0 || flags[i] == 0xf) - { - flags[i] = 0; - continue; - } - const unsigned short reg = chf.spans[i].reg; - if (!reg || (reg & RC_BORDER_REG)) - continue; - const unsigned char area = chf.areas[i]; - - verts.clear(); - simplified.clear(); - - ctx->startTimer(RC_TIMER_BUILD_CONTOURS_TRACE); - walkContour(x, y, i, chf, flags, verts); - ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_TRACE); - - ctx->startTimer(RC_TIMER_BUILD_CONTOURS_SIMPLIFY); - simplifyContour(verts, simplified, maxError, maxEdgeLen, buildFlags); - removeDegenerateSegments(simplified); - ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_SIMPLIFY); - - - // Store region->contour remap info. - // Create contour. - if (simplified.size()/4 >= 3) - { - if (cset.nconts >= maxContours) - { - // Allocate more contours. - // This happens when a region has holes. - const int oldMax = maxContours; - maxContours *= 2; - rcContour* newConts = (rcContour*)rcAlloc(sizeof(rcContour)*maxContours, RC_ALLOC_PERM); - for (int j = 0; j < cset.nconts; ++j) - { - newConts[j] = cset.conts[j]; - // Reset source pointers to prevent data deletion. - cset.conts[j].verts = 0; - cset.conts[j].rverts = 0; - } - rcFree(cset.conts); - cset.conts = newConts; - - ctx->log(RC_LOG_WARNING, "rcBuildContours: Expanding max contours from %d to %d.", oldMax, maxContours); - } - - rcContour* cont = &cset.conts[cset.nconts++]; - - cont->nverts = simplified.size()/4; - cont->verts = (int*)rcAlloc(sizeof(int)*cont->nverts*4, RC_ALLOC_PERM); - if (!cont->verts) - { - ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'verts' (%d).", cont->nverts); - return false; - } - memcpy(cont->verts, &simplified[0], sizeof(int)*cont->nverts*4); - if (borderSize > 0) - { - // If the heightfield was build with bordersize, remove the offset. - for (int j = 0; j < cont->nverts; ++j) - { - int* v = &cont->verts[j*4]; - v[0] -= borderSize; - v[2] -= borderSize; - } - } - - cont->nrverts = verts.size()/4; - cont->rverts = (int*)rcAlloc(sizeof(int)*cont->nrverts*4, RC_ALLOC_PERM); - if (!cont->rverts) - { - ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'rverts' (%d).", cont->nrverts); - return false; - } - memcpy(cont->rverts, &verts[0], sizeof(int)*cont->nrverts*4); - if (borderSize > 0) - { - // If the heightfield was build with bordersize, remove the offset. - for (int j = 0; j < cont->nrverts; ++j) - { - int* v = &cont->rverts[j*4]; - v[0] -= borderSize; - v[2] -= borderSize; - } - } - - cont->reg = reg; - cont->area = area; - } - } - } - } - - // Merge holes if needed. - if (cset.nconts > 0) - { - // Calculate winding of all polygons. - rcScopedDelete winding((signed char*)rcAlloc(sizeof(signed char)*cset.nconts, RC_ALLOC_TEMP)); - if (!winding) - { - ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'hole' (%d).", cset.nconts); - return false; - } - int nholes = 0; - for (int i = 0; i < cset.nconts; ++i) - { - rcContour& cont = cset.conts[i]; - // If the contour is wound backwards, it is a hole. - winding[i] = calcAreaOfPolygon2D(cont.verts, cont.nverts) < 0 ? -1 : 1; - if (winding[i] < 0) - nholes++; - } - - if (nholes > 0) - { - // Collect outline contour and holes contours per region. - // We assume that there is one outline and multiple holes. - const int nregions = chf.maxRegions+1; - rcScopedDelete regions((rcContourRegion*)rcAlloc(sizeof(rcContourRegion)*nregions, RC_ALLOC_TEMP)); - if (!regions) - { - ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'regions' (%d).", nregions); - return false; - } - memset(regions, 0, sizeof(rcContourRegion)*nregions); - - rcScopedDelete holes((rcContourHole*)rcAlloc(sizeof(rcContourHole)*cset.nconts, RC_ALLOC_TEMP)); - if (!holes) - { - ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'holes' (%d).", cset.nconts); - return false; - } - memset(holes, 0, sizeof(rcContourHole)*cset.nconts); - - for (int i = 0; i < cset.nconts; ++i) - { - rcContour& cont = cset.conts[i]; - // Positively would contours are outlines, negative holes. - if (winding[i] > 0) - { - if (regions[cont.reg].outline) - ctx->log(RC_LOG_ERROR, "rcBuildContours: Multiple outlines for region %d.", cont.reg); - regions[cont.reg].outline = &cont; - } - else - { - regions[cont.reg].nholes++; - } - } - int index = 0; - for (int i = 0; i < nregions; i++) - { - if (regions[i].nholes > 0) - { - regions[i].holes = &holes[index]; - index += regions[i].nholes; - regions[i].nholes = 0; - } - } - for (int i = 0; i < cset.nconts; ++i) - { - rcContour& cont = cset.conts[i]; - rcContourRegion& reg = regions[cont.reg]; - if (winding[i] < 0) - reg.holes[reg.nholes++].contour = &cont; - } - - // Finally merge each regions holes into the outline. - for (int i = 0; i < nregions; i++) - { - rcContourRegion& reg = regions[i]; - if (!reg.nholes) continue; - - if (reg.outline) - { - mergeRegionHoles(ctx, reg); - } - else - { - // The region does not have an outline. - // This can happen if the contour becaomes selfoverlapping because of - // too aggressive simplification settings. - ctx->log(RC_LOG_ERROR, "rcBuildContours: Bad outline for region %d, contour simplification is likely too aggressive.", i); - } - } - } - - } - - return true; -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastFilter.cpp b/thirdparty/recastnavigation/Recast/Source/RecastFilter.cpp deleted file mode 100644 index b5adba4..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastFilter.cpp +++ /dev/null @@ -1,184 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include "Recast.h" -#include "RecastAssert.h" - -#include - -void rcFilterLowHangingWalkableObstacles(rcContext* context, const int walkableClimb, rcHeightfield& heightfield) -{ - rcAssert(context); - - rcScopedTimer timer(context, RC_TIMER_FILTER_LOW_OBSTACLES); - - const int xSize = heightfield.width; - const int zSize = heightfield.height; - - for (int z = 0; z < zSize; ++z) - { - for (int x = 0; x < xSize; ++x) - { - rcSpan* previousSpan = NULL; - bool previousWasWalkable = false; - unsigned char previousArea = RC_NULL_AREA; - - for (rcSpan* span = heightfield.spans[x + z * xSize]; span != NULL; previousSpan = span, span = span->next) - { - const bool walkable = span->area != RC_NULL_AREA; - // If current span is not walkable, but there is walkable - // span just below it, mark the span above it walkable too. - if (!walkable && previousWasWalkable) - { - if (rcAbs((int)span->smax - (int)previousSpan->smax) <= walkableClimb) - { - span->area = previousArea; - } - } - // Copy walkable flag so that it cannot propagate - // past multiple non-walkable objects. - previousWasWalkable = walkable; - previousArea = span->area; - } - } - } -} - -void rcFilterLedgeSpans(rcContext* context, const int walkableHeight, const int walkableClimb, - rcHeightfield& heightfield) -{ - rcAssert(context); - - rcScopedTimer timer(context, RC_TIMER_FILTER_BORDER); - - const int xSize = heightfield.width; - const int zSize = heightfield.height; - const int MAX_HEIGHT = 0xffff; // TODO (graham): Move this to a more visible constant and update usages. - - // Mark border spans. - for (int z = 0; z < zSize; ++z) - { - for (int x = 0; x < xSize; ++x) - { - for (rcSpan* span = heightfield.spans[x + z * xSize]; span; span = span->next) - { - // Skip non walkable spans. - if (span->area == RC_NULL_AREA) - { - continue; - } - - const int bot = (int)(span->smax); - const int top = span->next ? (int)(span->next->smin) : MAX_HEIGHT; - - // Find neighbours minimum height. - int minNeighborHeight = MAX_HEIGHT; - - // Min and max height of accessible neighbours. - int accessibleNeighborMinHeight = span->smax; - int accessibleNeighborMaxHeight = span->smax; - - for (int direction = 0; direction < 4; ++direction) - { - int dx = x + rcGetDirOffsetX(direction); - int dy = z + rcGetDirOffsetY(direction); - // Skip neighbours which are out of bounds. - if (dx < 0 || dy < 0 || dx >= xSize || dy >= zSize) - { - minNeighborHeight = rcMin(minNeighborHeight, -walkableClimb - bot); - continue; - } - - // From minus infinity to the first span. - const rcSpan* neighborSpan = heightfield.spans[dx + dy * xSize]; - int neighborBot = -walkableClimb; - int neighborTop = neighborSpan ? (int)neighborSpan->smin : MAX_HEIGHT; - - // Skip neighbour if the gap between the spans is too small. - if (rcMin(top, neighborTop) - rcMax(bot, neighborBot) > walkableHeight) - { - minNeighborHeight = rcMin(minNeighborHeight, neighborBot - bot); - } - - // Rest of the spans. - for (neighborSpan = heightfield.spans[dx + dy * xSize]; neighborSpan; neighborSpan = neighborSpan->next) - { - neighborBot = (int)neighborSpan->smax; - neighborTop = neighborSpan->next ? (int)neighborSpan->next->smin : MAX_HEIGHT; - - // Skip neighbour if the gap between the spans is too small. - if (rcMin(top, neighborTop) - rcMax(bot, neighborBot) > walkableHeight) - { - minNeighborHeight = rcMin(minNeighborHeight, neighborBot - bot); - - // Find min/max accessible neighbour height. - if (rcAbs(neighborBot - bot) <= walkableClimb) - { - if (neighborBot < accessibleNeighborMinHeight) accessibleNeighborMinHeight = neighborBot; - if (neighborBot > accessibleNeighborMaxHeight) accessibleNeighborMaxHeight = neighborBot; - } - - } - } - } - - // The current span is close to a ledge if the drop to any - // neighbour span is less than the walkableClimb. - if (minNeighborHeight < -walkableClimb) - { - span->area = RC_NULL_AREA; - } - // If the difference between all neighbours is too large, - // we are at steep slope, mark the span as ledge. - else if ((accessibleNeighborMaxHeight - accessibleNeighborMinHeight) > walkableClimb) - { - span->area = RC_NULL_AREA; - } - } - } - } -} - -void rcFilterWalkableLowHeightSpans(rcContext* context, const int walkableHeight, rcHeightfield& heightfield) -{ - rcAssert(context); - - rcScopedTimer timer(context, RC_TIMER_FILTER_WALKABLE); - - const int xSize = heightfield.width; - const int zSize = heightfield.height; - const int MAX_HEIGHT = 0xffff; - - // Remove walkable flag from spans which do not have enough - // space above them for the agent to stand there. - for (int z = 0; z < zSize; ++z) - { - for (int x = 0; x < xSize; ++x) - { - for (rcSpan* span = heightfield.spans[x + z*xSize]; span; span = span->next) - { - const int bot = (int)(span->smax); - const int top = span->next ? (int)(span->next->smin) : MAX_HEIGHT; - if ((top - bot) < walkableHeight) - { - span->area = RC_NULL_AREA; - } - } - } - } -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastLayers.cpp b/thirdparty/recastnavigation/Recast/Source/RecastLayers.cpp deleted file mode 100644 index ca37ebb..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastLayers.cpp +++ /dev/null @@ -1,656 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - - -// Must be 255 or smaller (not 256) because layer IDs are stored as -// a byte where 255 is a special value. -#ifndef RC_MAX_LAYERS_DEF -#define RC_MAX_LAYERS_DEF 63 -#endif - -#if RC_MAX_LAYERS_DEF > 255 -#error RC_MAX_LAYERS_DEF must be 255 or smaller -#endif - -#ifndef RC_MAX_NEIS_DEF -#define RC_MAX_NEIS_DEF 16 -#endif - -// Keep type checking. -static const int RC_MAX_LAYERS = RC_MAX_LAYERS_DEF; -static const int RC_MAX_NEIS = RC_MAX_NEIS_DEF; - -struct rcLayerRegion -{ - unsigned char layers[RC_MAX_LAYERS]; - unsigned char neis[RC_MAX_NEIS]; - unsigned short ymin, ymax; - unsigned char layerId; // Layer ID - unsigned char nlayers; // Layer count - unsigned char nneis; // Neighbour count - unsigned char base; // Flag indicating if the region is the base of merged regions. -}; - - -static bool contains(const unsigned char* a, const unsigned char an, const unsigned char v) -{ - const int n = (int)an; - for (int i = 0; i < n; ++i) - { - if (a[i] == v) - return true; - } - return false; -} - -static bool addUnique(unsigned char* a, unsigned char& an, int anMax, unsigned char v) -{ - if (contains(a, an, v)) - return true; - - if ((int)an >= anMax) - return false; - - a[an] = v; - an++; - return true; -} - - -inline bool overlapRange(const unsigned short amin, const unsigned short amax, - const unsigned short bmin, const unsigned short bmax) -{ - return (amin > bmax || amax < bmin) ? false : true; -} - - - -struct rcLayerSweepSpan -{ - unsigned short ns; // number samples - unsigned char id; // region id - unsigned char nei; // neighbour id -}; - -/// @par -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcAllocHeightfieldLayerSet, rcCompactHeightfield, rcHeightfieldLayerSet, rcConfig -bool rcBuildHeightfieldLayers(rcContext* ctx, const rcCompactHeightfield& chf, - const int borderSize, const int walkableHeight, - rcHeightfieldLayerSet& lset) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_LAYERS); - - const int w = chf.width; - const int h = chf.height; - - rcScopedDelete srcReg((unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP)); - if (!srcReg) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'srcReg' (%d).", chf.spanCount); - return false; - } - memset(srcReg,0xff,sizeof(unsigned char)*chf.spanCount); - - const int nsweeps = chf.width; - rcScopedDelete sweeps((rcLayerSweepSpan*)rcAlloc(sizeof(rcLayerSweepSpan)*nsweeps, RC_ALLOC_TEMP)); - if (!sweeps) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'sweeps' (%d).", nsweeps); - return false; - } - - - // Partition walkable area into monotone regions. - int prevCount[256]; - unsigned char regId = 0; - - for (int y = borderSize; y < h-borderSize; ++y) - { - memset(prevCount,0,sizeof(int)*regId); - unsigned char sweepId = 0; - - for (int x = borderSize; x < w-borderSize; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - if (chf.areas[i] == RC_NULL_AREA) continue; - - unsigned char sid = 0xff; - - // -x - if (rcGetCon(s, 0) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(0); - const int ay = y + rcGetDirOffsetY(0); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 0); - if (chf.areas[ai] != RC_NULL_AREA && srcReg[ai] != 0xff) - sid = srcReg[ai]; - } - - if (sid == 0xff) - { - sid = sweepId++; - sweeps[sid].nei = 0xff; - sweeps[sid].ns = 0; - } - - // -y - if (rcGetCon(s,3) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(3); - const int ay = y + rcGetDirOffsetY(3); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 3); - const unsigned char nr = srcReg[ai]; - if (nr != 0xff) - { - // Set neighbour when first valid neighbour is encoutered. - if (sweeps[sid].ns == 0) - sweeps[sid].nei = nr; - - if (sweeps[sid].nei == nr) - { - // Update existing neighbour - sweeps[sid].ns++; - prevCount[nr]++; - } - else - { - // This is hit if there is nore than one neighbour. - // Invalidate the neighbour. - sweeps[sid].nei = 0xff; - } - } - } - - srcReg[i] = sid; - } - } - - // Create unique ID. - for (int i = 0; i < sweepId; ++i) - { - // If the neighbour is set and there is only one continuous connection to it, - // the sweep will be merged with the previous one, else new region is created. - if (sweeps[i].nei != 0xff && prevCount[sweeps[i].nei] == (int)sweeps[i].ns) - { - sweeps[i].id = sweeps[i].nei; - } - else - { - if (regId == 255) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Region ID overflow."); - return false; - } - sweeps[i].id = regId++; - } - } - - // Remap local sweep ids to region ids. - for (int x = borderSize; x < w-borderSize; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (srcReg[i] != 0xff) - srcReg[i] = sweeps[srcReg[i]].id; - } - } - } - - // Allocate and init layer regions. - const int nregs = (int)regId; - rcScopedDelete regs((rcLayerRegion*)rcAlloc(sizeof(rcLayerRegion)*nregs, RC_ALLOC_TEMP)); - if (!regs) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'regs' (%d).", nregs); - return false; - } - memset(regs, 0, sizeof(rcLayerRegion)*nregs); - for (int i = 0; i < nregs; ++i) - { - regs[i].layerId = 0xff; - regs[i].ymin = 0xffff; - regs[i].ymax = 0; - } - - // Find region neighbours and overlapping regions. - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - unsigned char lregs[RC_MAX_LAYERS]; - int nlregs = 0; - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - const unsigned char ri = srcReg[i]; - if (ri == 0xff) continue; - - regs[ri].ymin = rcMin(regs[ri].ymin, s.y); - regs[ri].ymax = rcMax(regs[ri].ymax, s.y); - - // Collect all region layers. - if (nlregs < RC_MAX_LAYERS) - lregs[nlregs++] = ri; - - // Update neighbours - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - const unsigned char rai = srcReg[ai]; - if (rai != 0xff && rai != ri) - { - // Don't check return value -- if we cannot add the neighbor - // it will just cause a few more regions to be created, which - // is fine. - addUnique(regs[ri].neis, regs[ri].nneis, RC_MAX_NEIS, rai); - } - } - } - - } - - // Update overlapping regions. - for (int i = 0; i < nlregs-1; ++i) - { - for (int j = i+1; j < nlregs; ++j) - { - if (lregs[i] != lregs[j]) - { - rcLayerRegion& ri = regs[lregs[i]]; - rcLayerRegion& rj = regs[lregs[j]]; - - if (!addUnique(ri.layers, ri.nlayers, RC_MAX_LAYERS, lregs[j]) || - !addUnique(rj.layers, rj.nlayers, RC_MAX_LAYERS, lregs[i])) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: layer overflow (too many overlapping walkable platforms). Try increasing RC_MAX_LAYERS."); - return false; - } - } - } - } - - } - } - - // Create 2D layers from regions. - unsigned char layerId = 0; - - static const int MAX_STACK = 64; - unsigned char stack[MAX_STACK]; - int nstack = 0; - - for (int i = 0; i < nregs; ++i) - { - rcLayerRegion& root = regs[i]; - // Skip already visited. - if (root.layerId != 0xff) - continue; - - // Start search. - root.layerId = layerId; - root.base = 1; - - nstack = 0; - stack[nstack++] = (unsigned char)i; - - while (nstack) - { - // Pop front - rcLayerRegion& reg = regs[stack[0]]; - nstack--; - for (int j = 0; j < nstack; ++j) - stack[j] = stack[j+1]; - - const int nneis = (int)reg.nneis; - for (int j = 0; j < nneis; ++j) - { - const unsigned char nei = reg.neis[j]; - rcLayerRegion& regn = regs[nei]; - // Skip already visited. - if (regn.layerId != 0xff) - continue; - // Skip if the neighbour is overlapping root region. - if (contains(root.layers, root.nlayers, nei)) - continue; - // Skip if the height range would become too large. - const int ymin = rcMin(root.ymin, regn.ymin); - const int ymax = rcMax(root.ymax, regn.ymax); - if ((ymax - ymin) >= 255) - continue; - - if (nstack < MAX_STACK) - { - // Deepen - stack[nstack++] = (unsigned char)nei; - - // Mark layer id - regn.layerId = layerId; - // Merge current layers to root. - for (int k = 0; k < regn.nlayers; ++k) - { - if (!addUnique(root.layers, root.nlayers, RC_MAX_LAYERS, regn.layers[k])) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: layer overflow (too many overlapping walkable platforms). Try increasing RC_MAX_LAYERS."); - return false; - } - } - root.ymin = rcMin(root.ymin, regn.ymin); - root.ymax = rcMax(root.ymax, regn.ymax); - } - } - } - - layerId++; - } - - // Merge non-overlapping regions that are close in height. - const unsigned short mergeHeight = (unsigned short)walkableHeight * 4; - - for (int i = 0; i < nregs; ++i) - { - rcLayerRegion& ri = regs[i]; - if (!ri.base) continue; - - unsigned char newId = ri.layerId; - - for (;;) - { - unsigned char oldId = 0xff; - - for (int j = 0; j < nregs; ++j) - { - if (i == j) continue; - rcLayerRegion& rj = regs[j]; - if (!rj.base) continue; - - // Skip if the regions are not close to each other. - if (!overlapRange(ri.ymin,ri.ymax+mergeHeight, rj.ymin,rj.ymax+mergeHeight)) - continue; - // Skip if the height range would become too large. - const int ymin = rcMin(ri.ymin, rj.ymin); - const int ymax = rcMax(ri.ymax, rj.ymax); - if ((ymax - ymin) >= 255) - continue; - - // Make sure that there is no overlap when merging 'ri' and 'rj'. - bool overlap = false; - // Iterate over all regions which have the same layerId as 'rj' - for (int k = 0; k < nregs; ++k) - { - if (regs[k].layerId != rj.layerId) - continue; - // Check if region 'k' is overlapping region 'ri' - // Index to 'regs' is the same as region id. - if (contains(ri.layers,ri.nlayers, (unsigned char)k)) - { - overlap = true; - break; - } - } - // Cannot merge of regions overlap. - if (overlap) - continue; - - // Can merge i and j. - oldId = rj.layerId; - break; - } - - // Could not find anything to merge with, stop. - if (oldId == 0xff) - break; - - // Merge - for (int j = 0; j < nregs; ++j) - { - rcLayerRegion& rj = regs[j]; - if (rj.layerId == oldId) - { - rj.base = 0; - // Remap layerIds. - rj.layerId = newId; - // Add overlaid layers from 'rj' to 'ri'. - for (int k = 0; k < rj.nlayers; ++k) - { - if (!addUnique(ri.layers, ri.nlayers, RC_MAX_LAYERS, rj.layers[k])) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: layer overflow (too many overlapping walkable platforms). Try increasing RC_MAX_LAYERS."); - return false; - } - } - - // Update height bounds. - ri.ymin = rcMin(ri.ymin, rj.ymin); - ri.ymax = rcMax(ri.ymax, rj.ymax); - } - } - } - } - - // Compact layerIds - unsigned char remap[256]; - memset(remap, 0, 256); - - // Find number of unique layers. - layerId = 0; - for (int i = 0; i < nregs; ++i) - remap[regs[i].layerId] = 1; - for (int i = 0; i < 256; ++i) - { - if (remap[i]) - remap[i] = layerId++; - else - remap[i] = 0xff; - } - // Remap ids. - for (int i = 0; i < nregs; ++i) - regs[i].layerId = remap[regs[i].layerId]; - - // No layers, return empty. - if (layerId == 0) - return true; - - // Create layers. - rcAssert(lset.layers == 0); - - const int lw = w - borderSize*2; - const int lh = h - borderSize*2; - - // Build contracted bbox for layers. - float bmin[3], bmax[3]; - rcVcopy(bmin, chf.bmin); - rcVcopy(bmax, chf.bmax); - bmin[0] += borderSize*chf.cs; - bmin[2] += borderSize*chf.cs; - bmax[0] -= borderSize*chf.cs; - bmax[2] -= borderSize*chf.cs; - - lset.nlayers = (int)layerId; - - lset.layers = (rcHeightfieldLayer*)rcAlloc(sizeof(rcHeightfieldLayer)*lset.nlayers, RC_ALLOC_PERM); - if (!lset.layers) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'layers' (%d).", lset.nlayers); - return false; - } - memset(lset.layers, 0, sizeof(rcHeightfieldLayer)*lset.nlayers); - - - // Store layers. - for (int i = 0; i < lset.nlayers; ++i) - { - unsigned char curId = (unsigned char)i; - - rcHeightfieldLayer* layer = &lset.layers[i]; - - const int gridSize = sizeof(unsigned char)*lw*lh; - - layer->heights = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM); - if (!layer->heights) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'heights' (%d).", gridSize); - return false; - } - memset(layer->heights, 0xff, gridSize); - - layer->areas = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM); - if (!layer->areas) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'areas' (%d).", gridSize); - return false; - } - memset(layer->areas, 0, gridSize); - - layer->cons = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM); - if (!layer->cons) - { - ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'cons' (%d).", gridSize); - return false; - } - memset(layer->cons, 0, gridSize); - - // Find layer height bounds. - int hmin = 0, hmax = 0; - for (int j = 0; j < nregs; ++j) - { - if (regs[j].base && regs[j].layerId == curId) - { - hmin = (int)regs[j].ymin; - hmax = (int)regs[j].ymax; - } - } - - layer->width = lw; - layer->height = lh; - layer->cs = chf.cs; - layer->ch = chf.ch; - - // Adjust the bbox to fit the heightfield. - rcVcopy(layer->bmin, bmin); - rcVcopy(layer->bmax, bmax); - layer->bmin[1] = bmin[1] + hmin*chf.ch; - layer->bmax[1] = bmin[1] + hmax*chf.ch; - layer->hmin = hmin; - layer->hmax = hmax; - - // Update usable data region. - layer->minx = layer->width; - layer->maxx = 0; - layer->miny = layer->height; - layer->maxy = 0; - - // Copy height and area from compact heightfield. - for (int y = 0; y < lh; ++y) - { - for (int x = 0; x < lw; ++x) - { - const int cx = borderSize+x; - const int cy = borderSize+y; - const rcCompactCell& c = chf.cells[cx+cy*w]; - for (int j = (int)c.index, nj = (int)(c.index+c.count); j < nj; ++j) - { - const rcCompactSpan& s = chf.spans[j]; - // Skip unassigned regions. - if (srcReg[j] == 0xff) - continue; - // Skip of does nto belong to current layer. - unsigned char lid = regs[srcReg[j]].layerId; - if (lid != curId) - continue; - - // Update data bounds. - layer->minx = rcMin(layer->minx, x); - layer->maxx = rcMax(layer->maxx, x); - layer->miny = rcMin(layer->miny, y); - layer->maxy = rcMax(layer->maxy, y); - - // Store height and area type. - const int idx = x+y*lw; - layer->heights[idx] = (unsigned char)(s.y - hmin); - layer->areas[idx] = chf.areas[j]; - - // Check connection. - unsigned char portal = 0; - unsigned char con = 0; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = cx + rcGetDirOffsetX(dir); - const int ay = cy + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - unsigned char alid = srcReg[ai] != 0xff ? regs[srcReg[ai]].layerId : 0xff; - // Portal mask - if (chf.areas[ai] != RC_NULL_AREA && lid != alid) - { - portal |= (unsigned char)(1< hmin) - layer->heights[idx] = rcMax(layer->heights[idx], (unsigned char)(as.y - hmin)); - } - // Valid connection mask - if (chf.areas[ai] != RC_NULL_AREA && lid == alid) - { - const int nx = ax - borderSize; - const int ny = ay - borderSize; - if (nx >= 0 && ny >= 0 && nx < lw && ny < lh) - con |= (unsigned char)(1<cons[idx] = (portal << 4) | con; - } - } - } - - if (layer->minx > layer->maxx) - layer->minx = layer->maxx = 0; - if (layer->miny > layer->maxy) - layer->miny = layer->maxy = 0; - } - - return true; -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastMesh.cpp b/thirdparty/recastnavigation/Recast/Source/RecastMesh.cpp deleted file mode 100644 index c2c0d51..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastMesh.cpp +++ /dev/null @@ -1,1549 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - -struct rcEdge -{ - unsigned short vert[2]; - unsigned short polyEdge[2]; - unsigned short poly[2]; -}; - -static bool buildMeshAdjacency(unsigned short* polys, const int npolys, - const int nverts, const int vertsPerPoly) -{ - // Based on code by Eric Lengyel from: - // https://web.archive.org/web/20080704083314/http://www.terathon.com/code/edges.php - - int maxEdgeCount = npolys*vertsPerPoly; - unsigned short* firstEdge = (unsigned short*)rcAlloc(sizeof(unsigned short)*(nverts + maxEdgeCount), RC_ALLOC_TEMP); - if (!firstEdge) - return false; - unsigned short* nextEdge = firstEdge + nverts; - int edgeCount = 0; - - rcEdge* edges = (rcEdge*)rcAlloc(sizeof(rcEdge)*maxEdgeCount, RC_ALLOC_TEMP); - if (!edges) - { - rcFree(firstEdge); - return false; - } - - for (int i = 0; i < nverts; i++) - firstEdge[i] = RC_MESH_NULL_IDX; - - for (int i = 0; i < npolys; ++i) - { - unsigned short* t = &polys[i*vertsPerPoly*2]; - for (int j = 0; j < vertsPerPoly; ++j) - { - if (t[j] == RC_MESH_NULL_IDX) break; - unsigned short v0 = t[j]; - unsigned short v1 = (j+1 >= vertsPerPoly || t[j+1] == RC_MESH_NULL_IDX) ? t[0] : t[j+1]; - if (v0 < v1) - { - rcEdge& edge = edges[edgeCount]; - edge.vert[0] = v0; - edge.vert[1] = v1; - edge.poly[0] = (unsigned short)i; - edge.polyEdge[0] = (unsigned short)j; - edge.poly[1] = (unsigned short)i; - edge.polyEdge[1] = 0; - // Insert edge - nextEdge[edgeCount] = firstEdge[v0]; - firstEdge[v0] = (unsigned short)edgeCount; - edgeCount++; - } - } - } - - for (int i = 0; i < npolys; ++i) - { - unsigned short* t = &polys[i*vertsPerPoly*2]; - for (int j = 0; j < vertsPerPoly; ++j) - { - if (t[j] == RC_MESH_NULL_IDX) break; - unsigned short v0 = t[j]; - unsigned short v1 = (j+1 >= vertsPerPoly || t[j+1] == RC_MESH_NULL_IDX) ? t[0] : t[j+1]; - if (v0 > v1) - { - for (unsigned short e = firstEdge[v1]; e != RC_MESH_NULL_IDX; e = nextEdge[e]) - { - rcEdge& edge = edges[e]; - if (edge.vert[1] == v0 && edge.poly[0] == edge.poly[1]) - { - edge.poly[1] = (unsigned short)i; - edge.polyEdge[1] = (unsigned short)j; - break; - } - } - } - } - } - - // Store adjacency - for (int i = 0; i < edgeCount; ++i) - { - const rcEdge& e = edges[i]; - if (e.poly[0] != e.poly[1]) - { - unsigned short* p0 = &polys[e.poly[0]*vertsPerPoly*2]; - unsigned short* p1 = &polys[e.poly[1]*vertsPerPoly*2]; - p0[vertsPerPoly + e.polyEdge[0]] = e.poly[1]; - p1[vertsPerPoly + e.polyEdge[1]] = e.poly[0]; - } - } - - rcFree(firstEdge); - rcFree(edges); - - return true; -} - - -static const int VERTEX_BUCKET_COUNT = (1<<12); - -inline int computeVertexHash(int x, int y, int z) -{ - const unsigned int h1 = 0x8da6b343; // Large multiplicative constants; - const unsigned int h2 = 0xd8163841; // here arbitrarily chosen primes - const unsigned int h3 = 0xcb1ab31f; - unsigned int n = h1 * x + h2 * y + h3 * z; - return (int)(n & (VERTEX_BUCKET_COUNT-1)); -} - -static unsigned short addVertex(unsigned short x, unsigned short y, unsigned short z, - unsigned short* verts, int* firstVert, int* nextVert, int& nv) -{ - int bucket = computeVertexHash(x, 0, z); - int i = firstVert[bucket]; - - while (i != -1) - { - const unsigned short* v = &verts[i*3]; - if (v[0] == x && (rcAbs(v[1] - y) <= 2) && v[2] == z) - return (unsigned short)i; - i = nextVert[i]; // next - } - - // Could not find, create new. - i = nv; nv++; - unsigned short* v = &verts[i*3]; - v[0] = x; - v[1] = y; - v[2] = z; - nextVert[i] = firstVert[bucket]; - firstVert[bucket] = i; - - return (unsigned short)i; -} - -// Last time I checked the if version got compiled using cmov, which was a lot faster than module (with idiv). -inline int prev(int i, int n) { return i-1 >= 0 ? i-1 : n-1; } -inline int next(int i, int n) { return i+1 < n ? i+1 : 0; } - -inline int area2(const int* a, const int* b, const int* c) -{ - return (b[0] - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (b[2] - a[2]); -} - -// Exclusive or: true iff exactly one argument is true. -// The arguments are negated to ensure that they are 0/1 -// values. Then the bitwise Xor operator may apply. -// (This idea is due to Michael Baldwin.) -inline bool xorb(bool x, bool y) -{ - return !x ^ !y; -} - -// Returns true iff c is strictly to the left of the directed -// line through a to b. -inline bool left(const int* a, const int* b, const int* c) -{ - return area2(a, b, c) < 0; -} - -inline bool leftOn(const int* a, const int* b, const int* c) -{ - return area2(a, b, c) <= 0; -} - -inline bool collinear(const int* a, const int* b, const int* c) -{ - return area2(a, b, c) == 0; -} - -// Returns true iff ab properly intersects cd: they share -// a point interior to both segments. The properness of the -// intersection is ensured by using strict leftness. -static bool intersectProp(const int* a, const int* b, const int* c, const int* d) -{ - // Eliminate improper cases. - if (collinear(a,b,c) || collinear(a,b,d) || - collinear(c,d,a) || collinear(c,d,b)) - return false; - - return xorb(left(a,b,c), left(a,b,d)) && xorb(left(c,d,a), left(c,d,b)); -} - -// Returns T iff (a,b,c) are collinear and point c lies -// on the closed segement ab. -static bool between(const int* a, const int* b, const int* c) -{ - if (!collinear(a, b, c)) - return false; - // If ab not vertical, check betweenness on x; else on y. - if (a[0] != b[0]) - return ((a[0] <= c[0]) && (c[0] <= b[0])) || ((a[0] >= c[0]) && (c[0] >= b[0])); - else - return ((a[2] <= c[2]) && (c[2] <= b[2])) || ((a[2] >= c[2]) && (c[2] >= b[2])); -} - -// Returns true iff segments ab and cd intersect, properly or improperly. -static bool intersect(const int* a, const int* b, const int* c, const int* d) -{ - if (intersectProp(a, b, c, d)) - return true; - else if (between(a, b, c) || between(a, b, d) || - between(c, d, a) || between(c, d, b)) - return true; - else - return false; -} - -static bool vequal(const int* a, const int* b) -{ - return a[0] == b[0] && a[2] == b[2]; -} - -// Returns T iff (v_i, v_j) is a proper internal *or* external -// diagonal of P, *ignoring edges incident to v_i and v_j*. -static bool diagonalie(int i, int j, int n, const int* verts, int* indices) -{ - const int* d0 = &verts[(indices[i] & 0x0fffffff) * 4]; - const int* d1 = &verts[(indices[j] & 0x0fffffff) * 4]; - - // For each edge (k,k+1) of P - for (int k = 0; k < n; k++) - { - int k1 = next(k, n); - // Skip edges incident to i or j - if (!((k == i) || (k1 == i) || (k == j) || (k1 == j))) - { - const int* p0 = &verts[(indices[k] & 0x0fffffff) * 4]; - const int* p1 = &verts[(indices[k1] & 0x0fffffff) * 4]; - - if (vequal(d0, p0) || vequal(d1, p0) || vequal(d0, p1) || vequal(d1, p1)) - continue; - - if (intersect(d0, d1, p0, p1)) - return false; - } - } - return true; -} - -// Returns true iff the diagonal (i,j) is strictly internal to the -// polygon P in the neighborhood of the i endpoint. -static bool inCone(int i, int j, int n, const int* verts, int* indices) -{ - const int* pi = &verts[(indices[i] & 0x0fffffff) * 4]; - const int* pj = &verts[(indices[j] & 0x0fffffff) * 4]; - const int* pi1 = &verts[(indices[next(i, n)] & 0x0fffffff) * 4]; - const int* pin1 = &verts[(indices[prev(i, n)] & 0x0fffffff) * 4]; - - // If P[i] is a convex vertex [ i+1 left or on (i-1,i) ]. - if (leftOn(pin1, pi, pi1)) - return left(pi, pj, pin1) && left(pj, pi, pi1); - // Assume (i-1,i,i+1) not collinear. - // else P[i] is reflex. - return !(leftOn(pi, pj, pi1) && leftOn(pj, pi, pin1)); -} - -// Returns T iff (v_i, v_j) is a proper internal -// diagonal of P. -static bool diagonal(int i, int j, int n, const int* verts, int* indices) -{ - return inCone(i, j, n, verts, indices) && diagonalie(i, j, n, verts, indices); -} - - -static bool diagonalieLoose(int i, int j, int n, const int* verts, int* indices) -{ - const int* d0 = &verts[(indices[i] & 0x0fffffff) * 4]; - const int* d1 = &verts[(indices[j] & 0x0fffffff) * 4]; - - // For each edge (k,k+1) of P - for (int k = 0; k < n; k++) - { - int k1 = next(k, n); - // Skip edges incident to i or j - if (!((k == i) || (k1 == i) || (k == j) || (k1 == j))) - { - const int* p0 = &verts[(indices[k] & 0x0fffffff) * 4]; - const int* p1 = &verts[(indices[k1] & 0x0fffffff) * 4]; - - if (vequal(d0, p0) || vequal(d1, p0) || vequal(d0, p1) || vequal(d1, p1)) - continue; - - if (intersectProp(d0, d1, p0, p1)) - return false; - } - } - return true; -} - -static bool inConeLoose(int i, int j, int n, const int* verts, int* indices) -{ - const int* pi = &verts[(indices[i] & 0x0fffffff) * 4]; - const int* pj = &verts[(indices[j] & 0x0fffffff) * 4]; - const int* pi1 = &verts[(indices[next(i, n)] & 0x0fffffff) * 4]; - const int* pin1 = &verts[(indices[prev(i, n)] & 0x0fffffff) * 4]; - - // If P[i] is a convex vertex [ i+1 left or on (i-1,i) ]. - if (leftOn(pin1, pi, pi1)) - return leftOn(pi, pj, pin1) && leftOn(pj, pi, pi1); - // Assume (i-1,i,i+1) not collinear. - // else P[i] is reflex. - return !(leftOn(pi, pj, pi1) && leftOn(pj, pi, pin1)); -} - -static bool diagonalLoose(int i, int j, int n, const int* verts, int* indices) -{ - return inConeLoose(i, j, n, verts, indices) && diagonalieLoose(i, j, n, verts, indices); -} - - -static int triangulate(int n, const int* verts, int* indices, int* tris) -{ - int ntris = 0; - int* dst = tris; - - // The last bit of the index is used to indicate if the vertex can be removed. - for (int i = 0; i < n; i++) - { - int i1 = next(i, n); - int i2 = next(i1, n); - if (diagonal(i, i2, n, verts, indices)) - indices[i1] |= 0x80000000; - } - - while (n > 3) - { - int minLen = -1; - int mini = -1; - for (int i = 0; i < n; i++) - { - int i1 = next(i, n); - if (indices[i1] & 0x80000000) - { - const int* p0 = &verts[(indices[i] & 0x0fffffff) * 4]; - const int* p2 = &verts[(indices[next(i1, n)] & 0x0fffffff) * 4]; - - int dx = p2[0] - p0[0]; - int dy = p2[2] - p0[2]; - int len = dx*dx + dy*dy; - - if (minLen < 0 || len < minLen) - { - minLen = len; - mini = i; - } - } - } - - if (mini == -1) - { - // We might get here because the contour has overlapping segments, like this: - // - // A o-o=====o---o B - // / |C D| \. - // o o o o - // : : : : - // We'll try to recover by loosing up the inCone test a bit so that a diagonal - // like A-B or C-D can be found and we can continue. - minLen = -1; - mini = -1; - for (int i = 0; i < n; i++) - { - int i1 = next(i, n); - int i2 = next(i1, n); - if (diagonalLoose(i, i2, n, verts, indices)) - { - const int* p0 = &verts[(indices[i] & 0x0fffffff) * 4]; - const int* p2 = &verts[(indices[next(i2, n)] & 0x0fffffff) * 4]; - int dx = p2[0] - p0[0]; - int dy = p2[2] - p0[2]; - int len = dx*dx + dy*dy; - - if (minLen < 0 || len < minLen) - { - minLen = len; - mini = i; - } - } - } - if (mini == -1) - { - // The contour is messed up. This sometimes happens - // if the contour simplification is too aggressive. - return -ntris; - } - } - - int i = mini; - int i1 = next(i, n); - int i2 = next(i1, n); - - *dst++ = indices[i] & 0x0fffffff; - *dst++ = indices[i1] & 0x0fffffff; - *dst++ = indices[i2] & 0x0fffffff; - ntris++; - - // Removes P[i1] by copying P[i+1]...P[n-1] left one index. - n--; - for (int k = i1; k < n; k++) - indices[k] = indices[k+1]; - - if (i1 >= n) i1 = 0; - i = prev(i1,n); - // Update diagonal flags. - if (diagonal(prev(i, n), i1, n, verts, indices)) - indices[i] |= 0x80000000; - else - indices[i] &= 0x0fffffff; - - if (diagonal(i, next(i1, n), n, verts, indices)) - indices[i1] |= 0x80000000; - else - indices[i1] &= 0x0fffffff; - } - - // Append the remaining triangle. - *dst++ = indices[0] & 0x0fffffff; - *dst++ = indices[1] & 0x0fffffff; - *dst++ = indices[2] & 0x0fffffff; - ntris++; - - return ntris; -} - -static int countPolyVerts(const unsigned short* p, const int nvp) -{ - for (int i = 0; i < nvp; ++i) - if (p[i] == RC_MESH_NULL_IDX) - return i; - return nvp; -} - -inline bool uleft(const unsigned short* a, const unsigned short* b, const unsigned short* c) -{ - return ((int)b[0] - (int)a[0]) * ((int)c[2] - (int)a[2]) - - ((int)c[0] - (int)a[0]) * ((int)b[2] - (int)a[2]) < 0; -} - -static int getPolyMergeValue(unsigned short* pa, unsigned short* pb, - const unsigned short* verts, int& ea, int& eb, - const int nvp) -{ - const int na = countPolyVerts(pa, nvp); - const int nb = countPolyVerts(pb, nvp); - - // If the merged polygon would be too big, do not merge. - if (na+nb-2 > nvp) - return -1; - - // Check if the polygons share an edge. - ea = -1; - eb = -1; - - for (int i = 0; i < na; ++i) - { - unsigned short va0 = pa[i]; - unsigned short va1 = pa[(i+1) % na]; - if (va0 > va1) - rcSwap(va0, va1); - for (int j = 0; j < nb; ++j) - { - unsigned short vb0 = pb[j]; - unsigned short vb1 = pb[(j+1) % nb]; - if (vb0 > vb1) - rcSwap(vb0, vb1); - if (va0 == vb0 && va1 == vb1) - { - ea = i; - eb = j; - break; - } - } - } - - // No common edge, cannot merge. - if (ea == -1 || eb == -1) - return -1; - - // Check to see if the merged polygon would be convex. - unsigned short va, vb, vc; - - va = pa[(ea+na-1) % na]; - vb = pa[ea]; - vc = pb[(eb+2) % nb]; - if (!uleft(&verts[va*3], &verts[vb*3], &verts[vc*3])) - return -1; - - va = pb[(eb+nb-1) % nb]; - vb = pb[eb]; - vc = pa[(ea+2) % na]; - if (!uleft(&verts[va*3], &verts[vb*3], &verts[vc*3])) - return -1; - - va = pa[ea]; - vb = pa[(ea+1)%na]; - - int dx = (int)verts[va*3+0] - (int)verts[vb*3+0]; - int dy = (int)verts[va*3+2] - (int)verts[vb*3+2]; - - return dx*dx + dy*dy; -} - -static void mergePolyVerts(unsigned short* pa, unsigned short* pb, int ea, int eb, - unsigned short* tmp, const int nvp) -{ - const int na = countPolyVerts(pa, nvp); - const int nb = countPolyVerts(pb, nvp); - - // Merge polygons. - memset(tmp, 0xff, sizeof(unsigned short)*nvp); - int n = 0; - // Add pa - for (int i = 0; i < na-1; ++i) - tmp[n++] = pa[(ea+1+i) % na]; - // Add pb - for (int i = 0; i < nb-1; ++i) - tmp[n++] = pb[(eb+1+i) % nb]; - - memcpy(pa, tmp, sizeof(unsigned short)*nvp); -} - - -static void pushFront(int v, int* arr, int& an) -{ - an++; - for (int i = an-1; i > 0; --i) arr[i] = arr[i-1]; - arr[0] = v; -} - -static void pushBack(int v, int* arr, int& an) -{ - arr[an] = v; - an++; -} - -static bool canRemoveVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short rem) -{ - const int nvp = mesh.nvp; - - // Count number of polygons to remove. - int numTouchedVerts = 0; - int numRemainingEdges = 0; - for (int i = 0; i < mesh.npolys; ++i) - { - unsigned short* p = &mesh.polys[i*nvp*2]; - const int nv = countPolyVerts(p, nvp); - int numRemoved = 0; - int numVerts = 0; - for (int j = 0; j < nv; ++j) - { - if (p[j] == rem) - { - numTouchedVerts++; - numRemoved++; - } - numVerts++; - } - if (numRemoved) - { - numRemainingEdges += numVerts-(numRemoved+1); - } - } - - // There would be too few edges remaining to create a polygon. - // This can happen for example when a tip of a triangle is marked - // as deletion, but there are no other polys that share the vertex. - // In this case, the vertex should not be removed. - if (numRemainingEdges <= 2) - return false; - - // Find edges which share the removed vertex. - const int maxEdges = numTouchedVerts*2; - int nedges = 0; - rcScopedDelete edges((int*)rcAlloc(sizeof(int)*maxEdges*3, RC_ALLOC_TEMP)); - if (!edges) - { - ctx->log(RC_LOG_WARNING, "canRemoveVertex: Out of memory 'edges' (%d).", maxEdges*3); - return false; - } - - for (int i = 0; i < mesh.npolys; ++i) - { - unsigned short* p = &mesh.polys[i*nvp*2]; - const int nv = countPolyVerts(p, nvp); - - // Collect edges which touches the removed vertex. - for (int j = 0, k = nv-1; j < nv; k = j++) - { - if (p[j] == rem || p[k] == rem) - { - // Arrange edge so that a=rem. - int a = p[j], b = p[k]; - if (b == rem) - rcSwap(a,b); - - // Check if the edge exists - bool exists = false; - for (int m = 0; m < nedges; ++m) - { - int* e = &edges[m*3]; - if (e[1] == b) - { - // Exists, increment vertex share count. - e[2]++; - exists = true; - } - } - // Add new edge. - if (!exists) - { - int* e = &edges[nedges*3]; - e[0] = a; - e[1] = b; - e[2] = 1; - nedges++; - } - } - } - } - - // There should be no more than 2 open edges. - // This catches the case that two non-adjacent polygons - // share the removed vertex. In that case, do not remove the vertex. - int numOpenEdges = 0; - for (int i = 0; i < nedges; ++i) - { - if (edges[i*3+2] < 2) - numOpenEdges++; - } - if (numOpenEdges > 2) - return false; - - return true; -} - -static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short rem, const int maxTris) -{ - const int nvp = mesh.nvp; - - // Count number of polygons to remove. - int numRemovedVerts = 0; - for (int i = 0; i < mesh.npolys; ++i) - { - unsigned short* p = &mesh.polys[i*nvp*2]; - const int nv = countPolyVerts(p, nvp); - for (int j = 0; j < nv; ++j) - { - if (p[j] == rem) - numRemovedVerts++; - } - } - - int nedges = 0; - rcScopedDelete edges((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp*4, RC_ALLOC_TEMP)); - if (!edges) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'edges' (%d).", numRemovedVerts*nvp*4); - return false; - } - - int nhole = 0; - rcScopedDelete hole((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp, RC_ALLOC_TEMP)); - if (!hole) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'hole' (%d).", numRemovedVerts*nvp); - return false; - } - - int nhreg = 0; - rcScopedDelete hreg((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp, RC_ALLOC_TEMP)); - if (!hreg) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'hreg' (%d).", numRemovedVerts*nvp); - return false; - } - - int nharea = 0; - rcScopedDelete harea((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp, RC_ALLOC_TEMP)); - if (!harea) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'harea' (%d).", numRemovedVerts*nvp); - return false; - } - - for (int i = 0; i < mesh.npolys; ++i) - { - unsigned short* p = &mesh.polys[i*nvp*2]; - const int nv = countPolyVerts(p, nvp); - bool hasRem = false; - for (int j = 0; j < nv; ++j) - if (p[j] == rem) hasRem = true; - if (hasRem) - { - // Collect edges which does not touch the removed vertex. - for (int j = 0, k = nv-1; j < nv; k = j++) - { - if (p[j] != rem && p[k] != rem) - { - int* e = &edges[nedges*4]; - e[0] = p[k]; - e[1] = p[j]; - e[2] = mesh.regs[i]; - e[3] = mesh.areas[i]; - nedges++; - } - } - // Remove the polygon. - unsigned short* p2 = &mesh.polys[(mesh.npolys-1)*nvp*2]; - if (p != p2) - memcpy(p,p2,sizeof(unsigned short)*nvp); - memset(p+nvp,0xff,sizeof(unsigned short)*nvp); - mesh.regs[i] = mesh.regs[mesh.npolys-1]; - mesh.areas[i] = mesh.areas[mesh.npolys-1]; - mesh.npolys--; - --i; - } - } - - // Remove vertex. - for (int i = (int)rem; i < mesh.nverts - 1; ++i) - { - mesh.verts[i*3+0] = mesh.verts[(i+1)*3+0]; - mesh.verts[i*3+1] = mesh.verts[(i+1)*3+1]; - mesh.verts[i*3+2] = mesh.verts[(i+1)*3+2]; - } - mesh.nverts--; - - // Adjust indices to match the removed vertex layout. - for (int i = 0; i < mesh.npolys; ++i) - { - unsigned short* p = &mesh.polys[i*nvp*2]; - const int nv = countPolyVerts(p, nvp); - for (int j = 0; j < nv; ++j) - if (p[j] > rem) p[j]--; - } - for (int i = 0; i < nedges; ++i) - { - if (edges[i*4+0] > rem) edges[i*4+0]--; - if (edges[i*4+1] > rem) edges[i*4+1]--; - } - - if (nedges == 0) - return true; - - // Start with one vertex, keep appending connected - // segments to the start and end of the hole. - pushBack(edges[0], hole, nhole); - pushBack(edges[2], hreg, nhreg); - pushBack(edges[3], harea, nharea); - - while (nedges) - { - bool match = false; - - for (int i = 0; i < nedges; ++i) - { - const int ea = edges[i*4+0]; - const int eb = edges[i*4+1]; - const int r = edges[i*4+2]; - const int a = edges[i*4+3]; - bool add = false; - if (hole[0] == eb) - { - // The segment matches the beginning of the hole boundary. - pushFront(ea, hole, nhole); - pushFront(r, hreg, nhreg); - pushFront(a, harea, nharea); - add = true; - } - else if (hole[nhole-1] == ea) - { - // The segment matches the end of the hole boundary. - pushBack(eb, hole, nhole); - pushBack(r, hreg, nhreg); - pushBack(a, harea, nharea); - add = true; - } - if (add) - { - // The edge segment was added, remove it. - edges[i*4+0] = edges[(nedges-1)*4+0]; - edges[i*4+1] = edges[(nedges-1)*4+1]; - edges[i*4+2] = edges[(nedges-1)*4+2]; - edges[i*4+3] = edges[(nedges-1)*4+3]; - --nedges; - match = true; - --i; - } - } - - if (!match) - break; - } - - rcScopedDelete tris((int*)rcAlloc(sizeof(int)*nhole*3, RC_ALLOC_TEMP)); - if (!tris) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'tris' (%d).", nhole*3); - return false; - } - - rcScopedDelete tverts((int*)rcAlloc(sizeof(int)*nhole*4, RC_ALLOC_TEMP)); - if (!tverts) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'tverts' (%d).", nhole*4); - return false; - } - - rcScopedDelete thole((int*)rcAlloc(sizeof(int)*nhole, RC_ALLOC_TEMP)); - if (!thole) - { - ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'thole' (%d).", nhole); - return false; - } - - // Generate temp vertex array for triangulation. - for (int i = 0; i < nhole; ++i) - { - const int pi = hole[i]; - tverts[i*4+0] = mesh.verts[pi*3+0]; - tverts[i*4+1] = mesh.verts[pi*3+1]; - tverts[i*4+2] = mesh.verts[pi*3+2]; - tverts[i*4+3] = 0; - thole[i] = i; - } - - // Triangulate the hole. - int ntris = triangulate(nhole, &tverts[0], &thole[0], tris); - if (ntris < 0) - { - ntris = -ntris; - ctx->log(RC_LOG_WARNING, "removeVertex: triangulate() returned bad results."); - } - - // Merge the hole triangles back to polygons. - rcScopedDelete polys((unsigned short*)rcAlloc(sizeof(unsigned short)*(ntris+1)*nvp, RC_ALLOC_TEMP)); - if (!polys) - { - ctx->log(RC_LOG_ERROR, "removeVertex: Out of memory 'polys' (%d).", (ntris+1)*nvp); - return false; - } - rcScopedDelete pregs((unsigned short*)rcAlloc(sizeof(unsigned short)*ntris, RC_ALLOC_TEMP)); - if (!pregs) - { - ctx->log(RC_LOG_ERROR, "removeVertex: Out of memory 'pregs' (%d).", ntris); - return false; - } - rcScopedDelete pareas((unsigned char*)rcAlloc(sizeof(unsigned char)*ntris, RC_ALLOC_TEMP)); - if (!pareas) - { - ctx->log(RC_LOG_ERROR, "removeVertex: Out of memory 'pareas' (%d).", ntris); - return false; - } - - unsigned short* tmpPoly = &polys[ntris*nvp]; - - // Build initial polygons. - int npolys = 0; - memset(polys, 0xff, ntris*nvp*sizeof(unsigned short)); - for (int j = 0; j < ntris; ++j) - { - int* t = &tris[j*3]; - if (t[0] != t[1] && t[0] != t[2] && t[1] != t[2]) - { - polys[npolys*nvp+0] = (unsigned short)hole[t[0]]; - polys[npolys*nvp+1] = (unsigned short)hole[t[1]]; - polys[npolys*nvp+2] = (unsigned short)hole[t[2]]; - - // If this polygon covers multiple region types then - // mark it as such - if (hreg[t[0]] != hreg[t[1]] || hreg[t[1]] != hreg[t[2]]) - pregs[npolys] = RC_MULTIPLE_REGS; - else - pregs[npolys] = (unsigned short)hreg[t[0]]; - - pareas[npolys] = (unsigned char)harea[t[0]]; - npolys++; - } - } - if (!npolys) - return true; - - // Merge polygons. - if (nvp > 3) - { - for (;;) - { - // Find best polygons to merge. - int bestMergeVal = 0; - int bestPa = 0, bestPb = 0, bestEa = 0, bestEb = 0; - - for (int j = 0; j < npolys-1; ++j) - { - unsigned short* pj = &polys[j*nvp]; - for (int k = j+1; k < npolys; ++k) - { - unsigned short* pk = &polys[k*nvp]; - int ea, eb; - int v = getPolyMergeValue(pj, pk, mesh.verts, ea, eb, nvp); - if (v > bestMergeVal) - { - bestMergeVal = v; - bestPa = j; - bestPb = k; - bestEa = ea; - bestEb = eb; - } - } - } - - if (bestMergeVal > 0) - { - // Found best, merge. - unsigned short* pa = &polys[bestPa*nvp]; - unsigned short* pb = &polys[bestPb*nvp]; - mergePolyVerts(pa, pb, bestEa, bestEb, tmpPoly, nvp); - if (pregs[bestPa] != pregs[bestPb]) - pregs[bestPa] = RC_MULTIPLE_REGS; - - unsigned short* last = &polys[(npolys-1)*nvp]; - if (pb != last) - memcpy(pb, last, sizeof(unsigned short)*nvp); - pregs[bestPb] = pregs[npolys-1]; - pareas[bestPb] = pareas[npolys-1]; - npolys--; - } - else - { - // Could not merge any polygons, stop. - break; - } - } - } - - // Store polygons. - for (int i = 0; i < npolys; ++i) - { - if (mesh.npolys >= maxTris) break; - unsigned short* p = &mesh.polys[mesh.npolys*nvp*2]; - memset(p,0xff,sizeof(unsigned short)*nvp*2); - for (int j = 0; j < nvp; ++j) - p[j] = polys[i*nvp+j]; - mesh.regs[mesh.npolys] = pregs[i]; - mesh.areas[mesh.npolys] = pareas[i]; - mesh.npolys++; - if (mesh.npolys > maxTris) - { - ctx->log(RC_LOG_ERROR, "removeVertex: Too many polygons %d (max:%d).", mesh.npolys, maxTris); - return false; - } - } - - return true; -} - -/// @par -/// -/// @note If the mesh data is to be used to construct a Detour navigation mesh, then the upper -/// limit must be retricted to <= #DT_VERTS_PER_POLYGON. -/// -/// @see rcAllocPolyMesh, rcContourSet, rcPolyMesh, rcConfig -bool rcBuildPolyMesh(rcContext* ctx, const rcContourSet& cset, const int nvp, rcPolyMesh& mesh) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_POLYMESH); - - rcVcopy(mesh.bmin, cset.bmin); - rcVcopy(mesh.bmax, cset.bmax); - mesh.cs = cset.cs; - mesh.ch = cset.ch; - mesh.borderSize = cset.borderSize; - mesh.maxEdgeError = cset.maxError; - - int maxVertices = 0; - int maxTris = 0; - int maxVertsPerCont = 0; - for (int i = 0; i < cset.nconts; ++i) - { - // Skip null contours. - if (cset.conts[i].nverts < 3) continue; - maxVertices += cset.conts[i].nverts; - maxTris += cset.conts[i].nverts - 2; - maxVertsPerCont = rcMax(maxVertsPerCont, cset.conts[i].nverts); - } - - if (maxVertices >= 0xfffe) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Too many vertices %d.", maxVertices); - return false; - } - - rcScopedDelete vflags((unsigned char*)rcAlloc(sizeof(unsigned char)*maxVertices, RC_ALLOC_TEMP)); - if (!vflags) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'vflags' (%d).", maxVertices); - return false; - } - memset(vflags, 0, maxVertices); - - mesh.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxVertices*3, RC_ALLOC_PERM); - if (!mesh.verts) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices); - return false; - } - mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris*nvp*2, RC_ALLOC_PERM); - if (!mesh.polys) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.polys' (%d).", maxTris*nvp*2); - return false; - } - mesh.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris, RC_ALLOC_PERM); - if (!mesh.regs) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.regs' (%d).", maxTris); - return false; - } - mesh.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxTris, RC_ALLOC_PERM); - if (!mesh.areas) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.areas' (%d).", maxTris); - return false; - } - - mesh.nverts = 0; - mesh.npolys = 0; - mesh.nvp = nvp; - mesh.maxpolys = maxTris; - - memset(mesh.verts, 0, sizeof(unsigned short)*maxVertices*3); - memset(mesh.polys, 0xff, sizeof(unsigned short)*maxTris*nvp*2); - memset(mesh.regs, 0, sizeof(unsigned short)*maxTris); - memset(mesh.areas, 0, sizeof(unsigned char)*maxTris); - - rcScopedDelete nextVert((int*)rcAlloc(sizeof(int)*maxVertices, RC_ALLOC_TEMP)); - if (!nextVert) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'nextVert' (%d).", maxVertices); - return false; - } - memset(nextVert, 0, sizeof(int)*maxVertices); - - rcScopedDelete firstVert((int*)rcAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RC_ALLOC_TEMP)); - if (!firstVert) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'firstVert' (%d).", VERTEX_BUCKET_COUNT); - return false; - } - for (int i = 0; i < VERTEX_BUCKET_COUNT; ++i) - firstVert[i] = -1; - - rcScopedDelete indices((int*)rcAlloc(sizeof(int)*maxVertsPerCont, RC_ALLOC_TEMP)); - if (!indices) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'indices' (%d).", maxVertsPerCont); - return false; - } - rcScopedDelete tris((int*)rcAlloc(sizeof(int)*maxVertsPerCont*3, RC_ALLOC_TEMP)); - if (!tris) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'tris' (%d).", maxVertsPerCont*3); - return false; - } - rcScopedDelete polys((unsigned short*)rcAlloc(sizeof(unsigned short)*(maxVertsPerCont+1)*nvp, RC_ALLOC_TEMP)); - if (!polys) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'polys' (%d).", maxVertsPerCont*nvp); - return false; - } - unsigned short* tmpPoly = &polys[maxVertsPerCont*nvp]; - - for (int i = 0; i < cset.nconts; ++i) - { - rcContour& cont = cset.conts[i]; - - // Skip null contours. - if (cont.nverts < 3) - continue; - - // Triangulate contour - for (int j = 0; j < cont.nverts; ++j) - indices[j] = j; - - int ntris = triangulate(cont.nverts, cont.verts, &indices[0], &tris[0]); - if (ntris <= 0) - { - // Bad triangulation, should not happen. -/* printf("\tconst float bmin[3] = {%ff,%ff,%ff};\n", cset.bmin[0], cset.bmin[1], cset.bmin[2]); - printf("\tconst float cs = %ff;\n", cset.cs); - printf("\tconst float ch = %ff;\n", cset.ch); - printf("\tconst int verts[] = {\n"); - for (int k = 0; k < cont.nverts; ++k) - { - const int* v = &cont.verts[k*4]; - printf("\t\t%d,%d,%d,%d,\n", v[0], v[1], v[2], v[3]); - } - printf("\t};\n\tconst int nverts = sizeof(verts)/(sizeof(int)*4);\n");*/ - ctx->log(RC_LOG_WARNING, "rcBuildPolyMesh: Bad triangulation Contour %d.", i); - ntris = -ntris; - } - - // Add and merge vertices. - for (int j = 0; j < cont.nverts; ++j) - { - const int* v = &cont.verts[j*4]; - indices[j] = addVertex((unsigned short)v[0], (unsigned short)v[1], (unsigned short)v[2], - mesh.verts, firstVert, nextVert, mesh.nverts); - if (v[3] & RC_BORDER_VERTEX) - { - // This vertex should be removed. - vflags[indices[j]] = 1; - } - } - - // Build initial polygons. - int npolys = 0; - memset(polys, 0xff, maxVertsPerCont*nvp*sizeof(unsigned short)); - for (int j = 0; j < ntris; ++j) - { - int* t = &tris[j*3]; - if (t[0] != t[1] && t[0] != t[2] && t[1] != t[2]) - { - polys[npolys*nvp+0] = (unsigned short)indices[t[0]]; - polys[npolys*nvp+1] = (unsigned short)indices[t[1]]; - polys[npolys*nvp+2] = (unsigned short)indices[t[2]]; - npolys++; - } - } - if (!npolys) - continue; - - // Merge polygons. - if (nvp > 3) - { - for(;;) - { - // Find best polygons to merge. - int bestMergeVal = 0; - int bestPa = 0, bestPb = 0, bestEa = 0, bestEb = 0; - - for (int j = 0; j < npolys-1; ++j) - { - unsigned short* pj = &polys[j*nvp]; - for (int k = j+1; k < npolys; ++k) - { - unsigned short* pk = &polys[k*nvp]; - int ea, eb; - int v = getPolyMergeValue(pj, pk, mesh.verts, ea, eb, nvp); - if (v > bestMergeVal) - { - bestMergeVal = v; - bestPa = j; - bestPb = k; - bestEa = ea; - bestEb = eb; - } - } - } - - if (bestMergeVal > 0) - { - // Found best, merge. - unsigned short* pa = &polys[bestPa*nvp]; - unsigned short* pb = &polys[bestPb*nvp]; - mergePolyVerts(pa, pb, bestEa, bestEb, tmpPoly, nvp); - unsigned short* lastPoly = &polys[(npolys-1)*nvp]; - if (pb != lastPoly) - memcpy(pb, lastPoly, sizeof(unsigned short)*nvp); - npolys--; - } - else - { - // Could not merge any polygons, stop. - break; - } - } - } - - // Store polygons. - for (int j = 0; j < npolys; ++j) - { - unsigned short* p = &mesh.polys[mesh.npolys*nvp*2]; - unsigned short* q = &polys[j*nvp]; - for (int k = 0; k < nvp; ++k) - p[k] = q[k]; - mesh.regs[mesh.npolys] = cont.reg; - mesh.areas[mesh.npolys] = cont.area; - mesh.npolys++; - if (mesh.npolys > maxTris) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Too many polygons %d (max:%d).", mesh.npolys, maxTris); - return false; - } - } - } - - - // Remove edge vertices. - for (int i = 0; i < mesh.nverts; ++i) - { - if (vflags[i]) - { - if (!canRemoveVertex(ctx, mesh, (unsigned short)i)) - continue; - if (!removeVertex(ctx, mesh, (unsigned short)i, maxTris)) - { - // Failed to remove vertex - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Failed to remove edge vertex %d.", i); - return false; - } - // Remove vertex - // Note: mesh.nverts is already decremented inside removeVertex()! - // Fixup vertex flags - for (int j = i; j < mesh.nverts; ++j) - vflags[j] = vflags[j+1]; - --i; - } - } - - // Calculate adjacency. - if (!buildMeshAdjacency(mesh.polys, mesh.npolys, mesh.nverts, nvp)) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Adjacency failed."); - return false; - } - - // Find portal edges - if (mesh.borderSize > 0) - { - const int w = cset.width; - const int h = cset.height; - for (int i = 0; i < mesh.npolys; ++i) - { - unsigned short* p = &mesh.polys[i*2*nvp]; - for (int j = 0; j < nvp; ++j) - { - if (p[j] == RC_MESH_NULL_IDX) break; - // Skip connected edges. - if (p[nvp+j] != RC_MESH_NULL_IDX) - continue; - int nj = j+1; - if (nj >= nvp || p[nj] == RC_MESH_NULL_IDX) nj = 0; - const unsigned short* va = &mesh.verts[p[j]*3]; - const unsigned short* vb = &mesh.verts[p[nj]*3]; - - if ((int)va[0] == 0 && (int)vb[0] == 0) - p[nvp+j] = 0x8000 | 0; - else if ((int)va[2] == h && (int)vb[2] == h) - p[nvp+j] = 0x8000 | 1; - else if ((int)va[0] == w && (int)vb[0] == w) - p[nvp+j] = 0x8000 | 2; - else if ((int)va[2] == 0 && (int)vb[2] == 0) - p[nvp+j] = 0x8000 | 3; - } - } - } - - // Just allocate the mesh flags array. The user is resposible to fill it. - mesh.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*mesh.npolys, RC_ALLOC_PERM); - if (!mesh.flags) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.flags' (%d).", mesh.npolys); - return false; - } - memset(mesh.flags, 0, sizeof(unsigned short) * mesh.npolys); - - if (mesh.nverts > 0xffff) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: The resulting mesh has too many vertices %d (max %d). Data can be corrupted.", mesh.nverts, 0xffff); - } - if (mesh.npolys > 0xffff) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: The resulting mesh has too many polygons %d (max %d). Data can be corrupted.", mesh.npolys, 0xffff); - } - - return true; -} - -/// @see rcAllocPolyMesh, rcPolyMesh -bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, rcPolyMesh& mesh) -{ - rcAssert(ctx); - - if (!nmeshes || !meshes) - return true; - - rcScopedTimer timer(ctx, RC_TIMER_MERGE_POLYMESH); - - mesh.nvp = meshes[0]->nvp; - mesh.cs = meshes[0]->cs; - mesh.ch = meshes[0]->ch; - rcVcopy(mesh.bmin, meshes[0]->bmin); - rcVcopy(mesh.bmax, meshes[0]->bmax); - - int maxVerts = 0; - int maxPolys = 0; - int maxVertsPerMesh = 0; - for (int i = 0; i < nmeshes; ++i) - { - rcVmin(mesh.bmin, meshes[i]->bmin); - rcVmax(mesh.bmax, meshes[i]->bmax); - maxVertsPerMesh = rcMax(maxVertsPerMesh, meshes[i]->nverts); - maxVerts += meshes[i]->nverts; - maxPolys += meshes[i]->npolys; - } - - mesh.nverts = 0; - mesh.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxVerts*3, RC_ALLOC_PERM); - if (!mesh.verts) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.verts' (%d).", maxVerts*3); - return false; - } - - mesh.npolys = 0; - mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxPolys*2*mesh.nvp, RC_ALLOC_PERM); - if (!mesh.polys) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.polys' (%d).", maxPolys*2*mesh.nvp); - return false; - } - memset(mesh.polys, 0xff, sizeof(unsigned short)*maxPolys*2*mesh.nvp); - - mesh.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxPolys, RC_ALLOC_PERM); - if (!mesh.regs) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.regs' (%d).", maxPolys); - return false; - } - memset(mesh.regs, 0, sizeof(unsigned short)*maxPolys); - - mesh.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxPolys, RC_ALLOC_PERM); - if (!mesh.areas) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.areas' (%d).", maxPolys); - return false; - } - memset(mesh.areas, 0, sizeof(unsigned char)*maxPolys); - - mesh.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxPolys, RC_ALLOC_PERM); - if (!mesh.flags) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.flags' (%d).", maxPolys); - return false; - } - memset(mesh.flags, 0, sizeof(unsigned short)*maxPolys); - - rcScopedDelete nextVert((int*)rcAlloc(sizeof(int)*maxVerts, RC_ALLOC_TEMP)); - if (!nextVert) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'nextVert' (%d).", maxVerts); - return false; - } - memset(nextVert, 0, sizeof(int)*maxVerts); - - rcScopedDelete firstVert((int*)rcAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RC_ALLOC_TEMP)); - if (!firstVert) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'firstVert' (%d).", VERTEX_BUCKET_COUNT); - return false; - } - for (int i = 0; i < VERTEX_BUCKET_COUNT; ++i) - firstVert[i] = -1; - - rcScopedDelete vremap((unsigned short*)rcAlloc(sizeof(unsigned short)*maxVertsPerMesh, RC_ALLOC_PERM)); - if (!vremap) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'vremap' (%d).", maxVertsPerMesh); - return false; - } - memset(vremap, 0, sizeof(unsigned short)*maxVertsPerMesh); - - for (int i = 0; i < nmeshes; ++i) - { - const rcPolyMesh* pmesh = meshes[i]; - - const unsigned short ox = (unsigned short)floorf((pmesh->bmin[0]-mesh.bmin[0])/mesh.cs+0.5f); - const unsigned short oz = (unsigned short)floorf((pmesh->bmin[2]-mesh.bmin[2])/mesh.cs+0.5f); - - bool isMinX = (ox == 0); - bool isMinZ = (oz == 0); - bool isMaxX = ((unsigned short)floorf((mesh.bmax[0] - pmesh->bmax[0]) / mesh.cs + 0.5f)) == 0; - bool isMaxZ = ((unsigned short)floorf((mesh.bmax[2] - pmesh->bmax[2]) / mesh.cs + 0.5f)) == 0; - bool isOnBorder = (isMinX || isMinZ || isMaxX || isMaxZ); - - for (int j = 0; j < pmesh->nverts; ++j) - { - unsigned short* v = &pmesh->verts[j*3]; - vremap[j] = addVertex(v[0]+ox, v[1], v[2]+oz, - mesh.verts, firstVert, nextVert, mesh.nverts); - } - - for (int j = 0; j < pmesh->npolys; ++j) - { - unsigned short* tgt = &mesh.polys[mesh.npolys*2*mesh.nvp]; - unsigned short* src = &pmesh->polys[j*2*mesh.nvp]; - mesh.regs[mesh.npolys] = pmesh->regs[j]; - mesh.areas[mesh.npolys] = pmesh->areas[j]; - mesh.flags[mesh.npolys] = pmesh->flags[j]; - mesh.npolys++; - for (int k = 0; k < mesh.nvp; ++k) - { - if (src[k] == RC_MESH_NULL_IDX) break; - tgt[k] = vremap[src[k]]; - } - - if (isOnBorder) - { - for (int k = mesh.nvp; k < mesh.nvp * 2; ++k) - { - if (src[k] & 0x8000 && src[k] != 0xffff) - { - unsigned short dir = src[k] & 0xf; - switch (dir) - { - case 0: // Portal x- - if (isMinX) - tgt[k] = src[k]; - break; - case 1: // Portal z+ - if (isMaxZ) - tgt[k] = src[k]; - break; - case 2: // Portal x+ - if (isMaxX) - tgt[k] = src[k]; - break; - case 3: // Portal z- - if (isMinZ) - tgt[k] = src[k]; - break; - } - } - } - } - } - } - - // Calculate adjacency. - if (!buildMeshAdjacency(mesh.polys, mesh.npolys, mesh.nverts, mesh.nvp)) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Adjacency failed."); - return false; - } - - if (mesh.nverts > 0xffff) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: The resulting mesh has too many vertices %d (max %d). Data can be corrupted.", mesh.nverts, 0xffff); - } - if (mesh.npolys > 0xffff) - { - ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: The resulting mesh has too many polygons %d (max %d). Data can be corrupted.", mesh.npolys, 0xffff); - } - - return true; -} - -bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) -{ - rcAssert(ctx); - - // Destination must be empty. - rcAssert(dst.verts == 0); - rcAssert(dst.polys == 0); - rcAssert(dst.regs == 0); - rcAssert(dst.areas == 0); - rcAssert(dst.flags == 0); - - dst.nverts = src.nverts; - dst.npolys = src.npolys; - dst.maxpolys = src.npolys; - dst.nvp = src.nvp; - rcVcopy(dst.bmin, src.bmin); - rcVcopy(dst.bmax, src.bmax); - dst.cs = src.cs; - dst.ch = src.ch; - dst.borderSize = src.borderSize; - dst.maxEdgeError = src.maxEdgeError; - - dst.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.nverts*3, RC_ALLOC_PERM); - if (!dst.verts) - { - ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.verts' (%d).", src.nverts*3); - return false; - } - memcpy(dst.verts, src.verts, sizeof(unsigned short)*src.nverts*3); - - dst.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys*2*src.nvp, RC_ALLOC_PERM); - if (!dst.polys) - { - ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.polys' (%d).", src.npolys*2*src.nvp); - return false; - } - memcpy(dst.polys, src.polys, sizeof(unsigned short)*src.npolys*2*src.nvp); - - dst.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys, RC_ALLOC_PERM); - if (!dst.regs) - { - ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.regs' (%d).", src.npolys); - return false; - } - memcpy(dst.regs, src.regs, sizeof(unsigned short)*src.npolys); - - dst.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*src.npolys, RC_ALLOC_PERM); - if (!dst.areas) - { - ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.areas' (%d).", src.npolys); - return false; - } - memcpy(dst.areas, src.areas, sizeof(unsigned char)*src.npolys); - - dst.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys, RC_ALLOC_PERM); - if (!dst.flags) - { - ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.flags' (%d).", src.npolys); - return false; - } - memcpy(dst.flags, src.flags, sizeof(unsigned short)*src.npolys); - - return true; -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastMeshDetail.cpp b/thirdparty/recastnavigation/Recast/Source/RecastMeshDetail.cpp deleted file mode 100644 index 40f5b8c..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastMeshDetail.cpp +++ /dev/null @@ -1,1463 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - - -static const unsigned RC_UNSET_HEIGHT = 0xffff; - -struct rcHeightPatch -{ - inline rcHeightPatch() : data(0), xmin(0), ymin(0), width(0), height(0) {} - inline ~rcHeightPatch() { rcFree(data); } - unsigned short* data; - int xmin, ymin, width, height; -}; - - -inline float vdot2(const float* a, const float* b) -{ - return a[0]*b[0] + a[2]*b[2]; -} - -inline float vdistSq2(const float* p, const float* q) -{ - const float dx = q[0] - p[0]; - const float dy = q[2] - p[2]; - return dx*dx + dy*dy; -} - -inline float vdist2(const float* p, const float* q) -{ - return sqrtf(vdistSq2(p,q)); -} - -inline float vcross2(const float* p1, const float* p2, const float* p3) -{ - const float u1 = p2[0] - p1[0]; - const float v1 = p2[2] - p1[2]; - const float u2 = p3[0] - p1[0]; - const float v2 = p3[2] - p1[2]; - return u1 * v2 - v1 * u2; -} - -static bool circumCircle(const float* p1, const float* p2, const float* p3, - float* c, float& r) -{ - static const float EPS = 1e-6f; - // Calculate the circle relative to p1, to avoid some precision issues. - const float v1[3] = {0,0,0}; - float v2[3], v3[3]; - rcVsub(v2, p2,p1); - rcVsub(v3, p3,p1); - - const float cp = vcross2(v1, v2, v3); - if (fabsf(cp) > EPS) - { - const float v1Sq = vdot2(v1,v1); - const float v2Sq = vdot2(v2,v2); - const float v3Sq = vdot2(v3,v3); - c[0] = (v1Sq*(v2[2]-v3[2]) + v2Sq*(v3[2]-v1[2]) + v3Sq*(v1[2]-v2[2])) / (2*cp); - c[1] = 0; - c[2] = (v1Sq*(v3[0]-v2[0]) + v2Sq*(v1[0]-v3[0]) + v3Sq*(v2[0]-v1[0])) / (2*cp); - r = vdist2(c, v1); - rcVadd(c, c, p1); - return true; - } - - rcVcopy(c, p1); - r = 0; - return false; -} - -static float distPtTri(const float* p, const float* a, const float* b, const float* c) -{ - float v0[3], v1[3], v2[3]; - rcVsub(v0, c,a); - rcVsub(v1, b,a); - rcVsub(v2, p,a); - - const float dot00 = vdot2(v0, v0); - const float dot01 = vdot2(v0, v1); - const float dot02 = vdot2(v0, v2); - const float dot11 = vdot2(v1, v1); - const float dot12 = vdot2(v1, v2); - - // Compute barycentric coordinates - const float invDenom = 1.0f / (dot00 * dot11 - dot01 * dot01); - const float u = (dot11 * dot02 - dot01 * dot12) * invDenom; - float v = (dot00 * dot12 - dot01 * dot02) * invDenom; - - // If point lies inside the triangle, return interpolated y-coord. - static const float EPS = 1e-4f; - if (u >= -EPS && v >= -EPS && (u+v) <= 1+EPS) - { - const float y = a[1] + v0[1]*u + v1[1]*v; - return fabsf(y-p[1]); - } - return FLT_MAX; -} - -static float distancePtSeg(const float* pt, const float* p, const float* q) -{ - float pqx = q[0] - p[0]; - float pqy = q[1] - p[1]; - float pqz = q[2] - p[2]; - float dx = pt[0] - p[0]; - float dy = pt[1] - p[1]; - float dz = pt[2] - p[2]; - float d = pqx*pqx + pqy*pqy + pqz*pqz; - float t = pqx*dx + pqy*dy + pqz*dz; - if (d > 0) - t /= d; - if (t < 0) - t = 0; - else if (t > 1) - t = 1; - - dx = p[0] + t*pqx - pt[0]; - dy = p[1] + t*pqy - pt[1]; - dz = p[2] + t*pqz - pt[2]; - - return dx*dx + dy*dy + dz*dz; -} - -static float distancePtSeg2d(const float* pt, const float* p, const float* q) -{ - float pqx = q[0] - p[0]; - float pqz = q[2] - p[2]; - float dx = pt[0] - p[0]; - float dz = pt[2] - p[2]; - float d = pqx*pqx + pqz*pqz; - float t = pqx*dx + pqz*dz; - if (d > 0) - t /= d; - if (t < 0) - t = 0; - else if (t > 1) - t = 1; - - dx = p[0] + t*pqx - pt[0]; - dz = p[2] + t*pqz - pt[2]; - - return dx*dx + dz*dz; -} - -static float distToTriMesh(const float* p, const float* verts, const int /*nverts*/, const int* tris, const int ntris) -{ - float dmin = FLT_MAX; - for (int i = 0; i < ntris; ++i) - { - const float* va = &verts[tris[i*4+0]*3]; - const float* vb = &verts[tris[i*4+1]*3]; - const float* vc = &verts[tris[i*4+2]*3]; - float d = distPtTri(p, va,vb,vc); - if (d < dmin) - dmin = d; - } - if (dmin == FLT_MAX) return -1; - return dmin; -} - -static float distToPoly(int nvert, const float* verts, const float* p) -{ - - float dmin = FLT_MAX; - int i, j, c = 0; - for (i = 0, j = nvert-1; i < nvert; j = i++) - { - const float* vi = &verts[i*3]; - const float* vj = &verts[j*3]; - if (((vi[2] > p[2]) != (vj[2] > p[2])) && - (p[0] < (vj[0]-vi[0]) * (p[2]-vi[2]) / (vj[2]-vi[2]) + vi[0]) ) - c = !c; - dmin = rcMin(dmin, distancePtSeg2d(p, vj, vi)); - } - return c ? -dmin : dmin; -} - - -static unsigned short getHeight(const float fx, const float fy, const float fz, - const float /*cs*/, const float ics, const float ch, - const int radius, const rcHeightPatch& hp) -{ - int ix = (int)floorf(fx*ics + 0.01f); - int iz = (int)floorf(fz*ics + 0.01f); - ix = rcClamp(ix-hp.xmin, 0, hp.width - 1); - iz = rcClamp(iz-hp.ymin, 0, hp.height - 1); - unsigned short h = hp.data[ix+iz*hp.width]; - if (h == RC_UNSET_HEIGHT) - { - // Special case when data might be bad. - // Walk adjacent cells in a spiral up to 'radius', and look - // for a pixel which has a valid height. - int x = 1, z = 0, dx = 1, dz = 0; - int maxSize = radius * 2 + 1; - int maxIter = maxSize * maxSize - 1; - - int nextRingIterStart = 8; - int nextRingIters = 16; - - float dmin = FLT_MAX; - for (int i = 0; i < maxIter; i++) - { - const int nx = ix + x; - const int nz = iz + z; - - if (nx >= 0 && nz >= 0 && nx < hp.width && nz < hp.height) - { - const unsigned short nh = hp.data[nx + nz*hp.width]; - if (nh != RC_UNSET_HEIGHT) - { - const float d = fabsf(nh*ch - fy); - if (d < dmin) - { - h = nh; - dmin = d; - } - } - } - - // We are searching in a grid which looks approximately like this: - // __________ - // |2 ______ 2| - // | |1 __ 1| | - // | | |__| | | - // | |______| | - // |__________| - // We want to find the best height as close to the center cell as possible. This means that - // if we find a height in one of the neighbor cells to the center, we don't want to - // expand further out than the 8 neighbors - we want to limit our search to the closest - // of these "rings", but the best height in the ring. - // For example, the center is just 1 cell. We checked that at the entrance to the function. - // The next "ring" contains 8 cells (marked 1 above). Those are all the neighbors to the center cell. - // The next one again contains 16 cells (marked 2). In general each ring has 8 additional cells, which - // can be thought of as adding 2 cells around the "center" of each side when we expand the ring. - // Here we detect if we are about to enter the next ring, and if we are and we have found - // a height, we abort the search. - if (i + 1 == nextRingIterStart) - { - if (h != RC_UNSET_HEIGHT) - break; - - nextRingIterStart += nextRingIters; - nextRingIters += 8; - } - - if ((x == z) || ((x < 0) && (x == -z)) || ((x > 0) && (x == 1 - z))) - { - int tmp = dx; - dx = -dz; - dz = tmp; - } - x += dx; - z += dz; - } - } - return h; -} - - -enum EdgeValues -{ - EV_UNDEF = -1, - EV_HULL = -2 -}; - -static int findEdge(const int* edges, int nedges, int s, int t) -{ - for (int i = 0; i < nedges; i++) - { - const int* e = &edges[i*4]; - if ((e[0] == s && e[1] == t) || (e[0] == t && e[1] == s)) - return i; - } - return EV_UNDEF; -} - -static int addEdge(rcContext* ctx, int* edges, int& nedges, const int maxEdges, int s, int t, int l, int r) -{ - if (nedges >= maxEdges) - { - ctx->log(RC_LOG_ERROR, "addEdge: Too many edges (%d/%d).", nedges, maxEdges); - return EV_UNDEF; - } - - // Add edge if not already in the triangulation. - int e = findEdge(edges, nedges, s, t); - if (e == EV_UNDEF) - { - int* edge = &edges[nedges*4]; - edge[0] = s; - edge[1] = t; - edge[2] = l; - edge[3] = r; - return nedges++; - } - else - { - return EV_UNDEF; - } -} - -static void updateLeftFace(int* e, int s, int t, int f) -{ - if (e[0] == s && e[1] == t && e[2] == EV_UNDEF) - e[2] = f; - else if (e[1] == s && e[0] == t && e[3] == EV_UNDEF) - e[3] = f; -} - -static int overlapSegSeg2d(const float* a, const float* b, const float* c, const float* d) -{ - const float a1 = vcross2(a, b, d); - const float a2 = vcross2(a, b, c); - if (a1*a2 < 0.0f) - { - float a3 = vcross2(c, d, a); - float a4 = a3 + a2 - a1; - if (a3 * a4 < 0.0f) - return 1; - } - return 0; -} - -static bool overlapEdges(const float* pts, const int* edges, int nedges, int s1, int t1) -{ - for (int i = 0; i < nedges; ++i) - { - const int s0 = edges[i*4+0]; - const int t0 = edges[i*4+1]; - // Same or connected edges do not overlap. - if (s0 == s1 || s0 == t1 || t0 == s1 || t0 == t1) - continue; - if (overlapSegSeg2d(&pts[s0*3],&pts[t0*3], &pts[s1*3],&pts[t1*3])) - return true; - } - return false; -} - -static void completeFacet(rcContext* ctx, const float* pts, int npts, int* edges, int& nedges, const int maxEdges, int& nfaces, int e) -{ - static const float EPS = 1e-5f; - - int* edge = &edges[e*4]; - - // Cache s and t. - int s,t; - if (edge[2] == EV_UNDEF) - { - s = edge[0]; - t = edge[1]; - } - else if (edge[3] == EV_UNDEF) - { - s = edge[1]; - t = edge[0]; - } - else - { - // Edge already completed. - return; - } - - // Find best point on left of edge. - int pt = npts; - float c[3] = {0,0,0}; - float r = -1; - for (int u = 0; u < npts; ++u) - { - if (u == s || u == t) continue; - if (vcross2(&pts[s*3], &pts[t*3], &pts[u*3]) > EPS) - { - if (r < 0) - { - // The circle is not updated yet, do it now. - pt = u; - circumCircle(&pts[s*3], &pts[t*3], &pts[u*3], c, r); - continue; - } - const float d = vdist2(c, &pts[u*3]); - const float tol = 0.001f; - if (d > r*(1+tol)) - { - // Outside current circumcircle, skip. - continue; - } - else if (d < r*(1-tol)) - { - // Inside safe circumcircle, update circle. - pt = u; - circumCircle(&pts[s*3], &pts[t*3], &pts[u*3], c, r); - } - else - { - // Inside epsilon circum circle, do extra tests to make sure the edge is valid. - // s-u and t-u cannot overlap with s-pt nor t-pt if they exists. - if (overlapEdges(pts, edges, nedges, s,u)) - continue; - if (overlapEdges(pts, edges, nedges, t,u)) - continue; - // Edge is valid. - pt = u; - circumCircle(&pts[s*3], &pts[t*3], &pts[u*3], c, r); - } - } - } - - // Add new triangle or update edge info if s-t is on hull. - if (pt < npts) - { - // Update face information of edge being completed. - updateLeftFace(&edges[e*4], s, t, nfaces); - - // Add new edge or update face info of old edge. - e = findEdge(edges, nedges, pt, s); - if (e == EV_UNDEF) - addEdge(ctx, edges, nedges, maxEdges, pt, s, nfaces, EV_UNDEF); - else - updateLeftFace(&edges[e*4], pt, s, nfaces); - - // Add new edge or update face info of old edge. - e = findEdge(edges, nedges, t, pt); - if (e == EV_UNDEF) - addEdge(ctx, edges, nedges, maxEdges, t, pt, nfaces, EV_UNDEF); - else - updateLeftFace(&edges[e*4], t, pt, nfaces); - - nfaces++; - } - else - { - updateLeftFace(&edges[e*4], s, t, EV_HULL); - } -} - -static void delaunayHull(rcContext* ctx, const int npts, const float* pts, - const int nhull, const int* hull, - rcIntArray& tris, rcIntArray& edges) -{ - int nfaces = 0; - int nedges = 0; - const int maxEdges = npts*10; - edges.resize(maxEdges*4); - - for (int i = 0, j = nhull-1; i < nhull; j=i++) - addEdge(ctx, &edges[0], nedges, maxEdges, hull[j],hull[i], EV_HULL, EV_UNDEF); - - int currentEdge = 0; - while (currentEdge < nedges) - { - if (edges[currentEdge*4+2] == EV_UNDEF) - completeFacet(ctx, pts, npts, &edges[0], nedges, maxEdges, nfaces, currentEdge); - if (edges[currentEdge*4+3] == EV_UNDEF) - completeFacet(ctx, pts, npts, &edges[0], nedges, maxEdges, nfaces, currentEdge); - currentEdge++; - } - - // Create tris - tris.resize(nfaces*4); - for (int i = 0; i < nfaces*4; ++i) - tris[i] = -1; - - for (int i = 0; i < nedges; ++i) - { - const int* e = &edges[i*4]; - if (e[3] >= 0) - { - // Left face - int* t = &tris[e[3]*4]; - if (t[0] == -1) - { - t[0] = e[0]; - t[1] = e[1]; - } - else if (t[0] == e[1]) - t[2] = e[0]; - else if (t[1] == e[0]) - t[2] = e[1]; - } - if (e[2] >= 0) - { - // Right - int* t = &tris[e[2]*4]; - if (t[0] == -1) - { - t[0] = e[1]; - t[1] = e[0]; - } - else if (t[0] == e[0]) - t[2] = e[1]; - else if (t[1] == e[1]) - t[2] = e[0]; - } - } - - for (int i = 0; i < tris.size()/4; ++i) - { - int* t = &tris[i*4]; - if (t[0] == -1 || t[1] == -1 || t[2] == -1) - { - ctx->log(RC_LOG_WARNING, "delaunayHull: Removing dangling face %d [%d,%d,%d].", i, t[0],t[1],t[2]); - t[0] = tris[tris.size()-4]; - t[1] = tris[tris.size()-3]; - t[2] = tris[tris.size()-2]; - t[3] = tris[tris.size()-1]; - tris.resize(tris.size()-4); - --i; - } - } -} - -// Calculate minimum extend of the polygon. -static float polyMinExtent(const float* verts, const int nverts) -{ - float minDist = FLT_MAX; - for (int i = 0; i < nverts; i++) - { - const int ni = (i+1) % nverts; - const float* p1 = &verts[i*3]; - const float* p2 = &verts[ni*3]; - float maxEdgeDist = 0; - for (int j = 0; j < nverts; j++) - { - if (j == i || j == ni) continue; - float d = distancePtSeg2d(&verts[j*3], p1,p2); - maxEdgeDist = rcMax(maxEdgeDist, d); - } - minDist = rcMin(minDist, maxEdgeDist); - } - return rcSqrt(minDist); -} - -// Last time I checked the if version got compiled using cmov, which was a lot faster than module (with idiv). -inline int prev(int i, int n) { return i-1 >= 0 ? i-1 : n-1; } -inline int next(int i, int n) { return i+1 < n ? i+1 : 0; } - -static void triangulateHull(const int /*nverts*/, const float* verts, const int nhull, const int* hull, const int nin, rcIntArray& tris) -{ - int start = 0, left = 1, right = nhull-1; - - // Start from an ear with shortest perimeter. - // This tends to favor well formed triangles as starting point. - float dmin = FLT_MAX; - for (int i = 0; i < nhull; i++) - { - if (hull[i] >= nin) continue; // Ears are triangles with original vertices as middle vertex while others are actually line segments on edges - int pi = prev(i, nhull); - int ni = next(i, nhull); - const float* pv = &verts[hull[pi]*3]; - const float* cv = &verts[hull[i]*3]; - const float* nv = &verts[hull[ni]*3]; - const float d = vdist2(pv,cv) + vdist2(cv,nv) + vdist2(nv,pv); - if (d < dmin) - { - start = i; - left = ni; - right = pi; - dmin = d; - } - } - - // Add first triangle - tris.push(hull[start]); - tris.push(hull[left]); - tris.push(hull[right]); - tris.push(0); - - // Triangulate the polygon by moving left or right, - // depending on which triangle has shorter perimeter. - // This heuristic was chose emprically, since it seems - // handle tesselated straight edges well. - while (next(left, nhull) != right) - { - // Check to see if se should advance left or right. - int nleft = next(left, nhull); - int nright = prev(right, nhull); - - const float* cvleft = &verts[hull[left]*3]; - const float* nvleft = &verts[hull[nleft]*3]; - const float* cvright = &verts[hull[right]*3]; - const float* nvright = &verts[hull[nright]*3]; - const float dleft = vdist2(cvleft, nvleft) + vdist2(nvleft, cvright); - const float dright = vdist2(cvright, nvright) + vdist2(cvleft, nvright); - - if (dleft < dright) - { - tris.push(hull[left]); - tris.push(hull[nleft]); - tris.push(hull[right]); - tris.push(0); - left = nleft; - } - else - { - tris.push(hull[left]); - tris.push(hull[nright]); - tris.push(hull[right]); - tris.push(0); - right = nright; - } - } -} - - -inline float getJitterX(const int i) -{ - return (((i * 0x8da6b343) & 0xffff) / 65535.0f * 2.0f) - 1.0f; -} - -inline float getJitterY(const int i) -{ - return (((i * 0xd8163841) & 0xffff) / 65535.0f * 2.0f) - 1.0f; -} - -static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin, - const float sampleDist, const float sampleMaxError, - const int heightSearchRadius, const rcCompactHeightfield& chf, - const rcHeightPatch& hp, float* verts, int& nverts, - rcIntArray& tris, rcIntArray& edges, rcIntArray& samples) -{ - static const int MAX_VERTS = 127; - static const int MAX_TRIS = 255; // Max tris for delaunay is 2n-2-k (n=num verts, k=num hull verts). - static const int MAX_VERTS_PER_EDGE = 32; - float edge[(MAX_VERTS_PER_EDGE+1)*3]; - int hull[MAX_VERTS]; - int nhull = 0; - - nverts = nin; - - for (int i = 0; i < nin; ++i) - rcVcopy(&verts[i*3], &in[i*3]); - - edges.clear(); - tris.clear(); - - const float cs = chf.cs; - const float ics = 1.0f/cs; - - // Calculate minimum extents of the polygon based on input data. - float minExtent = polyMinExtent(verts, nverts); - - // Tessellate outlines. - // This is done in separate pass in order to ensure - // seamless height values across the ply boundaries. - if (sampleDist > 0) - { - for (int i = 0, j = nin-1; i < nin; j=i++) - { - const float* vj = &in[j*3]; - const float* vi = &in[i*3]; - bool swapped = false; - // Make sure the segments are always handled in same order - // using lexological sort or else there will be seams. - if (fabsf(vj[0]-vi[0]) < 1e-6f) - { - if (vj[2] > vi[2]) - { - rcSwap(vj,vi); - swapped = true; - } - } - else - { - if (vj[0] > vi[0]) - { - rcSwap(vj,vi); - swapped = true; - } - } - // Create samples along the edge. - float dx = vi[0] - vj[0]; - float dy = vi[1] - vj[1]; - float dz = vi[2] - vj[2]; - float d = sqrtf(dx*dx + dz*dz); - int nn = 1 + (int)floorf(d/sampleDist); - if (nn >= MAX_VERTS_PER_EDGE) nn = MAX_VERTS_PER_EDGE-1; - if (nverts+nn >= MAX_VERTS) - nn = MAX_VERTS-1-nverts; - - for (int k = 0; k <= nn; ++k) - { - float u = (float)k/(float)nn; - float* pos = &edge[k*3]; - pos[0] = vj[0] + dx*u; - pos[1] = vj[1] + dy*u; - pos[2] = vj[2] + dz*u; - pos[1] = getHeight(pos[0],pos[1],pos[2], cs, ics, chf.ch, heightSearchRadius, hp)*chf.ch; - } - // Simplify samples. - int idx[MAX_VERTS_PER_EDGE] = {0,nn}; - int nidx = 2; - for (int k = 0; k < nidx-1; ) - { - const int a = idx[k]; - const int b = idx[k+1]; - const float* va = &edge[a*3]; - const float* vb = &edge[b*3]; - // Find maximum deviation along the segment. - float maxd = 0; - int maxi = -1; - for (int m = a+1; m < b; ++m) - { - float dev = distancePtSeg(&edge[m*3],va,vb); - if (dev > maxd) - { - maxd = dev; - maxi = m; - } - } - // If the max deviation is larger than accepted error, - // add new point, else continue to next segment. - if (maxi != -1 && maxd > rcSqr(sampleMaxError)) - { - for (int m = nidx; m > k; --m) - idx[m] = idx[m-1]; - idx[k+1] = maxi; - nidx++; - } - else - { - ++k; - } - } - - hull[nhull++] = j; - // Add new vertices. - if (swapped) - { - for (int k = nidx-2; k > 0; --k) - { - rcVcopy(&verts[nverts*3], &edge[idx[k]*3]); - hull[nhull++] = nverts; - nverts++; - } - } - else - { - for (int k = 1; k < nidx-1; ++k) - { - rcVcopy(&verts[nverts*3], &edge[idx[k]*3]); - hull[nhull++] = nverts; - nverts++; - } - } - } - } - - // If the polygon minimum extent is small (sliver or small triangle), do not try to add internal points. - if (minExtent < sampleDist*2) - { - triangulateHull(nverts, verts, nhull, hull, nin, tris); - return true; - } - - // Tessellate the base mesh. - // We're using the triangulateHull instead of delaunayHull as it tends to - // create a bit better triangulation for long thin triangles when there - // are no internal points. - triangulateHull(nverts, verts, nhull, hull, nin, tris); - - if (tris.size() == 0) - { - // Could not triangulate the poly, make sure there is some valid data there. - ctx->log(RC_LOG_WARNING, "buildPolyDetail: Could not triangulate polygon (%d verts).", nverts); - return true; - } - - if (sampleDist > 0) - { - // Create sample locations in a grid. - float bmin[3], bmax[3]; - rcVcopy(bmin, in); - rcVcopy(bmax, in); - for (int i = 1; i < nin; ++i) - { - rcVmin(bmin, &in[i*3]); - rcVmax(bmax, &in[i*3]); - } - int x0 = (int)floorf(bmin[0]/sampleDist); - int x1 = (int)ceilf(bmax[0]/sampleDist); - int z0 = (int)floorf(bmin[2]/sampleDist); - int z1 = (int)ceilf(bmax[2]/sampleDist); - samples.clear(); - for (int z = z0; z < z1; ++z) - { - for (int x = x0; x < x1; ++x) - { - float pt[3]; - pt[0] = x*sampleDist; - pt[1] = (bmax[1]+bmin[1])*0.5f; - pt[2] = z*sampleDist; - // Make sure the samples are not too close to the edges. - if (distToPoly(nin,in,pt) > -sampleDist/2) continue; - samples.push(x); - samples.push(getHeight(pt[0], pt[1], pt[2], cs, ics, chf.ch, heightSearchRadius, hp)); - samples.push(z); - samples.push(0); // Not added - } - } - - // Add the samples starting from the one that has the most - // error. The procedure stops when all samples are added - // or when the max error is within treshold. - const int nsamples = samples.size()/4; - for (int iter = 0; iter < nsamples; ++iter) - { - if (nverts >= MAX_VERTS) - break; - - // Find sample with most error. - float bestpt[3] = {0,0,0}; - float bestd = 0; - int besti = -1; - for (int i = 0; i < nsamples; ++i) - { - const int* s = &samples[i*4]; - if (s[3]) continue; // skip added. - float pt[3]; - // The sample location is jittered to get rid of some bad triangulations - // which are cause by symmetrical data from the grid structure. - pt[0] = s[0]*sampleDist + getJitterX(i)*cs*0.1f; - pt[1] = s[1]*chf.ch; - pt[2] = s[2]*sampleDist + getJitterY(i)*cs*0.1f; - float d = distToTriMesh(pt, verts, nverts, &tris[0], tris.size()/4); - if (d < 0) continue; // did not hit the mesh. - if (d > bestd) - { - bestd = d; - besti = i; - rcVcopy(bestpt,pt); - } - } - // If the max error is within accepted threshold, stop tesselating. - if (bestd <= sampleMaxError || besti == -1) - break; - // Mark sample as added. - samples[besti*4+3] = 1; - // Add the new sample point. - rcVcopy(&verts[nverts*3],bestpt); - nverts++; - - // Create new triangulation. - // TODO: Incremental add instead of full rebuild. - edges.clear(); - tris.clear(); - delaunayHull(ctx, nverts, verts, nhull, hull, tris, edges); - } - } - - const int ntris = tris.size()/4; - if (ntris > MAX_TRIS) - { - tris.resize(MAX_TRIS*4); - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Shrinking triangle count from %d to max %d.", ntris, MAX_TRIS); - } - - return true; -} - -static void seedArrayWithPolyCenter(rcContext* ctx, const rcCompactHeightfield& chf, - const unsigned short* poly, const int npoly, - const unsigned short* verts, const int bs, - rcHeightPatch& hp, rcIntArray& array) -{ - // Note: Reads to the compact heightfield are offset by border size (bs) - // since border size offset is already removed from the polymesh vertices. - - static const int offset[9*2] = - { - 0,0, -1,-1, 0,-1, 1,-1, 1,0, 1,1, 0,1, -1,1, -1,0, - }; - - // Find cell closest to a poly vertex - int startCellX = 0, startCellY = 0, startSpanIndex = -1; - int dmin = RC_UNSET_HEIGHT; - for (int j = 0; j < npoly && dmin > 0; ++j) - { - for (int k = 0; k < 9 && dmin > 0; ++k) - { - const int ax = (int)verts[poly[j]*3+0] + offset[k*2+0]; - const int ay = (int)verts[poly[j]*3+1]; - const int az = (int)verts[poly[j]*3+2] + offset[k*2+1]; - if (ax < hp.xmin || ax >= hp.xmin+hp.width || - az < hp.ymin || az >= hp.ymin+hp.height) - continue; - - const rcCompactCell& c = chf.cells[(ax+bs)+(az+bs)*chf.width]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni && dmin > 0; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - int d = rcAbs(ay - (int)s.y); - if (d < dmin) - { - startCellX = ax; - startCellY = az; - startSpanIndex = i; - dmin = d; - } - } - } - } - - rcAssert(startSpanIndex != -1); - // Find center of the polygon - int pcx = 0, pcy = 0; - for (int j = 0; j < npoly; ++j) - { - pcx += (int)verts[poly[j]*3+0]; - pcy += (int)verts[poly[j]*3+2]; - } - pcx /= npoly; - pcy /= npoly; - - // Use seeds array as a stack for DFS - array.clear(); - array.push(startCellX); - array.push(startCellY); - array.push(startSpanIndex); - - int dirs[] = { 0, 1, 2, 3 }; - memset(hp.data, 0, sizeof(unsigned short)*hp.width*hp.height); - // DFS to move to the center. Note that we need a DFS here and can not just move - // directly towards the center without recording intermediate nodes, even though the polygons - // are convex. In very rare we can get stuck due to contour simplification if we do not - // record nodes. - int cx = -1, cy = -1, ci = -1; - while (true) - { - if (array.size() < 3) - { - ctx->log(RC_LOG_WARNING, "Walk towards polygon center failed to reach center"); - break; - } - - ci = array.pop(); - cy = array.pop(); - cx = array.pop(); - - if (cx == pcx && cy == pcy) - break; - - // If we are already at the correct X-position, prefer direction - // directly towards the center in the Y-axis; otherwise prefer - // direction in the X-axis - int directDir; - if (cx == pcx) - directDir = rcGetDirForOffset(0, pcy > cy ? 1 : -1); - else - directDir = rcGetDirForOffset(pcx > cx ? 1 : -1, 0); - - // Push the direct dir last so we start with this on next iteration - rcSwap(dirs[directDir], dirs[3]); - - const rcCompactSpan& cs = chf.spans[ci]; - for (int i = 0; i < 4; i++) - { - int dir = dirs[i]; - if (rcGetCon(cs, dir) == RC_NOT_CONNECTED) - continue; - - int newX = cx + rcGetDirOffsetX(dir); - int newY = cy + rcGetDirOffsetY(dir); - - int hpx = newX - hp.xmin; - int hpy = newY - hp.ymin; - if (hpx < 0 || hpx >= hp.width || hpy < 0 || hpy >= hp.height) - continue; - - if (hp.data[hpx+hpy*hp.width] != 0) - continue; - - hp.data[hpx+hpy*hp.width] = 1; - array.push(newX); - array.push(newY); - array.push((int)chf.cells[(newX+bs)+(newY+bs)*chf.width].index + rcGetCon(cs, dir)); - } - - rcSwap(dirs[directDir], dirs[3]); - } - - array.clear(); - // getHeightData seeds are given in coordinates with borders - array.push(cx+bs); - array.push(cy+bs); - array.push(ci); - - memset(hp.data, 0xff, sizeof(unsigned short)*hp.width*hp.height); - const rcCompactSpan& cs = chf.spans[ci]; - hp.data[cx-hp.xmin+(cy-hp.ymin)*hp.width] = cs.y; -} - - -static void push3(rcIntArray& queue, int v1, int v2, int v3) -{ - queue.resize(queue.size() + 3); - queue[queue.size() - 3] = v1; - queue[queue.size() - 2] = v2; - queue[queue.size() - 1] = v3; -} - -static void getHeightData(rcContext* ctx, const rcCompactHeightfield& chf, - const unsigned short* poly, const int npoly, - const unsigned short* verts, const int bs, - rcHeightPatch& hp, rcIntArray& queue, - int region) -{ - // Note: Reads to the compact heightfield are offset by border size (bs) - // since border size offset is already removed from the polymesh vertices. - - queue.clear(); - // Set all heights to RC_UNSET_HEIGHT. - memset(hp.data, 0xff, sizeof(unsigned short)*hp.width*hp.height); - - bool empty = true; - - // We cannot sample from this poly if it was created from polys - // of different regions. If it was then it could potentially be overlapping - // with polys of that region and the heights sampled here could be wrong. - if (region != RC_MULTIPLE_REGS) - { - // Copy the height from the same region, and mark region borders - // as seed points to fill the rest. - for (int hy = 0; hy < hp.height; hy++) - { - int y = hp.ymin + hy + bs; - for (int hx = 0; hx < hp.width; hx++) - { - int x = hp.xmin + hx + bs; - const rcCompactCell& c = chf.cells[x + y*chf.width]; - for (int i = (int)c.index, ni = (int)(c.index + c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - if (s.reg == region) - { - // Store height - hp.data[hx + hy*hp.width] = s.y; - empty = false; - - // If any of the neighbours is not in same region, - // add the current location as flood fill start - bool border = false; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax + ay*chf.width].index + rcGetCon(s, dir); - const rcCompactSpan& as = chf.spans[ai]; - if (as.reg != region) - { - border = true; - break; - } - } - } - if (border) - push3(queue, x, y, i); - break; - } - } - } - } - } - - // if the polygon does not contain any points from the current region (rare, but happens) - // or if it could potentially be overlapping polygons of the same region, - // then use the center as the seed point. - if (empty) - seedArrayWithPolyCenter(ctx, chf, poly, npoly, verts, bs, hp, queue); - - static const int RETRACT_SIZE = 256; - int head = 0; - - // We assume the seed is centered in the polygon, so a BFS to collect - // height data will ensure we do not move onto overlapping polygons and - // sample wrong heights. - while (head*3 < queue.size()) - { - int cx = queue[head*3+0]; - int cy = queue[head*3+1]; - int ci = queue[head*3+2]; - head++; - if (head >= RETRACT_SIZE) - { - head = 0; - if (queue.size() > RETRACT_SIZE*3) - memmove(&queue[0], &queue[RETRACT_SIZE*3], sizeof(int)*(queue.size()-RETRACT_SIZE*3)); - queue.resize(queue.size()-RETRACT_SIZE*3); - } - - const rcCompactSpan& cs = chf.spans[ci]; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(cs, dir) == RC_NOT_CONNECTED) continue; - - const int ax = cx + rcGetDirOffsetX(dir); - const int ay = cy + rcGetDirOffsetY(dir); - const int hx = ax - hp.xmin - bs; - const int hy = ay - hp.ymin - bs; - - if ((unsigned int)hx >= (unsigned int)hp.width || (unsigned int)hy >= (unsigned int)hp.height) - continue; - - if (hp.data[hx + hy*hp.width] != RC_UNSET_HEIGHT) - continue; - - const int ai = (int)chf.cells[ax + ay*chf.width].index + rcGetCon(cs, dir); - const rcCompactSpan& as = chf.spans[ai]; - - hp.data[hx + hy*hp.width] = as.y; - - push3(queue, ax, ay, ai); - } - } -} - -static unsigned char getEdgeFlags(const float* va, const float* vb, - const float* vpoly, const int npoly) -{ - // The flag returned by this function matches dtDetailTriEdgeFlags in Detour. - // Figure out if edge (va,vb) is part of the polygon boundary. - static const float thrSqr = rcSqr(0.001f); - for (int i = 0, j = npoly-1; i < npoly; j=i++) - { - if (distancePtSeg2d(va, &vpoly[j*3], &vpoly[i*3]) < thrSqr && - distancePtSeg2d(vb, &vpoly[j*3], &vpoly[i*3]) < thrSqr) - return 1; - } - return 0; -} - -static unsigned char getTriFlags(const float* va, const float* vb, const float* vc, - const float* vpoly, const int npoly) -{ - unsigned char flags = 0; - flags |= getEdgeFlags(va,vb,vpoly,npoly) << 0; - flags |= getEdgeFlags(vb,vc,vpoly,npoly) << 2; - flags |= getEdgeFlags(vc,va,vpoly,npoly) << 4; - return flags; -} - -/// @par -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// @see rcAllocPolyMeshDetail, rcPolyMesh, rcCompactHeightfield, rcPolyMeshDetail, rcConfig -bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompactHeightfield& chf, - const float sampleDist, const float sampleMaxError, - rcPolyMeshDetail& dmesh) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_POLYMESHDETAIL); - - if (mesh.nverts == 0 || mesh.npolys == 0) - return true; - - const int nvp = mesh.nvp; - const float cs = mesh.cs; - const float ch = mesh.ch; - const float* orig = mesh.bmin; - const int borderSize = mesh.borderSize; - const int heightSearchRadius = rcMax(1, (int)ceilf(mesh.maxEdgeError)); - - rcIntArray edges(64); - rcIntArray tris(512); - rcIntArray arr(512); - rcIntArray samples(512); - float verts[256*3]; - rcHeightPatch hp; - int nPolyVerts = 0; - int maxhw = 0, maxhh = 0; - - rcScopedDelete bounds((int*)rcAlloc(sizeof(int)*mesh.npolys*4, RC_ALLOC_TEMP)); - if (!bounds) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'bounds' (%d).", mesh.npolys*4); - return false; - } - rcScopedDelete poly((float*)rcAlloc(sizeof(float)*nvp*3, RC_ALLOC_TEMP)); - if (!poly) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'poly' (%d).", nvp*3); - return false; - } - - // Find max size for a polygon area. - for (int i = 0; i < mesh.npolys; ++i) - { - const unsigned short* p = &mesh.polys[i*nvp*2]; - int& xmin = bounds[i*4+0]; - int& xmax = bounds[i*4+1]; - int& ymin = bounds[i*4+2]; - int& ymax = bounds[i*4+3]; - xmin = chf.width; - xmax = 0; - ymin = chf.height; - ymax = 0; - for (int j = 0; j < nvp; ++j) - { - if(p[j] == RC_MESH_NULL_IDX) break; - const unsigned short* v = &mesh.verts[p[j]*3]; - xmin = rcMin(xmin, (int)v[0]); - xmax = rcMax(xmax, (int)v[0]); - ymin = rcMin(ymin, (int)v[2]); - ymax = rcMax(ymax, (int)v[2]); - nPolyVerts++; - } - xmin = rcMax(0,xmin-1); - xmax = rcMin(chf.width,xmax+1); - ymin = rcMax(0,ymin-1); - ymax = rcMin(chf.height,ymax+1); - if (xmin >= xmax || ymin >= ymax) continue; - maxhw = rcMax(maxhw, xmax-xmin); - maxhh = rcMax(maxhh, ymax-ymin); - } - - hp.data = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxhw*maxhh, RC_ALLOC_TEMP); - if (!hp.data) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'hp.data' (%d).", maxhw*maxhh); - return false; - } - - dmesh.nmeshes = mesh.npolys; - dmesh.nverts = 0; - dmesh.ntris = 0; - dmesh.meshes = (unsigned int*)rcAlloc(sizeof(unsigned int)*dmesh.nmeshes*4, RC_ALLOC_PERM); - if (!dmesh.meshes) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.meshes' (%d).", dmesh.nmeshes*4); - return false; - } - - int vcap = nPolyVerts+nPolyVerts/2; - int tcap = vcap*2; - - dmesh.nverts = 0; - dmesh.verts = (float*)rcAlloc(sizeof(float)*vcap*3, RC_ALLOC_PERM); - if (!dmesh.verts) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.verts' (%d).", vcap*3); - return false; - } - dmesh.ntris = 0; - dmesh.tris = (unsigned char*)rcAlloc(sizeof(unsigned char)*tcap*4, RC_ALLOC_PERM); - if (!dmesh.tris) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.tris' (%d).", tcap*4); - return false; - } - - for (int i = 0; i < mesh.npolys; ++i) - { - const unsigned short* p = &mesh.polys[i*nvp*2]; - - // Store polygon vertices for processing. - int npoly = 0; - for (int j = 0; j < nvp; ++j) - { - if(p[j] == RC_MESH_NULL_IDX) break; - const unsigned short* v = &mesh.verts[p[j]*3]; - poly[j*3+0] = v[0]*cs; - poly[j*3+1] = v[1]*ch; - poly[j*3+2] = v[2]*cs; - npoly++; - } - - // Get the height data from the area of the polygon. - hp.xmin = bounds[i*4+0]; - hp.ymin = bounds[i*4+2]; - hp.width = bounds[i*4+1]-bounds[i*4+0]; - hp.height = bounds[i*4+3]-bounds[i*4+2]; - getHeightData(ctx, chf, p, npoly, mesh.verts, borderSize, hp, arr, mesh.regs[i]); - - // Build detail mesh. - int nverts = 0; - if (!buildPolyDetail(ctx, poly, npoly, - sampleDist, sampleMaxError, - heightSearchRadius, chf, hp, - verts, nverts, tris, - edges, samples)) - { - return false; - } - - // Move detail verts to world space. - for (int j = 0; j < nverts; ++j) - { - verts[j*3+0] += orig[0]; - verts[j*3+1] += orig[1] + chf.ch; // Is this offset necessary? - verts[j*3+2] += orig[2]; - } - // Offset poly too, will be used to flag checking. - for (int j = 0; j < npoly; ++j) - { - poly[j*3+0] += orig[0]; - poly[j*3+1] += orig[1]; - poly[j*3+2] += orig[2]; - } - - // Store detail submesh. - const int ntris = tris.size()/4; - - dmesh.meshes[i*4+0] = (unsigned int)dmesh.nverts; - dmesh.meshes[i*4+1] = (unsigned int)nverts; - dmesh.meshes[i*4+2] = (unsigned int)dmesh.ntris; - dmesh.meshes[i*4+3] = (unsigned int)ntris; - - // Store vertices, allocate more memory if necessary. - if (dmesh.nverts+nverts > vcap) - { - while (dmesh.nverts+nverts > vcap) - vcap += 256; - - float* newv = (float*)rcAlloc(sizeof(float)*vcap*3, RC_ALLOC_PERM); - if (!newv) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'newv' (%d).", vcap*3); - return false; - } - if (dmesh.nverts) - memcpy(newv, dmesh.verts, sizeof(float)*3*dmesh.nverts); - rcFree(dmesh.verts); - dmesh.verts = newv; - } - for (int j = 0; j < nverts; ++j) - { - dmesh.verts[dmesh.nverts*3+0] = verts[j*3+0]; - dmesh.verts[dmesh.nverts*3+1] = verts[j*3+1]; - dmesh.verts[dmesh.nverts*3+2] = verts[j*3+2]; - dmesh.nverts++; - } - - // Store triangles, allocate more memory if necessary. - if (dmesh.ntris+ntris > tcap) - { - while (dmesh.ntris+ntris > tcap) - tcap += 256; - unsigned char* newt = (unsigned char*)rcAlloc(sizeof(unsigned char)*tcap*4, RC_ALLOC_PERM); - if (!newt) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'newt' (%d).", tcap*4); - return false; - } - if (dmesh.ntris) - memcpy(newt, dmesh.tris, sizeof(unsigned char)*4*dmesh.ntris); - rcFree(dmesh.tris); - dmesh.tris = newt; - } - for (int j = 0; j < ntris; ++j) - { - const int* t = &tris[j*4]; - dmesh.tris[dmesh.ntris*4+0] = (unsigned char)t[0]; - dmesh.tris[dmesh.ntris*4+1] = (unsigned char)t[1]; - dmesh.tris[dmesh.ntris*4+2] = (unsigned char)t[2]; - dmesh.tris[dmesh.ntris*4+3] = getTriFlags(&verts[t[0]*3], &verts[t[1]*3], &verts[t[2]*3], poly, npoly); - dmesh.ntris++; - } - } - - return true; -} - -/// @see rcAllocPolyMeshDetail, rcPolyMeshDetail -bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int nmeshes, rcPolyMeshDetail& mesh) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_MERGE_POLYMESHDETAIL); - - int maxVerts = 0; - int maxTris = 0; - int maxMeshes = 0; - - for (int i = 0; i < nmeshes; ++i) - { - if (!meshes[i]) continue; - maxVerts += meshes[i]->nverts; - maxTris += meshes[i]->ntris; - maxMeshes += meshes[i]->nmeshes; - } - - mesh.nmeshes = 0; - mesh.meshes = (unsigned int*)rcAlloc(sizeof(unsigned int)*maxMeshes*4, RC_ALLOC_PERM); - if (!mesh.meshes) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'pmdtl.meshes' (%d).", maxMeshes*4); - return false; - } - - mesh.ntris = 0; - mesh.tris = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxTris*4, RC_ALLOC_PERM); - if (!mesh.tris) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.tris' (%d).", maxTris*4); - return false; - } - - mesh.nverts = 0; - mesh.verts = (float*)rcAlloc(sizeof(float)*maxVerts*3, RC_ALLOC_PERM); - if (!mesh.verts) - { - ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.verts' (%d).", maxVerts*3); - return false; - } - - // Merge datas. - for (int i = 0; i < nmeshes; ++i) - { - rcPolyMeshDetail* dm = meshes[i]; - if (!dm) continue; - for (int j = 0; j < dm->nmeshes; ++j) - { - unsigned int* dst = &mesh.meshes[mesh.nmeshes*4]; - unsigned int* src = &dm->meshes[j*4]; - dst[0] = (unsigned int)mesh.nverts+src[0]; - dst[1] = src[1]; - dst[2] = (unsigned int)mesh.ntris+src[2]; - dst[3] = src[3]; - mesh.nmeshes++; - } - - for (int k = 0; k < dm->nverts; ++k) - { - rcVcopy(&mesh.verts[mesh.nverts*3], &dm->verts[k*3]); - mesh.nverts++; - } - for (int k = 0; k < dm->ntris; ++k) - { - mesh.tris[mesh.ntris*4+0] = dm->tris[k*4+0]; - mesh.tris[mesh.ntris*4+1] = dm->tris[k*4+1]; - mesh.tris[mesh.ntris*4+2] = dm->tris[k*4+2]; - mesh.tris[mesh.ntris*4+3] = dm->tris[k*4+3]; - mesh.ntris++; - } - } - - return true; -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastRasterization.cpp b/thirdparty/recastnavigation/Recast/Source/RecastRasterization.cpp deleted file mode 100644 index 2a4f619..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastRasterization.cpp +++ /dev/null @@ -1,556 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - -/// Check whether two bounding boxes overlap -/// -/// @param[in] aMin Min axis extents of bounding box A -/// @param[in] aMax Max axis extents of bounding box A -/// @param[in] bMin Min axis extents of bounding box B -/// @param[in] bMax Max axis extents of bounding box B -/// @returns true if the two bounding boxes overlap. False otherwise. -static bool overlapBounds(const float* aMin, const float* aMax, const float* bMin, const float* bMax) -{ - return - aMin[0] <= bMax[0] && aMax[0] >= bMin[0] && - aMin[1] <= bMax[1] && aMax[1] >= bMin[1] && - aMin[2] <= bMax[2] && aMax[2] >= bMin[2]; -} - -/// Allocates a new span in the heightfield. -/// Use a memory pool and free list to minimize actual allocations. -/// -/// @param[in] hf The heightfield -/// @returns A pointer to the allocated or re-used span memory. -static rcSpan* allocSpan(rcHeightfield& hf) -{ - // If necessary, allocate new page and update the freelist. - if (hf.freelist == NULL || hf.freelist->next == NULL) - { - // Create new page. - // Allocate memory for the new pool. - rcSpanPool* spanPool = (rcSpanPool*)rcAlloc(sizeof(rcSpanPool), RC_ALLOC_PERM); - if (spanPool == NULL) - { - return NULL; - } - - // Add the pool into the list of pools. - spanPool->next = hf.pools; - hf.pools = spanPool; - - // Add new spans to the free list. - rcSpan* freeList = hf.freelist; - rcSpan* head = &spanPool->items[0]; - rcSpan* it = &spanPool->items[RC_SPANS_PER_POOL]; - do - { - --it; - it->next = freeList; - freeList = it; - } - while (it != head); - hf.freelist = it; - } - - // Pop item from the front of the free list. - rcSpan* newSpan = hf.freelist; - hf.freelist = hf.freelist->next; - return newSpan; -} - -/// Releases the memory used by the span back to the heightfield, so it can be re-used for new spans. -/// @param[in] hf The heightfield. -/// @param[in] span A pointer to the span to free -static void freeSpan(rcHeightfield& hf, rcSpan* span) -{ - if (span == NULL) - { - return; - } - // Add the span to the front of the free list. - span->next = hf.freelist; - hf.freelist = span; -} - -/// Adds a span to the heightfield. If the new span overlaps existing spans, -/// it will merge the new span with the existing ones. -/// -/// @param[in] hf Heightfield to add spans to -/// @param[in] x The new span's column cell x index -/// @param[in] z The new span's column cell z index -/// @param[in] min The new span's minimum cell index -/// @param[in] max The new span's maximum cell index -/// @param[in] areaID The new span's area type ID -/// @param[in] flagMergeThreshold How close two spans maximum extents need to be to merge area type IDs -static bool addSpan(rcHeightfield& hf, - const int x, const int z, - const unsigned short min, const unsigned short max, - const unsigned char areaID, const int flagMergeThreshold) -{ - // Create the new span. - rcSpan* newSpan = allocSpan(hf); - if (newSpan == NULL) - { - return false; - } - newSpan->smin = min; - newSpan->smax = max; - newSpan->area = areaID; - newSpan->next = NULL; - - const int columnIndex = x + z * hf.width; - rcSpan* previousSpan = NULL; - rcSpan* currentSpan = hf.spans[columnIndex]; - - // Insert the new span, possibly merging it with existing spans. - while (currentSpan != NULL) - { - if (currentSpan->smin > newSpan->smax) - { - // Current span is completely after the new span, break. - break; - } - - if (currentSpan->smax < newSpan->smin) - { - // Current span is completely before the new span. Keep going. - previousSpan = currentSpan; - currentSpan = currentSpan->next; - } - else - { - // The new span overlaps with an existing span. Merge them. - if (currentSpan->smin < newSpan->smin) - { - newSpan->smin = currentSpan->smin; - } - if (currentSpan->smax > newSpan->smax) - { - newSpan->smax = currentSpan->smax; - } - - // Merge flags. - if (rcAbs((int)newSpan->smax - (int)currentSpan->smax) <= flagMergeThreshold) - { - // Higher area ID numbers indicate higher resolution priority. - newSpan->area = rcMax(newSpan->area, currentSpan->area); - } - - // Remove the current span since it's now merged with newSpan. - // Keep going because there might be other overlapping spans that also need to be merged. - rcSpan* next = currentSpan->next; - freeSpan(hf, currentSpan); - if (previousSpan) - { - previousSpan->next = next; - } - else - { - hf.spans[columnIndex] = next; - } - currentSpan = next; - } - } - - // Insert new span after prev - if (previousSpan != NULL) - { - newSpan->next = previousSpan->next; - previousSpan->next = newSpan; - } - else - { - // This span should go before the others in the list - newSpan->next = hf.spans[columnIndex]; - hf.spans[columnIndex] = newSpan; - } - - return true; -} - -bool rcAddSpan(rcContext* context, rcHeightfield& heightfield, - const int x, const int z, - const unsigned short spanMin, const unsigned short spanMax, - const unsigned char areaID, const int flagMergeThreshold) -{ - rcAssert(context); - - if (!addSpan(heightfield, x, z, spanMin, spanMax, areaID, flagMergeThreshold)) - { - context->log(RC_LOG_ERROR, "rcAddSpan: Out of memory."); - return false; - } - - return true; -} - -enum rcAxis -{ - RC_AXIS_X = 0, - RC_AXIS_Y = 1, - RC_AXIS_Z = 2 -}; - -/// Divides a convex polygon of max 12 vertices into two convex polygons -/// across a separating axis. -/// -/// @param[in] inVerts The input polygon vertices -/// @param[in] inVertsCount The number of input polygon vertices -/// @param[out] outVerts1 Resulting polygon 1's vertices -/// @param[out] outVerts1Count The number of resulting polygon 1 vertices -/// @param[out] outVerts2 Resulting polygon 2's vertices -/// @param[out] outVerts2Count The number of resulting polygon 2 vertices -/// @param[in] axisOffset THe offset along the specified axis -/// @param[in] axis The separating axis -static void dividePoly(const float* inVerts, int inVertsCount, - float* outVerts1, int* outVerts1Count, - float* outVerts2, int* outVerts2Count, - float axisOffset, rcAxis axis) -{ - rcAssert(inVertsCount <= 12); - - // How far positive or negative away from the separating axis is each vertex. - float inVertAxisDelta[12]; - for (int inVert = 0; inVert < inVertsCount; ++inVert) - { - inVertAxisDelta[inVert] = axisOffset - inVerts[inVert * 3 + axis]; - } - - int poly1Vert = 0; - int poly2Vert = 0; - for (int inVertA = 0, inVertB = inVertsCount - 1; inVertA < inVertsCount; inVertB = inVertA, ++inVertA) - { - // If the two vertices are on the same side of the separating axis - bool sameSide = (inVertAxisDelta[inVertA] >= 0) == (inVertAxisDelta[inVertB] >= 0); - - if (!sameSide) - { - float s = inVertAxisDelta[inVertB] / (inVertAxisDelta[inVertB] - inVertAxisDelta[inVertA]); - outVerts1[poly1Vert * 3 + 0] = inVerts[inVertB * 3 + 0] + (inVerts[inVertA * 3 + 0] - inVerts[inVertB * 3 + 0]) * s; - outVerts1[poly1Vert * 3 + 1] = inVerts[inVertB * 3 + 1] + (inVerts[inVertA * 3 + 1] - inVerts[inVertB * 3 + 1]) * s; - outVerts1[poly1Vert * 3 + 2] = inVerts[inVertB * 3 + 2] + (inVerts[inVertA * 3 + 2] - inVerts[inVertB * 3 + 2]) * s; - rcVcopy(&outVerts2[poly2Vert * 3], &outVerts1[poly1Vert * 3]); - poly1Vert++; - poly2Vert++; - - // add the inVertA point to the right polygon. Do NOT add points that are on the dividing line - // since these were already added above - if (inVertAxisDelta[inVertA] > 0) - { - rcVcopy(&outVerts1[poly1Vert * 3], &inVerts[inVertA * 3]); - poly1Vert++; - } - else if (inVertAxisDelta[inVertA] < 0) - { - rcVcopy(&outVerts2[poly2Vert * 3], &inVerts[inVertA * 3]); - poly2Vert++; - } - } - else - { - // add the inVertA point to the right polygon. Addition is done even for points on the dividing line - if (inVertAxisDelta[inVertA] >= 0) - { - rcVcopy(&outVerts1[poly1Vert * 3], &inVerts[inVertA * 3]); - poly1Vert++; - if (inVertAxisDelta[inVertA] != 0) - { - continue; - } - } - rcVcopy(&outVerts2[poly2Vert * 3], &inVerts[inVertA * 3]); - poly2Vert++; - } - } - - *outVerts1Count = poly1Vert; - *outVerts2Count = poly2Vert; -} - -/// Rasterize a single triangle to the heightfield. -/// -/// This code is extremely hot, so much care should be given to maintaining maximum perf here. -/// -/// @param[in] v0 Triangle vertex 0 -/// @param[in] v1 Triangle vertex 1 -/// @param[in] v2 Triangle vertex 2 -/// @param[in] areaID The area ID to assign to the rasterized spans -/// @param[in] hf Heightfield to rasterize into -/// @param[in] hfBBMin The min extents of the heightfield bounding box -/// @param[in] hfBBMax The max extents of the heightfield bounding box -/// @param[in] cellSize The x and z axis size of a voxel in the heightfield -/// @param[in] inverseCellSize 1 / cellSize -/// @param[in] inverseCellHeight 1 / cellHeight -/// @param[in] flagMergeThreshold The threshold in which area flags will be merged -/// @returns true if the operation completes successfully. false if there was an error adding spans to the heightfield. -static bool rasterizeTri(const float* v0, const float* v1, const float* v2, - const unsigned char areaID, rcHeightfield& hf, - const float* hfBBMin, const float* hfBBMax, - const float cellSize, const float inverseCellSize, const float inverseCellHeight, - const int flagMergeThreshold) -{ - // Calculate the bounding box of the triangle. - float triBBMin[3]; - rcVcopy(triBBMin, v0); - rcVmin(triBBMin, v1); - rcVmin(triBBMin, v2); - - float triBBMax[3]; - rcVcopy(triBBMax, v0); - rcVmax(triBBMax, v1); - rcVmax(triBBMax, v2); - - // If the triangle does not touch the bounding box of the heightfield, skip the triangle. - if (!overlapBounds(triBBMin, triBBMax, hfBBMin, hfBBMax)) - { - return true; - } - - const int w = hf.width; - const int h = hf.height; - const float by = hfBBMax[1] - hfBBMin[1]; - - // Calculate the footprint of the triangle on the grid's z-axis - int z0 = (int)((triBBMin[2] - hfBBMin[2]) * inverseCellSize); - int z1 = (int)((triBBMax[2] - hfBBMin[2]) * inverseCellSize); - - // use -1 rather than 0 to cut the polygon properly at the start of the tile - z0 = rcClamp(z0, -1, h - 1); - z1 = rcClamp(z1, 0, h - 1); - - // Clip the triangle into all grid cells it touches. - float buf[7 * 3 * 4]; - float* in = buf; - float* inRow = buf + 7 * 3; - float* p1 = inRow + 7 * 3; - float* p2 = p1 + 7 * 3; - - rcVcopy(&in[0], v0); - rcVcopy(&in[1 * 3], v1); - rcVcopy(&in[2 * 3], v2); - int nvRow; - int nvIn = 3; - - for (int z = z0; z <= z1; ++z) - { - // Clip polygon to row. Store the remaining polygon as well - const float cellZ = hfBBMin[2] + (float)z * cellSize; - dividePoly(in, nvIn, inRow, &nvRow, p1, &nvIn, cellZ + cellSize, RC_AXIS_Z); - rcSwap(in, p1); - - if (nvRow < 3) - { - continue; - } - if (z < 0) - { - continue; - } - - // find X-axis bounds of the row - float minX = inRow[0]; - float maxX = inRow[0]; - for (int vert = 1; vert < nvRow; ++vert) - { - if (minX > inRow[vert * 3]) - { - minX = inRow[vert * 3]; - } - if (maxX < inRow[vert * 3]) - { - maxX = inRow[vert * 3]; - } - } - int x0 = (int)((minX - hfBBMin[0]) * inverseCellSize); - int x1 = (int)((maxX - hfBBMin[0]) * inverseCellSize); - if (x1 < 0 || x0 >= w) - { - continue; - } - x0 = rcClamp(x0, -1, w - 1); - x1 = rcClamp(x1, 0, w - 1); - - int nv; - int nv2 = nvRow; - - for (int x = x0; x <= x1; ++x) - { - // Clip polygon to column. store the remaining polygon as well - const float cx = hfBBMin[0] + (float)x * cellSize; - dividePoly(inRow, nv2, p1, &nv, p2, &nv2, cx + cellSize, RC_AXIS_X); - rcSwap(inRow, p2); - - if (nv < 3) - { - continue; - } - if (x < 0) - { - continue; - } - - // Calculate min and max of the span. - float spanMin = p1[1]; - float spanMax = p1[1]; - for (int vert = 1; vert < nv; ++vert) - { - spanMin = rcMin(spanMin, p1[vert * 3 + 1]); - spanMax = rcMax(spanMax, p1[vert * 3 + 1]); - } - spanMin -= hfBBMin[1]; - spanMax -= hfBBMin[1]; - - // Skip the span if it's completely outside the heightfield bounding box - if (spanMax < 0.0f) - { - continue; - } - if (spanMin > by) - { - continue; - } - - // Clamp the span to the heightfield bounding box. - if (spanMin < 0.0f) - { - spanMin = 0; - } - if (spanMax > by) - { - spanMax = by; - } - - // Snap the span to the heightfield height grid. - unsigned short spanMinCellIndex = (unsigned short)rcClamp((int)floorf(spanMin * inverseCellHeight), 0, RC_SPAN_MAX_HEIGHT); - unsigned short spanMaxCellIndex = (unsigned short)rcClamp((int)ceilf(spanMax * inverseCellHeight), (int)spanMinCellIndex + 1, RC_SPAN_MAX_HEIGHT); - - if (!addSpan(hf, x, z, spanMinCellIndex, spanMaxCellIndex, areaID, flagMergeThreshold)) - { - return false; - } - } - } - - return true; -} - -bool rcRasterizeTriangle(rcContext* context, - const float* v0, const float* v1, const float* v2, - const unsigned char areaID, rcHeightfield& heightfield, const int flagMergeThreshold) -{ - rcAssert(context != NULL); - - rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); - - // Rasterize the single triangle. - const float inverseCellSize = 1.0f / heightfield.cs; - const float inverseCellHeight = 1.0f / heightfield.ch; - if (!rasterizeTri(v0, v1, v2, areaID, heightfield, heightfield.bmin, heightfield.bmax, heightfield.cs, inverseCellSize, inverseCellHeight, flagMergeThreshold)) - { - context->log(RC_LOG_ERROR, "rcRasterizeTriangle: Out of memory."); - return false; - } - - return true; -} - -bool rcRasterizeTriangles(rcContext* context, - const float* verts, const int /*nv*/, - const int* tris, const unsigned char* triAreaIDs, const int numTris, - rcHeightfield& heightfield, const int flagMergeThreshold) -{ - rcAssert(context != NULL); - - rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); - - // Rasterize the triangles. - const float inverseCellSize = 1.0f / heightfield.cs; - const float inverseCellHeight = 1.0f / heightfield.ch; - for (int triIndex = 0; triIndex < numTris; ++triIndex) - { - const float* v0 = &verts[tris[triIndex * 3 + 0] * 3]; - const float* v1 = &verts[tris[triIndex * 3 + 1] * 3]; - const float* v2 = &verts[tris[triIndex * 3 + 2] * 3]; - if (!rasterizeTri(v0, v1, v2, triAreaIDs[triIndex], heightfield, heightfield.bmin, heightfield.bmax, heightfield.cs, inverseCellSize, inverseCellHeight, flagMergeThreshold)) - { - context->log(RC_LOG_ERROR, "rcRasterizeTriangles: Out of memory."); - return false; - } - } - - return true; -} - -bool rcRasterizeTriangles(rcContext* context, - const float* verts, const int /*nv*/, - const unsigned short* tris, const unsigned char* triAreaIDs, const int numTris, - rcHeightfield& heightfield, const int flagMergeThreshold) -{ - rcAssert(context != NULL); - - rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); - - // Rasterize the triangles. - const float inverseCellSize = 1.0f / heightfield.cs; - const float inverseCellHeight = 1.0f / heightfield.ch; - for (int triIndex = 0; triIndex < numTris; ++triIndex) - { - const float* v0 = &verts[tris[triIndex * 3 + 0] * 3]; - const float* v1 = &verts[tris[triIndex * 3 + 1] * 3]; - const float* v2 = &verts[tris[triIndex * 3 + 2] * 3]; - if (!rasterizeTri(v0, v1, v2, triAreaIDs[triIndex], heightfield, heightfield.bmin, heightfield.bmax, heightfield.cs, inverseCellSize, inverseCellHeight, flagMergeThreshold)) - { - context->log(RC_LOG_ERROR, "rcRasterizeTriangles: Out of memory."); - return false; - } - } - - return true; -} - -bool rcRasterizeTriangles(rcContext* context, - const float* verts, const unsigned char* triAreaIDs, const int numTris, - rcHeightfield& heightfield, const int flagMergeThreshold) -{ - rcAssert(context != NULL); - - rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); - - // Rasterize the triangles. - const float inverseCellSize = 1.0f / heightfield.cs; - const float inverseCellHeight = 1.0f / heightfield.ch; - for (int triIndex = 0; triIndex < numTris; ++triIndex) - { - const float* v0 = &verts[(triIndex * 3 + 0) * 3]; - const float* v1 = &verts[(triIndex * 3 + 1) * 3]; - const float* v2 = &verts[(triIndex * 3 + 2) * 3]; - if (!rasterizeTri(v0, v1, v2, triAreaIDs[triIndex], heightfield, heightfield.bmin, heightfield.bmax, heightfield.cs, inverseCellSize, inverseCellHeight, flagMergeThreshold)) - { - context->log(RC_LOG_ERROR, "rcRasterizeTriangles: Out of memory."); - return false; - } - } - - return true; -} diff --git a/thirdparty/recastnavigation/Recast/Source/RecastRegion.cpp b/thirdparty/recastnavigation/Recast/Source/RecastRegion.cpp deleted file mode 100644 index 4a7e841..0000000 --- a/thirdparty/recastnavigation/Recast/Source/RecastRegion.cpp +++ /dev/null @@ -1,1811 +0,0 @@ -// -// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// 2. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// 3. This notice may not be removed or altered from any source distribution. -// - -#include -#include -#include -#include -#include -#include "Recast.h" -#include "RecastAlloc.h" -#include "RecastAssert.h" - -namespace -{ -struct LevelStackEntry -{ - LevelStackEntry(int x_, int y_, int index_) : x(x_), y(y_), index(index_) {} - int x; - int y; - int index; -}; -} // namespace - -static void calculateDistanceField(rcCompactHeightfield& chf, unsigned short* src, unsigned short& maxDist) -{ - const int w = chf.width; - const int h = chf.height; - - // Init distance and points. - for (int i = 0; i < chf.spanCount; ++i) - src[i] = 0xffff; - - // Mark boundary cells. - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - const unsigned char area = chf.areas[i]; - - int nc = 0; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - if (area == chf.areas[ai]) - nc++; - } - } - if (nc != 4) - src[i] = 0; - } - } - } - - - // Pass 1 - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - - if (rcGetCon(s, 0) != RC_NOT_CONNECTED) - { - // (-1,0) - const int ax = x + rcGetDirOffsetX(0); - const int ay = y + rcGetDirOffsetY(0); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 0); - const rcCompactSpan& as = chf.spans[ai]; - if (src[ai]+2 < src[i]) - src[i] = src[ai]+2; - - // (-1,-1) - if (rcGetCon(as, 3) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(3); - const int aay = ay + rcGetDirOffsetY(3); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 3); - if (src[aai]+3 < src[i]) - src[i] = src[aai]+3; - } - } - if (rcGetCon(s, 3) != RC_NOT_CONNECTED) - { - // (0,-1) - const int ax = x + rcGetDirOffsetX(3); - const int ay = y + rcGetDirOffsetY(3); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 3); - const rcCompactSpan& as = chf.spans[ai]; - if (src[ai]+2 < src[i]) - src[i] = src[ai]+2; - - // (1,-1) - if (rcGetCon(as, 2) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(2); - const int aay = ay + rcGetDirOffsetY(2); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 2); - if (src[aai]+3 < src[i]) - src[i] = src[aai]+3; - } - } - } - } - } - - // Pass 2 - for (int y = h-1; y >= 0; --y) - { - for (int x = w-1; x >= 0; --x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - - if (rcGetCon(s, 2) != RC_NOT_CONNECTED) - { - // (1,0) - const int ax = x + rcGetDirOffsetX(2); - const int ay = y + rcGetDirOffsetY(2); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 2); - const rcCompactSpan& as = chf.spans[ai]; - if (src[ai]+2 < src[i]) - src[i] = src[ai]+2; - - // (1,1) - if (rcGetCon(as, 1) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(1); - const int aay = ay + rcGetDirOffsetY(1); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 1); - if (src[aai]+3 < src[i]) - src[i] = src[aai]+3; - } - } - if (rcGetCon(s, 1) != RC_NOT_CONNECTED) - { - // (0,1) - const int ax = x + rcGetDirOffsetX(1); - const int ay = y + rcGetDirOffsetY(1); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 1); - const rcCompactSpan& as = chf.spans[ai]; - if (src[ai]+2 < src[i]) - src[i] = src[ai]+2; - - // (-1,1) - if (rcGetCon(as, 0) != RC_NOT_CONNECTED) - { - const int aax = ax + rcGetDirOffsetX(0); - const int aay = ay + rcGetDirOffsetY(0); - const int aai = (int)chf.cells[aax+aay*w].index + rcGetCon(as, 0); - if (src[aai]+3 < src[i]) - src[i] = src[aai]+3; - } - } - } - } - } - - maxDist = 0; - for (int i = 0; i < chf.spanCount; ++i) - maxDist = rcMax(src[i], maxDist); - -} - -static unsigned short* boxBlur(rcCompactHeightfield& chf, int thr, - unsigned short* src, unsigned short* dst) -{ - const int w = chf.width; - const int h = chf.height; - - thr *= 2; - - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - const unsigned short cd = src[i]; - if (cd <= thr) - { - dst[i] = cd; - continue; - } - - int d = (int)cd; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - d += (int)src[ai]; - - const rcCompactSpan& as = chf.spans[ai]; - const int dir2 = (dir+1) & 0x3; - if (rcGetCon(as, dir2) != RC_NOT_CONNECTED) - { - const int ax2 = ax + rcGetDirOffsetX(dir2); - const int ay2 = ay + rcGetDirOffsetY(dir2); - const int ai2 = (int)chf.cells[ax2+ay2*w].index + rcGetCon(as, dir2); - d += (int)src[ai2]; - } - else - { - d += cd; - } - } - else - { - d += cd*2; - } - } - dst[i] = (unsigned short)((d+5)/9); - } - } - } - return dst; -} - - -static bool floodRegion(int x, int y, int i, - unsigned short level, unsigned short r, - rcCompactHeightfield& chf, - unsigned short* srcReg, unsigned short* srcDist, - rcTempVector& stack) -{ - const int w = chf.width; - - const unsigned char area = chf.areas[i]; - - // Flood fill mark region. - stack.clear(); - stack.push_back(LevelStackEntry(x, y, i)); - srcReg[i] = r; - srcDist[i] = 0; - - unsigned short lev = level >= 2 ? level-2 : 0; - int count = 0; - - while (stack.size() > 0) - { - LevelStackEntry& back = stack.back(); - int cx = back.x; - int cy = back.y; - int ci = back.index; - stack.pop_back(); - - const rcCompactSpan& cs = chf.spans[ci]; - - // Check if any of the neighbours already have a valid region set. - unsigned short ar = 0; - for (int dir = 0; dir < 4; ++dir) - { - // 8 connected - if (rcGetCon(cs, dir) != RC_NOT_CONNECTED) - { - const int ax = cx + rcGetDirOffsetX(dir); - const int ay = cy + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(cs, dir); - if (chf.areas[ai] != area) - continue; - unsigned short nr = srcReg[ai]; - if (nr & RC_BORDER_REG) // Do not take borders into account. - continue; - if (nr != 0 && nr != r) - { - ar = nr; - break; - } - - const rcCompactSpan& as = chf.spans[ai]; - - const int dir2 = (dir+1) & 0x3; - if (rcGetCon(as, dir2) != RC_NOT_CONNECTED) - { - const int ax2 = ax + rcGetDirOffsetX(dir2); - const int ay2 = ay + rcGetDirOffsetY(dir2); - const int ai2 = (int)chf.cells[ax2+ay2*w].index + rcGetCon(as, dir2); - if (chf.areas[ai2] != area) - continue; - unsigned short nr2 = srcReg[ai2]; - if (nr2 != 0 && nr2 != r) - { - ar = nr2; - break; - } - } - } - } - if (ar != 0) - { - srcReg[ci] = 0; - continue; - } - - count++; - - // Expand neighbours. - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(cs, dir) != RC_NOT_CONNECTED) - { - const int ax = cx + rcGetDirOffsetX(dir); - const int ay = cy + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(cs, dir); - if (chf.areas[ai] != area) - continue; - if (chf.dist[ai] >= lev && srcReg[ai] == 0) - { - srcReg[ai] = r; - srcDist[ai] = 0; - stack.push_back(LevelStackEntry(ax, ay, ai)); - } - } - } - } - - return count > 0; -} - -// Struct to keep track of entries in the region table that have been changed. -struct DirtyEntry -{ - DirtyEntry(int index_, unsigned short region_, unsigned short distance2_) - : index(index_), region(region_), distance2(distance2_) {} - int index; - unsigned short region; - unsigned short distance2; -}; -static void expandRegions(int maxIter, unsigned short level, - rcCompactHeightfield& chf, - unsigned short* srcReg, unsigned short* srcDist, - rcTempVector& stack, - bool fillStack) -{ - const int w = chf.width; - const int h = chf.height; - - if (fillStack) - { - // Find cells revealed by the raised level. - stack.clear(); - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (chf.dist[i] >= level && srcReg[i] == 0 && chf.areas[i] != RC_NULL_AREA) - { - stack.push_back(LevelStackEntry(x, y, i)); - } - } - } - } - } - else // use cells in the input stack - { - // mark all cells which already have a region - for (int j=0; j dirtyEntries; - int iter = 0; - while (stack.size() > 0) - { - int failed = 0; - dirtyEntries.clear(); - - for (int j = 0; j < stack.size(); j++) - { - int x = stack[j].x; - int y = stack[j].y; - int i = stack[j].index; - if (i < 0) - { - failed++; - continue; - } - - unsigned short r = srcReg[i]; - unsigned short d2 = 0xffff; - const unsigned char area = chf.areas[i]; - const rcCompactSpan& s = chf.spans[i]; - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) == RC_NOT_CONNECTED) continue; - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - if (chf.areas[ai] != area) continue; - if (srcReg[ai] > 0 && (srcReg[ai] & RC_BORDER_REG) == 0) - { - if ((int)srcDist[ai]+2 < (int)d2) - { - r = srcReg[ai]; - d2 = srcDist[ai]+2; - } - } - } - if (r) - { - stack[j].index = -1; // mark as used - dirtyEntries.push_back(DirtyEntry(i, r, d2)); - } - else - { - failed++; - } - } - - // Copy entries that differ between src and dst to keep them in sync. - for (int i = 0; i < dirtyEntries.size(); i++) { - int idx = dirtyEntries[i].index; - srcReg[idx] = dirtyEntries[i].region; - srcDist[idx] = dirtyEntries[i].distance2; - } - - if (failed == stack.size()) - break; - - if (level > 0) - { - ++iter; - if (iter >= maxIter) - break; - } - } -} - - - -static void sortCellsByLevel(unsigned short startLevel, - rcCompactHeightfield& chf, - const unsigned short* srcReg, - unsigned int nbStacks, rcTempVector* stacks, - unsigned short loglevelsPerStack) // the levels per stack (2 in our case) as a bit shift -{ - const int w = chf.width; - const int h = chf.height; - startLevel = startLevel >> loglevelsPerStack; - - for (unsigned int j=0; j> loglevelsPerStack; - int sId = startLevel - level; - if (sId >= (int)nbStacks) - continue; - if (sId < 0) - sId = 0; - - stacks[sId].push_back(LevelStackEntry(x, y, i)); - } - } - } -} - - -static void appendStacks(const rcTempVector& srcStack, - rcTempVector& dstStack, - const unsigned short* srcReg) -{ - for (int j=0; j 1; ) - { - int ni = (i+1) % reg.connections.size(); - if (reg.connections[i] == reg.connections[ni]) - { - // Remove duplicate - for (int j = i; j < reg.connections.size()-1; ++j) - reg.connections[j] = reg.connections[j+1]; - reg.connections.pop(); - } - else - ++i; - } -} - -static void replaceNeighbour(rcRegion& reg, unsigned short oldId, unsigned short newId) -{ - bool neiChanged = false; - for (int i = 0; i < reg.connections.size(); ++i) - { - if (reg.connections[i] == oldId) - { - reg.connections[i] = newId; - neiChanged = true; - } - } - for (int i = 0; i < reg.floors.size(); ++i) - { - if (reg.floors[i] == oldId) - reg.floors[i] = newId; - } - if (neiChanged) - removeAdjacentNeighbours(reg); -} - -static bool canMergeWithRegion(const rcRegion& rega, const rcRegion& regb) -{ - if (rega.areaType != regb.areaType) - return false; - int n = 0; - for (int i = 0; i < rega.connections.size(); ++i) - { - if (rega.connections[i] == regb.id) - n++; - } - if (n > 1) - return false; - for (int i = 0; i < rega.floors.size(); ++i) - { - if (rega.floors[i] == regb.id) - return false; - } - return true; -} - -static void addUniqueFloorRegion(rcRegion& reg, int n) -{ - for (int i = 0; i < reg.floors.size(); ++i) - if (reg.floors[i] == n) - return; - reg.floors.push(n); -} - -static bool mergeRegions(rcRegion& rega, rcRegion& regb) -{ - unsigned short aid = rega.id; - unsigned short bid = regb.id; - - // Duplicate current neighbourhood. - rcIntArray acon; - acon.resize(rega.connections.size()); - for (int i = 0; i < rega.connections.size(); ++i) - acon[i] = rega.connections[i]; - rcIntArray& bcon = regb.connections; - - // Find insertion point on A. - int insa = -1; - for (int i = 0; i < acon.size(); ++i) - { - if (acon[i] == bid) - { - insa = i; - break; - } - } - if (insa == -1) - return false; - - // Find insertion point on B. - int insb = -1; - for (int i = 0; i < bcon.size(); ++i) - { - if (bcon[i] == aid) - { - insb = i; - break; - } - } - if (insb == -1) - return false; - - // Merge neighbours. - rega.connections.clear(); - for (int i = 0, ni = acon.size(); i < ni-1; ++i) - rega.connections.push(acon[(insa+1+i) % ni]); - - for (int i = 0, ni = bcon.size(); i < ni-1; ++i) - rega.connections.push(bcon[(insb+1+i) % ni]); - - removeAdjacentNeighbours(rega); - - for (int j = 0; j < regb.floors.size(); ++j) - addUniqueFloorRegion(rega, regb.floors[j]); - rega.spanCount += regb.spanCount; - regb.spanCount = 0; - regb.connections.resize(0); - - return true; -} - -static bool isRegionConnectedToBorder(const rcRegion& reg) -{ - // Region is connected to border if - // one of the neighbours is null id. - for (int i = 0; i < reg.connections.size(); ++i) - { - if (reg.connections[i] == 0) - return true; - } - return false; -} - -static bool isSolidEdge(rcCompactHeightfield& chf, const unsigned short* srcReg, - int x, int y, int i, int dir) -{ - const rcCompactSpan& s = chf.spans[i]; - unsigned short r = 0; - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(s, dir); - r = srcReg[ai]; - } - if (r == srcReg[i]) - return false; - return true; -} - -static void walkContour(int x, int y, int i, int dir, - rcCompactHeightfield& chf, - const unsigned short* srcReg, - rcIntArray& cont) -{ - int startDir = dir; - int starti = i; - - const rcCompactSpan& ss = chf.spans[i]; - unsigned short curReg = 0; - if (rcGetCon(ss, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(ss, dir); - curReg = srcReg[ai]; - } - cont.push(curReg); - - int iter = 0; - while (++iter < 40000) - { - const rcCompactSpan& s = chf.spans[i]; - - if (isSolidEdge(chf, srcReg, x, y, i, dir)) - { - // Choose the edge corner - unsigned short r = 0; - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*chf.width].index + rcGetCon(s, dir); - r = srcReg[ai]; - } - if (r != curReg) - { - curReg = r; - cont.push(curReg); - } - - dir = (dir+1) & 0x3; // Rotate CW - } - else - { - int ni = -1; - const int nx = x + rcGetDirOffsetX(dir); - const int ny = y + rcGetDirOffsetY(dir); - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const rcCompactCell& nc = chf.cells[nx+ny*chf.width]; - ni = (int)nc.index + rcGetCon(s, dir); - } - if (ni == -1) - { - // Should not happen. - return; - } - x = nx; - y = ny; - i = ni; - dir = (dir+3) & 0x3; // Rotate CCW - } - - if (starti == i && startDir == dir) - { - break; - } - } - - // Remove adjacent duplicates. - if (cont.size() > 1) - { - for (int j = 0; j < cont.size(); ) - { - int nj = (j+1) % cont.size(); - if (cont[j] == cont[nj]) - { - for (int k = j; k < cont.size()-1; ++k) - cont[k] = cont[k+1]; - cont.pop(); - } - else - ++j; - } - } -} - - -static bool mergeAndFilterRegions(rcContext* ctx, int minRegionArea, int mergeRegionSize, - unsigned short& maxRegionId, - rcCompactHeightfield& chf, - unsigned short* srcReg, rcIntArray& overlaps) -{ - const int w = chf.width; - const int h = chf.height; - - const int nreg = maxRegionId+1; - rcTempVector regions; - if (!regions.reserve(nreg)) { - ctx->log(RC_LOG_ERROR, "mergeAndFilterRegions: Out of memory 'regions' (%d).", nreg); - return false; - } - - // Construct regions - for (int i = 0; i < nreg; ++i) - regions.push_back(rcRegion((unsigned short) i)); - - // Find edge of a region and find connections around the contour. - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - unsigned short r = srcReg[i]; - if (r == 0 || r >= nreg) - continue; - - rcRegion& reg = regions[r]; - reg.spanCount++; - - // Update floors. - for (int j = (int)c.index; j < ni; ++j) - { - if (i == j) continue; - unsigned short floorId = srcReg[j]; - if (floorId == 0 || floorId >= nreg) - continue; - if (floorId == r) - reg.overlap = true; - addUniqueFloorRegion(reg, floorId); - } - - // Have found contour - if (reg.connections.size() > 0) - continue; - - reg.areaType = chf.areas[i]; - - // Check if this cell is next to a border. - int ndir = -1; - for (int dir = 0; dir < 4; ++dir) - { - if (isSolidEdge(chf, srcReg, x, y, i, dir)) - { - ndir = dir; - break; - } - } - - if (ndir != -1) - { - // The cell is at border. - // Walk around the contour to find all the neighbours. - walkContour(x, y, i, ndir, chf, srcReg, reg.connections); - } - } - } - } - - // Remove too small regions. - rcIntArray stack(32); - rcIntArray trace(32); - for (int i = 0; i < nreg; ++i) - { - rcRegion& reg = regions[i]; - if (reg.id == 0 || (reg.id & RC_BORDER_REG)) - continue; - if (reg.spanCount == 0) - continue; - if (reg.visited) - continue; - - // Count the total size of all the connected regions. - // Also keep track of the regions connects to a tile border. - bool connectsToBorder = false; - int spanCount = 0; - stack.clear(); - trace.clear(); - - reg.visited = true; - stack.push(i); - - while (stack.size()) - { - // Pop - int ri = stack.pop(); - - rcRegion& creg = regions[ri]; - - spanCount += creg.spanCount; - trace.push(ri); - - for (int j = 0; j < creg.connections.size(); ++j) - { - if (creg.connections[j] & RC_BORDER_REG) - { - connectsToBorder = true; - continue; - } - rcRegion& neireg = regions[creg.connections[j]]; - if (neireg.visited) - continue; - if (neireg.id == 0 || (neireg.id & RC_BORDER_REG)) - continue; - // Visit - stack.push(neireg.id); - neireg.visited = true; - } - } - - // If the accumulated regions size is too small, remove it. - // Do not remove areas which connect to tile borders - // as their size cannot be estimated correctly and removing them - // can potentially remove necessary areas. - if (spanCount < minRegionArea && !connectsToBorder) - { - // Kill all visited regions. - for (int j = 0; j < trace.size(); ++j) - { - regions[trace[j]].spanCount = 0; - regions[trace[j]].id = 0; - } - } - } - - // Merge too small regions to neighbour regions. - int mergeCount = 0 ; - do - { - mergeCount = 0; - for (int i = 0; i < nreg; ++i) - { - rcRegion& reg = regions[i]; - if (reg.id == 0 || (reg.id & RC_BORDER_REG)) - continue; - if (reg.overlap) - continue; - if (reg.spanCount == 0) - continue; - - // Check to see if the region should be merged. - if (reg.spanCount > mergeRegionSize && isRegionConnectedToBorder(reg)) - continue; - - // Small region with more than 1 connection. - // Or region which is not connected to a border at all. - // Find smallest neighbour region that connects to this one. - int smallest = 0xfffffff; - unsigned short mergeId = reg.id; - for (int j = 0; j < reg.connections.size(); ++j) - { - if (reg.connections[j] & RC_BORDER_REG) continue; - rcRegion& mreg = regions[reg.connections[j]]; - if (mreg.id == 0 || (mreg.id & RC_BORDER_REG) || mreg.overlap) continue; - if (mreg.spanCount < smallest && - canMergeWithRegion(reg, mreg) && - canMergeWithRegion(mreg, reg)) - { - smallest = mreg.spanCount; - mergeId = mreg.id; - } - } - // Found new id. - if (mergeId != reg.id) - { - unsigned short oldId = reg.id; - rcRegion& target = regions[mergeId]; - - // Merge neighbours. - if (mergeRegions(target, reg)) - { - // Fixup regions pointing to current region. - for (int j = 0; j < nreg; ++j) - { - if (regions[j].id == 0 || (regions[j].id & RC_BORDER_REG)) continue; - // If another region was already merged into current region - // change the nid of the previous region too. - if (regions[j].id == oldId) - regions[j].id = mergeId; - // Replace the current region with the new one if the - // current regions is neighbour. - replaceNeighbour(regions[j], oldId, mergeId); - } - mergeCount++; - } - } - } - } - while (mergeCount > 0); - - // Compress region Ids. - for (int i = 0; i < nreg; ++i) - { - regions[i].remap = false; - if (regions[i].id == 0) continue; // Skip nil regions. - if (regions[i].id & RC_BORDER_REG) continue; // Skip external regions. - regions[i].remap = true; - } - - unsigned short regIdGen = 0; - for (int i = 0; i < nreg; ++i) - { - if (!regions[i].remap) - continue; - unsigned short oldId = regions[i].id; - unsigned short newId = ++regIdGen; - for (int j = i; j < nreg; ++j) - { - if (regions[j].id == oldId) - { - regions[j].id = newId; - regions[j].remap = false; - } - } - } - maxRegionId = regIdGen; - - // Remap regions. - for (int i = 0; i < chf.spanCount; ++i) - { - if ((srcReg[i] & RC_BORDER_REG) == 0) - srcReg[i] = regions[srcReg[i]].id; - } - - // Return regions that we found to be overlapping. - for (int i = 0; i < nreg; ++i) - if (regions[i].overlap) - overlaps.push(regions[i].id); - - return true; -} - - -static void addUniqueConnection(rcRegion& reg, int n) -{ - for (int i = 0; i < reg.connections.size(); ++i) - if (reg.connections[i] == n) - return; - reg.connections.push(n); -} - -static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea, - unsigned short& maxRegionId, - rcCompactHeightfield& chf, - unsigned short* srcReg) -{ - const int w = chf.width; - const int h = chf.height; - - const int nreg = maxRegionId+1; - rcTempVector regions; - - // Construct regions - if (!regions.reserve(nreg)) { - ctx->log(RC_LOG_ERROR, "mergeAndFilterLayerRegions: Out of memory 'regions' (%d).", nreg); - return false; - } - for (int i = 0; i < nreg; ++i) - regions.push_back(rcRegion((unsigned short) i)); - - // Find region neighbours and overlapping regions. - rcIntArray lregs(32); - for (int y = 0; y < h; ++y) - { - for (int x = 0; x < w; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - lregs.clear(); - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - const unsigned short ri = srcReg[i]; - if (ri == 0 || ri >= nreg) continue; - rcRegion& reg = regions[ri]; - - reg.spanCount++; - - reg.ymin = rcMin(reg.ymin, s.y); - reg.ymax = rcMax(reg.ymax, s.y); - - // Collect all region layers. - lregs.push(ri); - - // Update neighbours - for (int dir = 0; dir < 4; ++dir) - { - if (rcGetCon(s, dir) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(dir); - const int ay = y + rcGetDirOffsetY(dir); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, dir); - const unsigned short rai = srcReg[ai]; - if (rai > 0 && rai < nreg && rai != ri) - addUniqueConnection(reg, rai); - if (rai & RC_BORDER_REG) - reg.connectsToBorder = true; - } - } - - } - - // Update overlapping regions. - for (int i = 0; i < lregs.size()-1; ++i) - { - for (int j = i+1; j < lregs.size(); ++j) - { - if (lregs[i] != lregs[j]) - { - rcRegion& ri = regions[lregs[i]]; - rcRegion& rj = regions[lregs[j]]; - addUniqueFloorRegion(ri, lregs[j]); - addUniqueFloorRegion(rj, lregs[i]); - } - } - } - - } - } - - // Create 2D layers from regions. - unsigned short layerId = 1; - - for (int i = 0; i < nreg; ++i) - regions[i].id = 0; - - // Merge montone regions to create non-overlapping areas. - rcIntArray stack(32); - for (int i = 1; i < nreg; ++i) - { - rcRegion& root = regions[i]; - // Skip already visited. - if (root.id != 0) - continue; - - // Start search. - root.id = layerId; - - stack.clear(); - stack.push(i); - - while (stack.size() > 0) - { - // Pop front - rcRegion& reg = regions[stack[0]]; - for (int j = 0; j < stack.size()-1; ++j) - stack[j] = stack[j+1]; - stack.resize(stack.size()-1); - - const int ncons = (int)reg.connections.size(); - for (int j = 0; j < ncons; ++j) - { - const int nei = reg.connections[j]; - rcRegion& regn = regions[nei]; - // Skip already visited. - if (regn.id != 0) - continue; - // Skip if the neighbour is overlapping root region. - bool overlap = false; - for (int k = 0; k < root.floors.size(); k++) - { - if (root.floors[k] == nei) - { - overlap = true; - break; - } - } - if (overlap) - continue; - - // Deepen - stack.push(nei); - - // Mark layer id - regn.id = layerId; - // Merge current layers to root. - for (int k = 0; k < regn.floors.size(); ++k) - addUniqueFloorRegion(root, regn.floors[k]); - root.ymin = rcMin(root.ymin, regn.ymin); - root.ymax = rcMax(root.ymax, regn.ymax); - root.spanCount += regn.spanCount; - regn.spanCount = 0; - root.connectsToBorder = root.connectsToBorder || regn.connectsToBorder; - } - } - - layerId++; - } - - // Remove small regions - for (int i = 0; i < nreg; ++i) - { - if (regions[i].spanCount > 0 && regions[i].spanCount < minRegionArea && !regions[i].connectsToBorder) - { - unsigned short reg = regions[i].id; - for (int j = 0; j < nreg; ++j) - if (regions[j].id == reg) - regions[j].id = 0; - } - } - - // Compress region Ids. - for (int i = 0; i < nreg; ++i) - { - regions[i].remap = false; - if (regions[i].id == 0) continue; // Skip nil regions. - if (regions[i].id & RC_BORDER_REG) continue; // Skip external regions. - regions[i].remap = true; - } - - unsigned short regIdGen = 0; - for (int i = 0; i < nreg; ++i) - { - if (!regions[i].remap) - continue; - unsigned short oldId = regions[i].id; - unsigned short newId = ++regIdGen; - for (int j = i; j < nreg; ++j) - { - if (regions[j].id == oldId) - { - regions[j].id = newId; - regions[j].remap = false; - } - } - } - maxRegionId = regIdGen; - - // Remap regions. - for (int i = 0; i < chf.spanCount; ++i) - { - if ((srcReg[i] & RC_BORDER_REG) == 0) - srcReg[i] = regions[srcReg[i]].id; - } - - return true; -} - - - -/// @par -/// -/// This is usually the second to the last step in creating a fully built -/// compact heightfield. This step is required before regions are built -/// using #rcBuildRegions or #rcBuildRegionsMonotone. -/// -/// After this step, the distance data is available via the rcCompactHeightfield::maxDistance -/// and rcCompactHeightfield::dist fields. -/// -/// @see rcCompactHeightfield, rcBuildRegions, rcBuildRegionsMonotone -bool rcBuildDistanceField(rcContext* ctx, rcCompactHeightfield& chf) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_DISTANCEFIELD); - - if (chf.dist) - { - rcFree(chf.dist); - chf.dist = 0; - } - - unsigned short* src = (unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP); - if (!src) - { - ctx->log(RC_LOG_ERROR, "rcBuildDistanceField: Out of memory 'src' (%d).", chf.spanCount); - return false; - } - unsigned short* dst = (unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP); - if (!dst) - { - ctx->log(RC_LOG_ERROR, "rcBuildDistanceField: Out of memory 'dst' (%d).", chf.spanCount); - rcFree(src); - return false; - } - - unsigned short maxDist = 0; - - { - rcScopedTimer timerDist(ctx, RC_TIMER_BUILD_DISTANCEFIELD_DIST); - - calculateDistanceField(chf, src, maxDist); - chf.maxDistance = maxDist; - } - - { - rcScopedTimer timerBlur(ctx, RC_TIMER_BUILD_DISTANCEFIELD_BLUR); - - // Blur - if (boxBlur(chf, 1, src, dst) != src) - rcSwap(src, dst); - - // Store distance. - chf.dist = src; - } - - rcFree(dst); - - return true; -} - -static void paintRectRegion(int minx, int maxx, int miny, int maxy, unsigned short regId, - rcCompactHeightfield& chf, unsigned short* srcReg) -{ - const int w = chf.width; - for (int y = miny; y < maxy; ++y) - { - for (int x = minx; x < maxx; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (chf.areas[i] != RC_NULL_AREA) - srcReg[i] = regId; - } - } - } -} - - -static const unsigned short RC_NULL_NEI = 0xffff; - -struct rcSweepSpan -{ - unsigned short rid; // row id - unsigned short id; // region id - unsigned short ns; // number samples - unsigned short nei; // neighbour id -}; - -/// @par -/// -/// Non-null regions will consist of connected, non-overlapping walkable spans that form a single contour. -/// Contours will form simple polygons. -/// -/// If multiple regions form an area that is smaller than @p minRegionArea, then all spans will be -/// re-assigned to the zero (null) region. -/// -/// Partitioning can result in smaller than necessary regions. @p mergeRegionArea helps -/// reduce unecessarily small regions. -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// The region data will be available via the rcCompactHeightfield::maxRegions -/// and rcCompactSpan::reg fields. -/// -/// @warning The distance field must be created using #rcBuildDistanceField before attempting to build regions. -/// -/// @see rcCompactHeightfield, rcCompactSpan, rcBuildDistanceField, rcBuildRegionsMonotone, rcConfig -bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, - const int borderSize, const int minRegionArea, const int mergeRegionArea) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_REGIONS); - - const int w = chf.width; - const int h = chf.height; - unsigned short id = 1; - - rcScopedDelete srcReg((unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP)); - if (!srcReg) - { - ctx->log(RC_LOG_ERROR, "rcBuildRegionsMonotone: Out of memory 'src' (%d).", chf.spanCount); - return false; - } - memset(srcReg,0,sizeof(unsigned short)*chf.spanCount); - - const int nsweeps = rcMax(chf.width,chf.height); - rcScopedDelete sweeps((rcSweepSpan*)rcAlloc(sizeof(rcSweepSpan)*nsweeps, RC_ALLOC_TEMP)); - if (!sweeps) - { - ctx->log(RC_LOG_ERROR, "rcBuildRegionsMonotone: Out of memory 'sweeps' (%d).", nsweeps); - return false; - } - - - // Mark border regions. - if (borderSize > 0) - { - // Make sure border will not overflow. - const int bw = rcMin(w, borderSize); - const int bh = rcMin(h, borderSize); - // Paint regions - paintRectRegion(0, bw, 0, h, id|RC_BORDER_REG, chf, srcReg); id++; - paintRectRegion(w-bw, w, 0, h, id|RC_BORDER_REG, chf, srcReg); id++; - paintRectRegion(0, w, 0, bh, id|RC_BORDER_REG, chf, srcReg); id++; - paintRectRegion(0, w, h-bh, h, id|RC_BORDER_REG, chf, srcReg); id++; - } - - chf.borderSize = borderSize; - - rcIntArray prev(256); - - // Sweep one line at a time. - for (int y = borderSize; y < h-borderSize; ++y) - { - // Collect spans from this row. - prev.resize(id+1); - memset(&prev[0],0,sizeof(int)*id); - unsigned short rid = 1; - - for (int x = borderSize; x < w-borderSize; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - if (chf.areas[i] == RC_NULL_AREA) continue; - - // -x - unsigned short previd = 0; - if (rcGetCon(s, 0) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(0); - const int ay = y + rcGetDirOffsetY(0); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 0); - if ((srcReg[ai] & RC_BORDER_REG) == 0 && chf.areas[i] == chf.areas[ai]) - previd = srcReg[ai]; - } - - if (!previd) - { - previd = rid++; - sweeps[previd].rid = previd; - sweeps[previd].ns = 0; - sweeps[previd].nei = 0; - } - - // -y - if (rcGetCon(s,3) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(3); - const int ay = y + rcGetDirOffsetY(3); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 3); - if (srcReg[ai] && (srcReg[ai] & RC_BORDER_REG) == 0 && chf.areas[i] == chf.areas[ai]) - { - unsigned short nr = srcReg[ai]; - if (!sweeps[previd].nei || sweeps[previd].nei == nr) - { - sweeps[previd].nei = nr; - sweeps[previd].ns++; - prev[nr]++; - } - else - { - sweeps[previd].nei = RC_NULL_NEI; - } - } - } - - srcReg[i] = previd; - } - } - - // Create unique ID. - for (int i = 1; i < rid; ++i) - { - if (sweeps[i].nei != RC_NULL_NEI && sweeps[i].nei != 0 && - prev[sweeps[i].nei] == (int)sweeps[i].ns) - { - sweeps[i].id = sweeps[i].nei; - } - else - { - sweeps[i].id = id++; - } - } - - // Remap IDs - for (int x = borderSize; x < w-borderSize; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (srcReg[i] > 0 && srcReg[i] < rid) - srcReg[i] = sweeps[srcReg[i]].id; - } - } - } - - - { - rcScopedTimer timerFilter(ctx, RC_TIMER_BUILD_REGIONS_FILTER); - - // Merge regions and filter out small regions. - rcIntArray overlaps; - chf.maxRegions = id; - if (!mergeAndFilterRegions(ctx, minRegionArea, mergeRegionArea, chf.maxRegions, chf, srcReg, overlaps)) - return false; - - // Monotone partitioning does not generate overlapping regions. - } - - // Store the result out. - for (int i = 0; i < chf.spanCount; ++i) - chf.spans[i].reg = srcReg[i]; - - return true; -} - -/// @par -/// -/// Non-null regions will consist of connected, non-overlapping walkable spans that form a single contour. -/// Contours will form simple polygons. -/// -/// If multiple regions form an area that is smaller than @p minRegionArea, then all spans will be -/// re-assigned to the zero (null) region. -/// -/// Watershed partitioning can result in smaller than necessary regions, especially in diagonal corridors. -/// @p mergeRegionArea helps reduce unecessarily small regions. -/// -/// See the #rcConfig documentation for more information on the configuration parameters. -/// -/// The region data will be available via the rcCompactHeightfield::maxRegions -/// and rcCompactSpan::reg fields. -/// -/// @warning The distance field must be created using #rcBuildDistanceField before attempting to build regions. -/// -/// @see rcCompactHeightfield, rcCompactSpan, rcBuildDistanceField, rcBuildRegionsMonotone, rcConfig -bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf, - const int borderSize, const int minRegionArea, const int mergeRegionArea) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_REGIONS); - - const int w = chf.width; - const int h = chf.height; - - rcScopedDelete buf((unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount*2, RC_ALLOC_TEMP)); - if (!buf) - { - ctx->log(RC_LOG_ERROR, "rcBuildRegions: Out of memory 'tmp' (%d).", chf.spanCount*4); - return false; - } - - ctx->startTimer(RC_TIMER_BUILD_REGIONS_WATERSHED); - - const int LOG_NB_STACKS = 3; - const int NB_STACKS = 1 << LOG_NB_STACKS; - rcTempVector lvlStacks[NB_STACKS]; - for (int i=0; i stack; - stack.reserve(256); - - unsigned short* srcReg = buf; - unsigned short* srcDist = buf+chf.spanCount; - - memset(srcReg, 0, sizeof(unsigned short)*chf.spanCount); - memset(srcDist, 0, sizeof(unsigned short)*chf.spanCount); - - unsigned short regionId = 1; - unsigned short level = (chf.maxDistance+1) & ~1; - - // TODO: Figure better formula, expandIters defines how much the - // watershed "overflows" and simplifies the regions. Tying it to - // agent radius was usually good indication how greedy it could be. -// const int expandIters = 4 + walkableRadius * 2; - const int expandIters = 8; - - if (borderSize > 0) - { - // Make sure border will not overflow. - const int bw = rcMin(w, borderSize); - const int bh = rcMin(h, borderSize); - - // Paint regions - paintRectRegion(0, bw, 0, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++; - paintRectRegion(w-bw, w, 0, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++; - paintRectRegion(0, w, 0, bh, regionId|RC_BORDER_REG, chf, srcReg); regionId++; - paintRectRegion(0, w, h-bh, h, regionId|RC_BORDER_REG, chf, srcReg); regionId++; - } - - chf.borderSize = borderSize; - - int sId = -1; - while (level > 0) - { - level = level >= 2 ? level-2 : 0; - sId = (sId+1) & (NB_STACKS-1); - -// ctx->startTimer(RC_TIMER_DIVIDE_TO_LEVELS); - - if (sId == 0) - sortCellsByLevel(level, chf, srcReg, NB_STACKS, lvlStacks, 1); - else - appendStacks(lvlStacks[sId-1], lvlStacks[sId], srcReg); // copy left overs from last level - -// ctx->stopTimer(RC_TIMER_DIVIDE_TO_LEVELS); - - { - rcScopedTimer timerExpand(ctx, RC_TIMER_BUILD_REGIONS_EXPAND); - - // Expand current regions until no empty connected cells found. - expandRegions(expandIters, level, chf, srcReg, srcDist, lvlStacks[sId], false); - } - - { - rcScopedTimer timerFloor(ctx, RC_TIMER_BUILD_REGIONS_FLOOD); - - // Mark new regions with IDs. - for (int j = 0; j= 0 && srcReg[i] == 0) - { - if (floodRegion(x, y, i, level, regionId, chf, srcReg, srcDist, stack)) - { - if (regionId == 0xFFFF) - { - ctx->log(RC_LOG_ERROR, "rcBuildRegions: Region ID overflow"); - return false; - } - - regionId++; - } - } - } - } - } - - // Expand current regions until no empty connected cells found. - expandRegions(expandIters*8, 0, chf, srcReg, srcDist, stack, true); - - ctx->stopTimer(RC_TIMER_BUILD_REGIONS_WATERSHED); - - { - rcScopedTimer timerFilter(ctx, RC_TIMER_BUILD_REGIONS_FILTER); - - // Merge regions and filter out smalle regions. - rcIntArray overlaps; - chf.maxRegions = regionId; - if (!mergeAndFilterRegions(ctx, minRegionArea, mergeRegionArea, chf.maxRegions, chf, srcReg, overlaps)) - return false; - - // If overlapping regions were found during merging, split those regions. - if (overlaps.size() > 0) - { - ctx->log(RC_LOG_ERROR, "rcBuildRegions: %d overlapping regions.", overlaps.size()); - } - } - - // Write the result out. - for (int i = 0; i < chf.spanCount; ++i) - chf.spans[i].reg = srcReg[i]; - - return true; -} - - -bool rcBuildLayerRegions(rcContext* ctx, rcCompactHeightfield& chf, - const int borderSize, const int minRegionArea) -{ - rcAssert(ctx); - - rcScopedTimer timer(ctx, RC_TIMER_BUILD_REGIONS); - - const int w = chf.width; - const int h = chf.height; - unsigned short id = 1; - - rcScopedDelete srcReg((unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP)); - if (!srcReg) - { - ctx->log(RC_LOG_ERROR, "rcBuildLayerRegions: Out of memory 'src' (%d).", chf.spanCount); - return false; - } - memset(srcReg,0,sizeof(unsigned short)*chf.spanCount); - - const int nsweeps = rcMax(chf.width,chf.height); - rcScopedDelete sweeps((rcSweepSpan*)rcAlloc(sizeof(rcSweepSpan)*nsweeps, RC_ALLOC_TEMP)); - if (!sweeps) - { - ctx->log(RC_LOG_ERROR, "rcBuildLayerRegions: Out of memory 'sweeps' (%d).", nsweeps); - return false; - } - - - // Mark border regions. - if (borderSize > 0) - { - // Make sure border will not overflow. - const int bw = rcMin(w, borderSize); - const int bh = rcMin(h, borderSize); - // Paint regions - paintRectRegion(0, bw, 0, h, id|RC_BORDER_REG, chf, srcReg); id++; - paintRectRegion(w-bw, w, 0, h, id|RC_BORDER_REG, chf, srcReg); id++; - paintRectRegion(0, w, 0, bh, id|RC_BORDER_REG, chf, srcReg); id++; - paintRectRegion(0, w, h-bh, h, id|RC_BORDER_REG, chf, srcReg); id++; - } - - chf.borderSize = borderSize; - - rcIntArray prev(256); - - // Sweep one line at a time. - for (int y = borderSize; y < h-borderSize; ++y) - { - // Collect spans from this row. - prev.resize(id+1); - memset(&prev[0],0,sizeof(int)*id); - unsigned short rid = 1; - - for (int x = borderSize; x < w-borderSize; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - const rcCompactSpan& s = chf.spans[i]; - if (chf.areas[i] == RC_NULL_AREA) continue; - - // -x - unsigned short previd = 0; - if (rcGetCon(s, 0) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(0); - const int ay = y + rcGetDirOffsetY(0); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 0); - if ((srcReg[ai] & RC_BORDER_REG) == 0 && chf.areas[i] == chf.areas[ai]) - previd = srcReg[ai]; - } - - if (!previd) - { - previd = rid++; - sweeps[previd].rid = previd; - sweeps[previd].ns = 0; - sweeps[previd].nei = 0; - } - - // -y - if (rcGetCon(s,3) != RC_NOT_CONNECTED) - { - const int ax = x + rcGetDirOffsetX(3); - const int ay = y + rcGetDirOffsetY(3); - const int ai = (int)chf.cells[ax+ay*w].index + rcGetCon(s, 3); - if (srcReg[ai] && (srcReg[ai] & RC_BORDER_REG) == 0 && chf.areas[i] == chf.areas[ai]) - { - unsigned short nr = srcReg[ai]; - if (!sweeps[previd].nei || sweeps[previd].nei == nr) - { - sweeps[previd].nei = nr; - sweeps[previd].ns++; - prev[nr]++; - } - else - { - sweeps[previd].nei = RC_NULL_NEI; - } - } - } - - srcReg[i] = previd; - } - } - - // Create unique ID. - for (int i = 1; i < rid; ++i) - { - if (sweeps[i].nei != RC_NULL_NEI && sweeps[i].nei != 0 && - prev[sweeps[i].nei] == (int)sweeps[i].ns) - { - sweeps[i].id = sweeps[i].nei; - } - else - { - sweeps[i].id = id++; - } - } - - // Remap IDs - for (int x = borderSize; x < w-borderSize; ++x) - { - const rcCompactCell& c = chf.cells[x+y*w]; - - for (int i = (int)c.index, ni = (int)(c.index+c.count); i < ni; ++i) - { - if (srcReg[i] > 0 && srcReg[i] < rid) - srcReg[i] = sweeps[srcReg[i]].id; - } - } - } - - - { - rcScopedTimer timerFilter(ctx, RC_TIMER_BUILD_REGIONS_FILTER); - - // Merge monotone regions to layers and remove small regions. - chf.maxRegions = id; - if (!mergeAndFilterLayerRegions(ctx, minRegionArea, chf.maxRegions, chf, srcReg)) - return false; - } - - - // Store the result out. - for (int i = 0; i < chf.spanCount; ++i) - chf.spans[i].reg = srcReg[i]; - - return true; -} diff --git a/thirdparty/rvo2/LICENSE b/thirdparty/rvo2/LICENSE deleted file mode 100644 index d645695..0000000 --- a/thirdparty/rvo2/LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/thirdparty/rvo2/rvo2_2d/Agent2d.cpp b/thirdparty/rvo2/rvo2_2d/Agent2d.cpp deleted file mode 100644 index 3ff95a4..0000000 --- a/thirdparty/rvo2/rvo2_2d/Agent2d.cpp +++ /dev/null @@ -1,594 +0,0 @@ -/* - * Agent2d.cpp - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "Agent2d.h" - -#include "KdTree2d.h" -#include "Obstacle2d.h" - -namespace RVO2D { - Agent2D::Agent2D() : maxNeighbors_(0), maxSpeed_(0.0f), neighborDist_(0.0f), radius_(0.0f), timeHorizon_(0.0f), timeHorizonObst_(0.0f), id_(0) { } - - void Agent2D::computeNeighbors(RVOSimulator2D *sim_) - { - obstacleNeighbors_.clear(); - float rangeSq = sqr(timeHorizonObst_ * maxSpeed_ + radius_); - sim_->kdTree_->computeObstacleNeighbors(this, rangeSq); - - agentNeighbors_.clear(); - - if (maxNeighbors_ > 0) { - rangeSq = sqr(neighborDist_); - sim_->kdTree_->computeAgentNeighbors(this, rangeSq); - } - } - - /* Search for the best new velocity. */ - void Agent2D::computeNewVelocity(RVOSimulator2D *sim_) - { - orcaLines_.clear(); - - const float invTimeHorizonObst = 1.0f / timeHorizonObst_; - - /* Create obstacle ORCA lines. */ - for (size_t i = 0; i < obstacleNeighbors_.size(); ++i) { - - const Obstacle2D *obstacle1 = obstacleNeighbors_[i].second; - const Obstacle2D *obstacle2 = obstacle1->nextObstacle_; - - const Vector2 relativePosition1 = obstacle1->point_ - position_; - const Vector2 relativePosition2 = obstacle2->point_ - position_; - - /* - * Check if velocity obstacle of obstacle is already taken care of by - * previously constructed obstacle ORCA lines. - */ - bool alreadyCovered = false; - - for (size_t j = 0; j < orcaLines_.size(); ++j) { - if (det(invTimeHorizonObst * relativePosition1 - orcaLines_[j].point, orcaLines_[j].direction) - invTimeHorizonObst * radius_ >= -RVO_EPSILON && det(invTimeHorizonObst * relativePosition2 - orcaLines_[j].point, orcaLines_[j].direction) - invTimeHorizonObst * radius_ >= -RVO_EPSILON) { - alreadyCovered = true; - break; - } - } - - if (alreadyCovered) { - continue; - } - - /* Not yet covered. Check for collisions. */ - - const float distSq1 = absSq(relativePosition1); - const float distSq2 = absSq(relativePosition2); - - const float radiusSq = sqr(radius_); - - const Vector2 obstacleVector = obstacle2->point_ - obstacle1->point_; - const float s = (-relativePosition1 * obstacleVector) / absSq(obstacleVector); - const float distSqLine = absSq(-relativePosition1 - s * obstacleVector); - - Line line; - - if (s < 0.0f && distSq1 <= radiusSq) { - /* Collision with left vertex. Ignore if non-convex. */ - if (obstacle1->isConvex_) { - line.point = Vector2(0.0f, 0.0f); - line.direction = normalize(Vector2(-relativePosition1.y(), relativePosition1.x())); - orcaLines_.push_back(line); - } - - continue; - } - else if (s > 1.0f && distSq2 <= radiusSq) { - /* Collision with right vertex. Ignore if non-convex - * or if it will be taken care of by neighoring obstace */ - if (obstacle2->isConvex_ && det(relativePosition2, obstacle2->unitDir_) >= 0.0f) { - line.point = Vector2(0.0f, 0.0f); - line.direction = normalize(Vector2(-relativePosition2.y(), relativePosition2.x())); - orcaLines_.push_back(line); - } - - continue; - } - else if (s >= 0.0f && s < 1.0f && distSqLine <= radiusSq) { - /* Collision with obstacle segment. */ - line.point = Vector2(0.0f, 0.0f); - line.direction = -obstacle1->unitDir_; - orcaLines_.push_back(line); - continue; - } - - /* - * No collision. - * Compute legs. When obliquely viewed, both legs can come from a single - * vertex. Legs extend cut-off line when nonconvex vertex. - */ - - Vector2 leftLegDirection, rightLegDirection; - - if (s < 0.0f && distSqLine <= radiusSq) { - /* - * Obstacle viewed obliquely so that left vertex - * defines velocity obstacle. - */ - if (!obstacle1->isConvex_) { - /* Ignore obstacle. */ - continue; - } - - obstacle2 = obstacle1; - - const float leg1 = std::sqrt(distSq1 - radiusSq); - leftLegDirection = Vector2(relativePosition1.x() * leg1 - relativePosition1.y() * radius_, relativePosition1.x() * radius_ + relativePosition1.y() * leg1) / distSq1; - rightLegDirection = Vector2(relativePosition1.x() * leg1 + relativePosition1.y() * radius_, -relativePosition1.x() * radius_ + relativePosition1.y() * leg1) / distSq1; - } - else if (s > 1.0f && distSqLine <= radiusSq) { - /* - * Obstacle viewed obliquely so that - * right vertex defines velocity obstacle. - */ - if (!obstacle2->isConvex_) { - /* Ignore obstacle. */ - continue; - } - - obstacle1 = obstacle2; - - const float leg2 = std::sqrt(distSq2 - radiusSq); - leftLegDirection = Vector2(relativePosition2.x() * leg2 - relativePosition2.y() * radius_, relativePosition2.x() * radius_ + relativePosition2.y() * leg2) / distSq2; - rightLegDirection = Vector2(relativePosition2.x() * leg2 + relativePosition2.y() * radius_, -relativePosition2.x() * radius_ + relativePosition2.y() * leg2) / distSq2; - } - else { - /* Usual situation. */ - if (obstacle1->isConvex_) { - const float leg1 = std::sqrt(distSq1 - radiusSq); - leftLegDirection = Vector2(relativePosition1.x() * leg1 - relativePosition1.y() * radius_, relativePosition1.x() * radius_ + relativePosition1.y() * leg1) / distSq1; - } - else { - /* Left vertex non-convex; left leg extends cut-off line. */ - leftLegDirection = -obstacle1->unitDir_; - } - - if (obstacle2->isConvex_) { - const float leg2 = std::sqrt(distSq2 - radiusSq); - rightLegDirection = Vector2(relativePosition2.x() * leg2 + relativePosition2.y() * radius_, -relativePosition2.x() * radius_ + relativePosition2.y() * leg2) / distSq2; - } - else { - /* Right vertex non-convex; right leg extends cut-off line. */ - rightLegDirection = obstacle1->unitDir_; - } - } - - /* - * Legs can never point into neighboring edge when convex vertex, - * take cutoff-line of neighboring edge instead. If velocity projected on - * "foreign" leg, no constraint is added. - */ - - const Obstacle2D *const leftNeighbor = obstacle1->prevObstacle_; - - bool isLeftLegForeign = false; - bool isRightLegForeign = false; - - if (obstacle1->isConvex_ && det(leftLegDirection, -leftNeighbor->unitDir_) >= 0.0f) { - /* Left leg points into obstacle. */ - leftLegDirection = -leftNeighbor->unitDir_; - isLeftLegForeign = true; - } - - if (obstacle2->isConvex_ && det(rightLegDirection, obstacle2->unitDir_) <= 0.0f) { - /* Right leg points into obstacle. */ - rightLegDirection = obstacle2->unitDir_; - isRightLegForeign = true; - } - - /* Compute cut-off centers. */ - const Vector2 leftCutoff = invTimeHorizonObst * (obstacle1->point_ - position_); - const Vector2 rightCutoff = invTimeHorizonObst * (obstacle2->point_ - position_); - const Vector2 cutoffVec = rightCutoff - leftCutoff; - - /* Project current velocity on velocity obstacle. */ - - /* Check if current velocity is projected on cutoff circles. */ - const float t = (obstacle1 == obstacle2 ? 0.5f : ((velocity_ - leftCutoff) * cutoffVec) / absSq(cutoffVec)); - const float tLeft = ((velocity_ - leftCutoff) * leftLegDirection); - const float tRight = ((velocity_ - rightCutoff) * rightLegDirection); - - if ((t < 0.0f && tLeft < 0.0f) || (obstacle1 == obstacle2 && tLeft < 0.0f && tRight < 0.0f)) { - /* Project on left cut-off circle. */ - const Vector2 unitW = normalize(velocity_ - leftCutoff); - - line.direction = Vector2(unitW.y(), -unitW.x()); - line.point = leftCutoff + radius_ * invTimeHorizonObst * unitW; - orcaLines_.push_back(line); - continue; - } - else if (t > 1.0f && tRight < 0.0f) { - /* Project on right cut-off circle. */ - const Vector2 unitW = normalize(velocity_ - rightCutoff); - - line.direction = Vector2(unitW.y(), -unitW.x()); - line.point = rightCutoff + radius_ * invTimeHorizonObst * unitW; - orcaLines_.push_back(line); - continue; - } - - /* - * Project on left leg, right leg, or cut-off line, whichever is closest - * to velocity. - */ - const float distSqCutoff = ((t < 0.0f || t > 1.0f || obstacle1 == obstacle2) ? std::numeric_limits::infinity() : absSq(velocity_ - (leftCutoff + t * cutoffVec))); - const float distSqLeft = ((tLeft < 0.0f) ? std::numeric_limits::infinity() : absSq(velocity_ - (leftCutoff + tLeft * leftLegDirection))); - const float distSqRight = ((tRight < 0.0f) ? std::numeric_limits::infinity() : absSq(velocity_ - (rightCutoff + tRight * rightLegDirection))); - - if (distSqCutoff <= distSqLeft && distSqCutoff <= distSqRight) { - /* Project on cut-off line. */ - line.direction = -obstacle1->unitDir_; - line.point = leftCutoff + radius_ * invTimeHorizonObst * Vector2(-line.direction.y(), line.direction.x()); - orcaLines_.push_back(line); - continue; - } - else if (distSqLeft <= distSqRight) { - /* Project on left leg. */ - if (isLeftLegForeign) { - continue; - } - - line.direction = leftLegDirection; - line.point = leftCutoff + radius_ * invTimeHorizonObst * Vector2(-line.direction.y(), line.direction.x()); - orcaLines_.push_back(line); - continue; - } - else { - /* Project on right leg. */ - if (isRightLegForeign) { - continue; - } - - line.direction = -rightLegDirection; - line.point = rightCutoff + radius_ * invTimeHorizonObst * Vector2(-line.direction.y(), line.direction.x()); - orcaLines_.push_back(line); - continue; - } - } - - const size_t numObstLines = orcaLines_.size(); - - const float invTimeHorizon = 1.0f / timeHorizon_; - - /* Create agent ORCA lines. */ - for (size_t i = 0; i < agentNeighbors_.size(); ++i) { - const Agent2D *const other = agentNeighbors_[i].second; - - //const float timeHorizon_mod = (avoidance_priority_ - other->avoidance_priority_ + 1.0f) * 0.5f; - //const float invTimeHorizon = (1.0f / timeHorizon_) * timeHorizon_mod; - - const Vector2 relativePosition = other->position_ - position_; - const Vector2 relativeVelocity = velocity_ - other->velocity_; - const float distSq = absSq(relativePosition); - const float combinedRadius = radius_ + other->radius_; - const float combinedRadiusSq = sqr(combinedRadius); - - Line line; - Vector2 u; - - if (distSq > combinedRadiusSq) { - /* No collision. */ - const Vector2 w = relativeVelocity - invTimeHorizon * relativePosition; - /* Vector from cutoff center to relative velocity. */ - const float wLengthSq = absSq(w); - - const float dotProduct1 = w * relativePosition; - - if (dotProduct1 < 0.0f && sqr(dotProduct1) > combinedRadiusSq * wLengthSq) { - /* Project on cut-off circle. */ - const float wLength = std::sqrt(wLengthSq); - const Vector2 unitW = w / wLength; - - line.direction = Vector2(unitW.y(), -unitW.x()); - u = (combinedRadius * invTimeHorizon - wLength) * unitW; - } - else { - /* Project on legs. */ - const float leg = std::sqrt(distSq - combinedRadiusSq); - - if (det(relativePosition, w) > 0.0f) { - /* Project on left leg. */ - line.direction = Vector2(relativePosition.x() * leg - relativePosition.y() * combinedRadius, relativePosition.x() * combinedRadius + relativePosition.y() * leg) / distSq; - } - else { - /* Project on right leg. */ - line.direction = -Vector2(relativePosition.x() * leg + relativePosition.y() * combinedRadius, -relativePosition.x() * combinedRadius + relativePosition.y() * leg) / distSq; - } - - const float dotProduct2 = relativeVelocity * line.direction; - - u = dotProduct2 * line.direction - relativeVelocity; - } - } - else { - /* Collision. Project on cut-off circle of time timeStep. */ - const float invTimeStep = 1.0f / sim_->timeStep_; - - /* Vector from cutoff center to relative velocity. */ - const Vector2 w = relativeVelocity - invTimeStep * relativePosition; - - const float wLength = abs(w); - const Vector2 unitW = w / wLength; - - line.direction = Vector2(unitW.y(), -unitW.x()); - u = (combinedRadius * invTimeStep - wLength) * unitW; - } - - line.point = velocity_ + 0.5f * u; - orcaLines_.push_back(line); - } - - size_t lineFail = linearProgram2(orcaLines_, maxSpeed_, prefVelocity_, false, newVelocity_); - - if (lineFail < orcaLines_.size()) { - linearProgram3(orcaLines_, numObstLines, lineFail, maxSpeed_, newVelocity_); - } - } - - void Agent2D::insertAgentNeighbor(const Agent2D *agent, float &rangeSq) - { - // no point processing same agent - if (this == agent) { - return; - } - // ignore other agent if layers/mask bitmasks have no matching bit - if ((avoidance_mask_ & agent->avoidance_layers_) == 0) { - return; - } - // ignore other agent if this agent is below or above - if ((elevation_ > agent->elevation_ + agent->height_) || (elevation_ + height_ < agent->elevation_)) { - return; - } - - if (avoidance_priority_ > agent->avoidance_priority_) { - return; - } - - const float distSq = absSq(position_ - agent->position_); - - if (distSq < rangeSq) { - if (agentNeighbors_.size() < maxNeighbors_) { - agentNeighbors_.push_back(std::make_pair(distSq, agent)); - } - - size_t i = agentNeighbors_.size() - 1; - - while (i != 0 && distSq < agentNeighbors_[i - 1].first) { - agentNeighbors_[i] = agentNeighbors_[i - 1]; - --i; - } - - agentNeighbors_[i] = std::make_pair(distSq, agent); - - if (agentNeighbors_.size() == maxNeighbors_) { - rangeSq = agentNeighbors_.back().first; - } - } - } - - void Agent2D::insertObstacleNeighbor(const Obstacle2D *obstacle, float rangeSq) - { - const Obstacle2D *const nextObstacle = obstacle->nextObstacle_; - - // ignore obstacle if no matching layer/mask - if ((avoidance_mask_ & nextObstacle->avoidance_layers_) == 0) { - return; - } - // ignore obstacle if below or above - if ((elevation_ > obstacle->elevation_ + obstacle->height_) || (elevation_ + height_ < obstacle->elevation_)) { - return; - } - - const float distSq = distSqPointLineSegment(obstacle->point_, nextObstacle->point_, position_); - - if (distSq < rangeSq) { - obstacleNeighbors_.push_back(std::make_pair(distSq, obstacle)); - - size_t i = obstacleNeighbors_.size() - 1; - - while (i != 0 && distSq < obstacleNeighbors_[i - 1].first) { - obstacleNeighbors_[i] = obstacleNeighbors_[i - 1]; - --i; - } - - obstacleNeighbors_[i] = std::make_pair(distSq, obstacle); - } - //} - } - - void Agent2D::update(RVOSimulator2D *sim_) - { - velocity_ = newVelocity_; - position_ += velocity_ * sim_->timeStep_; - } - - bool linearProgram1(const std::vector &lines, size_t lineNo, float radius, const Vector2 &optVelocity, bool directionOpt, Vector2 &result) - { - const float dotProduct = lines[lineNo].point * lines[lineNo].direction; - const float discriminant = sqr(dotProduct) + sqr(radius) - absSq(lines[lineNo].point); - - if (discriminant < 0.0f) { - /* Max speed circle fully invalidates line lineNo. */ - return false; - } - - const float sqrtDiscriminant = std::sqrt(discriminant); - float tLeft = -dotProduct - sqrtDiscriminant; - float tRight = -dotProduct + sqrtDiscriminant; - - for (size_t i = 0; i < lineNo; ++i) { - const float denominator = det(lines[lineNo].direction, lines[i].direction); - const float numerator = det(lines[i].direction, lines[lineNo].point - lines[i].point); - - if (std::fabs(denominator) <= RVO_EPSILON) { - /* Lines lineNo and i are (almost) parallel. */ - if (numerator < 0.0f) { - return false; - } - else { - continue; - } - } - - const float t = numerator / denominator; - - if (denominator >= 0.0f) { - /* Line i bounds line lineNo on the right. */ - tRight = std::min(tRight, t); - } - else { - /* Line i bounds line lineNo on the left. */ - tLeft = std::max(tLeft, t); - } - - if (tLeft > tRight) { - return false; - } - } - - if (directionOpt) { - /* Optimize direction. */ - if (optVelocity * lines[lineNo].direction > 0.0f) { - /* Take right extreme. */ - result = lines[lineNo].point + tRight * lines[lineNo].direction; - } - else { - /* Take left extreme. */ - result = lines[lineNo].point + tLeft * lines[lineNo].direction; - } - } - else { - /* Optimize closest point. */ - const float t = lines[lineNo].direction * (optVelocity - lines[lineNo].point); - - if (t < tLeft) { - result = lines[lineNo].point + tLeft * lines[lineNo].direction; - } - else if (t > tRight) { - result = lines[lineNo].point + tRight * lines[lineNo].direction; - } - else { - result = lines[lineNo].point + t * lines[lineNo].direction; - } - } - - return true; - } - - size_t linearProgram2(const std::vector &lines, float radius, const Vector2 &optVelocity, bool directionOpt, Vector2 &result) - { - if (directionOpt) { - /* - * Optimize direction. Note that the optimization velocity is of unit - * length in this case. - */ - result = optVelocity * radius; - } - else if (absSq(optVelocity) > sqr(radius)) { - /* Optimize closest point and outside circle. */ - result = normalize(optVelocity) * radius; - } - else { - /* Optimize closest point and inside circle. */ - result = optVelocity; - } - - for (size_t i = 0; i < lines.size(); ++i) { - if (det(lines[i].direction, lines[i].point - result) > 0.0f) { - /* Result does not satisfy constraint i. Compute new optimal result. */ - const Vector2 tempResult = result; - - if (!linearProgram1(lines, i, radius, optVelocity, directionOpt, result)) { - result = tempResult; - return i; - } - } - } - - return lines.size(); - } - - void linearProgram3(const std::vector &lines, size_t numObstLines, size_t beginLine, float radius, Vector2 &result) - { - float distance = 0.0f; - - for (size_t i = beginLine; i < lines.size(); ++i) { - if (det(lines[i].direction, lines[i].point - result) > distance) { - /* Result does not satisfy constraint of line i. */ - std::vector projLines(lines.begin(), lines.begin() + static_cast(numObstLines)); - - for (size_t j = numObstLines; j < i; ++j) { - Line line; - - float determinant = det(lines[i].direction, lines[j].direction); - - if (std::fabs(determinant) <= RVO_EPSILON) { - /* Line i and line j are parallel. */ - if (lines[i].direction * lines[j].direction > 0.0f) { - /* Line i and line j point in the same direction. */ - continue; - } - else { - /* Line i and line j point in opposite direction. */ - line.point = 0.5f * (lines[i].point + lines[j].point); - } - } - else { - line.point = lines[i].point + (det(lines[j].direction, lines[i].point - lines[j].point) / determinant) * lines[i].direction; - } - - line.direction = normalize(lines[j].direction - lines[i].direction); - projLines.push_back(line); - } - - const Vector2 tempResult = result; - - if (linearProgram2(projLines, radius, Vector2(-lines[i].direction.y(), lines[i].direction.x()), true, result) < projLines.size()) { - /* This should in principle not happen. The result is by definition - * already in the feasible region of this linear program. If it fails, - * it is due to small floating point error, and the current result is - * kept. - */ - result = tempResult; - } - - distance = det(lines[i].direction, lines[i].point - result); - } - } - } -} diff --git a/thirdparty/rvo2/rvo2_2d/Agent2d.h b/thirdparty/rvo2/rvo2_2d/Agent2d.h deleted file mode 100644 index c666c2d..0000000 --- a/thirdparty/rvo2/rvo2_2d/Agent2d.h +++ /dev/null @@ -1,160 +0,0 @@ -/* - * Agent2d.h - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#ifndef RVO2D_AGENT_H_ -#define RVO2D_AGENT_H_ - -/** - * \file Agent2d.h - * \brief Contains the Agent class. - */ - -#include "Definitions.h" -#include "RVOSimulator2d.h" - -namespace RVO2D { - /** - * \brief Defines an agent in the simulation. - */ - class Agent2D { - public: - /** - * \brief Constructs an agent instance. - * \param sim The simulator instance. - */ - explicit Agent2D(); - - /** - * \brief Computes the neighbors of this agent. - */ - void computeNeighbors(RVOSimulator2D *sim_); - - /** - * \brief Computes the new velocity of this agent. - */ - void computeNewVelocity(RVOSimulator2D *sim_); - - /** - * \brief Inserts an agent neighbor into the set of neighbors of - * this agent. - * \param agent A pointer to the agent to be inserted. - * \param rangeSq The squared range around this agent. - */ - void insertAgentNeighbor(const Agent2D *agent, float &rangeSq); - - /** - * \brief Inserts a static obstacle neighbor into the set of neighbors - * of this agent. - * \param obstacle The number of the static obstacle to be - * inserted. - * \param rangeSq The squared range around this agent. - */ - void insertObstacleNeighbor(const Obstacle2D *obstacle, float rangeSq); - - /** - * \brief Updates the two-dimensional position and two-dimensional - * velocity of this agent. - */ - void update(RVOSimulator2D *sim_); - - std::vector > agentNeighbors_; - size_t maxNeighbors_; - float maxSpeed_; - float neighborDist_; - Vector2 newVelocity_; - std::vector > obstacleNeighbors_; - std::vector orcaLines_; - Vector2 position_; - Vector2 prefVelocity_; - float radius_; - float timeHorizon_; - float timeHorizonObst_; - Vector2 velocity_; - float height_ = 0.0; - float elevation_ = 0.0; - uint32_t avoidance_layers_ = 1; - uint32_t avoidance_mask_ = 1; - float avoidance_priority_ = 1.0; - - size_t id_; - - friend class KdTree2D; - friend class RVOSimulator2D; - }; - - /** - * \relates Agent - * \brief Solves a one-dimensional linear program on a specified line - * subject to linear constraints defined by lines and a circular - * constraint. - * \param lines Lines defining the linear constraints. - * \param lineNo The specified line constraint. - * \param radius The radius of the circular constraint. - * \param optVelocity The optimization velocity. - * \param directionOpt True if the direction should be optimized. - * \param result A reference to the result of the linear program. - * \return True if successful. - */ - bool linearProgram1(const std::vector &lines, size_t lineNo, - float radius, const Vector2 &optVelocity, - bool directionOpt, Vector2 &result); - - /** - * \relates Agent - * \brief Solves a two-dimensional linear program subject to linear - * constraints defined by lines and a circular constraint. - * \param lines Lines defining the linear constraints. - * \param radius The radius of the circular constraint. - * \param optVelocity The optimization velocity. - * \param directionOpt True if the direction should be optimized. - * \param result A reference to the result of the linear program. - * \return The number of the line it fails on, and the number of lines if successful. - */ - size_t linearProgram2(const std::vector &lines, float radius, - const Vector2 &optVelocity, bool directionOpt, - Vector2 &result); - - /** - * \relates Agent - * \brief Solves a two-dimensional linear program subject to linear - * constraints defined by lines and a circular constraint. - * \param lines Lines defining the linear constraints. - * \param numObstLines Count of obstacle lines. - * \param beginLine The line on which the 2-d linear program failed. - * \param radius The radius of the circular constraint. - * \param result A reference to the result of the linear program. - */ - void linearProgram3(const std::vector &lines, size_t numObstLines, size_t beginLine, - float radius, Vector2 &result); -} - -#endif /* RVO2D_AGENT_H_ */ diff --git a/thirdparty/rvo2/rvo2_2d/Definitions.h b/thirdparty/rvo2/rvo2_2d/Definitions.h deleted file mode 100644 index a5553d8..0000000 --- a/thirdparty/rvo2/rvo2_2d/Definitions.h +++ /dev/null @@ -1,110 +0,0 @@ -/* - * Definitions.h - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#ifndef RVO2D_DEFINITIONS_H_ -#define RVO2D_DEFINITIONS_H_ - -/** - * \file Definitions.h - * \brief Contains functions and constants used in multiple classes. - */ - -#include -#include -#include -#include -#include -#include - -#include "Vector2.h" - -/** - * \brief A sufficiently small positive number. - */ -const float RVO_EPSILON = 0.00001f; - -namespace RVO2D { - class Agent2D; - class Obstacle2D; - class RVOSimulator2D; - - /** - * \brief Computes the squared distance from a line segment with the - * specified endpoints to a specified point. - * \param a The first endpoint of the line segment. - * \param b The second endpoint of the line segment. - * \param c The point to which the squared distance is to - * be calculated. - * \return The squared distance from the line segment to the point. - */ - inline float distSqPointLineSegment(const Vector2 &a, const Vector2 &b, - const Vector2 &c) - { - const float r = ((c - a) * (b - a)) / absSq(b - a); - - if (r < 0.0f) { - return absSq(c - a); - } - else if (r > 1.0f) { - return absSq(c - b); - } - else { - return absSq(c - (a + r * (b - a))); - } - } - - /** - * \brief Computes the signed distance from a line connecting the - * specified points to a specified point. - * \param a The first point on the line. - * \param b The second point on the line. - * \param c The point to which the signed distance is to - * be calculated. - * \return Positive when the point c lies to the left of the line ab. - */ - inline float leftOf(const Vector2 &a, const Vector2 &b, const Vector2 &c) - { - return det(a - c, b - a); - } - - /** - * \brief Computes the square of a float. - * \param a The float to be squared. - * \return The square of the float. - */ - inline float sqr(float a) - { - return a * a; - } -} - -#endif /* RVO2D_DEFINITIONS_H_ */ diff --git a/thirdparty/rvo2/rvo2_2d/KdTree2d.cpp b/thirdparty/rvo2/rvo2_2d/KdTree2d.cpp deleted file mode 100644 index 184bc74..0000000 --- a/thirdparty/rvo2/rvo2_2d/KdTree2d.cpp +++ /dev/null @@ -1,357 +0,0 @@ -/* - * KdTree2d.cpp - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "KdTree2d.h" - -#include "Agent2d.h" -#include "RVOSimulator2d.h" -#include "Obstacle2d.h" - -namespace RVO2D { - KdTree2D::KdTree2D(RVOSimulator2D *sim) : obstacleTree_(NULL), sim_(sim) { } - - KdTree2D::~KdTree2D() - { - deleteObstacleTree(obstacleTree_); - } - - void KdTree2D::buildAgentTree(std::vector agents) - { - agents_.swap(agents); - - if (!agents_.empty()) { - agentTree_.resize(2 * agents_.size() - 1); - buildAgentTreeRecursive(0, agents_.size(), 0); - } - } - - void KdTree2D::buildAgentTreeRecursive(size_t begin, size_t end, size_t node) - { - agentTree_[node].begin = begin; - agentTree_[node].end = end; - agentTree_[node].minX = agentTree_[node].maxX = agents_[begin]->position_.x(); - agentTree_[node].minY = agentTree_[node].maxY = agents_[begin]->position_.y(); - - for (size_t i = begin + 1; i < end; ++i) { - agentTree_[node].maxX = std::max(agentTree_[node].maxX, agents_[i]->position_.x()); - agentTree_[node].minX = std::min(agentTree_[node].minX, agents_[i]->position_.x()); - agentTree_[node].maxY = std::max(agentTree_[node].maxY, agents_[i]->position_.y()); - agentTree_[node].minY = std::min(agentTree_[node].minY, agents_[i]->position_.y()); - } - - if (end - begin > MAX_LEAF_SIZE) { - /* No leaf node. */ - const bool isVertical = (agentTree_[node].maxX - agentTree_[node].minX > agentTree_[node].maxY - agentTree_[node].minY); - const float splitValue = (isVertical ? 0.5f * (agentTree_[node].maxX + agentTree_[node].minX) : 0.5f * (agentTree_[node].maxY + agentTree_[node].minY)); - - size_t left = begin; - size_t right = end; - - while (left < right) { - while (left < right && (isVertical ? agents_[left]->position_.x() : agents_[left]->position_.y()) < splitValue) { - ++left; - } - - while (right > left && (isVertical ? agents_[right - 1]->position_.x() : agents_[right - 1]->position_.y()) >= splitValue) { - --right; - } - - if (left < right) { - std::swap(agents_[left], agents_[right - 1]); - ++left; - --right; - } - } - - if (left == begin) { - ++left; - ++right; - } - - agentTree_[node].left = node + 1; - agentTree_[node].right = node + 2 * (left - begin); - - buildAgentTreeRecursive(begin, left, agentTree_[node].left); - buildAgentTreeRecursive(left, end, agentTree_[node].right); - } - } - - void KdTree2D::buildObstacleTree(std::vector obstacles) - { - deleteObstacleTree(obstacleTree_); - - obstacleTree_ = buildObstacleTreeRecursive(obstacles); - } - - - KdTree2D::ObstacleTreeNode *KdTree2D::buildObstacleTreeRecursive(const std::vector &obstacles) - { - if (obstacles.empty()) { - return NULL; - } - else { - ObstacleTreeNode *const node = new ObstacleTreeNode; - - size_t optimalSplit = 0; - size_t minLeft = obstacles.size(); - size_t minRight = obstacles.size(); - - for (size_t i = 0; i < obstacles.size(); ++i) { - size_t leftSize = 0; - size_t rightSize = 0; - - const Obstacle2D *const obstacleI1 = obstacles[i]; - const Obstacle2D *const obstacleI2 = obstacleI1->nextObstacle_; - - /* Compute optimal split node. */ - for (size_t j = 0; j < obstacles.size(); ++j) { - if (i == j) { - continue; - } - - const Obstacle2D *const obstacleJ1 = obstacles[j]; - const Obstacle2D *const obstacleJ2 = obstacleJ1->nextObstacle_; - - const float j1LeftOfI = leftOf(obstacleI1->point_, obstacleI2->point_, obstacleJ1->point_); - const float j2LeftOfI = leftOf(obstacleI1->point_, obstacleI2->point_, obstacleJ2->point_); - - if (j1LeftOfI >= -RVO_EPSILON && j2LeftOfI >= -RVO_EPSILON) { - ++leftSize; - } - else if (j1LeftOfI <= RVO_EPSILON && j2LeftOfI <= RVO_EPSILON) { - ++rightSize; - } - else { - ++leftSize; - ++rightSize; - } - - if (std::make_pair(std::max(leftSize, rightSize), std::min(leftSize, rightSize)) >= std::make_pair(std::max(minLeft, minRight), std::min(minLeft, minRight))) { - break; - } - } - - if (std::make_pair(std::max(leftSize, rightSize), std::min(leftSize, rightSize)) < std::make_pair(std::max(minLeft, minRight), std::min(minLeft, minRight))) { - minLeft = leftSize; - minRight = rightSize; - optimalSplit = i; - } - } - - /* Build split node. */ - std::vector leftObstacles(minLeft); - std::vector rightObstacles(minRight); - - size_t leftCounter = 0; - size_t rightCounter = 0; - const size_t i = optimalSplit; - - const Obstacle2D *const obstacleI1 = obstacles[i]; - const Obstacle2D *const obstacleI2 = obstacleI1->nextObstacle_; - - for (size_t j = 0; j < obstacles.size(); ++j) { - if (i == j) { - continue; - } - - Obstacle2D *const obstacleJ1 = obstacles[j]; - Obstacle2D *const obstacleJ2 = obstacleJ1->nextObstacle_; - - const float j1LeftOfI = leftOf(obstacleI1->point_, obstacleI2->point_, obstacleJ1->point_); - const float j2LeftOfI = leftOf(obstacleI1->point_, obstacleI2->point_, obstacleJ2->point_); - - if (j1LeftOfI >= -RVO_EPSILON && j2LeftOfI >= -RVO_EPSILON) { - leftObstacles[leftCounter++] = obstacles[j]; - } - else if (j1LeftOfI <= RVO_EPSILON && j2LeftOfI <= RVO_EPSILON) { - rightObstacles[rightCounter++] = obstacles[j]; - } - else { - /* Split obstacle j. */ - const float t = det(obstacleI2->point_ - obstacleI1->point_, obstacleJ1->point_ - obstacleI1->point_) / det(obstacleI2->point_ - obstacleI1->point_, obstacleJ1->point_ - obstacleJ2->point_); - - const Vector2 splitpoint = obstacleJ1->point_ + t * (obstacleJ2->point_ - obstacleJ1->point_); - - Obstacle2D *const newObstacle = new Obstacle2D(); - newObstacle->point_ = splitpoint; - newObstacle->prevObstacle_ = obstacleJ1; - newObstacle->nextObstacle_ = obstacleJ2; - newObstacle->isConvex_ = true; - newObstacle->unitDir_ = obstacleJ1->unitDir_; - - newObstacle->id_ = sim_->obstacles_.size(); - - sim_->obstacles_.push_back(newObstacle); - - obstacleJ1->nextObstacle_ = newObstacle; - obstacleJ2->prevObstacle_ = newObstacle; - - if (j1LeftOfI > 0.0f) { - leftObstacles[leftCounter++] = obstacleJ1; - rightObstacles[rightCounter++] = newObstacle; - } - else { - rightObstacles[rightCounter++] = obstacleJ1; - leftObstacles[leftCounter++] = newObstacle; - } - } - } - - node->obstacle = obstacleI1; - node->left = buildObstacleTreeRecursive(leftObstacles); - node->right = buildObstacleTreeRecursive(rightObstacles); - return node; - } - } - - void KdTree2D::computeAgentNeighbors(Agent2D *agent, float &rangeSq) const - { - queryAgentTreeRecursive(agent, rangeSq, 0); - } - - void KdTree2D::computeObstacleNeighbors(Agent2D *agent, float rangeSq) const - { - queryObstacleTreeRecursive(agent, rangeSq, obstacleTree_); - } - - void KdTree2D::deleteObstacleTree(ObstacleTreeNode *node) - { - if (node != NULL) { - deleteObstacleTree(node->left); - deleteObstacleTree(node->right); - delete node; - } - } - - void KdTree2D::queryAgentTreeRecursive(Agent2D *agent, float &rangeSq, size_t node) const - { - if (agentTree_[node].end - agentTree_[node].begin <= MAX_LEAF_SIZE) { - for (size_t i = agentTree_[node].begin; i < agentTree_[node].end; ++i) { - agent->insertAgentNeighbor(agents_[i], rangeSq); - } - } - else { - const float distSqLeft = sqr(std::max(0.0f, agentTree_[agentTree_[node].left].minX - agent->position_.x())) + sqr(std::max(0.0f, agent->position_.x() - agentTree_[agentTree_[node].left].maxX)) + sqr(std::max(0.0f, agentTree_[agentTree_[node].left].minY - agent->position_.y())) + sqr(std::max(0.0f, agent->position_.y() - agentTree_[agentTree_[node].left].maxY)); - - const float distSqRight = sqr(std::max(0.0f, agentTree_[agentTree_[node].right].minX - agent->position_.x())) + sqr(std::max(0.0f, agent->position_.x() - agentTree_[agentTree_[node].right].maxX)) + sqr(std::max(0.0f, agentTree_[agentTree_[node].right].minY - agent->position_.y())) + sqr(std::max(0.0f, agent->position_.y() - agentTree_[agentTree_[node].right].maxY)); - - if (distSqLeft < distSqRight) { - if (distSqLeft < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].left); - - if (distSqRight < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].right); - } - } - } - else { - if (distSqRight < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].right); - - if (distSqLeft < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].left); - } - } - } - - } - } - - void KdTree2D::queryObstacleTreeRecursive(Agent2D *agent, float rangeSq, const ObstacleTreeNode *node) const - { - if (node == NULL) { - return; - } - else { - const Obstacle2D *const obstacle1 = node->obstacle; - const Obstacle2D *const obstacle2 = obstacle1->nextObstacle_; - - const float agentLeftOfLine = leftOf(obstacle1->point_, obstacle2->point_, agent->position_); - - queryObstacleTreeRecursive(agent, rangeSq, (agentLeftOfLine >= 0.0f ? node->left : node->right)); - - const float distSqLine = sqr(agentLeftOfLine) / absSq(obstacle2->point_ - obstacle1->point_); - - if (distSqLine < rangeSq) { - if (agentLeftOfLine < 0.0f) { - /* - * Try obstacle at this node only if agent is on right side of - * obstacle (and can see obstacle). - */ - agent->insertObstacleNeighbor(node->obstacle, rangeSq); - } - - /* Try other side of line. */ - queryObstacleTreeRecursive(agent, rangeSq, (agentLeftOfLine >= 0.0f ? node->right : node->left)); - - } - } - } - - bool KdTree2D::queryVisibility(const Vector2 &q1, const Vector2 &q2, float radius) const - { - return queryVisibilityRecursive(q1, q2, radius, obstacleTree_); - } - - bool KdTree2D::queryVisibilityRecursive(const Vector2 &q1, const Vector2 &q2, float radius, const ObstacleTreeNode *node) const - { - if (node == NULL) { - return true; - } - else { - const Obstacle2D *const obstacle1 = node->obstacle; - const Obstacle2D *const obstacle2 = obstacle1->nextObstacle_; - - const float q1LeftOfI = leftOf(obstacle1->point_, obstacle2->point_, q1); - const float q2LeftOfI = leftOf(obstacle1->point_, obstacle2->point_, q2); - const float invLengthI = 1.0f / absSq(obstacle2->point_ - obstacle1->point_); - - if (q1LeftOfI >= 0.0f && q2LeftOfI >= 0.0f) { - return queryVisibilityRecursive(q1, q2, radius, node->left) && ((sqr(q1LeftOfI) * invLengthI >= sqr(radius) && sqr(q2LeftOfI) * invLengthI >= sqr(radius)) || queryVisibilityRecursive(q1, q2, radius, node->right)); - } - else if (q1LeftOfI <= 0.0f && q2LeftOfI <= 0.0f) { - return queryVisibilityRecursive(q1, q2, radius, node->right) && ((sqr(q1LeftOfI) * invLengthI >= sqr(radius) && sqr(q2LeftOfI) * invLengthI >= sqr(radius)) || queryVisibilityRecursive(q1, q2, radius, node->left)); - } - else if (q1LeftOfI >= 0.0f && q2LeftOfI <= 0.0f) { - /* One can see through obstacle from left to right. */ - return queryVisibilityRecursive(q1, q2, radius, node->left) && queryVisibilityRecursive(q1, q2, radius, node->right); - } - else { - const float point1LeftOfQ = leftOf(q1, q2, obstacle1->point_); - const float point2LeftOfQ = leftOf(q1, q2, obstacle2->point_); - const float invLengthQ = 1.0f / absSq(q2 - q1); - - return (point1LeftOfQ * point2LeftOfQ >= 0.0f && sqr(point1LeftOfQ) * invLengthQ > sqr(radius) && sqr(point2LeftOfQ) * invLengthQ > sqr(radius) && queryVisibilityRecursive(q1, q2, radius, node->left) && queryVisibilityRecursive(q1, q2, radius, node->right)); - } - } - } -} diff --git a/thirdparty/rvo2/rvo2_2d/KdTree2d.h b/thirdparty/rvo2/rvo2_2d/KdTree2d.h deleted file mode 100644 index c7159ea..0000000 --- a/thirdparty/rvo2/rvo2_2d/KdTree2d.h +++ /dev/null @@ -1,203 +0,0 @@ -/* - * KdTree2d.h - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#ifndef RVO2D_KD_TREE_H_ -#define RVO2D_KD_TREE_H_ - -/** - * \file KdTree2d.h - * \brief Contains the KdTree class. - */ - -#include "Definitions.h" - -namespace RVO2D { - /** - * \brief Defines kd-trees for agents and static obstacles in the - * simulation. - */ - class KdTree2D { - public: - /** - * \brief Defines an agent kd-tree node. - */ - class AgentTreeNode { - public: - /** - * \brief The beginning node number. - */ - size_t begin; - - /** - * \brief The ending node number. - */ - size_t end; - - /** - * \brief The left node number. - */ - size_t left; - - /** - * \brief The maximum x-coordinate. - */ - float maxX; - - /** - * \brief The maximum y-coordinate. - */ - float maxY; - - /** - * \brief The minimum x-coordinate. - */ - float minX; - - /** - * \brief The minimum y-coordinate. - */ - float minY; - - /** - * \brief The right node number. - */ - size_t right; - }; - - /** - * \brief Defines an obstacle kd-tree node. - */ - class ObstacleTreeNode { - public: - /** - * \brief The left obstacle tree node. - */ - ObstacleTreeNode *left; - - /** - * \brief The obstacle number. - */ - const Obstacle2D *obstacle; - - /** - * \brief The right obstacle tree node. - */ - ObstacleTreeNode *right; - }; - - /** - * \brief Constructs a kd-tree instance. - * \param sim The simulator instance. - */ - explicit KdTree2D(RVOSimulator2D *sim); - - /** - * \brief Destroys this kd-tree instance. - */ - ~KdTree2D(); - - /** - * \brief Builds an agent kd-tree. - */ - void buildAgentTree(std::vector agents); - - void buildAgentTreeRecursive(size_t begin, size_t end, size_t node); - - /** - * \brief Builds an obstacle kd-tree. - */ - void buildObstacleTree(std::vector obstacles); - - ObstacleTreeNode *buildObstacleTreeRecursive(const std::vector & - obstacles); - - /** - * \brief Computes the agent neighbors of the specified agent. - * \param agent A pointer to the agent for which agent - * neighbors are to be computed. - * \param rangeSq The squared range around the agent. - */ - void computeAgentNeighbors(Agent2D *agent, float &rangeSq) const; - - /** - * \brief Computes the obstacle neighbors of the specified agent. - * \param agent A pointer to the agent for which obstacle - * neighbors are to be computed. - * \param rangeSq The squared range around the agent. - */ - void computeObstacleNeighbors(Agent2D *agent, float rangeSq) const; - - /** - * \brief Deletes the specified obstacle tree node. - * \param node A pointer to the obstacle tree node to be - * deleted. - */ - void deleteObstacleTree(ObstacleTreeNode *node); - - void queryAgentTreeRecursive(Agent2D *agent, float &rangeSq, - size_t node) const; - - void queryObstacleTreeRecursive(Agent2D *agent, float rangeSq, - const ObstacleTreeNode *node) const; - - /** - * \brief Queries the visibility between two points within a - * specified radius. - * \param q1 The first point between which visibility is - * to be tested. - * \param q2 The second point between which visibility is - * to be tested. - * \param radius The radius within which visibility is to be - * tested. - * \return True if q1 and q2 are mutually visible within the radius; - * false otherwise. - */ - bool queryVisibility(const Vector2 &q1, const Vector2 &q2, - float radius) const; - - bool queryVisibilityRecursive(const Vector2 &q1, const Vector2 &q2, - float radius, - const ObstacleTreeNode *node) const; - - std::vector agents_; - std::vector agentTree_; - ObstacleTreeNode *obstacleTree_; - RVOSimulator2D *sim_; - - static const size_t MAX_LEAF_SIZE = 10; - - friend class Agent2D; - friend class RVOSimulator2D; - }; -} - -#endif /* RVO2D_KD_TREE_H_ */ diff --git a/thirdparty/rvo2/rvo2_2d/Obstacle2d.cpp b/thirdparty/rvo2/rvo2_2d/Obstacle2d.cpp deleted file mode 100644 index a80c8af..0000000 --- a/thirdparty/rvo2/rvo2_2d/Obstacle2d.cpp +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Obstacle2d.cpp - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "Obstacle2d.h" -#include "RVOSimulator2d.h" - -namespace RVO2D { - Obstacle2D::Obstacle2D() : isConvex_(false), nextObstacle_(NULL), prevObstacle_(NULL), id_(0) { } -} diff --git a/thirdparty/rvo2/rvo2_2d/Obstacle2d.h b/thirdparty/rvo2/rvo2_2d/Obstacle2d.h deleted file mode 100644 index 9ba5937..0000000 --- a/thirdparty/rvo2/rvo2_2d/Obstacle2d.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Obstacle2d.h - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#ifndef RVO2D_OBSTACLE_H_ -#define RVO2D_OBSTACLE_H_ - -/** - * \file Obstacle2d.h - * \brief Contains the Obstacle class. - */ - -#include "Definitions.h" - -namespace RVO2D { - /** - * \brief Defines static obstacles in the simulation. - */ - class Obstacle2D { - public: - /** - * \brief Constructs a static obstacle instance. - */ - Obstacle2D(); - - bool isConvex_; - Obstacle2D *nextObstacle_; - Vector2 point_; - Obstacle2D *prevObstacle_; - Vector2 unitDir_; - - float height_ = 1.0; - float elevation_ = 0.0; - uint32_t avoidance_layers_ = 1; - - size_t id_; - - friend class Agent2D; - friend class KdTree2D; - friend class RVOSimulator2D; - }; -} - -#endif /* RVO2D_OBSTACLE_H_ */ diff --git a/thirdparty/rvo2/rvo2_2d/RVOSimulator2d.cpp b/thirdparty/rvo2/rvo2_2d/RVOSimulator2d.cpp deleted file mode 100644 index 9fb1555..0000000 --- a/thirdparty/rvo2/rvo2_2d/RVOSimulator2d.cpp +++ /dev/null @@ -1,363 +0,0 @@ -/* - * RVOSimulator2d.cpp - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "RVOSimulator2d.h" - -#include "Agent2d.h" -#include "KdTree2d.h" -#include "Obstacle2d.h" - -#ifdef _OPENMP -#include -#endif - -namespace RVO2D { - RVOSimulator2D::RVOSimulator2D() : defaultAgent_(NULL), globalTime_(0.0f), kdTree_(NULL), timeStep_(0.0f) - { - kdTree_ = new KdTree2D(this); - } - - RVOSimulator2D::RVOSimulator2D(float timeStep, float neighborDist, size_t maxNeighbors, float timeHorizon, float timeHorizonObst, float radius, float maxSpeed, const Vector2 &velocity) : defaultAgent_(NULL), globalTime_(0.0f), kdTree_(NULL), timeStep_(timeStep) - { - kdTree_ = new KdTree2D(this); - defaultAgent_ = new Agent2D(); - - defaultAgent_->maxNeighbors_ = maxNeighbors; - defaultAgent_->maxSpeed_ = maxSpeed; - defaultAgent_->neighborDist_ = neighborDist; - defaultAgent_->radius_ = radius; - defaultAgent_->timeHorizon_ = timeHorizon; - defaultAgent_->timeHorizonObst_ = timeHorizonObst; - defaultAgent_->velocity_ = velocity; - } - - RVOSimulator2D::~RVOSimulator2D() - { - if (defaultAgent_ != NULL) { - delete defaultAgent_; - } - - for (size_t i = 0; i < agents_.size(); ++i) { - delete agents_[i]; - } - - for (size_t i = 0; i < obstacles_.size(); ++i) { - delete obstacles_[i]; - } - - delete kdTree_; - } - - size_t RVOSimulator2D::addAgent(const Vector2 &position) - { - if (defaultAgent_ == NULL) { - return RVO2D_ERROR; - } - - Agent2D *agent = new Agent2D(); - - agent->position_ = position; - agent->maxNeighbors_ = defaultAgent_->maxNeighbors_; - agent->maxSpeed_ = defaultAgent_->maxSpeed_; - agent->neighborDist_ = defaultAgent_->neighborDist_; - agent->radius_ = defaultAgent_->radius_; - agent->timeHorizon_ = defaultAgent_->timeHorizon_; - agent->timeHorizonObst_ = defaultAgent_->timeHorizonObst_; - agent->velocity_ = defaultAgent_->velocity_; - - agent->id_ = agents_.size(); - - agents_.push_back(agent); - - return agents_.size() - 1; - } - - size_t RVOSimulator2D::addAgent(const Vector2 &position, float neighborDist, size_t maxNeighbors, float timeHorizon, float timeHorizonObst, float radius, float maxSpeed, const Vector2 &velocity) - { - Agent2D *agent = new Agent2D(); - - agent->position_ = position; - agent->maxNeighbors_ = maxNeighbors; - agent->maxSpeed_ = maxSpeed; - agent->neighborDist_ = neighborDist; - agent->radius_ = radius; - agent->timeHorizon_ = timeHorizon; - agent->timeHorizonObst_ = timeHorizonObst; - agent->velocity_ = velocity; - - agent->id_ = agents_.size(); - - agents_.push_back(agent); - - return agents_.size() - 1; - } - - size_t RVOSimulator2D::addObstacle(const std::vector &vertices) - { - if (vertices.size() < 2) { - return RVO2D_ERROR; - } - - const size_t obstacleNo = obstacles_.size(); - - for (size_t i = 0; i < vertices.size(); ++i) { - Obstacle2D *obstacle = new Obstacle2D(); - obstacle->point_ = vertices[i]; - - if (i != 0) { - obstacle->prevObstacle_ = obstacles_.back(); - obstacle->prevObstacle_->nextObstacle_ = obstacle; - } - - if (i == vertices.size() - 1) { - obstacle->nextObstacle_ = obstacles_[obstacleNo]; - obstacle->nextObstacle_->prevObstacle_ = obstacle; - } - - obstacle->unitDir_ = normalize(vertices[(i == vertices.size() - 1 ? 0 : i + 1)] - vertices[i]); - - if (vertices.size() == 2) { - obstacle->isConvex_ = true; - } - else { - obstacle->isConvex_ = (leftOf(vertices[(i == 0 ? vertices.size() - 1 : i - 1)], vertices[i], vertices[(i == vertices.size() - 1 ? 0 : i + 1)]) >= 0.0f); - } - - obstacle->id_ = obstacles_.size(); - - obstacles_.push_back(obstacle); - } - - return obstacleNo; - } - - void RVOSimulator2D::doStep() - { - kdTree_->buildAgentTree(agents_); - - for (int i = 0; i < static_cast(agents_.size()); ++i) { - agents_[i]->computeNeighbors(this); - agents_[i]->computeNewVelocity(this); - } - - for (int i = 0; i < static_cast(agents_.size()); ++i) { - agents_[i]->update(this); - } - - globalTime_ += timeStep_; - } - - size_t RVOSimulator2D::getAgentAgentNeighbor(size_t agentNo, size_t neighborNo) const - { - return agents_[agentNo]->agentNeighbors_[neighborNo].second->id_; - } - - size_t RVOSimulator2D::getAgentMaxNeighbors(size_t agentNo) const - { - return agents_[agentNo]->maxNeighbors_; - } - - float RVOSimulator2D::getAgentMaxSpeed(size_t agentNo) const - { - return agents_[agentNo]->maxSpeed_; - } - - float RVOSimulator2D::getAgentNeighborDist(size_t agentNo) const - { - return agents_[agentNo]->neighborDist_; - } - - size_t RVOSimulator2D::getAgentNumAgentNeighbors(size_t agentNo) const - { - return agents_[agentNo]->agentNeighbors_.size(); - } - - size_t RVOSimulator2D::getAgentNumObstacleNeighbors(size_t agentNo) const - { - return agents_[agentNo]->obstacleNeighbors_.size(); - } - - size_t RVOSimulator2D::getAgentNumORCALines(size_t agentNo) const - { - return agents_[agentNo]->orcaLines_.size(); - } - - size_t RVOSimulator2D::getAgentObstacleNeighbor(size_t agentNo, size_t neighborNo) const - { - return agents_[agentNo]->obstacleNeighbors_[neighborNo].second->id_; - } - - const Line &RVOSimulator2D::getAgentORCALine(size_t agentNo, size_t lineNo) const - { - return agents_[agentNo]->orcaLines_[lineNo]; - } - - const Vector2 &RVOSimulator2D::getAgentPosition(size_t agentNo) const - { - return agents_[agentNo]->position_; - } - - const Vector2 &RVOSimulator2D::getAgentPrefVelocity(size_t agentNo) const - { - return agents_[agentNo]->prefVelocity_; - } - - float RVOSimulator2D::getAgentRadius(size_t agentNo) const - { - return agents_[agentNo]->radius_; - } - - float RVOSimulator2D::getAgentTimeHorizon(size_t agentNo) const - { - return agents_[agentNo]->timeHorizon_; - } - - float RVOSimulator2D::getAgentTimeHorizonObst(size_t agentNo) const - { - return agents_[agentNo]->timeHorizonObst_; - } - - const Vector2 &RVOSimulator2D::getAgentVelocity(size_t agentNo) const - { - return agents_[agentNo]->velocity_; - } - - float RVOSimulator2D::getGlobalTime() const - { - return globalTime_; - } - - size_t RVOSimulator2D::getNumAgents() const - { - return agents_.size(); - } - - size_t RVOSimulator2D::getNumObstacleVertices() const - { - return obstacles_.size(); - } - - const Vector2 &RVOSimulator2D::getObstacleVertex(size_t vertexNo) const - { - return obstacles_[vertexNo]->point_; - } - - size_t RVOSimulator2D::getNextObstacleVertexNo(size_t vertexNo) const - { - return obstacles_[vertexNo]->nextObstacle_->id_; - } - - size_t RVOSimulator2D::getPrevObstacleVertexNo(size_t vertexNo) const - { - return obstacles_[vertexNo]->prevObstacle_->id_; - } - - float RVOSimulator2D::getTimeStep() const - { - return timeStep_; - } - - void RVOSimulator2D::processObstacles() - { - kdTree_->buildObstacleTree(obstacles_); - } - - bool RVOSimulator2D::queryVisibility(const Vector2 &point1, const Vector2 &point2, float radius) const - { - return kdTree_->queryVisibility(point1, point2, radius); - } - - void RVOSimulator2D::setAgentDefaults(float neighborDist, size_t maxNeighbors, float timeHorizon, float timeHorizonObst, float radius, float maxSpeed, const Vector2 &velocity) - { - if (defaultAgent_ == NULL) { - defaultAgent_ = new Agent2D(); - } - - defaultAgent_->maxNeighbors_ = maxNeighbors; - defaultAgent_->maxSpeed_ = maxSpeed; - defaultAgent_->neighborDist_ = neighborDist; - defaultAgent_->radius_ = radius; - defaultAgent_->timeHorizon_ = timeHorizon; - defaultAgent_->timeHorizonObst_ = timeHorizonObst; - defaultAgent_->velocity_ = velocity; - } - - void RVOSimulator2D::setAgentMaxNeighbors(size_t agentNo, size_t maxNeighbors) - { - agents_[agentNo]->maxNeighbors_ = maxNeighbors; - } - - void RVOSimulator2D::setAgentMaxSpeed(size_t agentNo, float maxSpeed) - { - agents_[agentNo]->maxSpeed_ = maxSpeed; - } - - void RVOSimulator2D::setAgentNeighborDist(size_t agentNo, float neighborDist) - { - agents_[agentNo]->neighborDist_ = neighborDist; - } - - void RVOSimulator2D::setAgentPosition(size_t agentNo, const Vector2 &position) - { - agents_[agentNo]->position_ = position; - } - - void RVOSimulator2D::setAgentPrefVelocity(size_t agentNo, const Vector2 &prefVelocity) - { - agents_[agentNo]->prefVelocity_ = prefVelocity; - } - - void RVOSimulator2D::setAgentRadius(size_t agentNo, float radius) - { - agents_[agentNo]->radius_ = radius; - } - - void RVOSimulator2D::setAgentTimeHorizon(size_t agentNo, float timeHorizon) - { - agents_[agentNo]->timeHorizon_ = timeHorizon; - } - - void RVOSimulator2D::setAgentTimeHorizonObst(size_t agentNo, float timeHorizonObst) - { - agents_[agentNo]->timeHorizonObst_ = timeHorizonObst; - } - - void RVOSimulator2D::setAgentVelocity(size_t agentNo, const Vector2 &velocity) - { - agents_[agentNo]->velocity_ = velocity; - } - - void RVOSimulator2D::setTimeStep(float timeStep) - { - timeStep_ = timeStep; - } -} diff --git a/thirdparty/rvo2/rvo2_2d/RVOSimulator2d.h b/thirdparty/rvo2/rvo2_2d/RVOSimulator2d.h deleted file mode 100644 index e074e0f..0000000 --- a/thirdparty/rvo2/rvo2_2d/RVOSimulator2d.h +++ /dev/null @@ -1,592 +0,0 @@ -/* - * RVOSimulator2d.h - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#ifndef RVO2D_RVO_SIMULATOR_H_ -#define RVO2D_RVO_SIMULATOR_H_ - -/** - * \file RVOSimulator2d.h - * \brief Contains the RVOSimulator2D class. - */ - -#include -#include -#include - -#include "Vector2.h" - -namespace RVO2D { - /** - * \brief Error value. - * - * A value equal to the largest unsigned integer that is returned in case - * of an error by functions in RVO2D::RVOSimulator2D. - */ - const size_t RVO2D_ERROR = std::numeric_limits::max(); - - /** - * \brief Defines a directed line. - */ - class Line { - public: - /** - * \brief A point on the directed line. - */ - Vector2 point; - - /** - * \brief The direction of the directed line. - */ - Vector2 direction; - }; - - class Agent2D; - class KdTree2D; - class Obstacle2D; - - /** - * \brief Defines the simulation. - * - * The main class of the library that contains all simulation functionality. - */ - class RVOSimulator2D { - public: - /** - * \brief Constructs a simulator instance. - */ - RVOSimulator2D(); - - /** - * \brief Constructs a simulator instance and sets the default - * properties for any new agent that is added. - * \param timeStep The time step of the simulation. - * Must be positive. - * \param neighborDist The default maximum distance (center point - * to center point) to other agents a new agent - * takes into account in the navigation. The - * larger this number, the longer he running - * time of the simulation. If the number is too - * low, the simulation will not be safe. Must be - * non-negative. - * \param maxNeighbors The default maximum number of other agents a - * new agent takes into account in the - * navigation. The larger this number, the - * longer the running time of the simulation. - * If the number is too low, the simulation - * will not be safe. - * \param timeHorizon The default minimal amount of time for which - * a new agent's velocities that are computed - * by the simulation are safe with respect to - * other agents. The larger this number, the - * sooner an agent will respond to the presence - * of other agents, but the less freedom the - * agent has in choosing its velocities. - * Must be positive. - * \param timeHorizonObst The default minimal amount of time for which - * a new agent's velocities that are computed - * by the simulation are safe with respect to - * obstacles. The larger this number, the - * sooner an agent will respond to the presence - * of obstacles, but the less freedom the agent - * has in choosing its velocities. - * Must be positive. - * \param radius The default radius of a new agent. - * Must be non-negative. - * \param maxSpeed The default maximum speed of a new agent. - * Must be non-negative. - * \param velocity The default initial two-dimensional linear - * velocity of a new agent (optional). - */ - RVOSimulator2D(float timeStep, float neighborDist, size_t maxNeighbors, - float timeHorizon, float timeHorizonObst, float radius, - float maxSpeed, const Vector2 &velocity = Vector2()); - - /** - * \brief Destroys this simulator instance. - */ - ~RVOSimulator2D(); - - /** - * \brief Adds a new agent with default properties to the - * simulation. - * \param position The two-dimensional starting position of - * this agent. - * \return The number of the agent, or RVO2D::RVO2D_ERROR when the agent - * defaults have not been set. - */ - size_t addAgent(const Vector2 &position); - - /** - * \brief Adds a new agent to the simulation. - * \param position The two-dimensional starting position of - * this agent. - * \param neighborDist The maximum distance (center point to - * center point) to other agents this agent - * takes into account in the navigation. The - * larger this number, the longer the running - * time of the simulation. If the number is too - * low, the simulation will not be safe. - * Must be non-negative. - * \param maxNeighbors The maximum number of other agents this - * agent takes into account in the navigation. - * The larger this number, the longer the - * running time of the simulation. If the - * number is too low, the simulation will not - * be safe. - * \param timeHorizon The minimal amount of time for which this - * agent's velocities that are computed by the - * simulation are safe with respect to other - * agents. The larger this number, the sooner - * this agent will respond to the presence of - * other agents, but the less freedom this - * agent has in choosing its velocities. - * Must be positive. - * \param timeHorizonObst The minimal amount of time for which this - * agent's velocities that are computed by the - * simulation are safe with respect to - * obstacles. The larger this number, the - * sooner this agent will respond to the - * presence of obstacles, but the less freedom - * this agent has in choosing its velocities. - * Must be positive. - * \param radius The radius of this agent. - * Must be non-negative. - * \param maxSpeed The maximum speed of this agent. - * Must be non-negative. - * \param velocity The initial two-dimensional linear velocity - * of this agent (optional). - * \return The number of the agent. - */ - size_t addAgent(const Vector2 &position, float neighborDist, - size_t maxNeighbors, float timeHorizon, - float timeHorizonObst, float radius, float maxSpeed, - const Vector2 &velocity = Vector2()); - - /** - * \brief Adds a new obstacle to the simulation. - * \param vertices List of the vertices of the polygonal - * obstacle in counterclockwise order. - * \return The number of the first vertex of the obstacle, - * or RVO2D::RVO2D_ERROR when the number of vertices is less than two. - * \note To add a "negative" obstacle, e.g. a bounding polygon around - * the environment, the vertices should be listed in clockwise - * order. - */ - size_t addObstacle(const std::vector &vertices); - - /** - * \brief Lets the simulator perform a simulation step and updates the - * two-dimensional position and two-dimensional velocity of - * each agent. - */ - void doStep(); - - /** - * \brief Returns the specified agent neighbor of the specified - * agent. - * \param agentNo The number of the agent whose agent - * neighbor is to be retrieved. - * \param neighborNo The number of the agent neighbor to be - * retrieved. - * \return The number of the neighboring agent. - */ - size_t getAgentAgentNeighbor(size_t agentNo, size_t neighborNo) const; - - /** - * \brief Returns the maximum neighbor count of a specified agent. - * \param agentNo The number of the agent whose maximum - * neighbor count is to be retrieved. - * \return The present maximum neighbor count of the agent. - */ - size_t getAgentMaxNeighbors(size_t agentNo) const; - - /** - * \brief Returns the maximum speed of a specified agent. - * \param agentNo The number of the agent whose maximum speed - * is to be retrieved. - * \return The present maximum speed of the agent. - */ - float getAgentMaxSpeed(size_t agentNo) const; - - /** - * \brief Returns the maximum neighbor distance of a specified - * agent. - * \param agentNo The number of the agent whose maximum - * neighbor distance is to be retrieved. - * \return The present maximum neighbor distance of the agent. - */ - float getAgentNeighborDist(size_t agentNo) const; - - /** - * \brief Returns the count of agent neighbors taken into account to - * compute the current velocity for the specified agent. - * \param agentNo The number of the agent whose count of agent - * neighbors is to be retrieved. - * \return The count of agent neighbors taken into account to compute - * the current velocity for the specified agent. - */ - size_t getAgentNumAgentNeighbors(size_t agentNo) const; - - /** - * \brief Returns the count of obstacle neighbors taken into account - * to compute the current velocity for the specified agent. - * \param agentNo The number of the agent whose count of - * obstacle neighbors is to be retrieved. - * \return The count of obstacle neighbors taken into account to - * compute the current velocity for the specified agent. - */ - size_t getAgentNumObstacleNeighbors(size_t agentNo) const; - - - /** - * \brief Returns the count of ORCA constraints used to compute - * the current velocity for the specified agent. - * \param agentNo The number of the agent whose count of ORCA - * constraints is to be retrieved. - * \return The count of ORCA constraints used to compute the current - * velocity for the specified agent. - */ - size_t getAgentNumORCALines(size_t agentNo) const; - - /** - * \brief Returns the specified obstacle neighbor of the specified - * agent. - * \param agentNo The number of the agent whose obstacle - * neighbor is to be retrieved. - * \param neighborNo The number of the obstacle neighbor to be - * retrieved. - * \return The number of the first vertex of the neighboring obstacle - * edge. - */ - size_t getAgentObstacleNeighbor(size_t agentNo, size_t neighborNo) const; - - /** - * \brief Returns the specified ORCA constraint of the specified - * agent. - * \param agentNo The number of the agent whose ORCA - * constraint is to be retrieved. - * \param lineNo The number of the ORCA constraint to be - * retrieved. - * \return A line representing the specified ORCA constraint. - * \note The halfplane to the left of the line is the region of - * permissible velocities with respect to the specified - * ORCA constraint. - */ - const Line &getAgentORCALine(size_t agentNo, size_t lineNo) const; - - /** - * \brief Returns the two-dimensional position of a specified - * agent. - * \param agentNo The number of the agent whose - * two-dimensional position is to be retrieved. - * \return The present two-dimensional position of the (center of the) - * agent. - */ - const Vector2 &getAgentPosition(size_t agentNo) const; - - /** - * \brief Returns the two-dimensional preferred velocity of a - * specified agent. - * \param agentNo The number of the agent whose - * two-dimensional preferred velocity is to be - * retrieved. - * \return The present two-dimensional preferred velocity of the agent. - */ - const Vector2 &getAgentPrefVelocity(size_t agentNo) const; - - /** - * \brief Returns the radius of a specified agent. - * \param agentNo The number of the agent whose radius is to - * be retrieved. - * \return The present radius of the agent. - */ - float getAgentRadius(size_t agentNo) const; - - /** - * \brief Returns the time horizon of a specified agent. - * \param agentNo The number of the agent whose time horizon - * is to be retrieved. - * \return The present time horizon of the agent. - */ - float getAgentTimeHorizon(size_t agentNo) const; - - /** - * \brief Returns the time horizon with respect to obstacles of a - * specified agent. - * \param agentNo The number of the agent whose time horizon - * with respect to obstacles is to be - * retrieved. - * \return The present time horizon with respect to obstacles of the - * agent. - */ - float getAgentTimeHorizonObst(size_t agentNo) const; - - /** - * \brief Returns the two-dimensional linear velocity of a - * specified agent. - * \param agentNo The number of the agent whose - * two-dimensional linear velocity is to be - * retrieved. - * \return The present two-dimensional linear velocity of the agent. - */ - const Vector2 &getAgentVelocity(size_t agentNo) const; - - /** - * \brief Returns the global time of the simulation. - * \return The present global time of the simulation (zero initially). - */ - float getGlobalTime() const; - - /** - * \brief Returns the count of agents in the simulation. - * \return The count of agents in the simulation. - */ - size_t getNumAgents() const; - - /** - * \brief Returns the count of obstacle vertices in the simulation. - * \return The count of obstacle vertices in the simulation. - */ - size_t getNumObstacleVertices() const; - - /** - * \brief Returns the two-dimensional position of a specified obstacle - * vertex. - * \param vertexNo The number of the obstacle vertex to be - * retrieved. - * \return The two-dimensional position of the specified obstacle - * vertex. - */ - const Vector2 &getObstacleVertex(size_t vertexNo) const; - - /** - * \brief Returns the number of the obstacle vertex succeeding the - * specified obstacle vertex in its polygon. - * \param vertexNo The number of the obstacle vertex whose - * successor is to be retrieved. - * \return The number of the obstacle vertex succeeding the specified - * obstacle vertex in its polygon. - */ - size_t getNextObstacleVertexNo(size_t vertexNo) const; - - /** - * \brief Returns the number of the obstacle vertex preceding the - * specified obstacle vertex in its polygon. - * \param vertexNo The number of the obstacle vertex whose - * predecessor is to be retrieved. - * \return The number of the obstacle vertex preceding the specified - * obstacle vertex in its polygon. - */ - size_t getPrevObstacleVertexNo(size_t vertexNo) const; - - /** - * \brief Returns the time step of the simulation. - * \return The present time step of the simulation. - */ - float getTimeStep() const; - - /** - * \brief Processes the obstacles that have been added so that they - * are accounted for in the simulation. - * \note Obstacles added to the simulation after this function has - * been called are not accounted for in the simulation. - */ - void processObstacles(); - - /** - * \brief Performs a visibility query between the two specified - * points with respect to the obstacles - * \param point1 The first point of the query. - * \param point2 The second point of the query. - * \param radius The minimal distance between the line - * connecting the two points and the obstacles - * in order for the points to be mutually - * visible (optional). Must be non-negative. - * \return A boolean specifying whether the two points are mutually - * visible. Returns true when the obstacles have not been - * processed. - */ - bool queryVisibility(const Vector2 &point1, const Vector2 &point2, - float radius = 0.0f) const; - - /** - * \brief Sets the default properties for any new agent that is - * added. - * \param neighborDist The default maximum distance (center point - * to center point) to other agents a new agent - * takes into account in the navigation. The - * larger this number, the longer he running - * time of the simulation. If the number is too - * low, the simulation will not be safe. - * Must be non-negative. - * \param maxNeighbors The default maximum number of other agents a - * new agent takes into account in the - * navigation. The larger this number, the - * longer the running time of the simulation. - * If the number is too low, the simulation - * will not be safe. - * \param timeHorizon The default minimal amount of time for which - * a new agent's velocities that are computed - * by the simulation are safe with respect to - * other agents. The larger this number, the - * sooner an agent will respond to the presence - * of other agents, but the less freedom the - * agent has in choosing its velocities. - * Must be positive. - * \param timeHorizonObst The default minimal amount of time for which - * a new agent's velocities that are computed - * by the simulation are safe with respect to - * obstacles. The larger this number, the - * sooner an agent will respond to the presence - * of obstacles, but the less freedom the agent - * has in choosing its velocities. - * Must be positive. - * \param radius The default radius of a new agent. - * Must be non-negative. - * \param maxSpeed The default maximum speed of a new agent. - * Must be non-negative. - * \param velocity The default initial two-dimensional linear - * velocity of a new agent (optional). - */ - void setAgentDefaults(float neighborDist, size_t maxNeighbors, - float timeHorizon, float timeHorizonObst, - float radius, float maxSpeed, - const Vector2 &velocity = Vector2()); - - /** - * \brief Sets the maximum neighbor count of a specified agent. - * \param agentNo The number of the agent whose maximum - * neighbor count is to be modified. - * \param maxNeighbors The replacement maximum neighbor count. - */ - void setAgentMaxNeighbors(size_t agentNo, size_t maxNeighbors); - - /** - * \brief Sets the maximum speed of a specified agent. - * \param agentNo The number of the agent whose maximum speed - * is to be modified. - * \param maxSpeed The replacement maximum speed. Must be - * non-negative. - */ - void setAgentMaxSpeed(size_t agentNo, float maxSpeed); - - /** - * \brief Sets the maximum neighbor distance of a specified agent. - * \param agentNo The number of the agent whose maximum - * neighbor distance is to be modified. - * \param neighborDist The replacement maximum neighbor distance. - * Must be non-negative. - */ - void setAgentNeighborDist(size_t agentNo, float neighborDist); - - /** - * \brief Sets the two-dimensional position of a specified agent. - * \param agentNo The number of the agent whose - * two-dimensional position is to be modified. - * \param position The replacement of the two-dimensional - * position. - */ - void setAgentPosition(size_t agentNo, const Vector2 &position); - - /** - * \brief Sets the two-dimensional preferred velocity of a - * specified agent. - * \param agentNo The number of the agent whose - * two-dimensional preferred velocity is to be - * modified. - * \param prefVelocity The replacement of the two-dimensional - * preferred velocity. - */ - void setAgentPrefVelocity(size_t agentNo, const Vector2 &prefVelocity); - - /** - * \brief Sets the radius of a specified agent. - * \param agentNo The number of the agent whose radius is to - * be modified. - * \param radius The replacement radius. - * Must be non-negative. - */ - void setAgentRadius(size_t agentNo, float radius); - - /** - * \brief Sets the time horizon of a specified agent with respect - * to other agents. - * \param agentNo The number of the agent whose time horizon - * is to be modified. - * \param timeHorizon The replacement time horizon with respect - * to other agents. Must be positive. - */ - void setAgentTimeHorizon(size_t agentNo, float timeHorizon); - - /** - * \brief Sets the time horizon of a specified agent with respect - * to obstacles. - * \param agentNo The number of the agent whose time horizon - * with respect to obstacles is to be modified. - * \param timeHorizonObst The replacement time horizon with respect to - * obstacles. Must be positive. - */ - void setAgentTimeHorizonObst(size_t agentNo, float timeHorizonObst); - - /** - * \brief Sets the two-dimensional linear velocity of a specified - * agent. - * \param agentNo The number of the agent whose - * two-dimensional linear velocity is to be - * modified. - * \param velocity The replacement two-dimensional linear - * velocity. - */ - void setAgentVelocity(size_t agentNo, const Vector2 &velocity); - - /** - * \brief Sets the time step of the simulation. - * \param timeStep The time step of the simulation. - * Must be positive. - */ - void setTimeStep(float timeStep); - - public: - std::vector agents_; - Agent2D *defaultAgent_; - float globalTime_; - KdTree2D *kdTree_; - std::vector obstacles_; - float timeStep_; - - friend class Agent2D; - friend class KdTree2D; - friend class Obstacle2D; - }; -} - -#endif /* RVO2D_RVO_SIMULATOR_H_ */ diff --git a/thirdparty/rvo2/rvo2_2d/Vector2.h b/thirdparty/rvo2/rvo2_2d/Vector2.h deleted file mode 100644 index 24353e0..0000000 --- a/thirdparty/rvo2/rvo2_2d/Vector2.h +++ /dev/null @@ -1,346 +0,0 @@ -/* - * Vector2.h - * RVO2 Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#ifndef RVO_VECTOR2_H_ -#define RVO_VECTOR2_H_ - -/** - * \file Vector2.h - * \brief Contains the Vector2 class. - */ - -#include -#include - -namespace RVO2D { - /** - * \brief Defines a two-dimensional vector. - */ - class Vector2 { - public: - /** - * \brief Constructs and initializes a two-dimensional vector instance - * to (0.0, 0.0). - */ - inline Vector2() : x_(0.0f), y_(0.0f) { } - - /** - * \brief Constructs and initializes a two-dimensional vector from - * the specified xy-coordinates. - * \param x The x-coordinate of the two-dimensional - * vector. - * \param y The y-coordinate of the two-dimensional - * vector. - */ - inline Vector2(float x, float y) : x_(x), y_(y) { } - - inline Vector2(const Vector2 &vector) - { - x_ = vector.x(); - y_ = vector.y(); - } - - /** - * \brief Returns the x-coordinate of this two-dimensional vector. - * \return The x-coordinate of the two-dimensional vector. - */ - inline float x() const { return x_; } - - /** - * \brief Returns the y-coordinate of this two-dimensional vector. - * \return The y-coordinate of the two-dimensional vector. - */ - inline float y() const { return y_; } - - /** - * \brief Computes the negation of this two-dimensional vector. - * \return The negation of this two-dimensional vector. - */ - inline Vector2 operator-() const - { - return Vector2(-x_, -y_); - } - - /** - * \brief Computes the dot product of this two-dimensional vector with - * the specified two-dimensional vector. - * \param vector The two-dimensional vector with which the - * dot product should be computed. - * \return The dot product of this two-dimensional vector with a - * specified two-dimensional vector. - */ - inline float operator*(const Vector2 &vector) const - { - return x_ * vector.x() + y_ * vector.y(); - } - - /** - * \brief Computes the scalar multiplication of this - * two-dimensional vector with the specified scalar value. - * \param s The scalar value with which the scalar - * multiplication should be computed. - * \return The scalar multiplication of this two-dimensional vector - * with a specified scalar value. - */ - inline Vector2 operator*(float s) const - { - return Vector2(x_ * s, y_ * s); - } - - /** - * \brief Computes the scalar division of this two-dimensional vector - * with the specified scalar value. - * \param s The scalar value with which the scalar - * division should be computed. - * \return The scalar division of this two-dimensional vector with a - * specified scalar value. - */ - inline Vector2 operator/(float s) const - { - const float invS = 1.0f / s; - - return Vector2(x_ * invS, y_ * invS); - } - - /** - * \brief Computes the vector sum of this two-dimensional vector with - * the specified two-dimensional vector. - * \param vector The two-dimensional vector with which the - * vector sum should be computed. - * \return The vector sum of this two-dimensional vector with a - * specified two-dimensional vector. - */ - inline Vector2 operator+(const Vector2 &vector) const - { - return Vector2(x_ + vector.x(), y_ + vector.y()); - } - - /** - * \brief Computes the vector difference of this two-dimensional - * vector with the specified two-dimensional vector. - * \param vector The two-dimensional vector with which the - * vector difference should be computed. - * \return The vector difference of this two-dimensional vector with a - * specified two-dimensional vector. - */ - inline Vector2 operator-(const Vector2 &vector) const - { - return Vector2(x_ - vector.x(), y_ - vector.y()); - } - - /** - * \brief Tests this two-dimensional vector for equality with the - * specified two-dimensional vector. - * \param vector The two-dimensional vector with which to - * test for equality. - * \return True if the two-dimensional vectors are equal. - */ - inline bool operator==(const Vector2 &vector) const - { - return x_ == vector.x() && y_ == vector.y(); - } - - /** - * \brief Tests this two-dimensional vector for inequality with the - * specified two-dimensional vector. - * \param vector The two-dimensional vector with which to - * test for inequality. - * \return True if the two-dimensional vectors are not equal. - */ - inline bool operator!=(const Vector2 &vector) const - { - return x_ != vector.x() || y_ != vector.y(); - } - - /** - * \brief Sets the value of this two-dimensional vector to the scalar - * multiplication of itself with the specified scalar value. - * \param s The scalar value with which the scalar - * multiplication should be computed. - * \return A reference to this two-dimensional vector. - */ - inline Vector2 &operator*=(float s) - { - x_ *= s; - y_ *= s; - - return *this; - } - - /** - * \brief Sets the value of this two-dimensional vector to the scalar - * division of itself with the specified scalar value. - * \param s The scalar value with which the scalar - * division should be computed. - * \return A reference to this two-dimensional vector. - */ - inline Vector2 &operator/=(float s) - { - const float invS = 1.0f / s; - x_ *= invS; - y_ *= invS; - - return *this; - } - - /** - * \brief Sets the value of this two-dimensional vector to the vector - * sum of itself with the specified two-dimensional vector. - * \param vector The two-dimensional vector with which the - * vector sum should be computed. - * \return A reference to this two-dimensional vector. - */ - inline Vector2 &operator+=(const Vector2 &vector) - { - x_ += vector.x(); - y_ += vector.y(); - - return *this; - } - - /** - * \brief Sets the value of this two-dimensional vector to the vector - * difference of itself with the specified two-dimensional - * vector. - * \param vector The two-dimensional vector with which the - * vector difference should be computed. - * \return A reference to this two-dimensional vector. - */ - inline Vector2 &operator-=(const Vector2 &vector) - { - x_ -= vector.x(); - y_ -= vector.y(); - - return *this; - } - - inline Vector2 &operator=(const Vector2 &vector) - { - x_ = vector.x(); - y_ = vector.y(); - - return *this; - } - - private: - float x_; - float y_; - }; - - /** - * \relates Vector2 - * \brief Computes the scalar multiplication of the specified - * two-dimensional vector with the specified scalar value. - * \param s The scalar value with which the scalar - * multiplication should be computed. - * \param vector The two-dimensional vector with which the scalar - * multiplication should be computed. - * \return The scalar multiplication of the two-dimensional vector with the - * scalar value. - */ - inline Vector2 operator*(float s, const Vector2 &vector) - { - return Vector2(s * vector.x(), s * vector.y()); - } - - /** - * \relates Vector2 - * \brief Inserts the specified two-dimensional vector into the specified - * output stream. - * \param os The output stream into which the two-dimensional - * vector should be inserted. - * \param vector The two-dimensional vector which to insert into - * the output stream. - * \return A reference to the output stream. - */ - inline std::ostream &operator<<(std::ostream &os, const Vector2 &vector) - { - os << "(" << vector.x() << "," << vector.y() << ")"; - - return os; - } - - /** - * \relates Vector2 - * \brief Computes the length of a specified two-dimensional vector. - * \param vector The two-dimensional vector whose length is to be - * computed. - * \return The length of the two-dimensional vector. - */ - inline float abs(const Vector2 &vector) - { - return std::sqrt(vector * vector); - } - - /** - * \relates Vector2 - * \brief Computes the squared length of a specified two-dimensional - * vector. - * \param vector The two-dimensional vector whose squared length - * is to be computed. - * \return The squared length of the two-dimensional vector. - */ - inline float absSq(const Vector2 &vector) - { - return vector * vector; - } - - /** - * \relates Vector2 - * \brief Computes the determinant of a two-dimensional square matrix with - * rows consisting of the specified two-dimensional vectors. - * \param vector1 The top row of the two-dimensional square - * matrix. - * \param vector2 The bottom row of the two-dimensional square - * matrix. - * \return The determinant of the two-dimensional square matrix. - */ - inline float det(const Vector2 &vector1, const Vector2 &vector2) - { - return vector1.x() * vector2.y() - vector1.y() * vector2.x(); - } - - /** - * \relates Vector2 - * \brief Computes the normalization of the specified two-dimensional - * vector. - * \param vector The two-dimensional vector whose normalization - * is to be computed. - * \return The normalization of the two-dimensional vector. - */ - inline Vector2 normalize(const Vector2 &vector) - { - return vector / abs(vector); - } -} - -#endif /* RVO_VECTOR2_H_ */ diff --git a/thirdparty/rvo2/rvo2_3d/Agent3d.cpp b/thirdparty/rvo2/rvo2_3d/Agent3d.cpp deleted file mode 100644 index bddf226..0000000 --- a/thirdparty/rvo2/rvo2_3d/Agent3d.cpp +++ /dev/null @@ -1,449 +0,0 @@ -/* - * Agent.cpp - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "Agent3d.h" - -#include -#include - -#include "Definitions.h" -#include "KdTree3d.h" - -namespace RVO3D { - /** - * \brief A sufficiently small positive number. - */ - const float RVO3D_EPSILON = 0.00001f; - - /** - * \brief Defines a directed line. - */ - class Line3D { - public: - /** - * \brief The direction of the directed line. - */ - Vector3 direction; - - /** - * \brief A point on the directed line. - */ - Vector3 point; - }; - - /** - * \brief Solves a one-dimensional linear program on a specified line subject to linear constraints defined by planes and a spherical constraint. - * \param planes Planes defining the linear constraints. - * \param planeNo The plane on which the line lies. - * \param line The line on which the 1-d linear program is solved - * \param radius The radius of the spherical constraint. - * \param optVelocity The optimization velocity. - * \param directionOpt True if the direction should be optimized. - * \param result A reference to the result of the linear program. - * \return True if successful. - */ - bool linearProgram1(const std::vector &planes, size_t planeNo, const Line3D &line, float radius, const Vector3 &optVelocity, bool directionOpt, Vector3 &result); - - /** - * \brief Solves a two-dimensional linear program on a specified plane subject to linear constraints defined by planes and a spherical constraint. - * \param planes Planes defining the linear constraints. - * \param planeNo The plane on which the 2-d linear program is solved - * \param radius The radius of the spherical constraint. - * \param optVelocity The optimization velocity. - * \param directionOpt True if the direction should be optimized. - * \param result A reference to the result of the linear program. - * \return True if successful. - */ - bool linearProgram2(const std::vector &planes, size_t planeNo, float radius, const Vector3 &optVelocity, bool directionOpt, Vector3 &result); - - /** - * \brief Solves a three-dimensional linear program subject to linear constraints defined by planes and a spherical constraint. - * \param planes Planes defining the linear constraints. - * \param radius The radius of the spherical constraint. - * \param optVelocity The optimization velocity. - * \param directionOpt True if the direction should be optimized. - * \param result A reference to the result of the linear program. - * \return The number of the plane it fails on, and the number of planes if successful. - */ - size_t linearProgram3(const std::vector &planes, float radius, const Vector3 &optVelocity, bool directionOpt, Vector3 &result); - - /** - * \brief Solves a four-dimensional linear program subject to linear constraints defined by planes and a spherical constraint. - * \param planes Planes defining the linear constraints. - * \param beginPlane The plane on which the 3-d linear program failed. - * \param radius The radius of the spherical constraint. - * \param result A reference to the result of the linear program. - */ - void linearProgram4(const std::vector &planes, size_t beginPlane, float radius, Vector3 &result); - - Agent3D::Agent3D() : id_(0), maxNeighbors_(0), maxSpeed_(0.0f), neighborDist_(0.0f), radius_(0.0f), timeHorizon_(0.0f) { } - - void Agent3D::computeNeighbors(RVOSimulator3D *sim_) - { - agentNeighbors_.clear(); - - if (maxNeighbors_ > 0) { - sim_->kdTree_->computeAgentNeighbors(this, neighborDist_ * neighborDist_); - } - } - - void Agent3D::computeNewVelocity(RVOSimulator3D *sim_) - { - orcaPlanes_.clear(); - - const float invTimeHorizon = 1.0f / timeHorizon_; - - /* Create agent ORCA planes. */ - for (size_t i = 0; i < agentNeighbors_.size(); ++i) { - const Agent3D *const other = agentNeighbors_[i].second; - - //const float timeHorizon_mod = (avoidance_priority_ - other->avoidance_priority_ + 1.0f) * 0.5f; - //const float invTimeHorizon = (1.0f / timeHorizon_) * timeHorizon_mod; - - const Vector3 relativePosition = other->position_ - position_; - const Vector3 relativeVelocity = velocity_ - other->velocity_; - const float distSq = absSq(relativePosition); - const float combinedRadius = radius_ + other->radius_; - const float combinedRadiusSq = sqr(combinedRadius); - - Plane plane; - Vector3 u; - - if (distSq > combinedRadiusSq) { - /* No collision. */ - const Vector3 w = relativeVelocity - invTimeHorizon * relativePosition; - /* Vector from cutoff center to relative velocity. */ - const float wLengthSq = absSq(w); - - const float dotProduct = w * relativePosition; - - if (dotProduct < 0.0f && sqr(dotProduct) > combinedRadiusSq * wLengthSq) { - /* Project on cut-off circle. */ - const float wLength = std::sqrt(wLengthSq); - const Vector3 unitW = w / wLength; - - plane.normal = unitW; - u = (combinedRadius * invTimeHorizon - wLength) * unitW; - } - else { - /* Project on cone. */ - const float a = distSq; - const float b = relativePosition * relativeVelocity; - const float c = absSq(relativeVelocity) - absSq(cross(relativePosition, relativeVelocity)) / (distSq - combinedRadiusSq); - const float t = (b + std::sqrt(sqr(b) - a * c)) / a; - const Vector3 w = relativeVelocity - t * relativePosition; - const float wLength = abs(w); - const Vector3 unitW = w / wLength; - - plane.normal = unitW; - u = (combinedRadius * t - wLength) * unitW; - } - } - else { - /* Collision. */ - const float invTimeStep = 1.0f / sim_->timeStep_; - const Vector3 w = relativeVelocity - invTimeStep * relativePosition; - const float wLength = abs(w); - const Vector3 unitW = w / wLength; - - plane.normal = unitW; - u = (combinedRadius * invTimeStep - wLength) * unitW; - } - - plane.point = velocity_ + 0.5f * u; - orcaPlanes_.push_back(plane); - } - - const size_t planeFail = linearProgram3(orcaPlanes_, maxSpeed_, prefVelocity_, false, newVelocity_); - - if (planeFail < orcaPlanes_.size()) { - linearProgram4(orcaPlanes_, planeFail, maxSpeed_, newVelocity_); - } - } - - void Agent3D::insertAgentNeighbor(const Agent3D *agent, float &rangeSq) - { - // no point processing same agent - if (this == agent) { - return; - } - // ignore other agent if layers/mask bitmasks have no matching bit - if ((avoidance_mask_ & agent->avoidance_layers_) == 0) { - return; - } - - if (avoidance_priority_ > agent->avoidance_priority_) { - return; - } - - const float distSq = absSq(position_ - agent->position_); - - if (distSq < rangeSq) { - if (agentNeighbors_.size() < maxNeighbors_) { - agentNeighbors_.push_back(std::make_pair(distSq, agent)); - } - - size_t i = agentNeighbors_.size() - 1; - - while (i != 0 && distSq < agentNeighbors_[i - 1].first) { - agentNeighbors_[i] = agentNeighbors_[i - 1]; - --i; - } - - agentNeighbors_[i] = std::make_pair(distSq, agent); - - if (agentNeighbors_.size() == maxNeighbors_) { - rangeSq = agentNeighbors_.back().first; - } - } - } - - void Agent3D::update(RVOSimulator3D *sim_) - { - velocity_ = newVelocity_; - position_ += velocity_ * sim_->timeStep_; - } - - bool linearProgram1(const std::vector &planes, size_t planeNo, const Line3D &line, float radius, const Vector3 &optVelocity, bool directionOpt, Vector3 &result) - { - const float dotProduct = line.point * line.direction; - const float discriminant = sqr(dotProduct) + sqr(radius) - absSq(line.point); - - if (discriminant < 0.0f) { - /* Max speed sphere fully invalidates line. */ - return false; - } - - const float sqrtDiscriminant = std::sqrt(discriminant); - float tLeft = -dotProduct - sqrtDiscriminant; - float tRight = -dotProduct + sqrtDiscriminant; - - for (size_t i = 0; i < planeNo; ++i) { - const float numerator = (planes[i].point - line.point) * planes[i].normal; - const float denominator = line.direction * planes[i].normal; - - if (sqr(denominator) <= RVO3D_EPSILON) { - /* Lines3D line is (almost) parallel to plane i. */ - if (numerator > 0.0f) { - return false; - } - else { - continue; - } - } - - const float t = numerator / denominator; - - if (denominator >= 0.0f) { - /* Plane i bounds line on the left. */ - tLeft = std::max(tLeft, t); - } - else { - /* Plane i bounds line on the right. */ - tRight = std::min(tRight, t); - } - - if (tLeft > tRight) { - return false; - } - } - - if (directionOpt) { - /* Optimize direction. */ - if (optVelocity * line.direction > 0.0f) { - /* Take right extreme. */ - result = line.point + tRight * line.direction; - } - else { - /* Take left extreme. */ - result = line.point + tLeft * line.direction; - } - } - else { - /* Optimize closest point. */ - const float t = line.direction * (optVelocity - line.point); - - if (t < tLeft) { - result = line.point + tLeft * line.direction; - } - else if (t > tRight) { - result = line.point + tRight * line.direction; - } - else { - result = line.point + t * line.direction; - } - } - - return true; - } - - bool linearProgram2(const std::vector &planes, size_t planeNo, float radius, const Vector3 &optVelocity, bool directionOpt, Vector3 &result) - { - const float planeDist = planes[planeNo].point * planes[planeNo].normal; - const float planeDistSq = sqr(planeDist); - const float radiusSq = sqr(radius); - - if (planeDistSq > radiusSq) { - /* Max speed sphere fully invalidates plane planeNo. */ - return false; - } - - const float planeRadiusSq = radiusSq - planeDistSq; - - const Vector3 planeCenter = planeDist * planes[planeNo].normal; - - if (directionOpt) { - /* Project direction optVelocity on plane planeNo. */ - const Vector3 planeOptVelocity = optVelocity - (optVelocity * planes[planeNo].normal) * planes[planeNo].normal; - const float planeOptVelocityLengthSq = absSq(planeOptVelocity); - - if (planeOptVelocityLengthSq <= RVO3D_EPSILON) { - result = planeCenter; - } - else { - result = planeCenter + std::sqrt(planeRadiusSq / planeOptVelocityLengthSq) * planeOptVelocity; - } - } - else { - /* Project point optVelocity on plane planeNo. */ - result = optVelocity + ((planes[planeNo].point - optVelocity) * planes[planeNo].normal) * planes[planeNo].normal; - - /* If outside planeCircle, project on planeCircle. */ - if (absSq(result) > radiusSq) { - const Vector3 planeResult = result - planeCenter; - const float planeResultLengthSq = absSq(planeResult); - result = planeCenter + std::sqrt(planeRadiusSq / planeResultLengthSq) * planeResult; - } - } - - for (size_t i = 0; i < planeNo; ++i) { - if (planes[i].normal * (planes[i].point - result) > 0.0f) { - /* Result does not satisfy constraint i. Compute new optimal result. */ - /* Compute intersection line of plane i and plane planeNo. */ - Vector3 crossProduct = cross(planes[i].normal, planes[planeNo].normal); - - if (absSq(crossProduct) <= RVO3D_EPSILON) { - /* Planes planeNo and i are (almost) parallel, and plane i fully invalidates plane planeNo. */ - return false; - } - - Line3D line; - line.direction = normalize(crossProduct); - const Vector3 lineNormal = cross(line.direction, planes[planeNo].normal); - line.point = planes[planeNo].point + (((planes[i].point - planes[planeNo].point) * planes[i].normal) / (lineNormal * planes[i].normal)) * lineNormal; - - if (!linearProgram1(planes, i, line, radius, optVelocity, directionOpt, result)) { - return false; - } - } - } - - return true; - } - - size_t linearProgram3(const std::vector &planes, float radius, const Vector3 &optVelocity, bool directionOpt, Vector3 &result) - { - if (directionOpt) { - /* Optimize direction. Note that the optimization velocity is of unit length in this case. */ - result = optVelocity * radius; - } - else if (absSq(optVelocity) > sqr(radius)) { - /* Optimize closest point and outside circle. */ - result = normalize(optVelocity) * radius; - } - else { - /* Optimize closest point and inside circle. */ - result = optVelocity; - } - - for (size_t i = 0; i < planes.size(); ++i) { - if (planes[i].normal * (planes[i].point - result) > 0.0f) { - /* Result does not satisfy constraint i. Compute new optimal result. */ - const Vector3 tempResult = result; - - if (!linearProgram2(planes, i, radius, optVelocity, directionOpt, result)) { - result = tempResult; - return i; - } - } - } - - return planes.size(); - } - - void linearProgram4(const std::vector &planes, size_t beginPlane, float radius, Vector3 &result) - { - float distance = 0.0f; - - for (size_t i = beginPlane; i < planes.size(); ++i) { - if (planes[i].normal * (planes[i].point - result) > distance) { - /* Result does not satisfy constraint of plane i. */ - std::vector projPlanes; - - for (size_t j = 0; j < i; ++j) { - Plane plane; - - const Vector3 crossProduct = cross(planes[j].normal, planes[i].normal); - - if (absSq(crossProduct) <= RVO3D_EPSILON) { - /* Plane i and plane j are (almost) parallel. */ - if (planes[i].normal * planes[j].normal > 0.0f) { - /* Plane i and plane j point in the same direction. */ - continue; - } - else { - /* Plane i and plane j point in opposite direction. */ - plane.point = 0.5f * (planes[i].point + planes[j].point); - } - } - else { - /* Plane.point is point on line of intersection between plane i and plane j. */ - const Vector3 lineNormal = cross(crossProduct, planes[i].normal); - plane.point = planes[i].point + (((planes[j].point - planes[i].point) * planes[j].normal) / (lineNormal * planes[j].normal)) * lineNormal; - } - - plane.normal = normalize(planes[j].normal - planes[i].normal); - projPlanes.push_back(plane); - } - - const Vector3 tempResult = result; - - if (linearProgram3(projPlanes, radius, planes[i].normal, true, result) < projPlanes.size()) { - /* This should in principle not happen. The result is by definition already in the feasible region of this linear program. If it fails, it is due to small floating point error, and the current result is kept. */ - result = tempResult; - } - - distance = planes[i].normal * (planes[i].point - result); - } - } - } -} diff --git a/thirdparty/rvo2/rvo2_3d/Agent3d.h b/thirdparty/rvo2/rvo2_3d/Agent3d.h deleted file mode 100644 index d99e3ca..0000000 --- a/thirdparty/rvo2/rvo2_3d/Agent3d.h +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Agent.h - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -/** - * \file Agent.h - * \brief Contains the Agent class. - */ -#ifndef RVO3D_AGENT_H_ -#define RVO3D_AGENT_H_ - -#include -#include -#include -#include - -#include "RVOSimulator3d.h" -#include "Vector3.h" - -namespace RVO3D { - /** - * \brief Defines an agent in the simulation. - */ - class Agent3D { - public: - /** - * \brief Constructs an agent instance. - * \param sim The simulator instance. - */ - explicit Agent3D(); - - /** - * \brief Computes the neighbors of this agent. - */ - void computeNeighbors(RVOSimulator3D *sim_); - - /** - * \brief Computes the new velocity of this agent. - */ - void computeNewVelocity(RVOSimulator3D *sim_); - - /** - * \brief Inserts an agent neighbor into the set of neighbors of this agent. - * \param agent A pointer to the agent to be inserted. - * \param rangeSq The squared range around this agent. - */ - void insertAgentNeighbor(const Agent3D *agent, float &rangeSq); - - /** - * \brief Updates the three-dimensional position and three-dimensional velocity of this agent. - */ - void update(RVOSimulator3D *sim_); - - Vector3 newVelocity_; - Vector3 position_; - Vector3 prefVelocity_; - Vector3 velocity_; - RVOSimulator3D *sim_; - size_t id_; - size_t maxNeighbors_; - float maxSpeed_; - float neighborDist_; - float radius_; - float timeHorizon_; - float timeHorizonObst_; - std::vector > agentNeighbors_; - std::vector orcaPlanes_; - float height_ = 1.0; - uint32_t avoidance_layers_ = 1; - uint32_t avoidance_mask_ = 1; - float avoidance_priority_ = 1.0; - - friend class KdTree3D; - friend class RVOSimulator3D; - }; -} - -#endif /* RVO3D_AGENT_H_ */ diff --git a/thirdparty/rvo2/rvo2_3d/Definitions.h b/thirdparty/rvo2/rvo2_3d/Definitions.h deleted file mode 100644 index 34d1d06..0000000 --- a/thirdparty/rvo2/rvo2_3d/Definitions.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Definitions.h - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -/** - * \file Definitions.h - * \brief Contains functions and constants used in multiple classes. - */ - -#ifndef RVO3D_DEFINITIONS_H_ -#define RVO3D_DEFINITIONS_H_ - -namespace RVO3D { - /** - * \brief Computes the square of a float. - * \param scalar The float to be squared. - * \return The square of the float. - */ - inline float sqr(float scalar) - { - return scalar * scalar; - } -} - -#endif /* RVO3D_DEFINITIONS_H_ */ diff --git a/thirdparty/rvo2/rvo2_3d/KdTree3d.cpp b/thirdparty/rvo2/rvo2_3d/KdTree3d.cpp deleted file mode 100644 index 2534871..0000000 --- a/thirdparty/rvo2/rvo2_3d/KdTree3d.cpp +++ /dev/null @@ -1,161 +0,0 @@ -/* - * KdTree.cpp - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "KdTree3d.h" - -#include - -#include "Agent3d.h" -#include "Definitions.h" -#include "RVOSimulator3d.h" - -namespace RVO3D { - const size_t RVO3D_MAX_LEAF_SIZE = 10; - - KdTree3D::KdTree3D(RVOSimulator3D *sim) : sim_(sim) { } - - void KdTree3D::buildAgentTree(std::vector agents) - { - agents_.swap(agents); - - if (!agents_.empty()) { - agentTree_.resize(2 * agents_.size() - 1); - buildAgentTreeRecursive(0, agents_.size(), 0); - } - } - - void KdTree3D::buildAgentTreeRecursive(size_t begin, size_t end, size_t node) - { - agentTree_[node].begin = begin; - agentTree_[node].end = end; - agentTree_[node].minCoord = agents_[begin]->position_; - agentTree_[node].maxCoord = agents_[begin]->position_; - - for (size_t i = begin + 1; i < end; ++i) { - agentTree_[node].maxCoord[0] = std::max(agentTree_[node].maxCoord[0], agents_[i]->position_.x()); - agentTree_[node].minCoord[0] = std::min(agentTree_[node].minCoord[0], agents_[i]->position_.x()); - agentTree_[node].maxCoord[1] = std::max(agentTree_[node].maxCoord[1], agents_[i]->position_.y()); - agentTree_[node].minCoord[1] = std::min(agentTree_[node].minCoord[1], agents_[i]->position_.y()); - agentTree_[node].maxCoord[2] = std::max(agentTree_[node].maxCoord[2], agents_[i]->position_.z()); - agentTree_[node].minCoord[2] = std::min(agentTree_[node].minCoord[2], agents_[i]->position_.z()); - } - - if (end - begin > RVO3D_MAX_LEAF_SIZE) { - /* No leaf node. */ - size_t coord; - - if (agentTree_[node].maxCoord[0] - agentTree_[node].minCoord[0] > agentTree_[node].maxCoord[1] - agentTree_[node].minCoord[1] && agentTree_[node].maxCoord[0] - agentTree_[node].minCoord[0] > agentTree_[node].maxCoord[2] - agentTree_[node].minCoord[2]) { - coord = 0; - } - else if (agentTree_[node].maxCoord[1] - agentTree_[node].minCoord[1] > agentTree_[node].maxCoord[2] - agentTree_[node].minCoord[2]) { - coord = 1; - } - else { - coord = 2; - } - - const float splitValue = 0.5f * (agentTree_[node].maxCoord[coord] + agentTree_[node].minCoord[coord]); - - size_t left = begin; - - size_t right = end; - - while (left < right) { - while (left < right && agents_[left]->position_[coord] < splitValue) { - ++left; - } - - while (right > left && agents_[right - 1]->position_[coord] >= splitValue) { - --right; - } - - if (left < right) { - std::swap(agents_[left], agents_[right - 1]); - ++left; - --right; - } - } - - size_t leftSize = left - begin; - - if (leftSize == 0) { - ++leftSize; - ++left; - ++right; - } - - agentTree_[node].left = node + 1; - agentTree_[node].right = node + 2 * leftSize; - - buildAgentTreeRecursive(begin, left, agentTree_[node].left); - buildAgentTreeRecursive(left, end, agentTree_[node].right); - } - } - - void KdTree3D::computeAgentNeighbors(Agent3D *agent, float rangeSq) const - { - queryAgentTreeRecursive(agent, rangeSq, 0); - } - - void KdTree3D::queryAgentTreeRecursive(Agent3D *agent, float &rangeSq, size_t node) const - { - if (agentTree_[node].end - agentTree_[node].begin <= RVO3D_MAX_LEAF_SIZE) { - for (size_t i = agentTree_[node].begin; i < agentTree_[node].end; ++i) { - agent->insertAgentNeighbor(agents_[i], rangeSq); - } - } - else { - const float distSqLeft = sqr(std::max(0.0f, agentTree_[agentTree_[node].left].minCoord[0] - agent->position_.x())) + sqr(std::max(0.0f, agent->position_.x() - agentTree_[agentTree_[node].left].maxCoord[0])) + sqr(std::max(0.0f, agentTree_[agentTree_[node].left].minCoord[1] - agent->position_.y())) + sqr(std::max(0.0f, agent->position_.y() - agentTree_[agentTree_[node].left].maxCoord[1])) + sqr(std::max(0.0f, agentTree_[agentTree_[node].left].minCoord[2] - agent->position_.z())) + sqr(std::max(0.0f, agent->position_.z() - agentTree_[agentTree_[node].left].maxCoord[2])); - - const float distSqRight = sqr(std::max(0.0f, agentTree_[agentTree_[node].right].minCoord[0] - agent->position_.x())) + sqr(std::max(0.0f, agent->position_.x() - agentTree_[agentTree_[node].right].maxCoord[0])) + sqr(std::max(0.0f, agentTree_[agentTree_[node].right].minCoord[1] - agent->position_.y())) + sqr(std::max(0.0f, agent->position_.y() - agentTree_[agentTree_[node].right].maxCoord[1])) + sqr(std::max(0.0f, agentTree_[agentTree_[node].right].minCoord[2] - agent->position_.z())) + sqr(std::max(0.0f, agent->position_.z() - agentTree_[agentTree_[node].right].maxCoord[2])); - - if (distSqLeft < distSqRight) { - if (distSqLeft < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].left); - - if (distSqRight < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].right); - } - } - } - else { - if (distSqRight < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].right); - - if (distSqLeft < rangeSq) { - queryAgentTreeRecursive(agent, rangeSq, agentTree_[node].left); - } - } - } - } - } -} diff --git a/thirdparty/rvo2/rvo2_3d/KdTree3d.h b/thirdparty/rvo2/rvo2_3d/KdTree3d.h deleted file mode 100644 index c018f98..0000000 --- a/thirdparty/rvo2/rvo2_3d/KdTree3d.h +++ /dev/null @@ -1,120 +0,0 @@ -/* - * KdTree.h - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ -/** - * \file KdTree.h - * \brief Contains the KdTree class. - */ -#ifndef RVO3D_KD_TREE_H_ -#define RVO3D_KD_TREE_H_ - -#include -#include - -#include "Vector3.h" - -namespace RVO3D { - class Agent3D; - class RVOSimulator3D; - - /** - * \brief Defines kd-trees for agents in the simulation. - */ - class KdTree3D { - public: - /** - * \brief Defines an agent kd-tree node. - */ - class AgentTreeNode3D { - public: - /** - * \brief The beginning node number. - */ - size_t begin; - - /** - * \brief The ending node number. - */ - size_t end; - - /** - * \brief The left node number. - */ - size_t left; - - /** - * \brief The right node number. - */ - size_t right; - - /** - * \brief The maximum coordinates. - */ - Vector3 maxCoord; - - /** - * \brief The minimum coordinates. - */ - Vector3 minCoord; - }; - - /** - * \brief Constructs a kd-tree instance. - * \param sim The simulator instance. - */ - explicit KdTree3D(RVOSimulator3D *sim); - - /** - * \brief Builds an agent kd-tree. - */ - void buildAgentTree(std::vector agents); - - void buildAgentTreeRecursive(size_t begin, size_t end, size_t node); - - /** - * \brief Computes the agent neighbors of the specified agent. - * \param agent A pointer to the agent for which agent neighbors are to be computed. - * \param rangeSq The squared range around the agent. - */ - void computeAgentNeighbors(Agent3D *agent, float rangeSq) const; - - void queryAgentTreeRecursive(Agent3D *agent, float &rangeSq, size_t node) const; - - std::vector agents_; - std::vector agentTree_; - RVOSimulator3D *sim_; - - friend class Agent3D; - friend class RVOSimulator3D; - }; -} - -#endif /* RVO3D_KD_TREE_H_ */ diff --git a/thirdparty/rvo2/rvo2_3d/RVOSimulator3d.cpp b/thirdparty/rvo2/rvo2_3d/RVOSimulator3d.cpp deleted file mode 100644 index 71e5aea..0000000 --- a/thirdparty/rvo2/rvo2_3d/RVOSimulator3d.cpp +++ /dev/null @@ -1,274 +0,0 @@ -/* - * RVOSimulator.cpp - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -#include "RVOSimulator3d.h" - -#ifdef _OPENMP -#include -#endif - -#include "Agent3d.h" -#include "KdTree3d.h" - -namespace RVO3D { - RVOSimulator3D::RVOSimulator3D() : defaultAgent_(NULL), kdTree_(NULL), globalTime_(0.0f), timeStep_(0.0f) - { - kdTree_ = new KdTree3D(this); - } - - RVOSimulator3D::RVOSimulator3D(float timeStep, float neighborDist, size_t maxNeighbors, float timeHorizon, float radius, float maxSpeed, const Vector3 &velocity) : defaultAgent_(NULL), kdTree_(NULL), globalTime_(0.0f), timeStep_(timeStep) - { - kdTree_ = new KdTree3D(this); - defaultAgent_ = new Agent3D(); - - defaultAgent_->maxNeighbors_ = maxNeighbors; - defaultAgent_->maxSpeed_ = maxSpeed; - defaultAgent_->neighborDist_ = neighborDist; - defaultAgent_->radius_ = radius; - defaultAgent_->timeHorizon_ = timeHorizon; - defaultAgent_->velocity_ = velocity; - } - - RVOSimulator3D::~RVOSimulator3D() - { - if (defaultAgent_ != NULL) { - delete defaultAgent_; - } - - for (size_t i = 0; i < agents_.size(); ++i) { - delete agents_[i]; - } - - if (kdTree_ != NULL) { - delete kdTree_; - } - } - - size_t RVOSimulator3D::getAgentNumAgentNeighbors(size_t agentNo) const - { - return agents_[agentNo]->agentNeighbors_.size(); - } - - size_t RVOSimulator3D::getAgentAgentNeighbor(size_t agentNo, size_t neighborNo) const - { - return agents_[agentNo]->agentNeighbors_[neighborNo].second->id_; - } - - size_t RVOSimulator3D::getAgentNumORCAPlanes(size_t agentNo) const - { - return agents_[agentNo]->orcaPlanes_.size(); - } - - const Plane &RVOSimulator3D::getAgentORCAPlane(size_t agentNo, size_t planeNo) const - { - return agents_[agentNo]->orcaPlanes_[planeNo]; - } - - void RVOSimulator3D::removeAgent(size_t agentNo) - { - delete agents_[agentNo]; - agents_[agentNo] = agents_.back(); - agents_.pop_back(); - } - - size_t RVOSimulator3D::addAgent(const Vector3 &position) - { - if (defaultAgent_ == NULL) { - return RVO3D_ERROR; - } - - Agent3D *agent = new Agent3D(); - - agent->position_ = position; - agent->maxNeighbors_ = defaultAgent_->maxNeighbors_; - agent->maxSpeed_ = defaultAgent_->maxSpeed_; - agent->neighborDist_ = defaultAgent_->neighborDist_; - agent->radius_ = defaultAgent_->radius_; - agent->timeHorizon_ = defaultAgent_->timeHorizon_; - agent->velocity_ = defaultAgent_->velocity_; - - agent->id_ = agents_.size(); - - agents_.push_back(agent); - - return agents_.size() - 1; - } - - size_t RVOSimulator3D::addAgent(const Vector3 &position, float neighborDist, size_t maxNeighbors, float timeHorizon, float radius, float maxSpeed, const Vector3 &velocity) - { - Agent3D *agent = new Agent3D(); - - agent->position_ = position; - agent->maxNeighbors_ = maxNeighbors; - agent->maxSpeed_ = maxSpeed; - agent->neighborDist_ = neighborDist; - agent->radius_ = radius; - agent->timeHorizon_ = timeHorizon; - agent->velocity_ = velocity; - - agent->id_ = agents_.size(); - - agents_.push_back(agent); - - return agents_.size() - 1; - } - - void RVOSimulator3D::doStep() - { - kdTree_->buildAgentTree(agents_); - - for (int i = 0; i < static_cast(agents_.size()); ++i) { - agents_[i]->computeNeighbors(this); - agents_[i]->computeNewVelocity(this); - } - - for (int i = 0; i < static_cast(agents_.size()); ++i) { - agents_[i]->update(this); - } - - globalTime_ += timeStep_; - } - - size_t RVOSimulator3D::getAgentMaxNeighbors(size_t agentNo) const - { - return agents_[agentNo]->maxNeighbors_; - } - - float RVOSimulator3D::getAgentMaxSpeed(size_t agentNo) const - { - return agents_[agentNo]->maxSpeed_; - } - - float RVOSimulator3D::getAgentNeighborDist(size_t agentNo) const - { - return agents_[agentNo]->neighborDist_; - } - - const Vector3 &RVOSimulator3D::getAgentPosition(size_t agentNo) const - { - return agents_[agentNo]->position_; - } - - const Vector3 &RVOSimulator3D::getAgentPrefVelocity(size_t agentNo) const - { - return agents_[agentNo]->prefVelocity_; - } - - float RVOSimulator3D::getAgentRadius(size_t agentNo) const - { - return agents_[agentNo]->radius_; - } - - float RVOSimulator3D::getAgentTimeHorizon(size_t agentNo) const - { - return agents_[agentNo]->timeHorizon_; - } - - const Vector3 &RVOSimulator3D::getAgentVelocity(size_t agentNo) const - { - return agents_[agentNo]->velocity_; - } - - float RVOSimulator3D::getGlobalTime() const - { - return globalTime_; - } - - size_t RVOSimulator3D::getNumAgents() const - { - return agents_.size(); - } - - float RVOSimulator3D::getTimeStep() const - { - return timeStep_; - } - - void RVOSimulator3D::setAgentDefaults(float neighborDist, size_t maxNeighbors, float timeHorizon, float radius, float maxSpeed, const Vector3 &velocity) - { - if (defaultAgent_ == NULL) { - defaultAgent_ = new Agent3D(); - } - - defaultAgent_->maxNeighbors_ = maxNeighbors; - defaultAgent_->maxSpeed_ = maxSpeed; - defaultAgent_->neighborDist_ = neighborDist; - defaultAgent_->radius_ = radius; - defaultAgent_->timeHorizon_ = timeHorizon; - defaultAgent_->velocity_ = velocity; - } - - void RVOSimulator3D::setAgentMaxNeighbors(size_t agentNo, size_t maxNeighbors) - { - agents_[agentNo]->maxNeighbors_ = maxNeighbors; - } - - void RVOSimulator3D::setAgentMaxSpeed(size_t agentNo, float maxSpeed) - { - agents_[agentNo]->maxSpeed_ = maxSpeed; - } - - void RVOSimulator3D::setAgentNeighborDist(size_t agentNo, float neighborDist) - { - agents_[agentNo]->neighborDist_ = neighborDist; - } - - void RVOSimulator3D::setAgentPosition(size_t agentNo, const Vector3 &position) - { - agents_[agentNo]->position_ = position; - } - - void RVOSimulator3D::setAgentPrefVelocity(size_t agentNo, const Vector3 &prefVelocity) - { - agents_[agentNo]->prefVelocity_ = prefVelocity; - } - - void RVOSimulator3D::setAgentRadius(size_t agentNo, float radius) - { - agents_[agentNo]->radius_ = radius; - } - - void RVOSimulator3D::setAgentTimeHorizon(size_t agentNo, float timeHorizon) - { - agents_[agentNo]->timeHorizon_ = timeHorizon; - } - - void RVOSimulator3D::setAgentVelocity(size_t agentNo, const Vector3 &velocity) - { - agents_[agentNo]->velocity_ = velocity; - } - - void RVOSimulator3D::setTimeStep(float timeStep) - { - timeStep_ = timeStep; - } -} diff --git a/thirdparty/rvo2/rvo2_3d/RVOSimulator3d.h b/thirdparty/rvo2/rvo2_3d/RVOSimulator3d.h deleted file mode 100644 index 4ea093d..0000000 --- a/thirdparty/rvo2/rvo2_3d/RVOSimulator3d.h +++ /dev/null @@ -1,324 +0,0 @@ -/* - * RVOSimulator.h - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -/** - * \file RVOSimulator.h - * \brief Contains the RVOSimulator class. - */ -#ifndef RVO3D_RVO_SIMULATOR_H_ -#define RVO3D_RVO_SIMULATOR_H_ - -#include -#include -#include - -#include "Vector3.h" - -namespace RVO3D { - class Agent3D; - class KdTree3D; - - /** - * \brief Error value. - * - * A value equal to the largest unsigned integer, which is returned in case of an error by functions in RVO3D::RVOSimulator. - */ - const size_t RVO3D_ERROR = std::numeric_limits::max(); - - /** - * \brief Defines a plane. - */ - class Plane { - public: - /** - * \brief A point on the plane. - */ - Vector3 point; - - /** - * \brief The normal to the plane. - */ - Vector3 normal; - }; - - /** - * \brief Defines the simulation. - * - * The main class of the library that contains all simulation functionality. - */ - class RVOSimulator3D { - public: - /** - * \brief Constructs a simulator instance. - */ - RVOSimulator3D(); - - /** - * \brief Constructs a simulator instance and sets the default properties for any new agent that is added. - * \param timeStep The time step of the simulation. Must be positive. - * \param neighborDist The default maximum distance (center point to center point) to other agents a new agent takes into account in the navigation. The larger this number, the longer he running time of the simulation. If the number is too low, the simulation will not be safe. Must be non-negative. - * \param maxNeighbors The default maximum number of other agents a new agent takes into account in the navigation. The larger this number, the longer the running time of the simulation. If the number is too low, the simulation will not be safe. - * \param timeHorizon The default minimum amount of time for which a new agent's velocities that are computed by the simulation are safe with respect to other agents. The larger this number, the sooner an agent will respond to the presence of other agents, but the less freedom the agent has in choosing its velocities. Must be positive. - * \param radius The default radius of a new agent. Must be non-negative. - * \param maxSpeed The default maximum speed of a new agent. Must be non-negative. - * \param velocity The default initial three-dimensional linear velocity of a new agent (optional). - */ - RVOSimulator3D(float timeStep, float neighborDist, size_t maxNeighbors, float timeHorizon, float radius, float maxSpeed, const Vector3 &velocity = Vector3()); - - /** - * \brief Destroys this simulator instance. - */ - ~RVOSimulator3D(); - - /** - * \brief Adds a new agent with default properties to the simulation. - * \param position The three-dimensional starting position of this agent. - * \return The number of the agent, or RVO3D::RVO3D_ERROR when the agent defaults have not been set. - */ - size_t addAgent(const Vector3 &position); - - /** - * \brief Adds a new agent to the simulation. - * \param position The three-dimensional starting position of this agent. - * \param neighborDist The maximum distance (center point to center point) to other agents this agent takes into account in the navigation. The larger this number, the longer the running time of the simulation. If the number is too low, the simulation will not be safe. Must be non-negative. - * \param maxNeighbors The maximum number of other agents this agent takes into account in the navigation. The larger this number, the longer the running time of the simulation. If the number is too low, the simulation will not be safe. - * \param timeHorizon The minimum amount of time for which this agent's velocities that are computed by the simulation are safe with respect to other agents. The larger this number, the sooner this agent will respond to the presence of other agents, but the less freedom this agent has in choosing its velocities. Must be positive. - * \param radius The radius of this agent. Must be non-negative. - * \param maxSpeed The maximum speed of this agent. Must be non-negative. - * \param velocity The initial three-dimensional linear velocity of this agent (optional). - * \return The number of the agent. - */ - size_t addAgent(const Vector3 &position, float neighborDist, size_t maxNeighbors, float timeHorizon, float radius, float maxSpeed, const Vector3 &velocity = Vector3()); - - /** - * \brief Lets the simulator perform a simulation step and updates the three-dimensional position and three-dimensional velocity of each agent. - */ - void doStep(); - - /** - * \brief Returns the specified agent neighbor of the specified agent. - * \param agentNo The number of the agent whose agent neighbor is to be retrieved. - * \param neighborNo The number of the agent neighbor to be retrieved. - * \return The number of the neighboring agent. - */ - size_t getAgentAgentNeighbor(size_t agentNo, size_t neighborNo) const; - - /** - * \brief Returns the maximum neighbor count of a specified agent. - * \param agentNo The number of the agent whose maximum neighbor count is to be retrieved. - * \return The present maximum neighbor count of the agent. - */ - size_t getAgentMaxNeighbors(size_t agentNo) const; - - /** - * \brief Returns the maximum speed of a specified agent. - * \param agentNo The number of the agent whose maximum speed is to be retrieved. - * \return The present maximum speed of the agent. - */ - float getAgentMaxSpeed(size_t agentNo) const; - - /** - * \brief Returns the maximum neighbor distance of a specified agent. - * \param agentNo The number of the agent whose maximum neighbor distance is to be retrieved. - * \return The present maximum neighbor distance of the agent. - */ - float getAgentNeighborDist(size_t agentNo) const; - - /** - * \brief Returns the count of agent neighbors taken into account to compute the current velocity for the specified agent. - * \param agentNo The number of the agent whose count of agent neighbors is to be retrieved. - * \return The count of agent neighbors taken into account to compute the current velocity for the specified agent. - */ - size_t getAgentNumAgentNeighbors(size_t agentNo) const; - - /** - * \brief Returns the count of ORCA constraints used to compute the current velocity for the specified agent. - * \param agentNo The number of the agent whose count of ORCA constraints is to be retrieved. - * \return The count of ORCA constraints used to compute the current velocity for the specified agent. - */ - size_t getAgentNumORCAPlanes(size_t agentNo) const; - - /** - * \brief Returns the specified ORCA constraint of the specified agent. - * \param agentNo The number of the agent whose ORCA constraint is to be retrieved. - * \param planeNo The number of the ORCA constraint to be retrieved. - * \return A plane representing the specified ORCA constraint. - * \note The halfspace to which the normal of the plane points is the region of permissible velocities with respect to the specified ORCA constraint. - */ - const Plane &getAgentORCAPlane(size_t agentNo, size_t planeNo) const; - - /** - * \brief Returns the three-dimensional position of a specified agent. - * \param agentNo The number of the agent whose three-dimensional position is to be retrieved. - * \return The present three-dimensional position of the (center of the) agent. - */ - const Vector3 &getAgentPosition(size_t agentNo) const; - - /** - * \brief Returns the three-dimensional preferred velocity of a specified agent. - * \param agentNo The number of the agent whose three-dimensional preferred velocity is to be retrieved. - * \return The present three-dimensional preferred velocity of the agent. - */ - const Vector3 &getAgentPrefVelocity(size_t agentNo) const; - - /** - * \brief Returns the radius of a specified agent. - * \param agentNo The number of the agent whose radius is to be retrieved. - * \return The present radius of the agent. - */ - float getAgentRadius(size_t agentNo) const; - - /** - * \brief Returns the time horizon of a specified agent. - * \param agentNo The number of the agent whose time horizon is to be retrieved. - * \return The present time horizon of the agent. - */ - float getAgentTimeHorizon(size_t agentNo) const; - - /** - * \brief Returns the three-dimensional linear velocity of a specified agent. - * \param agentNo The number of the agent whose three-dimensional linear velocity is to be retrieved. - * \return The present three-dimensional linear velocity of the agent. - */ - const Vector3 &getAgentVelocity(size_t agentNo) const; - - /** - * \brief Returns the global time of the simulation. - * \return The present global time of the simulation (zero initially). - */ - float getGlobalTime() const; - - /** - * \brief Returns the count of agents in the simulation. - * \return The count of agents in the simulation. - */ - size_t getNumAgents() const; - - /** - * \brief Returns the time step of the simulation. - * \return The present time step of the simulation. - */ - float getTimeStep() const; - - /** - * \brief Removes an agent from the simulation. - * \param agentNo The number of the agent that is to be removed. - * \note After the removal of the agent, the agent that previously had number getNumAgents() - 1 will now have number agentNo. - */ - void removeAgent(size_t agentNo); - - /** - * \brief Sets the default properties for any new agent that is added. - * \param neighborDist The default maximum distance (center point to center point) to other agents a new agent takes into account in the navigation. The larger this number, the longer he running time of the simulation. If the number is too low, the simulation will not be safe. Must be non-negative. - * \param maxNeighbors The default maximum number of other agents a new agent takes into account in the navigation. The larger this number, the longer the running time of the simulation. If the number is too low, the simulation will not be safe. - * \param timeHorizon The default minimum amount of time for which a new agent's velocities that are computed by the simulation are safe with respect to other agents. The larger this number, the sooner an agent will respond to the presence of other agents, but the less freedom the agent has in choosing its velocities. Must be positive. - * \param radius The default radius of a new agent. Must be non-negative. - * \param maxSpeed The default maximum speed of a new agent. Must be non-negative. - * \param velocity The default initial three-dimensional linear velocity of a new agent (optional). - */ - void setAgentDefaults(float neighborDist, size_t maxNeighbors, float timeHorizon, float radius, float maxSpeed, const Vector3 &velocity = Vector3()); - - /** - * \brief Sets the maximum neighbor count of a specified agent. - * \param agentNo The number of the agent whose maximum neighbor count is to be modified. - * \param maxNeighbors The replacement maximum neighbor count. - */ - void setAgentMaxNeighbors(size_t agentNo, size_t maxNeighbors); - - /** - * \brief Sets the maximum speed of a specified agent. - * \param agentNo The number of the agent whose maximum speed is to be modified. - * \param maxSpeed The replacement maximum speed. Must be non-negative. - */ - void setAgentMaxSpeed(size_t agentNo, float maxSpeed); - - /** - * \brief Sets the maximum neighbor distance of a specified agent. - * \param agentNo The number of the agent whose maximum neighbor distance is to be modified. - * \param neighborDist The replacement maximum neighbor distance. Must be non-negative. - */ - void setAgentNeighborDist(size_t agentNo, float neighborDist); - - /** - * \brief Sets the three-dimensional position of a specified agent. - * \param agentNo The number of the agent whose three-dimensional position is to be modified. - * \param position The replacement of the three-dimensional position. - */ - void setAgentPosition(size_t agentNo, const Vector3 &position); - - /** - * \brief Sets the three-dimensional preferred velocity of a specified agent. - * \param agentNo The number of the agent whose three-dimensional preferred velocity is to be modified. - * \param prefVelocity The replacement of the three-dimensional preferred velocity. - */ - void setAgentPrefVelocity(size_t agentNo, const Vector3 &prefVelocity); - - /** - * \brief Sets the radius of a specified agent. - * \param agentNo The number of the agent whose radius is to be modified. - * \param radius The replacement radius. Must be non-negative. - */ - void setAgentRadius(size_t agentNo, float radius); - - /** - * \brief Sets the time horizon of a specified agent with respect to other agents. - * \param agentNo The number of the agent whose time horizon is to be modified. - * \param timeHorizon The replacement time horizon with respect to other agents. Must be positive. - */ - void setAgentTimeHorizon(size_t agentNo, float timeHorizon); - - /** - * \brief Sets the three-dimensional linear velocity of a specified agent. - * \param agentNo The number of the agent whose three-dimensional linear velocity is to be modified. - * \param velocity The replacement three-dimensional linear velocity. - */ - void setAgentVelocity(size_t agentNo, const Vector3 &velocity); - - /** - * \brief Sets the time step of the simulation. - * \param timeStep The time step of the simulation. Must be positive. - */ - void setTimeStep(float timeStep); - - public: - Agent3D *defaultAgent_; - KdTree3D *kdTree_; - float globalTime_; - float timeStep_; - std::vector agents_; - - friend class Agent3D; - friend class KdTree3D; - }; -} - -#endif diff --git a/thirdparty/rvo2/rvo2_3d/Vector3.h b/thirdparty/rvo2/rvo2_3d/Vector3.h deleted file mode 100644 index 6fa4bb0..0000000 --- a/thirdparty/rvo2/rvo2_3d/Vector3.h +++ /dev/null @@ -1,353 +0,0 @@ -/* - * Vector3.h - * RVO2-3D Library - * - * Copyright 2008 University of North Carolina at Chapel Hill - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Please send all bug reports to . - * - * The authors may be contacted via: - * - * Jur van den Berg, Stephen J. Guy, Jamie Snape, Ming C. Lin, Dinesh Manocha - * Dept. of Computer Science - * 201 S. Columbia St. - * Frederick P. Brooks, Jr. Computer Science Bldg. - * Chapel Hill, N.C. 27599-3175 - * United States of America - * - * - */ - -/** - * \file Vector3.h - * \brief Contains the Vector3 class. - */ -#ifndef RVO3D_VECTOR3_H_ -#define RVO3D_VECTOR3_H_ - -#include -#include -#include - -namespace RVO3D { - /** - * \brief Defines a three-dimensional vector. - */ - class Vector3 { - public: - /** - * \brief Constructs and initializes a three-dimensional vector instance to zero. - */ - inline Vector3() - { - val_[0] = 0.0f; - val_[1] = 0.0f; - val_[2] = 0.0f; - } - - /** - * \brief Constructs and initializes a three-dimensional vector from the specified three-dimensional vector. - * \param vector The three-dimensional vector containing the xyz-coordinates. - */ - inline Vector3(const Vector3 &vector) - { - val_[0] = vector[0]; - val_[1] = vector[1]; - val_[2] = vector[2]; - } - - /** - * \brief Constructs and initializes a three-dimensional vector from the specified three-element array. - * \param val The three-element array containing the xyz-coordinates. - */ - inline explicit Vector3(const float val[3]) - { - val_[0] = val[0]; - val_[1] = val[1]; - val_[2] = val[2]; - } - - /** - * \brief Constructs and initializes a three-dimensional vector from the specified xyz-coordinates. - * \param x The x-coordinate of the three-dimensional vector. - * \param y The y-coordinate of the three-dimensional vector. - * \param z The z-coordinate of the three-dimensional vector. - */ - inline Vector3(float x, float y, float z) - { - val_[0] = x; - val_[1] = y; - val_[2] = z; - } - - /** - * \brief Returns the x-coordinate of this three-dimensional vector. - * \return The x-coordinate of the three-dimensional vector. - */ - inline float x() const { return val_[0]; } - - /** - * \brief Returns the y-coordinate of this three-dimensional vector. - * \return The y-coordinate of the three-dimensional vector. - */ - inline float y() const { return val_[1]; } - - /** - * \brief Returns the z-coordinate of this three-dimensional vector. - * \return The z-coordinate of the three-dimensional vector. - */ - inline float z() const { return val_[2]; } - - /** - * \brief Returns the specified coordinate of this three-dimensional vector. - * \param i The coordinate that should be returned (0 <= i < 3). - * \return The specified coordinate of the three-dimensional vector. - */ - inline float operator[](size_t i) const { return val_[i]; } - - /** - * \brief Returns a reference to the specified coordinate of this three-dimensional vector. - * \param i The coordinate to which a reference should be returned (0 <= i < 3). - * \return A reference to the specified coordinate of the three-dimensional vector. - */ - inline float &operator[](size_t i) { return val_[i]; } - - /** - * \brief Computes the negation of this three-dimensional vector. - * \return The negation of this three-dimensional vector. - */ - inline Vector3 operator-() const - { - return Vector3(-val_[0], -val_[1], -val_[2]); - } - - /** - * \brief Computes the dot product of this three-dimensional vector with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which the dot product should be computed. - * \return The dot product of this three-dimensional vector with a specified three-dimensional vector. - */ - inline float operator*(const Vector3 &vector) const - { - return val_[0] * vector[0] + val_[1] * vector[1] + val_[2] * vector[2]; - } - - /** - * \brief Computes the scalar multiplication of this three-dimensional vector with the specified scalar value. - * \param scalar The scalar value with which the scalar multiplication should be computed. - * \return The scalar multiplication of this three-dimensional vector with a specified scalar value. - */ - inline Vector3 operator*(float scalar) const - { - return Vector3(val_[0] * scalar, val_[1] * scalar, val_[2] * scalar); - } - - /** - * \brief Computes the scalar division of this three-dimensional vector with the specified scalar value. - * \param scalar The scalar value with which the scalar division should be computed. - * \return The scalar division of this three-dimensional vector with a specified scalar value. - */ - inline Vector3 operator/(float scalar) const - { - const float invScalar = 1.0f / scalar; - - return Vector3(val_[0] * invScalar, val_[1] * invScalar, val_[2] * invScalar); - } - - /** - * \brief Computes the vector sum of this three-dimensional vector with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which the vector sum should be computed. - * \return The vector sum of this three-dimensional vector with a specified three-dimensional vector. - */ - inline Vector3 operator+(const Vector3 &vector) const - { - return Vector3(val_[0] + vector[0], val_[1] + vector[1], val_[2] + vector[2]); - } - - /** - * \brief Computes the vector difference of this three-dimensional vector with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which the vector difference should be computed. - * \return The vector difference of this three-dimensional vector with a specified three-dimensional vector. - */ - inline Vector3 operator-(const Vector3 &vector) const - { - return Vector3(val_[0] - vector[0], val_[1] - vector[1], val_[2] - vector[2]); - } - - /** - * \brief Tests this three-dimensional vector for equality with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which to test for equality. - * \return True if the three-dimensional vectors are equal. - */ - inline bool operator==(const Vector3 &vector) const - { - return val_[0] == vector[0] && val_[1] == vector[1] && val_[2] == vector[2]; - } - - /** - * \brief Tests this three-dimensional vector for inequality with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which to test for inequality. - * \return True if the three-dimensional vectors are not equal. - */ - inline bool operator!=(const Vector3 &vector) const - { - return val_[0] != vector[0] || val_[1] != vector[1] || val_[2] != vector[2]; - } - - /** - * \brief Sets the value of this three-dimensional vector to the scalar multiplication of itself with the specified scalar value. - * \param scalar The scalar value with which the scalar multiplication should be computed. - * \return A reference to this three-dimensional vector. - */ - inline Vector3 &operator*=(float scalar) - { - val_[0] *= scalar; - val_[1] *= scalar; - val_[2] *= scalar; - - return *this; - } - - /** - * \brief Sets the value of this three-dimensional vector to the scalar division of itself with the specified scalar value. - * \param scalar The scalar value with which the scalar division should be computed. - * \return A reference to this three-dimensional vector. - */ - inline Vector3 &operator/=(float scalar) - { - const float invScalar = 1.0f / scalar; - - val_[0] *= invScalar; - val_[1] *= invScalar; - val_[2] *= invScalar; - - return *this; - } - - /** - * \brief Sets the value of this three-dimensional vector to the vector - * sum of itself with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which the vector sum should be computed. - * \return A reference to this three-dimensional vector. - */ - inline Vector3 &operator+=(const Vector3 &vector) - { - val_[0] += vector[0]; - val_[1] += vector[1]; - val_[2] += vector[2]; - - return *this; - } - - /** - * \brief Sets the value of this three-dimensional vector to the vector difference of itself with the specified three-dimensional vector. - * \param vector The three-dimensional vector with which the vector difference should be computed. - * \return A reference to this three-dimensional vector. - */ - inline Vector3 &operator-=(const Vector3 &vector) - { - val_[0] -= vector[0]; - val_[1] -= vector[1]; - val_[2] -= vector[2]; - - return *this; - } - - inline Vector3 &operator=(const Vector3 &vector) - { - val_[0] = vector[0]; - val_[1] = vector[1]; - val_[2] = vector[2]; - - return *this; - } - - private: - float val_[3]; - }; - - - /** - * \relates Vector3 - * \brief Computes the scalar multiplication of the specified three-dimensional vector with the specified scalar value. - * \param scalar The scalar value with which the scalar multiplication should be computed. - * \param vector The three-dimensional vector with which the scalar multiplication should be computed. - * \return The scalar multiplication of the three-dimensional vector with the scalar value. - */ - inline Vector3 operator*(float scalar, const Vector3 &vector) - { - return Vector3(scalar * vector[0], scalar * vector[1], scalar * vector[2]); - } - - /** - * \relates Vector3 - * \brief Computes the cross product of the specified three-dimensional vectors. - * \param vector1 The first vector with which the cross product should be computed. - * \param vector2 The second vector with which the cross product should be computed. - * \return The cross product of the two specified vectors. - */ - inline Vector3 cross(const Vector3 &vector1, const Vector3 &vector2) - { - return Vector3(vector1[1] * vector2[2] - vector1[2] * vector2[1], vector1[2] * vector2[0] - vector1[0] * vector2[2], vector1[0] * vector2[1] - vector1[1] * vector2[0]); - } - - /** - * \relates Vector3 - * \brief Inserts the specified three-dimensional vector into the specified output stream. - * \param os The output stream into which the three-dimensional vector should be inserted. - * \param vector The three-dimensional vector which to insert into the output stream. - * \return A reference to the output stream. - */ - inline std::ostream &operator<<(std::ostream &os, const Vector3 &vector) - { - os << "(" << vector[0] << "," << vector[1] << "," << vector[2] << ")"; - - return os; - } - - /** - * \relates Vector3 - * \brief Computes the length of a specified three-dimensional vector. - * \param vector The three-dimensional vector whose length is to be computed. - * \return The length of the three-dimensional vector. - */ - inline float abs(const Vector3 &vector) - { - return std::sqrt(vector * vector); - } - - /** - * \relates Vector3 - * \brief Computes the squared length of a specified three-dimensional vector. - * \param vector The three-dimensional vector whose squared length is to be computed. - * \return The squared length of the three-dimensional vector. - */ - inline float absSq(const Vector3 &vector) - { - return vector * vector; - } - - /** - * \relates Vector3 - * \brief Computes the normalization of the specified three-dimensional vector. - * \param vector The three-dimensional vector whose normalization is to be computed. - * \return The normalization of the three-dimensional vector. - */ - inline Vector3 normalize(const Vector3 &vector) - { - return vector / abs(vector); - } -} - -#endif