
Static batching allows the engine to reduce draw calls for geometry of any size, provided it shares the same material and does not move. It is often more efficient than dynamic batching (it does not transform vertices on the CPU), but it uses more memory.

In order to take advantage of static batching, you need to explicitly specify that certain game objects are **static** and do not move, rotate or scale in the game. To do so, set the game object to the **Babylon Static** layer.

Please refer to the [Unity Layer](https://docs.unity3d.com/Manual/Layers.html) documentation for details.

## Babylon Static Layer

![Static Layer](/img/exporters/unity/staticlayer.webp)

The static batching layer can prepare your objects to take advantage of the toolkit's static batching export. This step is a useful performance optimization that allows the engine to reduce the number of draw calls dramatically while keeping the amount of rendered geometry intact.

By setting game objects to the **Babylon Static** layer, you create internal meshes at export time that contain combined geometry. This allows game objects to remain separate pieces at design time, making it easy to place and move static geometry. You can also use the **Geometry Tools** to pre-bake and combine meshes at design time. Any pre-baked meshes will no longer be separate movable meshes during game development.

Game objects with the same material will be batched together, so it is useful to share as many textures and materials as you can. **Texture Atlas** support is also included in the toolkit to help improve rendering performance.



The process of creating a navigation mesh from the level geometry is called **NavMesh Baking**. It collects the **Render Meshes** and **Terrains** of all game objects marked as Navigation Static, then processes them to create a navigation mesh that approximates the walkable surfaces of the level. Please refer to the [Unity Navigation](https://docs.unity3d.com/Manual/nav-Overview.html) documentation for details.

In Unity, navigation mesh generation is handled from the _ **Navigation** _ window (Menu: **Window > Navigation**).

Building a navigation mesh for your scene can be done in four quick steps. Please refer to the [Unity Navigation Mesh](https://docs.unity3d.com/Manual/nav-BuildingNavMesh.html) documentation for details.

## Babylon Navigation Mesh

The [Babylon Navigation Mesh](https://github.com/wanadev/babylon-navigation-mesh) extension is a pathfinding tool for AI agents. It uses the **A Star** and **Funnel** algorithms to calculate a path on the exported baked navigation mesh and is packaged as a toolkit plugin.

## Managed Runtime Support

The toolkit scene manager provides easy-to-use helper functions for client-side navigation:

```javascript no-code-variants
    declare module BABYLON {
        class SceneManager {

            /** Gets the native babylon mesh navigation tool */
            getNavigationTool(): Navigation;

            /** Gets the current navigation zone */
            getNavigationZone(): string;

            /** Finds a navigation path and returns a array of navigation positions */
            findNavigationPath(origin: BABYLON.Vector3, destination: BABYLON.Vector3): BABYLON.Vector3[];

            /** Gets true if the scene has a navigation mesh */
            hasNavigationMesh(): boolean;

            /** Returns the current scene's navigation mesh */
            getNavigationMesh(): BABYLON.AbstractMesh;

            /** Builds the current scene's navigation nodes */
            buildNavigationMesh(mesh: BABYLON.AbstractMesh): any;

            /** Returns a picked navigation point */
            getNavigationPoint(position: BABYLON.Vector3, raise?: number, length?: number): BABYLON.Vector3;

            /** Moves the specified navigation again along a path of positions */
            moveNavigationAgent(agent: BABYLON.AbstractMesh, path: BABYLON.Vector3[], speed?: number, loop?: boolean, callback?: () => void): void;

            /** Returns an array of navigation agents */
            getNavigationAgents(): BABYLON.Mesh[];

            /** Returns the specfied navigation agent info */
            getNavigationAgentInfo(agent: BABYLON.AbstractMesh): BABYLON.NavigationAgent;

            /** Returns the current scene's navigation area table */
            getNavigationAreaTable(): BABYLON.INavigationArea[];

            /** Returns the current scene's navigation area indexes */
            getNavigationAreaIndexes(): number[];

            /** Returns the current scene's navigation area names */
            getNavigationAreaName(index: number): string;

            /** Returns the current scene's navigation area cost */
            getNavigationAreaCost(index: number): number;
        }
    }
```

Example **Navigation Mesh** script component:

```javascript no-code-variants
    module PROJECT {
        export class NavMeshComponent extends BABYLON.MeshComponent {
            private navmesh:BABYLON.AbstractMesh = null;
            public constructor(owner: BABYLON.AbstractMesh, scene: BABYLON.Scene, tick: boolean = true, propertyBag: any = {}) {
                super(owner, scene, tick, propertyBag);
            }
            protected start() :void {
                this.navmesh = this.manager.getNavigationMesh();
                if (this.navmesh) {
                    const minimoi = BABYLON.MeshBuilder.CreateBox("MiniMoi", {size: 0.5}, this.scene);
                    minimoi.material = new BABYLON.StandardMaterial("MoiMaterial", this.scene);
                    (<BABYLON.StandardMaterial>minimoi.material).diffuseColor = new BABYLON.Color3(1., 0., 0);
                    minimoi.position = new BABYLON.Vector3(0, 0.25, 0);

                    // Setup point and click demo navigation
                    const canvas = document.getElementById("cvs");
                    canvas.addEventListener('click', (evt)=> {
                        const pickingInfo = this.scene.pick(this.scene.pointerX, this.scene.pointerY, (mesh) => { return (mesh === this.navmesh); });
                        if (pickingInfo.hit) {
                            const navpoint = pickingInfo.pickedPoint;
                            const path = this.manager.findNavigationPath(minimoi.position, navpoint);
                            if (path != null) {
                                this.manager.moveNavigationAgent(minimoi, path, 5.0);
                            }
                        }
                    });
                }
            }
        }
    }
```



It is convenient to build a game object in the scene by adding components and setting their properties to the appropriate values. This can create problems, however, when you have an object like an NPC, prop, or piece of scenery that is reused several times in the scene. Simply copying the object will certainly produce duplicates, but they will all be independently editable. Generally, you want all instances of a particular object to have the same properties, so when you edit one object in the scene, you would prefer not to make the same edit repeatedly to all the copies.

Fortunately, Unity has a Prefab asset type that allows you to store a game object complete with components and properties. The prefab acts as a template from which you can create new object instances in the scene. Any edits made to a prefab asset are immediately reflected in all instances produced from it, but you can also override components and settings for each instance individually.

**Note:** When you drag an asset file (e.g., a Mesh) into the scene, it creates a new object instance, and all such instances will change when the original asset is changed. However, although its behavior is superficially similar, the asset is not a prefab, so you won’t be able to add components to it or make use of the other prefab features described below.

Check out the [Unity Prefab Concept Video](https://unity3d.com/learn/tutorials/topics/interface-essentials/prefabs-concept-usage) for details on prefab usage.

## Unity Prefab System

## Using Runtime Prefabs

You can create a prefab by selecting **Asset > Create Prefab** and then dragging an object from the scene onto the “empty” prefab asset that appears. If you then drag a different game object onto the prefab you will be asked if you want to replace your current game object with the new one. Simply dragging the prefab asset from the project view to the scene view will then create instances of the prefab. Objects created as prefab instances will be shown in the hierarchy view in blue text. (Normal objects are shown in black text.)

As mentioned above, changes to the prefab asset itself will be reflected in all instances, but you can also modify individual instances separately. This is useful, for example, when you want to create several similar NPCs but introduce variations to make them more realistic. To make it clear when a property has been overridden, it is shown in the inspector with its name label in boldface. (When a completely new component is added to a prefab instance, all of its properties will be shown in boldface.)

![Prefab Override](https://docs.unity3d.com/uploads/Main/PrefabsAddedObjectIndicator1.png)

You can also create instances of prefabs at runtime from your scripts. See the **Managed Runtime Support** section for further details.

## Editing Runtime Prefabs

The inspector for a prefab instance has three buttons not present for a normal object: **Select**, **Revert** and **Apply**.

The **Select** button selects the prefab asset from which the instance was generated. This allows you to edit the main prefab and thereby change all its instances. However, you can also save overridden values from an instance back to the originating prefab using the **Apply** button (modified transform position values are excluded for obvious reasons). This effectively lets you edit all instances, except those that override the changed value, through any single instance and is a very quick and convenient way to make global changes.

If you experiment with overriding properties but then decide you preferred the default values, you can use the **Revert** button to realign the instance with its prefab.

## Babylon Prefab Layer

![Prefab Layer](/img/exporters/unity/prefablayer.webp)

The prefab layer can prepare your objects to take advantage of the toolkit's deep cloning to instantiate game object prefabs at runtime. This step is required to use _ **Unity Style Prefabs** _ in a web browser environment. Web games cannot directly instantiate a prefab from disk, so game objects intended for use as runtime prefabs must be present but disabled in the scene.

By setting game objects to the **Babylon Prefab** layer, you create disabled source meshes used for deep cloning when you call the scene manager instantiate prefab function.

## Managed Runtime Support

The toolkit scene manager provides easy-to-use helper functions for client-side prefab instantiation:

```javascript
    declare module BABYLON {
        class SceneManager {

            /** Checks the scene has the specified prefab mesh. */
            hasPrefabMesh(prefabName: string): boolean;

            /** Gets ths the raw prefab mesh from scene. */
            getPrefabMesh(prefabName: string): BABYLON.Mesh;

            /** Instantiates the specfied prefab object into scene. */
            instantiatePrefab(prefabName: string, cloneName: string, newPosition?: BABYLON.Vector3, newRotation?: BABYLON.Vector3, newScaling?: BABYLON.Vector3, newParent?: Node): BABYLON.Mesh;
        }
    }
```

Example **Runtime Prefab** script component:

```javascript no-code-variants
    module PROJECT {
        export class TestMeshComponent extends BABYLON.MeshComponent {
            public constructor(owner: BABYLON.AbstractMesh, scene: BABYLON.Scene, tick: boolean = true, propertyBag: any = {}) {
                super(owner, scene, tick, propertyBag);
            }
            protected start() :void {

                // Spawn player game object
                const player:BABYLON.Mesh = this.manager.instantiatePrefab("Player", "NewPlayer", BABYLON.Vector3.Zero());
                console.log("Echo Player: " + player.name);
            }
        }
    }

```


Static Batching

Babylon Static Layer