How to use the babylonjs.Vector3.Zero function in babylonjs

public init() {
        // Not sure why a camera is needed on the server side...
        var camera = new ArcRotateCamera("Camera", 0, 0.8, 100, Vector3.Zero(), this.scene);

        // Important to first enable physics before creating any mesh
        const OIMO = require("oimo");
        this.scene.enablePhysics(new Vector3(0, -20, 0), new OimoJSPlugin(undefined, OIMO));

        // Creat mesh objects
        this.area.init();

        this.scene.executeWhenReady(() => {
            this.engine.runRenderLoop(() => {
                this.scene.render();
            });

            // Update to clients in fixed interval
            setInterval(() => {
                Object.keys(this.playerObjs).forEach((key) => {

protected resetToOriginal (): void {
        const m = this.object['metadata'].original;
        
        // Common
        this.object.loop = m.loop;
        this.object.setVolume(m.volume);
        this.object.rolloffFactor = m.rolloffFactor;
        this.object.setPlaybackRate(m.playbackRate);
        this.object.spatialSound = m.spatialSound;

        // Spatial
        if (!m.connectedMeshId) {
            this.object.detachFromMesh();
            this.object.setPosition(Vector3.Zero());
            this.editor.graph.setParent(this.object['id'], this.editor.graph.root);
        } else {
            const mesh = this.editor.core.scene.getMeshByID(m.connectedMeshId);
            if (mesh) {
                this.object.attachToMesh(mesh);
                this.object.setPosition(Vector3.FromArray(m.position));
                this.editor.graph.setParent(this.object['id'], mesh.id);
            }
        }

        // Update
        setTimeout(() => {
            Tags.RemoveTagsFrom(this.object, 'modified');
            this.editor.graph.updateObjectMark(this.object);
        }, 1);

import { Sound, Vector3, Tags } from 'babylonjs';

import AbstractEditionTool from './edition-tool';
import Tools from '../tools/tools';
import Picker from '../gui/picker';

export default class SoundTool extends AbstractEditionTool {
    // Public members
    public divId: string = 'SOUND-TOOL';
    public tabName: string = 'Sound';

    // Private members
    private _volume: number = 0;
    private _playbackRate: number = 0;
    private _rolloffFactor: number = 0;
    private _position: Vector3 = Vector3.Zero();
    private _time: number = 0;

	/**
	* Returns if the object is supported
	* @param object the object selected in the graph
	*/
    public isSupported(object: any): boolean {
        return object instanceof Sound;
    }

	/**
	* Updates the edition tool
	* @param object the object selected in the graph
	*/
    public update(sound: Sound): void {
        super.update(sound);

public static async CreatePreview (d: AssetElement, engine: Engine): Promise {
        const serialization = SceneSerializer.SerializeMesh(d.data.sourceMesh, false, true);
        const file = Tools.CreateFile(Tools.ConvertStringToUInt8Array(JSON.stringify(serialization)), d.name + '.babylon');
        const canvas = engine.getRenderingCanvas();

        const scene = new Scene(engine);
        scene.clearColor.set(0, 0, 0, 1);

        const camera = new FreeCamera('PrefabAssetCamera', Vector3.Zero(), scene);
        const light = new PointLight('PrefabAssetLight', Vector3.Zero(), scene);

        await SceneLoader.AppendAsync('file:', file, scene, () => engine.hideLoadingUI());
        await new Promise((resolve) => {
            engine.runRenderLoop(() => {
                scene.render();
                
                if (scene.getWaitingItemsCount() === 0) {
                    // Find camera position
                    let boundingInfo = d.data.sourceMesh.getBoundingInfo();
                    const descendants = d.data.sourceMesh.getDescendants();

                    descendants.forEach(d => {
                        if (!(d instanceof AbstractMesh))
                            return;
                        
                        d.getBoundingInfo().update(d.getWorldMatrix());

private createCamera() {
        this.camera = new ArcRotateCamera("Camera", 0, Math.PI / 2, 12, Vector3.Zero(), this.scene);
        this.camera.attachControl(this, false);

        this.camera.lowerRadiusLimit = 6;
        this.camera.upperRadiusLimit = 6;
        this.camera.minZ = 1;
    }

vertex: "custom",
                fragment: "custom",
            },
            {
                attributes: ["position", "normal", "uv"],
                uniforms: ["world", "worldView", "worldViewProjection", "view", "projection"]
            });

        const mesh = Mesh.CreatePlane("mesh", 10.0, this.scene);
        mesh.rotate(Axis.Y, Math.PI * .5);

        const refTexture = new Texture("http://i.imgur.com/HP1V7TJ.png", this.scene);

        shaderMaterial.setTexture("refSampler", refTexture);
        shaderMaterial.setFloat("time", 0);
        shaderMaterial.setVector3("cameraPosition", Vector3.Zero());

        shaderMaterial.backFaceCulling = false;

        mesh.material = shaderMaterial;

        let time = 0;

        this.scene.registerBeforeRender(() => {

            shaderMaterial.setFloat("time", time);
            time += 0.02;

            shaderMaterial.setVector3("cameraPosition", this.scene.activeCamera!.position);
        });
    }
}

return (
      <div>
        <div>
          <div>'pointer over' boombox to see mesh</div>
          <div>
            Move Avocado: 
            <button></button>
            &nbsp;&nbsp;
            <button></button>
          </div>
        </div>
        <div>
          <div>
            
              
                
                
                
                

                
              
            
          </div>
          <div>
            <pre>                </pre></div></div></div>

addCamera() {
    this._camera = new FreeCamera(
      'FreeCamera',
      new Vector3(0, 4, -24),
      this.scene
    );
    this._camera.setTarget(new Vector3(0, 1, 0));
    this._camera.inputs.attached.mouse.detachControl();
    this._camera.setTarget(Vector3.Zero());
  }

vertex: "custom",
                fragment: "custom",
            },
            {
                attributes: ["position", "normal", "uv"],
                uniforms: ["world", "worldView", "worldViewProjection", "view", "projection"]
            });

        const mesh = Mesh.CreatePlane("mesh", 10.0, this.scene);
        mesh.rotate(Axis.Y, Math.PI * .5);

        const refTexture = new Texture("http://i.imgur.com/HP1V7TJ.png", this.scene);

        shaderMaterial.setTexture("refSampler", refTexture);
        shaderMaterial.setFloat("time", 0);
        shaderMaterial.setVector3("cameraPosition", Vector3.Zero());

        shaderMaterial.backFaceCulling = false;

        mesh.material = shaderMaterial;

        let time = 0;

        this.scene.registerBeforeRender(() => {

            shaderMaterial.setFloat("time", time);
            time += 0.02;

            shaderMaterial.setVector3("cameraPosition", this.scene.activeCamera!.position);
        });
    }
}