using System; using System.Diagnostics; using System.IO; using System.Text; public static partial class Recast { /// The value of PI used by Recast. public const float RC_PI = 3.14159265f; /// Defines the number of bits allocated to rcSpan::smin and rcSpan::smax. public const int RC_SPAN_HEIGHT_BITS = 13; /// Defines the maximum value for rcSpan::smin and rcSpan::smax. public const int RC_SPAN_MAX_HEIGHT = (1 << RC_SPAN_HEIGHT_BITS) - 1; /// Recast log categories. /// @see rcContext public 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 public 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 }; public static void rcCalcBounds(float[] verts, int nv, float[] bmin, float[] bmax) { // Calculate bounding box. rcVcopy(bmin, verts); rcVcopy(bmax, verts); for (int i = 1; i < nv; ++i) { int vStart = i * 3; rcVmin(bmin, 0, verts, vStart); rcVmax(bmax, 0, verts, vStart); } } public static void rcCalcGridSize(float[] bmin, float[] bmax, float cs, out int w, out int h) { w = (int)((bmax[0] - bmin[0]) / cs + 0.5f); h = (int)((bmax[2] - bmin[2]) / cs + 0.5f); } /// @par /// /// See the #rcConfig documentation for more information on the configuration parameters. /// /// @see rcAllocHeightfield, rcHeightfield public static bool rcCreateHeightfield(rcContext ctx, rcHeightfield hf, int width, int height, float[] bmin, float[] bmax, float cs, float ch) { rcIgnoreUnused(ctx); hf.width = width; hf.height = height; rcVcopy(hf.bmin, bmin); rcVcopy(hf.bmax, bmax); hf.cs = cs; hf.ch = ch; hf.spans = new rcSpan[hf.width * hf.height];//(rcSpan**)rcAlloc(sizeof(rcSpan*)*hf.width*hf.height, RC_ALLOC_PERM); if (hf.spans == null) return false; //memset(hf.spans, 0, sizeof(rcSpan*)*hf.width*hf.height); return true; } public static void calcTriNormal(float[] v0, float[] v1, float[] v2, float[] norm) { float[] e0 = new float[3]; float[] e1 = new float[3]; rcVsub(e0, v1, v0); rcVsub(e1, v2, v0); rcVcross(norm, e0, e1); rcVnormalize(norm); } public static void calcTriNormal(float[] v0, int v0Start, float[] v1, int v1Start, float[] v2, int v2Start, float[] norm) { float[] e0 = new float[3]; float[] e1 = new float[3]; rcVsub(e0, 0, v1, v1Start, v0, v0Start); rcVsub(e1, 0, v2, v2Start, v0, v0Start); rcVcross(norm, 0, e0, 0, e1, 0); rcVnormalize(norm); } /// @par /// /// Only sets the aread id's for the walkable triangles. Does not alter the /// area id's for unwalkable triangles. /// /// See the #rcConfig documentation for more information on the configuration parameters. /// /// @see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles public static void rcMarkWalkableTriangles(rcContext ctx, float walkableSlopeAngle, float[] verts, int nv, int[] tris, int nt, byte[] areas) { rcIgnoreUnused(ctx); float walkableThr = (float)Math.Cos(walkableSlopeAngle / 180.0f * RC_PI); float[] norm = new float[3]; for (int i = 0; i < nt; ++i) { int triStart = i * 3; calcTriNormal(verts, tris[triStart + 0] * 3, verts, tris[triStart + 1] * 3, verts, tris[triStart + 2] * 3, norm); // Check if the face is walkable. if (norm[1] > walkableThr) areas[i] = RC_WALKABLE_AREA; } } /// @par /// /// Only sets the aread id's for the unwalkable 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 public static void rcClearUnwalkableTriangles(rcContext ctx, float walkableSlopeAngle, float[] verts, int nv, int[] tris, int nt, byte[] areas) { rcIgnoreUnused(ctx); float walkableThr = (float)Math.Cos(walkableSlopeAngle / 180.0f * RC_PI); float[] norm = new float[3]; for (int i = 0; i < nt; ++i) { int triStart = i * 3; calcTriNormal(verts, tris[triStart + 0] * 3, verts, tris[triStart + 1] * 3, verts, tris[triStart + 2] * 3, norm); // Check if the face is walkable. if (norm[1] <= walkableThr) areas[i] = RC_NULL_AREA; } } public static int rcGetHeightFieldSpanCount(rcContext ctx, rcHeightfield hf) { rcIgnoreUnused(ctx); int w = hf.width; int h = hf.height; int spanCount = 0; for (int y = 0; y < h; ++y) { for (int x = 0; x < w; ++x) { for (rcSpan s = hf.spans[x + y * w]; s != null; s = s.next) { if (s.area != RC_NULL_AREA) spanCount++; } } } return spanCount; } public static void rccsArrayItemsCreate(T[] array) where T : class, new() { for (int i = 0; i < array.Length; ++i) { array[i] = new T(); } } /// @par /// /// This is just the beginning of the process of fully building a compact heightfield. /// Various filters may be applied 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 public static bool rcBuildCompactHeightfield(rcContext ctx, int walkableHeight, int walkableClimb, rcHeightfield hf, rcCompactHeightfield chf) { Debug.Assert(ctx != null, "rcBuildCompactHeightfield Assert(ctx != null)"); ctx.startTimer(rcTimerLabel.RC_TIMER_BUILD_COMPACTHEIGHTFIELD); int w = hf.width; int h = hf.height; int spanCount = rcGetHeightFieldSpanCount(ctx, hf); // Fill in header. chf.width = w; chf.height = h; chf.spanCount = spanCount; chf.walkableHeight = walkableHeight; chf.walkableClimb = walkableClimb; chf.maxRegions = 0; rcVcopy(chf.bmin, hf.bmin); rcVcopy(chf.bmax, hf.bmax); chf.bmax[1] += walkableHeight * hf.ch; chf.cs = hf.cs; chf.ch = hf.ch; chf.cells = new rcCompactCell[w * h]; //chf.cells = (rcCompactCell*)rcAlloc(sizeof(rcCompactCell)*w*h, RC_ALLOC_PERM); if (chf.cells == null) { ctx.log(rcLogCategory.RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.cells' (" + (w * h) + ")"); return false; } chf.spans = new rcCompactSpan[spanCount];// (rcCompactSpan*)rcAlloc(sizeof(rcCompactSpan)*spanCount, RC_ALLOC_PERM); if (chf.spans == null) { ctx.log(rcLogCategory.RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.spans' (" + spanCount + ")"); return false; } chf.areas = new byte[spanCount]; //(byte*)rcAlloc(sizeof(byte)*spanCount, RC_ALLOC_PERM); if (chf.areas == null) { ctx.log(rcLogCategory.RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.areas' (" + spanCount + ")"); ; return false; } int MAX_HEIGHT = 0xffff; // Fill in cells and spans. int idx = 0; for (int y = 0; y < h; ++y) { for (int x = 0; x < w; ++x) { rcSpan s = hf.spans[x + y * w]; // If there are no spans at this cell, just leave the data to index=0, count=0. if (s == null) { continue; } rcCompactCell c;// = chf.cells[x + y * w]; c.index = (uint)idx; c.count = 0; while (s != null) { if (s.area != RC_NULL_AREA) { int bot = (int)s.smax; int top = s.next != null ? (int)s.next.smin : MAX_HEIGHT; chf.spans[idx].y = (ushort)rcClamp(bot, 0, 0xffff); chf.spans[idx].h = (byte)rcClamp(top - bot, 0, 0xff); chf.areas[idx] = s.area; idx++; c.count++; } s = s.next; } chf.cells[x + y * w] = c; } } // Find neighbour connections. int MAX_LAYERS = RC_NOT_CONNECTED - 1; int tooHighNeighbour = 0; for (int y = 0; y < h; ++y) { for (int x = 0; x < w; ++x) { rcCompactCell c = chf.cells[x + y * w]; for (int i = (int)c.index, ni = (int)(c.index + c.count); i < ni; ++i) { rcCompactSpan s = chf.spans[i]; for (int dir = 0; dir < 4; ++dir) { rcSetCon(ref s, dir, RC_NOT_CONNECTED); int nx = x + rcGetDirOffsetX(dir); int ny = y + rcGetDirOffsetY(dir); // First check that the neighbour cell is in bounds. if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue; // Iterate over all neighbour spans and check if any of the is // accessible from current cell. rcCompactCell nc = chf.cells[nx + ny * w]; for (int k = (int)nc.index, nk = (int)(nc.index + nc.count); k < nk; ++k) { rcCompactSpan ns = chf.spans[k]; int bot = Math.Max(s.y, ns.y); int top = Math.Min(s.y + s.h, ns.y + ns.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 && Math.Abs((int)ns.y - (int)s.y) <= walkableClimb) { // Mark direction as walkable. int lidx = k - (int)nc.index; if (lidx < 0 || lidx > MAX_LAYERS) { tooHighNeighbour = Math.Max(tooHighNeighbour, lidx); continue; } rcSetCon(ref s, dir, lidx); break; } } } chf.spans[i] = s; } } } if (tooHighNeighbour > MAX_LAYERS) { ctx.log(rcLogCategory.RC_LOG_ERROR, "rcBuildCompactHeightfield: Heightfield has too many layers " + tooHighNeighbour + " (max: " + MAX_LAYERS + ")"); } ctx.stopTimer(rcTimerLabel.RC_TIMER_BUILD_COMPACTHEIGHTFIELD); return true; } /* static int getHeightfieldMemoryUsage(const rcHeightfield& hf) { int size = 0; size += sizeof(hf); size += hf.width * hf.height * sizeof(rcSpan*); rcSpanPool* pool = hf.pools; while (pool) { size += (sizeof(rcSpanPool) - sizeof(rcSpan)) + sizeof(rcSpan)*RC_SPANS_PER_POOL; pool = pool.next; } return size; } static int getCompactHeightFieldMemoryusage(const rcCompactHeightfield& chf) { int size = 0; size += sizeof(rcCompactHeightfield); size += sizeof(rcCompactSpan) * chf.spanCount; size += sizeof(rcCompactCell) * chf.width * chf.height; return size; } */ /// @class rcContext /// @par /// /// 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. /// /// @par /// /// Example: /// @code /// // Where ctx is an instance of rcContext and filepath is a char array. /// ctx.log(rcLogCategory.RC_LOG_ERROR, "buildTiledNavigation: Could not load '%s'", filepath); /// @endcode /// Provides an interface for optional logging and performance tracking of the Recast /// build process. /// @ingroup recast public class rcContext { /// True if logging is enabled. bool m_logEnabled = true; /// True if the performance timers are enabled. bool m_timerEnabled = true; /// Contructor. /// @param[in] state TRUE if the logging and performance timers should be enabled. [Default: true] public rcContext(bool state = true) { m_logEnabled = state; m_timerEnabled = state; } /// Enables or disables logging. /// @param[in] state TRUE if logging should be enabled. public void enableLog(bool state) { m_logEnabled = state; } /// Clears all log entries. public void resetLog() { if (m_logEnabled) { doResetLog(); } } /// Logs a message. /// @param[in] category The category of the message. /// @param[in] message The message. //public void log(rcLogCategory category, string message); public void log(rcLogCategory category, string message) { if (!m_logEnabled) { return; } doLog(category, message); } /// Enables or disables the performance timers. /// @param[in] state TRUE if timers should be enabled. public void enableTimer(bool state) { m_timerEnabled = state; } /// Clears all peformance timers. (Resets all to unused.) public void resetTimers() { if (m_timerEnabled) { doResetTimers(); } } /// Starts the specified performance timer. /// @param label The category of timer. public void startTimer(rcTimerLabel label) { if (m_timerEnabled) { doStartTimer(label); } } /// Stops the specified performance timer. /// @param label The category of the timer. public void stopTimer(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. public long getAccumulatedTime(rcTimerLabel label) { return m_timerEnabled ? doGetAccumulatedTime(label) : -1; } public double getAccumulatedTimeHiResolution(rcTimerLabel label) { return m_timerEnabled ? doGetAccumulatedTimeHiResolution(label) : -1.0; } /// Clears all log entries. protected virtual void doResetLog() { } /// Logs a message. /// @param[in] category The category of the message. /// @param[in] msg The formatted message. protected virtual void doLog(rcLogCategory category, string msg) { //int len unnecessary because c# string } /// Clears all timers. (Resets all to unused.) protected virtual void doResetTimers() { } /// Starts the specified performance timer. /// @param[in] label The category of timer. protected virtual void doStartTimer(rcTimerLabel label) { } /// Stops the specified performance timer. /// @param[in] label The category of the timer. protected virtual void doStopTimer(rcTimerLabel 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. protected virtual long doGetAccumulatedTime(rcTimerLabel label) { return -1; } //C# port: alternate return type to use high precision timer on platforms where it's available /// 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. protected virtual double doGetAccumulatedTimeHiResolution(rcTimerLabel label) { return -1.0; } }; /// Specifies a configuration to use when performing Recast builds. /// @ingroup recast public class rcConfig { /// The width of the field along the x-axis. [Limit: >= 0] [Units: vx] public int width; /// The height of the field along the z-axis. [Limit: >= 0] [Units: vx] public int height; /// The width/height size of tile's on the xz-plane. [Limit: >= 0] [Units: vx] public int tileSize; /// The size of the non-navigable border around the heightfield. [Limit: >=0] [Units: vx] public int borderSize; /// The xz-plane cell size to use for fields. [Limit: > 0] [Units: wu] public float cs; /// The y-axis cell size to use for fields. [Limit: > 0] [Units: wu] public float ch; /// The minimum bounds of the field's AABB. [(x, y, z)] [Units: wu] public float[] bmin = new float[3]; /// The maximum bounds of the field's AABB. [(x, y, z)] [Units: wu] public float[] bmax = new float[3]; /// The maximum slope that is considered walkable. [Limits: 0 <= value < 90] [Units: Degrees] public float walkableSlopeAngle; /// Minimum floor to 'ceiling' height that will still allow the floor area to /// be considered walkable. [Limit: >= 3] [Units: vx] public int walkableHeight; /// Maximum ledge height that is considered to still be traversable. [Limit: >=0] [Units: vx] public int walkableClimb; /// The distance to erode/shrink the walkable area of the heightfield away from /// obstructions. [Limit: >=0] [Units: vx] public int walkableRadius; /// The maximum allowed length for contour edges along the border of the mesh. [Limit: >=0] [Units: vx] public int maxEdgeLen; /// The maximum distance a simplfied contour's border edges should deviate /// the original raw contour. [Limit: >=0] [Units: vx] public float maxSimplificationError; /// The minimum number of cells allowed to form isolated island areas. [Limit: >=0] [Units: vx] public int minRegionArea; /// Any regions with a span count smaller than this value will, if possible, /// be merged with larger regions. [Limit: >=0] [Units: vx] public int mergeRegionArea; /// The maximum number of vertices allowed for polygons generated during the /// contour to polygon conversion process. [Limit: >= 3] public int maxVertsPerPoly; /// Sets the sampling distance to use when generating the detail mesh. /// (For height detail only.) [Limits: 0 or >= 0.9] [Units: wu] public float detailSampleDist; /// The maximum distance the detail mesh surface should deviate from heightfield /// data. (For height detail only.) [Limit: >=0] [Units: wu] public float detailSampleMaxError; }; /// Represents a span in a heightfield. /// @see rcHeightfield public class rcSpan { public ushort smin;// : 13; //< The lower limit of the span. [Limit: < #smax] public ushort smax;// : 13; //< The upper limit of the span. [Limit: <= #RC_SPAN_MAX_HEIGHT] public byte area;// : 6; //< The area id assigned to the span. public rcSpan next = null; //< The next span higher up in column. } // A memory pool used for quick allocation of spans within a heightfield. // @see rcHeightfield public class rcSpanPool { public rcSpanPool next = null; //< The next span pool. public rcSpan[] items = new rcSpan[RC_SPANS_PER_POOL]; //< Array of spans in the pool. /// public rcSpanPool() { for (int i = 0; i < items.Length; ++i) { items[i] = new rcSpan(); } } }; /// A dynamic heightfield representing obstructed space. /// @ingroup recast public class rcHeightfield { public int width; //< The width of the heightfield. (Along the x-axis in cell units.) public int height; //< The height of the heightfield. (Along the z-axis in cell units.) public float[] bmin = new float[3]; //< The minimum bounds in world space. [(x, y, z)] public float[] bmax = new float[3]; //< The maximum bounds in world space. [(x, y, z)] public float cs; //< The size of each cell. (On the xz-plane.) public float ch; //< The height of each cell. (The minimum increment along the y-axis.) public rcSpan[] spans = null;//** //< Heightfield of spans (width*height). public rcSpanPool pools = null; //< Linked list of span pools. public rcSpan freelist = null; //< The next free span. }; /// Provides information on the content of a cell column in a compact heightfield. public struct rcCompactCell { public uint index;// : 24; //< Index to the first span in the column. public ushort count;// : 8; //< Number of spans in the column. }; /// Represents a span of unobstructed space within a compact heightfield. public struct rcCompactSpan { public ushort y; //< The lower extent of the span. (Measured from the heightfield's base.) public ushort reg; //< The id of the region the span belongs to. (Or zero if not in a region.) public uint con;// : 24; //< Packed neighbor connection data. public ushort h;// : 8; //< The height of the span. (Measured from #y.) }; /// A compact, static heightfield representing unobstructed space. /// @ingroup recast public class rcCompactHeightfield { public int width; //< The width of the heightfield. (Along the x-axis in cell units.) public int height; //< The height of the heightfield. (Along the z-axis in cell units.) public int spanCount; //< The number of spans in the heightfield. public int walkableHeight; //< The walkable height used during the build of the field. (See: rcConfig::walkableHeight) public int walkableClimb; //< The walkable climb used during the build of the field. (See: rcConfig::walkableClimb) public int borderSize; //< The AABB border size used during the build of the field. (See: rcConfig::borderSize) public ushort maxDistance; //< The maximum distance value of any span within the field. public ushort maxRegions; //< The maximum region id of any span within the field. public float[] bmin = new float[3]; //< The minimum bounds in world space. [(x, y, z)] public float[] bmax = new float[3]; //< The maximum bounds in world space. [(x, y, z)] public float cs; //< The size of each cell. (On the xz-plane.) public float ch; //< The height of each cell. (The minimum increment along the y-axis.) public rcCompactCell[] cells = null; //< Array of cells. [Size: #width*#height] public rcCompactSpan[] spans = null; //< Array of spans. [Size: #spanCount] public ushort[] dist = null; //< Array containing border distance data. [Size: #spanCount] public byte[] areas = null; //< Array containing area id data. [Size: #spanCount] }; /// Represents a heightfield layer within a layer set. /// @see rcHeightfieldLayerSet public class rcHeightfieldLayer { public float[] bmin = new float[3]; //< The minimum bounds in world space. [(x, y, z)] public float[] bmax = new float[3]; //< The maximum bounds in world space. [(x, y, z)] public float cs; //< The size of each cell. (On the xz-plane.) public float ch; //< The height of each cell. (The minimum increment along the y-axis.) public int width; //< The width of the heightfield. (Along the x-axis in cell units.) public int height; //< The height of the heightfield. (Along the z-axis in cell units.) public int minx; //< The minimum x-bounds of usable data. public int maxx; //< The maximum x-bounds of usable data. public int miny; //< The minimum y-bounds of usable data. (Along the z-axis.) public int maxy; //< The maximum y-bounds of usable data. (Along the z-axis.) public int hmin; //< The minimum height bounds of usable data. (Along the y-axis.) public int hmax; //< The maximum height bounds of usable data. (Along the y-axis.) public byte[] heights; //< The heightfield. [Size: (width - borderSize*2) * (h - borderSize*2)] public byte[] areas; //< Area ids. [Size: Same as #heights] public byte[] cons; //< Packed neighbor connection information. [Size: Same as #heights] }; /// Represents a set of heightfield layers. /// @ingroup recast /// @see rcAllocHeightfieldLayerSet, rcFreeHeightfieldLayerSet public class rcHeightfieldLayerSet { public rcHeightfieldLayer[] layers = null; //< The layers in the set. [Size: #nlayers] public int nlayers; //< The number of layers in the set. }; /// Represents a simple, non-overlapping contour in field space. public struct rcContour { public int[] verts; //< Simplified contour vertex and connection data. [Size: 4 * #nverts] public int nverts; //< The number of vertices in the simplified contour. public int[] rverts; //< Raw contour vertex and connection data. [Size: 4 * #nrverts] public int nrverts; //< The number of vertices in the raw contour. public ushort reg; //< The region id of the contour. public byte area; //< The area id of the contour. /// public void dumpToTxt(StreamWriter stream) { stream.WriteLine("\treg: " + reg); stream.WriteLine("\tarea: " + area); stream.WriteLine("\tnverts: " + nverts); for (int i = 0; i < nverts; ++i) { int vIndex = i * 4; stream.WriteLine("\t\tverts[" + i + "]: x:" + verts[vIndex] + " y:" + verts[vIndex + 1] + " z:" + verts[vIndex + 2] + " ?:" + verts[vIndex + 3]); } stream.WriteLine("\tnrverts: " + nrverts); for (int i = 0; i < nrverts; ++i) { int vIndex = i * 4; stream.WriteLine("\t\trverts[" + i + "]: x:" + rverts[vIndex] + " y:" + rverts[vIndex + 1] + " z:" + rverts[vIndex + 2] + " ?:" + rverts[vIndex + 3]); } } public string dumpToString() { StringBuilder sb = new StringBuilder(); sb.AppendLine("\treg: " + reg); sb.AppendLine("\tarea: " + area); sb.AppendLine("\tnverts: " + nverts); for (int i = 0; i < nverts; ++i) { int vIndex = i * 4; sb.AppendLine("\t\tverts[" + i + "]: x:" + verts[vIndex] + " y:" + verts[vIndex + 1] + " z:" + verts[vIndex + 2] + " ?:" + verts[vIndex + 3]); } sb.AppendLine("\tnrverts: " + nrverts); for (int i = 0; i < nrverts; ++i) { int vIndex = i * 4; sb.AppendLine("\t\trverts[" + i + "]: x:" + rverts[vIndex] + " y:" + rverts[vIndex + 1] + " z:" + rverts[vIndex + 2] + " ?:" + rverts[vIndex + 3]); } return sb.ToString(); } }; /// Represents a group of related contours. /// @ingroup recast public class rcContourSet { public rcContour[] conts = null; //< An array of the contours in the set. [Size: #nconts] public int nconts; //< The number of contours in the set. public float[] bmin = new float[3]; //< The minimum bounds in world space. [(x, y, z)] public float[] bmax = new float[3]; //< The maximum bounds in world space. [(x, y, z)] public float cs; //< The size of each cell. (On the xz-plane.) public float ch; //< The height of each cell. (The minimum increment along the y-axis.) public int width; //< The width of the set. (Along the x-axis in cell units.) public int height; //< The height of the set. (Along the z-axis in cell units.) public int borderSize; //< The AABB border size used to generate the source data from which the contours were derived. /// public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendLine("nconts: " + nconts); sb.AppendLine("bmin: " + bmin[0] + " " + bmin[1] + " " + bmin[2]); sb.AppendLine("bmax: " + bmax[0] + " " + bmax[1] + " " + bmax[2]); sb.AppendLine("cs: " + cs); sb.AppendLine("ch: " + ch); sb.AppendLine("width: " + width); sb.AppendLine("height: " + height); sb.AppendLine("bordersize: " + borderSize); for (int i = 0; i < nconts; ++i) { sb.Append("contour[" + i + "]: "); sb.AppendLine(conts[i].ToString()); } return sb.ToString(); } }; /// Represents a polygon mesh suitable for use in building a navigation mesh. /// @ingroup recast public class rcPolyMesh { public ushort[] verts = null; //< The mesh vertices. [Form: (x, y, z) * #nverts] public ushort[] polys = null; //< Polygon and neighbor data. [Length: #maxpolys * 2 * #nvp] public ushort[] regs = null; //< The region id assigned to each polygon. [Length: #maxpolys] public ushort[] flags = null; //< The user defined flags for each polygon. [Length: #maxpolys] public byte[] areas = null; //< The area id assigned to each polygon. [Length: #maxpolys] public int nverts; //< The number of vertices. public int npolys; //< The number of polygons. public int maxpolys; //< The number of allocated polygons. public int nvp; //< The maximum number of vertices per polygon. public float[] bmin = new float[3]; //< The minimum bounds in world space. [(x, y, z)] public float[] bmax = new float[3]; //< The maximum bounds in world space. [(x, y, z)] public float cs; //< The size of each cell. (On the xz-plane.) public float ch; //< The height of each cell. (The minimum increment along the y-axis.) public int borderSize; //< The AABB border size used to generate the source data from which the mesh was derived. /// public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendLine("bmin: " + bmin[0] + " " + bmin[1] + " " + bmin[2]); sb.AppendLine("bmax: " + bmax[0] + " " + bmax[1] + " " + bmax[2]); sb.AppendLine("cs: " + cs); sb.AppendLine("ch: " + ch); sb.AppendLine("bordersize: " + borderSize); sb.AppendLine("nverts: " + nverts); for (int i = 0; i < nverts; ++i) { int vIndex = i * 3; sb.AppendLine("\tverts[" + i + "]: x:" + verts[vIndex] + " y:" + verts[vIndex + 1] + " z:" + verts[vIndex + 2]); } sb.AppendLine("\tmaxpolys: " + maxpolys); sb.AppendLine("\tnvp: " + nvp); sb.AppendLine("\tnpolys: " + npolys); for (int i = 0; i < maxpolys; ++i) { int vIndex = i * nvp; sb.Append("\t\tpolys[" + i + "]: "); for (int j = 0; j < nvp; ++j) { sb.Append(" " + j + ":" + polys[vIndex + j]); } vIndex += nvp; sb.AppendLine(); sb.Append("\t\tneighbor[" + i + "]: "); for (int j = 0; j < nvp; ++j) { sb.Append(" " + j + ":" + polys[vIndex + j]); } sb.AppendLine(); } for (int i = 0; i < maxpolys; ++i) { sb.AppendLine("regs[" + i + "]: " + regs[i]); } sb.AppendLine(); for (int i = 0; i < flags.Length; ++i) { sb.AppendLine("flags[" + i + "]: " + flags[i]); } return sb.ToString(); } public string ToObj(){ StringBuilder sb = new StringBuilder(); sb.AppendLine("# Recast Navmesh"); sb.AppendLine("o NavMesh"); sb.AppendLine(); for (int i = 0; i < nverts; ++i) { //ushort* v = &pmesh.verts[i*3]; int vIndex = i * 3; float x = bmin[0] + verts[vIndex + 0] * cs; float y = bmin[1] + (verts[vIndex + 1] + 1) * ch + 0.1f; float z = bmin[2] + verts[vIndex + 2] * cs; //ioprintf(io, "v %f %f %f\n", x,y,z); sb.AppendLine("v " + x + " " + y + " " + z); } sb.AppendLine(); for (int i = 0; i < npolys; ++i) { //const unsigned short* p = &pmesh.polys[i*nvp*2]; int pIndex = i * nvp * 2; for (int j = 2; j < nvp; ++j) { if (polys[pIndex + j] == RC_MESH_NULL_IDX) break; //ioprintf(io, "f %d %d %d\n", p[0]+1, p[j-1]+1, p[j]+1); int a = polys[pIndex] + 1; int b = polys[pIndex + j - 1] + 1; int c = polys[pIndex + j] + 1; sb.AppendLine("f " + a + " " + b + " " + c); } } return sb.ToString (); } }; /// Contains triangle meshes that represent detailed height data associated /// with the polygons in its associated polygon mesh object. /// @ingroup recast public class rcPolyMeshDetail { public uint[] meshes = null; //< The sub-mesh data. [Size: 4*#nmeshes] public float[] verts = null; //< The mesh vertices. [Size: 3*#nverts] public byte[] tris = null; //< The mesh triangles. [Size: 4*#ntris] public int nmeshes; //< The number of sub-meshes defined by #meshes. public int nverts; //< The number of vertices in #verts. public int ntris; //< The number of triangles in #tris. public override string ToString() { StringBuilder sb = new StringBuilder(); sb.AppendLine("nmeshes: " + nmeshes); for (int i = 0; i < nmeshes; ++i) { int vIndex = i * 4; sb.AppendLine("\tmeshes[" + i + "]: a:" + meshes[vIndex] + " b:" + meshes[vIndex + 1] + " c:" + meshes[vIndex + 2] + " d:" + meshes[vIndex + 3]); } sb.AppendLine("nverts: " + nverts); for (int i = 0; i < nverts; ++i) { int vIndex = i * 3; sb.AppendLine("\tverts[" + i + "]: x:" + verts[vIndex] + " y:" + verts[vIndex + 1] + " z:" + verts[vIndex + 2]); } sb.AppendLine("ntris: " + ntris); for (int i = 0; i < ntris; ++i) { int vIndex = i * 4; sb.AppendLine("\ttris[" + i + "]: a:" + tris[vIndex] + " b:" + tris[vIndex + 1] + " c:" + tris[vIndex + 2] + " d:" + tris[vIndex + 3]); } return sb.ToString(); } public string ToObj() { StringBuilder sb = new StringBuilder(); sb.AppendLine("# Recast C# Navmesh\n"); sb.AppendLine("o NavMesh\n"); sb.AppendLine("\n"); for (int i = 0; i < nverts; ++i) { int vIndex = i * 3; sb.AppendLine("v " + verts[vIndex + 0] + " " + verts[vIndex + 1] + " " + verts[vIndex + 2]); } sb.AppendLine(); for (int i = 0; i < nmeshes; ++i) { //uint* m = &dmesh.meshes[i*4]; int mIndex = i * 4; uint bverts = meshes[mIndex + 0]; uint btris = meshes[mIndex + 2]; uint _ntris = meshes[mIndex + 3]; uint trisIndex = btris * 4; for (uint j = 0; j < _ntris; ++j) { sb.AppendLine("f " + ((int)(bverts + tris[trisIndex + j * 4 + 0]) + 1) + " " + ((int)(bverts + tris[trisIndex + j * 4 + 1]) + 1) + " " + ((int)(bverts + tris[trisIndex + j * 4 + 2]) + 1) + " "); } } return sb.ToString(); } }; /// @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] hf A heightfield allocated using #rcAllocHeightfield /// @ingroup recast /// @see rcAllocHeightfield //void rcFreeHeightField(rcHeightfield* hf); /// 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] chf A compact heightfield allocated using #rcAllocCompactHeightfield /// @ingroup recast /// @see rcAllocCompactHeightfield //void rcFreeCompactHeightfield(rcCompactHeightfield* chf); /// 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] lset A heightfield layer set allocated using #rcAllocHeightfieldLayerSet /// @ingroup recast /// @see rcAllocHeightfieldLayerSet //void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* lset); /// 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] cset A contour set allocated using #rcAllocContourSet /// @ingroup recast /// @see rcAllocContourSet //void rcFreeContourSet(rcContourSet* cset); /// 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] pmesh A polygon mesh allocated using #rcAllocPolyMesh /// @ingroup recast /// @see rcAllocPolyMesh //void rcFreePolyMesh(rcPolyMesh* pmesh); /// 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] dmesh A detail mesh allocated using #rcAllocPolyMeshDetail /// @ingroup recast /// @see rcAllocPolyMeshDetail //void rcFreePolyMeshDetail(rcPolyMeshDetail* dmesh); /// The number of spans allocated per span spool. /// @see rcSpanPool public const int RC_SPANS_PER_POOL = 2048; /// Heighfield border flag. /// If a heightfield region ID has this bit set, then the region is a border /// region and its spans are considered unwalkable. /// (Used during the region and contour build process.) /// @see rcCompactSpan::reg public const ushort RC_BORDER_REG = 0x8000; /// 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 public 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 public const int RC_AREA_BORDER = 0x20000; /// Contour build flags. /// @see rcBuildContours public 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 public 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 public const ushort 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 unwalkable.) public const byte 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. public const byte RC_WALKABLE_AREA = 63; /// The value returned by #rcGetCon if the specified direction is not connected /// to another span. (Has no neighbor.) public const int RC_NOT_CONNECTED = 0x3f; /// @name General helper functions /// @{ /// Used to ignore a function parameter. VS complains about unused parameters /// and this silences the warning. /// @param [in] _ Unused parameter public static void rcIgnoreUnused(T t) { } //Use C# for this kind of things /// Swaps the values of the two parameters. /// @param[in,out] a Value A /// @param[in,out] b Value B //public void rcSwap(T a, T b) { T t = a; a = b; b = t; } static void rcSwap(ref T lhs, ref T rhs) { T temp = lhs; lhs = rhs; rhs = temp; } /// Returns the minimum of two values. /// @param[in] a Value A /// @param[in] b Value B /// @return The minimum of the two values. //public T Math.Min(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 Math.Max(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] v The value to clamp. /// @param[in] mn The minimum permitted return value. /// @param[in] mx The maximum permitted return value. /// @return The value, clamped to the specified range. //template inline T rcClamp(T v, T mn, T mx) { return v < mn ? mn : (v > mx ? mx : v); } public static int rcClamp(int v, int mn, int mx) { return v < mn ? mn : (v > mx ? mx : v); } /// 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)] public static void rcVcross(float[] dest, float[] v1, 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]; } public static void rcVcross(float[] dest, int destStart, float[] v1, int v1Start, float[] v2, int v2Start) { dest[destStart + 0] = v1[v1Start + 1] * v2[v2Start + 2] - v1[v1Start + 2] * v2[v2Start + 1]; dest[destStart + 1] = v1[v1Start + 2] * v2[v2Start + 0] - v1[v1Start + 0] * v2[v2Start + 2]; dest[destStart + 2] = v1[v1Start + 0] * v2[v2Start + 1] - v1[v1Start + 1] * v2[v2Start + 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. public static float rcVdot(float[] v1, 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. public static void rcVmad(float[] dest, float[] v1, float[] v2, 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)] public static void rcVadd(float[] dest, float[] v1, 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)] public static void rcVsub(float[] dest, float[] v1, float[] v2) { dest[0] = v1[0] - v2[0]; dest[1] = v1[1] - v2[1]; dest[2] = v1[2] - v2[2]; } public static void rcVsub(float[] dest, int destStart, float[] v1, int v1Start, float[] v2, int v2Start) { dest[destStart + 0] = v1[v1Start + 0] - v2[v2Start + 0]; dest[destStart + 1] = v1[v1Start + 1] - v2[v2Start + 1]; dest[destStart + 2] = v1[v1Start + 2] - v2[v2Start + 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)] public static void rcVmin(float[] mn, float[] v) { mn[0] = Math.Min(mn[0], v[0]); mn[1] = Math.Min(mn[1], v[1]); mn[2] = Math.Min(mn[2], v[2]); } public static void rcVmin(float[] mn, int mnStart, float[] v, int vStart) { mn[0 + mnStart] = Math.Min(mn[0 + mnStart], v[0 + vStart]); mn[1 + mnStart] = Math.Min(mn[1 + mnStart], v[1 + vStart]); mn[2 + mnStart] = Math.Min(mn[2 + mnStart], v[2 + vStart]); } /// 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)] public static void rcVmax(float[] mx, float[] v) { mx[0] = Math.Max(mx[0], v[0]); mx[1] = Math.Max(mx[1], v[1]); mx[2] = Math.Max(mx[2], v[2]); } public static void rcVmax(float[] mx, int mxStart, float[] v, int vStart) { mx[0 + mxStart] = Math.Max(mx[0 + mxStart], v[0 + vStart]); mx[1 + mxStart] = Math.Max(mx[1 + mxStart], v[1 + vStart]); mx[2 + mxStart] = Math.Max(mx[2 + mxStart], v[2 + vStart]); } /// Performs a vector copy. /// @param[out] dest The result. [(x, y, z)] /// @param[in] v The vector to copy. [(x, y, z)] public static void rcVcopy(float[] dest, float[] v) { dest[0] = v[0]; dest[1] = v[1]; dest[2] = v[2]; } public static void rcVcopy(float[] dest, int destStart, float[] v, int vStart) { dest[destStart + 0] = v[vStart + 0]; dest[destStart + 1] = v[vStart + 1]; dest[destStart + 2] = v[vStart + 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. public static float rcVdist(float[] v1, float[] v2) { float dx = v2[0] - v1[0]; float dy = v2[1] - v1[1]; float dz = v2[2] - v1[2]; return (float)Math.Sqrt(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. public static float rcVdistSqr(float[] v1, 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)] public static void rcVnormalize(float[] v) { float d = 1.0f / (float)Math.Sqrt((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * 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] nv The number of vertices in the @p verts array. /// @param[out] bmin The minimum bounds of the AABB. [(x, y, z)] [Units: wu] /// @param[out] bmax The maximum bounds of the AABB. [(x, y, z)] [Units: wu] //void rcCalcBounds(const float* verts, int nv, float* bmin, float* bmax); /// Calculates the grid size based on the bounding box and grid cell size. /// @ingroup recast /// @param[in] bmin The minimum bounds of the AABB. [(x, y, z)] [Units: wu] /// @param[in] bmax The maximum bounds of the AABB. [(x, y, z)] [Units: wu] /// @param[in] cs The xz-plane cell size. [Limit: > 0] [Units: wu] /// @param[out] w The width along the x-axis. [Limit: >= 0] [Units: vx] /// @param[out] h The height along the z-axis. [Limit: >= 0] [Units: vx] //void rcCalcGridSize(const float* bmin, const float* bmax, float cs, int* w, int* h); /// Initializes a new heightfield. /// @ingroup recast /// @param[in,out] ctx The build context to use during the operation. /// @param[in,out] hf The allocated heightfield to initialize. /// @param[in] width The width of the field along the x-axis. [Limit: >= 0] [Units: vx] /// @param[in] height The height of the field along the z-axis. [Limit: >= 0] [Units: vx] /// @param[in] bmin The minimum bounds of the field's AABB. [(x, y, z)] [Units: wu] /// @param[in] bmax The maximum bounds of the field's AABB. [(x, y, z)] [Units: wu] /// @param[in] cs The xz-plane cell size to use for the field. [Limit: > 0] [Units: wu] /// @param[in] ch The y-axis cell size to use for field. [Limit: > 0] [Units: wu] //bool rcCreateHeightfield(rcContext* ctx, rcHeightfield& hf, int width, int height, // const float* bmin, const float* bmax, // float cs, float ch); /// Sets the area id of all triangles with a slope below the specified value /// to #RC_WALKABLE_AREA. /// @ingroup recast /// @param[in,out] ctx 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] nv The number of vertices. /// @param[in] tris The triangle vertex indices. [(vertA, vertB, vertC) * @p nt] /// @param[in] nt The number of triangles. /// @param[out] areas The triangle area ids. [Length: >= @p nt] //void rcMarkWalkableTriangles(rcContext* ctx, const float walkableSlopeAngle, const float* verts, int nv, // const int* tris, int nt, byte* areas); /// Sets the area id of all triangles with a slope greater than or equal to the specified value to #RC_NULL_AREA. /// @ingroup recast /// @param[in,out] ctx 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] nv The number of vertices. /// @param[in] tris The triangle vertex indices. [(vertA, vertB, vertC) * @p nt] /// @param[in] nt The number of triangles. /// @param[out] areas The triangle area ids. [Length: >= @p nt] //void rcClearUnwalkableTriangles(rcContext* ctx, const float walkableSlopeAngle, const float* verts, int nv, //const int* tris, int nt, byte* areas); /// Adds a span to the specified heightfield. /// @ingroup recast /// @param[in,out] ctx The build context to use during the operation. /// @param[in,out] hf An initialized heightfield. /// @param[in] x The width index where the span is to be added. /// [Limits: 0 <= value < rcHeightfield::width] /// @param[in] y The height index where the span is to be added. /// [Limits: 0 <= value < rcHeightfield::height] /// @param[in] smin The minimum height of the span. [Limit: < @p smax] [Units: vx] /// @param[in] smax The maximum height of the span. [Limit: <= #RC_SPAN_MAX_HEIGHT] [Units: vx] /// @param[in] area The area id of the span. [Limit: <= #RC_WALKABLE_AREA) /// @param[in] flagMergeThr The merge theshold. [Limit: >= 0] [Units: vx] //void rcAddSpan(rcContext* ctx, rcHeightfield& hf, const int x, const int y, // const ushort smin, const ushort smax, // const byte area, const int flagMergeThr); /// Rasterizes a triangle into the specified heightfield. /// @ingroup recast /// @param[in,out] ctx 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] area The area id of the triangle. [Limit: <= #RC_WALKABLE_AREA] /// @param[in,out] solid An initialized heightfield. /// @param[in] flagMergeThr The distance where the walkable flag is favored over the non-walkable flag. /// [Limit: >= 0] [Units: vx] //void rcRasterizeTriangle(rcContext* ctx, const float* v0, const float* v1, const float* v2, // const byte area, rcHeightfield& solid, // const int flagMergeThr = 1); /// Rasterizes an indexed triangle mesh into the specified heightfield. /// @ingroup recast /// @param[in,out] ctx The build context to use during the operation. /// @param[in] verts The vertices. [(x, y, z) * @p nv] /// @param[in] nv The number of vertices. /// @param[in] tris The triangle indices. [(vertA, vertB, vertC) * @p nt] /// @param[in] areas The area id's of the triangles. [Limit: <= #RC_WALKABLE_AREA] [Size: @p nt] /// @param[in] nt The number of triangles. /// @param[in,out] solid An initialized heightfield. /// @param[in] flagMergeThr The distance where the walkable flag is favored over the non-walkable flag. /// [Limit: >= 0] [Units: vx] //void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int nv, // const int* tris, const byte* areas, const int nt, // rcHeightfield& solid, const int flagMergeThr = 1); /// Rasterizes an indexed triangle mesh into the specified heightfield. /// @ingroup recast /// @param[in,out] ctx The build context to use during the operation. /// @param[in] verts The vertices. [(x, y, z) * @p nv] /// @param[in] nv The number of vertices. /// @param[in] tris The triangle indices. [(vertA, vertB, vertC) * @p nt] /// @param[in] areas The area id's of the triangles. [Limit: <= #RC_WALKABLE_AREA] [Size: @p nt] /// @param[in] nt The number of triangles. /// @param[in,out] solid An initialized heightfield. /// @param[in] flagMergeThr The distance where the walkable flag is favored over the non-walkable flag. /// [Limit: >= 0] [Units: vx] //void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int nv, // const ushort* tris, const byte* areas, const int nt, // rcHeightfield& solid, const int flagMergeThr = 1); /// Rasterizes triangles into the specified heightfield. /// @ingroup recast /// @param[in,out] ctx 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] areas The area id's of the triangles. [Limit: <= #RC_WALKABLE_AREA] [Size: @p nt] /// @param[in] nt The number of triangles. /// @param[in,out] solid An initialized heightfield. /// @param[in] flagMergeThr The distance where the walkable flag is favored over the non-walkable flag. /// [Limit: >= 0] [Units: vx] //void rcRasterizeTriangles(rcContext* ctx, const float* verts, const byte* areas, const int nt, // rcHeightfield& solid, const int flagMergeThr = 1); /// Marks non-walkable spans as walkable if their maximum is within @p walkableClimp of a walkable neihbor. /// @ingroup recast /// @param[in,out] ctx 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] solid A fully built heightfield. (All spans have been added.) //void rcFilterLowHangingWalkableObstacles(rcContext* ctx, const int walkableClimb, rcHeightfield& solid); /// Marks spans that are ledges as not-walkable. /// @ingroup recast /// @param[in,out] ctx 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] solid A fully built heightfield. (All spans have been added.) //void rcFilterLedgeSpans(rcContext* ctx, const int walkableHeight, // const int walkableClimb, rcHeightfield& solid); /// Marks walkable spans as not walkable if the clearence above the span is less than the specified height. /// @ingroup recast /// @param[in,out] ctx 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] solid A fully built heightfield. (All spans have been added.) //void rcFilterWalkableLowHeightSpans(rcContext* ctx, int walkableHeight, rcHeightfield& solid); /// Returns the number of spans contained in the specified heightfield. /// @ingroup recast /// @param[in,out] ctx The build context to use during the operation. /// @param[in] hf An initialized heightfield. /// @returns The number of spans in the heightfield. //int rcGetHeightFieldSpanCount(rcContext* ctx, rcHeightfield& hf); /// @} /// @name Compact Heightfield Functions /// @see rcCompactHeightfield /// @{ /// Builds a compact heightfield representing open space, from a heightfield representing solid space. /// @ingroup recast /// @param[in,out] ctx 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] hf The heightfield to be compacted. /// @param[out] chf The resulting compact heightfield. (Must be pre-allocated.) /// @returns True if the operation completed successfully. //bool rcBuildCompactHeightfield(rcContext* ctx, const int walkableHeight, const int walkableClimb, // rcHeightfield& hf, rcCompactHeightfield& chf); /// 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, byte 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, byte 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[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, byte 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, // const int borderSize, const int minRegionArea, const int mergeRegionArea); /// 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, // const int borderSize, const int minRegionArea, const int mergeRegionArea); /// Sets the neighbor connection data for the specified direction. /// @param[in] s The span to update. /// @param[in] dir The direction to set. [Limits: 0 <= value < 4] /// @param[in] i The index of the neighbor span. public static void rcSetCon(ref rcCompactSpan s, int dir, int i) { uint udir = (uint)dir; int shift = (int)(udir * 6); uint con = s.con; s.con = (uint)(con & ~(0x3f << shift)) | (((uint)i & 0x3f) << shift); } /// Gets neighbor connection data for the specified direction. /// @param[in] s The span to check. /// @param[in] dir 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. public static int rcGetCon(rcCompactSpan s, int dir) { uint udir = (uint)dir; int shift = (int)(udir * 6); return (int)((s.con >> shift) & 0x3f); } /// Gets the standard width (x-axis) offset for the specified direction. /// @param[in] dir The direction. [Limits: 0 <= value < 4] /// @return The width offset to apply to the current cell position to move /// in the direction. public static int rcGetDirOffsetX(int dir) { int[] offset = new int[] { -1, 0, 1, 0, }; return offset[dir & 0x03]; } /// Gets the standard height (z-axis) offset for the specified direction. /// @param[in] dir The direction. [Limits: 0 <= value < 4] /// @return The height offset to apply to the current cell position to move /// in the direction. public static int rcGetDirOffsetY(int dir) { int[] offset = new int[] { 0, 1, 0, -1 }; return offset[dir & 0x03]; } /// @} /// @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, rcCompactHeightfield& chf, // const int borderSize, const 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 simplfied 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, rcCompactHeightfield& chf, // const float maxError, const int maxEdgeLen, // rcContourSet& cset, const int flags = 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, 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 samping 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, // const float sampleDist, const 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); /// @} } /////////////////////////////////////////////////////////////////////////// // 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.