@babylonjs-toolkit/next 9.0.1

package/README.md

@@ -0,0 +1,319 @@
+# ESNext Edition
+The <a href="https://www.babylontoolkit.com">Babylon Toolkit</a> is a runtime library extension for BabylonJS development that provides modern programming mechanics with a familiar Unity like scripting model to fast track native web game development.
+
+<a href="https://www.npmjs.com/package/babylonjs-toolkit">Classic Edition (UMD)</a>
+<br/>
+<a href="https://github.com/BabylonJS/BabylonToolkit/tree/master/Runtime">Browser Library (CDN)</a>
+<br/>
+<a href="https://github.com/MackeyK24/ES6-StarterAssets">Demo React Project (TSX)</a>
+<br/>
+<a href="https://github.com/MackeyK24/NJS-StarterAssets">Next.js React Project (TSX)</a>
+
+
+## Basic Installation
+```bash
+npm install @babylonjs-toolkit/next
+```
+
+## Default Installation (ES6)
+```bash
+npm install @babylonjs/core @babylonjs/gui @babylonjs/loaders @babylonjs/materials @babylonjs/havok @babylonjs-toolkit/next
+```
+
+* Default Module Import Libraries
+```javascript
+import { Engine, Scene } from "@babylonjs/core";
+import { HavokPlugin } from "@babylonjs/core/Physics/v2/Plugins/havokPlugin";
+import HavokPhysics from "@babylonjs/havok";
+import { SceneManager, ScriptComponent } from "@babylonjs-toolkit/next";
+```
+
+* Granular File Level Import Libraries
+```javascript
+import { Engine } from "@babylonjs/core/Engines/engine";
+import { Scene } from "@babylonjs/core/scene";
+import { HavokPlugin } from "@babylonjs/core/Physics/v2/Plugins/havokPlugin";
+import HavokPhysics from "@babylonjs/havok";
+import { SceneManager } from "@babylonjs-toolkit/next/scenemanager";
+import { ScriptComponent } from "@babylonjs-toolkit/next/scenemanager";
+import { LocalMessageBus } from "@babylonjs-toolkit/next/localmessagebus";
+import { CharacterController } from "@babylonjs-toolkit/next/charactercontroller";
+```
+
+* Legacy Global Namespace Import Libraries
+```javascript
+import * as BABYLON from "@babylonjs/core/Legacy/legacy";
+import { HavokPlugin } from "@babylonjs/core/Physics/v2/Plugins/havokPlugin";
+import HavokPhysics from "@babylonjs/havok";
+import * as TOOLKIT from "@babylonjs-toolkit/next";
+TOOLKIT.SceneManager.AutoStripNamespacePrefix = false;
+```
+
+## Navigation Mesh And Pathfinding ([Navigation](https://github.com/MackeyK24/babylon-navigation-mesh))
+
+Import Navigation from the babylon-toolkit library:
+```
+import { Navigation } from '@babylonjs-toolkit/next';
+```
+
+### Vite Configuration (ES6)
+
+The Vite bundle services behave differently in devmode than production. To preserve some required classes during devmode, these `exclude` and `include` settings are strongly recommended in your vite.config.js settings file.
+
+```json
+  optimizeDeps: {
+    exclude: mode === 'development' ? [
+      "@babylonjs/havok",
+      "@babylonjs/core",
+      "@babylonjs/loaders",
+      "@babylonjs/loaders/glTF",
+    ] : ["@babylonjs/havok"],
+    include: mode === 'development' ? [
+      "@babylonjs/gui", 
+      "@babylonjs/materials",
+      "@babylonjs/inspector",
+      "@babylonjs-toolkit/dlc",
+      "@babylonjs-toolkit/next"
+    ] : [],
+  },
+```
+
+# 🌳 Tree Shaking 
+
+The Babylon Toolkit ES6 library is optimized for maximum tree-shaking with **39 separate module files** containing **114 total declarations**. The build system intelligently groups related classes to handle circular dependencies while maintaining optimal bundle sizes.
+
+### Key Benefits:
+- ✅ **Smart dependency grouping** - Related classes are bundled together
+- ✅ **Zero unused code** - Only imported classes are included
+- ✅ **Circular dependency handling** - Complex relationships are managed automatically
+- ✅ **Multiple import styles** - Choose the approach that fits your needs
+
+## 🚀 Import Methods
+
+### Method 1: Main Index Import (Recommended)
+```typescript
+import { SceneManager, ScriptComponent, InputController } from "@babylonjs-toolkit/next";
+```
+- **Pros**: Simple, clean, easy to refactor
+- **Cons**: Bundler must analyze index.js
+- **Use Case**: Most applications, rapid development
+
+### Method 2: File-Level Import (Maximum Control)
+```typescript
+import { SceneManager } from "@babylonjs-toolkit/next/scenemanager";
+import { LocalMessageBus } from "@babylonjs-toolkit/next/localmessagebus";
+```
+- **Pros**: Explicit dependencies, maximum bundler hints
+- **Cons**: More verbose, requires knowledge of file structure
+- **Use Case**: Library authors, performance-critical applications
+
+## 📦 Module Groups
+
+The toolkit is organized into logical groups based on dependency analysis. The main entry point uses file level imports automatically
+
+### Core Group (scenemanager.ts)
+The largest group containing the main runtime and interconnected components:
+
+**Classes:**
+- `SceneManager` - Main toolkit framework manager
+- `ScriptComponent` - Base class for all script components  
+- `PreloadAssetsManager` - Asset preloading management
+- `GlobalMessageBus` - Global messaging system
+- `RequestHeader` - HTTP request utilities
+- `CubeTextureLoader` - Cube texture loading utilities
+- `MetadataParser` - Scene metadata parsing
+- `Utilities` - General utility functions
+- `InputController` - User input management
+- `WindowManager` - Window and screen management
+- `AnimationState` - Animation state machine component
+- `BlendTreeValue` - Animation blend tree values
+- `BlendTreeUtils` - Animation blend tree utilities
+- `BlendTreeSystem` - Animation blend tree system
+- `MachineState` - State machine implementation
+- `TransitionCheck` - Animation transition logic
+- `AnimationMixer` - Animation mixing utilities
+- `BlendingWeights` - Animation blending weights
+- `AudioSource` - Audio playback component
+- `HavokRaycastVehicle` - Havok physics vehicle
+- `HavokWheelInfo` - Vehicle wheel information
+- `HavokVehicleUtilities` - Vehicle utility functions
+- `RaycastVehicle` - Generic raycast vehicle
+- `RigidbodyPhysics` - Physics rigidbody component
+- `PhyscisContainerData` - Physics container data
+
+**Interfaces:**
+- `IAssetPreloader` - Asset preloading interface
+- `IWindowMessage` - Window messaging interface
+- `IRuntimeOptions` - Runtime configuration
+- `IUnityTransform` - Unity transform compatibility
+- `IUnityCurve` - Unity animation curve compatibility
+- `IUnityMaterial` - Unity material compatibility
+- `IUnityTexture` - Unity texture compatibility
+- `IUnityCubemap` - Unity cubemap compatibility
+- `IUnityAudioClip` - Unity audio clip compatibility
+- `IUnityVideoClip` - Unity video clip compatibility
+- `IUnityFontAsset` - Unity font asset compatibility
+- `IUnityTextAsset` - Unity text asset compatibility
+- `IUnityDefaultAsset` - Unity default asset compatibility
+- `IUnityVector2` - Unity Vector2 compatibility
+- `IUnityVector3` - Unity Vector3 compatibility
+- `IUnityVector4` - Unity Vector4 compatibility
+- `IUnityColor` - Unity Color compatibility
+- `UserInputPress` - User input press interface
+- `KeymapState` - Input keymap state
+- `IAnimatorEvent` - Animation event interface
+- `IAvatarMask` - Animation avatar mask
+- `IAnimationLayer` - Animation layer interface
+- `IBehaviour` - Animation behavior interface
+- `ITransition` - Animation transition interface
+- `ICondition` - Animation condition interface
+- `IBlendTree` - Animation blend tree interface
+- `IBlendTreeChild` - Blend tree child interface
+- `IPhysicsShapeCastResult` - Physics shape cast result
+- `IPhysicsShapeCastQuery` - Physics shape cast query
+
+**Types:**
+- `UserInputAction` - User input action callback type
+
+**Enums:**
+- `System` - System type enumeration
+- `SearchType` - Search functionality types  
+- `PlayerNumber` - Player identification
+- `RenderQuality` - Graphics quality settings
+- `GamepadType` - Controller types
+- `UserInputAxis` - Input axis enumeration
+- `UserInputKey` - Input key enumeration
+- `MaterialAlphaMode` - Material alpha blending modes
+- `DragDirection` - Touch drag directions
+- `PinchZoomState` - Pinch zoom states
+- `MotionType` - Animation motion types
+- `ConditionMode` - Animation condition modes
+- `InterruptionSource` - Animation interruption sources
+- `BlendTreeType` - Animation blend tree types
+- `AnimatorParameterType` - Animation parameter types
+
+### Standalone Component Groups
+
+The remaining components are organized into standalone modules for optimal tree-shaking:
+
+#### Animation & Media Components
+- `ShurikenParticles` - Particle system component
+- `WebVideoPlayer` - Video playback component
+
+#### Character Controllers
+- `CharacterController` - Physics-based character controller
+- `SimpleCharacterController` - Basic character movement
+- `RecastCharacterController` - Navigation mesh character controller
+- `NavigationAgent` - Navigation mesh agent
+- `UniversalCharacterController` - Universal character controller type
+
+#### Terrain & Environment  
+- `TerrainGenerator` - Procedural terrain generation
+- `UniversalTerrainMaterial` - Advanced terrain material
+- `UniversalTerrainMaterialPlugin` - Terrain material plugin
+
+#### Material & Rendering Systems
+- `CustomShaderMaterial` - Custom shader material system
+- `CustomShaderMaterialPlugin` - Custom shader material plugin
+- `CustomLoadingScreen` - Custom loading screen implementation
+- `LinesMeshRenderer` - Line rendering utilities
+
+#### Input & Control Enums
+- `Handedness` - Hand preference enumeration
+- `PlayerControl` - Player control types
+- `Xbox360Trigger` - Xbox controller trigger enumeration
+- `MovementType` - Character movement types
+- `MouseButtonMode` - Mouse button interaction modes
+- `TouchMouseButton` - Touch to mouse button mapping
+- `UserInputPointer` - Input pointer types
+
+#### Physics & Collision Systems
+- `CollisionContact` - Collision contact types
+- `CollisionState` - Collision state enumeration
+- `CollisionFlags` - Physics collision flags
+- `CollisionFilters` - Collision filtering system
+- `IntersectionPrecision` - Ray intersection precision
+
+#### Animation & UI Types
+- `BlendTreePosition` - Animation blend tree positioning
+- `IAnimationCurve` - Animation curve interface
+- `IAnimationKeyframe` - Animation keyframe interface
+- `TouchJoystickHandler` - Touch joystick input handler
+
+#### Data Structures & Results
+- `RaycastHitResult` - Ray casting result data
+- `TriggerVolume` - Physics trigger volume
+- `RoomErrorMessage` - Network room error messaging
+- `PrefabObjectPool` - Object pooling system
+- `LocalMessageBus` - Local messaging system
+- `EntityController` - Entity management controller
+
+## 🎯 Best Practices
+
+### 1. Start Small
+Begin with minimal imports and add components as needed:
+```typescript
+// Start with this
+import { SceneManager } from "@babylonjs-toolkit/next";
+
+// Add components incrementally
+import { SceneManager, InputController } from "@babylonjs-toolkit/next";
+```
+
+### 2. Group Related Imports
+Import related functionality together:
+```typescript
+// Good - related physics components
+import { 
+    CharacterController, 
+    RigidbodyPhysics, 
+    CollisionState 
+} from "@babylonjs-toolkit/next";
+```
+
+### 3. Use File-Level Imports For Maximum Control
+When bundle size is critical:
+```typescript
+// Maximum tree-shaking for production
+import { SceneManager } from "@babylonjs-toolkit/next/scenemanager";
+
+// Character Controllers
+import { CharacterController } from "@babylonjs-toolkit/next/scenemanager";
+import { SimpleCharacterController } from "@babylonjs-toolkit/next/scenemanager";
+import { RecastCharacterController } from "@babylonjs-toolkit/next/scenemanager";
+
+// Animation & Media Components
+import { ShurikenParticles } from "@babylonjs-toolkit/next/shurikenparticles";
+import { WebVideoPlayer } from "@babylonjs-toolkit/next/webvideoplayer";
+
+// Terrain & Environment
+import { TerrainGenerator } from "@babylonjs-toolkit/next/terraingenerator";
+import { UniversalTerrainMaterial } from "@babylonjs-toolkit/next/universalterrainmaterial";
+
+// Material Systems
+import { CustomShaderMaterial } from "@babylonjs-toolkit/next/customshadermaterial";
+import { CustomShaderMaterialPlugin } from "@babylonjs-toolkit/next/customshadermaterialplugin";
+
+// Utility Classes
+import { CustomLoadingScreen } from "@babylonjs-toolkit/next/customloadingscreen";
+import { PrefabObjectPool } from "@babylonjs-toolkit/next/prefabobjectpool";
+import { LocalMessageBus } from "@babylonjs-toolkit/next/localmessagebus";
+import { LinesMeshRenderer } from "@babylonjs-toolkit/next/linesmeshrenderer";
+
+// Enums & Types (Smallest Imports)
+import { Handedness } from "@babylonjs-toolkit/next/handedness";
+import { PlayerControl } from "@babylonjs-toolkit/next/playercontrol";
+import { MovementType } from "@babylonjs-toolkit/next/movementtype";
+import { CollisionContact } from "@babylonjs-toolkit/next/collisioncontact";
+import { BlendTreePosition } from "@babylonjs-toolkit/next/blendtreeposition";
+```
+
+### 4. Analyze Your Bundle
+Use your bundler's analysis tools to verify tree-shaking:
+```bash
+# Vite bundle analysis
+npm run build -- --mode production
+
+# Webpack bundle analyzer
+npm install --save-dev webpack-bundle-analyzer
+```

package/lib/blendtreeposition.d.ts

@@ -0,0 +1,5 @@
+export declare enum BlendTreePosition {
+    Lower = 0,
+    Upper = 1
+}
+//# sourceMappingURL=blendtreeposition.d.ts.map

package/lib/blendtreeposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendtreeposition.d.ts","sourceRoot":"","sources":["../src/blendtreeposition.ts"],"names":[],"mappings":"AACA,oBAAY,iBAAiB;IACrB,KAAK,IAAI;IACT,KAAK,IAAI;CACZ"}

package/lib/blendtreeposition.js

@@ -0,0 +1,5 @@
+export var BlendTreePosition;
+(function (BlendTreePosition) {
+    BlendTreePosition[BlendTreePosition["Lower"] = 0] = "Lower";
+    BlendTreePosition[BlendTreePosition["Upper"] = 1] = "Upper";
+})(BlendTreePosition || (BlendTreePosition = {}));

package/lib/channelmixerplugin.d.ts

@@ -0,0 +1,11 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { PostProcess } from '@babylonjs/core';
+export declare class ChannelMixerPlugin {
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        red?: number[];
+        green?: number[];
+        blue?: number[];
+    }): PostProcess;
+}
+//# sourceMappingURL=channelmixerplugin.d.ts.map

package/lib/channelmixerplugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channelmixerplugin.d.ts","sourceRoot":"","sources":["../src/channelmixerplugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,qBAAa,kBAAkB;WAKT,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QACpE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAClB;CAiCJ"}

package/lib/channelmixerplugin.js

@@ -0,0 +1,34 @@
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { PostProcess } from '@babylonjs/core';
+export class ChannelMixerPlugin {
+    static CreatePostProcess(scene, camera, options) {
+        const opts = options || {};
+        const red = opts.red || [1, 0, 0];
+        const green = opts.green || [0, 1, 0];
+        const blue = opts.blue || [0, 0, 1];
+        const fragment = `
+                precision highp float;
+                varying vec2 vUV;
+                uniform sampler2D textureSampler;
+                uniform vec3 redMix;
+                uniform vec3 greenMix;
+                uniform vec3 blueMix;
+
+                void main(void) {
+                    vec4 sceneColor = texture2D(textureSampler, vUV);
+                    vec3 rgb = sceneColor.rgb;
+                    float newR = dot(rgb, redMix);
+                    float newG = dot(rgb, greenMix);
+                    float newB = dot(rgb, blueMix);
+                    gl_FragColor = vec4(newR, newG, newB, sceneColor.a);
+                }
+            `;
+        const post = new PostProcess("channelMixer", fragment, ["redMix", "greenMix", "blueMix"], [], 1.0, camera, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false);
+        post.onApply = (effect) => {
+            effect.setFloat3('redMix', red[0] || 1, red[1] || 0, red[2] || 0);
+            effect.setFloat3('greenMix', green[0] || 0, green[1] || 1, green[2] || 0);
+            effect.setFloat3('blueMix', blue[0] || 0, blue[1] || 0, blue[2] || 1);
+        };
+        return post;
+    }
+}

package/lib/collisioncontact.d.ts

@@ -0,0 +1,7 @@
+export declare enum CollisionContact {
+    Top = 0,
+    Left = 1,
+    Right = 2,
+    Bottom = 3
+}
+//# sourceMappingURL=collisioncontact.d.ts.map

package/lib/collisioncontact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collisioncontact.d.ts","sourceRoot":"","sources":["../src/collisioncontact.ts"],"names":[],"mappings":"AACA,oBAAY,gBAAgB;IACpB,GAAG,IAAI;IACP,IAAI,IAAI;IACR,KAAK,IAAI;IACT,MAAM,IAAI;CACb"}

package/lib/collisioncontact.js

@@ -0,0 +1,7 @@
+export var CollisionContact;
+(function (CollisionContact) {
+    CollisionContact[CollisionContact["Top"] = 0] = "Top";
+    CollisionContact[CollisionContact["Left"] = 1] = "Left";
+    CollisionContact[CollisionContact["Right"] = 2] = "Right";
+    CollisionContact[CollisionContact["Bottom"] = 3] = "Bottom";
+})(CollisionContact || (CollisionContact = {}));

package/lib/collisionfilters.d.ts

@@ -0,0 +1,10 @@
+export declare enum CollisionFilters {
+    DefaultFilter = 1,
+    StaticFilter = 2,
+    KinematicFilter = 4,
+    DebrisFilter = 8,
+    SensorTrigger = 16,
+    CharacterFilter = 32,
+    AllFilter = -1
+}
+//# sourceMappingURL=collisionfilters.d.ts.map

package/lib/collisionfilters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collisionfilters.d.ts","sourceRoot":"","sources":["../src/collisionfilters.ts"],"names":[],"mappings":"AACA,oBAAY,gBAAgB;IACpB,aAAa,IAAI;IACjB,YAAY,IAAI;IAChB,eAAe,IAAI;IACnB,YAAY,IAAI;IAChB,aAAa,KAAK;IAClB,eAAe,KAAK;IACpB,SAAS,KAAK;CACjB"}

package/lib/collisionfilters.js

@@ -0,0 +1,10 @@
+export var CollisionFilters;
+(function (CollisionFilters) {
+    CollisionFilters[CollisionFilters["DefaultFilter"] = 1] = "DefaultFilter";
+    CollisionFilters[CollisionFilters["StaticFilter"] = 2] = "StaticFilter";
+    CollisionFilters[CollisionFilters["KinematicFilter"] = 4] = "KinematicFilter";
+    CollisionFilters[CollisionFilters["DebrisFilter"] = 8] = "DebrisFilter";
+    CollisionFilters[CollisionFilters["SensorTrigger"] = 16] = "SensorTrigger";
+    CollisionFilters[CollisionFilters["CharacterFilter"] = 32] = "CharacterFilter";
+    CollisionFilters[CollisionFilters["AllFilter"] = -1] = "AllFilter";
+})(CollisionFilters || (CollisionFilters = {}));

package/lib/collisionflags.d.ts

@@ -0,0 +1,14 @@
+export declare enum CollisionFlags {
+    CF_STATIC_OBJECT = 1,
+    CF_KINEMATIC_OBJECT = 2,
+    CF_NO_CONTACT_RESPONSE = 4,
+    CF_CUSTOM_MATERIAL_CALLBACK = 8,
+    CF_CHARACTER_OBJECT = 16,
+    CF_DISABLE_VISUALIZE_OBJECT = 32,
+    CF_DISABLE_SPU_COLLISION_PROCESSING = 64,
+    CF_HAS_CONTACT_STIFFNESS_DAMPING = 128,
+    CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256,
+    CF_HAS_FRICTION_ANCHOR = 512,
+    CF_HAS_COLLISION_SOUND_TRIGGER = 1024
+}
+//# sourceMappingURL=collisionflags.d.ts.map

package/lib/collisionflags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collisionflags.d.ts","sourceRoot":"","sources":["../src/collisionflags.ts"],"names":[],"mappings":"AACA,oBAAY,cAAc;IAClB,gBAAgB,IAAI;IACpB,mBAAmB,IAAI;IACvB,sBAAsB,IAAI;IAC1B,2BAA2B,IAAI;IAC/B,mBAAmB,KAAK;IACxB,2BAA2B,KAAK;IAChC,mCAAmC,KAAK;IACxC,gCAAgC,MAAM;IACtC,mCAAmC,MAAM;IACzC,sBAAsB,MAAM;IAC5B,8BAA8B,OAAO;CACxC"}

package/lib/collisionflags.js

@@ -0,0 +1,14 @@
+export var CollisionFlags;
+(function (CollisionFlags) {
+    CollisionFlags[CollisionFlags["CF_STATIC_OBJECT"] = 1] = "CF_STATIC_OBJECT";
+    CollisionFlags[CollisionFlags["CF_KINEMATIC_OBJECT"] = 2] = "CF_KINEMATIC_OBJECT";
+    CollisionFlags[CollisionFlags["CF_NO_CONTACT_RESPONSE"] = 4] = "CF_NO_CONTACT_RESPONSE";
+    CollisionFlags[CollisionFlags["CF_CUSTOM_MATERIAL_CALLBACK"] = 8] = "CF_CUSTOM_MATERIAL_CALLBACK";
+    CollisionFlags[CollisionFlags["CF_CHARACTER_OBJECT"] = 16] = "CF_CHARACTER_OBJECT";
+    CollisionFlags[CollisionFlags["CF_DISABLE_VISUALIZE_OBJECT"] = 32] = "CF_DISABLE_VISUALIZE_OBJECT";
+    CollisionFlags[CollisionFlags["CF_DISABLE_SPU_COLLISION_PROCESSING"] = 64] = "CF_DISABLE_SPU_COLLISION_PROCESSING";
+    CollisionFlags[CollisionFlags["CF_HAS_CONTACT_STIFFNESS_DAMPING"] = 128] = "CF_HAS_CONTACT_STIFFNESS_DAMPING";
+    CollisionFlags[CollisionFlags["CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR"] = 256] = "CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR";
+    CollisionFlags[CollisionFlags["CF_HAS_FRICTION_ANCHOR"] = 512] = "CF_HAS_FRICTION_ANCHOR";
+    CollisionFlags[CollisionFlags["CF_HAS_COLLISION_SOUND_TRIGGER"] = 1024] = "CF_HAS_COLLISION_SOUND_TRIGGER";
+})(CollisionFlags || (CollisionFlags = {}));

package/lib/collisionstate.d.ts

@@ -0,0 +1,8 @@
+export declare enum CollisionState {
+    ACTIVE_TAG = 1,
+    ISLAND_SLEEPING = 2,
+    WANTS_DEACTIVATION = 3,
+    DISABLE_DEACTIVATION = 4,
+    DISABLE_SIMULATION = 5
+}
+//# sourceMappingURL=collisionstate.d.ts.map

package/lib/collisionstate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collisionstate.d.ts","sourceRoot":"","sources":["../src/collisionstate.ts"],"names":[],"mappings":"AACA,oBAAY,cAAc;IAClB,UAAU,IAAI;IACd,eAAe,IAAI;IACnB,kBAAkB,IAAI;IACtB,oBAAoB,IAAI;IACxB,kBAAkB,IAAI;CACzB"}

package/lib/collisionstate.js

@@ -0,0 +1,8 @@
+export var CollisionState;
+(function (CollisionState) {
+    CollisionState[CollisionState["ACTIVE_TAG"] = 1] = "ACTIVE_TAG";
+    CollisionState[CollisionState["ISLAND_SLEEPING"] = 2] = "ISLAND_SLEEPING";
+    CollisionState[CollisionState["WANTS_DEACTIVATION"] = 3] = "WANTS_DEACTIVATION";
+    CollisionState[CollisionState["DISABLE_DEACTIVATION"] = 4] = "DISABLE_DEACTIVATION";
+    CollisionState[CollisionState["DISABLE_SIMULATION"] = 5] = "DISABLE_SIMULATION";
+})(CollisionState || (CollisionState = {}));

package/lib/customloadingscreen.d.ts

@@ -0,0 +1,16 @@
+import { ILoadingScreen } from '@babylonjs/core/Loading/loadingScreen';
+export declare class CustomLoadingScreen implements ILoadingScreen {
+    loadingDivId: string;
+    loadingUIText: string;
+    hideLoadingUIWithEngine: boolean;
+    customInnerHtml: string;
+    customInnerCss: string;
+    loadingUIBackgroundColor: string;
+    constructor(loadingDivId: string, loadingUIText: string, hideLoadingUIWithEngine?: boolean, customInnerHtml?: string, customInnerCss?: string);
+    displayLoadingUI(): void;
+    hideLoadingUI(): void;
+    showLoadingDiv(show: boolean): void;
+    getLoadingDiv(): HTMLDivElement;
+    hasLoadingDiv(): boolean;
+}
+//# sourceMappingURL=customloadingscreen.d.ts.map

package/lib/customloadingscreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customloadingscreen.d.ts","sourceRoot":"","sources":["../src/customloadingscreen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAGvE,qBAAa,mBAAoB,YAAW,cAAc;IAE/B,YAAY,EAAE,MAAM;IAAS,aAAa,EAAE,MAAM;IAAS,uBAAuB,EAAE,OAAO;IAAgB,eAAe,EAAE,MAAM;IAAgB,cAAc,EAAE,MAAM;IADpL,wBAAwB,EAAE,MAAM,CAAa;gBACjC,YAAY,EAAE,MAAM,EAAS,aAAa,EAAE,MAAM,EAAS,uBAAuB,GAAE,OAAc,EAAS,eAAe,GAAE,MAAa,EAAS,cAAc,GAAE,MAAa;IAQ3L,gBAAgB,IAAI,IAAI;IAkBxB,aAAa,IAAI,IAAI;IAKrB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAInC,aAAa,IAAI,cAAc;IAG/B,aAAa,IAAI,OAAO;CAGlC"}

package/lib/customloadingscreen.js

@@ -0,0 +1,48 @@
+export class CustomLoadingScreen {
+    constructor(loadingDivId, loadingUIText, hideLoadingUIWithEngine = true, customInnerHtml = null, customInnerCss = null) {
+        this.loadingDivId = loadingDivId;
+        this.loadingUIText = loadingUIText;
+        this.hideLoadingUIWithEngine = hideLoadingUIWithEngine;
+        this.customInnerHtml = customInnerHtml;
+        this.customInnerCss = customInnerCss;
+        this.loadingUIBackgroundColor = "#000000";
+        if (this.loadingDivId == null || this.loadingDivId === "") {
+            this.loadingDivId = "customLoadingScreen";
+        }
+        if (this.loadingUIText == null || this.loadingUIText === "") {
+            this.loadingUIText = "Please Wait";
+        }
+    }
+    displayLoadingUI() {
+        if (this.hasLoadingDiv()) {
+            this.showLoadingDiv(true);
+            return;
+        }
+        const defaultLoadingScreenCss = "";
+        const customLoadingScreenCss = document.createElement("style");
+        customLoadingScreenCss.type = "text/css";
+        customLoadingScreenCss.innerHTML = (this.customInnerCss || defaultLoadingScreenCss);
+        document.getElementsByTagName("head")[0].appendChild(customLoadingScreenCss);
+        const defaultLoadingScreenDiv = this.loadingUIText;
+        const customLoadingScreenDiv = document.createElement("div");
+        customLoadingScreenDiv.id = this.loadingDivId;
+        customLoadingScreenDiv.innerHTML = (this.customInnerHtml || defaultLoadingScreenDiv);
+        document.body.appendChild(customLoadingScreenDiv);
+    }
+    hideLoadingUI() {
+        if (this.hideLoadingUIWithEngine === true) {
+            this.showLoadingDiv(false);
+        }
+    }
+    showLoadingDiv(show) {
+        const loadingDiv = this.getLoadingDiv();
+        if (loadingDiv != null)
+            loadingDiv.style.display = (show) ? "initial" : "none";
+    }
+    getLoadingDiv() {
+        return document.getElementById(this.loadingDivId);
+    }
+    hasLoadingDiv() {
+        return (document.getElementById(this.loadingDivId) != null);
+    }
+}

package/lib/entitycontroller.d.ts

@@ -0,0 +1,11 @@
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+export declare class EntityController {
+    static HasNetworkEntity(transform: TransformNode): boolean;
+    static GetNetworkEntityId(transform: TransformNode): string;
+    static GetNetworkEntityType(transform: TransformNode): number;
+    static GetNetworkEntitySessionId(transform: TransformNode): string;
+    static QueryNetworkAttribute(transform: TransformNode, key: string): string;
+    static QueryBufferedAttribute(transform: TransformNode, index: number): number;
+    static PostBufferedAttribute(transform: TransformNode, index: number, value: number): void;
+}
+//# sourceMappingURL=entitycontroller.d.ts.map

package/lib/entitycontroller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entitycontroller.d.ts","sourceRoot":"","sources":["../src/entitycontroller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAErE,qBAAa,gBAAgB;WAEP,gBAAgB,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO;WAKnD,kBAAkB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM;WAKpD,oBAAoB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM;WAKtD,yBAAyB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM;WAK3D,qBAAqB,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;WAQpE,sBAAsB,CAAC,SAAS,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;WAQvE,qBAAqB,CAAC,SAAS,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAIpG"}

package/lib/entitycontroller.js

@@ -0,0 +1,41 @@
+export class EntityController {
+    static HasNetworkEntity(transform) {
+        if (transform == null)
+            return false;
+        return (transform.networkEntity != null);
+    }
+    static GetNetworkEntityId(transform) {
+        if (transform == null)
+            return null;
+        return (transform.networkEntity != null) ? transform.networkEntity.id : null;
+    }
+    static GetNetworkEntityType(transform) {
+        if (transform == null)
+            return 0;
+        return (transform.networkEntityType != null) ? transform.networkEntityType : 0;
+    }
+    static GetNetworkEntitySessionId(transform) {
+        if (transform == null)
+            return null;
+        return (transform.networkEntity != null) ? transform.networkEntity.ownerId : null;
+    }
+    static QueryNetworkAttribute(transform, key) {
+        let result = null;
+        if (transform != null && transform.networkEntity != null && transform.networkEntity.attributes != null) {
+            result = transform.networkEntity.attributes.get(key);
+        }
+        return result;
+    }
+    static QueryBufferedAttribute(transform, index) {
+        let result = 0;
+        if (transform != null && transform.networkEntityAttributeBuffer != null) {
+            result = transform.networkEntityAttributeBuffer[index.toFixed(0)];
+        }
+        return result;
+    }
+    static PostBufferedAttribute(transform, index, value) {
+        if (transform.networkEntityBatch == null)
+            transform.networkEntityBatch = {};
+        transform.networkEntityBatch[index.toFixed(0)] = value;
+    }
+}

package/lib/fontmanifestentry.d.ts

@@ -0,0 +1,8 @@
+export interface FontManifestEntry {
+    family: string;
+    style: string;
+    weight: string;
+    path: string;
+    fileName: string;
+}
+//# sourceMappingURL=fontmanifestentry.d.ts.map

package/lib/fontmanifestentry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontmanifestentry.d.ts","sourceRoot":"","sources":["../src/fontmanifestentry.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,iBAAiB;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACpB"}

package/lib/fontmanifestentry.js

@@ -0,0 +1 @@
+export {};

package/lib/handedness.d.ts

@@ -0,0 +1,6 @@
+export declare enum Handedness {
+    Default = -1,
+    Right = 0,
+    Left = 1
+}
+//# sourceMappingURL=handedness.d.ts.map

package/lib/handedness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handedness.d.ts","sourceRoot":"","sources":["../src/handedness.ts"],"names":[],"mappings":"AACA,oBAAY,UAAU;IACd,OAAO,KAAK;IACZ,KAAK,IAAI;IACT,IAAI,IAAI;CACX"}