Subversion Repository Public Repository

Divide-Framework

This repository has no backups
This repository's network speed is throttled to 100KB/sec

Diff Revisions 330 vs 331 for /trunk/Source Code/AI/PathFinding/NavMeshes/Headers/NavMeshConfig.h

Diff revisions: vs.
  @@ -26,7 +26,7 @@
26 26 #include "NavMeshDefines.h"
27 27 #include <math.h>
28 28
29 - /*Code from: http://www.ogre3d.org/forums/viewtopic.php?f=11&t=69781&sid=2439989b4c0208780a353e4c90f9864b */
29 + /*http://www.ogre3d.org/forums/viewtopic.php?f=11&t=69781&sid=2439989b4c0208780a353e4c90f9864b */
30 30
31 31 namespace Divide {
32 32 namespace AI {
  @@ -56,46 +56,123 @@
56 56 /*****************
57 57 * Rasterization
58 58 *****************/
59 - inline void setCellSize(F32 cellSize) { this->_cellSize = cellSize; eval(); }
60 - inline void setCellHeight(F32 cellHeight) { this->_cellHeight = cellHeight; eval(); }
61 - inline void setTileSize(I32 tileSize) { this->_tileSize = tileSize;}
59 + inline void setCellSize(F32 cellSize) {
60 + this->_cellSize = cellSize;
61 + eval();
62 + }
63 +
64 + inline void setCellHeight(F32 cellHeight) {
65 + this->_cellHeight = cellHeight;
66 + eval();
67 + }
68 +
69 + inline void setTileSize(I32 tileSize) {
70 + this->_tileSize = tileSize;
71 + }
72 +
62 73 /*****************
63 74 * Agent
64 75 *****************/
65 - inline void setAgentHeight(F32 agentHeight) { this->_agentHeight = agentHeight; eval(); }
66 - inline void setAgentRadius(F32 agentRadius) { this->_agentRadius = agentRadius; eval(); }
67 - inline void setAgentMaxClimb(F32 agentMaxClimb) { this->_agentMaxClimb = agentMaxClimb; eval(); }
68 - inline void setAgentMaxSlope(F32 agentMaxSlope) { this->_agentMaxSlope = agentMaxSlope; }
76 + inline void setAgentHeight(F32 agentHeight) {
77 + this->_agentHeight = agentHeight;
78 + eval();
79 + }
80 +
81 + inline void setAgentRadius(F32 agentRadius) {
82 + this->_agentRadius = agentRadius;
83 + eval();
84 + }
85 +
86 + inline void setAgentMaxClimb(F32 agentMaxClimb) {
87 + this->_agentMaxClimb = agentMaxClimb;
88 + eval();
89 + }
90 +
91 + inline void setAgentMaxSlope(F32 agentMaxSlope) {
92 + this->_agentMaxSlope = agentMaxSlope;
93 + }
94 +
69 95 /*****************
70 96 * Region
71 97 *****************/
72 - inline void setRegionMinSize(F32 regionMinSize) { this->_regionMinSize = regionMinSize; eval(); }
73 - inline void setRegionMergeSize(F32 regionMergeSize) { this->_regionMergeSize = regionMergeSize; eval(); }
98 + inline void setRegionMinSize(F32 regionMinSize) {
99 + this->_regionMinSize = regionMinSize;
100 + eval();
101 + }
102 +
103 + inline void setRegionMergeSize(F32 regionMergeSize) {
104 + this->_regionMergeSize = regionMergeSize;
105 + eval();
106 + }
107 +
74 108 /*****************
75 109 * Polygonization
76 110 *****************/
77 - inline void setEdgeMaxLen(F32 edgeMaxLength) { this->_edgeMaxLen = edgeMaxLength; eval(); }
78 - inline void setEdgeMaxError(F32 edgeMaxError) { this->_edgeMaxError = edgeMaxError;}
79 - inline void setVertsPerPoly(I32 vertsPerPoly) { this->_vertsPerPoly = vertsPerPoly; }
111 + inline void setEdgeMaxLen(F32 edgeMaxLength) {
112 + this->_edgeMaxLen = edgeMaxLength;
113 + eval();
114 + }
115 +
116 + inline void setEdgeMaxError(F32 edgeMaxError) {
117 + this->_edgeMaxError = edgeMaxError;
118 + }
119 +
120 + inline void setVertsPerPoly(I32 vertsPerPoly) {
121 + this->_vertsPerPoly = vertsPerPoly;
122 + }
123 +
80 124 /*****************
81 125 * Detail mesh
82 126 *****************/
83 - inline void setDetailSampleDist(F32 detailSampleDist) { this->_detailSampleDist = detailSampleDist; eval(); }
84 - inline void setDetailSampleMaxError(F32 detailSampleMaxError) { this->_detailSampleMaxError = detailSampleMaxError; eval(); }
85 - inline void setKeepInterResults(bool keepInterResults) { this->_keepInterResults = keepInterResults; }
127 + inline void setDetailSampleDist(F32 detailSampleDist) {
128 + this->_detailSampleDist = detailSampleDist;
129 + eval();
130 + }
131 +
132 + inline void setDetailSampleMaxError(F32 detailSampleMaxError) {
133 + this->_detailSampleMaxError = detailSampleMaxError;
134 + eval();
135 + }
136 +
137 + inline void setKeepInterResults(bool keepInterResults) {
138 + this->_keepInterResults = keepInterResults;
139 + }
86 140
87 141 /*********************************************************************
88 142 * Override derived parameters (params set in the eval function)
89 143 *********************************************************************/
90 144
91 - inline void base_setWalkableHeight(I32 walkableHeight) { this->_walkableHeight = walkableHeight; }
92 - inline void base_setWalkableClimb(I32 walkableClimb) { this->_walkableClimb = walkableClimb; }
93 - inline void base_setWalkableRadius(I32 walkableRadius) { this->_walkableRadius = walkableRadius; }
94 - inline void base_setMaxEdgeLen(I32 maxEdgeLen) { this->_maxEdgeLen = maxEdgeLen; }
95 - inline void base_setMinRegionArea(I32 minRegionArea) { this->_minRegionArea = minRegionArea; }
96 - inline void base_setMergeRegionArea(I32 mergeRegionArea) { this->_mergeRegionArea = mergeRegionArea; }
97 - inline void base_setDetailSampleDist(F32 detailSampleDist) { this->_base_detailSampleDist = detailSampleDist; }
98 - inline void base_setDetailSampleMaxError(F32 detailSampleMaxError) { this->_base_detailSampleMaxError = detailSampleMaxError; }
145 + inline void base_setWalkableHeight(I32 walkableHeight) {
146 + this->_walkableHeight = walkableHeight;
147 + }
148 +
149 + inline void base_setWalkableClimb(I32 walkableClimb) {
150 + this->_walkableClimb = walkableClimb;
151 + }
152 +
153 + inline void base_setWalkableRadius(I32 walkableRadius) {
154 + this->_walkableRadius = walkableRadius;
155 + }
156 +
157 + inline void base_setMaxEdgeLen(I32 maxEdgeLen) {
158 + this->_maxEdgeLen = maxEdgeLen;
159 + }
160 +
161 + inline void base_setMinRegionArea(I32 minRegionArea) {
162 + this->_minRegionArea = minRegionArea;
163 + }
164 +
165 + inline void base_setMergeRegionArea(I32 mergeRegionArea) {
166 + this->_mergeRegionArea = mergeRegionArea;
167 + }
168 +
169 + inline void base_setDetailSampleDist(F32 detailSampleDist) {
170 + this->_base_detailSampleDist = detailSampleDist;
171 + }
172 +
173 + inline void base_setDetailSampleMaxError(F32 detailSampleMaxError) {
174 + this->_base_detailSampleMaxError = detailSampleMaxError;
175 + }
99 176
100 177 inline F32 getCellSize() const { return _cellSize; }
101 178 inline F32 getCellHeight() const { return _cellHeight; }
  @@ -146,27 +223,36 @@
146 223 /**
147 224 * Cellsize (cs) is the width and depth resolution used when sampling the source geometry.
148 225 * The width and depth of the cell columns that make up voxel fields.
149 - * Cells are laid out on the width/depth plane of voxel fields. Width is associated with the x-axis of the source geometry. Depth is associated with the z-axis.
150 - * A lower value allows for the generated meshes to more closely match the source geometry, but at a higher processing and memory cost.
151 - *
226 + * Cells are laid out on the width/depth plane of voxel fields.
227 + * Width is associated with the x-axis of the source geometry. Depth is associated with the z-axis.
228 + * A lower value allows for the generated meshes to more closely match the source geometry,
229 + * but at a higher processing and memory cost.
152 230 * The xz-plane cell size to use for fields. [Limit: > 0] [Units: wu].
153 - * cs and ch define voxel/grid/cell size. So their values have significant side effects on all parameters defined in voxel units.
154 - * The minimum value for this parameter depends on the platform's floating point accuracy, with the practical minimum usually around 0.05.
231 + * cs and ch define voxel/grid/cell size.
232 + * So their values have significant side effects on all parameters defined in voxel units.
233 + * The minimum value for this parameter depends on the platform's floating point accuracy,
234 + * with the practical minimum usually around 0.05.
155 235 **/
156 236 F32 _cellSize;
157 237
158 238 /**
159 - * Cellheight (ch) is the height resolution used when sampling the source geometry. The height of the voxels in voxel fields.
239 + * Cellheight (ch) is the height resolution used when sampling the source geometry.
240 + * The height of the voxels in voxel fields.
160 241 * Height is associated with the y-axis of the source geometry.
161 - * A smaller value allows for the final meshes to more closely match the source geometry at a potentially higher processing cost.
242 + * A smaller value allows for the final meshes to more closely match the source geometry
243 + * at a potentially higher processing cost.
162 244 * (Unlike cellSize, using a lower value for cellHeight does not significantly increase memory use.)
163 245 *
164 246 * The y-axis cell size to use for fields. [Limit: > 0] [Units: wu].
165 - * cs and ch define voxel/grid/cell size. So their values have significant side effects on all parameters defined in voxel units.
166 - * The minimum value for this parameter depends on the platform's floating point accuracy, with the practical minimum usually around 0.05.
167 - *
168 - * Setting ch lower will result in more accurate detection of areas the agent can still pass under, as min walkable height is discretisized
169 - * in number of cells. Also walkableClimb's precision is affected by ch in the same way, along with some other parameters.
247 + * cs and ch define voxel/grid/cell size. So their values have significant side effects
248 + * on all parameters defined in voxel units.
249 + * The minimum value for this parameter depends on the platform's floating point accuracy,
250 + * with the practical minimum usually around 0.05.
251 + *
252 + * Setting ch lower will result in more accurate detection of areas the agent can still pass under,
253 + * as min walkable height is discretisized
254 + * in number of cells. Also walkableClimb's precision is affected by ch in the same way,
255 + * along with some other parameters.
170 256 **/
171 257 F32 _cellHeight;
172 258
  @@ -184,27 +270,33 @@
184 270 * agents can walk under. Parts of the navmesh with lower ceilings
185 271 * will be pruned off.
186 272 *
187 - * This parameter serves at setting walkableHeight (minTraversableHeight) parameter, precision of this parameter is determined by cellHeight (ch).
273 + * This parameter serves at setting walkableHeight (minTraversableHeight) parameter,
274 + * precision of this parameter is determined by cellHeight (ch).
188 275 **/
189 276 F32 _agentHeight;
190 277
191 278 /**
192 279 * The Maximum ledge height that is considered to still be traversable.
193 - * This parameter serves at setting walkableClimb (maxTraversableStep) parameter, precision of this parameter is determined by cellHeight (ch).
280 + * This parameter serves at setting walkableClimb (maxTraversableStep) parameter,
281 + * precision of this parameter is determined by cellHeight (ch).
194 282 * [Limit: >=0]
195 - * Allows the mesh to flow over low lying obstructions such as curbs and up/down stairways. The value is usually set to how far up/down an agent can step.
283 + * Allows the mesh to flow over low lying obstructions such as curbs and up/down stairways.
284 + * The value is usually set to how far up/down an agent can step.
196 285 **/
197 286 F32 _agentMaxClimb;
198 287
199 288 /**
200 289 * The radius on the xz (ground) plane of the circle that describes the agent (character) size.
201 - * Serves at setting walkableRadius (traversableAreaBorderSize) parameter, the precision of walkableRadius is affected by cellSize (cs).
290 + * Serves at setting walkableRadius (traversableAreaBorderSize) parameter,
291 + * the precision of walkableRadius is affected by cellSize (cs).
202 292 *
203 - * This parameter is also used by DetourCrowd to determine the area other agents have to avoid in order not to collide with an agent.
293 + * This parameter is also used by DetourCrowd to determine the area other agents have to avoid
294 + * in order not to collide with an agent.
204 295 * The distance to erode/shrink the walkable area of the heightfield away from obstructions.
205 296 * [Limit: >=0]
206 297 *
207 - * In general, this is the closest any part of the final mesh should get to an obstruction in the source geometry. It is usually set to the maximum agent radius.
298 + * In general, this is the closest any part of the final mesh should get to an obstruction
299 + * in the source geometry. It is usually set to the maximum agent radius.
208 300 * While a value of zero is legal, it is not recommended and can result in odd edge case issues.
209 301 *
210 302 **/
  @@ -213,46 +305,54 @@
213 305 /**
214 306 * The maximum allowed length for contour edges along the border of the mesh.
215 307 * [Limit: >=0]
216 - * Extra vertices will be inserted as needed to keep contour edges below this length. A value of zero effectively disables this feature.
308 + * Extra vertices will be inserted as needed to keep contour edges below this length.
309 + * A value of zero effectively disables this feature.
217 310 * Serves at setting maxEdgeLen, the precision of maxEdgeLen is affected by cellSize (cs).
218 311 **/
219 312 F32 _edgeMaxLen;
220 313
221 314 /**
222 - * The maximum distance a simplfied contour's border edges should deviate the original raw contour. (edge matching)
223 - * [Limit: >=0] [Units: wu]
315 + * The maximum distance a simplfied contour's border edges should deviate the original raw contour.
316 + * (edge matching) [Limit: >=0] [Units: wu]
224 317 * The effect of this parameter only applies to the xz-plane.
225 318 *
226 319 * Also called maxSimplificationError or edgeMaxDeviation
227 320 * The maximum distance the edges of meshes may deviate from the source geometry.
228 - * A lower value will result in mesh edges following the xz-plane geometry contour more accurately at the expense of an increased triangle count.
229 - * A value to zero is not recommended since it can result in a large increase in the number of polygons in the final meshes at a high processing cost.
321 + * A lower value will result in mesh edges following the xz-plane geometry contour more accurately
322 + * at the expense of an increased triangle count.
323 + * A value to zero is not recommended since it can result in a large increase in the number of
324 + * polygons in the final meshes at a high processing cost.
230 325 **/
231 326 F32 _edgeMaxError;
232 327
233 328 /**
234 329 * The minimum number of cells allowed to form isolated island areas (size).
235 330 * [Limit: >=0]
236 - * Any regions that are smaller than this area will be marked as unwalkable. This is useful in removing useless regions that can sometimes form on geometry such as table tops, box tops, etc.
237 - * Serves at setting minRegionArea, which will be set to the square of this value (the regions are square, thus area=size*size)
331 + * Any regions that are smaller than this area will be marked as unwalkable.
332 + * This is useful in removing useless regions that can sometimes form on geometry such as table tops, box tops, etc.
333 + * Serves at setting minRegionArea, which will be set to the square of this value
334 + * (the regions are square, thus area=size*size)
238 335 **/
239 336 F32 _regionMinSize;
240 337
241 338 /**
242 339 * Any regions with a span count smaller than this value will, if possible, be merged with larger regions.
243 340 * [Limit: >=0] [Units: vx]
244 - * Serves at setting MergeRegionArea, which will be set to the square of this value (the regions are square, thus area=size*size)
341 + * Serves at setting MergeRegionArea, which will be set to the square of this value
342 + * (the regions are square, thus area=size*size)
245 343 **/
246 344 F32 _regionMergeSize;
247 345
248 346 /**
249 347 * The maximum number of vertices allowed for polygons generated during the contour to polygon conversion process.
250 348 * [Limit: >= 3]
251 - * If the mesh data is to be used to construct a Detour navigation mesh, then the upper limit is limited to <= DT_VERTS_PER_POLYGON (=6).
349 + * If the mesh data is to be used to construct a Detour navigation mesh,
350 + * then the upper limit is limited to <= DT_VERTS_PER_POLYGON (=6).
252 351 *
253 352 * Also called maxVertsPerPoly
254 353 * The maximum number of vertices per polygon for polygons generated during the voxel to polygon conversion process.
255 - * Higher values increase processing cost, but can also result in better formed polygons in the final meshes. A value of around 6 is generally adequate with diminishing returns for higher values.
354 + * Higher values increase processing cost, but can also result in better formed polygons in the final meshes.
355 + * A value of around 6 is generally adequate with diminishing returns for higher values.
256 356 **/
257 357 I32 _vertsPerPoly;
258 358
  @@ -262,7 +362,9 @@
262 362 *
263 363 * Also called contourSampleDistance
264 364 * Sets the sampling distance to use when matching the detail mesh to the surface of the original geometry.
265 - * Impacts how well the final detail mesh conforms to the surface contour of the original geometry. Higher values result in a detail mesh which conforms more closely to the original geometry's surface at the cost of a higher final triangle count and higher processing cost.
365 + * Impacts how well the final detail mesh conforms to the surface contour of the original geometry.
366 + * Higher values result in a detail mesh which conforms more closely to the original geometry's surface
367 + * at the cost of a higher final triangle count and higher processing cost.
266 368 * Setting this argument to less than 0.9 disables this functionality.
267 369 **/
268 370 F32 _detailSampleDist;
  @@ -275,13 +377,15 @@
275 377 * The maximum distance the surface of the detail mesh may deviate from the surface of the original geometry.
276 378 * The accuracy is impacted by contourSampleDistance.
277 379 * The value of this parameter has no meaning if contourSampleDistance is set to zero.
278 - * Setting the value to zero is not recommended since it can result in a large increase in the number of triangles in the final detail mesh at a high processing cost.
380 + * Setting the value to zero is not recommended since it can result in a large increase in the number of
381 + * triangles in the final detail mesh at a high processing cost.
279 382 * Stronly related to detailSampleDist (contourSampleDistance).
280 383 **/
281 384 F32 _detailSampleMaxError;
282 385
283 386 /**
284 - * Determines whether intermediary results are stored in OgreRecast class or whether they are removed after navmesh creation.
387 + * Determines whether intermediary results are stored in OgreRecast class or whether they are
388 + * removed after navmesh creation.
285 389 **/
286 390 bool _keepInterResults;
287 391
  @@ -292,7 +396,8 @@
292 396 *
293 397 * Minimum floor to 'ceiling' height that will still allow the floor area to be considered walkable.
294 398 * [Limit: >= 3] [Units: vx]
295 - * Permits detection of overhangs in the source geometry that make the geometry below un-walkable. The value is usually set to the maximum agent height.
399 + * Permits detection of overhangs in the source geometry that make the geometry below un-walkable.
400 + * The value is usually set to the maximum agent height.
296 401 *
297 402 * Also called minTraversableHeight
298 403 * This value should be at least two times the value of cellHeight in order to get good results.
  @@ -302,18 +407,21 @@
302 407 /**
303 408 * Maximum ledge height that is considered to still be traversable, in number of cells (height).
304 409 * [Limit: >=0] [Units: vx].
305 - * Allows the mesh to flow over low lying obstructions such as curbs and up/down stairways. The value is usually set to how far up/down an agent can step.
410 + * Allows the mesh to flow over low lying obstructions such as curbs and up/down stairways.
411 + * The value is usually set to how far up/down an agent can step.
306 412 *
307 413 * Also called maxTraversableStep
308 414 * Represents the maximum ledge height that is considered to still be traversable.
309 - * Prevents minor deviations in height from improperly showing as obstructions. Permits detection of stair-like structures, curbs, etc.
415 + * Prevents minor deviations in height from improperly showing as obstructions.
416 + * Permits detection of stair-like structures, curbs, etc.
310 417 **/
311 418 I32 _walkableClimb;
312 419
313 420 /**
314 421 * The distance to erode/shrink the walkable area of the heightfield away from obstructions, in cellsize units.
315 422 * [Limit: >=0] [Units: vx]
316 - * In general, this is the closest any part of the final mesh should get to an obstruction in the source geometry. It is usually set to the maximum agent radius.
423 + * In general, this is the closest any part of the final mesh should get to an obstruction in the source geometry.
424 + * It is usually set to the maximum agent radius.
317 425 * While a value of zero is legal, it is not recommended and can result in odd edge case issues.
318 426 *
319 427 * Also called traversableAreaBorderSize
  @@ -321,15 +429,18 @@
321 429 * Usually this value is set to the maximum bounding radius of agents utilizing the meshes for navigation decisions.
322 430 *
323 431 * This value must be greater than the cellSize to have an effect.
324 - * The actual border will be larger around ledges if ledge clipping is enabled. See the clipLedges parameter for more information.
325 - * The actual border area will be larger if smoothingTreshold is > 0. See the smoothingThreshold parameter for more information.
432 + * The actual border will be larger around ledges if ledge clipping is enabled.
433 + * See the clipLedges parameter for more information.
434 + * The actual border area will be larger if smoothingTreshold is > 0.
435 + * See the smoothingThreshold parameter for more information.
326 436 **/
327 437 I32 _walkableRadius;
328 438
329 439 /**
330 440 * The maximum allowed length for contour edges along the border of the mesh.
331 441 * [Limit: >=0] [Units: vx].
332 - * Extra vertices will be inserted as needed to keep contour edges below this length. A value of zero effectively disables this feature.
442 + * Extra vertices will be inserted as needed to keep contour edges below this length.
443 + * A value of zero effectively disables this feature.
333 444 *
334 445 * Also called maxEdgeLength
335 446 * The maximum length of polygon edges that represent the border of meshes.
  @@ -348,7 +459,8 @@
348 459 * Also called minUnconnectedRegionSize
349 460 * The minimum region size for unconnected (island) regions.
350 461 * The value is in voxels.
351 - * Regions that are not connected to any other region and are smaller than this size will be culled before mesh generation. I.e. They will no longer be considered traversable.
462 + * Regions that are not connected to any other region and are smaller than this size will be
463 + * culled before mesh generation. I.e. They will no longer be considered traversable.
352 464 **/
353 465 I32 _minRegionArea;
354 466
  @@ -359,8 +471,10 @@
359 471 * Also called mergeRegionSize or mergeRegionArea
360 472 * Any regions smaller than this size will, if possible, be merged with larger regions.
361 473 * Value is in voxels.
362 - * Helps reduce the number of small regions. This is especially an issue in diagonal path regions where inherent faults in the region generation algorithm can result in unnecessarily small regions.
363 - * Small regions are left unchanged if they cannot be legally merged with a neighbor region. (E.g. Merging will result in a non-simple polygon.)
474 + * Helps reduce the number of small regions. This is especially an issue in diagonal path regions
475 + * where inherent faults in the region generation algorithm can result in unnecessarily small regions.
476 + * Small regions are left unchanged if they cannot be legally merged with a neighbor region.
477 + * (E.g. Merging will result in a non-simple polygon.)
364 478 **/
365 479 I32 _mergeRegionArea;
366 480
  @@ -370,12 +484,16 @@
370 484 *
371 485 * Also called contourSampleDistance
372 486 * Sets the sampling distance to use when matching the detail mesh to the surface of the original geometry.
373 - * Impacts how well the final detail mesh conforms to the surface contour of the original geometry. Higher values result in a
374 - * detail mesh which conforms more closely to the original geometry's surface at the cost of a higher final triangle count and higher processing cost.
487 + * Impacts how well the final detail mesh conforms to the surface contour of the original geometry.
488 + * Higher values result in a
489 + * detail mesh which conforms more closely to the original geometry's surface at the cost of
490 + * a higher final triangle count and higher processing cost.
375 491 * Setting this argument to less than 0.9 disables this functionality.
376 492 *
377 - * The difference between this parameter and edge matching (edgeMaxError) is that this parameter operates on the height rather than the xz-plane.
378 - * It also matches the entire detail mesh surface to the contour of the original geometry. Edge matching only matches edges of meshes to the contour of the original geometry.
493 + * The difference between this parameter and edge matching (edgeMaxError) is that this parameter
494 + * operates on the height rather than the xz-plane.
495 + * It also matches the entire detail mesh surface to the contour of the original geometry.
496 + * Edge matching only matches edges of meshes to the contour of the original geometry.
379 497 **/
380 498 F32 _base_detailSampleDist;
381 499
  @@ -387,7 +505,8 @@
387 505 * The maximum distance the surface of the detail mesh may deviate from the surface of the original geometry.
388 506 * The accuracy is impacted by contourSampleDistance (detailSampleDist).
389 507 * The value of this parameter has no meaning if contourSampleDistance is set to zero.
390 - * Setting the value to zero is not recommended since it can result in a large increase in the number of triangles in the final detail mesh at a high processing cost.
508 + * Setting the value to zero is not recommended since it can result in a large increase in the number of
509 + * triangles in the final detail mesh at a high processing cost.
391 510 * This parameter has no impact if contourSampleDistance is set to zero.
392 511 **/
393 512 F32 _base_detailSampleMaxError;