
## Draw an Arc Between Two Vectors

Given an origin O and two vectors OA and OB this snippet draws an arc between the two vectors with a given radius. The arc can be drawn in three types 0 (default) a solid line, 1 a dashed line, 2 filled between arc and vectors.

```javascript
function showAngleSector(origin, vector1, vector2, radius, sectorType) {
  radius = radius || 1;
  sectorType = sectorType || 0;
  const cross = BABYLON.Vector3.Cross(vector1, vector2);
  const dot = BABYLON.Vector3.Dot(vector1, vector2);
  const angle = Math.acos(dot / (vector1.length() * vector2.length()));
  const points = [];
  const minNb = 4;
  const factor = 2;
  let nbPoints = Math.floor(radius * angle * factor);
  nbPoints = nbPoints < minNb ? minNb : nbPoints;

  const firstPoint = BABYLON.Vector3.Normalize(vector1).scale(radius);
  const lastPoint = BABYLON.Vector3.Normalize(vector2).scale(radius);
  let matrix;
  let ang = angle / nbPoints;
  let rotated;
  for (let i = 0; i < nbPoints; i++) {
    matrix = BABYLON.Matrix.RotationAxis(cross, ang * i);
    rotated = BABYLON.Vector3.TransformCoordinates(firstPoint, matrix);
    points.push(rotated.add(origin));
  }
  points.push(lastPoint.add(origin));

  let sector;
  switch (sectorType) {
    case 0:
      sector = BABYLON.MeshBuilder.CreateLines("sector", { points }, scene);
      break;
    case 1:
      sector = BABYLON.Mesh.CreateDashedLines("sector", points, 3, 1, nbPoints, scene);
      break;
    case 2:
      const pointO = [];
      for (let j = 0; j < points.length; j++) {
        pointO.push(origin);
      }
      sector = BABYLON.Mesh.CreateRibbon("sector", [points, pointO], null, null, 0, scene);
      break;
    default:
      sector = BABYLON.MeshBuilder.CreateLines("sector", { points }, scene);
      break;
  }
  return sector;
}
```

## Playground

<Playground id="#FUK3S#8" title="Draw an Arc Between Two Vectors" description=""/>



## Spherical Panning for 360 Camera Rotation

This snippet shows a way to add spherical panning behavior to a scene.  The behavior is similar to the interactions from viewing 3D images on Facebook, Google Maps, etc.  The function contains several constants, such as INERTIA_DECAY_FACTOR, which can be tuned to customize the default feel of the interaction.

Note that this function uses quaternion math which is not available in Babylon.js v3.3.0 or earlier.

```javascript
var addSphericalPanningCameraToScene = function (scene, canvas) {
    // Set cursor to grab.
    scene.defaultCursor = "grab";

    // Add the actual camera to the scene.  Since we are going to be controlling it manually,
    // we don't attach any inputs directly to it.
    // NOTE: We position the camera at origin in this case, but it doesn't have to be there.
    // Spherical panning should work just fine regardless of the camera's position.
    var camera = new BABYLON.FreeCamera("camera", BABYLON.Vector3.Zero(), scene);

    // Ensure the camera's rotation quaternion is initialized correctly.
    camera.rotationQuaternion = BABYLON.Quaternion.Identity();

    // The spherical panning math has singularities at the poles (up and down) that cause
    // the orientation to seem to "flip."  This is undesirable, so this method helps reject
    // inputs that would cause this behavior.
    var isNewForwardVectorTooCloseToSingularity = v => {
        const TOO_CLOSE_TO_UP_THRESHOLD = 0.99;
        return Math.abs(BABYLON.Vector3.Dot(v, BABYLON.Vector3.Up())) > TOO_CLOSE_TO_UP_THRESHOLD;
    }

    // Local state variables which will be used in the spherical pan method; declared outside 
    // because they must persist from frame to frame.
    var ptrX = 0;
    var ptrY = 0;
    var inertiaX = 0;
    var inertiaY = 0;

    // Variables internal to spherical pan, declared here just to avoid reallocating them when
    // running.
    var priorDir = new BABYLON.Vector3();
    var currentDir = new BABYLON.Vector3();
    var rotationAxis = new BABYLON.Vector3();
    var rotationAngle = 0;
    var rotation = new BABYLON.Quaternion();
    var newForward = new BABYLON.Vector3();
    var newRight = new BABYLON.Vector3();
    var newUp = new BABYLON.Vector3();
    var matrix = new BABYLON.Matrix.Identity();

    // The core pan method.
    // Intuition: there exists a rotation of the camera that brings priorDir to currentDir.
    // By concatenating this rotation with the existing rotation of the camera, we can move
    // the camera so that the cursor appears to remain over the same point in the scene, 
    // creating the feeling of smooth and responsive 1-to-1 motion.
    var pan = (currX, currY) => {
        // Helper method to convert a screen point (in pixels) to a direction in view space.
        var getPointerViewSpaceDirectionToRef = (x, y, ref) => {
            BABYLON.Vector3.UnprojectToRef(
                new BABYLON.Vector3(x, y, 0), 
                canvas.width, 
                canvas.height,
                BABYLON.Matrix.Identity(),
                BABYLON.Matrix.Identity(), 
                camera.getProjectionMatrix(),
                ref);
            ref.normalize();
        }

        // Helper method that computes the new forward direction.  This was split into its own
        // function because, near the singularity, we may to do this twice in a single frame
        // in order to reject inputs that would bring the forward vector too close to vertical.
        var computeNewForward = (x, y) => {
            getPointerViewSpaceDirectionToRef(ptrX, ptrY, priorDir);
            getPointerViewSpaceDirectionToRef(x, y, currentDir);

            BABYLON.Vector3.CrossToRef(priorDir, currentDir, rotationAxis);

            // If the magnitude of the cross-product is zero, then the cursor has not moved
            // since the prior frame and there is no need to do anything.
            if (rotationAxis.lengthSquared() > 0) {
                rotationAngle = BABYLON.Vector3.GetAngleBetweenVectors(priorDir, currentDir, rotationAxis);
                BABYLON.Quaternion.RotationAxisToRef(rotationAxis, -rotationAngle, rotation);

                // Order matters here.  We create the new forward vector by applying the new rotation 
                // first, then apply the camera's existing rotation.  This is because, since the new
                // rotation is computed in view space, it only makes sense for a camera that is
                // facing forward.
                newForward.set(0, 0, 1);
                newForward.rotateByQuaternionToRef(rotation, newForward);
                newForward.rotateByQuaternionToRef(camera.rotationQuaternion, newForward);

                return !isNewForwardVectorTooCloseToSingularity(newForward);
            }

            return false;
        }

        // Compute the new forward vector first using the actual input, both X and Y.  If this results
        // in a forward vector that would be too close to the singularity, recompute using only the
        // new X input, repeating the Y input from the prior frame.  If either of these computations
        // succeeds, construct the new rotation matrix using the result.
        if (computeNewForward(currX, currY) || computeNewForward(currX, ptrY)) {
            // We manually compute the new right and up vectors to ensure that the camera 
            // only has pitch and yaw, never roll.  This dependency on the world-space
            // vertical axis is what causes the singularity described above.
            BABYLON.Vector3.CrossToRef(BABYLON.Vector3.Up(), newForward, newRight);
            BABYLON.Vector3.CrossToRef(newForward, newRight, newUp);

            // Create the new world-space rotation matrix from the computed forward, right, 
            // and up vectors.
            matrix.setRowFromFloats(0, newRight.x, newRight.y, newRight.z, 0);
            matrix.setRowFromFloats(1, newUp.x, newUp.y, newUp.z, 0);
            matrix.setRowFromFloats(2, newForward.x, newForward.y, newForward.z, 0);

            BABYLON.Quaternion.FromRotationMatrixToRef(matrix.getRotationMatrix(), camera.rotationQuaternion);
        }
    };

    // The main panning loop, to be run while the pointer is down.
    var sphericalPan = () => {
        pan(scene.pointerX, scene.pointerY);

        // Store the state variables for use in the next frame.
        inertiaX = scene.pointerX - ptrX;
        inertiaY = scene.pointerY - ptrY;
        ptrX = scene.pointerX;
        ptrY = scene.pointerY;
    }

    // The inertial panning loop, to be run after the pointer is released until inertia
    // runs out, or until the pointer goes down again, whichever happens first.  Essentially
    // just pretends to provide a decreasing amount of input based on the last observed input,
    // removing itself once the input becomes negligible.
    const INERTIA_DECAY_FACTOR = 0.9;
    const INERTIA_NEGLIGIBLE_THRESHOLD = 0.5;
    var inertialPanObserver;
    var inertialPan = () => {
        if (Math.abs(inertiaX) > INERTIA_NEGLIGIBLE_THRESHOLD || Math.abs(inertiaY) > INERTIA_NEGLIGIBLE_THRESHOLD) {
            pan(ptrX + inertiaX, ptrY + inertiaY);

            inertiaX *= INERTIA_DECAY_FACTOR;
            inertiaY *= INERTIA_DECAY_FACTOR;
        }
        else {
            scene.onBeforeRenderObservable.remove(inertialPanObserver);
        }
    };

    // Enable/disable spherical panning depending on click state.  Note that this is an 
    // extremely simplistic way to do this, so it gets a little janky on multi-touch.
    var sphericalPanObserver;
    var pointersDown = 0;
    scene.onPointerDown = () => {
        pointersDown += 1;
        if (pointersDown !== 1) {
            return;
        }

        // Disable inertial panning.
        scene.onBeforeRenderObservable.remove(inertialPanObserver);

        // Switch cursor to grabbing.
        scene.defaultCursor = "grabbing";

        // Store the current pointer position to clean out whatever values were left in
        // there from prior iterations.
        ptrX = scene.pointerX;
        ptrY = scene.pointerY;
        
        // Enable spherical panning.
        sphericalPanObserver = scene.onBeforeRenderObservable.add(sphericalPan);
    }
    scene.onPointerUp = () => {
        pointersDown -= 1;
        if (pointersDown !== 0) {
            return;
        }

        // Switch cursor to grab.
        scene.defaultCursor = "grab";

        // Disable spherical panning.
        scene.onBeforeRenderObservable.remove(sphericalPanObserver);

        // Enable inertial panning.
        inertialPanObserver = scene.onBeforeRenderObservable.add(inertialPan);
    }
};
```
## Playground

<Playground id="#21UPR3#30" title="Spherical Panning Camera" description=""/>


## Rotating and Enlarging Relative to a Centre.
The following two code snippets give the opportunity to place a centre of rotation or enlargement, or pivot, at any time and have a mesh rotate or enlarge relative to that centre.


## Rotate
 
```javascript
BABYLON.Mesh.prototype.rotateAroundPivot = function(pivotPoint, axis, angle) {
	if(!this._rotationQuaternion) {
		this._rq = BABYLON.Quaternion.RotationYawPitchRoll(this.rotation.y, this.rotation.x, this.rotation.z);
	}
	else this._rq = this.rotationQuaternion		
	var _p = new BABYLON.Quaternion(this.position.x - pivotPoint.x, this.position.y - pivotPoint.y, this.position.z - pivotPoint.z, 0);
	axis.normalize();
	var _q = BABYLON.Quaternion.RotationAxis(axis,angle);  //form quaternion rotation		
	var _qinv = BABYLON.Quaternion.Inverse(_q);	
	var _pdash = _q.multiply(_p).multiply(_qinv);
	this.position = new BABYLON.Vector3(pivotPoint.x + _pdash.x, pivotPoint.y + _pdash.y, pivotPoint.z + _pdash.z);
	this.rotationQuaternion = _q.multiply(this._rq);
}

mesh.rotateAroundPivot(new BABYLON.Vector3(1, 2, -1), new BABYLON.Axis.Y, Math.PI/4);
```

The parameters are the position of the pivot (centre of rotation) as a Vector3, axis of rotation as a Vector3 and an angle of rotation a number in radians.

Succesive rotations are accumulative.

## Enlargement

```javascript
BABYLON.Mesh.prototype.scaleFromPivot = function(pivotPoint, sx, sy, sz) {
	var _sx = sx / this.scaling.x;
	var _sy = sy / this.scaling.y;
	var _sz = sz / this.scaling.z;
	this.scaling = new BABYLON.Vector3(sx, sy, sz);	
	this.position = new BABYLON.Vector3(pivotPoint.x + _sx * (this.position.x - pivotPoint.x), pivotPoint.y + _sy * (this.position.y - pivotPoint.y), pivotPoint.z + _sz * (this.position.z - pivotPoint.z));
}

mesh.scaleFromPivotnew BABYLON.Vector3(1, 2, -1), 2, 6, 0.5);
```

The parameters are the position of the pivot (centre of enlargemen) as a Vector3, scaling in the x, y and z directions as numbers.

## Playground

<Playground id="#1MKHR9#254" title="Rotating and Enlarging Relative to a Centre" description=""/>


Draw a Sector of a Circle

Draw an Arc Between Two Vectors

Playground