From d5e3ef1f32781a97a399b443747ac0d6849be591 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 27 Jul 2026 19:37:01 +0200 Subject: [PATCH 01/51] WIP --- Extensions/NavMeshPathfinding/JsExtension.js | 161 + .../NavMeshCharacterRuntimeBehavior.ts | 539 ++++ .../NavMeshObstacleRuntimeBehavior.ts | 181 ++ .../recast-navigation-generators.js | 2840 +++++++++++++++++ .../recast-navigation.wasm.js | 38 + .../recast-navigation.wasm.wasm | Bin 0 -> 338824 bytes GDJS/Runtime/types/global-recast.d.ts | 89 + GDJS/package.json | 1 + 8 files changed, 3849 insertions(+) create mode 100644 Extensions/NavMeshPathfinding/JsExtension.js create mode 100644 Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts create mode 100644 Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts create mode 100644 Extensions/NavMeshPathfinding/recast-navigation-generators.js create mode 100644 Extensions/NavMeshPathfinding/recast-navigation.wasm.js create mode 100755 Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm create mode 100644 GDJS/Runtime/types/global-recast.d.ts diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js new file mode 100644 index 000000000000..a8da9fcdcaba --- /dev/null +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -0,0 +1,161 @@ +//@ts-check +/// +/** + * This is a declaration of an extension for GDevelop 5. + * + * ℹ️ Changes in this file are watched and automatically imported if the editor + * is running. You can also manually run `node import-GDJS-Runtime.js` (in newIDE/app/scripts). + * + * The file must be named "JsExtension.js", otherwise GDevelop won't load it. + * ⚠️ If you make a change and the extension is not loaded, open the developer console + * and search for any errors. + * + * More information on https://github.com/4ian/GDevelop/blob/master/newIDE/README-extensions.md + */ + +/** @type {ExtensionModule} */ +module.exports = { + createExtension: function (_, gd) { + const extension = new gd.PlatformExtension(); + extension + .setExtensionInformation( + 'NavMeshPathfinding', + _('Pathfinding behavior'), + 'Pathfinding allows to compute an efficient path for objects, avoiding obstacles on the way.', + '', + 'Open source (MIT License)' + ) + .setShortDescription( + 'A* pathfinding: compute paths avoiding obstacles. Configurable speed, grid, diagonals.' + ) + .setDimension('3D') + .setCategory('Movement') + .setTags('pathfinding, obstacle, collision') + .setExtensionHelpPath('/behaviors/pathfinding'); + { + const behavior = new gd.BehaviorJsImplementation(); + behavior.updateProperty = function ( + behaviorContent, + propertyName, + newValue + ) { + return false; + }; + behavior.getProperties = function (behaviorContent) { + const behaviorProperties = new gd.MapStringPropertyDescriptor(); + return behaviorProperties; + }; + + behavior.initializeContent = function (behaviorContent) {}; + + const sharedData = new gd.BehaviorSharedDataJsImplementation(); + sharedData.updateProperty = function ( + sharedContent, + propertyName, + newValue + ) { + return false; + }; + sharedData.getProperties = function (sharedContent) { + const sharedProperties = new gd.MapStringPropertyDescriptor(); + return sharedProperties; + }; + sharedData.initializeContent = function (behaviorContent) {}; + + const aut = extension + .addBehavior( + 'NavMeshCharacterBehavior', + _('3D pathfinding'), + 'NavMeshCharacter', + _( + 'Move objects to a target while avoiding all objects that are flagged as obstacles.' + ), + '', + 'CppPlatform/Extensions/AStaricon.png', + 'PathfindingBehavior', + //@ts-ignore The class hierarchy is incorrect leading to a type error, but this is valid. + behavior, + sharedData + ) + .markAsIrrelevantForChildObjects() + .addIncludeFile( + 'Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.js' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.js' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/recast-navigation.wasm.js' + ) + .addRequiredFile( + 'Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/recast-navigation-generators.js' + ); + } + { + const behavior = new gd.BehaviorJsImplementation(); + behavior.updateProperty = function ( + behaviorContent, + propertyName, + newValue + ) { + return false; + }; + behavior.getProperties = function (behaviorContent) { + const behaviorProperties = new gd.MapStringPropertyDescriptor(); + return behaviorProperties; + }; + + behavior.initializeContent = function (behaviorContent) {}; + + const sharedData = new gd.BehaviorSharedDataJsImplementation(); + sharedData.updateProperty = function ( + sharedContent, + propertyName, + newValue + ) { + return false; + }; + sharedData.getProperties = function (sharedContent) { + const sharedProperties = new gd.MapStringPropertyDescriptor(); + return sharedProperties; + }; + sharedData.initializeContent = function (behaviorContent) {}; + + const aut = extension + .addBehavior( + 'NavMeshObstacleBehavior', + _('Obstacle for 3D pathfinding'), + 'NavMeshObstacle', + _('Flag objects as being obstacles for 3D pathfinding.'), + '', + 'CppPlatform/Extensions/pathfindingobstacleicon.png', + 'NavMeshObstacle', + //@ts-ignore The class hierarchy is incorrect leading to a type error, but this is valid. + behavior, + sharedData + ) + .markAsIrrelevantForChildObjects() + .addIncludeFile( + 'Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.js' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/recast-navigation.wasm.js' + ) + .addRequiredFile( + 'Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/recast-navigation-generators.js' + ); + } + + return extension; + }, + + runExtensionSanityTests: function (gd, extension) { + return []; + }, +}; diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts new file mode 100644 index 000000000000..66ae68b3a9f3 --- /dev/null +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -0,0 +1,539 @@ +/* +GDevelop - Pathfinding Behavior Extension +Copyright (c) 2010-2016 Florian Rival (Florian.Rival@gmail.com) + */ +namespace gdjs { + const loadRecast = async () => { + try { + const module = await import('./recast-navigation.wasm.js'); + const initializeRecast = module.default; + if (!initializeRecast) { + throw new Error('No default export found in Recast.'); + } + + const Recast = await initializeRecast(); + //@ts-ignore + window.Recast = Recast; + } catch (err) { + console.error('Unable to load Recast navigation mesh library.', err); + throw err; + } + }; + gdjs.registerAsynchronouslyLoadingLibraryPromise(loadRecast()); + + interface PathfindingNetworkSyncDataType { + // Syncing the path and its position on it should be enough to have a good prediction. + path: FloatPoint[]; + pf: boolean; + sp: number; + as: number; + cs: number; + tss: number; + re: boolean; + ma: number; + dos: number; + } + + /** @category Behaviors > 2D Pathfinding */ + export interface PathfindingNetworkSyncData extends BehaviorNetworkSyncData { + props: PathfindingNetworkSyncDataType; + } + + /** + * NavMeshCharacterRuntimeBehavior represents a behavior allowing objects to + * follow a path computed to avoid obstacles. + * @category Behaviors > 2D Pathfinding + */ + export class NavMeshCharacterRuntimeBehavior extends gdjs.RuntimeBehavior { + _path: Array = []; + /** Used by the path simplification algorithm */ + static _smoothingResultVertices: Array = []; + /** Used by the path simplification algorithm */ + static _smoothingWorkingVertices: Array = []; + + //Behavior configuration: + _allowDiagonals: boolean; + _acceleration: float; + _maxSpeed: float; + _angularMaxSpeed: float; + _rotateObject: boolean; + _angleOffset: float; + _cellWidth: float; + _cellHeight: float; + _gridOffsetX: float; + _gridOffsetY: float; + _extraBorder: float; + _smoothingMaxCellGap: float; + + //Attributes used for traveling on the path: + _pathFound: boolean = false; + _speed: float = 0; + _angularSpeed: float = 0; + _distanceOnSegment: float = 0; + _totalSegmentDistance: float = 0; + _currentSegment: integer = 0; + _reachedEnd: boolean = false; + _manager: PathfindingObstaclesManager; + + _movementAngle: float = 0; + + constructor( + instanceContainer: gdjs.RuntimeInstanceContainer, + behaviorData, + owner: gdjs.RuntimeObject + ) { + super(instanceContainer, behaviorData, owner); + + //The path computed and followed by the object (Array of arrays containing x and y position) + if (this._path === undefined) { + } else { + this._path.length = 0; + } + this._allowDiagonals = behaviorData.allowDiagonals; + this._acceleration = behaviorData.acceleration; + this._maxSpeed = behaviorData.maxSpeed; + this._angularMaxSpeed = behaviorData.angularMaxSpeed; + this._rotateObject = behaviorData.rotateObject; + this._angleOffset = behaviorData.angleOffset; + this._cellWidth = behaviorData.cellWidth; + this._cellHeight = behaviorData.cellHeight; + this._gridOffsetX = behaviorData.gridOffsetX || 0; + this._gridOffsetY = behaviorData.gridOffsetY || 0; + this._extraBorder = behaviorData.extraBorder; + this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap || 0; + // this._manager = + // gdjs.PathfindingObstaclesManager.getManager(instanceContainer); + } + + override applyBehaviorOverriding(behaviorData): boolean { + if (behaviorData.allowDiagonals !== undefined) { + this.allowDiagonals(behaviorData.allowDiagonals); + } + if (behaviorData.acceleration !== undefined) { + this.setAcceleration(behaviorData.acceleration); + } + if (behaviorData.maxSpeed !== undefined) { + this.setMaxSpeed(behaviorData.maxSpeed); + } + if (behaviorData.angularMaxSpeed !== undefined) { + this.setAngularMaxSpeed(behaviorData.angularMaxSpeed); + } + if (behaviorData.rotateObject !== undefined) { + this.setRotateObject(behaviorData.rotateObject); + } + if (behaviorData.angleOffset !== undefined) { + this.setAngleOffset(behaviorData.angleOffset); + } + if (behaviorData.cellWidth !== undefined) { + this.setCellWidth(behaviorData.cellWidth); + } + if (behaviorData.cellHeight !== undefined) { + this.setCellHeight(behaviorData.cellHeight); + } + if (behaviorData.gridOffsetX !== undefined) { + this._gridOffsetX = behaviorData.gridOffsetX; + } + if (behaviorData.gridOffsetY !== undefined) { + this._gridOffsetY = behaviorData.gridOffsetY; + } + if (behaviorData.extraBorder !== undefined) { + this.setExtraBorder(behaviorData.extraBorder); + } + if (behaviorData.smoothingMaxCellGap !== undefined) { + this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap; + } + return true; + } + + getNetworkSyncData( + options: GetNetworkSyncDataOptions + ): PathfindingNetworkSyncData { + return { + ...super.getNetworkSyncData(options), + props: { + path: this._path, + pf: this._pathFound, + sp: this._speed, + as: this._angularSpeed, + cs: this._currentSegment, + tss: this._totalSegmentDistance, + re: this._reachedEnd, + ma: this._movementAngle, + dos: this._distanceOnSegment, + }, + }; + } + + updateFromNetworkSyncData( + networkSyncData: PathfindingNetworkSyncData, + options: UpdateFromNetworkSyncDataOptions + ): void { + super.updateFromNetworkSyncData(networkSyncData, options); + const behaviorSpecificProps = networkSyncData.props; + if (behaviorSpecificProps.path !== undefined) { + this._path = behaviorSpecificProps.path; + } + if (behaviorSpecificProps.pf !== undefined) { + this._pathFound = behaviorSpecificProps.pf; + } + if (behaviorSpecificProps.sp !== undefined) { + this._speed = behaviorSpecificProps.sp; + } + if (behaviorSpecificProps.as !== undefined) { + this._angularSpeed = behaviorSpecificProps.as; + } + if ( + behaviorSpecificProps.cs !== undefined && + behaviorSpecificProps.cs !== this._currentSegment + ) { + this._currentSegment = behaviorSpecificProps.cs; + } + if (behaviorSpecificProps.tss !== undefined) { + this._totalSegmentDistance = behaviorSpecificProps.tss; + } + if (behaviorSpecificProps.re !== undefined) { + this._reachedEnd = behaviorSpecificProps.re; + } + if (behaviorSpecificProps.ma !== undefined) { + this._movementAngle = behaviorSpecificProps.ma; + } + if (behaviorSpecificProps.dos !== undefined) { + this._distanceOnSegment = behaviorSpecificProps.dos; + } + } + + setCellWidth(width: float): void { + this._cellWidth = width; + } + + getCellWidth(): float { + return this._cellWidth; + } + + setCellHeight(height: float): void { + this._cellHeight = height; + } + + getCellHeight(): float { + return this._cellHeight; + } + + setGridOffsetX(gridOffsetX: float): void { + this._gridOffsetX = gridOffsetX; + } + + getGridOffsetX(): float { + return this._gridOffsetX; + } + + setGridOffsetY(gridOffsetY: float): void { + this._gridOffsetY = gridOffsetY; + } + + getGridOffsetY(): float { + return this._gridOffsetY; + } + + setAcceleration(acceleration: float): void { + this._acceleration = acceleration; + } + + getAcceleration() { + return this._acceleration; + } + + setMaxSpeed(maxSpeed: float): void { + this._maxSpeed = maxSpeed; + } + + getMaxSpeed() { + return this._maxSpeed; + } + + setSpeed(speed: float): void { + this._speed = speed; + } + + getSpeed() { + return this._speed; + } + + getMovementAngle() { + return this._movementAngle; + } + + movementAngleIsAround(degreeAngle: float, tolerance: float) { + return ( + Math.abs( + gdjs.evtTools.common.angleDifference(this._movementAngle, degreeAngle) + ) <= tolerance + ); + } + + setAngularMaxSpeed(angularMaxSpeed: float): void { + this._angularMaxSpeed = angularMaxSpeed; + } + + getAngularMaxSpeed() { + return this._angularMaxSpeed; + } + + setAngleOffset(angleOffset: float): void { + this._angleOffset = angleOffset; + } + + getAngleOffset() { + return this._angleOffset; + } + + setExtraBorder(extraBorder): void { + this._extraBorder = extraBorder; + } + + getExtraBorder() { + return this._extraBorder; + } + + allowDiagonals(allow: boolean) { + this._allowDiagonals = allow; + } + + diagonalsAllowed() { + return this._allowDiagonals; + } + + setRotateObject(allow: boolean): void { + this._rotateObject = allow; + } + + isObjectRotated(): boolean { + return this._rotateObject; + } + + getNodeX(index: integer): float { + if (index < this._path.length) { + return this._path[index][0]; + } + return 0; + } + + getNodeY(index: integer): float { + if (index < this._path.length) { + return this._path[index][1]; + } + return 0; + } + + getNextNodeIndex() { + if (this._currentSegment + 1 < this._path.length) { + return this._currentSegment + 1; + } else { + return this._path.length - 1; + } + } + + getNodeCount(): integer { + return this._path.length; + } + + getNextNodeX(): float { + if (this._path.length === 0) { + return 0; + } + if (this._currentSegment + 1 < this._path.length) { + return this._path[this._currentSegment + 1][0]; + } else { + return this._path[this._path.length - 1][0]; + } + } + + getNextNodeY(): float { + if (this._path.length === 0) { + return 0; + } + if (this._currentSegment + 1 < this._path.length) { + return this._path[this._currentSegment + 1][1]; + } else { + return this._path[this._path.length - 1][1]; + } + } + + getLastNodeX(): float { + if (this._path.length < 2) { + return 0; + } + if (this._currentSegment < this._path.length - 1) { + return this._path[this._currentSegment][0]; + } else { + return this._path[this._path.length - 1][0]; + } + } + + getLastNodeY(): float { + if (this._path.length < 2) { + return 0; + } + if (this._currentSegment < this._path.length - 1) { + return this._path[this._currentSegment][1]; + } else { + return this._path[this._path.length - 1][1]; + } + } + + getDestinationX(): float { + if (this._path.length === 0) { + return 0; + } + return this._path[this._path.length - 1][0]; + } + + getDestinationY(): float { + if (this._path.length === 0) { + return 0; + } + return this._path[this._path.length - 1][1]; + } + + /** + * Return true if the latest call to moveTo succeeded. + */ + pathFound() { + return this._pathFound; + } + + /** + * Return true if the object reached its destination. + */ + destinationReached() { + return this._reachedEnd; + } + + /** + * Compute and move on the path to the specified destination. + */ + moveTo( + instanceContainer: gdjs.RuntimeInstanceContainer, + x: float, + y: float + ) { + const owner = this.owner; + + //First be sure that there is a path to compute. + const targetCellX = Math.round((x - this._gridOffsetX) / this._cellWidth); + const targetCellY = Math.round( + (y - this._gridOffsetY) / this._cellHeight + ); + const startCellX = Math.round( + (owner.getX() - this._gridOffsetX) / this._cellWidth + ); + const startCellY = Math.round( + (owner.getY() - this._gridOffsetY) / this._cellHeight + ); + if (startCellX == targetCellX && startCellY == targetCellY) { + this._path.length = 0; + this._path.push([owner.getX(), owner.getY()]); + this._path.push([x, y]); + this._enterSegment(0); + this._pathFound = true; + return; + } + + //Start searching for a path + if (false) { + //Path found: memorize it + } + + // No path found + this._pathFound = false; + } + + _enterSegment(segmentNumber: integer) { + if (this._path.length === 0) { + return; + } + this._currentSegment = segmentNumber; + if (this._currentSegment < this._path.length - 1) { + const pathX = + this._path[this._currentSegment + 1][0] - + this._path[this._currentSegment][0]; + const pathY = + this._path[this._currentSegment + 1][1] - + this._path[this._currentSegment][1]; + this._totalSegmentDistance = Math.sqrt(pathX * pathX + pathY * pathY); + this._distanceOnSegment = 0; + this._reachedEnd = false; + this._movementAngle = + (gdjs.toDegrees(Math.atan2(pathY, pathX)) + 360) % 360; + } else { + this._reachedEnd = true; + this._speed = 0; + } + } + + doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + if (this._path.length === 0 || this._reachedEnd) { + return; + } + + // Update the speed of the object + const timeDelta = this.owner.getElapsedTime() / 1000; + const previousSpeed = this._speed; + if (this._speed !== this._maxSpeed) { + this._speed += this._acceleration * timeDelta; + if (this._speed > this._maxSpeed) { + this._speed = this._maxSpeed; + } + } + this._angularSpeed = this._angularMaxSpeed; + + // Update the time on the segment and change segment if needed + // Use a Verlet integration to be frame rate independent. + this._distanceOnSegment += + ((this._speed + previousSpeed) / 2) * timeDelta; + const remainingDistanceOnSegment = + this._totalSegmentDistance - this._distanceOnSegment; + if ( + remainingDistanceOnSegment <= 0 && + this._currentSegment < this._path.length + ) { + this._enterSegment(this._currentSegment + 1); + this._distanceOnSegment = -remainingDistanceOnSegment; + } + + // Position object on the segment and update its angle + let newPos = [0, 0]; + if (this._currentSegment < this._path.length - 1) { + newPos[0] = gdjs.evtTools.common.lerp( + this._path[this._currentSegment][0], + this._path[this._currentSegment + 1][0], + this._distanceOnSegment / this._totalSegmentDistance + ); + newPos[1] = gdjs.evtTools.common.lerp( + this._path[this._currentSegment][1], + this._path[this._currentSegment + 1][1], + this._distanceOnSegment / this._totalSegmentDistance + ); + if ( + this._rotateObject && + this.owner.getAngle() !== this._movementAngle + this._angleOffset + ) { + this.owner.rotateTowardAngle( + this._movementAngle + this._angleOffset, + this._angularSpeed + ); + } + } else { + newPos = this._path[this._path.length - 1]; + } + this.owner.setX(newPos[0]); + this.owner.setY(newPos[1]); + } + + doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {} + + } + gdjs.registerBehavior( + 'NavMeshPathfinding::NavMeshCharacterBehavior', + gdjs.NavMeshCharacterRuntimeBehavior + ); +} diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts new file mode 100644 index 000000000000..d3bb17bb8d3d --- /dev/null +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -0,0 +1,181 @@ +/* +GDevelop - Pathfinding Behavior Extension +Copyright (c) 2013-2016 Florian Rival (Florian.Rival@gmail.com) + */ + +namespace gdjs { + export interface RuntimeInstanceContainer { + pathfindingObstaclesManager: gdjs.PathfindingObstaclesManager; + } + declare var rbush: any; + + /** + * PathfindingObstaclesManager manages the common objects shared by objects + * having a pathfinding behavior: In particular, the obstacles behaviors are + * required to declare themselves (see + * `PathfindingObstaclesManager.addObstacle`) to the manager of their + * associated container (see + * `gdjs.PathfindingRuntimeBehavior.obstaclesManagers`). + * @category Behaviors > 2D Pathfinding + */ + export class NavMeshObstaclesManager { + + constructor(instanceContainer: gdjs.RuntimeInstanceContainer) { + } + + /** + * Get the obstacles manager of an instance container. + */ + static getManager(instanceContainer: gdjs.RuntimeInstanceContainer) { + if (!instanceContainer.pathfindingObstaclesManager) { + //Create the shared manager if necessary. + instanceContainer.pathfindingObstaclesManager = + new gdjs.PathfindingObstaclesManager(instanceContainer); + } + return instanceContainer.pathfindingObstaclesManager; + } + + /** + * Add a obstacle to the list of existing obstacles. + */ + addObstacle( + pathfindingObstacleBehavior: PathfindingObstacleRuntimeBehavior + ) { + if (pathfindingObstacleBehavior.currentRBushAABB) + pathfindingObstacleBehavior.currentRBushAABB.updateAABBFromOwner(); + else + pathfindingObstacleBehavior.currentRBushAABB = + new gdjs.BehaviorRBushAABB(pathfindingObstacleBehavior); + + } + + /** + * Remove a obstacle from the list of existing obstacles. Be sure that the obstacle was + * added before. + */ + removeObstacle( + pathfindingObstacleBehavior: PathfindingObstacleRuntimeBehavior + ) { + } + } + + /** + * PathfindingObstacleRuntimeBehavior represents a behavior allowing objects to be + * considered as a obstacle by objects having Pathfinding Behavior. + * @category Behaviors > 2D Pathfinding + */ + export class NavMeshObstacleRuntimeBehavior extends gdjs.RuntimeBehavior { + _impassable: boolean; + _cost: float; + _oldX: float = 0; + _oldY: float = 0; + _oldWidth: float = 0; + _oldHeight: float = 0; + _manager: PathfindingObstaclesManager; + _registeredInManager: boolean = false; + currentRBushAABB: gdjs.BehaviorRBushAABB | null = + null; + + constructor( + instanceContainer: gdjs.RuntimeInstanceContainer, + behaviorData, + owner: gdjs.RuntimeObject + ) { + super(instanceContainer, behaviorData, owner); + this._impassable = behaviorData.impassable; + this._cost = behaviorData.cost; + this._manager = PathfindingObstaclesManager.getManager(instanceContainer); + + //Note that we can't use getX(), getWidth()... of owner here: + //The owner is not yet fully constructed. + } + + override applyBehaviorOverriding(behaviorData): boolean { + if (behaviorData.impassable !== undefined) { + this.setImpassable(behaviorData.impassable); + } + if (behaviorData.cost !== undefined) { + this.setCost(behaviorData.cost); + } + return true; + } + + onDestroy() { + if (this._manager && this._registeredInManager) { + this._manager.removeObstacle(this); + } + } + + doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + //Make sure the obstacle is or is not in the obstacles manager. + if (!this.activated() && this._registeredInManager) { + this._manager.removeObstacle(this); + this._registeredInManager = false; + } else { + if (this.activated() && !this._registeredInManager) { + this._manager.addObstacle(this); + this._registeredInManager = true; + } + } + + //Track changes in size or position + if ( + this._oldX !== this.owner.getX() || + this._oldY !== this.owner.getY() || + this._oldWidth !== this.owner.getWidth() || + this._oldHeight !== this.owner.getHeight() + ) { + if (this._registeredInManager) { + this._manager.removeObstacle(this); + this._manager.addObstacle(this); + } + this._oldX = this.owner.getX(); + this._oldY = this.owner.getY(); + this._oldWidth = this.owner.getWidth(); + this._oldHeight = this.owner.getHeight(); + } + } + + doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {} + + getAABB() { + return this.owner.getAABB(); + } + + onActivate() { + if (this._registeredInManager) { + return; + } + this._manager.addObstacle(this); + this._registeredInManager = true; + } + + onDeActivate() { + if (!this._registeredInManager) { + return; + } + this._manager.removeObstacle(this); + this._registeredInManager = false; + } + + getCost() { + return this._cost; + } + + setCost(cost: float): void { + this._cost = cost; + } + + isImpassable(): boolean { + return this._impassable; + } + + setImpassable(impassable: boolean): void { + this._impassable = impassable; + } + } + gdjs.registerBehavior( + 'NavMeshPathfinding::NavMeshObstacleBehavior', + gdjs.NavMeshObstacleRuntimeBehavior + ); +} diff --git a/Extensions/NavMeshPathfinding/recast-navigation-generators.js b/Extensions/NavMeshPathfinding/recast-navigation-generators.js new file mode 100644 index 000000000000..fe20d5880138 --- /dev/null +++ b/Extensions/NavMeshPathfinding/recast-navigation-generators.js @@ -0,0 +1,2840 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.RecastNav = {})); +})(this, (function (exports) { 'use strict'; + + /** + * Lower level bindings for the Recast and Detour libraries. + * + * The `init` function must be called before using the `Raw` api. + */ + const Raw = { + isNull: obj => { + return Raw.Module.getPointer(obj) === 0; + }, + destroy: obj => { + Raw.Module.destroy(obj); + } + }; + const Recast = {}; + const Detour = {}; + + class BaseArray { + get size() { + return this.raw.size; + } + constructor(raw) { + this.raw = raw; + } + get(i) { + return this.raw.get(i); + } + set(i, value) { + this.raw.set(i, value); + } + resize(size) { + this.raw.resize(size); + } + copy(data) { + this.raw.resize(data.length); + const view = this.getHeapView(); + view.set(data); + } + destroy() { + Raw.destroy(this.raw); + } + getHeapView() { + const heap = this.getHeap(); + return new this.ArrayConstructor(heap.buffer, this.raw.getDataPointer(), this.size); + } + toTypedArray() { + const view = this.getHeapView(); + const data = new this.ArrayConstructor(new ArrayBuffer(this.size * view.BYTES_PER_ELEMENT), 0, this.size); + data.set(view); + return data; + } + } + class IntArray extends BaseArray { + ArrayConstructor = Int32Array; + constructor(raw) { + super(raw ?? new Raw.Module.IntArray()); + } + getHeap() { + return Raw.Module.HEAP32; + } + static fromRaw(raw) { + return new IntArray(raw); + } + } + class UnsignedCharArray extends BaseArray { + ArrayConstructor = Uint8Array; + constructor(raw) { + super(raw ?? new Raw.Module.UnsignedCharArray()); + } + getHeap() { + return Raw.Module.HEAPU8; + } + static fromRaw(raw) { + return new UnsignedCharArray(raw); + } + } + class UnsignedShortArray extends BaseArray { + ArrayConstructor = Uint16Array; + constructor(raw) { + super(raw ?? new Raw.Module.UnsignedShortArray()); + } + getHeap() { + return Raw.Module.HEAPU16; + } + static fromRaw(raw) { + return new UnsignedShortArray(raw); + } + } + class FloatArray extends BaseArray { + ArrayConstructor = Float32Array; + constructor(raw) { + super(raw ?? new Raw.Module.FloatArray()); + } + getHeap() { + return Raw.Module.HEAPF32; + } + static fromRaw(raw) { + return new FloatArray(raw); + } + } + const VerticesArray = FloatArray; + const TrianglesArray = IntArray; + const TriangleAreasArray = UnsignedCharArray; + const ChunkIdsArray = IntArray; + const TileCacheData = UnsignedCharArray; + + const vec3 = { + toRaw: ({ + x, + y, + z + }, existing) => { + if (existing) { + existing.x = x; + existing.y = y; + existing.z = z; + return existing; + } + return new Raw.Module.Vec3(x, y, z); + }, + fromRaw: vec3 => { + const { + x, + y, + z + } = vec3; + return { + x, + y, + z + }; + }, + fromArray: ([x, y, z]) => { + return { + x, + y, + z + }; + }, + toArray: ({ + x, + y, + z + }) => { + return [x, y, z]; + }, + lerp: (a, b, t, out = { + x: 0, + y: 0, + z: 0 + }) => { + out.x = a.x + (b.x - a.x) * t; + out.y = a.y + (b.y - a.y) * t; + out.z = a.z + (b.z - a.z) * t; + }, + copy: (source, out = { + x: 0, + y: 0, + z: 0 + }) => { + out.x = source.x; + out.y = source.y; + out.z = source.z; + } + }; + const array = (getter, count) => { + const array = []; + for (let i = 0; i < count; i++) { + array.push(getter(i)); + } + return array; + }; + + const statusSucceed = status => { + return Raw.Detour.statusSucceed(status); + }; + const statusFailed = status => { + return Raw.Detour.statusFailed(status); + }; + const statusToReadableString = status => { + if (Raw.Detour.statusSucceed(status)) { + return 'success'; + } + if (Raw.Detour.statusInProgress(status)) { + return 'in progress'; + } + if (Raw.Detour.statusFailed(status)) { + let reason; + const DT_STATUS_REASONS = { + DT_WRONG_MAGIC: Detour.DT_WRONG_MAGIC, + DT_WRONG_VERSION: Detour.DT_WRONG_VERSION, + DT_OUT_OF_MEMORY: Detour.DT_OUT_OF_MEMORY, + DT_INVALID_PARAM: Detour.DT_INVALID_PARAM, + DT_BUFFER_TOO_SMALL: Detour.DT_BUFFER_TOO_SMALL, + DT_OUT_OF_NODES: Detour.DT_OUT_OF_NODES, + DT_PARTIAL_RESULT: Detour.DT_PARTIAL_RESULT, + DT_ALREADY_OCCUPIED: Detour.DT_ALREADY_OCCUPIED + }; + for (const [reasonName, reasonMask] of Object.entries(DT_STATUS_REASONS)) { + if (Raw.Detour.statusDetail(status, reasonMask)) { + reason = reasonName; + break; + } + } + if (reason) { + return `failed - ${reason}`; + } + return `failed - unknown`; + } + return 'unknown'; + }; + class DetourPolyDetail { + constructor(raw) { + this.raw = raw; + } + vertBase() { + return this.raw.vertBase; + } + triBase() { + return this.raw.triBase; + } + vertCount() { + return this.raw.vertCount; + } + triCount() { + return this.raw.triCount; + } + } + class DetourLink { + constructor(raw) { + this.raw = raw; + } + ref() { + return this.raw.ref; + } + next() { + return this.raw.next; + } + edge() { + return this.raw.edge; + } + side() { + return this.raw.side; + } + bmin() { + return this.raw.bmin; + } + bmax() { + return this.raw.bmax; + } + } + class DetourBVNode { + constructor(raw) { + this.raw = raw; + } + bmin() { + return vec3.fromArray(array(i => this.raw.get_bmin(i), 3)); + } + bmax() { + return vec3.fromArray(array(i => this.raw.get_bmax(i), 3)); + } + i() { + return this.raw.i; + } + } + class DetourOffMeshConnection { + constructor(raw) { + this.raw = raw; + } + pos(index) { + return this.raw.get_pos(index); + } + rad() { + return this.raw.rad; + } + poly() { + return this.raw.poly; + } + flags() { + return this.raw.flags; + } + side() { + return this.raw.side; + } + userId() { + return this.raw.userId; + } + } + class DetourMeshHeader { + constructor(raw) { + this.raw = raw; + } + magic() { + return this.raw.magic; + } + version() { + return this.raw.version; + } + x() { + return this.raw.x; + } + y() { + return this.raw.y; + } + layer() { + return this.raw.layer; + } + userId() { + return this.raw.userId; + } + polyCount() { + return this.raw.polyCount; + } + vertCount() { + return this.raw.vertCount; + } + maxLinkCount() { + return this.raw.maxLinkCount; + } + detailMeshCount() { + return this.raw.detailMeshCount; + } + detailVertCount() { + return this.raw.detailVertCount; + } + detailTriCount() { + return this.raw.detailTriCount; + } + bvNodeCount() { + return this.raw.bvNodeCount; + } + offMeshConCount() { + return this.raw.offMeshConCount; + } + offMeshBase() { + return this.raw.offMeshBase; + } + walkableHeight() { + return this.raw.walkableHeight; + } + walkableRadius() { + return this.raw.walkableRadius; + } + walkableClimb() { + return this.raw.walkableClimb; + } + bmin(index) { + return this.raw.get_bmin(index); + } + bmax(index) { + return this.raw.get_bmax(index); + } + bvQuantFactor() { + return this.raw.bvQuantFactor; + } + } + class DetourPoly { + constructor(raw) { + this.raw = raw; + } + firstLink() { + return this.raw.firstLink; + } + verts(index) { + return this.raw.get_verts(index); + } + neis(index) { + return this.raw.get_neis(index); + } + flags() { + return this.raw.flags; + } + vertCount() { + return this.raw.vertCount; + } + areaAndType() { + return this.raw.get_areaAndtype(); + } + getType() { + return this.raw.getType(); + } + } + class DetourMeshTile { + constructor(raw) { + this.raw = raw; + } + salt() { + return this.raw.salt; + } + linksFreeList() { + return this.raw.linksFreeList; + } + header() { + return !Raw.isNull(this.raw.header) ? new DetourMeshHeader(this.raw.header) : null; + } + polys(index) { + return new DetourPoly(this.raw.get_polys(index)); + } + verts(index) { + return this.raw.get_verts(index); + } + links(index) { + return new DetourLink(this.raw.get_links(index)); + } + detailMeshes(index) { + return new DetourPolyDetail(this.raw.get_detailMeshes(index)); + } + detailVerts(index) { + return this.raw.get_detailVerts(index); + } + detailTris(index) { + return this.raw.get_detailTris(index); + } + bvTree(index) { + return new DetourBVNode(this.raw.get_bvTree(index)); + } + offMeshCons(index) { + return new DetourOffMeshConnection(this.raw.get_offMeshCons(index)); + } + data(index) { + return this.raw.get_data(index); + } + dataSize() { + return this.raw.dataSize; + } + flags() { + return this.raw.flags; + } + next() { + return new DetourMeshTile(this.raw.next); + } + } + const createNavMeshData = navMeshCreateParams => { + const result = Raw.DetourNavMeshBuilder.createNavMeshData(navMeshCreateParams.raw); + return { + success: result.success, + navMeshData: UnsignedCharArray.fromRaw(result.navMeshData) + }; + }; + class NavMeshCreateParams { + constructor(raw) { + this.raw = raw ?? new Raw.Module.dtNavMeshCreateParams(); + } + setPolyMeshCreateParams(polyMesh) { + Raw.DetourNavMeshBuilder.setPolyMeshCreateParams(this.raw, polyMesh.raw); + } + setPolyMeshDetailCreateParams(polyMeshDetail) { + Raw.DetourNavMeshBuilder.setPolyMeshDetailCreateParams(this.raw, polyMeshDetail.raw); + } + setOffMeshConnections(offMeshConnections) { + if (offMeshConnections.length <= 0) return; + const verts = []; + const rads = []; + const dir = []; + const areas = []; + const flags = []; + const userIds = []; + for (let i = 0; i < offMeshConnections.length; i++) { + const connection = offMeshConnections[i]; + verts.push(connection.startPosition.x, connection.startPosition.y, connection.startPosition.z); + verts.push(connection.endPosition.x, connection.endPosition.y, connection.endPosition.z); + rads.push(connection.radius); + dir.push(connection.bidirectional ? 1 : 0); + areas.push(connection.area ?? 0); + flags.push(connection.flags ?? 1); + userIds.push(connection.userId ?? 1000 + i); + } + Raw.DetourNavMeshBuilder.setOffMeshConnections(this.raw, offMeshConnections.length, verts, rads, dir, areas, flags, userIds); + } + verts(index) { + return this.raw.get_verts(index); + } + setVerts(index, value) { + this.raw.set_verts(index, value); + } + vertCount() { + return this.raw.vertCount; + } + polys(index) { + return this.raw.get_polys(index); + } + setPolys(index, value) { + this.raw.set_polys(index, value); + } + polyAreas(index) { + return this.raw.get_polyAreas(index); + } + setPolyAreas(index, value) { + this.raw.set_polyAreas(index, value); + } + polyFlags(index) { + return this.raw.get_polyFlags(index); + } + setPolyFlags(index, value) { + this.raw.set_polyFlags(index, value); + } + polyCount() { + return this.raw.polyCount; + } + nvp() { + return this.raw.nvp; + } + setNvp(value) { + this.raw.nvp = value; + } + detailMeshes(index) { + return this.raw.get_detailMeshes(index); + } + setDetailMeshes(index, value) { + this.raw.set_detailMeshes(index, value); + } + detailVerts(index) { + return this.raw.get_detailVerts(index); + } + setDetailVerts(index, value) { + this.raw.set_detailVerts(index, value); + } + detailVertsCount() { + return this.raw.detailVertsCount; + } + detailTris(index) { + return this.raw.get_detailTris(index); + } + setDetailTris(index, value) { + this.raw.set_detailTris(index, value); + } + detailTriCount() { + return this.raw.detailTriCount; + } + offMeshConVerts(index) { + return this.raw.get_offMeshConVerts(index); + } + offMeshConRad(index) { + return this.raw.get_offMeshConRad(index); + } + offMeshConDir(index) { + return this.raw.get_offMeshConDir(index); + } + offMeshConAreas(index) { + return this.raw.get_offMeshConAreas(index); + } + offMeshConFlags(index) { + return this.raw.get_offMeshConFlags(index); + } + offMeshConUserID(index) { + return this.raw.get_offMeshConUserID(index); + } + offMeshConCount() { + return this.raw.offMeshConCount; + } + userId() { + return this.raw.userId; + } + tileX() { + return this.raw.tileX; + } + setTileX(value) { + this.raw.tileX = value; + } + tileY() { + return this.raw.tileY; + } + setTileY(value) { + this.raw.tileY = value; + } + tileLayer() { + return this.raw.tileLayer; + } + setTileLayer(value) { + this.raw.tileLayer = value; + } + boundsMin() { + return array(i => this.raw.get_bmin(i), 3); + } + setBoundsMin(value) { + this.raw.set_bmin(0, value[0]); + this.raw.set_bmin(1, value[1]); + this.raw.set_bmin(2, value[2]); + } + boundsMax() { + return array(i => this.raw.get_bmax(i), 3); + } + setBoundsMax(value) { + this.raw.set_bmax(0, value[0]); + this.raw.set_bmax(1, value[1]); + this.raw.set_bmax(2, value[2]); + } + walkableHeight() { + return this.raw.walkableHeight; + } + setWalkableHeight(value) { + this.raw.walkableHeight = value; + } + walkableRadius() { + return this.raw.walkableRadius; + } + setWalkableRadius(value) { + this.raw.walkableRadius = value; + } + walkableClimb() { + return this.raw.walkableClimb; + } + setWalkableClimb(value) { + this.raw.walkableClimb = value; + } + cellSize() { + return this.raw.cs; + } + setCellSize(value) { + this.raw.cs = value; + } + cellHeight() { + return this.raw.ch; + } + setCellHeight(value) { + this.raw.ch = value; + } + buildBvTree() { + return this.raw.buildBvTree; + } + setBuildBvTree(value) { + this.raw.buildBvTree = value; + } + } + + class NavMeshGetTilesAtResult { + constructor(raw) { + this.raw = raw; + } + tiles(index) { + return new DetourMeshTile(this.raw.get_tiles(index)); + } + tileCount() { + return this.raw.tileCount; + } + } + class NavMeshRemoveTileResult { + constructor(raw) { + this.raw = raw; + } + data() { + return array(i => this.raw.get_data(i), this.raw.dataSize); + } + dataSize() { + return this.raw.dataSize; + } + } + class NavMeshCalcTileLocResult { + constructor(raw) { + this.raw = raw; + } + tileX() { + return this.raw.tileX; + } + tileY() { + return this.raw.tileY; + } + } + class NavMeshStoreTileStateResult { + constructor(raw) { + this.raw = raw; + } + data() { + return array(i => this.raw.get_data(i), this.raw.dataSize); + } + dataSize() { + return this.raw.dataSize; + } + } + class NavMeshParams { + constructor(raw) { + this.raw = raw; + } + static create(params) { + const raw = new Raw.Module.dtNavMeshParams(); + raw.set_orig(0, params.orig.x); + raw.set_orig(1, params.orig.y); + raw.set_orig(2, params.orig.z); + raw.tileWidth = params.tileWidth; + raw.tileHeight = params.tileHeight; + raw.maxTiles = params.maxTiles; + raw.maxPolys = params.maxPolys; + return new NavMeshParams(raw); + } + clone() { + return NavMeshParams.create({ + orig: { + x: this.raw.get_orig(0), + y: this.raw.get_orig(1), + z: this.raw.get_orig(2) + }, + tileWidth: this.raw.tileWidth, + tileHeight: this.raw.tileHeight, + maxTiles: this.raw.maxTiles, + maxPolys: this.raw.maxPolys + }); + } + } + class NavMesh { + constructor(raw) { + this.raw = raw ?? new Raw.Module.NavMesh(); + } + /** + * Initializes the NavMesh for use with a single tile. + * @param navMeshData the nav mesh data + * @returns the status of the operation + */ + initSolo(navMeshData) { + return this.raw.initSolo(navMeshData.raw); + } + /** + * Initializes the NavMesh for use with multiple tiles. + * @param params parameters for the NavMesh + * @returns the status of the operation + */ + initTiled(params) { + return this.raw.initTiled(params.raw); + } + /** + * Adds a tile to the NavMesh. + * @param navMeshData the nav mesh data + * @param flags the flags to use when building the nav mesh + * @param lastRef + * @returns the status of the operation and the reference of the added tile + */ + addTile(navMeshData, flags, lastRef) { + const tileRefRaw = new Raw.UnsignedIntRef(); + const status = this.raw.addTile(navMeshData.raw, flags, lastRef, tileRefRaw); + const tileRef = tileRefRaw.value; + Raw.destroy(tileRefRaw); + return { + status, + tileRef + }; + } + /** + * Decodes a standard polygon reference. + * @param polyRef The polygon reference to decode + * @returns the decoded polygon reference + */ + decodePolyId(polyRef) { + const saltRef = new Raw.UnsignedIntRef(); + const itRef = new Raw.UnsignedIntRef(); + const ipRef = new Raw.UnsignedIntRef(); + this.raw.decodePolyId(polyRef, saltRef, itRef, ipRef); + const tileSalt = saltRef.value; + Raw.destroy(saltRef); + const tileIndex = itRef.value; + Raw.destroy(itRef); + const tilePolygonIndex = ipRef.value; + Raw.destroy(ipRef); + return { + tileSalt, + tileIndex, + tilePolygonIndex + }; + } + /** + * Derives a standard polygon reference. + * @param salt The tile's salt value. + * @param tileIndex The index of the tile. `it` in the C++ api. + * @param tilePolygonIndex The index of the polygon within the tile. `ip` in the C++ api. + * @returns the derived polygon reference + */ + encodePolyId(salt, tileIndex, tilePolygonIndex) { + return this.raw.encodePolyId(salt, tileIndex, tilePolygonIndex); + } + /** + * Removes a tile from the NavMesh + * @param ref the tile ref + * @returns the nav mesh data, so it can be added back later + */ + removeTile(ref) { + return new NavMeshRemoveTileResult(this.raw.removeTile(ref)); + } + /** + * Calculates the tile grid location for the specified world position. + * @param pos The world position for the query. [(x, y, z)] + * @returns + */ + calcTileLoc(pos) { + return new NavMeshCalcTileLocResult(this.raw.calcTileLoc(vec3.toArray(pos))); + } + /** + * Gets the tile at the specified grid location. + * @param x The tile's x-location. (x, y, layer) + * @param y The tile's y-location. (x, y, layer) + * @param layer The tile's layer. (x, y, layer) + * @returns The tile, or null if the tile does not exist. + */ + getTileAt(x, y, layer) { + const tile = this.raw.getTileAt(x, y, layer); + return !Raw.isNull(tile) ? new DetourMeshTile(tile) : null; + } + /** + * Gets all tiles at the specified grid location. (All layers.) + * @param x The tile's x-location. (x, y) + * @param y The tile's y-location. (x, y) + * @param maxTiles The maximum tiles the tiles parameter can hold. + */ + getTilesAt(x, y, maxTiles) { + return new NavMeshGetTilesAtResult(this.raw.getTilesAt(x, y, maxTiles)); + } + /** + * Gets the tile reference for the tile at specified grid location. + * @param x The tile's x-location. (x, y, layer) + * @param y The tile's y-location. (x, y, layer) + * @param layer The tile's layer. (x, y, layer) + * @returns The tile reference of the tile, or 0 if there is none. + */ + getTileRefAt(x, y, layer) { + return this.raw.getTileRefAt(x, y, layer); + } + /** + * Gets the tile reference for the specified tile. + * @param tile + * @returns + */ + getTileRef(tile) { + return this.raw.getTileRef(tile.raw); + } + /** + * Gets the tile for the specified tile reference. + * @param ref The tile reference of the tile to retrieve. + * @returns The tile for the specified reference, or null if the reference is invalid. + */ + getTileByRef(ref) { + const tile = this.raw.getTileByRef(ref); + return !Raw.isNull(tile) ? new DetourMeshTile(tile) : null; + } + /** + * Returns the maximum number of tiles supported by the navigation mesh. + */ + getMaxTiles() { + return this.raw.getMaxTiles(); + } + /** + * Gets the tile at the specified index. + * @param i the tile index. [Limit: 0 >= index < #getMaxTiles()] + * @returns + */ + getTile(i) { + return new DetourMeshTile(this.raw.getTile(i)); + } + /** + * Gets the tile and polygon for the specified polygon reference. + * @param ref The reference for the a polygon. + * @returns + */ + getTileAndPolyByRef(ref) { + const result = this.raw.getTileAndPolyByRef(ref); + const tile = new DetourMeshTile(result.tile); + const poly = new DetourPoly(result.poly); + return { + success: statusSucceed(result.status), + status: result.status, + tile, + poly + }; + } + /** + * Gets the tile and polygon for the specified polygon reference. + * @param ref A known valid reference for a polygon. + * @returns + */ + getTileAndPolyByRefUnsafe(ref) { + const result = this.raw.getTileAndPolyByRef(ref); + const tile = new DetourMeshTile(result.tile); + const poly = new DetourPoly(result.poly); + return { + tile, + poly + }; + } + /** + * Checks the validity of a polygon reference. + * @param ref + * @returns + */ + isValidPolyRef(ref) { + return this.raw.isValidPolyRef(ref); + } + /** + * Gets the polygon reference for the tile's base polygon. + * @param tile + * @returns + */ + getPolyRefBase(tile) { + return this.raw.getPolyRefBase(tile.raw); + } + /** + * Gets the endpoints for an off-mesh connection, ordered by "direction of travel". + * @param prevRef The reference of the polygon before the connection. + * @param polyRef The reference of the off-mesh connection polygon. + * @returns + */ + getOffMeshConnectionPolyEndPoints(prevRef, polyRef) { + const startRaw = new Raw.Vec3(); + const endRaw = new Raw.Vec3(); + const status = this.raw.getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startRaw, endRaw); + const start = vec3.fromRaw(startRaw); + Raw.destroy(startRaw); + const end = vec3.fromRaw(endRaw); + Raw.destroy(endRaw); + return { + success: statusSucceed(status), + status, + start, + end + }; + } + /** + * Gets the specified off-mesh connection. + * @param ref The polygon reference of the off-mesh connection. + * @returns + */ + getOffMeshConnectionByRef(ref) { + return new DetourOffMeshConnection(this.raw.getOffMeshConnectionByRef(ref)); + } + /** + * Sets the user defined flags for the specified polygon. + * @param ref The polygon reference. + * @param flags The new flags for the polygon. + */ + setPolyFlags(ref, flags) { + return this.raw.setPolyFlags(ref, flags); + } + /** + * Gets the user defined flags for the specified polygon. + * @param ref The polygon reference. + * @returns + */ + getPolyFlags(ref) { + const flagsRaw = new Raw.UnsignedShortRef(); + const status = this.raw.getPolyFlags(ref, flagsRaw); + const flags = flagsRaw.value; + Raw.destroy(flagsRaw); + return { + status, + flags + }; + } + /** + * Sets the user defined area for the specified polygon. + * @param ref The polygon reference. + * @param flags The new flags for the polygon. + */ + setPolyArea(ref, area) { + return this.raw.setPolyArea(ref, area); + } + /** + * Gets the user defined area for the specified polygon. + * @param ref The polygon reference. + * @returns + */ + getPolyArea(ref) { + const areaRaw = new Raw.UnsignedCharRef(); + const status = this.raw.getPolyArea(ref, areaRaw); + const area = areaRaw.value; + Raw.destroy(areaRaw); + return { + status, + area + }; + } + /** + * Gets the size of the buffer required by #storeTileState to store the specified tile's state. + * @param tile + * @returns The size of the buffer required to store the state. + */ + getTileStateSize(tile) { + return this.raw.getTileStateSize(tile.raw); + } + /** + * Stores the non-structural state of the tile in the specified buffer. (Flags, area ids, etc.) + * @param tile The tile. + * @param maxDataSize The size of the data buffer. [Limit: >= #getTileStateSize] + * @returns + */ + storeTileState(tile, maxDataSize) { + return new NavMeshStoreTileStateResult(this.raw.storeTileState(tile.raw, maxDataSize)); + } + /** + * Restores the state of the tile. + * @param tile The tile. + * @param data The new state. (Obtained from @see storeTileState) + * @param maxDataSize The size of the state within the data buffer. + * @returns + */ + restoreTileState(tile, data, maxDataSize) { + return this.raw.restoreTileState(tile.raw, data, maxDataSize); + } + /** + * Destroys the NavMesh. + */ + destroy() { + this.raw.destroy(); + Raw.Module.destroy(this.raw); + } + } + + const recastConfigDefaults = { + borderSize: 0, + tileSize: 0, + cs: 0.2, + ch: 0.2, + walkableSlopeAngle: 60, + walkableHeight: 2, + walkableClimb: 2, + walkableRadius: 0.5, + maxEdgeLen: 12, + maxSimplificationError: 1.3, + minRegionArea: 8, + mergeRegionArea: 20, + maxVertsPerPoly: 6, + detailSampleDist: 6, + detailSampleMaxError: 1 + }; + const createRcConfig = partialConfig => { + const config = { + ...recastConfigDefaults, + ...partialConfig + }; + const rcConfig = new Raw.Module.rcConfig(); + rcConfig.borderSize = config.borderSize; + rcConfig.tileSize = config.tileSize; + rcConfig.cs = config.cs; + rcConfig.ch = config.ch; + rcConfig.walkableSlopeAngle = config.walkableSlopeAngle; + rcConfig.walkableHeight = config.walkableHeight; + rcConfig.walkableClimb = config.walkableClimb; + rcConfig.walkableRadius = config.walkableRadius; + rcConfig.maxEdgeLen = config.maxEdgeLen; + rcConfig.maxSimplificationError = config.maxSimplificationError; + rcConfig.minRegionArea = config.minRegionArea; + rcConfig.mergeRegionArea = config.mergeRegionArea; + rcConfig.maxVertsPerPoly = config.maxVertsPerPoly; + rcConfig.detailSampleDist = config.detailSampleDist; + rcConfig.detailSampleMaxError = config.detailSampleMaxError; + return rcConfig; + }; + const cloneRcConfig = rcConfig => { + const clone = new Raw.Module.rcConfig(); + clone.set_bmin(0, rcConfig.get_bmin(0)); + clone.set_bmin(1, rcConfig.get_bmin(1)); + clone.set_bmin(2, rcConfig.get_bmin(2)); + clone.set_bmax(0, rcConfig.get_bmax(0)); + clone.set_bmax(1, rcConfig.get_bmax(1)); + clone.set_bmax(2, rcConfig.get_bmax(2)); + clone.width = rcConfig.width; + clone.height = rcConfig.height; + clone.borderSize = rcConfig.borderSize; + clone.tileSize = rcConfig.tileSize; + clone.cs = rcConfig.cs; + clone.ch = rcConfig.ch; + clone.walkableSlopeAngle = rcConfig.walkableSlopeAngle; + clone.walkableHeight = rcConfig.walkableHeight; + clone.walkableClimb = rcConfig.walkableClimb; + clone.walkableRadius = rcConfig.walkableRadius; + clone.maxEdgeLen = rcConfig.maxEdgeLen; + clone.maxSimplificationError = rcConfig.maxSimplificationError; + clone.minRegionArea = rcConfig.minRegionArea; + clone.mergeRegionArea = rcConfig.mergeRegionArea; + clone.maxVertsPerPoly = rcConfig.maxVertsPerPoly; + clone.detailSampleDist = rcConfig.detailSampleDist; + clone.detailSampleMaxError = rcConfig.detailSampleMaxError; + return clone; + }; + class RecastBuildContext { + logs = []; + startTimes = {}; + accumulatedTimes = {}; + constructor(timersAndLogsEnabled = true) { + const impl = new Raw.Module.RecastBuildContextJsImpl(); + impl.log = (category, msg, len) => { + if (!this.raw.logEnabled()) return; + // type is string, but webidl binder passes us a pointer + const msgPointer = msg; + const view = new Uint8Array(Raw.Module.HEAPU8.buffer, msgPointer, len); + const data = new Uint8Array(len); + data.set(view); + const msgString = new TextDecoder().decode(data); + this.log(category, msgString); + }; + impl.resetLog = () => { + this.resetLog(); + }; + impl.startTimer = label => { + if (!this.raw.timerEnabled()) return; + this.startTimer(label); + }; + impl.stopTimer = label => { + if (!this.raw.timerEnabled()) return; + this.stopTimer(label); + }; + impl.getAccumulatedTime = label => { + if (!this.raw.timerEnabled()) return -1; + return this.getAccumulatedTime(label); + }; + impl.resetTimers = () => { + if (!this.raw.timerEnabled()) return; + this.startTimes = {}; + this.accumulatedTimes = {}; + }; + this.raw = new Raw.Module.RecastBuildContext(impl); + this.raw.enableTimer(timersAndLogsEnabled); + this.raw.enableLog(timersAndLogsEnabled); + this.resetTimers(); + } + log(category, msg) { + this.logs.push({ + category, + msg + }); + } + resetLog() { + this.logs = []; + } + startTimer(label) { + this.startTimes[label] = performance.now(); + } + stopTimer(label) { + const endTime = performance.now(); + const deltaTime = endTime - this.startTimes[label]; + if (this.accumulatedTimes[label] === -1) { + this.accumulatedTimes[label] = deltaTime; + } else { + this.accumulatedTimes[label] += deltaTime; + } + } + getAccumulatedTime(label) { + return this.accumulatedTimes[label]; + } + resetTimers() { + for (let i = 0; i < Recast.RC_MAX_TIMERS; i++) { + this.startTimes[i] = -1; + this.accumulatedTimes[i] = -1; + } + } + } + class RecastChunkyTriMesh { + constructor(raw) { + this.raw = raw ?? new Raw.rcChunkyTriMesh(); + } + init(verts, tris, ntris, trisPerChunk) { + return Raw.ChunkyTriMeshUtils.createChunkyTriMesh(verts.raw, tris.raw, ntris, trisPerChunk, this.raw); + } + getChunksOverlappingRect(boundsMin, boundsMax, chunks, maxChunks) { + return Raw.ChunkyTriMeshUtils.getChunksOverlappingRect(this.raw, boundsMin, boundsMax, chunks.raw, maxChunks); + } + getNodeTris(nodeId) { + return IntArray.fromRaw(Raw.ChunkyTriMeshUtils.getChunkyTriMeshNodeTris(this.raw, nodeId)); + } + nodes(index) { + return this.raw.get_nodes(index); + } + maxTrisPerChunk() { + return this.raw.maxTrisPerChunk; + } + } + class RecastSpan { + constructor(raw) { + this.raw = raw; + } + smin() { + return this.raw.smin; + } + smax() { + return this.raw.smax; + } + area() { + return this.raw.area; + } + next() { + return !Raw.isNull(this.raw.next) ? new RecastSpan(this.raw.next) : null; + } + } + class RecastSpanPool { + constructor(raw) { + this.raw = raw; + } + next() { + return !Raw.isNull(this.raw.next) ? new RecastSpanPool(this.raw.next) : null; + } + items(index) { + return new RecastSpan(this.raw.get_items(index)); + } + } + class RecastHeightfield { + constructor(raw) { + this.raw = raw; + } + width() { + return this.raw.width; + } + height() { + return this.raw.height; + } + bmin() { + return vec3.fromArray(array(i => this.raw.get_bmin(i), 3)); + } + bmax() { + return vec3.fromArray(array(i => this.raw.get_bmax(i), 3)); + } + cs() { + return this.raw.cs; + } + ch() { + return this.raw.ch; + } + spans(index) { + return new RecastSpan(this.raw.get_spans(index)); + } + pools(index) { + return new RecastSpanPool(this.raw.get_pools(index)); + } + freelist(index) { + return new RecastSpan(this.raw.get_freelist(index)); + } + } + class RecastCompactCell { + constructor(raw) { + this.raw = raw; + } + index() { + return this.raw.get_index(); + } + count() { + return this.raw.get_count(); + } + } + class RecastCompactSpan { + constructor(raw) { + this.raw = raw; + } + y() { + return this.raw.get_y(); + } + reg() { + return this.raw.get_reg(); + } + con() { + return this.raw.get_con(); + } + h() { + return this.raw.get_h(); + } + } + class RecastCompactHeightfield { + constructor(raw) { + this.raw = raw; + } + width() { + return this.raw.width; + } + height() { + return this.raw.height; + } + spanCount() { + return this.raw.spanCount; + } + walkableHeight() { + return this.raw.walkableHeight; + } + walkableClimb() { + return this.raw.walkableClimb; + } + borderSize() { + return this.raw.borderSize; + } + maxDistance() { + return this.raw.maxDistance; + } + maxRegions() { + return this.raw.maxRegions; + } + bmin() { + return vec3.fromArray(array(i => this.raw.get_bmin(i), 3)); + } + bmax() { + return vec3.fromArray(array(i => this.raw.get_bmax(i), 3)); + } + cs() { + return this.raw.cs; + } + ch() { + return this.raw.ch; + } + cells(index) { + return new RecastCompactCell(this.raw.get_cells(index)); + } + spans(index) { + return new RecastCompactSpan(this.raw.get_spans(index)); + } + dist(index) { + return this.raw.get_dist(index); + } + areas(index) { + return this.raw.get_areas(index); + } + } + class RecastContour { + constructor(raw) { + this.raw = raw; + } + verts(index) { + return this.raw.get_verts(index); + } + nverts() { + return this.raw.nverts; + } + rverts(index) { + return this.raw.get_rverts(index); + } + nrverts() { + return this.raw.nrverts; + } + reg() { + return this.raw.reg; + } + area() { + return this.raw.area; + } + } + class RecastContourSet { + constructor(raw) { + this.raw = raw; + } + conts(index) { + return new RecastContour(this.raw.get_conts(index)); + } + nconts() { + return this.raw.nconts; + } + bmin() { + return vec3.fromArray(array(i => this.raw.get_bmin(i), 3)); + } + bmax() { + return vec3.fromArray(array(i => this.raw.get_bmax(i), 3)); + } + cs() { + return this.raw.cs; + } + ch() { + return this.raw.ch; + } + width() { + return this.raw.width; + } + height() { + return this.raw.height; + } + borderSize() { + return this.raw.borderSize; + } + maxError() { + return this.raw.maxError; + } + } + class RecastHeightfieldLayer { + constructor(raw) { + this.raw = raw; + } + bmin() { + return vec3.fromArray(array(i => this.raw.get_bmin(i), 3)); + } + bmax() { + return vec3.fromArray(array(i => this.raw.get_bmax(i), 3)); + } + cs() { + return this.raw.cs; + } + ch() { + return this.raw.ch; + } + width() { + return this.raw.width; + } + height() { + return this.raw.height; + } + minx() { + return this.raw.minx; + } + maxx() { + return this.raw.maxx; + } + miny() { + return this.raw.miny; + } + maxy() { + return this.raw.maxy; + } + hmin() { + return this.raw.hmin; + } + hmax() { + return this.raw.hmax; + } + heights(index) { + return this.raw.get_heights(index); + } + areas(index) { + return this.raw.get_areas(index); + } + cons(index) { + return this.raw.get_cons(index); + } + } + class RecastHeightfieldLayerSet { + constructor(raw) { + this.raw = raw; + } + layers(index) { + return new RecastHeightfieldLayer(this.raw.get_layers(index)); + } + nlayers() { + return this.raw.nlayers; + } + } + class RecastPolyMesh { + constructor(raw) { + this.raw = raw; + } + verts(index) { + return this.raw.get_verts(index); + } + polys(index) { + return this.raw.get_polys(index); + } + regs(index) { + return this.raw.get_regs(index); + } + flags(index) { + return this.raw.get_flags(index); + } + setFlags(index, value) { + this.raw.set_flags(index, value); + } + areas(index) { + return this.raw.get_areas(index); + } + setAreas(index, value) { + this.raw.set_areas(index, value); + } + nverts() { + return this.raw.nverts; + } + npolys() { + return this.raw.npolys; + } + maxpolys() { + return this.raw.maxpolys; + } + nvp() { + return this.raw.nvp; + } + bmin() { + return vec3.fromArray(array(i => this.raw.get_bmin(i), 3)); + } + bmax() { + return vec3.fromArray(array(i => this.raw.get_bmax(i), 3)); + } + cs() { + return this.raw.cs; + } + ch() { + return this.raw.ch; + } + borderSize() { + return this.raw.borderSize; + } + maxEdgeError() { + return this.raw.maxEdgeError; + } + } + class RecastPolyMeshDetail { + constructor(raw) { + this.raw = raw; + } + meshes(index) { + return this.raw.get_meshes(index); + } + verts(index) { + return this.raw.get_verts(index); + } + tris(index) { + return this.raw.get_tris(index); + } + nmeshes() { + return this.raw.nmeshes; + } + nverts() { + return this.raw.nverts; + } + ntris() { + return this.raw.ntris; + } + } + const calcGridSize = (bmin, bmax, cs) => { + return Raw.Recast.calcGridSize(bmin, bmax, cs); + }; + const createHeightfield = (buildContext, heightfield, width, height, bmin, bmax, cs, ch) => { + return Raw.Recast.createHeightfield(buildContext.raw, heightfield.raw, width, height, bmin, bmax, cs, ch); + }; + const markWalkableTriangles = (buildContext, walkableSlopeAngle, verts, nv, tris, nt, areas) => { + return Raw.Recast.markWalkableTriangles(buildContext.raw, walkableSlopeAngle, verts.raw, nv, tris.raw, nt, areas.raw); + }; + const rasterizeTriangles = (buildContext, verts, nv, tris, areas, nt, heightfield, flagMergeThreshold = 1) => { + return Raw.Recast.rasterizeTriangles(buildContext.raw, verts.raw, nv, tris.raw, areas.raw, nt, heightfield.raw, flagMergeThreshold); + }; + const filterLowHangingWalkableObstacles = (buildContext, walkableClimb, heightfield) => { + return Raw.Recast.filterLowHangingWalkableObstacles(buildContext.raw, walkableClimb, heightfield.raw); + }; + const filterLedgeSpans = (buildContext, walkableHeight, walkableClimb, heightfield) => { + return Raw.Recast.filterLedgeSpans(buildContext.raw, walkableHeight, walkableClimb, heightfield.raw); + }; + const filterWalkableLowHeightSpans = (buildContext, walkableHeight, heightfield) => { + return Raw.Recast.filterWalkableLowHeightSpans(buildContext.raw, walkableHeight, heightfield.raw); + }; + const buildCompactHeightfield = (buildContext, walkableHeight, walkableClimb, heightfield, compactHeightfield) => { + return Raw.Recast.buildCompactHeightfield(buildContext.raw, walkableHeight, walkableClimb, heightfield.raw, compactHeightfield.raw); + }; + const erodeWalkableArea = (buildContext, radius, compactHeightfield) => { + return Raw.Recast.erodeWalkableArea(buildContext.raw, radius, compactHeightfield.raw); + }; + const buildDistanceField = (buildContext, compactHeightfield) => { + return Raw.Recast.buildDistanceField(buildContext.raw, compactHeightfield.raw); + }; + const buildRegions = (buildContext, compactHeightfield, borderSize, minRegionArea, mergeRegionArea) => { + return Raw.Recast.buildRegions(buildContext.raw, compactHeightfield.raw, borderSize, minRegionArea, mergeRegionArea); + }; + const buildHeightfieldLayers = (buildContext, compactHeightfield, borderSize, walkableHeight, heightfieldLayerSet) => { + return Raw.Recast.buildHeightfieldLayers(buildContext.raw, compactHeightfield.raw, borderSize, walkableHeight, heightfieldLayerSet.raw); + }; + const buildContours = (buildContext, compactHeightfield, maxError, maxEdgeLen, contourSet, buildFlags = Recast.RC_CONTOUR_TESS_WALL_EDGES) => { + return Raw.Recast.buildContours(buildContext.raw, compactHeightfield.raw, maxError, maxEdgeLen, contourSet.raw, buildFlags); + }; + const buildPolyMesh = (buildContext, contourSet, nvp, polyMesh) => { + return Raw.Recast.buildPolyMesh(buildContext.raw, contourSet.raw, nvp, polyMesh.raw); + }; + const buildPolyMeshDetail = (buildContext, mesh, compactHeightfield, sampleDist, sampleMaxError, polyMeshDetail) => { + return Raw.Recast.buildPolyMeshDetail(buildContext.raw, mesh.raw, compactHeightfield.raw, sampleDist, sampleMaxError, polyMeshDetail.raw); + }; + const getHeightfieldLayerHeights = heightfieldLayer => { + return UnsignedCharArray.fromRaw(Raw.Recast.getHeightfieldLayerHeights(heightfieldLayer.raw)); + }; + const getHeightfieldLayerAreas = heightfieldLayer => { + return UnsignedCharArray.fromRaw(Raw.Recast.getHeightfieldLayerAreas(heightfieldLayer.raw)); + }; + const getHeightfieldLayerCons = heightfieldLayer => { + return UnsignedCharArray.fromRaw(Raw.Recast.getHeightfieldLayerCons(heightfieldLayer.raw)); + }; + const allocHeightfield = () => { + return new RecastHeightfield(Raw.Recast.allocHeightfield()); + }; + const freeHeightfield = heightfield => { + return Raw.Recast.freeHeightfield(heightfield.raw); + }; + const allocCompactHeightfield = () => { + return new RecastCompactHeightfield(Raw.Recast.allocCompactHeightfield()); + }; + const freeCompactHeightfield = compactHeightfield => { + return Raw.Recast.freeCompactHeightfield(compactHeightfield.raw); + }; + const allocHeightfieldLayerSet = () => { + return new RecastHeightfieldLayerSet(Raw.Recast.allocHeightfieldLayerSet()); + }; + const freeHeightfieldLayerSet = heightfieldLayerSet => { + return Raw.Recast.freeHeightfieldLayerSet(heightfieldLayerSet.raw); + }; + const allocContourSet = () => { + return new RecastContourSet(Raw.Recast.allocContourSet()); + }; + const freeContourSet = contourSet => { + return Raw.Recast.freeContourSet(contourSet.raw); + }; + const allocPolyMesh = () => { + return new RecastPolyMesh(Raw.Recast.allocPolyMesh()); + }; + const freePolyMesh = polyMesh => { + return Raw.Recast.freePolyMesh(polyMesh.raw); + }; + const allocPolyMeshDetail = () => { + return new RecastPolyMeshDetail(Raw.Recast.allocPolyMeshDetail()); + }; + const freePolyMeshDetail = polyMeshDetail => { + return Raw.Recast.freePolyMeshDetail(polyMeshDetail.raw); + }; + + class DetourTileCacheParams { + constructor(raw) { + this.raw = raw; + } + static create(config) { + const tileCacheParams = new Raw.Module.dtTileCacheParams(); + tileCacheParams.set_orig(0, config.orig[0]); + tileCacheParams.set_orig(1, config.orig[1]); + tileCacheParams.set_orig(2, config.orig[2]); + tileCacheParams.set_cs(config.cs); + tileCacheParams.set_ch(config.ch); + tileCacheParams.set_width(config.width); + tileCacheParams.set_height(config.height); + tileCacheParams.set_walkableHeight(config.walkableHeight); + tileCacheParams.set_walkableRadius(config.walkableRadius); + tileCacheParams.set_walkableClimb(config.walkableClimb); + tileCacheParams.set_maxSimplificationError(config.maxSimplificationError); + tileCacheParams.set_maxTiles(config.maxTiles); + tileCacheParams.set_maxObstacles(config.maxObstacles); + return new DetourTileCacheParams(tileCacheParams); + } + } + class TileCache { + obstacles = new Map(); + constructor(raw) { + this.raw = raw ?? new Raw.Module.TileCache(); + } + /** + * Initialises the TileCache + * @param params + */ + init(params, alloc, compressor, meshProcess) { + return this.raw.init(params.raw, alloc, compressor, meshProcess.raw); + } + /** + * Updates the tile cache by rebuilding tiles touched by unfinished obstacle requests. + * + * After adding or removing obstacles you can call `tileCache.update(navMesh)` to rebuild navmesh tiles. + * + * Adding or removing an obstacle will internally create an "obstacle request". + * TileCache supports queuing up to 64 obstacle requests. + * + * The `tileCache.update` method returns `upToDate`, whether the tile cache is fully up to date with obstacle requests and tile rebuilds. + * Each update call processes up to 64 tiles touched by added or removed obstacles. + * If the tile cache isn't up to date another call will continue processing obstacle requests and tile rebuilds; otherwise it will have no effect. + * + * If not many obstacle requests occur between updates, an easy pattern is to call `tileCache.update` periodically, such as every game update. + * If many obstacle requests have been made and you need to avoid reaching the 64 obstacle request limit, you can call `tileCache.update` multiple times, bailing out when `upToDate` is true or after a maximum number of updates. + * + * @example + * ```ts + * const { success, status, upToDate } = tileCache.update(navMesh); + * ``` + */ + update(navMesh) { + const { + status, + upToDate + } = this.raw.update(navMesh.raw); + return { + success: statusSucceed(status), + status, + upToDate + }; + } + /** + * Creates a cylinder obstacle and adds it to the navigation mesh. + */ + addCylinderObstacle(position, radius, height) { + const result = this.raw.addCylinderObstacle(vec3.toRaw(position), radius, height); + if (result.status !== Detour.DT_SUCCESS) { + return { + success: false, + status: result.status + }; + } + const ref = result.ref; + const obstacle = { + type: 'cylinder', + ref, + position, + radius, + height + }; + this.obstacles.set(ref, obstacle); + return { + success: true, + status: result.status, + obstacle + }; + } + /** + * Creates a box obstacle and adds it to the navigation mesh. + */ + addBoxObstacle(position, halfExtents, angle) { + const rawPosition = vec3.toRaw(position); + const rawHalfExtents = vec3.toRaw(halfExtents); + const result = this.raw.addBoxObstacle(rawPosition, rawHalfExtents, angle); + Raw.destroy(rawPosition); + Raw.destroy(rawHalfExtents); + if (result.status !== Detour.DT_SUCCESS) { + return { + success: false, + status: result.status + }; + } + const ref = result.ref; + const obstacle = { + type: 'box', + ref, + position, + halfExtents, + angle + }; + this.obstacles.set(ref, obstacle); + return { + success: true, + status: result.status, + obstacle + }; + } + /** + * Removes an obstacle from the navigation mesh. + */ + removeObstacle(obstacle) { + let ref; + if (typeof obstacle === 'object') { + ref = obstacle.ref; + } else { + ref = obstacle; + } + this.obstacles.delete(ref); + const status = this.raw.removeObstacle(ref); + return { + success: statusSucceed(status), + status + }; + } + addTile(data, flags = Detour.DT_COMPRESSEDTILE_FREE_DATA) { + return this.raw.addTile(data.raw, flags); + } + buildNavMeshTile(ref, navMesh) { + return this.raw.buildNavMeshTile(ref, navMesh.raw); + } + buildNavMeshTilesAt(tx, ty, navMesh) { + return this.raw.buildNavMeshTilesAt(tx, ty, navMesh.raw); + } + destroy() { + this.raw.destroy(); + } + } + class TileCacheMeshProcess { + constructor(process) { + this.raw = new Raw.Module.TileCacheMeshProcess(); + this.raw.process = (paramsPtr, polyAreasArrayPtr, polyFlagsArrayPtr) => { + const params = new NavMeshCreateParams(Raw.Module.wrapPointer(paramsPtr, Raw.Module.dtNavMeshCreateParams)); + const polyAreasArray = Raw.Module.wrapPointer(polyAreasArrayPtr, Raw.Module.UnsignedCharArray); + const polyFlagsArray = Raw.Module.wrapPointer(polyFlagsArrayPtr, Raw.Module.UnsignedShortArray); + process(params, UnsignedCharArray.fromRaw(polyAreasArray), UnsignedShortArray.fromRaw(polyFlagsArray)); + }; + } + } + const buildTileCacheLayer = (comp, header, heights, areas, cons, tileCacheData) => { + return Raw.DetourTileCacheBuilder.buildTileCacheLayer(comp, header, heights.raw, areas.raw, cons.raw, tileCacheData.raw); + }; + + const getBoundingBox = (positions, indices) => { + const bbMin = { + x: Infinity, + y: Infinity, + z: Infinity + }; + const bbMax = { + x: -Infinity, + y: -Infinity, + z: -Infinity + }; + for (let i = 0; i < indices.length; i++) { + const ind = indices[i]; + const x = positions[ind * 3]; + const y = positions[ind * 3 + 1]; + const z = positions[ind * 3 + 2]; + bbMin.x = Math.min(bbMin.x, x); + bbMin.y = Math.min(bbMin.y, y); + bbMin.z = Math.min(bbMin.z, z); + bbMax.x = Math.max(bbMax.x, x); + bbMax.y = Math.max(bbMax.y, y); + bbMax.z = Math.max(bbMax.z, z); + } + return { + bbMin: vec3.toArray(bbMin), + bbMax: vec3.toArray(bbMax) + }; + }; + const dtIlog2 = v => { + let r = 0; + let shift = 0; + r = Number(v > 0xffff) << 4; + v >>= r; + shift = Number(v > 0xff) << 3; + v >>= shift; + r |= shift; + shift = Number(v > 0xf) << 2; + v >>= shift; + r |= shift; + shift = Number(v > 0x3) << 1; + v >>= shift; + r |= shift; + r |= v >> 1; + return r; + }; + const dtNextPow2 = v => { + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; + }; + + const soloNavMeshGeneratorConfigDefaults = { + ...recastConfigDefaults, + buildBvTree: true + }; + /** + * Builds Solo NavMesh data from the given positions and indices. + * @param positions a flat array of positions + * @param indices a flat array of indices + * @param navMeshGeneratorConfig optional configuration for the NavMesh generator + * @param keepIntermediates if true intermediates will be returned + */ + const generateSoloNavMeshData = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => { + const buildContext = new RecastBuildContext(); + const intermediates = { + type: 'solo', + buildContext + }; + const cleanup = () => { + if (keepIntermediates) return; + if (intermediates.heightfield) { + freeHeightfield(intermediates.heightfield); + intermediates.heightfield = undefined; + } + if (intermediates.compactHeightfield) { + freeCompactHeightfield(intermediates.compactHeightfield); + intermediates.compactHeightfield = undefined; + } + if (intermediates.contourSet) { + freeContourSet(intermediates.contourSet); + intermediates.contourSet = undefined; + } + if (intermediates.polyMesh) { + freePolyMesh(intermediates.polyMesh); + intermediates.polyMesh = undefined; + } + if (intermediates.polyMeshDetail) { + freePolyMeshDetail(intermediates.polyMeshDetail); + intermediates.polyMeshDetail = undefined; + } + }; + const fail = error => { + cleanup(); + return { + navMeshData: undefined, + success: false, + intermediates, + error + }; + }; + /* input geometry */ + const vertices = positions; + const numVertices = indices.length; + const verticesArray = new VerticesArray(); + verticesArray.copy(vertices); + const triangles = indices; + const numTriangles = indices.length / 3; + const trianglesArray = new TrianglesArray(); + trianglesArray.copy(triangles); + let bbMin; + let bbMax; + if (navMeshGeneratorConfig.bounds) { + bbMin = navMeshGeneratorConfig.bounds[0]; + bbMax = navMeshGeneratorConfig.bounds[1]; + } else { + const boundingBox = getBoundingBox(positions, indices); + bbMin = boundingBox.bbMin; + bbMax = boundingBox.bbMax; + } + // + // Step 1. Initialize build config. + // + const config = { + ...soloNavMeshGeneratorConfigDefaults, + ...navMeshGeneratorConfig + }; + const rcConfig = createRcConfig(config); + rcConfig.minRegionArea = rcConfig.minRegionArea * rcConfig.minRegionArea; // Note: area = size*size + rcConfig.mergeRegionArea = rcConfig.mergeRegionArea * rcConfig.mergeRegionArea; // Note: area = size*size + rcConfig.detailSampleDist = rcConfig.detailSampleDist < 0.9 ? 0 : rcConfig.cs * rcConfig.detailSampleDist; + rcConfig.detailSampleMaxError = rcConfig.ch * rcConfig.detailSampleMaxError; + const gridSize = calcGridSize(bbMin, bbMax, rcConfig.cs); + rcConfig.width = gridSize.width; + rcConfig.height = gridSize.height; + // + // Step 2. Rasterize input polygon soup. + // + // Allocate voxel heightfield where we rasterize our input data to. + const heightfield = allocHeightfield(); + intermediates.heightfield = heightfield; + if (!createHeightfield(buildContext, heightfield, rcConfig.width, rcConfig.height, bbMin, bbMax, rcConfig.cs, rcConfig.ch)) { + return fail('Could not create heightfield'); + } + // Find triangles which are walkable based on their slope and rasterize them. + // If your input data is multiple meshes, you can transform them here, calculate + // the are type for each of the meshes and rasterize them. + const triangleAreasArray = new TriangleAreasArray(); + triangleAreasArray.resize(numTriangles); + markWalkableTriangles(buildContext, rcConfig.walkableSlopeAngle, verticesArray, numVertices, trianglesArray, numTriangles, triangleAreasArray); + if (!rasterizeTriangles(buildContext, verticesArray, numVertices, trianglesArray, triangleAreasArray, numTriangles, heightfield, rcConfig.walkableClimb)) { + return fail('Could not rasterize triangles'); + } + triangleAreasArray.destroy(); + verticesArray.destroy(); + trianglesArray.destroy(); + // + // Step 3. Filter walkables surfaces. + // + // Once all geoemtry is rasterized, we do initial pass of filtering to + // remove unwanted overhangs caused by the conservative rasterization + // as well as filter spans where the character cannot possibly stand. + filterLowHangingWalkableObstacles(buildContext, rcConfig.walkableClimb, heightfield); + filterLedgeSpans(buildContext, rcConfig.walkableHeight, rcConfig.walkableClimb, heightfield); + filterWalkableLowHeightSpans(buildContext, rcConfig.walkableHeight, heightfield); + // + // Step 4. Partition walkable surface to simple regions. + // + // Compact the heightfield so that it is faster to handle from now on. + // This will result more cache coherent data as well as the neighbours + // between walkable cells will be calculated. + const compactHeightfield = allocCompactHeightfield(); + intermediates.compactHeightfield = compactHeightfield; + if (!buildCompactHeightfield(buildContext, rcConfig.walkableHeight, rcConfig.walkableClimb, heightfield, compactHeightfield)) { + return fail('Failed to build compact data'); + } + if (!keepIntermediates) { + freeHeightfield(heightfield); + intermediates.heightfield = undefined; + } + // Erode the walkable area by agent radius. + if (!erodeWalkableArea(buildContext, rcConfig.walkableRadius, compactHeightfield)) { + return fail('Failed to erode walkable area'); + } + // (Optional) Mark areas + // markConvexPolyArea(...) + // Prepare for region partitioning, by calculating Distance field along the walkable surface. + if (!buildDistanceField(buildContext, compactHeightfield)) { + return fail('Failed to build distance field'); + } + // Partition the walkable surface into simple regions without holes. + if (!buildRegions(buildContext, compactHeightfield, rcConfig.borderSize, rcConfig.minRegionArea, rcConfig.mergeRegionArea)) { + return fail('Failed to build regions'); + } + // + // Step 5. Trace and simplify region contours. + // + const contourSet = allocContourSet(); + intermediates.contourSet = contourSet; + if (!buildContours(buildContext, compactHeightfield, rcConfig.maxSimplificationError, rcConfig.maxEdgeLen, contourSet, Recast.RC_CONTOUR_TESS_WALL_EDGES)) { + return fail('Failed to create contours'); + } + // + // Step 6. Build polygons mesh from contours. + // + const polyMesh = allocPolyMesh(); + intermediates.polyMesh = polyMesh; + if (!buildPolyMesh(buildContext, contourSet, rcConfig.maxVertsPerPoly, polyMesh)) { + return fail('Failed to triangulate contours'); + } + // + // Step 7. Create detail mesh which allows to access approximate height on each polygon. + // + const polyMeshDetail = allocPolyMeshDetail(); + intermediates.polyMeshDetail = polyMeshDetail; + if (!buildPolyMeshDetail(buildContext, polyMesh, compactHeightfield, rcConfig.detailSampleDist, rcConfig.detailSampleMaxError, polyMeshDetail)) { + return fail('Failed to build detail mesh'); + } + if (!keepIntermediates) { + freeCompactHeightfield(compactHeightfield); + intermediates.compactHeightfield = undefined; + freeContourSet(contourSet); + intermediates.contourSet = undefined; + } + // + // Step 8. Create Detour data from Recast poly mesh. + // + for (let i = 0; i < polyMesh.npolys(); i++) { + if (polyMesh.areas(i) === Recast.RC_WALKABLE_AREA) { + polyMesh.setAreas(i, 0); + } + if (polyMesh.areas(i) === 0) { + polyMesh.setFlags(i, 1); + } + } + const navMeshCreateParams = new NavMeshCreateParams(); + navMeshCreateParams.setPolyMeshCreateParams(polyMesh); + navMeshCreateParams.setPolyMeshDetailCreateParams(polyMeshDetail); + navMeshCreateParams.setWalkableHeight(rcConfig.walkableHeight * rcConfig.ch); + navMeshCreateParams.setWalkableRadius(rcConfig.walkableRadius * rcConfig.cs); + navMeshCreateParams.setWalkableClimb(rcConfig.walkableClimb * rcConfig.ch); + navMeshCreateParams.setCellSize(rcConfig.cs); + navMeshCreateParams.setCellHeight(rcConfig.ch); + navMeshCreateParams.setBuildBvTree(config.buildBvTree); + if (navMeshGeneratorConfig.offMeshConnections) { + navMeshCreateParams.setOffMeshConnections(navMeshGeneratorConfig.offMeshConnections); + } + const createNavMeshDataResult = createNavMeshData(navMeshCreateParams); + if (!createNavMeshDataResult.success) { + return fail('Failed to create Detour navmesh data'); + } + cleanup(); + return { + navMeshData: createNavMeshDataResult.navMeshData, + success: true, + intermediates + }; + }; + /** + * Builds a Solo NavMesh from the given positions and indices. + * @param positions a flat array of positions + * @param indices a flat array of indices + * @param navMeshGeneratorConfig optional configuration for the NavMesh generator + * @param keepIntermediates if true intermediates will be returned + */ + const generateSoloNavMesh = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => { + if (!Raw.Module) { + throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization'); + } + const createNavMeshDataResult = generateSoloNavMeshData(positions, indices, navMeshGeneratorConfig, keepIntermediates); + if (!createNavMeshDataResult.success) { + return { + navMesh: undefined, + success: false, + intermediates: createNavMeshDataResult.intermediates, + error: createNavMeshDataResult.error + }; + } + const { + navMeshData + } = createNavMeshDataResult; + const navMesh = new NavMesh(); + if (!navMesh.initSolo(navMeshData)) { + navMeshData.destroy(); + return { + navMesh: undefined, + success: false, + intermediates: createNavMeshDataResult.intermediates, + error: 'Failed to initialize solo NavMesh' + }; + } + return { + success: true, + navMesh, + intermediates: createNavMeshDataResult.intermediates + }; + }; + + const tileCacheGeneratorConfigDefaults = { + ...recastConfigDefaults, + tileSize: 32, + expectedLayersPerTile: 4, + maxObstacles: 128 + }; + const createDefaultTileCacheMeshProcess = () => new TileCacheMeshProcess((navMeshCreateParams, polyAreas, polyFlags) => { + for (let i = 0; i < navMeshCreateParams.polyCount(); ++i) { + polyAreas.set(i, 0); + polyFlags.set(i, 1); + } + }); + /** + * Builds a TileCache and NavMesh from the given positions and indices. + * TileCache assumes small tiles (around 32-64 squared) and does some tricks to make the update fast. + * @param positions a flat array of positions + * @param indices a flat array of indices + * @param navMeshConfig optional configuration for the NavMesh + * @param keepIntermediates if true intermediates will be returned + */ + const generateTileCache = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => { + if (!Raw.Module) { + throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization'); + } + const buildContext = new RecastBuildContext(); + const intermediates = { + type: 'tilecache', + buildContext, + chunkyTriMesh: undefined, + tileIntermediates: [] + }; + const tileCache = new TileCache(); + const navMesh = new NavMesh(); + /* input geometry */ + const vertices = positions; + const numVertices = indices.length; + const verticesArray = new VerticesArray(); + verticesArray.copy(vertices); + const triangles = indices; + const numTriangles = indices.length / 3; + const trianglesArray = new TrianglesArray(); + trianglesArray.copy(triangles); + let bbMin; + let bbMax; + if (navMeshGeneratorConfig.bounds) { + bbMin = navMeshGeneratorConfig.bounds[0]; + bbMax = navMeshGeneratorConfig.bounds[1]; + } else { + const boundingBox = getBoundingBox(positions, indices); + bbMin = boundingBox.bbMin; + bbMax = boundingBox.bbMax; + } + const { + expectedLayersPerTile, + maxObstacles, + ...recastConfig + } = { + ...tileCacheGeneratorConfigDefaults, + ...navMeshGeneratorConfig + }; + const cleanup = () => { + verticesArray.destroy(); + trianglesArray.destroy(); + if (!keepIntermediates) { + for (let i = 0; i < intermediates.tileIntermediates.length; i++) { + const tileIntermediate = intermediates.tileIntermediates[i]; + if (tileIntermediate.heightfield) { + freeHeightfield(tileIntermediate.heightfield); + tileIntermediate.heightfield = undefined; + } + if (tileIntermediate.compactHeightfield) { + freeCompactHeightfield(tileIntermediate.compactHeightfield); + tileIntermediate.compactHeightfield = undefined; + } + if (tileIntermediate.heightfieldLayerSet) { + freeHeightfieldLayerSet(tileIntermediate.heightfieldLayerSet); + tileIntermediate.heightfieldLayerSet = undefined; + } + } + } + }; + const fail = error => { + cleanup(); + tileCache.destroy(); + navMesh.destroy(); + return { + success: false, + navMesh: undefined, + tileCache: undefined, + intermediates, + error + }; + }; + // + // Step 1. Initialize build config. + // + const config = createRcConfig(recastConfig); + const gridSize = calcGridSize(bbMin, bbMax, config.cs); + config.width = gridSize.width; + config.height = gridSize.height; + config.minRegionArea = config.minRegionArea * config.minRegionArea; // Note: area = size*size + config.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea; // Note: area = size*size + config.detailSampleDist = config.detailSampleDist < 0.9 ? 0 : config.cs * config.detailSampleDist; + config.detailSampleMaxError = config.ch * config.detailSampleMaxError; + const tileSize = Math.floor(config.tileSize); + const tileWidth = Math.floor((config.width + tileSize - 1) / tileSize); + const tileHeight = Math.floor((config.height + tileSize - 1) / tileSize); + // Generation params + config.borderSize = config.walkableRadius + 3; // Reserve enough padding. + config.width = config.tileSize + config.borderSize * 2; + config.height = config.tileSize + config.borderSize * 2; + // Tile cache params + const tileCacheParams = DetourTileCacheParams.create({ + orig: bbMin, + cs: config.cs, + ch: config.ch, + width: config.tileSize, + height: config.tileSize, + walkableHeight: config.walkableHeight * config.ch, + walkableRadius: config.walkableRadius * config.cs, + walkableClimb: config.walkableClimb * config.ch, + maxSimplificationError: config.maxSimplificationError, + maxTiles: tileWidth * tileHeight * expectedLayersPerTile, + maxObstacles + }); + const allocator = new Raw.RecastLinearAllocator(32000); + const compressor = new Raw.RecastFastLZCompressor(); + const tileCacheMeshProcess = navMeshGeneratorConfig.tileCacheMeshProcess ?? createDefaultTileCacheMeshProcess(); + if (!tileCache.init(tileCacheParams, allocator, compressor, tileCacheMeshProcess)) { + return fail('Failed to initialize tile cache'); + } + const orig = vec3.fromArray(bbMin); + // Max tiles and max polys affect how the tile IDs are caculated. + // There are 22 bits available for identifying a tile and a polygon. + let tileBits = Math.min(Math.floor(dtIlog2(dtNextPow2(tileWidth * tileHeight * expectedLayersPerTile))), 14); + if (tileBits > 14) { + tileBits = 14; + } + const polyBits = 22 - tileBits; + const maxTiles = 1 << tileBits; + const maxPolysPerTile = 1 << polyBits; + const navMeshParams = NavMeshParams.create({ + orig, + tileWidth: config.tileSize * config.cs, + tileHeight: config.tileSize * config.cs, + maxTiles, + maxPolys: maxPolysPerTile + }); + if (!navMesh.initTiled(navMeshParams)) { + return fail('Failed to initialize tiled navmesh'); + } + const chunkyTriMesh = new RecastChunkyTriMesh(); + intermediates.chunkyTriMesh = chunkyTriMesh; + if (!chunkyTriMesh.init(verticesArray, trianglesArray, numTriangles, 256)) { + return fail('Failed to build chunky triangle mesh'); + } + const rasterizeTileLayers = (tileX, tileY) => { + // Tile intermediates + const tileIntermediates = { + tileX, + tileY + }; + // Tile bounds + const tcs = config.tileSize * config.cs; + const tileConfig = cloneRcConfig(config); + const tileBoundsMin = [bbMin[0] + tileX * tcs, bbMin[1], bbMin[2] + tileY * tcs]; + const tileBoundsMax = [bbMin[0] + (tileX + 1) * tcs, bbMax[1], bbMin[2] + (tileY + 1) * tcs]; + tileBoundsMin[0] -= tileConfig.borderSize * tileConfig.cs; + tileBoundsMin[2] -= tileConfig.borderSize * tileConfig.cs; + tileBoundsMax[0] += tileConfig.borderSize * tileConfig.cs; + tileBoundsMax[2] += tileConfig.borderSize * tileConfig.cs; + tileConfig.set_bmin(0, tileBoundsMin[0]); + tileConfig.set_bmin(1, tileBoundsMin[1]); + tileConfig.set_bmin(2, tileBoundsMin[2]); + tileConfig.set_bmax(0, tileBoundsMax[0]); + tileConfig.set_bmax(1, tileBoundsMax[1]); + tileConfig.set_bmax(2, tileBoundsMax[2]); + // Allocate voxel heightfield where we rasterize our input data to. + const heightfield = allocHeightfield(); + tileIntermediates.heightfield = heightfield; + if (!createHeightfield(buildContext, heightfield, tileConfig.width, tileConfig.height, tileBoundsMin, tileBoundsMax, tileConfig.cs, tileConfig.ch)) { + return { + n: 0 + }; + } + const tbmin = [tileBoundsMin[0], tileBoundsMin[2]]; + const tbmax = [tileBoundsMax[0], tileBoundsMax[2]]; + // TODO: Make grow when returning too many items. + const maxChunkIds = 512; + const chunkIdsArray = new ChunkIdsArray(); + chunkIdsArray.resize(maxChunkIds); + const nChunksOverlapping = chunkyTriMesh.getChunksOverlappingRect(tbmin, tbmax, chunkIdsArray, maxChunkIds); + if (nChunksOverlapping === 0) { + return { + n: 0 + }; + } + for (let i = 0; i < nChunksOverlapping; ++i) { + const nodeId = chunkIdsArray.get(i); + const node = chunkyTriMesh.nodes(nodeId); + const nNodeTris = node.n; + const nodeTrianglesArray = chunkyTriMesh.getNodeTris(nodeId); + const triangleAreasArray = new TriangleAreasArray(); + triangleAreasArray.resize(nNodeTris); + // Find triangles which are walkable based on their slope and rasterize them. + // If your input data is multiple meshes, you can transform them here, calculate + // the are type for each of the meshes and rasterize them. + markWalkableTriangles(buildContext, tileConfig.walkableSlopeAngle, verticesArray, numVertices, nodeTrianglesArray, nNodeTris, triangleAreasArray); + const success = rasterizeTriangles(buildContext, verticesArray, numVertices, nodeTrianglesArray, triangleAreasArray, nNodeTris, heightfield, tileConfig.walkableClimb); + triangleAreasArray.destroy(); + if (!success) { + return { + n: 0 + }; + } + } + // Once all geometry is rasterized, we do initial pass of filtering to + // remove unwanted overhangs caused by the conservative rasterization + // as well as filter spans where the character cannot possibly stand. + filterLowHangingWalkableObstacles(buildContext, config.walkableClimb, heightfield); + filterLedgeSpans(buildContext, config.walkableHeight, config.walkableClimb, heightfield); + filterWalkableLowHeightSpans(buildContext, config.walkableHeight, heightfield); + const compactHeightfield = allocCompactHeightfield(); + if (!buildCompactHeightfield(buildContext, config.walkableHeight, config.walkableClimb, heightfield, compactHeightfield)) { + return { + n: 0 + }; + } + if (!keepIntermediates) { + freeHeightfield(tileIntermediates.heightfield); + tileIntermediates.heightfield = undefined; + } + // Erode the walkable area by agent radius + if (!erodeWalkableArea(buildContext, config.walkableRadius, compactHeightfield)) { + return { + n: 0 + }; + } + const heightfieldLayerSet = allocHeightfieldLayerSet(); + if (!buildHeightfieldLayers(buildContext, compactHeightfield, config.borderSize, config.walkableHeight, heightfieldLayerSet)) { + return { + n: 0 + }; + } + if (!keepIntermediates) { + freeCompactHeightfield(compactHeightfield); + tileIntermediates.compactHeightfield = undefined; + } + const tiles = []; + for (let i = 0; i < heightfieldLayerSet.nlayers(); i++) { + const tile = new TileCacheData(); + const heightfieldLayer = heightfieldLayerSet.layers(i); + // Store header + const header = new Raw.dtTileCacheLayerHeader(); + header.magic = Detour.DT_TILECACHE_MAGIC; + header.version = Detour.DT_TILECACHE_VERSION; + // Tile layer location in the navmesh + header.tx = tileX; + header.ty = tileY; + header.tlayer = i; + const heightfieldLayerBin = heightfieldLayer.bmin(); + const heightfieldLayerBmax = heightfieldLayer.bmax(); + header.set_bmin(0, heightfieldLayerBin.x); + header.set_bmin(1, heightfieldLayerBin.y); + header.set_bmin(2, heightfieldLayerBin.z); + header.set_bmax(0, heightfieldLayerBmax.x); + header.set_bmax(1, heightfieldLayerBmax.y); + header.set_bmax(2, heightfieldLayerBmax.z); + // Tile info + header.width = heightfieldLayer.width(); + header.height = heightfieldLayer.height(); + header.minx = heightfieldLayer.minx(); + header.maxx = heightfieldLayer.maxx(); + header.miny = heightfieldLayer.miny(); + header.maxy = heightfieldLayer.maxy(); + header.hmin = heightfieldLayer.hmin(); + header.hmax = heightfieldLayer.hmax(); + const heights = getHeightfieldLayerHeights(heightfieldLayer); + const areas = getHeightfieldLayerAreas(heightfieldLayer); + const cons = getHeightfieldLayerCons(heightfieldLayer); + const status = buildTileCacheLayer(compressor, header, heights, areas, cons, tile); + if (statusFailed(status)) { + return { + n: 0 + }; + } + tiles.push(tile); + } + if (!keepIntermediates) { + freeHeightfieldLayerSet(heightfieldLayerSet); + tileIntermediates.heightfieldLayerSet = undefined; + } + intermediates.tileIntermediates.push(tileIntermediates); + return { + n: tiles.length, + tiles + }; + }; + // Preprocess tiles + for (let y = 0; y < tileHeight; ++y) { + for (let x = 0; x < tileWidth; ++x) { + const { + n, + tiles: newTiles + } = rasterizeTileLayers(x, y); + if (n > 0 && newTiles) { + for (let i = 0; i < n; i++) { + const tileCacheData = newTiles[i]; + const addResult = tileCache.addTile(tileCacheData); + if (statusFailed(addResult.status)) { + buildContext.log(Recast.RC_LOG_WARNING, `Failed to add tile to tile cache - tx: ${x}, ty: ${y}`); + } + } + } + } + } + // Build initial meshes + for (let y = 0; y < tileHeight; y++) { + for (let x = 0; x < tileWidth; x++) { + const dtStatus = tileCache.buildNavMeshTilesAt(x, y, navMesh); + if (statusFailed(dtStatus)) { + return fail(`Failed to build nav mesh tiles at ${x}, ${y}`); + } + } + } + cleanup(); + return { + success: true, + tileCache, + navMesh, + intermediates + }; + }; + + const buildTiledNavMeshRcConfig = ({ + recastConfig, + navMeshBounds: [navMeshBoundsMin, navMeshBoundsMax] + }) => { + // + // Initialize build config. + // + const config = createRcConfig(recastConfig); + /* grid size */ + const gridSize = calcGridSize(navMeshBoundsMin, navMeshBoundsMax, config.cs); + config.width = gridSize.width; + config.height = gridSize.height; + config.minRegionArea = config.minRegionArea * config.minRegionArea; // Note: area = size*size + config.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea; // Note: area = size*size + config.tileSize = Math.floor(config.tileSize); + config.borderSize = config.walkableRadius + 3; // Reserve enough padding. + config.width = config.tileSize + config.borderSize * 2; + config.height = config.tileSize + config.borderSize * 2; + config.detailSampleDist = config.detailSampleDist < 0.9 ? 0 : config.cs * config.detailSampleDist; + config.detailSampleMaxError = config.ch * config.detailSampleMaxError; + // tile size + const tileSize = Math.floor(config.tileSize); + const tileWidth = Math.floor((gridSize.width + tileSize - 1) / tileSize); + const tileHeight = Math.floor((gridSize.height + tileSize - 1) / tileSize); + const tcs = config.tileSize * config.cs; + /* Create dtNavMeshParams, initialise nav mesh for tiled use */ + const orig = vec3.fromArray(navMeshBoundsMin); + // Max tiles and max polys affect how the tile IDs are caculated. + // There are 22 bits available for identifying a tile and a polygon. + let tileBits = Math.min(Math.floor(dtIlog2(dtNextPow2(tileWidth * tileHeight))), 14); + if (tileBits > 14) tileBits = 14; + const polyBits = 22 - tileBits; + const maxTiles = 1 << tileBits; + const maxPolysPerTile = 1 << polyBits; + return { + config, + gridSize, + tileSize, + tileWidth, + tileHeight, + tcs, + orig, + maxTiles, + maxPolysPerTile + }; + }; + const tiledNavMeshGeneratorConfigDefaults = { + ...recastConfigDefaults, + chunkyTriMeshTrisPerChunk: 256, + buildBvTree: true + }; + const generateTileNavMeshData = (positions, indices, rcConfig, chunkyTriMesh, tile, options = {}, keepIntermediates = false, buildContext = new RecastBuildContext()) => { + const tileIntermediate = { + x: tile.x, + y: tile.y + }; + const cleanup = () => { + if (keepIntermediates) return; + if (tileIntermediate.compactHeightfield) { + freeCompactHeightfield(tileIntermediate.compactHeightfield); + tileIntermediate.compactHeightfield = undefined; + } + if (tileIntermediate.heightfield) { + freeHeightfield(tileIntermediate.heightfield); + tileIntermediate.heightfield = undefined; + } + if (tileIntermediate.contourSet) { + freeContourSet(tileIntermediate.contourSet); + tileIntermediate.contourSet = undefined; + } + if (tileIntermediate.polyMesh) { + freePolyMesh(tileIntermediate.polyMesh); + tileIntermediate.polyMesh = undefined; + } + if (tileIntermediate.polyMeshDetail) { + freePolyMeshDetail(tileIntermediate.polyMeshDetail); + tileIntermediate.polyMeshDetail = undefined; + } + }; + const failTileMesh = error => { + buildContext.log(Recast.RC_LOG_ERROR, error); + cleanup(); + return { + success: false, + error, + intermediates: tileIntermediate + }; + }; + const tileConfig = cloneRcConfig(rcConfig); + // Expand the heightfield bounding box by border size to find the extents of geometry we need to build this tile. + // + // This is done in order to make sure that the navmesh tiles connect correctly at the borders, + // and the obstacles close to the border work correctly with the dilation process. + // No polygons (or contours) will be created on the border area. + // + // IMPORTANT! + // + // :''''''''': + // : +-----+ : + // : | | : + // : | |<--- tile to build + // : | | : + // : +-----+ :<-- geometry needed + // :.........: + // + // You should use this bounding box to query your input geometry. + // + // For example if you build a navmesh for terrain, and want the navmesh tiles to match the terrain tile size + // you will need to pass in data from neighbour terrain tiles too! In a simple case, just pass in all the 8 neighbours, + // or use the bounding box below to only pass in a sliver of each of the 8 neighbours. + const expandedTileBoundsMin = [...tile.bmin]; + const expandedTileBoundsMax = [...tile.bmax]; + expandedTileBoundsMin[0] -= tileConfig.borderSize * tileConfig.cs; + expandedTileBoundsMin[2] -= tileConfig.borderSize * tileConfig.cs; + expandedTileBoundsMax[0] += tileConfig.borderSize * tileConfig.cs; + expandedTileBoundsMax[2] += tileConfig.borderSize * tileConfig.cs; + tileConfig.set_bmin(0, expandedTileBoundsMin[0]); + tileConfig.set_bmin(1, expandedTileBoundsMin[1]); + tileConfig.set_bmin(2, expandedTileBoundsMin[2]); + tileConfig.set_bmax(0, expandedTileBoundsMax[0]); + tileConfig.set_bmax(1, expandedTileBoundsMax[1]); + tileConfig.set_bmax(2, expandedTileBoundsMax[2]); + // Reset build timer + buildContext.resetTimers(); + // Start the build process + buildContext.startTimer(Recast.RC_TIMER_TOTAL); + buildContext.log(Recast.RC_LOG_PROGRESS, `Building tile at x: ${tile.x}, y: ${tile.y}`); + buildContext.log(Recast.RC_LOG_PROGRESS, ` - ${tileConfig.width} x ${tileConfig.height} cells`); + buildContext.log(Recast.RC_LOG_PROGRESS, ` - ${positions.size / 3 / 1000}K verts, ${indices.size / 3 / 1000}K tris`); + // Allocate voxel heightfield where we rasterize our input data to. + const heightfield = allocHeightfield(); + tileIntermediate.heightfield = heightfield; + if (!createHeightfield(buildContext, heightfield, tileConfig.width, tileConfig.height, expandedTileBoundsMin, expandedTileBoundsMax, tileConfig.cs, tileConfig.ch)) { + return failTileMesh('Could not create heightfield'); + } + // Allocate array that can hold triangle flags. + // If you have multiple meshes you need to process, allocate + // and array which can hold the max number of triangles you need to process. + const triAreas = new TriangleAreasArray(); + triAreas.resize(chunkyTriMesh.maxTrisPerChunk()); + const tbmin = [expandedTileBoundsMin[0], expandedTileBoundsMin[2]]; + const tbmax = [expandedTileBoundsMax[0], expandedTileBoundsMax[2]]; + // TODO: Make grow when returning too many items. + const maxChunkIds = 512; + const chunkIdsArray = new ChunkIdsArray(); + chunkIdsArray.resize(maxChunkIds); + const nChunksOverlapping = chunkyTriMesh.getChunksOverlappingRect(tbmin, tbmax, chunkIdsArray, maxChunkIds); + if (nChunksOverlapping === 0) { + return { + success: true, + intermediates: tileIntermediate + }; + } + for (let i = 0; i < nChunksOverlapping; ++i) { + const nodeId = chunkIdsArray.get(i); + const node = chunkyTriMesh.nodes(nodeId); + const nNodeTris = node.n; + const nodeTrianglesArray = chunkyTriMesh.getNodeTris(nodeId); + const triangleAreasArray = new TriangleAreasArray(); + triangleAreasArray.resize(nNodeTris); + // Find triangles which are walkable based on their slope and rasterize them. + // If your input data is multiple meshes, you can transform them here, calculate + // the are type for each of the meshes and rasterize them. + markWalkableTriangles(buildContext, tileConfig.walkableSlopeAngle, positions, indices.size, nodeTrianglesArray, nNodeTris, triangleAreasArray); + const success = rasterizeTriangles(buildContext, positions, indices.size, nodeTrianglesArray, triangleAreasArray, nNodeTris, heightfield, tileConfig.walkableClimb); + triangleAreasArray.destroy(); + if (!success) { + return failTileMesh('Could not rasterize triangles'); + } + } + // Once all geometry is rasterized, we do initial pass of filtering to + // remove unwanted overhangs caused by the conservative rasterization + // as well as filter spans where the character cannot possibly stand. + filterLowHangingWalkableObstacles(buildContext, tileConfig.walkableClimb, heightfield); + filterLedgeSpans(buildContext, tileConfig.walkableHeight, tileConfig.walkableClimb, heightfield); + filterWalkableLowHeightSpans(buildContext, tileConfig.walkableHeight, heightfield); + // Compact the heightfield so that it is faster to handle from now on. + // This will result more cache coherent data as well as the neighbours + // between walkable cells will be calculated. + const compactHeightfield = allocCompactHeightfield(); + tileIntermediate.compactHeightfield = compactHeightfield; + if (!buildCompactHeightfield(buildContext, tileConfig.walkableHeight, tileConfig.walkableClimb, heightfield, compactHeightfield)) { + return failTileMesh('Could not build compact heightfield'); + } + if (!keepIntermediates) { + freeHeightfield(tileIntermediate.heightfield); + tileIntermediate.heightfield = undefined; + } + // Erode the walkable area by agent radius + if (!erodeWalkableArea(buildContext, tileConfig.walkableRadius, compactHeightfield)) { + return failTileMesh('Could not erode walkable area'); + } + // (Optional) Mark areas + // markConvexPolyArea(...) + // Prepare for region partitioning, by calculating Distance field along the walkable surface. + if (!buildDistanceField(buildContext, compactHeightfield)) { + return failTileMesh('Failed to build distance field'); + } + // Partition the walkable surface into simple regions without holes. + if (!buildRegions(buildContext, compactHeightfield, tileConfig.borderSize, tileConfig.minRegionArea, tileConfig.mergeRegionArea)) { + return failTileMesh('Failed to build regions'); + } + // + // Trace and simplify region contours. + // + const contourSet = allocContourSet(); + tileIntermediate.contourSet = contourSet; + if (!buildContours(buildContext, compactHeightfield, tileConfig.maxSimplificationError, tileConfig.maxEdgeLen, contourSet, Recast.RC_CONTOUR_TESS_WALL_EDGES)) { + return failTileMesh('Failed to create contours'); + } + // + // Build polygons mesh from contours. + // + const polyMesh = allocPolyMesh(); + tileIntermediate.polyMesh = polyMesh; + if (!buildPolyMesh(buildContext, contourSet, tileConfig.maxVertsPerPoly, polyMesh)) { + return failTileMesh('Failed to triangulate contours'); + } + // + // Create detail mesh which allows to access approximate height on each polygon. + // + const polyMeshDetail = allocPolyMeshDetail(); + tileIntermediate.polyMeshDetail = polyMeshDetail; + if (!buildPolyMeshDetail(buildContext, polyMesh, compactHeightfield, tileConfig.detailSampleDist, tileConfig.detailSampleMaxError, polyMeshDetail)) { + return failTileMesh('Failed to build detail mesh'); + } + if (!keepIntermediates) { + freeCompactHeightfield(compactHeightfield); + tileIntermediate.compactHeightfield = undefined; + freeContourSet(contourSet); + tileIntermediate.contourSet = undefined; + } + // Update poly flags from areas. + for (let i = 0; i < polyMesh.npolys(); i++) { + if (polyMesh.areas(i) === Recast.RC_WALKABLE_AREA) { + polyMesh.setAreas(i, 0); + } + if (polyMesh.areas(i) === 0) { + polyMesh.setFlags(i, 1); + } + } + const navMeshCreateParams = new NavMeshCreateParams(); + navMeshCreateParams.setPolyMeshCreateParams(polyMesh); + navMeshCreateParams.setPolyMeshDetailCreateParams(polyMeshDetail); + navMeshCreateParams.setWalkableHeight(tileConfig.walkableHeight * tileConfig.ch); + navMeshCreateParams.setWalkableRadius(tileConfig.walkableRadius * tileConfig.cs); + navMeshCreateParams.setWalkableClimb(tileConfig.walkableClimb * tileConfig.ch); + navMeshCreateParams.setCellSize(tileConfig.cs); + navMeshCreateParams.setCellHeight(tileConfig.ch); + navMeshCreateParams.setBuildBvTree(options.buildBvTree ?? tiledNavMeshGeneratorConfigDefaults.buildBvTree); + if (options.offMeshConnections) { + navMeshCreateParams.setOffMeshConnections(options.offMeshConnections); + } + navMeshCreateParams.setTileX(tile.x); + navMeshCreateParams.setTileY(tile.y); + const createNavMeshDataResult = createNavMeshData(navMeshCreateParams); + if (!createNavMeshDataResult.success) { + return failTileMesh('Failed to create Detour navmesh data'); + } + buildContext.log(Recast.RC_LOG_PROGRESS, `>> Polymesh: ${polyMesh.nverts()} vertices ${polyMesh.npolys()} polygons`); + return { + success: true, + data: createNavMeshDataResult.navMeshData, + intermediates: tileIntermediate + }; + }; + /** + * Builds a Tiled NavMesh + * @param positions a flat array of positions + * @param indices a flat array of indices + * @param navMeshGeneratorConfig optional configuration for the NavMesh generator + * @param keepIntermediates if true intermediates will be returned + */ + const generateTiledNavMesh = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => { + if (!Raw.Module) { + throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization'); + } + const buildContext = new RecastBuildContext(); + const intermediates = { + type: 'tiled', + buildContext, + chunkyTriMesh: undefined, + tileIntermediates: [] + }; + const navMesh = new NavMesh(); + /* input geometry */ + const vertices = positions; + const verticesArray = new VerticesArray(); + verticesArray.copy(vertices); + const triangles = indices; + const numTriangles = indices.length / 3; + const trianglesArray = new TrianglesArray(); + trianglesArray.copy(triangles); + const cleanup = () => { + verticesArray.destroy(); + trianglesArray.destroy(); + if (keepIntermediates) return; + if (intermediates.chunkyTriMesh) { + intermediates.chunkyTriMesh = undefined; + } + }; + const fail = error => { + cleanup(); + navMesh.destroy(); + return { + success: false, + navMesh: undefined, + intermediates, + error + }; + }; + // + // Initialize build config. + // + const generatorConfig = { + ...tiledNavMeshGeneratorConfigDefaults, + ...navMeshGeneratorConfig + }; + let bbMin; + let bbMax; + if (navMeshGeneratorConfig.bounds) { + bbMin = navMeshGeneratorConfig.bounds[0]; + bbMax = navMeshGeneratorConfig.bounds[1]; + } else { + const boundingBox = getBoundingBox(positions, indices); + bbMin = boundingBox.bbMin; + bbMax = boundingBox.bbMax; + } + const { + config: rcConfig, + tileWidth, + tileHeight, + tcs, + orig, + maxTiles, + maxPolysPerTile + } = buildTiledNavMeshRcConfig({ + recastConfig: generatorConfig, + navMeshBounds: [bbMin, bbMax] + }); + const navMeshParams = NavMeshParams.create({ + orig, + tileWidth: generatorConfig.tileSize * generatorConfig.cs, + tileHeight: generatorConfig.tileSize * generatorConfig.cs, + maxTiles, + maxPolys: maxPolysPerTile + }); + if (!navMesh.initTiled(navMeshParams)) { + return fail('Could not init nav mesh for tiled use'); + } + /* create chunky tri mesh */ + const chunkyTriMesh = new RecastChunkyTriMesh(); + intermediates.chunkyTriMesh = chunkyTriMesh; + if (!chunkyTriMesh.init(verticesArray, trianglesArray, numTriangles, generatorConfig.chunkyTriMeshTrisPerChunk)) { + return fail('Failed to build chunky triangle mesh'); + } + buildContext.startTimer(Recast.RC_TIMER_TEMP); + const lastBuiltTileBmin = [0, 0, 0]; + const lastBuiltTileBmax = [0, 0, 0]; + for (let y = 0; y < tileHeight; y++) { + for (let x = 0; x < tileWidth; x++) { + lastBuiltTileBmin[0] = bbMin[0] + x * tcs; + lastBuiltTileBmin[1] = bbMin[1]; + lastBuiltTileBmin[2] = bbMin[2] + y * tcs; + lastBuiltTileBmax[0] = bbMin[0] + (x + 1) * tcs; + lastBuiltTileBmax[1] = bbMax[1]; + lastBuiltTileBmax[2] = bbMin[2] + (y + 1) * tcs; + const tile = { + x, + y, + bmin: lastBuiltTileBmin, + bmax: lastBuiltTileBmax + }; + const generatorOptions = { + offMeshConnections: generatorConfig.offMeshConnections, + buildBvTree: generatorConfig.buildBvTree + }; + const result = generateTileNavMeshData(verticesArray, trianglesArray, rcConfig, chunkyTriMesh, tile, generatorOptions, keepIntermediates, buildContext); + intermediates.tileIntermediates.push(result.intermediates); + if (result.success && result.data) { + navMesh.removeTile(navMesh.getTileRefAt(x, y, 0)); + const addTileResult = navMesh.addTile(result.data, Detour.DT_TILE_FREE_DATA, 0); + if (statusFailed(addTileResult.status)) { + buildContext.log(Recast.RC_LOG_WARNING, `Failed to add tile to nav mesh tx: ${x}, ty: ${y}, status: ${statusToReadableString(addTileResult.status)} (${addTileResult.status})`); + result.data.destroy(); + } + } + } + } + buildContext.stopTimer(Recast.RC_TIMER_TEMP); + if (!keepIntermediates) { + cleanup(); + } + return { + success: true, + navMesh, + intermediates + }; + }; + + const mergePositionsAndIndices = meshes => { + const mergedPositions = []; + const mergedIndices = []; + const positionToIndex = {}; + let indexCounter = 0; + for (const { + positions, + indices + } of meshes) { + for (let i = 0; i < indices.length; i++) { + const pt = indices[i] * 3; + const x = positions[pt]; + const y = positions[pt + 1]; + const z = positions[pt + 2]; + const key = `${x}_${y}_${z}`; + let idx = positionToIndex[key]; + if (!idx) { + positionToIndex[key] = idx = indexCounter; + mergedPositions.push(x, y, z); + indexCounter++; + } + mergedIndices.push(idx); + } + } + return [Float32Array.from(mergedPositions), Uint32Array.from(mergedIndices)]; + }; + + exports.buildTiledNavMeshRcConfig = buildTiledNavMeshRcConfig; + exports.createDefaultTileCacheMeshProcess = createDefaultTileCacheMeshProcess; + exports.dtIlog2 = dtIlog2; + exports.dtNextPow2 = dtNextPow2; + exports.generateSoloNavMesh = generateSoloNavMesh; + exports.generateSoloNavMeshData = generateSoloNavMeshData; + exports.generateTileCache = generateTileCache; + exports.generateTileNavMeshData = generateTileNavMeshData; + exports.generateTiledNavMesh = generateTiledNavMesh; + exports.getBoundingBox = getBoundingBox; + exports.mergePositionsAndIndices = mergePositionsAndIndices; + exports.soloNavMeshGeneratorConfigDefaults = soloNavMeshGeneratorConfigDefaults; + exports.tileCacheGeneratorConfigDefaults = tileCacheGeneratorConfigDefaults; + exports.tiledNavMeshGeneratorConfigDefaults = tiledNavMeshGeneratorConfigDefaults; + +})); diff --git a/Extensions/NavMeshPathfinding/recast-navigation.wasm.js b/Extensions/NavMeshPathfinding/recast-navigation.wasm.js new file mode 100644 index 000000000000..6c3fcfbe8fc2 --- /dev/null +++ b/Extensions/NavMeshPathfinding/recast-navigation.wasm.js @@ -0,0 +1,38 @@ +// @recast-navigation/wasm, a port of recast navigation to JavaScript. +// https://github.com/isaac-mason/recast-navigation-js + +// recastnavigation +// https://github.com/recastnavigation/recastnavigation + +// Recast & Detour +// Copyright (c) 2009 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +var Recast = (() => { + + return ( +async function(moduleArg = {}) { + var moduleRtn; + +var Module=moduleArg;var ENVIRONMENT_IS_WEB=true;var ENVIRONMENT_IS_WORKER=false;var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text)}}var readyPromiseResolve,readyPromiseReject;var wasmMemory;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(onInits);wasmExports["h"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("recast-navigation.wasm.wasm")}return new URL("recast-navigation.wasm.wasm",import.meta.url).href}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["g"];updateMemoryViews();wasmTable=wasmExports["n"];assignWasmExports(wasmExports);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod,inst))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0};var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which]}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()))},timeout_ms);timers[which]={id,timeout_ms};return 0};var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{readEmAsmArgsArray.length=0;var ch;while(ch=HEAPU8[sigPtr++]){var wide=ch!=105;wide&=ch!=112;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?HEAPU32[buf>>2]:ch==105?HEAP32[buf>>2]:HEAPF64[buf>>3]);buf+=wide?8:4}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);return ASM_CONSTS[code](...args)};var _emscripten_asm_const_int=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array};var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead=NaN)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var onInits=[];var addOnInit=cb=>onInits.push(cb);var uleb128Encode=(n,target)=>{if(n<128){target.push(n)}else{target.push(n%128|128,n>>7)}};var sigToWasmTypes=sig=>{var typeNames={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"};var type={parameters:[],results:sig[0]=="v"?[]:[typeNames[sig[0]]]};for(var i=1;i{var sigRet=sig.slice(0,1);var sigParam=sig.slice(1);var typeCodes={i:127,p:127,j:126,f:125,d:124,e:111};target.push(96);uleb128Encode(sigParam.length,target);for(var paramType of sigParam){target.push(typeCodes[paramType])}if(sigRet=="v"){target.push(0)}else{target.push(1,typeCodes[sigRet])}};var convertJsFunctionToWasm=(func,sig)=>{if(typeof WebAssembly.Function=="function"){return new WebAssembly.Function(sigToWasmTypes(sig),func)}var typeSectionBody=[1];generateFuncType(sig,typeSectionBody);var bytes=[0,97,115,109,1,0,0,0,1];uleb128Encode(typeSectionBody.length,bytes);bytes.push(...typeSectionBody);bytes.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var module=new WebAssembly.Module(new Uint8Array(bytes));var instance=new WebAssembly.Instance(module,{e:{f:func}});var wrappedFunc=instance.exports["f"];return wrappedFunc};var wasmTableMirror=[];var wasmTable;var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func};var updateTableMap=(offset,count)=>{if(functionsInTableMap){for(var i=offset;i{if(!functionsInTableMap){functionsInTableMap=new WeakMap;updateTableMap(0,wasmTable.length)}return functionsInTableMap.get(func)||0};var freeTableIndexes=[];var getEmptyTableSlot=()=>{if(freeTableIndexes.length){return freeTableIndexes.pop()}try{wasmTable.grow(1)}catch(err){if(!(err instanceof RangeError)){throw err}throw"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."}return wasmTable.length-1};var setWasmTableEntry=(idx,func)=>{wasmTable.set(idx,func);wasmTableMirror[idx]=wasmTable.get(idx)};var addFunction=(func,sig)=>{var rtn=getFunctionAddress(func);if(rtn){return rtn}var ret=getEmptyTableSlot();try{setWasmTableEntry(ret,func)}catch(err){if(!(err instanceof TypeError)){throw err}var wrapped=convertJsFunctionToWasm(func,sig);setWasmTableEntry(ret,wrapped)}functionsInTableMap.set(func,ret);return ret};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"]}Module["addFunction"]=addFunction;Module["UTF8ToString"]=UTF8ToString;var ASM_CONSTS={14746:($0,$1,$2,$3)=>{var self=Module["getCache"](Module["TileCacheMeshProcess"])[$0];if(!self.hasOwnProperty("process"))throw"a JSImplementation must implement all functions, you forgot TileCacheMeshProcess::process.";self["process"]($1,$2,$3)},14981:$0=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("resetLog"))throw"a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::resetLog.";self["resetLog"]()},15219:($0,$1,$2,$3)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("log"))throw"a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::log.";self["log"]($1,$2,$3)},15450:$0=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("resetTimers"))throw"a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::resetTimers.";self["resetTimers"]()},15697:($0,$1)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("startTimer"))throw"a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::startTimer.";self["startTimer"]($1)},15943:($0,$1)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("stopTimer"))throw"a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::stopTimer.";self["stopTimer"]($1)},16186:($0,$1)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("getAccumulatedTime"))throw"a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::getAccumulatedTime.";return self["getAccumulatedTime"]($1)},16463:($0,$1)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleDepthMask"))throw"a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleDepthMask.";self["handleDepthMask"]($1)},16702:($0,$1)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleTexture"))throw"a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleTexture.";self["handleTexture"]($1)},16935:($0,$1,$2)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleBegin"))throw"a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleBegin.";self["handleBegin"]($1,$2)},17165:($0,$1,$2,$3,$4)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleVertexWithColor"))throw"a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleVertexWithColor.";self["handleVertexWithColor"]($1,$2,$3,$4)},17431:($0,$1,$2,$3,$4,$5,$6)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleVertexWithColorAndUV"))throw"a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleVertexWithColorAndUV.";self["handleVertexWithColorAndUV"]($1,$2,$3,$4,$5,$6)},17718:$0=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleEnd"))throw"a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleEnd.";self["handleEnd"]()}};var _webidl_free,_free,_webidl_malloc,_malloc,_emscripten_bind_duDebugDraw___destroy___0,_emscripten_bind_dtTileCacheCompressor___destroy___0,_emscripten_bind_TileCacheMeshProcessJsImpl_process_3,_emscripten_bind_TileCacheMeshProcessJsImpl___destroy___0,_emscripten_bind_dtTileCacheAlloc___destroy___0,_emscripten_bind_rcContext_rcContext_0,_emscripten_bind_rcContext_enableLog_1,_emscripten_bind_rcContext_resetLog_0,_emscripten_bind_rcContext_log_2,_emscripten_bind_rcContext_enableTimer_1,_emscripten_bind_rcContext_resetTimers_0,_emscripten_bind_rcContext_startTimer_1,_emscripten_bind_rcContext_stopTimer_1,_emscripten_bind_rcContext_getAccumulatedTime_1,_emscripten_bind_rcContext___destroy___0,_emscripten_bind_RecastBuildContextImpl___destroy___0,_emscripten_bind_DebugDraw___destroy___0,_emscripten_bind_VoidPtr___destroy___0,_emscripten_bind_rcConfig_rcConfig_0,_emscripten_bind_rcConfig_get_width_0,_emscripten_bind_rcConfig_set_width_1,_emscripten_bind_rcConfig_get_height_0,_emscripten_bind_rcConfig_set_height_1,_emscripten_bind_rcConfig_get_tileSize_0,_emscripten_bind_rcConfig_set_tileSize_1,_emscripten_bind_rcConfig_get_borderSize_0,_emscripten_bind_rcConfig_set_borderSize_1,_emscripten_bind_rcConfig_get_cs_0,_emscripten_bind_rcConfig_set_cs_1,_emscripten_bind_rcConfig_get_ch_0,_emscripten_bind_rcConfig_set_ch_1,_emscripten_bind_rcConfig_get_bmin_1,_emscripten_bind_rcConfig_set_bmin_2,_emscripten_bind_rcConfig_get_bmax_1,_emscripten_bind_rcConfig_set_bmax_2,_emscripten_bind_rcConfig_get_walkableSlopeAngle_0,_emscripten_bind_rcConfig_set_walkableSlopeAngle_1,_emscripten_bind_rcConfig_get_walkableHeight_0,_emscripten_bind_rcConfig_set_walkableHeight_1,_emscripten_bind_rcConfig_get_walkableClimb_0,_emscripten_bind_rcConfig_set_walkableClimb_1,_emscripten_bind_rcConfig_get_walkableRadius_0,_emscripten_bind_rcConfig_set_walkableRadius_1,_emscripten_bind_rcConfig_get_maxEdgeLen_0,_emscripten_bind_rcConfig_set_maxEdgeLen_1,_emscripten_bind_rcConfig_get_maxSimplificationError_0,_emscripten_bind_rcConfig_set_maxSimplificationError_1,_emscripten_bind_rcConfig_get_minRegionArea_0,_emscripten_bind_rcConfig_set_minRegionArea_1,_emscripten_bind_rcConfig_get_mergeRegionArea_0,_emscripten_bind_rcConfig_set_mergeRegionArea_1,_emscripten_bind_rcConfig_get_maxVertsPerPoly_0,_emscripten_bind_rcConfig_set_maxVertsPerPoly_1,_emscripten_bind_rcConfig_get_detailSampleDist_0,_emscripten_bind_rcConfig_set_detailSampleDist_1,_emscripten_bind_rcConfig_get_detailSampleMaxError_0,_emscripten_bind_rcConfig_set_detailSampleMaxError_1,_emscripten_bind_rcConfig___destroy___0,_emscripten_bind_dtMeshHeader_get_magic_0,_emscripten_bind_dtMeshHeader_set_magic_1,_emscripten_bind_dtMeshHeader_get_version_0,_emscripten_bind_dtMeshHeader_set_version_1,_emscripten_bind_dtMeshHeader_get_x_0,_emscripten_bind_dtMeshHeader_set_x_1,_emscripten_bind_dtMeshHeader_get_y_0,_emscripten_bind_dtMeshHeader_set_y_1,_emscripten_bind_dtMeshHeader_get_layer_0,_emscripten_bind_dtMeshHeader_set_layer_1,_emscripten_bind_dtMeshHeader_get_userId_0,_emscripten_bind_dtMeshHeader_set_userId_1,_emscripten_bind_dtMeshHeader_get_polyCount_0,_emscripten_bind_dtMeshHeader_set_polyCount_1,_emscripten_bind_dtMeshHeader_get_vertCount_0,_emscripten_bind_dtMeshHeader_set_vertCount_1,_emscripten_bind_dtMeshHeader_get_maxLinkCount_0,_emscripten_bind_dtMeshHeader_set_maxLinkCount_1,_emscripten_bind_dtMeshHeader_get_detailMeshCount_0,_emscripten_bind_dtMeshHeader_set_detailMeshCount_1,_emscripten_bind_dtMeshHeader_get_detailVertCount_0,_emscripten_bind_dtMeshHeader_set_detailVertCount_1,_emscripten_bind_dtMeshHeader_get_detailTriCount_0,_emscripten_bind_dtMeshHeader_set_detailTriCount_1,_emscripten_bind_dtMeshHeader_get_bvNodeCount_0,_emscripten_bind_dtMeshHeader_set_bvNodeCount_1,_emscripten_bind_dtMeshHeader_get_offMeshConCount_0,_emscripten_bind_dtMeshHeader_set_offMeshConCount_1,_emscripten_bind_dtMeshHeader_get_offMeshBase_0,_emscripten_bind_dtMeshHeader_set_offMeshBase_1,_emscripten_bind_dtMeshHeader_get_walkableHeight_0,_emscripten_bind_dtMeshHeader_set_walkableHeight_1,_emscripten_bind_dtMeshHeader_get_walkableRadius_0,_emscripten_bind_dtMeshHeader_set_walkableRadius_1,_emscripten_bind_dtMeshHeader_get_walkableClimb_0,_emscripten_bind_dtMeshHeader_set_walkableClimb_1,_emscripten_bind_dtMeshHeader_get_bmin_1,_emscripten_bind_dtMeshHeader_set_bmin_2,_emscripten_bind_dtMeshHeader_get_bmax_1,_emscripten_bind_dtMeshHeader_set_bmax_2,_emscripten_bind_dtMeshHeader_get_bvQuantFactor_0,_emscripten_bind_dtMeshHeader_set_bvQuantFactor_1,_emscripten_bind_dtMeshHeader___destroy___0,_emscripten_bind_dtPoly_setArea_1,_emscripten_bind_dtPoly_setType_1,_emscripten_bind_dtPoly_getType_0,_emscripten_bind_dtPoly_getArea_0,_emscripten_bind_dtPoly_get_firstLink_0,_emscripten_bind_dtPoly_set_firstLink_1,_emscripten_bind_dtPoly_get_verts_1,_emscripten_bind_dtPoly_set_verts_2,_emscripten_bind_dtPoly_get_neis_1,_emscripten_bind_dtPoly_set_neis_2,_emscripten_bind_dtPoly_get_flags_0,_emscripten_bind_dtPoly_set_flags_1,_emscripten_bind_dtPoly_get_vertCount_0,_emscripten_bind_dtPoly_set_vertCount_1,_emscripten_bind_dtPoly_get_areaAndtype_0,_emscripten_bind_dtPoly_set_areaAndtype_1,_emscripten_bind_dtPoly___destroy___0,_emscripten_bind_dtPolyDetail_get_vertBase_0,_emscripten_bind_dtPolyDetail_set_vertBase_1,_emscripten_bind_dtPolyDetail_get_triBase_0,_emscripten_bind_dtPolyDetail_set_triBase_1,_emscripten_bind_dtPolyDetail_get_vertCount_0,_emscripten_bind_dtPolyDetail_set_vertCount_1,_emscripten_bind_dtPolyDetail_get_triCount_0,_emscripten_bind_dtPolyDetail_set_triCount_1,_emscripten_bind_dtPolyDetail___destroy___0,_emscripten_bind_dtLink_get_ref_0,_emscripten_bind_dtLink_set_ref_1,_emscripten_bind_dtLink_get_next_0,_emscripten_bind_dtLink_set_next_1,_emscripten_bind_dtLink_get_edge_0,_emscripten_bind_dtLink_set_edge_1,_emscripten_bind_dtLink_get_side_0,_emscripten_bind_dtLink_set_side_1,_emscripten_bind_dtLink_get_bmin_0,_emscripten_bind_dtLink_set_bmin_1,_emscripten_bind_dtLink_get_bmax_0,_emscripten_bind_dtLink_set_bmax_1,_emscripten_bind_dtLink___destroy___0,_emscripten_bind_dtBVNode_get_bmin_1,_emscripten_bind_dtBVNode_set_bmin_2,_emscripten_bind_dtBVNode_get_bmax_1,_emscripten_bind_dtBVNode_set_bmax_2,_emscripten_bind_dtBVNode_get_i_0,_emscripten_bind_dtBVNode_set_i_1,_emscripten_bind_dtBVNode___destroy___0,_emscripten_bind_dtOffMeshConnection_get_pos_1,_emscripten_bind_dtOffMeshConnection_set_pos_2,_emscripten_bind_dtOffMeshConnection_get_rad_0,_emscripten_bind_dtOffMeshConnection_set_rad_1,_emscripten_bind_dtOffMeshConnection_get_poly_0,_emscripten_bind_dtOffMeshConnection_set_poly_1,_emscripten_bind_dtOffMeshConnection_get_flags_0,_emscripten_bind_dtOffMeshConnection_set_flags_1,_emscripten_bind_dtOffMeshConnection_get_side_0,_emscripten_bind_dtOffMeshConnection_set_side_1,_emscripten_bind_dtOffMeshConnection_get_userId_0,_emscripten_bind_dtOffMeshConnection_set_userId_1,_emscripten_bind_dtOffMeshConnection___destroy___0,_emscripten_bind_dtMeshTile_get_salt_0,_emscripten_bind_dtMeshTile_set_salt_1,_emscripten_bind_dtMeshTile_get_linksFreeList_0,_emscripten_bind_dtMeshTile_set_linksFreeList_1,_emscripten_bind_dtMeshTile_get_header_0,_emscripten_bind_dtMeshTile_set_header_1,_emscripten_bind_dtMeshTile_get_polys_1,_emscripten_bind_dtMeshTile_set_polys_2,_emscripten_bind_dtMeshTile_get_verts_1,_emscripten_bind_dtMeshTile_set_verts_2,_emscripten_bind_dtMeshTile_get_links_1,_emscripten_bind_dtMeshTile_set_links_2,_emscripten_bind_dtMeshTile_get_detailMeshes_1,_emscripten_bind_dtMeshTile_set_detailMeshes_2,_emscripten_bind_dtMeshTile_get_detailVerts_1,_emscripten_bind_dtMeshTile_set_detailVerts_2,_emscripten_bind_dtMeshTile_get_detailTris_1,_emscripten_bind_dtMeshTile_set_detailTris_2,_emscripten_bind_dtMeshTile_get_bvTree_1,_emscripten_bind_dtMeshTile_set_bvTree_2,_emscripten_bind_dtMeshTile_get_offMeshCons_1,_emscripten_bind_dtMeshTile_set_offMeshCons_2,_emscripten_bind_dtMeshTile_get_data_1,_emscripten_bind_dtMeshTile_set_data_2,_emscripten_bind_dtMeshTile_get_dataSize_0,_emscripten_bind_dtMeshTile_set_dataSize_1,_emscripten_bind_dtMeshTile_get_flags_0,_emscripten_bind_dtMeshTile_set_flags_1,_emscripten_bind_dtMeshTile_get_next_0,_emscripten_bind_dtMeshTile_set_next_1,_emscripten_bind_dtMeshTile___destroy___0,_emscripten_bind_dtNavMesh___destroy___0,_emscripten_bind_dtNavMeshCreateParams_dtNavMeshCreateParams_0,_emscripten_bind_dtNavMeshCreateParams_get_verts_1,_emscripten_bind_dtNavMeshCreateParams_get_vertCount_0,_emscripten_bind_dtNavMeshCreateParams_set_vertCount_1,_emscripten_bind_dtNavMeshCreateParams_get_polys_1,_emscripten_bind_dtNavMeshCreateParams_get_polyFlags_1,_emscripten_bind_dtNavMeshCreateParams_get_polyAreas_1,_emscripten_bind_dtNavMeshCreateParams_get_polyCount_0,_emscripten_bind_dtNavMeshCreateParams_set_polyCount_1,_emscripten_bind_dtNavMeshCreateParams_get_nvp_0,_emscripten_bind_dtNavMeshCreateParams_set_nvp_1,_emscripten_bind_dtNavMeshCreateParams_get_detailMeshes_1,_emscripten_bind_dtNavMeshCreateParams_get_detailVerts_1,_emscripten_bind_dtNavMeshCreateParams_get_detailVertsCount_0,_emscripten_bind_dtNavMeshCreateParams_set_detailVertsCount_1,_emscripten_bind_dtNavMeshCreateParams_get_detailTris_1,_emscripten_bind_dtNavMeshCreateParams_get_detailTriCount_0,_emscripten_bind_dtNavMeshCreateParams_set_detailTriCount_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConVerts_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConRad_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConFlags_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConAreas_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConDir_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConUserID_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConCount_0,_emscripten_bind_dtNavMeshCreateParams_set_offMeshConCount_1,_emscripten_bind_dtNavMeshCreateParams_get_userId_0,_emscripten_bind_dtNavMeshCreateParams_set_userId_1,_emscripten_bind_dtNavMeshCreateParams_get_tileX_0,_emscripten_bind_dtNavMeshCreateParams_set_tileX_1,_emscripten_bind_dtNavMeshCreateParams_get_tileY_0,_emscripten_bind_dtNavMeshCreateParams_set_tileY_1,_emscripten_bind_dtNavMeshCreateParams_get_tileLayer_0,_emscripten_bind_dtNavMeshCreateParams_set_tileLayer_1,_emscripten_bind_dtNavMeshCreateParams_get_bmin_1,_emscripten_bind_dtNavMeshCreateParams_set_bmin_2,_emscripten_bind_dtNavMeshCreateParams_get_bmax_1,_emscripten_bind_dtNavMeshCreateParams_set_bmax_2,_emscripten_bind_dtNavMeshCreateParams_get_walkableHeight_0,_emscripten_bind_dtNavMeshCreateParams_set_walkableHeight_1,_emscripten_bind_dtNavMeshCreateParams_get_walkableRadius_0,_emscripten_bind_dtNavMeshCreateParams_set_walkableRadius_1,_emscripten_bind_dtNavMeshCreateParams_get_walkableClimb_0,_emscripten_bind_dtNavMeshCreateParams_set_walkableClimb_1,_emscripten_bind_dtNavMeshCreateParams_get_cs_0,_emscripten_bind_dtNavMeshCreateParams_set_cs_1,_emscripten_bind_dtNavMeshCreateParams_get_ch_0,_emscripten_bind_dtNavMeshCreateParams_set_ch_1,_emscripten_bind_dtNavMeshCreateParams_get_buildBvTree_0,_emscripten_bind_dtNavMeshCreateParams_set_buildBvTree_1,_emscripten_bind_dtNavMeshCreateParams___destroy___0,_emscripten_bind_dtObstacleRef___destroy___0,_emscripten_bind_dtCompressedTileRef___destroy___0,_emscripten_bind_dtNavMeshParams_dtNavMeshParams_0,_emscripten_bind_dtNavMeshParams_get_orig_1,_emscripten_bind_dtNavMeshParams_set_orig_2,_emscripten_bind_dtNavMeshParams_get_tileWidth_0,_emscripten_bind_dtNavMeshParams_set_tileWidth_1,_emscripten_bind_dtNavMeshParams_get_tileHeight_0,_emscripten_bind_dtNavMeshParams_set_tileHeight_1,_emscripten_bind_dtNavMeshParams_get_maxTiles_0,_emscripten_bind_dtNavMeshParams_set_maxTiles_1,_emscripten_bind_dtNavMeshParams_get_maxPolys_0,_emscripten_bind_dtNavMeshParams_set_maxPolys_1,_emscripten_bind_dtNavMeshParams___destroy___0,_emscripten_bind_dtCrowdAgentParams_dtCrowdAgentParams_0,_emscripten_bind_dtCrowdAgentParams_get_radius_0,_emscripten_bind_dtCrowdAgentParams_set_radius_1,_emscripten_bind_dtCrowdAgentParams_get_height_0,_emscripten_bind_dtCrowdAgentParams_set_height_1,_emscripten_bind_dtCrowdAgentParams_get_maxAcceleration_0,_emscripten_bind_dtCrowdAgentParams_set_maxAcceleration_1,_emscripten_bind_dtCrowdAgentParams_get_maxSpeed_0,_emscripten_bind_dtCrowdAgentParams_set_maxSpeed_1,_emscripten_bind_dtCrowdAgentParams_get_collisionQueryRange_0,_emscripten_bind_dtCrowdAgentParams_set_collisionQueryRange_1,_emscripten_bind_dtCrowdAgentParams_get_pathOptimizationRange_0,_emscripten_bind_dtCrowdAgentParams_set_pathOptimizationRange_1,_emscripten_bind_dtCrowdAgentParams_get_separationWeight_0,_emscripten_bind_dtCrowdAgentParams_set_separationWeight_1,_emscripten_bind_dtCrowdAgentParams_get_updateFlags_0,_emscripten_bind_dtCrowdAgentParams_set_updateFlags_1,_emscripten_bind_dtCrowdAgentParams_get_obstacleAvoidanceType_0,_emscripten_bind_dtCrowdAgentParams_set_obstacleAvoidanceType_1,_emscripten_bind_dtCrowdAgentParams_get_queryFilterType_0,_emscripten_bind_dtCrowdAgentParams_set_queryFilterType_1,_emscripten_bind_dtCrowdAgentParams_get_userData_0,_emscripten_bind_dtCrowdAgentParams_set_userData_1,_emscripten_bind_dtCrowdAgentParams___destroy___0,_emscripten_bind_rcSpan_get_smin_0,_emscripten_bind_rcSpan_set_smin_1,_emscripten_bind_rcSpan_get_smax_0,_emscripten_bind_rcSpan_set_smax_1,_emscripten_bind_rcSpan_get_area_0,_emscripten_bind_rcSpan_set_area_1,_emscripten_bind_rcSpan_get_next_0,_emscripten_bind_rcSpan_set_next_1,_emscripten_bind_rcSpan___destroy___0,_emscripten_bind_rcSpanPool_get_next_0,_emscripten_bind_rcSpanPool_set_next_1,_emscripten_bind_rcSpanPool_get_items_1,_emscripten_bind_rcSpanPool_set_items_2,_emscripten_bind_rcSpanPool___destroy___0,_emscripten_bind_rcHeightfield_get_width_0,_emscripten_bind_rcHeightfield_set_width_1,_emscripten_bind_rcHeightfield_get_height_0,_emscripten_bind_rcHeightfield_set_height_1,_emscripten_bind_rcHeightfield_get_bmin_1,_emscripten_bind_rcHeightfield_set_bmin_2,_emscripten_bind_rcHeightfield_get_bmax_1,_emscripten_bind_rcHeightfield_set_bmax_2,_emscripten_bind_rcHeightfield_get_cs_0,_emscripten_bind_rcHeightfield_set_cs_1,_emscripten_bind_rcHeightfield_get_ch_0,_emscripten_bind_rcHeightfield_set_ch_1,_emscripten_bind_rcHeightfield_get_spans_1,_emscripten_bind_rcHeightfield_set_spans_2,_emscripten_bind_rcHeightfield_get_pools_1,_emscripten_bind_rcHeightfield_set_pools_2,_emscripten_bind_rcHeightfield_get_freelist_1,_emscripten_bind_rcHeightfield_set_freelist_2,_emscripten_bind_rcHeightfield___destroy___0,_emscripten_bind_rcCompactCell_get_index_0,_emscripten_bind_rcCompactCell_set_index_1,_emscripten_bind_rcCompactCell_get_count_0,_emscripten_bind_rcCompactCell_set_count_1,_emscripten_bind_rcCompactCell___destroy___0,_emscripten_bind_rcCompactSpan_get_y_0,_emscripten_bind_rcCompactSpan_set_y_1,_emscripten_bind_rcCompactSpan_get_reg_0,_emscripten_bind_rcCompactSpan_set_reg_1,_emscripten_bind_rcCompactSpan_get_con_0,_emscripten_bind_rcCompactSpan_set_con_1,_emscripten_bind_rcCompactSpan_get_h_0,_emscripten_bind_rcCompactSpan_set_h_1,_emscripten_bind_rcCompactSpan___destroy___0,_emscripten_bind_rcCompactHeightfield_get_width_0,_emscripten_bind_rcCompactHeightfield_set_width_1,_emscripten_bind_rcCompactHeightfield_get_height_0,_emscripten_bind_rcCompactHeightfield_set_height_1,_emscripten_bind_rcCompactHeightfield_get_spanCount_0,_emscripten_bind_rcCompactHeightfield_set_spanCount_1,_emscripten_bind_rcCompactHeightfield_get_walkableHeight_0,_emscripten_bind_rcCompactHeightfield_set_walkableHeight_1,_emscripten_bind_rcCompactHeightfield_get_walkableClimb_0,_emscripten_bind_rcCompactHeightfield_set_walkableClimb_1,_emscripten_bind_rcCompactHeightfield_get_borderSize_0,_emscripten_bind_rcCompactHeightfield_set_borderSize_1,_emscripten_bind_rcCompactHeightfield_get_maxDistance_0,_emscripten_bind_rcCompactHeightfield_set_maxDistance_1,_emscripten_bind_rcCompactHeightfield_get_maxRegions_0,_emscripten_bind_rcCompactHeightfield_set_maxRegions_1,_emscripten_bind_rcCompactHeightfield_get_bmin_1,_emscripten_bind_rcCompactHeightfield_set_bmin_2,_emscripten_bind_rcCompactHeightfield_get_bmax_1,_emscripten_bind_rcCompactHeightfield_set_bmax_2,_emscripten_bind_rcCompactHeightfield_get_cs_0,_emscripten_bind_rcCompactHeightfield_set_cs_1,_emscripten_bind_rcCompactHeightfield_get_ch_0,_emscripten_bind_rcCompactHeightfield_set_ch_1,_emscripten_bind_rcCompactHeightfield_get_cells_1,_emscripten_bind_rcCompactHeightfield_set_cells_2,_emscripten_bind_rcCompactHeightfield_get_spans_1,_emscripten_bind_rcCompactHeightfield_set_spans_2,_emscripten_bind_rcCompactHeightfield_get_dist_1,_emscripten_bind_rcCompactHeightfield_set_dist_2,_emscripten_bind_rcCompactHeightfield_get_areas_1,_emscripten_bind_rcCompactHeightfield_set_areas_2,_emscripten_bind_rcCompactHeightfield___destroy___0,_emscripten_bind_rcContour_get_verts_1,_emscripten_bind_rcContour_set_verts_2,_emscripten_bind_rcContour_get_nverts_0,_emscripten_bind_rcContour_set_nverts_1,_emscripten_bind_rcContour_get_rverts_1,_emscripten_bind_rcContour_set_rverts_2,_emscripten_bind_rcContour_get_nrverts_0,_emscripten_bind_rcContour_set_nrverts_1,_emscripten_bind_rcContour_get_reg_0,_emscripten_bind_rcContour_set_reg_1,_emscripten_bind_rcContour_get_area_0,_emscripten_bind_rcContour_set_area_1,_emscripten_bind_rcContour___destroy___0,_emscripten_bind_rcContourSet_get_conts_1,_emscripten_bind_rcContourSet_set_conts_2,_emscripten_bind_rcContourSet_get_nconts_0,_emscripten_bind_rcContourSet_set_nconts_1,_emscripten_bind_rcContourSet_get_bmin_1,_emscripten_bind_rcContourSet_set_bmin_2,_emscripten_bind_rcContourSet_get_bmax_1,_emscripten_bind_rcContourSet_set_bmax_2,_emscripten_bind_rcContourSet_get_cs_0,_emscripten_bind_rcContourSet_set_cs_1,_emscripten_bind_rcContourSet_get_ch_0,_emscripten_bind_rcContourSet_set_ch_1,_emscripten_bind_rcContourSet_get_width_0,_emscripten_bind_rcContourSet_set_width_1,_emscripten_bind_rcContourSet_get_height_0,_emscripten_bind_rcContourSet_set_height_1,_emscripten_bind_rcContourSet_get_borderSize_0,_emscripten_bind_rcContourSet_set_borderSize_1,_emscripten_bind_rcContourSet_get_maxError_0,_emscripten_bind_rcContourSet_set_maxError_1,_emscripten_bind_rcContourSet___destroy___0,_emscripten_bind_rcHeightfieldLayer_get_bmin_1,_emscripten_bind_rcHeightfieldLayer_set_bmin_2,_emscripten_bind_rcHeightfieldLayer_get_bmax_1,_emscripten_bind_rcHeightfieldLayer_set_bmax_2,_emscripten_bind_rcHeightfieldLayer_get_cs_0,_emscripten_bind_rcHeightfieldLayer_set_cs_1,_emscripten_bind_rcHeightfieldLayer_get_ch_0,_emscripten_bind_rcHeightfieldLayer_set_ch_1,_emscripten_bind_rcHeightfieldLayer_get_width_0,_emscripten_bind_rcHeightfieldLayer_set_width_1,_emscripten_bind_rcHeightfieldLayer_get_height_0,_emscripten_bind_rcHeightfieldLayer_set_height_1,_emscripten_bind_rcHeightfieldLayer_get_minx_0,_emscripten_bind_rcHeightfieldLayer_set_minx_1,_emscripten_bind_rcHeightfieldLayer_get_maxx_0,_emscripten_bind_rcHeightfieldLayer_set_maxx_1,_emscripten_bind_rcHeightfieldLayer_get_miny_0,_emscripten_bind_rcHeightfieldLayer_set_miny_1,_emscripten_bind_rcHeightfieldLayer_get_maxy_0,_emscripten_bind_rcHeightfieldLayer_set_maxy_1,_emscripten_bind_rcHeightfieldLayer_get_hmin_0,_emscripten_bind_rcHeightfieldLayer_set_hmin_1,_emscripten_bind_rcHeightfieldLayer_get_hmax_0,_emscripten_bind_rcHeightfieldLayer_set_hmax_1,_emscripten_bind_rcHeightfieldLayer_get_heights_1,_emscripten_bind_rcHeightfieldLayer_set_heights_2,_emscripten_bind_rcHeightfieldLayer_get_areas_1,_emscripten_bind_rcHeightfieldLayer_set_areas_2,_emscripten_bind_rcHeightfieldLayer_get_cons_1,_emscripten_bind_rcHeightfieldLayer_set_cons_2,_emscripten_bind_rcHeightfieldLayer___destroy___0,_emscripten_bind_rcHeightfieldLayerSet_get_layers_1,_emscripten_bind_rcHeightfieldLayerSet_set_layers_2,_emscripten_bind_rcHeightfieldLayerSet_get_nlayers_0,_emscripten_bind_rcHeightfieldLayerSet_set_nlayers_1,_emscripten_bind_rcHeightfieldLayerSet___destroy___0,_emscripten_bind_rcPolyMesh_get_verts_1,_emscripten_bind_rcPolyMesh_set_verts_2,_emscripten_bind_rcPolyMesh_get_polys_1,_emscripten_bind_rcPolyMesh_set_polys_2,_emscripten_bind_rcPolyMesh_get_regs_1,_emscripten_bind_rcPolyMesh_set_regs_2,_emscripten_bind_rcPolyMesh_get_flags_1,_emscripten_bind_rcPolyMesh_set_flags_2,_emscripten_bind_rcPolyMesh_get_areas_1,_emscripten_bind_rcPolyMesh_set_areas_2,_emscripten_bind_rcPolyMesh_get_nverts_0,_emscripten_bind_rcPolyMesh_set_nverts_1,_emscripten_bind_rcPolyMesh_get_npolys_0,_emscripten_bind_rcPolyMesh_set_npolys_1,_emscripten_bind_rcPolyMesh_get_maxpolys_0,_emscripten_bind_rcPolyMesh_set_maxpolys_1,_emscripten_bind_rcPolyMesh_get_nvp_0,_emscripten_bind_rcPolyMesh_set_nvp_1,_emscripten_bind_rcPolyMesh_get_bmin_1,_emscripten_bind_rcPolyMesh_set_bmin_2,_emscripten_bind_rcPolyMesh_get_bmax_1,_emscripten_bind_rcPolyMesh_set_bmax_2,_emscripten_bind_rcPolyMesh_get_cs_0,_emscripten_bind_rcPolyMesh_set_cs_1,_emscripten_bind_rcPolyMesh_get_ch_0,_emscripten_bind_rcPolyMesh_set_ch_1,_emscripten_bind_rcPolyMesh_get_borderSize_0,_emscripten_bind_rcPolyMesh_set_borderSize_1,_emscripten_bind_rcPolyMesh_get_maxEdgeError_0,_emscripten_bind_rcPolyMesh_set_maxEdgeError_1,_emscripten_bind_rcPolyMesh___destroy___0,_emscripten_bind_rcPolyMeshDetail_get_meshes_1,_emscripten_bind_rcPolyMeshDetail_set_meshes_2,_emscripten_bind_rcPolyMeshDetail_get_verts_1,_emscripten_bind_rcPolyMeshDetail_set_verts_2,_emscripten_bind_rcPolyMeshDetail_get_tris_1,_emscripten_bind_rcPolyMeshDetail_set_tris_2,_emscripten_bind_rcPolyMeshDetail_get_nmeshes_0,_emscripten_bind_rcPolyMeshDetail_set_nmeshes_1,_emscripten_bind_rcPolyMeshDetail_get_nverts_0,_emscripten_bind_rcPolyMeshDetail_set_nverts_1,_emscripten_bind_rcPolyMeshDetail_get_ntris_0,_emscripten_bind_rcPolyMeshDetail_set_ntris_1,_emscripten_bind_rcPolyMeshDetail___destroy___0,_emscripten_bind_Vec3_Vec3_0,_emscripten_bind_Vec3_Vec3_3,_emscripten_bind_Vec3_get_x_0,_emscripten_bind_Vec3_set_x_1,_emscripten_bind_Vec3_get_y_0,_emscripten_bind_Vec3_set_y_1,_emscripten_bind_Vec3_get_z_0,_emscripten_bind_Vec3_set_z_1,_emscripten_bind_Vec3___destroy___0,_emscripten_bind_NavMeshRemoveTileResult_get_status_0,_emscripten_bind_NavMeshRemoveTileResult_set_status_1,_emscripten_bind_NavMeshRemoveTileResult_get_data_1,_emscripten_bind_NavMeshRemoveTileResult_set_data_2,_emscripten_bind_NavMeshRemoveTileResult_get_dataSize_0,_emscripten_bind_NavMeshRemoveTileResult_set_dataSize_1,_emscripten_bind_NavMeshRemoveTileResult___destroy___0,_emscripten_bind_NavMeshCalcTileLocResult_get_tileX_0,_emscripten_bind_NavMeshCalcTileLocResult_set_tileX_1,_emscripten_bind_NavMeshCalcTileLocResult_get_tileY_0,_emscripten_bind_NavMeshCalcTileLocResult_set_tileY_1,_emscripten_bind_NavMeshCalcTileLocResult___destroy___0,_emscripten_bind_NavMeshGetTilesAtResult_get_tiles_1,_emscripten_bind_NavMeshGetTilesAtResult_get_tileCount_0,_emscripten_bind_NavMeshGetTilesAtResult_set_tileCount_1,_emscripten_bind_NavMeshGetTilesAtResult___destroy___0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_status_0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_status_1,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_tile_0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_tile_1,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_poly_0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_poly_1,_emscripten_bind_NavMeshGetTileAndPolyByRefResult___destroy___0,_emscripten_bind_NavMeshStoreTileStateResult_get_status_0,_emscripten_bind_NavMeshStoreTileStateResult_set_status_1,_emscripten_bind_NavMeshStoreTileStateResult_get_data_1,_emscripten_bind_NavMeshStoreTileStateResult_set_data_2,_emscripten_bind_NavMeshStoreTileStateResult_get_dataSize_0,_emscripten_bind_NavMeshStoreTileStateResult_set_dataSize_1,_emscripten_bind_NavMeshStoreTileStateResult___destroy___0,_emscripten_bind_NavMesh_NavMesh_0,_emscripten_bind_NavMesh_NavMesh_1,_emscripten_bind_NavMesh_initSolo_1,_emscripten_bind_NavMesh_initTiled_1,_emscripten_bind_NavMesh_addTile_4,_emscripten_bind_NavMesh_decodePolyId_4,_emscripten_bind_NavMesh_encodePolyId_3,_emscripten_bind_NavMesh_removeTile_1,_emscripten_bind_NavMesh_getNavMesh_0,_emscripten_bind_NavMesh_calcTileLoc_1,_emscripten_bind_NavMesh_getTileAt_3,_emscripten_bind_NavMesh_getTilesAt_3,_emscripten_bind_NavMesh_getTileRefAt_3,_emscripten_bind_NavMesh_getTileRef_1,_emscripten_bind_NavMesh_getTileByRef_1,_emscripten_bind_NavMesh_getMaxTiles_0,_emscripten_bind_NavMesh_getTile_1,_emscripten_bind_NavMesh_getTileAndPolyByRef_1,_emscripten_bind_NavMesh_getTileAndPolyByRefUnsafe_1,_emscripten_bind_NavMesh_isValidPolyRef_1,_emscripten_bind_NavMesh_getPolyRefBase_1,_emscripten_bind_NavMesh_getOffMeshConnectionPolyEndPoints_4,_emscripten_bind_NavMesh_getOffMeshConnectionByRef_1,_emscripten_bind_NavMesh_setPolyFlags_2,_emscripten_bind_NavMesh_getPolyFlags_2,_emscripten_bind_NavMesh_setPolyArea_2,_emscripten_bind_NavMesh_getPolyArea_2,_emscripten_bind_NavMesh_getTileStateSize_1,_emscripten_bind_NavMesh_storeTileState_2,_emscripten_bind_NavMesh_restoreTileState_3,_emscripten_bind_NavMesh_destroy_0,_emscripten_bind_NavMesh_get_m_navMesh_0,_emscripten_bind_NavMesh_set_m_navMesh_1,_emscripten_bind_NavMesh___destroy___0,_emscripten_bind_FastRand_getSeed_0,_emscripten_bind_FastRand_setSeed_1,_emscripten_bind_FastRand___destroy___0,_emscripten_bind_dtRaycastHit_dtRaycastHit_0,_emscripten_bind_dtRaycastHit_get_t_0,_emscripten_bind_dtRaycastHit_set_t_1,_emscripten_bind_dtRaycastHit_get_hitNormal_1,_emscripten_bind_dtRaycastHit_set_hitNormal_2,_emscripten_bind_dtRaycastHit_get_hitEdgeIndex_0,_emscripten_bind_dtRaycastHit_set_hitEdgeIndex_1,_emscripten_bind_dtRaycastHit_get_path_1,_emscripten_bind_dtRaycastHit_set_path_2,_emscripten_bind_dtRaycastHit_get_pathCount_0,_emscripten_bind_dtRaycastHit_set_pathCount_1,_emscripten_bind_dtRaycastHit_get_maxPath_0,_emscripten_bind_dtRaycastHit_set_maxPath_1,_emscripten_bind_dtRaycastHit_get_pathCost_0,_emscripten_bind_dtRaycastHit_set_pathCost_1,_emscripten_bind_dtRaycastHit___destroy___0,_emscripten_bind_NavMeshQuery_NavMeshQuery_0,_emscripten_bind_NavMeshQuery_NavMeshQuery_1,_emscripten_bind_NavMeshQuery_init_2,_emscripten_bind_NavMeshQuery_findPath_7,_emscripten_bind_NavMeshQuery_closestPointOnPoly_4,_emscripten_bind_NavMeshQuery_findClosestPoint_6,_emscripten_bind_NavMeshQuery_findStraightPath_9,_emscripten_bind_NavMeshQuery_findNearestPoly_6,_emscripten_bind_NavMeshQuery_findPolysAroundCircle_9,_emscripten_bind_NavMeshQuery_queryPolygons_6,_emscripten_bind_NavMeshQuery_raycast_7,_emscripten_bind_NavMeshQuery_findRandomPointAroundCircle_6,_emscripten_bind_NavMeshQuery_moveAlongSurface_7,_emscripten_bind_NavMeshQuery_findRandomPoint_3,_emscripten_bind_NavMeshQuery_getPolyHeight_3,_emscripten_bind_NavMeshQuery_destroy_0,_emscripten_bind_NavMeshQuery_get_m_navQuery_0,_emscripten_bind_NavMeshQuery_set_m_navQuery_1,_emscripten_bind_NavMeshQuery___destroy___0,_emscripten_bind_dtTileCacheParams_dtTileCacheParams_0,_emscripten_bind_dtTileCacheParams_get_orig_1,_emscripten_bind_dtTileCacheParams_set_orig_2,_emscripten_bind_dtTileCacheParams_get_cs_0,_emscripten_bind_dtTileCacheParams_set_cs_1,_emscripten_bind_dtTileCacheParams_get_ch_0,_emscripten_bind_dtTileCacheParams_set_ch_1,_emscripten_bind_dtTileCacheParams_get_width_0,_emscripten_bind_dtTileCacheParams_set_width_1,_emscripten_bind_dtTileCacheParams_get_height_0,_emscripten_bind_dtTileCacheParams_set_height_1,_emscripten_bind_dtTileCacheParams_get_walkableHeight_0,_emscripten_bind_dtTileCacheParams_set_walkableHeight_1,_emscripten_bind_dtTileCacheParams_get_walkableRadius_0,_emscripten_bind_dtTileCacheParams_set_walkableRadius_1,_emscripten_bind_dtTileCacheParams_get_walkableClimb_0,_emscripten_bind_dtTileCacheParams_set_walkableClimb_1,_emscripten_bind_dtTileCacheParams_get_maxSimplificationError_0,_emscripten_bind_dtTileCacheParams_set_maxSimplificationError_1,_emscripten_bind_dtTileCacheParams_get_maxTiles_0,_emscripten_bind_dtTileCacheParams_set_maxTiles_1,_emscripten_bind_dtTileCacheParams_get_maxObstacles_0,_emscripten_bind_dtTileCacheParams_set_maxObstacles_1,_emscripten_bind_dtTileCacheParams___destroy___0,_emscripten_bind_TileCacheAddTileResult_get_status_0,_emscripten_bind_TileCacheAddTileResult_set_status_1,_emscripten_bind_TileCacheAddTileResult_get_tileRef_0,_emscripten_bind_TileCacheAddTileResult_set_tileRef_1,_emscripten_bind_TileCacheAddTileResult___destroy___0,_emscripten_bind_TileCacheUpdateResult_get_status_0,_emscripten_bind_TileCacheUpdateResult_set_status_1,_emscripten_bind_TileCacheUpdateResult_get_upToDate_0,_emscripten_bind_TileCacheUpdateResult_set_upToDate_1,_emscripten_bind_TileCacheUpdateResult___destroy___0,_emscripten_bind_TileCacheAddObstacleResult_get_status_0,_emscripten_bind_TileCacheAddObstacleResult_set_status_1,_emscripten_bind_TileCacheAddObstacleResult_get_ref_0,_emscripten_bind_TileCacheAddObstacleResult_set_ref_1,_emscripten_bind_TileCacheAddObstacleResult___destroy___0,_emscripten_bind_RecastFastLZCompressor_RecastFastLZCompressor_0,_emscripten_bind_RecastFastLZCompressor___destroy___0,_emscripten_bind_TileCacheMeshProcess_TileCacheMeshProcess_0,_emscripten_bind_TileCacheMeshProcess_process_3,_emscripten_bind_TileCacheMeshProcess___destroy___0,_emscripten_bind_RecastLinearAllocator_RecastLinearAllocator_1,_emscripten_bind_RecastLinearAllocator___destroy___0,_emscripten_bind_TileCache_TileCache_0,_emscripten_bind_TileCache_init_4,_emscripten_bind_TileCache_addTile_2,_emscripten_bind_TileCache_buildNavMeshTile_2,_emscripten_bind_TileCache_buildNavMeshTilesAt_3,_emscripten_bind_TileCache_update_1,_emscripten_bind_TileCache_addCylinderObstacle_3,_emscripten_bind_TileCache_addBoxObstacle_3,_emscripten_bind_TileCache_removeObstacle_1,_emscripten_bind_TileCache_destroy_0,_emscripten_bind_TileCache___destroy___0,_emscripten_bind_CrowdUtils_CrowdUtils_0,_emscripten_bind_CrowdUtils_getActiveAgentCount_1,_emscripten_bind_CrowdUtils_overOffMeshConnection_2,_emscripten_bind_CrowdUtils_agentTeleport_5,_emscripten_bind_CrowdUtils___destroy___0,_emscripten_bind_Detour_Detour_0,_emscripten_bind_Detour_statusSucceed_1,_emscripten_bind_Detour_statusFailed_1,_emscripten_bind_Detour_statusInProgress_1,_emscripten_bind_Detour_statusDetail_2,_emscripten_bind_Detour_allocCrowd_0,_emscripten_bind_Detour_freeCrowd_1,_emscripten_bind_Detour_get_FAILURE_0,_emscripten_bind_Detour_get_SUCCESS_0,_emscripten_bind_Detour_get_IN_PROGRESS_0,_emscripten_bind_Detour_get_STATUS_DETAIL_MASK_0,_emscripten_bind_Detour_get_WRONG_MAGIC_0,_emscripten_bind_Detour_get_WRONG_VERSION_0,_emscripten_bind_Detour_get_OUT_OF_MEMORY_0,_emscripten_bind_Detour_get_INVALID_PARAM_0,_emscripten_bind_Detour_get_BUFFER_TOO_SMALL_0,_emscripten_bind_Detour_get_OUT_OF_NODES_0,_emscripten_bind_Detour_get_PARTIAL_RESULT_0,_emscripten_bind_Detour_get_ALREADY_OCCUPIED_0,_emscripten_bind_Detour_get_VERTS_PER_POLYGON_0,_emscripten_bind_Detour_get_NAVMESH_MAGIC_0,_emscripten_bind_Detour_get_NAVMESH_VERSION_0,_emscripten_bind_Detour_get_NAVMESH_STATE_MAGIC_0,_emscripten_bind_Detour_get_NAVMESH_STATE_VERSION_0,_emscripten_bind_Detour_get_TILECACHE_MAGIC_0,_emscripten_bind_Detour_get_TILECACHE_VERSION_0,_emscripten_bind_Detour_get_TILECACHE_NULL_AREA_0,_emscripten_bind_Detour_get_TILECACHE_WALKABLE_AREA_0,_emscripten_bind_Detour_get_TILECACHE_NULL_IDX_0,_emscripten_bind_Detour_get_NULL_LINK_0,_emscripten_bind_Detour_get_EXT_LINK_0,_emscripten_bind_Detour_get_OFFMESH_CON_BIDIR_0,_emscripten_bind_Detour___destroy___0,_emscripten_bind_dtPathCorridor_init_1,_emscripten_bind_dtPathCorridor_reset_2,_emscripten_bind_dtPathCorridor___destroy___0,_emscripten_bind_dtLocalBoundary_reset_0,_emscripten_bind_dtLocalBoundary___destroy___0,_emscripten_bind_dtCrowdNeighbour_dtCrowdNeighbour_0,_emscripten_bind_dtCrowdNeighbour_get_idx_0,_emscripten_bind_dtCrowdNeighbour_set_idx_1,_emscripten_bind_dtCrowdNeighbour_get_dist_0,_emscripten_bind_dtCrowdNeighbour_set_dist_1,_emscripten_bind_dtCrowdNeighbour___destroy___0,_emscripten_bind_dtCrowdAgent_dtCrowdAgent_0,_emscripten_bind_dtCrowdAgent_get_active_0,_emscripten_bind_dtCrowdAgent_set_active_1,_emscripten_bind_dtCrowdAgent_get_state_0,_emscripten_bind_dtCrowdAgent_set_state_1,_emscripten_bind_dtCrowdAgent_get_corridor_0,_emscripten_bind_dtCrowdAgent_get_boundary_0,_emscripten_bind_dtCrowdAgent_get_topologyOptTime_0,_emscripten_bind_dtCrowdAgent_set_topologyOptTime_1,_emscripten_bind_dtCrowdAgent_get_neis_1,_emscripten_bind_dtCrowdAgent_set_neis_2,_emscripten_bind_dtCrowdAgent_get_nneis_0,_emscripten_bind_dtCrowdAgent_set_nneis_1,_emscripten_bind_dtCrowdAgent_get_desiredSpeed_0,_emscripten_bind_dtCrowdAgent_set_desiredSpeed_1,_emscripten_bind_dtCrowdAgent_get_npos_1,_emscripten_bind_dtCrowdAgent_set_npos_2,_emscripten_bind_dtCrowdAgent_get_disp_1,_emscripten_bind_dtCrowdAgent_set_disp_2,_emscripten_bind_dtCrowdAgent_get_dvel_1,_emscripten_bind_dtCrowdAgent_set_dvel_2,_emscripten_bind_dtCrowdAgent_get_nvel_1,_emscripten_bind_dtCrowdAgent_set_nvel_2,_emscripten_bind_dtCrowdAgent_get_vel_1,_emscripten_bind_dtCrowdAgent_set_vel_2,_emscripten_bind_dtCrowdAgent_get_params_0,_emscripten_bind_dtCrowdAgent_set_params_1,_emscripten_bind_dtCrowdAgent_get_cornerVerts_1,_emscripten_bind_dtCrowdAgent_set_cornerVerts_2,_emscripten_bind_dtCrowdAgent_get_cornerFlags_1,_emscripten_bind_dtCrowdAgent_set_cornerFlags_2,_emscripten_bind_dtCrowdAgent_get_ncorners_0,_emscripten_bind_dtCrowdAgent_set_ncorners_1,_emscripten_bind_dtCrowdAgent_get_targetState_0,_emscripten_bind_dtCrowdAgent_set_targetState_1,_emscripten_bind_dtCrowdAgent_get_targetRef_0,_emscripten_bind_dtCrowdAgent_set_targetRef_1,_emscripten_bind_dtCrowdAgent_get_targetPos_1,_emscripten_bind_dtCrowdAgent_set_targetPos_2,_emscripten_bind_dtCrowdAgent_get_targetPathqRef_0,_emscripten_bind_dtCrowdAgent_set_targetPathqRef_1,_emscripten_bind_dtCrowdAgent_get_targetReplan_0,_emscripten_bind_dtCrowdAgent_set_targetReplan_1,_emscripten_bind_dtCrowdAgent_get_targetReplanTime_0,_emscripten_bind_dtCrowdAgent_set_targetReplanTime_1,_emscripten_bind_dtCrowdAgent___destroy___0,_emscripten_bind_dtObstacleAvoidanceParams_dtObstacleAvoidanceParams_0,_emscripten_bind_dtObstacleAvoidanceParams_get_velBias_0,_emscripten_bind_dtObstacleAvoidanceParams_set_velBias_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightDesVel_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightDesVel_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightCurVel_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightCurVel_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightSide_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightSide_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightToi_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightToi_1,_emscripten_bind_dtObstacleAvoidanceParams_get_horizTime_0,_emscripten_bind_dtObstacleAvoidanceParams_set_horizTime_1,_emscripten_bind_dtObstacleAvoidanceParams_get_gridSize_0,_emscripten_bind_dtObstacleAvoidanceParams_set_gridSize_1,_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDivs_0,_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDivs_1,_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveRings_0,_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveRings_1,_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDepth_0,_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDepth_1,_emscripten_bind_dtObstacleAvoidanceParams___destroy___0,_emscripten_bind_dtObstacleAvoidanceDebugData___destroy___0,_emscripten_bind_dtCrowdAgentDebugInfo_dtCrowdAgentDebugInfo_0,_emscripten_bind_dtCrowdAgentDebugInfo_get_idx_0,_emscripten_bind_dtCrowdAgentDebugInfo_set_idx_1,_emscripten_bind_dtCrowdAgentDebugInfo_get_optStart_1,_emscripten_bind_dtCrowdAgentDebugInfo_set_optStart_2,_emscripten_bind_dtCrowdAgentDebugInfo_get_optEnd_1,_emscripten_bind_dtCrowdAgentDebugInfo_set_optEnd_2,_emscripten_bind_dtCrowdAgentDebugInfo_get_vod_0,_emscripten_bind_dtCrowdAgentDebugInfo_set_vod_1,_emscripten_bind_dtCrowdAgentDebugInfo___destroy___0,_emscripten_bind_dtQueryFilter_dtQueryFilter_0,_emscripten_bind_dtQueryFilter_getAreaCost_1,_emscripten_bind_dtQueryFilter_setAreaCost_2,_emscripten_bind_dtQueryFilter_getIncludeFlags_0,_emscripten_bind_dtQueryFilter_setIncludeFlags_1,_emscripten_bind_dtQueryFilter_getExcludeFlags_0,_emscripten_bind_dtQueryFilter_setExcludeFlags_1,_emscripten_bind_dtQueryFilter___destroy___0,_emscripten_bind_dtNavMeshQuery_getAttachedNavMesh_0,_emscripten_bind_dtNavMeshQuery___destroy___0,_emscripten_bind_dtCrowd_dtCrowd_0,_emscripten_bind_dtCrowd_init_3,_emscripten_bind_dtCrowd_setObstacleAvoidanceParams_2,_emscripten_bind_dtCrowd_getObstacleAvoidanceParams_1,_emscripten_bind_dtCrowd_getAgent_1,_emscripten_bind_dtCrowd_getEditableAgent_1,_emscripten_bind_dtCrowd_getAgentCount_0,_emscripten_bind_dtCrowd_addAgent_2,_emscripten_bind_dtCrowd_updateAgentParameters_2,_emscripten_bind_dtCrowd_removeAgent_1,_emscripten_bind_dtCrowd_requestMoveTarget_3,_emscripten_bind_dtCrowd_requestMoveVelocity_2,_emscripten_bind_dtCrowd_resetMoveTarget_1,_emscripten_bind_dtCrowd_update_2,_emscripten_bind_dtCrowd_getFilter_1,_emscripten_bind_dtCrowd_getEditableFilter_1,_emscripten_bind_dtCrowd_getNavMeshQuery_0,_emscripten_bind_dtCrowd___destroy___0,_emscripten_bind_RecastBuildContextJsImpl_RecastBuildContextJsImpl_0,_emscripten_bind_RecastBuildContextJsImpl_resetLog_0,_emscripten_bind_RecastBuildContextJsImpl_log_3,_emscripten_bind_RecastBuildContextJsImpl_resetTimers_0,_emscripten_bind_RecastBuildContextJsImpl_startTimer_1,_emscripten_bind_RecastBuildContextJsImpl_stopTimer_1,_emscripten_bind_RecastBuildContextJsImpl_getAccumulatedTime_1,_emscripten_bind_RecastBuildContextJsImpl___destroy___0,_emscripten_bind_RecastBuildContext_RecastBuildContext_1,_emscripten_bind_RecastBuildContext_enableLog_1,_emscripten_bind_RecastBuildContext_resetLog_0,_emscripten_bind_RecastBuildContext_log_2,_emscripten_bind_RecastBuildContext_enableTimer_1,_emscripten_bind_RecastBuildContext_resetTimers_0,_emscripten_bind_RecastBuildContext_startTimer_1,_emscripten_bind_RecastBuildContext_stopTimer_1,_emscripten_bind_RecastBuildContext_getAccumulatedTime_1,_emscripten_bind_RecastBuildContext_logEnabled_0,_emscripten_bind_RecastBuildContext_timerEnabled_0,_emscripten_bind_RecastBuildContext___destroy___0,_emscripten_bind_RecastCalcBoundsResult_get_bmin_1,_emscripten_bind_RecastCalcBoundsResult_set_bmin_2,_emscripten_bind_RecastCalcBoundsResult_get_bmax_1,_emscripten_bind_RecastCalcBoundsResult_set_bmax_2,_emscripten_bind_RecastCalcBoundsResult___destroy___0,_emscripten_bind_RecastCalcGridSizeResult_get_width_0,_emscripten_bind_RecastCalcGridSizeResult_set_width_1,_emscripten_bind_RecastCalcGridSizeResult_get_height_0,_emscripten_bind_RecastCalcGridSizeResult_set_height_1,_emscripten_bind_RecastCalcGridSizeResult___destroy___0,_emscripten_bind_Recast_Recast_0,_emscripten_bind_Recast_calcBounds_2,_emscripten_bind_Recast_calcGridSize_3,_emscripten_bind_Recast_createHeightfield_8,_emscripten_bind_Recast_markWalkableTriangles_7,_emscripten_bind_Recast_clearUnwalkableTriangles_7,_emscripten_bind_Recast_rasterizeTriangles_8,_emscripten_bind_Recast_filterLowHangingWalkableObstacles_3,_emscripten_bind_Recast_filterLedgeSpans_4,_emscripten_bind_Recast_filterWalkableLowHeightSpans_3,_emscripten_bind_Recast_getHeightFieldSpanCount_2,_emscripten_bind_Recast_buildCompactHeightfield_5,_emscripten_bind_Recast_erodeWalkableArea_3,_emscripten_bind_Recast_medianFilterWalkableArea_2,_emscripten_bind_Recast_markBoxArea_5,_emscripten_bind_Recast_markConvexPolyArea_7,_emscripten_bind_Recast_markCylinderArea_6,_emscripten_bind_Recast_buildDistanceField_2,_emscripten_bind_Recast_buildRegions_5,_emscripten_bind_Recast_buildLayerRegions_4,_emscripten_bind_Recast_buildRegionsMonotone_5,_emscripten_bind_Recast_setCon_3,_emscripten_bind_Recast_getCon_2,_emscripten_bind_Recast_getDirOffsetX_1,_emscripten_bind_Recast_getDirOffsetY_1,_emscripten_bind_Recast_getDirForOffset_2,_emscripten_bind_Recast_buildHeightfieldLayers_5,_emscripten_bind_Recast_buildContours_6,_emscripten_bind_Recast_buildPolyMesh_4,_emscripten_bind_Recast_mergePolyMeshes_4,_emscripten_bind_Recast_buildPolyMeshDetail_6,_emscripten_bind_Recast_copyPolyMesh_3,_emscripten_bind_Recast_mergePolyMeshDetails_4,_emscripten_bind_Recast_getHeightfieldLayerHeights_1,_emscripten_bind_Recast_getHeightfieldLayerAreas_1,_emscripten_bind_Recast_getHeightfieldLayerCons_1,_emscripten_bind_Recast_allocHeightfield_0,_emscripten_bind_Recast_freeHeightfield_1,_emscripten_bind_Recast_allocCompactHeightfield_0,_emscripten_bind_Recast_freeCompactHeightfield_1,_emscripten_bind_Recast_allocHeightfieldLayerSet_0,_emscripten_bind_Recast_freeHeightfieldLayerSet_1,_emscripten_bind_Recast_allocContourSet_0,_emscripten_bind_Recast_freeContourSet_1,_emscripten_bind_Recast_allocPolyMesh_0,_emscripten_bind_Recast_freePolyMesh_1,_emscripten_bind_Recast_allocPolyMeshDetail_0,_emscripten_bind_Recast_freePolyMeshDetail_1,_emscripten_bind_Recast_get_BORDER_REG_0,_emscripten_bind_Recast_set_BORDER_REG_1,_emscripten_bind_Recast_get_MULTIPLE_REGS_0,_emscripten_bind_Recast_set_MULTIPLE_REGS_1,_emscripten_bind_Recast_get_BORDER_VERTEX_0,_emscripten_bind_Recast_set_BORDER_VERTEX_1,_emscripten_bind_Recast_get_AREA_BORDER_0,_emscripten_bind_Recast_set_AREA_BORDER_1,_emscripten_bind_Recast_get_CONTOUR_REG_MASK_0,_emscripten_bind_Recast_set_CONTOUR_REG_MASK_1,_emscripten_bind_Recast_get_MESH_NULL_IDX_0,_emscripten_bind_Recast_set_MESH_NULL_IDX_1,_emscripten_bind_Recast_get_NULL_AREA_0,_emscripten_bind_Recast_set_NULL_AREA_1,_emscripten_bind_Recast_get_WALKABLE_AREA_0,_emscripten_bind_Recast_set_WALKABLE_AREA_1,_emscripten_bind_Recast_get_NOT_CONNECTED_0,_emscripten_bind_Recast_set_NOT_CONNECTED_1,_emscripten_bind_Recast___destroy___0,_emscripten_bind_CreateNavMeshDataResult_get_success_0,_emscripten_bind_CreateNavMeshDataResult_set_success_1,_emscripten_bind_CreateNavMeshDataResult_get_navMeshData_0,_emscripten_bind_CreateNavMeshDataResult_set_navMeshData_1,_emscripten_bind_CreateNavMeshDataResult___destroy___0,_emscripten_bind_DetourNavMeshBuilder_DetourNavMeshBuilder_0,_emscripten_bind_DetourNavMeshBuilder_setPolyMeshCreateParams_2,_emscripten_bind_DetourNavMeshBuilder_setPolyMeshDetailCreateParams_2,_emscripten_bind_DetourNavMeshBuilder_setOffMeshConnections_8,_emscripten_bind_DetourNavMeshBuilder_createNavMeshData_1,_emscripten_bind_DetourNavMeshBuilder___destroy___0,_emscripten_bind_dtTileCacheLayer___destroy___0,_emscripten_bind_dtTileCacheContourSet___destroy___0,_emscripten_bind_dtTileCachePolyMesh___destroy___0,_emscripten_bind_dtTileCacheLayerHeader_dtTileCacheLayerHeader_0,_emscripten_bind_dtTileCacheLayerHeader_get_magic_0,_emscripten_bind_dtTileCacheLayerHeader_set_magic_1,_emscripten_bind_dtTileCacheLayerHeader_get_version_0,_emscripten_bind_dtTileCacheLayerHeader_set_version_1,_emscripten_bind_dtTileCacheLayerHeader_get_tx_0,_emscripten_bind_dtTileCacheLayerHeader_set_tx_1,_emscripten_bind_dtTileCacheLayerHeader_get_ty_0,_emscripten_bind_dtTileCacheLayerHeader_set_ty_1,_emscripten_bind_dtTileCacheLayerHeader_get_tlayer_0,_emscripten_bind_dtTileCacheLayerHeader_set_tlayer_1,_emscripten_bind_dtTileCacheLayerHeader_get_bmin_1,_emscripten_bind_dtTileCacheLayerHeader_set_bmin_2,_emscripten_bind_dtTileCacheLayerHeader_get_bmax_1,_emscripten_bind_dtTileCacheLayerHeader_set_bmax_2,_emscripten_bind_dtTileCacheLayerHeader_get_hmin_0,_emscripten_bind_dtTileCacheLayerHeader_set_hmin_1,_emscripten_bind_dtTileCacheLayerHeader_get_hmax_0,_emscripten_bind_dtTileCacheLayerHeader_set_hmax_1,_emscripten_bind_dtTileCacheLayerHeader_get_width_0,_emscripten_bind_dtTileCacheLayerHeader_set_width_1,_emscripten_bind_dtTileCacheLayerHeader_get_height_0,_emscripten_bind_dtTileCacheLayerHeader_set_height_1,_emscripten_bind_dtTileCacheLayerHeader_get_minx_0,_emscripten_bind_dtTileCacheLayerHeader_set_minx_1,_emscripten_bind_dtTileCacheLayerHeader_get_maxx_0,_emscripten_bind_dtTileCacheLayerHeader_set_maxx_1,_emscripten_bind_dtTileCacheLayerHeader_get_miny_0,_emscripten_bind_dtTileCacheLayerHeader_set_miny_1,_emscripten_bind_dtTileCacheLayerHeader_get_maxy_0,_emscripten_bind_dtTileCacheLayerHeader_set_maxy_1,_emscripten_bind_dtTileCacheLayerHeader___destroy___0,_emscripten_bind_DetourTileCacheBuilder_DetourTileCacheBuilder_0,_emscripten_bind_DetourTileCacheBuilder_buildTileCacheLayer_6,_emscripten_bind_DetourTileCacheBuilder___destroy___0,_emscripten_bind_rcChunkyTriMeshNode_get_bmin_1,_emscripten_bind_rcChunkyTriMeshNode_set_bmin_2,_emscripten_bind_rcChunkyTriMeshNode_get_bmax_1,_emscripten_bind_rcChunkyTriMeshNode_set_bmax_2,_emscripten_bind_rcChunkyTriMeshNode_get_i_0,_emscripten_bind_rcChunkyTriMeshNode_set_i_1,_emscripten_bind_rcChunkyTriMeshNode_get_n_0,_emscripten_bind_rcChunkyTriMeshNode_set_n_1,_emscripten_bind_rcChunkyTriMeshNode___destroy___0,_emscripten_bind_rcChunkyTriMesh_rcChunkyTriMesh_0,_emscripten_bind_rcChunkyTriMesh_get_nodes_1,_emscripten_bind_rcChunkyTriMesh_set_nodes_2,_emscripten_bind_rcChunkyTriMesh_get_nnodes_0,_emscripten_bind_rcChunkyTriMesh_set_nnodes_1,_emscripten_bind_rcChunkyTriMesh_get_tris_1,_emscripten_bind_rcChunkyTriMesh_set_tris_2,_emscripten_bind_rcChunkyTriMesh_get_ntris_0,_emscripten_bind_rcChunkyTriMesh_set_ntris_1,_emscripten_bind_rcChunkyTriMesh_get_maxTrisPerChunk_0,_emscripten_bind_rcChunkyTriMesh_set_maxTrisPerChunk_1,_emscripten_bind_rcChunkyTriMesh___destroy___0,_emscripten_bind_ChunkyTriMeshUtils_ChunkyTriMeshUtils_0,_emscripten_bind_ChunkyTriMeshUtils_createChunkyTriMesh_5,_emscripten_bind_ChunkyTriMeshUtils_getChunksOverlappingRect_5,_emscripten_bind_ChunkyTriMeshUtils_getChunkyTriMeshNodeTris_2,_emscripten_bind_ChunkyTriMeshUtils___destroy___0,_emscripten_bind_BoolRef_BoolRef_0,_emscripten_bind_BoolRef_get_value_0,_emscripten_bind_BoolRef_set_value_1,_emscripten_bind_BoolRef___destroy___0,_emscripten_bind_IntRef_IntRef_0,_emscripten_bind_IntRef_get_value_0,_emscripten_bind_IntRef_set_value_1,_emscripten_bind_IntRef___destroy___0,_emscripten_bind_UnsignedIntRef_UnsignedIntRef_0,_emscripten_bind_UnsignedIntRef_get_value_0,_emscripten_bind_UnsignedIntRef_set_value_1,_emscripten_bind_UnsignedIntRef___destroy___0,_emscripten_bind_UnsignedCharRef_UnsignedCharRef_0,_emscripten_bind_UnsignedCharRef_get_value_0,_emscripten_bind_UnsignedCharRef_set_value_1,_emscripten_bind_UnsignedCharRef___destroy___0,_emscripten_bind_UnsignedShortRef_UnsignedShortRef_0,_emscripten_bind_UnsignedShortRef_get_value_0,_emscripten_bind_UnsignedShortRef_set_value_1,_emscripten_bind_UnsignedShortRef___destroy___0,_emscripten_bind_FloatRef_FloatRef_0,_emscripten_bind_FloatRef_get_value_0,_emscripten_bind_FloatRef_set_value_1,_emscripten_bind_FloatRef___destroy___0,_emscripten_bind_IntArray_IntArray_0,_emscripten_bind_IntArray_resize_1,_emscripten_bind_IntArray_copy_2,_emscripten_bind_IntArray_free_0,_emscripten_bind_IntArray_get_1,_emscripten_bind_IntArray_set_2,_emscripten_bind_IntArray_getDataPointer_0,_emscripten_bind_IntArray_get_data_1,_emscripten_bind_IntArray_set_data_2,_emscripten_bind_IntArray_get_size_0,_emscripten_bind_IntArray_set_size_1,_emscripten_bind_IntArray_get_isView_0,_emscripten_bind_IntArray_set_isView_1,_emscripten_bind_IntArray___destroy___0,_emscripten_bind_UnsignedIntArray_UnsignedIntArray_0,_emscripten_bind_UnsignedIntArray_resize_1,_emscripten_bind_UnsignedIntArray_copy_2,_emscripten_bind_UnsignedIntArray_free_0,_emscripten_bind_UnsignedIntArray_get_1,_emscripten_bind_UnsignedIntArray_set_2,_emscripten_bind_UnsignedIntArray_getDataPointer_0,_emscripten_bind_UnsignedIntArray_get_data_1,_emscripten_bind_UnsignedIntArray_set_data_2,_emscripten_bind_UnsignedIntArray_get_size_0,_emscripten_bind_UnsignedIntArray_set_size_1,_emscripten_bind_UnsignedIntArray_get_isView_0,_emscripten_bind_UnsignedIntArray_set_isView_1,_emscripten_bind_UnsignedIntArray___destroy___0,_emscripten_bind_UnsignedCharArray_UnsignedCharArray_0,_emscripten_bind_UnsignedCharArray_resize_1,_emscripten_bind_UnsignedCharArray_copy_2,_emscripten_bind_UnsignedCharArray_free_0,_emscripten_bind_UnsignedCharArray_get_1,_emscripten_bind_UnsignedCharArray_set_2,_emscripten_bind_UnsignedCharArray_getDataPointer_0,_emscripten_bind_UnsignedCharArray_get_data_1,_emscripten_bind_UnsignedCharArray_set_data_2,_emscripten_bind_UnsignedCharArray_get_size_0,_emscripten_bind_UnsignedCharArray_set_size_1,_emscripten_bind_UnsignedCharArray_get_isView_0,_emscripten_bind_UnsignedCharArray_set_isView_1,_emscripten_bind_UnsignedCharArray___destroy___0,_emscripten_bind_UnsignedShortArray_UnsignedShortArray_0,_emscripten_bind_UnsignedShortArray_resize_1,_emscripten_bind_UnsignedShortArray_copy_2,_emscripten_bind_UnsignedShortArray_free_0,_emscripten_bind_UnsignedShortArray_get_1,_emscripten_bind_UnsignedShortArray_set_2,_emscripten_bind_UnsignedShortArray_getDataPointer_0,_emscripten_bind_UnsignedShortArray_get_data_1,_emscripten_bind_UnsignedShortArray_set_data_2,_emscripten_bind_UnsignedShortArray_get_size_0,_emscripten_bind_UnsignedShortArray_set_size_1,_emscripten_bind_UnsignedShortArray_get_isView_0,_emscripten_bind_UnsignedShortArray_set_isView_1,_emscripten_bind_UnsignedShortArray___destroy___0,_emscripten_bind_FloatArray_FloatArray_0,_emscripten_bind_FloatArray_resize_1,_emscripten_bind_FloatArray_copy_2,_emscripten_bind_FloatArray_free_0,_emscripten_bind_FloatArray_get_1,_emscripten_bind_FloatArray_set_2,_emscripten_bind_FloatArray_getDataPointer_0,_emscripten_bind_FloatArray_get_data_1,_emscripten_bind_FloatArray_set_data_2,_emscripten_bind_FloatArray_get_size_0,_emscripten_bind_FloatArray_set_size_1,_emscripten_bind_FloatArray_get_isView_0,_emscripten_bind_FloatArray_set_isView_1,_emscripten_bind_FloatArray___destroy___0,_emscripten_bind_NavMeshImporterResult_get_navMesh_0,_emscripten_bind_NavMeshImporterResult_set_navMesh_1,_emscripten_bind_NavMeshImporterResult_get_tileCache_0,_emscripten_bind_NavMeshImporterResult_set_tileCache_1,_emscripten_bind_NavMeshImporterResult_get_allocator_0,_emscripten_bind_NavMeshImporterResult_set_allocator_1,_emscripten_bind_NavMeshImporterResult_get_compressor_0,_emscripten_bind_NavMeshImporterResult_set_compressor_1,_emscripten_bind_NavMeshImporterResult___destroy___0,_emscripten_bind_NavMeshImporter_NavMeshImporter_0,_emscripten_bind_NavMeshImporter_importNavMesh_2,_emscripten_bind_NavMeshImporter___destroy___0,_emscripten_bind_NavMeshExport_NavMeshExport_0,_emscripten_bind_NavMeshExport_get_dataPointer_0,_emscripten_bind_NavMeshExport_set_dataPointer_1,_emscripten_bind_NavMeshExport_get_size_0,_emscripten_bind_NavMeshExport_set_size_1,_emscripten_bind_NavMeshExport___destroy___0,_emscripten_bind_NavMeshExporter_NavMeshExporter_0,_emscripten_bind_NavMeshExporter_exportNavMesh_2,_emscripten_bind_NavMeshExporter_freeNavMeshExport_1,_emscripten_bind_NavMeshExporter___destroy___0,_emscripten_bind_DebugDrawImpl_DebugDrawImpl_0,_emscripten_bind_DebugDrawImpl_handleDepthMask_1,_emscripten_bind_DebugDrawImpl_handleTexture_1,_emscripten_bind_DebugDrawImpl_handleBegin_2,_emscripten_bind_DebugDrawImpl_handleVertexWithColor_4,_emscripten_bind_DebugDrawImpl_handleVertexWithColorAndUV_6,_emscripten_bind_DebugDrawImpl_handleEnd_0,_emscripten_bind_DebugDrawImpl___destroy___0,_emscripten_bind_RecastDebugDraw_RecastDebugDraw_0,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldSolid_2,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldWalkable_2,_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldSolid_2,_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldRegions_2,_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldDistance_2,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayer_3,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayers_2,_emscripten_bind_RecastDebugDraw_debugDrawRegionConnections_3,_emscripten_bind_RecastDebugDraw_debugDrawRawContours_3,_emscripten_bind_RecastDebugDraw_debugDrawContours_3,_emscripten_bind_RecastDebugDraw_debugDrawPolyMesh_2,_emscripten_bind_RecastDebugDraw_debugDrawPolyMeshDetail_2,_emscripten_bind_RecastDebugDraw___destroy___0,_emscripten_bind_DetourDebugDraw_DetourDebugDraw_0,_emscripten_bind_DetourDebugDraw_debugDrawNavMesh_3,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshWithClosedList_4,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshNodes_2,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshBVTree_2,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPortals_2,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPolysWithFlags_4,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPoly_4,_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerAreas_4,_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerRegions_4,_emscripten_bind_DetourDebugDraw_debugDrawTileCacheContours_5,_emscripten_bind_DetourDebugDraw_debugDrawTileCachePolyMesh_5,_emscripten_bind_DetourDebugDraw___destroy___0,_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_START,_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_END,_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION,_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS,_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS,_emscripten_enum_dtFindPathOptions_DT_FINDPATH_ANY_ANGLE,_emscripten_enum_dtRaycastOptions_DT_RAYCAST_USE_COSTS,_emscripten_enum_dtTileFlags_DT_TILE_FREE_DATA,_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_INVALID,_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_WALKING,_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_NONE,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_FAILED,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VALID,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY,_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES,_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES,_emscripten_enum_rcLogCategory_RC_LOG_PROGRESS,_emscripten_enum_rcLogCategory_RC_LOG_WARNING,_emscripten_enum_rcLogCategory_RC_LOG_ERROR,_emscripten_enum_rcTimerLabel_RC_TIMER_TOTAL,_emscripten_enum_rcTimerLabel_RC_TIMER_TEMP,_emscripten_enum_rcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY,_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_BORDER,_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_WALKABLE,_emscripten_enum_rcTimerLabel_RC_TIMER_MEDIAN_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESH,_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESH,_emscripten_enum_rcTimerLabel_RC_TIMER_ERODE_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_BOX_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_LAYERS,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL,_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL,_emscripten_enum_rcTimerLabel_RC_MAX_TIMERS,_emscripten_enum_dtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_POINTS,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_LINES,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_TRIS,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_QUADS,__emscripten_timeout;function assignWasmExports(wasmExports){Module["_webidl_free"]=_webidl_free=wasmExports["i"];Module["_free"]=_free=wasmExports["j"];Module["_webidl_malloc"]=_webidl_malloc=wasmExports["k"];Module["_malloc"]=_malloc=wasmExports["l"];Module["_emscripten_bind_duDebugDraw___destroy___0"]=_emscripten_bind_duDebugDraw___destroy___0=wasmExports["m"];Module["_emscripten_bind_dtTileCacheCompressor___destroy___0"]=_emscripten_bind_dtTileCacheCompressor___destroy___0=wasmExports["o"];Module["_emscripten_bind_TileCacheMeshProcessJsImpl_process_3"]=_emscripten_bind_TileCacheMeshProcessJsImpl_process_3=wasmExports["p"];Module["_emscripten_bind_TileCacheMeshProcessJsImpl___destroy___0"]=_emscripten_bind_TileCacheMeshProcessJsImpl___destroy___0=wasmExports["q"];Module["_emscripten_bind_dtTileCacheAlloc___destroy___0"]=_emscripten_bind_dtTileCacheAlloc___destroy___0=wasmExports["r"];Module["_emscripten_bind_rcContext_rcContext_0"]=_emscripten_bind_rcContext_rcContext_0=wasmExports["s"];Module["_emscripten_bind_rcContext_enableLog_1"]=_emscripten_bind_rcContext_enableLog_1=wasmExports["t"];Module["_emscripten_bind_rcContext_resetLog_0"]=_emscripten_bind_rcContext_resetLog_0=wasmExports["u"];Module["_emscripten_bind_rcContext_log_2"]=_emscripten_bind_rcContext_log_2=wasmExports["v"];Module["_emscripten_bind_rcContext_enableTimer_1"]=_emscripten_bind_rcContext_enableTimer_1=wasmExports["w"];Module["_emscripten_bind_rcContext_resetTimers_0"]=_emscripten_bind_rcContext_resetTimers_0=wasmExports["x"];Module["_emscripten_bind_rcContext_startTimer_1"]=_emscripten_bind_rcContext_startTimer_1=wasmExports["y"];Module["_emscripten_bind_rcContext_stopTimer_1"]=_emscripten_bind_rcContext_stopTimer_1=wasmExports["z"];Module["_emscripten_bind_rcContext_getAccumulatedTime_1"]=_emscripten_bind_rcContext_getAccumulatedTime_1=wasmExports["A"];Module["_emscripten_bind_rcContext___destroy___0"]=_emscripten_bind_rcContext___destroy___0=wasmExports["B"];Module["_emscripten_bind_RecastBuildContextImpl___destroy___0"]=_emscripten_bind_RecastBuildContextImpl___destroy___0=wasmExports["C"];Module["_emscripten_bind_DebugDraw___destroy___0"]=_emscripten_bind_DebugDraw___destroy___0=wasmExports["D"];Module["_emscripten_bind_VoidPtr___destroy___0"]=_emscripten_bind_VoidPtr___destroy___0=wasmExports["E"];Module["_emscripten_bind_rcConfig_rcConfig_0"]=_emscripten_bind_rcConfig_rcConfig_0=wasmExports["F"];Module["_emscripten_bind_rcConfig_get_width_0"]=_emscripten_bind_rcConfig_get_width_0=wasmExports["G"];Module["_emscripten_bind_rcConfig_set_width_1"]=_emscripten_bind_rcConfig_set_width_1=wasmExports["H"];Module["_emscripten_bind_rcConfig_get_height_0"]=_emscripten_bind_rcConfig_get_height_0=wasmExports["I"];Module["_emscripten_bind_rcConfig_set_height_1"]=_emscripten_bind_rcConfig_set_height_1=wasmExports["J"];Module["_emscripten_bind_rcConfig_get_tileSize_0"]=_emscripten_bind_rcConfig_get_tileSize_0=wasmExports["K"];Module["_emscripten_bind_rcConfig_set_tileSize_1"]=_emscripten_bind_rcConfig_set_tileSize_1=wasmExports["L"];Module["_emscripten_bind_rcConfig_get_borderSize_0"]=_emscripten_bind_rcConfig_get_borderSize_0=wasmExports["M"];Module["_emscripten_bind_rcConfig_set_borderSize_1"]=_emscripten_bind_rcConfig_set_borderSize_1=wasmExports["N"];Module["_emscripten_bind_rcConfig_get_cs_0"]=_emscripten_bind_rcConfig_get_cs_0=wasmExports["O"];Module["_emscripten_bind_rcConfig_set_cs_1"]=_emscripten_bind_rcConfig_set_cs_1=wasmExports["P"];Module["_emscripten_bind_rcConfig_get_ch_0"]=_emscripten_bind_rcConfig_get_ch_0=wasmExports["Q"];Module["_emscripten_bind_rcConfig_set_ch_1"]=_emscripten_bind_rcConfig_set_ch_1=wasmExports["R"];Module["_emscripten_bind_rcConfig_get_bmin_1"]=_emscripten_bind_rcConfig_get_bmin_1=wasmExports["S"];Module["_emscripten_bind_rcConfig_set_bmin_2"]=_emscripten_bind_rcConfig_set_bmin_2=wasmExports["T"];Module["_emscripten_bind_rcConfig_get_bmax_1"]=_emscripten_bind_rcConfig_get_bmax_1=wasmExports["U"];Module["_emscripten_bind_rcConfig_set_bmax_2"]=_emscripten_bind_rcConfig_set_bmax_2=wasmExports["V"];Module["_emscripten_bind_rcConfig_get_walkableSlopeAngle_0"]=_emscripten_bind_rcConfig_get_walkableSlopeAngle_0=wasmExports["W"];Module["_emscripten_bind_rcConfig_set_walkableSlopeAngle_1"]=_emscripten_bind_rcConfig_set_walkableSlopeAngle_1=wasmExports["X"];Module["_emscripten_bind_rcConfig_get_walkableHeight_0"]=_emscripten_bind_rcConfig_get_walkableHeight_0=wasmExports["Y"];Module["_emscripten_bind_rcConfig_set_walkableHeight_1"]=_emscripten_bind_rcConfig_set_walkableHeight_1=wasmExports["Z"];Module["_emscripten_bind_rcConfig_get_walkableClimb_0"]=_emscripten_bind_rcConfig_get_walkableClimb_0=wasmExports["_"];Module["_emscripten_bind_rcConfig_set_walkableClimb_1"]=_emscripten_bind_rcConfig_set_walkableClimb_1=wasmExports["$"];Module["_emscripten_bind_rcConfig_get_walkableRadius_0"]=_emscripten_bind_rcConfig_get_walkableRadius_0=wasmExports["aa"];Module["_emscripten_bind_rcConfig_set_walkableRadius_1"]=_emscripten_bind_rcConfig_set_walkableRadius_1=wasmExports["ba"];Module["_emscripten_bind_rcConfig_get_maxEdgeLen_0"]=_emscripten_bind_rcConfig_get_maxEdgeLen_0=wasmExports["ca"];Module["_emscripten_bind_rcConfig_set_maxEdgeLen_1"]=_emscripten_bind_rcConfig_set_maxEdgeLen_1=wasmExports["da"];Module["_emscripten_bind_rcConfig_get_maxSimplificationError_0"]=_emscripten_bind_rcConfig_get_maxSimplificationError_0=wasmExports["ea"];Module["_emscripten_bind_rcConfig_set_maxSimplificationError_1"]=_emscripten_bind_rcConfig_set_maxSimplificationError_1=wasmExports["fa"];Module["_emscripten_bind_rcConfig_get_minRegionArea_0"]=_emscripten_bind_rcConfig_get_minRegionArea_0=wasmExports["ga"];Module["_emscripten_bind_rcConfig_set_minRegionArea_1"]=_emscripten_bind_rcConfig_set_minRegionArea_1=wasmExports["ha"];Module["_emscripten_bind_rcConfig_get_mergeRegionArea_0"]=_emscripten_bind_rcConfig_get_mergeRegionArea_0=wasmExports["ia"];Module["_emscripten_bind_rcConfig_set_mergeRegionArea_1"]=_emscripten_bind_rcConfig_set_mergeRegionArea_1=wasmExports["ja"];Module["_emscripten_bind_rcConfig_get_maxVertsPerPoly_0"]=_emscripten_bind_rcConfig_get_maxVertsPerPoly_0=wasmExports["ka"];Module["_emscripten_bind_rcConfig_set_maxVertsPerPoly_1"]=_emscripten_bind_rcConfig_set_maxVertsPerPoly_1=wasmExports["la"];Module["_emscripten_bind_rcConfig_get_detailSampleDist_0"]=_emscripten_bind_rcConfig_get_detailSampleDist_0=wasmExports["ma"];Module["_emscripten_bind_rcConfig_set_detailSampleDist_1"]=_emscripten_bind_rcConfig_set_detailSampleDist_1=wasmExports["na"];Module["_emscripten_bind_rcConfig_get_detailSampleMaxError_0"]=_emscripten_bind_rcConfig_get_detailSampleMaxError_0=wasmExports["oa"];Module["_emscripten_bind_rcConfig_set_detailSampleMaxError_1"]=_emscripten_bind_rcConfig_set_detailSampleMaxError_1=wasmExports["pa"];Module["_emscripten_bind_rcConfig___destroy___0"]=_emscripten_bind_rcConfig___destroy___0=wasmExports["qa"];Module["_emscripten_bind_dtMeshHeader_get_magic_0"]=_emscripten_bind_dtMeshHeader_get_magic_0=wasmExports["ra"];Module["_emscripten_bind_dtMeshHeader_set_magic_1"]=_emscripten_bind_dtMeshHeader_set_magic_1=wasmExports["sa"];Module["_emscripten_bind_dtMeshHeader_get_version_0"]=_emscripten_bind_dtMeshHeader_get_version_0=wasmExports["ta"];Module["_emscripten_bind_dtMeshHeader_set_version_1"]=_emscripten_bind_dtMeshHeader_set_version_1=wasmExports["ua"];Module["_emscripten_bind_dtMeshHeader_get_x_0"]=_emscripten_bind_dtMeshHeader_get_x_0=wasmExports["va"];Module["_emscripten_bind_dtMeshHeader_set_x_1"]=_emscripten_bind_dtMeshHeader_set_x_1=wasmExports["wa"];Module["_emscripten_bind_dtMeshHeader_get_y_0"]=_emscripten_bind_dtMeshHeader_get_y_0=wasmExports["xa"];Module["_emscripten_bind_dtMeshHeader_set_y_1"]=_emscripten_bind_dtMeshHeader_set_y_1=wasmExports["ya"];Module["_emscripten_bind_dtMeshHeader_get_layer_0"]=_emscripten_bind_dtMeshHeader_get_layer_0=wasmExports["za"];Module["_emscripten_bind_dtMeshHeader_set_layer_1"]=_emscripten_bind_dtMeshHeader_set_layer_1=wasmExports["Aa"];Module["_emscripten_bind_dtMeshHeader_get_userId_0"]=_emscripten_bind_dtMeshHeader_get_userId_0=wasmExports["Ba"];Module["_emscripten_bind_dtMeshHeader_set_userId_1"]=_emscripten_bind_dtMeshHeader_set_userId_1=wasmExports["Ca"];Module["_emscripten_bind_dtMeshHeader_get_polyCount_0"]=_emscripten_bind_dtMeshHeader_get_polyCount_0=wasmExports["Da"];Module["_emscripten_bind_dtMeshHeader_set_polyCount_1"]=_emscripten_bind_dtMeshHeader_set_polyCount_1=wasmExports["Ea"];Module["_emscripten_bind_dtMeshHeader_get_vertCount_0"]=_emscripten_bind_dtMeshHeader_get_vertCount_0=wasmExports["Fa"];Module["_emscripten_bind_dtMeshHeader_set_vertCount_1"]=_emscripten_bind_dtMeshHeader_set_vertCount_1=wasmExports["Ga"];Module["_emscripten_bind_dtMeshHeader_get_maxLinkCount_0"]=_emscripten_bind_dtMeshHeader_get_maxLinkCount_0=wasmExports["Ha"];Module["_emscripten_bind_dtMeshHeader_set_maxLinkCount_1"]=_emscripten_bind_dtMeshHeader_set_maxLinkCount_1=wasmExports["Ia"];Module["_emscripten_bind_dtMeshHeader_get_detailMeshCount_0"]=_emscripten_bind_dtMeshHeader_get_detailMeshCount_0=wasmExports["Ja"];Module["_emscripten_bind_dtMeshHeader_set_detailMeshCount_1"]=_emscripten_bind_dtMeshHeader_set_detailMeshCount_1=wasmExports["Ka"];Module["_emscripten_bind_dtMeshHeader_get_detailVertCount_0"]=_emscripten_bind_dtMeshHeader_get_detailVertCount_0=wasmExports["La"];Module["_emscripten_bind_dtMeshHeader_set_detailVertCount_1"]=_emscripten_bind_dtMeshHeader_set_detailVertCount_1=wasmExports["Ma"];Module["_emscripten_bind_dtMeshHeader_get_detailTriCount_0"]=_emscripten_bind_dtMeshHeader_get_detailTriCount_0=wasmExports["Na"];Module["_emscripten_bind_dtMeshHeader_set_detailTriCount_1"]=_emscripten_bind_dtMeshHeader_set_detailTriCount_1=wasmExports["Oa"];Module["_emscripten_bind_dtMeshHeader_get_bvNodeCount_0"]=_emscripten_bind_dtMeshHeader_get_bvNodeCount_0=wasmExports["Pa"];Module["_emscripten_bind_dtMeshHeader_set_bvNodeCount_1"]=_emscripten_bind_dtMeshHeader_set_bvNodeCount_1=wasmExports["Qa"];Module["_emscripten_bind_dtMeshHeader_get_offMeshConCount_0"]=_emscripten_bind_dtMeshHeader_get_offMeshConCount_0=wasmExports["Ra"];Module["_emscripten_bind_dtMeshHeader_set_offMeshConCount_1"]=_emscripten_bind_dtMeshHeader_set_offMeshConCount_1=wasmExports["Sa"];Module["_emscripten_bind_dtMeshHeader_get_offMeshBase_0"]=_emscripten_bind_dtMeshHeader_get_offMeshBase_0=wasmExports["Ta"];Module["_emscripten_bind_dtMeshHeader_set_offMeshBase_1"]=_emscripten_bind_dtMeshHeader_set_offMeshBase_1=wasmExports["Ua"];Module["_emscripten_bind_dtMeshHeader_get_walkableHeight_0"]=_emscripten_bind_dtMeshHeader_get_walkableHeight_0=wasmExports["Va"];Module["_emscripten_bind_dtMeshHeader_set_walkableHeight_1"]=_emscripten_bind_dtMeshHeader_set_walkableHeight_1=wasmExports["Wa"];Module["_emscripten_bind_dtMeshHeader_get_walkableRadius_0"]=_emscripten_bind_dtMeshHeader_get_walkableRadius_0=wasmExports["Xa"];Module["_emscripten_bind_dtMeshHeader_set_walkableRadius_1"]=_emscripten_bind_dtMeshHeader_set_walkableRadius_1=wasmExports["Ya"];Module["_emscripten_bind_dtMeshHeader_get_walkableClimb_0"]=_emscripten_bind_dtMeshHeader_get_walkableClimb_0=wasmExports["Za"];Module["_emscripten_bind_dtMeshHeader_set_walkableClimb_1"]=_emscripten_bind_dtMeshHeader_set_walkableClimb_1=wasmExports["_a"];Module["_emscripten_bind_dtMeshHeader_get_bmin_1"]=_emscripten_bind_dtMeshHeader_get_bmin_1=wasmExports["$a"];Module["_emscripten_bind_dtMeshHeader_set_bmin_2"]=_emscripten_bind_dtMeshHeader_set_bmin_2=wasmExports["ab"];Module["_emscripten_bind_dtMeshHeader_get_bmax_1"]=_emscripten_bind_dtMeshHeader_get_bmax_1=wasmExports["bb"];Module["_emscripten_bind_dtMeshHeader_set_bmax_2"]=_emscripten_bind_dtMeshHeader_set_bmax_2=wasmExports["cb"];Module["_emscripten_bind_dtMeshHeader_get_bvQuantFactor_0"]=_emscripten_bind_dtMeshHeader_get_bvQuantFactor_0=wasmExports["db"];Module["_emscripten_bind_dtMeshHeader_set_bvQuantFactor_1"]=_emscripten_bind_dtMeshHeader_set_bvQuantFactor_1=wasmExports["eb"];Module["_emscripten_bind_dtMeshHeader___destroy___0"]=_emscripten_bind_dtMeshHeader___destroy___0=wasmExports["fb"];Module["_emscripten_bind_dtPoly_setArea_1"]=_emscripten_bind_dtPoly_setArea_1=wasmExports["gb"];Module["_emscripten_bind_dtPoly_setType_1"]=_emscripten_bind_dtPoly_setType_1=wasmExports["hb"];Module["_emscripten_bind_dtPoly_getType_0"]=_emscripten_bind_dtPoly_getType_0=wasmExports["ib"];Module["_emscripten_bind_dtPoly_getArea_0"]=_emscripten_bind_dtPoly_getArea_0=wasmExports["jb"];Module["_emscripten_bind_dtPoly_get_firstLink_0"]=_emscripten_bind_dtPoly_get_firstLink_0=wasmExports["kb"];Module["_emscripten_bind_dtPoly_set_firstLink_1"]=_emscripten_bind_dtPoly_set_firstLink_1=wasmExports["lb"];Module["_emscripten_bind_dtPoly_get_verts_1"]=_emscripten_bind_dtPoly_get_verts_1=wasmExports["mb"];Module["_emscripten_bind_dtPoly_set_verts_2"]=_emscripten_bind_dtPoly_set_verts_2=wasmExports["nb"];Module["_emscripten_bind_dtPoly_get_neis_1"]=_emscripten_bind_dtPoly_get_neis_1=wasmExports["ob"];Module["_emscripten_bind_dtPoly_set_neis_2"]=_emscripten_bind_dtPoly_set_neis_2=wasmExports["pb"];Module["_emscripten_bind_dtPoly_get_flags_0"]=_emscripten_bind_dtPoly_get_flags_0=wasmExports["qb"];Module["_emscripten_bind_dtPoly_set_flags_1"]=_emscripten_bind_dtPoly_set_flags_1=wasmExports["rb"];Module["_emscripten_bind_dtPoly_get_vertCount_0"]=_emscripten_bind_dtPoly_get_vertCount_0=wasmExports["sb"];Module["_emscripten_bind_dtPoly_set_vertCount_1"]=_emscripten_bind_dtPoly_set_vertCount_1=wasmExports["tb"];Module["_emscripten_bind_dtPoly_get_areaAndtype_0"]=_emscripten_bind_dtPoly_get_areaAndtype_0=wasmExports["ub"];Module["_emscripten_bind_dtPoly_set_areaAndtype_1"]=_emscripten_bind_dtPoly_set_areaAndtype_1=wasmExports["vb"];Module["_emscripten_bind_dtPoly___destroy___0"]=_emscripten_bind_dtPoly___destroy___0=wasmExports["wb"];Module["_emscripten_bind_dtPolyDetail_get_vertBase_0"]=_emscripten_bind_dtPolyDetail_get_vertBase_0=wasmExports["xb"];Module["_emscripten_bind_dtPolyDetail_set_vertBase_1"]=_emscripten_bind_dtPolyDetail_set_vertBase_1=wasmExports["yb"];Module["_emscripten_bind_dtPolyDetail_get_triBase_0"]=_emscripten_bind_dtPolyDetail_get_triBase_0=wasmExports["zb"];Module["_emscripten_bind_dtPolyDetail_set_triBase_1"]=_emscripten_bind_dtPolyDetail_set_triBase_1=wasmExports["Ab"];Module["_emscripten_bind_dtPolyDetail_get_vertCount_0"]=_emscripten_bind_dtPolyDetail_get_vertCount_0=wasmExports["Bb"];Module["_emscripten_bind_dtPolyDetail_set_vertCount_1"]=_emscripten_bind_dtPolyDetail_set_vertCount_1=wasmExports["Cb"];Module["_emscripten_bind_dtPolyDetail_get_triCount_0"]=_emscripten_bind_dtPolyDetail_get_triCount_0=wasmExports["Db"];Module["_emscripten_bind_dtPolyDetail_set_triCount_1"]=_emscripten_bind_dtPolyDetail_set_triCount_1=wasmExports["Eb"];Module["_emscripten_bind_dtPolyDetail___destroy___0"]=_emscripten_bind_dtPolyDetail___destroy___0=wasmExports["Fb"];Module["_emscripten_bind_dtLink_get_ref_0"]=_emscripten_bind_dtLink_get_ref_0=wasmExports["Gb"];Module["_emscripten_bind_dtLink_set_ref_1"]=_emscripten_bind_dtLink_set_ref_1=wasmExports["Hb"];Module["_emscripten_bind_dtLink_get_next_0"]=_emscripten_bind_dtLink_get_next_0=wasmExports["Ib"];Module["_emscripten_bind_dtLink_set_next_1"]=_emscripten_bind_dtLink_set_next_1=wasmExports["Jb"];Module["_emscripten_bind_dtLink_get_edge_0"]=_emscripten_bind_dtLink_get_edge_0=wasmExports["Kb"];Module["_emscripten_bind_dtLink_set_edge_1"]=_emscripten_bind_dtLink_set_edge_1=wasmExports["Lb"];Module["_emscripten_bind_dtLink_get_side_0"]=_emscripten_bind_dtLink_get_side_0=wasmExports["Mb"];Module["_emscripten_bind_dtLink_set_side_1"]=_emscripten_bind_dtLink_set_side_1=wasmExports["Nb"];Module["_emscripten_bind_dtLink_get_bmin_0"]=_emscripten_bind_dtLink_get_bmin_0=wasmExports["Ob"];Module["_emscripten_bind_dtLink_set_bmin_1"]=_emscripten_bind_dtLink_set_bmin_1=wasmExports["Pb"];Module["_emscripten_bind_dtLink_get_bmax_0"]=_emscripten_bind_dtLink_get_bmax_0=wasmExports["Qb"];Module["_emscripten_bind_dtLink_set_bmax_1"]=_emscripten_bind_dtLink_set_bmax_1=wasmExports["Rb"];Module["_emscripten_bind_dtLink___destroy___0"]=_emscripten_bind_dtLink___destroy___0=wasmExports["Sb"];Module["_emscripten_bind_dtBVNode_get_bmin_1"]=_emscripten_bind_dtBVNode_get_bmin_1=wasmExports["Tb"];Module["_emscripten_bind_dtBVNode_set_bmin_2"]=_emscripten_bind_dtBVNode_set_bmin_2=wasmExports["Ub"];Module["_emscripten_bind_dtBVNode_get_bmax_1"]=_emscripten_bind_dtBVNode_get_bmax_1=wasmExports["Vb"];Module["_emscripten_bind_dtBVNode_set_bmax_2"]=_emscripten_bind_dtBVNode_set_bmax_2=wasmExports["Wb"];Module["_emscripten_bind_dtBVNode_get_i_0"]=_emscripten_bind_dtBVNode_get_i_0=wasmExports["Xb"];Module["_emscripten_bind_dtBVNode_set_i_1"]=_emscripten_bind_dtBVNode_set_i_1=wasmExports["Yb"];Module["_emscripten_bind_dtBVNode___destroy___0"]=_emscripten_bind_dtBVNode___destroy___0=wasmExports["Zb"];Module["_emscripten_bind_dtOffMeshConnection_get_pos_1"]=_emscripten_bind_dtOffMeshConnection_get_pos_1=wasmExports["_b"];Module["_emscripten_bind_dtOffMeshConnection_set_pos_2"]=_emscripten_bind_dtOffMeshConnection_set_pos_2=wasmExports["$b"];Module["_emscripten_bind_dtOffMeshConnection_get_rad_0"]=_emscripten_bind_dtOffMeshConnection_get_rad_0=wasmExports["ac"];Module["_emscripten_bind_dtOffMeshConnection_set_rad_1"]=_emscripten_bind_dtOffMeshConnection_set_rad_1=wasmExports["bc"];Module["_emscripten_bind_dtOffMeshConnection_get_poly_0"]=_emscripten_bind_dtOffMeshConnection_get_poly_0=wasmExports["cc"];Module["_emscripten_bind_dtOffMeshConnection_set_poly_1"]=_emscripten_bind_dtOffMeshConnection_set_poly_1=wasmExports["dc"];Module["_emscripten_bind_dtOffMeshConnection_get_flags_0"]=_emscripten_bind_dtOffMeshConnection_get_flags_0=wasmExports["ec"];Module["_emscripten_bind_dtOffMeshConnection_set_flags_1"]=_emscripten_bind_dtOffMeshConnection_set_flags_1=wasmExports["fc"];Module["_emscripten_bind_dtOffMeshConnection_get_side_0"]=_emscripten_bind_dtOffMeshConnection_get_side_0=wasmExports["gc"];Module["_emscripten_bind_dtOffMeshConnection_set_side_1"]=_emscripten_bind_dtOffMeshConnection_set_side_1=wasmExports["hc"];Module["_emscripten_bind_dtOffMeshConnection_get_userId_0"]=_emscripten_bind_dtOffMeshConnection_get_userId_0=wasmExports["ic"];Module["_emscripten_bind_dtOffMeshConnection_set_userId_1"]=_emscripten_bind_dtOffMeshConnection_set_userId_1=wasmExports["jc"];Module["_emscripten_bind_dtOffMeshConnection___destroy___0"]=_emscripten_bind_dtOffMeshConnection___destroy___0=wasmExports["kc"];Module["_emscripten_bind_dtMeshTile_get_salt_0"]=_emscripten_bind_dtMeshTile_get_salt_0=wasmExports["lc"];Module["_emscripten_bind_dtMeshTile_set_salt_1"]=_emscripten_bind_dtMeshTile_set_salt_1=wasmExports["mc"];Module["_emscripten_bind_dtMeshTile_get_linksFreeList_0"]=_emscripten_bind_dtMeshTile_get_linksFreeList_0=wasmExports["nc"];Module["_emscripten_bind_dtMeshTile_set_linksFreeList_1"]=_emscripten_bind_dtMeshTile_set_linksFreeList_1=wasmExports["oc"];Module["_emscripten_bind_dtMeshTile_get_header_0"]=_emscripten_bind_dtMeshTile_get_header_0=wasmExports["pc"];Module["_emscripten_bind_dtMeshTile_set_header_1"]=_emscripten_bind_dtMeshTile_set_header_1=wasmExports["qc"];Module["_emscripten_bind_dtMeshTile_get_polys_1"]=_emscripten_bind_dtMeshTile_get_polys_1=wasmExports["rc"];Module["_emscripten_bind_dtMeshTile_set_polys_2"]=_emscripten_bind_dtMeshTile_set_polys_2=wasmExports["sc"];Module["_emscripten_bind_dtMeshTile_get_verts_1"]=_emscripten_bind_dtMeshTile_get_verts_1=wasmExports["tc"];Module["_emscripten_bind_dtMeshTile_set_verts_2"]=_emscripten_bind_dtMeshTile_set_verts_2=wasmExports["uc"];Module["_emscripten_bind_dtMeshTile_get_links_1"]=_emscripten_bind_dtMeshTile_get_links_1=wasmExports["vc"];Module["_emscripten_bind_dtMeshTile_set_links_2"]=_emscripten_bind_dtMeshTile_set_links_2=wasmExports["wc"];Module["_emscripten_bind_dtMeshTile_get_detailMeshes_1"]=_emscripten_bind_dtMeshTile_get_detailMeshes_1=wasmExports["xc"];Module["_emscripten_bind_dtMeshTile_set_detailMeshes_2"]=_emscripten_bind_dtMeshTile_set_detailMeshes_2=wasmExports["yc"];Module["_emscripten_bind_dtMeshTile_get_detailVerts_1"]=_emscripten_bind_dtMeshTile_get_detailVerts_1=wasmExports["zc"];Module["_emscripten_bind_dtMeshTile_set_detailVerts_2"]=_emscripten_bind_dtMeshTile_set_detailVerts_2=wasmExports["Ac"];Module["_emscripten_bind_dtMeshTile_get_detailTris_1"]=_emscripten_bind_dtMeshTile_get_detailTris_1=wasmExports["Bc"];Module["_emscripten_bind_dtMeshTile_set_detailTris_2"]=_emscripten_bind_dtMeshTile_set_detailTris_2=wasmExports["Cc"];Module["_emscripten_bind_dtMeshTile_get_bvTree_1"]=_emscripten_bind_dtMeshTile_get_bvTree_1=wasmExports["Dc"];Module["_emscripten_bind_dtMeshTile_set_bvTree_2"]=_emscripten_bind_dtMeshTile_set_bvTree_2=wasmExports["Ec"];Module["_emscripten_bind_dtMeshTile_get_offMeshCons_1"]=_emscripten_bind_dtMeshTile_get_offMeshCons_1=wasmExports["Fc"];Module["_emscripten_bind_dtMeshTile_set_offMeshCons_2"]=_emscripten_bind_dtMeshTile_set_offMeshCons_2=wasmExports["Gc"];Module["_emscripten_bind_dtMeshTile_get_data_1"]=_emscripten_bind_dtMeshTile_get_data_1=wasmExports["Hc"];Module["_emscripten_bind_dtMeshTile_set_data_2"]=_emscripten_bind_dtMeshTile_set_data_2=wasmExports["Ic"];Module["_emscripten_bind_dtMeshTile_get_dataSize_0"]=_emscripten_bind_dtMeshTile_get_dataSize_0=wasmExports["Jc"];Module["_emscripten_bind_dtMeshTile_set_dataSize_1"]=_emscripten_bind_dtMeshTile_set_dataSize_1=wasmExports["Kc"];Module["_emscripten_bind_dtMeshTile_get_flags_0"]=_emscripten_bind_dtMeshTile_get_flags_0=wasmExports["Lc"];Module["_emscripten_bind_dtMeshTile_set_flags_1"]=_emscripten_bind_dtMeshTile_set_flags_1=wasmExports["Mc"];Module["_emscripten_bind_dtMeshTile_get_next_0"]=_emscripten_bind_dtMeshTile_get_next_0=wasmExports["Nc"];Module["_emscripten_bind_dtMeshTile_set_next_1"]=_emscripten_bind_dtMeshTile_set_next_1=wasmExports["Oc"];Module["_emscripten_bind_dtMeshTile___destroy___0"]=_emscripten_bind_dtMeshTile___destroy___0=wasmExports["Pc"];Module["_emscripten_bind_dtNavMesh___destroy___0"]=_emscripten_bind_dtNavMesh___destroy___0=wasmExports["Qc"];Module["_emscripten_bind_dtNavMeshCreateParams_dtNavMeshCreateParams_0"]=_emscripten_bind_dtNavMeshCreateParams_dtNavMeshCreateParams_0=wasmExports["Rc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_verts_1"]=_emscripten_bind_dtNavMeshCreateParams_get_verts_1=wasmExports["Sc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_vertCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_vertCount_0=wasmExports["Tc"];Module["_emscripten_bind_dtNavMeshCreateParams_set_vertCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_vertCount_1=wasmExports["Uc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polys_1"]=_emscripten_bind_dtNavMeshCreateParams_get_polys_1=wasmExports["Vc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polyFlags_1"]=_emscripten_bind_dtNavMeshCreateParams_get_polyFlags_1=wasmExports["Wc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polyAreas_1"]=_emscripten_bind_dtNavMeshCreateParams_get_polyAreas_1=wasmExports["Xc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polyCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_polyCount_0=wasmExports["Yc"];Module["_emscripten_bind_dtNavMeshCreateParams_set_polyCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_polyCount_1=wasmExports["Zc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_nvp_0"]=_emscripten_bind_dtNavMeshCreateParams_get_nvp_0=wasmExports["_c"];Module["_emscripten_bind_dtNavMeshCreateParams_set_nvp_1"]=_emscripten_bind_dtNavMeshCreateParams_set_nvp_1=wasmExports["$c"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailMeshes_1"]=_emscripten_bind_dtNavMeshCreateParams_get_detailMeshes_1=wasmExports["ad"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailVerts_1"]=_emscripten_bind_dtNavMeshCreateParams_get_detailVerts_1=wasmExports["bd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailVertsCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_detailVertsCount_0=wasmExports["cd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_detailVertsCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_detailVertsCount_1=wasmExports["dd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailTris_1"]=_emscripten_bind_dtNavMeshCreateParams_get_detailTris_1=wasmExports["ed"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailTriCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_detailTriCount_0=wasmExports["fd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_detailTriCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_detailTriCount_1=wasmExports["gd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConVerts_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConVerts_1=wasmExports["hd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConRad_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConRad_1=wasmExports["id"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConFlags_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConFlags_1=wasmExports["jd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConAreas_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConAreas_1=wasmExports["kd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConDir_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConDir_1=wasmExports["ld"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConUserID_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConUserID_1=wasmExports["md"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConCount_0=wasmExports["nd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_offMeshConCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_offMeshConCount_1=wasmExports["od"];Module["_emscripten_bind_dtNavMeshCreateParams_get_userId_0"]=_emscripten_bind_dtNavMeshCreateParams_get_userId_0=wasmExports["pd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_userId_1"]=_emscripten_bind_dtNavMeshCreateParams_set_userId_1=wasmExports["qd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_tileX_0"]=_emscripten_bind_dtNavMeshCreateParams_get_tileX_0=wasmExports["rd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_tileX_1"]=_emscripten_bind_dtNavMeshCreateParams_set_tileX_1=wasmExports["sd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_tileY_0"]=_emscripten_bind_dtNavMeshCreateParams_get_tileY_0=wasmExports["td"];Module["_emscripten_bind_dtNavMeshCreateParams_set_tileY_1"]=_emscripten_bind_dtNavMeshCreateParams_set_tileY_1=wasmExports["ud"];Module["_emscripten_bind_dtNavMeshCreateParams_get_tileLayer_0"]=_emscripten_bind_dtNavMeshCreateParams_get_tileLayer_0=wasmExports["vd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_tileLayer_1"]=_emscripten_bind_dtNavMeshCreateParams_set_tileLayer_1=wasmExports["wd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_bmin_1"]=_emscripten_bind_dtNavMeshCreateParams_get_bmin_1=wasmExports["xd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_bmin_2"]=_emscripten_bind_dtNavMeshCreateParams_set_bmin_2=wasmExports["yd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_bmax_1"]=_emscripten_bind_dtNavMeshCreateParams_get_bmax_1=wasmExports["zd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_bmax_2"]=_emscripten_bind_dtNavMeshCreateParams_set_bmax_2=wasmExports["Ad"];Module["_emscripten_bind_dtNavMeshCreateParams_get_walkableHeight_0"]=_emscripten_bind_dtNavMeshCreateParams_get_walkableHeight_0=wasmExports["Bd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_walkableHeight_1"]=_emscripten_bind_dtNavMeshCreateParams_set_walkableHeight_1=wasmExports["Cd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_walkableRadius_0"]=_emscripten_bind_dtNavMeshCreateParams_get_walkableRadius_0=wasmExports["Dd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_walkableRadius_1"]=_emscripten_bind_dtNavMeshCreateParams_set_walkableRadius_1=wasmExports["Ed"];Module["_emscripten_bind_dtNavMeshCreateParams_get_walkableClimb_0"]=_emscripten_bind_dtNavMeshCreateParams_get_walkableClimb_0=wasmExports["Fd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_walkableClimb_1"]=_emscripten_bind_dtNavMeshCreateParams_set_walkableClimb_1=wasmExports["Gd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_cs_0"]=_emscripten_bind_dtNavMeshCreateParams_get_cs_0=wasmExports["Hd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_cs_1"]=_emscripten_bind_dtNavMeshCreateParams_set_cs_1=wasmExports["Id"];Module["_emscripten_bind_dtNavMeshCreateParams_get_ch_0"]=_emscripten_bind_dtNavMeshCreateParams_get_ch_0=wasmExports["Jd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_ch_1"]=_emscripten_bind_dtNavMeshCreateParams_set_ch_1=wasmExports["Kd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_buildBvTree_0"]=_emscripten_bind_dtNavMeshCreateParams_get_buildBvTree_0=wasmExports["Ld"];Module["_emscripten_bind_dtNavMeshCreateParams_set_buildBvTree_1"]=_emscripten_bind_dtNavMeshCreateParams_set_buildBvTree_1=wasmExports["Md"];Module["_emscripten_bind_dtNavMeshCreateParams___destroy___0"]=_emscripten_bind_dtNavMeshCreateParams___destroy___0=wasmExports["Nd"];Module["_emscripten_bind_dtObstacleRef___destroy___0"]=_emscripten_bind_dtObstacleRef___destroy___0=wasmExports["Od"];Module["_emscripten_bind_dtCompressedTileRef___destroy___0"]=_emscripten_bind_dtCompressedTileRef___destroy___0=wasmExports["Pd"];Module["_emscripten_bind_dtNavMeshParams_dtNavMeshParams_0"]=_emscripten_bind_dtNavMeshParams_dtNavMeshParams_0=wasmExports["Qd"];Module["_emscripten_bind_dtNavMeshParams_get_orig_1"]=_emscripten_bind_dtNavMeshParams_get_orig_1=wasmExports["Rd"];Module["_emscripten_bind_dtNavMeshParams_set_orig_2"]=_emscripten_bind_dtNavMeshParams_set_orig_2=wasmExports["Sd"];Module["_emscripten_bind_dtNavMeshParams_get_tileWidth_0"]=_emscripten_bind_dtNavMeshParams_get_tileWidth_0=wasmExports["Td"];Module["_emscripten_bind_dtNavMeshParams_set_tileWidth_1"]=_emscripten_bind_dtNavMeshParams_set_tileWidth_1=wasmExports["Ud"];Module["_emscripten_bind_dtNavMeshParams_get_tileHeight_0"]=_emscripten_bind_dtNavMeshParams_get_tileHeight_0=wasmExports["Vd"];Module["_emscripten_bind_dtNavMeshParams_set_tileHeight_1"]=_emscripten_bind_dtNavMeshParams_set_tileHeight_1=wasmExports["Wd"];Module["_emscripten_bind_dtNavMeshParams_get_maxTiles_0"]=_emscripten_bind_dtNavMeshParams_get_maxTiles_0=wasmExports["Xd"];Module["_emscripten_bind_dtNavMeshParams_set_maxTiles_1"]=_emscripten_bind_dtNavMeshParams_set_maxTiles_1=wasmExports["Yd"];Module["_emscripten_bind_dtNavMeshParams_get_maxPolys_0"]=_emscripten_bind_dtNavMeshParams_get_maxPolys_0=wasmExports["Zd"];Module["_emscripten_bind_dtNavMeshParams_set_maxPolys_1"]=_emscripten_bind_dtNavMeshParams_set_maxPolys_1=wasmExports["_d"];Module["_emscripten_bind_dtNavMeshParams___destroy___0"]=_emscripten_bind_dtNavMeshParams___destroy___0=wasmExports["$d"];Module["_emscripten_bind_dtCrowdAgentParams_dtCrowdAgentParams_0"]=_emscripten_bind_dtCrowdAgentParams_dtCrowdAgentParams_0=wasmExports["ae"];Module["_emscripten_bind_dtCrowdAgentParams_get_radius_0"]=_emscripten_bind_dtCrowdAgentParams_get_radius_0=wasmExports["be"];Module["_emscripten_bind_dtCrowdAgentParams_set_radius_1"]=_emscripten_bind_dtCrowdAgentParams_set_radius_1=wasmExports["ce"];Module["_emscripten_bind_dtCrowdAgentParams_get_height_0"]=_emscripten_bind_dtCrowdAgentParams_get_height_0=wasmExports["de"];Module["_emscripten_bind_dtCrowdAgentParams_set_height_1"]=_emscripten_bind_dtCrowdAgentParams_set_height_1=wasmExports["ee"];Module["_emscripten_bind_dtCrowdAgentParams_get_maxAcceleration_0"]=_emscripten_bind_dtCrowdAgentParams_get_maxAcceleration_0=wasmExports["fe"];Module["_emscripten_bind_dtCrowdAgentParams_set_maxAcceleration_1"]=_emscripten_bind_dtCrowdAgentParams_set_maxAcceleration_1=wasmExports["ge"];Module["_emscripten_bind_dtCrowdAgentParams_get_maxSpeed_0"]=_emscripten_bind_dtCrowdAgentParams_get_maxSpeed_0=wasmExports["he"];Module["_emscripten_bind_dtCrowdAgentParams_set_maxSpeed_1"]=_emscripten_bind_dtCrowdAgentParams_set_maxSpeed_1=wasmExports["ie"];Module["_emscripten_bind_dtCrowdAgentParams_get_collisionQueryRange_0"]=_emscripten_bind_dtCrowdAgentParams_get_collisionQueryRange_0=wasmExports["je"];Module["_emscripten_bind_dtCrowdAgentParams_set_collisionQueryRange_1"]=_emscripten_bind_dtCrowdAgentParams_set_collisionQueryRange_1=wasmExports["ke"];Module["_emscripten_bind_dtCrowdAgentParams_get_pathOptimizationRange_0"]=_emscripten_bind_dtCrowdAgentParams_get_pathOptimizationRange_0=wasmExports["le"];Module["_emscripten_bind_dtCrowdAgentParams_set_pathOptimizationRange_1"]=_emscripten_bind_dtCrowdAgentParams_set_pathOptimizationRange_1=wasmExports["me"];Module["_emscripten_bind_dtCrowdAgentParams_get_separationWeight_0"]=_emscripten_bind_dtCrowdAgentParams_get_separationWeight_0=wasmExports["ne"];Module["_emscripten_bind_dtCrowdAgentParams_set_separationWeight_1"]=_emscripten_bind_dtCrowdAgentParams_set_separationWeight_1=wasmExports["oe"];Module["_emscripten_bind_dtCrowdAgentParams_get_updateFlags_0"]=_emscripten_bind_dtCrowdAgentParams_get_updateFlags_0=wasmExports["pe"];Module["_emscripten_bind_dtCrowdAgentParams_set_updateFlags_1"]=_emscripten_bind_dtCrowdAgentParams_set_updateFlags_1=wasmExports["qe"];Module["_emscripten_bind_dtCrowdAgentParams_get_obstacleAvoidanceType_0"]=_emscripten_bind_dtCrowdAgentParams_get_obstacleAvoidanceType_0=wasmExports["re"];Module["_emscripten_bind_dtCrowdAgentParams_set_obstacleAvoidanceType_1"]=_emscripten_bind_dtCrowdAgentParams_set_obstacleAvoidanceType_1=wasmExports["se"];Module["_emscripten_bind_dtCrowdAgentParams_get_queryFilterType_0"]=_emscripten_bind_dtCrowdAgentParams_get_queryFilterType_0=wasmExports["te"];Module["_emscripten_bind_dtCrowdAgentParams_set_queryFilterType_1"]=_emscripten_bind_dtCrowdAgentParams_set_queryFilterType_1=wasmExports["ue"];Module["_emscripten_bind_dtCrowdAgentParams_get_userData_0"]=_emscripten_bind_dtCrowdAgentParams_get_userData_0=wasmExports["ve"];Module["_emscripten_bind_dtCrowdAgentParams_set_userData_1"]=_emscripten_bind_dtCrowdAgentParams_set_userData_1=wasmExports["we"];Module["_emscripten_bind_dtCrowdAgentParams___destroy___0"]=_emscripten_bind_dtCrowdAgentParams___destroy___0=wasmExports["xe"];Module["_emscripten_bind_rcSpan_get_smin_0"]=_emscripten_bind_rcSpan_get_smin_0=wasmExports["ye"];Module["_emscripten_bind_rcSpan_set_smin_1"]=_emscripten_bind_rcSpan_set_smin_1=wasmExports["ze"];Module["_emscripten_bind_rcSpan_get_smax_0"]=_emscripten_bind_rcSpan_get_smax_0=wasmExports["Ae"];Module["_emscripten_bind_rcSpan_set_smax_1"]=_emscripten_bind_rcSpan_set_smax_1=wasmExports["Be"];Module["_emscripten_bind_rcSpan_get_area_0"]=_emscripten_bind_rcSpan_get_area_0=wasmExports["Ce"];Module["_emscripten_bind_rcSpan_set_area_1"]=_emscripten_bind_rcSpan_set_area_1=wasmExports["De"];Module["_emscripten_bind_rcSpan_get_next_0"]=_emscripten_bind_rcSpan_get_next_0=wasmExports["Ee"];Module["_emscripten_bind_rcSpan_set_next_1"]=_emscripten_bind_rcSpan_set_next_1=wasmExports["Fe"];Module["_emscripten_bind_rcSpan___destroy___0"]=_emscripten_bind_rcSpan___destroy___0=wasmExports["Ge"];Module["_emscripten_bind_rcSpanPool_get_next_0"]=_emscripten_bind_rcSpanPool_get_next_0=wasmExports["He"];Module["_emscripten_bind_rcSpanPool_set_next_1"]=_emscripten_bind_rcSpanPool_set_next_1=wasmExports["Ie"];Module["_emscripten_bind_rcSpanPool_get_items_1"]=_emscripten_bind_rcSpanPool_get_items_1=wasmExports["Je"];Module["_emscripten_bind_rcSpanPool_set_items_2"]=_emscripten_bind_rcSpanPool_set_items_2=wasmExports["Ke"];Module["_emscripten_bind_rcSpanPool___destroy___0"]=_emscripten_bind_rcSpanPool___destroy___0=wasmExports["Le"];Module["_emscripten_bind_rcHeightfield_get_width_0"]=_emscripten_bind_rcHeightfield_get_width_0=wasmExports["Me"];Module["_emscripten_bind_rcHeightfield_set_width_1"]=_emscripten_bind_rcHeightfield_set_width_1=wasmExports["Ne"];Module["_emscripten_bind_rcHeightfield_get_height_0"]=_emscripten_bind_rcHeightfield_get_height_0=wasmExports["Oe"];Module["_emscripten_bind_rcHeightfield_set_height_1"]=_emscripten_bind_rcHeightfield_set_height_1=wasmExports["Pe"];Module["_emscripten_bind_rcHeightfield_get_bmin_1"]=_emscripten_bind_rcHeightfield_get_bmin_1=wasmExports["Qe"];Module["_emscripten_bind_rcHeightfield_set_bmin_2"]=_emscripten_bind_rcHeightfield_set_bmin_2=wasmExports["Re"];Module["_emscripten_bind_rcHeightfield_get_bmax_1"]=_emscripten_bind_rcHeightfield_get_bmax_1=wasmExports["Se"];Module["_emscripten_bind_rcHeightfield_set_bmax_2"]=_emscripten_bind_rcHeightfield_set_bmax_2=wasmExports["Te"];Module["_emscripten_bind_rcHeightfield_get_cs_0"]=_emscripten_bind_rcHeightfield_get_cs_0=wasmExports["Ue"];Module["_emscripten_bind_rcHeightfield_set_cs_1"]=_emscripten_bind_rcHeightfield_set_cs_1=wasmExports["Ve"];Module["_emscripten_bind_rcHeightfield_get_ch_0"]=_emscripten_bind_rcHeightfield_get_ch_0=wasmExports["We"];Module["_emscripten_bind_rcHeightfield_set_ch_1"]=_emscripten_bind_rcHeightfield_set_ch_1=wasmExports["Xe"];Module["_emscripten_bind_rcHeightfield_get_spans_1"]=_emscripten_bind_rcHeightfield_get_spans_1=wasmExports["Ye"];Module["_emscripten_bind_rcHeightfield_set_spans_2"]=_emscripten_bind_rcHeightfield_set_spans_2=wasmExports["Ze"];Module["_emscripten_bind_rcHeightfield_get_pools_1"]=_emscripten_bind_rcHeightfield_get_pools_1=wasmExports["_e"];Module["_emscripten_bind_rcHeightfield_set_pools_2"]=_emscripten_bind_rcHeightfield_set_pools_2=wasmExports["$e"];Module["_emscripten_bind_rcHeightfield_get_freelist_1"]=_emscripten_bind_rcHeightfield_get_freelist_1=wasmExports["af"];Module["_emscripten_bind_rcHeightfield_set_freelist_2"]=_emscripten_bind_rcHeightfield_set_freelist_2=wasmExports["bf"];Module["_emscripten_bind_rcHeightfield___destroy___0"]=_emscripten_bind_rcHeightfield___destroy___0=wasmExports["cf"];Module["_emscripten_bind_rcCompactCell_get_index_0"]=_emscripten_bind_rcCompactCell_get_index_0=wasmExports["df"];Module["_emscripten_bind_rcCompactCell_set_index_1"]=_emscripten_bind_rcCompactCell_set_index_1=wasmExports["ef"];Module["_emscripten_bind_rcCompactCell_get_count_0"]=_emscripten_bind_rcCompactCell_get_count_0=wasmExports["ff"];Module["_emscripten_bind_rcCompactCell_set_count_1"]=_emscripten_bind_rcCompactCell_set_count_1=wasmExports["gf"];Module["_emscripten_bind_rcCompactCell___destroy___0"]=_emscripten_bind_rcCompactCell___destroy___0=wasmExports["hf"];Module["_emscripten_bind_rcCompactSpan_get_y_0"]=_emscripten_bind_rcCompactSpan_get_y_0=wasmExports["jf"];Module["_emscripten_bind_rcCompactSpan_set_y_1"]=_emscripten_bind_rcCompactSpan_set_y_1=wasmExports["kf"];Module["_emscripten_bind_rcCompactSpan_get_reg_0"]=_emscripten_bind_rcCompactSpan_get_reg_0=wasmExports["lf"];Module["_emscripten_bind_rcCompactSpan_set_reg_1"]=_emscripten_bind_rcCompactSpan_set_reg_1=wasmExports["mf"];Module["_emscripten_bind_rcCompactSpan_get_con_0"]=_emscripten_bind_rcCompactSpan_get_con_0=wasmExports["nf"];Module["_emscripten_bind_rcCompactSpan_set_con_1"]=_emscripten_bind_rcCompactSpan_set_con_1=wasmExports["of"];Module["_emscripten_bind_rcCompactSpan_get_h_0"]=_emscripten_bind_rcCompactSpan_get_h_0=wasmExports["pf"];Module["_emscripten_bind_rcCompactSpan_set_h_1"]=_emscripten_bind_rcCompactSpan_set_h_1=wasmExports["qf"];Module["_emscripten_bind_rcCompactSpan___destroy___0"]=_emscripten_bind_rcCompactSpan___destroy___0=wasmExports["rf"];Module["_emscripten_bind_rcCompactHeightfield_get_width_0"]=_emscripten_bind_rcCompactHeightfield_get_width_0=wasmExports["sf"];Module["_emscripten_bind_rcCompactHeightfield_set_width_1"]=_emscripten_bind_rcCompactHeightfield_set_width_1=wasmExports["tf"];Module["_emscripten_bind_rcCompactHeightfield_get_height_0"]=_emscripten_bind_rcCompactHeightfield_get_height_0=wasmExports["uf"];Module["_emscripten_bind_rcCompactHeightfield_set_height_1"]=_emscripten_bind_rcCompactHeightfield_set_height_1=wasmExports["vf"];Module["_emscripten_bind_rcCompactHeightfield_get_spanCount_0"]=_emscripten_bind_rcCompactHeightfield_get_spanCount_0=wasmExports["wf"];Module["_emscripten_bind_rcCompactHeightfield_set_spanCount_1"]=_emscripten_bind_rcCompactHeightfield_set_spanCount_1=wasmExports["xf"];Module["_emscripten_bind_rcCompactHeightfield_get_walkableHeight_0"]=_emscripten_bind_rcCompactHeightfield_get_walkableHeight_0=wasmExports["yf"];Module["_emscripten_bind_rcCompactHeightfield_set_walkableHeight_1"]=_emscripten_bind_rcCompactHeightfield_set_walkableHeight_1=wasmExports["zf"];Module["_emscripten_bind_rcCompactHeightfield_get_walkableClimb_0"]=_emscripten_bind_rcCompactHeightfield_get_walkableClimb_0=wasmExports["Af"];Module["_emscripten_bind_rcCompactHeightfield_set_walkableClimb_1"]=_emscripten_bind_rcCompactHeightfield_set_walkableClimb_1=wasmExports["Bf"];Module["_emscripten_bind_rcCompactHeightfield_get_borderSize_0"]=_emscripten_bind_rcCompactHeightfield_get_borderSize_0=wasmExports["Cf"];Module["_emscripten_bind_rcCompactHeightfield_set_borderSize_1"]=_emscripten_bind_rcCompactHeightfield_set_borderSize_1=wasmExports["Df"];Module["_emscripten_bind_rcCompactHeightfield_get_maxDistance_0"]=_emscripten_bind_rcCompactHeightfield_get_maxDistance_0=wasmExports["Ef"];Module["_emscripten_bind_rcCompactHeightfield_set_maxDistance_1"]=_emscripten_bind_rcCompactHeightfield_set_maxDistance_1=wasmExports["Ff"];Module["_emscripten_bind_rcCompactHeightfield_get_maxRegions_0"]=_emscripten_bind_rcCompactHeightfield_get_maxRegions_0=wasmExports["Gf"];Module["_emscripten_bind_rcCompactHeightfield_set_maxRegions_1"]=_emscripten_bind_rcCompactHeightfield_set_maxRegions_1=wasmExports["Hf"];Module["_emscripten_bind_rcCompactHeightfield_get_bmin_1"]=_emscripten_bind_rcCompactHeightfield_get_bmin_1=wasmExports["If"];Module["_emscripten_bind_rcCompactHeightfield_set_bmin_2"]=_emscripten_bind_rcCompactHeightfield_set_bmin_2=wasmExports["Jf"];Module["_emscripten_bind_rcCompactHeightfield_get_bmax_1"]=_emscripten_bind_rcCompactHeightfield_get_bmax_1=wasmExports["Kf"];Module["_emscripten_bind_rcCompactHeightfield_set_bmax_2"]=_emscripten_bind_rcCompactHeightfield_set_bmax_2=wasmExports["Lf"];Module["_emscripten_bind_rcCompactHeightfield_get_cs_0"]=_emscripten_bind_rcCompactHeightfield_get_cs_0=wasmExports["Mf"];Module["_emscripten_bind_rcCompactHeightfield_set_cs_1"]=_emscripten_bind_rcCompactHeightfield_set_cs_1=wasmExports["Nf"];Module["_emscripten_bind_rcCompactHeightfield_get_ch_0"]=_emscripten_bind_rcCompactHeightfield_get_ch_0=wasmExports["Of"];Module["_emscripten_bind_rcCompactHeightfield_set_ch_1"]=_emscripten_bind_rcCompactHeightfield_set_ch_1=wasmExports["Pf"];Module["_emscripten_bind_rcCompactHeightfield_get_cells_1"]=_emscripten_bind_rcCompactHeightfield_get_cells_1=wasmExports["Qf"];Module["_emscripten_bind_rcCompactHeightfield_set_cells_2"]=_emscripten_bind_rcCompactHeightfield_set_cells_2=wasmExports["Rf"];Module["_emscripten_bind_rcCompactHeightfield_get_spans_1"]=_emscripten_bind_rcCompactHeightfield_get_spans_1=wasmExports["Sf"];Module["_emscripten_bind_rcCompactHeightfield_set_spans_2"]=_emscripten_bind_rcCompactHeightfield_set_spans_2=wasmExports["Tf"];Module["_emscripten_bind_rcCompactHeightfield_get_dist_1"]=_emscripten_bind_rcCompactHeightfield_get_dist_1=wasmExports["Uf"];Module["_emscripten_bind_rcCompactHeightfield_set_dist_2"]=_emscripten_bind_rcCompactHeightfield_set_dist_2=wasmExports["Vf"];Module["_emscripten_bind_rcCompactHeightfield_get_areas_1"]=_emscripten_bind_rcCompactHeightfield_get_areas_1=wasmExports["Wf"];Module["_emscripten_bind_rcCompactHeightfield_set_areas_2"]=_emscripten_bind_rcCompactHeightfield_set_areas_2=wasmExports["Xf"];Module["_emscripten_bind_rcCompactHeightfield___destroy___0"]=_emscripten_bind_rcCompactHeightfield___destroy___0=wasmExports["Yf"];Module["_emscripten_bind_rcContour_get_verts_1"]=_emscripten_bind_rcContour_get_verts_1=wasmExports["Zf"];Module["_emscripten_bind_rcContour_set_verts_2"]=_emscripten_bind_rcContour_set_verts_2=wasmExports["_f"];Module["_emscripten_bind_rcContour_get_nverts_0"]=_emscripten_bind_rcContour_get_nverts_0=wasmExports["$f"];Module["_emscripten_bind_rcContour_set_nverts_1"]=_emscripten_bind_rcContour_set_nverts_1=wasmExports["ag"];Module["_emscripten_bind_rcContour_get_rverts_1"]=_emscripten_bind_rcContour_get_rverts_1=wasmExports["bg"];Module["_emscripten_bind_rcContour_set_rverts_2"]=_emscripten_bind_rcContour_set_rverts_2=wasmExports["cg"];Module["_emscripten_bind_rcContour_get_nrverts_0"]=_emscripten_bind_rcContour_get_nrverts_0=wasmExports["dg"];Module["_emscripten_bind_rcContour_set_nrverts_1"]=_emscripten_bind_rcContour_set_nrverts_1=wasmExports["eg"];Module["_emscripten_bind_rcContour_get_reg_0"]=_emscripten_bind_rcContour_get_reg_0=wasmExports["fg"];Module["_emscripten_bind_rcContour_set_reg_1"]=_emscripten_bind_rcContour_set_reg_1=wasmExports["gg"];Module["_emscripten_bind_rcContour_get_area_0"]=_emscripten_bind_rcContour_get_area_0=wasmExports["hg"];Module["_emscripten_bind_rcContour_set_area_1"]=_emscripten_bind_rcContour_set_area_1=wasmExports["ig"];Module["_emscripten_bind_rcContour___destroy___0"]=_emscripten_bind_rcContour___destroy___0=wasmExports["jg"];Module["_emscripten_bind_rcContourSet_get_conts_1"]=_emscripten_bind_rcContourSet_get_conts_1=wasmExports["kg"];Module["_emscripten_bind_rcContourSet_set_conts_2"]=_emscripten_bind_rcContourSet_set_conts_2=wasmExports["lg"];Module["_emscripten_bind_rcContourSet_get_nconts_0"]=_emscripten_bind_rcContourSet_get_nconts_0=wasmExports["mg"];Module["_emscripten_bind_rcContourSet_set_nconts_1"]=_emscripten_bind_rcContourSet_set_nconts_1=wasmExports["ng"];Module["_emscripten_bind_rcContourSet_get_bmin_1"]=_emscripten_bind_rcContourSet_get_bmin_1=wasmExports["og"];Module["_emscripten_bind_rcContourSet_set_bmin_2"]=_emscripten_bind_rcContourSet_set_bmin_2=wasmExports["pg"];Module["_emscripten_bind_rcContourSet_get_bmax_1"]=_emscripten_bind_rcContourSet_get_bmax_1=wasmExports["qg"];Module["_emscripten_bind_rcContourSet_set_bmax_2"]=_emscripten_bind_rcContourSet_set_bmax_2=wasmExports["rg"];Module["_emscripten_bind_rcContourSet_get_cs_0"]=_emscripten_bind_rcContourSet_get_cs_0=wasmExports["sg"];Module["_emscripten_bind_rcContourSet_set_cs_1"]=_emscripten_bind_rcContourSet_set_cs_1=wasmExports["tg"];Module["_emscripten_bind_rcContourSet_get_ch_0"]=_emscripten_bind_rcContourSet_get_ch_0=wasmExports["ug"];Module["_emscripten_bind_rcContourSet_set_ch_1"]=_emscripten_bind_rcContourSet_set_ch_1=wasmExports["vg"];Module["_emscripten_bind_rcContourSet_get_width_0"]=_emscripten_bind_rcContourSet_get_width_0=wasmExports["wg"];Module["_emscripten_bind_rcContourSet_set_width_1"]=_emscripten_bind_rcContourSet_set_width_1=wasmExports["xg"];Module["_emscripten_bind_rcContourSet_get_height_0"]=_emscripten_bind_rcContourSet_get_height_0=wasmExports["yg"];Module["_emscripten_bind_rcContourSet_set_height_1"]=_emscripten_bind_rcContourSet_set_height_1=wasmExports["zg"];Module["_emscripten_bind_rcContourSet_get_borderSize_0"]=_emscripten_bind_rcContourSet_get_borderSize_0=wasmExports["Ag"];Module["_emscripten_bind_rcContourSet_set_borderSize_1"]=_emscripten_bind_rcContourSet_set_borderSize_1=wasmExports["Bg"];Module["_emscripten_bind_rcContourSet_get_maxError_0"]=_emscripten_bind_rcContourSet_get_maxError_0=wasmExports["Cg"];Module["_emscripten_bind_rcContourSet_set_maxError_1"]=_emscripten_bind_rcContourSet_set_maxError_1=wasmExports["Dg"];Module["_emscripten_bind_rcContourSet___destroy___0"]=_emscripten_bind_rcContourSet___destroy___0=wasmExports["Eg"];Module["_emscripten_bind_rcHeightfieldLayer_get_bmin_1"]=_emscripten_bind_rcHeightfieldLayer_get_bmin_1=wasmExports["Fg"];Module["_emscripten_bind_rcHeightfieldLayer_set_bmin_2"]=_emscripten_bind_rcHeightfieldLayer_set_bmin_2=wasmExports["Gg"];Module["_emscripten_bind_rcHeightfieldLayer_get_bmax_1"]=_emscripten_bind_rcHeightfieldLayer_get_bmax_1=wasmExports["Hg"];Module["_emscripten_bind_rcHeightfieldLayer_set_bmax_2"]=_emscripten_bind_rcHeightfieldLayer_set_bmax_2=wasmExports["Ig"];Module["_emscripten_bind_rcHeightfieldLayer_get_cs_0"]=_emscripten_bind_rcHeightfieldLayer_get_cs_0=wasmExports["Jg"];Module["_emscripten_bind_rcHeightfieldLayer_set_cs_1"]=_emscripten_bind_rcHeightfieldLayer_set_cs_1=wasmExports["Kg"];Module["_emscripten_bind_rcHeightfieldLayer_get_ch_0"]=_emscripten_bind_rcHeightfieldLayer_get_ch_0=wasmExports["Lg"];Module["_emscripten_bind_rcHeightfieldLayer_set_ch_1"]=_emscripten_bind_rcHeightfieldLayer_set_ch_1=wasmExports["Mg"];Module["_emscripten_bind_rcHeightfieldLayer_get_width_0"]=_emscripten_bind_rcHeightfieldLayer_get_width_0=wasmExports["Ng"];Module["_emscripten_bind_rcHeightfieldLayer_set_width_1"]=_emscripten_bind_rcHeightfieldLayer_set_width_1=wasmExports["Og"];Module["_emscripten_bind_rcHeightfieldLayer_get_height_0"]=_emscripten_bind_rcHeightfieldLayer_get_height_0=wasmExports["Pg"];Module["_emscripten_bind_rcHeightfieldLayer_set_height_1"]=_emscripten_bind_rcHeightfieldLayer_set_height_1=wasmExports["Qg"];Module["_emscripten_bind_rcHeightfieldLayer_get_minx_0"]=_emscripten_bind_rcHeightfieldLayer_get_minx_0=wasmExports["Rg"];Module["_emscripten_bind_rcHeightfieldLayer_set_minx_1"]=_emscripten_bind_rcHeightfieldLayer_set_minx_1=wasmExports["Sg"];Module["_emscripten_bind_rcHeightfieldLayer_get_maxx_0"]=_emscripten_bind_rcHeightfieldLayer_get_maxx_0=wasmExports["Tg"];Module["_emscripten_bind_rcHeightfieldLayer_set_maxx_1"]=_emscripten_bind_rcHeightfieldLayer_set_maxx_1=wasmExports["Ug"];Module["_emscripten_bind_rcHeightfieldLayer_get_miny_0"]=_emscripten_bind_rcHeightfieldLayer_get_miny_0=wasmExports["Vg"];Module["_emscripten_bind_rcHeightfieldLayer_set_miny_1"]=_emscripten_bind_rcHeightfieldLayer_set_miny_1=wasmExports["Wg"];Module["_emscripten_bind_rcHeightfieldLayer_get_maxy_0"]=_emscripten_bind_rcHeightfieldLayer_get_maxy_0=wasmExports["Xg"];Module["_emscripten_bind_rcHeightfieldLayer_set_maxy_1"]=_emscripten_bind_rcHeightfieldLayer_set_maxy_1=wasmExports["Yg"];Module["_emscripten_bind_rcHeightfieldLayer_get_hmin_0"]=_emscripten_bind_rcHeightfieldLayer_get_hmin_0=wasmExports["Zg"];Module["_emscripten_bind_rcHeightfieldLayer_set_hmin_1"]=_emscripten_bind_rcHeightfieldLayer_set_hmin_1=wasmExports["_g"];Module["_emscripten_bind_rcHeightfieldLayer_get_hmax_0"]=_emscripten_bind_rcHeightfieldLayer_get_hmax_0=wasmExports["$g"];Module["_emscripten_bind_rcHeightfieldLayer_set_hmax_1"]=_emscripten_bind_rcHeightfieldLayer_set_hmax_1=wasmExports["ah"];Module["_emscripten_bind_rcHeightfieldLayer_get_heights_1"]=_emscripten_bind_rcHeightfieldLayer_get_heights_1=wasmExports["bh"];Module["_emscripten_bind_rcHeightfieldLayer_set_heights_2"]=_emscripten_bind_rcHeightfieldLayer_set_heights_2=wasmExports["ch"];Module["_emscripten_bind_rcHeightfieldLayer_get_areas_1"]=_emscripten_bind_rcHeightfieldLayer_get_areas_1=wasmExports["dh"];Module["_emscripten_bind_rcHeightfieldLayer_set_areas_2"]=_emscripten_bind_rcHeightfieldLayer_set_areas_2=wasmExports["eh"];Module["_emscripten_bind_rcHeightfieldLayer_get_cons_1"]=_emscripten_bind_rcHeightfieldLayer_get_cons_1=wasmExports["fh"];Module["_emscripten_bind_rcHeightfieldLayer_set_cons_2"]=_emscripten_bind_rcHeightfieldLayer_set_cons_2=wasmExports["gh"];Module["_emscripten_bind_rcHeightfieldLayer___destroy___0"]=_emscripten_bind_rcHeightfieldLayer___destroy___0=wasmExports["hh"];Module["_emscripten_bind_rcHeightfieldLayerSet_get_layers_1"]=_emscripten_bind_rcHeightfieldLayerSet_get_layers_1=wasmExports["ih"];Module["_emscripten_bind_rcHeightfieldLayerSet_set_layers_2"]=_emscripten_bind_rcHeightfieldLayerSet_set_layers_2=wasmExports["jh"];Module["_emscripten_bind_rcHeightfieldLayerSet_get_nlayers_0"]=_emscripten_bind_rcHeightfieldLayerSet_get_nlayers_0=wasmExports["kh"];Module["_emscripten_bind_rcHeightfieldLayerSet_set_nlayers_1"]=_emscripten_bind_rcHeightfieldLayerSet_set_nlayers_1=wasmExports["lh"];Module["_emscripten_bind_rcHeightfieldLayerSet___destroy___0"]=_emscripten_bind_rcHeightfieldLayerSet___destroy___0=wasmExports["mh"];Module["_emscripten_bind_rcPolyMesh_get_verts_1"]=_emscripten_bind_rcPolyMesh_get_verts_1=wasmExports["nh"];Module["_emscripten_bind_rcPolyMesh_set_verts_2"]=_emscripten_bind_rcPolyMesh_set_verts_2=wasmExports["oh"];Module["_emscripten_bind_rcPolyMesh_get_polys_1"]=_emscripten_bind_rcPolyMesh_get_polys_1=wasmExports["ph"];Module["_emscripten_bind_rcPolyMesh_set_polys_2"]=_emscripten_bind_rcPolyMesh_set_polys_2=wasmExports["qh"];Module["_emscripten_bind_rcPolyMesh_get_regs_1"]=_emscripten_bind_rcPolyMesh_get_regs_1=wasmExports["rh"];Module["_emscripten_bind_rcPolyMesh_set_regs_2"]=_emscripten_bind_rcPolyMesh_set_regs_2=wasmExports["sh"];Module["_emscripten_bind_rcPolyMesh_get_flags_1"]=_emscripten_bind_rcPolyMesh_get_flags_1=wasmExports["th"];Module["_emscripten_bind_rcPolyMesh_set_flags_2"]=_emscripten_bind_rcPolyMesh_set_flags_2=wasmExports["uh"];Module["_emscripten_bind_rcPolyMesh_get_areas_1"]=_emscripten_bind_rcPolyMesh_get_areas_1=wasmExports["vh"];Module["_emscripten_bind_rcPolyMesh_set_areas_2"]=_emscripten_bind_rcPolyMesh_set_areas_2=wasmExports["wh"];Module["_emscripten_bind_rcPolyMesh_get_nverts_0"]=_emscripten_bind_rcPolyMesh_get_nverts_0=wasmExports["xh"];Module["_emscripten_bind_rcPolyMesh_set_nverts_1"]=_emscripten_bind_rcPolyMesh_set_nverts_1=wasmExports["yh"];Module["_emscripten_bind_rcPolyMesh_get_npolys_0"]=_emscripten_bind_rcPolyMesh_get_npolys_0=wasmExports["zh"];Module["_emscripten_bind_rcPolyMesh_set_npolys_1"]=_emscripten_bind_rcPolyMesh_set_npolys_1=wasmExports["Ah"];Module["_emscripten_bind_rcPolyMesh_get_maxpolys_0"]=_emscripten_bind_rcPolyMesh_get_maxpolys_0=wasmExports["Bh"];Module["_emscripten_bind_rcPolyMesh_set_maxpolys_1"]=_emscripten_bind_rcPolyMesh_set_maxpolys_1=wasmExports["Ch"];Module["_emscripten_bind_rcPolyMesh_get_nvp_0"]=_emscripten_bind_rcPolyMesh_get_nvp_0=wasmExports["Dh"];Module["_emscripten_bind_rcPolyMesh_set_nvp_1"]=_emscripten_bind_rcPolyMesh_set_nvp_1=wasmExports["Eh"];Module["_emscripten_bind_rcPolyMesh_get_bmin_1"]=_emscripten_bind_rcPolyMesh_get_bmin_1=wasmExports["Fh"];Module["_emscripten_bind_rcPolyMesh_set_bmin_2"]=_emscripten_bind_rcPolyMesh_set_bmin_2=wasmExports["Gh"];Module["_emscripten_bind_rcPolyMesh_get_bmax_1"]=_emscripten_bind_rcPolyMesh_get_bmax_1=wasmExports["Hh"];Module["_emscripten_bind_rcPolyMesh_set_bmax_2"]=_emscripten_bind_rcPolyMesh_set_bmax_2=wasmExports["Ih"];Module["_emscripten_bind_rcPolyMesh_get_cs_0"]=_emscripten_bind_rcPolyMesh_get_cs_0=wasmExports["Jh"];Module["_emscripten_bind_rcPolyMesh_set_cs_1"]=_emscripten_bind_rcPolyMesh_set_cs_1=wasmExports["Kh"];Module["_emscripten_bind_rcPolyMesh_get_ch_0"]=_emscripten_bind_rcPolyMesh_get_ch_0=wasmExports["Lh"];Module["_emscripten_bind_rcPolyMesh_set_ch_1"]=_emscripten_bind_rcPolyMesh_set_ch_1=wasmExports["Mh"];Module["_emscripten_bind_rcPolyMesh_get_borderSize_0"]=_emscripten_bind_rcPolyMesh_get_borderSize_0=wasmExports["Nh"];Module["_emscripten_bind_rcPolyMesh_set_borderSize_1"]=_emscripten_bind_rcPolyMesh_set_borderSize_1=wasmExports["Oh"];Module["_emscripten_bind_rcPolyMesh_get_maxEdgeError_0"]=_emscripten_bind_rcPolyMesh_get_maxEdgeError_0=wasmExports["Ph"];Module["_emscripten_bind_rcPolyMesh_set_maxEdgeError_1"]=_emscripten_bind_rcPolyMesh_set_maxEdgeError_1=wasmExports["Qh"];Module["_emscripten_bind_rcPolyMesh___destroy___0"]=_emscripten_bind_rcPolyMesh___destroy___0=wasmExports["Rh"];Module["_emscripten_bind_rcPolyMeshDetail_get_meshes_1"]=_emscripten_bind_rcPolyMeshDetail_get_meshes_1=wasmExports["Sh"];Module["_emscripten_bind_rcPolyMeshDetail_set_meshes_2"]=_emscripten_bind_rcPolyMeshDetail_set_meshes_2=wasmExports["Th"];Module["_emscripten_bind_rcPolyMeshDetail_get_verts_1"]=_emscripten_bind_rcPolyMeshDetail_get_verts_1=wasmExports["Uh"];Module["_emscripten_bind_rcPolyMeshDetail_set_verts_2"]=_emscripten_bind_rcPolyMeshDetail_set_verts_2=wasmExports["Vh"];Module["_emscripten_bind_rcPolyMeshDetail_get_tris_1"]=_emscripten_bind_rcPolyMeshDetail_get_tris_1=wasmExports["Wh"];Module["_emscripten_bind_rcPolyMeshDetail_set_tris_2"]=_emscripten_bind_rcPolyMeshDetail_set_tris_2=wasmExports["Xh"];Module["_emscripten_bind_rcPolyMeshDetail_get_nmeshes_0"]=_emscripten_bind_rcPolyMeshDetail_get_nmeshes_0=wasmExports["Yh"];Module["_emscripten_bind_rcPolyMeshDetail_set_nmeshes_1"]=_emscripten_bind_rcPolyMeshDetail_set_nmeshes_1=wasmExports["Zh"];Module["_emscripten_bind_rcPolyMeshDetail_get_nverts_0"]=_emscripten_bind_rcPolyMeshDetail_get_nverts_0=wasmExports["_h"];Module["_emscripten_bind_rcPolyMeshDetail_set_nverts_1"]=_emscripten_bind_rcPolyMeshDetail_set_nverts_1=wasmExports["$h"];Module["_emscripten_bind_rcPolyMeshDetail_get_ntris_0"]=_emscripten_bind_rcPolyMeshDetail_get_ntris_0=wasmExports["ai"];Module["_emscripten_bind_rcPolyMeshDetail_set_ntris_1"]=_emscripten_bind_rcPolyMeshDetail_set_ntris_1=wasmExports["bi"];Module["_emscripten_bind_rcPolyMeshDetail___destroy___0"]=_emscripten_bind_rcPolyMeshDetail___destroy___0=wasmExports["ci"];Module["_emscripten_bind_Vec3_Vec3_0"]=_emscripten_bind_Vec3_Vec3_0=wasmExports["di"];Module["_emscripten_bind_Vec3_Vec3_3"]=_emscripten_bind_Vec3_Vec3_3=wasmExports["ei"];Module["_emscripten_bind_Vec3_get_x_0"]=_emscripten_bind_Vec3_get_x_0=wasmExports["fi"];Module["_emscripten_bind_Vec3_set_x_1"]=_emscripten_bind_Vec3_set_x_1=wasmExports["gi"];Module["_emscripten_bind_Vec3_get_y_0"]=_emscripten_bind_Vec3_get_y_0=wasmExports["hi"];Module["_emscripten_bind_Vec3_set_y_1"]=_emscripten_bind_Vec3_set_y_1=wasmExports["ii"];Module["_emscripten_bind_Vec3_get_z_0"]=_emscripten_bind_Vec3_get_z_0=wasmExports["ji"];Module["_emscripten_bind_Vec3_set_z_1"]=_emscripten_bind_Vec3_set_z_1=wasmExports["ki"];Module["_emscripten_bind_Vec3___destroy___0"]=_emscripten_bind_Vec3___destroy___0=wasmExports["li"];Module["_emscripten_bind_NavMeshRemoveTileResult_get_status_0"]=_emscripten_bind_NavMeshRemoveTileResult_get_status_0=wasmExports["mi"];Module["_emscripten_bind_NavMeshRemoveTileResult_set_status_1"]=_emscripten_bind_NavMeshRemoveTileResult_set_status_1=wasmExports["ni"];Module["_emscripten_bind_NavMeshRemoveTileResult_get_data_1"]=_emscripten_bind_NavMeshRemoveTileResult_get_data_1=wasmExports["oi"];Module["_emscripten_bind_NavMeshRemoveTileResult_set_data_2"]=_emscripten_bind_NavMeshRemoveTileResult_set_data_2=wasmExports["pi"];Module["_emscripten_bind_NavMeshRemoveTileResult_get_dataSize_0"]=_emscripten_bind_NavMeshRemoveTileResult_get_dataSize_0=wasmExports["qi"];Module["_emscripten_bind_NavMeshRemoveTileResult_set_dataSize_1"]=_emscripten_bind_NavMeshRemoveTileResult_set_dataSize_1=wasmExports["ri"];Module["_emscripten_bind_NavMeshRemoveTileResult___destroy___0"]=_emscripten_bind_NavMeshRemoveTileResult___destroy___0=wasmExports["si"];Module["_emscripten_bind_NavMeshCalcTileLocResult_get_tileX_0"]=_emscripten_bind_NavMeshCalcTileLocResult_get_tileX_0=wasmExports["ti"];Module["_emscripten_bind_NavMeshCalcTileLocResult_set_tileX_1"]=_emscripten_bind_NavMeshCalcTileLocResult_set_tileX_1=wasmExports["ui"];Module["_emscripten_bind_NavMeshCalcTileLocResult_get_tileY_0"]=_emscripten_bind_NavMeshCalcTileLocResult_get_tileY_0=wasmExports["vi"];Module["_emscripten_bind_NavMeshCalcTileLocResult_set_tileY_1"]=_emscripten_bind_NavMeshCalcTileLocResult_set_tileY_1=wasmExports["wi"];Module["_emscripten_bind_NavMeshCalcTileLocResult___destroy___0"]=_emscripten_bind_NavMeshCalcTileLocResult___destroy___0=wasmExports["xi"];Module["_emscripten_bind_NavMeshGetTilesAtResult_get_tiles_1"]=_emscripten_bind_NavMeshGetTilesAtResult_get_tiles_1=wasmExports["yi"];Module["_emscripten_bind_NavMeshGetTilesAtResult_get_tileCount_0"]=_emscripten_bind_NavMeshGetTilesAtResult_get_tileCount_0=wasmExports["zi"];Module["_emscripten_bind_NavMeshGetTilesAtResult_set_tileCount_1"]=_emscripten_bind_NavMeshGetTilesAtResult_set_tileCount_1=wasmExports["Ai"];Module["_emscripten_bind_NavMeshGetTilesAtResult___destroy___0"]=_emscripten_bind_NavMeshGetTilesAtResult___destroy___0=wasmExports["Bi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_status_0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_status_0=wasmExports["Ci"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_status_1"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_status_1=wasmExports["Di"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_tile_0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_tile_0=wasmExports["Ei"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_tile_1"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_tile_1=wasmExports["Fi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_poly_0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_poly_0=wasmExports["Gi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_poly_1"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_poly_1=wasmExports["Hi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult___destroy___0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult___destroy___0=wasmExports["Ii"];Module["_emscripten_bind_NavMeshStoreTileStateResult_get_status_0"]=_emscripten_bind_NavMeshStoreTileStateResult_get_status_0=wasmExports["Ji"];Module["_emscripten_bind_NavMeshStoreTileStateResult_set_status_1"]=_emscripten_bind_NavMeshStoreTileStateResult_set_status_1=wasmExports["Ki"];Module["_emscripten_bind_NavMeshStoreTileStateResult_get_data_1"]=_emscripten_bind_NavMeshStoreTileStateResult_get_data_1=wasmExports["Li"];Module["_emscripten_bind_NavMeshStoreTileStateResult_set_data_2"]=_emscripten_bind_NavMeshStoreTileStateResult_set_data_2=wasmExports["Mi"];Module["_emscripten_bind_NavMeshStoreTileStateResult_get_dataSize_0"]=_emscripten_bind_NavMeshStoreTileStateResult_get_dataSize_0=wasmExports["Ni"];Module["_emscripten_bind_NavMeshStoreTileStateResult_set_dataSize_1"]=_emscripten_bind_NavMeshStoreTileStateResult_set_dataSize_1=wasmExports["Oi"];Module["_emscripten_bind_NavMeshStoreTileStateResult___destroy___0"]=_emscripten_bind_NavMeshStoreTileStateResult___destroy___0=wasmExports["Pi"];Module["_emscripten_bind_NavMesh_NavMesh_0"]=_emscripten_bind_NavMesh_NavMesh_0=wasmExports["Qi"];Module["_emscripten_bind_NavMesh_NavMesh_1"]=_emscripten_bind_NavMesh_NavMesh_1=wasmExports["Ri"];Module["_emscripten_bind_NavMesh_initSolo_1"]=_emscripten_bind_NavMesh_initSolo_1=wasmExports["Si"];Module["_emscripten_bind_NavMesh_initTiled_1"]=_emscripten_bind_NavMesh_initTiled_1=wasmExports["Ti"];Module["_emscripten_bind_NavMesh_addTile_4"]=_emscripten_bind_NavMesh_addTile_4=wasmExports["Ui"];Module["_emscripten_bind_NavMesh_decodePolyId_4"]=_emscripten_bind_NavMesh_decodePolyId_4=wasmExports["Vi"];Module["_emscripten_bind_NavMesh_encodePolyId_3"]=_emscripten_bind_NavMesh_encodePolyId_3=wasmExports["Wi"];Module["_emscripten_bind_NavMesh_removeTile_1"]=_emscripten_bind_NavMesh_removeTile_1=wasmExports["Xi"];Module["_emscripten_bind_NavMesh_getNavMesh_0"]=_emscripten_bind_NavMesh_getNavMesh_0=wasmExports["Yi"];Module["_emscripten_bind_NavMesh_calcTileLoc_1"]=_emscripten_bind_NavMesh_calcTileLoc_1=wasmExports["Zi"];Module["_emscripten_bind_NavMesh_getTileAt_3"]=_emscripten_bind_NavMesh_getTileAt_3=wasmExports["_i"];Module["_emscripten_bind_NavMesh_getTilesAt_3"]=_emscripten_bind_NavMesh_getTilesAt_3=wasmExports["$i"];Module["_emscripten_bind_NavMesh_getTileRefAt_3"]=_emscripten_bind_NavMesh_getTileRefAt_3=wasmExports["aj"];Module["_emscripten_bind_NavMesh_getTileRef_1"]=_emscripten_bind_NavMesh_getTileRef_1=wasmExports["bj"];Module["_emscripten_bind_NavMesh_getTileByRef_1"]=_emscripten_bind_NavMesh_getTileByRef_1=wasmExports["cj"];Module["_emscripten_bind_NavMesh_getMaxTiles_0"]=_emscripten_bind_NavMesh_getMaxTiles_0=wasmExports["dj"];Module["_emscripten_bind_NavMesh_getTile_1"]=_emscripten_bind_NavMesh_getTile_1=wasmExports["ej"];Module["_emscripten_bind_NavMesh_getTileAndPolyByRef_1"]=_emscripten_bind_NavMesh_getTileAndPolyByRef_1=wasmExports["fj"];Module["_emscripten_bind_NavMesh_getTileAndPolyByRefUnsafe_1"]=_emscripten_bind_NavMesh_getTileAndPolyByRefUnsafe_1=wasmExports["gj"];Module["_emscripten_bind_NavMesh_isValidPolyRef_1"]=_emscripten_bind_NavMesh_isValidPolyRef_1=wasmExports["hj"];Module["_emscripten_bind_NavMesh_getPolyRefBase_1"]=_emscripten_bind_NavMesh_getPolyRefBase_1=wasmExports["ij"];Module["_emscripten_bind_NavMesh_getOffMeshConnectionPolyEndPoints_4"]=_emscripten_bind_NavMesh_getOffMeshConnectionPolyEndPoints_4=wasmExports["jj"];Module["_emscripten_bind_NavMesh_getOffMeshConnectionByRef_1"]=_emscripten_bind_NavMesh_getOffMeshConnectionByRef_1=wasmExports["kj"];Module["_emscripten_bind_NavMesh_setPolyFlags_2"]=_emscripten_bind_NavMesh_setPolyFlags_2=wasmExports["lj"];Module["_emscripten_bind_NavMesh_getPolyFlags_2"]=_emscripten_bind_NavMesh_getPolyFlags_2=wasmExports["mj"];Module["_emscripten_bind_NavMesh_setPolyArea_2"]=_emscripten_bind_NavMesh_setPolyArea_2=wasmExports["nj"];Module["_emscripten_bind_NavMesh_getPolyArea_2"]=_emscripten_bind_NavMesh_getPolyArea_2=wasmExports["oj"];Module["_emscripten_bind_NavMesh_getTileStateSize_1"]=_emscripten_bind_NavMesh_getTileStateSize_1=wasmExports["pj"];Module["_emscripten_bind_NavMesh_storeTileState_2"]=_emscripten_bind_NavMesh_storeTileState_2=wasmExports["qj"];Module["_emscripten_bind_NavMesh_restoreTileState_3"]=_emscripten_bind_NavMesh_restoreTileState_3=wasmExports["rj"];Module["_emscripten_bind_NavMesh_destroy_0"]=_emscripten_bind_NavMesh_destroy_0=wasmExports["sj"];Module["_emscripten_bind_NavMesh_get_m_navMesh_0"]=_emscripten_bind_NavMesh_get_m_navMesh_0=wasmExports["tj"];Module["_emscripten_bind_NavMesh_set_m_navMesh_1"]=_emscripten_bind_NavMesh_set_m_navMesh_1=wasmExports["uj"];Module["_emscripten_bind_NavMesh___destroy___0"]=_emscripten_bind_NavMesh___destroy___0=wasmExports["vj"];Module["_emscripten_bind_FastRand_getSeed_0"]=_emscripten_bind_FastRand_getSeed_0=wasmExports["wj"];Module["_emscripten_bind_FastRand_setSeed_1"]=_emscripten_bind_FastRand_setSeed_1=wasmExports["xj"];Module["_emscripten_bind_FastRand___destroy___0"]=_emscripten_bind_FastRand___destroy___0=wasmExports["yj"];Module["_emscripten_bind_dtRaycastHit_dtRaycastHit_0"]=_emscripten_bind_dtRaycastHit_dtRaycastHit_0=wasmExports["zj"];Module["_emscripten_bind_dtRaycastHit_get_t_0"]=_emscripten_bind_dtRaycastHit_get_t_0=wasmExports["Aj"];Module["_emscripten_bind_dtRaycastHit_set_t_1"]=_emscripten_bind_dtRaycastHit_set_t_1=wasmExports["Bj"];Module["_emscripten_bind_dtRaycastHit_get_hitNormal_1"]=_emscripten_bind_dtRaycastHit_get_hitNormal_1=wasmExports["Cj"];Module["_emscripten_bind_dtRaycastHit_set_hitNormal_2"]=_emscripten_bind_dtRaycastHit_set_hitNormal_2=wasmExports["Dj"];Module["_emscripten_bind_dtRaycastHit_get_hitEdgeIndex_0"]=_emscripten_bind_dtRaycastHit_get_hitEdgeIndex_0=wasmExports["Ej"];Module["_emscripten_bind_dtRaycastHit_set_hitEdgeIndex_1"]=_emscripten_bind_dtRaycastHit_set_hitEdgeIndex_1=wasmExports["Fj"];Module["_emscripten_bind_dtRaycastHit_get_path_1"]=_emscripten_bind_dtRaycastHit_get_path_1=wasmExports["Gj"];Module["_emscripten_bind_dtRaycastHit_set_path_2"]=_emscripten_bind_dtRaycastHit_set_path_2=wasmExports["Hj"];Module["_emscripten_bind_dtRaycastHit_get_pathCount_0"]=_emscripten_bind_dtRaycastHit_get_pathCount_0=wasmExports["Ij"];Module["_emscripten_bind_dtRaycastHit_set_pathCount_1"]=_emscripten_bind_dtRaycastHit_set_pathCount_1=wasmExports["Jj"];Module["_emscripten_bind_dtRaycastHit_get_maxPath_0"]=_emscripten_bind_dtRaycastHit_get_maxPath_0=wasmExports["Kj"];Module["_emscripten_bind_dtRaycastHit_set_maxPath_1"]=_emscripten_bind_dtRaycastHit_set_maxPath_1=wasmExports["Lj"];Module["_emscripten_bind_dtRaycastHit_get_pathCost_0"]=_emscripten_bind_dtRaycastHit_get_pathCost_0=wasmExports["Mj"];Module["_emscripten_bind_dtRaycastHit_set_pathCost_1"]=_emscripten_bind_dtRaycastHit_set_pathCost_1=wasmExports["Nj"];Module["_emscripten_bind_dtRaycastHit___destroy___0"]=_emscripten_bind_dtRaycastHit___destroy___0=wasmExports["Oj"];Module["_emscripten_bind_NavMeshQuery_NavMeshQuery_0"]=_emscripten_bind_NavMeshQuery_NavMeshQuery_0=wasmExports["Pj"];Module["_emscripten_bind_NavMeshQuery_NavMeshQuery_1"]=_emscripten_bind_NavMeshQuery_NavMeshQuery_1=wasmExports["Qj"];Module["_emscripten_bind_NavMeshQuery_init_2"]=_emscripten_bind_NavMeshQuery_init_2=wasmExports["Rj"];Module["_emscripten_bind_NavMeshQuery_findPath_7"]=_emscripten_bind_NavMeshQuery_findPath_7=wasmExports["Sj"];Module["_emscripten_bind_NavMeshQuery_closestPointOnPoly_4"]=_emscripten_bind_NavMeshQuery_closestPointOnPoly_4=wasmExports["Tj"];Module["_emscripten_bind_NavMeshQuery_findClosestPoint_6"]=_emscripten_bind_NavMeshQuery_findClosestPoint_6=wasmExports["Uj"];Module["_emscripten_bind_NavMeshQuery_findStraightPath_9"]=_emscripten_bind_NavMeshQuery_findStraightPath_9=wasmExports["Vj"];Module["_emscripten_bind_NavMeshQuery_findNearestPoly_6"]=_emscripten_bind_NavMeshQuery_findNearestPoly_6=wasmExports["Wj"];Module["_emscripten_bind_NavMeshQuery_findPolysAroundCircle_9"]=_emscripten_bind_NavMeshQuery_findPolysAroundCircle_9=wasmExports["Xj"];Module["_emscripten_bind_NavMeshQuery_queryPolygons_6"]=_emscripten_bind_NavMeshQuery_queryPolygons_6=wasmExports["Yj"];Module["_emscripten_bind_NavMeshQuery_raycast_7"]=_emscripten_bind_NavMeshQuery_raycast_7=wasmExports["Zj"];Module["_emscripten_bind_NavMeshQuery_findRandomPointAroundCircle_6"]=_emscripten_bind_NavMeshQuery_findRandomPointAroundCircle_6=wasmExports["_j"];Module["_emscripten_bind_NavMeshQuery_moveAlongSurface_7"]=_emscripten_bind_NavMeshQuery_moveAlongSurface_7=wasmExports["$j"];Module["_emscripten_bind_NavMeshQuery_findRandomPoint_3"]=_emscripten_bind_NavMeshQuery_findRandomPoint_3=wasmExports["ak"];Module["_emscripten_bind_NavMeshQuery_getPolyHeight_3"]=_emscripten_bind_NavMeshQuery_getPolyHeight_3=wasmExports["bk"];Module["_emscripten_bind_NavMeshQuery_destroy_0"]=_emscripten_bind_NavMeshQuery_destroy_0=wasmExports["ck"];Module["_emscripten_bind_NavMeshQuery_get_m_navQuery_0"]=_emscripten_bind_NavMeshQuery_get_m_navQuery_0=wasmExports["dk"];Module["_emscripten_bind_NavMeshQuery_set_m_navQuery_1"]=_emscripten_bind_NavMeshQuery_set_m_navQuery_1=wasmExports["ek"];Module["_emscripten_bind_NavMeshQuery___destroy___0"]=_emscripten_bind_NavMeshQuery___destroy___0=wasmExports["fk"];Module["_emscripten_bind_dtTileCacheParams_dtTileCacheParams_0"]=_emscripten_bind_dtTileCacheParams_dtTileCacheParams_0=wasmExports["gk"];Module["_emscripten_bind_dtTileCacheParams_get_orig_1"]=_emscripten_bind_dtTileCacheParams_get_orig_1=wasmExports["hk"];Module["_emscripten_bind_dtTileCacheParams_set_orig_2"]=_emscripten_bind_dtTileCacheParams_set_orig_2=wasmExports["ik"];Module["_emscripten_bind_dtTileCacheParams_get_cs_0"]=_emscripten_bind_dtTileCacheParams_get_cs_0=wasmExports["jk"];Module["_emscripten_bind_dtTileCacheParams_set_cs_1"]=_emscripten_bind_dtTileCacheParams_set_cs_1=wasmExports["kk"];Module["_emscripten_bind_dtTileCacheParams_get_ch_0"]=_emscripten_bind_dtTileCacheParams_get_ch_0=wasmExports["lk"];Module["_emscripten_bind_dtTileCacheParams_set_ch_1"]=_emscripten_bind_dtTileCacheParams_set_ch_1=wasmExports["mk"];Module["_emscripten_bind_dtTileCacheParams_get_width_0"]=_emscripten_bind_dtTileCacheParams_get_width_0=wasmExports["nk"];Module["_emscripten_bind_dtTileCacheParams_set_width_1"]=_emscripten_bind_dtTileCacheParams_set_width_1=wasmExports["ok"];Module["_emscripten_bind_dtTileCacheParams_get_height_0"]=_emscripten_bind_dtTileCacheParams_get_height_0=wasmExports["pk"];Module["_emscripten_bind_dtTileCacheParams_set_height_1"]=_emscripten_bind_dtTileCacheParams_set_height_1=wasmExports["qk"];Module["_emscripten_bind_dtTileCacheParams_get_walkableHeight_0"]=_emscripten_bind_dtTileCacheParams_get_walkableHeight_0=wasmExports["rk"];Module["_emscripten_bind_dtTileCacheParams_set_walkableHeight_1"]=_emscripten_bind_dtTileCacheParams_set_walkableHeight_1=wasmExports["sk"];Module["_emscripten_bind_dtTileCacheParams_get_walkableRadius_0"]=_emscripten_bind_dtTileCacheParams_get_walkableRadius_0=wasmExports["tk"];Module["_emscripten_bind_dtTileCacheParams_set_walkableRadius_1"]=_emscripten_bind_dtTileCacheParams_set_walkableRadius_1=wasmExports["uk"];Module["_emscripten_bind_dtTileCacheParams_get_walkableClimb_0"]=_emscripten_bind_dtTileCacheParams_get_walkableClimb_0=wasmExports["vk"];Module["_emscripten_bind_dtTileCacheParams_set_walkableClimb_1"]=_emscripten_bind_dtTileCacheParams_set_walkableClimb_1=wasmExports["wk"];Module["_emscripten_bind_dtTileCacheParams_get_maxSimplificationError_0"]=_emscripten_bind_dtTileCacheParams_get_maxSimplificationError_0=wasmExports["xk"];Module["_emscripten_bind_dtTileCacheParams_set_maxSimplificationError_1"]=_emscripten_bind_dtTileCacheParams_set_maxSimplificationError_1=wasmExports["yk"];Module["_emscripten_bind_dtTileCacheParams_get_maxTiles_0"]=_emscripten_bind_dtTileCacheParams_get_maxTiles_0=wasmExports["zk"];Module["_emscripten_bind_dtTileCacheParams_set_maxTiles_1"]=_emscripten_bind_dtTileCacheParams_set_maxTiles_1=wasmExports["Ak"];Module["_emscripten_bind_dtTileCacheParams_get_maxObstacles_0"]=_emscripten_bind_dtTileCacheParams_get_maxObstacles_0=wasmExports["Bk"];Module["_emscripten_bind_dtTileCacheParams_set_maxObstacles_1"]=_emscripten_bind_dtTileCacheParams_set_maxObstacles_1=wasmExports["Ck"];Module["_emscripten_bind_dtTileCacheParams___destroy___0"]=_emscripten_bind_dtTileCacheParams___destroy___0=wasmExports["Dk"];Module["_emscripten_bind_TileCacheAddTileResult_get_status_0"]=_emscripten_bind_TileCacheAddTileResult_get_status_0=wasmExports["Ek"];Module["_emscripten_bind_TileCacheAddTileResult_set_status_1"]=_emscripten_bind_TileCacheAddTileResult_set_status_1=wasmExports["Fk"];Module["_emscripten_bind_TileCacheAddTileResult_get_tileRef_0"]=_emscripten_bind_TileCacheAddTileResult_get_tileRef_0=wasmExports["Gk"];Module["_emscripten_bind_TileCacheAddTileResult_set_tileRef_1"]=_emscripten_bind_TileCacheAddTileResult_set_tileRef_1=wasmExports["Hk"];Module["_emscripten_bind_TileCacheAddTileResult___destroy___0"]=_emscripten_bind_TileCacheAddTileResult___destroy___0=wasmExports["Ik"];Module["_emscripten_bind_TileCacheUpdateResult_get_status_0"]=_emscripten_bind_TileCacheUpdateResult_get_status_0=wasmExports["Jk"];Module["_emscripten_bind_TileCacheUpdateResult_set_status_1"]=_emscripten_bind_TileCacheUpdateResult_set_status_1=wasmExports["Kk"];Module["_emscripten_bind_TileCacheUpdateResult_get_upToDate_0"]=_emscripten_bind_TileCacheUpdateResult_get_upToDate_0=wasmExports["Lk"];Module["_emscripten_bind_TileCacheUpdateResult_set_upToDate_1"]=_emscripten_bind_TileCacheUpdateResult_set_upToDate_1=wasmExports["Mk"];Module["_emscripten_bind_TileCacheUpdateResult___destroy___0"]=_emscripten_bind_TileCacheUpdateResult___destroy___0=wasmExports["Nk"];Module["_emscripten_bind_TileCacheAddObstacleResult_get_status_0"]=_emscripten_bind_TileCacheAddObstacleResult_get_status_0=wasmExports["Ok"];Module["_emscripten_bind_TileCacheAddObstacleResult_set_status_1"]=_emscripten_bind_TileCacheAddObstacleResult_set_status_1=wasmExports["Pk"];Module["_emscripten_bind_TileCacheAddObstacleResult_get_ref_0"]=_emscripten_bind_TileCacheAddObstacleResult_get_ref_0=wasmExports["Qk"];Module["_emscripten_bind_TileCacheAddObstacleResult_set_ref_1"]=_emscripten_bind_TileCacheAddObstacleResult_set_ref_1=wasmExports["Rk"];Module["_emscripten_bind_TileCacheAddObstacleResult___destroy___0"]=_emscripten_bind_TileCacheAddObstacleResult___destroy___0=wasmExports["Sk"];Module["_emscripten_bind_RecastFastLZCompressor_RecastFastLZCompressor_0"]=_emscripten_bind_RecastFastLZCompressor_RecastFastLZCompressor_0=wasmExports["Tk"];Module["_emscripten_bind_RecastFastLZCompressor___destroy___0"]=_emscripten_bind_RecastFastLZCompressor___destroy___0=wasmExports["Uk"];Module["_emscripten_bind_TileCacheMeshProcess_TileCacheMeshProcess_0"]=_emscripten_bind_TileCacheMeshProcess_TileCacheMeshProcess_0=wasmExports["Vk"];Module["_emscripten_bind_TileCacheMeshProcess_process_3"]=_emscripten_bind_TileCacheMeshProcess_process_3=wasmExports["Wk"];Module["_emscripten_bind_TileCacheMeshProcess___destroy___0"]=_emscripten_bind_TileCacheMeshProcess___destroy___0=wasmExports["Xk"];Module["_emscripten_bind_RecastLinearAllocator_RecastLinearAllocator_1"]=_emscripten_bind_RecastLinearAllocator_RecastLinearAllocator_1=wasmExports["Yk"];Module["_emscripten_bind_RecastLinearAllocator___destroy___0"]=_emscripten_bind_RecastLinearAllocator___destroy___0=wasmExports["Zk"];Module["_emscripten_bind_TileCache_TileCache_0"]=_emscripten_bind_TileCache_TileCache_0=wasmExports["_k"];Module["_emscripten_bind_TileCache_init_4"]=_emscripten_bind_TileCache_init_4=wasmExports["$k"];Module["_emscripten_bind_TileCache_addTile_2"]=_emscripten_bind_TileCache_addTile_2=wasmExports["al"];Module["_emscripten_bind_TileCache_buildNavMeshTile_2"]=_emscripten_bind_TileCache_buildNavMeshTile_2=wasmExports["bl"];Module["_emscripten_bind_TileCache_buildNavMeshTilesAt_3"]=_emscripten_bind_TileCache_buildNavMeshTilesAt_3=wasmExports["cl"];Module["_emscripten_bind_TileCache_update_1"]=_emscripten_bind_TileCache_update_1=wasmExports["dl"];Module["_emscripten_bind_TileCache_addCylinderObstacle_3"]=_emscripten_bind_TileCache_addCylinderObstacle_3=wasmExports["el"];Module["_emscripten_bind_TileCache_addBoxObstacle_3"]=_emscripten_bind_TileCache_addBoxObstacle_3=wasmExports["fl"];Module["_emscripten_bind_TileCache_removeObstacle_1"]=_emscripten_bind_TileCache_removeObstacle_1=wasmExports["gl"];Module["_emscripten_bind_TileCache_destroy_0"]=_emscripten_bind_TileCache_destroy_0=wasmExports["hl"];Module["_emscripten_bind_TileCache___destroy___0"]=_emscripten_bind_TileCache___destroy___0=wasmExports["il"];Module["_emscripten_bind_CrowdUtils_CrowdUtils_0"]=_emscripten_bind_CrowdUtils_CrowdUtils_0=wasmExports["jl"];Module["_emscripten_bind_CrowdUtils_getActiveAgentCount_1"]=_emscripten_bind_CrowdUtils_getActiveAgentCount_1=wasmExports["kl"];Module["_emscripten_bind_CrowdUtils_overOffMeshConnection_2"]=_emscripten_bind_CrowdUtils_overOffMeshConnection_2=wasmExports["ll"];Module["_emscripten_bind_CrowdUtils_agentTeleport_5"]=_emscripten_bind_CrowdUtils_agentTeleport_5=wasmExports["ml"];Module["_emscripten_bind_CrowdUtils___destroy___0"]=_emscripten_bind_CrowdUtils___destroy___0=wasmExports["nl"];Module["_emscripten_bind_Detour_Detour_0"]=_emscripten_bind_Detour_Detour_0=wasmExports["ol"];Module["_emscripten_bind_Detour_statusSucceed_1"]=_emscripten_bind_Detour_statusSucceed_1=wasmExports["pl"];Module["_emscripten_bind_Detour_statusFailed_1"]=_emscripten_bind_Detour_statusFailed_1=wasmExports["ql"];Module["_emscripten_bind_Detour_statusInProgress_1"]=_emscripten_bind_Detour_statusInProgress_1=wasmExports["rl"];Module["_emscripten_bind_Detour_statusDetail_2"]=_emscripten_bind_Detour_statusDetail_2=wasmExports["sl"];Module["_emscripten_bind_Detour_allocCrowd_0"]=_emscripten_bind_Detour_allocCrowd_0=wasmExports["tl"];Module["_emscripten_bind_Detour_freeCrowd_1"]=_emscripten_bind_Detour_freeCrowd_1=wasmExports["ul"];Module["_emscripten_bind_Detour_get_FAILURE_0"]=_emscripten_bind_Detour_get_FAILURE_0=wasmExports["vl"];Module["_emscripten_bind_Detour_get_SUCCESS_0"]=_emscripten_bind_Detour_get_SUCCESS_0=wasmExports["wl"];Module["_emscripten_bind_Detour_get_IN_PROGRESS_0"]=_emscripten_bind_Detour_get_IN_PROGRESS_0=wasmExports["xl"];Module["_emscripten_bind_Detour_get_STATUS_DETAIL_MASK_0"]=_emscripten_bind_Detour_get_STATUS_DETAIL_MASK_0=wasmExports["yl"];Module["_emscripten_bind_Detour_get_WRONG_MAGIC_0"]=_emscripten_bind_Detour_get_WRONG_MAGIC_0=wasmExports["zl"];Module["_emscripten_bind_Detour_get_WRONG_VERSION_0"]=_emscripten_bind_Detour_get_WRONG_VERSION_0=wasmExports["Al"];Module["_emscripten_bind_Detour_get_OUT_OF_MEMORY_0"]=_emscripten_bind_Detour_get_OUT_OF_MEMORY_0=wasmExports["Bl"];Module["_emscripten_bind_Detour_get_INVALID_PARAM_0"]=_emscripten_bind_Detour_get_INVALID_PARAM_0=wasmExports["Cl"];Module["_emscripten_bind_Detour_get_BUFFER_TOO_SMALL_0"]=_emscripten_bind_Detour_get_BUFFER_TOO_SMALL_0=wasmExports["Dl"];Module["_emscripten_bind_Detour_get_OUT_OF_NODES_0"]=_emscripten_bind_Detour_get_OUT_OF_NODES_0=wasmExports["El"];Module["_emscripten_bind_Detour_get_PARTIAL_RESULT_0"]=_emscripten_bind_Detour_get_PARTIAL_RESULT_0=wasmExports["Fl"];Module["_emscripten_bind_Detour_get_ALREADY_OCCUPIED_0"]=_emscripten_bind_Detour_get_ALREADY_OCCUPIED_0=wasmExports["Gl"];Module["_emscripten_bind_Detour_get_VERTS_PER_POLYGON_0"]=_emscripten_bind_Detour_get_VERTS_PER_POLYGON_0=wasmExports["Hl"];Module["_emscripten_bind_Detour_get_NAVMESH_MAGIC_0"]=_emscripten_bind_Detour_get_NAVMESH_MAGIC_0=wasmExports["Il"];Module["_emscripten_bind_Detour_get_NAVMESH_VERSION_0"]=_emscripten_bind_Detour_get_NAVMESH_VERSION_0=wasmExports["Jl"];Module["_emscripten_bind_Detour_get_NAVMESH_STATE_MAGIC_0"]=_emscripten_bind_Detour_get_NAVMESH_STATE_MAGIC_0=wasmExports["Kl"];Module["_emscripten_bind_Detour_get_NAVMESH_STATE_VERSION_0"]=_emscripten_bind_Detour_get_NAVMESH_STATE_VERSION_0=wasmExports["Ll"];Module["_emscripten_bind_Detour_get_TILECACHE_MAGIC_0"]=_emscripten_bind_Detour_get_TILECACHE_MAGIC_0=wasmExports["Ml"];Module["_emscripten_bind_Detour_get_TILECACHE_VERSION_0"]=_emscripten_bind_Detour_get_TILECACHE_VERSION_0=wasmExports["Nl"];Module["_emscripten_bind_Detour_get_TILECACHE_NULL_AREA_0"]=_emscripten_bind_Detour_get_TILECACHE_NULL_AREA_0=wasmExports["Ol"];Module["_emscripten_bind_Detour_get_TILECACHE_WALKABLE_AREA_0"]=_emscripten_bind_Detour_get_TILECACHE_WALKABLE_AREA_0=wasmExports["Pl"];Module["_emscripten_bind_Detour_get_TILECACHE_NULL_IDX_0"]=_emscripten_bind_Detour_get_TILECACHE_NULL_IDX_0=wasmExports["Ql"];Module["_emscripten_bind_Detour_get_NULL_LINK_0"]=_emscripten_bind_Detour_get_NULL_LINK_0=wasmExports["Rl"];Module["_emscripten_bind_Detour_get_EXT_LINK_0"]=_emscripten_bind_Detour_get_EXT_LINK_0=wasmExports["Sl"];Module["_emscripten_bind_Detour_get_OFFMESH_CON_BIDIR_0"]=_emscripten_bind_Detour_get_OFFMESH_CON_BIDIR_0=wasmExports["Tl"];Module["_emscripten_bind_Detour___destroy___0"]=_emscripten_bind_Detour___destroy___0=wasmExports["Ul"];Module["_emscripten_bind_dtPathCorridor_init_1"]=_emscripten_bind_dtPathCorridor_init_1=wasmExports["Vl"];Module["_emscripten_bind_dtPathCorridor_reset_2"]=_emscripten_bind_dtPathCorridor_reset_2=wasmExports["Wl"];Module["_emscripten_bind_dtPathCorridor___destroy___0"]=_emscripten_bind_dtPathCorridor___destroy___0=wasmExports["Xl"];Module["_emscripten_bind_dtLocalBoundary_reset_0"]=_emscripten_bind_dtLocalBoundary_reset_0=wasmExports["Yl"];Module["_emscripten_bind_dtLocalBoundary___destroy___0"]=_emscripten_bind_dtLocalBoundary___destroy___0=wasmExports["Zl"];Module["_emscripten_bind_dtCrowdNeighbour_dtCrowdNeighbour_0"]=_emscripten_bind_dtCrowdNeighbour_dtCrowdNeighbour_0=wasmExports["_l"];Module["_emscripten_bind_dtCrowdNeighbour_get_idx_0"]=_emscripten_bind_dtCrowdNeighbour_get_idx_0=wasmExports["$l"];Module["_emscripten_bind_dtCrowdNeighbour_set_idx_1"]=_emscripten_bind_dtCrowdNeighbour_set_idx_1=wasmExports["am"];Module["_emscripten_bind_dtCrowdNeighbour_get_dist_0"]=_emscripten_bind_dtCrowdNeighbour_get_dist_0=wasmExports["bm"];Module["_emscripten_bind_dtCrowdNeighbour_set_dist_1"]=_emscripten_bind_dtCrowdNeighbour_set_dist_1=wasmExports["cm"];Module["_emscripten_bind_dtCrowdNeighbour___destroy___0"]=_emscripten_bind_dtCrowdNeighbour___destroy___0=wasmExports["dm"];Module["_emscripten_bind_dtCrowdAgent_dtCrowdAgent_0"]=_emscripten_bind_dtCrowdAgent_dtCrowdAgent_0=wasmExports["em"];Module["_emscripten_bind_dtCrowdAgent_get_active_0"]=_emscripten_bind_dtCrowdAgent_get_active_0=wasmExports["fm"];Module["_emscripten_bind_dtCrowdAgent_set_active_1"]=_emscripten_bind_dtCrowdAgent_set_active_1=wasmExports["gm"];Module["_emscripten_bind_dtCrowdAgent_get_state_0"]=_emscripten_bind_dtCrowdAgent_get_state_0=wasmExports["hm"];Module["_emscripten_bind_dtCrowdAgent_set_state_1"]=_emscripten_bind_dtCrowdAgent_set_state_1=wasmExports["im"];Module["_emscripten_bind_dtCrowdAgent_get_corridor_0"]=_emscripten_bind_dtCrowdAgent_get_corridor_0=wasmExports["jm"];Module["_emscripten_bind_dtCrowdAgent_get_boundary_0"]=_emscripten_bind_dtCrowdAgent_get_boundary_0=wasmExports["km"];Module["_emscripten_bind_dtCrowdAgent_get_topologyOptTime_0"]=_emscripten_bind_dtCrowdAgent_get_topologyOptTime_0=wasmExports["lm"];Module["_emscripten_bind_dtCrowdAgent_set_topologyOptTime_1"]=_emscripten_bind_dtCrowdAgent_set_topologyOptTime_1=wasmExports["mm"];Module["_emscripten_bind_dtCrowdAgent_get_neis_1"]=_emscripten_bind_dtCrowdAgent_get_neis_1=wasmExports["nm"];Module["_emscripten_bind_dtCrowdAgent_set_neis_2"]=_emscripten_bind_dtCrowdAgent_set_neis_2=wasmExports["om"];Module["_emscripten_bind_dtCrowdAgent_get_nneis_0"]=_emscripten_bind_dtCrowdAgent_get_nneis_0=wasmExports["pm"];Module["_emscripten_bind_dtCrowdAgent_set_nneis_1"]=_emscripten_bind_dtCrowdAgent_set_nneis_1=wasmExports["qm"];Module["_emscripten_bind_dtCrowdAgent_get_desiredSpeed_0"]=_emscripten_bind_dtCrowdAgent_get_desiredSpeed_0=wasmExports["rm"];Module["_emscripten_bind_dtCrowdAgent_set_desiredSpeed_1"]=_emscripten_bind_dtCrowdAgent_set_desiredSpeed_1=wasmExports["sm"];Module["_emscripten_bind_dtCrowdAgent_get_npos_1"]=_emscripten_bind_dtCrowdAgent_get_npos_1=wasmExports["tm"];Module["_emscripten_bind_dtCrowdAgent_set_npos_2"]=_emscripten_bind_dtCrowdAgent_set_npos_2=wasmExports["um"];Module["_emscripten_bind_dtCrowdAgent_get_disp_1"]=_emscripten_bind_dtCrowdAgent_get_disp_1=wasmExports["vm"];Module["_emscripten_bind_dtCrowdAgent_set_disp_2"]=_emscripten_bind_dtCrowdAgent_set_disp_2=wasmExports["wm"];Module["_emscripten_bind_dtCrowdAgent_get_dvel_1"]=_emscripten_bind_dtCrowdAgent_get_dvel_1=wasmExports["xm"];Module["_emscripten_bind_dtCrowdAgent_set_dvel_2"]=_emscripten_bind_dtCrowdAgent_set_dvel_2=wasmExports["ym"];Module["_emscripten_bind_dtCrowdAgent_get_nvel_1"]=_emscripten_bind_dtCrowdAgent_get_nvel_1=wasmExports["zm"];Module["_emscripten_bind_dtCrowdAgent_set_nvel_2"]=_emscripten_bind_dtCrowdAgent_set_nvel_2=wasmExports["Am"];Module["_emscripten_bind_dtCrowdAgent_get_vel_1"]=_emscripten_bind_dtCrowdAgent_get_vel_1=wasmExports["Bm"];Module["_emscripten_bind_dtCrowdAgent_set_vel_2"]=_emscripten_bind_dtCrowdAgent_set_vel_2=wasmExports["Cm"];Module["_emscripten_bind_dtCrowdAgent_get_params_0"]=_emscripten_bind_dtCrowdAgent_get_params_0=wasmExports["Dm"];Module["_emscripten_bind_dtCrowdAgent_set_params_1"]=_emscripten_bind_dtCrowdAgent_set_params_1=wasmExports["Em"];Module["_emscripten_bind_dtCrowdAgent_get_cornerVerts_1"]=_emscripten_bind_dtCrowdAgent_get_cornerVerts_1=wasmExports["Fm"];Module["_emscripten_bind_dtCrowdAgent_set_cornerVerts_2"]=_emscripten_bind_dtCrowdAgent_set_cornerVerts_2=wasmExports["Gm"];Module["_emscripten_bind_dtCrowdAgent_get_cornerFlags_1"]=_emscripten_bind_dtCrowdAgent_get_cornerFlags_1=wasmExports["Hm"];Module["_emscripten_bind_dtCrowdAgent_set_cornerFlags_2"]=_emscripten_bind_dtCrowdAgent_set_cornerFlags_2=wasmExports["Im"];Module["_emscripten_bind_dtCrowdAgent_get_ncorners_0"]=_emscripten_bind_dtCrowdAgent_get_ncorners_0=wasmExports["Jm"];Module["_emscripten_bind_dtCrowdAgent_set_ncorners_1"]=_emscripten_bind_dtCrowdAgent_set_ncorners_1=wasmExports["Km"];Module["_emscripten_bind_dtCrowdAgent_get_targetState_0"]=_emscripten_bind_dtCrowdAgent_get_targetState_0=wasmExports["Lm"];Module["_emscripten_bind_dtCrowdAgent_set_targetState_1"]=_emscripten_bind_dtCrowdAgent_set_targetState_1=wasmExports["Mm"];Module["_emscripten_bind_dtCrowdAgent_get_targetRef_0"]=_emscripten_bind_dtCrowdAgent_get_targetRef_0=wasmExports["Nm"];Module["_emscripten_bind_dtCrowdAgent_set_targetRef_1"]=_emscripten_bind_dtCrowdAgent_set_targetRef_1=wasmExports["Om"];Module["_emscripten_bind_dtCrowdAgent_get_targetPos_1"]=_emscripten_bind_dtCrowdAgent_get_targetPos_1=wasmExports["Pm"];Module["_emscripten_bind_dtCrowdAgent_set_targetPos_2"]=_emscripten_bind_dtCrowdAgent_set_targetPos_2=wasmExports["Qm"];Module["_emscripten_bind_dtCrowdAgent_get_targetPathqRef_0"]=_emscripten_bind_dtCrowdAgent_get_targetPathqRef_0=wasmExports["Rm"];Module["_emscripten_bind_dtCrowdAgent_set_targetPathqRef_1"]=_emscripten_bind_dtCrowdAgent_set_targetPathqRef_1=wasmExports["Sm"];Module["_emscripten_bind_dtCrowdAgent_get_targetReplan_0"]=_emscripten_bind_dtCrowdAgent_get_targetReplan_0=wasmExports["Tm"];Module["_emscripten_bind_dtCrowdAgent_set_targetReplan_1"]=_emscripten_bind_dtCrowdAgent_set_targetReplan_1=wasmExports["Um"];Module["_emscripten_bind_dtCrowdAgent_get_targetReplanTime_0"]=_emscripten_bind_dtCrowdAgent_get_targetReplanTime_0=wasmExports["Vm"];Module["_emscripten_bind_dtCrowdAgent_set_targetReplanTime_1"]=_emscripten_bind_dtCrowdAgent_set_targetReplanTime_1=wasmExports["Wm"];Module["_emscripten_bind_dtCrowdAgent___destroy___0"]=_emscripten_bind_dtCrowdAgent___destroy___0=wasmExports["Xm"];Module["_emscripten_bind_dtObstacleAvoidanceParams_dtObstacleAvoidanceParams_0"]=_emscripten_bind_dtObstacleAvoidanceParams_dtObstacleAvoidanceParams_0=wasmExports["Ym"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_velBias_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_velBias_0=wasmExports["Zm"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_velBias_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_velBias_1=wasmExports["_m"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightDesVel_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightDesVel_0=wasmExports["$m"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightDesVel_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightDesVel_1=wasmExports["an"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightCurVel_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightCurVel_0=wasmExports["bn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightCurVel_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightCurVel_1=wasmExports["cn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightSide_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightSide_0=wasmExports["dn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightSide_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightSide_1=wasmExports["en"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightToi_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightToi_0=wasmExports["fn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightToi_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightToi_1=wasmExports["gn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_horizTime_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_horizTime_0=wasmExports["hn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_horizTime_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_horizTime_1=wasmExports["jn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_gridSize_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_gridSize_0=wasmExports["kn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_gridSize_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_gridSize_1=wasmExports["ln"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDivs_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDivs_0=wasmExports["mn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDivs_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDivs_1=wasmExports["nn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveRings_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveRings_0=wasmExports["on"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveRings_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveRings_1=wasmExports["pn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDepth_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDepth_0=wasmExports["qn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDepth_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDepth_1=wasmExports["rn"];Module["_emscripten_bind_dtObstacleAvoidanceParams___destroy___0"]=_emscripten_bind_dtObstacleAvoidanceParams___destroy___0=wasmExports["sn"];Module["_emscripten_bind_dtObstacleAvoidanceDebugData___destroy___0"]=_emscripten_bind_dtObstacleAvoidanceDebugData___destroy___0=wasmExports["tn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_dtCrowdAgentDebugInfo_0"]=_emscripten_bind_dtCrowdAgentDebugInfo_dtCrowdAgentDebugInfo_0=wasmExports["un"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_idx_0"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_idx_0=wasmExports["vn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_idx_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_idx_1=wasmExports["wn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_optStart_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_optStart_1=wasmExports["xn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_optStart_2"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_optStart_2=wasmExports["yn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_optEnd_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_optEnd_1=wasmExports["zn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_optEnd_2"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_optEnd_2=wasmExports["An"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_vod_0"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_vod_0=wasmExports["Bn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_vod_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_vod_1=wasmExports["Cn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo___destroy___0"]=_emscripten_bind_dtCrowdAgentDebugInfo___destroy___0=wasmExports["Dn"];Module["_emscripten_bind_dtQueryFilter_dtQueryFilter_0"]=_emscripten_bind_dtQueryFilter_dtQueryFilter_0=wasmExports["En"];Module["_emscripten_bind_dtQueryFilter_getAreaCost_1"]=_emscripten_bind_dtQueryFilter_getAreaCost_1=wasmExports["Fn"];Module["_emscripten_bind_dtQueryFilter_setAreaCost_2"]=_emscripten_bind_dtQueryFilter_setAreaCost_2=wasmExports["Gn"];Module["_emscripten_bind_dtQueryFilter_getIncludeFlags_0"]=_emscripten_bind_dtQueryFilter_getIncludeFlags_0=wasmExports["Hn"];Module["_emscripten_bind_dtQueryFilter_setIncludeFlags_1"]=_emscripten_bind_dtQueryFilter_setIncludeFlags_1=wasmExports["In"];Module["_emscripten_bind_dtQueryFilter_getExcludeFlags_0"]=_emscripten_bind_dtQueryFilter_getExcludeFlags_0=wasmExports["Jn"];Module["_emscripten_bind_dtQueryFilter_setExcludeFlags_1"]=_emscripten_bind_dtQueryFilter_setExcludeFlags_1=wasmExports["Kn"];Module["_emscripten_bind_dtQueryFilter___destroy___0"]=_emscripten_bind_dtQueryFilter___destroy___0=wasmExports["Ln"];Module["_emscripten_bind_dtNavMeshQuery_getAttachedNavMesh_0"]=_emscripten_bind_dtNavMeshQuery_getAttachedNavMesh_0=wasmExports["Mn"];Module["_emscripten_bind_dtNavMeshQuery___destroy___0"]=_emscripten_bind_dtNavMeshQuery___destroy___0=wasmExports["Nn"];Module["_emscripten_bind_dtCrowd_dtCrowd_0"]=_emscripten_bind_dtCrowd_dtCrowd_0=wasmExports["On"];Module["_emscripten_bind_dtCrowd_init_3"]=_emscripten_bind_dtCrowd_init_3=wasmExports["Pn"];Module["_emscripten_bind_dtCrowd_setObstacleAvoidanceParams_2"]=_emscripten_bind_dtCrowd_setObstacleAvoidanceParams_2=wasmExports["Qn"];Module["_emscripten_bind_dtCrowd_getObstacleAvoidanceParams_1"]=_emscripten_bind_dtCrowd_getObstacleAvoidanceParams_1=wasmExports["Rn"];Module["_emscripten_bind_dtCrowd_getAgent_1"]=_emscripten_bind_dtCrowd_getAgent_1=wasmExports["Sn"];Module["_emscripten_bind_dtCrowd_getEditableAgent_1"]=_emscripten_bind_dtCrowd_getEditableAgent_1=wasmExports["Tn"];Module["_emscripten_bind_dtCrowd_getAgentCount_0"]=_emscripten_bind_dtCrowd_getAgentCount_0=wasmExports["Un"];Module["_emscripten_bind_dtCrowd_addAgent_2"]=_emscripten_bind_dtCrowd_addAgent_2=wasmExports["Vn"];Module["_emscripten_bind_dtCrowd_updateAgentParameters_2"]=_emscripten_bind_dtCrowd_updateAgentParameters_2=wasmExports["Wn"];Module["_emscripten_bind_dtCrowd_removeAgent_1"]=_emscripten_bind_dtCrowd_removeAgent_1=wasmExports["Xn"];Module["_emscripten_bind_dtCrowd_requestMoveTarget_3"]=_emscripten_bind_dtCrowd_requestMoveTarget_3=wasmExports["Yn"];Module["_emscripten_bind_dtCrowd_requestMoveVelocity_2"]=_emscripten_bind_dtCrowd_requestMoveVelocity_2=wasmExports["Zn"];Module["_emscripten_bind_dtCrowd_resetMoveTarget_1"]=_emscripten_bind_dtCrowd_resetMoveTarget_1=wasmExports["_n"];Module["_emscripten_bind_dtCrowd_update_2"]=_emscripten_bind_dtCrowd_update_2=wasmExports["$n"];Module["_emscripten_bind_dtCrowd_getFilter_1"]=_emscripten_bind_dtCrowd_getFilter_1=wasmExports["ao"];Module["_emscripten_bind_dtCrowd_getEditableFilter_1"]=_emscripten_bind_dtCrowd_getEditableFilter_1=wasmExports["bo"];Module["_emscripten_bind_dtCrowd_getNavMeshQuery_0"]=_emscripten_bind_dtCrowd_getNavMeshQuery_0=wasmExports["co"];Module["_emscripten_bind_dtCrowd___destroy___0"]=_emscripten_bind_dtCrowd___destroy___0=wasmExports["eo"];Module["_emscripten_bind_RecastBuildContextJsImpl_RecastBuildContextJsImpl_0"]=_emscripten_bind_RecastBuildContextJsImpl_RecastBuildContextJsImpl_0=wasmExports["fo"];Module["_emscripten_bind_RecastBuildContextJsImpl_resetLog_0"]=_emscripten_bind_RecastBuildContextJsImpl_resetLog_0=wasmExports["go"];Module["_emscripten_bind_RecastBuildContextJsImpl_log_3"]=_emscripten_bind_RecastBuildContextJsImpl_log_3=wasmExports["ho"];Module["_emscripten_bind_RecastBuildContextJsImpl_resetTimers_0"]=_emscripten_bind_RecastBuildContextJsImpl_resetTimers_0=wasmExports["io"];Module["_emscripten_bind_RecastBuildContextJsImpl_startTimer_1"]=_emscripten_bind_RecastBuildContextJsImpl_startTimer_1=wasmExports["jo"];Module["_emscripten_bind_RecastBuildContextJsImpl_stopTimer_1"]=_emscripten_bind_RecastBuildContextJsImpl_stopTimer_1=wasmExports["ko"];Module["_emscripten_bind_RecastBuildContextJsImpl_getAccumulatedTime_1"]=_emscripten_bind_RecastBuildContextJsImpl_getAccumulatedTime_1=wasmExports["lo"];Module["_emscripten_bind_RecastBuildContextJsImpl___destroy___0"]=_emscripten_bind_RecastBuildContextJsImpl___destroy___0=wasmExports["mo"];Module["_emscripten_bind_RecastBuildContext_RecastBuildContext_1"]=_emscripten_bind_RecastBuildContext_RecastBuildContext_1=wasmExports["no"];Module["_emscripten_bind_RecastBuildContext_enableLog_1"]=_emscripten_bind_RecastBuildContext_enableLog_1=wasmExports["oo"];Module["_emscripten_bind_RecastBuildContext_resetLog_0"]=_emscripten_bind_RecastBuildContext_resetLog_0=wasmExports["po"];Module["_emscripten_bind_RecastBuildContext_log_2"]=_emscripten_bind_RecastBuildContext_log_2=wasmExports["qo"];Module["_emscripten_bind_RecastBuildContext_enableTimer_1"]=_emscripten_bind_RecastBuildContext_enableTimer_1=wasmExports["ro"];Module["_emscripten_bind_RecastBuildContext_resetTimers_0"]=_emscripten_bind_RecastBuildContext_resetTimers_0=wasmExports["so"];Module["_emscripten_bind_RecastBuildContext_startTimer_1"]=_emscripten_bind_RecastBuildContext_startTimer_1=wasmExports["to"];Module["_emscripten_bind_RecastBuildContext_stopTimer_1"]=_emscripten_bind_RecastBuildContext_stopTimer_1=wasmExports["uo"];Module["_emscripten_bind_RecastBuildContext_getAccumulatedTime_1"]=_emscripten_bind_RecastBuildContext_getAccumulatedTime_1=wasmExports["vo"];Module["_emscripten_bind_RecastBuildContext_logEnabled_0"]=_emscripten_bind_RecastBuildContext_logEnabled_0=wasmExports["wo"];Module["_emscripten_bind_RecastBuildContext_timerEnabled_0"]=_emscripten_bind_RecastBuildContext_timerEnabled_0=wasmExports["xo"];Module["_emscripten_bind_RecastBuildContext___destroy___0"]=_emscripten_bind_RecastBuildContext___destroy___0=wasmExports["yo"];Module["_emscripten_bind_RecastCalcBoundsResult_get_bmin_1"]=_emscripten_bind_RecastCalcBoundsResult_get_bmin_1=wasmExports["zo"];Module["_emscripten_bind_RecastCalcBoundsResult_set_bmin_2"]=_emscripten_bind_RecastCalcBoundsResult_set_bmin_2=wasmExports["Ao"];Module["_emscripten_bind_RecastCalcBoundsResult_get_bmax_1"]=_emscripten_bind_RecastCalcBoundsResult_get_bmax_1=wasmExports["Bo"];Module["_emscripten_bind_RecastCalcBoundsResult_set_bmax_2"]=_emscripten_bind_RecastCalcBoundsResult_set_bmax_2=wasmExports["Co"];Module["_emscripten_bind_RecastCalcBoundsResult___destroy___0"]=_emscripten_bind_RecastCalcBoundsResult___destroy___0=wasmExports["Do"];Module["_emscripten_bind_RecastCalcGridSizeResult_get_width_0"]=_emscripten_bind_RecastCalcGridSizeResult_get_width_0=wasmExports["Eo"];Module["_emscripten_bind_RecastCalcGridSizeResult_set_width_1"]=_emscripten_bind_RecastCalcGridSizeResult_set_width_1=wasmExports["Fo"];Module["_emscripten_bind_RecastCalcGridSizeResult_get_height_0"]=_emscripten_bind_RecastCalcGridSizeResult_get_height_0=wasmExports["Go"];Module["_emscripten_bind_RecastCalcGridSizeResult_set_height_1"]=_emscripten_bind_RecastCalcGridSizeResult_set_height_1=wasmExports["Ho"];Module["_emscripten_bind_RecastCalcGridSizeResult___destroy___0"]=_emscripten_bind_RecastCalcGridSizeResult___destroy___0=wasmExports["Io"];Module["_emscripten_bind_Recast_Recast_0"]=_emscripten_bind_Recast_Recast_0=wasmExports["Jo"];Module["_emscripten_bind_Recast_calcBounds_2"]=_emscripten_bind_Recast_calcBounds_2=wasmExports["Ko"];Module["_emscripten_bind_Recast_calcGridSize_3"]=_emscripten_bind_Recast_calcGridSize_3=wasmExports["Lo"];Module["_emscripten_bind_Recast_createHeightfield_8"]=_emscripten_bind_Recast_createHeightfield_8=wasmExports["Mo"];Module["_emscripten_bind_Recast_markWalkableTriangles_7"]=_emscripten_bind_Recast_markWalkableTriangles_7=wasmExports["No"];Module["_emscripten_bind_Recast_clearUnwalkableTriangles_7"]=_emscripten_bind_Recast_clearUnwalkableTriangles_7=wasmExports["Oo"];Module["_emscripten_bind_Recast_rasterizeTriangles_8"]=_emscripten_bind_Recast_rasterizeTriangles_8=wasmExports["Po"];Module["_emscripten_bind_Recast_filterLowHangingWalkableObstacles_3"]=_emscripten_bind_Recast_filterLowHangingWalkableObstacles_3=wasmExports["Qo"];Module["_emscripten_bind_Recast_filterLedgeSpans_4"]=_emscripten_bind_Recast_filterLedgeSpans_4=wasmExports["Ro"];Module["_emscripten_bind_Recast_filterWalkableLowHeightSpans_3"]=_emscripten_bind_Recast_filterWalkableLowHeightSpans_3=wasmExports["So"];Module["_emscripten_bind_Recast_getHeightFieldSpanCount_2"]=_emscripten_bind_Recast_getHeightFieldSpanCount_2=wasmExports["To"];Module["_emscripten_bind_Recast_buildCompactHeightfield_5"]=_emscripten_bind_Recast_buildCompactHeightfield_5=wasmExports["Uo"];Module["_emscripten_bind_Recast_erodeWalkableArea_3"]=_emscripten_bind_Recast_erodeWalkableArea_3=wasmExports["Vo"];Module["_emscripten_bind_Recast_medianFilterWalkableArea_2"]=_emscripten_bind_Recast_medianFilterWalkableArea_2=wasmExports["Wo"];Module["_emscripten_bind_Recast_markBoxArea_5"]=_emscripten_bind_Recast_markBoxArea_5=wasmExports["Xo"];Module["_emscripten_bind_Recast_markConvexPolyArea_7"]=_emscripten_bind_Recast_markConvexPolyArea_7=wasmExports["Yo"];Module["_emscripten_bind_Recast_markCylinderArea_6"]=_emscripten_bind_Recast_markCylinderArea_6=wasmExports["Zo"];Module["_emscripten_bind_Recast_buildDistanceField_2"]=_emscripten_bind_Recast_buildDistanceField_2=wasmExports["_o"];Module["_emscripten_bind_Recast_buildRegions_5"]=_emscripten_bind_Recast_buildRegions_5=wasmExports["$o"];Module["_emscripten_bind_Recast_buildLayerRegions_4"]=_emscripten_bind_Recast_buildLayerRegions_4=wasmExports["ap"];Module["_emscripten_bind_Recast_buildRegionsMonotone_5"]=_emscripten_bind_Recast_buildRegionsMonotone_5=wasmExports["bp"];Module["_emscripten_bind_Recast_setCon_3"]=_emscripten_bind_Recast_setCon_3=wasmExports["cp"];Module["_emscripten_bind_Recast_getCon_2"]=_emscripten_bind_Recast_getCon_2=wasmExports["dp"];Module["_emscripten_bind_Recast_getDirOffsetX_1"]=_emscripten_bind_Recast_getDirOffsetX_1=wasmExports["ep"];Module["_emscripten_bind_Recast_getDirOffsetY_1"]=_emscripten_bind_Recast_getDirOffsetY_1=wasmExports["fp"];Module["_emscripten_bind_Recast_getDirForOffset_2"]=_emscripten_bind_Recast_getDirForOffset_2=wasmExports["gp"];Module["_emscripten_bind_Recast_buildHeightfieldLayers_5"]=_emscripten_bind_Recast_buildHeightfieldLayers_5=wasmExports["hp"];Module["_emscripten_bind_Recast_buildContours_6"]=_emscripten_bind_Recast_buildContours_6=wasmExports["ip"];Module["_emscripten_bind_Recast_buildPolyMesh_4"]=_emscripten_bind_Recast_buildPolyMesh_4=wasmExports["jp"];Module["_emscripten_bind_Recast_mergePolyMeshes_4"]=_emscripten_bind_Recast_mergePolyMeshes_4=wasmExports["kp"];Module["_emscripten_bind_Recast_buildPolyMeshDetail_6"]=_emscripten_bind_Recast_buildPolyMeshDetail_6=wasmExports["lp"];Module["_emscripten_bind_Recast_copyPolyMesh_3"]=_emscripten_bind_Recast_copyPolyMesh_3=wasmExports["mp"];Module["_emscripten_bind_Recast_mergePolyMeshDetails_4"]=_emscripten_bind_Recast_mergePolyMeshDetails_4=wasmExports["np"];Module["_emscripten_bind_Recast_getHeightfieldLayerHeights_1"]=_emscripten_bind_Recast_getHeightfieldLayerHeights_1=wasmExports["op"];Module["_emscripten_bind_Recast_getHeightfieldLayerAreas_1"]=_emscripten_bind_Recast_getHeightfieldLayerAreas_1=wasmExports["pp"];Module["_emscripten_bind_Recast_getHeightfieldLayerCons_1"]=_emscripten_bind_Recast_getHeightfieldLayerCons_1=wasmExports["qp"];Module["_emscripten_bind_Recast_allocHeightfield_0"]=_emscripten_bind_Recast_allocHeightfield_0=wasmExports["rp"];Module["_emscripten_bind_Recast_freeHeightfield_1"]=_emscripten_bind_Recast_freeHeightfield_1=wasmExports["sp"];Module["_emscripten_bind_Recast_allocCompactHeightfield_0"]=_emscripten_bind_Recast_allocCompactHeightfield_0=wasmExports["tp"];Module["_emscripten_bind_Recast_freeCompactHeightfield_1"]=_emscripten_bind_Recast_freeCompactHeightfield_1=wasmExports["up"];Module["_emscripten_bind_Recast_allocHeightfieldLayerSet_0"]=_emscripten_bind_Recast_allocHeightfieldLayerSet_0=wasmExports["vp"];Module["_emscripten_bind_Recast_freeHeightfieldLayerSet_1"]=_emscripten_bind_Recast_freeHeightfieldLayerSet_1=wasmExports["wp"];Module["_emscripten_bind_Recast_allocContourSet_0"]=_emscripten_bind_Recast_allocContourSet_0=wasmExports["xp"];Module["_emscripten_bind_Recast_freeContourSet_1"]=_emscripten_bind_Recast_freeContourSet_1=wasmExports["yp"];Module["_emscripten_bind_Recast_allocPolyMesh_0"]=_emscripten_bind_Recast_allocPolyMesh_0=wasmExports["zp"];Module["_emscripten_bind_Recast_freePolyMesh_1"]=_emscripten_bind_Recast_freePolyMesh_1=wasmExports["Ap"];Module["_emscripten_bind_Recast_allocPolyMeshDetail_0"]=_emscripten_bind_Recast_allocPolyMeshDetail_0=wasmExports["Bp"];Module["_emscripten_bind_Recast_freePolyMeshDetail_1"]=_emscripten_bind_Recast_freePolyMeshDetail_1=wasmExports["Cp"];Module["_emscripten_bind_Recast_get_BORDER_REG_0"]=_emscripten_bind_Recast_get_BORDER_REG_0=wasmExports["Dp"];Module["_emscripten_bind_Recast_set_BORDER_REG_1"]=_emscripten_bind_Recast_set_BORDER_REG_1=wasmExports["Ep"];Module["_emscripten_bind_Recast_get_MULTIPLE_REGS_0"]=_emscripten_bind_Recast_get_MULTIPLE_REGS_0=wasmExports["Fp"];Module["_emscripten_bind_Recast_set_MULTIPLE_REGS_1"]=_emscripten_bind_Recast_set_MULTIPLE_REGS_1=wasmExports["Gp"];Module["_emscripten_bind_Recast_get_BORDER_VERTEX_0"]=_emscripten_bind_Recast_get_BORDER_VERTEX_0=wasmExports["Hp"];Module["_emscripten_bind_Recast_set_BORDER_VERTEX_1"]=_emscripten_bind_Recast_set_BORDER_VERTEX_1=wasmExports["Ip"];Module["_emscripten_bind_Recast_get_AREA_BORDER_0"]=_emscripten_bind_Recast_get_AREA_BORDER_0=wasmExports["Jp"];Module["_emscripten_bind_Recast_set_AREA_BORDER_1"]=_emscripten_bind_Recast_set_AREA_BORDER_1=wasmExports["Kp"];Module["_emscripten_bind_Recast_get_CONTOUR_REG_MASK_0"]=_emscripten_bind_Recast_get_CONTOUR_REG_MASK_0=wasmExports["Lp"];Module["_emscripten_bind_Recast_set_CONTOUR_REG_MASK_1"]=_emscripten_bind_Recast_set_CONTOUR_REG_MASK_1=wasmExports["Mp"];Module["_emscripten_bind_Recast_get_MESH_NULL_IDX_0"]=_emscripten_bind_Recast_get_MESH_NULL_IDX_0=wasmExports["Np"];Module["_emscripten_bind_Recast_set_MESH_NULL_IDX_1"]=_emscripten_bind_Recast_set_MESH_NULL_IDX_1=wasmExports["Op"];Module["_emscripten_bind_Recast_get_NULL_AREA_0"]=_emscripten_bind_Recast_get_NULL_AREA_0=wasmExports["Pp"];Module["_emscripten_bind_Recast_set_NULL_AREA_1"]=_emscripten_bind_Recast_set_NULL_AREA_1=wasmExports["Qp"];Module["_emscripten_bind_Recast_get_WALKABLE_AREA_0"]=_emscripten_bind_Recast_get_WALKABLE_AREA_0=wasmExports["Rp"];Module["_emscripten_bind_Recast_set_WALKABLE_AREA_1"]=_emscripten_bind_Recast_set_WALKABLE_AREA_1=wasmExports["Sp"];Module["_emscripten_bind_Recast_get_NOT_CONNECTED_0"]=_emscripten_bind_Recast_get_NOT_CONNECTED_0=wasmExports["Tp"];Module["_emscripten_bind_Recast_set_NOT_CONNECTED_1"]=_emscripten_bind_Recast_set_NOT_CONNECTED_1=wasmExports["Up"];Module["_emscripten_bind_Recast___destroy___0"]=_emscripten_bind_Recast___destroy___0=wasmExports["Vp"];Module["_emscripten_bind_CreateNavMeshDataResult_get_success_0"]=_emscripten_bind_CreateNavMeshDataResult_get_success_0=wasmExports["Wp"];Module["_emscripten_bind_CreateNavMeshDataResult_set_success_1"]=_emscripten_bind_CreateNavMeshDataResult_set_success_1=wasmExports["Xp"];Module["_emscripten_bind_CreateNavMeshDataResult_get_navMeshData_0"]=_emscripten_bind_CreateNavMeshDataResult_get_navMeshData_0=wasmExports["Yp"];Module["_emscripten_bind_CreateNavMeshDataResult_set_navMeshData_1"]=_emscripten_bind_CreateNavMeshDataResult_set_navMeshData_1=wasmExports["Zp"];Module["_emscripten_bind_CreateNavMeshDataResult___destroy___0"]=_emscripten_bind_CreateNavMeshDataResult___destroy___0=wasmExports["_p"];Module["_emscripten_bind_DetourNavMeshBuilder_DetourNavMeshBuilder_0"]=_emscripten_bind_DetourNavMeshBuilder_DetourNavMeshBuilder_0=wasmExports["$p"];Module["_emscripten_bind_DetourNavMeshBuilder_setPolyMeshCreateParams_2"]=_emscripten_bind_DetourNavMeshBuilder_setPolyMeshCreateParams_2=wasmExports["aq"];Module["_emscripten_bind_DetourNavMeshBuilder_setPolyMeshDetailCreateParams_2"]=_emscripten_bind_DetourNavMeshBuilder_setPolyMeshDetailCreateParams_2=wasmExports["bq"];Module["_emscripten_bind_DetourNavMeshBuilder_setOffMeshConnections_8"]=_emscripten_bind_DetourNavMeshBuilder_setOffMeshConnections_8=wasmExports["cq"];Module["_emscripten_bind_DetourNavMeshBuilder_createNavMeshData_1"]=_emscripten_bind_DetourNavMeshBuilder_createNavMeshData_1=wasmExports["dq"];Module["_emscripten_bind_DetourNavMeshBuilder___destroy___0"]=_emscripten_bind_DetourNavMeshBuilder___destroy___0=wasmExports["eq"];Module["_emscripten_bind_dtTileCacheLayer___destroy___0"]=_emscripten_bind_dtTileCacheLayer___destroy___0=wasmExports["fq"];Module["_emscripten_bind_dtTileCacheContourSet___destroy___0"]=_emscripten_bind_dtTileCacheContourSet___destroy___0=wasmExports["gq"];Module["_emscripten_bind_dtTileCachePolyMesh___destroy___0"]=_emscripten_bind_dtTileCachePolyMesh___destroy___0=wasmExports["hq"];Module["_emscripten_bind_dtTileCacheLayerHeader_dtTileCacheLayerHeader_0"]=_emscripten_bind_dtTileCacheLayerHeader_dtTileCacheLayerHeader_0=wasmExports["iq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_magic_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_magic_0=wasmExports["jq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_magic_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_magic_1=wasmExports["kq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_version_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_version_0=wasmExports["lq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_version_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_version_1=wasmExports["mq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_tx_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_tx_0=wasmExports["nq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_tx_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_tx_1=wasmExports["oq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_ty_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_ty_0=wasmExports["pq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_ty_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_ty_1=wasmExports["qq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_tlayer_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_tlayer_0=wasmExports["rq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_tlayer_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_tlayer_1=wasmExports["sq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_bmin_1"]=_emscripten_bind_dtTileCacheLayerHeader_get_bmin_1=wasmExports["tq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_bmin_2"]=_emscripten_bind_dtTileCacheLayerHeader_set_bmin_2=wasmExports["uq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_bmax_1"]=_emscripten_bind_dtTileCacheLayerHeader_get_bmax_1=wasmExports["vq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_bmax_2"]=_emscripten_bind_dtTileCacheLayerHeader_set_bmax_2=wasmExports["wq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_hmin_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_hmin_0=wasmExports["xq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_hmin_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_hmin_1=wasmExports["yq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_hmax_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_hmax_0=wasmExports["zq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_hmax_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_hmax_1=wasmExports["Aq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_width_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_width_0=wasmExports["Bq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_width_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_width_1=wasmExports["Cq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_height_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_height_0=wasmExports["Dq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_height_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_height_1=wasmExports["Eq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_minx_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_minx_0=wasmExports["Fq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_minx_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_minx_1=wasmExports["Gq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_maxx_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_maxx_0=wasmExports["Hq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_maxx_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_maxx_1=wasmExports["Iq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_miny_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_miny_0=wasmExports["Jq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_miny_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_miny_1=wasmExports["Kq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_maxy_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_maxy_0=wasmExports["Lq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_maxy_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_maxy_1=wasmExports["Mq"];Module["_emscripten_bind_dtTileCacheLayerHeader___destroy___0"]=_emscripten_bind_dtTileCacheLayerHeader___destroy___0=wasmExports["Nq"];Module["_emscripten_bind_DetourTileCacheBuilder_DetourTileCacheBuilder_0"]=_emscripten_bind_DetourTileCacheBuilder_DetourTileCacheBuilder_0=wasmExports["Oq"];Module["_emscripten_bind_DetourTileCacheBuilder_buildTileCacheLayer_6"]=_emscripten_bind_DetourTileCacheBuilder_buildTileCacheLayer_6=wasmExports["Pq"];Module["_emscripten_bind_DetourTileCacheBuilder___destroy___0"]=_emscripten_bind_DetourTileCacheBuilder___destroy___0=wasmExports["Qq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_bmin_1"]=_emscripten_bind_rcChunkyTriMeshNode_get_bmin_1=wasmExports["Rq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_bmin_2"]=_emscripten_bind_rcChunkyTriMeshNode_set_bmin_2=wasmExports["Sq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_bmax_1"]=_emscripten_bind_rcChunkyTriMeshNode_get_bmax_1=wasmExports["Tq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_bmax_2"]=_emscripten_bind_rcChunkyTriMeshNode_set_bmax_2=wasmExports["Uq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_i_0"]=_emscripten_bind_rcChunkyTriMeshNode_get_i_0=wasmExports["Vq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_i_1"]=_emscripten_bind_rcChunkyTriMeshNode_set_i_1=wasmExports["Wq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_n_0"]=_emscripten_bind_rcChunkyTriMeshNode_get_n_0=wasmExports["Xq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_n_1"]=_emscripten_bind_rcChunkyTriMeshNode_set_n_1=wasmExports["Yq"];Module["_emscripten_bind_rcChunkyTriMeshNode___destroy___0"]=_emscripten_bind_rcChunkyTriMeshNode___destroy___0=wasmExports["Zq"];Module["_emscripten_bind_rcChunkyTriMesh_rcChunkyTriMesh_0"]=_emscripten_bind_rcChunkyTriMesh_rcChunkyTriMesh_0=wasmExports["_q"];Module["_emscripten_bind_rcChunkyTriMesh_get_nodes_1"]=_emscripten_bind_rcChunkyTriMesh_get_nodes_1=wasmExports["$q"];Module["_emscripten_bind_rcChunkyTriMesh_set_nodes_2"]=_emscripten_bind_rcChunkyTriMesh_set_nodes_2=wasmExports["ar"];Module["_emscripten_bind_rcChunkyTriMesh_get_nnodes_0"]=_emscripten_bind_rcChunkyTriMesh_get_nnodes_0=wasmExports["br"];Module["_emscripten_bind_rcChunkyTriMesh_set_nnodes_1"]=_emscripten_bind_rcChunkyTriMesh_set_nnodes_1=wasmExports["cr"];Module["_emscripten_bind_rcChunkyTriMesh_get_tris_1"]=_emscripten_bind_rcChunkyTriMesh_get_tris_1=wasmExports["dr"];Module["_emscripten_bind_rcChunkyTriMesh_set_tris_2"]=_emscripten_bind_rcChunkyTriMesh_set_tris_2=wasmExports["er"];Module["_emscripten_bind_rcChunkyTriMesh_get_ntris_0"]=_emscripten_bind_rcChunkyTriMesh_get_ntris_0=wasmExports["fr"];Module["_emscripten_bind_rcChunkyTriMesh_set_ntris_1"]=_emscripten_bind_rcChunkyTriMesh_set_ntris_1=wasmExports["gr"];Module["_emscripten_bind_rcChunkyTriMesh_get_maxTrisPerChunk_0"]=_emscripten_bind_rcChunkyTriMesh_get_maxTrisPerChunk_0=wasmExports["hr"];Module["_emscripten_bind_rcChunkyTriMesh_set_maxTrisPerChunk_1"]=_emscripten_bind_rcChunkyTriMesh_set_maxTrisPerChunk_1=wasmExports["ir"];Module["_emscripten_bind_rcChunkyTriMesh___destroy___0"]=_emscripten_bind_rcChunkyTriMesh___destroy___0=wasmExports["jr"];Module["_emscripten_bind_ChunkyTriMeshUtils_ChunkyTriMeshUtils_0"]=_emscripten_bind_ChunkyTriMeshUtils_ChunkyTriMeshUtils_0=wasmExports["kr"];Module["_emscripten_bind_ChunkyTriMeshUtils_createChunkyTriMesh_5"]=_emscripten_bind_ChunkyTriMeshUtils_createChunkyTriMesh_5=wasmExports["lr"];Module["_emscripten_bind_ChunkyTriMeshUtils_getChunksOverlappingRect_5"]=_emscripten_bind_ChunkyTriMeshUtils_getChunksOverlappingRect_5=wasmExports["mr"];Module["_emscripten_bind_ChunkyTriMeshUtils_getChunkyTriMeshNodeTris_2"]=_emscripten_bind_ChunkyTriMeshUtils_getChunkyTriMeshNodeTris_2=wasmExports["nr"];Module["_emscripten_bind_ChunkyTriMeshUtils___destroy___0"]=_emscripten_bind_ChunkyTriMeshUtils___destroy___0=wasmExports["or"];Module["_emscripten_bind_BoolRef_BoolRef_0"]=_emscripten_bind_BoolRef_BoolRef_0=wasmExports["pr"];Module["_emscripten_bind_BoolRef_get_value_0"]=_emscripten_bind_BoolRef_get_value_0=wasmExports["qr"];Module["_emscripten_bind_BoolRef_set_value_1"]=_emscripten_bind_BoolRef_set_value_1=wasmExports["rr"];Module["_emscripten_bind_BoolRef___destroy___0"]=_emscripten_bind_BoolRef___destroy___0=wasmExports["sr"];Module["_emscripten_bind_IntRef_IntRef_0"]=_emscripten_bind_IntRef_IntRef_0=wasmExports["tr"];Module["_emscripten_bind_IntRef_get_value_0"]=_emscripten_bind_IntRef_get_value_0=wasmExports["ur"];Module["_emscripten_bind_IntRef_set_value_1"]=_emscripten_bind_IntRef_set_value_1=wasmExports["vr"];Module["_emscripten_bind_IntRef___destroy___0"]=_emscripten_bind_IntRef___destroy___0=wasmExports["wr"];Module["_emscripten_bind_UnsignedIntRef_UnsignedIntRef_0"]=_emscripten_bind_UnsignedIntRef_UnsignedIntRef_0=wasmExports["xr"];Module["_emscripten_bind_UnsignedIntRef_get_value_0"]=_emscripten_bind_UnsignedIntRef_get_value_0=wasmExports["yr"];Module["_emscripten_bind_UnsignedIntRef_set_value_1"]=_emscripten_bind_UnsignedIntRef_set_value_1=wasmExports["zr"];Module["_emscripten_bind_UnsignedIntRef___destroy___0"]=_emscripten_bind_UnsignedIntRef___destroy___0=wasmExports["Ar"];Module["_emscripten_bind_UnsignedCharRef_UnsignedCharRef_0"]=_emscripten_bind_UnsignedCharRef_UnsignedCharRef_0=wasmExports["Br"];Module["_emscripten_bind_UnsignedCharRef_get_value_0"]=_emscripten_bind_UnsignedCharRef_get_value_0=wasmExports["Cr"];Module["_emscripten_bind_UnsignedCharRef_set_value_1"]=_emscripten_bind_UnsignedCharRef_set_value_1=wasmExports["Dr"];Module["_emscripten_bind_UnsignedCharRef___destroy___0"]=_emscripten_bind_UnsignedCharRef___destroy___0=wasmExports["Er"];Module["_emscripten_bind_UnsignedShortRef_UnsignedShortRef_0"]=_emscripten_bind_UnsignedShortRef_UnsignedShortRef_0=wasmExports["Fr"];Module["_emscripten_bind_UnsignedShortRef_get_value_0"]=_emscripten_bind_UnsignedShortRef_get_value_0=wasmExports["Gr"];Module["_emscripten_bind_UnsignedShortRef_set_value_1"]=_emscripten_bind_UnsignedShortRef_set_value_1=wasmExports["Hr"];Module["_emscripten_bind_UnsignedShortRef___destroy___0"]=_emscripten_bind_UnsignedShortRef___destroy___0=wasmExports["Ir"];Module["_emscripten_bind_FloatRef_FloatRef_0"]=_emscripten_bind_FloatRef_FloatRef_0=wasmExports["Jr"];Module["_emscripten_bind_FloatRef_get_value_0"]=_emscripten_bind_FloatRef_get_value_0=wasmExports["Kr"];Module["_emscripten_bind_FloatRef_set_value_1"]=_emscripten_bind_FloatRef_set_value_1=wasmExports["Lr"];Module["_emscripten_bind_FloatRef___destroy___0"]=_emscripten_bind_FloatRef___destroy___0=wasmExports["Mr"];Module["_emscripten_bind_IntArray_IntArray_0"]=_emscripten_bind_IntArray_IntArray_0=wasmExports["Nr"];Module["_emscripten_bind_IntArray_resize_1"]=_emscripten_bind_IntArray_resize_1=wasmExports["Or"];Module["_emscripten_bind_IntArray_copy_2"]=_emscripten_bind_IntArray_copy_2=wasmExports["Pr"];Module["_emscripten_bind_IntArray_free_0"]=_emscripten_bind_IntArray_free_0=wasmExports["Qr"];Module["_emscripten_bind_IntArray_get_1"]=_emscripten_bind_IntArray_get_1=wasmExports["Rr"];Module["_emscripten_bind_IntArray_set_2"]=_emscripten_bind_IntArray_set_2=wasmExports["Sr"];Module["_emscripten_bind_IntArray_getDataPointer_0"]=_emscripten_bind_IntArray_getDataPointer_0=wasmExports["Tr"];Module["_emscripten_bind_IntArray_get_data_1"]=_emscripten_bind_IntArray_get_data_1=wasmExports["Ur"];Module["_emscripten_bind_IntArray_set_data_2"]=_emscripten_bind_IntArray_set_data_2=wasmExports["Vr"];Module["_emscripten_bind_IntArray_get_size_0"]=_emscripten_bind_IntArray_get_size_0=wasmExports["Wr"];Module["_emscripten_bind_IntArray_set_size_1"]=_emscripten_bind_IntArray_set_size_1=wasmExports["Xr"];Module["_emscripten_bind_IntArray_get_isView_0"]=_emscripten_bind_IntArray_get_isView_0=wasmExports["Yr"];Module["_emscripten_bind_IntArray_set_isView_1"]=_emscripten_bind_IntArray_set_isView_1=wasmExports["Zr"];Module["_emscripten_bind_IntArray___destroy___0"]=_emscripten_bind_IntArray___destroy___0=wasmExports["_r"];Module["_emscripten_bind_UnsignedIntArray_UnsignedIntArray_0"]=_emscripten_bind_UnsignedIntArray_UnsignedIntArray_0=wasmExports["$r"];Module["_emscripten_bind_UnsignedIntArray_resize_1"]=_emscripten_bind_UnsignedIntArray_resize_1=wasmExports["as"];Module["_emscripten_bind_UnsignedIntArray_copy_2"]=_emscripten_bind_UnsignedIntArray_copy_2=wasmExports["bs"];Module["_emscripten_bind_UnsignedIntArray_free_0"]=_emscripten_bind_UnsignedIntArray_free_0=wasmExports["cs"];Module["_emscripten_bind_UnsignedIntArray_get_1"]=_emscripten_bind_UnsignedIntArray_get_1=wasmExports["ds"];Module["_emscripten_bind_UnsignedIntArray_set_2"]=_emscripten_bind_UnsignedIntArray_set_2=wasmExports["es"];Module["_emscripten_bind_UnsignedIntArray_getDataPointer_0"]=_emscripten_bind_UnsignedIntArray_getDataPointer_0=wasmExports["fs"];Module["_emscripten_bind_UnsignedIntArray_get_data_1"]=_emscripten_bind_UnsignedIntArray_get_data_1=wasmExports["gs"];Module["_emscripten_bind_UnsignedIntArray_set_data_2"]=_emscripten_bind_UnsignedIntArray_set_data_2=wasmExports["hs"];Module["_emscripten_bind_UnsignedIntArray_get_size_0"]=_emscripten_bind_UnsignedIntArray_get_size_0=wasmExports["is"];Module["_emscripten_bind_UnsignedIntArray_set_size_1"]=_emscripten_bind_UnsignedIntArray_set_size_1=wasmExports["js"];Module["_emscripten_bind_UnsignedIntArray_get_isView_0"]=_emscripten_bind_UnsignedIntArray_get_isView_0=wasmExports["ks"];Module["_emscripten_bind_UnsignedIntArray_set_isView_1"]=_emscripten_bind_UnsignedIntArray_set_isView_1=wasmExports["ls"];Module["_emscripten_bind_UnsignedIntArray___destroy___0"]=_emscripten_bind_UnsignedIntArray___destroy___0=wasmExports["ms"];Module["_emscripten_bind_UnsignedCharArray_UnsignedCharArray_0"]=_emscripten_bind_UnsignedCharArray_UnsignedCharArray_0=wasmExports["ns"];Module["_emscripten_bind_UnsignedCharArray_resize_1"]=_emscripten_bind_UnsignedCharArray_resize_1=wasmExports["os"];Module["_emscripten_bind_UnsignedCharArray_copy_2"]=_emscripten_bind_UnsignedCharArray_copy_2=wasmExports["ps"];Module["_emscripten_bind_UnsignedCharArray_free_0"]=_emscripten_bind_UnsignedCharArray_free_0=wasmExports["qs"];Module["_emscripten_bind_UnsignedCharArray_get_1"]=_emscripten_bind_UnsignedCharArray_get_1=wasmExports["rs"];Module["_emscripten_bind_UnsignedCharArray_set_2"]=_emscripten_bind_UnsignedCharArray_set_2=wasmExports["ss"];Module["_emscripten_bind_UnsignedCharArray_getDataPointer_0"]=_emscripten_bind_UnsignedCharArray_getDataPointer_0=wasmExports["ts"];Module["_emscripten_bind_UnsignedCharArray_get_data_1"]=_emscripten_bind_UnsignedCharArray_get_data_1=wasmExports["us"];Module["_emscripten_bind_UnsignedCharArray_set_data_2"]=_emscripten_bind_UnsignedCharArray_set_data_2=wasmExports["vs"];Module["_emscripten_bind_UnsignedCharArray_get_size_0"]=_emscripten_bind_UnsignedCharArray_get_size_0=wasmExports["ws"];Module["_emscripten_bind_UnsignedCharArray_set_size_1"]=_emscripten_bind_UnsignedCharArray_set_size_1=wasmExports["xs"];Module["_emscripten_bind_UnsignedCharArray_get_isView_0"]=_emscripten_bind_UnsignedCharArray_get_isView_0=wasmExports["ys"];Module["_emscripten_bind_UnsignedCharArray_set_isView_1"]=_emscripten_bind_UnsignedCharArray_set_isView_1=wasmExports["zs"];Module["_emscripten_bind_UnsignedCharArray___destroy___0"]=_emscripten_bind_UnsignedCharArray___destroy___0=wasmExports["As"];Module["_emscripten_bind_UnsignedShortArray_UnsignedShortArray_0"]=_emscripten_bind_UnsignedShortArray_UnsignedShortArray_0=wasmExports["Bs"];Module["_emscripten_bind_UnsignedShortArray_resize_1"]=_emscripten_bind_UnsignedShortArray_resize_1=wasmExports["Cs"];Module["_emscripten_bind_UnsignedShortArray_copy_2"]=_emscripten_bind_UnsignedShortArray_copy_2=wasmExports["Ds"];Module["_emscripten_bind_UnsignedShortArray_free_0"]=_emscripten_bind_UnsignedShortArray_free_0=wasmExports["Es"];Module["_emscripten_bind_UnsignedShortArray_get_1"]=_emscripten_bind_UnsignedShortArray_get_1=wasmExports["Fs"];Module["_emscripten_bind_UnsignedShortArray_set_2"]=_emscripten_bind_UnsignedShortArray_set_2=wasmExports["Gs"];Module["_emscripten_bind_UnsignedShortArray_getDataPointer_0"]=_emscripten_bind_UnsignedShortArray_getDataPointer_0=wasmExports["Hs"];Module["_emscripten_bind_UnsignedShortArray_get_data_1"]=_emscripten_bind_UnsignedShortArray_get_data_1=wasmExports["Is"];Module["_emscripten_bind_UnsignedShortArray_set_data_2"]=_emscripten_bind_UnsignedShortArray_set_data_2=wasmExports["Js"];Module["_emscripten_bind_UnsignedShortArray_get_size_0"]=_emscripten_bind_UnsignedShortArray_get_size_0=wasmExports["Ks"];Module["_emscripten_bind_UnsignedShortArray_set_size_1"]=_emscripten_bind_UnsignedShortArray_set_size_1=wasmExports["Ls"];Module["_emscripten_bind_UnsignedShortArray_get_isView_0"]=_emscripten_bind_UnsignedShortArray_get_isView_0=wasmExports["Ms"];Module["_emscripten_bind_UnsignedShortArray_set_isView_1"]=_emscripten_bind_UnsignedShortArray_set_isView_1=wasmExports["Ns"];Module["_emscripten_bind_UnsignedShortArray___destroy___0"]=_emscripten_bind_UnsignedShortArray___destroy___0=wasmExports["Os"];Module["_emscripten_bind_FloatArray_FloatArray_0"]=_emscripten_bind_FloatArray_FloatArray_0=wasmExports["Ps"];Module["_emscripten_bind_FloatArray_resize_1"]=_emscripten_bind_FloatArray_resize_1=wasmExports["Qs"];Module["_emscripten_bind_FloatArray_copy_2"]=_emscripten_bind_FloatArray_copy_2=wasmExports["Rs"];Module["_emscripten_bind_FloatArray_free_0"]=_emscripten_bind_FloatArray_free_0=wasmExports["Ss"];Module["_emscripten_bind_FloatArray_get_1"]=_emscripten_bind_FloatArray_get_1=wasmExports["Ts"];Module["_emscripten_bind_FloatArray_set_2"]=_emscripten_bind_FloatArray_set_2=wasmExports["Us"];Module["_emscripten_bind_FloatArray_getDataPointer_0"]=_emscripten_bind_FloatArray_getDataPointer_0=wasmExports["Vs"];Module["_emscripten_bind_FloatArray_get_data_1"]=_emscripten_bind_FloatArray_get_data_1=wasmExports["Ws"];Module["_emscripten_bind_FloatArray_set_data_2"]=_emscripten_bind_FloatArray_set_data_2=wasmExports["Xs"];Module["_emscripten_bind_FloatArray_get_size_0"]=_emscripten_bind_FloatArray_get_size_0=wasmExports["Ys"];Module["_emscripten_bind_FloatArray_set_size_1"]=_emscripten_bind_FloatArray_set_size_1=wasmExports["Zs"];Module["_emscripten_bind_FloatArray_get_isView_0"]=_emscripten_bind_FloatArray_get_isView_0=wasmExports["_s"];Module["_emscripten_bind_FloatArray_set_isView_1"]=_emscripten_bind_FloatArray_set_isView_1=wasmExports["$s"];Module["_emscripten_bind_FloatArray___destroy___0"]=_emscripten_bind_FloatArray___destroy___0=wasmExports["at"];Module["_emscripten_bind_NavMeshImporterResult_get_navMesh_0"]=_emscripten_bind_NavMeshImporterResult_get_navMesh_0=wasmExports["bt"];Module["_emscripten_bind_NavMeshImporterResult_set_navMesh_1"]=_emscripten_bind_NavMeshImporterResult_set_navMesh_1=wasmExports["ct"];Module["_emscripten_bind_NavMeshImporterResult_get_tileCache_0"]=_emscripten_bind_NavMeshImporterResult_get_tileCache_0=wasmExports["dt"];Module["_emscripten_bind_NavMeshImporterResult_set_tileCache_1"]=_emscripten_bind_NavMeshImporterResult_set_tileCache_1=wasmExports["et"];Module["_emscripten_bind_NavMeshImporterResult_get_allocator_0"]=_emscripten_bind_NavMeshImporterResult_get_allocator_0=wasmExports["ft"];Module["_emscripten_bind_NavMeshImporterResult_set_allocator_1"]=_emscripten_bind_NavMeshImporterResult_set_allocator_1=wasmExports["gt"];Module["_emscripten_bind_NavMeshImporterResult_get_compressor_0"]=_emscripten_bind_NavMeshImporterResult_get_compressor_0=wasmExports["ht"];Module["_emscripten_bind_NavMeshImporterResult_set_compressor_1"]=_emscripten_bind_NavMeshImporterResult_set_compressor_1=wasmExports["it"];Module["_emscripten_bind_NavMeshImporterResult___destroy___0"]=_emscripten_bind_NavMeshImporterResult___destroy___0=wasmExports["jt"];Module["_emscripten_bind_NavMeshImporter_NavMeshImporter_0"]=_emscripten_bind_NavMeshImporter_NavMeshImporter_0=wasmExports["kt"];Module["_emscripten_bind_NavMeshImporter_importNavMesh_2"]=_emscripten_bind_NavMeshImporter_importNavMesh_2=wasmExports["lt"];Module["_emscripten_bind_NavMeshImporter___destroy___0"]=_emscripten_bind_NavMeshImporter___destroy___0=wasmExports["mt"];Module["_emscripten_bind_NavMeshExport_NavMeshExport_0"]=_emscripten_bind_NavMeshExport_NavMeshExport_0=wasmExports["nt"];Module["_emscripten_bind_NavMeshExport_get_dataPointer_0"]=_emscripten_bind_NavMeshExport_get_dataPointer_0=wasmExports["ot"];Module["_emscripten_bind_NavMeshExport_set_dataPointer_1"]=_emscripten_bind_NavMeshExport_set_dataPointer_1=wasmExports["pt"];Module["_emscripten_bind_NavMeshExport_get_size_0"]=_emscripten_bind_NavMeshExport_get_size_0=wasmExports["qt"];Module["_emscripten_bind_NavMeshExport_set_size_1"]=_emscripten_bind_NavMeshExport_set_size_1=wasmExports["rt"];Module["_emscripten_bind_NavMeshExport___destroy___0"]=_emscripten_bind_NavMeshExport___destroy___0=wasmExports["st"];Module["_emscripten_bind_NavMeshExporter_NavMeshExporter_0"]=_emscripten_bind_NavMeshExporter_NavMeshExporter_0=wasmExports["tt"];Module["_emscripten_bind_NavMeshExporter_exportNavMesh_2"]=_emscripten_bind_NavMeshExporter_exportNavMesh_2=wasmExports["ut"];Module["_emscripten_bind_NavMeshExporter_freeNavMeshExport_1"]=_emscripten_bind_NavMeshExporter_freeNavMeshExport_1=wasmExports["vt"];Module["_emscripten_bind_NavMeshExporter___destroy___0"]=_emscripten_bind_NavMeshExporter___destroy___0=wasmExports["wt"];Module["_emscripten_bind_DebugDrawImpl_DebugDrawImpl_0"]=_emscripten_bind_DebugDrawImpl_DebugDrawImpl_0=wasmExports["xt"];Module["_emscripten_bind_DebugDrawImpl_handleDepthMask_1"]=_emscripten_bind_DebugDrawImpl_handleDepthMask_1=wasmExports["yt"];Module["_emscripten_bind_DebugDrawImpl_handleTexture_1"]=_emscripten_bind_DebugDrawImpl_handleTexture_1=wasmExports["zt"];Module["_emscripten_bind_DebugDrawImpl_handleBegin_2"]=_emscripten_bind_DebugDrawImpl_handleBegin_2=wasmExports["At"];Module["_emscripten_bind_DebugDrawImpl_handleVertexWithColor_4"]=_emscripten_bind_DebugDrawImpl_handleVertexWithColor_4=wasmExports["Bt"];Module["_emscripten_bind_DebugDrawImpl_handleVertexWithColorAndUV_6"]=_emscripten_bind_DebugDrawImpl_handleVertexWithColorAndUV_6=wasmExports["Ct"];Module["_emscripten_bind_DebugDrawImpl_handleEnd_0"]=_emscripten_bind_DebugDrawImpl_handleEnd_0=wasmExports["Dt"];Module["_emscripten_bind_DebugDrawImpl___destroy___0"]=_emscripten_bind_DebugDrawImpl___destroy___0=wasmExports["Et"];Module["_emscripten_bind_RecastDebugDraw_RecastDebugDraw_0"]=_emscripten_bind_RecastDebugDraw_RecastDebugDraw_0=wasmExports["Ft"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldSolid_2"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldSolid_2=wasmExports["Gt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldWalkable_2"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldWalkable_2=wasmExports["Ht"];Module["_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldSolid_2"]=_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldSolid_2=wasmExports["It"];Module["_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldRegions_2"]=_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldRegions_2=wasmExports["Jt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldDistance_2"]=_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldDistance_2=wasmExports["Kt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayer_3"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayer_3=wasmExports["Lt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayers_2"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayers_2=wasmExports["Mt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawRegionConnections_3"]=_emscripten_bind_RecastDebugDraw_debugDrawRegionConnections_3=wasmExports["Nt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawRawContours_3"]=_emscripten_bind_RecastDebugDraw_debugDrawRawContours_3=wasmExports["Ot"];Module["_emscripten_bind_RecastDebugDraw_debugDrawContours_3"]=_emscripten_bind_RecastDebugDraw_debugDrawContours_3=wasmExports["Pt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawPolyMesh_2"]=_emscripten_bind_RecastDebugDraw_debugDrawPolyMesh_2=wasmExports["Qt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawPolyMeshDetail_2"]=_emscripten_bind_RecastDebugDraw_debugDrawPolyMeshDetail_2=wasmExports["Rt"];Module["_emscripten_bind_RecastDebugDraw___destroy___0"]=_emscripten_bind_RecastDebugDraw___destroy___0=wasmExports["St"];Module["_emscripten_bind_DetourDebugDraw_DetourDebugDraw_0"]=_emscripten_bind_DetourDebugDraw_DetourDebugDraw_0=wasmExports["Tt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMesh_3"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMesh_3=wasmExports["Ut"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshWithClosedList_4"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshWithClosedList_4=wasmExports["Vt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshNodes_2"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshNodes_2=wasmExports["Wt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshBVTree_2"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshBVTree_2=wasmExports["Xt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPortals_2"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPortals_2=wasmExports["Yt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPolysWithFlags_4"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPolysWithFlags_4=wasmExports["Zt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPoly_4"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPoly_4=wasmExports["_t"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerAreas_4"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerAreas_4=wasmExports["$t"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerRegions_4"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerRegions_4=wasmExports["au"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCacheContours_5"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCacheContours_5=wasmExports["bu"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCachePolyMesh_5"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCachePolyMesh_5=wasmExports["cu"];Module["_emscripten_bind_DetourDebugDraw___destroy___0"]=_emscripten_bind_DetourDebugDraw___destroy___0=wasmExports["du"];Module["_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_START"]=_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_START=wasmExports["eu"];Module["_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_END"]=_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_END=wasmExports["fu"];Module["_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION"]=_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION=wasmExports["gu"];Module["_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS"]=_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS=wasmExports["hu"];Module["_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS"]=_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS=wasmExports["iu"];Module["_emscripten_enum_dtFindPathOptions_DT_FINDPATH_ANY_ANGLE"]=_emscripten_enum_dtFindPathOptions_DT_FINDPATH_ANY_ANGLE=wasmExports["ju"];Module["_emscripten_enum_dtRaycastOptions_DT_RAYCAST_USE_COSTS"]=_emscripten_enum_dtRaycastOptions_DT_RAYCAST_USE_COSTS=wasmExports["ku"];Module["_emscripten_enum_dtTileFlags_DT_TILE_FREE_DATA"]=_emscripten_enum_dtTileFlags_DT_TILE_FREE_DATA=wasmExports["lu"];Module["_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_INVALID"]=_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_INVALID=wasmExports["mu"];Module["_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_WALKING"]=_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_WALKING=wasmExports["nu"];Module["_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH"]=_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH=wasmExports["ou"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_NONE"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_NONE=wasmExports["pu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_FAILED"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_FAILED=wasmExports["qu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VALID"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VALID=wasmExports["ru"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING=wasmExports["su"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE=wasmExports["tu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH=wasmExports["uu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY=wasmExports["vu"];Module["_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES"]=_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES=wasmExports["wu"];Module["_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES"]=_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES=wasmExports["xu"];Module["_emscripten_enum_rcLogCategory_RC_LOG_PROGRESS"]=_emscripten_enum_rcLogCategory_RC_LOG_PROGRESS=wasmExports["yu"];Module["_emscripten_enum_rcLogCategory_RC_LOG_WARNING"]=_emscripten_enum_rcLogCategory_RC_LOG_WARNING=wasmExports["zu"];Module["_emscripten_enum_rcLogCategory_RC_LOG_ERROR"]=_emscripten_enum_rcLogCategory_RC_LOG_ERROR=wasmExports["Au"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_TOTAL"]=_emscripten_enum_rcTimerLabel_RC_TIMER_TOTAL=wasmExports["Bu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_TEMP"]=_emscripten_enum_rcTimerLabel_RC_TIMER_TEMP=wasmExports["Cu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES"]=_emscripten_enum_rcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES=wasmExports["Du"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD=wasmExports["Eu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS=wasmExports["Fu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE=wasmExports["Gu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY=wasmExports["Hu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_BORDER"]=_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_BORDER=wasmExports["Iu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_WALKABLE"]=_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_WALKABLE=wasmExports["Ju"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MEDIAN_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MEDIAN_AREA=wasmExports["Ku"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES"]=_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES=wasmExports["Lu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESH"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESH=wasmExports["Mu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESH"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESH=wasmExports["Nu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_ERODE_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_ERODE_AREA=wasmExports["Ou"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_BOX_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_BOX_AREA=wasmExports["Pu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA=wasmExports["Qu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA=wasmExports["Ru"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD=wasmExports["Su"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST=wasmExports["Tu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR=wasmExports["Uu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS=wasmExports["Vu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED=wasmExports["Wu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND=wasmExports["Xu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD=wasmExports["Yu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER=wasmExports["Zu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_LAYERS"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_LAYERS=wasmExports["_u"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL=wasmExports["$u"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL=wasmExports["av"];Module["_emscripten_enum_rcTimerLabel_RC_MAX_TIMERS"]=_emscripten_enum_rcTimerLabel_RC_MAX_TIMERS=wasmExports["bv"];Module["_emscripten_enum_dtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA"]=_emscripten_enum_dtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA=wasmExports["cv"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_POINTS"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_POINTS=wasmExports["dv"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_LINES"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_LINES=wasmExports["ev"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_TRIS"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_TRIS=wasmExports["fv"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_QUADS"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_QUADS=wasmExports["gv"];__emscripten_timeout=wasmExports["hv"]}var wasmImports={e:__abort_js,c:__emscripten_runtime_keepalive_clear,d:__setitimer_js,a:_emscripten_asm_const_int,f:_emscripten_resize_heap,b:_proc_exit};var wasmExports=await createWasm();function run(){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}function preInit(){if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}preInit();run();function WrapperObject(){}WrapperObject.prototype=Object.create(WrapperObject.prototype);WrapperObject.prototype.constructor=WrapperObject;WrapperObject.prototype.__class__=WrapperObject;WrapperObject.__cache__={};Module["WrapperObject"]=WrapperObject;function getCache(__class__){return(__class__||WrapperObject).__cache__}Module["getCache"]=getCache;function wrapPointer(ptr,__class__){var cache=getCache(__class__);var ret=cache[ptr];if(ret)return ret;ret=Object.create((__class__||WrapperObject).prototype);ret.ptr=ptr;return cache[ptr]=ret}Module["wrapPointer"]=wrapPointer;function castObject(obj,__class__){return wrapPointer(obj.ptr,__class__)}Module["castObject"]=castObject;Module["NULL"]=wrapPointer(0);function destroy(obj){if(!obj["__destroy__"])throw"Error: Cannot destroy object. (Did you create it yourself?)";obj["__destroy__"]();delete getCache(obj.__class__)[obj.ptr]}Module["destroy"]=destroy;function compare(obj1,obj2){return obj1.ptr===obj2.ptr}Module["compare"]=compare;function getPointer(obj){return obj.ptr}Module["getPointer"]=getPointer;function getClass(obj){return obj.__class__}Module["getClass"]=getClass;var ensureCache={buffer:0,size:0,pos:0,temps:[],needed:0,prepare(){if(ensureCache.needed){for(var i=0;i=ensureCache.size){assert(len>0);ensureCache.needed+=len;ret=Module["_webidl_malloc"](len);ensureCache.temps.push(ret)}else{ret=ensureCache.buffer+ensureCache.pos;ensureCache.pos+=len}return ret},copy(array,view,offset){offset/=view.BYTES_PER_ELEMENT;for(var i=0;i{readyPromiseResolve=resolve;readyPromiseReject=reject})} + + + return moduleRtn; +} +); +})(); +export default Recast; diff --git a/Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm b/Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm new file mode 100755 index 0000000000000000000000000000000000000000..38dbd7ca739c81d223ac1a5592c927a3f3d9e0d2 GIT binary patch literal 338824 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

|I|FAD7S`k|XR$Q~MSv#pN?0%cB3BL` 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

~1-?gYjn8S@AL4}eQ>r4^hOuklxk}I}JQlhO! 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Ϋ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 Date: Tue, 28 Jul 2026 13:52:37 +0200 Subject: [PATCH 02/51] Lib plugged --- .../NavMeshCharacterRuntimeBehavior.ts | 53 +++++ .../recast-navigation-generators.js | 190 ++++++++++++++++-- GDJS/Runtime/types/global-recast.d.ts | 1 + 3 files changed, 227 insertions(+), 17 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 66ae68b3a9f3..311944e5736e 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -12,6 +12,9 @@ namespace gdjs { } const Recast = await initializeRecast(); + + await RecastNav.init(); + console.log("Initialized Recast"); //@ts-ignore window.Recast = Recast; } catch (err) { @@ -103,6 +106,56 @@ namespace gdjs { this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap || 0; // this._manager = // gdjs.PathfindingObstaclesManager.getManager(instanceContainer); + + // const positions = [ + // 0, 0, 0, + // 0, 1, 0, + // 1, 1, 0, + // 1, 0, 0, + // ]; + + // const positions = [ + // 0, 0, 0, + // 0, 0, 1, + // 1, 0, 1, + // 1, 0, 0, + // ]; + + // const indices = [ + // 0, 1, 2, + // 1, 2, 3, + // ]; + + const groundMesh = new THREE.Mesh(new THREE.BoxGeometry(4, 0.2, 4)); + //const groundMesh = new THREE.Mesh(new THREE.PlaneGeometry( 1, 1 )); + const positions = groundMesh.geometry.attributes.position.array; + const indices = groundMesh.geometry.index.array; + + console.log(positions,indices); + + const navMeshConfig = { + borderSize: 0, + cs: 0.2, + ch: 0.2, + walkableSlopeAngle: 35, + walkableHeight: 1, + walkableClimb: 1, + walkableRadius: 1, + maxEdgeLen: 12, + maxSimplificationError: 1.3, + minRegionArea: 8, + mergeRegionArea: 20, + maxVertsPerPoly: 6, + detailSampleDist: 6, + detailSampleMaxError: 1, + }; + + const result = RecastNav.generateSoloNavMesh( + positions, + indices, + navMeshConfig + ); + console.log(result); } override applyBehaviorOverriding(behaviorData): boolean { diff --git a/Extensions/NavMeshPathfinding/recast-navigation-generators.js b/Extensions/NavMeshPathfinding/recast-navigation-generators.js index fe20d5880138..5095a6d3697e 100644 --- a/Extensions/NavMeshPathfinding/recast-navigation-generators.js +++ b/Extensions/NavMeshPathfinding/recast-navigation-generators.js @@ -4,6 +4,9 @@ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.RecastNav = {})); })(this, (function (exports) { 'use strict'; + var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null; + const instances = ['Recast', 'Detour', 'DetourNavMeshBuilder', 'DetourTileCacheBuilder', 'NavMeshImporter', 'NavMeshExporter', 'CrowdUtils', 'ChunkyTriMeshUtils', 'RecastDebugDraw', 'DetourDebugDraw']; + const classes = ['rcConfig', 'rcContext', 'dtNavMeshParams', 'dtNavMeshCreateParams', 'RecastLinearAllocator', 'RecastFastLZCompressor', 'rcChunkyTriMesh', 'dtTileCacheParams', 'dtTileCacheLayerHeader', 'Vec3', 'BoolRef', 'IntRef', 'UnsignedIntRef', 'UnsignedCharRef', 'UnsignedShortRef', 'FloatRef', 'IntArray', 'UnsignedIntArray', 'UnsignedCharArray', 'UnsignedShortArray', 'FloatArray']; /** * Lower level bindings for the Recast and Detour libraries. * @@ -17,8 +20,117 @@ Raw.Module.destroy(obj); } }; - const Recast = {}; + const Recast$1 = {}; const Detour = {}; + const init = async impl => { + if (Raw.Module !== undefined) { + return; + } + if (impl) { + Raw.Module = await impl(); + } else { + const defaultExport = (await Promise.resolve().then(function () { return recastNavigation_wasmCompat; })).default; + Raw.Module = await defaultExport(); + } + for (const instance of instances) { + Raw[instance] = new Raw.Module[instance](); + } + for (const clazz of classes) { + Raw[clazz] = Raw.Module[clazz]; + } + // recast constants + Recast$1.RC_BORDER_REG = Raw.Recast.BORDER_REG; + Recast$1.RC_MULTIPLE_REGS = Raw.Recast.MULTIPLE_REGS; + Recast$1.RC_BORDER_VERTEX = Raw.Recast.BORDER_VERTEX; + Recast$1.RC_AREA_BORDER = Raw.Recast.AREA_BORDER; + Recast$1.RC_CONTOUR_REG_MASK = Raw.Recast.CONTOUR_REG_MASK; + Recast$1.RC_MESH_NULL_IDX = Raw.Recast.MESH_NULL_IDX; + Recast$1.RC_NULL_AREA = Raw.Recast.NULL_AREA; + Recast$1.RC_WALKABLE_AREA = Raw.Recast.WALKABLE_AREA; + Recast$1.RC_NOT_CONNECTED = Raw.Recast.NOT_CONNECTED; + // recast enums + Recast$1.RC_CONTOUR_TESS_WALL_EDGES = Raw.Module.RC_CONTOUR_TESS_WALL_EDGES; + Recast$1.RC_CONTOUR_TESS_AREA_EDGES = Raw.Module.RC_CONTOUR_TESS_AREA_EDGES; + Recast$1.RC_LOG_PROGRESS = Raw.Module.RC_LOG_PROGRESS; + Recast$1.RC_LOG_WARNING = Raw.Module.RC_LOG_WARNING; + Recast$1.RC_LOG_ERROR = Raw.Module.RC_LOG_ERROR; + Recast$1.RC_TIMER_TOTAL = Raw.Module.RC_TIMER_TOTAL; + Recast$1.RC_TIMER_TEMP = Raw.Module.RC_TIMER_TEMP; + Recast$1.RC_TIMER_RASTERIZE_TRIANGLES = Raw.Module.RC_TIMER_RASTERIZE_TRIANGLES; + Recast$1.RC_TIMER_BUILD_COMPACTHEIGHTFIELD = Raw.Module.RC_TIMER_BUILD_COMPACTHEIGHTFIELD; + Recast$1.RC_TIMER_BUILD_CONTOURS = Raw.Module.RC_TIMER_BUILD_CONTOURS; + Recast$1.RC_TIMER_BUILD_CONTOURS_TRACE = Raw.Module.RC_TIMER_BUILD_CONTOURS_TRACE; + Recast$1.RC_TIMER_BUILD_CONTOURS_SIMPLIFY = Raw.Module.RC_TIMER_BUILD_CONTOURS_SIMPLIFY; + Recast$1.RC_TIMER_FILTER_BORDER = Raw.Module.RC_TIMER_FILTER_BORDER; + Recast$1.RC_TIMER_FILTER_WALKABLE = Raw.Module.RC_TIMER_FILTER_WALKABLE; + Recast$1.RC_TIMER_MEDIAN_AREA = Raw.Module.RC_TIMER_MEDIAN_AREA; + Recast$1.RC_TIMER_FILTER_LOW_OBSTACLES = Raw.Module.RC_TIMER_FILTER_LOW_OBSTACLES; + Recast$1.RC_TIMER_BUILD_POLYMESH = Raw.Module.RC_TIMER_BUILD_POLYMESH; + Recast$1.RC_TIMER_MERGE_POLYMESH = Raw.Module.RC_TIMER_MERGE_POLYMESH; + Recast$1.RC_TIMER_ERODE_AREA = Raw.Module.RC_TIMER_ERODE_AREA; + Recast$1.RC_TIMER_MARK_BOX_AREA = Raw.Module.RC_TIMER_MARK_BOX_AREA; + Recast$1.RC_TIMER_MARK_CYLINDER_AREA = Raw.Module.RC_TIMER_MARK_CYLINDER_AREA; + Recast$1.RC_TIMER_MARK_CONVEXPOLY_AREA = Raw.Module.RC_TIMER_MARK_CONVEXPOLY_AREA; + Recast$1.RC_TIMER_BUILD_DISTANCEFIELD = Raw.Module.RC_TIMER_BUILD_DISTANCEFIELD; + Recast$1.RC_TIMER_BUILD_DISTANCEFIELD_DIST = Raw.Module.RC_TIMER_BUILD_DISTANCEFIELD_DIST; + Recast$1.RC_TIMER_BUILD_DISTANCEFIELD_BLUR = Raw.Module.RC_TIMER_BUILD_DISTANCEFIELD_BLUR; + Recast$1.RC_TIMER_BUILD_REGIONS = Raw.Module.RC_TIMER_BUILD_REGIONS; + Recast$1.RC_TIMER_BUILD_REGIONS_WATERSHED = Raw.Module.RC_TIMER_BUILD_REGIONS_WATERSHED; + Recast$1.RC_TIMER_BUILD_REGIONS_EXPAND = Raw.Module.RC_TIMER_BUILD_REGIONS_EXPAND; + Recast$1.RC_TIMER_BUILD_REGIONS_FLOOD = Raw.Module.RC_TIMER_BUILD_REGIONS_FLOOD; + Recast$1.RC_TIMER_BUILD_REGIONS_FILTER = Raw.Module.RC_TIMER_BUILD_REGIONS_FILTER; + Recast$1.RC_TIMER_BUILD_LAYERS = Raw.Module.RC_TIMER_BUILD_LAYERS; + Recast$1.RC_TIMER_BUILD_POLYMESHDETAIL = Raw.Module.RC_TIMER_BUILD_POLYMESHDETAIL; + Recast$1.RC_TIMER_MERGE_POLYMESHDETAIL = Raw.Module.RC_TIMER_MERGE_POLYMESHDETAIL; + Recast$1.RC_MAX_TIMERS = Raw.Module.RC_MAX_TIMERS; + // detour constants + Detour.DT_FAILURE = Raw.Detour.FAILURE; + Detour.DT_SUCCESS = Raw.Detour.SUCCESS; + Detour.DT_IN_PROGRESS = Raw.Detour.IN_PROGRESS; + Detour.DT_STATUS_DETAIL_MASK = Raw.Detour.STATUS_DETAIL_MASK; + Detour.DT_WRONG_MAGIC = Raw.Detour.WRONG_MAGIC; + Detour.DT_WRONG_VERSION = Raw.Detour.WRONG_VERSION; + Detour.DT_OUT_OF_MEMORY = Raw.Detour.OUT_OF_MEMORY; + Detour.DT_INVALID_PARAM = Raw.Detour.INVALID_PARAM; + Detour.DT_BUFFER_TOO_SMALL = Raw.Detour.BUFFER_TOO_SMALL; + Detour.DT_OUT_OF_NODES = Raw.Detour.OUT_OF_NODES; + Detour.DT_PARTIAL_RESULT = Raw.Detour.PARTIAL_RESULT; + Detour.DT_ALREADY_OCCUPIED = Raw.Detour.ALREADY_OCCUPIED; + Detour.DT_VERTS_PER_POLYGON = Raw.Detour.VERTS_PER_POLYGON; + Detour.DT_NAVMESH_MAGIC = Raw.Detour.NAVMESH_MAGIC; + Detour.DT_NAVMESH_VERSION = Raw.Detour.NAVMESH_VERSION; + Detour.DT_NAVMESH_STATE_MAGIC = Raw.Detour.NAVMESH_STATE_MAGIC; + Detour.DT_NAVMESH_STATE_VERSION = Raw.Detour.NAVMESH_STATE_VERSION; + Detour.DT_TILECACHE_MAGIC = Raw.Detour.TILECACHE_MAGIC; + Detour.DT_TILECACHE_VERSION = Raw.Detour.TILECACHE_VERSION; + Detour.DT_TILECACHE_NULL_AREA = Raw.Detour.TILECACHE_NULL_AREA; + Detour.DT_TILECACHE_WALKABLE_AREA = Raw.Detour.TILECACHE_WALKABLE_AREA; + Detour.DT_TILECACHE_NULL_IDX = Raw.Detour.TILECACHE_NULL_IDX; + Detour.DT_NULL_LINK = Raw.Detour.NULL_LINK; + Detour.DT_NULL_LINK = Raw.Detour.NULL_LINK; + Detour.DT_EXT_LINK = Raw.Detour.EXT_LINK; + Detour.DT_OFFMESH_CON_BIDIR = Raw.Detour.OFFMESH_CON_BIDIR; + // detour enums + Detour.DT_STRAIGHTPATH_START = Raw.Module.DT_STRAIGHTPATH_START; + Detour.DT_STRAIGHTPATH_END = Raw.Module.DT_STRAIGHTPATH_END; + Detour.DT_STRAIGHTPATH_OFFMESH_CONNECTION = Raw.Module.DT_STRAIGHTPATH_OFFMESH_CONNECTION; + Detour.DT_STRAIGHTPATH_AREA_CROSSINGS = Raw.Module.DT_STRAIGHTPATH_AREA_CROSSINGS; + Detour.DT_STRAIGHTPATH_ALL_CROSSINGS = Raw.Module.DT_STRAIGHTPATH_ALL_CROSSINGS; + Detour.DT_FINDPATH_ANY_ANGLE = Raw.Module.DT_FINDPATH_ANY_ANGLE; + Detour.DT_RAYCAST_USE_COSTS = Raw.Module.DT_RAYCAST_USE_COSTS; + Detour.DT_CROWDAGENT_STATE_INVALID = Raw.Module.DT_CROWDAGENT_STATE_INVALID; + Detour.DT_CROWDAGENT_STATE_WALKING = Raw.Module.DT_CROWDAGENT_STATE_WALKING; + Detour.DT_CROWDAGENT_STATE_OFFMESH = Raw.Module.DT_CROWDAGENT_STATE_OFFMESH; + Detour.DT_CROWDAGENT_TARGET_NONE = Raw.Module.DT_CROWDAGENT_TARGET_NONE; + Detour.DT_CROWDAGENT_TARGET_FAILED = Raw.Module.DT_CROWDAGENT_TARGET_FAILED; + Detour.DT_CROWDAGENT_TARGET_VALID = Raw.Module.DT_CROWDAGENT_TARGET_VALID; + Detour.DT_CROWDAGENT_TARGET_REQUESTING = Raw.Module.DT_CROWDAGENT_TARGET_REQUESTING; + Detour.DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE = Raw.Module.DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE; + Detour.DT_CROWDAGENT_TARGET_WAITING_FOR_PATH = Raw.Module.DT_CROWDAGENT_TARGET_WAITING_FOR_PATH; + Detour.DT_CROWDAGENT_TARGET_VELOCITY = Raw.Module.DT_CROWDAGENT_TARGET_VELOCITY; + Detour.DT_COMPRESSEDTILE_FREE_DATA = Raw.Module.DT_COMPRESSEDTILE_FREE_DATA; + Detour.DT_TILE_FREE_DATA = Raw.Module.DT_TILE_FREE_DATA; + }; class BaseArray { get size() { @@ -1137,7 +1249,7 @@ return this.accumulatedTimes[label]; } resetTimers() { - for (let i = 0; i < Recast.RC_MAX_TIMERS; i++) { + for (let i = 0; i < Recast$1.RC_MAX_TIMERS; i++) { this.startTimes[i] = -1; this.accumulatedTimes[i] = -1; } @@ -1538,7 +1650,7 @@ const buildHeightfieldLayers = (buildContext, compactHeightfield, borderSize, walkableHeight, heightfieldLayerSet) => { return Raw.Recast.buildHeightfieldLayers(buildContext.raw, compactHeightfield.raw, borderSize, walkableHeight, heightfieldLayerSet.raw); }; - const buildContours = (buildContext, compactHeightfield, maxError, maxEdgeLen, contourSet, buildFlags = Recast.RC_CONTOUR_TESS_WALL_EDGES) => { + const buildContours = (buildContext, compactHeightfield, maxError, maxEdgeLen, contourSet, buildFlags = Recast$1.RC_CONTOUR_TESS_WALL_EDGES) => { return Raw.Recast.buildContours(buildContext.raw, compactHeightfield.raw, maxError, maxEdgeLen, contourSet.raw, buildFlags); }; const buildPolyMesh = (buildContext, contourSet, nvp, polyMesh) => { @@ -1962,7 +2074,7 @@ // const contourSet = allocContourSet(); intermediates.contourSet = contourSet; - if (!buildContours(buildContext, compactHeightfield, rcConfig.maxSimplificationError, rcConfig.maxEdgeLen, contourSet, Recast.RC_CONTOUR_TESS_WALL_EDGES)) { + if (!buildContours(buildContext, compactHeightfield, rcConfig.maxSimplificationError, rcConfig.maxEdgeLen, contourSet, Recast$1.RC_CONTOUR_TESS_WALL_EDGES)) { return fail('Failed to create contours'); } // @@ -1991,7 +2103,7 @@ // Step 8. Create Detour data from Recast poly mesh. // for (let i = 0; i < polyMesh.npolys(); i++) { - if (polyMesh.areas(i) === Recast.RC_WALKABLE_AREA) { + if (polyMesh.areas(i) === Recast$1.RC_WALKABLE_AREA) { polyMesh.setAreas(i, 0); } if (polyMesh.areas(i) === 0) { @@ -2371,7 +2483,7 @@ const tileCacheData = newTiles[i]; const addResult = tileCache.addTile(tileCacheData); if (statusFailed(addResult.status)) { - buildContext.log(Recast.RC_LOG_WARNING, `Failed to add tile to tile cache - tx: ${x}, ty: ${y}`); + buildContext.log(Recast$1.RC_LOG_WARNING, `Failed to add tile to tile cache - tx: ${x}, ty: ${y}`); } } } @@ -2475,7 +2587,7 @@ } }; const failTileMesh = error => { - buildContext.log(Recast.RC_LOG_ERROR, error); + buildContext.log(Recast$1.RC_LOG_ERROR, error); cleanup(); return { success: false, @@ -2520,10 +2632,10 @@ // Reset build timer buildContext.resetTimers(); // Start the build process - buildContext.startTimer(Recast.RC_TIMER_TOTAL); - buildContext.log(Recast.RC_LOG_PROGRESS, `Building tile at x: ${tile.x}, y: ${tile.y}`); - buildContext.log(Recast.RC_LOG_PROGRESS, ` - ${tileConfig.width} x ${tileConfig.height} cells`); - buildContext.log(Recast.RC_LOG_PROGRESS, ` - ${positions.size / 3 / 1000}K verts, ${indices.size / 3 / 1000}K tris`); + buildContext.startTimer(Recast$1.RC_TIMER_TOTAL); + buildContext.log(Recast$1.RC_LOG_PROGRESS, `Building tile at x: ${tile.x}, y: ${tile.y}`); + buildContext.log(Recast$1.RC_LOG_PROGRESS, ` - ${tileConfig.width} x ${tileConfig.height} cells`); + buildContext.log(Recast$1.RC_LOG_PROGRESS, ` - ${positions.size / 3 / 1000}K verts, ${indices.size / 3 / 1000}K tris`); // Allocate voxel heightfield where we rasterize our input data to. const heightfield = allocHeightfield(); tileIntermediate.heightfield = heightfield; @@ -2602,7 +2714,7 @@ // const contourSet = allocContourSet(); tileIntermediate.contourSet = contourSet; - if (!buildContours(buildContext, compactHeightfield, tileConfig.maxSimplificationError, tileConfig.maxEdgeLen, contourSet, Recast.RC_CONTOUR_TESS_WALL_EDGES)) { + if (!buildContours(buildContext, compactHeightfield, tileConfig.maxSimplificationError, tileConfig.maxEdgeLen, contourSet, Recast$1.RC_CONTOUR_TESS_WALL_EDGES)) { return failTileMesh('Failed to create contours'); } // @@ -2629,7 +2741,7 @@ } // Update poly flags from areas. for (let i = 0; i < polyMesh.npolys(); i++) { - if (polyMesh.areas(i) === Recast.RC_WALKABLE_AREA) { + if (polyMesh.areas(i) === Recast$1.RC_WALKABLE_AREA) { polyMesh.setAreas(i, 0); } if (polyMesh.areas(i) === 0) { @@ -2654,7 +2766,7 @@ if (!createNavMeshDataResult.success) { return failTileMesh('Failed to create Detour navmesh data'); } - buildContext.log(Recast.RC_LOG_PROGRESS, `>> Polymesh: ${polyMesh.nverts()} vertices ${polyMesh.npolys()} polygons`); + buildContext.log(Recast$1.RC_LOG_PROGRESS, `>> Polymesh: ${polyMesh.nverts()} vertices ${polyMesh.npolys()} polygons`); return { success: true, data: createNavMeshDataResult.navMeshData, @@ -2751,7 +2863,7 @@ if (!chunkyTriMesh.init(verticesArray, trianglesArray, numTriangles, generatorConfig.chunkyTriMeshTrisPerChunk)) { return fail('Failed to build chunky triangle mesh'); } - buildContext.startTimer(Recast.RC_TIMER_TEMP); + buildContext.startTimer(Recast$1.RC_TIMER_TEMP); const lastBuiltTileBmin = [0, 0, 0]; const lastBuiltTileBmax = [0, 0, 0]; for (let y = 0; y < tileHeight; y++) { @@ -2778,13 +2890,13 @@ navMesh.removeTile(navMesh.getTileRefAt(x, y, 0)); const addTileResult = navMesh.addTile(result.data, Detour.DT_TILE_FREE_DATA, 0); if (statusFailed(addTileResult.status)) { - buildContext.log(Recast.RC_LOG_WARNING, `Failed to add tile to nav mesh tx: ${x}, ty: ${y}, status: ${statusToReadableString(addTileResult.status)} (${addTileResult.status})`); + buildContext.log(Recast$1.RC_LOG_WARNING, `Failed to add tile to nav mesh tx: ${x}, ty: ${y}, status: ${statusToReadableString(addTileResult.status)} (${addTileResult.status})`); result.data.destroy(); } } } } - buildContext.stopTimer(Recast.RC_TIMER_TEMP); + buildContext.stopTimer(Recast$1.RC_TIMER_TEMP); if (!keepIntermediates) { cleanup(); } @@ -2822,6 +2934,49 @@ return [Float32Array.from(mergedPositions), Uint32Array.from(mergedIndices)]; }; + // @recast-navigation/wasm, a port of recast navigation to JavaScript. + // https://github.com/isaac-mason/recast-navigation-js + + // recastnavigation + // https://github.com/recastnavigation/recastnavigation + + // Recast & Detour + // Copyright (c) 2009 Mikko Mononen memon@inside.org + // + // This software is provided 'as-is', without any express or implied + // warranty. In no event will the authors be held liable for any damages + // arising from the use of this software. + // + // Permission is granted to anyone to use this software for any purpose, + // including commercial applications, and to alter it and redistribute it + // freely, subject to the following restrictions: + // + // 1. The origin of this software must not be misrepresented; you must not + // claim that you wrote the original software. If you use this software + // in a product, an acknowledgment in the product documentation would be + // appreciated but is not required. + // 2. Altered source versions must be plainly marked as such, and must not be + // misrepresented as being the original software. + // 3. This notice may not be removed or altered from any source distribution. + var Recast = (() => { + + return ( + async function(moduleArg = {}) { + var moduleRtn; + + var Module=moduleArg;var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=(typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('recast-navigation-generators.js', document.baseURI).href));var scriptDirectory="";{try{scriptDirectory=new URL(".",_scriptName).href;}catch{}}console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text);}}var readyPromiseResolve,readyPromiseReject;var wasmMemory;var HEAP8,HEAPU8,HEAP16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift());}}callRuntimeCallbacks(onPreRuns);}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(onInits);wasmExports["h"]();}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift());}}callRuntimeCallbacks(onPostRuns);}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies);}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return base64Decode("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")}function getBinarySync(file){if(ArrayBuffer.isView(file)){return file}if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}throw "both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason);}}async function instantiateAsync(binary,binaryFile,imports){return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return {a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["g"];updateMemoryViews();wasmTable=wasmExports["n"];assignWasmExports(wasmExports);removeRunDependency();return wasmExports}addRunDependency();function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(mod,inst)=>{resolve(receiveInstance(mod));});})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status;}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module);}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var base64Decode=b64=>{var b1,b2,i=0,j=0,bLength=b64.length;var output=new Uint8Array((bLength*3>>2)-(b64[bLength-2]=="=")-(b64[bLength-1]=="="));for(;i>4;output[j+1]=b1<<4|b2>>2;output[j+2]=b2<<6|base64ReverseLookup[b64.charCodeAt(i+3)];}return output};var noExitRuntime=true;var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0;};var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e);};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true;}quit_(code,new ExitStatus(code));};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status);};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS);}catch(e){handleException(e);}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit();}catch(e){handleException(e);}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which];}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()));},timeout_ms);timers[which]={id,timeout_ms};return 0};var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{readEmAsmArgsArray.length=0;var ch;while(ch=HEAPU8[sigPtr++]){var wide=ch!=105;wide&=ch!=112;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?HEAPU32[buf>>2]:ch==105?HEAP32[buf>>2]:HEAPF64[buf>>3]);buf+=wide?8:4;}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);return ASM_CONSTS[code](...args)};var _emscripten_asm_const_int=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i;}else {len+=3;}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=endIdx)break;heap[outIdx++]=u;}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63;}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;}else {if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++;}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=lengthBytesUTF8(stringy)+1;var u8array=new Array(len);stringToUTF8Array(stringy,u8array,0,u8array.length);return u8array};var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead=NaN)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023);}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var onInits=[];var addOnInit=cb=>onInits.push(cb);var uleb128Encode=(n,target)=>{if(n<128){target.push(n);}else {target.push(n%128|128,n>>7);}};var sigToWasmTypes=sig=>{var typeNames={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"};var type={parameters:[],results:sig[0]=="v"?[]:[typeNames[sig[0]]]};for(var i=1;i{var sigRet=sig.slice(0,1);var sigParam=sig.slice(1);var typeCodes={i:127,p:127,j:126,f:125,d:124,e:111};target.push(96);uleb128Encode(sigParam.length,target);for(var paramType of sigParam){target.push(typeCodes[paramType]);}if(sigRet=="v"){target.push(0);}else {target.push(1,typeCodes[sigRet]);}};var convertJsFunctionToWasm=(func,sig)=>{if(typeof WebAssembly.Function=="function"){return new WebAssembly.Function(sigToWasmTypes(sig),func)}var typeSectionBody=[1];generateFuncType(sig,typeSectionBody);var bytes=[0,97,115,109,1,0,0,0,1];uleb128Encode(typeSectionBody.length,bytes);bytes.push(...typeSectionBody);bytes.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var module=new WebAssembly.Module(new Uint8Array(bytes));var instance=new WebAssembly.Instance(module,{e:{f:func}});var wrappedFunc=instance.exports["f"];return wrappedFunc};var wasmTableMirror=[];var wasmTable;var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr);}return func};var updateTableMap=(offset,count)=>{if(functionsInTableMap){for(var i=offset;i{if(!functionsInTableMap){functionsInTableMap=new WeakMap;updateTableMap(0,wasmTable.length);}return functionsInTableMap.get(func)||0};var freeTableIndexes=[];var getEmptyTableSlot=()=>{if(freeTableIndexes.length){return freeTableIndexes.pop()}try{wasmTable.grow(1);}catch(err){if(!(err instanceof RangeError)){throw err}throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."}return wasmTable.length-1};var setWasmTableEntry=(idx,func)=>{wasmTable.set(idx,func);wasmTableMirror[idx]=wasmTable.get(idx);};var addFunction=(func,sig)=>{var rtn=getFunctionAddress(func);if(rtn){return rtn}var ret=getEmptyTableSlot();try{setWasmTableEntry(ret,func);}catch(err){if(!(err instanceof TypeError)){throw err}var wrapped=convertJsFunctionToWasm(func,sig);setWasmTableEntry(ret,wrapped);}functionsInTableMap.set(func,ret);return ret};for(var base64ReverseLookup=new Uint8Array(123),i=25;i>=0;--i){base64ReverseLookup[48+i]=52+i;base64ReverseLookup[65+i]=i;base64ReverseLookup[97+i]=26+i;}base64ReverseLookup[43]=62;base64ReverseLookup[47]=63;{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])Module["thisProgram"];}Module["addFunction"]=addFunction;Module["UTF8ToString"]=UTF8ToString;var ASM_CONSTS={14746:($0,$1,$2,$3)=>{var self=Module["getCache"](Module["TileCacheMeshProcess"])[$0];if(!self.hasOwnProperty("process"))throw "a JSImplementation must implement all functions, you forgot TileCacheMeshProcess::process.";self["process"]($1,$2,$3);},14981:$0=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("resetLog"))throw "a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::resetLog.";self["resetLog"]();},15219:($0,$1,$2,$3)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("log"))throw "a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::log.";self["log"]($1,$2,$3);},15450:$0=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("resetTimers"))throw "a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::resetTimers.";self["resetTimers"]();},15697:($0,$1)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("startTimer"))throw "a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::startTimer.";self["startTimer"]($1);},15943:($0,$1)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("stopTimer"))throw "a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::stopTimer.";self["stopTimer"]($1);},16186:($0,$1)=>{var self=Module["getCache"](Module["RecastBuildContextJsImpl"])[$0];if(!self.hasOwnProperty("getAccumulatedTime"))throw "a JSImplementation must implement all functions, you forgot RecastBuildContextJsImpl::getAccumulatedTime.";return self["getAccumulatedTime"]($1)},16463:($0,$1)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleDepthMask"))throw "a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleDepthMask.";self["handleDepthMask"]($1);},16702:($0,$1)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleTexture"))throw "a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleTexture.";self["handleTexture"]($1);},16935:($0,$1,$2)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleBegin"))throw "a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleBegin.";self["handleBegin"]($1,$2);},17165:($0,$1,$2,$3,$4)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleVertexWithColor"))throw "a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleVertexWithColor.";self["handleVertexWithColor"]($1,$2,$3,$4);},17431:($0,$1,$2,$3,$4,$5,$6)=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleVertexWithColorAndUV"))throw "a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleVertexWithColorAndUV.";self["handleVertexWithColorAndUV"]($1,$2,$3,$4,$5,$6);},17718:$0=>{var self=Module["getCache"](Module["DebugDrawImpl"])[$0];if(!self.hasOwnProperty("handleEnd"))throw "a JSImplementation must implement all functions, you forgot DebugDrawImpl::handleEnd.";self["handleEnd"]();}};var _emscripten_bind_duDebugDraw___destroy___0,_emscripten_bind_dtTileCacheCompressor___destroy___0,_emscripten_bind_TileCacheMeshProcessJsImpl_process_3,_emscripten_bind_TileCacheMeshProcessJsImpl___destroy___0,_emscripten_bind_dtTileCacheAlloc___destroy___0,_emscripten_bind_rcContext_rcContext_0,_emscripten_bind_rcContext_enableLog_1,_emscripten_bind_rcContext_resetLog_0,_emscripten_bind_rcContext_log_2,_emscripten_bind_rcContext_enableTimer_1,_emscripten_bind_rcContext_resetTimers_0,_emscripten_bind_rcContext_startTimer_1,_emscripten_bind_rcContext_stopTimer_1,_emscripten_bind_rcContext_getAccumulatedTime_1,_emscripten_bind_rcContext___destroy___0,_emscripten_bind_RecastBuildContextImpl___destroy___0,_emscripten_bind_DebugDraw___destroy___0,_emscripten_bind_VoidPtr___destroy___0,_emscripten_bind_rcConfig_rcConfig_0,_emscripten_bind_rcConfig_get_width_0,_emscripten_bind_rcConfig_set_width_1,_emscripten_bind_rcConfig_get_height_0,_emscripten_bind_rcConfig_set_height_1,_emscripten_bind_rcConfig_get_tileSize_0,_emscripten_bind_rcConfig_set_tileSize_1,_emscripten_bind_rcConfig_get_borderSize_0,_emscripten_bind_rcConfig_set_borderSize_1,_emscripten_bind_rcConfig_get_cs_0,_emscripten_bind_rcConfig_set_cs_1,_emscripten_bind_rcConfig_get_ch_0,_emscripten_bind_rcConfig_set_ch_1,_emscripten_bind_rcConfig_get_bmin_1,_emscripten_bind_rcConfig_set_bmin_2,_emscripten_bind_rcConfig_get_bmax_1,_emscripten_bind_rcConfig_set_bmax_2,_emscripten_bind_rcConfig_get_walkableSlopeAngle_0,_emscripten_bind_rcConfig_set_walkableSlopeAngle_1,_emscripten_bind_rcConfig_get_walkableHeight_0,_emscripten_bind_rcConfig_set_walkableHeight_1,_emscripten_bind_rcConfig_get_walkableClimb_0,_emscripten_bind_rcConfig_set_walkableClimb_1,_emscripten_bind_rcConfig_get_walkableRadius_0,_emscripten_bind_rcConfig_set_walkableRadius_1,_emscripten_bind_rcConfig_get_maxEdgeLen_0,_emscripten_bind_rcConfig_set_maxEdgeLen_1,_emscripten_bind_rcConfig_get_maxSimplificationError_0,_emscripten_bind_rcConfig_set_maxSimplificationError_1,_emscripten_bind_rcConfig_get_minRegionArea_0,_emscripten_bind_rcConfig_set_minRegionArea_1,_emscripten_bind_rcConfig_get_mergeRegionArea_0,_emscripten_bind_rcConfig_set_mergeRegionArea_1,_emscripten_bind_rcConfig_get_maxVertsPerPoly_0,_emscripten_bind_rcConfig_set_maxVertsPerPoly_1,_emscripten_bind_rcConfig_get_detailSampleDist_0,_emscripten_bind_rcConfig_set_detailSampleDist_1,_emscripten_bind_rcConfig_get_detailSampleMaxError_0,_emscripten_bind_rcConfig_set_detailSampleMaxError_1,_emscripten_bind_rcConfig___destroy___0,_emscripten_bind_dtMeshHeader_get_magic_0,_emscripten_bind_dtMeshHeader_set_magic_1,_emscripten_bind_dtMeshHeader_get_version_0,_emscripten_bind_dtMeshHeader_set_version_1,_emscripten_bind_dtMeshHeader_get_x_0,_emscripten_bind_dtMeshHeader_set_x_1,_emscripten_bind_dtMeshHeader_get_y_0,_emscripten_bind_dtMeshHeader_set_y_1,_emscripten_bind_dtMeshHeader_get_layer_0,_emscripten_bind_dtMeshHeader_set_layer_1,_emscripten_bind_dtMeshHeader_get_userId_0,_emscripten_bind_dtMeshHeader_set_userId_1,_emscripten_bind_dtMeshHeader_get_polyCount_0,_emscripten_bind_dtMeshHeader_set_polyCount_1,_emscripten_bind_dtMeshHeader_get_vertCount_0,_emscripten_bind_dtMeshHeader_set_vertCount_1,_emscripten_bind_dtMeshHeader_get_maxLinkCount_0,_emscripten_bind_dtMeshHeader_set_maxLinkCount_1,_emscripten_bind_dtMeshHeader_get_detailMeshCount_0,_emscripten_bind_dtMeshHeader_set_detailMeshCount_1,_emscripten_bind_dtMeshHeader_get_detailVertCount_0,_emscripten_bind_dtMeshHeader_set_detailVertCount_1,_emscripten_bind_dtMeshHeader_get_detailTriCount_0,_emscripten_bind_dtMeshHeader_set_detailTriCount_1,_emscripten_bind_dtMeshHeader_get_bvNodeCount_0,_emscripten_bind_dtMeshHeader_set_bvNodeCount_1,_emscripten_bind_dtMeshHeader_get_offMeshConCount_0,_emscripten_bind_dtMeshHeader_set_offMeshConCount_1,_emscripten_bind_dtMeshHeader_get_offMeshBase_0,_emscripten_bind_dtMeshHeader_set_offMeshBase_1,_emscripten_bind_dtMeshHeader_get_walkableHeight_0,_emscripten_bind_dtMeshHeader_set_walkableHeight_1,_emscripten_bind_dtMeshHeader_get_walkableRadius_0,_emscripten_bind_dtMeshHeader_set_walkableRadius_1,_emscripten_bind_dtMeshHeader_get_walkableClimb_0,_emscripten_bind_dtMeshHeader_set_walkableClimb_1,_emscripten_bind_dtMeshHeader_get_bmin_1,_emscripten_bind_dtMeshHeader_set_bmin_2,_emscripten_bind_dtMeshHeader_get_bmax_1,_emscripten_bind_dtMeshHeader_set_bmax_2,_emscripten_bind_dtMeshHeader_get_bvQuantFactor_0,_emscripten_bind_dtMeshHeader_set_bvQuantFactor_1,_emscripten_bind_dtMeshHeader___destroy___0,_emscripten_bind_dtPoly_setArea_1,_emscripten_bind_dtPoly_setType_1,_emscripten_bind_dtPoly_getType_0,_emscripten_bind_dtPoly_getArea_0,_emscripten_bind_dtPoly_get_firstLink_0,_emscripten_bind_dtPoly_set_firstLink_1,_emscripten_bind_dtPoly_get_verts_1,_emscripten_bind_dtPoly_set_verts_2,_emscripten_bind_dtPoly_get_neis_1,_emscripten_bind_dtPoly_set_neis_2,_emscripten_bind_dtPoly_get_flags_0,_emscripten_bind_dtPoly_set_flags_1,_emscripten_bind_dtPoly_get_vertCount_0,_emscripten_bind_dtPoly_set_vertCount_1,_emscripten_bind_dtPoly_get_areaAndtype_0,_emscripten_bind_dtPoly_set_areaAndtype_1,_emscripten_bind_dtPoly___destroy___0,_emscripten_bind_dtPolyDetail_get_vertBase_0,_emscripten_bind_dtPolyDetail_set_vertBase_1,_emscripten_bind_dtPolyDetail_get_triBase_0,_emscripten_bind_dtPolyDetail_set_triBase_1,_emscripten_bind_dtPolyDetail_get_vertCount_0,_emscripten_bind_dtPolyDetail_set_vertCount_1,_emscripten_bind_dtPolyDetail_get_triCount_0,_emscripten_bind_dtPolyDetail_set_triCount_1,_emscripten_bind_dtPolyDetail___destroy___0,_emscripten_bind_dtLink_get_ref_0,_emscripten_bind_dtLink_set_ref_1,_emscripten_bind_dtLink_get_next_0,_emscripten_bind_dtLink_set_next_1,_emscripten_bind_dtLink_get_edge_0,_emscripten_bind_dtLink_set_edge_1,_emscripten_bind_dtLink_get_side_0,_emscripten_bind_dtLink_set_side_1,_emscripten_bind_dtLink_get_bmin_0,_emscripten_bind_dtLink_set_bmin_1,_emscripten_bind_dtLink_get_bmax_0,_emscripten_bind_dtLink_set_bmax_1,_emscripten_bind_dtLink___destroy___0,_emscripten_bind_dtBVNode_get_bmin_1,_emscripten_bind_dtBVNode_set_bmin_2,_emscripten_bind_dtBVNode_get_bmax_1,_emscripten_bind_dtBVNode_set_bmax_2,_emscripten_bind_dtBVNode_get_i_0,_emscripten_bind_dtBVNode_set_i_1,_emscripten_bind_dtBVNode___destroy___0,_emscripten_bind_dtOffMeshConnection_get_pos_1,_emscripten_bind_dtOffMeshConnection_set_pos_2,_emscripten_bind_dtOffMeshConnection_get_rad_0,_emscripten_bind_dtOffMeshConnection_set_rad_1,_emscripten_bind_dtOffMeshConnection_get_poly_0,_emscripten_bind_dtOffMeshConnection_set_poly_1,_emscripten_bind_dtOffMeshConnection_get_flags_0,_emscripten_bind_dtOffMeshConnection_set_flags_1,_emscripten_bind_dtOffMeshConnection_get_side_0,_emscripten_bind_dtOffMeshConnection_set_side_1,_emscripten_bind_dtOffMeshConnection_get_userId_0,_emscripten_bind_dtOffMeshConnection_set_userId_1,_emscripten_bind_dtOffMeshConnection___destroy___0,_emscripten_bind_dtMeshTile_get_salt_0,_emscripten_bind_dtMeshTile_set_salt_1,_emscripten_bind_dtMeshTile_get_linksFreeList_0,_emscripten_bind_dtMeshTile_set_linksFreeList_1,_emscripten_bind_dtMeshTile_get_header_0,_emscripten_bind_dtMeshTile_set_header_1,_emscripten_bind_dtMeshTile_get_polys_1,_emscripten_bind_dtMeshTile_set_polys_2,_emscripten_bind_dtMeshTile_get_verts_1,_emscripten_bind_dtMeshTile_set_verts_2,_emscripten_bind_dtMeshTile_get_links_1,_emscripten_bind_dtMeshTile_set_links_2,_emscripten_bind_dtMeshTile_get_detailMeshes_1,_emscripten_bind_dtMeshTile_set_detailMeshes_2,_emscripten_bind_dtMeshTile_get_detailVerts_1,_emscripten_bind_dtMeshTile_set_detailVerts_2,_emscripten_bind_dtMeshTile_get_detailTris_1,_emscripten_bind_dtMeshTile_set_detailTris_2,_emscripten_bind_dtMeshTile_get_bvTree_1,_emscripten_bind_dtMeshTile_set_bvTree_2,_emscripten_bind_dtMeshTile_get_offMeshCons_1,_emscripten_bind_dtMeshTile_set_offMeshCons_2,_emscripten_bind_dtMeshTile_get_data_1,_emscripten_bind_dtMeshTile_set_data_2,_emscripten_bind_dtMeshTile_get_dataSize_0,_emscripten_bind_dtMeshTile_set_dataSize_1,_emscripten_bind_dtMeshTile_get_flags_0,_emscripten_bind_dtMeshTile_set_flags_1,_emscripten_bind_dtMeshTile_get_next_0,_emscripten_bind_dtMeshTile_set_next_1,_emscripten_bind_dtMeshTile___destroy___0,_emscripten_bind_dtNavMesh___destroy___0,_emscripten_bind_dtNavMeshCreateParams_dtNavMeshCreateParams_0,_emscripten_bind_dtNavMeshCreateParams_get_verts_1,_emscripten_bind_dtNavMeshCreateParams_get_vertCount_0,_emscripten_bind_dtNavMeshCreateParams_set_vertCount_1,_emscripten_bind_dtNavMeshCreateParams_get_polys_1,_emscripten_bind_dtNavMeshCreateParams_get_polyFlags_1,_emscripten_bind_dtNavMeshCreateParams_get_polyAreas_1,_emscripten_bind_dtNavMeshCreateParams_get_polyCount_0,_emscripten_bind_dtNavMeshCreateParams_set_polyCount_1,_emscripten_bind_dtNavMeshCreateParams_get_nvp_0,_emscripten_bind_dtNavMeshCreateParams_set_nvp_1,_emscripten_bind_dtNavMeshCreateParams_get_detailMeshes_1,_emscripten_bind_dtNavMeshCreateParams_get_detailVerts_1,_emscripten_bind_dtNavMeshCreateParams_get_detailVertsCount_0,_emscripten_bind_dtNavMeshCreateParams_set_detailVertsCount_1,_emscripten_bind_dtNavMeshCreateParams_get_detailTris_1,_emscripten_bind_dtNavMeshCreateParams_get_detailTriCount_0,_emscripten_bind_dtNavMeshCreateParams_set_detailTriCount_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConVerts_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConRad_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConFlags_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConAreas_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConDir_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConUserID_1,_emscripten_bind_dtNavMeshCreateParams_get_offMeshConCount_0,_emscripten_bind_dtNavMeshCreateParams_set_offMeshConCount_1,_emscripten_bind_dtNavMeshCreateParams_get_userId_0,_emscripten_bind_dtNavMeshCreateParams_set_userId_1,_emscripten_bind_dtNavMeshCreateParams_get_tileX_0,_emscripten_bind_dtNavMeshCreateParams_set_tileX_1,_emscripten_bind_dtNavMeshCreateParams_get_tileY_0,_emscripten_bind_dtNavMeshCreateParams_set_tileY_1,_emscripten_bind_dtNavMeshCreateParams_get_tileLayer_0,_emscripten_bind_dtNavMeshCreateParams_set_tileLayer_1,_emscripten_bind_dtNavMeshCreateParams_get_bmin_1,_emscripten_bind_dtNavMeshCreateParams_set_bmin_2,_emscripten_bind_dtNavMeshCreateParams_get_bmax_1,_emscripten_bind_dtNavMeshCreateParams_set_bmax_2,_emscripten_bind_dtNavMeshCreateParams_get_walkableHeight_0,_emscripten_bind_dtNavMeshCreateParams_set_walkableHeight_1,_emscripten_bind_dtNavMeshCreateParams_get_walkableRadius_0,_emscripten_bind_dtNavMeshCreateParams_set_walkableRadius_1,_emscripten_bind_dtNavMeshCreateParams_get_walkableClimb_0,_emscripten_bind_dtNavMeshCreateParams_set_walkableClimb_1,_emscripten_bind_dtNavMeshCreateParams_get_cs_0,_emscripten_bind_dtNavMeshCreateParams_set_cs_1,_emscripten_bind_dtNavMeshCreateParams_get_ch_0,_emscripten_bind_dtNavMeshCreateParams_set_ch_1,_emscripten_bind_dtNavMeshCreateParams_get_buildBvTree_0,_emscripten_bind_dtNavMeshCreateParams_set_buildBvTree_1,_emscripten_bind_dtNavMeshCreateParams___destroy___0,_emscripten_bind_dtObstacleRef___destroy___0,_emscripten_bind_dtCompressedTileRef___destroy___0,_emscripten_bind_dtNavMeshParams_dtNavMeshParams_0,_emscripten_bind_dtNavMeshParams_get_orig_1,_emscripten_bind_dtNavMeshParams_set_orig_2,_emscripten_bind_dtNavMeshParams_get_tileWidth_0,_emscripten_bind_dtNavMeshParams_set_tileWidth_1,_emscripten_bind_dtNavMeshParams_get_tileHeight_0,_emscripten_bind_dtNavMeshParams_set_tileHeight_1,_emscripten_bind_dtNavMeshParams_get_maxTiles_0,_emscripten_bind_dtNavMeshParams_set_maxTiles_1,_emscripten_bind_dtNavMeshParams_get_maxPolys_0,_emscripten_bind_dtNavMeshParams_set_maxPolys_1,_emscripten_bind_dtNavMeshParams___destroy___0,_emscripten_bind_dtCrowdAgentParams_dtCrowdAgentParams_0,_emscripten_bind_dtCrowdAgentParams_get_radius_0,_emscripten_bind_dtCrowdAgentParams_set_radius_1,_emscripten_bind_dtCrowdAgentParams_get_height_0,_emscripten_bind_dtCrowdAgentParams_set_height_1,_emscripten_bind_dtCrowdAgentParams_get_maxAcceleration_0,_emscripten_bind_dtCrowdAgentParams_set_maxAcceleration_1,_emscripten_bind_dtCrowdAgentParams_get_maxSpeed_0,_emscripten_bind_dtCrowdAgentParams_set_maxSpeed_1,_emscripten_bind_dtCrowdAgentParams_get_collisionQueryRange_0,_emscripten_bind_dtCrowdAgentParams_set_collisionQueryRange_1,_emscripten_bind_dtCrowdAgentParams_get_pathOptimizationRange_0,_emscripten_bind_dtCrowdAgentParams_set_pathOptimizationRange_1,_emscripten_bind_dtCrowdAgentParams_get_separationWeight_0,_emscripten_bind_dtCrowdAgentParams_set_separationWeight_1,_emscripten_bind_dtCrowdAgentParams_get_updateFlags_0,_emscripten_bind_dtCrowdAgentParams_set_updateFlags_1,_emscripten_bind_dtCrowdAgentParams_get_obstacleAvoidanceType_0,_emscripten_bind_dtCrowdAgentParams_set_obstacleAvoidanceType_1,_emscripten_bind_dtCrowdAgentParams_get_queryFilterType_0,_emscripten_bind_dtCrowdAgentParams_set_queryFilterType_1,_emscripten_bind_dtCrowdAgentParams_get_userData_0,_emscripten_bind_dtCrowdAgentParams_set_userData_1,_emscripten_bind_dtCrowdAgentParams___destroy___0,_emscripten_bind_rcSpan_get_smin_0,_emscripten_bind_rcSpan_set_smin_1,_emscripten_bind_rcSpan_get_smax_0,_emscripten_bind_rcSpan_set_smax_1,_emscripten_bind_rcSpan_get_area_0,_emscripten_bind_rcSpan_set_area_1,_emscripten_bind_rcSpan_get_next_0,_emscripten_bind_rcSpan_set_next_1,_emscripten_bind_rcSpan___destroy___0,_emscripten_bind_rcSpanPool_get_next_0,_emscripten_bind_rcSpanPool_set_next_1,_emscripten_bind_rcSpanPool_get_items_1,_emscripten_bind_rcSpanPool_set_items_2,_emscripten_bind_rcSpanPool___destroy___0,_emscripten_bind_rcHeightfield_get_width_0,_emscripten_bind_rcHeightfield_set_width_1,_emscripten_bind_rcHeightfield_get_height_0,_emscripten_bind_rcHeightfield_set_height_1,_emscripten_bind_rcHeightfield_get_bmin_1,_emscripten_bind_rcHeightfield_set_bmin_2,_emscripten_bind_rcHeightfield_get_bmax_1,_emscripten_bind_rcHeightfield_set_bmax_2,_emscripten_bind_rcHeightfield_get_cs_0,_emscripten_bind_rcHeightfield_set_cs_1,_emscripten_bind_rcHeightfield_get_ch_0,_emscripten_bind_rcHeightfield_set_ch_1,_emscripten_bind_rcHeightfield_get_spans_1,_emscripten_bind_rcHeightfield_set_spans_2,_emscripten_bind_rcHeightfield_get_pools_1,_emscripten_bind_rcHeightfield_set_pools_2,_emscripten_bind_rcHeightfield_get_freelist_1,_emscripten_bind_rcHeightfield_set_freelist_2,_emscripten_bind_rcHeightfield___destroy___0,_emscripten_bind_rcCompactCell_get_index_0,_emscripten_bind_rcCompactCell_set_index_1,_emscripten_bind_rcCompactCell_get_count_0,_emscripten_bind_rcCompactCell_set_count_1,_emscripten_bind_rcCompactCell___destroy___0,_emscripten_bind_rcCompactSpan_get_y_0,_emscripten_bind_rcCompactSpan_set_y_1,_emscripten_bind_rcCompactSpan_get_reg_0,_emscripten_bind_rcCompactSpan_set_reg_1,_emscripten_bind_rcCompactSpan_get_con_0,_emscripten_bind_rcCompactSpan_set_con_1,_emscripten_bind_rcCompactSpan_get_h_0,_emscripten_bind_rcCompactSpan_set_h_1,_emscripten_bind_rcCompactSpan___destroy___0,_emscripten_bind_rcCompactHeightfield_get_width_0,_emscripten_bind_rcCompactHeightfield_set_width_1,_emscripten_bind_rcCompactHeightfield_get_height_0,_emscripten_bind_rcCompactHeightfield_set_height_1,_emscripten_bind_rcCompactHeightfield_get_spanCount_0,_emscripten_bind_rcCompactHeightfield_set_spanCount_1,_emscripten_bind_rcCompactHeightfield_get_walkableHeight_0,_emscripten_bind_rcCompactHeightfield_set_walkableHeight_1,_emscripten_bind_rcCompactHeightfield_get_walkableClimb_0,_emscripten_bind_rcCompactHeightfield_set_walkableClimb_1,_emscripten_bind_rcCompactHeightfield_get_borderSize_0,_emscripten_bind_rcCompactHeightfield_set_borderSize_1,_emscripten_bind_rcCompactHeightfield_get_maxDistance_0,_emscripten_bind_rcCompactHeightfield_set_maxDistance_1,_emscripten_bind_rcCompactHeightfield_get_maxRegions_0,_emscripten_bind_rcCompactHeightfield_set_maxRegions_1,_emscripten_bind_rcCompactHeightfield_get_bmin_1,_emscripten_bind_rcCompactHeightfield_set_bmin_2,_emscripten_bind_rcCompactHeightfield_get_bmax_1,_emscripten_bind_rcCompactHeightfield_set_bmax_2,_emscripten_bind_rcCompactHeightfield_get_cs_0,_emscripten_bind_rcCompactHeightfield_set_cs_1,_emscripten_bind_rcCompactHeightfield_get_ch_0,_emscripten_bind_rcCompactHeightfield_set_ch_1,_emscripten_bind_rcCompactHeightfield_get_cells_1,_emscripten_bind_rcCompactHeightfield_set_cells_2,_emscripten_bind_rcCompactHeightfield_get_spans_1,_emscripten_bind_rcCompactHeightfield_set_spans_2,_emscripten_bind_rcCompactHeightfield_get_dist_1,_emscripten_bind_rcCompactHeightfield_set_dist_2,_emscripten_bind_rcCompactHeightfield_get_areas_1,_emscripten_bind_rcCompactHeightfield_set_areas_2,_emscripten_bind_rcCompactHeightfield___destroy___0,_emscripten_bind_rcContour_get_verts_1,_emscripten_bind_rcContour_set_verts_2,_emscripten_bind_rcContour_get_nverts_0,_emscripten_bind_rcContour_set_nverts_1,_emscripten_bind_rcContour_get_rverts_1,_emscripten_bind_rcContour_set_rverts_2,_emscripten_bind_rcContour_get_nrverts_0,_emscripten_bind_rcContour_set_nrverts_1,_emscripten_bind_rcContour_get_reg_0,_emscripten_bind_rcContour_set_reg_1,_emscripten_bind_rcContour_get_area_0,_emscripten_bind_rcContour_set_area_1,_emscripten_bind_rcContour___destroy___0,_emscripten_bind_rcContourSet_get_conts_1,_emscripten_bind_rcContourSet_set_conts_2,_emscripten_bind_rcContourSet_get_nconts_0,_emscripten_bind_rcContourSet_set_nconts_1,_emscripten_bind_rcContourSet_get_bmin_1,_emscripten_bind_rcContourSet_set_bmin_2,_emscripten_bind_rcContourSet_get_bmax_1,_emscripten_bind_rcContourSet_set_bmax_2,_emscripten_bind_rcContourSet_get_cs_0,_emscripten_bind_rcContourSet_set_cs_1,_emscripten_bind_rcContourSet_get_ch_0,_emscripten_bind_rcContourSet_set_ch_1,_emscripten_bind_rcContourSet_get_width_0,_emscripten_bind_rcContourSet_set_width_1,_emscripten_bind_rcContourSet_get_height_0,_emscripten_bind_rcContourSet_set_height_1,_emscripten_bind_rcContourSet_get_borderSize_0,_emscripten_bind_rcContourSet_set_borderSize_1,_emscripten_bind_rcContourSet_get_maxError_0,_emscripten_bind_rcContourSet_set_maxError_1,_emscripten_bind_rcContourSet___destroy___0,_emscripten_bind_rcHeightfieldLayer_get_bmin_1,_emscripten_bind_rcHeightfieldLayer_set_bmin_2,_emscripten_bind_rcHeightfieldLayer_get_bmax_1,_emscripten_bind_rcHeightfieldLayer_set_bmax_2,_emscripten_bind_rcHeightfieldLayer_get_cs_0,_emscripten_bind_rcHeightfieldLayer_set_cs_1,_emscripten_bind_rcHeightfieldLayer_get_ch_0,_emscripten_bind_rcHeightfieldLayer_set_ch_1,_emscripten_bind_rcHeightfieldLayer_get_width_0,_emscripten_bind_rcHeightfieldLayer_set_width_1,_emscripten_bind_rcHeightfieldLayer_get_height_0,_emscripten_bind_rcHeightfieldLayer_set_height_1,_emscripten_bind_rcHeightfieldLayer_get_minx_0,_emscripten_bind_rcHeightfieldLayer_set_minx_1,_emscripten_bind_rcHeightfieldLayer_get_maxx_0,_emscripten_bind_rcHeightfieldLayer_set_maxx_1,_emscripten_bind_rcHeightfieldLayer_get_miny_0,_emscripten_bind_rcHeightfieldLayer_set_miny_1,_emscripten_bind_rcHeightfieldLayer_get_maxy_0,_emscripten_bind_rcHeightfieldLayer_set_maxy_1,_emscripten_bind_rcHeightfieldLayer_get_hmin_0,_emscripten_bind_rcHeightfieldLayer_set_hmin_1,_emscripten_bind_rcHeightfieldLayer_get_hmax_0,_emscripten_bind_rcHeightfieldLayer_set_hmax_1,_emscripten_bind_rcHeightfieldLayer_get_heights_1,_emscripten_bind_rcHeightfieldLayer_set_heights_2,_emscripten_bind_rcHeightfieldLayer_get_areas_1,_emscripten_bind_rcHeightfieldLayer_set_areas_2,_emscripten_bind_rcHeightfieldLayer_get_cons_1,_emscripten_bind_rcHeightfieldLayer_set_cons_2,_emscripten_bind_rcHeightfieldLayer___destroy___0,_emscripten_bind_rcHeightfieldLayerSet_get_layers_1,_emscripten_bind_rcHeightfieldLayerSet_set_layers_2,_emscripten_bind_rcHeightfieldLayerSet_get_nlayers_0,_emscripten_bind_rcHeightfieldLayerSet_set_nlayers_1,_emscripten_bind_rcHeightfieldLayerSet___destroy___0,_emscripten_bind_rcPolyMesh_get_verts_1,_emscripten_bind_rcPolyMesh_set_verts_2,_emscripten_bind_rcPolyMesh_get_polys_1,_emscripten_bind_rcPolyMesh_set_polys_2,_emscripten_bind_rcPolyMesh_get_regs_1,_emscripten_bind_rcPolyMesh_set_regs_2,_emscripten_bind_rcPolyMesh_get_flags_1,_emscripten_bind_rcPolyMesh_set_flags_2,_emscripten_bind_rcPolyMesh_get_areas_1,_emscripten_bind_rcPolyMesh_set_areas_2,_emscripten_bind_rcPolyMesh_get_nverts_0,_emscripten_bind_rcPolyMesh_set_nverts_1,_emscripten_bind_rcPolyMesh_get_npolys_0,_emscripten_bind_rcPolyMesh_set_npolys_1,_emscripten_bind_rcPolyMesh_get_maxpolys_0,_emscripten_bind_rcPolyMesh_set_maxpolys_1,_emscripten_bind_rcPolyMesh_get_nvp_0,_emscripten_bind_rcPolyMesh_set_nvp_1,_emscripten_bind_rcPolyMesh_get_bmin_1,_emscripten_bind_rcPolyMesh_set_bmin_2,_emscripten_bind_rcPolyMesh_get_bmax_1,_emscripten_bind_rcPolyMesh_set_bmax_2,_emscripten_bind_rcPolyMesh_get_cs_0,_emscripten_bind_rcPolyMesh_set_cs_1,_emscripten_bind_rcPolyMesh_get_ch_0,_emscripten_bind_rcPolyMesh_set_ch_1,_emscripten_bind_rcPolyMesh_get_borderSize_0,_emscripten_bind_rcPolyMesh_set_borderSize_1,_emscripten_bind_rcPolyMesh_get_maxEdgeError_0,_emscripten_bind_rcPolyMesh_set_maxEdgeError_1,_emscripten_bind_rcPolyMesh___destroy___0,_emscripten_bind_rcPolyMeshDetail_get_meshes_1,_emscripten_bind_rcPolyMeshDetail_set_meshes_2,_emscripten_bind_rcPolyMeshDetail_get_verts_1,_emscripten_bind_rcPolyMeshDetail_set_verts_2,_emscripten_bind_rcPolyMeshDetail_get_tris_1,_emscripten_bind_rcPolyMeshDetail_set_tris_2,_emscripten_bind_rcPolyMeshDetail_get_nmeshes_0,_emscripten_bind_rcPolyMeshDetail_set_nmeshes_1,_emscripten_bind_rcPolyMeshDetail_get_nverts_0,_emscripten_bind_rcPolyMeshDetail_set_nverts_1,_emscripten_bind_rcPolyMeshDetail_get_ntris_0,_emscripten_bind_rcPolyMeshDetail_set_ntris_1,_emscripten_bind_rcPolyMeshDetail___destroy___0,_emscripten_bind_Vec3_Vec3_0,_emscripten_bind_Vec3_Vec3_3,_emscripten_bind_Vec3_get_x_0,_emscripten_bind_Vec3_set_x_1,_emscripten_bind_Vec3_get_y_0,_emscripten_bind_Vec3_set_y_1,_emscripten_bind_Vec3_get_z_0,_emscripten_bind_Vec3_set_z_1,_emscripten_bind_Vec3___destroy___0,_emscripten_bind_NavMeshRemoveTileResult_get_status_0,_emscripten_bind_NavMeshRemoveTileResult_set_status_1,_emscripten_bind_NavMeshRemoveTileResult_get_data_1,_emscripten_bind_NavMeshRemoveTileResult_set_data_2,_emscripten_bind_NavMeshRemoveTileResult_get_dataSize_0,_emscripten_bind_NavMeshRemoveTileResult_set_dataSize_1,_emscripten_bind_NavMeshRemoveTileResult___destroy___0,_emscripten_bind_NavMeshCalcTileLocResult_get_tileX_0,_emscripten_bind_NavMeshCalcTileLocResult_set_tileX_1,_emscripten_bind_NavMeshCalcTileLocResult_get_tileY_0,_emscripten_bind_NavMeshCalcTileLocResult_set_tileY_1,_emscripten_bind_NavMeshCalcTileLocResult___destroy___0,_emscripten_bind_NavMeshGetTilesAtResult_get_tiles_1,_emscripten_bind_NavMeshGetTilesAtResult_get_tileCount_0,_emscripten_bind_NavMeshGetTilesAtResult_set_tileCount_1,_emscripten_bind_NavMeshGetTilesAtResult___destroy___0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_status_0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_status_1,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_tile_0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_tile_1,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_poly_0,_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_poly_1,_emscripten_bind_NavMeshGetTileAndPolyByRefResult___destroy___0,_emscripten_bind_NavMeshStoreTileStateResult_get_status_0,_emscripten_bind_NavMeshStoreTileStateResult_set_status_1,_emscripten_bind_NavMeshStoreTileStateResult_get_data_1,_emscripten_bind_NavMeshStoreTileStateResult_set_data_2,_emscripten_bind_NavMeshStoreTileStateResult_get_dataSize_0,_emscripten_bind_NavMeshStoreTileStateResult_set_dataSize_1,_emscripten_bind_NavMeshStoreTileStateResult___destroy___0,_emscripten_bind_NavMesh_NavMesh_0,_emscripten_bind_NavMesh_NavMesh_1,_emscripten_bind_NavMesh_initSolo_1,_emscripten_bind_NavMesh_initTiled_1,_emscripten_bind_NavMesh_addTile_4,_emscripten_bind_NavMesh_decodePolyId_4,_emscripten_bind_NavMesh_encodePolyId_3,_emscripten_bind_NavMesh_removeTile_1,_emscripten_bind_NavMesh_getNavMesh_0,_emscripten_bind_NavMesh_calcTileLoc_1,_emscripten_bind_NavMesh_getTileAt_3,_emscripten_bind_NavMesh_getTilesAt_3,_emscripten_bind_NavMesh_getTileRefAt_3,_emscripten_bind_NavMesh_getTileRef_1,_emscripten_bind_NavMesh_getTileByRef_1,_emscripten_bind_NavMesh_getMaxTiles_0,_emscripten_bind_NavMesh_getTile_1,_emscripten_bind_NavMesh_getTileAndPolyByRef_1,_emscripten_bind_NavMesh_getTileAndPolyByRefUnsafe_1,_emscripten_bind_NavMesh_isValidPolyRef_1,_emscripten_bind_NavMesh_getPolyRefBase_1,_emscripten_bind_NavMesh_getOffMeshConnectionPolyEndPoints_4,_emscripten_bind_NavMesh_getOffMeshConnectionByRef_1,_emscripten_bind_NavMesh_setPolyFlags_2,_emscripten_bind_NavMesh_getPolyFlags_2,_emscripten_bind_NavMesh_setPolyArea_2,_emscripten_bind_NavMesh_getPolyArea_2,_emscripten_bind_NavMesh_getTileStateSize_1,_emscripten_bind_NavMesh_storeTileState_2,_emscripten_bind_NavMesh_restoreTileState_3,_emscripten_bind_NavMesh_destroy_0,_emscripten_bind_NavMesh_get_m_navMesh_0,_emscripten_bind_NavMesh_set_m_navMesh_1,_emscripten_bind_NavMesh___destroy___0,_emscripten_bind_FastRand_getSeed_0,_emscripten_bind_FastRand_setSeed_1,_emscripten_bind_FastRand___destroy___0,_emscripten_bind_dtRaycastHit_dtRaycastHit_0,_emscripten_bind_dtRaycastHit_get_t_0,_emscripten_bind_dtRaycastHit_set_t_1,_emscripten_bind_dtRaycastHit_get_hitNormal_1,_emscripten_bind_dtRaycastHit_set_hitNormal_2,_emscripten_bind_dtRaycastHit_get_hitEdgeIndex_0,_emscripten_bind_dtRaycastHit_set_hitEdgeIndex_1,_emscripten_bind_dtRaycastHit_get_path_1,_emscripten_bind_dtRaycastHit_set_path_2,_emscripten_bind_dtRaycastHit_get_pathCount_0,_emscripten_bind_dtRaycastHit_set_pathCount_1,_emscripten_bind_dtRaycastHit_get_maxPath_0,_emscripten_bind_dtRaycastHit_set_maxPath_1,_emscripten_bind_dtRaycastHit_get_pathCost_0,_emscripten_bind_dtRaycastHit_set_pathCost_1,_emscripten_bind_dtRaycastHit___destroy___0,_emscripten_bind_NavMeshQuery_NavMeshQuery_0,_emscripten_bind_NavMeshQuery_NavMeshQuery_1,_emscripten_bind_NavMeshQuery_init_2,_emscripten_bind_NavMeshQuery_findPath_7,_emscripten_bind_NavMeshQuery_closestPointOnPoly_4,_emscripten_bind_NavMeshQuery_findClosestPoint_6,_emscripten_bind_NavMeshQuery_findStraightPath_9,_emscripten_bind_NavMeshQuery_findNearestPoly_6,_emscripten_bind_NavMeshQuery_findPolysAroundCircle_9,_emscripten_bind_NavMeshQuery_queryPolygons_6,_emscripten_bind_NavMeshQuery_raycast_7,_emscripten_bind_NavMeshQuery_findRandomPointAroundCircle_6,_emscripten_bind_NavMeshQuery_moveAlongSurface_7,_emscripten_bind_NavMeshQuery_findRandomPoint_3,_emscripten_bind_NavMeshQuery_getPolyHeight_3,_emscripten_bind_NavMeshQuery_destroy_0,_emscripten_bind_NavMeshQuery_get_m_navQuery_0,_emscripten_bind_NavMeshQuery_set_m_navQuery_1,_emscripten_bind_NavMeshQuery___destroy___0,_emscripten_bind_dtTileCacheParams_dtTileCacheParams_0,_emscripten_bind_dtTileCacheParams_get_orig_1,_emscripten_bind_dtTileCacheParams_set_orig_2,_emscripten_bind_dtTileCacheParams_get_cs_0,_emscripten_bind_dtTileCacheParams_set_cs_1,_emscripten_bind_dtTileCacheParams_get_ch_0,_emscripten_bind_dtTileCacheParams_set_ch_1,_emscripten_bind_dtTileCacheParams_get_width_0,_emscripten_bind_dtTileCacheParams_set_width_1,_emscripten_bind_dtTileCacheParams_get_height_0,_emscripten_bind_dtTileCacheParams_set_height_1,_emscripten_bind_dtTileCacheParams_get_walkableHeight_0,_emscripten_bind_dtTileCacheParams_set_walkableHeight_1,_emscripten_bind_dtTileCacheParams_get_walkableRadius_0,_emscripten_bind_dtTileCacheParams_set_walkableRadius_1,_emscripten_bind_dtTileCacheParams_get_walkableClimb_0,_emscripten_bind_dtTileCacheParams_set_walkableClimb_1,_emscripten_bind_dtTileCacheParams_get_maxSimplificationError_0,_emscripten_bind_dtTileCacheParams_set_maxSimplificationError_1,_emscripten_bind_dtTileCacheParams_get_maxTiles_0,_emscripten_bind_dtTileCacheParams_set_maxTiles_1,_emscripten_bind_dtTileCacheParams_get_maxObstacles_0,_emscripten_bind_dtTileCacheParams_set_maxObstacles_1,_emscripten_bind_dtTileCacheParams___destroy___0,_emscripten_bind_TileCacheAddTileResult_get_status_0,_emscripten_bind_TileCacheAddTileResult_set_status_1,_emscripten_bind_TileCacheAddTileResult_get_tileRef_0,_emscripten_bind_TileCacheAddTileResult_set_tileRef_1,_emscripten_bind_TileCacheAddTileResult___destroy___0,_emscripten_bind_TileCacheUpdateResult_get_status_0,_emscripten_bind_TileCacheUpdateResult_set_status_1,_emscripten_bind_TileCacheUpdateResult_get_upToDate_0,_emscripten_bind_TileCacheUpdateResult_set_upToDate_1,_emscripten_bind_TileCacheUpdateResult___destroy___0,_emscripten_bind_TileCacheAddObstacleResult_get_status_0,_emscripten_bind_TileCacheAddObstacleResult_set_status_1,_emscripten_bind_TileCacheAddObstacleResult_get_ref_0,_emscripten_bind_TileCacheAddObstacleResult_set_ref_1,_emscripten_bind_TileCacheAddObstacleResult___destroy___0,_emscripten_bind_RecastFastLZCompressor_RecastFastLZCompressor_0,_emscripten_bind_RecastFastLZCompressor___destroy___0,_emscripten_bind_TileCacheMeshProcess_TileCacheMeshProcess_0,_emscripten_bind_TileCacheMeshProcess_process_3,_emscripten_bind_TileCacheMeshProcess___destroy___0,_emscripten_bind_RecastLinearAllocator_RecastLinearAllocator_1,_emscripten_bind_RecastLinearAllocator___destroy___0,_emscripten_bind_TileCache_TileCache_0,_emscripten_bind_TileCache_init_4,_emscripten_bind_TileCache_addTile_2,_emscripten_bind_TileCache_buildNavMeshTile_2,_emscripten_bind_TileCache_buildNavMeshTilesAt_3,_emscripten_bind_TileCache_update_1,_emscripten_bind_TileCache_addCylinderObstacle_3,_emscripten_bind_TileCache_addBoxObstacle_3,_emscripten_bind_TileCache_removeObstacle_1,_emscripten_bind_TileCache_destroy_0,_emscripten_bind_TileCache___destroy___0,_emscripten_bind_CrowdUtils_CrowdUtils_0,_emscripten_bind_CrowdUtils_getActiveAgentCount_1,_emscripten_bind_CrowdUtils_overOffMeshConnection_2,_emscripten_bind_CrowdUtils_agentTeleport_5,_emscripten_bind_CrowdUtils___destroy___0,_emscripten_bind_Detour_Detour_0,_emscripten_bind_Detour_statusSucceed_1,_emscripten_bind_Detour_statusFailed_1,_emscripten_bind_Detour_statusInProgress_1,_emscripten_bind_Detour_statusDetail_2,_emscripten_bind_Detour_allocCrowd_0,_emscripten_bind_Detour_freeCrowd_1,_emscripten_bind_Detour_get_FAILURE_0,_emscripten_bind_Detour_get_SUCCESS_0,_emscripten_bind_Detour_get_IN_PROGRESS_0,_emscripten_bind_Detour_get_STATUS_DETAIL_MASK_0,_emscripten_bind_Detour_get_WRONG_MAGIC_0,_emscripten_bind_Detour_get_WRONG_VERSION_0,_emscripten_bind_Detour_get_OUT_OF_MEMORY_0,_emscripten_bind_Detour_get_INVALID_PARAM_0,_emscripten_bind_Detour_get_BUFFER_TOO_SMALL_0,_emscripten_bind_Detour_get_OUT_OF_NODES_0,_emscripten_bind_Detour_get_PARTIAL_RESULT_0,_emscripten_bind_Detour_get_ALREADY_OCCUPIED_0,_emscripten_bind_Detour_get_VERTS_PER_POLYGON_0,_emscripten_bind_Detour_get_NAVMESH_MAGIC_0,_emscripten_bind_Detour_get_NAVMESH_VERSION_0,_emscripten_bind_Detour_get_NAVMESH_STATE_MAGIC_0,_emscripten_bind_Detour_get_NAVMESH_STATE_VERSION_0,_emscripten_bind_Detour_get_TILECACHE_MAGIC_0,_emscripten_bind_Detour_get_TILECACHE_VERSION_0,_emscripten_bind_Detour_get_TILECACHE_NULL_AREA_0,_emscripten_bind_Detour_get_TILECACHE_WALKABLE_AREA_0,_emscripten_bind_Detour_get_TILECACHE_NULL_IDX_0,_emscripten_bind_Detour_get_NULL_LINK_0,_emscripten_bind_Detour_get_EXT_LINK_0,_emscripten_bind_Detour_get_OFFMESH_CON_BIDIR_0,_emscripten_bind_Detour___destroy___0,_emscripten_bind_dtPathCorridor_init_1,_emscripten_bind_dtPathCorridor_reset_2,_emscripten_bind_dtPathCorridor___destroy___0,_emscripten_bind_dtLocalBoundary_reset_0,_emscripten_bind_dtLocalBoundary___destroy___0,_emscripten_bind_dtCrowdNeighbour_dtCrowdNeighbour_0,_emscripten_bind_dtCrowdNeighbour_get_idx_0,_emscripten_bind_dtCrowdNeighbour_set_idx_1,_emscripten_bind_dtCrowdNeighbour_get_dist_0,_emscripten_bind_dtCrowdNeighbour_set_dist_1,_emscripten_bind_dtCrowdNeighbour___destroy___0,_emscripten_bind_dtCrowdAgent_dtCrowdAgent_0,_emscripten_bind_dtCrowdAgent_get_active_0,_emscripten_bind_dtCrowdAgent_set_active_1,_emscripten_bind_dtCrowdAgent_get_state_0,_emscripten_bind_dtCrowdAgent_set_state_1,_emscripten_bind_dtCrowdAgent_get_corridor_0,_emscripten_bind_dtCrowdAgent_get_boundary_0,_emscripten_bind_dtCrowdAgent_get_topologyOptTime_0,_emscripten_bind_dtCrowdAgent_set_topologyOptTime_1,_emscripten_bind_dtCrowdAgent_get_neis_1,_emscripten_bind_dtCrowdAgent_set_neis_2,_emscripten_bind_dtCrowdAgent_get_nneis_0,_emscripten_bind_dtCrowdAgent_set_nneis_1,_emscripten_bind_dtCrowdAgent_get_desiredSpeed_0,_emscripten_bind_dtCrowdAgent_set_desiredSpeed_1,_emscripten_bind_dtCrowdAgent_get_npos_1,_emscripten_bind_dtCrowdAgent_set_npos_2,_emscripten_bind_dtCrowdAgent_get_disp_1,_emscripten_bind_dtCrowdAgent_set_disp_2,_emscripten_bind_dtCrowdAgent_get_dvel_1,_emscripten_bind_dtCrowdAgent_set_dvel_2,_emscripten_bind_dtCrowdAgent_get_nvel_1,_emscripten_bind_dtCrowdAgent_set_nvel_2,_emscripten_bind_dtCrowdAgent_get_vel_1,_emscripten_bind_dtCrowdAgent_set_vel_2,_emscripten_bind_dtCrowdAgent_get_params_0,_emscripten_bind_dtCrowdAgent_set_params_1,_emscripten_bind_dtCrowdAgent_get_cornerVerts_1,_emscripten_bind_dtCrowdAgent_set_cornerVerts_2,_emscripten_bind_dtCrowdAgent_get_cornerFlags_1,_emscripten_bind_dtCrowdAgent_set_cornerFlags_2,_emscripten_bind_dtCrowdAgent_get_ncorners_0,_emscripten_bind_dtCrowdAgent_set_ncorners_1,_emscripten_bind_dtCrowdAgent_get_targetState_0,_emscripten_bind_dtCrowdAgent_set_targetState_1,_emscripten_bind_dtCrowdAgent_get_targetRef_0,_emscripten_bind_dtCrowdAgent_set_targetRef_1,_emscripten_bind_dtCrowdAgent_get_targetPos_1,_emscripten_bind_dtCrowdAgent_set_targetPos_2,_emscripten_bind_dtCrowdAgent_get_targetPathqRef_0,_emscripten_bind_dtCrowdAgent_set_targetPathqRef_1,_emscripten_bind_dtCrowdAgent_get_targetReplan_0,_emscripten_bind_dtCrowdAgent_set_targetReplan_1,_emscripten_bind_dtCrowdAgent_get_targetReplanTime_0,_emscripten_bind_dtCrowdAgent_set_targetReplanTime_1,_emscripten_bind_dtCrowdAgent___destroy___0,_emscripten_bind_dtObstacleAvoidanceParams_dtObstacleAvoidanceParams_0,_emscripten_bind_dtObstacleAvoidanceParams_get_velBias_0,_emscripten_bind_dtObstacleAvoidanceParams_set_velBias_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightDesVel_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightDesVel_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightCurVel_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightCurVel_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightSide_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightSide_1,_emscripten_bind_dtObstacleAvoidanceParams_get_weightToi_0,_emscripten_bind_dtObstacleAvoidanceParams_set_weightToi_1,_emscripten_bind_dtObstacleAvoidanceParams_get_horizTime_0,_emscripten_bind_dtObstacleAvoidanceParams_set_horizTime_1,_emscripten_bind_dtObstacleAvoidanceParams_get_gridSize_0,_emscripten_bind_dtObstacleAvoidanceParams_set_gridSize_1,_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDivs_0,_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDivs_1,_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveRings_0,_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveRings_1,_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDepth_0,_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDepth_1,_emscripten_bind_dtObstacleAvoidanceParams___destroy___0,_emscripten_bind_dtObstacleAvoidanceDebugData___destroy___0,_emscripten_bind_dtCrowdAgentDebugInfo_dtCrowdAgentDebugInfo_0,_emscripten_bind_dtCrowdAgentDebugInfo_get_idx_0,_emscripten_bind_dtCrowdAgentDebugInfo_set_idx_1,_emscripten_bind_dtCrowdAgentDebugInfo_get_optStart_1,_emscripten_bind_dtCrowdAgentDebugInfo_set_optStart_2,_emscripten_bind_dtCrowdAgentDebugInfo_get_optEnd_1,_emscripten_bind_dtCrowdAgentDebugInfo_set_optEnd_2,_emscripten_bind_dtCrowdAgentDebugInfo_get_vod_0,_emscripten_bind_dtCrowdAgentDebugInfo_set_vod_1,_emscripten_bind_dtCrowdAgentDebugInfo___destroy___0,_emscripten_bind_dtQueryFilter_dtQueryFilter_0,_emscripten_bind_dtQueryFilter_getAreaCost_1,_emscripten_bind_dtQueryFilter_setAreaCost_2,_emscripten_bind_dtQueryFilter_getIncludeFlags_0,_emscripten_bind_dtQueryFilter_setIncludeFlags_1,_emscripten_bind_dtQueryFilter_getExcludeFlags_0,_emscripten_bind_dtQueryFilter_setExcludeFlags_1,_emscripten_bind_dtQueryFilter___destroy___0,_emscripten_bind_dtNavMeshQuery_getAttachedNavMesh_0,_emscripten_bind_dtNavMeshQuery___destroy___0,_emscripten_bind_dtCrowd_dtCrowd_0,_emscripten_bind_dtCrowd_init_3,_emscripten_bind_dtCrowd_setObstacleAvoidanceParams_2,_emscripten_bind_dtCrowd_getObstacleAvoidanceParams_1,_emscripten_bind_dtCrowd_getAgent_1,_emscripten_bind_dtCrowd_getEditableAgent_1,_emscripten_bind_dtCrowd_getAgentCount_0,_emscripten_bind_dtCrowd_addAgent_2,_emscripten_bind_dtCrowd_updateAgentParameters_2,_emscripten_bind_dtCrowd_removeAgent_1,_emscripten_bind_dtCrowd_requestMoveTarget_3,_emscripten_bind_dtCrowd_requestMoveVelocity_2,_emscripten_bind_dtCrowd_resetMoveTarget_1,_emscripten_bind_dtCrowd_update_2,_emscripten_bind_dtCrowd_getFilter_1,_emscripten_bind_dtCrowd_getEditableFilter_1,_emscripten_bind_dtCrowd_getNavMeshQuery_0,_emscripten_bind_dtCrowd___destroy___0,_emscripten_bind_RecastBuildContextJsImpl_RecastBuildContextJsImpl_0,_emscripten_bind_RecastBuildContextJsImpl_resetLog_0,_emscripten_bind_RecastBuildContextJsImpl_log_3,_emscripten_bind_RecastBuildContextJsImpl_resetTimers_0,_emscripten_bind_RecastBuildContextJsImpl_startTimer_1,_emscripten_bind_RecastBuildContextJsImpl_stopTimer_1,_emscripten_bind_RecastBuildContextJsImpl_getAccumulatedTime_1,_emscripten_bind_RecastBuildContextJsImpl___destroy___0,_emscripten_bind_RecastBuildContext_RecastBuildContext_1,_emscripten_bind_RecastBuildContext_enableLog_1,_emscripten_bind_RecastBuildContext_resetLog_0,_emscripten_bind_RecastBuildContext_log_2,_emscripten_bind_RecastBuildContext_enableTimer_1,_emscripten_bind_RecastBuildContext_resetTimers_0,_emscripten_bind_RecastBuildContext_startTimer_1,_emscripten_bind_RecastBuildContext_stopTimer_1,_emscripten_bind_RecastBuildContext_getAccumulatedTime_1,_emscripten_bind_RecastBuildContext_logEnabled_0,_emscripten_bind_RecastBuildContext_timerEnabled_0,_emscripten_bind_RecastBuildContext___destroy___0,_emscripten_bind_RecastCalcBoundsResult_get_bmin_1,_emscripten_bind_RecastCalcBoundsResult_set_bmin_2,_emscripten_bind_RecastCalcBoundsResult_get_bmax_1,_emscripten_bind_RecastCalcBoundsResult_set_bmax_2,_emscripten_bind_RecastCalcBoundsResult___destroy___0,_emscripten_bind_RecastCalcGridSizeResult_get_width_0,_emscripten_bind_RecastCalcGridSizeResult_set_width_1,_emscripten_bind_RecastCalcGridSizeResult_get_height_0,_emscripten_bind_RecastCalcGridSizeResult_set_height_1,_emscripten_bind_RecastCalcGridSizeResult___destroy___0,_emscripten_bind_Recast_Recast_0,_emscripten_bind_Recast_calcBounds_2,_emscripten_bind_Recast_calcGridSize_3,_emscripten_bind_Recast_createHeightfield_8,_emscripten_bind_Recast_markWalkableTriangles_7,_emscripten_bind_Recast_clearUnwalkableTriangles_7,_emscripten_bind_Recast_rasterizeTriangles_8,_emscripten_bind_Recast_filterLowHangingWalkableObstacles_3,_emscripten_bind_Recast_filterLedgeSpans_4,_emscripten_bind_Recast_filterWalkableLowHeightSpans_3,_emscripten_bind_Recast_getHeightFieldSpanCount_2,_emscripten_bind_Recast_buildCompactHeightfield_5,_emscripten_bind_Recast_erodeWalkableArea_3,_emscripten_bind_Recast_medianFilterWalkableArea_2,_emscripten_bind_Recast_markBoxArea_5,_emscripten_bind_Recast_markConvexPolyArea_7,_emscripten_bind_Recast_markCylinderArea_6,_emscripten_bind_Recast_buildDistanceField_2,_emscripten_bind_Recast_buildRegions_5,_emscripten_bind_Recast_buildLayerRegions_4,_emscripten_bind_Recast_buildRegionsMonotone_5,_emscripten_bind_Recast_setCon_3,_emscripten_bind_Recast_getCon_2,_emscripten_bind_Recast_getDirOffsetX_1,_emscripten_bind_Recast_getDirOffsetY_1,_emscripten_bind_Recast_getDirForOffset_2,_emscripten_bind_Recast_buildHeightfieldLayers_5,_emscripten_bind_Recast_buildContours_6,_emscripten_bind_Recast_buildPolyMesh_4,_emscripten_bind_Recast_mergePolyMeshes_4,_emscripten_bind_Recast_buildPolyMeshDetail_6,_emscripten_bind_Recast_copyPolyMesh_3,_emscripten_bind_Recast_mergePolyMeshDetails_4,_emscripten_bind_Recast_getHeightfieldLayerHeights_1,_emscripten_bind_Recast_getHeightfieldLayerAreas_1,_emscripten_bind_Recast_getHeightfieldLayerCons_1,_emscripten_bind_Recast_allocHeightfield_0,_emscripten_bind_Recast_freeHeightfield_1,_emscripten_bind_Recast_allocCompactHeightfield_0,_emscripten_bind_Recast_freeCompactHeightfield_1,_emscripten_bind_Recast_allocHeightfieldLayerSet_0,_emscripten_bind_Recast_freeHeightfieldLayerSet_1,_emscripten_bind_Recast_allocContourSet_0,_emscripten_bind_Recast_freeContourSet_1,_emscripten_bind_Recast_allocPolyMesh_0,_emscripten_bind_Recast_freePolyMesh_1,_emscripten_bind_Recast_allocPolyMeshDetail_0,_emscripten_bind_Recast_freePolyMeshDetail_1,_emscripten_bind_Recast_get_BORDER_REG_0,_emscripten_bind_Recast_set_BORDER_REG_1,_emscripten_bind_Recast_get_MULTIPLE_REGS_0,_emscripten_bind_Recast_set_MULTIPLE_REGS_1,_emscripten_bind_Recast_get_BORDER_VERTEX_0,_emscripten_bind_Recast_set_BORDER_VERTEX_1,_emscripten_bind_Recast_get_AREA_BORDER_0,_emscripten_bind_Recast_set_AREA_BORDER_1,_emscripten_bind_Recast_get_CONTOUR_REG_MASK_0,_emscripten_bind_Recast_set_CONTOUR_REG_MASK_1,_emscripten_bind_Recast_get_MESH_NULL_IDX_0,_emscripten_bind_Recast_set_MESH_NULL_IDX_1,_emscripten_bind_Recast_get_NULL_AREA_0,_emscripten_bind_Recast_set_NULL_AREA_1,_emscripten_bind_Recast_get_WALKABLE_AREA_0,_emscripten_bind_Recast_set_WALKABLE_AREA_1,_emscripten_bind_Recast_get_NOT_CONNECTED_0,_emscripten_bind_Recast_set_NOT_CONNECTED_1,_emscripten_bind_Recast___destroy___0,_emscripten_bind_CreateNavMeshDataResult_get_success_0,_emscripten_bind_CreateNavMeshDataResult_set_success_1,_emscripten_bind_CreateNavMeshDataResult_get_navMeshData_0,_emscripten_bind_CreateNavMeshDataResult_set_navMeshData_1,_emscripten_bind_CreateNavMeshDataResult___destroy___0,_emscripten_bind_DetourNavMeshBuilder_DetourNavMeshBuilder_0,_emscripten_bind_DetourNavMeshBuilder_setPolyMeshCreateParams_2,_emscripten_bind_DetourNavMeshBuilder_setPolyMeshDetailCreateParams_2,_emscripten_bind_DetourNavMeshBuilder_setOffMeshConnections_8,_emscripten_bind_DetourNavMeshBuilder_createNavMeshData_1,_emscripten_bind_DetourNavMeshBuilder___destroy___0,_emscripten_bind_dtTileCacheLayer___destroy___0,_emscripten_bind_dtTileCacheContourSet___destroy___0,_emscripten_bind_dtTileCachePolyMesh___destroy___0,_emscripten_bind_dtTileCacheLayerHeader_dtTileCacheLayerHeader_0,_emscripten_bind_dtTileCacheLayerHeader_get_magic_0,_emscripten_bind_dtTileCacheLayerHeader_set_magic_1,_emscripten_bind_dtTileCacheLayerHeader_get_version_0,_emscripten_bind_dtTileCacheLayerHeader_set_version_1,_emscripten_bind_dtTileCacheLayerHeader_get_tx_0,_emscripten_bind_dtTileCacheLayerHeader_set_tx_1,_emscripten_bind_dtTileCacheLayerHeader_get_ty_0,_emscripten_bind_dtTileCacheLayerHeader_set_ty_1,_emscripten_bind_dtTileCacheLayerHeader_get_tlayer_0,_emscripten_bind_dtTileCacheLayerHeader_set_tlayer_1,_emscripten_bind_dtTileCacheLayerHeader_get_bmin_1,_emscripten_bind_dtTileCacheLayerHeader_set_bmin_2,_emscripten_bind_dtTileCacheLayerHeader_get_bmax_1,_emscripten_bind_dtTileCacheLayerHeader_set_bmax_2,_emscripten_bind_dtTileCacheLayerHeader_get_hmin_0,_emscripten_bind_dtTileCacheLayerHeader_set_hmin_1,_emscripten_bind_dtTileCacheLayerHeader_get_hmax_0,_emscripten_bind_dtTileCacheLayerHeader_set_hmax_1,_emscripten_bind_dtTileCacheLayerHeader_get_width_0,_emscripten_bind_dtTileCacheLayerHeader_set_width_1,_emscripten_bind_dtTileCacheLayerHeader_get_height_0,_emscripten_bind_dtTileCacheLayerHeader_set_height_1,_emscripten_bind_dtTileCacheLayerHeader_get_minx_0,_emscripten_bind_dtTileCacheLayerHeader_set_minx_1,_emscripten_bind_dtTileCacheLayerHeader_get_maxx_0,_emscripten_bind_dtTileCacheLayerHeader_set_maxx_1,_emscripten_bind_dtTileCacheLayerHeader_get_miny_0,_emscripten_bind_dtTileCacheLayerHeader_set_miny_1,_emscripten_bind_dtTileCacheLayerHeader_get_maxy_0,_emscripten_bind_dtTileCacheLayerHeader_set_maxy_1,_emscripten_bind_dtTileCacheLayerHeader___destroy___0,_emscripten_bind_DetourTileCacheBuilder_DetourTileCacheBuilder_0,_emscripten_bind_DetourTileCacheBuilder_buildTileCacheLayer_6,_emscripten_bind_DetourTileCacheBuilder___destroy___0,_emscripten_bind_rcChunkyTriMeshNode_get_bmin_1,_emscripten_bind_rcChunkyTriMeshNode_set_bmin_2,_emscripten_bind_rcChunkyTriMeshNode_get_bmax_1,_emscripten_bind_rcChunkyTriMeshNode_set_bmax_2,_emscripten_bind_rcChunkyTriMeshNode_get_i_0,_emscripten_bind_rcChunkyTriMeshNode_set_i_1,_emscripten_bind_rcChunkyTriMeshNode_get_n_0,_emscripten_bind_rcChunkyTriMeshNode_set_n_1,_emscripten_bind_rcChunkyTriMeshNode___destroy___0,_emscripten_bind_rcChunkyTriMesh_rcChunkyTriMesh_0,_emscripten_bind_rcChunkyTriMesh_get_nodes_1,_emscripten_bind_rcChunkyTriMesh_set_nodes_2,_emscripten_bind_rcChunkyTriMesh_get_nnodes_0,_emscripten_bind_rcChunkyTriMesh_set_nnodes_1,_emscripten_bind_rcChunkyTriMesh_get_tris_1,_emscripten_bind_rcChunkyTriMesh_set_tris_2,_emscripten_bind_rcChunkyTriMesh_get_ntris_0,_emscripten_bind_rcChunkyTriMesh_set_ntris_1,_emscripten_bind_rcChunkyTriMesh_get_maxTrisPerChunk_0,_emscripten_bind_rcChunkyTriMesh_set_maxTrisPerChunk_1,_emscripten_bind_rcChunkyTriMesh___destroy___0,_emscripten_bind_ChunkyTriMeshUtils_ChunkyTriMeshUtils_0,_emscripten_bind_ChunkyTriMeshUtils_createChunkyTriMesh_5,_emscripten_bind_ChunkyTriMeshUtils_getChunksOverlappingRect_5,_emscripten_bind_ChunkyTriMeshUtils_getChunkyTriMeshNodeTris_2,_emscripten_bind_ChunkyTriMeshUtils___destroy___0,_emscripten_bind_BoolRef_BoolRef_0,_emscripten_bind_BoolRef_get_value_0,_emscripten_bind_BoolRef_set_value_1,_emscripten_bind_BoolRef___destroy___0,_emscripten_bind_IntRef_IntRef_0,_emscripten_bind_IntRef_get_value_0,_emscripten_bind_IntRef_set_value_1,_emscripten_bind_IntRef___destroy___0,_emscripten_bind_UnsignedIntRef_UnsignedIntRef_0,_emscripten_bind_UnsignedIntRef_get_value_0,_emscripten_bind_UnsignedIntRef_set_value_1,_emscripten_bind_UnsignedIntRef___destroy___0,_emscripten_bind_UnsignedCharRef_UnsignedCharRef_0,_emscripten_bind_UnsignedCharRef_get_value_0,_emscripten_bind_UnsignedCharRef_set_value_1,_emscripten_bind_UnsignedCharRef___destroy___0,_emscripten_bind_UnsignedShortRef_UnsignedShortRef_0,_emscripten_bind_UnsignedShortRef_get_value_0,_emscripten_bind_UnsignedShortRef_set_value_1,_emscripten_bind_UnsignedShortRef___destroy___0,_emscripten_bind_FloatRef_FloatRef_0,_emscripten_bind_FloatRef_get_value_0,_emscripten_bind_FloatRef_set_value_1,_emscripten_bind_FloatRef___destroy___0,_emscripten_bind_IntArray_IntArray_0,_emscripten_bind_IntArray_resize_1,_emscripten_bind_IntArray_copy_2,_emscripten_bind_IntArray_free_0,_emscripten_bind_IntArray_get_1,_emscripten_bind_IntArray_set_2,_emscripten_bind_IntArray_getDataPointer_0,_emscripten_bind_IntArray_get_data_1,_emscripten_bind_IntArray_set_data_2,_emscripten_bind_IntArray_get_size_0,_emscripten_bind_IntArray_set_size_1,_emscripten_bind_IntArray_get_isView_0,_emscripten_bind_IntArray_set_isView_1,_emscripten_bind_IntArray___destroy___0,_emscripten_bind_UnsignedIntArray_UnsignedIntArray_0,_emscripten_bind_UnsignedIntArray_resize_1,_emscripten_bind_UnsignedIntArray_copy_2,_emscripten_bind_UnsignedIntArray_free_0,_emscripten_bind_UnsignedIntArray_get_1,_emscripten_bind_UnsignedIntArray_set_2,_emscripten_bind_UnsignedIntArray_getDataPointer_0,_emscripten_bind_UnsignedIntArray_get_data_1,_emscripten_bind_UnsignedIntArray_set_data_2,_emscripten_bind_UnsignedIntArray_get_size_0,_emscripten_bind_UnsignedIntArray_set_size_1,_emscripten_bind_UnsignedIntArray_get_isView_0,_emscripten_bind_UnsignedIntArray_set_isView_1,_emscripten_bind_UnsignedIntArray___destroy___0,_emscripten_bind_UnsignedCharArray_UnsignedCharArray_0,_emscripten_bind_UnsignedCharArray_resize_1,_emscripten_bind_UnsignedCharArray_copy_2,_emscripten_bind_UnsignedCharArray_free_0,_emscripten_bind_UnsignedCharArray_get_1,_emscripten_bind_UnsignedCharArray_set_2,_emscripten_bind_UnsignedCharArray_getDataPointer_0,_emscripten_bind_UnsignedCharArray_get_data_1,_emscripten_bind_UnsignedCharArray_set_data_2,_emscripten_bind_UnsignedCharArray_get_size_0,_emscripten_bind_UnsignedCharArray_set_size_1,_emscripten_bind_UnsignedCharArray_get_isView_0,_emscripten_bind_UnsignedCharArray_set_isView_1,_emscripten_bind_UnsignedCharArray___destroy___0,_emscripten_bind_UnsignedShortArray_UnsignedShortArray_0,_emscripten_bind_UnsignedShortArray_resize_1,_emscripten_bind_UnsignedShortArray_copy_2,_emscripten_bind_UnsignedShortArray_free_0,_emscripten_bind_UnsignedShortArray_get_1,_emscripten_bind_UnsignedShortArray_set_2,_emscripten_bind_UnsignedShortArray_getDataPointer_0,_emscripten_bind_UnsignedShortArray_get_data_1,_emscripten_bind_UnsignedShortArray_set_data_2,_emscripten_bind_UnsignedShortArray_get_size_0,_emscripten_bind_UnsignedShortArray_set_size_1,_emscripten_bind_UnsignedShortArray_get_isView_0,_emscripten_bind_UnsignedShortArray_set_isView_1,_emscripten_bind_UnsignedShortArray___destroy___0,_emscripten_bind_FloatArray_FloatArray_0,_emscripten_bind_FloatArray_resize_1,_emscripten_bind_FloatArray_copy_2,_emscripten_bind_FloatArray_free_0,_emscripten_bind_FloatArray_get_1,_emscripten_bind_FloatArray_set_2,_emscripten_bind_FloatArray_getDataPointer_0,_emscripten_bind_FloatArray_get_data_1,_emscripten_bind_FloatArray_set_data_2,_emscripten_bind_FloatArray_get_size_0,_emscripten_bind_FloatArray_set_size_1,_emscripten_bind_FloatArray_get_isView_0,_emscripten_bind_FloatArray_set_isView_1,_emscripten_bind_FloatArray___destroy___0,_emscripten_bind_NavMeshImporterResult_get_navMesh_0,_emscripten_bind_NavMeshImporterResult_set_navMesh_1,_emscripten_bind_NavMeshImporterResult_get_tileCache_0,_emscripten_bind_NavMeshImporterResult_set_tileCache_1,_emscripten_bind_NavMeshImporterResult_get_allocator_0,_emscripten_bind_NavMeshImporterResult_set_allocator_1,_emscripten_bind_NavMeshImporterResult_get_compressor_0,_emscripten_bind_NavMeshImporterResult_set_compressor_1,_emscripten_bind_NavMeshImporterResult___destroy___0,_emscripten_bind_NavMeshImporter_NavMeshImporter_0,_emscripten_bind_NavMeshImporter_importNavMesh_2,_emscripten_bind_NavMeshImporter___destroy___0,_emscripten_bind_NavMeshExport_NavMeshExport_0,_emscripten_bind_NavMeshExport_get_dataPointer_0,_emscripten_bind_NavMeshExport_set_dataPointer_1,_emscripten_bind_NavMeshExport_get_size_0,_emscripten_bind_NavMeshExport_set_size_1,_emscripten_bind_NavMeshExport___destroy___0,_emscripten_bind_NavMeshExporter_NavMeshExporter_0,_emscripten_bind_NavMeshExporter_exportNavMesh_2,_emscripten_bind_NavMeshExporter_freeNavMeshExport_1,_emscripten_bind_NavMeshExporter___destroy___0,_emscripten_bind_DebugDrawImpl_DebugDrawImpl_0,_emscripten_bind_DebugDrawImpl_handleDepthMask_1,_emscripten_bind_DebugDrawImpl_handleTexture_1,_emscripten_bind_DebugDrawImpl_handleBegin_2,_emscripten_bind_DebugDrawImpl_handleVertexWithColor_4,_emscripten_bind_DebugDrawImpl_handleVertexWithColorAndUV_6,_emscripten_bind_DebugDrawImpl_handleEnd_0,_emscripten_bind_DebugDrawImpl___destroy___0,_emscripten_bind_RecastDebugDraw_RecastDebugDraw_0,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldSolid_2,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldWalkable_2,_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldSolid_2,_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldRegions_2,_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldDistance_2,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayer_3,_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayers_2,_emscripten_bind_RecastDebugDraw_debugDrawRegionConnections_3,_emscripten_bind_RecastDebugDraw_debugDrawRawContours_3,_emscripten_bind_RecastDebugDraw_debugDrawContours_3,_emscripten_bind_RecastDebugDraw_debugDrawPolyMesh_2,_emscripten_bind_RecastDebugDraw_debugDrawPolyMeshDetail_2,_emscripten_bind_RecastDebugDraw___destroy___0,_emscripten_bind_DetourDebugDraw_DetourDebugDraw_0,_emscripten_bind_DetourDebugDraw_debugDrawNavMesh_3,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshWithClosedList_4,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshNodes_2,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshBVTree_2,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPortals_2,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPolysWithFlags_4,_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPoly_4,_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerAreas_4,_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerRegions_4,_emscripten_bind_DetourDebugDraw_debugDrawTileCacheContours_5,_emscripten_bind_DetourDebugDraw_debugDrawTileCachePolyMesh_5,_emscripten_bind_DetourDebugDraw___destroy___0,_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_START,_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_END,_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION,_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS,_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS,_emscripten_enum_dtFindPathOptions_DT_FINDPATH_ANY_ANGLE,_emscripten_enum_dtRaycastOptions_DT_RAYCAST_USE_COSTS,_emscripten_enum_dtTileFlags_DT_TILE_FREE_DATA,_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_INVALID,_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_WALKING,_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_NONE,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_FAILED,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VALID,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH,_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY,_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES,_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES,_emscripten_enum_rcLogCategory_RC_LOG_PROGRESS,_emscripten_enum_rcLogCategory_RC_LOG_WARNING,_emscripten_enum_rcLogCategory_RC_LOG_ERROR,_emscripten_enum_rcTimerLabel_RC_TIMER_TOTAL,_emscripten_enum_rcTimerLabel_RC_TIMER_TEMP,_emscripten_enum_rcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY,_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_BORDER,_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_WALKABLE,_emscripten_enum_rcTimerLabel_RC_TIMER_MEDIAN_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESH,_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESH,_emscripten_enum_rcTimerLabel_RC_TIMER_ERODE_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_BOX_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_LAYERS,_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL,_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL,_emscripten_enum_rcTimerLabel_RC_MAX_TIMERS,_emscripten_enum_dtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_POINTS,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_LINES,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_TRIS,_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_QUADS,__emscripten_timeout;function assignWasmExports(wasmExports){Module["_webidl_free"]=wasmExports["i"];Module["_free"]=wasmExports["j"];Module["_webidl_malloc"]=wasmExports["k"];Module["_malloc"]=wasmExports["l"];Module["_emscripten_bind_duDebugDraw___destroy___0"]=_emscripten_bind_duDebugDraw___destroy___0=wasmExports["m"];Module["_emscripten_bind_dtTileCacheCompressor___destroy___0"]=_emscripten_bind_dtTileCacheCompressor___destroy___0=wasmExports["o"];Module["_emscripten_bind_TileCacheMeshProcessJsImpl_process_3"]=_emscripten_bind_TileCacheMeshProcessJsImpl_process_3=wasmExports["p"];Module["_emscripten_bind_TileCacheMeshProcessJsImpl___destroy___0"]=_emscripten_bind_TileCacheMeshProcessJsImpl___destroy___0=wasmExports["q"];Module["_emscripten_bind_dtTileCacheAlloc___destroy___0"]=_emscripten_bind_dtTileCacheAlloc___destroy___0=wasmExports["r"];Module["_emscripten_bind_rcContext_rcContext_0"]=_emscripten_bind_rcContext_rcContext_0=wasmExports["s"];Module["_emscripten_bind_rcContext_enableLog_1"]=_emscripten_bind_rcContext_enableLog_1=wasmExports["t"];Module["_emscripten_bind_rcContext_resetLog_0"]=_emscripten_bind_rcContext_resetLog_0=wasmExports["u"];Module["_emscripten_bind_rcContext_log_2"]=_emscripten_bind_rcContext_log_2=wasmExports["v"];Module["_emscripten_bind_rcContext_enableTimer_1"]=_emscripten_bind_rcContext_enableTimer_1=wasmExports["w"];Module["_emscripten_bind_rcContext_resetTimers_0"]=_emscripten_bind_rcContext_resetTimers_0=wasmExports["x"];Module["_emscripten_bind_rcContext_startTimer_1"]=_emscripten_bind_rcContext_startTimer_1=wasmExports["y"];Module["_emscripten_bind_rcContext_stopTimer_1"]=_emscripten_bind_rcContext_stopTimer_1=wasmExports["z"];Module["_emscripten_bind_rcContext_getAccumulatedTime_1"]=_emscripten_bind_rcContext_getAccumulatedTime_1=wasmExports["A"];Module["_emscripten_bind_rcContext___destroy___0"]=_emscripten_bind_rcContext___destroy___0=wasmExports["B"];Module["_emscripten_bind_RecastBuildContextImpl___destroy___0"]=_emscripten_bind_RecastBuildContextImpl___destroy___0=wasmExports["C"];Module["_emscripten_bind_DebugDraw___destroy___0"]=_emscripten_bind_DebugDraw___destroy___0=wasmExports["D"];Module["_emscripten_bind_VoidPtr___destroy___0"]=_emscripten_bind_VoidPtr___destroy___0=wasmExports["E"];Module["_emscripten_bind_rcConfig_rcConfig_0"]=_emscripten_bind_rcConfig_rcConfig_0=wasmExports["F"];Module["_emscripten_bind_rcConfig_get_width_0"]=_emscripten_bind_rcConfig_get_width_0=wasmExports["G"];Module["_emscripten_bind_rcConfig_set_width_1"]=_emscripten_bind_rcConfig_set_width_1=wasmExports["H"];Module["_emscripten_bind_rcConfig_get_height_0"]=_emscripten_bind_rcConfig_get_height_0=wasmExports["I"];Module["_emscripten_bind_rcConfig_set_height_1"]=_emscripten_bind_rcConfig_set_height_1=wasmExports["J"];Module["_emscripten_bind_rcConfig_get_tileSize_0"]=_emscripten_bind_rcConfig_get_tileSize_0=wasmExports["K"];Module["_emscripten_bind_rcConfig_set_tileSize_1"]=_emscripten_bind_rcConfig_set_tileSize_1=wasmExports["L"];Module["_emscripten_bind_rcConfig_get_borderSize_0"]=_emscripten_bind_rcConfig_get_borderSize_0=wasmExports["M"];Module["_emscripten_bind_rcConfig_set_borderSize_1"]=_emscripten_bind_rcConfig_set_borderSize_1=wasmExports["N"];Module["_emscripten_bind_rcConfig_get_cs_0"]=_emscripten_bind_rcConfig_get_cs_0=wasmExports["O"];Module["_emscripten_bind_rcConfig_set_cs_1"]=_emscripten_bind_rcConfig_set_cs_1=wasmExports["P"];Module["_emscripten_bind_rcConfig_get_ch_0"]=_emscripten_bind_rcConfig_get_ch_0=wasmExports["Q"];Module["_emscripten_bind_rcConfig_set_ch_1"]=_emscripten_bind_rcConfig_set_ch_1=wasmExports["R"];Module["_emscripten_bind_rcConfig_get_bmin_1"]=_emscripten_bind_rcConfig_get_bmin_1=wasmExports["S"];Module["_emscripten_bind_rcConfig_set_bmin_2"]=_emscripten_bind_rcConfig_set_bmin_2=wasmExports["T"];Module["_emscripten_bind_rcConfig_get_bmax_1"]=_emscripten_bind_rcConfig_get_bmax_1=wasmExports["U"];Module["_emscripten_bind_rcConfig_set_bmax_2"]=_emscripten_bind_rcConfig_set_bmax_2=wasmExports["V"];Module["_emscripten_bind_rcConfig_get_walkableSlopeAngle_0"]=_emscripten_bind_rcConfig_get_walkableSlopeAngle_0=wasmExports["W"];Module["_emscripten_bind_rcConfig_set_walkableSlopeAngle_1"]=_emscripten_bind_rcConfig_set_walkableSlopeAngle_1=wasmExports["X"];Module["_emscripten_bind_rcConfig_get_walkableHeight_0"]=_emscripten_bind_rcConfig_get_walkableHeight_0=wasmExports["Y"];Module["_emscripten_bind_rcConfig_set_walkableHeight_1"]=_emscripten_bind_rcConfig_set_walkableHeight_1=wasmExports["Z"];Module["_emscripten_bind_rcConfig_get_walkableClimb_0"]=_emscripten_bind_rcConfig_get_walkableClimb_0=wasmExports["_"];Module["_emscripten_bind_rcConfig_set_walkableClimb_1"]=_emscripten_bind_rcConfig_set_walkableClimb_1=wasmExports["$"];Module["_emscripten_bind_rcConfig_get_walkableRadius_0"]=_emscripten_bind_rcConfig_get_walkableRadius_0=wasmExports["aa"];Module["_emscripten_bind_rcConfig_set_walkableRadius_1"]=_emscripten_bind_rcConfig_set_walkableRadius_1=wasmExports["ba"];Module["_emscripten_bind_rcConfig_get_maxEdgeLen_0"]=_emscripten_bind_rcConfig_get_maxEdgeLen_0=wasmExports["ca"];Module["_emscripten_bind_rcConfig_set_maxEdgeLen_1"]=_emscripten_bind_rcConfig_set_maxEdgeLen_1=wasmExports["da"];Module["_emscripten_bind_rcConfig_get_maxSimplificationError_0"]=_emscripten_bind_rcConfig_get_maxSimplificationError_0=wasmExports["ea"];Module["_emscripten_bind_rcConfig_set_maxSimplificationError_1"]=_emscripten_bind_rcConfig_set_maxSimplificationError_1=wasmExports["fa"];Module["_emscripten_bind_rcConfig_get_minRegionArea_0"]=_emscripten_bind_rcConfig_get_minRegionArea_0=wasmExports["ga"];Module["_emscripten_bind_rcConfig_set_minRegionArea_1"]=_emscripten_bind_rcConfig_set_minRegionArea_1=wasmExports["ha"];Module["_emscripten_bind_rcConfig_get_mergeRegionArea_0"]=_emscripten_bind_rcConfig_get_mergeRegionArea_0=wasmExports["ia"];Module["_emscripten_bind_rcConfig_set_mergeRegionArea_1"]=_emscripten_bind_rcConfig_set_mergeRegionArea_1=wasmExports["ja"];Module["_emscripten_bind_rcConfig_get_maxVertsPerPoly_0"]=_emscripten_bind_rcConfig_get_maxVertsPerPoly_0=wasmExports["ka"];Module["_emscripten_bind_rcConfig_set_maxVertsPerPoly_1"]=_emscripten_bind_rcConfig_set_maxVertsPerPoly_1=wasmExports["la"];Module["_emscripten_bind_rcConfig_get_detailSampleDist_0"]=_emscripten_bind_rcConfig_get_detailSampleDist_0=wasmExports["ma"];Module["_emscripten_bind_rcConfig_set_detailSampleDist_1"]=_emscripten_bind_rcConfig_set_detailSampleDist_1=wasmExports["na"];Module["_emscripten_bind_rcConfig_get_detailSampleMaxError_0"]=_emscripten_bind_rcConfig_get_detailSampleMaxError_0=wasmExports["oa"];Module["_emscripten_bind_rcConfig_set_detailSampleMaxError_1"]=_emscripten_bind_rcConfig_set_detailSampleMaxError_1=wasmExports["pa"];Module["_emscripten_bind_rcConfig___destroy___0"]=_emscripten_bind_rcConfig___destroy___0=wasmExports["qa"];Module["_emscripten_bind_dtMeshHeader_get_magic_0"]=_emscripten_bind_dtMeshHeader_get_magic_0=wasmExports["ra"];Module["_emscripten_bind_dtMeshHeader_set_magic_1"]=_emscripten_bind_dtMeshHeader_set_magic_1=wasmExports["sa"];Module["_emscripten_bind_dtMeshHeader_get_version_0"]=_emscripten_bind_dtMeshHeader_get_version_0=wasmExports["ta"];Module["_emscripten_bind_dtMeshHeader_set_version_1"]=_emscripten_bind_dtMeshHeader_set_version_1=wasmExports["ua"];Module["_emscripten_bind_dtMeshHeader_get_x_0"]=_emscripten_bind_dtMeshHeader_get_x_0=wasmExports["va"];Module["_emscripten_bind_dtMeshHeader_set_x_1"]=_emscripten_bind_dtMeshHeader_set_x_1=wasmExports["wa"];Module["_emscripten_bind_dtMeshHeader_get_y_0"]=_emscripten_bind_dtMeshHeader_get_y_0=wasmExports["xa"];Module["_emscripten_bind_dtMeshHeader_set_y_1"]=_emscripten_bind_dtMeshHeader_set_y_1=wasmExports["ya"];Module["_emscripten_bind_dtMeshHeader_get_layer_0"]=_emscripten_bind_dtMeshHeader_get_layer_0=wasmExports["za"];Module["_emscripten_bind_dtMeshHeader_set_layer_1"]=_emscripten_bind_dtMeshHeader_set_layer_1=wasmExports["Aa"];Module["_emscripten_bind_dtMeshHeader_get_userId_0"]=_emscripten_bind_dtMeshHeader_get_userId_0=wasmExports["Ba"];Module["_emscripten_bind_dtMeshHeader_set_userId_1"]=_emscripten_bind_dtMeshHeader_set_userId_1=wasmExports["Ca"];Module["_emscripten_bind_dtMeshHeader_get_polyCount_0"]=_emscripten_bind_dtMeshHeader_get_polyCount_0=wasmExports["Da"];Module["_emscripten_bind_dtMeshHeader_set_polyCount_1"]=_emscripten_bind_dtMeshHeader_set_polyCount_1=wasmExports["Ea"];Module["_emscripten_bind_dtMeshHeader_get_vertCount_0"]=_emscripten_bind_dtMeshHeader_get_vertCount_0=wasmExports["Fa"];Module["_emscripten_bind_dtMeshHeader_set_vertCount_1"]=_emscripten_bind_dtMeshHeader_set_vertCount_1=wasmExports["Ga"];Module["_emscripten_bind_dtMeshHeader_get_maxLinkCount_0"]=_emscripten_bind_dtMeshHeader_get_maxLinkCount_0=wasmExports["Ha"];Module["_emscripten_bind_dtMeshHeader_set_maxLinkCount_1"]=_emscripten_bind_dtMeshHeader_set_maxLinkCount_1=wasmExports["Ia"];Module["_emscripten_bind_dtMeshHeader_get_detailMeshCount_0"]=_emscripten_bind_dtMeshHeader_get_detailMeshCount_0=wasmExports["Ja"];Module["_emscripten_bind_dtMeshHeader_set_detailMeshCount_1"]=_emscripten_bind_dtMeshHeader_set_detailMeshCount_1=wasmExports["Ka"];Module["_emscripten_bind_dtMeshHeader_get_detailVertCount_0"]=_emscripten_bind_dtMeshHeader_get_detailVertCount_0=wasmExports["La"];Module["_emscripten_bind_dtMeshHeader_set_detailVertCount_1"]=_emscripten_bind_dtMeshHeader_set_detailVertCount_1=wasmExports["Ma"];Module["_emscripten_bind_dtMeshHeader_get_detailTriCount_0"]=_emscripten_bind_dtMeshHeader_get_detailTriCount_0=wasmExports["Na"];Module["_emscripten_bind_dtMeshHeader_set_detailTriCount_1"]=_emscripten_bind_dtMeshHeader_set_detailTriCount_1=wasmExports["Oa"];Module["_emscripten_bind_dtMeshHeader_get_bvNodeCount_0"]=_emscripten_bind_dtMeshHeader_get_bvNodeCount_0=wasmExports["Pa"];Module["_emscripten_bind_dtMeshHeader_set_bvNodeCount_1"]=_emscripten_bind_dtMeshHeader_set_bvNodeCount_1=wasmExports["Qa"];Module["_emscripten_bind_dtMeshHeader_get_offMeshConCount_0"]=_emscripten_bind_dtMeshHeader_get_offMeshConCount_0=wasmExports["Ra"];Module["_emscripten_bind_dtMeshHeader_set_offMeshConCount_1"]=_emscripten_bind_dtMeshHeader_set_offMeshConCount_1=wasmExports["Sa"];Module["_emscripten_bind_dtMeshHeader_get_offMeshBase_0"]=_emscripten_bind_dtMeshHeader_get_offMeshBase_0=wasmExports["Ta"];Module["_emscripten_bind_dtMeshHeader_set_offMeshBase_1"]=_emscripten_bind_dtMeshHeader_set_offMeshBase_1=wasmExports["Ua"];Module["_emscripten_bind_dtMeshHeader_get_walkableHeight_0"]=_emscripten_bind_dtMeshHeader_get_walkableHeight_0=wasmExports["Va"];Module["_emscripten_bind_dtMeshHeader_set_walkableHeight_1"]=_emscripten_bind_dtMeshHeader_set_walkableHeight_1=wasmExports["Wa"];Module["_emscripten_bind_dtMeshHeader_get_walkableRadius_0"]=_emscripten_bind_dtMeshHeader_get_walkableRadius_0=wasmExports["Xa"];Module["_emscripten_bind_dtMeshHeader_set_walkableRadius_1"]=_emscripten_bind_dtMeshHeader_set_walkableRadius_1=wasmExports["Ya"];Module["_emscripten_bind_dtMeshHeader_get_walkableClimb_0"]=_emscripten_bind_dtMeshHeader_get_walkableClimb_0=wasmExports["Za"];Module["_emscripten_bind_dtMeshHeader_set_walkableClimb_1"]=_emscripten_bind_dtMeshHeader_set_walkableClimb_1=wasmExports["_a"];Module["_emscripten_bind_dtMeshHeader_get_bmin_1"]=_emscripten_bind_dtMeshHeader_get_bmin_1=wasmExports["$a"];Module["_emscripten_bind_dtMeshHeader_set_bmin_2"]=_emscripten_bind_dtMeshHeader_set_bmin_2=wasmExports["ab"];Module["_emscripten_bind_dtMeshHeader_get_bmax_1"]=_emscripten_bind_dtMeshHeader_get_bmax_1=wasmExports["bb"];Module["_emscripten_bind_dtMeshHeader_set_bmax_2"]=_emscripten_bind_dtMeshHeader_set_bmax_2=wasmExports["cb"];Module["_emscripten_bind_dtMeshHeader_get_bvQuantFactor_0"]=_emscripten_bind_dtMeshHeader_get_bvQuantFactor_0=wasmExports["db"];Module["_emscripten_bind_dtMeshHeader_set_bvQuantFactor_1"]=_emscripten_bind_dtMeshHeader_set_bvQuantFactor_1=wasmExports["eb"];Module["_emscripten_bind_dtMeshHeader___destroy___0"]=_emscripten_bind_dtMeshHeader___destroy___0=wasmExports["fb"];Module["_emscripten_bind_dtPoly_setArea_1"]=_emscripten_bind_dtPoly_setArea_1=wasmExports["gb"];Module["_emscripten_bind_dtPoly_setType_1"]=_emscripten_bind_dtPoly_setType_1=wasmExports["hb"];Module["_emscripten_bind_dtPoly_getType_0"]=_emscripten_bind_dtPoly_getType_0=wasmExports["ib"];Module["_emscripten_bind_dtPoly_getArea_0"]=_emscripten_bind_dtPoly_getArea_0=wasmExports["jb"];Module["_emscripten_bind_dtPoly_get_firstLink_0"]=_emscripten_bind_dtPoly_get_firstLink_0=wasmExports["kb"];Module["_emscripten_bind_dtPoly_set_firstLink_1"]=_emscripten_bind_dtPoly_set_firstLink_1=wasmExports["lb"];Module["_emscripten_bind_dtPoly_get_verts_1"]=_emscripten_bind_dtPoly_get_verts_1=wasmExports["mb"];Module["_emscripten_bind_dtPoly_set_verts_2"]=_emscripten_bind_dtPoly_set_verts_2=wasmExports["nb"];Module["_emscripten_bind_dtPoly_get_neis_1"]=_emscripten_bind_dtPoly_get_neis_1=wasmExports["ob"];Module["_emscripten_bind_dtPoly_set_neis_2"]=_emscripten_bind_dtPoly_set_neis_2=wasmExports["pb"];Module["_emscripten_bind_dtPoly_get_flags_0"]=_emscripten_bind_dtPoly_get_flags_0=wasmExports["qb"];Module["_emscripten_bind_dtPoly_set_flags_1"]=_emscripten_bind_dtPoly_set_flags_1=wasmExports["rb"];Module["_emscripten_bind_dtPoly_get_vertCount_0"]=_emscripten_bind_dtPoly_get_vertCount_0=wasmExports["sb"];Module["_emscripten_bind_dtPoly_set_vertCount_1"]=_emscripten_bind_dtPoly_set_vertCount_1=wasmExports["tb"];Module["_emscripten_bind_dtPoly_get_areaAndtype_0"]=_emscripten_bind_dtPoly_get_areaAndtype_0=wasmExports["ub"];Module["_emscripten_bind_dtPoly_set_areaAndtype_1"]=_emscripten_bind_dtPoly_set_areaAndtype_1=wasmExports["vb"];Module["_emscripten_bind_dtPoly___destroy___0"]=_emscripten_bind_dtPoly___destroy___0=wasmExports["wb"];Module["_emscripten_bind_dtPolyDetail_get_vertBase_0"]=_emscripten_bind_dtPolyDetail_get_vertBase_0=wasmExports["xb"];Module["_emscripten_bind_dtPolyDetail_set_vertBase_1"]=_emscripten_bind_dtPolyDetail_set_vertBase_1=wasmExports["yb"];Module["_emscripten_bind_dtPolyDetail_get_triBase_0"]=_emscripten_bind_dtPolyDetail_get_triBase_0=wasmExports["zb"];Module["_emscripten_bind_dtPolyDetail_set_triBase_1"]=_emscripten_bind_dtPolyDetail_set_triBase_1=wasmExports["Ab"];Module["_emscripten_bind_dtPolyDetail_get_vertCount_0"]=_emscripten_bind_dtPolyDetail_get_vertCount_0=wasmExports["Bb"];Module["_emscripten_bind_dtPolyDetail_set_vertCount_1"]=_emscripten_bind_dtPolyDetail_set_vertCount_1=wasmExports["Cb"];Module["_emscripten_bind_dtPolyDetail_get_triCount_0"]=_emscripten_bind_dtPolyDetail_get_triCount_0=wasmExports["Db"];Module["_emscripten_bind_dtPolyDetail_set_triCount_1"]=_emscripten_bind_dtPolyDetail_set_triCount_1=wasmExports["Eb"];Module["_emscripten_bind_dtPolyDetail___destroy___0"]=_emscripten_bind_dtPolyDetail___destroy___0=wasmExports["Fb"];Module["_emscripten_bind_dtLink_get_ref_0"]=_emscripten_bind_dtLink_get_ref_0=wasmExports["Gb"];Module["_emscripten_bind_dtLink_set_ref_1"]=_emscripten_bind_dtLink_set_ref_1=wasmExports["Hb"];Module["_emscripten_bind_dtLink_get_next_0"]=_emscripten_bind_dtLink_get_next_0=wasmExports["Ib"];Module["_emscripten_bind_dtLink_set_next_1"]=_emscripten_bind_dtLink_set_next_1=wasmExports["Jb"];Module["_emscripten_bind_dtLink_get_edge_0"]=_emscripten_bind_dtLink_get_edge_0=wasmExports["Kb"];Module["_emscripten_bind_dtLink_set_edge_1"]=_emscripten_bind_dtLink_set_edge_1=wasmExports["Lb"];Module["_emscripten_bind_dtLink_get_side_0"]=_emscripten_bind_dtLink_get_side_0=wasmExports["Mb"];Module["_emscripten_bind_dtLink_set_side_1"]=_emscripten_bind_dtLink_set_side_1=wasmExports["Nb"];Module["_emscripten_bind_dtLink_get_bmin_0"]=_emscripten_bind_dtLink_get_bmin_0=wasmExports["Ob"];Module["_emscripten_bind_dtLink_set_bmin_1"]=_emscripten_bind_dtLink_set_bmin_1=wasmExports["Pb"];Module["_emscripten_bind_dtLink_get_bmax_0"]=_emscripten_bind_dtLink_get_bmax_0=wasmExports["Qb"];Module["_emscripten_bind_dtLink_set_bmax_1"]=_emscripten_bind_dtLink_set_bmax_1=wasmExports["Rb"];Module["_emscripten_bind_dtLink___destroy___0"]=_emscripten_bind_dtLink___destroy___0=wasmExports["Sb"];Module["_emscripten_bind_dtBVNode_get_bmin_1"]=_emscripten_bind_dtBVNode_get_bmin_1=wasmExports["Tb"];Module["_emscripten_bind_dtBVNode_set_bmin_2"]=_emscripten_bind_dtBVNode_set_bmin_2=wasmExports["Ub"];Module["_emscripten_bind_dtBVNode_get_bmax_1"]=_emscripten_bind_dtBVNode_get_bmax_1=wasmExports["Vb"];Module["_emscripten_bind_dtBVNode_set_bmax_2"]=_emscripten_bind_dtBVNode_set_bmax_2=wasmExports["Wb"];Module["_emscripten_bind_dtBVNode_get_i_0"]=_emscripten_bind_dtBVNode_get_i_0=wasmExports["Xb"];Module["_emscripten_bind_dtBVNode_set_i_1"]=_emscripten_bind_dtBVNode_set_i_1=wasmExports["Yb"];Module["_emscripten_bind_dtBVNode___destroy___0"]=_emscripten_bind_dtBVNode___destroy___0=wasmExports["Zb"];Module["_emscripten_bind_dtOffMeshConnection_get_pos_1"]=_emscripten_bind_dtOffMeshConnection_get_pos_1=wasmExports["_b"];Module["_emscripten_bind_dtOffMeshConnection_set_pos_2"]=_emscripten_bind_dtOffMeshConnection_set_pos_2=wasmExports["$b"];Module["_emscripten_bind_dtOffMeshConnection_get_rad_0"]=_emscripten_bind_dtOffMeshConnection_get_rad_0=wasmExports["ac"];Module["_emscripten_bind_dtOffMeshConnection_set_rad_1"]=_emscripten_bind_dtOffMeshConnection_set_rad_1=wasmExports["bc"];Module["_emscripten_bind_dtOffMeshConnection_get_poly_0"]=_emscripten_bind_dtOffMeshConnection_get_poly_0=wasmExports["cc"];Module["_emscripten_bind_dtOffMeshConnection_set_poly_1"]=_emscripten_bind_dtOffMeshConnection_set_poly_1=wasmExports["dc"];Module["_emscripten_bind_dtOffMeshConnection_get_flags_0"]=_emscripten_bind_dtOffMeshConnection_get_flags_0=wasmExports["ec"];Module["_emscripten_bind_dtOffMeshConnection_set_flags_1"]=_emscripten_bind_dtOffMeshConnection_set_flags_1=wasmExports["fc"];Module["_emscripten_bind_dtOffMeshConnection_get_side_0"]=_emscripten_bind_dtOffMeshConnection_get_side_0=wasmExports["gc"];Module["_emscripten_bind_dtOffMeshConnection_set_side_1"]=_emscripten_bind_dtOffMeshConnection_set_side_1=wasmExports["hc"];Module["_emscripten_bind_dtOffMeshConnection_get_userId_0"]=_emscripten_bind_dtOffMeshConnection_get_userId_0=wasmExports["ic"];Module["_emscripten_bind_dtOffMeshConnection_set_userId_1"]=_emscripten_bind_dtOffMeshConnection_set_userId_1=wasmExports["jc"];Module["_emscripten_bind_dtOffMeshConnection___destroy___0"]=_emscripten_bind_dtOffMeshConnection___destroy___0=wasmExports["kc"];Module["_emscripten_bind_dtMeshTile_get_salt_0"]=_emscripten_bind_dtMeshTile_get_salt_0=wasmExports["lc"];Module["_emscripten_bind_dtMeshTile_set_salt_1"]=_emscripten_bind_dtMeshTile_set_salt_1=wasmExports["mc"];Module["_emscripten_bind_dtMeshTile_get_linksFreeList_0"]=_emscripten_bind_dtMeshTile_get_linksFreeList_0=wasmExports["nc"];Module["_emscripten_bind_dtMeshTile_set_linksFreeList_1"]=_emscripten_bind_dtMeshTile_set_linksFreeList_1=wasmExports["oc"];Module["_emscripten_bind_dtMeshTile_get_header_0"]=_emscripten_bind_dtMeshTile_get_header_0=wasmExports["pc"];Module["_emscripten_bind_dtMeshTile_set_header_1"]=_emscripten_bind_dtMeshTile_set_header_1=wasmExports["qc"];Module["_emscripten_bind_dtMeshTile_get_polys_1"]=_emscripten_bind_dtMeshTile_get_polys_1=wasmExports["rc"];Module["_emscripten_bind_dtMeshTile_set_polys_2"]=_emscripten_bind_dtMeshTile_set_polys_2=wasmExports["sc"];Module["_emscripten_bind_dtMeshTile_get_verts_1"]=_emscripten_bind_dtMeshTile_get_verts_1=wasmExports["tc"];Module["_emscripten_bind_dtMeshTile_set_verts_2"]=_emscripten_bind_dtMeshTile_set_verts_2=wasmExports["uc"];Module["_emscripten_bind_dtMeshTile_get_links_1"]=_emscripten_bind_dtMeshTile_get_links_1=wasmExports["vc"];Module["_emscripten_bind_dtMeshTile_set_links_2"]=_emscripten_bind_dtMeshTile_set_links_2=wasmExports["wc"];Module["_emscripten_bind_dtMeshTile_get_detailMeshes_1"]=_emscripten_bind_dtMeshTile_get_detailMeshes_1=wasmExports["xc"];Module["_emscripten_bind_dtMeshTile_set_detailMeshes_2"]=_emscripten_bind_dtMeshTile_set_detailMeshes_2=wasmExports["yc"];Module["_emscripten_bind_dtMeshTile_get_detailVerts_1"]=_emscripten_bind_dtMeshTile_get_detailVerts_1=wasmExports["zc"];Module["_emscripten_bind_dtMeshTile_set_detailVerts_2"]=_emscripten_bind_dtMeshTile_set_detailVerts_2=wasmExports["Ac"];Module["_emscripten_bind_dtMeshTile_get_detailTris_1"]=_emscripten_bind_dtMeshTile_get_detailTris_1=wasmExports["Bc"];Module["_emscripten_bind_dtMeshTile_set_detailTris_2"]=_emscripten_bind_dtMeshTile_set_detailTris_2=wasmExports["Cc"];Module["_emscripten_bind_dtMeshTile_get_bvTree_1"]=_emscripten_bind_dtMeshTile_get_bvTree_1=wasmExports["Dc"];Module["_emscripten_bind_dtMeshTile_set_bvTree_2"]=_emscripten_bind_dtMeshTile_set_bvTree_2=wasmExports["Ec"];Module["_emscripten_bind_dtMeshTile_get_offMeshCons_1"]=_emscripten_bind_dtMeshTile_get_offMeshCons_1=wasmExports["Fc"];Module["_emscripten_bind_dtMeshTile_set_offMeshCons_2"]=_emscripten_bind_dtMeshTile_set_offMeshCons_2=wasmExports["Gc"];Module["_emscripten_bind_dtMeshTile_get_data_1"]=_emscripten_bind_dtMeshTile_get_data_1=wasmExports["Hc"];Module["_emscripten_bind_dtMeshTile_set_data_2"]=_emscripten_bind_dtMeshTile_set_data_2=wasmExports["Ic"];Module["_emscripten_bind_dtMeshTile_get_dataSize_0"]=_emscripten_bind_dtMeshTile_get_dataSize_0=wasmExports["Jc"];Module["_emscripten_bind_dtMeshTile_set_dataSize_1"]=_emscripten_bind_dtMeshTile_set_dataSize_1=wasmExports["Kc"];Module["_emscripten_bind_dtMeshTile_get_flags_0"]=_emscripten_bind_dtMeshTile_get_flags_0=wasmExports["Lc"];Module["_emscripten_bind_dtMeshTile_set_flags_1"]=_emscripten_bind_dtMeshTile_set_flags_1=wasmExports["Mc"];Module["_emscripten_bind_dtMeshTile_get_next_0"]=_emscripten_bind_dtMeshTile_get_next_0=wasmExports["Nc"];Module["_emscripten_bind_dtMeshTile_set_next_1"]=_emscripten_bind_dtMeshTile_set_next_1=wasmExports["Oc"];Module["_emscripten_bind_dtMeshTile___destroy___0"]=_emscripten_bind_dtMeshTile___destroy___0=wasmExports["Pc"];Module["_emscripten_bind_dtNavMesh___destroy___0"]=_emscripten_bind_dtNavMesh___destroy___0=wasmExports["Qc"];Module["_emscripten_bind_dtNavMeshCreateParams_dtNavMeshCreateParams_0"]=_emscripten_bind_dtNavMeshCreateParams_dtNavMeshCreateParams_0=wasmExports["Rc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_verts_1"]=_emscripten_bind_dtNavMeshCreateParams_get_verts_1=wasmExports["Sc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_vertCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_vertCount_0=wasmExports["Tc"];Module["_emscripten_bind_dtNavMeshCreateParams_set_vertCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_vertCount_1=wasmExports["Uc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polys_1"]=_emscripten_bind_dtNavMeshCreateParams_get_polys_1=wasmExports["Vc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polyFlags_1"]=_emscripten_bind_dtNavMeshCreateParams_get_polyFlags_1=wasmExports["Wc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polyAreas_1"]=_emscripten_bind_dtNavMeshCreateParams_get_polyAreas_1=wasmExports["Xc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_polyCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_polyCount_0=wasmExports["Yc"];Module["_emscripten_bind_dtNavMeshCreateParams_set_polyCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_polyCount_1=wasmExports["Zc"];Module["_emscripten_bind_dtNavMeshCreateParams_get_nvp_0"]=_emscripten_bind_dtNavMeshCreateParams_get_nvp_0=wasmExports["_c"];Module["_emscripten_bind_dtNavMeshCreateParams_set_nvp_1"]=_emscripten_bind_dtNavMeshCreateParams_set_nvp_1=wasmExports["$c"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailMeshes_1"]=_emscripten_bind_dtNavMeshCreateParams_get_detailMeshes_1=wasmExports["ad"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailVerts_1"]=_emscripten_bind_dtNavMeshCreateParams_get_detailVerts_1=wasmExports["bd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailVertsCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_detailVertsCount_0=wasmExports["cd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_detailVertsCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_detailVertsCount_1=wasmExports["dd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailTris_1"]=_emscripten_bind_dtNavMeshCreateParams_get_detailTris_1=wasmExports["ed"];Module["_emscripten_bind_dtNavMeshCreateParams_get_detailTriCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_detailTriCount_0=wasmExports["fd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_detailTriCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_detailTriCount_1=wasmExports["gd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConVerts_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConVerts_1=wasmExports["hd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConRad_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConRad_1=wasmExports["id"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConFlags_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConFlags_1=wasmExports["jd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConAreas_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConAreas_1=wasmExports["kd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConDir_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConDir_1=wasmExports["ld"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConUserID_1"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConUserID_1=wasmExports["md"];Module["_emscripten_bind_dtNavMeshCreateParams_get_offMeshConCount_0"]=_emscripten_bind_dtNavMeshCreateParams_get_offMeshConCount_0=wasmExports["nd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_offMeshConCount_1"]=_emscripten_bind_dtNavMeshCreateParams_set_offMeshConCount_1=wasmExports["od"];Module["_emscripten_bind_dtNavMeshCreateParams_get_userId_0"]=_emscripten_bind_dtNavMeshCreateParams_get_userId_0=wasmExports["pd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_userId_1"]=_emscripten_bind_dtNavMeshCreateParams_set_userId_1=wasmExports["qd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_tileX_0"]=_emscripten_bind_dtNavMeshCreateParams_get_tileX_0=wasmExports["rd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_tileX_1"]=_emscripten_bind_dtNavMeshCreateParams_set_tileX_1=wasmExports["sd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_tileY_0"]=_emscripten_bind_dtNavMeshCreateParams_get_tileY_0=wasmExports["td"];Module["_emscripten_bind_dtNavMeshCreateParams_set_tileY_1"]=_emscripten_bind_dtNavMeshCreateParams_set_tileY_1=wasmExports["ud"];Module["_emscripten_bind_dtNavMeshCreateParams_get_tileLayer_0"]=_emscripten_bind_dtNavMeshCreateParams_get_tileLayer_0=wasmExports["vd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_tileLayer_1"]=_emscripten_bind_dtNavMeshCreateParams_set_tileLayer_1=wasmExports["wd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_bmin_1"]=_emscripten_bind_dtNavMeshCreateParams_get_bmin_1=wasmExports["xd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_bmin_2"]=_emscripten_bind_dtNavMeshCreateParams_set_bmin_2=wasmExports["yd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_bmax_1"]=_emscripten_bind_dtNavMeshCreateParams_get_bmax_1=wasmExports["zd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_bmax_2"]=_emscripten_bind_dtNavMeshCreateParams_set_bmax_2=wasmExports["Ad"];Module["_emscripten_bind_dtNavMeshCreateParams_get_walkableHeight_0"]=_emscripten_bind_dtNavMeshCreateParams_get_walkableHeight_0=wasmExports["Bd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_walkableHeight_1"]=_emscripten_bind_dtNavMeshCreateParams_set_walkableHeight_1=wasmExports["Cd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_walkableRadius_0"]=_emscripten_bind_dtNavMeshCreateParams_get_walkableRadius_0=wasmExports["Dd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_walkableRadius_1"]=_emscripten_bind_dtNavMeshCreateParams_set_walkableRadius_1=wasmExports["Ed"];Module["_emscripten_bind_dtNavMeshCreateParams_get_walkableClimb_0"]=_emscripten_bind_dtNavMeshCreateParams_get_walkableClimb_0=wasmExports["Fd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_walkableClimb_1"]=_emscripten_bind_dtNavMeshCreateParams_set_walkableClimb_1=wasmExports["Gd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_cs_0"]=_emscripten_bind_dtNavMeshCreateParams_get_cs_0=wasmExports["Hd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_cs_1"]=_emscripten_bind_dtNavMeshCreateParams_set_cs_1=wasmExports["Id"];Module["_emscripten_bind_dtNavMeshCreateParams_get_ch_0"]=_emscripten_bind_dtNavMeshCreateParams_get_ch_0=wasmExports["Jd"];Module["_emscripten_bind_dtNavMeshCreateParams_set_ch_1"]=_emscripten_bind_dtNavMeshCreateParams_set_ch_1=wasmExports["Kd"];Module["_emscripten_bind_dtNavMeshCreateParams_get_buildBvTree_0"]=_emscripten_bind_dtNavMeshCreateParams_get_buildBvTree_0=wasmExports["Ld"];Module["_emscripten_bind_dtNavMeshCreateParams_set_buildBvTree_1"]=_emscripten_bind_dtNavMeshCreateParams_set_buildBvTree_1=wasmExports["Md"];Module["_emscripten_bind_dtNavMeshCreateParams___destroy___0"]=_emscripten_bind_dtNavMeshCreateParams___destroy___0=wasmExports["Nd"];Module["_emscripten_bind_dtObstacleRef___destroy___0"]=_emscripten_bind_dtObstacleRef___destroy___0=wasmExports["Od"];Module["_emscripten_bind_dtCompressedTileRef___destroy___0"]=_emscripten_bind_dtCompressedTileRef___destroy___0=wasmExports["Pd"];Module["_emscripten_bind_dtNavMeshParams_dtNavMeshParams_0"]=_emscripten_bind_dtNavMeshParams_dtNavMeshParams_0=wasmExports["Qd"];Module["_emscripten_bind_dtNavMeshParams_get_orig_1"]=_emscripten_bind_dtNavMeshParams_get_orig_1=wasmExports["Rd"];Module["_emscripten_bind_dtNavMeshParams_set_orig_2"]=_emscripten_bind_dtNavMeshParams_set_orig_2=wasmExports["Sd"];Module["_emscripten_bind_dtNavMeshParams_get_tileWidth_0"]=_emscripten_bind_dtNavMeshParams_get_tileWidth_0=wasmExports["Td"];Module["_emscripten_bind_dtNavMeshParams_set_tileWidth_1"]=_emscripten_bind_dtNavMeshParams_set_tileWidth_1=wasmExports["Ud"];Module["_emscripten_bind_dtNavMeshParams_get_tileHeight_0"]=_emscripten_bind_dtNavMeshParams_get_tileHeight_0=wasmExports["Vd"];Module["_emscripten_bind_dtNavMeshParams_set_tileHeight_1"]=_emscripten_bind_dtNavMeshParams_set_tileHeight_1=wasmExports["Wd"];Module["_emscripten_bind_dtNavMeshParams_get_maxTiles_0"]=_emscripten_bind_dtNavMeshParams_get_maxTiles_0=wasmExports["Xd"];Module["_emscripten_bind_dtNavMeshParams_set_maxTiles_1"]=_emscripten_bind_dtNavMeshParams_set_maxTiles_1=wasmExports["Yd"];Module["_emscripten_bind_dtNavMeshParams_get_maxPolys_0"]=_emscripten_bind_dtNavMeshParams_get_maxPolys_0=wasmExports["Zd"];Module["_emscripten_bind_dtNavMeshParams_set_maxPolys_1"]=_emscripten_bind_dtNavMeshParams_set_maxPolys_1=wasmExports["_d"];Module["_emscripten_bind_dtNavMeshParams___destroy___0"]=_emscripten_bind_dtNavMeshParams___destroy___0=wasmExports["$d"];Module["_emscripten_bind_dtCrowdAgentParams_dtCrowdAgentParams_0"]=_emscripten_bind_dtCrowdAgentParams_dtCrowdAgentParams_0=wasmExports["ae"];Module["_emscripten_bind_dtCrowdAgentParams_get_radius_0"]=_emscripten_bind_dtCrowdAgentParams_get_radius_0=wasmExports["be"];Module["_emscripten_bind_dtCrowdAgentParams_set_radius_1"]=_emscripten_bind_dtCrowdAgentParams_set_radius_1=wasmExports["ce"];Module["_emscripten_bind_dtCrowdAgentParams_get_height_0"]=_emscripten_bind_dtCrowdAgentParams_get_height_0=wasmExports["de"];Module["_emscripten_bind_dtCrowdAgentParams_set_height_1"]=_emscripten_bind_dtCrowdAgentParams_set_height_1=wasmExports["ee"];Module["_emscripten_bind_dtCrowdAgentParams_get_maxAcceleration_0"]=_emscripten_bind_dtCrowdAgentParams_get_maxAcceleration_0=wasmExports["fe"];Module["_emscripten_bind_dtCrowdAgentParams_set_maxAcceleration_1"]=_emscripten_bind_dtCrowdAgentParams_set_maxAcceleration_1=wasmExports["ge"];Module["_emscripten_bind_dtCrowdAgentParams_get_maxSpeed_0"]=_emscripten_bind_dtCrowdAgentParams_get_maxSpeed_0=wasmExports["he"];Module["_emscripten_bind_dtCrowdAgentParams_set_maxSpeed_1"]=_emscripten_bind_dtCrowdAgentParams_set_maxSpeed_1=wasmExports["ie"];Module["_emscripten_bind_dtCrowdAgentParams_get_collisionQueryRange_0"]=_emscripten_bind_dtCrowdAgentParams_get_collisionQueryRange_0=wasmExports["je"];Module["_emscripten_bind_dtCrowdAgentParams_set_collisionQueryRange_1"]=_emscripten_bind_dtCrowdAgentParams_set_collisionQueryRange_1=wasmExports["ke"];Module["_emscripten_bind_dtCrowdAgentParams_get_pathOptimizationRange_0"]=_emscripten_bind_dtCrowdAgentParams_get_pathOptimizationRange_0=wasmExports["le"];Module["_emscripten_bind_dtCrowdAgentParams_set_pathOptimizationRange_1"]=_emscripten_bind_dtCrowdAgentParams_set_pathOptimizationRange_1=wasmExports["me"];Module["_emscripten_bind_dtCrowdAgentParams_get_separationWeight_0"]=_emscripten_bind_dtCrowdAgentParams_get_separationWeight_0=wasmExports["ne"];Module["_emscripten_bind_dtCrowdAgentParams_set_separationWeight_1"]=_emscripten_bind_dtCrowdAgentParams_set_separationWeight_1=wasmExports["oe"];Module["_emscripten_bind_dtCrowdAgentParams_get_updateFlags_0"]=_emscripten_bind_dtCrowdAgentParams_get_updateFlags_0=wasmExports["pe"];Module["_emscripten_bind_dtCrowdAgentParams_set_updateFlags_1"]=_emscripten_bind_dtCrowdAgentParams_set_updateFlags_1=wasmExports["qe"];Module["_emscripten_bind_dtCrowdAgentParams_get_obstacleAvoidanceType_0"]=_emscripten_bind_dtCrowdAgentParams_get_obstacleAvoidanceType_0=wasmExports["re"];Module["_emscripten_bind_dtCrowdAgentParams_set_obstacleAvoidanceType_1"]=_emscripten_bind_dtCrowdAgentParams_set_obstacleAvoidanceType_1=wasmExports["se"];Module["_emscripten_bind_dtCrowdAgentParams_get_queryFilterType_0"]=_emscripten_bind_dtCrowdAgentParams_get_queryFilterType_0=wasmExports["te"];Module["_emscripten_bind_dtCrowdAgentParams_set_queryFilterType_1"]=_emscripten_bind_dtCrowdAgentParams_set_queryFilterType_1=wasmExports["ue"];Module["_emscripten_bind_dtCrowdAgentParams_get_userData_0"]=_emscripten_bind_dtCrowdAgentParams_get_userData_0=wasmExports["ve"];Module["_emscripten_bind_dtCrowdAgentParams_set_userData_1"]=_emscripten_bind_dtCrowdAgentParams_set_userData_1=wasmExports["we"];Module["_emscripten_bind_dtCrowdAgentParams___destroy___0"]=_emscripten_bind_dtCrowdAgentParams___destroy___0=wasmExports["xe"];Module["_emscripten_bind_rcSpan_get_smin_0"]=_emscripten_bind_rcSpan_get_smin_0=wasmExports["ye"];Module["_emscripten_bind_rcSpan_set_smin_1"]=_emscripten_bind_rcSpan_set_smin_1=wasmExports["ze"];Module["_emscripten_bind_rcSpan_get_smax_0"]=_emscripten_bind_rcSpan_get_smax_0=wasmExports["Ae"];Module["_emscripten_bind_rcSpan_set_smax_1"]=_emscripten_bind_rcSpan_set_smax_1=wasmExports["Be"];Module["_emscripten_bind_rcSpan_get_area_0"]=_emscripten_bind_rcSpan_get_area_0=wasmExports["Ce"];Module["_emscripten_bind_rcSpan_set_area_1"]=_emscripten_bind_rcSpan_set_area_1=wasmExports["De"];Module["_emscripten_bind_rcSpan_get_next_0"]=_emscripten_bind_rcSpan_get_next_0=wasmExports["Ee"];Module["_emscripten_bind_rcSpan_set_next_1"]=_emscripten_bind_rcSpan_set_next_1=wasmExports["Fe"];Module["_emscripten_bind_rcSpan___destroy___0"]=_emscripten_bind_rcSpan___destroy___0=wasmExports["Ge"];Module["_emscripten_bind_rcSpanPool_get_next_0"]=_emscripten_bind_rcSpanPool_get_next_0=wasmExports["He"];Module["_emscripten_bind_rcSpanPool_set_next_1"]=_emscripten_bind_rcSpanPool_set_next_1=wasmExports["Ie"];Module["_emscripten_bind_rcSpanPool_get_items_1"]=_emscripten_bind_rcSpanPool_get_items_1=wasmExports["Je"];Module["_emscripten_bind_rcSpanPool_set_items_2"]=_emscripten_bind_rcSpanPool_set_items_2=wasmExports["Ke"];Module["_emscripten_bind_rcSpanPool___destroy___0"]=_emscripten_bind_rcSpanPool___destroy___0=wasmExports["Le"];Module["_emscripten_bind_rcHeightfield_get_width_0"]=_emscripten_bind_rcHeightfield_get_width_0=wasmExports["Me"];Module["_emscripten_bind_rcHeightfield_set_width_1"]=_emscripten_bind_rcHeightfield_set_width_1=wasmExports["Ne"];Module["_emscripten_bind_rcHeightfield_get_height_0"]=_emscripten_bind_rcHeightfield_get_height_0=wasmExports["Oe"];Module["_emscripten_bind_rcHeightfield_set_height_1"]=_emscripten_bind_rcHeightfield_set_height_1=wasmExports["Pe"];Module["_emscripten_bind_rcHeightfield_get_bmin_1"]=_emscripten_bind_rcHeightfield_get_bmin_1=wasmExports["Qe"];Module["_emscripten_bind_rcHeightfield_set_bmin_2"]=_emscripten_bind_rcHeightfield_set_bmin_2=wasmExports["Re"];Module["_emscripten_bind_rcHeightfield_get_bmax_1"]=_emscripten_bind_rcHeightfield_get_bmax_1=wasmExports["Se"];Module["_emscripten_bind_rcHeightfield_set_bmax_2"]=_emscripten_bind_rcHeightfield_set_bmax_2=wasmExports["Te"];Module["_emscripten_bind_rcHeightfield_get_cs_0"]=_emscripten_bind_rcHeightfield_get_cs_0=wasmExports["Ue"];Module["_emscripten_bind_rcHeightfield_set_cs_1"]=_emscripten_bind_rcHeightfield_set_cs_1=wasmExports["Ve"];Module["_emscripten_bind_rcHeightfield_get_ch_0"]=_emscripten_bind_rcHeightfield_get_ch_0=wasmExports["We"];Module["_emscripten_bind_rcHeightfield_set_ch_1"]=_emscripten_bind_rcHeightfield_set_ch_1=wasmExports["Xe"];Module["_emscripten_bind_rcHeightfield_get_spans_1"]=_emscripten_bind_rcHeightfield_get_spans_1=wasmExports["Ye"];Module["_emscripten_bind_rcHeightfield_set_spans_2"]=_emscripten_bind_rcHeightfield_set_spans_2=wasmExports["Ze"];Module["_emscripten_bind_rcHeightfield_get_pools_1"]=_emscripten_bind_rcHeightfield_get_pools_1=wasmExports["_e"];Module["_emscripten_bind_rcHeightfield_set_pools_2"]=_emscripten_bind_rcHeightfield_set_pools_2=wasmExports["$e"];Module["_emscripten_bind_rcHeightfield_get_freelist_1"]=_emscripten_bind_rcHeightfield_get_freelist_1=wasmExports["af"];Module["_emscripten_bind_rcHeightfield_set_freelist_2"]=_emscripten_bind_rcHeightfield_set_freelist_2=wasmExports["bf"];Module["_emscripten_bind_rcHeightfield___destroy___0"]=_emscripten_bind_rcHeightfield___destroy___0=wasmExports["cf"];Module["_emscripten_bind_rcCompactCell_get_index_0"]=_emscripten_bind_rcCompactCell_get_index_0=wasmExports["df"];Module["_emscripten_bind_rcCompactCell_set_index_1"]=_emscripten_bind_rcCompactCell_set_index_1=wasmExports["ef"];Module["_emscripten_bind_rcCompactCell_get_count_0"]=_emscripten_bind_rcCompactCell_get_count_0=wasmExports["ff"];Module["_emscripten_bind_rcCompactCell_set_count_1"]=_emscripten_bind_rcCompactCell_set_count_1=wasmExports["gf"];Module["_emscripten_bind_rcCompactCell___destroy___0"]=_emscripten_bind_rcCompactCell___destroy___0=wasmExports["hf"];Module["_emscripten_bind_rcCompactSpan_get_y_0"]=_emscripten_bind_rcCompactSpan_get_y_0=wasmExports["jf"];Module["_emscripten_bind_rcCompactSpan_set_y_1"]=_emscripten_bind_rcCompactSpan_set_y_1=wasmExports["kf"];Module["_emscripten_bind_rcCompactSpan_get_reg_0"]=_emscripten_bind_rcCompactSpan_get_reg_0=wasmExports["lf"];Module["_emscripten_bind_rcCompactSpan_set_reg_1"]=_emscripten_bind_rcCompactSpan_set_reg_1=wasmExports["mf"];Module["_emscripten_bind_rcCompactSpan_get_con_0"]=_emscripten_bind_rcCompactSpan_get_con_0=wasmExports["nf"];Module["_emscripten_bind_rcCompactSpan_set_con_1"]=_emscripten_bind_rcCompactSpan_set_con_1=wasmExports["of"];Module["_emscripten_bind_rcCompactSpan_get_h_0"]=_emscripten_bind_rcCompactSpan_get_h_0=wasmExports["pf"];Module["_emscripten_bind_rcCompactSpan_set_h_1"]=_emscripten_bind_rcCompactSpan_set_h_1=wasmExports["qf"];Module["_emscripten_bind_rcCompactSpan___destroy___0"]=_emscripten_bind_rcCompactSpan___destroy___0=wasmExports["rf"];Module["_emscripten_bind_rcCompactHeightfield_get_width_0"]=_emscripten_bind_rcCompactHeightfield_get_width_0=wasmExports["sf"];Module["_emscripten_bind_rcCompactHeightfield_set_width_1"]=_emscripten_bind_rcCompactHeightfield_set_width_1=wasmExports["tf"];Module["_emscripten_bind_rcCompactHeightfield_get_height_0"]=_emscripten_bind_rcCompactHeightfield_get_height_0=wasmExports["uf"];Module["_emscripten_bind_rcCompactHeightfield_set_height_1"]=_emscripten_bind_rcCompactHeightfield_set_height_1=wasmExports["vf"];Module["_emscripten_bind_rcCompactHeightfield_get_spanCount_0"]=_emscripten_bind_rcCompactHeightfield_get_spanCount_0=wasmExports["wf"];Module["_emscripten_bind_rcCompactHeightfield_set_spanCount_1"]=_emscripten_bind_rcCompactHeightfield_set_spanCount_1=wasmExports["xf"];Module["_emscripten_bind_rcCompactHeightfield_get_walkableHeight_0"]=_emscripten_bind_rcCompactHeightfield_get_walkableHeight_0=wasmExports["yf"];Module["_emscripten_bind_rcCompactHeightfield_set_walkableHeight_1"]=_emscripten_bind_rcCompactHeightfield_set_walkableHeight_1=wasmExports["zf"];Module["_emscripten_bind_rcCompactHeightfield_get_walkableClimb_0"]=_emscripten_bind_rcCompactHeightfield_get_walkableClimb_0=wasmExports["Af"];Module["_emscripten_bind_rcCompactHeightfield_set_walkableClimb_1"]=_emscripten_bind_rcCompactHeightfield_set_walkableClimb_1=wasmExports["Bf"];Module["_emscripten_bind_rcCompactHeightfield_get_borderSize_0"]=_emscripten_bind_rcCompactHeightfield_get_borderSize_0=wasmExports["Cf"];Module["_emscripten_bind_rcCompactHeightfield_set_borderSize_1"]=_emscripten_bind_rcCompactHeightfield_set_borderSize_1=wasmExports["Df"];Module["_emscripten_bind_rcCompactHeightfield_get_maxDistance_0"]=_emscripten_bind_rcCompactHeightfield_get_maxDistance_0=wasmExports["Ef"];Module["_emscripten_bind_rcCompactHeightfield_set_maxDistance_1"]=_emscripten_bind_rcCompactHeightfield_set_maxDistance_1=wasmExports["Ff"];Module["_emscripten_bind_rcCompactHeightfield_get_maxRegions_0"]=_emscripten_bind_rcCompactHeightfield_get_maxRegions_0=wasmExports["Gf"];Module["_emscripten_bind_rcCompactHeightfield_set_maxRegions_1"]=_emscripten_bind_rcCompactHeightfield_set_maxRegions_1=wasmExports["Hf"];Module["_emscripten_bind_rcCompactHeightfield_get_bmin_1"]=_emscripten_bind_rcCompactHeightfield_get_bmin_1=wasmExports["If"];Module["_emscripten_bind_rcCompactHeightfield_set_bmin_2"]=_emscripten_bind_rcCompactHeightfield_set_bmin_2=wasmExports["Jf"];Module["_emscripten_bind_rcCompactHeightfield_get_bmax_1"]=_emscripten_bind_rcCompactHeightfield_get_bmax_1=wasmExports["Kf"];Module["_emscripten_bind_rcCompactHeightfield_set_bmax_2"]=_emscripten_bind_rcCompactHeightfield_set_bmax_2=wasmExports["Lf"];Module["_emscripten_bind_rcCompactHeightfield_get_cs_0"]=_emscripten_bind_rcCompactHeightfield_get_cs_0=wasmExports["Mf"];Module["_emscripten_bind_rcCompactHeightfield_set_cs_1"]=_emscripten_bind_rcCompactHeightfield_set_cs_1=wasmExports["Nf"];Module["_emscripten_bind_rcCompactHeightfield_get_ch_0"]=_emscripten_bind_rcCompactHeightfield_get_ch_0=wasmExports["Of"];Module["_emscripten_bind_rcCompactHeightfield_set_ch_1"]=_emscripten_bind_rcCompactHeightfield_set_ch_1=wasmExports["Pf"];Module["_emscripten_bind_rcCompactHeightfield_get_cells_1"]=_emscripten_bind_rcCompactHeightfield_get_cells_1=wasmExports["Qf"];Module["_emscripten_bind_rcCompactHeightfield_set_cells_2"]=_emscripten_bind_rcCompactHeightfield_set_cells_2=wasmExports["Rf"];Module["_emscripten_bind_rcCompactHeightfield_get_spans_1"]=_emscripten_bind_rcCompactHeightfield_get_spans_1=wasmExports["Sf"];Module["_emscripten_bind_rcCompactHeightfield_set_spans_2"]=_emscripten_bind_rcCompactHeightfield_set_spans_2=wasmExports["Tf"];Module["_emscripten_bind_rcCompactHeightfield_get_dist_1"]=_emscripten_bind_rcCompactHeightfield_get_dist_1=wasmExports["Uf"];Module["_emscripten_bind_rcCompactHeightfield_set_dist_2"]=_emscripten_bind_rcCompactHeightfield_set_dist_2=wasmExports["Vf"];Module["_emscripten_bind_rcCompactHeightfield_get_areas_1"]=_emscripten_bind_rcCompactHeightfield_get_areas_1=wasmExports["Wf"];Module["_emscripten_bind_rcCompactHeightfield_set_areas_2"]=_emscripten_bind_rcCompactHeightfield_set_areas_2=wasmExports["Xf"];Module["_emscripten_bind_rcCompactHeightfield___destroy___0"]=_emscripten_bind_rcCompactHeightfield___destroy___0=wasmExports["Yf"];Module["_emscripten_bind_rcContour_get_verts_1"]=_emscripten_bind_rcContour_get_verts_1=wasmExports["Zf"];Module["_emscripten_bind_rcContour_set_verts_2"]=_emscripten_bind_rcContour_set_verts_2=wasmExports["_f"];Module["_emscripten_bind_rcContour_get_nverts_0"]=_emscripten_bind_rcContour_get_nverts_0=wasmExports["$f"];Module["_emscripten_bind_rcContour_set_nverts_1"]=_emscripten_bind_rcContour_set_nverts_1=wasmExports["ag"];Module["_emscripten_bind_rcContour_get_rverts_1"]=_emscripten_bind_rcContour_get_rverts_1=wasmExports["bg"];Module["_emscripten_bind_rcContour_set_rverts_2"]=_emscripten_bind_rcContour_set_rverts_2=wasmExports["cg"];Module["_emscripten_bind_rcContour_get_nrverts_0"]=_emscripten_bind_rcContour_get_nrverts_0=wasmExports["dg"];Module["_emscripten_bind_rcContour_set_nrverts_1"]=_emscripten_bind_rcContour_set_nrverts_1=wasmExports["eg"];Module["_emscripten_bind_rcContour_get_reg_0"]=_emscripten_bind_rcContour_get_reg_0=wasmExports["fg"];Module["_emscripten_bind_rcContour_set_reg_1"]=_emscripten_bind_rcContour_set_reg_1=wasmExports["gg"];Module["_emscripten_bind_rcContour_get_area_0"]=_emscripten_bind_rcContour_get_area_0=wasmExports["hg"];Module["_emscripten_bind_rcContour_set_area_1"]=_emscripten_bind_rcContour_set_area_1=wasmExports["ig"];Module["_emscripten_bind_rcContour___destroy___0"]=_emscripten_bind_rcContour___destroy___0=wasmExports["jg"];Module["_emscripten_bind_rcContourSet_get_conts_1"]=_emscripten_bind_rcContourSet_get_conts_1=wasmExports["kg"];Module["_emscripten_bind_rcContourSet_set_conts_2"]=_emscripten_bind_rcContourSet_set_conts_2=wasmExports["lg"];Module["_emscripten_bind_rcContourSet_get_nconts_0"]=_emscripten_bind_rcContourSet_get_nconts_0=wasmExports["mg"];Module["_emscripten_bind_rcContourSet_set_nconts_1"]=_emscripten_bind_rcContourSet_set_nconts_1=wasmExports["ng"];Module["_emscripten_bind_rcContourSet_get_bmin_1"]=_emscripten_bind_rcContourSet_get_bmin_1=wasmExports["og"];Module["_emscripten_bind_rcContourSet_set_bmin_2"]=_emscripten_bind_rcContourSet_set_bmin_2=wasmExports["pg"];Module["_emscripten_bind_rcContourSet_get_bmax_1"]=_emscripten_bind_rcContourSet_get_bmax_1=wasmExports["qg"];Module["_emscripten_bind_rcContourSet_set_bmax_2"]=_emscripten_bind_rcContourSet_set_bmax_2=wasmExports["rg"];Module["_emscripten_bind_rcContourSet_get_cs_0"]=_emscripten_bind_rcContourSet_get_cs_0=wasmExports["sg"];Module["_emscripten_bind_rcContourSet_set_cs_1"]=_emscripten_bind_rcContourSet_set_cs_1=wasmExports["tg"];Module["_emscripten_bind_rcContourSet_get_ch_0"]=_emscripten_bind_rcContourSet_get_ch_0=wasmExports["ug"];Module["_emscripten_bind_rcContourSet_set_ch_1"]=_emscripten_bind_rcContourSet_set_ch_1=wasmExports["vg"];Module["_emscripten_bind_rcContourSet_get_width_0"]=_emscripten_bind_rcContourSet_get_width_0=wasmExports["wg"];Module["_emscripten_bind_rcContourSet_set_width_1"]=_emscripten_bind_rcContourSet_set_width_1=wasmExports["xg"];Module["_emscripten_bind_rcContourSet_get_height_0"]=_emscripten_bind_rcContourSet_get_height_0=wasmExports["yg"];Module["_emscripten_bind_rcContourSet_set_height_1"]=_emscripten_bind_rcContourSet_set_height_1=wasmExports["zg"];Module["_emscripten_bind_rcContourSet_get_borderSize_0"]=_emscripten_bind_rcContourSet_get_borderSize_0=wasmExports["Ag"];Module["_emscripten_bind_rcContourSet_set_borderSize_1"]=_emscripten_bind_rcContourSet_set_borderSize_1=wasmExports["Bg"];Module["_emscripten_bind_rcContourSet_get_maxError_0"]=_emscripten_bind_rcContourSet_get_maxError_0=wasmExports["Cg"];Module["_emscripten_bind_rcContourSet_set_maxError_1"]=_emscripten_bind_rcContourSet_set_maxError_1=wasmExports["Dg"];Module["_emscripten_bind_rcContourSet___destroy___0"]=_emscripten_bind_rcContourSet___destroy___0=wasmExports["Eg"];Module["_emscripten_bind_rcHeightfieldLayer_get_bmin_1"]=_emscripten_bind_rcHeightfieldLayer_get_bmin_1=wasmExports["Fg"];Module["_emscripten_bind_rcHeightfieldLayer_set_bmin_2"]=_emscripten_bind_rcHeightfieldLayer_set_bmin_2=wasmExports["Gg"];Module["_emscripten_bind_rcHeightfieldLayer_get_bmax_1"]=_emscripten_bind_rcHeightfieldLayer_get_bmax_1=wasmExports["Hg"];Module["_emscripten_bind_rcHeightfieldLayer_set_bmax_2"]=_emscripten_bind_rcHeightfieldLayer_set_bmax_2=wasmExports["Ig"];Module["_emscripten_bind_rcHeightfieldLayer_get_cs_0"]=_emscripten_bind_rcHeightfieldLayer_get_cs_0=wasmExports["Jg"];Module["_emscripten_bind_rcHeightfieldLayer_set_cs_1"]=_emscripten_bind_rcHeightfieldLayer_set_cs_1=wasmExports["Kg"];Module["_emscripten_bind_rcHeightfieldLayer_get_ch_0"]=_emscripten_bind_rcHeightfieldLayer_get_ch_0=wasmExports["Lg"];Module["_emscripten_bind_rcHeightfieldLayer_set_ch_1"]=_emscripten_bind_rcHeightfieldLayer_set_ch_1=wasmExports["Mg"];Module["_emscripten_bind_rcHeightfieldLayer_get_width_0"]=_emscripten_bind_rcHeightfieldLayer_get_width_0=wasmExports["Ng"];Module["_emscripten_bind_rcHeightfieldLayer_set_width_1"]=_emscripten_bind_rcHeightfieldLayer_set_width_1=wasmExports["Og"];Module["_emscripten_bind_rcHeightfieldLayer_get_height_0"]=_emscripten_bind_rcHeightfieldLayer_get_height_0=wasmExports["Pg"];Module["_emscripten_bind_rcHeightfieldLayer_set_height_1"]=_emscripten_bind_rcHeightfieldLayer_set_height_1=wasmExports["Qg"];Module["_emscripten_bind_rcHeightfieldLayer_get_minx_0"]=_emscripten_bind_rcHeightfieldLayer_get_minx_0=wasmExports["Rg"];Module["_emscripten_bind_rcHeightfieldLayer_set_minx_1"]=_emscripten_bind_rcHeightfieldLayer_set_minx_1=wasmExports["Sg"];Module["_emscripten_bind_rcHeightfieldLayer_get_maxx_0"]=_emscripten_bind_rcHeightfieldLayer_get_maxx_0=wasmExports["Tg"];Module["_emscripten_bind_rcHeightfieldLayer_set_maxx_1"]=_emscripten_bind_rcHeightfieldLayer_set_maxx_1=wasmExports["Ug"];Module["_emscripten_bind_rcHeightfieldLayer_get_miny_0"]=_emscripten_bind_rcHeightfieldLayer_get_miny_0=wasmExports["Vg"];Module["_emscripten_bind_rcHeightfieldLayer_set_miny_1"]=_emscripten_bind_rcHeightfieldLayer_set_miny_1=wasmExports["Wg"];Module["_emscripten_bind_rcHeightfieldLayer_get_maxy_0"]=_emscripten_bind_rcHeightfieldLayer_get_maxy_0=wasmExports["Xg"];Module["_emscripten_bind_rcHeightfieldLayer_set_maxy_1"]=_emscripten_bind_rcHeightfieldLayer_set_maxy_1=wasmExports["Yg"];Module["_emscripten_bind_rcHeightfieldLayer_get_hmin_0"]=_emscripten_bind_rcHeightfieldLayer_get_hmin_0=wasmExports["Zg"];Module["_emscripten_bind_rcHeightfieldLayer_set_hmin_1"]=_emscripten_bind_rcHeightfieldLayer_set_hmin_1=wasmExports["_g"];Module["_emscripten_bind_rcHeightfieldLayer_get_hmax_0"]=_emscripten_bind_rcHeightfieldLayer_get_hmax_0=wasmExports["$g"];Module["_emscripten_bind_rcHeightfieldLayer_set_hmax_1"]=_emscripten_bind_rcHeightfieldLayer_set_hmax_1=wasmExports["ah"];Module["_emscripten_bind_rcHeightfieldLayer_get_heights_1"]=_emscripten_bind_rcHeightfieldLayer_get_heights_1=wasmExports["bh"];Module["_emscripten_bind_rcHeightfieldLayer_set_heights_2"]=_emscripten_bind_rcHeightfieldLayer_set_heights_2=wasmExports["ch"];Module["_emscripten_bind_rcHeightfieldLayer_get_areas_1"]=_emscripten_bind_rcHeightfieldLayer_get_areas_1=wasmExports["dh"];Module["_emscripten_bind_rcHeightfieldLayer_set_areas_2"]=_emscripten_bind_rcHeightfieldLayer_set_areas_2=wasmExports["eh"];Module["_emscripten_bind_rcHeightfieldLayer_get_cons_1"]=_emscripten_bind_rcHeightfieldLayer_get_cons_1=wasmExports["fh"];Module["_emscripten_bind_rcHeightfieldLayer_set_cons_2"]=_emscripten_bind_rcHeightfieldLayer_set_cons_2=wasmExports["gh"];Module["_emscripten_bind_rcHeightfieldLayer___destroy___0"]=_emscripten_bind_rcHeightfieldLayer___destroy___0=wasmExports["hh"];Module["_emscripten_bind_rcHeightfieldLayerSet_get_layers_1"]=_emscripten_bind_rcHeightfieldLayerSet_get_layers_1=wasmExports["ih"];Module["_emscripten_bind_rcHeightfieldLayerSet_set_layers_2"]=_emscripten_bind_rcHeightfieldLayerSet_set_layers_2=wasmExports["jh"];Module["_emscripten_bind_rcHeightfieldLayerSet_get_nlayers_0"]=_emscripten_bind_rcHeightfieldLayerSet_get_nlayers_0=wasmExports["kh"];Module["_emscripten_bind_rcHeightfieldLayerSet_set_nlayers_1"]=_emscripten_bind_rcHeightfieldLayerSet_set_nlayers_1=wasmExports["lh"];Module["_emscripten_bind_rcHeightfieldLayerSet___destroy___0"]=_emscripten_bind_rcHeightfieldLayerSet___destroy___0=wasmExports["mh"];Module["_emscripten_bind_rcPolyMesh_get_verts_1"]=_emscripten_bind_rcPolyMesh_get_verts_1=wasmExports["nh"];Module["_emscripten_bind_rcPolyMesh_set_verts_2"]=_emscripten_bind_rcPolyMesh_set_verts_2=wasmExports["oh"];Module["_emscripten_bind_rcPolyMesh_get_polys_1"]=_emscripten_bind_rcPolyMesh_get_polys_1=wasmExports["ph"];Module["_emscripten_bind_rcPolyMesh_set_polys_2"]=_emscripten_bind_rcPolyMesh_set_polys_2=wasmExports["qh"];Module["_emscripten_bind_rcPolyMesh_get_regs_1"]=_emscripten_bind_rcPolyMesh_get_regs_1=wasmExports["rh"];Module["_emscripten_bind_rcPolyMesh_set_regs_2"]=_emscripten_bind_rcPolyMesh_set_regs_2=wasmExports["sh"];Module["_emscripten_bind_rcPolyMesh_get_flags_1"]=_emscripten_bind_rcPolyMesh_get_flags_1=wasmExports["th"];Module["_emscripten_bind_rcPolyMesh_set_flags_2"]=_emscripten_bind_rcPolyMesh_set_flags_2=wasmExports["uh"];Module["_emscripten_bind_rcPolyMesh_get_areas_1"]=_emscripten_bind_rcPolyMesh_get_areas_1=wasmExports["vh"];Module["_emscripten_bind_rcPolyMesh_set_areas_2"]=_emscripten_bind_rcPolyMesh_set_areas_2=wasmExports["wh"];Module["_emscripten_bind_rcPolyMesh_get_nverts_0"]=_emscripten_bind_rcPolyMesh_get_nverts_0=wasmExports["xh"];Module["_emscripten_bind_rcPolyMesh_set_nverts_1"]=_emscripten_bind_rcPolyMesh_set_nverts_1=wasmExports["yh"];Module["_emscripten_bind_rcPolyMesh_get_npolys_0"]=_emscripten_bind_rcPolyMesh_get_npolys_0=wasmExports["zh"];Module["_emscripten_bind_rcPolyMesh_set_npolys_1"]=_emscripten_bind_rcPolyMesh_set_npolys_1=wasmExports["Ah"];Module["_emscripten_bind_rcPolyMesh_get_maxpolys_0"]=_emscripten_bind_rcPolyMesh_get_maxpolys_0=wasmExports["Bh"];Module["_emscripten_bind_rcPolyMesh_set_maxpolys_1"]=_emscripten_bind_rcPolyMesh_set_maxpolys_1=wasmExports["Ch"];Module["_emscripten_bind_rcPolyMesh_get_nvp_0"]=_emscripten_bind_rcPolyMesh_get_nvp_0=wasmExports["Dh"];Module["_emscripten_bind_rcPolyMesh_set_nvp_1"]=_emscripten_bind_rcPolyMesh_set_nvp_1=wasmExports["Eh"];Module["_emscripten_bind_rcPolyMesh_get_bmin_1"]=_emscripten_bind_rcPolyMesh_get_bmin_1=wasmExports["Fh"];Module["_emscripten_bind_rcPolyMesh_set_bmin_2"]=_emscripten_bind_rcPolyMesh_set_bmin_2=wasmExports["Gh"];Module["_emscripten_bind_rcPolyMesh_get_bmax_1"]=_emscripten_bind_rcPolyMesh_get_bmax_1=wasmExports["Hh"];Module["_emscripten_bind_rcPolyMesh_set_bmax_2"]=_emscripten_bind_rcPolyMesh_set_bmax_2=wasmExports["Ih"];Module["_emscripten_bind_rcPolyMesh_get_cs_0"]=_emscripten_bind_rcPolyMesh_get_cs_0=wasmExports["Jh"];Module["_emscripten_bind_rcPolyMesh_set_cs_1"]=_emscripten_bind_rcPolyMesh_set_cs_1=wasmExports["Kh"];Module["_emscripten_bind_rcPolyMesh_get_ch_0"]=_emscripten_bind_rcPolyMesh_get_ch_0=wasmExports["Lh"];Module["_emscripten_bind_rcPolyMesh_set_ch_1"]=_emscripten_bind_rcPolyMesh_set_ch_1=wasmExports["Mh"];Module["_emscripten_bind_rcPolyMesh_get_borderSize_0"]=_emscripten_bind_rcPolyMesh_get_borderSize_0=wasmExports["Nh"];Module["_emscripten_bind_rcPolyMesh_set_borderSize_1"]=_emscripten_bind_rcPolyMesh_set_borderSize_1=wasmExports["Oh"];Module["_emscripten_bind_rcPolyMesh_get_maxEdgeError_0"]=_emscripten_bind_rcPolyMesh_get_maxEdgeError_0=wasmExports["Ph"];Module["_emscripten_bind_rcPolyMesh_set_maxEdgeError_1"]=_emscripten_bind_rcPolyMesh_set_maxEdgeError_1=wasmExports["Qh"];Module["_emscripten_bind_rcPolyMesh___destroy___0"]=_emscripten_bind_rcPolyMesh___destroy___0=wasmExports["Rh"];Module["_emscripten_bind_rcPolyMeshDetail_get_meshes_1"]=_emscripten_bind_rcPolyMeshDetail_get_meshes_1=wasmExports["Sh"];Module["_emscripten_bind_rcPolyMeshDetail_set_meshes_2"]=_emscripten_bind_rcPolyMeshDetail_set_meshes_2=wasmExports["Th"];Module["_emscripten_bind_rcPolyMeshDetail_get_verts_1"]=_emscripten_bind_rcPolyMeshDetail_get_verts_1=wasmExports["Uh"];Module["_emscripten_bind_rcPolyMeshDetail_set_verts_2"]=_emscripten_bind_rcPolyMeshDetail_set_verts_2=wasmExports["Vh"];Module["_emscripten_bind_rcPolyMeshDetail_get_tris_1"]=_emscripten_bind_rcPolyMeshDetail_get_tris_1=wasmExports["Wh"];Module["_emscripten_bind_rcPolyMeshDetail_set_tris_2"]=_emscripten_bind_rcPolyMeshDetail_set_tris_2=wasmExports["Xh"];Module["_emscripten_bind_rcPolyMeshDetail_get_nmeshes_0"]=_emscripten_bind_rcPolyMeshDetail_get_nmeshes_0=wasmExports["Yh"];Module["_emscripten_bind_rcPolyMeshDetail_set_nmeshes_1"]=_emscripten_bind_rcPolyMeshDetail_set_nmeshes_1=wasmExports["Zh"];Module["_emscripten_bind_rcPolyMeshDetail_get_nverts_0"]=_emscripten_bind_rcPolyMeshDetail_get_nverts_0=wasmExports["_h"];Module["_emscripten_bind_rcPolyMeshDetail_set_nverts_1"]=_emscripten_bind_rcPolyMeshDetail_set_nverts_1=wasmExports["$h"];Module["_emscripten_bind_rcPolyMeshDetail_get_ntris_0"]=_emscripten_bind_rcPolyMeshDetail_get_ntris_0=wasmExports["ai"];Module["_emscripten_bind_rcPolyMeshDetail_set_ntris_1"]=_emscripten_bind_rcPolyMeshDetail_set_ntris_1=wasmExports["bi"];Module["_emscripten_bind_rcPolyMeshDetail___destroy___0"]=_emscripten_bind_rcPolyMeshDetail___destroy___0=wasmExports["ci"];Module["_emscripten_bind_Vec3_Vec3_0"]=_emscripten_bind_Vec3_Vec3_0=wasmExports["di"];Module["_emscripten_bind_Vec3_Vec3_3"]=_emscripten_bind_Vec3_Vec3_3=wasmExports["ei"];Module["_emscripten_bind_Vec3_get_x_0"]=_emscripten_bind_Vec3_get_x_0=wasmExports["fi"];Module["_emscripten_bind_Vec3_set_x_1"]=_emscripten_bind_Vec3_set_x_1=wasmExports["gi"];Module["_emscripten_bind_Vec3_get_y_0"]=_emscripten_bind_Vec3_get_y_0=wasmExports["hi"];Module["_emscripten_bind_Vec3_set_y_1"]=_emscripten_bind_Vec3_set_y_1=wasmExports["ii"];Module["_emscripten_bind_Vec3_get_z_0"]=_emscripten_bind_Vec3_get_z_0=wasmExports["ji"];Module["_emscripten_bind_Vec3_set_z_1"]=_emscripten_bind_Vec3_set_z_1=wasmExports["ki"];Module["_emscripten_bind_Vec3___destroy___0"]=_emscripten_bind_Vec3___destroy___0=wasmExports["li"];Module["_emscripten_bind_NavMeshRemoveTileResult_get_status_0"]=_emscripten_bind_NavMeshRemoveTileResult_get_status_0=wasmExports["mi"];Module["_emscripten_bind_NavMeshRemoveTileResult_set_status_1"]=_emscripten_bind_NavMeshRemoveTileResult_set_status_1=wasmExports["ni"];Module["_emscripten_bind_NavMeshRemoveTileResult_get_data_1"]=_emscripten_bind_NavMeshRemoveTileResult_get_data_1=wasmExports["oi"];Module["_emscripten_bind_NavMeshRemoveTileResult_set_data_2"]=_emscripten_bind_NavMeshRemoveTileResult_set_data_2=wasmExports["pi"];Module["_emscripten_bind_NavMeshRemoveTileResult_get_dataSize_0"]=_emscripten_bind_NavMeshRemoveTileResult_get_dataSize_0=wasmExports["qi"];Module["_emscripten_bind_NavMeshRemoveTileResult_set_dataSize_1"]=_emscripten_bind_NavMeshRemoveTileResult_set_dataSize_1=wasmExports["ri"];Module["_emscripten_bind_NavMeshRemoveTileResult___destroy___0"]=_emscripten_bind_NavMeshRemoveTileResult___destroy___0=wasmExports["si"];Module["_emscripten_bind_NavMeshCalcTileLocResult_get_tileX_0"]=_emscripten_bind_NavMeshCalcTileLocResult_get_tileX_0=wasmExports["ti"];Module["_emscripten_bind_NavMeshCalcTileLocResult_set_tileX_1"]=_emscripten_bind_NavMeshCalcTileLocResult_set_tileX_1=wasmExports["ui"];Module["_emscripten_bind_NavMeshCalcTileLocResult_get_tileY_0"]=_emscripten_bind_NavMeshCalcTileLocResult_get_tileY_0=wasmExports["vi"];Module["_emscripten_bind_NavMeshCalcTileLocResult_set_tileY_1"]=_emscripten_bind_NavMeshCalcTileLocResult_set_tileY_1=wasmExports["wi"];Module["_emscripten_bind_NavMeshCalcTileLocResult___destroy___0"]=_emscripten_bind_NavMeshCalcTileLocResult___destroy___0=wasmExports["xi"];Module["_emscripten_bind_NavMeshGetTilesAtResult_get_tiles_1"]=_emscripten_bind_NavMeshGetTilesAtResult_get_tiles_1=wasmExports["yi"];Module["_emscripten_bind_NavMeshGetTilesAtResult_get_tileCount_0"]=_emscripten_bind_NavMeshGetTilesAtResult_get_tileCount_0=wasmExports["zi"];Module["_emscripten_bind_NavMeshGetTilesAtResult_set_tileCount_1"]=_emscripten_bind_NavMeshGetTilesAtResult_set_tileCount_1=wasmExports["Ai"];Module["_emscripten_bind_NavMeshGetTilesAtResult___destroy___0"]=_emscripten_bind_NavMeshGetTilesAtResult___destroy___0=wasmExports["Bi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_status_0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_status_0=wasmExports["Ci"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_status_1"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_status_1=wasmExports["Di"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_tile_0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_tile_0=wasmExports["Ei"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_tile_1"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_tile_1=wasmExports["Fi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_poly_0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_get_poly_0=wasmExports["Gi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_poly_1"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult_set_poly_1=wasmExports["Hi"];Module["_emscripten_bind_NavMeshGetTileAndPolyByRefResult___destroy___0"]=_emscripten_bind_NavMeshGetTileAndPolyByRefResult___destroy___0=wasmExports["Ii"];Module["_emscripten_bind_NavMeshStoreTileStateResult_get_status_0"]=_emscripten_bind_NavMeshStoreTileStateResult_get_status_0=wasmExports["Ji"];Module["_emscripten_bind_NavMeshStoreTileStateResult_set_status_1"]=_emscripten_bind_NavMeshStoreTileStateResult_set_status_1=wasmExports["Ki"];Module["_emscripten_bind_NavMeshStoreTileStateResult_get_data_1"]=_emscripten_bind_NavMeshStoreTileStateResult_get_data_1=wasmExports["Li"];Module["_emscripten_bind_NavMeshStoreTileStateResult_set_data_2"]=_emscripten_bind_NavMeshStoreTileStateResult_set_data_2=wasmExports["Mi"];Module["_emscripten_bind_NavMeshStoreTileStateResult_get_dataSize_0"]=_emscripten_bind_NavMeshStoreTileStateResult_get_dataSize_0=wasmExports["Ni"];Module["_emscripten_bind_NavMeshStoreTileStateResult_set_dataSize_1"]=_emscripten_bind_NavMeshStoreTileStateResult_set_dataSize_1=wasmExports["Oi"];Module["_emscripten_bind_NavMeshStoreTileStateResult___destroy___0"]=_emscripten_bind_NavMeshStoreTileStateResult___destroy___0=wasmExports["Pi"];Module["_emscripten_bind_NavMesh_NavMesh_0"]=_emscripten_bind_NavMesh_NavMesh_0=wasmExports["Qi"];Module["_emscripten_bind_NavMesh_NavMesh_1"]=_emscripten_bind_NavMesh_NavMesh_1=wasmExports["Ri"];Module["_emscripten_bind_NavMesh_initSolo_1"]=_emscripten_bind_NavMesh_initSolo_1=wasmExports["Si"];Module["_emscripten_bind_NavMesh_initTiled_1"]=_emscripten_bind_NavMesh_initTiled_1=wasmExports["Ti"];Module["_emscripten_bind_NavMesh_addTile_4"]=_emscripten_bind_NavMesh_addTile_4=wasmExports["Ui"];Module["_emscripten_bind_NavMesh_decodePolyId_4"]=_emscripten_bind_NavMesh_decodePolyId_4=wasmExports["Vi"];Module["_emscripten_bind_NavMesh_encodePolyId_3"]=_emscripten_bind_NavMesh_encodePolyId_3=wasmExports["Wi"];Module["_emscripten_bind_NavMesh_removeTile_1"]=_emscripten_bind_NavMesh_removeTile_1=wasmExports["Xi"];Module["_emscripten_bind_NavMesh_getNavMesh_0"]=_emscripten_bind_NavMesh_getNavMesh_0=wasmExports["Yi"];Module["_emscripten_bind_NavMesh_calcTileLoc_1"]=_emscripten_bind_NavMesh_calcTileLoc_1=wasmExports["Zi"];Module["_emscripten_bind_NavMesh_getTileAt_3"]=_emscripten_bind_NavMesh_getTileAt_3=wasmExports["_i"];Module["_emscripten_bind_NavMesh_getTilesAt_3"]=_emscripten_bind_NavMesh_getTilesAt_3=wasmExports["$i"];Module["_emscripten_bind_NavMesh_getTileRefAt_3"]=_emscripten_bind_NavMesh_getTileRefAt_3=wasmExports["aj"];Module["_emscripten_bind_NavMesh_getTileRef_1"]=_emscripten_bind_NavMesh_getTileRef_1=wasmExports["bj"];Module["_emscripten_bind_NavMesh_getTileByRef_1"]=_emscripten_bind_NavMesh_getTileByRef_1=wasmExports["cj"];Module["_emscripten_bind_NavMesh_getMaxTiles_0"]=_emscripten_bind_NavMesh_getMaxTiles_0=wasmExports["dj"];Module["_emscripten_bind_NavMesh_getTile_1"]=_emscripten_bind_NavMesh_getTile_1=wasmExports["ej"];Module["_emscripten_bind_NavMesh_getTileAndPolyByRef_1"]=_emscripten_bind_NavMesh_getTileAndPolyByRef_1=wasmExports["fj"];Module["_emscripten_bind_NavMesh_getTileAndPolyByRefUnsafe_1"]=_emscripten_bind_NavMesh_getTileAndPolyByRefUnsafe_1=wasmExports["gj"];Module["_emscripten_bind_NavMesh_isValidPolyRef_1"]=_emscripten_bind_NavMesh_isValidPolyRef_1=wasmExports["hj"];Module["_emscripten_bind_NavMesh_getPolyRefBase_1"]=_emscripten_bind_NavMesh_getPolyRefBase_1=wasmExports["ij"];Module["_emscripten_bind_NavMesh_getOffMeshConnectionPolyEndPoints_4"]=_emscripten_bind_NavMesh_getOffMeshConnectionPolyEndPoints_4=wasmExports["jj"];Module["_emscripten_bind_NavMesh_getOffMeshConnectionByRef_1"]=_emscripten_bind_NavMesh_getOffMeshConnectionByRef_1=wasmExports["kj"];Module["_emscripten_bind_NavMesh_setPolyFlags_2"]=_emscripten_bind_NavMesh_setPolyFlags_2=wasmExports["lj"];Module["_emscripten_bind_NavMesh_getPolyFlags_2"]=_emscripten_bind_NavMesh_getPolyFlags_2=wasmExports["mj"];Module["_emscripten_bind_NavMesh_setPolyArea_2"]=_emscripten_bind_NavMesh_setPolyArea_2=wasmExports["nj"];Module["_emscripten_bind_NavMesh_getPolyArea_2"]=_emscripten_bind_NavMesh_getPolyArea_2=wasmExports["oj"];Module["_emscripten_bind_NavMesh_getTileStateSize_1"]=_emscripten_bind_NavMesh_getTileStateSize_1=wasmExports["pj"];Module["_emscripten_bind_NavMesh_storeTileState_2"]=_emscripten_bind_NavMesh_storeTileState_2=wasmExports["qj"];Module["_emscripten_bind_NavMesh_restoreTileState_3"]=_emscripten_bind_NavMesh_restoreTileState_3=wasmExports["rj"];Module["_emscripten_bind_NavMesh_destroy_0"]=_emscripten_bind_NavMesh_destroy_0=wasmExports["sj"];Module["_emscripten_bind_NavMesh_get_m_navMesh_0"]=_emscripten_bind_NavMesh_get_m_navMesh_0=wasmExports["tj"];Module["_emscripten_bind_NavMesh_set_m_navMesh_1"]=_emscripten_bind_NavMesh_set_m_navMesh_1=wasmExports["uj"];Module["_emscripten_bind_NavMesh___destroy___0"]=_emscripten_bind_NavMesh___destroy___0=wasmExports["vj"];Module["_emscripten_bind_FastRand_getSeed_0"]=_emscripten_bind_FastRand_getSeed_0=wasmExports["wj"];Module["_emscripten_bind_FastRand_setSeed_1"]=_emscripten_bind_FastRand_setSeed_1=wasmExports["xj"];Module["_emscripten_bind_FastRand___destroy___0"]=_emscripten_bind_FastRand___destroy___0=wasmExports["yj"];Module["_emscripten_bind_dtRaycastHit_dtRaycastHit_0"]=_emscripten_bind_dtRaycastHit_dtRaycastHit_0=wasmExports["zj"];Module["_emscripten_bind_dtRaycastHit_get_t_0"]=_emscripten_bind_dtRaycastHit_get_t_0=wasmExports["Aj"];Module["_emscripten_bind_dtRaycastHit_set_t_1"]=_emscripten_bind_dtRaycastHit_set_t_1=wasmExports["Bj"];Module["_emscripten_bind_dtRaycastHit_get_hitNormal_1"]=_emscripten_bind_dtRaycastHit_get_hitNormal_1=wasmExports["Cj"];Module["_emscripten_bind_dtRaycastHit_set_hitNormal_2"]=_emscripten_bind_dtRaycastHit_set_hitNormal_2=wasmExports["Dj"];Module["_emscripten_bind_dtRaycastHit_get_hitEdgeIndex_0"]=_emscripten_bind_dtRaycastHit_get_hitEdgeIndex_0=wasmExports["Ej"];Module["_emscripten_bind_dtRaycastHit_set_hitEdgeIndex_1"]=_emscripten_bind_dtRaycastHit_set_hitEdgeIndex_1=wasmExports["Fj"];Module["_emscripten_bind_dtRaycastHit_get_path_1"]=_emscripten_bind_dtRaycastHit_get_path_1=wasmExports["Gj"];Module["_emscripten_bind_dtRaycastHit_set_path_2"]=_emscripten_bind_dtRaycastHit_set_path_2=wasmExports["Hj"];Module["_emscripten_bind_dtRaycastHit_get_pathCount_0"]=_emscripten_bind_dtRaycastHit_get_pathCount_0=wasmExports["Ij"];Module["_emscripten_bind_dtRaycastHit_set_pathCount_1"]=_emscripten_bind_dtRaycastHit_set_pathCount_1=wasmExports["Jj"];Module["_emscripten_bind_dtRaycastHit_get_maxPath_0"]=_emscripten_bind_dtRaycastHit_get_maxPath_0=wasmExports["Kj"];Module["_emscripten_bind_dtRaycastHit_set_maxPath_1"]=_emscripten_bind_dtRaycastHit_set_maxPath_1=wasmExports["Lj"];Module["_emscripten_bind_dtRaycastHit_get_pathCost_0"]=_emscripten_bind_dtRaycastHit_get_pathCost_0=wasmExports["Mj"];Module["_emscripten_bind_dtRaycastHit_set_pathCost_1"]=_emscripten_bind_dtRaycastHit_set_pathCost_1=wasmExports["Nj"];Module["_emscripten_bind_dtRaycastHit___destroy___0"]=_emscripten_bind_dtRaycastHit___destroy___0=wasmExports["Oj"];Module["_emscripten_bind_NavMeshQuery_NavMeshQuery_0"]=_emscripten_bind_NavMeshQuery_NavMeshQuery_0=wasmExports["Pj"];Module["_emscripten_bind_NavMeshQuery_NavMeshQuery_1"]=_emscripten_bind_NavMeshQuery_NavMeshQuery_1=wasmExports["Qj"];Module["_emscripten_bind_NavMeshQuery_init_2"]=_emscripten_bind_NavMeshQuery_init_2=wasmExports["Rj"];Module["_emscripten_bind_NavMeshQuery_findPath_7"]=_emscripten_bind_NavMeshQuery_findPath_7=wasmExports["Sj"];Module["_emscripten_bind_NavMeshQuery_closestPointOnPoly_4"]=_emscripten_bind_NavMeshQuery_closestPointOnPoly_4=wasmExports["Tj"];Module["_emscripten_bind_NavMeshQuery_findClosestPoint_6"]=_emscripten_bind_NavMeshQuery_findClosestPoint_6=wasmExports["Uj"];Module["_emscripten_bind_NavMeshQuery_findStraightPath_9"]=_emscripten_bind_NavMeshQuery_findStraightPath_9=wasmExports["Vj"];Module["_emscripten_bind_NavMeshQuery_findNearestPoly_6"]=_emscripten_bind_NavMeshQuery_findNearestPoly_6=wasmExports["Wj"];Module["_emscripten_bind_NavMeshQuery_findPolysAroundCircle_9"]=_emscripten_bind_NavMeshQuery_findPolysAroundCircle_9=wasmExports["Xj"];Module["_emscripten_bind_NavMeshQuery_queryPolygons_6"]=_emscripten_bind_NavMeshQuery_queryPolygons_6=wasmExports["Yj"];Module["_emscripten_bind_NavMeshQuery_raycast_7"]=_emscripten_bind_NavMeshQuery_raycast_7=wasmExports["Zj"];Module["_emscripten_bind_NavMeshQuery_findRandomPointAroundCircle_6"]=_emscripten_bind_NavMeshQuery_findRandomPointAroundCircle_6=wasmExports["_j"];Module["_emscripten_bind_NavMeshQuery_moveAlongSurface_7"]=_emscripten_bind_NavMeshQuery_moveAlongSurface_7=wasmExports["$j"];Module["_emscripten_bind_NavMeshQuery_findRandomPoint_3"]=_emscripten_bind_NavMeshQuery_findRandomPoint_3=wasmExports["ak"];Module["_emscripten_bind_NavMeshQuery_getPolyHeight_3"]=_emscripten_bind_NavMeshQuery_getPolyHeight_3=wasmExports["bk"];Module["_emscripten_bind_NavMeshQuery_destroy_0"]=_emscripten_bind_NavMeshQuery_destroy_0=wasmExports["ck"];Module["_emscripten_bind_NavMeshQuery_get_m_navQuery_0"]=_emscripten_bind_NavMeshQuery_get_m_navQuery_0=wasmExports["dk"];Module["_emscripten_bind_NavMeshQuery_set_m_navQuery_1"]=_emscripten_bind_NavMeshQuery_set_m_navQuery_1=wasmExports["ek"];Module["_emscripten_bind_NavMeshQuery___destroy___0"]=_emscripten_bind_NavMeshQuery___destroy___0=wasmExports["fk"];Module["_emscripten_bind_dtTileCacheParams_dtTileCacheParams_0"]=_emscripten_bind_dtTileCacheParams_dtTileCacheParams_0=wasmExports["gk"];Module["_emscripten_bind_dtTileCacheParams_get_orig_1"]=_emscripten_bind_dtTileCacheParams_get_orig_1=wasmExports["hk"];Module["_emscripten_bind_dtTileCacheParams_set_orig_2"]=_emscripten_bind_dtTileCacheParams_set_orig_2=wasmExports["ik"];Module["_emscripten_bind_dtTileCacheParams_get_cs_0"]=_emscripten_bind_dtTileCacheParams_get_cs_0=wasmExports["jk"];Module["_emscripten_bind_dtTileCacheParams_set_cs_1"]=_emscripten_bind_dtTileCacheParams_set_cs_1=wasmExports["kk"];Module["_emscripten_bind_dtTileCacheParams_get_ch_0"]=_emscripten_bind_dtTileCacheParams_get_ch_0=wasmExports["lk"];Module["_emscripten_bind_dtTileCacheParams_set_ch_1"]=_emscripten_bind_dtTileCacheParams_set_ch_1=wasmExports["mk"];Module["_emscripten_bind_dtTileCacheParams_get_width_0"]=_emscripten_bind_dtTileCacheParams_get_width_0=wasmExports["nk"];Module["_emscripten_bind_dtTileCacheParams_set_width_1"]=_emscripten_bind_dtTileCacheParams_set_width_1=wasmExports["ok"];Module["_emscripten_bind_dtTileCacheParams_get_height_0"]=_emscripten_bind_dtTileCacheParams_get_height_0=wasmExports["pk"];Module["_emscripten_bind_dtTileCacheParams_set_height_1"]=_emscripten_bind_dtTileCacheParams_set_height_1=wasmExports["qk"];Module["_emscripten_bind_dtTileCacheParams_get_walkableHeight_0"]=_emscripten_bind_dtTileCacheParams_get_walkableHeight_0=wasmExports["rk"];Module["_emscripten_bind_dtTileCacheParams_set_walkableHeight_1"]=_emscripten_bind_dtTileCacheParams_set_walkableHeight_1=wasmExports["sk"];Module["_emscripten_bind_dtTileCacheParams_get_walkableRadius_0"]=_emscripten_bind_dtTileCacheParams_get_walkableRadius_0=wasmExports["tk"];Module["_emscripten_bind_dtTileCacheParams_set_walkableRadius_1"]=_emscripten_bind_dtTileCacheParams_set_walkableRadius_1=wasmExports["uk"];Module["_emscripten_bind_dtTileCacheParams_get_walkableClimb_0"]=_emscripten_bind_dtTileCacheParams_get_walkableClimb_0=wasmExports["vk"];Module["_emscripten_bind_dtTileCacheParams_set_walkableClimb_1"]=_emscripten_bind_dtTileCacheParams_set_walkableClimb_1=wasmExports["wk"];Module["_emscripten_bind_dtTileCacheParams_get_maxSimplificationError_0"]=_emscripten_bind_dtTileCacheParams_get_maxSimplificationError_0=wasmExports["xk"];Module["_emscripten_bind_dtTileCacheParams_set_maxSimplificationError_1"]=_emscripten_bind_dtTileCacheParams_set_maxSimplificationError_1=wasmExports["yk"];Module["_emscripten_bind_dtTileCacheParams_get_maxTiles_0"]=_emscripten_bind_dtTileCacheParams_get_maxTiles_0=wasmExports["zk"];Module["_emscripten_bind_dtTileCacheParams_set_maxTiles_1"]=_emscripten_bind_dtTileCacheParams_set_maxTiles_1=wasmExports["Ak"];Module["_emscripten_bind_dtTileCacheParams_get_maxObstacles_0"]=_emscripten_bind_dtTileCacheParams_get_maxObstacles_0=wasmExports["Bk"];Module["_emscripten_bind_dtTileCacheParams_set_maxObstacles_1"]=_emscripten_bind_dtTileCacheParams_set_maxObstacles_1=wasmExports["Ck"];Module["_emscripten_bind_dtTileCacheParams___destroy___0"]=_emscripten_bind_dtTileCacheParams___destroy___0=wasmExports["Dk"];Module["_emscripten_bind_TileCacheAddTileResult_get_status_0"]=_emscripten_bind_TileCacheAddTileResult_get_status_0=wasmExports["Ek"];Module["_emscripten_bind_TileCacheAddTileResult_set_status_1"]=_emscripten_bind_TileCacheAddTileResult_set_status_1=wasmExports["Fk"];Module["_emscripten_bind_TileCacheAddTileResult_get_tileRef_0"]=_emscripten_bind_TileCacheAddTileResult_get_tileRef_0=wasmExports["Gk"];Module["_emscripten_bind_TileCacheAddTileResult_set_tileRef_1"]=_emscripten_bind_TileCacheAddTileResult_set_tileRef_1=wasmExports["Hk"];Module["_emscripten_bind_TileCacheAddTileResult___destroy___0"]=_emscripten_bind_TileCacheAddTileResult___destroy___0=wasmExports["Ik"];Module["_emscripten_bind_TileCacheUpdateResult_get_status_0"]=_emscripten_bind_TileCacheUpdateResult_get_status_0=wasmExports["Jk"];Module["_emscripten_bind_TileCacheUpdateResult_set_status_1"]=_emscripten_bind_TileCacheUpdateResult_set_status_1=wasmExports["Kk"];Module["_emscripten_bind_TileCacheUpdateResult_get_upToDate_0"]=_emscripten_bind_TileCacheUpdateResult_get_upToDate_0=wasmExports["Lk"];Module["_emscripten_bind_TileCacheUpdateResult_set_upToDate_1"]=_emscripten_bind_TileCacheUpdateResult_set_upToDate_1=wasmExports["Mk"];Module["_emscripten_bind_TileCacheUpdateResult___destroy___0"]=_emscripten_bind_TileCacheUpdateResult___destroy___0=wasmExports["Nk"];Module["_emscripten_bind_TileCacheAddObstacleResult_get_status_0"]=_emscripten_bind_TileCacheAddObstacleResult_get_status_0=wasmExports["Ok"];Module["_emscripten_bind_TileCacheAddObstacleResult_set_status_1"]=_emscripten_bind_TileCacheAddObstacleResult_set_status_1=wasmExports["Pk"];Module["_emscripten_bind_TileCacheAddObstacleResult_get_ref_0"]=_emscripten_bind_TileCacheAddObstacleResult_get_ref_0=wasmExports["Qk"];Module["_emscripten_bind_TileCacheAddObstacleResult_set_ref_1"]=_emscripten_bind_TileCacheAddObstacleResult_set_ref_1=wasmExports["Rk"];Module["_emscripten_bind_TileCacheAddObstacleResult___destroy___0"]=_emscripten_bind_TileCacheAddObstacleResult___destroy___0=wasmExports["Sk"];Module["_emscripten_bind_RecastFastLZCompressor_RecastFastLZCompressor_0"]=_emscripten_bind_RecastFastLZCompressor_RecastFastLZCompressor_0=wasmExports["Tk"];Module["_emscripten_bind_RecastFastLZCompressor___destroy___0"]=_emscripten_bind_RecastFastLZCompressor___destroy___0=wasmExports["Uk"];Module["_emscripten_bind_TileCacheMeshProcess_TileCacheMeshProcess_0"]=_emscripten_bind_TileCacheMeshProcess_TileCacheMeshProcess_0=wasmExports["Vk"];Module["_emscripten_bind_TileCacheMeshProcess_process_3"]=_emscripten_bind_TileCacheMeshProcess_process_3=wasmExports["Wk"];Module["_emscripten_bind_TileCacheMeshProcess___destroy___0"]=_emscripten_bind_TileCacheMeshProcess___destroy___0=wasmExports["Xk"];Module["_emscripten_bind_RecastLinearAllocator_RecastLinearAllocator_1"]=_emscripten_bind_RecastLinearAllocator_RecastLinearAllocator_1=wasmExports["Yk"];Module["_emscripten_bind_RecastLinearAllocator___destroy___0"]=_emscripten_bind_RecastLinearAllocator___destroy___0=wasmExports["Zk"];Module["_emscripten_bind_TileCache_TileCache_0"]=_emscripten_bind_TileCache_TileCache_0=wasmExports["_k"];Module["_emscripten_bind_TileCache_init_4"]=_emscripten_bind_TileCache_init_4=wasmExports["$k"];Module["_emscripten_bind_TileCache_addTile_2"]=_emscripten_bind_TileCache_addTile_2=wasmExports["al"];Module["_emscripten_bind_TileCache_buildNavMeshTile_2"]=_emscripten_bind_TileCache_buildNavMeshTile_2=wasmExports["bl"];Module["_emscripten_bind_TileCache_buildNavMeshTilesAt_3"]=_emscripten_bind_TileCache_buildNavMeshTilesAt_3=wasmExports["cl"];Module["_emscripten_bind_TileCache_update_1"]=_emscripten_bind_TileCache_update_1=wasmExports["dl"];Module["_emscripten_bind_TileCache_addCylinderObstacle_3"]=_emscripten_bind_TileCache_addCylinderObstacle_3=wasmExports["el"];Module["_emscripten_bind_TileCache_addBoxObstacle_3"]=_emscripten_bind_TileCache_addBoxObstacle_3=wasmExports["fl"];Module["_emscripten_bind_TileCache_removeObstacle_1"]=_emscripten_bind_TileCache_removeObstacle_1=wasmExports["gl"];Module["_emscripten_bind_TileCache_destroy_0"]=_emscripten_bind_TileCache_destroy_0=wasmExports["hl"];Module["_emscripten_bind_TileCache___destroy___0"]=_emscripten_bind_TileCache___destroy___0=wasmExports["il"];Module["_emscripten_bind_CrowdUtils_CrowdUtils_0"]=_emscripten_bind_CrowdUtils_CrowdUtils_0=wasmExports["jl"];Module["_emscripten_bind_CrowdUtils_getActiveAgentCount_1"]=_emscripten_bind_CrowdUtils_getActiveAgentCount_1=wasmExports["kl"];Module["_emscripten_bind_CrowdUtils_overOffMeshConnection_2"]=_emscripten_bind_CrowdUtils_overOffMeshConnection_2=wasmExports["ll"];Module["_emscripten_bind_CrowdUtils_agentTeleport_5"]=_emscripten_bind_CrowdUtils_agentTeleport_5=wasmExports["ml"];Module["_emscripten_bind_CrowdUtils___destroy___0"]=_emscripten_bind_CrowdUtils___destroy___0=wasmExports["nl"];Module["_emscripten_bind_Detour_Detour_0"]=_emscripten_bind_Detour_Detour_0=wasmExports["ol"];Module["_emscripten_bind_Detour_statusSucceed_1"]=_emscripten_bind_Detour_statusSucceed_1=wasmExports["pl"];Module["_emscripten_bind_Detour_statusFailed_1"]=_emscripten_bind_Detour_statusFailed_1=wasmExports["ql"];Module["_emscripten_bind_Detour_statusInProgress_1"]=_emscripten_bind_Detour_statusInProgress_1=wasmExports["rl"];Module["_emscripten_bind_Detour_statusDetail_2"]=_emscripten_bind_Detour_statusDetail_2=wasmExports["sl"];Module["_emscripten_bind_Detour_allocCrowd_0"]=_emscripten_bind_Detour_allocCrowd_0=wasmExports["tl"];Module["_emscripten_bind_Detour_freeCrowd_1"]=_emscripten_bind_Detour_freeCrowd_1=wasmExports["ul"];Module["_emscripten_bind_Detour_get_FAILURE_0"]=_emscripten_bind_Detour_get_FAILURE_0=wasmExports["vl"];Module["_emscripten_bind_Detour_get_SUCCESS_0"]=_emscripten_bind_Detour_get_SUCCESS_0=wasmExports["wl"];Module["_emscripten_bind_Detour_get_IN_PROGRESS_0"]=_emscripten_bind_Detour_get_IN_PROGRESS_0=wasmExports["xl"];Module["_emscripten_bind_Detour_get_STATUS_DETAIL_MASK_0"]=_emscripten_bind_Detour_get_STATUS_DETAIL_MASK_0=wasmExports["yl"];Module["_emscripten_bind_Detour_get_WRONG_MAGIC_0"]=_emscripten_bind_Detour_get_WRONG_MAGIC_0=wasmExports["zl"];Module["_emscripten_bind_Detour_get_WRONG_VERSION_0"]=_emscripten_bind_Detour_get_WRONG_VERSION_0=wasmExports["Al"];Module["_emscripten_bind_Detour_get_OUT_OF_MEMORY_0"]=_emscripten_bind_Detour_get_OUT_OF_MEMORY_0=wasmExports["Bl"];Module["_emscripten_bind_Detour_get_INVALID_PARAM_0"]=_emscripten_bind_Detour_get_INVALID_PARAM_0=wasmExports["Cl"];Module["_emscripten_bind_Detour_get_BUFFER_TOO_SMALL_0"]=_emscripten_bind_Detour_get_BUFFER_TOO_SMALL_0=wasmExports["Dl"];Module["_emscripten_bind_Detour_get_OUT_OF_NODES_0"]=_emscripten_bind_Detour_get_OUT_OF_NODES_0=wasmExports["El"];Module["_emscripten_bind_Detour_get_PARTIAL_RESULT_0"]=_emscripten_bind_Detour_get_PARTIAL_RESULT_0=wasmExports["Fl"];Module["_emscripten_bind_Detour_get_ALREADY_OCCUPIED_0"]=_emscripten_bind_Detour_get_ALREADY_OCCUPIED_0=wasmExports["Gl"];Module["_emscripten_bind_Detour_get_VERTS_PER_POLYGON_0"]=_emscripten_bind_Detour_get_VERTS_PER_POLYGON_0=wasmExports["Hl"];Module["_emscripten_bind_Detour_get_NAVMESH_MAGIC_0"]=_emscripten_bind_Detour_get_NAVMESH_MAGIC_0=wasmExports["Il"];Module["_emscripten_bind_Detour_get_NAVMESH_VERSION_0"]=_emscripten_bind_Detour_get_NAVMESH_VERSION_0=wasmExports["Jl"];Module["_emscripten_bind_Detour_get_NAVMESH_STATE_MAGIC_0"]=_emscripten_bind_Detour_get_NAVMESH_STATE_MAGIC_0=wasmExports["Kl"];Module["_emscripten_bind_Detour_get_NAVMESH_STATE_VERSION_0"]=_emscripten_bind_Detour_get_NAVMESH_STATE_VERSION_0=wasmExports["Ll"];Module["_emscripten_bind_Detour_get_TILECACHE_MAGIC_0"]=_emscripten_bind_Detour_get_TILECACHE_MAGIC_0=wasmExports["Ml"];Module["_emscripten_bind_Detour_get_TILECACHE_VERSION_0"]=_emscripten_bind_Detour_get_TILECACHE_VERSION_0=wasmExports["Nl"];Module["_emscripten_bind_Detour_get_TILECACHE_NULL_AREA_0"]=_emscripten_bind_Detour_get_TILECACHE_NULL_AREA_0=wasmExports["Ol"];Module["_emscripten_bind_Detour_get_TILECACHE_WALKABLE_AREA_0"]=_emscripten_bind_Detour_get_TILECACHE_WALKABLE_AREA_0=wasmExports["Pl"];Module["_emscripten_bind_Detour_get_TILECACHE_NULL_IDX_0"]=_emscripten_bind_Detour_get_TILECACHE_NULL_IDX_0=wasmExports["Ql"];Module["_emscripten_bind_Detour_get_NULL_LINK_0"]=_emscripten_bind_Detour_get_NULL_LINK_0=wasmExports["Rl"];Module["_emscripten_bind_Detour_get_EXT_LINK_0"]=_emscripten_bind_Detour_get_EXT_LINK_0=wasmExports["Sl"];Module["_emscripten_bind_Detour_get_OFFMESH_CON_BIDIR_0"]=_emscripten_bind_Detour_get_OFFMESH_CON_BIDIR_0=wasmExports["Tl"];Module["_emscripten_bind_Detour___destroy___0"]=_emscripten_bind_Detour___destroy___0=wasmExports["Ul"];Module["_emscripten_bind_dtPathCorridor_init_1"]=_emscripten_bind_dtPathCorridor_init_1=wasmExports["Vl"];Module["_emscripten_bind_dtPathCorridor_reset_2"]=_emscripten_bind_dtPathCorridor_reset_2=wasmExports["Wl"];Module["_emscripten_bind_dtPathCorridor___destroy___0"]=_emscripten_bind_dtPathCorridor___destroy___0=wasmExports["Xl"];Module["_emscripten_bind_dtLocalBoundary_reset_0"]=_emscripten_bind_dtLocalBoundary_reset_0=wasmExports["Yl"];Module["_emscripten_bind_dtLocalBoundary___destroy___0"]=_emscripten_bind_dtLocalBoundary___destroy___0=wasmExports["Zl"];Module["_emscripten_bind_dtCrowdNeighbour_dtCrowdNeighbour_0"]=_emscripten_bind_dtCrowdNeighbour_dtCrowdNeighbour_0=wasmExports["_l"];Module["_emscripten_bind_dtCrowdNeighbour_get_idx_0"]=_emscripten_bind_dtCrowdNeighbour_get_idx_0=wasmExports["$l"];Module["_emscripten_bind_dtCrowdNeighbour_set_idx_1"]=_emscripten_bind_dtCrowdNeighbour_set_idx_1=wasmExports["am"];Module["_emscripten_bind_dtCrowdNeighbour_get_dist_0"]=_emscripten_bind_dtCrowdNeighbour_get_dist_0=wasmExports["bm"];Module["_emscripten_bind_dtCrowdNeighbour_set_dist_1"]=_emscripten_bind_dtCrowdNeighbour_set_dist_1=wasmExports["cm"];Module["_emscripten_bind_dtCrowdNeighbour___destroy___0"]=_emscripten_bind_dtCrowdNeighbour___destroy___0=wasmExports["dm"];Module["_emscripten_bind_dtCrowdAgent_dtCrowdAgent_0"]=_emscripten_bind_dtCrowdAgent_dtCrowdAgent_0=wasmExports["em"];Module["_emscripten_bind_dtCrowdAgent_get_active_0"]=_emscripten_bind_dtCrowdAgent_get_active_0=wasmExports["fm"];Module["_emscripten_bind_dtCrowdAgent_set_active_1"]=_emscripten_bind_dtCrowdAgent_set_active_1=wasmExports["gm"];Module["_emscripten_bind_dtCrowdAgent_get_state_0"]=_emscripten_bind_dtCrowdAgent_get_state_0=wasmExports["hm"];Module["_emscripten_bind_dtCrowdAgent_set_state_1"]=_emscripten_bind_dtCrowdAgent_set_state_1=wasmExports["im"];Module["_emscripten_bind_dtCrowdAgent_get_corridor_0"]=_emscripten_bind_dtCrowdAgent_get_corridor_0=wasmExports["jm"];Module["_emscripten_bind_dtCrowdAgent_get_boundary_0"]=_emscripten_bind_dtCrowdAgent_get_boundary_0=wasmExports["km"];Module["_emscripten_bind_dtCrowdAgent_get_topologyOptTime_0"]=_emscripten_bind_dtCrowdAgent_get_topologyOptTime_0=wasmExports["lm"];Module["_emscripten_bind_dtCrowdAgent_set_topologyOptTime_1"]=_emscripten_bind_dtCrowdAgent_set_topologyOptTime_1=wasmExports["mm"];Module["_emscripten_bind_dtCrowdAgent_get_neis_1"]=_emscripten_bind_dtCrowdAgent_get_neis_1=wasmExports["nm"];Module["_emscripten_bind_dtCrowdAgent_set_neis_2"]=_emscripten_bind_dtCrowdAgent_set_neis_2=wasmExports["om"];Module["_emscripten_bind_dtCrowdAgent_get_nneis_0"]=_emscripten_bind_dtCrowdAgent_get_nneis_0=wasmExports["pm"];Module["_emscripten_bind_dtCrowdAgent_set_nneis_1"]=_emscripten_bind_dtCrowdAgent_set_nneis_1=wasmExports["qm"];Module["_emscripten_bind_dtCrowdAgent_get_desiredSpeed_0"]=_emscripten_bind_dtCrowdAgent_get_desiredSpeed_0=wasmExports["rm"];Module["_emscripten_bind_dtCrowdAgent_set_desiredSpeed_1"]=_emscripten_bind_dtCrowdAgent_set_desiredSpeed_1=wasmExports["sm"];Module["_emscripten_bind_dtCrowdAgent_get_npos_1"]=_emscripten_bind_dtCrowdAgent_get_npos_1=wasmExports["tm"];Module["_emscripten_bind_dtCrowdAgent_set_npos_2"]=_emscripten_bind_dtCrowdAgent_set_npos_2=wasmExports["um"];Module["_emscripten_bind_dtCrowdAgent_get_disp_1"]=_emscripten_bind_dtCrowdAgent_get_disp_1=wasmExports["vm"];Module["_emscripten_bind_dtCrowdAgent_set_disp_2"]=_emscripten_bind_dtCrowdAgent_set_disp_2=wasmExports["wm"];Module["_emscripten_bind_dtCrowdAgent_get_dvel_1"]=_emscripten_bind_dtCrowdAgent_get_dvel_1=wasmExports["xm"];Module["_emscripten_bind_dtCrowdAgent_set_dvel_2"]=_emscripten_bind_dtCrowdAgent_set_dvel_2=wasmExports["ym"];Module["_emscripten_bind_dtCrowdAgent_get_nvel_1"]=_emscripten_bind_dtCrowdAgent_get_nvel_1=wasmExports["zm"];Module["_emscripten_bind_dtCrowdAgent_set_nvel_2"]=_emscripten_bind_dtCrowdAgent_set_nvel_2=wasmExports["Am"];Module["_emscripten_bind_dtCrowdAgent_get_vel_1"]=_emscripten_bind_dtCrowdAgent_get_vel_1=wasmExports["Bm"];Module["_emscripten_bind_dtCrowdAgent_set_vel_2"]=_emscripten_bind_dtCrowdAgent_set_vel_2=wasmExports["Cm"];Module["_emscripten_bind_dtCrowdAgent_get_params_0"]=_emscripten_bind_dtCrowdAgent_get_params_0=wasmExports["Dm"];Module["_emscripten_bind_dtCrowdAgent_set_params_1"]=_emscripten_bind_dtCrowdAgent_set_params_1=wasmExports["Em"];Module["_emscripten_bind_dtCrowdAgent_get_cornerVerts_1"]=_emscripten_bind_dtCrowdAgent_get_cornerVerts_1=wasmExports["Fm"];Module["_emscripten_bind_dtCrowdAgent_set_cornerVerts_2"]=_emscripten_bind_dtCrowdAgent_set_cornerVerts_2=wasmExports["Gm"];Module["_emscripten_bind_dtCrowdAgent_get_cornerFlags_1"]=_emscripten_bind_dtCrowdAgent_get_cornerFlags_1=wasmExports["Hm"];Module["_emscripten_bind_dtCrowdAgent_set_cornerFlags_2"]=_emscripten_bind_dtCrowdAgent_set_cornerFlags_2=wasmExports["Im"];Module["_emscripten_bind_dtCrowdAgent_get_ncorners_0"]=_emscripten_bind_dtCrowdAgent_get_ncorners_0=wasmExports["Jm"];Module["_emscripten_bind_dtCrowdAgent_set_ncorners_1"]=_emscripten_bind_dtCrowdAgent_set_ncorners_1=wasmExports["Km"];Module["_emscripten_bind_dtCrowdAgent_get_targetState_0"]=_emscripten_bind_dtCrowdAgent_get_targetState_0=wasmExports["Lm"];Module["_emscripten_bind_dtCrowdAgent_set_targetState_1"]=_emscripten_bind_dtCrowdAgent_set_targetState_1=wasmExports["Mm"];Module["_emscripten_bind_dtCrowdAgent_get_targetRef_0"]=_emscripten_bind_dtCrowdAgent_get_targetRef_0=wasmExports["Nm"];Module["_emscripten_bind_dtCrowdAgent_set_targetRef_1"]=_emscripten_bind_dtCrowdAgent_set_targetRef_1=wasmExports["Om"];Module["_emscripten_bind_dtCrowdAgent_get_targetPos_1"]=_emscripten_bind_dtCrowdAgent_get_targetPos_1=wasmExports["Pm"];Module["_emscripten_bind_dtCrowdAgent_set_targetPos_2"]=_emscripten_bind_dtCrowdAgent_set_targetPos_2=wasmExports["Qm"];Module["_emscripten_bind_dtCrowdAgent_get_targetPathqRef_0"]=_emscripten_bind_dtCrowdAgent_get_targetPathqRef_0=wasmExports["Rm"];Module["_emscripten_bind_dtCrowdAgent_set_targetPathqRef_1"]=_emscripten_bind_dtCrowdAgent_set_targetPathqRef_1=wasmExports["Sm"];Module["_emscripten_bind_dtCrowdAgent_get_targetReplan_0"]=_emscripten_bind_dtCrowdAgent_get_targetReplan_0=wasmExports["Tm"];Module["_emscripten_bind_dtCrowdAgent_set_targetReplan_1"]=_emscripten_bind_dtCrowdAgent_set_targetReplan_1=wasmExports["Um"];Module["_emscripten_bind_dtCrowdAgent_get_targetReplanTime_0"]=_emscripten_bind_dtCrowdAgent_get_targetReplanTime_0=wasmExports["Vm"];Module["_emscripten_bind_dtCrowdAgent_set_targetReplanTime_1"]=_emscripten_bind_dtCrowdAgent_set_targetReplanTime_1=wasmExports["Wm"];Module["_emscripten_bind_dtCrowdAgent___destroy___0"]=_emscripten_bind_dtCrowdAgent___destroy___0=wasmExports["Xm"];Module["_emscripten_bind_dtObstacleAvoidanceParams_dtObstacleAvoidanceParams_0"]=_emscripten_bind_dtObstacleAvoidanceParams_dtObstacleAvoidanceParams_0=wasmExports["Ym"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_velBias_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_velBias_0=wasmExports["Zm"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_velBias_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_velBias_1=wasmExports["_m"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightDesVel_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightDesVel_0=wasmExports["$m"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightDesVel_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightDesVel_1=wasmExports["an"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightCurVel_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightCurVel_0=wasmExports["bn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightCurVel_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightCurVel_1=wasmExports["cn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightSide_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightSide_0=wasmExports["dn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightSide_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightSide_1=wasmExports["en"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_weightToi_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_weightToi_0=wasmExports["fn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_weightToi_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_weightToi_1=wasmExports["gn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_horizTime_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_horizTime_0=wasmExports["hn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_horizTime_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_horizTime_1=wasmExports["jn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_gridSize_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_gridSize_0=wasmExports["kn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_gridSize_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_gridSize_1=wasmExports["ln"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDivs_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDivs_0=wasmExports["mn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDivs_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDivs_1=wasmExports["nn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveRings_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveRings_0=wasmExports["on"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveRings_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveRings_1=wasmExports["pn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDepth_0"]=_emscripten_bind_dtObstacleAvoidanceParams_get_adaptiveDepth_0=wasmExports["qn"];Module["_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDepth_1"]=_emscripten_bind_dtObstacleAvoidanceParams_set_adaptiveDepth_1=wasmExports["rn"];Module["_emscripten_bind_dtObstacleAvoidanceParams___destroy___0"]=_emscripten_bind_dtObstacleAvoidanceParams___destroy___0=wasmExports["sn"];Module["_emscripten_bind_dtObstacleAvoidanceDebugData___destroy___0"]=_emscripten_bind_dtObstacleAvoidanceDebugData___destroy___0=wasmExports["tn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_dtCrowdAgentDebugInfo_0"]=_emscripten_bind_dtCrowdAgentDebugInfo_dtCrowdAgentDebugInfo_0=wasmExports["un"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_idx_0"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_idx_0=wasmExports["vn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_idx_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_idx_1=wasmExports["wn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_optStart_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_optStart_1=wasmExports["xn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_optStart_2"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_optStart_2=wasmExports["yn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_optEnd_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_optEnd_1=wasmExports["zn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_optEnd_2"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_optEnd_2=wasmExports["An"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_get_vod_0"]=_emscripten_bind_dtCrowdAgentDebugInfo_get_vod_0=wasmExports["Bn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo_set_vod_1"]=_emscripten_bind_dtCrowdAgentDebugInfo_set_vod_1=wasmExports["Cn"];Module["_emscripten_bind_dtCrowdAgentDebugInfo___destroy___0"]=_emscripten_bind_dtCrowdAgentDebugInfo___destroy___0=wasmExports["Dn"];Module["_emscripten_bind_dtQueryFilter_dtQueryFilter_0"]=_emscripten_bind_dtQueryFilter_dtQueryFilter_0=wasmExports["En"];Module["_emscripten_bind_dtQueryFilter_getAreaCost_1"]=_emscripten_bind_dtQueryFilter_getAreaCost_1=wasmExports["Fn"];Module["_emscripten_bind_dtQueryFilter_setAreaCost_2"]=_emscripten_bind_dtQueryFilter_setAreaCost_2=wasmExports["Gn"];Module["_emscripten_bind_dtQueryFilter_getIncludeFlags_0"]=_emscripten_bind_dtQueryFilter_getIncludeFlags_0=wasmExports["Hn"];Module["_emscripten_bind_dtQueryFilter_setIncludeFlags_1"]=_emscripten_bind_dtQueryFilter_setIncludeFlags_1=wasmExports["In"];Module["_emscripten_bind_dtQueryFilter_getExcludeFlags_0"]=_emscripten_bind_dtQueryFilter_getExcludeFlags_0=wasmExports["Jn"];Module["_emscripten_bind_dtQueryFilter_setExcludeFlags_1"]=_emscripten_bind_dtQueryFilter_setExcludeFlags_1=wasmExports["Kn"];Module["_emscripten_bind_dtQueryFilter___destroy___0"]=_emscripten_bind_dtQueryFilter___destroy___0=wasmExports["Ln"];Module["_emscripten_bind_dtNavMeshQuery_getAttachedNavMesh_0"]=_emscripten_bind_dtNavMeshQuery_getAttachedNavMesh_0=wasmExports["Mn"];Module["_emscripten_bind_dtNavMeshQuery___destroy___0"]=_emscripten_bind_dtNavMeshQuery___destroy___0=wasmExports["Nn"];Module["_emscripten_bind_dtCrowd_dtCrowd_0"]=_emscripten_bind_dtCrowd_dtCrowd_0=wasmExports["On"];Module["_emscripten_bind_dtCrowd_init_3"]=_emscripten_bind_dtCrowd_init_3=wasmExports["Pn"];Module["_emscripten_bind_dtCrowd_setObstacleAvoidanceParams_2"]=_emscripten_bind_dtCrowd_setObstacleAvoidanceParams_2=wasmExports["Qn"];Module["_emscripten_bind_dtCrowd_getObstacleAvoidanceParams_1"]=_emscripten_bind_dtCrowd_getObstacleAvoidanceParams_1=wasmExports["Rn"];Module["_emscripten_bind_dtCrowd_getAgent_1"]=_emscripten_bind_dtCrowd_getAgent_1=wasmExports["Sn"];Module["_emscripten_bind_dtCrowd_getEditableAgent_1"]=_emscripten_bind_dtCrowd_getEditableAgent_1=wasmExports["Tn"];Module["_emscripten_bind_dtCrowd_getAgentCount_0"]=_emscripten_bind_dtCrowd_getAgentCount_0=wasmExports["Un"];Module["_emscripten_bind_dtCrowd_addAgent_2"]=_emscripten_bind_dtCrowd_addAgent_2=wasmExports["Vn"];Module["_emscripten_bind_dtCrowd_updateAgentParameters_2"]=_emscripten_bind_dtCrowd_updateAgentParameters_2=wasmExports["Wn"];Module["_emscripten_bind_dtCrowd_removeAgent_1"]=_emscripten_bind_dtCrowd_removeAgent_1=wasmExports["Xn"];Module["_emscripten_bind_dtCrowd_requestMoveTarget_3"]=_emscripten_bind_dtCrowd_requestMoveTarget_3=wasmExports["Yn"];Module["_emscripten_bind_dtCrowd_requestMoveVelocity_2"]=_emscripten_bind_dtCrowd_requestMoveVelocity_2=wasmExports["Zn"];Module["_emscripten_bind_dtCrowd_resetMoveTarget_1"]=_emscripten_bind_dtCrowd_resetMoveTarget_1=wasmExports["_n"];Module["_emscripten_bind_dtCrowd_update_2"]=_emscripten_bind_dtCrowd_update_2=wasmExports["$n"];Module["_emscripten_bind_dtCrowd_getFilter_1"]=_emscripten_bind_dtCrowd_getFilter_1=wasmExports["ao"];Module["_emscripten_bind_dtCrowd_getEditableFilter_1"]=_emscripten_bind_dtCrowd_getEditableFilter_1=wasmExports["bo"];Module["_emscripten_bind_dtCrowd_getNavMeshQuery_0"]=_emscripten_bind_dtCrowd_getNavMeshQuery_0=wasmExports["co"];Module["_emscripten_bind_dtCrowd___destroy___0"]=_emscripten_bind_dtCrowd___destroy___0=wasmExports["eo"];Module["_emscripten_bind_RecastBuildContextJsImpl_RecastBuildContextJsImpl_0"]=_emscripten_bind_RecastBuildContextJsImpl_RecastBuildContextJsImpl_0=wasmExports["fo"];Module["_emscripten_bind_RecastBuildContextJsImpl_resetLog_0"]=_emscripten_bind_RecastBuildContextJsImpl_resetLog_0=wasmExports["go"];Module["_emscripten_bind_RecastBuildContextJsImpl_log_3"]=_emscripten_bind_RecastBuildContextJsImpl_log_3=wasmExports["ho"];Module["_emscripten_bind_RecastBuildContextJsImpl_resetTimers_0"]=_emscripten_bind_RecastBuildContextJsImpl_resetTimers_0=wasmExports["io"];Module["_emscripten_bind_RecastBuildContextJsImpl_startTimer_1"]=_emscripten_bind_RecastBuildContextJsImpl_startTimer_1=wasmExports["jo"];Module["_emscripten_bind_RecastBuildContextJsImpl_stopTimer_1"]=_emscripten_bind_RecastBuildContextJsImpl_stopTimer_1=wasmExports["ko"];Module["_emscripten_bind_RecastBuildContextJsImpl_getAccumulatedTime_1"]=_emscripten_bind_RecastBuildContextJsImpl_getAccumulatedTime_1=wasmExports["lo"];Module["_emscripten_bind_RecastBuildContextJsImpl___destroy___0"]=_emscripten_bind_RecastBuildContextJsImpl___destroy___0=wasmExports["mo"];Module["_emscripten_bind_RecastBuildContext_RecastBuildContext_1"]=_emscripten_bind_RecastBuildContext_RecastBuildContext_1=wasmExports["no"];Module["_emscripten_bind_RecastBuildContext_enableLog_1"]=_emscripten_bind_RecastBuildContext_enableLog_1=wasmExports["oo"];Module["_emscripten_bind_RecastBuildContext_resetLog_0"]=_emscripten_bind_RecastBuildContext_resetLog_0=wasmExports["po"];Module["_emscripten_bind_RecastBuildContext_log_2"]=_emscripten_bind_RecastBuildContext_log_2=wasmExports["qo"];Module["_emscripten_bind_RecastBuildContext_enableTimer_1"]=_emscripten_bind_RecastBuildContext_enableTimer_1=wasmExports["ro"];Module["_emscripten_bind_RecastBuildContext_resetTimers_0"]=_emscripten_bind_RecastBuildContext_resetTimers_0=wasmExports["so"];Module["_emscripten_bind_RecastBuildContext_startTimer_1"]=_emscripten_bind_RecastBuildContext_startTimer_1=wasmExports["to"];Module["_emscripten_bind_RecastBuildContext_stopTimer_1"]=_emscripten_bind_RecastBuildContext_stopTimer_1=wasmExports["uo"];Module["_emscripten_bind_RecastBuildContext_getAccumulatedTime_1"]=_emscripten_bind_RecastBuildContext_getAccumulatedTime_1=wasmExports["vo"];Module["_emscripten_bind_RecastBuildContext_logEnabled_0"]=_emscripten_bind_RecastBuildContext_logEnabled_0=wasmExports["wo"];Module["_emscripten_bind_RecastBuildContext_timerEnabled_0"]=_emscripten_bind_RecastBuildContext_timerEnabled_0=wasmExports["xo"];Module["_emscripten_bind_RecastBuildContext___destroy___0"]=_emscripten_bind_RecastBuildContext___destroy___0=wasmExports["yo"];Module["_emscripten_bind_RecastCalcBoundsResult_get_bmin_1"]=_emscripten_bind_RecastCalcBoundsResult_get_bmin_1=wasmExports["zo"];Module["_emscripten_bind_RecastCalcBoundsResult_set_bmin_2"]=_emscripten_bind_RecastCalcBoundsResult_set_bmin_2=wasmExports["Ao"];Module["_emscripten_bind_RecastCalcBoundsResult_get_bmax_1"]=_emscripten_bind_RecastCalcBoundsResult_get_bmax_1=wasmExports["Bo"];Module["_emscripten_bind_RecastCalcBoundsResult_set_bmax_2"]=_emscripten_bind_RecastCalcBoundsResult_set_bmax_2=wasmExports["Co"];Module["_emscripten_bind_RecastCalcBoundsResult___destroy___0"]=_emscripten_bind_RecastCalcBoundsResult___destroy___0=wasmExports["Do"];Module["_emscripten_bind_RecastCalcGridSizeResult_get_width_0"]=_emscripten_bind_RecastCalcGridSizeResult_get_width_0=wasmExports["Eo"];Module["_emscripten_bind_RecastCalcGridSizeResult_set_width_1"]=_emscripten_bind_RecastCalcGridSizeResult_set_width_1=wasmExports["Fo"];Module["_emscripten_bind_RecastCalcGridSizeResult_get_height_0"]=_emscripten_bind_RecastCalcGridSizeResult_get_height_0=wasmExports["Go"];Module["_emscripten_bind_RecastCalcGridSizeResult_set_height_1"]=_emscripten_bind_RecastCalcGridSizeResult_set_height_1=wasmExports["Ho"];Module["_emscripten_bind_RecastCalcGridSizeResult___destroy___0"]=_emscripten_bind_RecastCalcGridSizeResult___destroy___0=wasmExports["Io"];Module["_emscripten_bind_Recast_Recast_0"]=_emscripten_bind_Recast_Recast_0=wasmExports["Jo"];Module["_emscripten_bind_Recast_calcBounds_2"]=_emscripten_bind_Recast_calcBounds_2=wasmExports["Ko"];Module["_emscripten_bind_Recast_calcGridSize_3"]=_emscripten_bind_Recast_calcGridSize_3=wasmExports["Lo"];Module["_emscripten_bind_Recast_createHeightfield_8"]=_emscripten_bind_Recast_createHeightfield_8=wasmExports["Mo"];Module["_emscripten_bind_Recast_markWalkableTriangles_7"]=_emscripten_bind_Recast_markWalkableTriangles_7=wasmExports["No"];Module["_emscripten_bind_Recast_clearUnwalkableTriangles_7"]=_emscripten_bind_Recast_clearUnwalkableTriangles_7=wasmExports["Oo"];Module["_emscripten_bind_Recast_rasterizeTriangles_8"]=_emscripten_bind_Recast_rasterizeTriangles_8=wasmExports["Po"];Module["_emscripten_bind_Recast_filterLowHangingWalkableObstacles_3"]=_emscripten_bind_Recast_filterLowHangingWalkableObstacles_3=wasmExports["Qo"];Module["_emscripten_bind_Recast_filterLedgeSpans_4"]=_emscripten_bind_Recast_filterLedgeSpans_4=wasmExports["Ro"];Module["_emscripten_bind_Recast_filterWalkableLowHeightSpans_3"]=_emscripten_bind_Recast_filterWalkableLowHeightSpans_3=wasmExports["So"];Module["_emscripten_bind_Recast_getHeightFieldSpanCount_2"]=_emscripten_bind_Recast_getHeightFieldSpanCount_2=wasmExports["To"];Module["_emscripten_bind_Recast_buildCompactHeightfield_5"]=_emscripten_bind_Recast_buildCompactHeightfield_5=wasmExports["Uo"];Module["_emscripten_bind_Recast_erodeWalkableArea_3"]=_emscripten_bind_Recast_erodeWalkableArea_3=wasmExports["Vo"];Module["_emscripten_bind_Recast_medianFilterWalkableArea_2"]=_emscripten_bind_Recast_medianFilterWalkableArea_2=wasmExports["Wo"];Module["_emscripten_bind_Recast_markBoxArea_5"]=_emscripten_bind_Recast_markBoxArea_5=wasmExports["Xo"];Module["_emscripten_bind_Recast_markConvexPolyArea_7"]=_emscripten_bind_Recast_markConvexPolyArea_7=wasmExports["Yo"];Module["_emscripten_bind_Recast_markCylinderArea_6"]=_emscripten_bind_Recast_markCylinderArea_6=wasmExports["Zo"];Module["_emscripten_bind_Recast_buildDistanceField_2"]=_emscripten_bind_Recast_buildDistanceField_2=wasmExports["_o"];Module["_emscripten_bind_Recast_buildRegions_5"]=_emscripten_bind_Recast_buildRegions_5=wasmExports["$o"];Module["_emscripten_bind_Recast_buildLayerRegions_4"]=_emscripten_bind_Recast_buildLayerRegions_4=wasmExports["ap"];Module["_emscripten_bind_Recast_buildRegionsMonotone_5"]=_emscripten_bind_Recast_buildRegionsMonotone_5=wasmExports["bp"];Module["_emscripten_bind_Recast_setCon_3"]=_emscripten_bind_Recast_setCon_3=wasmExports["cp"];Module["_emscripten_bind_Recast_getCon_2"]=_emscripten_bind_Recast_getCon_2=wasmExports["dp"];Module["_emscripten_bind_Recast_getDirOffsetX_1"]=_emscripten_bind_Recast_getDirOffsetX_1=wasmExports["ep"];Module["_emscripten_bind_Recast_getDirOffsetY_1"]=_emscripten_bind_Recast_getDirOffsetY_1=wasmExports["fp"];Module["_emscripten_bind_Recast_getDirForOffset_2"]=_emscripten_bind_Recast_getDirForOffset_2=wasmExports["gp"];Module["_emscripten_bind_Recast_buildHeightfieldLayers_5"]=_emscripten_bind_Recast_buildHeightfieldLayers_5=wasmExports["hp"];Module["_emscripten_bind_Recast_buildContours_6"]=_emscripten_bind_Recast_buildContours_6=wasmExports["ip"];Module["_emscripten_bind_Recast_buildPolyMesh_4"]=_emscripten_bind_Recast_buildPolyMesh_4=wasmExports["jp"];Module["_emscripten_bind_Recast_mergePolyMeshes_4"]=_emscripten_bind_Recast_mergePolyMeshes_4=wasmExports["kp"];Module["_emscripten_bind_Recast_buildPolyMeshDetail_6"]=_emscripten_bind_Recast_buildPolyMeshDetail_6=wasmExports["lp"];Module["_emscripten_bind_Recast_copyPolyMesh_3"]=_emscripten_bind_Recast_copyPolyMesh_3=wasmExports["mp"];Module["_emscripten_bind_Recast_mergePolyMeshDetails_4"]=_emscripten_bind_Recast_mergePolyMeshDetails_4=wasmExports["np"];Module["_emscripten_bind_Recast_getHeightfieldLayerHeights_1"]=_emscripten_bind_Recast_getHeightfieldLayerHeights_1=wasmExports["op"];Module["_emscripten_bind_Recast_getHeightfieldLayerAreas_1"]=_emscripten_bind_Recast_getHeightfieldLayerAreas_1=wasmExports["pp"];Module["_emscripten_bind_Recast_getHeightfieldLayerCons_1"]=_emscripten_bind_Recast_getHeightfieldLayerCons_1=wasmExports["qp"];Module["_emscripten_bind_Recast_allocHeightfield_0"]=_emscripten_bind_Recast_allocHeightfield_0=wasmExports["rp"];Module["_emscripten_bind_Recast_freeHeightfield_1"]=_emscripten_bind_Recast_freeHeightfield_1=wasmExports["sp"];Module["_emscripten_bind_Recast_allocCompactHeightfield_0"]=_emscripten_bind_Recast_allocCompactHeightfield_0=wasmExports["tp"];Module["_emscripten_bind_Recast_freeCompactHeightfield_1"]=_emscripten_bind_Recast_freeCompactHeightfield_1=wasmExports["up"];Module["_emscripten_bind_Recast_allocHeightfieldLayerSet_0"]=_emscripten_bind_Recast_allocHeightfieldLayerSet_0=wasmExports["vp"];Module["_emscripten_bind_Recast_freeHeightfieldLayerSet_1"]=_emscripten_bind_Recast_freeHeightfieldLayerSet_1=wasmExports["wp"];Module["_emscripten_bind_Recast_allocContourSet_0"]=_emscripten_bind_Recast_allocContourSet_0=wasmExports["xp"];Module["_emscripten_bind_Recast_freeContourSet_1"]=_emscripten_bind_Recast_freeContourSet_1=wasmExports["yp"];Module["_emscripten_bind_Recast_allocPolyMesh_0"]=_emscripten_bind_Recast_allocPolyMesh_0=wasmExports["zp"];Module["_emscripten_bind_Recast_freePolyMesh_1"]=_emscripten_bind_Recast_freePolyMesh_1=wasmExports["Ap"];Module["_emscripten_bind_Recast_allocPolyMeshDetail_0"]=_emscripten_bind_Recast_allocPolyMeshDetail_0=wasmExports["Bp"];Module["_emscripten_bind_Recast_freePolyMeshDetail_1"]=_emscripten_bind_Recast_freePolyMeshDetail_1=wasmExports["Cp"];Module["_emscripten_bind_Recast_get_BORDER_REG_0"]=_emscripten_bind_Recast_get_BORDER_REG_0=wasmExports["Dp"];Module["_emscripten_bind_Recast_set_BORDER_REG_1"]=_emscripten_bind_Recast_set_BORDER_REG_1=wasmExports["Ep"];Module["_emscripten_bind_Recast_get_MULTIPLE_REGS_0"]=_emscripten_bind_Recast_get_MULTIPLE_REGS_0=wasmExports["Fp"];Module["_emscripten_bind_Recast_set_MULTIPLE_REGS_1"]=_emscripten_bind_Recast_set_MULTIPLE_REGS_1=wasmExports["Gp"];Module["_emscripten_bind_Recast_get_BORDER_VERTEX_0"]=_emscripten_bind_Recast_get_BORDER_VERTEX_0=wasmExports["Hp"];Module["_emscripten_bind_Recast_set_BORDER_VERTEX_1"]=_emscripten_bind_Recast_set_BORDER_VERTEX_1=wasmExports["Ip"];Module["_emscripten_bind_Recast_get_AREA_BORDER_0"]=_emscripten_bind_Recast_get_AREA_BORDER_0=wasmExports["Jp"];Module["_emscripten_bind_Recast_set_AREA_BORDER_1"]=_emscripten_bind_Recast_set_AREA_BORDER_1=wasmExports["Kp"];Module["_emscripten_bind_Recast_get_CONTOUR_REG_MASK_0"]=_emscripten_bind_Recast_get_CONTOUR_REG_MASK_0=wasmExports["Lp"];Module["_emscripten_bind_Recast_set_CONTOUR_REG_MASK_1"]=_emscripten_bind_Recast_set_CONTOUR_REG_MASK_1=wasmExports["Mp"];Module["_emscripten_bind_Recast_get_MESH_NULL_IDX_0"]=_emscripten_bind_Recast_get_MESH_NULL_IDX_0=wasmExports["Np"];Module["_emscripten_bind_Recast_set_MESH_NULL_IDX_1"]=_emscripten_bind_Recast_set_MESH_NULL_IDX_1=wasmExports["Op"];Module["_emscripten_bind_Recast_get_NULL_AREA_0"]=_emscripten_bind_Recast_get_NULL_AREA_0=wasmExports["Pp"];Module["_emscripten_bind_Recast_set_NULL_AREA_1"]=_emscripten_bind_Recast_set_NULL_AREA_1=wasmExports["Qp"];Module["_emscripten_bind_Recast_get_WALKABLE_AREA_0"]=_emscripten_bind_Recast_get_WALKABLE_AREA_0=wasmExports["Rp"];Module["_emscripten_bind_Recast_set_WALKABLE_AREA_1"]=_emscripten_bind_Recast_set_WALKABLE_AREA_1=wasmExports["Sp"];Module["_emscripten_bind_Recast_get_NOT_CONNECTED_0"]=_emscripten_bind_Recast_get_NOT_CONNECTED_0=wasmExports["Tp"];Module["_emscripten_bind_Recast_set_NOT_CONNECTED_1"]=_emscripten_bind_Recast_set_NOT_CONNECTED_1=wasmExports["Up"];Module["_emscripten_bind_Recast___destroy___0"]=_emscripten_bind_Recast___destroy___0=wasmExports["Vp"];Module["_emscripten_bind_CreateNavMeshDataResult_get_success_0"]=_emscripten_bind_CreateNavMeshDataResult_get_success_0=wasmExports["Wp"];Module["_emscripten_bind_CreateNavMeshDataResult_set_success_1"]=_emscripten_bind_CreateNavMeshDataResult_set_success_1=wasmExports["Xp"];Module["_emscripten_bind_CreateNavMeshDataResult_get_navMeshData_0"]=_emscripten_bind_CreateNavMeshDataResult_get_navMeshData_0=wasmExports["Yp"];Module["_emscripten_bind_CreateNavMeshDataResult_set_navMeshData_1"]=_emscripten_bind_CreateNavMeshDataResult_set_navMeshData_1=wasmExports["Zp"];Module["_emscripten_bind_CreateNavMeshDataResult___destroy___0"]=_emscripten_bind_CreateNavMeshDataResult___destroy___0=wasmExports["_p"];Module["_emscripten_bind_DetourNavMeshBuilder_DetourNavMeshBuilder_0"]=_emscripten_bind_DetourNavMeshBuilder_DetourNavMeshBuilder_0=wasmExports["$p"];Module["_emscripten_bind_DetourNavMeshBuilder_setPolyMeshCreateParams_2"]=_emscripten_bind_DetourNavMeshBuilder_setPolyMeshCreateParams_2=wasmExports["aq"];Module["_emscripten_bind_DetourNavMeshBuilder_setPolyMeshDetailCreateParams_2"]=_emscripten_bind_DetourNavMeshBuilder_setPolyMeshDetailCreateParams_2=wasmExports["bq"];Module["_emscripten_bind_DetourNavMeshBuilder_setOffMeshConnections_8"]=_emscripten_bind_DetourNavMeshBuilder_setOffMeshConnections_8=wasmExports["cq"];Module["_emscripten_bind_DetourNavMeshBuilder_createNavMeshData_1"]=_emscripten_bind_DetourNavMeshBuilder_createNavMeshData_1=wasmExports["dq"];Module["_emscripten_bind_DetourNavMeshBuilder___destroy___0"]=_emscripten_bind_DetourNavMeshBuilder___destroy___0=wasmExports["eq"];Module["_emscripten_bind_dtTileCacheLayer___destroy___0"]=_emscripten_bind_dtTileCacheLayer___destroy___0=wasmExports["fq"];Module["_emscripten_bind_dtTileCacheContourSet___destroy___0"]=_emscripten_bind_dtTileCacheContourSet___destroy___0=wasmExports["gq"];Module["_emscripten_bind_dtTileCachePolyMesh___destroy___0"]=_emscripten_bind_dtTileCachePolyMesh___destroy___0=wasmExports["hq"];Module["_emscripten_bind_dtTileCacheLayerHeader_dtTileCacheLayerHeader_0"]=_emscripten_bind_dtTileCacheLayerHeader_dtTileCacheLayerHeader_0=wasmExports["iq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_magic_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_magic_0=wasmExports["jq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_magic_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_magic_1=wasmExports["kq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_version_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_version_0=wasmExports["lq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_version_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_version_1=wasmExports["mq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_tx_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_tx_0=wasmExports["nq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_tx_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_tx_1=wasmExports["oq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_ty_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_ty_0=wasmExports["pq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_ty_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_ty_1=wasmExports["qq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_tlayer_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_tlayer_0=wasmExports["rq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_tlayer_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_tlayer_1=wasmExports["sq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_bmin_1"]=_emscripten_bind_dtTileCacheLayerHeader_get_bmin_1=wasmExports["tq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_bmin_2"]=_emscripten_bind_dtTileCacheLayerHeader_set_bmin_2=wasmExports["uq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_bmax_1"]=_emscripten_bind_dtTileCacheLayerHeader_get_bmax_1=wasmExports["vq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_bmax_2"]=_emscripten_bind_dtTileCacheLayerHeader_set_bmax_2=wasmExports["wq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_hmin_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_hmin_0=wasmExports["xq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_hmin_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_hmin_1=wasmExports["yq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_hmax_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_hmax_0=wasmExports["zq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_hmax_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_hmax_1=wasmExports["Aq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_width_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_width_0=wasmExports["Bq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_width_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_width_1=wasmExports["Cq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_height_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_height_0=wasmExports["Dq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_height_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_height_1=wasmExports["Eq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_minx_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_minx_0=wasmExports["Fq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_minx_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_minx_1=wasmExports["Gq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_maxx_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_maxx_0=wasmExports["Hq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_maxx_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_maxx_1=wasmExports["Iq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_miny_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_miny_0=wasmExports["Jq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_miny_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_miny_1=wasmExports["Kq"];Module["_emscripten_bind_dtTileCacheLayerHeader_get_maxy_0"]=_emscripten_bind_dtTileCacheLayerHeader_get_maxy_0=wasmExports["Lq"];Module["_emscripten_bind_dtTileCacheLayerHeader_set_maxy_1"]=_emscripten_bind_dtTileCacheLayerHeader_set_maxy_1=wasmExports["Mq"];Module["_emscripten_bind_dtTileCacheLayerHeader___destroy___0"]=_emscripten_bind_dtTileCacheLayerHeader___destroy___0=wasmExports["Nq"];Module["_emscripten_bind_DetourTileCacheBuilder_DetourTileCacheBuilder_0"]=_emscripten_bind_DetourTileCacheBuilder_DetourTileCacheBuilder_0=wasmExports["Oq"];Module["_emscripten_bind_DetourTileCacheBuilder_buildTileCacheLayer_6"]=_emscripten_bind_DetourTileCacheBuilder_buildTileCacheLayer_6=wasmExports["Pq"];Module["_emscripten_bind_DetourTileCacheBuilder___destroy___0"]=_emscripten_bind_DetourTileCacheBuilder___destroy___0=wasmExports["Qq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_bmin_1"]=_emscripten_bind_rcChunkyTriMeshNode_get_bmin_1=wasmExports["Rq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_bmin_2"]=_emscripten_bind_rcChunkyTriMeshNode_set_bmin_2=wasmExports["Sq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_bmax_1"]=_emscripten_bind_rcChunkyTriMeshNode_get_bmax_1=wasmExports["Tq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_bmax_2"]=_emscripten_bind_rcChunkyTriMeshNode_set_bmax_2=wasmExports["Uq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_i_0"]=_emscripten_bind_rcChunkyTriMeshNode_get_i_0=wasmExports["Vq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_i_1"]=_emscripten_bind_rcChunkyTriMeshNode_set_i_1=wasmExports["Wq"];Module["_emscripten_bind_rcChunkyTriMeshNode_get_n_0"]=_emscripten_bind_rcChunkyTriMeshNode_get_n_0=wasmExports["Xq"];Module["_emscripten_bind_rcChunkyTriMeshNode_set_n_1"]=_emscripten_bind_rcChunkyTriMeshNode_set_n_1=wasmExports["Yq"];Module["_emscripten_bind_rcChunkyTriMeshNode___destroy___0"]=_emscripten_bind_rcChunkyTriMeshNode___destroy___0=wasmExports["Zq"];Module["_emscripten_bind_rcChunkyTriMesh_rcChunkyTriMesh_0"]=_emscripten_bind_rcChunkyTriMesh_rcChunkyTriMesh_0=wasmExports["_q"];Module["_emscripten_bind_rcChunkyTriMesh_get_nodes_1"]=_emscripten_bind_rcChunkyTriMesh_get_nodes_1=wasmExports["$q"];Module["_emscripten_bind_rcChunkyTriMesh_set_nodes_2"]=_emscripten_bind_rcChunkyTriMesh_set_nodes_2=wasmExports["ar"];Module["_emscripten_bind_rcChunkyTriMesh_get_nnodes_0"]=_emscripten_bind_rcChunkyTriMesh_get_nnodes_0=wasmExports["br"];Module["_emscripten_bind_rcChunkyTriMesh_set_nnodes_1"]=_emscripten_bind_rcChunkyTriMesh_set_nnodes_1=wasmExports["cr"];Module["_emscripten_bind_rcChunkyTriMesh_get_tris_1"]=_emscripten_bind_rcChunkyTriMesh_get_tris_1=wasmExports["dr"];Module["_emscripten_bind_rcChunkyTriMesh_set_tris_2"]=_emscripten_bind_rcChunkyTriMesh_set_tris_2=wasmExports["er"];Module["_emscripten_bind_rcChunkyTriMesh_get_ntris_0"]=_emscripten_bind_rcChunkyTriMesh_get_ntris_0=wasmExports["fr"];Module["_emscripten_bind_rcChunkyTriMesh_set_ntris_1"]=_emscripten_bind_rcChunkyTriMesh_set_ntris_1=wasmExports["gr"];Module["_emscripten_bind_rcChunkyTriMesh_get_maxTrisPerChunk_0"]=_emscripten_bind_rcChunkyTriMesh_get_maxTrisPerChunk_0=wasmExports["hr"];Module["_emscripten_bind_rcChunkyTriMesh_set_maxTrisPerChunk_1"]=_emscripten_bind_rcChunkyTriMesh_set_maxTrisPerChunk_1=wasmExports["ir"];Module["_emscripten_bind_rcChunkyTriMesh___destroy___0"]=_emscripten_bind_rcChunkyTriMesh___destroy___0=wasmExports["jr"];Module["_emscripten_bind_ChunkyTriMeshUtils_ChunkyTriMeshUtils_0"]=_emscripten_bind_ChunkyTriMeshUtils_ChunkyTriMeshUtils_0=wasmExports["kr"];Module["_emscripten_bind_ChunkyTriMeshUtils_createChunkyTriMesh_5"]=_emscripten_bind_ChunkyTriMeshUtils_createChunkyTriMesh_5=wasmExports["lr"];Module["_emscripten_bind_ChunkyTriMeshUtils_getChunksOverlappingRect_5"]=_emscripten_bind_ChunkyTriMeshUtils_getChunksOverlappingRect_5=wasmExports["mr"];Module["_emscripten_bind_ChunkyTriMeshUtils_getChunkyTriMeshNodeTris_2"]=_emscripten_bind_ChunkyTriMeshUtils_getChunkyTriMeshNodeTris_2=wasmExports["nr"];Module["_emscripten_bind_ChunkyTriMeshUtils___destroy___0"]=_emscripten_bind_ChunkyTriMeshUtils___destroy___0=wasmExports["or"];Module["_emscripten_bind_BoolRef_BoolRef_0"]=_emscripten_bind_BoolRef_BoolRef_0=wasmExports["pr"];Module["_emscripten_bind_BoolRef_get_value_0"]=_emscripten_bind_BoolRef_get_value_0=wasmExports["qr"];Module["_emscripten_bind_BoolRef_set_value_1"]=_emscripten_bind_BoolRef_set_value_1=wasmExports["rr"];Module["_emscripten_bind_BoolRef___destroy___0"]=_emscripten_bind_BoolRef___destroy___0=wasmExports["sr"];Module["_emscripten_bind_IntRef_IntRef_0"]=_emscripten_bind_IntRef_IntRef_0=wasmExports["tr"];Module["_emscripten_bind_IntRef_get_value_0"]=_emscripten_bind_IntRef_get_value_0=wasmExports["ur"];Module["_emscripten_bind_IntRef_set_value_1"]=_emscripten_bind_IntRef_set_value_1=wasmExports["vr"];Module["_emscripten_bind_IntRef___destroy___0"]=_emscripten_bind_IntRef___destroy___0=wasmExports["wr"];Module["_emscripten_bind_UnsignedIntRef_UnsignedIntRef_0"]=_emscripten_bind_UnsignedIntRef_UnsignedIntRef_0=wasmExports["xr"];Module["_emscripten_bind_UnsignedIntRef_get_value_0"]=_emscripten_bind_UnsignedIntRef_get_value_0=wasmExports["yr"];Module["_emscripten_bind_UnsignedIntRef_set_value_1"]=_emscripten_bind_UnsignedIntRef_set_value_1=wasmExports["zr"];Module["_emscripten_bind_UnsignedIntRef___destroy___0"]=_emscripten_bind_UnsignedIntRef___destroy___0=wasmExports["Ar"];Module["_emscripten_bind_UnsignedCharRef_UnsignedCharRef_0"]=_emscripten_bind_UnsignedCharRef_UnsignedCharRef_0=wasmExports["Br"];Module["_emscripten_bind_UnsignedCharRef_get_value_0"]=_emscripten_bind_UnsignedCharRef_get_value_0=wasmExports["Cr"];Module["_emscripten_bind_UnsignedCharRef_set_value_1"]=_emscripten_bind_UnsignedCharRef_set_value_1=wasmExports["Dr"];Module["_emscripten_bind_UnsignedCharRef___destroy___0"]=_emscripten_bind_UnsignedCharRef___destroy___0=wasmExports["Er"];Module["_emscripten_bind_UnsignedShortRef_UnsignedShortRef_0"]=_emscripten_bind_UnsignedShortRef_UnsignedShortRef_0=wasmExports["Fr"];Module["_emscripten_bind_UnsignedShortRef_get_value_0"]=_emscripten_bind_UnsignedShortRef_get_value_0=wasmExports["Gr"];Module["_emscripten_bind_UnsignedShortRef_set_value_1"]=_emscripten_bind_UnsignedShortRef_set_value_1=wasmExports["Hr"];Module["_emscripten_bind_UnsignedShortRef___destroy___0"]=_emscripten_bind_UnsignedShortRef___destroy___0=wasmExports["Ir"];Module["_emscripten_bind_FloatRef_FloatRef_0"]=_emscripten_bind_FloatRef_FloatRef_0=wasmExports["Jr"];Module["_emscripten_bind_FloatRef_get_value_0"]=_emscripten_bind_FloatRef_get_value_0=wasmExports["Kr"];Module["_emscripten_bind_FloatRef_set_value_1"]=_emscripten_bind_FloatRef_set_value_1=wasmExports["Lr"];Module["_emscripten_bind_FloatRef___destroy___0"]=_emscripten_bind_FloatRef___destroy___0=wasmExports["Mr"];Module["_emscripten_bind_IntArray_IntArray_0"]=_emscripten_bind_IntArray_IntArray_0=wasmExports["Nr"];Module["_emscripten_bind_IntArray_resize_1"]=_emscripten_bind_IntArray_resize_1=wasmExports["Or"];Module["_emscripten_bind_IntArray_copy_2"]=_emscripten_bind_IntArray_copy_2=wasmExports["Pr"];Module["_emscripten_bind_IntArray_free_0"]=_emscripten_bind_IntArray_free_0=wasmExports["Qr"];Module["_emscripten_bind_IntArray_get_1"]=_emscripten_bind_IntArray_get_1=wasmExports["Rr"];Module["_emscripten_bind_IntArray_set_2"]=_emscripten_bind_IntArray_set_2=wasmExports["Sr"];Module["_emscripten_bind_IntArray_getDataPointer_0"]=_emscripten_bind_IntArray_getDataPointer_0=wasmExports["Tr"];Module["_emscripten_bind_IntArray_get_data_1"]=_emscripten_bind_IntArray_get_data_1=wasmExports["Ur"];Module["_emscripten_bind_IntArray_set_data_2"]=_emscripten_bind_IntArray_set_data_2=wasmExports["Vr"];Module["_emscripten_bind_IntArray_get_size_0"]=_emscripten_bind_IntArray_get_size_0=wasmExports["Wr"];Module["_emscripten_bind_IntArray_set_size_1"]=_emscripten_bind_IntArray_set_size_1=wasmExports["Xr"];Module["_emscripten_bind_IntArray_get_isView_0"]=_emscripten_bind_IntArray_get_isView_0=wasmExports["Yr"];Module["_emscripten_bind_IntArray_set_isView_1"]=_emscripten_bind_IntArray_set_isView_1=wasmExports["Zr"];Module["_emscripten_bind_IntArray___destroy___0"]=_emscripten_bind_IntArray___destroy___0=wasmExports["_r"];Module["_emscripten_bind_UnsignedIntArray_UnsignedIntArray_0"]=_emscripten_bind_UnsignedIntArray_UnsignedIntArray_0=wasmExports["$r"];Module["_emscripten_bind_UnsignedIntArray_resize_1"]=_emscripten_bind_UnsignedIntArray_resize_1=wasmExports["as"];Module["_emscripten_bind_UnsignedIntArray_copy_2"]=_emscripten_bind_UnsignedIntArray_copy_2=wasmExports["bs"];Module["_emscripten_bind_UnsignedIntArray_free_0"]=_emscripten_bind_UnsignedIntArray_free_0=wasmExports["cs"];Module["_emscripten_bind_UnsignedIntArray_get_1"]=_emscripten_bind_UnsignedIntArray_get_1=wasmExports["ds"];Module["_emscripten_bind_UnsignedIntArray_set_2"]=_emscripten_bind_UnsignedIntArray_set_2=wasmExports["es"];Module["_emscripten_bind_UnsignedIntArray_getDataPointer_0"]=_emscripten_bind_UnsignedIntArray_getDataPointer_0=wasmExports["fs"];Module["_emscripten_bind_UnsignedIntArray_get_data_1"]=_emscripten_bind_UnsignedIntArray_get_data_1=wasmExports["gs"];Module["_emscripten_bind_UnsignedIntArray_set_data_2"]=_emscripten_bind_UnsignedIntArray_set_data_2=wasmExports["hs"];Module["_emscripten_bind_UnsignedIntArray_get_size_0"]=_emscripten_bind_UnsignedIntArray_get_size_0=wasmExports["is"];Module["_emscripten_bind_UnsignedIntArray_set_size_1"]=_emscripten_bind_UnsignedIntArray_set_size_1=wasmExports["js"];Module["_emscripten_bind_UnsignedIntArray_get_isView_0"]=_emscripten_bind_UnsignedIntArray_get_isView_0=wasmExports["ks"];Module["_emscripten_bind_UnsignedIntArray_set_isView_1"]=_emscripten_bind_UnsignedIntArray_set_isView_1=wasmExports["ls"];Module["_emscripten_bind_UnsignedIntArray___destroy___0"]=_emscripten_bind_UnsignedIntArray___destroy___0=wasmExports["ms"];Module["_emscripten_bind_UnsignedCharArray_UnsignedCharArray_0"]=_emscripten_bind_UnsignedCharArray_UnsignedCharArray_0=wasmExports["ns"];Module["_emscripten_bind_UnsignedCharArray_resize_1"]=_emscripten_bind_UnsignedCharArray_resize_1=wasmExports["os"];Module["_emscripten_bind_UnsignedCharArray_copy_2"]=_emscripten_bind_UnsignedCharArray_copy_2=wasmExports["ps"];Module["_emscripten_bind_UnsignedCharArray_free_0"]=_emscripten_bind_UnsignedCharArray_free_0=wasmExports["qs"];Module["_emscripten_bind_UnsignedCharArray_get_1"]=_emscripten_bind_UnsignedCharArray_get_1=wasmExports["rs"];Module["_emscripten_bind_UnsignedCharArray_set_2"]=_emscripten_bind_UnsignedCharArray_set_2=wasmExports["ss"];Module["_emscripten_bind_UnsignedCharArray_getDataPointer_0"]=_emscripten_bind_UnsignedCharArray_getDataPointer_0=wasmExports["ts"];Module["_emscripten_bind_UnsignedCharArray_get_data_1"]=_emscripten_bind_UnsignedCharArray_get_data_1=wasmExports["us"];Module["_emscripten_bind_UnsignedCharArray_set_data_2"]=_emscripten_bind_UnsignedCharArray_set_data_2=wasmExports["vs"];Module["_emscripten_bind_UnsignedCharArray_get_size_0"]=_emscripten_bind_UnsignedCharArray_get_size_0=wasmExports["ws"];Module["_emscripten_bind_UnsignedCharArray_set_size_1"]=_emscripten_bind_UnsignedCharArray_set_size_1=wasmExports["xs"];Module["_emscripten_bind_UnsignedCharArray_get_isView_0"]=_emscripten_bind_UnsignedCharArray_get_isView_0=wasmExports["ys"];Module["_emscripten_bind_UnsignedCharArray_set_isView_1"]=_emscripten_bind_UnsignedCharArray_set_isView_1=wasmExports["zs"];Module["_emscripten_bind_UnsignedCharArray___destroy___0"]=_emscripten_bind_UnsignedCharArray___destroy___0=wasmExports["As"];Module["_emscripten_bind_UnsignedShortArray_UnsignedShortArray_0"]=_emscripten_bind_UnsignedShortArray_UnsignedShortArray_0=wasmExports["Bs"];Module["_emscripten_bind_UnsignedShortArray_resize_1"]=_emscripten_bind_UnsignedShortArray_resize_1=wasmExports["Cs"];Module["_emscripten_bind_UnsignedShortArray_copy_2"]=_emscripten_bind_UnsignedShortArray_copy_2=wasmExports["Ds"];Module["_emscripten_bind_UnsignedShortArray_free_0"]=_emscripten_bind_UnsignedShortArray_free_0=wasmExports["Es"];Module["_emscripten_bind_UnsignedShortArray_get_1"]=_emscripten_bind_UnsignedShortArray_get_1=wasmExports["Fs"];Module["_emscripten_bind_UnsignedShortArray_set_2"]=_emscripten_bind_UnsignedShortArray_set_2=wasmExports["Gs"];Module["_emscripten_bind_UnsignedShortArray_getDataPointer_0"]=_emscripten_bind_UnsignedShortArray_getDataPointer_0=wasmExports["Hs"];Module["_emscripten_bind_UnsignedShortArray_get_data_1"]=_emscripten_bind_UnsignedShortArray_get_data_1=wasmExports["Is"];Module["_emscripten_bind_UnsignedShortArray_set_data_2"]=_emscripten_bind_UnsignedShortArray_set_data_2=wasmExports["Js"];Module["_emscripten_bind_UnsignedShortArray_get_size_0"]=_emscripten_bind_UnsignedShortArray_get_size_0=wasmExports["Ks"];Module["_emscripten_bind_UnsignedShortArray_set_size_1"]=_emscripten_bind_UnsignedShortArray_set_size_1=wasmExports["Ls"];Module["_emscripten_bind_UnsignedShortArray_get_isView_0"]=_emscripten_bind_UnsignedShortArray_get_isView_0=wasmExports["Ms"];Module["_emscripten_bind_UnsignedShortArray_set_isView_1"]=_emscripten_bind_UnsignedShortArray_set_isView_1=wasmExports["Ns"];Module["_emscripten_bind_UnsignedShortArray___destroy___0"]=_emscripten_bind_UnsignedShortArray___destroy___0=wasmExports["Os"];Module["_emscripten_bind_FloatArray_FloatArray_0"]=_emscripten_bind_FloatArray_FloatArray_0=wasmExports["Ps"];Module["_emscripten_bind_FloatArray_resize_1"]=_emscripten_bind_FloatArray_resize_1=wasmExports["Qs"];Module["_emscripten_bind_FloatArray_copy_2"]=_emscripten_bind_FloatArray_copy_2=wasmExports["Rs"];Module["_emscripten_bind_FloatArray_free_0"]=_emscripten_bind_FloatArray_free_0=wasmExports["Ss"];Module["_emscripten_bind_FloatArray_get_1"]=_emscripten_bind_FloatArray_get_1=wasmExports["Ts"];Module["_emscripten_bind_FloatArray_set_2"]=_emscripten_bind_FloatArray_set_2=wasmExports["Us"];Module["_emscripten_bind_FloatArray_getDataPointer_0"]=_emscripten_bind_FloatArray_getDataPointer_0=wasmExports["Vs"];Module["_emscripten_bind_FloatArray_get_data_1"]=_emscripten_bind_FloatArray_get_data_1=wasmExports["Ws"];Module["_emscripten_bind_FloatArray_set_data_2"]=_emscripten_bind_FloatArray_set_data_2=wasmExports["Xs"];Module["_emscripten_bind_FloatArray_get_size_0"]=_emscripten_bind_FloatArray_get_size_0=wasmExports["Ys"];Module["_emscripten_bind_FloatArray_set_size_1"]=_emscripten_bind_FloatArray_set_size_1=wasmExports["Zs"];Module["_emscripten_bind_FloatArray_get_isView_0"]=_emscripten_bind_FloatArray_get_isView_0=wasmExports["_s"];Module["_emscripten_bind_FloatArray_set_isView_1"]=_emscripten_bind_FloatArray_set_isView_1=wasmExports["$s"];Module["_emscripten_bind_FloatArray___destroy___0"]=_emscripten_bind_FloatArray___destroy___0=wasmExports["at"];Module["_emscripten_bind_NavMeshImporterResult_get_navMesh_0"]=_emscripten_bind_NavMeshImporterResult_get_navMesh_0=wasmExports["bt"];Module["_emscripten_bind_NavMeshImporterResult_set_navMesh_1"]=_emscripten_bind_NavMeshImporterResult_set_navMesh_1=wasmExports["ct"];Module["_emscripten_bind_NavMeshImporterResult_get_tileCache_0"]=_emscripten_bind_NavMeshImporterResult_get_tileCache_0=wasmExports["dt"];Module["_emscripten_bind_NavMeshImporterResult_set_tileCache_1"]=_emscripten_bind_NavMeshImporterResult_set_tileCache_1=wasmExports["et"];Module["_emscripten_bind_NavMeshImporterResult_get_allocator_0"]=_emscripten_bind_NavMeshImporterResult_get_allocator_0=wasmExports["ft"];Module["_emscripten_bind_NavMeshImporterResult_set_allocator_1"]=_emscripten_bind_NavMeshImporterResult_set_allocator_1=wasmExports["gt"];Module["_emscripten_bind_NavMeshImporterResult_get_compressor_0"]=_emscripten_bind_NavMeshImporterResult_get_compressor_0=wasmExports["ht"];Module["_emscripten_bind_NavMeshImporterResult_set_compressor_1"]=_emscripten_bind_NavMeshImporterResult_set_compressor_1=wasmExports["it"];Module["_emscripten_bind_NavMeshImporterResult___destroy___0"]=_emscripten_bind_NavMeshImporterResult___destroy___0=wasmExports["jt"];Module["_emscripten_bind_NavMeshImporter_NavMeshImporter_0"]=_emscripten_bind_NavMeshImporter_NavMeshImporter_0=wasmExports["kt"];Module["_emscripten_bind_NavMeshImporter_importNavMesh_2"]=_emscripten_bind_NavMeshImporter_importNavMesh_2=wasmExports["lt"];Module["_emscripten_bind_NavMeshImporter___destroy___0"]=_emscripten_bind_NavMeshImporter___destroy___0=wasmExports["mt"];Module["_emscripten_bind_NavMeshExport_NavMeshExport_0"]=_emscripten_bind_NavMeshExport_NavMeshExport_0=wasmExports["nt"];Module["_emscripten_bind_NavMeshExport_get_dataPointer_0"]=_emscripten_bind_NavMeshExport_get_dataPointer_0=wasmExports["ot"];Module["_emscripten_bind_NavMeshExport_set_dataPointer_1"]=_emscripten_bind_NavMeshExport_set_dataPointer_1=wasmExports["pt"];Module["_emscripten_bind_NavMeshExport_get_size_0"]=_emscripten_bind_NavMeshExport_get_size_0=wasmExports["qt"];Module["_emscripten_bind_NavMeshExport_set_size_1"]=_emscripten_bind_NavMeshExport_set_size_1=wasmExports["rt"];Module["_emscripten_bind_NavMeshExport___destroy___0"]=_emscripten_bind_NavMeshExport___destroy___0=wasmExports["st"];Module["_emscripten_bind_NavMeshExporter_NavMeshExporter_0"]=_emscripten_bind_NavMeshExporter_NavMeshExporter_0=wasmExports["tt"];Module["_emscripten_bind_NavMeshExporter_exportNavMesh_2"]=_emscripten_bind_NavMeshExporter_exportNavMesh_2=wasmExports["ut"];Module["_emscripten_bind_NavMeshExporter_freeNavMeshExport_1"]=_emscripten_bind_NavMeshExporter_freeNavMeshExport_1=wasmExports["vt"];Module["_emscripten_bind_NavMeshExporter___destroy___0"]=_emscripten_bind_NavMeshExporter___destroy___0=wasmExports["wt"];Module["_emscripten_bind_DebugDrawImpl_DebugDrawImpl_0"]=_emscripten_bind_DebugDrawImpl_DebugDrawImpl_0=wasmExports["xt"];Module["_emscripten_bind_DebugDrawImpl_handleDepthMask_1"]=_emscripten_bind_DebugDrawImpl_handleDepthMask_1=wasmExports["yt"];Module["_emscripten_bind_DebugDrawImpl_handleTexture_1"]=_emscripten_bind_DebugDrawImpl_handleTexture_1=wasmExports["zt"];Module["_emscripten_bind_DebugDrawImpl_handleBegin_2"]=_emscripten_bind_DebugDrawImpl_handleBegin_2=wasmExports["At"];Module["_emscripten_bind_DebugDrawImpl_handleVertexWithColor_4"]=_emscripten_bind_DebugDrawImpl_handleVertexWithColor_4=wasmExports["Bt"];Module["_emscripten_bind_DebugDrawImpl_handleVertexWithColorAndUV_6"]=_emscripten_bind_DebugDrawImpl_handleVertexWithColorAndUV_6=wasmExports["Ct"];Module["_emscripten_bind_DebugDrawImpl_handleEnd_0"]=_emscripten_bind_DebugDrawImpl_handleEnd_0=wasmExports["Dt"];Module["_emscripten_bind_DebugDrawImpl___destroy___0"]=_emscripten_bind_DebugDrawImpl___destroy___0=wasmExports["Et"];Module["_emscripten_bind_RecastDebugDraw_RecastDebugDraw_0"]=_emscripten_bind_RecastDebugDraw_RecastDebugDraw_0=wasmExports["Ft"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldSolid_2"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldSolid_2=wasmExports["Gt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldWalkable_2"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldWalkable_2=wasmExports["Ht"];Module["_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldSolid_2"]=_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldSolid_2=wasmExports["It"];Module["_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldRegions_2"]=_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldRegions_2=wasmExports["Jt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldDistance_2"]=_emscripten_bind_RecastDebugDraw_debugDrawCompactHeightfieldDistance_2=wasmExports["Kt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayer_3"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayer_3=wasmExports["Lt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayers_2"]=_emscripten_bind_RecastDebugDraw_debugDrawHeightfieldLayers_2=wasmExports["Mt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawRegionConnections_3"]=_emscripten_bind_RecastDebugDraw_debugDrawRegionConnections_3=wasmExports["Nt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawRawContours_3"]=_emscripten_bind_RecastDebugDraw_debugDrawRawContours_3=wasmExports["Ot"];Module["_emscripten_bind_RecastDebugDraw_debugDrawContours_3"]=_emscripten_bind_RecastDebugDraw_debugDrawContours_3=wasmExports["Pt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawPolyMesh_2"]=_emscripten_bind_RecastDebugDraw_debugDrawPolyMesh_2=wasmExports["Qt"];Module["_emscripten_bind_RecastDebugDraw_debugDrawPolyMeshDetail_2"]=_emscripten_bind_RecastDebugDraw_debugDrawPolyMeshDetail_2=wasmExports["Rt"];Module["_emscripten_bind_RecastDebugDraw___destroy___0"]=_emscripten_bind_RecastDebugDraw___destroy___0=wasmExports["St"];Module["_emscripten_bind_DetourDebugDraw_DetourDebugDraw_0"]=_emscripten_bind_DetourDebugDraw_DetourDebugDraw_0=wasmExports["Tt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMesh_3"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMesh_3=wasmExports["Ut"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshWithClosedList_4"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshWithClosedList_4=wasmExports["Vt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshNodes_2"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshNodes_2=wasmExports["Wt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshBVTree_2"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshBVTree_2=wasmExports["Xt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPortals_2"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPortals_2=wasmExports["Yt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPolysWithFlags_4"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPolysWithFlags_4=wasmExports["Zt"];Module["_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPoly_4"]=_emscripten_bind_DetourDebugDraw_debugDrawNavMeshPoly_4=wasmExports["_t"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerAreas_4"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerAreas_4=wasmExports["$t"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerRegions_4"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCacheLayerRegions_4=wasmExports["au"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCacheContours_5"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCacheContours_5=wasmExports["bu"];Module["_emscripten_bind_DetourDebugDraw_debugDrawTileCachePolyMesh_5"]=_emscripten_bind_DetourDebugDraw_debugDrawTileCachePolyMesh_5=wasmExports["cu"];Module["_emscripten_bind_DetourDebugDraw___destroy___0"]=_emscripten_bind_DetourDebugDraw___destroy___0=wasmExports["du"];Module["_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_START"]=_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_START=wasmExports["eu"];Module["_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_END"]=_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_END=wasmExports["fu"];Module["_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION"]=_emscripten_enum_dtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION=wasmExports["gu"];Module["_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS"]=_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS=wasmExports["hu"];Module["_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS"]=_emscripten_enum_dtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS=wasmExports["iu"];Module["_emscripten_enum_dtFindPathOptions_DT_FINDPATH_ANY_ANGLE"]=_emscripten_enum_dtFindPathOptions_DT_FINDPATH_ANY_ANGLE=wasmExports["ju"];Module["_emscripten_enum_dtRaycastOptions_DT_RAYCAST_USE_COSTS"]=_emscripten_enum_dtRaycastOptions_DT_RAYCAST_USE_COSTS=wasmExports["ku"];Module["_emscripten_enum_dtTileFlags_DT_TILE_FREE_DATA"]=_emscripten_enum_dtTileFlags_DT_TILE_FREE_DATA=wasmExports["lu"];Module["_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_INVALID"]=_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_INVALID=wasmExports["mu"];Module["_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_WALKING"]=_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_WALKING=wasmExports["nu"];Module["_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH"]=_emscripten_enum_CrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH=wasmExports["ou"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_NONE"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_NONE=wasmExports["pu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_FAILED"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_FAILED=wasmExports["qu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VALID"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VALID=wasmExports["ru"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING=wasmExports["su"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE=wasmExports["tu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH=wasmExports["uu"];Module["_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY"]=_emscripten_enum_MoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY=wasmExports["vu"];Module["_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES"]=_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES=wasmExports["wu"];Module["_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES"]=_emscripten_enum_rcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES=wasmExports["xu"];Module["_emscripten_enum_rcLogCategory_RC_LOG_PROGRESS"]=_emscripten_enum_rcLogCategory_RC_LOG_PROGRESS=wasmExports["yu"];Module["_emscripten_enum_rcLogCategory_RC_LOG_WARNING"]=_emscripten_enum_rcLogCategory_RC_LOG_WARNING=wasmExports["zu"];Module["_emscripten_enum_rcLogCategory_RC_LOG_ERROR"]=_emscripten_enum_rcLogCategory_RC_LOG_ERROR=wasmExports["Au"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_TOTAL"]=_emscripten_enum_rcTimerLabel_RC_TIMER_TOTAL=wasmExports["Bu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_TEMP"]=_emscripten_enum_rcTimerLabel_RC_TIMER_TEMP=wasmExports["Cu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES"]=_emscripten_enum_rcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES=wasmExports["Du"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD=wasmExports["Eu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS=wasmExports["Fu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE=wasmExports["Gu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY=wasmExports["Hu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_BORDER"]=_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_BORDER=wasmExports["Iu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_WALKABLE"]=_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_WALKABLE=wasmExports["Ju"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MEDIAN_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MEDIAN_AREA=wasmExports["Ku"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES"]=_emscripten_enum_rcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES=wasmExports["Lu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESH"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESH=wasmExports["Mu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESH"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESH=wasmExports["Nu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_ERODE_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_ERODE_AREA=wasmExports["Ou"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_BOX_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_BOX_AREA=wasmExports["Pu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA=wasmExports["Qu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA=wasmExports["Ru"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD=wasmExports["Su"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST=wasmExports["Tu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR=wasmExports["Uu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS=wasmExports["Vu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED=wasmExports["Wu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND=wasmExports["Xu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD=wasmExports["Yu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER=wasmExports["Zu"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_LAYERS"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_LAYERS=wasmExports["_u"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL"]=_emscripten_enum_rcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL=wasmExports["$u"];Module["_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL"]=_emscripten_enum_rcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL=wasmExports["av"];Module["_emscripten_enum_rcTimerLabel_RC_MAX_TIMERS"]=_emscripten_enum_rcTimerLabel_RC_MAX_TIMERS=wasmExports["bv"];Module["_emscripten_enum_dtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA"]=_emscripten_enum_dtCompressedTileFlags_DT_COMPRESSEDTILE_FREE_DATA=wasmExports["cv"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_POINTS"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_POINTS=wasmExports["dv"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_LINES"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_LINES=wasmExports["ev"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_TRIS"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_TRIS=wasmExports["fv"];Module["_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_QUADS"]=_emscripten_enum_duDebugDrawPrimitives_DU_DRAW_QUADS=wasmExports["gv"];__emscripten_timeout=wasmExports["hv"];}var wasmImports={e:__abort_js,c:__emscripten_runtime_keepalive_clear,d:__setitimer_js,a:_emscripten_asm_const_int,f:_emscripten_resize_heap,b:_proc_exit};var wasmExports=await createWasm();function run(){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun();},1);}else {doRun();}}function preInit(){if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()();}}}preInit();run();function WrapperObject(){}WrapperObject.prototype=Object.create(WrapperObject.prototype);WrapperObject.prototype.constructor=WrapperObject;WrapperObject.prototype.__class__=WrapperObject;WrapperObject.__cache__={};Module["WrapperObject"]=WrapperObject;function getCache(__class__){return (__class__||WrapperObject).__cache__}Module["getCache"]=getCache;function wrapPointer(ptr,__class__){var cache=getCache(__class__);var ret=cache[ptr];if(ret)return ret;ret=Object.create((__class__||WrapperObject).prototype);ret.ptr=ptr;return cache[ptr]=ret}Module["wrapPointer"]=wrapPointer;function castObject(obj,__class__){return wrapPointer(obj.ptr,__class__)}Module["castObject"]=castObject;Module["NULL"]=wrapPointer(0);function destroy(obj){if(!obj["__destroy__"])throw "Error: Cannot destroy object. (Did you create it yourself?)";obj["__destroy__"]();delete getCache(obj.__class__)[obj.ptr];}Module["destroy"]=destroy;function compare(obj1,obj2){return obj1.ptr===obj2.ptr}Module["compare"]=compare;function getPointer(obj){return obj.ptr}Module["getPointer"]=getPointer;function getClass(obj){return obj.__class__}Module["getClass"]=getClass;var ensureCache={buffer:0,size:0,pos:0,temps:[],needed:0,prepare(){if(ensureCache.needed){for(var i=0;i=ensureCache.size){assert(len>0);ensureCache.needed+=len;ret=Module["_webidl_malloc"](len);ensureCache.temps.push(ret);}else {ret=ensureCache.buffer+ensureCache.pos;ensureCache.pos+=len;}return ret},copy(array,view,offset){offset/=view.BYTES_PER_ELEMENT;for(var i=0;i{readyPromiseResolve=resolve;readyPromiseReject=reject;});} + + + return moduleRtn; + } + ); + })(); + + var recastNavigation_wasmCompat = /*#__PURE__*/Object.freeze({ + __proto__: null, + default: Recast + }); + exports.buildTiledNavMeshRcConfig = buildTiledNavMeshRcConfig; exports.createDefaultTileCacheMeshProcess = createDefaultTileCacheMeshProcess; exports.dtIlog2 = dtIlog2; @@ -2832,6 +2987,7 @@ exports.generateTileNavMeshData = generateTileNavMeshData; exports.generateTiledNavMesh = generateTiledNavMesh; exports.getBoundingBox = getBoundingBox; + exports.init = init; exports.mergePositionsAndIndices = mergePositionsAndIndices; exports.soloNavMeshGeneratorConfigDefaults = soloNavMeshGeneratorConfigDefaults; exports.tileCacheGeneratorConfigDefaults = tileCacheGeneratorConfigDefaults; diff --git a/GDJS/Runtime/types/global-recast.d.ts b/GDJS/Runtime/types/global-recast.d.ts index 5568b11de6aa..15b906094471 100644 --- a/GDJS/Runtime/types/global-recast.d.ts +++ b/GDJS/Runtime/types/global-recast.d.ts @@ -15,6 +15,7 @@ import { tiledNavMeshGeneratorConfigDefaults, } from 'recast-navigation/generators'; import { + init, DebugDrawerUtils, RecastBuildContext, RecastChunkyTriMesh, From e4faea19da46c659ce9601e1e6c710d713882c73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Wed, 29 Jul 2026 16:55:50 +0200 Subject: [PATCH 03/51] Can find a path --- Extensions/NavMeshPathfinding/JsExtension.js | 14 + .../NavMeshCharacterRuntimeBehavior.ts | 218 +-- .../NavMeshObstacleRuntimeBehavior.ts | 130 +- .../recast-navigation-generators.js | 1221 +++++++++++++++++ GDJS/Runtime/types/global-recast.d.ts | 116 +- 5 files changed, 1561 insertions(+), 138 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index a8da9fcdcaba..5cda024f26df 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -93,6 +93,20 @@ module.exports = { .addIncludeFile( 'Extensions/NavMeshPathfinding/recast-navigation-generators.js' ); + + aut.addAction("MoveTo", + _("Move to a position"), + _("Move the object to a position"), + _("Move _PARAM0_ to _PARAM2_ ; _PARAM3_ ; _PARAM4_"), + _("Movement on the path"), + "CppPlatform/Extensions/AStaricon24.png", + "CppPlatform/Extensions/AStaricon16.png") + .addParameter("object", _("Object")) + .addParameter("behavior", _("Behavior"), "NavMeshCharacterBehavior") + .addParameter("expression", _("Destination X position")) + .addParameter("expression", _("Destination Y position")) + .addParameter("expression", _("Destination Z position")) + .setFunctionName("moveTo"); } { const behavior = new gd.BehaviorJsImplementation(); diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 311944e5736e..4d169eab39ed 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -14,7 +14,7 @@ namespace gdjs { const Recast = await initializeRecast(); await RecastNav.init(); - console.log("Initialized Recast"); + console.log('Initialized Recast'); //@ts-ignore window.Recast = Recast; } catch (err) { @@ -24,9 +24,9 @@ namespace gdjs { }; gdjs.registerAsynchronouslyLoadingLibraryPromise(loadRecast()); - interface PathfindingNetworkSyncDataType { + interface NavMeshCharacterNetworkSyncDataType { // Syncing the path and its position on it should be enough to have a good prediction. - path: FloatPoint[]; + path: RecastNav.Vector3[]; pf: boolean; sp: number; as: number; @@ -38,8 +38,8 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface PathfindingNetworkSyncData extends BehaviorNetworkSyncData { - props: PathfindingNetworkSyncDataType; + export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + props: NavMeshCharacterNetworkSyncDataType; } /** @@ -48,7 +48,7 @@ namespace gdjs { * @category Behaviors > 2D Pathfinding */ export class NavMeshCharacterRuntimeBehavior extends gdjs.RuntimeBehavior { - _path: Array = []; + _path: Array = []; /** Used by the path simplification algorithm */ static _smoothingResultVertices: Array = []; /** Used by the path simplification algorithm */ @@ -76,7 +76,7 @@ namespace gdjs { _totalSegmentDistance: float = 0; _currentSegment: integer = 0; _reachedEnd: boolean = false; - _manager: PathfindingObstaclesManager; + _manager: NavMeshObstaclesManager; _movementAngle: float = 0; @@ -104,58 +104,15 @@ namespace gdjs { this._gridOffsetY = behaviorData.gridOffsetY || 0; this._extraBorder = behaviorData.extraBorder; this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap || 0; - // this._manager = - // gdjs.PathfindingObstaclesManager.getManager(instanceContainer); - - // const positions = [ - // 0, 0, 0, - // 0, 1, 0, - // 1, 1, 0, - // 1, 0, 0, - // ]; - - // const positions = [ - // 0, 0, 0, - // 0, 0, 1, - // 1, 0, 1, - // 1, 0, 0, - // ]; - - // const indices = [ - // 0, 1, 2, - // 1, 2, 3, - // ]; - - const groundMesh = new THREE.Mesh(new THREE.BoxGeometry(4, 0.2, 4)); - //const groundMesh = new THREE.Mesh(new THREE.PlaneGeometry( 1, 1 )); - const positions = groundMesh.geometry.attributes.position.array; - const indices = groundMesh.geometry.index.array; - - console.log(positions,indices); - - const navMeshConfig = { - borderSize: 0, - cs: 0.2, - ch: 0.2, - walkableSlopeAngle: 35, - walkableHeight: 1, - walkableClimb: 1, - walkableRadius: 1, - maxEdgeLen: 12, - maxSimplificationError: 1.3, - minRegionArea: 8, - mergeRegionArea: 20, - maxVertsPerPoly: 6, - detailSampleDist: 6, - detailSampleMaxError: 1, - }; + this._manager = + gdjs.NavMeshObstaclesManager.getManager(instanceContainer); - const result = RecastNav.generateSoloNavMesh( - positions, - indices, - navMeshConfig - ); - console.log(result); + // TODO Remove + this._acceleration = 1000; + this._maxSpeed = 300; + this._angularMaxSpeed = 720; + this._rotateObject = true; + this._angleOffset = 0; } override applyBehaviorOverriding(behaviorData): boolean { @@ -200,7 +157,7 @@ namespace gdjs { getNetworkSyncData( options: GetNetworkSyncDataOptions - ): PathfindingNetworkSyncData { + ): NavMeshCharacterNetworkSyncData { return { ...super.getNetworkSyncData(options), props: { @@ -218,7 +175,7 @@ namespace gdjs { } updateFromNetworkSyncData( - networkSyncData: PathfindingNetworkSyncData, + networkSyncData: NavMeshCharacterNetworkSyncData, options: UpdateFromNetworkSyncDataOptions ): void { super.updateFromNetworkSyncData(networkSyncData, options); @@ -464,14 +421,10 @@ namespace gdjs { /** * Compute and move on the path to the specified destination. */ - moveTo( - instanceContainer: gdjs.RuntimeInstanceContainer, - x: float, - y: float - ) { + moveTo(x: float, y: float, z: float) { const owner = this.owner; - //First be sure that there is a path to compute. + // First be sure that there is a path to compute. const targetCellX = Math.round((x - this._gridOffsetX) / this._cellWidth); const targetCellY = Math.round( (y - this._gridOffsetY) / this._cellHeight @@ -484,20 +437,82 @@ namespace gdjs { ); if (startCellX == targetCellX && startCellY == targetCellY) { this._path.length = 0; - this._path.push([owner.getX(), owner.getY()]); - this._path.push([x, y]); + this._path.push({ x: owner.getX(), y: owner.getY(), z: owner.getZ() }); + this._path.push({ x, y, z }); this._enterSegment(0); this._pathFound = true; return; } - //Start searching for a path - if (false) { - //Path found: memorize it + if (!this._manager.navMesh) { + this._manager.rebuildNavMesh(); + } + if (!this._manager.navMesh) { + console.log("Can't build the nav mesh"); + return; + } + + // Start searching for a path + const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); + + const { success: hasFindOrigin, point: origin } = + navMeshQuery.findClosestPoint( + { + x: owner.getX(), + y: owner.getZ(), + z: owner.getY(), + }, + { halfExtents: { x: 100, y: 100, z: 100 } } + ); + if (!hasFindOrigin) { + this._pathFound = false; + console.log( + "Can't find origin", + owner.getX(), + owner.getY(), + owner.getZ() + ); + return; + } + const { success: hasFindDestination, point: destination } = + navMeshQuery.findClosestPoint( + { x, y: z, z: y }, + { halfExtents: { x: 100, y: 100, z: 100 } } + ); + if (!hasFindDestination) { + this._pathFound = false; + console.log("Can't find destination", x, y, z); + return; + } + const { + success: hasFindPath, + error, + path, + } = navMeshQuery.computePath(origin, destination); + if (!hasFindPath) { + this._pathFound = false; + console.log( + "Can't find a path from", + origin.x, + origin.z, + origin.y, + 'to', + destination.x, + destination.z, + destination.y + ); + return; } - // No path found - this._pathFound = false; + // Path found: memorize it + for (const point of path) { + const y = point.y; + point.y = point.z; + point.z = y; + } + console.log('path', path); + this._path = path; + this._enterSegment(0); } _enterSegment(segmentNumber: integer) { @@ -507,12 +522,15 @@ namespace gdjs { this._currentSegment = segmentNumber; if (this._currentSegment < this._path.length - 1) { const pathX = - this._path[this._currentSegment + 1][0] - - this._path[this._currentSegment][0]; + this._path[this._currentSegment + 1].x - + this._path[this._currentSegment].x; const pathY = - this._path[this._currentSegment + 1][1] - - this._path[this._currentSegment][1]; - this._totalSegmentDistance = Math.sqrt(pathX * pathX + pathY * pathY); + this._path[this._currentSegment + 1].y - + this._path[this._currentSegment].y; + const pathZ = + this._path[this._currentSegment + 1].z - + this._path[this._currentSegment].z; + this._totalSegmentDistance = Math.hypot(pathX, pathY, pathZ); this._distanceOnSegment = 0; this._reachedEnd = false; this._movementAngle = @@ -554,16 +572,23 @@ namespace gdjs { } // Position object on the segment and update its angle - let newPos = [0, 0]; + let x = 0; + let y = 0; + let z = 0; if (this._currentSegment < this._path.length - 1) { - newPos[0] = gdjs.evtTools.common.lerp( - this._path[this._currentSegment][0], - this._path[this._currentSegment + 1][0], + x = gdjs.evtTools.common.lerp( + this._path[this._currentSegment].x, + this._path[this._currentSegment + 1].x, + this._distanceOnSegment / this._totalSegmentDistance + ); + y = gdjs.evtTools.common.lerp( + this._path[this._currentSegment].y, + this._path[this._currentSegment + 1].y, this._distanceOnSegment / this._totalSegmentDistance ); - newPos[1] = gdjs.evtTools.common.lerp( - this._path[this._currentSegment][1], - this._path[this._currentSegment + 1][1], + z = gdjs.evtTools.common.lerp( + this._path[this._currentSegment].z, + this._path[this._currentSegment + 1].z, this._distanceOnSegment / this._totalSegmentDistance ); if ( @@ -576,14 +601,27 @@ namespace gdjs { ); } } else { - newPos = this._path[this._path.length - 1]; - } - this.owner.setX(newPos[0]); - this.owner.setY(newPos[1]); + const newPos = this._path[this._path.length - 1]; + x = newPos.x; + y = newPos.y; + z = newPos.z; + } + console.log( + 'move', + this._distanceOnSegment, + '/', + this._totalSegmentDistance, + 'at', + x, + y, + z + ); + this.owner.setX(x); + this.owner.setY(y); + this.owner.setZ(z); } doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {} - } gdjs.registerBehavior( 'NavMeshPathfinding::NavMeshCharacterBehavior', diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index d3bb17bb8d3d..d67631546061 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -5,48 +5,122 @@ Copyright (c) 2013-2016 Florian Rival (Florian.Rival@gmail.com) namespace gdjs { export interface RuntimeInstanceContainer { - pathfindingObstaclesManager: gdjs.PathfindingObstaclesManager; + navMeshObstaclesManager: gdjs.NavMeshObstaclesManager; } - declare var rbush: any; + + const cubePositions = [ + 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, + -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, + ]; + const cubeIndices = [ + 0, 1, 2, 1, 3, 2, 4, 5, 6, 5, 7, 6, 4, 6, 2, 6, 8, 2, 7, 5, 1, 5, 3, 1, 6, + 7, 8, 7, 1, 8, 2, 3, 4, 3, 5, 4, + ]; /** - * PathfindingObstaclesManager manages the common objects shared by objects + * NavMeshObstaclesManager manages the common objects shared by objects * having a pathfinding behavior: In particular, the obstacles behaviors are * required to declare themselves (see - * `PathfindingObstaclesManager.addObstacle`) to the manager of their + * `NavMeshObstaclesManager.addObstacle`) to the manager of their * associated container (see * `gdjs.PathfindingRuntimeBehavior.obstaclesManagers`). * @category Behaviors > 2D Pathfinding */ export class NavMeshObstaclesManager { + obstacles = new Set(); + navMesh: RecastNav.NavMesh | null = null; - constructor(instanceContainer: gdjs.RuntimeInstanceContainer) { - } + constructor(instanceContainer: gdjs.RuntimeInstanceContainer) {} /** * Get the obstacles manager of an instance container. */ static getManager(instanceContainer: gdjs.RuntimeInstanceContainer) { - if (!instanceContainer.pathfindingObstaclesManager) { + if (!instanceContainer.navMeshObstaclesManager) { //Create the shared manager if necessary. - instanceContainer.pathfindingObstaclesManager = - new gdjs.PathfindingObstaclesManager(instanceContainer); + instanceContainer.navMeshObstaclesManager = + new gdjs.NavMeshObstaclesManager(instanceContainer); + } + return instanceContainer.navMeshObstaclesManager; + } + + rebuildNavMesh() { + const navMeshConfig = { + borderSize: 0, + cs: 2, + ch: 2, + walkableSlopeAngle: 60, + walkableHeight: 1, + walkableClimb: 1, + walkableRadius: 1, + maxEdgeLen: 12, + maxSimplificationError: 1.3, + minRegionArea: 8, + mergeRegionArea: 20, + maxVertsPerPoly: 6, + detailSampleDist: 6, + detailSampleMaxError: 1, + }; + + const positions: Array = []; + const indices: Array = []; + + const euler = new THREE.Euler(); + euler.order = 'ZYX'; + const point = new THREE.Vector3(); + + for (const obstacle of this.obstacles) { + //@ts-ignore + const object: gdjs.RuntimeObject3D = obstacle.owner; + const indicesOffset = Math.round(positions.length / 3); + for ( + let index = 0; + index + 2 < cubePositions.length; + index = index + 3 + ) { + let x = cubePositions[index]; + let y = cubePositions[index + 2]; + let z = cubePositions[index + 1]; + + x *= object.getWidth(); + y *= object.getHeight(); + z *= object.getDepth(); + + point.set(x, y, z); + euler.set( + object.getRotationX(), + object.getRotationY(), + object.getAngle() + ); + point.applyEuler(euler); + + x = object.getCenterXInScene() + point.x; + y = object.getCenterYInScene() + point.y; + z = object.getCenterZInScene() + point.z; + + // Y is the top for Recast + positions.push(x, z, y); + } + for (const vertexIndex of cubeIndices) { + indices.push(vertexIndex + indicesOffset); + } + } + + const result = RecastNav.generateSoloNavMesh( + positions, + indices, + navMeshConfig + ); + if (result.success) { + this.navMesh = result.navMesh; } - return instanceContainer.pathfindingObstaclesManager; } /** * Add a obstacle to the list of existing obstacles. */ - addObstacle( - pathfindingObstacleBehavior: PathfindingObstacleRuntimeBehavior - ) { - if (pathfindingObstacleBehavior.currentRBushAABB) - pathfindingObstacleBehavior.currentRBushAABB.updateAABBFromOwner(); - else - pathfindingObstacleBehavior.currentRBushAABB = - new gdjs.BehaviorRBushAABB(pathfindingObstacleBehavior); - + addObstacle(pathfindingObstacleBehavior: NavMeshObstacleRuntimeBehavior) { + this.obstacles.add(pathfindingObstacleBehavior); } /** @@ -54,13 +128,14 @@ namespace gdjs { * added before. */ removeObstacle( - pathfindingObstacleBehavior: PathfindingObstacleRuntimeBehavior + pathfindingObstacleBehavior: NavMeshObstacleRuntimeBehavior ) { + this.obstacles.delete(pathfindingObstacleBehavior); } } /** - * PathfindingObstacleRuntimeBehavior represents a behavior allowing objects to be + * NavMeshObstacleRuntimeBehavior represents a behavior allowing objects to be * considered as a obstacle by objects having Pathfinding Behavior. * @category Behaviors > 2D Pathfinding */ @@ -71,10 +146,8 @@ namespace gdjs { _oldY: float = 0; _oldWidth: float = 0; _oldHeight: float = 0; - _manager: PathfindingObstaclesManager; + _manager: NavMeshObstaclesManager; _registeredInManager: boolean = false; - currentRBushAABB: gdjs.BehaviorRBushAABB | null = - null; constructor( instanceContainer: gdjs.RuntimeInstanceContainer, @@ -84,7 +157,7 @@ namespace gdjs { super(instanceContainer, behaviorData, owner); this._impassable = behaviorData.impassable; this._cost = behaviorData.cost; - this._manager = PathfindingObstaclesManager.getManager(instanceContainer); + this._manager = NavMeshObstaclesManager.getManager(instanceContainer); //Note that we can't use getX(), getWidth()... of owner here: //The owner is not yet fully constructed. @@ -126,8 +199,7 @@ namespace gdjs { this._oldHeight !== this.owner.getHeight() ) { if (this._registeredInManager) { - this._manager.removeObstacle(this); - this._manager.addObstacle(this); + // TODO Notify that the mesh is out of date? } this._oldX = this.owner.getX(); this._oldY = this.owner.getY(); @@ -138,10 +210,6 @@ namespace gdjs { doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {} - getAABB() { - return this.owner.getAABB(); - } - onActivate() { if (this._registeredInManager) { return; diff --git a/Extensions/NavMeshPathfinding/recast-navigation-generators.js b/Extensions/NavMeshPathfinding/recast-navigation-generators.js index 5095a6d3697e..75a6d98c3d82 100644 --- a/Extensions/NavMeshPathfinding/recast-navigation-generators.js +++ b/Extensions/NavMeshPathfinding/recast-navigation-generators.js @@ -179,6 +179,18 @@ return new IntArray(raw); } } + class UnsignedIntArray extends BaseArray { + ArrayConstructor = Uint32Array; + constructor(raw) { + super(raw ?? new Raw.Module.UnsignedIntArray()); + } + getHeap() { + return Raw.Module.HEAPU32; + } + static fromRaw(raw) { + return new UnsignedIntArray(raw); + } + } class UnsignedCharArray extends BaseArray { ArrayConstructor = Uint8Array; constructor(raw) { @@ -740,6 +752,1174 @@ } } + class QueryFilter { + get includeFlags() { + return this.raw.getIncludeFlags(); + } + set includeFlags(flags) { + this.raw.setIncludeFlags(flags); + } + get excludeFlags() { + return this.raw.getExcludeFlags(); + } + set excludeFlags(flags) { + this.raw.setExcludeFlags(flags); + } + constructor(raw) { + this.raw = raw ?? new Raw.Module.dtQueryFilter(); + } + getAreaCost(i) { + return this.raw.getAreaCost(i); + } + setAreaCost(i, cost) { + this.raw.setAreaCost(i, cost); + } + } + class NavMeshQuery { + /** + * Default query filter. + */ + + /** + * Default search distance along each axis. + */ + defaultQueryHalfExtents = { + x: 1, + y: 1, + z: 1 + }; + constructor(value, params) { + if (value instanceof Raw.Module.NavMeshQuery) { + this.raw = value; + } else { + this.raw = new Raw.Module.NavMeshQuery(); + this.raw.init(value.raw, params?.maxNodes ?? 2048); + } + if (params?.defaultQueryFilter) { + this.defaultFilter = params.defaultQueryFilter; + } else { + this.defaultFilter = new QueryFilter(); + this.defaultFilter.includeFlags = 0xffff; + this.defaultFilter.excludeFlags = 0; + } + } + /** + * Finds the polygon nearest to the given position. + */ + findNearestPoly(position, options) { + const nearestRefRaw = new Raw.UnsignedIntRef(); + const nearestPointRaw = new Raw.Vec3(); + const isOverPolyRaw = new Raw.BoolRef(); + const status = this.raw.findNearestPoly(vec3.toArray(position), vec3.toArray(options?.halfExtents ?? this.defaultQueryHalfExtents), options?.filter?.raw ?? this.defaultFilter.raw, nearestRefRaw, nearestPointRaw, isOverPolyRaw); + const nearestPoint = vec3.fromRaw(nearestPointRaw); + Raw.destroy(nearestPointRaw); + const nearestRef = nearestRefRaw.value; + Raw.destroy(nearestRefRaw); + const isOverPoly = isOverPolyRaw.value; + Raw.destroy(isOverPolyRaw); + return { + success: statusSucceed(status), + status, + nearestRef, + nearestPoint, + isOverPoly + }; + } + /** + * Finds the polygons along the navigation graph that touch the specified circle. + * @param startRef Reference of polygon to start search from + * @param centerPos Center of circle + * @param radius Radius of circle + * @param options + */ + findPolysAroundCircle(startRef, centerPos, radius, options) { + const filter = options?.filter ?? this.defaultFilter; + const maxPolys = options?.maxPolys ?? 256; + const resultRefArray = new UnsignedIntArray(); + const resultParentArray = new UnsignedIntArray(); + const resultCostArray = new FloatArray(); + resultRefArray.resize(maxPolys); + resultParentArray.resize(maxPolys); + resultCostArray.resize(maxPolys); + const resultCountRef = new Raw.IntRef(); + const status = this.raw.findPolysAroundCircle(startRef, vec3.toArray(centerPos), radius, filter.raw, resultRefArray.raw, resultParentArray.raw, resultCostArray.raw, resultCountRef, maxPolys); + const resultRefs = [...resultRefArray.getHeapView()]; + resultRefArray.destroy(); + const resultParents = [...resultParentArray.getHeapView()]; + resultParentArray.destroy(); + const resultCost = [...resultCostArray.getHeapView()]; + resultCostArray.destroy(); + const resultCount = resultCountRef.value; + Raw.destroy(resultCountRef); + // todo: freeing resultCostRef and resultCountRef intermittently throws + // memory related errors. + // const resultCost = resultCostRef.value; + // const resultCount = resultCountRef.value; + return { + success: statusSucceed(status), + status, + resultRefs, + resultParents, + resultCost, + resultCount + }; + } + /** + * Finds polygons that overlap the search box. + * @param center The center of the search box + * @param halfExtents The search distance along each axis + * @param options + */ + queryPolygons(center, halfExtents, options) { + const filter = options?.filter ?? this.defaultFilter; + const maxPolys = options?.maxPolys ?? 256; + const polysRefsArray = new UnsignedIntArray(); + polysRefsArray.resize(maxPolys); + const polyCountRef = new Raw.IntRef(); + const status = this.raw.queryPolygons(vec3.toArray(center), vec3.toArray(halfExtents), filter.raw, polysRefsArray.raw, polyCountRef, maxPolys); + const polyCount = polyCountRef.value; + Raw.destroy(polyCountRef); + const polyRefs = [...polysRefsArray.getHeapView()].slice(0, polyCount); + polysRefsArray.destroy(); + return { + success: statusSucceed(status), + status, + polyRefs + }; + } + /** + * Returns the closest point on the given polygon to the given position. + * + * @param polyRef The reference of the polygon + * @param position The position to find the closest point to + */ + closestPointOnPoly(polyRef, position) { + const closestPointRaw = new Raw.Vec3(); + const positionOverPolyRaw = new Raw.BoolRef(); + const status = this.raw.closestPointOnPoly(polyRef, vec3.toArray(position), closestPointRaw, positionOverPolyRaw); + const closestPoint = vec3.fromRaw(closestPointRaw); + Raw.destroy(closestPointRaw); + const isPointOverPoly = positionOverPolyRaw.value; + Raw.destroy(positionOverPolyRaw); + return { + success: statusSucceed(status), + status, + closestPoint, + isPointOverPoly + }; + } + /** + * Finds the closest point on the NavMesh to the given position. + * @param position the position to find the closest point to + * @param options additional options + * @returns the result of the find closest point operation + */ + findClosestPoint(position, options) { + const filter = options?.filter ?? this.defaultFilter; + const halfExtents = options?.halfExtents ?? this.defaultQueryHalfExtents; + const resultPolyRef = new Raw.UnsignedIntRef(); + const resultPoint = new Raw.Vec3(); + const resultPointOverPoly = new Raw.BoolRef(); + const status = this.raw.findClosestPoint(vec3.toArray(position), vec3.toArray(halfExtents), filter.raw, resultPolyRef, resultPoint, resultPointOverPoly); + const polyRef = resultPolyRef.value; + Raw.destroy(resultPolyRef); + const point = vec3.fromRaw(resultPoint); + Raw.destroy(resultPoint); + const isPointOverPoly = resultPointOverPoly.value; + Raw.destroy(resultPointOverPoly); + return { + success: statusSucceed(status), + status, + polyRef, + point, + isPointOverPoly + }; + } + /** + * Returns a random point on the NavMesh within the given radius of the given position. + * + * @param position the center of the search circle + * @param radius the radius of the search circle + * @param options additional options + */ + findRandomPointAroundCircle(position, radius, options) { + const filter = options?.filter ?? this.defaultFilter; + const halfExtents = options?.halfExtents ?? this.defaultQueryHalfExtents; + let startRef; + if (options?.startRef) { + startRef = options.startRef; + } else { + const nearestPoly = this.findNearestPoly(position, { + filter, + halfExtents + }); + if (!nearestPoly.success) { + return { + success: false, + status: nearestPoly.status, + randomPolyRef: 0, + randomPoint: { + x: 0, + y: 0, + z: 0 + } + }; + } + startRef = nearestPoly.nearestRef; + } + const randomPolyRefRaw = new Raw.UnsignedIntRef(); + const randomPointRaw = new Raw.Vec3(); + const status = this.raw.findRandomPointAroundCircle(startRef, vec3.toArray(position), radius, filter.raw, randomPolyRefRaw, randomPointRaw); + const randomPolyRef = randomPolyRefRaw.value; + Raw.destroy(randomPolyRefRaw); + const randomPoint = vec3.fromRaw(randomPointRaw); + Raw.destroy(randomPointRaw); + return { + success: statusSucceed(status), + status, + randomPolyRef, + randomPoint + }; + } + /** + * Moves from the start to the end position constrained to the navigation mesh. + * + * @param startRef the reference id of the start polygon. + * @param startPosition a position of the mover within the start polygon. + * @param endPosition the desired end position of the mover. + * + * @returns The result of the move along surface operation. + */ + moveAlongSurface(startRef, startPosition, endPosition, options) { + const maxVisitedSize = options?.maxVisitedSize ?? 256; + const resultPositionRaw = new Raw.Vec3(); + const visitedArray = new UnsignedIntArray(); + const filter = options?.filter?.raw ?? this.defaultFilter.raw; + const status = this.raw.moveAlongSurface(startRef, vec3.toArray(startPosition), vec3.toArray(endPosition), filter, resultPositionRaw, visitedArray.raw, maxVisitedSize); + const resultPosition = vec3.fromRaw(resultPositionRaw); + Raw.destroy(resultPositionRaw); + const visited = [...visitedArray.getHeapView()]; + visitedArray.destroy(); + return { + success: statusSucceed(status), + status, + resultPosition, + visited + }; + } + /** + * Returns a random point on the navmesh. + * @param options additional options + * @returns a random point on the navmesh + */ + findRandomPoint(options) { + const randomPolyRefRaw = new Raw.UnsignedIntRef(); + const randomPointRaw = new Raw.Vec3(); + const status = this.raw.findRandomPoint(options?.filter?.raw ?? this.defaultFilter.raw, randomPolyRefRaw, randomPointRaw); + const randomPolyRef = randomPolyRefRaw.value; + Raw.destroy(randomPolyRefRaw); + const randomPoint = vec3.fromRaw(randomPointRaw); + Raw.destroy(randomPointRaw); + return { + success: statusSucceed(status), + status, + randomPolyRef, + randomPoint + }; + } + /** + * Gets the height of the polygon at the provided position using the height detail. + * + * @param polyRef the reference id of the polygon. + * @param position a position within the xz-bounds of the polygon. + */ + getPolyHeight(polyRef, position) { + const floatRef = new Raw.FloatRef(); + const status = this.raw.getPolyHeight(polyRef, vec3.toArray(position), floatRef); + const height = floatRef.value; + Raw.destroy(floatRef); + return { + success: statusSucceed(status), + status, + height + }; + } + /** + * Finds a straight path from the start position to the end position. + * + * @param start the start position + * @param end the end position + * @param options additional options + * + * @returns an array of Vector3 positions that make up the path, or an empty array if no path was found. + */ + computePath(start, end, options) { + const filter = options?.filter ?? this.defaultFilter; + const halfExtents = options?.halfExtents ?? this.defaultQueryHalfExtents; + // find nearest polygons for start and end positions + const startNearestPolyResult = this.findNearestPoly(start, { + filter, + halfExtents + }); + if (!startNearestPolyResult.success) { + return { + success: false, + error: { + name: 'findNearestPoly for start position failed', + status: startNearestPolyResult.status + }, + path: [] + }; + } + const endNearestPolyResult = this.findNearestPoly(end, { + filter, + halfExtents + }); + if (!endNearestPolyResult.success) { + return { + success: false, + error: { + name: 'findNearestPoly for end position failed', + status: endNearestPolyResult.status + }, + path: [] + }; + } + const startRef = startNearestPolyResult.nearestRef; + const endRef = endNearestPolyResult.nearestRef; + // find polygon path + const maxPathPolys = options?.maxPathPolys ?? 256; + const findPathResult = this.findPath(startRef, endRef, start, end, { + filter, + maxPathPolys + }); + if (!findPathResult.success) { + return { + success: false, + error: { + name: 'findPath unsuccessful', + status: findPathResult.status + }, + path: [] + }; + } + if (findPathResult.polys.size <= 0) { + return { + success: false, + error: { + name: 'no polygon path found' + }, + path: [] + }; + } + const lastPoly = findPathResult.polys.get(findPathResult.polys.size - 1); + let closestEnd = { + x: end.x, + y: end.y, + z: end.z + }; + if (lastPoly !== endRef) { + const lastPolyClosestPointResult = this.closestPointOnPoly(lastPoly, end); + if (!lastPolyClosestPointResult.success) { + return { + success: false, + error: { + name: 'no closest point on last polygon found', + status: lastPolyClosestPointResult.status + }, + path: [] + }; + } + closestEnd = lastPolyClosestPointResult.closestPoint; + } + // find straight path + const maxStraightPathPoints = options?.maxStraightPathPoints; + const findStraightPathResult = this.findStraightPath(start, closestEnd, findPathResult.polys, { + maxStraightPathPoints + }); + if (!findStraightPathResult.success) { + return { + success: false, + error: { + name: 'findStraightPath unsuccessful', + status: findStraightPathResult.status + }, + path: [] + }; + } + const { + straightPath, + straightPathCount + } = findStraightPathResult; + // format output + const points = []; + for (let i = 0; i < straightPathCount; i++) { + points.push({ + x: straightPath.get(i * 3), + y: straightPath.get(i * 3 + 1), + z: straightPath.get(i * 3 + 2) + }); + } + findPathResult.polys.destroy(); + findStraightPathResult.straightPath.destroy(); + findStraightPathResult.straightPathFlags.destroy(); + findStraightPathResult.straightPathRefs.destroy(); + return { + success: true, + path: points + }; + } + /** + * Finds a path from the start polygon to the end polygon. + * @param startRef the reference id of the start polygon. + * @param endRef the reference id of the end polygon. + * @param startPosition position within the start polygon. + * @param endPosition position within the end polygon. + * @param options additional options + * @returns + * + * The `polys` array returned must be freed after use. + * + * ```ts + * findPathResult.polys.destroy(); + * ``` + */ + findPath(startRef, endRef, startPosition, endPosition, options) { + const filter = options?.filter ?? this.defaultFilter; + const maxPathPolys = options?.maxPathPolys ?? 256; + const polysArray = new UnsignedIntArray(); + polysArray.resize(maxPathPolys); + const status = this.raw.findPath(startRef, endRef, vec3.toArray(startPosition), vec3.toArray(endPosition), filter.raw, polysArray.raw, maxPathPolys); + return { + success: statusSucceed(status), + status, + polys: polysArray + }; + } + /** + * Finds the straight path from the start to the end position within the polygon corridor. + * + * This method peforms what is often called 'string pulling'. + * + * The start position is clamped to the first polygon in the path, and the + * end position is clamped to the last. So the start and end positions should + * normally be within or very near the first and last polygons respectively. + * + * The returned polygon references represent the reference id of the polygon + * that is entered at the associated path position. The reference id associated + * with the end point will always be zero. This allows, for example, matching + * off-mesh link points to their representative polygons. + * + * If the provided result arrays are too small for the entire result set, + * they will be filled as far as possible from the start toward the end + * position. + * + * @param start path start position + * @param end path end position + * @param path an array of polygon references that represent the path corridor + * @param options additional options + * @returns the straight path result + * + * The straightPath, straightPathFlags, and straightPathRefs arrays returned must be freed after use. + * + * ```ts + * findStraightPathResult.straightPath.destroy(); + * findStraightPathResult.straightPathFlags.destroy(); + * findStraightPathResult.straightPathRefs.destroy(); + * ``` + */ + findStraightPath(start, end, path, options) { + const maxStraightPathPoints = options?.maxStraightPathPoints ?? 256; + const straightPathOptions = options?.straightPathOptions ?? 0; + let pathPolys; + if (Array.isArray(path)) { + pathPolys = new UnsignedIntArray(); + pathPolys.copy(path); + } else { + pathPolys = path; + } + const straightPath = new FloatArray(); + straightPath.resize(maxStraightPathPoints * 3); + const straightPathFlags = new UnsignedCharArray(); + straightPathFlags.resize(maxStraightPathPoints); + const straightPathRefs = new UnsignedIntArray(); + straightPathRefs.resize(maxStraightPathPoints); + const straightPathCountRaw = new Raw.IntRef(); + const status = this.raw.findStraightPath(vec3.toArray(start), vec3.toArray(end), pathPolys.raw, straightPath.raw, straightPathFlags.raw, straightPathRefs.raw, straightPathCountRaw, maxStraightPathPoints, straightPathOptions); + const straightPathCount = straightPathCountRaw.value; + Raw.destroy(straightPathCountRaw); + if (Array.isArray(path)) { + pathPolys.destroy(); + } + return { + success: statusSucceed(status), + status, + straightPath, + straightPathFlags, + straightPathRefs, + straightPathCount + }; + } + /** + * Casts a 'walkability' ray along the surface of the navigation mesh from the start position toward the end position. + * + * This method is meant to be used for quick, short distance checks. + * + * If the path array is too small to hold the result, it will be filled as far as possible from the start postion toward the end position. + * + * The raycast ignores the y-value of the end position. (2D check.) This places significant limits on how it can be used. + * + * Using the Hit Parameter (t) + * + * If the hit parameter is a very high value, then the ray has hit + * the end position. In this case the path represents a valid corridor to the + * end position and the value of hitNormal is undefined. + * + * If the hit parameter is zero, then the start position is on the wall that + * was hit and the value of hitNormal is undefined. + * + * If 0 < t < 1.0 then the following applies: + * + * ``` + * distanceToHitBorder = distanceToEndPosition * t + * hitPoint = startPos + (endPos - startPos) * t + * ``` + * + * Use Case Restriction + * + * Consider a scene where there is a main floor with a second floor balcony that hangs over the main floor. + * So the first floor mesh extends below the balcony mesh. + * The start position is somewhere on the first floor. + * The end position is on the balcony. + * + * The raycast will search toward the end position along the first floor mesh. + * If it reaches the end position's xz-coordinates it will indicate FLT_MAX,(no wall hit), meaning it reached the end position. + * This is one example of why this method is meant for short distance checks. + * + * @param startRef the reference id of the start polygon. + * @param startPosition a position within the start polygon representing the start of the ray + * @param endPosition the position to cast the ray toward. + * @param options additional options + */ + raycast(startRef, startPosition, endPosition, options) { + const raycastHit = new Raw.Module.dtRaycastHit(); + const raycastOptions = options?.raycastOptions ?? 0; + const prevRef = options?.prevRef ?? 0; + const queryFilter = options?.filter?.raw ?? this.defaultFilter.raw; + const status = this.raw.raycast(startRef, vec3.toArray(startPosition), vec3.toArray(endPosition), queryFilter, raycastOptions, raycastHit, prevRef); + const result = { + success: statusSucceed(status), + status, + t: raycastHit.t, + hitNormal: vec3.fromArray(array(i => raycastHit.get_hitNormal(i), 3)), + hitEdgeIndex: raycastHit.hitEdgeIndex, + path: array(i => raycastHit.get_path(i), raycastHit.pathCount), + maxPath: raycastHit.maxPath, + pathCost: raycastHit.pathCost + }; + Raw.destroy(raycastHit); + return result; + } + /** + * Destroys the NavMeshQuery instance + */ + destroy() { + this.raw.destroy(); + } + } + + const crowdAgentParamsDefaults = { + radius: 0.5, + height: 1, + maxAcceleration: 20, + maxSpeed: 6, + collisionQueryRange: 2.5, + pathOptimizationRange: 0, + separationWeight: 0, + updateFlags: 7, + obstacleAvoidanceType: 0, + queryFilterType: 0, + userData: 0 + }; + class CrowdAgent { + get radius() { + return this.raw.params.radius; + } + set radius(value) { + this.raw.params.radius = value; + } + get height() { + return this.raw.params.height; + } + set height(value) { + this.raw.params.height = value; + } + get maxAcceleration() { + return this.raw.params.maxAcceleration; + } + set maxAcceleration(value) { + this.raw.params.maxAcceleration = value; + } + get maxSpeed() { + return this.raw.params.maxSpeed; + } + set maxSpeed(value) { + this.raw.params.maxSpeed = value; + } + get collisionQueryRange() { + return this.raw.params.collisionQueryRange; + } + set collisionQueryRange(value) { + this.raw.params.collisionQueryRange = value; + } + get pathOptimizationRange() { + return this.raw.params.pathOptimizationRange; + } + set pathOptimizationRange(value) { + this.raw.params.pathOptimizationRange = value; + } + get separationWeight() { + return this.raw.params.separationWeight; + } + set separationWeight(value) { + this.raw.params.separationWeight = value; + } + get updateFlags() { + return this.raw.params.updateFlags; + } + set updateFlags(value) { + this.raw.params.updateFlags = value; + } + get obstacleAvoidanceType() { + return this.raw.params.obstacleAvoidanceType; + } + set obstacleAvoidanceType(value) { + this.raw.params.obstacleAvoidanceType = value; + } + get queryFilterType() { + return this.raw.params.queryFilterType; + } + set queryFilterType(value) { + this.raw.params.queryFilterType = value; + } + get userData() { + return this.raw.params.userData; + } + set userData(value) { + this.raw.params.userData = value; + } + /** + * The interpolated position of the agent. + * + * Use this if stepping the crowd with interpolation. + * This will not be updated if stepping the crowd without interpolation. + */ + interpolatedPosition = { + x: 0, + y: 0, + z: 0 + }; + constructor(crowd, agentIndex) { + this.crowd = crowd; + this.agentIndex = agentIndex; + this.raw = crowd.raw.getEditableAgent(agentIndex); + this.interpolatedPosition = this.position(); + } + /** + * Updates the agent's target. + * @param position The new target position. + * @returns True if the request was successful. + */ + requestMoveTarget(position) { + const { + nearestPoint, + nearestRef + } = this.crowd.navMeshQuery.findNearestPoly(position, { + halfExtents: this.crowd.navMeshQuery.defaultQueryHalfExtents, + filter: this.crowd.navMeshQuery.defaultFilter + }); + return this.crowd.raw.requestMoveTarget(this.agentIndex, nearestRef, vec3.toArray(nearestPoint)); + } + /** + * Submits a new move request for the specified agent. + * @param velocity The desired velocity of the agent. + * @returns True if the request was successful. + */ + requestMoveVelocity(velocity) { + return this.crowd.raw.requestMoveVelocity(this.agentIndex, vec3.toArray(velocity)); + } + /** + * Resets the current move request for the specified agent. + */ + resetMoveTarget() { + this.crowd.raw.resetMoveTarget(this.agentIndex); + } + /** + * Teleports the agent to the specified position. + * @param position + */ + teleport(position) { + Raw.CrowdUtils.agentTeleport(this.crowd.raw, this.agentIndex, vec3.toArray(position), vec3.toArray(this.crowd.navMeshQuery.defaultQueryHalfExtents), this.crowd.navMeshQuery.defaultFilter.raw); + vec3.copy(position, this.interpolatedPosition); + } + /** + * The position of the agent. + * @returns + */ + position() { + return { + x: this.raw.get_npos(0), + y: this.raw.get_npos(1), + z: this.raw.get_npos(2) + }; + } + /** + * The actual velocity of the agent. The change from velocityDesiredObstacleAdjusted -> velocity is constrained by max acceleration. + */ + velocity() { + return { + x: this.raw.get_vel(0), + y: this.raw.get_vel(1), + z: this.raw.get_vel(2) + }; + } + /** + * The desired velocity of the agent. Based on the current path, calculated from scratch each frame. + */ + desiredVelocity() { + return { + x: this.raw.get_dvel(0), + y: this.raw.get_dvel(1), + z: this.raw.get_dvel(2) + }; + } + /** + * The desired velocity adjusted by obstacle avoidance, calculated from scratch each frame. + */ + desiredVelocityObstacleAdjusted() { + return { + x: this.raw.get_nvel(0), + y: this.raw.get_nvel(1), + z: this.raw.get_nvel(2) + }; + } + /** + * Returns the state of the agent. + * + * 0 = DT_CROWDAGENT_STATE_INVALID + * 1 = DT_CROWDAGENT_STATE_WALKING + * 2 = DT_CROWDAGENT_STATE_OFFMESH + */ + state() { + return this.raw.state; + } + /** + * Returns the next target position on the path to the target + * @returns + */ + target() { + return { + x: this.raw.get_targetPos(0), + y: this.raw.get_targetPos(1), + z: this.raw.get_targetPos(2) + }; + } + /** + * Returns the next target position on the path to the target + * @returns + */ + nextTargetInPath() { + return { + x: this.raw.get_cornerVerts(0), + y: this.raw.get_cornerVerts(1), + z: this.raw.get_cornerVerts(2) + }; + } + /** + * Returns the local path corridor corners for the agent + * @returns + */ + corners() { + const points = []; + for (let i = 0; i < this.raw.ncorners; i++) { + points.push({ + x: this.raw.get_cornerVerts(i * 3), + y: this.raw.get_cornerVerts(i * 3 + 1), + z: this.raw.get_cornerVerts(i * 3 + 2) + }); + } + return points; + } + /** + * Returns the agents parameters. + * @returns + */ + parameters() { + const { + params + } = this.raw; + return { + radius: params.radius, + height: params.height, + maxAcceleration: params.maxAcceleration, + maxSpeed: params.maxSpeed, + collisionQueryRange: params.collisionQueryRange, + pathOptimizationRange: params.pathOptimizationRange, + separationWeight: params.separationWeight, + updateFlags: params.updateFlags, + obstacleAvoidanceType: params.obstacleAvoidanceType, + queryFilterType: params.queryFilterType, + userData: params.userData + }; + } + /** + * Updates the agent's parameters. + * Any parameters not specified in the crowdAgentParams object will be unchanged. + * @param crowdAgentParams agent parameters to update. + */ + updateParameters(crowdAgentParams) { + const params = { + ...this.parameters(), + ...crowdAgentParams + }; + this.setParameters(params); + } + /** + * Sets the agent's parameters. + * Any parameters not specified in the crowdAgentParams object will be set to their default values. + * @param crowdAgentParams agent parameters + */ + setParameters(crowdAgentParams) { + const params = { + ...crowdAgentParamsDefaults, + ...crowdAgentParams + }; + const dtCrowdAgentParams = new Raw.Module.dtCrowdAgentParams(); + dtCrowdAgentParams.radius = params.radius; + dtCrowdAgentParams.height = params.height; + dtCrowdAgentParams.maxAcceleration = params.maxAcceleration; + dtCrowdAgentParams.maxSpeed = params.maxSpeed; + dtCrowdAgentParams.collisionQueryRange = params.collisionQueryRange; + dtCrowdAgentParams.pathOptimizationRange = params.pathOptimizationRange; + dtCrowdAgentParams.separationWeight = params.separationWeight; + dtCrowdAgentParams.updateFlags = params.updateFlags; + dtCrowdAgentParams.obstacleAvoidanceType = params.obstacleAvoidanceType; + dtCrowdAgentParams.queryFilterType = params.queryFilterType; + dtCrowdAgentParams.userData = params.userData; + this.crowd.raw.updateAgentParameters(this.agentIndex, dtCrowdAgentParams); + } + /** + * Returns whether the agent is over an off-mesh connection. + * @returns + */ + overOffMeshConnection() { + return Raw.CrowdUtils.overOffMeshConnection(this.crowd.raw, this.agentIndex); + } + } + class Crowd { + /** + * The agents in the crowd. + */ + agents = {}; + /** + * The NavMesh the crowd is interacting with. + */ + + /** + * The NavMeshQuery used to find nearest polys for commands + */ + + /** + * Accumulator for fixed updates with interpolation + */ + accumulator = 0; + /** + * + * @param navMesh the navmesh the crowd will use for planning + * @param param1 the crowd parameters + * + * @example + * ```ts + * const crowd = new Crowd(navMesh, { + * maxAgents: 100, + * maxAgentRadius: 1, + * }); + * ``` + */ + constructor(navMesh, { + maxAgents, + maxAgentRadius + }) { + this.navMesh = navMesh; + this.raw = Raw.Detour.allocCrowd(); + this.raw.init(maxAgents, maxAgentRadius, navMesh.raw.getNavMesh()); + this.navMeshQuery = new NavMeshQuery(new Raw.Module.NavMeshQuery(this.raw.getNavMeshQuery())); + } + /** + * Steps the crowd forward in time with a fixed time step. + * + * There are two modes. The simple mode is fixed timestepping without interpolation. In this case you only use the first argument. The second case uses interpolation. In that you also provide the time since the function was last used, as well as the maximum fixed timesteps to take. + * + * @param dt The fixed time step size to use. + * @param timeSinceLastCalled The time elapsed since the function was last called. + * @param maxSubSteps Maximum number of fixed steps to take per function call. + * + * @example fixed time stepping + * ```ts + * const deltaTime = 1 / 60; + * crowd.update(deltaTime); + * ``` + * + * @example variable time stepping + * ```ts + * crowd.update(timeSinceLastUpdate); + * ``` + * + * @example fixed time stepping with interpolation + * ```ts + * const deltaTime = 1 / 60; + * const maxSubSteps = 10; + * crowd.update(deltaTime, timeSinceLastUpdate, maxSubSteps); + * + * console.log(agent.interpolatedPosition); + * ``` + */ + update(dt, timeSinceLastCalled, maxSubSteps = 10) { + if (timeSinceLastCalled === undefined) { + // fixed step + this.raw.update(dt, undefined); + } else { + this.accumulator += timeSinceLastCalled; + // Do fixed steps to catch up + let substeps = 0; + while (this.accumulator >= dt && substeps < maxSubSteps) { + this.raw.update(dt, undefined); + this.accumulator -= dt; + substeps++; + } + // Interpolate the agent positions + const t = this.accumulator % dt / dt; + const agents = this.getAgents(); + for (const agent of agents) { + vec3.lerp(agent.interpolatedPosition, agent.position(), t, agent.interpolatedPosition); + } + } + } + /** + * Adds a new agent to the crowd. + */ + addAgent(position, crowdAgentParams) { + const params = { + ...crowdAgentParamsDefaults, + ...crowdAgentParams + }; + const dtCrowdAgentParams = new Raw.Module.dtCrowdAgentParams(); + dtCrowdAgentParams.radius = params.radius; + dtCrowdAgentParams.height = params.height; + dtCrowdAgentParams.maxAcceleration = params.maxAcceleration; + dtCrowdAgentParams.maxSpeed = params.maxSpeed; + dtCrowdAgentParams.collisionQueryRange = params.collisionQueryRange; + dtCrowdAgentParams.pathOptimizationRange = params.pathOptimizationRange; + dtCrowdAgentParams.separationWeight = params.separationWeight; + dtCrowdAgentParams.updateFlags = params.updateFlags; + dtCrowdAgentParams.obstacleAvoidanceType = params.obstacleAvoidanceType; + dtCrowdAgentParams.queryFilterType = params.queryFilterType; + dtCrowdAgentParams.userData = params.userData; + const agentIndex = this.raw.addAgent(vec3.toArray(position), dtCrowdAgentParams); + const agent = new CrowdAgent(this, agentIndex); + this.agents[agentIndex] = agent; + return agent; + } + /** + * Gets the agent for the specified index, or null if no agent has the given index. + * @param agentIndex + * @returns + */ + getAgent(agentIndex) { + const agent = this.agents[agentIndex]; + if (!agent) { + return null; + } + return agent; + } + /** + * Removes the agent from the crowd. + */ + removeAgent(agent) { + const agentIndex = typeof agent === 'number' ? agent : agent.agentIndex; + this.raw.removeAgent(agentIndex); + delete this.agents[agentIndex]; + } + /** + * Returns the maximum number of agents that can be managed by the crowd. + */ + getAgentCount() { + return this.raw.getAgentCount(); + } + /** + * Returns the number of active agents in the crowd. + */ + getActiveAgentCount() { + return Raw.CrowdUtils.getActiveAgentCount(this.raw); + } + /** + * Returns all the agents managed by the crowd. + */ + getAgents() { + return Object.values(this.agents); + } + /** + * Gets the query filter for the specified index. + * @param filterIndex the index of the query filter to retrieve, (min 0, max 15) + * @returns the query filter + */ + getFilter(filterIndex) { + return new QueryFilter(this.raw.getEditableFilter(filterIndex)); + } + /** + * Destroys the crowd. + */ + destroy() { + Raw.Detour.freeCrowd(this.raw); + } + } + + /** + * Represents a helper class to visualize navigation cur and related data in PlayCanvas. + */ + class DebugDrawerUtils { + currentPrimitiveType = 0; + currentVertices = []; + primitives = []; + constructor() { + this.debugDrawImpl = new Raw.Module.DebugDrawImpl(); + // Bind the debug draw implementation handlers + this.debugDrawImpl.handleBegin = (primitive, _size) => { + this.currentPrimitiveType = primitive; + this.currentVertices = []; + }; + this.debugDrawImpl.handleDepthMask = _state => { + // unused for now... + }; + this.debugDrawImpl.handleTexture = _state => { + // unused for now... + }; + this.debugDrawImpl.handleVertexWithColor = (x, y, z, color) => { + this.vertex(x, y, z, color); + }; + this.debugDrawImpl.handleVertexWithColorAndUV = (x, y, z, color, _u, _v) => { + this.vertex(x, y, z, color); + }; + const primitiveMap = { + [Raw.Module.DU_DRAW_LINES]: 'lines', + [Raw.Module.DU_DRAW_TRIS]: 'tris', + [Raw.Module.DU_DRAW_QUADS]: 'quads', + [Raw.Module.DU_DRAW_POINTS]: 'points' + }; + this.debugDrawImpl.handleEnd = () => { + const type = primitiveMap[this.currentPrimitiveType]; + this.primitives.push({ + type, + vertices: this.currentVertices + }); + }; + } + flush() { + const cur = this.primitives; + this.primitives = []; + return cur; + } + drawHeightfieldSolid(hf) { + Raw.RecastDebugDraw.debugDrawHeightfieldSolid(this.debugDrawImpl, hf.raw); + return this.flush(); + } + drawHeightfieldWalkable(hf) { + Raw.RecastDebugDraw.debugDrawHeightfieldWalkable(this.debugDrawImpl, hf.raw); + return this.flush(); + } + drawCompactHeightfieldSolid(chf) { + Raw.RecastDebugDraw.debugDrawCompactHeightfieldSolid(this.debugDrawImpl, chf.raw); + return this.flush(); + } + drawCompactHeightfieldRegions(chf) { + Raw.RecastDebugDraw.debugDrawCompactHeightfieldRegions(this.debugDrawImpl, chf.raw); + return this.flush(); + } + drawCompactHeightfieldDistance(chf) { + Raw.RecastDebugDraw.debugDrawCompactHeightfieldDistance(this.debugDrawImpl, chf.raw); + return this.flush(); + } + drawHeightfieldLayer(layer, idx) { + Raw.RecastDebugDraw.debugDrawHeightfieldLayer(this.debugDrawImpl, layer.raw, idx); + return this.flush(); + } + drawHeightfieldLayers(lset) { + Raw.RecastDebugDraw.debugDrawHeightfieldLayers(this.debugDrawImpl, lset.raw); + return this.flush(); + } + drawRegionConnections(cset, alpha = 1) { + Raw.RecastDebugDraw.debugDrawRegionConnections(this.debugDrawImpl, cset.raw, alpha); + return this.flush(); + } + drawRawContours(cset, alpha = 1) { + Raw.RecastDebugDraw.debugDrawRawContours(this.debugDrawImpl, cset.raw, alpha); + return this.flush(); + } + drawContours(cset, alpha = 1) { + Raw.RecastDebugDraw.debugDrawContours(this.debugDrawImpl, cset.raw, alpha); + return this.flush(); + } + drawPolyMesh(mesh) { + Raw.RecastDebugDraw.debugDrawPolyMesh(this.debugDrawImpl, mesh.raw); + return this.flush(); + } + drawPolyMeshDetail(dmesh) { + Raw.RecastDebugDraw.debugDrawPolyMeshDetail(this.debugDrawImpl, dmesh.raw); + return this.flush(); + } + drawNavMesh(mesh, flags = 0) { + Raw.DetourDebugDraw.debugDrawNavMesh(this.debugDrawImpl, mesh.raw.getNavMesh(), flags); + return this.flush(); + } + drawNavMeshWithClosedList(mesh, query, flags = 0) { + Raw.DetourDebugDraw.debugDrawNavMeshWithClosedList(this.debugDrawImpl, mesh.raw.m_navMesh, query.raw.m_navQuery, flags); + return this.flush(); + } + drawNavMeshNodes(query) { + Raw.DetourDebugDraw.debugDrawNavMeshNodes(this.debugDrawImpl, query.raw.m_navQuery); + return this.flush(); + } + drawNavMeshBVTree(mesh) { + Raw.DetourDebugDraw.debugDrawNavMeshBVTree(this.debugDrawImpl, mesh.raw.m_navMesh); + return this.flush(); + } + drawNavMeshPortals(mesh) { + Raw.DetourDebugDraw.debugDrawNavMeshPortals(this.debugDrawImpl, mesh.raw.m_navMesh); + return this.flush(); + } + drawNavMeshPolysWithFlags(mesh, flags, col) { + Raw.DetourDebugDraw.debugDrawNavMeshPolysWithFlags(this.debugDrawImpl, mesh.raw.m_navMesh, flags, col); + return this.flush(); + } + drawNavMeshPoly(mesh, ref, col) { + Raw.DetourDebugDraw.debugDrawNavMeshPoly(this.debugDrawImpl, mesh.raw.m_navMesh, ref, col); + return this.flush(); + } + /** + * Disposes of the debug drawer and releases resources. + */ + dispose() { + Raw.Module.destroy(this.debugDrawImpl); + } + vertex(x, y, z, color) { + const r = (color & 0xff) / 255; + const g = (color >> 8 & 0xff) / 255; + const b = (color >> 16 & 0xff) / 255; + const a = (color >> 24 & 0xff) / 255; + this.currentVertices.push([x, y, z, r, g, b, a]); + } + } + class NavMeshGetTilesAtResult { constructor(raw) { this.raw = raw; @@ -2977,6 +4157,47 @@ default: Recast }); + exports.Crowd = Crowd; + exports.CrowdAgent = CrowdAgent; + exports.DebugDrawerUtils = DebugDrawerUtils; + exports.DetourBVNode = DetourBVNode; + exports.DetourLink = DetourLink; + exports.DetourMeshHeader = DetourMeshHeader; + exports.DetourMeshTile = DetourMeshTile; + exports.DetourOffMeshConnection = DetourOffMeshConnection; + exports.DetourPoly = DetourPoly; + exports.DetourPolyDetail = DetourPolyDetail; + exports.DetourTileCacheParams = DetourTileCacheParams; + exports.FloatArray = FloatArray; + exports.IntArray = IntArray; + exports.NavMesh = NavMesh; + exports.NavMeshCalcTileLocResult = NavMeshCalcTileLocResult; + exports.NavMeshCreateParams = NavMeshCreateParams; + exports.NavMeshGetTilesAtResult = NavMeshGetTilesAtResult; + exports.NavMeshParams = NavMeshParams; + exports.NavMeshQuery = NavMeshQuery; + exports.NavMeshRemoveTileResult = NavMeshRemoveTileResult; + exports.NavMeshStoreTileStateResult = NavMeshStoreTileStateResult; + exports.QueryFilter = QueryFilter; + exports.RecastBuildContext = RecastBuildContext; + exports.RecastChunkyTriMesh = RecastChunkyTriMesh; + exports.RecastCompactCell = RecastCompactCell; + exports.RecastCompactHeightfield = RecastCompactHeightfield; + exports.RecastCompactSpan = RecastCompactSpan; + exports.RecastContour = RecastContour; + exports.RecastContourSet = RecastContourSet; + exports.RecastHeightfield = RecastHeightfield; + exports.RecastHeightfieldLayer = RecastHeightfieldLayer; + exports.RecastHeightfieldLayerSet = RecastHeightfieldLayerSet; + exports.RecastPolyMesh = RecastPolyMesh; + exports.RecastPolyMeshDetail = RecastPolyMeshDetail; + exports.RecastSpan = RecastSpan; + exports.RecastSpanPool = RecastSpanPool; + exports.TileCache = TileCache; + exports.TileCacheMeshProcess = TileCacheMeshProcess; + exports.UnsignedCharArray = UnsignedCharArray; + exports.UnsignedIntArray = UnsignedIntArray; + exports.UnsignedShortArray = UnsignedShortArray; exports.buildTiledNavMeshRcConfig = buildTiledNavMeshRcConfig; exports.createDefaultTileCacheMeshProcess = createDefaultTileCacheMeshProcess; exports.dtIlog2 = dtIlog2; diff --git a/GDJS/Runtime/types/global-recast.d.ts b/GDJS/Runtime/types/global-recast.d.ts index 15b906094471..6bf816666168 100644 --- a/GDJS/Runtime/types/global-recast.d.ts +++ b/GDJS/Runtime/types/global-recast.d.ts @@ -1,19 +1,3 @@ -import { - buildTiledNavMeshRcConfig, - createDefaultTileCacheMeshProcess, - dtIlog2, - dtNextPow2, - generateSoloNavMesh, - generateSoloNavMeshData, - generateTileCache, - generateTileNavMeshData, - generateTiledNavMesh, - getBoundingBox, - mergePositionsAndIndices, - soloNavMeshGeneratorConfigDefaults, - tileCacheGeneratorConfigDefaults, - tiledNavMeshGeneratorConfigDefaults, -} from 'recast-navigation/generators'; import { init, DebugDrawerUtils, @@ -83,8 +67,106 @@ import { NavMeshQueryParams, } from 'recast-navigation'; +import { + buildTiledNavMeshRcConfig, + createDefaultTileCacheMeshProcess, + dtIlog2, + dtNextPow2, + generateSoloNavMesh, + generateSoloNavMeshData, + generateTileCache, + generateTileNavMeshData, + generateTiledNavMesh, + getBoundingBox, + mergePositionsAndIndices, + soloNavMeshGeneratorConfigDefaults, + tileCacheGeneratorConfigDefaults, + tiledNavMeshGeneratorConfigDefaults, +} from 'recast-navigation/generators'; + declare global { namespace RecastNav { - export { generateSoloNavMesh, NavMesh }; + export { + init, + DebugDrawerUtils, + RecastBuildContext, + RecastChunkyTriMesh, + RecastSpan, + RecastSpanPool, + RecastHeightfield, + RecastCompactCell, + RecastCompactSpan, + RecastCompactHeightfield, + RecastContour, + RecastContourSet, + RecastHeightfieldLayer, + RecastHeightfieldLayerSet, + RecastPolyMesh, + RecastPolyMeshDetail, + IntArray, + UnsignedIntArray, + UnsignedCharArray, + UnsignedShortArray, + FloatArray, + QueryFilter, + NavMeshQuery, + CrowdAgent, + Crowd, + NavMeshGetTilesAtResult, + NavMeshRemoveTileResult, + NavMeshCalcTileLocResult, + NavMeshStoreTileStateResult, + NavMeshParams, + NavMesh, + DetourTileCacheParams, + TileCache, + TileCacheMeshProcess, + DetourPolyDetail, + DetourLink, + DetourBVNode, + DetourOffMeshConnection, + DetourMeshHeader, + DetourPoly, + DetourMeshTile, + NavMeshCreateParams, + DebugDrawerPrimitiveType, + DebugDrawerPrimitive, + ObstacleRef, + BoxObstacle, + CylinderObstacle, + AddObstacleResult, + RemoveObstacleResult, + Obstacle, + TileCacheParamsType, + TileCacheUpdateResult, + NavMeshDecodePolyIdResult, + NavMeshParamsType, + ImportNavMeshResult, + ImportTileCacheResult, + Pretty, + RecastConfig, + OffMeshConnectionParams, + Vector3, + Vector3Tuple, + Vector2, + Vector2Tuple, + CrowdAgentParams, + CrowdParams, + NavMeshQueryParams, + buildTiledNavMeshRcConfig, + createDefaultTileCacheMeshProcess, + dtIlog2, + dtNextPow2, + generateSoloNavMesh, + generateSoloNavMeshData, + generateTileCache, + generateTileNavMeshData, + generateTiledNavMesh, + getBoundingBox, + mergePositionsAndIndices, + soloNavMeshGeneratorConfigDefaults, + tileCacheGeneratorConfigDefaults, + tiledNavMeshGeneratorConfigDefaults, + }; } } From bda10d70af02af70804763f5265f4e62ec3ac5cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 30 Jul 2026 11:22:44 +0200 Subject: [PATCH 04/51] Fix slopes --- .../NavMeshObstacleRuntimeBehavior.ts | 19 ++++++++++--------- GDJS/Runtime/types/global-recast.d.ts | 2 ++ 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index d67631546061..22e26fce0c6d 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -29,6 +29,7 @@ namespace gdjs { export class NavMeshObstaclesManager { obstacles = new Set(); navMesh: RecastNav.NavMesh | null = null; + crowd: RecastNav.Crowd | null = null; constructor(instanceContainer: gdjs.RuntimeInstanceContainer) {} @@ -45,13 +46,13 @@ namespace gdjs { } rebuildNavMesh() { - const navMeshConfig = { + const navMeshConfig: Partial = { borderSize: 0, - cs: 2, - ch: 2, + cs: 10, + ch: 10, walkableSlopeAngle: 60, - walkableHeight: 1, - walkableClimb: 1, + walkableHeight: 10, + walkableClimb: 2, walkableRadius: 1, maxEdgeLen: 12, maxSimplificationError: 1.3, @@ -59,7 +60,7 @@ namespace gdjs { mergeRegionArea: 20, maxVertsPerPoly: 6, detailSampleDist: 6, - detailSampleMaxError: 1, + detailSampleMaxError: 10, }; const positions: Array = []; @@ -88,9 +89,9 @@ namespace gdjs { point.set(x, y, z); euler.set( - object.getRotationX(), - object.getRotationY(), - object.getAngle() + gdjs.toRad(object.getRotationX()), + gdjs.toRad(object.getRotationY()), + gdjs.toRad(object.getAngle()) ); point.applyEuler(euler); diff --git a/GDJS/Runtime/types/global-recast.d.ts b/GDJS/Runtime/types/global-recast.d.ts index 6bf816666168..aa7084f5fe67 100644 --- a/GDJS/Runtime/types/global-recast.d.ts +++ b/GDJS/Runtime/types/global-recast.d.ts @@ -82,6 +82,7 @@ import { soloNavMeshGeneratorConfigDefaults, tileCacheGeneratorConfigDefaults, tiledNavMeshGeneratorConfigDefaults, + SoloNavMeshGeneratorConfig, } from 'recast-navigation/generators'; declare global { @@ -167,6 +168,7 @@ declare global { soloNavMeshGeneratorConfigDefaults, tileCacheGeneratorConfigDefaults, tiledNavMeshGeneratorConfigDefaults, + SoloNavMeshGeneratorConfig, }; } } From 09907dccf784301bbf1a144384b976133bb82087 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 30 Jul 2026 12:43:47 +0200 Subject: [PATCH 05/51] Use agents --- .../NavMeshCharacterRuntimeBehavior.ts | 195 +++++------------- .../NavMeshObstacleRuntimeBehavior.ts | 80 +++++++ 2 files changed, 135 insertions(+), 140 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 4d169eab39ed..8d45eb67f14e 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -104,15 +104,18 @@ namespace gdjs { this._gridOffsetY = behaviorData.gridOffsetY || 0; this._extraBorder = behaviorData.extraBorder; this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap || 0; - this._manager = - gdjs.NavMeshObstaclesManager.getManager(instanceContainer); // TODO Remove this._acceleration = 1000; this._maxSpeed = 300; - this._angularMaxSpeed = 720; + this._angularMaxSpeed = 360; this._rotateObject = true; this._angleOffset = 0; + this._angularSpeed = this._angularMaxSpeed; + + this._manager = + gdjs.NavMeshObstaclesManager.getManager(instanceContainer); + this._manager.addCharacter(this); } override applyBehaviorOverriding(behaviorData): boolean { @@ -212,6 +215,22 @@ namespace gdjs { } } + onActivate() { + if (this._registeredInManager) { + return; + } + this._manager.addCharacter(this); + this._registeredInManager = true; + } + + onDeActivate() { + if (!this._registeredInManager) { + return; + } + this._manager.removeCharacter(this); + this._registeredInManager = false; + } + setCellWidth(width: float): void { this._cellWidth = width; } @@ -424,26 +443,6 @@ namespace gdjs { moveTo(x: float, y: float, z: float) { const owner = this.owner; - // First be sure that there is a path to compute. - const targetCellX = Math.round((x - this._gridOffsetX) / this._cellWidth); - const targetCellY = Math.round( - (y - this._gridOffsetY) / this._cellHeight - ); - const startCellX = Math.round( - (owner.getX() - this._gridOffsetX) / this._cellWidth - ); - const startCellY = Math.round( - (owner.getY() - this._gridOffsetY) / this._cellHeight - ); - if (startCellX == targetCellX && startCellY == targetCellY) { - this._path.length = 0; - this._path.push({ x: owner.getX(), y: owner.getY(), z: owner.getZ() }); - this._path.push({ x, y, z }); - this._enterSegment(0); - this._pathFound = true; - return; - } - if (!this._manager.navMesh) { this._manager.rebuildNavMesh(); } @@ -455,25 +454,6 @@ namespace gdjs { // Start searching for a path const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); - const { success: hasFindOrigin, point: origin } = - navMeshQuery.findClosestPoint( - { - x: owner.getX(), - y: owner.getZ(), - z: owner.getY(), - }, - { halfExtents: { x: 100, y: 100, z: 100 } } - ); - if (!hasFindOrigin) { - this._pathFound = false; - console.log( - "Can't find origin", - owner.getX(), - owner.getY(), - owner.getZ() - ); - return; - } const { success: hasFindDestination, point: destination } = navMeshQuery.findClosestPoint( { x, y: z, z: y }, @@ -484,35 +464,14 @@ namespace gdjs { console.log("Can't find destination", x, y, z); return; } - const { - success: hasFindPath, - error, - path, - } = navMeshQuery.computePath(origin, destination); - if (!hasFindPath) { - this._pathFound = false; - console.log( - "Can't find a path from", - origin.x, - origin.z, - origin.y, - 'to', - destination.x, - destination.z, - destination.y - ); - return; - } - // Path found: memorize it - for (const point of path) { - const y = point.y; - point.y = point.z; - point.z = y; + const agent = this._manager.characterAgents.get(this); + if (!agent) { + console.log('No agent'); + return; } - console.log('path', path); - this._path = path; - this._enterSegment(0); + const hasFindPath = agent.requestMoveTarget(destination); + console.log('hasFindPath', hasFindPath); } _enterSegment(segmentNumber: integer) { @@ -542,86 +501,42 @@ namespace gdjs { } doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { - if (this._path.length === 0 || this._reachedEnd) { + const timeDelta = this.owner.getElapsedTime() / 1000; + this._manager.step(timeDelta); + + const agent = this._manager.characterAgents.get(this); + if (!agent) { return; } - // Update the speed of the object - const timeDelta = this.owner.getElapsedTime() / 1000; - const previousSpeed = this._speed; - if (this._speed !== this._maxSpeed) { - this._speed += this._acceleration * timeDelta; - if (this._speed > this._maxSpeed) { - this._speed = this._maxSpeed; - } - } - this._angularSpeed = this._angularMaxSpeed; + const oldX = this.owner.getX(); + const oldY = this.owner.getY(); + const newX = agent.interpolatedPosition.x; + const newY = agent.interpolatedPosition.z; + const newZ = agent.interpolatedPosition.y; + this.owner.setX(newX); + this.owner.setY(newY); + this.owner.setZ(newZ); - // Update the time on the segment and change segment if needed - // Use a Verlet integration to be frame rate independent. - this._distanceOnSegment += - ((this._speed + previousSpeed) / 2) * timeDelta; - const remainingDistanceOnSegment = - this._totalSegmentDistance - this._distanceOnSegment; + if (newX != oldX && newY != oldY) { + this._movementAngle = gdjs.toDegrees( + Math.atan2(newY - oldY, newX - oldX) + ); + } if ( - remainingDistanceOnSegment <= 0 && - this._currentSegment < this._path.length + this._rotateObject && + this.owner.getAngle() !== this._movementAngle + this._angleOffset ) { - this._enterSegment(this._currentSegment + 1); - this._distanceOnSegment = -remainingDistanceOnSegment; - } - - // Position object on the segment and update its angle - let x = 0; - let y = 0; - let z = 0; - if (this._currentSegment < this._path.length - 1) { - x = gdjs.evtTools.common.lerp( - this._path[this._currentSegment].x, - this._path[this._currentSegment + 1].x, - this._distanceOnSegment / this._totalSegmentDistance + this.owner.rotateTowardAngle( + this._movementAngle + this._angleOffset, + this._angularSpeed ); - y = gdjs.evtTools.common.lerp( - this._path[this._currentSegment].y, - this._path[this._currentSegment + 1].y, - this._distanceOnSegment / this._totalSegmentDistance - ); - z = gdjs.evtTools.common.lerp( - this._path[this._currentSegment].z, - this._path[this._currentSegment + 1].z, - this._distanceOnSegment / this._totalSegmentDistance - ); - if ( - this._rotateObject && - this.owner.getAngle() !== this._movementAngle + this._angleOffset - ) { - this.owner.rotateTowardAngle( - this._movementAngle + this._angleOffset, - this._angularSpeed - ); - } - } else { - const newPos = this._path[this._path.length - 1]; - x = newPos.x; - y = newPos.y; - z = newPos.z; - } - console.log( - 'move', - this._distanceOnSegment, - '/', - this._totalSegmentDistance, - 'at', - x, - y, - z - ); - this.owner.setX(x); - this.owner.setY(y); - this.owner.setZ(z); + } } - doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {} + doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + this._manager.hasStepped = false; + } } gdjs.registerBehavior( 'NavMeshPathfinding::NavMeshCharacterBehavior', diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 22e26fce0c6d..ab26ea7b0a96 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -30,6 +30,11 @@ namespace gdjs { obstacles = new Set(); navMesh: RecastNav.NavMesh | null = null; crowd: RecastNav.Crowd | null = null; + characterAgents = new Map< + NavMeshCharacterRuntimeBehavior, + RecastNav.CrowdAgent | null + >(); + hasStepped = false; constructor(instanceContainer: gdjs.RuntimeInstanceContainer) {} @@ -45,6 +50,18 @@ namespace gdjs { return instanceContainer.navMeshObstaclesManager; } + step(timeDelta: float) { + if (this.hasStepped) { + return; + } + this.hasStepped = true; + + if (!this.crowd) { + return; + } + this.crowd.update(1 / 60, timeDelta, 8); + } + rebuildNavMesh() { const navMeshConfig: Partial = { borderSize: 0, @@ -114,7 +131,53 @@ namespace gdjs { ); if (result.success) { this.navMesh = result.navMesh; + this.crowd = new RecastNav.Crowd(this.navMesh, { + maxAgents: 100, + maxAgentRadius: 50, + }); + for (const character of this.characterAgents.keys()) { + this.rebuildCharacterAgent(character); + } + } + } + + private rebuildCharacterAgent(character: NavMeshCharacterRuntimeBehavior) { + if (!this.navMesh || !this.crowd) { + this.characterAgents.set(character, null); + return; } + const owner = character.owner; + const navMeshQuery = new RecastNav.NavMeshQuery(this.navMesh); + const { success: hasFindOrigin, point: origin } = + navMeshQuery.findClosestPoint( + { + x: owner.getX(), + y: owner.getZ(), + z: owner.getY(), + }, + { halfExtents: { x: 100, y: 100, z: 100 } } + ); + if (!hasFindOrigin) { + console.log( + "Can't find origin", + owner.getX(), + owner.getY(), + owner.getZ() + ); + return; + } + const agent = this.crowd + ? this.crowd.addAgent(origin, { + radius: 40, + height: 100, + maxAcceleration: 1000, + maxSpeed: 300, + collisionQueryRange: 60, + pathOptimizationRange: 0.0, + separationWeight: 1.0, + }) + : null; + this.characterAgents.set(character, agent); } /** @@ -133,6 +196,23 @@ namespace gdjs { ) { this.obstacles.delete(pathfindingObstacleBehavior); } + + /** + * Add a character to the list of existing characters. + */ + addCharacter(character: NavMeshCharacterRuntimeBehavior) { + if (this.characterAgents.get(character)) { + return; + } + this.rebuildCharacterAgent(character); + } + + /** + * Remove a character from the list of existing characters. + */ + removeCharacter(character: NavMeshCharacterRuntimeBehavior) { + this.characterAgents.delete(character); + } } /** From 243cd75eb0465b5859d818a44eb6f96646647848 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 30 Jul 2026 14:30:13 +0200 Subject: [PATCH 06/51] Smooth the rotation --- .../NavMeshCharacterRuntimeBehavior.ts | 46 +++++++++++++++++-- .../NavMeshObstacleRuntimeBehavior.ts | 2 +- 2 files changed, 42 insertions(+), 6 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 8d45eb67f14e..63f7fb20edfe 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -59,6 +59,7 @@ namespace gdjs { _acceleration: float; _maxSpeed: float; _angularMaxSpeed: float; + _angularAcceleration: float; _rotateObject: boolean; _angleOffset: float; _cellWidth: float; @@ -108,7 +109,8 @@ namespace gdjs { // TODO Remove this._acceleration = 1000; this._maxSpeed = 300; - this._angularMaxSpeed = 360; + this._angularMaxSpeed = 720; + this._angularAcceleration = 7200; this._rotateObject = true; this._angleOffset = 0; this._angularSpeed = this._angularMaxSpeed; @@ -527,11 +529,45 @@ namespace gdjs { this._rotateObject && this.owner.getAngle() !== this._movementAngle + this._angleOffset ) { - this.owner.rotateTowardAngle( - this._movementAngle + this._angleOffset, - this._angularSpeed - ); + this.rotateTowardAngle(this._movementAngle + this._angleOffset); + } + } + + /** + * @param angle The targeted angle. + * @param speed The rotation speed. 0 for an immediate rotation to the target angle. + */ + private rotateTowardAngle(angle: float): void { + const angularDiff = gdjs.evtTools.common.angleDifference( + this.owner.getAngle(), + angle + ); + const diffWasPositive = angularDiff >= 0; + + const timeDelta = this.owner.getElapsedTime() / 1000; + // Always rotate the right way. + if ((this._angularSpeed > 0) ^ diffWasPositive) { + this._angularSpeed = 0; + } + this._angularSpeed = gdjs.evtTools.common.clamp( + this._angularSpeed + + (diffWasPositive ? -1.0 : 1.0) * + this._angularAcceleration * + timeDelta, + -this._angularMaxSpeed, + this._angularMaxSpeed + ); + let newAngle = + this.owner.getAngle() + this._angularSpeed * timeDelta; + + if ( + // @ts-ignore + (gdjs.evtTools.common.angleDifference(newAngle, angle) > 0) ^ + diffWasPositive + ) { + newAngle = angle; } + this.owner.setAngle(newAngle); } doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index ab26ea7b0a96..0217cbce18c4 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -172,7 +172,7 @@ namespace gdjs { height: 100, maxAcceleration: 1000, maxSpeed: 300, - collisionQueryRange: 60, + collisionQueryRange: 120, pathOptimizationRange: 0.0, separationWeight: 1.0, }) From 6da6e9895c0ca5362d4b075137fa1bf926ae65fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 30 Jul 2026 18:01:40 +0200 Subject: [PATCH 07/51] Handle meshes --- Extensions/NavMeshPathfinding/JsExtension.js | 48 ++++- .../NavMeshObstacleRuntimeBehavior.ts | 195 ++++++++++++++---- 2 files changed, 206 insertions(+), 37 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 5cda024f26df..166ea0d44aa2 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -115,14 +115,60 @@ module.exports = { propertyName, newValue ) { + if (propertyName === 'shape') { + const normalizedValue = newValue.toLowerCase(); + let shapeValue = ''; + if (normalizedValue === 'box') shapeValue = 'Box'; + else if (normalizedValue === 'capsule') shapeValue = 'Capsule'; + else if (normalizedValue === 'sphere') shapeValue = 'Sphere'; + else if (normalizedValue === 'cylinder') shapeValue = 'Cylinder'; + else if (normalizedValue === 'mesh') shapeValue = 'Mesh'; + else return false; + + behaviorContent.getOrCreateChild('shape').setStringValue(shapeValue); + if (shapeValue === 'Mesh') { + behaviorContent + .getOrCreateChild('bodyType') + .setStringValue('Static'); + } + return true; + } + + if (propertyName === 'meshShapeResourceName') { + behaviorContent + .getOrCreateChild('meshShapeResourceName') + .setStringValue(newValue); + return true; + } return false; }; behavior.getProperties = function (behaviorContent) { const behaviorProperties = new gd.MapStringPropertyDescriptor(); + + behaviorProperties + .getOrCreate('shape') + .setValue(behaviorContent.getChild('shape').getStringValue()) + .setType('Choice') + .setLabel('Shape') + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden) + .addChoice('Box', _('Box')) + .addChoice('Mesh', _('Mesh')); + behaviorProperties + .getOrCreate('meshShapeResourceName') + .setValue( + behaviorContent.getChild('meshShapeResourceName').getStringValue() + ) + .setType('resource') + .addExtraInfo('model3D') + .setLabel(_("Simplified 3D model (leave empty to use object's one)")); + return behaviorProperties; }; - behavior.initializeContent = function (behaviorContent) {}; + behavior.initializeContent = function (behaviorContent) { + behaviorContent.addChild('shape').setStringValue('Box'); + behaviorContent.addChild('meshShapeResourceName').setStringValue(''); + }; const sharedData = new gd.BehaviorSharedDataJsImplementation(); sharedData.updateProperty = function ( diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 0217cbce18c4..ac949d873ccf 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -17,6 +17,13 @@ namespace gdjs { 7, 8, 7, 1, 8, 2, 3, 4, 3, 5, 4, ]; + const isModel3D = ( + object: gdjs.RuntimeObject + ): object is gdjs.Model3DRuntimeObject => { + //@ts-ignore We are checking if the methods are present. + return object._modelResourceName; + }; + /** * NavMeshObstaclesManager manages the common objects shared by objects * having a pathfinding behavior: In particular, the obstacles behaviors are @@ -82,45 +89,13 @@ namespace gdjs { const positions: Array = []; const indices: Array = []; - - const euler = new THREE.Euler(); - euler.order = 'ZYX'; - const point = new THREE.Vector3(); - for (const obstacle of this.obstacles) { //@ts-ignore const object: gdjs.RuntimeObject3D = obstacle.owner; - const indicesOffset = Math.round(positions.length / 3); - for ( - let index = 0; - index + 2 < cubePositions.length; - index = index + 3 - ) { - let x = cubePositions[index]; - let y = cubePositions[index + 2]; - let z = cubePositions[index + 1]; - - x *= object.getWidth(); - y *= object.getHeight(); - z *= object.getDepth(); - - point.set(x, y, z); - euler.set( - gdjs.toRad(object.getRotationX()), - gdjs.toRad(object.getRotationY()), - gdjs.toRad(object.getAngle()) - ); - point.applyEuler(euler); - - x = object.getCenterXInScene() + point.x; - y = object.getCenterYInScene() + point.y; - z = object.getCenterZInScene() + point.z; - - // Y is the top for Recast - positions.push(x, z, y); - } - for (const vertexIndex of cubeIndices) { - indices.push(vertexIndex + indicesOffset); + if (obstacle._shape === 'Mesh' && isModel3D(object)) { + this.addMeshFor(object, positions, indices); + } else { + this.addBoxFor(object, positions, indices); } } @@ -141,6 +116,149 @@ namespace gdjs { } } + private addBoxFor( + object: gdjs.RuntimeObject3D, + positions: Array, + indices: Array + ): void { + const point = new THREE.Vector3(); + const euler = new THREE.Euler(); + euler.order = 'ZYX'; + + const indicesOffset = Math.round(positions.length / 3); + for (let index = 0; index + 2 < cubePositions.length; index = index + 3) { + let x = cubePositions[index]; + let y = cubePositions[index + 2]; + let z = cubePositions[index + 1]; + + x *= object.getWidth(); + y *= object.getHeight(); + z *= object.getDepth(); + + point.set(x, y, z); + euler.set( + gdjs.toRad(object.getRotationX()), + gdjs.toRad(object.getRotationY()), + gdjs.toRad(object.getAngle()) + ); + point.applyEuler(euler); + + x = object.getCenterXInScene() + point.x; + y = object.getCenterYInScene() + point.y; + z = object.getCenterZInScene() + point.z; + + // Y is the top for Recast + positions.push(x, z, y); + } + for (const vertexIndex of cubeIndices) { + indices.push(vertexIndex + indicesOffset); + } + } + + private addMeshFor( + model3DRuntimeObject: gdjs.Model3DRuntimeObject, + positions: Array, + indices: Array + ): void { + const originalModel = model3DRuntimeObject + .getInstanceContainer() + .getGame() + .getModel3DManager() + .getModel( + this.meshShapeResourceName || + model3DRuntimeObject._modelResourceName || + '' + ); + + const modelInCube = new THREE.Group(); + modelInCube.rotation.order = 'ZYX'; + const root = THREE_ADDONS.SkeletonUtils.clone(originalModel.scene); + modelInCube.add(root); + + const data = model3DRuntimeObject._data.content; + model3DRuntimeObject._renderer.stretchModelIntoUnitaryCube( + modelInCube, + data.rotationX, + data.rotationY, + data.rotationZ + ); + + const threeObject = new THREE.Group(); + threeObject.rotation.order = 'ZYX'; + threeObject.add(modelInCube); + const object = model3DRuntimeObject; + const width = object.getWidth(); + const height = object.getHeight(); + const depth = object.getDepth(); + threeObject.scale.set( + object.isFlippedX() ? -width : width, + object.isFlippedY() ? -height : height, + object.isFlippedZ() ? -depth : depth + ); + threeObject.position.set( + object.getCenterXInScene(), + object.getCenterYInScene(), + object.getCenterZInScene(), + ); + threeObject.rotation.set( + gdjs.toRad(object.getRotationX()), + gdjs.toRad(object.getRotationY()), + gdjs.toRad(object.getAngle()), + ); + + threeObject.updateMatrixWorld(); + + // For indexed triangles + const vector3 = new THREE.Vector3(); + + threeObject.traverse((object3d) => { + const mesh = object3d as THREE.Mesh; + if (!mesh.isMesh) { + return; + } + const indicesOffset = Math.round(positions.length / 3); + const positionAttribute = mesh.geometry.getAttribute('position'); + object3d.getWorldScale(vector3); + // Negate it because we swap Y and Z. + const shouldTrianglesBeFlipped = !(vector3.x * vector3.y * vector3.z < 0); + const index = mesh.geometry.getIndex(); + if (index) { + for (let i = 0; i < positionAttribute.count; i++) { + vector3.fromBufferAttribute(positionAttribute, i); + object3d.localToWorld(vector3); + positions.push(vector3.x, vector3.z, vector3.y); + } + for (let i = 0; i < index.count; i += 3) { + indices.push( + indicesOffset + index.getX(shouldTrianglesBeFlipped ? i + 1 : i), + indicesOffset + index.getX(shouldTrianglesBeFlipped ? i : i + 1), + indicesOffset + index.getX(i + 2) + ); + } + } else { + for (let i = 0; i < positionAttribute.count; i += 3) { + vector3.fromBufferAttribute(positionAttribute, i); + object3d.localToWorld(vector3); + positions.push(vector3.x, vector3.z, vector3.y); + + vector3.fromBufferAttribute(positionAttribute, i + 1); + object3d.localToWorld(vector3); + positions.push(vector3.x, vector3.z, vector3.y); + + vector3.fromBufferAttribute(positionAttribute, i + 2); + object3d.localToWorld(vector3); + positions.push(vector3.x, vector3.z, vector3.y); + + indices.push( + indicesOffset + shouldTrianglesBeFlipped ? i + 1 : i, + indicesOffset + shouldTrianglesBeFlipped ? i : i + 1, + indicesOffset + i + 2 + ); + } + } + }); + } + private rebuildCharacterAgent(character: NavMeshCharacterRuntimeBehavior) { if (!this.navMesh || !this.crowd) { this.characterAgents.set(character, null); @@ -223,6 +341,9 @@ namespace gdjs { export class NavMeshObstacleRuntimeBehavior extends gdjs.RuntimeBehavior { _impassable: boolean; _cost: float; + _shape: string; + _meshShapeResourceName: string; + _oldX: float = 0; _oldY: float = 0; _oldWidth: float = 0; @@ -238,6 +359,8 @@ namespace gdjs { super(instanceContainer, behaviorData, owner); this._impassable = behaviorData.impassable; this._cost = behaviorData.cost; + this._shape = behaviorData.shape; + this.meshShapeResourceName = behaviorData.meshShapeResourceName || ''; this._manager = NavMeshObstaclesManager.getManager(instanceContainer); //Note that we can't use getX(), getWidth()... of owner here: From 3c08268a75877a871670d7853e8120bd0b0adef4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Fri, 31 Jul 2026 14:06:32 +0200 Subject: [PATCH 08/51] Fix extension count check --- newIDE/app/src/JsExtensionsLoader/LocalJsExtensionsLoader.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/newIDE/app/src/JsExtensionsLoader/LocalJsExtensionsLoader.js b/newIDE/app/src/JsExtensionsLoader/LocalJsExtensionsLoader.js index c8a9683efbd2..01d8d7dea48b 100644 --- a/newIDE/app/src/JsExtensionsLoader/LocalJsExtensionsLoader.js +++ b/newIDE/app/src/JsExtensionsLoader/LocalJsExtensionsLoader.js @@ -31,7 +31,7 @@ type GetExpectedNumberOfJSExtensionModulesArguments = {| function getExpectedNumberOfJSExtensionModules( { filterExamples } /*: GetExpectedNumberOfJSExtensionModulesArguments*/ ) /*:number*/ { - return 29 + (filterExamples ? 0 : 1); + return 30 + (filterExamples ? 0 : 1); } /** From 51cb366b5e676ec07df8c0e26b447ca0fa6455eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Fri, 31 Jul 2026 14:06:45 +0200 Subject: [PATCH 09/51] Add some properties --- Extensions/NavMeshPathfinding/JsExtension.js | 233 ++++++++++++++++-- .../NavMeshCharacterRuntimeBehavior.ts | 153 +++--------- .../NavMeshObstacleRuntimeBehavior.ts | 83 ++++--- 3 files changed, 293 insertions(+), 176 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 166ea0d44aa2..ddab869d5846 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -39,14 +39,144 @@ module.exports = { propertyName, newValue ) { + if (propertyName === 'acceleration') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + behaviorContent + .getOrCreateChild('acceleration') + .setDoubleValue(newValueAsNumber); + return true; + } + + if (propertyName === 'maxSpeed') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + behaviorContent + .getOrCreateChild('maxSpeed') + .setDoubleValue(newValueAsNumber); + return true; + } + + if (propertyName === 'angularMaxSpeed') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + behaviorContent + .getOrCreateChild('angularMaxSpeed') + .setDoubleValue(newValueAsNumber); + return true; + } + + if (propertyName === 'rotateObject') { + behaviorContent + .getOrCreateChild('rotateObject') + .setBoolValue(newValue === '1'); + return true; + } + + if (propertyName === 'angleOffset') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + behaviorContent + .getOrCreateChild('angleOffset') + .setDoubleValue(newValueAsNumber); + return true; + } + + if (propertyName === 'radius') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + behaviorContent + .getOrCreateChild('radius') + .setDoubleValue(newValueAsNumber); + return true; + } + + if (propertyName === 'avoidanceSightRange') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + behaviorContent + .getOrCreateChild('avoidanceSightRange') + .setDoubleValue(newValueAsNumber); + return true; + } + return false; }; behavior.getProperties = function (behaviorContent) { const behaviorProperties = new gd.MapStringPropertyDescriptor(); + + behaviorProperties + .getOrCreate('acceleration') + .setValue(behaviorContent.getChild('acceleration').getStringValue()) + .setLabel(_('Acceleration')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixelAcceleration()); + + behaviorProperties + .getOrCreate('maxSpeed') + .setValue(behaviorContent.getChild('maxSpeed').getStringValue()) + .setLabel(_('Max. speed')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixelSpeed()); + + behaviorProperties + .getOrCreate('angularMaxSpeed') + .setValue( + behaviorContent.getChild('angularMaxSpeed').getStringValue() + ) + .setLabel(_('Rotation speed')) + .setGroup(_('Rotation')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getAngularSpeed()); + + behaviorProperties + .getOrCreate('rotateObject') + .setValue( + behaviorContent.getChild('rotateObject').getBoolValue() + ? 'true' + : 'false' + ) + .setLabel(_('Rotate object')) + .setGroup(_('Rotation')) + .setType('Boolean'); + + behaviorProperties + .getOrCreate('angleOffset') + .setValue(behaviorContent.getChild('angleOffset').getStringValue()) + .setLabel(_('Angle offset')) + .setGroup(_('Rotation')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getDegreeAngle()); + + behaviorProperties + .getOrCreate('radius') + .setValue(behaviorContent.getChild('radius').getStringValue()) + .setLabel(_('Radius')) + .setGroup(_('Collision')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setAdvanced(true); + + behaviorProperties + .getOrCreate('avoidanceSightRange') + .setValue(behaviorContent.getChild('avoidanceSightRange').getStringValue()) + .setLabel(_('Avoidance sight range')) + .setGroup(_('Collision')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()); + return behaviorProperties; }; - behavior.initializeContent = function (behaviorContent) {}; + behavior.initializeContent = function (behaviorContent) { + behaviorContent.addChild('acceleration').setDoubleValue(400); + behaviorContent.addChild('maxSpeed').setDoubleValue(200); + behaviorContent.addChild('angularMaxSpeed').setDoubleValue(180); + behaviorContent.addChild('rotateObject').setBoolValue(true); + behaviorContent.addChild('angleOffset').setDoubleValue(0); + behaviorContent.addChild('radius').setDoubleValue(0); + behaviorContent.addChild('avoidanceSightRange').setDoubleValue(120); + }; const sharedData = new gd.BehaviorSharedDataJsImplementation(); sharedData.updateProperty = function ( @@ -54,13 +184,81 @@ module.exports = { propertyName, newValue ) { + if (propertyName === 'cellSize') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('cellSize') + .setDoubleValue(newValueAsNumber); + return true; + } + if (propertyName === 'cellDepth') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('cellDepth') + .setDoubleValue(newValueAsNumber); + return true; + } + if (propertyName === 'slopeMaxAngle') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('slopeMaxAngle') + .setDoubleValue(newValueAsNumber); + return true; + } return false; }; sharedData.getProperties = function (sharedContent) { const sharedProperties = new gd.MapStringPropertyDescriptor(); + + sharedProperties + .getOrCreate('cellSize') + .setLabel('Cell size') + .setGroup('') + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setValue( + sharedContent.getChild('cellSize').getDoubleValue().toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + + sharedProperties + .getOrCreate('cellDepth') + .setLabel('Cell depth') + .setGroup('') + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setValue( + sharedContent.getChild('cellDepth').getDoubleValue().toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + + sharedProperties + .getOrCreate('slopeMaxAngle') + .setLabel('Slope max. angle') + .setGroup('') + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getDegreeAngle()) + .setValue( + sharedContent + .getChild('slopeMaxAngle') + .getDoubleValue() + .toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + return sharedProperties; }; - sharedData.initializeContent = function (behaviorContent) {}; + sharedData.initializeContent = function (sharedContent) { + sharedContent.addChild('cellSize').setDoubleValue(10); + sharedContent.addChild('cellDepth').setDoubleValue(10); + sharedContent.addChild('slopeMaxAngle').setDoubleValue(50); + }; const aut = extension .addBehavior( @@ -94,19 +292,22 @@ module.exports = { 'Extensions/NavMeshPathfinding/recast-navigation-generators.js' ); - aut.addAction("MoveTo", - _("Move to a position"), - _("Move the object to a position"), - _("Move _PARAM0_ to _PARAM2_ ; _PARAM3_ ; _PARAM4_"), - _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") - .addParameter("object", _("Object")) - .addParameter("behavior", _("Behavior"), "NavMeshCharacterBehavior") - .addParameter("expression", _("Destination X position")) - .addParameter("expression", _("Destination Y position")) - .addParameter("expression", _("Destination Z position")) - .setFunctionName("moveTo"); + aut + .addAction( + 'MoveTo', + _('Move to a position'), + _('Move the object to a position'), + _('Move _PARAM0_ to _PARAM2_ ; _PARAM3_ ; _PARAM4_'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon24.png', + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .addParameter('expression', _('Destination X position')) + .addParameter('expression', _('Destination Y position')) + .addParameter('expression', _('Destination Z position')) + .setFunctionName('moveTo'); } { const behavior = new gd.BehaviorJsImplementation(); @@ -182,7 +383,7 @@ module.exports = { const sharedProperties = new gd.MapStringPropertyDescriptor(); return sharedProperties; }; - sharedData.initializeContent = function (behaviorContent) {}; + sharedData.initializeContent = function (sharedContent) {}; const aut = extension .addBehavior( diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 63f7fb20edfe..3e93d48bd1f0 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -55,19 +55,19 @@ namespace gdjs { static _smoothingWorkingVertices: Array = []; //Behavior configuration: - _allowDiagonals: boolean; - _acceleration: float; - _maxSpeed: float; _angularMaxSpeed: float; _angularAcceleration: float; _rotateObject: boolean; _angleOffset: float; - _cellWidth: float; - _cellHeight: float; - _gridOffsetX: float; - _gridOffsetY: float; - _extraBorder: float; - _smoothingMaxCellGap: float; + _radius: float; + _crowdAgentParams: Partial = { + radius: 40, + height: 100, + maxAcceleration: 1000, + maxSpeed: 300, + collisionQueryRange: 120, + separationWeight: 1.0, + }; //Attributes used for traveling on the path: _pathFound: boolean = false; @@ -93,27 +93,16 @@ namespace gdjs { } else { this._path.length = 0; } - this._allowDiagonals = behaviorData.allowDiagonals; - this._acceleration = behaviorData.acceleration; - this._maxSpeed = behaviorData.maxSpeed; this._angularMaxSpeed = behaviorData.angularMaxSpeed; this._rotateObject = behaviorData.rotateObject; this._angleOffset = behaviorData.angleOffset; - this._cellWidth = behaviorData.cellWidth; - this._cellHeight = behaviorData.cellHeight; - this._gridOffsetX = behaviorData.gridOffsetX || 0; - this._gridOffsetY = behaviorData.gridOffsetY || 0; - this._extraBorder = behaviorData.extraBorder; - this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap || 0; + this._radius = behaviorData.radius; + this._crowdAgentParams.maxAcceleration = behaviorData.acceleration; + this._crowdAgentParams.maxSpeed = behaviorData.maxSpeed; + this._crowdAgentParams.collisionQueryRange = behaviorData.avoidanceSightRange; // TODO Remove - this._acceleration = 1000; - this._maxSpeed = 300; - this._angularMaxSpeed = 720; this._angularAcceleration = 7200; - this._rotateObject = true; - this._angleOffset = 0; - this._angularSpeed = this._angularMaxSpeed; this._manager = gdjs.NavMeshObstaclesManager.getManager(instanceContainer); @@ -121,9 +110,6 @@ namespace gdjs { } override applyBehaviorOverriding(behaviorData): boolean { - if (behaviorData.allowDiagonals !== undefined) { - this.allowDiagonals(behaviorData.allowDiagonals); - } if (behaviorData.acceleration !== undefined) { this.setAcceleration(behaviorData.acceleration); } @@ -139,28 +125,10 @@ namespace gdjs { if (behaviorData.angleOffset !== undefined) { this.setAngleOffset(behaviorData.angleOffset); } - if (behaviorData.cellWidth !== undefined) { - this.setCellWidth(behaviorData.cellWidth); - } - if (behaviorData.cellHeight !== undefined) { - this.setCellHeight(behaviorData.cellHeight); - } - if (behaviorData.gridOffsetX !== undefined) { - this._gridOffsetX = behaviorData.gridOffsetX; - } - if (behaviorData.gridOffsetY !== undefined) { - this._gridOffsetY = behaviorData.gridOffsetY; - } - if (behaviorData.extraBorder !== undefined) { - this.setExtraBorder(behaviorData.extraBorder); - } - if (behaviorData.smoothingMaxCellGap !== undefined) { - this._smoothingMaxCellGap = behaviorData.smoothingMaxCellGap; - } return true; } - getNetworkSyncData( + override getNetworkSyncData( options: GetNetworkSyncDataOptions ): NavMeshCharacterNetworkSyncData { return { @@ -179,7 +147,7 @@ namespace gdjs { }; } - updateFromNetworkSyncData( + override updateFromNetworkSyncData( networkSyncData: NavMeshCharacterNetworkSyncData, options: UpdateFromNetworkSyncDataOptions ): void { @@ -217,83 +185,43 @@ namespace gdjs { } } - onActivate() { - if (this._registeredInManager) { - return; - } + override onActivate() { this._manager.addCharacter(this); - this._registeredInManager = true; } - onDeActivate() { - if (!this._registeredInManager) { - return; - } + override onDeActivate() { this._manager.removeCharacter(this); - this._registeredInManager = false; - } - - setCellWidth(width: float): void { - this._cellWidth = width; - } - - getCellWidth(): float { - return this._cellWidth; - } - - setCellHeight(height: float): void { - this._cellHeight = height; - } - - getCellHeight(): float { - return this._cellHeight; - } - - setGridOffsetX(gridOffsetX: float): void { - this._gridOffsetX = gridOffsetX; - } - - getGridOffsetX(): float { - return this._gridOffsetX; - } - - setGridOffsetY(gridOffsetY: float): void { - this._gridOffsetY = gridOffsetY; - } - - getGridOffsetY(): float { - return this._gridOffsetY; } setAcceleration(acceleration: float): void { - this._acceleration = acceleration; + this._crowdAgentParams.maxAcceleration = acceleration; } - getAcceleration() { - return this._acceleration; + getAcceleration(): float { + return this._crowdAgentParams.maxAcceleration || 0; } setMaxSpeed(maxSpeed: float): void { - this._maxSpeed = maxSpeed; + this._crowdAgentParams.maxSpeed = maxSpeed; } - getMaxSpeed() { - return this._maxSpeed; + getMaxSpeed(): float { + return this._crowdAgentParams.maxSpeed || 0; } setSpeed(speed: float): void { this._speed = speed; } - getSpeed() { + getSpeed(): float { return this._speed; } - getMovementAngle() { + getMovementAngle(): float { return this._movementAngle; } - movementAngleIsAround(degreeAngle: float, tolerance: float) { + movementAngleIsAround(degreeAngle: float, tolerance: float): boolean { return ( Math.abs( gdjs.evtTools.common.angleDifference(this._movementAngle, degreeAngle) @@ -317,22 +245,6 @@ namespace gdjs { return this._angleOffset; } - setExtraBorder(extraBorder): void { - this._extraBorder = extraBorder; - } - - getExtraBorder() { - return this._extraBorder; - } - - allowDiagonals(allow: boolean) { - this._allowDiagonals = allow; - } - - diagonalsAllowed() { - return this._allowDiagonals; - } - setRotateObject(allow: boolean): void { this._rotateObject = allow; } @@ -443,8 +355,6 @@ namespace gdjs { * Compute and move on the path to the specified destination. */ moveTo(x: float, y: float, z: float) { - const owner = this.owner; - if (!this._manager.navMesh) { this._manager.rebuildNavMesh(); } @@ -502,7 +412,7 @@ namespace gdjs { } } - doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { const timeDelta = this.owner.getElapsedTime() / 1000; this._manager.step(timeDelta); @@ -546,7 +456,7 @@ namespace gdjs { const timeDelta = this.owner.getElapsedTime() / 1000; // Always rotate the right way. - if ((this._angularSpeed > 0) ^ diffWasPositive) { + if (this._angularSpeed > 0 !== diffWasPositive) { this._angularSpeed = 0; } this._angularSpeed = gdjs.evtTools.common.clamp( @@ -557,8 +467,7 @@ namespace gdjs { -this._angularMaxSpeed, this._angularMaxSpeed ); - let newAngle = - this.owner.getAngle() + this._angularSpeed * timeDelta; + let newAngle = this.owner.getAngle() + this._angularSpeed * timeDelta; if ( // @ts-ignore @@ -570,7 +479,9 @@ namespace gdjs { this.owner.setAngle(newAngle); } - doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + override doStepPostEvents( + instanceContainer: gdjs.RuntimeInstanceContainer + ) { this._manager.hasStepped = false; } } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index ac949d873ccf..bd0f745acf80 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -42,17 +42,39 @@ namespace gdjs { RecastNav.CrowdAgent | null >(); hasStepped = false; - - constructor(instanceContainer: gdjs.RuntimeInstanceContainer) {} + private navMeshConfig: Partial = { + borderSize: 0, + cs: 10, + ch: 10, + walkableSlopeAngle: 60, + walkableHeight: 10, + walkableClimb: 2, + walkableRadius: 0.5, + maxEdgeLen: 12, + maxSimplificationError: 1.3, + minRegionArea: 8, + mergeRegionArea: 20, + maxVertsPerPoly: 6, + detailSampleDist: 6, + detailSampleMaxError: 10, + }; + + constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { + this.navMeshConfig.cs = sharedData.cellSize; + this.navMeshConfig.ch = sharedData.cellDepth; + this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; + } /** * Get the obstacles manager of an instance container. */ static getManager(instanceContainer: gdjs.RuntimeInstanceContainer) { if (!instanceContainer.navMeshObstaclesManager) { - //Create the shared manager if necessary. + // Create the shared manager if necessary. + const initialData = + instanceContainer.getInitialSharedDataForBehavior('NavMeshCharacter'); instanceContainer.navMeshObstaclesManager = - new gdjs.NavMeshObstaclesManager(instanceContainer); + new gdjs.NavMeshObstaclesManager(instanceContainer, initialData); } return instanceContainer.navMeshObstaclesManager; } @@ -70,30 +92,13 @@ namespace gdjs { } rebuildNavMesh() { - const navMeshConfig: Partial = { - borderSize: 0, - cs: 10, - ch: 10, - walkableSlopeAngle: 60, - walkableHeight: 10, - walkableClimb: 2, - walkableRadius: 1, - maxEdgeLen: 12, - maxSimplificationError: 1.3, - minRegionArea: 8, - mergeRegionArea: 20, - maxVertsPerPoly: 6, - detailSampleDist: 6, - detailSampleMaxError: 10, - }; - const positions: Array = []; const indices: Array = []; for (const obstacle of this.obstacles) { //@ts-ignore const object: gdjs.RuntimeObject3D = obstacle.owner; if (obstacle._shape === 'Mesh' && isModel3D(object)) { - this.addMeshFor(object, positions, indices); + this.addMeshFor(object, obstacle, positions, indices); } else { this.addBoxFor(object, positions, indices); } @@ -102,7 +107,7 @@ namespace gdjs { const result = RecastNav.generateSoloNavMesh( positions, indices, - navMeshConfig + this.navMeshConfig ); if (result.success) { this.navMesh = result.navMesh; @@ -157,6 +162,7 @@ namespace gdjs { private addMeshFor( model3DRuntimeObject: gdjs.Model3DRuntimeObject, + obstacle: NavMeshObstacleRuntimeBehavior, positions: Array, indices: Array ): void { @@ -165,7 +171,7 @@ namespace gdjs { .getGame() .getModel3DManager() .getModel( - this.meshShapeResourceName || + obstacle._meshShapeResourceName || model3DRuntimeObject._modelResourceName || '' ); @@ -198,12 +204,12 @@ namespace gdjs { threeObject.position.set( object.getCenterXInScene(), object.getCenterYInScene(), - object.getCenterZInScene(), + object.getCenterZInScene() ); threeObject.rotation.set( gdjs.toRad(object.getRotationX()), gdjs.toRad(object.getRotationY()), - gdjs.toRad(object.getAngle()), + gdjs.toRad(object.getAngle()) ); threeObject.updateMatrixWorld(); @@ -220,7 +226,10 @@ namespace gdjs { const positionAttribute = mesh.geometry.getAttribute('position'); object3d.getWorldScale(vector3); // Negate it because we swap Y and Z. - const shouldTrianglesBeFlipped = !(vector3.x * vector3.y * vector3.z < 0); + const shouldTrianglesBeFlipped = !( + vector3.x * vector3.y * vector3.z < + 0 + ); const index = mesh.geometry.getIndex(); if (index) { for (let i = 0; i < positionAttribute.count; i++) { @@ -250,8 +259,8 @@ namespace gdjs { positions.push(vector3.x, vector3.z, vector3.y); indices.push( - indicesOffset + shouldTrianglesBeFlipped ? i + 1 : i, - indicesOffset + shouldTrianglesBeFlipped ? i : i + 1, + indicesOffset + (shouldTrianglesBeFlipped ? i + 1 : i), + indicesOffset + (shouldTrianglesBeFlipped ? i : i + 1), indicesOffset + i + 2 ); } @@ -284,16 +293,12 @@ namespace gdjs { ); return; } + + character._crowdAgentParams.radius = + character._radius || Math.min(owner.getWidth(), owner.getHeight()); + character._crowdAgentParams.height = owner.getDepth(); const agent = this.crowd - ? this.crowd.addAgent(origin, { - radius: 40, - height: 100, - maxAcceleration: 1000, - maxSpeed: 300, - collisionQueryRange: 120, - pathOptimizationRange: 0.0, - separationWeight: 1.0, - }) + ? this.crowd.addAgent(origin, character._crowdAgentParams) : null; this.characterAgents.set(character, agent); } @@ -360,7 +365,7 @@ namespace gdjs { this._impassable = behaviorData.impassable; this._cost = behaviorData.cost; this._shape = behaviorData.shape; - this.meshShapeResourceName = behaviorData.meshShapeResourceName || ''; + this._meshShapeResourceName = behaviorData.meshShapeResourceName || ''; this._manager = NavMeshObstaclesManager.getManager(instanceContainer); //Note that we can't use getX(), getWidth()... of owner here: From 93c103d14f2c2225ed90aab0fa4e5746f55e4c74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 1 Aug 2026 17:03:07 +0200 Subject: [PATCH 10/51] Fix types --- .../NavMeshCharacterRuntimeBehavior.ts | 11 +++++++--- .../NavMeshObstacleRuntimeBehavior.ts | 20 +++++++------------ 2 files changed, 15 insertions(+), 16 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 3e93d48bd1f0..26ced140a018 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -99,9 +99,10 @@ namespace gdjs { this._radius = behaviorData.radius; this._crowdAgentParams.maxAcceleration = behaviorData.acceleration; this._crowdAgentParams.maxSpeed = behaviorData.maxSpeed; - this._crowdAgentParams.collisionQueryRange = behaviorData.avoidanceSightRange; + this._crowdAgentParams.collisionQueryRange = + behaviorData.avoidanceSightRange; - // TODO Remove + // TODO Add a property for it? this._angularAcceleration = 7200; this._manager = @@ -428,7 +429,11 @@ namespace gdjs { const newZ = agent.interpolatedPosition.y; this.owner.setX(newX); this.owner.setY(newY); - this.owner.setZ(newZ); + //@ts-ignore + if (this.owner.setZ) { + //@ts-ignore + this.owner.setZ(newZ); + } if (newX != oldX && newY != oldY) { this._movementAngle = gdjs.toDegrees( diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index bd0f745acf80..fa22d737b927 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -43,25 +43,17 @@ namespace gdjs { >(); hasStepped = false; private navMeshConfig: Partial = { - borderSize: 0, cs: 10, ch: 10, - walkableSlopeAngle: 60, + walkableSlopeAngle: 50, walkableHeight: 10, - walkableClimb: 2, - walkableRadius: 0.5, - maxEdgeLen: 12, - maxSimplificationError: 1.3, - minRegionArea: 8, - mergeRegionArea: 20, - maxVertsPerPoly: 6, - detailSampleDist: 6, - detailSampleMaxError: 10, + detailSampleMaxError: 50, }; constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { this.navMeshConfig.cs = sharedData.cellSize; this.navMeshConfig.ch = sharedData.cellDepth; + this.navMeshConfig.detailSampleMaxError = sharedData.cellDepth * 5; this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; } @@ -279,7 +271,8 @@ namespace gdjs { navMeshQuery.findClosestPoint( { x: owner.getX(), - y: owner.getZ(), + //@ts-ignore + y: owner.getZ ? owner.getZ() : 0, z: owner.getY(), }, { halfExtents: { x: 100, y: 100, z: 100 } } @@ -296,7 +289,8 @@ namespace gdjs { character._crowdAgentParams.radius = character._radius || Math.min(owner.getWidth(), owner.getHeight()); - character._crowdAgentParams.height = owner.getDepth(); + //@ts-ignore + character._crowdAgentParams.height = owner.getDepth ? owner.getDepth() : 1; const agent = this.crowd ? this.crowd.addAgent(origin, character._crowdAgentParams) : null; From 4996130c63c836533d8e62976e6ab60cc3accff9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 1 Aug 2026 18:16:48 +0200 Subject: [PATCH 11/51] Handle obstacle changes. --- .../NavMeshCharacterRuntimeBehavior.ts | 4 +- .../NavMeshObstacleRuntimeBehavior.ts | 97 ++++++++++++++++--- 2 files changed, 84 insertions(+), 17 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 26ced140a018..0a46e5be31fd 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -356,9 +356,7 @@ namespace gdjs { * Compute and move on the path to the specified destination. */ moveTo(x: float, y: float, z: float) { - if (!this._manager.navMesh) { - this._manager.rebuildNavMesh(); - } + this._manager.rebuildNavMeshIfNeeded(); if (!this._manager.navMesh) { console.log("Can't build the nav mesh"); return; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index fa22d737b927..9a5446f868ea 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -36,6 +36,9 @@ namespace gdjs { export class NavMeshObstaclesManager { obstacles = new Set(); navMesh: RecastNav.NavMesh | null = null; + timeSinceLastNavMeshLastRebuild: float = 1; + isNavMeshDirty = true; + isFirstFrame = true; crowd: RecastNav.Crowd | null = null; characterAgents = new Map< NavMeshCharacterRuntimeBehavior, @@ -76,6 +79,13 @@ namespace gdjs { return; } this.hasStepped = true; + this.timeSinceLastNavMeshLastRebuild += timeDelta; + // Don't try to build the nav mesh before the events get a chance + // to build the level. + if (!this.isFirstFrame) { + this.rebuildNavMeshIfNeeded(); + } + this.isFirstFrame = false; if (!this.crowd) { return; @@ -83,7 +93,16 @@ namespace gdjs { this.crowd.update(1 / 60, timeDelta, 8); } - rebuildNavMesh() { + invalidateNavMesh() { + this.isNavMeshDirty = true; + } + + rebuildNavMeshIfNeeded() { + if (!this.isNavMeshDirty || this.timeSinceLastNavMeshLastRebuild < 1) { + return; + } + console.log('Rebuild the NavMesh'); + this.timeSinceLastNavMeshLastRebuild = 0; const positions: Array = []; const indices: Array = []; for (const obstacle of this.obstacles) { @@ -110,6 +129,7 @@ namespace gdjs { for (const character of this.characterAgents.keys()) { this.rebuildCharacterAgent(character); } + this.isNavMeshDirty = false; } } @@ -289,11 +309,22 @@ namespace gdjs { character._crowdAgentParams.radius = character._radius || Math.min(owner.getWidth(), owner.getHeight()); - //@ts-ignore - character._crowdAgentParams.height = owner.getDepth ? owner.getDepth() : 1; + character._crowdAgentParams.height = + //@ts-ignore + owner.getDepth + ? //@ts-ignore + owner.getDepth() + : 1; const agent = this.crowd ? this.crowd.addAgent(origin, character._crowdAgentParams) : null; + + if (agent) { + const oldAgent = this.characterAgents.get(character); + if (oldAgent) { + agent.requestMoveTarget(oldAgent.target()); + } + } this.characterAgents.set(character, agent); } @@ -302,6 +333,7 @@ namespace gdjs { */ addObstacle(pathfindingObstacleBehavior: NavMeshObstacleRuntimeBehavior) { this.obstacles.add(pathfindingObstacleBehavior); + this.invalidateNavMesh(); } /** @@ -312,6 +344,7 @@ namespace gdjs { pathfindingObstacleBehavior: NavMeshObstacleRuntimeBehavior ) { this.obstacles.delete(pathfindingObstacleBehavior); + this.invalidateNavMesh(); } /** @@ -345,8 +378,13 @@ namespace gdjs { _oldX: float = 0; _oldY: float = 0; + _oldZ: float = 0; _oldWidth: float = 0; _oldHeight: float = 0; + _oldDepth: float = 0; + _oldRotationX: float = 0; + _oldRotationY: float = 0; + _oldRotationZ: float = 0; _manager: NavMeshObstaclesManager; _registeredInManager: boolean = false; @@ -383,7 +421,6 @@ namespace gdjs { } doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { - //Make sure the obstacle is or is not in the obstacles manager. if (!this.activated() && this._registeredInManager) { this._manager.removeObstacle(this); this._registeredInManager = false; @@ -394,20 +431,52 @@ namespace gdjs { } } - //Track changes in size or position + const newX = this.owner.getX(); + const newY = this.owner.getY(); + //@ts-ignore + const newZ = this.owner.getZ ? this.owner.getZ() : 0; + const newWidth = this.owner.getWidth(); + const newHeight = this.owner.getHeight(); + //@ts-ignore + const newDepth = this.owner.getDepth ? this.owner.getDepth() : 0; + //@ts-ignore + const newRotationX = this.owner.getRotationX + ? //@ts-ignore + this.owner.getRotationX() + : 0; + //@ts-ignore + const newRotationY = this.owner.getRotationY + ? //@ts-ignore + this.owner.getRotationY() + : 0; + //@ts-ignore + const newRotationZ = this.owner.getRotationZ + ? //@ts-ignore + this.owner.getRotationZ() + : 0; if ( - this._oldX !== this.owner.getX() || - this._oldY !== this.owner.getY() || - this._oldWidth !== this.owner.getWidth() || - this._oldHeight !== this.owner.getHeight() + this._oldX !== newX || + this._oldY !== newY || + this._oldZ !== newZ || + this._oldWidth !== newWidth || + this._oldHeight !== newHeight || + this._oldDepth !== newDepth || + this._oldRotationX !== newRotationX || + this._oldRotationY !== newRotationY || + this._oldRotationZ !== newRotationZ ) { if (this._registeredInManager) { - // TODO Notify that the mesh is out of date? + this._manager.invalidateNavMesh(); } - this._oldX = this.owner.getX(); - this._oldY = this.owner.getY(); - this._oldWidth = this.owner.getWidth(); - this._oldHeight = this.owner.getHeight(); + this._oldX = newX; + this._oldY = newY; + this._oldZ = newZ; + this._oldWidth = newWidth; + this._oldHeight = newHeight; + this._oldDepth = newDepth; + this._oldRotationX = newRotationX; + this._oldRotationY = newRotationY; + this._oldRotationZ = newRotationZ; } } From ed65b38e26a9c65c831dcb6541e0a940bc9fc521 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sun, 2 Aug 2026 19:41:40 +0200 Subject: [PATCH 12/51] Handle 2D --- .../NavMeshCharacterRuntimeBehavior.ts | 20 +- .../NavMeshObstacleRuntimeBehavior.ts | 747 +++++++++++++++++- 2 files changed, 751 insertions(+), 16 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 0a46e5be31fd..512800f89122 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -359,6 +359,7 @@ namespace gdjs { this._manager.rebuildNavMeshIfNeeded(); if (!this._manager.navMesh) { console.log("Can't build the nav mesh"); + this._pathFound = false; return; } @@ -379,10 +380,25 @@ namespace gdjs { const agent = this._manager.characterAgents.get(this); if (!agent) { console.log('No agent'); + this._pathFound = false; return; } - const hasFindPath = agent.requestMoveTarget(destination); - console.log('hasFindPath', hasFindPath); + this._pathFound = agent.requestMoveTarget(destination); + console.log( + 'hasFindPath', + this._pathFound, + this.owner.x, + this.owner.y, + //@ts-ignore + this.owner.getZ ? this.owner.getZ() : 0, + ' -> ', + x, + y, + z + ); + if (this._pathFound) { + this._reachedEnd = false; + } } _enterSegment(segmentNumber: integer) { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 9a5446f868ea..13cdfe0e6c64 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -35,6 +35,7 @@ namespace gdjs { */ export class NavMeshObstaclesManager { obstacles = new Set(); + is3D = false; navMesh: RecastNav.NavMesh | null = null; timeSinceLastNavMeshLastRebuild: float = 1; isNavMeshDirty = true; @@ -51,6 +52,7 @@ namespace gdjs { walkableSlopeAngle: 50, walkableHeight: 10, detailSampleMaxError: 50, + walkableClimb: 2, }; constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { @@ -108,28 +110,147 @@ namespace gdjs { for (const obstacle of this.obstacles) { //@ts-ignore const object: gdjs.RuntimeObject3D = obstacle.owner; - if (obstacle._shape === 'Mesh' && isModel3D(object)) { - this.addMeshFor(object, obstacle, positions, indices); - } else { - this.addBoxFor(object, positions, indices); + if (gdjs.Base3DHandler.is3D(object)) { + if (isModel3D(object) && obstacle._shape === 'Mesh') { + this.addMeshFor(object, obstacle, positions, indices); + } else { + this.addBoxFor(object, positions, indices); + } + } else if (!this.is3D) { + this.addPolygonsFor(object, positions, indices); } } + if (!this.is3D && positions.length > 0) { + this.addGroundFor2D(positions, indices); + this.navMeshConfig.walkableClimb = 0; + } const result = RecastNav.generateSoloNavMesh( positions, indices, this.navMeshConfig ); + console.log("Built", result.success); + this.navMeshConfig.walkableClimb = 2; if (result.success) { this.navMesh = result.navMesh; this.crowd = new RecastNav.Crowd(this.navMesh, { maxAgents: 100, - maxAgentRadius: 50, + maxAgentRadius: 100, }); for (const character of this.characterAgents.keys()) { this.rebuildCharacterAgent(character); } - this.isNavMeshDirty = false; + } + this.isNavMeshDirty = false; + } + + private addGroundFor2D( + positions: Array, + indices: Array + ): void { + let minX = Number.POSITIVE_INFINITY; + let minY = Number.POSITIVE_INFINITY; + let maxX = Number.NEGATIVE_INFINITY; + let maxY = Number.NEGATIVE_INFINITY; + for (let index = 0; index + 2 < positions.length; index += 3) { + const x = positions[index]; + const y = positions[index + 2]; + minX = Math.min(minX, x); + minY = Math.min(minY, y); + maxX = Math.max(maxX, x); + maxY = Math.max(maxY, y); + } + const width = maxX - minX; + const height = maxY - minY; + const centerX = (maxX + minX) / 2; + const centerY = (maxY + minY) / 2; + + console.log(width, height, centerX, centerY); + + const indicesOffset = Math.round(positions.length / 3); + for (let index = 0; index + 2 < cubePositions.length; index = index + 3) { + let x = cubePositions[index]; + let y = cubePositions[index + 2]; + let z = cubePositions[index + 1]; + + x *= width; + y *= height; + z *= 10; + + x += centerX; + y += centerY; + z -= 5; + + // Y is the top for Recast + positions.push(x, z, y); + } + for (const vertexIndex of cubeIndices) { + indices.push(vertexIndex + indicesOffset); + } + } + + private addPolygonsFor( + object: gdjs.RuntimeObject3D, + positions: Array, + indices: Array + ): void { + const vertexFlags: Array = []; + for (const hitBox of object.getHitBoxes()) { + let indicesOffset = Math.round(positions.length / 3); + const vertices: Array = hitBox.vertices.map(([x, y]) => ({ + x, + y, + })); + if ( + getSignedAreaX2( + vertices[0].x, + vertices[0].y, + vertices[1].x, + vertices[1].y, + vertices[2].x, + vertices[2].y + ) > 0 + ) { + vertices.reverse(); + } + triangulate( + vertices, + vertexFlags, + (p1: Point, p2: Point, p3: Point) => { + // Top + positions.push(p1.x, 10, p1.y); + positions.push(p2.x, 10, p2.y); + positions.push(p3.x, 10, p3.y); + indices.push( + indicesOffset + 0, + indicesOffset + 1, + indicesOffset + 2 + ); + // Bottom + positions.push(p1.x, 0, p1.y); + positions.push(p2.x, 0, p2.y); + positions.push(p3.x, 0, p3.y); + indices.push( + indicesOffset + 3, + indicesOffset + 5, + indicesOffset + 4 + ); + indicesOffset += 6; + } + ); + for (let index = 0; index < vertices.length; index++) { + const vertex = vertices[index]; + // Side + positions.push(vertex.x, 10, vertex.y); + positions.push(vertex.x, 0, vertex.y); + indices.push(indicesOffset + 0, indicesOffset + 1, indicesOffset + 2); + indices.push(indicesOffset + 3, indicesOffset + 2, indicesOffset + 1); + indicesOffset += 2; + } + const vertex = vertices[0]; + positions.push(vertex.x, 10, vertex.y); + positions.push(vertex.x, 0, vertex.y); } } @@ -302,13 +423,15 @@ namespace gdjs { "Can't find origin", owner.getX(), owner.getY(), - owner.getZ() + //@ts-ignore + owner.getZ ? owner.getZ() : 0 ); return; } character._crowdAgentParams.radius = character._radius || Math.min(owner.getWidth(), owner.getHeight()); + console.log(character._crowdAgentParams.radius); character._crowdAgentParams.height = //@ts-ignore owner.getDepth @@ -321,7 +444,7 @@ namespace gdjs { if (agent) { const oldAgent = this.characterAgents.get(character); - if (oldAgent) { + if (oldAgent && !character.destinationReached()) { agent.requestMoveTarget(oldAgent.target()); } } @@ -331,8 +454,11 @@ namespace gdjs { /** * Add a obstacle to the list of existing obstacles. */ - addObstacle(pathfindingObstacleBehavior: NavMeshObstacleRuntimeBehavior) { - this.obstacles.add(pathfindingObstacleBehavior); + addObstacle(obstacle: NavMeshObstacleRuntimeBehavior) { + this.obstacles.add(obstacle); + if (gdjs.Base3DHandler.is3D(obstacle.owner)) { + this.is3D = true; + } this.invalidateNavMesh(); } @@ -340,10 +466,8 @@ namespace gdjs { * Remove a obstacle from the list of existing obstacles. Be sure that the obstacle was * added before. */ - removeObstacle( - pathfindingObstacleBehavior: NavMeshObstacleRuntimeBehavior - ) { - this.obstacles.delete(pathfindingObstacleBehavior); + removeObstacle(obstacle: NavMeshObstacleRuntimeBehavior) { + this.obstacles.delete(obstacle); this.invalidateNavMesh(); } @@ -354,6 +478,9 @@ namespace gdjs { if (this.characterAgents.get(character)) { return; } + if (gdjs.Base3DHandler.is3D(character.owner)) { + this.is3D = true; + } this.rebuildCharacterAgent(character); } @@ -518,4 +645,596 @@ namespace gdjs { 'NavMeshPathfinding::NavMeshObstacleBehavior', gdjs.NavMeshObstacleRuntimeBehavior ); + + interface Point { + x: number; + y: number; + } + + /** + * Attempts to triangulate a polygon. + * + * @param vertices the polygon to be triangulate. + * The content is manipulated during the operation + * and it will be left in an undefined state at the end of + * the operation. + * @param vertexFlags only used internally + * @param outTriangles is called for each triangle derived + * from the original polygon. + * @return The number of triangles generated. Or, if triangulation + * failed, a negative number. + */ + function triangulate( + vertices: Array, + vertexFlags: Array, + outTriangles: (p1: Point, p2: Point, p3: Point) => void + ): void { + // Terminology, concepts and such: + // + // This algorithm loops around the edges of a polygon looking for + // new internal edges to add that will partition the polygon into a + // new valid triangle internal to the starting polygon. During each + // iteration the shortest potential new edge is selected to form that + // iteration's new triangle. + // + // Triangles will only be formed if a single new edge will create + // a triangle. Two new edges will never be added during a single + // iteration. This means that the triangulated portions of the + // original polygon will only contain triangles and the only + // non-triangle polygon will exist in the untriangulated portion + // of the original polygon. + // + // "Partition edge" refers to a potential new edge that will form a + // new valid triangle. + // + // "Center" vertex refers to the vertex in a potential new triangle + // which, if the triangle is formed, will be external to the + // remaining untriangulated portion of the polygon. Since it + // is now external to the polygon, it can't be used to form any + // new triangles. + // + // Some documentation refers to "iPlus2" even though the variable is + // not in scope or does not exist for that section of code. For + // documentation purposes, iPlus2 refers to the 2nd vertex after the + // primary vertex. + // E.g.: i, iPlus1, and iPlus2. + // + // Visualizations: http://www.critterai.org/projects/nmgen_study/polygen.html#triangulation + + // Loop through all vertices, flagging all indices that represent + // a center vertex of a valid new triangle. + vertexFlags.length = vertices.length; + for (let i = 0; i < vertices.length; i++) { + const iPlus1 = (i + 1) % vertices.length; + const iPlus2 = (i + 2) % vertices.length; + // A triangle formed by i, iPlus1, and iPlus2 will result + // in a valid internal triangle. + // Flag the center vertex (iPlus1) to indicate a valid triangle + // location. + vertexFlags[iPlus1] = isValidPartition(i, iPlus2, vertices); + } + + // Loop through the vertices creating triangles. When there is only a + // single triangle left, the operation is complete. + // + // When a valid triangle is formed, remove its center vertex. So for + // each loop, a single vertex will be removed. + // + // At the start of each iteration the indices list is in the following + // state: + // - Represents a simple polygon representing the un-triangulated + // portion of the original polygon. + // - All valid center vertices are flagged. + while (vertices.length > 3) { + // Find the shortest new valid edge. + + // NOTE: i and iPlus1 are defined in two different scopes in + // this section. So be careful. + + // Loop through all indices in the remaining polygon. + let minLengthSq = Number.MAX_VALUE; + let minLengthSqVertexIndex = -1; + for (let i = 0; i < vertices.length; i++) { + if (vertexFlags[(i + 1) % vertices.length]) { + // Indices i, iPlus1, and iPlus2 are known to form a + // valid triangle. + const vert = vertices[i]; + const vertPlus2 = vertices[(i + 2) % vertices.length]; + + // Determine the length of the partition edge. + // (i -> iPlus2) + const deltaX = vertPlus2.x - vert.x; + const deltaY = vertPlus2.y - vert.y; + const lengthSq = deltaX * deltaX + deltaY * deltaY; + + if (lengthSq < minLengthSq) { + minLengthSq = lengthSq; + minLengthSqVertexIndex = i; + } + } + } + + if (minLengthSqVertexIndex === -1) + // Could not find a new triangle. Triangulation failed. + // This happens if there are three or more vertices + // left, but none of them are flagged as being a + // potential center vertex. + return; + + let i = minLengthSqVertexIndex; + let iPlus1 = (i + 1) % vertices.length; + + // Add the new triangle to the output. + outTriangles( + vertices[i], + vertices[iPlus1], + vertices[(i + 2) % vertices.length] + ); + + // iPlus1, the "center" vert in the new triangle, is now external + // to the untriangulated portion of the polygon. Remove it from + // the vertices list since it cannot be a member of any new + // triangles. + vertices.splice(iPlus1, 1); + vertexFlags.splice(iPlus1, 1); + + if (iPlus1 === 0 || iPlus1 >= vertices.length) { + // The vertex removal has invalidated iPlus1 and/or i. So + // force a wrap, fixing the indices so they reference the + // correct indices again. This only occurs when the new + // triangle is formed across the wrap location of the polygon. + // Case 1: i = 14, iPlus1 = 15, iPlus2 = 0 + // Case 2: i = 15, iPlus1 = 0, iPlus2 = 1; + i = vertices.length - 1; + iPlus1 = 0; + } + + // At this point i and iPlus1 refer to the two indices from a + // successful triangulation that will be part of another new + // triangle. We now need to re-check these indices to see if they + // can now be the center index in a potential new partition. + vertexFlags[i] = isValidPartition( + (i - 1 + vertices.length) % vertices.length, + iPlus1, + vertices + ); + vertexFlags[iPlus1] = isValidPartition( + i, + (i + 2) % vertices.length, + vertices + ); + } + + // Only 3 vertices remain. + // Add their triangle to the output list. + outTriangles(vertices[0], vertices[1], vertices[2]); + } + + /** + * Check if the line segment formed by vertex A and vertex B will + * form a valid partition of the polygon. + * + * I.e. the line segment AB is internal to the polygon and will not + * cross existing line segments. + * + * Assumptions: + * - The vertices arguments define a valid simple polygon + * with vertices wrapped clockwise. + * - indexA != indexB + * + * Behavior is undefined if the arguments to not meet these + * assumptions + * + * @param indexA the index of the vertex that will form the segment AB. + * @param indexB the index of the vertex that will form the segment AB. + * @param vertices a polygon wrapped clockwise. + * @return true if the line segment formed by vertex A and vertex B will + * form a valid partition of the polygon. + */ + function isValidPartition( + indexA: integer, + indexB: integer, + vertices: Point[] + ): boolean { + // First check whether the segment AB lies within the internal + // angle formed at A (this is the faster check). + // If it does, then perform the more costly check. + return ( + liesWithinInternalAngle(indexA, indexB, vertices) && + !hasIllegalEdgeIntersection(indexA, indexB, vertices) + ); + } + + /** + * Check if vertex B lies within the internal angle of the polygon + * at vertex A. + * + * Vertex B does not have to be within the polygon border. It just has + * be be within the area encompassed by the internal angle formed at + * vertex A. + * + * This operation is a fast way of determining whether a line segment + * can possibly form a valid polygon partition. If this test returns + * FALSE, then more expensive checks can be skipped. + * + * Visualizations: http://www.critterai.org/projects/nmgen_study/polygen.html#anglecheck + * + * Special case: + * FALSE is returned if vertex B lies directly on either of the rays + * cast from vertex A along its associated polygon edges. So the test + * on vertex B is exclusive of the polygon edges. + * + * Assumptions: + * - The vertices and indices arguments define a valid simple polygon + * with vertices wrapped clockwise. + * -indexA != indexB + * + * Behavior is undefined if the arguments to not meet these + * assumptions + * + * @param indexA the index of the vertex that will form the segment AB. + * @param indexB the index of the vertex that will form the segment AB. + * @param vertices a polygon wrapped clockwise. + * @return true if vertex B lies within the internal angle of + * the polygon at vertex A. + */ + function liesWithinInternalAngle( + indexA: integer, + indexB: integer, + vertices: Point[] + ): boolean { + // Get pointers to the main vertices being tested. + const vertexA = vertices[indexA]; + const vertexB = vertices[indexB]; + + // Get pointers to the vertices just before and just after vertA. + const vertexAMinus = + vertices[(indexA - 1 + vertices.length) % vertices.length]; + const vertexAPlus = vertices[(indexA + 1) % vertices.length]; + + // First, find which of the two angles formed by the line segments + // AMinus->A->APlus is internal to (pointing towards) the polygon. + // Then test to see if B lies within the area formed by that angle. + + // TRUE if A is left of or on line AMinus->APlus + if ( + isLeftOrCollinear( + vertexA.x, + vertexA.y, + vertexAMinus.x, + vertexAMinus.y, + vertexAPlus.x, + vertexAPlus.y + ) + ) + // The angle internal to the polygon is <= 180 degrees + // (non-reflex angle). + // Test to see if B lies within this angle. + return ( + isLeft( + // TRUE if B is left of line A->AMinus + vertexB.x, + vertexB.y, + vertexA.x, + vertexA.y, + vertexAMinus.x, + vertexAMinus.y + ) && + // TRUE if B is right of line A->APlus + isRight( + vertexB.x, + vertexB.y, + vertexA.x, + vertexA.y, + vertexAPlus.x, + vertexAPlus.y + ) + ); + + // The angle internal to the polygon is > 180 degrees (reflex angle). + // Test to see if B lies within the external (<= 180 degree) angle and + // flip the result. (If B lies within the external angle, it can't + // lie within the internal angle) + return !( + // TRUE if B is left of or on line A->APlus + ( + isLeftOrCollinear( + vertexB.x, + vertexB.y, + vertexA.x, + vertexA.y, + vertexAPlus.x, + vertexAPlus.y + ) && + // TRUE if B is right of or on line A->AMinus + isRightOrCollinear( + vertexB.x, + vertexB.y, + vertexA.x, + vertexA.y, + vertexAMinus.x, + vertexAMinus.y + ) + ) + ); + } + + /** + * Check if point P is to the left of line AB when looking + * from A to B. + * @param px The x-value of the point to test. + * @param py The y-value of the point to test. + * @param ax The x-value of the point (ax, ay) that is point A on line AB. + * @param ay The y-value of the point (ax, ay) that is point A on line AB. + * @param bx The x-value of the point (bx, by) that is point B on line AB. + * @param by The y-value of the point (bx, by) that is point B on line AB. + * @return TRUE if point P is to the left of line AB when looking + * from A to B. + */ + function isLeft( + px: integer, + py: integer, + ax: integer, + ay: integer, + bx: integer, + by: integer + ): boolean { + return getSignedAreaX2(ax, ay, px, py, bx, by) < 0; + } + + /** + * Check if point P is to the left of line AB when looking + * from A to B or is collinear with line AB. + * @param px The x-value of the point to test. + * @param py The y-value of the point to test. + * @param ax The x-value of the point (ax, ay) that is point A on line AB. + * @param ay The y-value of the point (ax, ay) that is point A on line AB. + * @param bx The x-value of the point (bx, by) that is point B on line AB. + * @param by The y-value of the point (bx, by) that is point B on line AB. + * @return TRUE if point P is to the left of line AB when looking + * from A to B, or is collinear with line AB. + */ + function isLeftOrCollinear( + px: integer, + py: integer, + ax: integer, + ay: integer, + bx: integer, + by: integer + ): boolean { + return getSignedAreaX2(ax, ay, px, py, bx, by) <= 0; + } + + /** + * Check if point P is to the right of line AB when looking + * from A to B. + * @param px The x-value of the point to test. + * @param py The y-value of the point to test. + * @param ax The x-value of the point (ax, ay) that is point A on line AB. + * @param ay The y-value of the point (ax, ay) that is point A on line AB. + * @param bx The x-value of the point (bx, by) that is point B on line AB. + * @param by The y-value of the point (bx, by) that is point B on line AB. + * @return TRUE if point P is to the right of line AB when looking + * from A to B. + */ + function isRight( + px: integer, + py: integer, + ax: integer, + ay: integer, + bx: integer, + by: integer + ): boolean { + return getSignedAreaX2(ax, ay, px, py, bx, by) > 0; + } + + /** + * Check if point P is to the right of or on line AB when looking + * from A to B. + * @param px The x-value of the point to test. + * @param py The y-value of the point to test. + * @param ax The x-value of the point (ax, ay) that is point A on line AB. + * @param ay The y-value of the point (ax, ay) that is point A on line AB. + * @param bx The x-value of the point (bx, by) that is point B on line AB. + * @param by The y-value of the point (bx, by) that is point B on line AB. + * @return TRUE if point P is to the right of or on line AB when looking + * from A to B. + */ + function isRightOrCollinear( + px: integer, + py: integer, + ax: integer, + ay: integer, + bx: integer, + by: integer + ): boolean { + return getSignedAreaX2(ax, ay, px, py, bx, by) >= 0; + } + + /** + * The absolute value of the returned value is two times the area of the + * triangle defined by points (A, B, C). + * + * A positive value indicates: + * - Counterclockwise wrapping of the points. + * - Point B lies to the right of line AC, looking from A to C. + * + * A negative value indicates: + * - Clockwise wrapping of the points.< + * - Point B lies to the left of line AC, looking from A to C. + * + * A value of zero indicates that all points are collinear or + * represent the same point. + * + * This is a fast operation. + * + * @param ax The x-value for point (ax, ay) for vertex A of the triangle. + * @param ay The y-value for point (ax, ay) for vertex A of the triangle. + * @param bx The x-value for point (bx, by) for vertex B of the triangle. + * @param by The y-value for point (bx, by) for vertex B of the triangle. + * @param cx The x-value for point (cx, cy) for vertex C of the triangle. + * @param cy The y-value for point (cx, cy) for vertex C of the triangle. + * @return The signed value of two times the area of the triangle defined + * by the points (A, B, C). + */ + function getSignedAreaX2( + ax: integer, + ay: integer, + bx: integer, + by: integer, + cx: integer, + cy: integer + ): integer { + // References: + // http://softsurfer.com/Archive/algorithm_0101/algorithm_0101.htm#Modern%20Triangles + // http://mathworld.wolfram.com/TriangleArea.html (Search for "signed") + return (bx - ax) * (cy - ay) - (cx - ax) * (by - ay); + } + + /** + * Check if the line segment AB intersects any edges not already + * connected to one of the two vertices. + * + * Assumptions: + * - The vertices and indices arguments define a valid simple polygon + * with vertices wrapped clockwise. + * - indexA != indexB + * + * Behavior is undefined if the arguments to not meet these + * assumptions + * + * @param indexA the index of the vertex that will form the segment AB. + * @param indexB the index of the vertex that will form the segment AB. + * @param vertices a polygon wrapped clockwise. + * @return true if the line segment AB intersects any edges not already + * connected to one of the two vertices. + */ + function hasIllegalEdgeIntersection( + indexA: integer, + indexB: integer, + vertices: Point[] + ): boolean { + // Get pointers to the primary vertices being tested. + const vertexA = vertices[indexA]; + const vertexB = vertices[indexB]; + + // Loop through the polygon edges. + for ( + let edgeBeginIndex = 0; + edgeBeginIndex < vertices.length; + edgeBeginIndex++ + ) { + const edgeEndIndex = (edgeBeginIndex + 1) % vertices.length; + if ( + edgeBeginIndex === indexA || + edgeBeginIndex === indexB || + edgeEndIndex === indexA || + edgeEndIndex === indexB + ) { + continue; + } + // Neither of the test indices are endpoints of this edge. + // Get this edge's vertices. + const edgeBegin = vertices[edgeBeginIndex]; + const edgeEnd = vertices[edgeEndIndex]; + if ( + (edgeBegin.x === vertexA.x && edgeBegin.y === vertexA.y) || + (edgeBegin.x === vertexB.x && edgeBegin.y === vertexB.y) || + (edgeEnd.x === vertexA.x && edgeEnd.y === vertexA.y) || + (edgeEnd.x === vertexB.x && edgeEnd.y === vertexB.y) + ) { + // One of the test vertices is co-located + // with one of the endpoints of this edge (this is a + // test of the actual position of the vertices rather than + // simply the index check performed earlier). + // Skip this edge. + continue; + } + // This edge is not connected to either of the test vertices. + // If line segment AB intersects with this edge, then the + // intersection is illegal. + // I.e. New edges cannot cross existing edges. + if ( + segmentsIntersect( + vertexA.x, + vertexA.y, + vertexB.x, + vertexB.y, + edgeBegin.x, + edgeBegin.y, + edgeEnd.x, + edgeEnd.y + ) + ) { + return true; + } + } + return false; + } + + /** + * Returns TRUE if line segment AB intersects with line segment CD in any + * manner. Either collinear or at a single point. + * @param ax The x-value for point (ax, ay) in line segment AB. + * @param ay The y-value for point (ax, ay) in line segment AB. + * @param bx The x-value for point (bx, by) in line segment AB. + * @param by The y-value for point (bx, by) in line segment AB. + * @param cx The x-value for point (cx, cy) in line segment CD. + * @param cy The y-value for point (cx, cy) in line segment CD. + * @param dx The x-value for point (dx, dy) in line segment CD. + * @param dy The y-value for point (dx, dy) in line segment CD. + * @return TRUE if line segment AB intersects with line segment CD in any + * manner. + */ + function segmentsIntersect( + ax: integer, + ay: integer, + bx: integer, + by: integer, + cx: integer, + cy: integer, + dx: integer, + dy: integer + ): boolean { + // This is modified 2D line-line intersection/segment-segment + // intersection test. + + const deltaABx = bx - ax; + const deltaABy = by - ay; + const deltaCAx = ax - cx; + const deltaCAy = ay - cy; + const deltaCDx = dx - cx; + const deltaCDy = dy - cy; + + const numerator = deltaCAy * deltaCDx - deltaCAx * deltaCDy; + const denominator = deltaABx * deltaCDy - deltaABy * deltaCDx; + + // Perform early exit tests. + if (denominator === 0 && numerator !== 0) { + // If numerator is zero, then the lines are colinear. + // Since it isn't, then the lines must be parallel. + return false; + } + + // Lines intersect. But do the segments intersect? + + // Forcing float division on both of these via casting of the + // denominator. + const factorAB = numerator / denominator; + const factorCD = (deltaCAy * deltaABx - deltaCAx * deltaABy) / denominator; + + // Determine the type of intersection + if ( + factorAB >= 0.0 && + factorAB <= 1.0 && + factorCD >= 0.0 && + factorCD <= 1.0 + ) { + return true; // The two segments intersect. + } + + // The lines intersect, but segments to not. + + return false; + } } From 1c06792bc7d4b6501ea784ea4c7067442bff3432 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 3 Aug 2026 14:44:41 +0200 Subject: [PATCH 13/51] Simplify agent handling --- .../NavMeshCharacterRuntimeBehavior.ts | 68 ++++++++++--------- .../NavMeshObstacleRuntimeBehavior.ts | 30 ++++---- 2 files changed, 49 insertions(+), 49 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 512800f89122..e75a039314db 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -60,6 +60,7 @@ namespace gdjs { _rotateObject: boolean; _angleOffset: float; _radius: float; + _agent: RecastNav.CrowdAgent | null = null; _crowdAgentParams: Partial = { radius: 40, height: 100, @@ -196,6 +197,9 @@ namespace gdjs { setAcceleration(acceleration: float): void { this._crowdAgentParams.maxAcceleration = acceleration; + if (this._agent) { + this._agent.setParameters(this._crowdAgentParams); + } } getAcceleration(): float { @@ -204,6 +208,9 @@ namespace gdjs { setMaxSpeed(maxSpeed: float): void { this._crowdAgentParams.maxSpeed = maxSpeed; + if (this._agent) { + this._agent.setParameters(this._crowdAgentParams); + } } getMaxSpeed(): float { @@ -212,20 +219,42 @@ namespace gdjs { setSpeed(speed: float): void { this._speed = speed; + if (this._agent) { + const velocity = this._agent.desiredVelocityObstacleAdjusted(); + const oldSpeed = Math.hypot(velocity.x, velocity.y, velocity.z); + if (oldSpeed === 0) { + this._agent.requestMoveVelocity({ x: speed, y: 0, z: 0 }); + } else { + const ratio = speed / oldSpeed; + this._agent.requestMoveVelocity({ + x: velocity.x * ratio, + y: velocity.y * ratio, + z: velocity.z * ratio, + }); + } + } } getSpeed(): float { - return this._speed; + if (!this._agent) { + return 0; + } + const velocity = this._agent.desiredVelocityObstacleAdjusted(); + return Math.hypot(velocity.x, velocity.y, velocity.z); } getMovementAngle(): float { - return this._movementAngle; + if (!this._agent) { + return 0; + } + const velocity = this._agent.desiredVelocityObstacleAdjusted(); + return Math.atan2(velocity.z, velocity.x); } movementAngleIsAround(degreeAngle: float, tolerance: float): boolean { return ( Math.abs( - gdjs.evtTools.common.angleDifference(this._movementAngle, degreeAngle) + gdjs.evtTools.common.angleDifference(this.getMovementAngle(), degreeAngle) ) <= tolerance ); } @@ -377,13 +406,12 @@ namespace gdjs { return; } - const agent = this._manager.characterAgents.get(this); - if (!agent) { + if (!this._agent) { console.log('No agent'); this._pathFound = false; return; } - this._pathFound = agent.requestMoveTarget(destination); + this._pathFound = this._agent.requestMoveTarget(destination); console.log( 'hasFindPath', this._pathFound, @@ -401,37 +429,11 @@ namespace gdjs { } } - _enterSegment(segmentNumber: integer) { - if (this._path.length === 0) { - return; - } - this._currentSegment = segmentNumber; - if (this._currentSegment < this._path.length - 1) { - const pathX = - this._path[this._currentSegment + 1].x - - this._path[this._currentSegment].x; - const pathY = - this._path[this._currentSegment + 1].y - - this._path[this._currentSegment].y; - const pathZ = - this._path[this._currentSegment + 1].z - - this._path[this._currentSegment].z; - this._totalSegmentDistance = Math.hypot(pathX, pathY, pathZ); - this._distanceOnSegment = 0; - this._reachedEnd = false; - this._movementAngle = - (gdjs.toDegrees(Math.atan2(pathY, pathX)) + 360) % 360; - } else { - this._reachedEnd = true; - this._speed = 0; - } - } - override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { const timeDelta = this.owner.getElapsedTime() / 1000; this._manager.step(timeDelta); - const agent = this._manager.characterAgents.get(this); + const agent = this._agent; if (!agent) { return; } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 13cdfe0e6c64..131892c3e33d 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -35,17 +35,9 @@ namespace gdjs { */ export class NavMeshObstaclesManager { obstacles = new Set(); + characters = new Set(); is3D = false; navMesh: RecastNav.NavMesh | null = null; - timeSinceLastNavMeshLastRebuild: float = 1; - isNavMeshDirty = true; - isFirstFrame = true; - crowd: RecastNav.Crowd | null = null; - characterAgents = new Map< - NavMeshCharacterRuntimeBehavior, - RecastNav.CrowdAgent | null - >(); - hasStepped = false; private navMeshConfig: Partial = { cs: 10, ch: 10, @@ -54,6 +46,11 @@ namespace gdjs { detailSampleMaxError: 50, walkableClimb: 2, }; + timeSinceLastNavMeshLastRebuild: float = 1; + isNavMeshDirty = true; + isFirstFrame = true; + crowd: RecastNav.Crowd | null = null; + hasStepped = false; constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { this.navMeshConfig.cs = sharedData.cellSize; @@ -130,7 +127,7 @@ namespace gdjs { indices, this.navMeshConfig ); - console.log("Built", result.success); + console.log('Built', result.success); this.navMeshConfig.walkableClimb = 2; if (result.success) { this.navMesh = result.navMesh; @@ -138,7 +135,7 @@ namespace gdjs { maxAgents: 100, maxAgentRadius: 100, }); - for (const character of this.characterAgents.keys()) { + for (const character of this.characters) { this.rebuildCharacterAgent(character); } } @@ -403,7 +400,7 @@ namespace gdjs { private rebuildCharacterAgent(character: NavMeshCharacterRuntimeBehavior) { if (!this.navMesh || !this.crowd) { - this.characterAgents.set(character, null); + character._agent = null; return; } const owner = character.owner; @@ -443,12 +440,12 @@ namespace gdjs { : null; if (agent) { - const oldAgent = this.characterAgents.get(character); + const oldAgent = character._agent; if (oldAgent && !character.destinationReached()) { agent.requestMoveTarget(oldAgent.target()); } } - this.characterAgents.set(character, agent); + character._agent = agent; } /** @@ -475,9 +472,10 @@ namespace gdjs { * Add a character to the list of existing characters. */ addCharacter(character: NavMeshCharacterRuntimeBehavior) { - if (this.characterAgents.get(character)) { + if (this.characters.has(character)) { return; } + this.characters.add(character); if (gdjs.Base3DHandler.is3D(character.owner)) { this.is3D = true; } @@ -488,7 +486,7 @@ namespace gdjs { * Remove a character from the list of existing characters. */ removeCharacter(character: NavMeshCharacterRuntimeBehavior) { - this.characterAgents.delete(character); + this.characters.delete(character); } } From f0cff62ba2f6023125a7463cad6fb5c4d3007f34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 3 Aug 2026 19:09:41 +0200 Subject: [PATCH 14/51] Fix object rotation --- .../NavMeshCharacterRuntimeBehavior.ts | 113 ++++++++++-------- .../NavMeshObstacleRuntimeBehavior.ts | 4 +- 2 files changed, 64 insertions(+), 53 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index e75a039314db..615d12f21d89 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -71,12 +71,8 @@ namespace gdjs { }; //Attributes used for traveling on the path: - _pathFound: boolean = false; - _speed: float = 0; _angularSpeed: float = 0; - _distanceOnSegment: float = 0; - _totalSegmentDistance: float = 0; - _currentSegment: integer = 0; + _pathFound: boolean = false; _reachedEnd: boolean = false; _manager: NavMeshObstaclesManager; @@ -218,7 +214,6 @@ namespace gdjs { } setSpeed(speed: float): void { - this._speed = speed; if (this._agent) { const velocity = this._agent.desiredVelocityObstacleAdjusted(); const oldSpeed = Math.hypot(velocity.x, velocity.y, velocity.z); @@ -244,17 +239,13 @@ namespace gdjs { } getMovementAngle(): float { - if (!this._agent) { - return 0; - } - const velocity = this._agent.desiredVelocityObstacleAdjusted(); - return Math.atan2(velocity.z, velocity.x); + return this._movementAngle; } movementAngleIsAround(degreeAngle: float, tolerance: float): boolean { return ( Math.abs( - gdjs.evtTools.common.angleDifference(this.getMovementAngle(), degreeAngle) + gdjs.evtTools.common.angleDifference(this._movementAngle, degreeAngle) ) <= tolerance ); } @@ -298,11 +289,13 @@ namespace gdjs { } getNextNodeIndex() { - if (this._currentSegment + 1 < this._path.length) { - return this._currentSegment + 1; - } else { - return this._path.length - 1; + if (!this._agent) { + return 0; } + const remainingNodes = this._agent.raw.ncorners; + return remainingNodes === 0 + ? this._path.length - 1 + : this._path.length - remainingNodes; } getNodeCount(): integer { @@ -313,44 +306,42 @@ namespace gdjs { if (this._path.length === 0) { return 0; } - if (this._currentSegment + 1 < this._path.length) { - return this._path[this._currentSegment + 1][0]; - } else { - return this._path[this._path.length - 1][0]; - } + const nextNodeIndex = this.getNextNodeIndex(); + return this._path[nextNodeIndex].x; } getNextNodeY(): float { if (this._path.length === 0) { return 0; } - if (this._currentSegment + 1 < this._path.length) { - return this._path[this._currentSegment + 1][1]; - } else { - return this._path[this._path.length - 1][1]; + const nextNodeIndex = this.getNextNodeIndex(); + return this._path[nextNodeIndex].y; + } + + getPreviousNodeIndex() { + if (!this._agent) { + return 0; } + const remainingNodes = this._agent.raw.ncorners; + return remainingNodes === this._path.length + ? 0 + : this._path.length - remainingNodes - 1; } getLastNodeX(): float { if (this._path.length < 2) { return 0; } - if (this._currentSegment < this._path.length - 1) { - return this._path[this._currentSegment][0]; - } else { - return this._path[this._path.length - 1][0]; - } + const previousNodeIndex = this.getPreviousNodeIndex(); + return this._path[previousNodeIndex].x; } getLastNodeY(): float { if (this._path.length < 2) { return 0; } - if (this._currentSegment < this._path.length - 1) { - return this._path[this._currentSegment][1]; - } else { - return this._path[this._path.length - 1][1]; - } + const previousNodeIndex = this.getPreviousNodeIndex(); + return this._path[previousNodeIndex].y; } getDestinationX(): float { @@ -385,6 +376,7 @@ namespace gdjs { * Compute and move on the path to the specified destination. */ moveTo(x: float, y: float, z: float) { + this._path = []; this._manager.rebuildNavMeshIfNeeded(); if (!this._manager.navMesh) { console.log("Can't build the nav mesh"); @@ -424,6 +416,16 @@ namespace gdjs { y, z ); + + // Path found: memorize it + const path = this._agent.corners(); + for (const point of path) { + const y = point.y; + point.y = point.z; + point.z = y; + } + console.log('path', path); + this._path = path; if (this._pathFound) { this._reachedEnd = false; } @@ -431,6 +433,7 @@ namespace gdjs { override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { const timeDelta = this.owner.getElapsedTime() / 1000; + // The wrapper interpolation seems bugged, so we don't use it. this._manager.step(timeDelta); const agent = this._agent; @@ -440,9 +443,10 @@ namespace gdjs { const oldX = this.owner.getX(); const oldY = this.owner.getY(); - const newX = agent.interpolatedPosition.x; - const newY = agent.interpolatedPosition.z; - const newZ = agent.interpolatedPosition.y; + const newPosition = agent.position(); + const newX = newPosition.x; + const newY = newPosition.z; + const newZ = newPosition.y; this.owner.setX(newX); this.owner.setY(newY); //@ts-ignore @@ -451,9 +455,13 @@ namespace gdjs { this.owner.setZ(newZ); } - if (newX != oldX && newY != oldY) { + // Avoid to frequently change of direction when not moving much. + const deltaX = newX - oldX; + const deltaY = newY - oldY; + if (Math.abs(deltaX) + Math.abs(deltaY) > 1 + ) { this._movementAngle = gdjs.toDegrees( - Math.atan2(newY - oldY, newX - oldX) + Math.atan2(deltaY, deltaX) ); } if ( @@ -476,18 +484,21 @@ namespace gdjs { const diffWasPositive = angularDiff >= 0; const timeDelta = this.owner.getElapsedTime() / 1000; + this._angularSpeed = + (diffWasPositive ? -1.0 : 1.0) * this._angularMaxSpeed; // Always rotate the right way. - if (this._angularSpeed > 0 !== diffWasPositive) { - this._angularSpeed = 0; - } - this._angularSpeed = gdjs.evtTools.common.clamp( - this._angularSpeed + - (diffWasPositive ? -1.0 : 1.0) * - this._angularAcceleration * - timeDelta, - -this._angularMaxSpeed, - this._angularMaxSpeed - ); + // if (this._angularSpeed > 0 !== diffWasPositive) { + // this._angularSpeed = 0; + // } + // this._angularSpeed = gdjs.evtTools.common.clamp( + // this._angularSpeed + + // (diffWasPositive ? -1.0 : 1.0) * + // this._angularAcceleration * + // timeDelta, + // -this._angularMaxSpeed, + // this._angularMaxSpeed + // ); + let newAngle = this.owner.getAngle() + this._angularSpeed * timeDelta; if ( diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 131892c3e33d..a3aefcfc8f46 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -89,7 +89,7 @@ namespace gdjs { if (!this.crowd) { return; } - this.crowd.update(1 / 60, timeDelta, 8); + this.crowd.update(timeDelta);//1 / 60, timeDelta, 8); } invalidateNavMesh() { @@ -163,7 +163,7 @@ namespace gdjs { const centerX = (maxX + minX) / 2; const centerY = (maxY + minY) / 2; - console.log(width, height, centerX, centerY); + console.log("Ground", width, height, centerX, centerY); const indicesOffset = Math.round(positions.length / 3); for (let index = 0; index + 2 < cubePositions.length; index = index + 3) { From f7227cdb58d91a575bd48035cc1a93e629ce4988 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Tue, 4 Aug 2026 16:08:12 +0200 Subject: [PATCH 15/51] Use an automatic margin by default. --- Extensions/NavMeshPathfinding/JsExtension.js | 30 +++++++++++++++---- .../NavMeshCharacterRuntimeBehavior.ts | 14 +++++---- .../NavMeshObstacleRuntimeBehavior.ts | 25 ++++++++++++---- 3 files changed, 53 insertions(+), 16 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index ddab869d5846..eca994ee35e9 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -208,6 +208,14 @@ module.exports = { .setDoubleValue(newValueAsNumber); return true; } + if (propertyName === 'walkableRadius') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('walkableRadius') + .setDoubleValue(newValueAsNumber); + return true; + } return false; }; sharedData.getProperties = function (sharedContent) { @@ -215,8 +223,7 @@ module.exports = { sharedProperties .getOrCreate('cellSize') - .setLabel('Cell size') - .setGroup('') + .setLabel(_('Cell size')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( @@ -227,8 +234,7 @@ module.exports = { sharedProperties .getOrCreate('cellDepth') - .setLabel('Cell depth') - .setGroup('') + .setLabel(_('Cell depth')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( @@ -239,8 +245,7 @@ module.exports = { sharedProperties .getOrCreate('slopeMaxAngle') - .setLabel('Slope max. angle') - .setGroup('') + .setLabel(_('Slope max. angle')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getDegreeAngle()) .setValue( @@ -252,12 +257,25 @@ module.exports = { .setAdvanced(true) .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + sharedProperties + .getOrCreate('walkableRadius') + .setLabel(_('Walkable radius')) + .setDescription(_('The biggest character radius is automatically used when left negative.')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setValue( + sharedContent.getChild('walkableRadius').getDoubleValue().toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + return sharedProperties; }; sharedData.initializeContent = function (sharedContent) { sharedContent.addChild('cellSize').setDoubleValue(10); sharedContent.addChild('cellDepth').setDoubleValue(10); sharedContent.addChild('slopeMaxAngle').setDoubleValue(50); + sharedContent.addChild('walkableRadius').setDoubleValue(-1); }; const aut = extension diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 615d12f21d89..ccd5ae9d36fe 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -191,6 +191,13 @@ namespace gdjs { this._manager.removeCharacter(this); } + getRadius(): float { + return ( + this._radius || + Math.min(this.owner.getWidth(), this.owner.getHeight()) / 2 + ); + } + setAcceleration(acceleration: float): void { this._crowdAgentParams.maxAcceleration = acceleration; if (this._agent) { @@ -458,11 +465,8 @@ namespace gdjs { // Avoid to frequently change of direction when not moving much. const deltaX = newX - oldX; const deltaY = newY - oldY; - if (Math.abs(deltaX) + Math.abs(deltaY) > 1 - ) { - this._movementAngle = gdjs.toDegrees( - Math.atan2(deltaY, deltaX) - ); + if (Math.abs(deltaX) + Math.abs(deltaY) > 1) { + this._movementAngle = gdjs.toDegrees(Math.atan2(deltaY, deltaX)); } if ( this._rotateObject && diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index a3aefcfc8f46..ec3181baca0d 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -45,7 +45,10 @@ namespace gdjs { walkableHeight: 10, detailSampleMaxError: 50, walkableClimb: 2, + // TODO + walkableRadius: 5, }; + walkableRadius: float = -1; timeSinceLastNavMeshLastRebuild: float = 1; isNavMeshDirty = true; isFirstFrame = true; @@ -57,6 +60,7 @@ namespace gdjs { this.navMeshConfig.ch = sharedData.cellDepth; this.navMeshConfig.detailSampleMaxError = sharedData.cellDepth * 5; this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; + this.walkableRadius = sharedData.walkableRadius; } /** @@ -89,7 +93,7 @@ namespace gdjs { if (!this.crowd) { return; } - this.crowd.update(timeDelta);//1 / 60, timeDelta, 8); + this.crowd.update(timeDelta); //1 / 60, timeDelta, 8); } invalidateNavMesh() { @@ -122,6 +126,18 @@ namespace gdjs { this.navMeshConfig.walkableClimb = 0; } + let characterRadiusMax = 0; + for (const character of this.characters) { + characterRadiusMax = Math.max( + characterRadiusMax, + character.getRadius() + ); + } + this.navMeshConfig.walkableRadius = this.navMeshConfig.cs + ? (this.walkableRadius < 0 ? characterRadiusMax : this.walkableRadius) / + this.navMeshConfig.cs + : 0; + const result = RecastNav.generateSoloNavMesh( positions, indices, @@ -133,7 +149,7 @@ namespace gdjs { this.navMesh = result.navMesh; this.crowd = new RecastNav.Crowd(this.navMesh, { maxAgents: 100, - maxAgentRadius: 100, + maxAgentRadius: characterRadiusMax, }); for (const character of this.characters) { this.rebuildCharacterAgent(character); @@ -163,7 +179,7 @@ namespace gdjs { const centerX = (maxX + minX) / 2; const centerY = (maxY + minY) / 2; - console.log("Ground", width, height, centerX, centerY); + console.log('Ground', width, height, centerX, centerY); const indicesOffset = Math.round(positions.length / 3); for (let index = 0; index + 2 < cubePositions.length; index = index + 3) { @@ -426,8 +442,7 @@ namespace gdjs { return; } - character._crowdAgentParams.radius = - character._radius || Math.min(owner.getWidth(), owner.getHeight()); + character._crowdAgentParams.radius = character.getRadius(); console.log(character._crowdAgentParams.radius); character._crowdAgentParams.height = //@ts-ignore From 6731e1878bf2dc1b0202de1f97fb8c3a575b1184 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Wed, 5 Aug 2026 15:22:52 +0200 Subject: [PATCH 16/51] Add debug draw --- Extensions/NavMeshPathfinding/JsExtension.js | 43 ++++- .../NavMeshCharacterRuntimeBehavior.ts | 9 +- .../NavMeshDebugPixiRenderer.ts | 165 ++++++++++++++++++ .../NavMeshObstacleRuntimeBehavior.ts | 32 ++++ .../CustomRuntimeObjectInstanceContainer.ts | 4 +- GDJS/Runtime/RuntimeInstanceContainer.ts | 7 + .../pixi-renderers/DebuggerPixiRenderer.ts | 14 +- GDJS/Runtime/runtimescene.ts | 4 +- 8 files changed, 269 insertions(+), 9 deletions(-) create mode 100644 Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index eca994ee35e9..83efcd028ce3 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -159,7 +159,9 @@ module.exports = { behaviorProperties .getOrCreate('avoidanceSightRange') - .setValue(behaviorContent.getChild('avoidanceSightRange').getStringValue()) + .setValue( + behaviorContent.getChild('avoidanceSightRange').getStringValue() + ) .setLabel(_('Avoidance sight range')) .setGroup(_('Collision')) .setType('Number') @@ -260,11 +262,18 @@ module.exports = { sharedProperties .getOrCreate('walkableRadius') .setLabel(_('Walkable radius')) - .setDescription(_('The biggest character radius is automatically used when left negative.')) + .setDescription( + _( + 'The biggest character radius is automatically used when left negative.' + ) + ) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( - sharedContent.getChild('walkableRadius').getDoubleValue().toString(10) + sharedContent + .getChild('walkableRadius') + .getDoubleValue() + .toString(10) ) .setAdvanced(true) .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); @@ -431,6 +440,34 @@ module.exports = { ); } + extension + .addAction( + 'EnableDebugDraw', + _('Draw pathfinding walkable area'), + _('This activates the display of the walkable area (in blue).'), + _('Enable debugging view of pathfinding: _PARAM1_'), + '', + 'res/actions/planicon24.png', + 'res/actions/planicon.png' + ) + .addCodeOnlyParameter('currentScene', '') + .addParameter('yesorno', _('Enable debug draw'), '', true) + .getCodeExtraInformation() + .addIncludeFile( + 'Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.js' + ) + .addIncludeFile('Extensions/NavMeshPathfinding/recast-navigation.wasm.js') + .addIncludeFile( + 'Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/recast-navigation-generators.js' + ) + .addIncludeFile( + 'Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.js' + ) + .setFunctionName('gdjs.NavMeshObstaclesManager.enableDebugDraw'); + return extension; }, diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index ccd5ae9d36fe..80917e51db29 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -38,7 +38,8 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData + extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -431,7 +432,7 @@ namespace gdjs { point.y = point.z; point.z = y; } - console.log('path', path); + console.log('path', path.length); this._path = path; if (this._pathFound) { this._reachedEnd = false; @@ -462,10 +463,12 @@ namespace gdjs { this.owner.setZ(newZ); } + //console.log("newZ", newZ); + // Avoid to frequently change of direction when not moving much. const deltaX = newX - oldX; const deltaY = newY - oldY; - if (Math.abs(deltaX) + Math.abs(deltaY) > 1) { + if (Math.abs(deltaX) + Math.abs(deltaY) > this.getMaxSpeed() / 100) { this._movementAngle = gdjs.toDegrees(Math.atan2(deltaY, deltaX)); } if ( diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts new file mode 100644 index 000000000000..918276e73a6f --- /dev/null +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -0,0 +1,165 @@ +/* +GDevelop - Pathfinding Behavior Extension +Copyright (c) 2013-2016 Florian Rival (Florian.Rival@gmail.com) + */ + +namespace gdjs { + class NavMeshDebuggerPixiRenderer { + obstaclesManager: NavMeshObstaclesManager; + debugDrawerUtils: RecastNav.DebugDrawerUtils | null = null; + enabled = false; + meshes: Array = []; + material: THREE.MeshStandardMaterial | null = null; + + constructor(obstaclesManager: NavMeshObstaclesManager) { + this.obstaclesManager = obstaclesManager; + } + + setEnabled(enabled: boolean): void { + this.enabled = enabled; + } + + registerFor2D() { + const firstObstacle: NavMeshObstacleRuntimeBehavior = + this.obstaclesManager.obstacles.values().next().value; + if (firstObstacle) { + firstObstacle.owner + .getRuntimeScene() + .registerDebugDrawHook((rendererObject: PIXI.Graphics) => { + if (!this.enabled || this.obstaclesManager.is3D) { + return; + } + const { navMesh, obstacles } = this.obstaclesManager; + if (!navMesh) { + return; + } + if (!this.debugDrawerUtils) { + this.debugDrawerUtils = new RecastNav.DebugDrawerUtils(); + } + const primitives = this.debugDrawerUtils.drawNavMesh(navMesh); + const firstObstacle: gdjs.NavMeshObstacleRuntimeBehavior = obstacles + .values() + .next().value; + const scene = firstObstacle.owner.getRuntimeScene(); + const layer = scene.getLayer(firstObstacle.owner.getLayer()); + const workingPoint: FloatPoint = [0, 0]; + + rendererObject.beginFill(); + rendererObject.fill.alpha = 0.2; + rendererObject.fill.color = 0x778ee8; + + for (const primitive of primitives) { + switch (primitive.type) { + case 'tris': + for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { + const [x0, y0, z0] = primitive.vertices[i]; + //console.log("y", y0); + if (y0 < 15) { + const [x1, y1, z1] = primitive.vertices[i + 1]; + const [x2, y2, z2] = primitive.vertices[i + 2]; + + const positions: Array = []; + positions.push.apply( + positions, + layer.applyLayerTransformation(x0, z0, 0, workingPoint) + ); + positions.push.apply( + positions, + layer.applyLayerTransformation(x1, z1, 0, workingPoint) + ); + positions.push.apply( + positions, + layer.applyLayerTransformation(x2, z2, 0, workingPoint) + ); + rendererObject.drawPolygon(positions); + } + } + break; + } + } + rendererObject.endFill(); + }); + } + } + + renderFor3D() { + for (const mesh of this.meshes) { + mesh.removeFromParent(); + } + this.meshes.length = 0; + if (!this.enabled || !this.obstaclesManager.is3D) { + return; + } + const { navMesh, obstacles } = this.obstaclesManager; + if (!navMesh) { + return; + } + if (!this.debugDrawerUtils) { + this.debugDrawerUtils = new RecastNav.DebugDrawerUtils(); + } + const firstObstacle: gdjs.NavMeshObstacleRuntimeBehavior = obstacles + .values() + .next().value; + const scene = firstObstacle.owner.getRuntimeScene(); + const inverseWorldScale = scene.getRenderer3DInverseWorldScale(); + const layer = scene.getLayer(firstObstacle.owner.getLayer()); + const rendererObject = layer.get3DRendererObject(); + if (!rendererObject) { + return; + } + const primitives = this.debugDrawerUtils.drawNavMesh(navMesh); + const meshes: Array = []; + for (const primitive of primitives) { + switch (primitive.type) { + case 'tris': + const geometry = new THREE.BufferGeometry(); + const positions = new Float32Array(primitive.vertices.length * 3); + + for (let i = 0; i < primitive.vertices.length; i++) { + const [x, y, z] = primitive.vertices[i]; + + // Invert triangles side + const triangleVertexIndex = i % 3; + const vertexIndex = + triangleVertexIndex === 0 + ? i + 1 + : triangleVertexIndex === 1 + ? i - 1 + : i; + + positions[vertexIndex * 3 + 0] = x; + positions[vertexIndex * 3 + 1] = z; + positions[vertexIndex * 3 + 2] = y; + } + + geometry.setAttribute( + 'position', + new THREE.BufferAttribute(positions, 3) + ); + + if (!this.material) { + this.material = new THREE.MeshStandardMaterial({ + color: 0x778ee8, + }); + } + const mesh = new THREE.Mesh(geometry, this.material); + + console.log(positions); + meshes.push(mesh); + rendererObject.add(mesh); + break; + } + } + } + } + + // Register the class to let the engine use it. + /** + * @category Debugging > Debugger Renderer + */ + export type NavMeshDebuggerRenderer = NavMeshDebuggerPixiRenderer; + /** + * @category Debugging > Debugger Renderer + */ + export const NavMeshDebuggerRenderer = NavMeshDebuggerPixiRenderer; +} diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index ec3181baca0d..37fa52d72bc5 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -54,6 +54,7 @@ namespace gdjs { isFirstFrame = true; crowd: RecastNav.Crowd | null = null; hasStepped = false; + debuggerRenderer: gdjs.NavMeshDebuggerRenderer | null = null; constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { this.navMeshConfig.cs = sharedData.cellSize; @@ -124,6 +125,7 @@ namespace gdjs { if (!this.is3D && positions.length > 0) { this.addGroundFor2D(positions, indices); this.navMeshConfig.walkableClimb = 0; + this.navMeshConfig.ch = 10; } let characterRadiusMax = 0; @@ -154,10 +156,20 @@ namespace gdjs { for (const character of this.characters) { this.rebuildCharacterAgent(character); } + this.debuggerRenderer.renderFor3D(); } this.isNavMeshDirty = false; } + setDebugDrawEnabled(enableDebugDraw: boolean): void { + if (!this.debuggerRenderer) { + this.debuggerRenderer = new gdjs.NavMeshDebuggerRenderer(this); + this.debuggerRenderer.registerFor2D(); + } + this.debuggerRenderer.setEnabled(enableDebugDraw); + this.debuggerRenderer.renderFor3D(); + } + private addGroundFor2D( positions: Array, indices: Array @@ -505,6 +517,26 @@ namespace gdjs { } } + /** @category Behaviors > 2D Pathfinding */ + export namespace NavMeshObstaclesManager { + /** + * Enable or disable the debug draw. + * @param instanceContainer The current container. + * @param enableDebugDraw true to enable the debug draw, false to disable it. + */ + export const enableDebugDraw = function ( + instanceContainer: gdjs.RuntimeInstanceContainer, + enableDebugDraw: boolean + ) { + if (enableDebugDraw) { + instanceContainer._debugDrawEnabled = true; + } + const manager = + gdjs.NavMeshObstaclesManager.getManager(instanceContainer); + manager.setDebugDrawEnabled(enableDebugDraw); + }; + } + /** * NavMeshObstacleRuntimeBehavior represents a behavior allowing objects to be * considered as a obstacle by objects having Pathfinding Behavior. diff --git a/GDJS/Runtime/CustomRuntimeObjectInstanceContainer.ts b/GDJS/Runtime/CustomRuntimeObjectInstanceContainer.ts index 20dc3d0f728d..161dd4a4d382 100644 --- a/GDJS/Runtime/CustomRuntimeObjectInstanceContainer.ts +++ b/GDJS/Runtime/CustomRuntimeObjectInstanceContainer.ts @@ -280,9 +280,11 @@ namespace gdjs { if (this._debugDrawEnabled) { this._debuggerRenderer.renderDebugDraw( allInstancesList, + this._debugDrawShowHitBoxes, this._debugDrawShowHiddenInstances, this._debugDrawShowPointsNames, - this._debugDrawShowCustomPoints + this._debugDrawShowCustomPoints, + this._debugDrawHooks ); } diff --git a/GDJS/Runtime/RuntimeInstanceContainer.ts b/GDJS/Runtime/RuntimeInstanceContainer.ts index b6c19d9f0647..a8476a8235f5 100644 --- a/GDJS/Runtime/RuntimeInstanceContainer.ts +++ b/GDJS/Runtime/RuntimeInstanceContainer.ts @@ -52,9 +52,11 @@ namespace gdjs { // Options for the debug draw: _debugDrawEnabled: boolean = false; + _debugDrawShowHitBoxes: boolean = false; _debugDrawShowHiddenInstances: boolean = false; _debugDrawShowPointsNames: boolean = false; _debugDrawShowCustomPoints: boolean = false; + _debugDrawHooks: Array<(rendererObject: any) => void> = []; _onceTriggers: OnceTriggers; @@ -243,11 +245,16 @@ namespace gdjs { } this._debugDrawEnabled = enableDebugDraw; + this._debugDrawShowHitBoxes = enableDebugDraw; this._debugDrawShowHiddenInstances = showHiddenInstances; this._debugDrawShowPointsNames = showPointsNames; this._debugDrawShowCustomPoints = showCustomPoints; } + registerDebugDrawHook(render: (rendererObject: any) => void) { + this._debugDrawHooks.push(render); + } + /** * Check if an object is registered, meaning that instances of it can be * created and lives in the container. diff --git a/GDJS/Runtime/pixi-renderers/DebuggerPixiRenderer.ts b/GDJS/Runtime/pixi-renderers/DebuggerPixiRenderer.ts index f5697ad66156..1f46aef01947 100644 --- a/GDJS/Runtime/pixi-renderers/DebuggerPixiRenderer.ts +++ b/GDJS/Runtime/pixi-renderers/DebuggerPixiRenderer.ts @@ -6,6 +6,7 @@ namespace gdjs { * @category Debugging > Debugger Renderer */ export class DebuggerPixiRenderer { + // as this is for debug draw. _instanceContainer: gdjs.RuntimeInstanceContainer; _debugDraw: PIXI.Graphics | null = null; _debugDrawContainer: PIXI.Container | null = null; @@ -34,9 +35,11 @@ namespace gdjs { */ renderDebugDraw( instances: gdjs.RuntimeObject[], + showHitBoxes: boolean, showHiddenInstances: boolean, showPointsNames: boolean, - showCustomPoints: boolean + showCustomPoints: boolean, + debugDrawHooks: Array<(rendererObject: any) => void> ) { const pixiContainer = this._instanceContainer .getRenderer() @@ -84,6 +87,15 @@ namespace gdjs { }; debugDraw.clear(); + + for (const render of debugDrawHooks) { + render(debugDraw); + } + + if (!showHitBoxes) { + return; + } + debugDraw.beginFill(); debugDraw.alpha = 0.8; debugDraw.lineStyle(2, 0x0000ff, 1); diff --git a/GDJS/Runtime/runtimescene.ts b/GDJS/Runtime/runtimescene.ts index acf90459a3e2..d216ad256478 100644 --- a/GDJS/Runtime/runtimescene.ts +++ b/GDJS/Runtime/runtimescene.ts @@ -478,9 +478,11 @@ namespace gdjs { if (this._debugDrawEnabled) { this._debuggerRenderer.renderDebugDraw( this.getAdhocListOfAllInstances(), + this._debugDrawShowHitBoxes, this._debugDrawShowHiddenInstances, this._debugDrawShowPointsNames, - this._debugDrawShowCustomPoints + this._debugDrawShowCustomPoints, + this._debugDrawHooks ); } From ffbef1e6c55d2482c613c67e29714bb1e4665223 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Wed, 5 Aug 2026 16:50:54 +0200 Subject: [PATCH 17/51] Move up some functions --- .../NavMeshCharacterRuntimeBehavior.ts | 288 +++++++++--------- .../NavMeshObstacleRuntimeBehavior.ts | 3 +- 2 files changed, 145 insertions(+), 146 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 80917e51db29..d239f23de679 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -192,6 +192,150 @@ namespace gdjs { this._manager.removeCharacter(this); } + /** + * Compute and move on the path to the specified destination. + */ + moveTo(x: float, y: float, z: float) { + this._path = []; + this._manager.rebuildNavMeshIfNeeded(); + if (!this._manager.navMesh) { + console.log("Can't build the nav mesh"); + this._pathFound = false; + return; + } + + // Start searching for a path + const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); + + const { success: hasFindDestination, point: destination } = + navMeshQuery.findClosestPoint( + { x, y: z, z: y }, + { halfExtents: { x: 100, y: 100, z: 100 } } + ); + if (!hasFindDestination) { + this._pathFound = false; + console.log("Can't find destination", x, y, z); + return; + } + + if (!this._agent) { + console.log('No agent'); + this._pathFound = false; + return; + } + this._pathFound = this._agent.requestMoveTarget(destination); + console.log( + 'hasFindPath', + this._pathFound, + this.owner.x, + this.owner.y, + //@ts-ignore + this.owner.getZ ? this.owner.getZ() : 0, + ' -> ', + x, + y, + z + ); + + // Path found: memorize it + const path = this._agent.corners(); + for (const point of path) { + const y = point.y; + point.y = point.z; + point.z = y; + } + console.log('path', path.length); + this._path = path; + if (this._pathFound) { + this._reachedEnd = false; + } + } + + override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + const timeDelta = this.owner.getElapsedTime() / 1000; + // The wrapper interpolation seems bugged, so we don't use it. + this._manager.step(timeDelta); + + const agent = this._agent; + if (!agent) { + return; + } + + const oldX = this.owner.getX(); + const oldY = this.owner.getY(); + const newPosition = agent.position(); + const newX = newPosition.x; + const newY = newPosition.z; + const newZ = newPosition.y; + this.owner.setX(newX); + this.owner.setY(newY); + //@ts-ignore + if (this.owner.setZ) { + //@ts-ignore + this.owner.setZ(newZ); + } + + //console.log("newZ", newZ); + + // Avoid to frequently change of direction when not moving much. + const deltaX = newX - oldX; + const deltaY = newY - oldY; + if (Math.abs(deltaX) + Math.abs(deltaY) > this.getMaxSpeed() / 100) { + this._movementAngle = gdjs.toDegrees(Math.atan2(deltaY, deltaX)); + } + if ( + this._rotateObject && + this.owner.getAngle() !== this._movementAngle + this._angleOffset + ) { + this.rotateTowardAngle(this._movementAngle + this._angleOffset); + } + } + + /** + * @param angle The targeted angle. + * @param speed The rotation speed. 0 for an immediate rotation to the target angle. + */ + private rotateTowardAngle(angle: float): void { + const angularDiff = gdjs.evtTools.common.angleDifference( + this.owner.getAngle(), + angle + ); + const diffWasPositive = angularDiff >= 0; + + const timeDelta = this.owner.getElapsedTime() / 1000; + this._angularSpeed = + (diffWasPositive ? -1.0 : 1.0) * this._angularMaxSpeed; + // Always rotate the right way. + // if (this._angularSpeed > 0 !== diffWasPositive) { + // this._angularSpeed = 0; + // } + // this._angularSpeed = gdjs.evtTools.common.clamp( + // this._angularSpeed + + // (diffWasPositive ? -1.0 : 1.0) * + // this._angularAcceleration * + // timeDelta, + // -this._angularMaxSpeed, + // this._angularMaxSpeed + // ); + + let newAngle = this.owner.getAngle() + this._angularSpeed * timeDelta; + + if ( + // @ts-ignore + (gdjs.evtTools.common.angleDifference(newAngle, angle) > 0) ^ + diffWasPositive + ) { + newAngle = angle; + } + this.owner.setAngle(newAngle); + } + + override doStepPostEvents( + instanceContainer: gdjs.RuntimeInstanceContainer + ) { + this._manager.hasStepped = false; + } + getRadius(): float { return ( this._radius || @@ -379,150 +523,6 @@ namespace gdjs { destinationReached() { return this._reachedEnd; } - - /** - * Compute and move on the path to the specified destination. - */ - moveTo(x: float, y: float, z: float) { - this._path = []; - this._manager.rebuildNavMeshIfNeeded(); - if (!this._manager.navMesh) { - console.log("Can't build the nav mesh"); - this._pathFound = false; - return; - } - - // Start searching for a path - const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); - - const { success: hasFindDestination, point: destination } = - navMeshQuery.findClosestPoint( - { x, y: z, z: y }, - { halfExtents: { x: 100, y: 100, z: 100 } } - ); - if (!hasFindDestination) { - this._pathFound = false; - console.log("Can't find destination", x, y, z); - return; - } - - if (!this._agent) { - console.log('No agent'); - this._pathFound = false; - return; - } - this._pathFound = this._agent.requestMoveTarget(destination); - console.log( - 'hasFindPath', - this._pathFound, - this.owner.x, - this.owner.y, - //@ts-ignore - this.owner.getZ ? this.owner.getZ() : 0, - ' -> ', - x, - y, - z - ); - - // Path found: memorize it - const path = this._agent.corners(); - for (const point of path) { - const y = point.y; - point.y = point.z; - point.z = y; - } - console.log('path', path.length); - this._path = path; - if (this._pathFound) { - this._reachedEnd = false; - } - } - - override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { - const timeDelta = this.owner.getElapsedTime() / 1000; - // The wrapper interpolation seems bugged, so we don't use it. - this._manager.step(timeDelta); - - const agent = this._agent; - if (!agent) { - return; - } - - const oldX = this.owner.getX(); - const oldY = this.owner.getY(); - const newPosition = agent.position(); - const newX = newPosition.x; - const newY = newPosition.z; - const newZ = newPosition.y; - this.owner.setX(newX); - this.owner.setY(newY); - //@ts-ignore - if (this.owner.setZ) { - //@ts-ignore - this.owner.setZ(newZ); - } - - //console.log("newZ", newZ); - - // Avoid to frequently change of direction when not moving much. - const deltaX = newX - oldX; - const deltaY = newY - oldY; - if (Math.abs(deltaX) + Math.abs(deltaY) > this.getMaxSpeed() / 100) { - this._movementAngle = gdjs.toDegrees(Math.atan2(deltaY, deltaX)); - } - if ( - this._rotateObject && - this.owner.getAngle() !== this._movementAngle + this._angleOffset - ) { - this.rotateTowardAngle(this._movementAngle + this._angleOffset); - } - } - - /** - * @param angle The targeted angle. - * @param speed The rotation speed. 0 for an immediate rotation to the target angle. - */ - private rotateTowardAngle(angle: float): void { - const angularDiff = gdjs.evtTools.common.angleDifference( - this.owner.getAngle(), - angle - ); - const diffWasPositive = angularDiff >= 0; - - const timeDelta = this.owner.getElapsedTime() / 1000; - this._angularSpeed = - (diffWasPositive ? -1.0 : 1.0) * this._angularMaxSpeed; - // Always rotate the right way. - // if (this._angularSpeed > 0 !== diffWasPositive) { - // this._angularSpeed = 0; - // } - // this._angularSpeed = gdjs.evtTools.common.clamp( - // this._angularSpeed + - // (diffWasPositive ? -1.0 : 1.0) * - // this._angularAcceleration * - // timeDelta, - // -this._angularMaxSpeed, - // this._angularMaxSpeed - // ); - - let newAngle = this.owner.getAngle() + this._angularSpeed * timeDelta; - - if ( - // @ts-ignore - (gdjs.evtTools.common.angleDifference(newAngle, angle) > 0) ^ - diffWasPositive - ) { - newAngle = angle; - } - this.owner.setAngle(newAngle); - } - - override doStepPostEvents( - instanceContainer: gdjs.RuntimeInstanceContainer - ) { - this._manager.hasStepped = false; - } } gdjs.registerBehavior( 'NavMeshPathfinding::NavMeshCharacterBehavior', diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 37fa52d72bc5..34d7cc636532 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -45,8 +45,7 @@ namespace gdjs { walkableHeight: 10, detailSampleMaxError: 50, walkableClimb: 2, - // TODO - walkableRadius: 5, + walkableRadius: 1, }; walkableRadius: float = -1; timeSinceLastNavMeshLastRebuild: float = 1; From 5d8edf616deaf245d8521b15f1007722e69e1202 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Wed, 5 Aug 2026 18:40:20 +0200 Subject: [PATCH 18/51] Add condition about path --- Extensions/NavMeshPathfinding/JsExtension.js | 28 +++++ .../NavMeshCharacterRuntimeBehavior.ts | 106 +++++++++++++----- .../NavMeshObstacleRuntimeBehavior.ts | 4 +- 3 files changed, 110 insertions(+), 28 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 83efcd028ce3..59bcf4890d38 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -335,6 +335,34 @@ module.exports = { .addParameter('expression', _('Destination Y position')) .addParameter('expression', _('Destination Z position')) .setFunctionName('moveTo'); + + aut + .addCondition( + 'PathFound', + _('Path found'), + _('Check if a path has been found.'), + _('A path has been found for _PARAM0_'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon24.png', + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('pathFound'); + + aut + .addCondition( + 'DestinationReached', + _('Destination reached'), + _('Check if the destination was reached.'), + _('_PARAM0_ reached its destination'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon24.png', + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('destinationReached'); } { const behavior = new gd.BehaviorJsImplementation(); diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index d239f23de679..036a5dfbf504 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -38,8 +38,7 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData - extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -236,16 +235,6 @@ namespace gdjs { y, z ); - - // Path found: memorize it - const path = this._agent.corners(); - for (const point of path) { - const y = point.y; - point.y = point.z; - point.z = y; - } - console.log('path', path.length); - this._path = path; if (this._pathFound) { this._reachedEnd = false; } @@ -261,19 +250,31 @@ namespace gdjs { return; } + // Path found: memorize it + // We can't get the agent path before a first step, so we do it here. + if (this._path.length === 0 && agent.raw.ncorners > 0) { + const path = agent.corners(); + path.push(agent.target()); + for (const point of path) { + const y = point.y; + point.y = point.z; + point.z = y; + } + this._path = path; + console.log('path', this._path); + + console.log( + 'Destination', + this.getDestinationX(), + this.getDestinationY() + ); + } + const oldX = this.owner.getX(); const oldY = this.owner.getY(); - const newPosition = agent.position(); - const newX = newPosition.x; - const newY = newPosition.z; - const newZ = newPosition.y; - this.owner.setX(newX); - this.owner.setY(newY); - //@ts-ignore - if (this.owner.setZ) { - //@ts-ignore - this.owner.setZ(newZ); - } + let newX = agent.raw.get_npos(0); + let newY = agent.raw.get_npos(2); + let newZ = agent.raw.get_npos(1); //console.log("newZ", newZ); @@ -289,6 +290,27 @@ namespace gdjs { ) { this.rotateTowardAngle(this._movementAngle + this._angleOffset); } + + const destinationX = this.getDestinationX(); + const destinationY = this.getDestinationY(); + const destinationZ = this.getDestinationZ(); + if ( + Math.abs(newX - destinationX) < 0.5 && + Math.abs(newY - destinationY) < 0.5 && + //@ts-ignore + (!this.owner.getZ || Math.abs(newZ - destinationZ) < 0.5) + ) { + this._reachedEnd = true; + agent.resetMoveTarget(); + console.log('Reached end'); + } + this.owner.setX(newX); + this.owner.setY(newY); + //@ts-ignore + if (this.owner.setZ) { + //@ts-ignore + this.owner.setZ(newZ); + } } /** @@ -428,14 +450,21 @@ namespace gdjs { getNodeX(index: integer): float { if (index < this._path.length) { - return this._path[index][0]; + return this._path[index].x; } return 0; } getNodeY(index: integer): float { if (index < this._path.length) { - return this._path[index][1]; + return this._path[index].y; + } + return 0; + } + + getNodeZ(index: integer): float { + if (index < this._path.length) { + return this._path[index].z; } return 0; } @@ -470,6 +499,14 @@ namespace gdjs { return this._path[nextNodeIndex].y; } + getNextNodeZ(): float { + if (this._path.length === 0) { + return 0; + } + const nextNodeIndex = this.getNextNodeIndex(); + return this._path[nextNodeIndex].z; + } + getPreviousNodeIndex() { if (!this._agent) { return 0; @@ -496,18 +533,33 @@ namespace gdjs { return this._path[previousNodeIndex].y; } + getLastNodeZ(): float { + if (this._path.length < 2) { + return 0; + } + const previousNodeIndex = this.getPreviousNodeIndex(); + return this._path[previousNodeIndex].z; + } + getDestinationX(): float { if (this._path.length === 0) { return 0; } - return this._path[this._path.length - 1][0]; + return this._path[this._path.length - 1].x; } getDestinationY(): float { if (this._path.length === 0) { return 0; } - return this._path[this._path.length - 1][1]; + return this._path[this._path.length - 1].y; + } + + getDestinationZ(): float { + if (this._path.length === 0) { + return 0; + } + return this._path[this._path.length - 1].z; } /** diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 34d7cc636532..1e8c9d9b9e31 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -155,7 +155,9 @@ namespace gdjs { for (const character of this.characters) { this.rebuildCharacterAgent(character); } - this.debuggerRenderer.renderFor3D(); + if (this.debuggerRenderer) { + this.debuggerRenderer.renderFor3D(); + } } this.isNavMeshDirty = false; } From 079f3c1602d0f1f720dec18489e2a4cff2811acb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 6 Aug 2026 11:53:39 +0200 Subject: [PATCH 19/51] Handle stairs --- Extensions/NavMeshPathfinding/JsExtension.js | 23 +++++++++++++++++++ .../NavMeshCharacterRuntimeBehavior.ts | 3 ++- .../NavMeshObstacleRuntimeBehavior.ts | 13 +++++++++++ 3 files changed, 38 insertions(+), 1 deletion(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 59bcf4890d38..467aa849d422 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -210,6 +210,14 @@ module.exports = { .setDoubleValue(newValueAsNumber); return true; } + if (propertyName === 'stairHeightMax') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('stairHeightMax') + .setDoubleValue(newValueAsNumber); + return true; + } if (propertyName === 'walkableRadius') { const newValueAsNumber = parseFloat(newValue); if (newValueAsNumber !== newValueAsNumber) return false; @@ -259,6 +267,20 @@ module.exports = { .setAdvanced(true) .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + sharedProperties + .getOrCreate('stairHeightMax') + .setLabel(_('Max. stair height')) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setValue( + sharedContent + .getChild('stairHeightMax') + .getDoubleValue() + .toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + sharedProperties .getOrCreate('walkableRadius') .setLabel(_('Walkable radius')) @@ -284,6 +306,7 @@ module.exports = { sharedContent.addChild('cellSize').setDoubleValue(10); sharedContent.addChild('cellDepth').setDoubleValue(10); sharedContent.addChild('slopeMaxAngle').setDoubleValue(50); + sharedContent.addChild('stairHeightMax').setDoubleValue(20); sharedContent.addChild('walkableRadius').setDoubleValue(-1); }; diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 036a5dfbf504..b74898316edc 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -38,7 +38,8 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData + extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 1e8c9d9b9e31..011d4034a5af 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -48,6 +48,7 @@ namespace gdjs { walkableRadius: 1, }; walkableRadius: float = -1; + stairHeightMax: float = 20; timeSinceLastNavMeshLastRebuild: float = 1; isNavMeshDirty = true; isFirstFrame = true; @@ -60,6 +61,7 @@ namespace gdjs { this.navMeshConfig.ch = sharedData.cellDepth; this.navMeshConfig.detailSampleMaxError = sharedData.cellDepth * 5; this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; + this.stairHeightMax = sharedData.stairHeightMax; this.walkableRadius = sharedData.walkableRadius; } @@ -138,6 +140,17 @@ namespace gdjs { ? (this.walkableRadius < 0 ? characterRadiusMax : this.walkableRadius) / this.navMeshConfig.cs : 0; + const walkableClimbMin = + this.navMeshConfig.walkableSlopeAngle && + this.navMeshConfig.walkableSlopeAngle > 40 + ? 2 + : 1; + this.navMeshConfig.walkableClimb = this.navMeshConfig.ch + ? Math.max( + walkableClimbMin, + this.stairHeightMax / this.navMeshConfig.ch + ) + : walkableClimbMin; const result = RecastNav.generateSoloNavMesh( positions, From 26fcbaf9d1fbf2e531cf5d83daaf6bf7ef7dbfcf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 6 Aug 2026 15:15:51 +0200 Subject: [PATCH 20/51] Handle isometry for 2D --- Extensions/3D/Base3DBehavior.ts | 14 ----- Extensions/NavMeshPathfinding/JsExtension.js | 32 +++++++++++- .../NavMeshCharacterRuntimeBehavior.ts | 44 ++++++++++++---- .../NavMeshDebugPixiRenderer.ts | 11 ++-- .../NavMeshObstacleRuntimeBehavior.ts | 51 ++++++++++--------- GDJS/Runtime/runtimeobject.ts | 14 +++++ 6 files changed, 113 insertions(+), 53 deletions(-) diff --git a/Extensions/3D/Base3DBehavior.ts b/Extensions/3D/Base3DBehavior.ts index 2da7f10ae21a..f3969c2c7ee9 100644 --- a/Extensions/3D/Base3DBehavior.ts +++ b/Extensions/3D/Base3DBehavior.ts @@ -186,20 +186,6 @@ namespace gdjs { content: Object3DDataContent; } - /** @category Objects > 3D Objects */ - export namespace Base3DHandler { - export const is3D = ( - object: gdjs.RuntimeObject - ): object is gdjs.RuntimeObject & - gdjs.Base3DHandler & - gdjs.Resizable & - gdjs.Scalable & - gdjs.Flippable => { - //@ts-ignore We are checking if the methods are present. - return object.getZ && object.setZ; - }; - } - /** * A behavior that forwards the Base3D interface to its object. * @category Core Engine > Behavior diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 467aa849d422..eb766a48c556 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -152,10 +152,10 @@ module.exports = { .getOrCreate('radius') .setValue(behaviorContent.getChild('radius').getStringValue()) .setLabel(_('Radius')) + .setLabel(_('Use the circle inside the object width and height when left to 0.')) .setGroup(_('Collision')) .setType('Number') - .setMeasurementUnit(gd.MeasurementUnit.getPixel()) - .setAdvanced(true); + .setMeasurementUnit(gd.MeasurementUnit.getPixel()); behaviorProperties .getOrCreate('avoidanceSightRange') @@ -226,6 +226,14 @@ module.exports = { .setDoubleValue(newValueAsNumber); return true; } + if (propertyName === 'speedScaleY') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('speedScaleY') + .setDoubleValue(newValueAsNumber); + return true; + } return false; }; sharedData.getProperties = function (sharedContent) { @@ -300,6 +308,25 @@ module.exports = { .setAdvanced(true) .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + sharedProperties + .getOrCreate('speedScaleY') + .setLabel(_('Y speed scale')) + .setDescription( + _( + 'Allow a depth effect for 2D games. Usually set to 0.5 for isometry.' + ) + ) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setValue( + sharedContent + .getChild('speedScaleY') + .getDoubleValue() + .toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + return sharedProperties; }; sharedData.initializeContent = function (sharedContent) { @@ -308,6 +335,7 @@ module.exports = { sharedContent.addChild('slopeMaxAngle').setDoubleValue(50); sharedContent.addChild('stairHeightMax').setDoubleValue(20); sharedContent.addChild('walkableRadius').setDoubleValue(-1); + sharedContent.addChild('speedScaleY').setDoubleValue(1); }; const aut = extension diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index b74898316edc..48b00cc18986 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -38,8 +38,7 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData - extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -209,7 +208,11 @@ namespace gdjs { const { success: hasFindDestination, point: destination } = navMeshQuery.findClosestPoint( - { x, y: z, z: y }, + { + x, + y: z, + z: this._manager.is3D ? y : y * this._manager.inverseSpeedScaleY, + }, { halfExtents: { x: 100, y: 100, z: 100 } } ); if (!hasFindDestination) { @@ -260,6 +263,9 @@ namespace gdjs { const y = point.y; point.y = point.z; point.z = y; + if (!this._manager.is3D) { + point.y *= this._manager.inverseSpeedScaleY; + } } this._path = path; console.log('path', this._path); @@ -272,9 +278,13 @@ namespace gdjs { } const oldX = this.owner.getX(); - const oldY = this.owner.getY(); + const oldY = this._manager.is3D + ? this.owner.getY() + : this.owner.getY() * this._manager.speedScaleY; let newX = agent.raw.get_npos(0); - let newY = agent.raw.get_npos(2); + let newY = this._manager.is3D + ? agent.raw.get_npos(2) + : agent.raw.get_npos(2) * this._manager.speedScaleY; let newZ = agent.raw.get_npos(1); //console.log("newZ", newZ); @@ -458,7 +468,11 @@ namespace gdjs { getNodeY(index: integer): float { if (index < this._path.length) { - return this._path[index].y; + let y = this._path[index].y; + if (!this._manager.is3D) { + y *= this._manager.inverseSpeedScaleY; + } + return y; } return 0; } @@ -497,7 +511,11 @@ namespace gdjs { return 0; } const nextNodeIndex = this.getNextNodeIndex(); - return this._path[nextNodeIndex].y; + let y = this._path[nextNodeIndex].y; + if (!this._manager.is3D) { + y *= this._manager.inverseSpeedScaleY; + } + return y; } getNextNodeZ(): float { @@ -531,7 +549,11 @@ namespace gdjs { return 0; } const previousNodeIndex = this.getPreviousNodeIndex(); - return this._path[previousNodeIndex].y; + let y = this._path[previousNodeIndex].y; + if (!this._manager.is3D) { + y *= this._manager.inverseSpeedScaleY; + } + return y; } getLastNodeZ(): float { @@ -553,7 +575,11 @@ namespace gdjs { if (this._path.length === 0) { return 0; } - return this._path[this._path.length - 1].y; + let y = this._path[this._path.length - 1].y; + if (!this._manager.is3D) { + y *= this._manager.inverseSpeedScaleY; + } + return y; } getDestinationZ(): float { diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index 918276e73a6f..7640c5ddab5f 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -48,6 +48,7 @@ namespace gdjs { rendererObject.fill.alpha = 0.2; rendererObject.fill.color = 0x778ee8; + const speedScaleY = this.obstaclesManager.speedScaleY; for (const primitive of primitives) { switch (primitive.type) { case 'tris': @@ -55,21 +56,21 @@ namespace gdjs { const [x0, y0, z0] = primitive.vertices[i]; //console.log("y", y0); if (y0 < 15) { - const [x1, y1, z1] = primitive.vertices[i + 1]; - const [x2, y2, z2] = primitive.vertices[i + 2]; + const [x1, _y1, z1] = primitive.vertices[i + 1]; + const [x2, _y2, z2] = primitive.vertices[i + 2]; const positions: Array = []; positions.push.apply( positions, - layer.applyLayerTransformation(x0, z0, 0, workingPoint) + layer.applyLayerTransformation(x0, z0 * speedScaleY, 0, workingPoint) ); positions.push.apply( positions, - layer.applyLayerTransformation(x1, z1, 0, workingPoint) + layer.applyLayerTransformation(x1, z1 * speedScaleY, 0, workingPoint) ); positions.push.apply( positions, - layer.applyLayerTransformation(x2, z2, 0, workingPoint) + layer.applyLayerTransformation(x2, z2 * speedScaleY, 0, workingPoint) ); rendererObject.drawPolygon(positions); } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 011d4034a5af..143c6ae93077 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -49,6 +49,8 @@ namespace gdjs { }; walkableRadius: float = -1; stairHeightMax: float = 20; + speedScaleY: float = 1; + inverseSpeedScaleY: float = 1; timeSinceLastNavMeshLastRebuild: float = 1; isNavMeshDirty = true; isFirstFrame = true; @@ -63,6 +65,8 @@ namespace gdjs { this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; this.stairHeightMax = sharedData.stairHeightMax; this.walkableRadius = sharedData.walkableRadius; + this.speedScaleY = sharedData.speedScaleY; + this.inverseSpeedScaleY = 1 / sharedData.speedScaleY; } /** @@ -127,6 +131,18 @@ namespace gdjs { this.addGroundFor2D(positions, indices); this.navMeshConfig.walkableClimb = 0; this.navMeshConfig.ch = 10; + } else { + const walkableClimbMin = + this.navMeshConfig.walkableSlopeAngle && + this.navMeshConfig.walkableSlopeAngle > 40 + ? 2 + : 1; + this.navMeshConfig.walkableClimb = this.navMeshConfig.ch + ? Math.max( + walkableClimbMin, + this.stairHeightMax / this.navMeshConfig.ch + ) + : walkableClimbMin; } let characterRadiusMax = 0; @@ -140,17 +156,6 @@ namespace gdjs { ? (this.walkableRadius < 0 ? characterRadiusMax : this.walkableRadius) / this.navMeshConfig.cs : 0; - const walkableClimbMin = - this.navMeshConfig.walkableSlopeAngle && - this.navMeshConfig.walkableSlopeAngle > 40 - ? 2 - : 1; - this.navMeshConfig.walkableClimb = this.navMeshConfig.ch - ? Math.max( - walkableClimbMin, - this.stairHeightMax / this.navMeshConfig.ch - ) - : walkableClimbMin; const result = RecastNav.generateSoloNavMesh( positions, @@ -201,9 +206,9 @@ namespace gdjs { maxY = Math.max(maxY, y); } const width = maxX - minX; - const height = maxY - minY; + const height = (maxY - minY) * this.inverseSpeedScaleY; const centerX = (maxX + minX) / 2; - const centerY = (maxY + minY) / 2; + const centerY = ((maxY + minY) / 2) * this.inverseSpeedScaleY; console.log('Ground', width, height, centerX, centerY); @@ -258,18 +263,18 @@ namespace gdjs { vertexFlags, (p1: Point, p2: Point, p3: Point) => { // Top - positions.push(p1.x, 10, p1.y); - positions.push(p2.x, 10, p2.y); - positions.push(p3.x, 10, p3.y); + positions.push(p1.x, 10, p1.y * this.inverseSpeedScaleY); + positions.push(p2.x, 10, p2.y * this.inverseSpeedScaleY); + positions.push(p3.x, 10, p3.y * this.inverseSpeedScaleY); indices.push( indicesOffset + 0, indicesOffset + 1, indicesOffset + 2 ); // Bottom - positions.push(p1.x, 0, p1.y); - positions.push(p2.x, 0, p2.y); - positions.push(p3.x, 0, p3.y); + positions.push(p1.x, 0, p1.y * this.inverseSpeedScaleY); + positions.push(p2.x, 0, p2.y * this.inverseSpeedScaleY); + positions.push(p3.x, 0, p3.y * this.inverseSpeedScaleY); indices.push( indicesOffset + 3, indicesOffset + 5, @@ -281,15 +286,15 @@ namespace gdjs { for (let index = 0; index < vertices.length; index++) { const vertex = vertices[index]; // Side - positions.push(vertex.x, 10, vertex.y); - positions.push(vertex.x, 0, vertex.y); + positions.push(vertex.x, 10, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, 0, vertex.y * this.inverseSpeedScaleY); indices.push(indicesOffset + 0, indicesOffset + 1, indicesOffset + 2); indices.push(indicesOffset + 3, indicesOffset + 2, indicesOffset + 1); indicesOffset += 2; } const vertex = vertices[0]; - positions.push(vertex.x, 10, vertex.y); - positions.push(vertex.x, 0, vertex.y); + positions.push(vertex.x, 10, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, 0, vertex.y * this.inverseSpeedScaleY); } } diff --git a/GDJS/Runtime/runtimeobject.ts b/GDJS/Runtime/runtimeobject.ts index fe339f8c83bc..6d422df95f1f 100644 --- a/GDJS/Runtime/runtimeobject.ts +++ b/GDJS/Runtime/runtimeobject.ts @@ -4,6 +4,20 @@ * This project is released under the MIT License. */ namespace gdjs { + /** @category Objects > 3D Objects */ + export namespace Base3DHandler { + export const is3D = ( + object: gdjs.RuntimeObject + ): object is gdjs.RuntimeObject & + gdjs.Base3DHandler & + gdjs.Resizable & + gdjs.Scalable & + gdjs.Flippable => { + //@ts-ignore We are checking if the methods are present. + return object.getZ && object.setZ; + }; + } + /** * An axis-aligned bounding box. Used to represents a box around an object for example. * @category Core Engine > Object From b283b02fc25f8ebe0c0b1617b0cf282f3d9d5ab5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 6 Aug 2026 16:29:06 +0200 Subject: [PATCH 21/51] Handle position changes --- Extensions/NavMeshPathfinding/JsExtension.js | 11 +++-- .../NavMeshCharacterRuntimeBehavior.ts | 48 +++++++++++++++++-- .../NavMeshDebugPixiRenderer.ts | 21 ++++++-- .../NavMeshObstacleRuntimeBehavior.ts | 3 ++ 4 files changed, 71 insertions(+), 12 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index eb766a48c556..03f13d3597db 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -152,7 +152,11 @@ module.exports = { .getOrCreate('radius') .setValue(behaviorContent.getChild('radius').getStringValue()) .setLabel(_('Radius')) - .setLabel(_('Use the circle inside the object width and height when left to 0.')) + .setLabel( + _( + 'Use the circle inside the object width and height when left to 0.' + ) + ) .setGroup(_('Collision')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()); @@ -319,10 +323,7 @@ module.exports = { .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( - sharedContent - .getChild('speedScaleY') - .getDoubleValue() - .toString(10) + sharedContent.getChild('speedScaleY').getDoubleValue().toString(10) ) .setAdvanced(true) .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 48b00cc18986..a8bc73e582c3 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -38,7 +38,8 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData + extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -226,6 +227,7 @@ namespace gdjs { this._pathFound = false; return; } + this.teleportAgentToObjectIfNeeded(); this._pathFound = this._agent.requestMoveTarget(destination); console.log( 'hasFindPath', @@ -244,6 +246,46 @@ namespace gdjs { } } + teleportAgentToObjectIfNeeded(): void { + const agent = this._agent; + if (!agent) { + return; + } + const oldX = this.owner.getX(); + const oldY = this.owner.getY(); + //@ts-ignore + const oldZ = this.owner.getZ ? this.owner.getZ() : 0; + + let expectedX = agent.raw.get_npos(0); + let expectedY = this._manager.is3D + ? agent.raw.get_npos(2) + : agent.raw.get_npos(2) * this._manager.speedScaleY; + //@ts-ignore + let expectedZ = this.owner.getZ ? agent.raw.get_npos(1) : 0; + + if (oldX !== expectedX || oldY !== expectedY || oldZ !== expectedZ) { + agent.teleport({ + x: oldX, + y: this._manager.is3D ? oldZ : oldZ, + z: oldY * this._manager.inverseSpeedScaleY, + }); + console.log( + oldX, + '!==', + expectedX, + '||', + oldY, + '!==', + expectedY, + '||', + oldZ, + '!==', + expectedZ + ); + console.log('Teleport to', oldX, oldY, oldZ); + } + } + override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { const timeDelta = this.owner.getElapsedTime() / 1000; // The wrapper interpolation seems bugged, so we don't use it. @@ -278,9 +320,7 @@ namespace gdjs { } const oldX = this.owner.getX(); - const oldY = this._manager.is3D - ? this.owner.getY() - : this.owner.getY() * this._manager.speedScaleY; + const oldY = this.owner.getY(); let newX = agent.raw.get_npos(0); let newY = this._manager.is3D ? agent.raw.get_npos(2) diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index 7640c5ddab5f..b40f923b779b 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -62,15 +62,30 @@ namespace gdjs { const positions: Array = []; positions.push.apply( positions, - layer.applyLayerTransformation(x0, z0 * speedScaleY, 0, workingPoint) + layer.applyLayerTransformation( + x0, + z0 * speedScaleY, + 0, + workingPoint + ) ); positions.push.apply( positions, - layer.applyLayerTransformation(x1, z1 * speedScaleY, 0, workingPoint) + layer.applyLayerTransformation( + x1, + z1 * speedScaleY, + 0, + workingPoint + ) ); positions.push.apply( positions, - layer.applyLayerTransformation(x2, z2 * speedScaleY, 0, workingPoint) + layer.applyLayerTransformation( + x2, + z2 * speedScaleY, + 0, + workingPoint + ) ); rendererObject.drawPolygon(positions); } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 143c6ae93077..860c09321f3d 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -99,6 +99,9 @@ namespace gdjs { if (!this.crowd) { return; } + for (const character of this.characters) { + character.teleportAgentToObjectIfNeeded(); + } this.crowd.update(timeDelta); //1 / 60, timeDelta, 8); } From 537a18eeda21d0b5a6afd1060e65fe4051e2d8fb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Thu, 6 Aug 2026 18:29:01 +0200 Subject: [PATCH 22/51] Add expressions --- Extensions/NavMeshPathfinding/JsExtension.js | 254 ++++++++++++++++++ .../NavMeshCharacterRuntimeBehavior.ts | 1 - .../NavMeshDebugPixiRenderer.ts | 2 +- 3 files changed, 255 insertions(+), 2 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 03f13d3597db..87c178f7b523 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -415,6 +415,260 @@ module.exports = { .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') .setFunctionName('destinationReached'); + + aut + .addExpressionAndConditionAndAction( + 'number', + 'Acceleration', + _('Acceleration'), + _('the acceleration when moving the object'), + _('the acceleration on the path'), + _('Pathfinding configuration'), + 'CppPlatform/Extensions/AStaricon24.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .useStandardParameters('number', gd.ParameterOptions.makeNewOptions()) + .setFunctionName('setAcceleration') + .setGetter('getAcceleration'); + + aut + .addExpressionAndConditionAndAction( + 'number', + 'MaxSpeed', + _('Maximum speed'), + _('the maximum speed when moving the object'), + _('the max. speed on the path'), + _('Pathfinding configuration'), + 'CppPlatform/Extensions/AStaricon24.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .useStandardParameters( + 'number', + gd.ParameterOptions.makeNewOptions().setDescription( + _('Max speed (in pixels per second)') + ) + ) + .setFunctionName('setMaxSpeed') + .setGetter('getMaxSpeed'); + + aut + .addExpressionAndConditionAndAction( + 'number', + 'Speed', + _('Speed'), + _('Change the speed of the object on the path'), + _('the speed on the path'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon24.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .useStandardParameters( + 'number', + gd.ParameterOptions.makeNewOptions().setDescription( + _('Speed (in pixels per second)') + ) + ) + .setFunctionName('setSpeed') + .setGetter('getSpeed'); + + aut + .addScopedCondition( + 'MovementAngleIsAround', + _('Angle of movement on its path'), + _('Compare the angle of movement of an object on its path.'), + _('Angle of movement of _PARAM0_ is _PARAM2_ ± _PARAM3_°'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon24.png', + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .addParameter('expression', _('Angle, in degrees')) + .addParameter('expression', _('Tolerance, in degrees')); + + aut + .addExpressionAndConditionAndAction( + 'number', + 'AngularMaxSpeed', + _('Angular maximum speed'), + _('the maximum angular speed when moving the object'), + _('the max. angular speed on the path'), + _('Pathfinding configuration'), + 'CppPlatform/Extensions/AStaricon24.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .useStandardParameters( + 'number', + gd.ParameterOptions.makeNewOptions().setDescription( + _('Max angular speed (in degrees per second)') + ) + ) + .setFunctionName('setAngularMaxSpeed') + .setGetter('getAngularMaxSpeed'); + + aut + .addExpressionAndConditionAndAction( + 'number', + 'AngleOffset', + _('Rotation offset'), + _('the rotation offset applied when moving the object'), + _('the rotation offset on the path'), + _('Pathfinding configuration'), + 'CppPlatform/Extensions/AStaricon24.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .useStandardParameters( + 'number', + gd.ParameterOptions.makeNewOptions().setDescription( + _('Angle (in degrees)') + ) + ) + .setFunctionName('setAngleOffset') + .setGetter('getAngleOffset'); + + aut + .addScopedAction( + 'RotateObject', + _('Rotate the object'), + _('Enable or disable rotation of the object on the path'), + _('Enable rotation of _PARAM0_ on the path: _PARAM2_'), + _('Pathfinding configuration'), + 'CppPlatform/Extensions/AStaricon24.png', + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .addParameter('yesorno', _('Rotate object?')) + .setFunctionName('setRotateObject'); + + aut + .addScopedCondition( + 'ObjectRotated', + _('Object rotated'), + _('Check if the object is rotated when traveling on its path.'), + _('_PARAM0_ is rotated when traveling on its path'), + _('Pathfinding configuration'), + 'CppPlatform/Extensions/AStaricon24.png', + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('isObjectRotated'); + + aut + .addExpression( + 'GetNodeX', + _('Get a waypoint X position'), + _('Get next waypoint X position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .addParameter('expression', _('Node index (start at 0!)')) + .setFunctionName('getNodeX'); + + aut + .addExpression( + 'GetNodeY', + _('Get a waypoint Y position'), + _('Get next waypoint Y position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .addParameter('expression', _('Node index (start at 0!)')) + .setFunctionName('getNodeY'); + + aut + .addExpression( + 'NextNodeIndex', + _('Index of the next waypoint'), + _('Get the index of the next waypoint to reach'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getNextNodeIndex'); + + aut + .addExpression( + 'NodeCount', + _('Waypoint count'), + _('Get the number of waypoints on the path'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getNodeCount'); + + aut + .addExpression( + 'NextNodeX', + _('Get next waypoint X position'), + _('Get next waypoint X position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getNextNodeX'); + + aut + .addExpression( + 'NextNodeY', + _('Get next waypoint Y position'), + _('Get next waypoint Y position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getNextNodeY'); + + aut + .addExpression( + 'LastNodeX', + _('Last waypoint X position'), + _('Last waypoint X position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getLastNodeX'); + + aut + .addExpression( + 'LastNodeY', + _('Last waypoint Y position'), + _('Last waypoint Y position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getLastNodeY'); + + aut + .addExpression( + 'MovementAngle', + _('Angle of movement on its path'), + _('Angle of movement on its path'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getMovementAngle'); } { const behavior = new gd.BehaviorJsImplementation(); diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index a8bc73e582c3..1202079b4976 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -14,7 +14,6 @@ namespace gdjs { const Recast = await initializeRecast(); await RecastNav.init(); - console.log('Initialized Recast'); //@ts-ignore window.Recast = Recast; } catch (err) { diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index b40f923b779b..ada9ac517af3 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -45,7 +45,7 @@ namespace gdjs { const workingPoint: FloatPoint = [0, 0]; rendererObject.beginFill(); - rendererObject.fill.alpha = 0.2; + rendererObject.fill.alpha = 0.5; rendererObject.fill.color = 0x778ee8; const speedScaleY = this.obstaclesManager.speedScaleY; From a9471cf4f88d1dd98eede4f6b5c04955101c9aa3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Fri, 7 Aug 2026 15:12:19 +0200 Subject: [PATCH 23/51] Fix movement angle --- .../NavMeshCharacterRuntimeBehavior.ts | 78 ++++++++++--------- 1 file changed, 40 insertions(+), 38 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 1202079b4976..3b28d42cc53b 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -37,8 +37,7 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData - extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -54,9 +53,8 @@ namespace gdjs { /** Used by the path simplification algorithm */ static _smoothingWorkingVertices: Array = []; - //Behavior configuration: + // Behavior configuration: _angularMaxSpeed: float; - _angularAcceleration: float; _rotateObject: boolean; _angleOffset: float; _radius: float; @@ -70,14 +68,14 @@ namespace gdjs { separationWeight: 1.0, }; - //Attributes used for traveling on the path: + // Attributes used for traveling on the path: _angularSpeed: float = 0; _pathFound: boolean = false; _reachedEnd: boolean = false; - _manager: NavMeshObstaclesManager; - _movementAngle: float = 0; + _manager: NavMeshObstaclesManager; + constructor( instanceContainer: gdjs.RuntimeInstanceContainer, behaviorData, @@ -99,9 +97,6 @@ namespace gdjs { this._crowdAgentParams.collisionQueryRange = behaviorData.avoidanceSightRange; - // TODO Add a property for it? - this._angularAcceleration = 7200; - this._manager = gdjs.NavMeshObstaclesManager.getManager(instanceContainer); this._manager.addCharacter(this); @@ -318,8 +313,6 @@ namespace gdjs { ); } - const oldX = this.owner.getX(); - const oldY = this.owner.getY(); let newX = agent.raw.get_npos(0); let newY = this._manager.is3D ? agent.raw.get_npos(2) @@ -328,11 +321,31 @@ namespace gdjs { //console.log("newZ", newZ); - // Avoid to frequently change of direction when not moving much. - const deltaX = newX - oldX; - const deltaY = newY - oldY; - if (Math.abs(deltaX) + Math.abs(deltaY) > this.getMaxSpeed() / 100) { - this._movementAngle = gdjs.toDegrees(Math.atan2(deltaY, deltaX)); + const destinationX = this.getDestinationX(); + const destinationY = this.getDestinationY(); + const destinationZ = this.getDestinationZ(); + + const velocity = agent.desiredVelocity(); + const velocityX = velocity.x; + const velocityY = this._manager.is3D + ? velocity.z + : velocity.z * this._manager.speedScaleY; + if ( + Math.abs(velocityX) > 0 && + Math.abs(velocityY) > 0 && + // Avoid to rotate strangely at the end of the path + Math.abs(destinationX - newX) > 3 && + Math.abs(destinationY - newY) > 3 + ) { + this._movementAngle = gdjs.evtTools.common.mod( + gdjs.toDegrees( + Math.atan2( + velocityY, + velocityX + ) + ), + 360 + ); } if ( this._rotateObject && @@ -340,15 +353,11 @@ namespace gdjs { ) { this.rotateTowardAngle(this._movementAngle + this._angleOffset); } - - const destinationX = this.getDestinationX(); - const destinationY = this.getDestinationY(); - const destinationZ = this.getDestinationZ(); if ( - Math.abs(newX - destinationX) < 0.5 && - Math.abs(newY - destinationY) < 0.5 && + Math.abs(newX - destinationX) < 1 && + Math.abs(newY - destinationY) < 1 && //@ts-ignore - (!this.owner.getZ || Math.abs(newZ - destinationZ) < 0.5) + (!this.owner.getZ || Math.abs(newZ - destinationZ) < 1) ) { this._reachedEnd = true; agent.resetMoveTarget(); @@ -377,18 +386,6 @@ namespace gdjs { const timeDelta = this.owner.getElapsedTime() / 1000; this._angularSpeed = (diffWasPositive ? -1.0 : 1.0) * this._angularMaxSpeed; - // Always rotate the right way. - // if (this._angularSpeed > 0 !== diffWasPositive) { - // this._angularSpeed = 0; - // } - // this._angularSpeed = gdjs.evtTools.common.clamp( - // this._angularSpeed + - // (diffWasPositive ? -1.0 : 1.0) * - // this._angularAcceleration * - // timeDelta, - // -this._angularMaxSpeed, - // this._angularMaxSpeed - // ); let newAngle = this.owner.getAngle() + this._angularSpeed * timeDelta; @@ -458,8 +455,13 @@ namespace gdjs { if (!this._agent) { return 0; } - const velocity = this._agent.desiredVelocityObstacleAdjusted(); - return Math.hypot(velocity.x, velocity.y, velocity.z); + const velocity = this._agent.desiredVelocity(); + + return Math.hypot( + velocity.x, + velocity.y, + this._manager.is3D ? velocity.z : velocity.z * this._manager.speedScaleY + ); } getMovementAngle(): float { From c5220f78e136260e52283f3bfe7189a9ef10c355 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Fri, 7 Aug 2026 15:52:08 +0200 Subject: [PATCH 24/51] Fix coords conversion --- Extensions/NavMeshPathfinding/JsExtension.js | 89 +++++++++++++++++-- .../NavMeshCharacterRuntimeBehavior.ts | 55 ++++-------- 2 files changed, 96 insertions(+), 48 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 87c178f7b523..f3ab0c13f04c 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -586,6 +586,19 @@ module.exports = { .addParameter('expression', _('Node index (start at 0!)')) .setFunctionName('getNodeY'); + aut + .addExpression( + 'GetNodeZ', + _('Get a waypoint Z position'), + _('Get next waypoint Z position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .addParameter('expression', _('Node index (start at 0!)')) + .setFunctionName('getNodeZ'); + aut .addExpression( 'NextNodeIndex', @@ -636,27 +649,87 @@ module.exports = { aut .addExpression( - 'LastNodeX', - _('Last waypoint X position'), - _('Last waypoint X position'), + 'NextNodeZ', + _('Get next waypoint Z position'), + _('Get next waypoint Z position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getNextNodeZ'); + + aut + .addExpression( + 'PreviousNodeX', + _('Previous waypoint X position'), + _('Previous waypoint X position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getPreviousNodeX'); + + aut + .addExpression( + 'PreviousNodeY', + _('Previous waypoint Y position'), + _('Previous waypoint Y position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getPreviousNodeY'); + + aut + .addExpression( + 'PreviousNodeZ', + _('Previous waypoint Z position'), + _('Previous waypoint Z position'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getPreviousNodeZ'); + + aut + .addExpression( + 'DestinationX', + _('Destination X position'), + _('Destination X position of the path'), + _('Movement on the path'), + 'CppPlatform/Extensions/AStaricon16.png' + ) + .addParameter('object', _('Object')) + .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') + .setFunctionName('getDestinationX'); + + aut + .addExpression( + 'DestinationY', + _('Destination Y position'), + _('Destination Y position of the path'), _('Movement on the path'), 'CppPlatform/Extensions/AStaricon16.png' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') - .setFunctionName('getLastNodeX'); + .setFunctionName('getDestinationY'); aut .addExpression( - 'LastNodeY', - _('Last waypoint Y position'), - _('Last waypoint Y position'), + 'DestinationZ', + _('Destination Z position'), + _('Destination Z position of the path'), _('Movement on the path'), 'CppPlatform/Extensions/AStaricon16.png' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') - .setFunctionName('getLastNodeY'); + .setFunctionName('getDestinationZ'); aut .addExpression( diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 3b28d42cc53b..6d83bc64bde4 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -260,8 +260,10 @@ namespace gdjs { if (oldX !== expectedX || oldY !== expectedY || oldZ !== expectedZ) { agent.teleport({ x: oldX, - y: this._manager.is3D ? oldZ : oldZ, - z: oldY * this._manager.inverseSpeedScaleY, + y: oldZ, + z: this._manager.is3D + ? oldY + : oldY * this._manager.inverseSpeedScaleY, }); console.log( oldX, @@ -300,7 +302,7 @@ namespace gdjs { point.y = point.z; point.z = y; if (!this._manager.is3D) { - point.y *= this._manager.inverseSpeedScaleY; + point.y *= this._manager.speedScaleY; } } this._path = path; @@ -327,9 +329,7 @@ namespace gdjs { const velocity = agent.desiredVelocity(); const velocityX = velocity.x; - const velocityY = this._manager.is3D - ? velocity.z - : velocity.z * this._manager.speedScaleY; + const velocityY = velocity.z; if ( Math.abs(velocityX) > 0 && Math.abs(velocityY) > 0 && @@ -338,12 +338,7 @@ namespace gdjs { Math.abs(destinationY - newY) > 3 ) { this._movementAngle = gdjs.evtTools.common.mod( - gdjs.toDegrees( - Math.atan2( - velocityY, - velocityX - ) - ), + gdjs.toDegrees(Math.atan2(velocityY, velocityX)), 360 ); } @@ -457,11 +452,7 @@ namespace gdjs { } const velocity = this._agent.desiredVelocity(); - return Math.hypot( - velocity.x, - velocity.y, - this._manager.is3D ? velocity.z : velocity.z * this._manager.speedScaleY - ); + return Math.hypot(velocity.x, velocity.y, velocity.z); } getMovementAngle(): float { @@ -509,11 +500,7 @@ namespace gdjs { getNodeY(index: integer): float { if (index < this._path.length) { - let y = this._path[index].y; - if (!this._manager.is3D) { - y *= this._manager.inverseSpeedScaleY; - } - return y; + return this._path[index].y; } return 0; } @@ -552,11 +539,7 @@ namespace gdjs { return 0; } const nextNodeIndex = this.getNextNodeIndex(); - let y = this._path[nextNodeIndex].y; - if (!this._manager.is3D) { - y *= this._manager.inverseSpeedScaleY; - } - return y; + return this._path[nextNodeIndex].y; } getNextNodeZ(): float { @@ -577,7 +560,7 @@ namespace gdjs { : this._path.length - remainingNodes - 1; } - getLastNodeX(): float { + getPreviousNodeX(): float { if (this._path.length < 2) { return 0; } @@ -585,19 +568,15 @@ namespace gdjs { return this._path[previousNodeIndex].x; } - getLastNodeY(): float { + getPreviousNodeY(): float { if (this._path.length < 2) { return 0; } const previousNodeIndex = this.getPreviousNodeIndex(); - let y = this._path[previousNodeIndex].y; - if (!this._manager.is3D) { - y *= this._manager.inverseSpeedScaleY; - } - return y; + return this._path[previousNodeIndex].y; } - getLastNodeZ(): float { + getPreviousNodeZ(): float { if (this._path.length < 2) { return 0; } @@ -616,11 +595,7 @@ namespace gdjs { if (this._path.length === 0) { return 0; } - let y = this._path[this._path.length - 1].y; - if (!this._manager.is3D) { - y *= this._manager.inverseSpeedScaleY; - } - return y; + return this._path[this._path.length - 1].y; } getDestinationZ(): float { From afaf9c2b7f2f84d3719b7076094d14df00380a40 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Fri, 7 Aug 2026 16:39:30 +0200 Subject: [PATCH 25/51] Fix movement angle --- Extensions/NavMeshPathfinding/JsExtension.js | 3 --- .../NavMeshCharacterRuntimeBehavior.ts | 27 +++---------------- 2 files changed, 4 insertions(+), 26 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index f3ab0c13f04c..699872d78bf3 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -864,9 +864,6 @@ module.exports = { 'Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.js' ) .addIncludeFile('Extensions/NavMeshPathfinding/recast-navigation.wasm.js') - .addIncludeFile( - 'Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm' - ) .addIncludeFile( 'Extensions/NavMeshPathfinding/recast-navigation-generators.js' ) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 6d83bc64bde4..6bcbe2238c68 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -265,19 +265,8 @@ namespace gdjs { ? oldY : oldY * this._manager.inverseSpeedScaleY, }); - console.log( - oldX, - '!==', - expectedX, - '||', - oldY, - '!==', - expectedY, - '||', - oldZ, - '!==', - expectedZ - ); + this._path = []; + this._pathFound = false; console.log('Teleport to', oldX, oldY, oldZ); } } @@ -307,12 +296,6 @@ namespace gdjs { } this._path = path; console.log('path', this._path); - - console.log( - 'Destination', - this.getDestinationX(), - this.getDestinationY() - ); } let newX = agent.raw.get_npos(0); @@ -331,11 +314,9 @@ namespace gdjs { const velocityX = velocity.x; const velocityY = velocity.z; if ( - Math.abs(velocityX) > 0 && - Math.abs(velocityY) > 0 && + Math.abs(velocityX) + Math.abs(velocityY) > 0 && // Avoid to rotate strangely at the end of the path - Math.abs(destinationX - newX) > 3 && - Math.abs(destinationY - newY) > 3 + (Math.abs(destinationX - newX) > 3 || Math.abs(destinationY - newY) > 3) ) { this._movementAngle = gdjs.evtTools.common.mod( gdjs.toDegrees(Math.atan2(velocityY, velocityX)), From 18424e963e7951995f15b675d0bdff9204ef6c41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Fri, 7 Aug 2026 20:14:44 +0200 Subject: [PATCH 26/51] Fix characters not exactly on the mesh were not moving --- Extensions/NavMeshPathfinding/JsExtension.js | 30 +++++++++++- .../NavMeshCharacterRuntimeBehavior.ts | 48 +++++++++++++++++-- .../NavMeshDebugPixiRenderer.ts | 4 -- .../NavMeshObstacleRuntimeBehavior.ts | 11 +++-- 4 files changed, 82 insertions(+), 11 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 699872d78bf3..5e447ee54240 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -152,7 +152,7 @@ module.exports = { .getOrCreate('radius') .setValue(behaviorContent.getChild('radius').getStringValue()) .setLabel(_('Radius')) - .setLabel( + .setDescription( _( 'Use the circle inside the object width and height when left to 0.' ) @@ -230,6 +230,14 @@ module.exports = { .setDoubleValue(newValueAsNumber); return true; } + if (propertyName === 'walkableHeight') { + const newValueAsNumber = parseFloat(newValue); + if (newValueAsNumber !== newValueAsNumber) return false; + sharedContent + .getOrCreateChild('walkableHeight') + .setDoubleValue(newValueAsNumber); + return true; + } if (propertyName === 'speedScaleY') { const newValueAsNumber = parseFloat(newValue); if (newValueAsNumber !== newValueAsNumber) return false; @@ -312,6 +320,25 @@ module.exports = { .setAdvanced(true) .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + sharedProperties + .getOrCreate('walkableHeight') + .setLabel(_('Walkable height')) + .setDescription( + _( + 'Minimum floor to ceiling height that will still allow the floor area to be considered walkable.' + ) + ) + .setType('Number') + .setMeasurementUnit(gd.MeasurementUnit.getPixel()) + .setValue( + sharedContent + .getChild('walkableHeight') + .getDoubleValue() + .toString(10) + ) + .setAdvanced(true) + .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); + sharedProperties .getOrCreate('speedScaleY') .setLabel(_('Y speed scale')) @@ -336,6 +363,7 @@ module.exports = { sharedContent.addChild('slopeMaxAngle').setDoubleValue(50); sharedContent.addChild('stairHeightMax').setDoubleValue(20); sharedContent.addChild('walkableRadius').setDoubleValue(-1); + sharedContent.addChild('walkableHeight').setDoubleValue(150); sharedContent.addChild('speedScaleY').setDoubleValue(1); }; diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 6bcbe2238c68..01e55964059a 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -221,7 +221,40 @@ namespace gdjs { this._pathFound = false; return; } - this.teleportAgentToObjectIfNeeded(); + const { success: hasFindOrigin, point: origin } = + navMeshQuery.findClosestPoint( + { + x: this.owner.getX(), + //@ts-ignore + y: this.owner.getZ ? this.owner.getZ() : 0, + z: this._manager.is3D + ? this.owner.getY() + : this.owner.getY() * this._manager.inverseSpeedScaleY, + }, + { halfExtents: { x: 100, y: 100, z: 100 } } + ); + if (!hasFindOrigin) { + this._pathFound = false; + console.log( + "Can't find origin", + this.owner.getX(), + this.owner.getY(), + //@ts-ignore + this.owner.getZ ? this.owner.getZ() : 0 + ); + return; + } + this._agent.teleport(origin); + this.owner.setX(origin.x); + this.owner.setY( + this._manager.is3D ? origin.z : origin.z * this._manager.speedScaleY + ); + //@ts-ignore + if (this.owner.setZ) { + //@ts-ignore + this.owner.setZ(origin.y); + } + this._pathFound = this._agent.requestMoveTarget(destination); console.log( 'hasFindPath', @@ -231,6 +264,12 @@ namespace gdjs { //@ts-ignore this.owner.getZ ? this.owner.getZ() : 0, ' -> ', + destination.x, + this._manager.is3D + ? destination.z + : destination.z * this._manager.speedScaleY, + destination.y, + 'extended from', x, y, z @@ -247,15 +286,17 @@ namespace gdjs { } const oldX = this.owner.getX(); const oldY = this.owner.getY(); + // For 2D we keep the agent position for Z because the ground may not be + // at 0 because of rasterization. //@ts-ignore - const oldZ = this.owner.getZ ? this.owner.getZ() : 0; + const oldZ = this.owner.getZ ? this.owner.getZ() : agent.raw.get_npos(1); let expectedX = agent.raw.get_npos(0); let expectedY = this._manager.is3D ? agent.raw.get_npos(2) : agent.raw.get_npos(2) * this._manager.speedScaleY; //@ts-ignore - let expectedZ = this.owner.getZ ? agent.raw.get_npos(1) : 0; + let expectedZ = agent.raw.get_npos(1); if (oldX !== expectedX || oldY !== expectedY || oldZ !== expectedZ) { agent.teleport({ @@ -297,6 +338,7 @@ namespace gdjs { this._path = path; console.log('path', this._path); } + console.log(agent.raw.get_npos(0), agent.raw.get_npos(2), agent.raw.get_npos(1)); let newX = agent.raw.get_npos(0); let newY = this._manager.is3D diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index ada9ac517af3..2acf73733c1a 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -54,7 +54,6 @@ namespace gdjs { case 'tris': for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { const [x0, y0, z0] = primitive.vertices[i]; - //console.log("y", y0); if (y0 < 15) { const [x1, _y1, z1] = primitive.vertices[i + 1]; const [x2, _y2, z2] = primitive.vertices[i + 2]; @@ -117,7 +116,6 @@ namespace gdjs { .values() .next().value; const scene = firstObstacle.owner.getRuntimeScene(); - const inverseWorldScale = scene.getRenderer3DInverseWorldScale(); const layer = scene.getLayer(firstObstacle.owner.getLayer()); const rendererObject = layer.get3DRendererObject(); if (!rendererObject) { @@ -159,8 +157,6 @@ namespace gdjs { }); } const mesh = new THREE.Mesh(geometry, this.material); - - console.log(positions); meshes.push(mesh); rendererObject.add(mesh); break; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 860c09321f3d..10c38cf7e3a0 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -42,12 +42,13 @@ namespace gdjs { cs: 10, ch: 10, walkableSlopeAngle: 50, - walkableHeight: 10, + walkableHeight: 15, detailSampleMaxError: 50, walkableClimb: 2, walkableRadius: 1, }; walkableRadius: float = -1; + walkableHeight: float = 150; stairHeightMax: float = 20; speedScaleY: float = 1; inverseSpeedScaleY: float = 1; @@ -64,6 +65,7 @@ namespace gdjs { this.navMeshConfig.detailSampleMaxError = sharedData.cellDepth * 5; this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; this.stairHeightMax = sharedData.stairHeightMax; + this.walkableHeight = sharedData.walkableHeight; this.walkableRadius = sharedData.walkableRadius; this.speedScaleY = sharedData.speedScaleY; this.inverseSpeedScaleY = 1 / sharedData.speedScaleY; @@ -132,7 +134,8 @@ namespace gdjs { } if (!this.is3D && positions.length > 0) { this.addGroundFor2D(positions, indices); - this.navMeshConfig.walkableClimb = 0; + this.navMeshConfig.walkableClimb = 0.1; + this.navMeshConfig.walkableHeight = 2; this.navMeshConfig.ch = 10; } else { const walkableClimbMin = @@ -146,6 +149,9 @@ namespace gdjs { this.stairHeightMax / this.navMeshConfig.ch ) : walkableClimbMin; + this.navMeshConfig.walkableHeight = this.navMeshConfig.ch + ? this.walkableHeight / this.navMeshConfig.ch + : this.walkableHeight; } let characterRadiusMax = 0; @@ -477,7 +483,6 @@ namespace gdjs { } character._crowdAgentParams.radius = character.getRadius(); - console.log(character._crowdAgentParams.radius); character._crowdAgentParams.height = //@ts-ignore owner.getDepth From d1475bb26a48114a4e4544fc56f8495c509c62ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 8 Aug 2026 10:45:03 +0200 Subject: [PATCH 27/51] Avoid to find a destination inside a 2D obstacle --- Extensions/NavMeshPathfinding/JsExtension.js | 17 +++++++++++------ .../NavMeshCharacterRuntimeBehavior.ts | 9 +++++---- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 5e447ee54240..23fa3453d28d 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -230,11 +230,11 @@ module.exports = { .setDoubleValue(newValueAsNumber); return true; } - if (propertyName === 'walkableHeight') { + if (propertyName === 'walkableDepth') { const newValueAsNumber = parseFloat(newValue); if (newValueAsNumber !== newValueAsNumber) return false; sharedContent - .getOrCreateChild('walkableHeight') + .getOrCreateChild('walkableDepth') .setDoubleValue(newValueAsNumber); return true; } @@ -265,6 +265,7 @@ module.exports = { sharedProperties .getOrCreate('cellDepth') .setLabel(_('Cell depth')) + .setGroup(_('3D only')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( @@ -276,6 +277,7 @@ module.exports = { sharedProperties .getOrCreate('slopeMaxAngle') .setLabel(_('Slope max. angle')) + .setGroup(_('3D only')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getDegreeAngle()) .setValue( @@ -290,6 +292,7 @@ module.exports = { sharedProperties .getOrCreate('stairHeightMax') .setLabel(_('Max. stair height')) + .setGroup(_('3D only')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( @@ -321,18 +324,19 @@ module.exports = { .setQuickCustomizationVisibility(gd.QuickCustomization.Hidden); sharedProperties - .getOrCreate('walkableHeight') - .setLabel(_('Walkable height')) + .getOrCreate('walkableDepth') + .setLabel(_('Walkable depth')) .setDescription( _( 'Minimum floor to ceiling height that will still allow the floor area to be considered walkable.' ) ) + .setGroup(_('3D only')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( sharedContent - .getChild('walkableHeight') + .getChild('walkableDepth') .getDoubleValue() .toString(10) ) @@ -347,6 +351,7 @@ module.exports = { 'Allow a depth effect for 2D games. Usually set to 0.5 for isometry.' ) ) + .setGroup(_('2D only')) .setType('Number') .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( @@ -363,7 +368,7 @@ module.exports = { sharedContent.addChild('slopeMaxAngle').setDoubleValue(50); sharedContent.addChild('stairHeightMax').setDoubleValue(20); sharedContent.addChild('walkableRadius').setDoubleValue(-1); - sharedContent.addChild('walkableHeight').setDoubleValue(150); + sharedContent.addChild('walkableDepth').setDoubleValue(150); sharedContent.addChild('speedScaleY').setDoubleValue(1); }; diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 01e55964059a..302b62cb9147 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -208,7 +208,8 @@ namespace gdjs { y: z, z: this._manager.is3D ? y : y * this._manager.inverseSpeedScaleY, }, - { halfExtents: { x: 100, y: 100, z: 100 } } + { halfExtents: { x: 100, y: this._manager.is3D + ? 100 : 10, z: 100 } } ); if (!hasFindDestination) { this._pathFound = false; @@ -231,7 +232,8 @@ namespace gdjs { ? this.owner.getY() : this.owner.getY() * this._manager.inverseSpeedScaleY, }, - { halfExtents: { x: 100, y: 100, z: 100 } } + { halfExtents: { x: 100, y: this._manager.is3D + ? 100 : 10, z: 100 } } ); if (!hasFindOrigin) { this._pathFound = false; @@ -338,7 +340,6 @@ namespace gdjs { this._path = path; console.log('path', this._path); } - console.log(agent.raw.get_npos(0), agent.raw.get_npos(2), agent.raw.get_npos(1)); let newX = agent.raw.get_npos(0); let newY = this._manager.is3D @@ -346,7 +347,7 @@ namespace gdjs { : agent.raw.get_npos(2) * this._manager.speedScaleY; let newZ = agent.raw.get_npos(1); - //console.log("newZ", newZ); + console.log("New position", newX, newY, newZ); const destinationX = this.getDestinationX(); const destinationY = this.getDestinationY(); From bf49b8873ab2e904b4f116c111592df8dba525f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 8 Aug 2026 17:20:49 +0200 Subject: [PATCH 28/51] Make cell height for 2D explicit --- .../NavMeshCharacterRuntimeBehavior.ts | 24 +++++++++++++++---- .../NavMeshDebugPixiRenderer.ts | 5 +++- .../NavMeshObstacleRuntimeBehavior.ts | 19 ++++++++------- 3 files changed, 34 insertions(+), 14 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 302b62cb9147..da546176f825 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -208,8 +208,15 @@ namespace gdjs { y: z, z: this._manager.is3D ? y : y * this._manager.inverseSpeedScaleY, }, - { halfExtents: { x: 100, y: this._manager.is3D - ? 100 : 10, z: 100 } } + { + halfExtents: { + x: 100, + y: this._manager.is3D + ? 100 + : gdjs.NavMeshObstaclesManager.cellHeightFor2D, + z: 100, + }, + } ); if (!hasFindDestination) { this._pathFound = false; @@ -232,8 +239,15 @@ namespace gdjs { ? this.owner.getY() : this.owner.getY() * this._manager.inverseSpeedScaleY, }, - { halfExtents: { x: 100, y: this._manager.is3D - ? 100 : 10, z: 100 } } + { + halfExtents: { + x: 100, + y: this._manager.is3D + ? 100 + : gdjs.NavMeshObstaclesManager.cellHeightFor2D, + z: 100, + }, + } ); if (!hasFindOrigin) { this._pathFound = false; @@ -347,7 +361,7 @@ namespace gdjs { : agent.raw.get_npos(2) * this._manager.speedScaleY; let newZ = agent.raw.get_npos(1); - console.log("New position", newX, newY, newZ); + console.log('New position', newX, newY, newZ); const destinationX = this.getDestinationX(); const destinationY = this.getDestinationY(); diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index 2acf73733c1a..e74323ab645f 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -54,7 +54,10 @@ namespace gdjs { case 'tris': for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { const [x0, y0, z0] = primitive.vertices[i]; - if (y0 < 15) { + if ( + y0 < + 1.5 * gdjs.NavMeshObstaclesManager.cellHeightFor2D + ) { const [x1, _y1, z1] = primitive.vertices[i + 1]; const [x2, _y2, z2] = primitive.vertices[i + 2]; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 10c38cf7e3a0..fbf09e461d99 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -59,6 +59,8 @@ namespace gdjs { hasStepped = false; debuggerRenderer: gdjs.NavMeshDebuggerRenderer | null = null; + static readonly cellHeightFor2D = 10; + constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { this.navMeshConfig.cs = sharedData.cellSize; this.navMeshConfig.ch = sharedData.cellDepth; @@ -136,7 +138,7 @@ namespace gdjs { this.addGroundFor2D(positions, indices); this.navMeshConfig.walkableClimb = 0.1; this.navMeshConfig.walkableHeight = 2; - this.navMeshConfig.ch = 10; + this.navMeshConfig.ch = gdjs.NavMeshObstaclesManager.cellHeightFor2D; } else { const walkableClimbMin = this.navMeshConfig.walkableSlopeAngle && @@ -229,11 +231,11 @@ namespace gdjs { x *= width; y *= height; - z *= 10; + z *= gdjs.NavMeshObstaclesManager.cellHeightFor2D; x += centerX; y += centerY; - z -= 5; + z -= gdjs.NavMeshObstaclesManager.cellHeightFor2D / 2; // Y is the top for Recast positions.push(x, z, y); @@ -267,14 +269,15 @@ namespace gdjs { ) { vertices.reverse(); } + const cellHeightFor2D = gdjs.NavMeshObstaclesManager.cellHeightFor2D; triangulate( vertices, vertexFlags, (p1: Point, p2: Point, p3: Point) => { // Top - positions.push(p1.x, 10, p1.y * this.inverseSpeedScaleY); - positions.push(p2.x, 10, p2.y * this.inverseSpeedScaleY); - positions.push(p3.x, 10, p3.y * this.inverseSpeedScaleY); + positions.push(p1.x, cellHeightFor2D, p1.y * this.inverseSpeedScaleY); + positions.push(p2.x, cellHeightFor2D, p2.y * this.inverseSpeedScaleY); + positions.push(p3.x, cellHeightFor2D, p3.y * this.inverseSpeedScaleY); indices.push( indicesOffset + 0, indicesOffset + 1, @@ -295,14 +298,14 @@ namespace gdjs { for (let index = 0; index < vertices.length; index++) { const vertex = vertices[index]; // Side - positions.push(vertex.x, 10, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, cellHeightFor2D, vertex.y * this.inverseSpeedScaleY); positions.push(vertex.x, 0, vertex.y * this.inverseSpeedScaleY); indices.push(indicesOffset + 0, indicesOffset + 1, indicesOffset + 2); indices.push(indicesOffset + 3, indicesOffset + 2, indicesOffset + 1); indicesOffset += 2; } const vertex = vertices[0]; - positions.push(vertex.x, 10, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, cellHeightFor2D, vertex.y * this.inverseSpeedScaleY); positions.push(vertex.x, 0, vertex.y * this.inverseSpeedScaleY); } } From 2ce3a845a845388f3647d1d25d8b242e63ed283b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 8 Aug 2026 17:39:08 +0200 Subject: [PATCH 29/51] Choose a cell height that works better for 2D --- .../NavMeshDebugPixiRenderer.ts | 3 +-- .../NavMeshObstacleRuntimeBehavior.ts | 27 ++++++++++--------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index e74323ab645f..ff3d91666557 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -55,8 +55,7 @@ namespace gdjs { for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { const [x0, y0, z0] = primitive.vertices[i]; if ( - y0 < - 1.5 * gdjs.NavMeshObstaclesManager.cellHeightFor2D + y0 < 1 ) { const [x1, _y1, z1] = primitive.vertices[i + 1]; const [x2, _y2, z2] = primitive.vertices[i + 2]; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index fbf09e461d99..52c1ef68402b 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -59,7 +59,7 @@ namespace gdjs { hasStepped = false; debuggerRenderer: gdjs.NavMeshDebuggerRenderer | null = null; - static readonly cellHeightFor2D = 10; + static readonly cellHeightFor2D = 5; constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { this.navMeshConfig.cs = sharedData.cellSize; @@ -231,7 +231,7 @@ namespace gdjs { x *= width; y *= height; - z *= gdjs.NavMeshObstaclesManager.cellHeightFor2D; + z *= gdjs.NavMeshObstaclesManager.cellHeightFor2D - 1; x += centerX; y += centerY; @@ -269,24 +269,25 @@ namespace gdjs { ) { vertices.reverse(); } - const cellHeightFor2D = gdjs.NavMeshObstaclesManager.cellHeightFor2D; + const depthMax = gdjs.NavMeshObstaclesManager.cellHeightFor2D - 1; + const depthMin = -1; triangulate( vertices, vertexFlags, (p1: Point, p2: Point, p3: Point) => { // Top - positions.push(p1.x, cellHeightFor2D, p1.y * this.inverseSpeedScaleY); - positions.push(p2.x, cellHeightFor2D, p2.y * this.inverseSpeedScaleY); - positions.push(p3.x, cellHeightFor2D, p3.y * this.inverseSpeedScaleY); + positions.push(p1.x, depthMax, p1.y * this.inverseSpeedScaleY); + positions.push(p2.x, depthMax, p2.y * this.inverseSpeedScaleY); + positions.push(p3.x, depthMax, p3.y * this.inverseSpeedScaleY); indices.push( indicesOffset + 0, indicesOffset + 1, indicesOffset + 2 ); // Bottom - positions.push(p1.x, 0, p1.y * this.inverseSpeedScaleY); - positions.push(p2.x, 0, p2.y * this.inverseSpeedScaleY); - positions.push(p3.x, 0, p3.y * this.inverseSpeedScaleY); + positions.push(p1.x, depthMin, p1.y * this.inverseSpeedScaleY); + positions.push(p2.x, depthMin, p2.y * this.inverseSpeedScaleY); + positions.push(p3.x, depthMin, p3.y * this.inverseSpeedScaleY); indices.push( indicesOffset + 3, indicesOffset + 5, @@ -298,15 +299,15 @@ namespace gdjs { for (let index = 0; index < vertices.length; index++) { const vertex = vertices[index]; // Side - positions.push(vertex.x, cellHeightFor2D, vertex.y * this.inverseSpeedScaleY); - positions.push(vertex.x, 0, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, depthMax, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, depthMin, vertex.y * this.inverseSpeedScaleY); indices.push(indicesOffset + 0, indicesOffset + 1, indicesOffset + 2); indices.push(indicesOffset + 3, indicesOffset + 2, indicesOffset + 1); indicesOffset += 2; } const vertex = vertices[0]; - positions.push(vertex.x, cellHeightFor2D, vertex.y * this.inverseSpeedScaleY); - positions.push(vertex.x, 0, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, depthMax, vertex.y * this.inverseSpeedScaleY); + positions.push(vertex.x, depthMin, vertex.y * this.inverseSpeedScaleY); } } From e7d568e72fbd64e86f84d0ed5c42fdad6229b724 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 8 Aug 2026 17:41:18 +0200 Subject: [PATCH 30/51] Format --- .../NavMeshCharacterRuntimeBehavior.ts | 3 ++- .../NavMeshPathfinding/NavMeshDebugPixiRenderer.ts | 4 +--- .../NavMeshObstacleRuntimeBehavior.ts | 12 ++++++++++-- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index da546176f825..bab0fd7aad7f 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -37,7 +37,8 @@ namespace gdjs { } /** @category Behaviors > 2D Pathfinding */ - export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData + extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index ff3d91666557..cffd38f0542b 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -54,9 +54,7 @@ namespace gdjs { case 'tris': for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { const [x0, y0, z0] = primitive.vertices[i]; - if ( - y0 < 1 - ) { + if (y0 < 1) { const [x1, _y1, z1] = primitive.vertices[i + 1]; const [x2, _y2, z2] = primitive.vertices[i + 2]; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 52c1ef68402b..ae143ad59935 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -299,8 +299,16 @@ namespace gdjs { for (let index = 0; index < vertices.length; index++) { const vertex = vertices[index]; // Side - positions.push(vertex.x, depthMax, vertex.y * this.inverseSpeedScaleY); - positions.push(vertex.x, depthMin, vertex.y * this.inverseSpeedScaleY); + positions.push( + vertex.x, + depthMax, + vertex.y * this.inverseSpeedScaleY + ); + positions.push( + vertex.x, + depthMin, + vertex.y * this.inverseSpeedScaleY + ); indices.push(indicesOffset + 0, indicesOffset + 1, indicesOffset + 2); indices.push(indicesOffset + 3, indicesOffset + 2, indicesOffset + 1); indicesOffset += 2; From 3aefe65313c804d20eda9e47f6233a7d1a846d94 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sat, 8 Aug 2026 18:25:36 +0200 Subject: [PATCH 31/51] Fix 3D debug was never removed --- .../NavMeshCharacterRuntimeBehavior.ts | 2 +- .../NavMeshDebugPixiRenderer.ts | 20 +++++++++++----- .../NavMeshObstacleRuntimeBehavior.ts | 23 ++++++++----------- 3 files changed, 25 insertions(+), 20 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index bab0fd7aad7f..5d14177bf5ec 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -362,7 +362,7 @@ namespace gdjs { : agent.raw.get_npos(2) * this._manager.speedScaleY; let newZ = agent.raw.get_npos(1); - console.log('New position', newX, newY, newZ); + //console.log('New position', newX, newY, newZ); const destinationX = this.getDestinationX(); const destinationY = this.getDestinationY(); diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index cffd38f0542b..dbd7ca5bce12 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -17,6 +17,11 @@ namespace gdjs { setEnabled(enabled: boolean): void { this.enabled = enabled; + if (enabled) { + this.renderFor3D(); + } else { + this.removeFor3D(); + } } registerFor2D() { @@ -97,11 +102,15 @@ namespace gdjs { } } - renderFor3D() { + removeFor3D() { for (const mesh of this.meshes) { mesh.removeFromParent(); } this.meshes.length = 0; + } + + renderFor3D() { + this.removeFor3D(); if (!this.enabled || !this.obstaclesManager.is3D) { return; } @@ -109,9 +118,6 @@ namespace gdjs { if (!navMesh) { return; } - if (!this.debugDrawerUtils) { - this.debugDrawerUtils = new RecastNav.DebugDrawerUtils(); - } const firstObstacle: gdjs.NavMeshObstacleRuntimeBehavior = obstacles .values() .next().value; @@ -121,8 +127,10 @@ namespace gdjs { if (!rendererObject) { return; } + if (!this.debugDrawerUtils) { + this.debugDrawerUtils = new RecastNav.DebugDrawerUtils(); + } const primitives = this.debugDrawerUtils.drawNavMesh(navMesh); - const meshes: Array = []; for (const primitive of primitives) { switch (primitive.type) { case 'tris': @@ -157,7 +165,7 @@ namespace gdjs { }); } const mesh = new THREE.Mesh(geometry, this.material); - meshes.push(mesh); + this.meshes.push(mesh); rendererObject.add(mesh); break; } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index ae143ad59935..77601b375e59 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -47,8 +47,9 @@ namespace gdjs { walkableClimb: 2, walkableRadius: 1, }; + cellDepth: float = 10; walkableRadius: float = -1; - walkableHeight: float = 150; + walkableDepth: float = 150; stairHeightMax: float = 20; speedScaleY: float = 1; inverseSpeedScaleY: float = 1; @@ -63,11 +64,11 @@ namespace gdjs { constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { this.navMeshConfig.cs = sharedData.cellSize; - this.navMeshConfig.ch = sharedData.cellDepth; + this.cellDepth = sharedData.cellDepth; this.navMeshConfig.detailSampleMaxError = sharedData.cellDepth * 5; this.navMeshConfig.walkableSlopeAngle = sharedData.slopeMaxAngle; this.stairHeightMax = sharedData.stairHeightMax; - this.walkableHeight = sharedData.walkableHeight; + this.walkableDepth = sharedData.walkableDepth; this.walkableRadius = sharedData.walkableRadius; this.speedScaleY = sharedData.speedScaleY; this.inverseSpeedScaleY = 1 / sharedData.speedScaleY; @@ -145,15 +146,12 @@ namespace gdjs { this.navMeshConfig.walkableSlopeAngle > 40 ? 2 : 1; - this.navMeshConfig.walkableClimb = this.navMeshConfig.ch - ? Math.max( - walkableClimbMin, - this.stairHeightMax / this.navMeshConfig.ch - ) - : walkableClimbMin; - this.navMeshConfig.walkableHeight = this.navMeshConfig.ch - ? this.walkableHeight / this.navMeshConfig.ch - : this.walkableHeight; + this.navMeshConfig.walkableClimb = Math.max( + walkableClimbMin, + this.stairHeightMax / this.cellDepth + ); + this.navMeshConfig.walkableHeight = this.walkableDepth / this.cellDepth; + this.navMeshConfig.ch = this.cellDepth; } let characterRadiusMax = 0; @@ -197,7 +195,6 @@ namespace gdjs { this.debuggerRenderer.registerFor2D(); } this.debuggerRenderer.setEnabled(enableDebugDraw); - this.debuggerRenderer.renderFor3D(); } private addGroundFor2D( From 2531e564fb275edc9cb760e51116e56cbe8b795a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sun, 9 Aug 2026 12:13:45 +0200 Subject: [PATCH 32/51] Fix hot-reload --- .../NavMeshCharacterRuntimeBehavior.ts | 53 +++++++++---------- .../NavMeshObstacleRuntimeBehavior.ts | 46 ++++++---------- 2 files changed, 42 insertions(+), 57 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 5d14177bf5ec..27bdb10465eb 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -25,15 +25,11 @@ namespace gdjs { interface NavMeshCharacterNetworkSyncDataType { // Syncing the path and its position on it should be enough to have a good prediction. - path: RecastNav.Vector3[]; + d: RecastNav.Vector3; pf: boolean; - sp: number; as: number; - cs: number; - tss: number; re: boolean; ma: number; - dos: number; } /** @category Behaviors > 2D Pathfinding */ @@ -119,6 +115,14 @@ namespace gdjs { if (behaviorData.angleOffset !== undefined) { this.setAngleOffset(behaviorData.angleOffset); } + if (behaviorData.angleOffset !== undefined) { + this._radius = behaviorData.angleOffset; + this._manager.invalidateNavMesh(); + } + if (behaviorData.avoidanceSightRange !== undefined) { + this._crowdAgentParams.collisionQueryRange = + behaviorData.avoidanceSightRange; + } return true; } @@ -128,15 +132,11 @@ namespace gdjs { return { ...super.getNetworkSyncData(options), props: { - path: this._path, + d: this._path[this._path.length - 1], pf: this._pathFound, - sp: this._speed, as: this._angularSpeed, - cs: this._currentSegment, - tss: this._totalSegmentDistance, re: this._reachedEnd, ma: this._movementAngle, - dos: this._distanceOnSegment, }, }; } @@ -147,36 +147,35 @@ namespace gdjs { ): void { super.updateFromNetworkSyncData(networkSyncData, options); const behaviorSpecificProps = networkSyncData.props; - if (behaviorSpecificProps.path !== undefined) { - this._path = behaviorSpecificProps.path; + if (behaviorSpecificProps.d !== undefined) { + // TODO Try a more reliable synchronization by overriding the path using the low level API. + const destination = this._path[this._path.length - 1]; + if ( + behaviorSpecificProps.d == null || + !destination || + destination.x !== behaviorSpecificProps.d.x || + destination.y !== behaviorSpecificProps.d.y || + destination.z !== behaviorSpecificProps.d.z + ) { + this.moveTo( + behaviorSpecificProps.d.x, + behaviorSpecificProps.d.y, + behaviorSpecificProps.d.z + ); + } } if (behaviorSpecificProps.pf !== undefined) { this._pathFound = behaviorSpecificProps.pf; } - if (behaviorSpecificProps.sp !== undefined) { - this._speed = behaviorSpecificProps.sp; - } if (behaviorSpecificProps.as !== undefined) { this._angularSpeed = behaviorSpecificProps.as; } - if ( - behaviorSpecificProps.cs !== undefined && - behaviorSpecificProps.cs !== this._currentSegment - ) { - this._currentSegment = behaviorSpecificProps.cs; - } - if (behaviorSpecificProps.tss !== undefined) { - this._totalSegmentDistance = behaviorSpecificProps.tss; - } if (behaviorSpecificProps.re !== undefined) { this._reachedEnd = behaviorSpecificProps.re; } if (behaviorSpecificProps.ma !== undefined) { this._movementAngle = behaviorSpecificProps.ma; } - if (behaviorSpecificProps.dos !== undefined) { - this._distanceOnSegment = behaviorSpecificProps.dos; - } } override onActivate() { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 77601b375e59..8bca156ddd3a 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -579,8 +579,6 @@ namespace gdjs { * @category Behaviors > 2D Pathfinding */ export class NavMeshObstacleRuntimeBehavior extends gdjs.RuntimeBehavior { - _impassable: boolean; - _cost: float; _shape: string; _meshShapeResourceName: string; @@ -602,10 +600,8 @@ namespace gdjs { owner: gdjs.RuntimeObject ) { super(instanceContainer, behaviorData, owner); - this._impassable = behaviorData.impassable; - this._cost = behaviorData.cost; this._shape = behaviorData.shape; - this._meshShapeResourceName = behaviorData.meshShapeResourceName || ''; + this._meshShapeResourceName = behaviorData.meshShapeResourceName; this._manager = NavMeshObstaclesManager.getManager(instanceContainer); //Note that we can't use getX(), getWidth()... of owner here: @@ -613,22 +609,24 @@ namespace gdjs { } override applyBehaviorOverriding(behaviorData): boolean { - if (behaviorData.impassable !== undefined) { - this.setImpassable(behaviorData.impassable); + if (behaviorData.shape !== undefined) { + this._shape = behaviorData.shape; + this._manager.invalidateNavMesh(); } - if (behaviorData.cost !== undefined) { - this.setCost(behaviorData.cost); + if (behaviorData.meshShapeResourceName !== undefined) { + this._meshShapeResourceName = behaviorData.meshShapeResourceName; + this._manager.invalidateNavMesh(); } return true; } - onDestroy() { + override onDestroy() { if (this._manager && this._registeredInManager) { this._manager.removeObstacle(this); } } - doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { + override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { if (!this.activated() && this._registeredInManager) { this._manager.removeObstacle(this); this._registeredInManager = false; @@ -688,9 +686,11 @@ namespace gdjs { } } - doStepPostEvents(instanceContainer: gdjs.RuntimeInstanceContainer) {} + override doStepPostEvents( + instanceContainer: gdjs.RuntimeInstanceContainer + ) {} - onActivate() { + override onActivate() { if (this._registeredInManager) { return; } @@ -698,35 +698,21 @@ namespace gdjs { this._registeredInManager = true; } - onDeActivate() { + override onDeActivate() { if (!this._registeredInManager) { return; } this._manager.removeObstacle(this); this._registeredInManager = false; } - - getCost() { - return this._cost; - } - - setCost(cost: float): void { - this._cost = cost; - } - - isImpassable(): boolean { - return this._impassable; - } - - setImpassable(impassable: boolean): void { - this._impassable = impassable; - } } gdjs.registerBehavior( 'NavMeshPathfinding::NavMeshObstacleBehavior', gdjs.NavMeshObstacleRuntimeBehavior ); + // The following code is inspired from Critterai + // https://github.com/stevefsp/critterai interface Point { x: number; y: number; From 3c5a80711d964a2d64c07b1f0a0ffa557987e957 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sun, 9 Aug 2026 12:30:48 +0200 Subject: [PATCH 33/51] Remove some dead code --- .../NavMeshCharacterRuntimeBehavior.ts | 102 ++++++------------ .../NavMeshObstacleRuntimeBehavior.ts | 5 - 2 files changed, 31 insertions(+), 76 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 27bdb10465eb..2a0adb63af56 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -1,7 +1,3 @@ -/* -GDevelop - Pathfinding Behavior Extension -Copyright (c) 2010-2016 Florian Rival (Florian.Rival@gmail.com) - */ namespace gdjs { const loadRecast = async () => { try { @@ -45,10 +41,6 @@ namespace gdjs { */ export class NavMeshCharacterRuntimeBehavior extends gdjs.RuntimeBehavior { _path: Array = []; - /** Used by the path simplification algorithm */ - static _smoothingResultVertices: Array = []; - /** Used by the path simplification algorithm */ - static _smoothingWorkingVertices: Array = []; // Behavior configuration: _angularMaxSpeed: float; @@ -66,7 +58,6 @@ namespace gdjs { }; // Attributes used for traveling on the path: - _angularSpeed: float = 0; _pathFound: boolean = false; _reachedEnd: boolean = false; _movementAngle: float = 0; @@ -80,11 +71,6 @@ namespace gdjs { ) { super(instanceContainer, behaviorData, owner); - //The path computed and followed by the object (Array of arrays containing x and y position) - if (this._path === undefined) { - } else { - this._path.length = 0; - } this._angularMaxSpeed = behaviorData.angularMaxSpeed; this._rotateObject = behaviorData.rotateObject; this._angleOffset = behaviorData.angleOffset; @@ -134,7 +120,7 @@ namespace gdjs { props: { d: this._path[this._path.length - 1], pf: this._pathFound, - as: this._angularSpeed, + as: this._angularMaxSpeed, re: this._reachedEnd, ma: this._movementAngle, }, @@ -168,7 +154,7 @@ namespace gdjs { this._pathFound = behaviorSpecificProps.pf; } if (behaviorSpecificProps.as !== undefined) { - this._angularSpeed = behaviorSpecificProps.as; + this._angularMaxSpeed = behaviorSpecificProps.as; } if (behaviorSpecificProps.re !== undefined) { this._reachedEnd = behaviorSpecificProps.re; @@ -197,38 +183,13 @@ namespace gdjs { this._pathFound = false; return; } - - // Start searching for a path - const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); - - const { success: hasFindDestination, point: destination } = - navMeshQuery.findClosestPoint( - { - x, - y: z, - z: this._manager.is3D ? y : y * this._manager.inverseSpeedScaleY, - }, - { - halfExtents: { - x: 100, - y: this._manager.is3D - ? 100 - : gdjs.NavMeshObstaclesManager.cellHeightFor2D, - z: 100, - }, - } - ); - if (!hasFindDestination) { - this._pathFound = false; - console.log("Can't find destination", x, y, z); - return; - } - if (!this._agent) { console.log('No agent'); this._pathFound = false; return; } + + const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); const { success: hasFindOrigin, point: origin } = navMeshQuery.findClosestPoint( { @@ -271,6 +232,29 @@ namespace gdjs { this.owner.setZ(origin.y); } + const { success: hasFindDestination, point: destination } = + navMeshQuery.findClosestPoint( + { + x, + y: z, + z: this._manager.is3D ? y : y * this._manager.inverseSpeedScaleY, + }, + { + halfExtents: { + x: 100, + y: this._manager.is3D + ? 100 + : gdjs.NavMeshObstaclesManager.cellHeightFor2D, + z: 100, + }, + } + ); + if (!hasFindDestination) { + this._pathFound = false; + console.log("Can't find destination", x, y, z); + return; + } + this._pathFound = this._agent.requestMoveTarget(destination); console.log( 'hasFindPath', @@ -384,7 +368,10 @@ namespace gdjs { this._rotateObject && this.owner.getAngle() !== this._movementAngle + this._angleOffset ) { - this.rotateTowardAngle(this._movementAngle + this._angleOffset); + this.owner.rotateTowardAngle( + this._movementAngle + this._angleOffset, + this._angularMaxSpeed + ); } if ( Math.abs(newX - destinationX) < 1 && @@ -405,33 +392,6 @@ namespace gdjs { } } - /** - * @param angle The targeted angle. - * @param speed The rotation speed. 0 for an immediate rotation to the target angle. - */ - private rotateTowardAngle(angle: float): void { - const angularDiff = gdjs.evtTools.common.angleDifference( - this.owner.getAngle(), - angle - ); - const diffWasPositive = angularDiff >= 0; - - const timeDelta = this.owner.getElapsedTime() / 1000; - this._angularSpeed = - (diffWasPositive ? -1.0 : 1.0) * this._angularMaxSpeed; - - let newAngle = this.owner.getAngle() + this._angularSpeed * timeDelta; - - if ( - // @ts-ignore - (gdjs.evtTools.common.angleDifference(newAngle, angle) > 0) ^ - diffWasPositive - ) { - newAngle = angle; - } - this.owner.setAngle(newAngle); - } - override doStepPostEvents( instanceContainer: gdjs.RuntimeInstanceContainer ) { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 8bca156ddd3a..5fd1f96a0026 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -1,8 +1,3 @@ -/* -GDevelop - Pathfinding Behavior Extension -Copyright (c) 2013-2016 Florian Rival (Florian.Rival@gmail.com) - */ - namespace gdjs { export interface RuntimeInstanceContainer { navMeshObstaclesManager: gdjs.NavMeshObstaclesManager; From d14f63ffaa3cac6be12d2979fab58831b8622c95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Sun, 9 Aug 2026 13:23:25 +0200 Subject: [PATCH 34/51] Improve types --- .../NavMeshCharacterRuntimeBehavior.ts | 47 +++++------- .../NavMeshObstacleRuntimeBehavior.ts | 76 ++++++++----------- GDJS/Runtime/runtimeobject.ts | 11 +-- 3 files changed, 59 insertions(+), 75 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 2a0adb63af56..8aa6c607b21c 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -175,7 +175,7 @@ namespace gdjs { /** * Compute and move on the path to the specified destination. */ - moveTo(x: float, y: float, z: float) { + moveTo(x: float, y: float, z: float): void { this._path = []; this._manager.rebuildNavMeshIfNeeded(); if (!this._manager.navMesh) { @@ -194,8 +194,7 @@ namespace gdjs { navMeshQuery.findClosestPoint( { x: this.owner.getX(), - //@ts-ignore - y: this.owner.getZ ? this.owner.getZ() : 0, + y: gdjs.Base3DHandler.is3D(this.owner) ? this.owner.getZ() : 0, z: this._manager.is3D ? this.owner.getY() : this.owner.getY() * this._manager.inverseSpeedScaleY, @@ -216,8 +215,7 @@ namespace gdjs { "Can't find origin", this.owner.getX(), this.owner.getY(), - //@ts-ignore - this.owner.getZ ? this.owner.getZ() : 0 + gdjs.Base3DHandler.is3D(this.owner) ? this.owner.getZ() : 0 ); return; } @@ -226,9 +224,7 @@ namespace gdjs { this.owner.setY( this._manager.is3D ? origin.z : origin.z * this._manager.speedScaleY ); - //@ts-ignore - if (this.owner.setZ) { - //@ts-ignore + if (gdjs.Base3DHandler.is3D(this.owner)) { this.owner.setZ(origin.y); } @@ -261,8 +257,7 @@ namespace gdjs { this._pathFound, this.owner.x, this.owner.y, - //@ts-ignore - this.owner.getZ ? this.owner.getZ() : 0, + gdjs.Base3DHandler.is3D(this.owner) ? this.owner.getZ() : 0, ' -> ', destination.x, this._manager.is3D @@ -288,14 +283,14 @@ namespace gdjs { const oldY = this.owner.getY(); // For 2D we keep the agent position for Z because the ground may not be // at 0 because of rasterization. - //@ts-ignore - const oldZ = this.owner.getZ ? this.owner.getZ() : agent.raw.get_npos(1); + const oldZ = gdjs.Base3DHandler.is3D(this.owner) + ? this.owner.getZ() + : agent.raw.get_npos(1); let expectedX = agent.raw.get_npos(0); let expectedY = this._manager.is3D ? agent.raw.get_npos(2) : agent.raw.get_npos(2) * this._manager.speedScaleY; - //@ts-ignore let expectedZ = agent.raw.get_npos(1); if (oldX !== expectedX || oldY !== expectedY || oldZ !== expectedZ) { @@ -369,15 +364,15 @@ namespace gdjs { this.owner.getAngle() !== this._movementAngle + this._angleOffset ) { this.owner.rotateTowardAngle( - this._movementAngle + this._angleOffset, - this._angularMaxSpeed - ); + this._movementAngle + this._angleOffset, + this._angularMaxSpeed + ); } if ( Math.abs(newX - destinationX) < 1 && Math.abs(newY - destinationY) < 1 && - //@ts-ignore - (!this.owner.getZ || Math.abs(newZ - destinationZ) < 1) + (!gdjs.Base3DHandler.is3D(this.owner) || + Math.abs(newZ - destinationZ) < 1) ) { this._reachedEnd = true; agent.resetMoveTarget(); @@ -385,9 +380,7 @@ namespace gdjs { } this.owner.setX(newX); this.owner.setY(newY); - //@ts-ignore - if (this.owner.setZ) { - //@ts-ignore + if (gdjs.Base3DHandler.is3D(this.owner)) { this.owner.setZ(newZ); } } @@ -469,7 +462,7 @@ namespace gdjs { this._angularMaxSpeed = angularMaxSpeed; } - getAngularMaxSpeed() { + getAngularMaxSpeed(): float { return this._angularMaxSpeed; } @@ -477,7 +470,7 @@ namespace gdjs { this._angleOffset = angleOffset; } - getAngleOffset() { + getAngleOffset(): float { return this._angleOffset; } @@ -510,7 +503,7 @@ namespace gdjs { return 0; } - getNextNodeIndex() { + getNextNodeIndex(): integer { if (!this._agent) { return 0; } @@ -548,7 +541,7 @@ namespace gdjs { return this._path[nextNodeIndex].z; } - getPreviousNodeIndex() { + getPreviousNodeIndex(): integer { if (!this._agent) { return 0; } @@ -606,14 +599,14 @@ namespace gdjs { /** * Return true if the latest call to moveTo succeeded. */ - pathFound() { + pathFound(): boolean { return this._pathFound; } /** * Return true if the object reached its destination. */ - destinationReached() { + destinationReached(): boolean { return this._reachedEnd; } } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 5fd1f96a0026..5b1421548f66 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -72,7 +72,9 @@ namespace gdjs { /** * Get the obstacles manager of an instance container. */ - static getManager(instanceContainer: gdjs.RuntimeInstanceContainer) { + static getManager( + instanceContainer: gdjs.RuntimeInstanceContainer + ): gdjs.NavMeshObstaclesManager { if (!instanceContainer.navMeshObstaclesManager) { // Create the shared manager if necessary. const initialData = @@ -83,7 +85,7 @@ namespace gdjs { return instanceContainer.navMeshObstaclesManager; } - step(timeDelta: float) { + step(timeDelta: float): void { if (this.hasStepped) { return; } @@ -105,11 +107,11 @@ namespace gdjs { this.crowd.update(timeDelta); //1 / 60, timeDelta, 8); } - invalidateNavMesh() { + invalidateNavMesh(): void { this.isNavMeshDirty = true; } - rebuildNavMeshIfNeeded() { + rebuildNavMeshIfNeeded(): void { if (!this.isNavMeshDirty || this.timeSinceLastNavMeshLastRebuild < 1) { return; } @@ -118,8 +120,7 @@ namespace gdjs { const positions: Array = []; const indices: Array = []; for (const obstacle of this.obstacles) { - //@ts-ignore - const object: gdjs.RuntimeObject3D = obstacle.owner; + const object = obstacle.owner; if (gdjs.Base3DHandler.is3D(object)) { if (isModel3D(object) && obstacle._shape === 'Mesh') { this.addMeshFor(object, obstacle, positions, indices); @@ -238,7 +239,7 @@ namespace gdjs { } private addPolygonsFor( - object: gdjs.RuntimeObject3D, + object: gdjs.RuntimeObject, positions: Array, indices: Array ): void { @@ -312,7 +313,7 @@ namespace gdjs { } private addBoxFor( - object: gdjs.RuntimeObject3D, + object: gdjs.AbstractRuntimeObject3D, positions: Array, indices: Array ): void { @@ -458,7 +459,9 @@ namespace gdjs { }); } - private rebuildCharacterAgent(character: NavMeshCharacterRuntimeBehavior) { + private rebuildCharacterAgent( + character: NavMeshCharacterRuntimeBehavior + ): void { if (!this.navMesh || !this.crowd) { character._agent = null; return; @@ -469,8 +472,7 @@ namespace gdjs { navMeshQuery.findClosestPoint( { x: owner.getX(), - //@ts-ignore - y: owner.getZ ? owner.getZ() : 0, + y: gdjs.Base3DHandler.is3D(owner) ? owner.getZ() : 0, z: owner.getY(), }, { halfExtents: { x: 100, y: 100, z: 100 } } @@ -480,19 +482,15 @@ namespace gdjs { "Can't find origin", owner.getX(), owner.getY(), - //@ts-ignore - owner.getZ ? owner.getZ() : 0 + gdjs.Base3DHandler.is3D(owner) ? owner.getZ() : 0 ); return; } character._crowdAgentParams.radius = character.getRadius(); - character._crowdAgentParams.height = - //@ts-ignore - owner.getDepth - ? //@ts-ignore - owner.getDepth() - : 1; + character._crowdAgentParams.height = gdjs.Base3DHandler.is3D(owner) + ? owner.getDepth() + : 1; const agent = this.crowd ? this.crowd.addAgent(origin, character._crowdAgentParams) : null; @@ -509,7 +507,7 @@ namespace gdjs { /** * Add a obstacle to the list of existing obstacles. */ - addObstacle(obstacle: NavMeshObstacleRuntimeBehavior) { + addObstacle(obstacle: NavMeshObstacleRuntimeBehavior): void { this.obstacles.add(obstacle); if (gdjs.Base3DHandler.is3D(obstacle.owner)) { this.is3D = true; @@ -521,7 +519,7 @@ namespace gdjs { * Remove a obstacle from the list of existing obstacles. Be sure that the obstacle was * added before. */ - removeObstacle(obstacle: NavMeshObstacleRuntimeBehavior) { + removeObstacle(obstacle: NavMeshObstacleRuntimeBehavior): void { this.obstacles.delete(obstacle); this.invalidateNavMesh(); } @@ -529,7 +527,7 @@ namespace gdjs { /** * Add a character to the list of existing characters. */ - addCharacter(character: NavMeshCharacterRuntimeBehavior) { + addCharacter(character: NavMeshCharacterRuntimeBehavior): void { if (this.characters.has(character)) { return; } @@ -543,7 +541,7 @@ namespace gdjs { /** * Remove a character from the list of existing characters. */ - removeCharacter(character: NavMeshCharacterRuntimeBehavior) { + removeCharacter(character: NavMeshCharacterRuntimeBehavior): void { this.characters.delete(character); } } @@ -558,7 +556,7 @@ namespace gdjs { export const enableDebugDraw = function ( instanceContainer: gdjs.RuntimeInstanceContainer, enableDebugDraw: boolean - ) { + ): void { if (enableDebugDraw) { instanceContainer._debugDrawEnabled = true; } @@ -634,27 +632,19 @@ namespace gdjs { const newX = this.owner.getX(); const newY = this.owner.getY(); - //@ts-ignore - const newZ = this.owner.getZ ? this.owner.getZ() : 0; const newWidth = this.owner.getWidth(); const newHeight = this.owner.getHeight(); - //@ts-ignore - const newDepth = this.owner.getDepth ? this.owner.getDepth() : 0; - //@ts-ignore - const newRotationX = this.owner.getRotationX - ? //@ts-ignore - this.owner.getRotationX() - : 0; - //@ts-ignore - const newRotationY = this.owner.getRotationY - ? //@ts-ignore - this.owner.getRotationY() - : 0; - //@ts-ignore - const newRotationZ = this.owner.getRotationZ - ? //@ts-ignore - this.owner.getRotationZ() - : 0; + const newRotationZ = this.owner.getAngle(); + let newZ = 0; + let newDepth = 0; + let newRotationX = 0; + let newRotationY = 0; + if (gdjs.Base3DHandler.is3D(this.owner)) { + newZ = this.owner.getZ(); + newDepth = this.owner.getDepth(); + newRotationX = this.owner.getRotationX(); + newRotationY = this.owner.getRotationY(); + } if ( this._oldX !== newX || this._oldY !== newY || diff --git a/GDJS/Runtime/runtimeobject.ts b/GDJS/Runtime/runtimeobject.ts index 6d422df95f1f..156ff17db325 100644 --- a/GDJS/Runtime/runtimeobject.ts +++ b/GDJS/Runtime/runtimeobject.ts @@ -4,15 +4,16 @@ * This project is released under the MIT License. */ namespace gdjs { + export type AbstractRuntimeObject3D = gdjs.RuntimeObject & + gdjs.Base3DHandler & + gdjs.Resizable & + gdjs.Scalable & + gdjs.Flippable; /** @category Objects > 3D Objects */ export namespace Base3DHandler { export const is3D = ( object: gdjs.RuntimeObject - ): object is gdjs.RuntimeObject & - gdjs.Base3DHandler & - gdjs.Resizable & - gdjs.Scalable & - gdjs.Flippable => { + ): object is AbstractRuntimeObject3D => { //@ts-ignore We are checking if the methods are present. return object.getZ && object.setZ; }; From a0be17a816bc9f5b1c69a1b96da9a7eeebc621af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 10:29:39 +0200 Subject: [PATCH 35/51] Change names --- Extensions/NavMeshPathfinding/JsExtension.js | 14 +++++++------- .../NavMeshCharacterRuntimeBehavior.ts | 4 ++-- .../NavMeshObstacleRuntimeBehavior.ts | 10 ++++------ 3 files changed, 13 insertions(+), 15 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 23fa3453d28d..8a49b351da91 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -20,18 +20,18 @@ module.exports = { extension .setExtensionInformation( 'NavMeshPathfinding', - _('Pathfinding behavior'), + _('NavMesh pathfinding behavior'), 'Pathfinding allows to compute an efficient path for objects, avoiding obstacles on the way.', '', 'Open source (MIT License)' ) .setShortDescription( - 'A* pathfinding: compute paths avoiding obstacles. Configurable speed, grid, diagonals.' + 'A* pathfinding: compute paths avoiding obstacles.' ) - .setDimension('3D') + .setDimension('2D/3D') .setCategory('Movement') .setTags('pathfinding, obstacle, collision') - .setExtensionHelpPath('/behaviors/pathfinding'); + .setExtensionHelpPath('/behaviors/nav-mesh-pathfinding'); { const behavior = new gd.BehaviorJsImplementation(); behavior.updateProperty = function ( @@ -375,7 +375,7 @@ module.exports = { const aut = extension .addBehavior( 'NavMeshCharacterBehavior', - _('3D pathfinding'), + _('Pathfinding character (nav-mesh based)'), 'NavMeshCharacter', _( 'Move objects to a target while avoiding all objects that are flagged as obstacles.' @@ -855,9 +855,9 @@ module.exports = { const aut = extension .addBehavior( 'NavMeshObstacleBehavior', - _('Obstacle for 3D pathfinding'), + _('Pathfinding obstacle (nav-mesh based)'), 'NavMeshObstacle', - _('Flag objects as being obstacles for 3D pathfinding.'), + _('Flag objects as being obstacles for nav-mesh pathfinding.'), '', 'CppPlatform/Extensions/pathfindingobstacleicon.png', 'NavMeshObstacle', diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 8aa6c607b21c..f3b419fc1a5e 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -28,7 +28,7 @@ namespace gdjs { ma: number; } - /** @category Behaviors > 2D Pathfinding */ + /** @category Behaviors > NavMesh pathfinding */ export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; @@ -37,7 +37,7 @@ namespace gdjs { /** * NavMeshCharacterRuntimeBehavior represents a behavior allowing objects to * follow a path computed to avoid obstacles. - * @category Behaviors > 2D Pathfinding + * @category Behaviors > NavMesh pathfinding */ export class NavMeshCharacterRuntimeBehavior extends gdjs.RuntimeBehavior { _path: Array = []; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 5b1421548f66..3a0fae545f45 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -26,7 +26,7 @@ namespace gdjs { * `NavMeshObstaclesManager.addObstacle`) to the manager of their * associated container (see * `gdjs.PathfindingRuntimeBehavior.obstaclesManagers`). - * @category Behaviors > 2D Pathfinding + * @category Behaviors > NavMesh pathfinding */ export class NavMeshObstaclesManager { obstacles = new Set(); @@ -546,7 +546,7 @@ namespace gdjs { } } - /** @category Behaviors > 2D Pathfinding */ + /** @category Behaviors > NavMesh pathfinding */ export namespace NavMeshObstaclesManager { /** * Enable or disable the debug draw. @@ -568,8 +568,8 @@ namespace gdjs { /** * NavMeshObstacleRuntimeBehavior represents a behavior allowing objects to be - * considered as a obstacle by objects having Pathfinding Behavior. - * @category Behaviors > 2D Pathfinding + * considered as a obstacle by objects having Character Behavior. + * @category Behaviors > NavMesh pathfinding */ export class NavMeshObstacleRuntimeBehavior extends gdjs.RuntimeBehavior { _shape: string; @@ -713,8 +713,6 @@ namespace gdjs { * @param vertexFlags only used internally * @param outTriangles is called for each triangle derived * from the original polygon. - * @return The number of triangles generated. Or, if triangulation - * failed, a negative number. */ function triangulate( vertices: Array, From 457c87e806ae2b1c80e102712975d4ec05068e31 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 10:33:39 +0200 Subject: [PATCH 36/51] Remove logs --- .../NavMeshCharacterRuntimeBehavior.ts | 37 +------------------ .../NavMeshObstacleRuntimeBehavior.ts | 11 ------ 2 files changed, 1 insertion(+), 47 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index f3b419fc1a5e..b7230c288292 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -178,13 +178,7 @@ namespace gdjs { moveTo(x: float, y: float, z: float): void { this._path = []; this._manager.rebuildNavMeshIfNeeded(); - if (!this._manager.navMesh) { - console.log("Can't build the nav mesh"); - this._pathFound = false; - return; - } - if (!this._agent) { - console.log('No agent'); + if (!this._manager.navMesh || !this._agent) { this._pathFound = false; return; } @@ -211,12 +205,6 @@ namespace gdjs { ); if (!hasFindOrigin) { this._pathFound = false; - console.log( - "Can't find origin", - this.owner.getX(), - this.owner.getY(), - gdjs.Base3DHandler.is3D(this.owner) ? this.owner.getZ() : 0 - ); return; } this._agent.teleport(origin); @@ -247,28 +235,10 @@ namespace gdjs { ); if (!hasFindDestination) { this._pathFound = false; - console.log("Can't find destination", x, y, z); return; } this._pathFound = this._agent.requestMoveTarget(destination); - console.log( - 'hasFindPath', - this._pathFound, - this.owner.x, - this.owner.y, - gdjs.Base3DHandler.is3D(this.owner) ? this.owner.getZ() : 0, - ' -> ', - destination.x, - this._manager.is3D - ? destination.z - : destination.z * this._manager.speedScaleY, - destination.y, - 'extended from', - x, - y, - z - ); if (this._pathFound) { this._reachedEnd = false; } @@ -303,7 +273,6 @@ namespace gdjs { }); this._path = []; this._pathFound = false; - console.log('Teleport to', oldX, oldY, oldZ); } } @@ -331,7 +300,6 @@ namespace gdjs { } } this._path = path; - console.log('path', this._path); } let newX = agent.raw.get_npos(0); @@ -340,8 +308,6 @@ namespace gdjs { : agent.raw.get_npos(2) * this._manager.speedScaleY; let newZ = agent.raw.get_npos(1); - //console.log('New position', newX, newY, newZ); - const destinationX = this.getDestinationX(); const destinationY = this.getDestinationY(); const destinationZ = this.getDestinationZ(); @@ -376,7 +342,6 @@ namespace gdjs { ) { this._reachedEnd = true; agent.resetMoveTarget(); - console.log('Reached end'); } this.owner.setX(newX); this.owner.setY(newY); diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 3a0fae545f45..7987607c10f3 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -115,7 +115,6 @@ namespace gdjs { if (!this.isNavMeshDirty || this.timeSinceLastNavMeshLastRebuild < 1) { return; } - console.log('Rebuild the NavMesh'); this.timeSinceLastNavMeshLastRebuild = 0; const positions: Array = []; const indices: Array = []; @@ -167,8 +166,6 @@ namespace gdjs { indices, this.navMeshConfig ); - console.log('Built', result.success); - this.navMeshConfig.walkableClimb = 2; if (result.success) { this.navMesh = result.navMesh; this.crowd = new RecastNav.Crowd(this.navMesh, { @@ -214,8 +211,6 @@ namespace gdjs { const centerX = (maxX + minX) / 2; const centerY = ((maxY + minY) / 2) * this.inverseSpeedScaleY; - console.log('Ground', width, height, centerX, centerY); - const indicesOffset = Math.round(positions.length / 3); for (let index = 0; index + 2 < cubePositions.length; index = index + 3) { let x = cubePositions[index]; @@ -478,12 +473,6 @@ namespace gdjs { { halfExtents: { x: 100, y: 100, z: 100 } } ); if (!hasFindOrigin) { - console.log( - "Can't find origin", - owner.getX(), - owner.getY(), - gdjs.Base3DHandler.is3D(owner) ? owner.getZ() : 0 - ); return; } From ee7e66e6b4ddf793fc534415bd8bf47addaf2871 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 10:39:54 +0200 Subject: [PATCH 37/51] Fix a crash when there is no character. --- .../NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 7987607c10f3..ccdcb8225528 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -58,6 +58,10 @@ namespace gdjs { static readonly cellHeightFor2D = 5; constructor(instanceContainer: gdjs.RuntimeInstanceContainer, sharedData) { + if (!sharedData) { + // It can happens when there is no object with the character behavior. + return; + } this.navMeshConfig.cs = sharedData.cellSize; this.cellDepth = sharedData.cellDepth; this.navMeshConfig.detailSampleMaxError = sharedData.cellDepth * 5; From ff0bb920e7c7a2cbe40e5a98bb63a3394fe5b0bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 13:07:13 +0200 Subject: [PATCH 38/51] Add new icons --- Extensions/NavMeshPathfinding/JsExtension.js | 72 ++++---- Extensions/PathfindingBehavior/Extension.cpp | 166 +++++++++--------- .../Extensions/pathfinding-character.svg | 22 +++ .../Extensions/pathfinding-obstacle.svg | 2 + .../Extensions/nav-mesh-character.svg | 29 +++ .../Extensions/nav-mesh-obstacle.svg | 2 + 6 files changed, 174 insertions(+), 119 deletions(-) create mode 100644 newIDE/app/public/CppPlatform/Extensions/pathfinding-character.svg create mode 100644 newIDE/app/public/CppPlatform/Extensions/pathfinding-obstacle.svg create mode 100644 newIDE/app/public/JsPlatform/Extensions/nav-mesh-character.svg create mode 100644 newIDE/app/public/JsPlatform/Extensions/nav-mesh-obstacle.svg diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 8a49b351da91..16d9f2cd5b85 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -26,7 +26,7 @@ module.exports = { 'Open source (MIT License)' ) .setShortDescription( - 'A* pathfinding: compute paths avoiding obstacles.' + 'Nav-mesh based pathfinding : compute path avoiding obstacles and handle crowds.' ) .setDimension('2D/3D') .setCategory('Movement') @@ -381,7 +381,7 @@ module.exports = { 'Move objects to a target while avoiding all objects that are flagged as obstacles.' ), '', - 'CppPlatform/Extensions/AStaricon.png', + 'JsPlatform/Extensions/nav-mesh-character.svg', 'PathfindingBehavior', //@ts-ignore The class hierarchy is incorrect leading to a type error, but this is valid. behavior, @@ -411,8 +411,8 @@ module.exports = { _('Move the object to a position'), _('Move _PARAM0_ to _PARAM2_ ; _PARAM3_ ; _PARAM4_'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon24.png', - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg', + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -428,8 +428,8 @@ module.exports = { _('Check if a path has been found.'), _('A path has been found for _PARAM0_'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon24.png', - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg', + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -442,8 +442,8 @@ module.exports = { _('Check if the destination was reached.'), _('_PARAM0_ reached its destination'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon24.png', - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg', + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -457,7 +457,7 @@ module.exports = { _('the acceleration when moving the object'), _('the acceleration on the path'), _('Pathfinding configuration'), - 'CppPlatform/Extensions/AStaricon24.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -473,7 +473,7 @@ module.exports = { _('the maximum speed when moving the object'), _('the max. speed on the path'), _('Pathfinding configuration'), - 'CppPlatform/Extensions/AStaricon24.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -494,7 +494,7 @@ module.exports = { _('Change the speed of the object on the path'), _('the speed on the path'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon24.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -514,8 +514,8 @@ module.exports = { _('Compare the angle of movement of an object on its path.'), _('Angle of movement of _PARAM0_ is _PARAM2_ ± _PARAM3_°'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon24.png', - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg', + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -530,7 +530,7 @@ module.exports = { _('the maximum angular speed when moving the object'), _('the max. angular speed on the path'), _('Pathfinding configuration'), - 'CppPlatform/Extensions/AStaricon24.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -551,7 +551,7 @@ module.exports = { _('the rotation offset applied when moving the object'), _('the rotation offset on the path'), _('Pathfinding configuration'), - 'CppPlatform/Extensions/AStaricon24.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -571,8 +571,8 @@ module.exports = { _('Enable or disable rotation of the object on the path'), _('Enable rotation of _PARAM0_ on the path: _PARAM2_'), _('Pathfinding configuration'), - 'CppPlatform/Extensions/AStaricon24.png', - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg', + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -586,8 +586,8 @@ module.exports = { _('Check if the object is rotated when traveling on its path.'), _('_PARAM0_ is rotated when traveling on its path'), _('Pathfinding configuration'), - 'CppPlatform/Extensions/AStaricon24.png', - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg', + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -599,7 +599,7 @@ module.exports = { _('Get a waypoint X position'), _('Get next waypoint X position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -612,7 +612,7 @@ module.exports = { _('Get a waypoint Y position'), _('Get next waypoint Y position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -625,7 +625,7 @@ module.exports = { _('Get a waypoint Z position'), _('Get next waypoint Z position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -638,7 +638,7 @@ module.exports = { _('Index of the next waypoint'), _('Get the index of the next waypoint to reach'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -650,7 +650,7 @@ module.exports = { _('Waypoint count'), _('Get the number of waypoints on the path'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -662,7 +662,7 @@ module.exports = { _('Get next waypoint X position'), _('Get next waypoint X position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -674,7 +674,7 @@ module.exports = { _('Get next waypoint Y position'), _('Get next waypoint Y position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -686,7 +686,7 @@ module.exports = { _('Get next waypoint Z position'), _('Get next waypoint Z position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -698,7 +698,7 @@ module.exports = { _('Previous waypoint X position'), _('Previous waypoint X position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -710,7 +710,7 @@ module.exports = { _('Previous waypoint Y position'), _('Previous waypoint Y position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -722,7 +722,7 @@ module.exports = { _('Previous waypoint Z position'), _('Previous waypoint Z position'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -734,7 +734,7 @@ module.exports = { _('Destination X position'), _('Destination X position of the path'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -746,7 +746,7 @@ module.exports = { _('Destination Y position'), _('Destination Y position of the path'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -758,7 +758,7 @@ module.exports = { _('Destination Z position'), _('Destination Z position of the path'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -770,7 +770,7 @@ module.exports = { _('Angle of movement on its path'), _('Angle of movement on its path'), _('Movement on the path'), - 'CppPlatform/Extensions/AStaricon16.png' + 'JsPlatform/Extensions/nav-mesh-character.svg' ) .addParameter('object', _('Object')) .addParameter('behavior', _('Behavior'), 'NavMeshCharacterBehavior') @@ -855,11 +855,11 @@ module.exports = { const aut = extension .addBehavior( 'NavMeshObstacleBehavior', - _('Pathfinding obstacle (nav-mesh based)'), + _('Obstacle for pathfinding (nav-mesh based)'), 'NavMeshObstacle', _('Flag objects as being obstacles for nav-mesh pathfinding.'), '', - 'CppPlatform/Extensions/pathfindingobstacleicon.png', + 'JsPlatform/Extensions/nav-mesh-obstacle.svg', 'NavMeshObstacle', //@ts-ignore The class hierarchy is incorrect leading to a type error, but this is valid. behavior, diff --git a/Extensions/PathfindingBehavior/Extension.cpp b/Extensions/PathfindingBehavior/Extension.cpp index e4154a747d51..9ddc7d8ee7cf 100644 --- a/Extensions/PathfindingBehavior/Extension.cpp +++ b/Extensions/PathfindingBehavior/Extension.cpp @@ -27,18 +27,18 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { .SetTags("pathfinding, obstacle, collision") .SetExtensionHelpPath("/behaviors/pathfinding"); extension.AddInstructionOrExpressionGroupMetadata(_("Pathfinding behavior")) - .SetIcon("CppPlatform/Extensions/AStaricon16.png"); + .SetIcon("CppPlatform/Extensions/pathfinding-character.svg"); { gd::BehaviorMetadata& aut = extension.AddBehavior("PathfindingBehavior", - _("Pathfinding"), + _("Pathfinding character (grid-based)"), "Pathfinding", _("Move objects to a target " "while avoiding all objects that are " "flagged as obstacles."), "", - "CppPlatform/Extensions/AStaricon.png", + "CppPlatform/Extensions/pathfinding-character.svg", "PathfindingBehavior", std::make_shared(), std::make_shared()); @@ -48,8 +48,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Move the object to a position"), _("Move _PARAM0_ to _PARAM3_;_PARAM4_"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .AddCodeOnlyParameter("currentScene", "") @@ -63,8 +63,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Check if a path has been found."), _("A path has been found for _PARAM0_"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -75,8 +75,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Check if the destination was reached."), _("_PARAM0_ reached its destination"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -87,8 +87,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the width of the cells of the virtual grid."), _("the width of the virtual cells"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -102,8 +102,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the width of the cells of the virtual grid."), _("the width of the virtual cells"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -116,8 +116,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the height of the cells of the virtual grid."), _("the height of the virtual cells"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -131,8 +131,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the height of the cells of the virtual grid."), _("the height of the virtual cells"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -145,8 +145,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the acceleration when moving the object"), _("the acceleration on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -160,8 +160,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the acceleration when moving the object"), _("the acceleration"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -174,8 +174,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the maximum speed when moving the object"), _("the max. speed on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -191,8 +191,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the maximum speed when moving the object"), _("the max. speed"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -207,8 +207,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the speed of the object on the path"), _("the speed on the path"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -224,8 +224,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the speed of the object on its path."), _("the speed"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -241,8 +241,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the angle of movement of an object on its path."), _("Angle of movement of _PARAM0_ is _PARAM2_ ± _PARAM3_°"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -254,8 +254,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the maximum angular speed when moving the object"), _("the max. angular speed on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -272,8 +272,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the maximum angular speed when moving the object"), _("the max. angular speed"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -289,8 +289,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the rotation offset applied when moving the object"), _("the rotation offset on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -306,8 +306,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the rotation offset when moving the object"), _("the rotation offset"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -324,8 +324,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { "planning a path"), _("the size of the extra border on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -340,8 +340,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { "object when planning a path"), _("the size of the extra border on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -355,8 +355,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Allow or restrict diagonal movement on the path"), _("Allow diagonal movement for _PARAM0_ on the path: _PARAM2_"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -369,8 +369,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { "diagonally on the path"), _("Diagonal moves allowed for _PARAM0_"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -381,8 +381,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Enable or disable rotation of the object on the path"), _("Enable rotation of _PARAM0_ on the path: _PARAM2_"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -395,8 +395,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { "its path."), _("_PARAM0_ is rotated when traveling on its path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon24.png", - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg", + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") @@ -406,7 +406,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Get a waypoint X position"), _("Get next waypoint X position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .AddParameter("expression", _("Node index (start at 0!)")) @@ -416,7 +416,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Get a waypoint Y position"), _("Get next waypoint Y position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .AddParameter("expression", _("Node index (start at 0!)")) @@ -426,7 +426,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Index of the next waypoint"), _("Get the index of the next waypoint to reach"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetNextNodeIndex"); @@ -435,7 +435,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Waypoint count"), _("Get the number of waypoints on the path"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetNodeCount"); @@ -444,7 +444,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Get next waypoint X position"), _("Get next waypoint X position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetNextNodeX"); @@ -453,7 +453,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Get next waypoint Y position"), _("Get next waypoint Y position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetNextNodeY"); @@ -462,7 +462,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Last waypoint X position"), _("Last waypoint X position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetLastNodeX"); @@ -471,7 +471,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Last waypoint Y position"), _("Last waypoint Y position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetLastNodeY"); @@ -480,7 +480,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Destination X position"), _("Destination X position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetDestinationX"); @@ -489,7 +489,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Destination Y position"), _("Destination Y position"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetDestinationY"); @@ -498,7 +498,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Acceleration"), _("Acceleration of the object on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetAcceleration"); @@ -507,7 +507,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Maximum speed"), _("Maximum speed of the object on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetMaxSpeed"); @@ -516,7 +516,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Speed"), _("Speed of the object on the path"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetSpeed"); @@ -525,7 +525,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Angular maximum speed"), _("Angular maximum speed of the object on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetAngularMaxSpeed"); @@ -534,7 +534,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Rotation offset"), _("Rotation offset applied the object on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetAngleOffset"); @@ -543,7 +543,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Extra border size"), _("Extra border applied the object on the path"), _("Pathfinding configuration"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetExtraBorder"); @@ -552,7 +552,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Width of a cell"), _("Width of the virtual grid"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetCellWidth"); @@ -561,7 +561,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Height of a cell"), _("Height of the virtual grid"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .SetFunctionName("GetCellHeight"); @@ -570,7 +570,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Angle of movement on its path"), _("Angle of movement on its path"), _("Movement on the path"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior"); @@ -580,7 +580,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("X offset of the virtual grid"), _("X offset of the virtual grid"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon24.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .UseStandardParameters("number", gd::ParameterOptions::MakeNewOptions()); @@ -591,7 +591,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Y offset of the virtual grid"), _("Y offset of the virtual grid"), _("Virtual grid"), - "CppPlatform/Extensions/AStaricon24.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingBehavior") .UseStandardParameters("number", gd::ParameterOptions::MakeNewOptions()); @@ -600,11 +600,11 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { { gd::BehaviorMetadata& aut = extension.AddBehavior( "PathfindingObstacleBehavior", - _("Obstacle for pathfinding"), + _("Obstacle for pathfinding (grid-based)"), "PathfindingObstacle", _("Flag objects as being obstacles for pathfinding."), "", - "CppPlatform/Extensions/pathfindingobstacleicon.png", + "CppPlatform/Extensions/pathfinding-obstacle.svg", "PathfindingObstacleBehavior", std::make_shared(), std::make_shared()); @@ -614,8 +614,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Change the cost of going through the object."), _("the cost"), _("Obstacles"), - "CppPlatform/Extensions/pathfindingobstacleicon24.png", - "CppPlatform/Extensions/pathfindingobstacleicon16.png") + "CppPlatform/Extensions/pathfinding-obstacle.svg", + "CppPlatform/Extensions/pathfinding-obstacle.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingObstacleBehavior") @@ -629,8 +629,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Compare the cost of going through the object"), _("the cost"), _("Obstacles"), - "CppPlatform/Extensions/pathfindingobstacleicon24.png", - "CppPlatform/Extensions/pathfindingobstacleicon16.png") + "CppPlatform/Extensions/pathfinding-obstacle.svg", + "CppPlatform/Extensions/pathfinding-obstacle.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingObstacleBehavior") @@ -643,8 +643,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Decide if the object is an impassable obstacle."), _("Set _PARAM0_ as an impassable obstacle: _PARAM2_"), _("Obstacles"), - "CppPlatform/Extensions/pathfindingobstacleicon24.png", - "CppPlatform/Extensions/pathfindingobstacleicon16.png") + "CppPlatform/Extensions/pathfinding-obstacle.svg", + "CppPlatform/Extensions/pathfinding-obstacle.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingObstacleBehavior") @@ -656,8 +656,8 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Check if the obstacle is impassable."), _("_PARAM0_ is impassable"), _("Obstacles"), - "CppPlatform/Extensions/pathfindingobstacleicon24.png", - "CppPlatform/Extensions/pathfindingobstacleicon16.png") + "CppPlatform/Extensions/pathfinding-obstacle.svg", + "CppPlatform/Extensions/pathfinding-obstacle.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingObstacleBehavior") @@ -667,7 +667,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { _("Cost"), _("Obstacle cost"), _("Obstacles"), - "CppPlatform/Extensions/AStaricon16.png") + "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) .AddParameter("behavior", _("Behavior"), "PathfindingObstacleBehavior") .SetFunctionName("GetCost"); diff --git a/newIDE/app/public/CppPlatform/Extensions/pathfinding-character.svg b/newIDE/app/public/CppPlatform/Extensions/pathfinding-character.svg new file mode 100644 index 000000000000..43857012b831 --- /dev/null +++ b/newIDE/app/public/CppPlatform/Extensions/pathfinding-character.svg @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/newIDE/app/public/CppPlatform/Extensions/pathfinding-obstacle.svg b/newIDE/app/public/CppPlatform/Extensions/pathfinding-obstacle.svg new file mode 100644 index 000000000000..33dccdbf7194 --- /dev/null +++ b/newIDE/app/public/CppPlatform/Extensions/pathfinding-obstacle.svg @@ -0,0 +1,2 @@ + + diff --git a/newIDE/app/public/JsPlatform/Extensions/nav-mesh-character.svg b/newIDE/app/public/JsPlatform/Extensions/nav-mesh-character.svg new file mode 100644 index 000000000000..62eaeebf74cb --- /dev/null +++ b/newIDE/app/public/JsPlatform/Extensions/nav-mesh-character.svg @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/newIDE/app/public/JsPlatform/Extensions/nav-mesh-obstacle.svg b/newIDE/app/public/JsPlatform/Extensions/nav-mesh-obstacle.svg new file mode 100644 index 000000000000..2872095e8d9d --- /dev/null +++ b/newIDE/app/public/JsPlatform/Extensions/nav-mesh-obstacle.svg @@ -0,0 +1,2 @@ + + From 67ba49f3978cbcaf4955e3e4f8db7b9397a464e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 15:12:48 +0200 Subject: [PATCH 39/51] Review changes --- Extensions/NavMeshPathfinding/JsExtension.js | 17 +++------- .../NavMeshCharacterRuntimeBehavior.ts | 19 ++++++----- .../NavMeshDebugPixiRenderer.ts | 7 +++- .../NavMeshObstacleRuntimeBehavior.ts | 34 +++++++++++++------ Extensions/PathfindingBehavior/Extension.cpp | 4 +-- .../pathfindingobstacleruntimebehavior.ts | 3 +- .../platformruntimebehavior.ts | 2 +- 7 files changed, 49 insertions(+), 37 deletions(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index 16d9f2cd5b85..e06cf3926c87 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -353,7 +353,6 @@ module.exports = { ) .setGroup(_('2D only')) .setType('Number') - .setMeasurementUnit(gd.MeasurementUnit.getPixel()) .setValue( sharedContent.getChild('speedScaleY').getDoubleValue().toString(10) ) @@ -382,7 +381,7 @@ module.exports = { ), '', 'JsPlatform/Extensions/nav-mesh-character.svg', - 'PathfindingBehavior', + 'NavMeshCharacterBehavior', //@ts-ignore The class hierarchy is incorrect leading to a type error, but this is valid. behavior, sharedData @@ -597,7 +596,7 @@ module.exports = { .addExpression( 'GetNodeX', _('Get a waypoint X position'), - _('Get next waypoint X position'), + _('Get a waypoint X position'), _('Movement on the path'), 'JsPlatform/Extensions/nav-mesh-character.svg' ) @@ -610,7 +609,7 @@ module.exports = { .addExpression( 'GetNodeY', _('Get a waypoint Y position'), - _('Get next waypoint Y position'), + _('Get a waypoint Y position'), _('Movement on the path'), 'JsPlatform/Extensions/nav-mesh-character.svg' ) @@ -623,7 +622,7 @@ module.exports = { .addExpression( 'GetNodeZ', _('Get a waypoint Z position'), - _('Get next waypoint Z position'), + _('Get a waypoint Z position'), _('Movement on the path'), 'JsPlatform/Extensions/nav-mesh-character.svg' ) @@ -787,18 +786,10 @@ module.exports = { const normalizedValue = newValue.toLowerCase(); let shapeValue = ''; if (normalizedValue === 'box') shapeValue = 'Box'; - else if (normalizedValue === 'capsule') shapeValue = 'Capsule'; - else if (normalizedValue === 'sphere') shapeValue = 'Sphere'; - else if (normalizedValue === 'cylinder') shapeValue = 'Cylinder'; else if (normalizedValue === 'mesh') shapeValue = 'Mesh'; else return false; behaviorContent.getOrCreateChild('shape').setStringValue(shapeValue); - if (shapeValue === 'Mesh') { - behaviorContent - .getOrCreateChild('bodyType') - .setStringValue('Static'); - } return true; } diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index b7230c288292..6ffbd1fcb73a 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -101,8 +101,8 @@ namespace gdjs { if (behaviorData.angleOffset !== undefined) { this.setAngleOffset(behaviorData.angleOffset); } - if (behaviorData.angleOffset !== undefined) { - this._radius = behaviorData.angleOffset; + if (behaviorData.radius !== undefined) { + this._radius = behaviorData.radius; this._manager.invalidateNavMesh(); } if (behaviorData.avoidanceSightRange !== undefined) { @@ -137,8 +137,7 @@ namespace gdjs { // TODO Try a more reliable synchronization by overriding the path using the low level API. const destination = this._path[this._path.length - 1]; if ( - behaviorSpecificProps.d == null || - !destination || + (behaviorSpecificProps.d !== null && !destination) || destination.x !== behaviorSpecificProps.d.x || destination.y !== behaviorSpecificProps.d.y || destination.z !== behaviorSpecificProps.d.z @@ -172,6 +171,10 @@ namespace gdjs { this._manager.removeCharacter(this); } + override onDestroy() { + this._manager.removeCharacter(this); + } + /** * Compute and move on the path to the specified destination. */ @@ -184,7 +187,7 @@ namespace gdjs { } const navMeshQuery = new RecastNav.NavMeshQuery(this._manager.navMesh); - const { success: hasFindOrigin, point: origin } = + const { success: hasFoundOrigin, point: origin } = navMeshQuery.findClosestPoint( { x: this.owner.getX(), @@ -203,7 +206,7 @@ namespace gdjs { }, } ); - if (!hasFindOrigin) { + if (!hasFoundOrigin) { this._pathFound = false; return; } @@ -216,7 +219,7 @@ namespace gdjs { this.owner.setZ(origin.y); } - const { success: hasFindDestination, point: destination } = + const { success: hasFoundDestination, point: destination } = navMeshQuery.findClosestPoint( { x, @@ -233,7 +236,7 @@ namespace gdjs { }, } ); - if (!hasFindDestination) { + if (!hasFoundDestination) { this._pathFound = false; return; } diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index dbd7ca5bce12..c2fc5ca639b8 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -10,6 +10,7 @@ namespace gdjs { enabled = false; meshes: Array = []; material: THREE.MeshStandardMaterial | null = null; + isRegisteredFor2D = false; constructor(obstaclesManager: NavMeshObstaclesManager) { this.obstaclesManager = obstaclesManager; @@ -19,15 +20,19 @@ namespace gdjs { this.enabled = enabled; if (enabled) { this.renderFor3D(); + if (!this.isRegisteredFor2D) { + this.registerFor2D(); + } } else { this.removeFor3D(); } } - registerFor2D() { + private registerFor2D() { const firstObstacle: NavMeshObstacleRuntimeBehavior = this.obstaclesManager.obstacles.values().next().value; if (firstObstacle) { + this.isRegisteredFor2D = true; firstObstacle.owner .getRuntimeScene() .registerDebugDrawHook((rendererObject: PIXI.Graphics) => { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index ccdcb8225528..5433c43d64f1 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -24,8 +24,7 @@ namespace gdjs { * having a pathfinding behavior: In particular, the obstacles behaviors are * required to declare themselves (see * `NavMeshObstaclesManager.addObstacle`) to the manager of their - * associated container (see - * `gdjs.PathfindingRuntimeBehavior.obstaclesManagers`). + * associated container (see `NavMeshObstaclesManager.getManager`). * @category Behaviors > NavMesh pathfinding */ export class NavMeshObstaclesManager { @@ -69,8 +68,9 @@ namespace gdjs { this.stairHeightMax = sharedData.stairHeightMax; this.walkableDepth = sharedData.walkableDepth; this.walkableRadius = sharedData.walkableRadius; - this.speedScaleY = sharedData.speedScaleY; - this.inverseSpeedScaleY = 1 / sharedData.speedScaleY; + this.speedScaleY = + sharedData.speedScaleY > 0 ? sharedData.speedScaleY : 1; + this.inverseSpeedScaleY = 1 / this.speedScaleY; } /** @@ -171,9 +171,15 @@ namespace gdjs { this.navMeshConfig ); if (result.success) { + if (this.navMesh) { + this.navMesh.destroy(); + } + if (this.crowd) { + this.crowd.destroy(); + } this.navMesh = result.navMesh; this.crowd = new RecastNav.Crowd(this.navMesh, { - maxAgents: 100, + maxAgents: this.characters.size + 100, maxAgentRadius: characterRadiusMax, }); for (const character of this.characters) { @@ -189,7 +195,6 @@ namespace gdjs { setDebugDrawEnabled(enableDebugDraw: boolean): void { if (!this.debuggerRenderer) { this.debuggerRenderer = new gdjs.NavMeshDebuggerRenderer(this); - this.debuggerRenderer.registerFor2D(); } this.debuggerRenderer.setEnabled(enableDebugDraw); } @@ -467,16 +472,18 @@ namespace gdjs { } const owner = character.owner; const navMeshQuery = new RecastNav.NavMeshQuery(this.navMesh); - const { success: hasFindOrigin, point: origin } = + const { success: hasFoundOrigin, point: origin } = navMeshQuery.findClosestPoint( { x: owner.getX(), y: gdjs.Base3DHandler.is3D(owner) ? owner.getZ() : 0, - z: owner.getY(), + z: this.is3D + ? owner.getY() + : owner.getY() * this.inverseSpeedScaleY, }, { halfExtents: { x: 100, y: 100, z: 100 } } ); - if (!hasFindOrigin) { + if (!hasFoundOrigin) { return; } @@ -536,6 +543,10 @@ namespace gdjs { */ removeCharacter(character: NavMeshCharacterRuntimeBehavior): void { this.characters.delete(character); + if (this.crowd && character._agent) { + this.crowd.removeAgent(character._agent); + character._agent = null; + } } } @@ -551,6 +562,9 @@ namespace gdjs { enableDebugDraw: boolean ): void { if (enableDebugDraw) { + // Make sure the debug layer will be displayed. + // We never set it back to false because users might have enabled hit-box + // debug draw with the other action. instanceContainer._debugDrawEnabled = true; } const manager = @@ -607,7 +621,7 @@ namespace gdjs { } override onDestroy() { - if (this._manager && this._registeredInManager) { + if (this._registeredInManager) { this._manager.removeObstacle(this); } } diff --git a/Extensions/PathfindingBehavior/Extension.cpp b/Extensions/PathfindingBehavior/Extension.cpp index 9ddc7d8ee7cf..2c82fcb9c9f5 100644 --- a/Extensions/PathfindingBehavior/Extension.cpp +++ b/Extensions/PathfindingBehavior/Extension.cpp @@ -404,7 +404,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { aut.AddExpression("GetNodeX", _("Get a waypoint X position"), - _("Get next waypoint X position"), + _("Get a waypoint X position"), _("Movement on the path"), "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) @@ -414,7 +414,7 @@ void DeclarePathfindingBehaviorExtension(gd::PlatformExtension& extension) { aut.AddExpression("GetNodeY", _("Get a waypoint Y position"), - _("Get next waypoint Y position"), + _("Get a waypoint Y position"), _("Movement on the path"), "CppPlatform/Extensions/pathfinding-character.svg") .AddParameter("object", _("Object")) diff --git a/Extensions/PathfindingBehavior/pathfindingobstacleruntimebehavior.ts b/Extensions/PathfindingBehavior/pathfindingobstacleruntimebehavior.ts index 94852e75c92e..eef7f4bf0dd9 100644 --- a/Extensions/PathfindingBehavior/pathfindingobstacleruntimebehavior.ts +++ b/Extensions/PathfindingBehavior/pathfindingobstacleruntimebehavior.ts @@ -14,8 +14,7 @@ namespace gdjs { * having a pathfinding behavior: In particular, the obstacles behaviors are * required to declare themselves (see * `PathfindingObstaclesManager.addObstacle`) to the manager of their - * associated container (see - * `gdjs.PathfindingRuntimeBehavior.obstaclesManagers`). + * associated container (see `PathfindingObstaclesManager.getManager`). * @category Behaviors > 2D Pathfinding */ export class PathfindingObstaclesManager { diff --git a/Extensions/PlatformBehavior/platformruntimebehavior.ts b/Extensions/PlatformBehavior/platformruntimebehavior.ts index c66e418b7c47..d362ea985795 100644 --- a/Extensions/PlatformBehavior/platformruntimebehavior.ts +++ b/Extensions/PlatformBehavior/platformruntimebehavior.ts @@ -10,7 +10,7 @@ namespace gdjs { * Manages the common objects shared by objects having a * platform behavior: in particular, the platforms behaviors are required to * declare themselves (see PlatformObjectsManager.addPlatform) to the manager - * of their associated container (see PlatformRuntimeBehavior.getManager). + * of their associated container (see PlatformObjectsManager.getManager). * @category Behaviors > Platform */ export class PlatformObjectsManager { From a545f129f8a539641b02d7471762b17a4e5ed974 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 15:26:54 +0200 Subject: [PATCH 40/51] Remove unused variable --- Extensions/NavMeshPathfinding/JsExtension.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Extensions/NavMeshPathfinding/JsExtension.js b/Extensions/NavMeshPathfinding/JsExtension.js index e06cf3926c87..d8977646d5db 100644 --- a/Extensions/NavMeshPathfinding/JsExtension.js +++ b/Extensions/NavMeshPathfinding/JsExtension.js @@ -843,7 +843,7 @@ module.exports = { }; sharedData.initializeContent = function (sharedContent) {}; - const aut = extension + extension .addBehavior( 'NavMeshObstacleBehavior', _('Obstacle for pathfinding (nav-mesh based)'), From 2c86fa59c8cff66cc758eb3667bfa938927daafa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 15:58:44 +0200 Subject: [PATCH 41/51] Make debug registering more reliable --- .../NavMeshDebugPixiRenderer.ts | 150 +++++++++--------- .../NavMeshObstacleRuntimeBehavior.ts | 9 +- 2 files changed, 82 insertions(+), 77 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts index c2fc5ca639b8..d64f77078b8d 100644 --- a/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts +++ b/Extensions/NavMeshPathfinding/NavMeshDebugPixiRenderer.ts @@ -16,95 +16,97 @@ namespace gdjs { this.obstaclesManager = obstaclesManager; } - setEnabled(enabled: boolean): void { + setEnabled( + instanceContainer: gdjs.RuntimeInstanceContainer, + enabled: boolean + ): void { this.enabled = enabled; if (enabled) { this.renderFor3D(); if (!this.isRegisteredFor2D) { - this.registerFor2D(); + this.isRegisteredFor2D = true; + this.registerFor2D(instanceContainer); } } else { this.removeFor3D(); } } - private registerFor2D() { - const firstObstacle: NavMeshObstacleRuntimeBehavior = - this.obstaclesManager.obstacles.values().next().value; - if (firstObstacle) { - this.isRegisteredFor2D = true; - firstObstacle.owner - .getRuntimeScene() - .registerDebugDrawHook((rendererObject: PIXI.Graphics) => { - if (!this.enabled || this.obstaclesManager.is3D) { - return; - } - const { navMesh, obstacles } = this.obstaclesManager; - if (!navMesh) { - return; - } - if (!this.debugDrawerUtils) { - this.debugDrawerUtils = new RecastNav.DebugDrawerUtils(); - } - const primitives = this.debugDrawerUtils.drawNavMesh(navMesh); - const firstObstacle: gdjs.NavMeshObstacleRuntimeBehavior = obstacles - .values() - .next().value; - const scene = firstObstacle.owner.getRuntimeScene(); - const layer = scene.getLayer(firstObstacle.owner.getLayer()); - const workingPoint: FloatPoint = [0, 0]; + private registerFor2D(instanceContainer: gdjs.RuntimeInstanceContainer) { + instanceContainer + .getScene() + .registerDebugDrawHook((rendererObject: PIXI.Graphics) => { + if (!this.enabled || this.obstaclesManager.is3D) { + return; + } + const { navMesh, obstacles } = this.obstaclesManager; + if (!navMesh) { + return; + } + const firstObstacle: gdjs.NavMeshObstacleRuntimeBehavior = obstacles + .values() + .next().value; + if (!firstObstacle) { + return; + } + const scene = firstObstacle.owner.getRuntimeScene(); + const layer = scene.getLayer(firstObstacle.owner.getLayer()); + const workingPoint: FloatPoint = [0, 0]; - rendererObject.beginFill(); - rendererObject.fill.alpha = 0.5; - rendererObject.fill.color = 0x778ee8; + rendererObject.beginFill(); + rendererObject.fill.alpha = 0.5; + rendererObject.fill.color = 0x778ee8; - const speedScaleY = this.obstaclesManager.speedScaleY; - for (const primitive of primitives) { - switch (primitive.type) { - case 'tris': - for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { - const [x0, y0, z0] = primitive.vertices[i]; - if (y0 < 1) { - const [x1, _y1, z1] = primitive.vertices[i + 1]; - const [x2, _y2, z2] = primitive.vertices[i + 2]; + if (!this.debugDrawerUtils) { + this.debugDrawerUtils = new RecastNav.DebugDrawerUtils(); + } + const primitives = this.debugDrawerUtils.drawNavMesh(navMesh); + const speedScaleY = this.obstaclesManager.speedScaleY; + for (const primitive of primitives) { + switch (primitive.type) { + case 'tris': + for (let i = 0; i + 2 < primitive.vertices.length; i += 3) { + const [x0, y0, z0] = primitive.vertices[i]; + if (y0 < 1) { + const [x1, _y1, z1] = primitive.vertices[i + 1]; + const [x2, _y2, z2] = primitive.vertices[i + 2]; - const positions: Array = []; - positions.push.apply( - positions, - layer.applyLayerTransformation( - x0, - z0 * speedScaleY, - 0, - workingPoint - ) - ); - positions.push.apply( - positions, - layer.applyLayerTransformation( - x1, - z1 * speedScaleY, - 0, - workingPoint - ) - ); - positions.push.apply( - positions, - layer.applyLayerTransformation( - x2, - z2 * speedScaleY, - 0, - workingPoint - ) - ); - rendererObject.drawPolygon(positions); - } + const positions: Array = []; + positions.push.apply( + positions, + layer.applyLayerTransformation( + x0, + z0 * speedScaleY, + 0, + workingPoint + ) + ); + positions.push.apply( + positions, + layer.applyLayerTransformation( + x1, + z1 * speedScaleY, + 0, + workingPoint + ) + ); + positions.push.apply( + positions, + layer.applyLayerTransformation( + x2, + z2 * speedScaleY, + 0, + workingPoint + ) + ); + rendererObject.drawPolygon(positions); } - break; - } + } + break; } - rendererObject.endFill(); - }); - } + } + rendererObject.endFill(); + }); } removeFor3D() { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 5433c43d64f1..f4703f8fd449 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -192,11 +192,14 @@ namespace gdjs { this.isNavMeshDirty = false; } - setDebugDrawEnabled(enableDebugDraw: boolean): void { + setDebugDrawEnabled( + instanceContainer: gdjs.RuntimeInstanceContainer, + enableDebugDraw: boolean + ): void { if (!this.debuggerRenderer) { this.debuggerRenderer = new gdjs.NavMeshDebuggerRenderer(this); } - this.debuggerRenderer.setEnabled(enableDebugDraw); + this.debuggerRenderer.setEnabled(instanceContainer, enableDebugDraw); } private addGroundFor2D( @@ -569,7 +572,7 @@ namespace gdjs { } const manager = gdjs.NavMeshObstaclesManager.getManager(instanceContainer); - manager.setDebugDrawEnabled(enableDebugDraw); + manager.setDebugDrawEnabled(instanceContainer, enableDebugDraw); }; } From 95eda093c588a8719b7fcfffa4cb659fc2352dc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 16:11:17 +0200 Subject: [PATCH 42/51] Destroy the query --- .../NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts | 2 ++ Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts | 1 + 2 files changed, 3 insertions(+) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 6ffbd1fcb73a..a95cfd444ff7 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -207,6 +207,7 @@ namespace gdjs { } ); if (!hasFoundOrigin) { + navMeshQuery.destroy(); this._pathFound = false; return; } @@ -236,6 +237,7 @@ namespace gdjs { }, } ); + navMeshQuery.destroy(); if (!hasFoundDestination) { this._pathFound = false; return; diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index f4703f8fd449..5c1298631033 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -486,6 +486,7 @@ namespace gdjs { }, { halfExtents: { x: 100, y: 100, z: 100 } } ); + navMeshQuery.destroy(); if (!hasFoundOrigin) { return; } From 74717222e80da3efaef2134b1b1ea501590d8e5a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 16:38:27 +0200 Subject: [PATCH 43/51] Fix characters going to 0;0;0 --- .../NavMeshObstacleRuntimeBehavior.ts | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 5c1298631033..717943c736a8 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -120,6 +120,7 @@ namespace gdjs { return; } this.timeSinceLastNavMeshLastRebuild = 0; + this.isNavMeshDirty = false; const positions: Array = []; const indices: Array = []; for (const obstacle of this.obstacles) { @@ -183,13 +184,12 @@ namespace gdjs { maxAgentRadius: characterRadiusMax, }); for (const character of this.characters) { - this.rebuildCharacterAgent(character); + this.buildCharacterAgent(character); } if (this.debuggerRenderer) { this.debuggerRenderer.renderFor3D(); } } - this.isNavMeshDirty = false; } setDebugDrawEnabled( @@ -466,11 +466,10 @@ namespace gdjs { }); } - private rebuildCharacterAgent( + private buildCharacterAgent( character: NavMeshCharacterRuntimeBehavior ): void { if (!this.navMesh || !this.crowd) { - character._agent = null; return; } const owner = character.owner; @@ -499,13 +498,16 @@ namespace gdjs { ? this.crowd.addAgent(origin, character._crowdAgentParams) : null; + character._agent = agent; if (agent) { - const oldAgent = character._agent; - if (oldAgent && !character.destinationReached()) { - agent.requestMoveTarget(oldAgent.target()); + if (character.pathFound() && !character.destinationReached()) { + character.moveTo( + character.getDestinationX(), + character.getDestinationY(), + character.getDestinationZ() + ); } } - character._agent = agent; } /** @@ -539,7 +541,11 @@ namespace gdjs { if (gdjs.Base3DHandler.is3D(character.owner)) { this.is3D = true; } - this.rebuildCharacterAgent(character); + if (this.crowd && character._agent) { + this.crowd.removeAgent(character._agent); + character._agent = null; + } + this.buildCharacterAgent(character); } /** From 064bc5300c5cca65b79254c18a70052d67937f60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 16:54:03 +0200 Subject: [PATCH 44/51] Avoid to move the character if no path is found --- .../NavMeshCharacterRuntimeBehavior.ts | 21 +++++++++++-------- .../NavMeshObstacleRuntimeBehavior.ts | 8 ++++++- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index a95cfd444ff7..5fc6136f1502 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -29,8 +29,7 @@ namespace gdjs { } /** @category Behaviors > NavMesh pathfinding */ - export interface NavMeshCharacterNetworkSyncData - extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -211,14 +210,8 @@ namespace gdjs { this._pathFound = false; return; } + const agentInitialPosition = this._agent.position(); this._agent.teleport(origin); - this.owner.setX(origin.x); - this.owner.setY( - this._manager.is3D ? origin.z : origin.z * this._manager.speedScaleY - ); - if (gdjs.Base3DHandler.is3D(this.owner)) { - this.owner.setZ(origin.y); - } const { success: hasFoundDestination, point: destination } = navMeshQuery.findClosestPoint( @@ -240,12 +233,22 @@ namespace gdjs { navMeshQuery.destroy(); if (!hasFoundDestination) { this._pathFound = false; + this._agent.teleport(agentInitialPosition); return; } this._pathFound = this._agent.requestMoveTarget(destination); if (this._pathFound) { this._reachedEnd = false; + this.owner.setX(origin.x); + this.owner.setY( + this._manager.is3D ? origin.z : origin.z * this._manager.speedScaleY + ); + if (gdjs.Base3DHandler.is3D(this.owner)) { + this.owner.setZ(origin.y); + } + } else { + this._agent.teleport(agentInitialPosition); } } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 717943c736a8..e1d1ec26db06 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -483,7 +483,13 @@ namespace gdjs { ? owner.getY() : owner.getY() * this.inverseSpeedScaleY, }, - { halfExtents: { x: 100, y: 100, z: 100 } } + { + halfExtents: { + x: 100, + y: this.is3D ? 100 : gdjs.NavMeshObstaclesManager.cellHeightFor2D, + z: 100, + }, + } ); navMeshQuery.destroy(); if (!hasFoundOrigin) { From b16c22a0138ab2dbb4b68a15b899d7dd82ea87b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 17:05:16 +0200 Subject: [PATCH 45/51] Allow multiplayer to stop the path --- .../NavMeshCharacterRuntimeBehavior.ts | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 5fc6136f1502..f0dbbef40584 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -117,7 +117,7 @@ namespace gdjs { return { ...super.getNetworkSyncData(options), props: { - d: this._path[this._path.length - 1], + d: this._path[this._path.length - 1] || null, pf: this._pathFound, as: this._angularMaxSpeed, re: this._reachedEnd, @@ -146,6 +146,8 @@ namespace gdjs { behaviorSpecificProps.d.y, behaviorSpecificProps.d.z ); + } else if (behaviorSpecificProps.d === null && destination) { + this.stop(); } } if (behaviorSpecificProps.pf !== undefined) { @@ -174,6 +176,16 @@ namespace gdjs { this._manager.removeCharacter(this); } + stop(): void { + if (!this._agent) { + return; + } + this._path = []; + this._pathFound = false; + this._reachedEnd = false; + this._agent.resetMoveTarget(); + } + /** * Compute and move on the path to the specified destination. */ From 247c004a55bed62b2bfc00129730e16586b2f4d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 17:06:52 +0200 Subject: [PATCH 46/51] Format --- .../NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index f0dbbef40584..43b2fc48f1b9 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -29,7 +29,8 @@ namespace gdjs { } /** @category Behaviors > NavMesh pathfinding */ - export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData + extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } From 85cc1fd3a38dd237b7e1c4091317ca171b364941 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 18:18:21 +0200 Subject: [PATCH 47/51] Fix character speed loss at obstacle changes --- .../NavMeshCharacterRuntimeBehavior.ts | 23 ++++++++++++------- .../NavMeshObstacleRuntimeBehavior.ts | 21 ++++++++++++----- 2 files changed, 30 insertions(+), 14 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 43b2fc48f1b9..8e721e55f725 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -224,7 +224,13 @@ namespace gdjs { return; } const agentInitialPosition = this._agent.position(); - this._agent.teleport(origin); + if ( + agentInitialPosition.x !== origin.x || + agentInitialPosition.y !== origin.y || + agentInitialPosition.z !== origin.z + ) { + this._agent.teleport(origin); + } const { success: hasFoundDestination, point: destination } = navMeshQuery.findClosestPoint( @@ -408,17 +414,18 @@ namespace gdjs { setSpeed(speed: float): void { if (this._agent) { - const velocity = this._agent.desiredVelocityObstacleAdjusted(); - const oldSpeed = Math.hypot(velocity.x, velocity.y, velocity.z); + const velocityX = this._agent.raw.get_vel(0); + const velocityY = this._agent.raw.get_vel(1); + const velocityZ = this._agent.raw.get_vel(2); + const oldSpeed = Math.hypot(velocityX, velocityY, velocityZ); if (oldSpeed === 0) { this._agent.requestMoveVelocity({ x: speed, y: 0, z: 0 }); } else { const ratio = speed / oldSpeed; - this._agent.requestMoveVelocity({ - x: velocity.x * ratio, - y: velocity.y * ratio, - z: velocity.z * ratio, - }); + + this._agent.raw.set_vel(0, velocityX * ratio); + this._agent.raw.set_vel(1, velocityY * ratio); + this._agent.raw.set_vel(2, velocityZ * ratio); } } } diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index e1d1ec26db06..4b8108ed744e 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -172,12 +172,8 @@ namespace gdjs { this.navMeshConfig ); if (result.success) { - if (this.navMesh) { - this.navMesh.destroy(); - } - if (this.crowd) { - this.crowd.destroy(); - } + const oldNavMesh = this.navMesh; + const oldCrowd = this.crowd; this.navMesh = result.navMesh; this.crowd = new RecastNav.Crowd(this.navMesh, { maxAgents: this.characters.size + 100, @@ -189,6 +185,13 @@ namespace gdjs { if (this.debuggerRenderer) { this.debuggerRenderer.renderFor3D(); } + + if (oldNavMesh) { + oldNavMesh.destroy(); + } + if (oldCrowd) { + oldCrowd.destroy(); + } } } @@ -504,6 +507,7 @@ namespace gdjs { ? this.crowd.addAgent(origin, character._crowdAgentParams) : null; + const oldAgent = character._agent; character._agent = agent; if (agent) { if (character.pathFound() && !character.destinationReached()) { @@ -513,6 +517,11 @@ namespace gdjs { character.getDestinationZ() ); } + if (oldAgent) { + agent.raw.set_vel(0, oldAgent.raw.get_vel(0)); + agent.raw.set_vel(1, oldAgent.raw.get_vel(1)); + agent.raw.set_vel(2, oldAgent.raw.get_vel(2)); + } } } From 993c45bab7b4936c409926f8847c4ae86fa94a06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 18:42:23 +0200 Subject: [PATCH 48/51] Review changes --- .../NavMeshCharacterRuntimeBehavior.ts | 11 +++++------ .../NavMeshObstacleRuntimeBehavior.ts | 7 ++----- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 8e721e55f725..983f1508f0fa 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -29,8 +29,7 @@ namespace gdjs { } /** @category Behaviors > NavMesh pathfinding */ - export interface NavMeshCharacterNetworkSyncData - extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -136,8 +135,10 @@ namespace gdjs { if (behaviorSpecificProps.d !== undefined) { // TODO Try a more reliable synchronization by overriding the path using the low level API. const destination = this._path[this._path.length - 1]; - if ( - (behaviorSpecificProps.d !== null && !destination) || + if (behaviorSpecificProps.d === null && destination) { + this.stop(); + } else if ( + !destination || destination.x !== behaviorSpecificProps.d.x || destination.y !== behaviorSpecificProps.d.y || destination.z !== behaviorSpecificProps.d.z @@ -147,8 +148,6 @@ namespace gdjs { behaviorSpecificProps.d.y, behaviorSpecificProps.d.z ); - } else if (behaviorSpecificProps.d === null && destination) { - this.stop(); } } if (behaviorSpecificProps.pf !== undefined) { diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 4b8108ed744e..625960a658ac 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -469,7 +469,7 @@ namespace gdjs { }); } - private buildCharacterAgent( + buildCharacterAgent( character: NavMeshCharacterRuntimeBehavior ): void { if (!this.navMesh || !this.crowd) { @@ -496,6 +496,7 @@ namespace gdjs { ); navMeshQuery.destroy(); if (!hasFoundOrigin) { + character._agent = null; return; } @@ -556,10 +557,6 @@ namespace gdjs { if (gdjs.Base3DHandler.is3D(character.owner)) { this.is3D = true; } - if (this.crowd && character._agent) { - this.crowd.removeAgent(character._agent); - character._agent = null; - } this.buildCharacterAgent(character); } From b82b6a20dadba13a920b144cd7fec223896140c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 19:01:10 +0200 Subject: [PATCH 49/51] Fix characters created far from the grid were stuck without an agent --- .../NavMeshCharacterRuntimeBehavior.ts | 63 ++++++++++++------- .../NavMeshObstacleRuntimeBehavior.ts | 4 +- 2 files changed, 41 insertions(+), 26 deletions(-) diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index 983f1508f0fa..aa439bf04a5e 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -29,7 +29,8 @@ namespace gdjs { } /** @category Behaviors > NavMesh pathfinding */ - export interface NavMeshCharacterNetworkSyncData extends BehaviorNetworkSyncData { + export interface NavMeshCharacterNetworkSyncData + extends BehaviorNetworkSyncData { props: NavMeshCharacterNetworkSyncDataType; } @@ -56,6 +57,10 @@ namespace gdjs { separationWeight: 1.0, }; + _oldX: float = 0; + _oldY: float = 0; + _oldZ: float = 0; + // Attributes used for traveling on the path: _pathFound: boolean = false; _reachedEnd: boolean = false; @@ -258,19 +263,38 @@ namespace gdjs { this._pathFound = this._agent.requestMoveTarget(destination); if (this._pathFound) { this._reachedEnd = false; - this.owner.setX(origin.x); - this.owner.setY( - this._manager.is3D ? origin.z : origin.z * this._manager.speedScaleY - ); + const newX = origin.x; + const newY = this._manager.is3D + ? origin.z + : origin.z * this._manager.speedScaleY; + const newZ = origin.y; + this.owner.setX(newX); + this.owner.setY(newY); if (gdjs.Base3DHandler.is3D(this.owner)) { - this.owner.setZ(origin.y); + this.owner.setZ(newZ); } + this._oldX = newX; + this._oldY = newY; + this._oldZ = newZ; } else { this._agent.teleport(agentInitialPosition); } } teleportAgentToObjectIfNeeded(): void { + if ( + this._oldX === this.owner.getX() && + this._oldY === this.owner.getY() && + (!gdjs.Base3DHandler.is3D(this.owner) || + this._oldZ === this.owner.getZ()) + ) { + return; + } + if (!this._agent) { + // Try to create the agent at the new object position. + this._manager.buildCharacterAgent(this); + return; + } const agent = this._agent; if (!agent) { return; @@ -283,23 +307,13 @@ namespace gdjs { ? this.owner.getZ() : agent.raw.get_npos(1); - let expectedX = agent.raw.get_npos(0); - let expectedY = this._manager.is3D - ? agent.raw.get_npos(2) - : agent.raw.get_npos(2) * this._manager.speedScaleY; - let expectedZ = agent.raw.get_npos(1); - - if (oldX !== expectedX || oldY !== expectedY || oldZ !== expectedZ) { - agent.teleport({ - x: oldX, - y: oldZ, - z: this._manager.is3D - ? oldY - : oldY * this._manager.inverseSpeedScaleY, - }); - this._path = []; - this._pathFound = false; - } + agent.teleport({ + x: oldX, + y: oldZ, + z: this._manager.is3D ? oldY : oldY * this._manager.inverseSpeedScaleY, + }); + this._path = []; + this._pathFound = false; } override doStepPreEvents(instanceContainer: gdjs.RuntimeInstanceContainer) { @@ -374,6 +388,9 @@ namespace gdjs { if (gdjs.Base3DHandler.is3D(this.owner)) { this.owner.setZ(newZ); } + this._oldX = newX; + this._oldY = newY; + this._oldZ = newZ; } override doStepPostEvents( diff --git a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts index 625960a658ac..21ea89e3648a 100644 --- a/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.ts @@ -469,9 +469,7 @@ namespace gdjs { }); } - buildCharacterAgent( - character: NavMeshCharacterRuntimeBehavior - ): void { + buildCharacterAgent(character: NavMeshCharacterRuntimeBehavior): void { if (!this.navMesh || !this.crowd) { return; } From e291379c4db8e20c97e636005d2ff805a9f2912d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Davy=20H=C3=A9lard?= Date: Mon, 10 Aug 2026 23:32:59 +0200 Subject: [PATCH 50/51] Add building instructions --- Extensions/NavMeshPathfinding/README.md | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Extensions/NavMeshPathfinding/README.md diff --git a/Extensions/NavMeshPathfinding/README.md b/Extensions/NavMeshPathfinding/README.md new file mode 100644 index 000000000000..bf77fe112568 --- /dev/null +++ b/Extensions/NavMeshPathfinding/README.md @@ -0,0 +1,11 @@ +# NavMesh pathfinding extension + +To update the library: +- Clone this fork https://github.com/D8H/recast-navigation-js +- Check out `main` +- Get the wasm build with npm +- Copy the wasm build into `recast-navigation-js/packages/recast-navigation-wasm/build` +- Run `yarn build` +- Check out `umd-build` +- Run `yarn build` +- Copy `recast-navigation-js/packages/recast-navigation/recast-navigation-generators.js` and the wasm build into this folder From a896e936ee42793f9329a149046961c743520af6 Mon Sep 17 00:00:00 2001 From: Florian Rival Date: Tue, 11 Aug 2026 10:20:14 +0200 Subject: [PATCH 51/51] Add unit tests (#8949) --- .../NavMeshCharacterRuntimeBehavior.ts | 19 +- .../navmeshcharacterruntimebehavior.spec.js | 399 ++++++++++++++++++ GDJS/package-lock.json | 40 ++ GDJS/tests/karma.conf.js | 19 + 4 files changed, 470 insertions(+), 7 deletions(-) create mode 100644 Extensions/NavMeshPathfinding/tests/navmeshcharacterruntimebehavior.spec.js diff --git a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts index aa439bf04a5e..06d83a0a1de1 100644 --- a/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts +++ b/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.ts @@ -140,8 +140,10 @@ namespace gdjs { if (behaviorSpecificProps.d !== undefined) { // TODO Try a more reliable synchronization by overriding the path using the low level API. const destination = this._path[this._path.length - 1]; - if (behaviorSpecificProps.d === null && destination) { - this.stop(); + if (behaviorSpecificProps.d === null) { + if (destination) { + this.stop(); + } } else if ( !destination || destination.x !== behaviorSpecificProps.d.x || @@ -228,12 +230,16 @@ namespace gdjs { return; } const agentInitialPosition = this._agent.position(); + // Teleporting the agent resets its velocity and move target, + // so it's only done (and rolled back) when actually needed. + let hasTeleported = false; if ( agentInitialPosition.x !== origin.x || agentInitialPosition.y !== origin.y || agentInitialPosition.z !== origin.z ) { this._agent.teleport(origin); + hasTeleported = true; } const { success: hasFoundDestination, point: destination } = @@ -256,7 +262,9 @@ namespace gdjs { navMeshQuery.destroy(); if (!hasFoundDestination) { this._pathFound = false; - this._agent.teleport(agentInitialPosition); + if (hasTeleported) { + this._agent.teleport(agentInitialPosition); + } return; } @@ -276,7 +284,7 @@ namespace gdjs { this._oldX = newX; this._oldY = newY; this._oldZ = newZ; - } else { + } else if (hasTeleported) { this._agent.teleport(agentInitialPosition); } } @@ -296,9 +304,6 @@ namespace gdjs { return; } const agent = this._agent; - if (!agent) { - return; - } const oldX = this.owner.getX(); const oldY = this.owner.getY(); // For 2D we keep the agent position for Z because the ground may not be diff --git a/Extensions/NavMeshPathfinding/tests/navmeshcharacterruntimebehavior.spec.js b/Extensions/NavMeshPathfinding/tests/navmeshcharacterruntimebehavior.spec.js new file mode 100644 index 000000000000..dfe6831dbfd3 --- /dev/null +++ b/Extensions/NavMeshPathfinding/tests/navmeshcharacterruntimebehavior.spec.js @@ -0,0 +1,399 @@ +// @ts-check +describe('gdjs.NavMeshCharacterRuntimeBehavior', function () { + const characterBehaviorName = 'NavMeshCharacter'; + + before(async function () { + // Give some time for the Recast navigation library (WASM) to be loaded. + this.timeout(30000); + await gdjs.getAllAsynchronouslyLoadingLibraryPromise(); + }); + + const createScene = (framePerSecond = 60) => { + const runtimeGame = gdjs.getPixiRuntimeGame(); + const runtimeScene = new gdjs.RuntimeScene(runtimeGame); + runtimeScene.loadFromScene({ + sceneData: { + layers: [ + { + name: '', + visibility: true, + effects: [], + cameras: [], + + ambientLightColorR: 0, + ambientLightColorG: 0, + ambientLightColorB: 0, + isLightingLayer: false, + followBaseLayerCamera: true, + }, + ], + variables: [], + r: 0, + v: 0, + b: 0, + mangledName: 'Scene1', + name: 'Scene1', + stopSoundsOnStartup: false, + title: '', + behaviorsSharedData: [], + objects: [], + objectsGroups: [], + instances: [], + usedResources: [], + uiSettings: { + grid: false, + gridType: 'rectangular', + gridWidth: 10, + gridHeight: 10, + gridDepth: 10, + gridOffsetX: 0, + gridOffsetY: 0, + gridOffsetZ: 0, + gridColor: 0, + gridAlpha: 1, + snap: false, + }, + }, + usedExtensionsWithVariablesData: [], + }); + const characterSharedData = { + name: characterBehaviorName, + type: 'NavMeshPathfinding::NavMeshCharacterBehavior', + cellSize: 10, + cellDepth: 10, + slopeMaxAngle: 50, + stairHeightMax: 20, + walkableRadius: -1, + walkableDepth: 150, + speedScaleY: 1, + }; + runtimeScene.setInitialSharedDataForBehavior( + characterBehaviorName, + characterSharedData + ); + setFramePerSecond(runtimeScene, framePerSecond); + return runtimeScene; + }; + const setFramePerSecond = (runtimeScene, framePerSecond) => { + runtimeScene._timeManager.getElapsedTime = function () { + return 1000 / framePerSecond; + }; + }; + + const addCharacter = (runtimeScene) => { + const character = new gdjs.RuntimeObject( + runtimeScene, + { + name: 'character', + type: '', + behaviors: [ + { + type: 'NavMeshPathfinding::NavMeshCharacterBehavior', + name: characterBehaviorName, + // @ts-ignore - properties are not typed + acceleration: 400, + maxSpeed: 200, + angularMaxSpeed: 180, + rotateObject: false, + angleOffset: 0, + radius: 0, + avoidanceSightRange: 120, + }, + ], + effects: [], + variables: [], + }, + undefined + ); + character.getWidth = function () { + return 20; + }; + character.getHeight = function () { + return 20; + }; + runtimeScene.addObject(character); + return character; + }; + + const addObstacle = (runtimeScene, width = 100, height = 100) => { + const obstacle = new gdjs.RuntimeObject( + runtimeScene, + { + name: 'obstacle', + type: '', + behaviors: [ + { + type: 'NavMeshPathfinding::NavMeshObstacleBehavior', + name: 'NavMeshObstacle', + // @ts-ignore - properties are not typed + shape: 'Box', + meshShapeResourceName: '', + }, + ], + effects: [], + variables: [], + }, + undefined + ); + obstacle.getWidth = function () { + return width; + }; + obstacle.getHeight = function () { + return height; + }; + runtimeScene.addObject(obstacle); + return obstacle; + }; + + /** + * Add obstacles far in 2 corners to define the walkable area: + * the ground used by the nav mesh covers the bounding box of all + * the obstacles. + */ + const addGroundDelimiters = (runtimeScene) => { + const topLeftObstacle = addObstacle(runtimeScene); + topLeftObstacle.setPosition(-300, -300); + const bottomRightObstacle = addObstacle(runtimeScene); + bottomRightObstacle.setPosition(1000, 700); + }; + + /** @returns {gdjs.NavMeshCharacterRuntimeBehavior} */ + const getCharacterBehavior = (character) => + // @ts-ignore - the behavior is from this extension. + character.getBehavior(characterBehaviorName); + + /** + * The path nodes are the remaining corners of the path (not including + * the current character position), so the path length is measured + * from the character position. + */ + const getPathLength = (character) => { + const behavior = getCharacterBehavior(character); + if (behavior.getNodeCount() < 1) { + return 0; + } + let pathLength = 0; + let previousNodeX = character.getX(); + let previousNodeY = character.getY(); + for (let index = 0; index < behavior.getNodeCount(); index++) { + const nodeX = behavior.getNodeX(index); + const nodeY = behavior.getNodeY(index); + pathLength += Math.hypot(nodeX - previousNodeX, nodeY - previousNodeY); + previousNodeX = nodeX; + previousNodeY = nodeY; + } + return pathLength; + }; + + const stepUntilDestinationIsReached = (runtimeScene, character) => { + const behavior = getCharacterBehavior(character); + for ( + let stepIndex = 0; + stepIndex < 600 && !behavior.destinationReached(); + stepIndex++ + ) { + runtimeScene.renderAndStep(1000 / 60); + } + }; + + let runtimeScene; + let character; + beforeEach(function () { + runtimeScene = createScene(); + character = addCharacter(runtimeScene); + addGroundDelimiters(runtimeScene); + }); + + it('can find a path without any obstacle in the way and reach the destination', function () { + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + getCharacterBehavior(character).moveTo(600, 300, 0); + expect(getCharacterBehavior(character).pathFound()).to.be(true); + // The path is extracted from the agent at the 1st step following moveTo. + runtimeScene.renderAndStep(1000 / 60); + // The origin and destination are snapped on the nav mesh grid, + // so allow a margin on the path length. + expect(getPathLength(character)).to.be.within(180, 220); + + stepUntilDestinationIsReached(runtimeScene, character); + expect(getCharacterBehavior(character).destinationReached()).to.be(true); + expect(character.getX()).to.be.within(580, 620); + expect(character.getY()).to.be.within(280, 320); + }); + + it('can find a path around an obstacle in the way and reach the destination', function () { + const blockingObstacle = addObstacle(runtimeScene, 50, 300); + blockingObstacle.setPosition(475, 150); + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + getCharacterBehavior(character).moveTo(600, 300, 0); + expect(getCharacterBehavior(character).pathFound()).to.be(true); + // The path is extracted from the agent at the 1st step following moveTo. + runtimeScene.renderAndStep(1000 / 60); + // The path can't be a straight line, it has to go around the obstacle. + expect(getPathLength(character)).to.be.above(240); + + stepUntilDestinationIsReached(runtimeScene, character); + expect(getCharacterBehavior(character).destinationReached()).to.be(true); + expect(character.getX()).to.be.within(580, 620); + expect(character.getY()).to.be.within(280, 320); + }); + + it('must not find a path to a destination outside of the walkable area', function () { + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + // The destination is way outside of the walkable area + // (which is the bounding box of all the obstacles). + getCharacterBehavior(character).moveTo(600, 5000, 0); + expect(getCharacterBehavior(character).pathFound()).to.be(false); + + // The character must not move. + for (let stepIndex = 0; stepIndex < 10; stepIndex++) { + runtimeScene.renderAndStep(1000 / 60); + } + expect(character.getX()).to.be.within(399, 401); + expect(character.getY()).to.be.within(299, 301); + }); + + it("keeps moving to its destination when a new destination can't be found", function () { + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + getCharacterBehavior(character).moveTo(600, 300, 0); + expect(getCharacterBehavior(character).pathFound()).to.be(true); + + // Let the character travel a bit. + for (let stepIndex = 0; stepIndex < 30; stepIndex++) { + runtimeScene.renderAndStep(1000 / 60); + } + expect(character.getX()).to.be.above(420); + + // Ask for a destination that can't be reached. + getCharacterBehavior(character).moveTo(600, 5000, 0); + expect(getCharacterBehavior(character).pathFound()).to.be(false); + + // The character keeps moving to its previous destination. + stepUntilDestinationIsReached(runtimeScene, character); + expect(getCharacterBehavior(character).destinationReached()).to.be(true); + expect(character.getX()).to.be.within(580, 620); + expect(character.getY()).to.be.within(280, 320); + }); + + it('can find a shorter path when an obstacle is deactivated', function () { + const blockingObstacle = addObstacle(runtimeScene, 50, 300); + blockingObstacle.setPosition(475, 150); + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + // To build the nav mesh a 1st time with the blocking obstacle. + runtimeScene.renderAndStep(1000 / 60); + + const obstacleBehavior = + /** @type {gdjs.NavMeshObstacleRuntimeBehavior} */ ( + blockingObstacle.getBehavior('NavMeshObstacle') + ); + obstacleBehavior.activate(false); + // The nav mesh is rebuilt at most once per second. + for (let stepIndex = 0; stepIndex < 61; stepIndex++) { + runtimeScene.renderAndStep(1000 / 60); + } + + getCharacterBehavior(character).moveTo(600, 300, 0); + expect(getCharacterBehavior(character).pathFound()).to.be(true); + // The path is extracted from the agent at the 1st step following moveTo. + runtimeScene.renderAndStep(1000 / 60); + // The path is a straight line as the obstacle is gone. + expect(getPathLength(character)).to.be.within(180, 220); + }); + + describe('(network synchronization)', function () { + it('can sync an idle character over an idle character without error', function () { + const otherCharacter = addCharacter(runtimeScene); + otherCharacter.setPosition(200, 300); + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + // Neither characters moved: their path is empty. + const syncData = getCharacterBehavior(character).getNetworkSyncData({}); + expect(syncData.props.d).to.be(null); + + // This must not crash nor start any movement. + getCharacterBehavior(otherCharacter).updateFromNetworkSyncData( + syncData, + {} + ); + expect(getCharacterBehavior(otherCharacter).pathFound()).to.be(false); + expect(getCharacterBehavior(otherCharacter).getNodeCount()).to.be(0); + }); + + it('can sync a moving character over an idle character', function () { + const otherCharacter = addCharacter(runtimeScene); + otherCharacter.setPosition(300, 200); + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + getCharacterBehavior(character).moveTo(600, 300, 0); + // Let the path be extracted from the agent. + runtimeScene.renderAndStep(1000 / 60); + expect(getCharacterBehavior(character).getNodeCount()).to.be.above(1); + + const syncData = getCharacterBehavior(character).getNetworkSyncData({}); + getCharacterBehavior(otherCharacter).updateFromNetworkSyncData( + syncData, + {} + ); + expect(getCharacterBehavior(otherCharacter).pathFound()).to.be(true); + + stepUntilDestinationIsReached(runtimeScene, otherCharacter); + expect(getCharacterBehavior(otherCharacter).destinationReached()).to.be( + true + ); + expect(otherCharacter.getX()).to.be.within(580, 620); + expect(otherCharacter.getY()).to.be.within(280, 320); + }); + + it('can sync an idle character over a moving character to stop it', function () { + const otherCharacter = addCharacter(runtimeScene); + otherCharacter.setPosition(400, 300); + character.setPosition(400, 300); + // To ensure obstacles are registered. + runtimeScene.renderAndStep(1000 / 60); + + getCharacterBehavior(otherCharacter).moveTo(600, 300, 0); + // Let the path be extracted from the agent. + runtimeScene.renderAndStep(1000 / 60); + expect(getCharacterBehavior(otherCharacter).getNodeCount()).to.be.above( + 1 + ); + + // The (idle) character path is empty. + const syncData = getCharacterBehavior(character).getNetworkSyncData({}); + expect(syncData.props.d).to.be(null); + + getCharacterBehavior(otherCharacter).updateFromNetworkSyncData( + syncData, + {} + ); + expect(getCharacterBehavior(otherCharacter).pathFound()).to.be(false); + expect(getCharacterBehavior(otherCharacter).getNodeCount()).to.be(0); + + // The character must not move anymore. + const oldX = otherCharacter.getX(); + const oldY = otherCharacter.getY(); + for (let stepIndex = 0; stepIndex < 10; stepIndex++) { + runtimeScene.renderAndStep(1000 / 60); + } + expect(otherCharacter.getX()).to.be.within(oldX - 1, oldX + 1); + expect(otherCharacter.getY()).to.be.within(oldY - 1, oldY + 1); + }); + }); +}); diff --git a/GDJS/package-lock.json b/GDJS/package-lock.json index 05656db394b5..4aef523a3da1 100644 --- a/GDJS/package-lock.json +++ b/GDJS/package-lock.json @@ -22,6 +22,7 @@ "patch-package": "^6.4.7", "pixi.js": "7.4.2", "prettier": "3.4.2", + "recast-navigation": "0.43.1", "recursive-readdir": "^2.2.2", "shelljs": "^0.8.4", "typedoc": "^0.25.13", @@ -285,6 +286,34 @@ "node": ">=14" } }, + "node_modules/@recast-navigation/core": { + "version": "0.43.1", + "resolved": "https://registry.npmjs.org/@recast-navigation/core/-/core-0.43.1.tgz", + "integrity": "sha512-4igfPgnoV90O92sDSIA0xHa6tanh3z/udlgGmD0SqGQ6PKV4JS2l9jWO8YnxfZuXP/NV52H4c5FU6pSdZc9WDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@recast-navigation/wasm": "0.43.1" + } + }, + "node_modules/@recast-navigation/generators": { + "version": "0.43.1", + "resolved": "https://registry.npmjs.org/@recast-navigation/generators/-/generators-0.43.1.tgz", + "integrity": "sha512-w7r6k/A93wWxuSN+Lg+PmlsUVXq06r5bqXmBglolxqDt2O/Y776BIhYtb6P2P6pbYqDWORu9NCZZJzfY4FNpaA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@recast-navigation/core": "0.43.1", + "@recast-navigation/wasm": "0.43.1" + } + }, + "node_modules/@recast-navigation/wasm": { + "version": "0.43.1", + "resolved": "https://registry.npmjs.org/@recast-navigation/wasm/-/wasm-0.43.1.tgz", + "integrity": "sha512-XFL6PhO8JodwXUHBSAkfaLUdUEweIkJsdP3HTmtJvMs5fkqEWxWJmBskZlACHJepv55NAriqWxOtuLlG3t7+Hg==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/css-font-loading-module": { "version": "0.0.12", "resolved": "https://registry.npmjs.org/@types/css-font-loading-module/-/css-font-loading-module-0.0.12.tgz", @@ -2252,6 +2281,17 @@ "node": ">= 4" } }, + "node_modules/recast-navigation": { + "version": "0.43.1", + "resolved": "https://registry.npmjs.org/recast-navigation/-/recast-navigation-0.43.1.tgz", + "integrity": "sha512-BVBQEHE6uqD36opJomVkI5TxMVZ8bBLdDn90mYtBUYJnNlqEuNFOL8DH8lLOksfVVaC+kjykYuS57P6MrxVB7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@recast-navigation/core": "0.43.1", + "@recast-navigation/generators": "0.43.1" + } + }, "node_modules/rechoir": { "version": "0.6.2", "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", diff --git a/GDJS/tests/karma.conf.js b/GDJS/tests/karma.conf.js index ee2e189d549b..571819a67d28 100644 --- a/GDJS/tests/karma.conf.js +++ b/GDJS/tests/karma.conf.js @@ -143,6 +143,25 @@ module.exports = function (config) { './newIDE/app/resources/GDJS/Runtime/Extensions/PathfindingBehavior/PathTools.js', './newIDE/app/resources/GDJS/Runtime/Extensions/PathfindingBehavior/pathfindingobstacleruntimebehavior.js', './newIDE/app/resources/GDJS/Runtime/Extensions/PathfindingBehavior/pathfindingruntimebehavior.js', + './newIDE/app/resources/GDJS/Runtime/Extensions/NavMeshPathfinding/recast-navigation-generators.js', + { + pattern: + './newIDE/app/resources/GDJS/Runtime/Extensions/NavMeshPathfinding/recast-navigation.wasm.js', + watched: true, + included: false, + served: true, + nocache: false, + }, + { + pattern: + './newIDE/app/resources/GDJS/Runtime/Extensions/NavMeshPathfinding/recast-navigation.wasm.wasm', + watched: true, + included: false, + served: true, + nocache: false, + }, + './newIDE/app/resources/GDJS/Runtime/Extensions/NavMeshPathfinding/NavMeshObstacleRuntimeBehavior.js', + './newIDE/app/resources/GDJS/Runtime/Extensions/NavMeshPathfinding/NavMeshCharacterRuntimeBehavior.js', './newIDE/app/resources/GDJS/Runtime/Extensions/PrimitiveDrawing/shapepainterruntimeobject.js', './newIDE/app/resources/GDJS/Runtime/Extensions/PrimitiveDrawing/shapepainterruntimeobject-pixi-renderer.js', './newIDE/app/resources/GDJS/Runtime/Extensions/TextInput/textinputruntimeobject.js',