// Mesh "stretch" effect along a chosen axis.
    
    // The axis and amount of scaling.
    var stretchAxis: Vector3;
    var stretchFactor = 1.0;
    
    // MeshFilter component and arrays for the original and transformed vertices.
    private var mf: MeshFilter;
    private var origVerts: Vector3[];
    private var newVerts: Vector3[];
    
    // Our new basis vectors.
    private var basisA: Vector3;
    private var basisB: Vector3;
    private var basisC: Vector3;
    
    
    function Start() {
        // Get the Mesh Filter, then make a copy of the original vertices
        // and a new array to calculate the transformed vertices.
        mf = GetComponent.<MeshFilter>();
        origVerts = mf.mesh.vertices;
        newVerts = new Vector3[origVerts.Length];
    }
    
    
    function Update() {
        // BasisA is just the specified axis for stretching - the
        // other two are just arbitrary axes generated by OrthoNormalize.
        basisA = stretchAxis;
        Vector3.OrthoNormalize(basisA, basisB, basisC);
        
        // Copy the three new basis vectors into the rows of a matrix
        // (since it is actually a 4x4 matrix, the bottom right corner
        // should also be set to 1).
        var toNewSpace: Matrix4x4 = new Matrix4x4();
        toNewSpace.SetRow(0, basisA);
        toNewSpace.SetRow(1, basisB);
        toNewSpace.SetRow(2, basisC);
        toNewSpace[3, 3] = 1.0;
        
        // The scale values are just the diagonal entries of the scale
        // matrix. The vertices should be stretched along the first axis
        // and squashed proportionally along the other two.
        var scale: Matrix4x4 = new Matrix4x4();
        scale[0, 0] = stretchFactor;
        scale[1, 1] = 1.0 / stretchFactor;
        scale[2, 2] = 1.0 / stretchFactor;
        scale[3, 3] = 1.0;
        
        // The inverse of the first matrix transforms the vertices back to
        // the original XYZ coordinate space(transpose is the same as inverse
        // for an orthogonal matrix, which this is).
        var fromNewSpace: Matrix4x4 = toNewSpace.transpose;
        
        // The three matrices can now be combined into a single symmetric matrix.
        var trans: Matrix4x4 = toNewSpace * scale * fromNewSpace;
        
        // Transform each of the mesh's vertices by the symmetric matrix.
        for (var i = 0; i < origVerts.Length; i++) {
            newVerts[i] = trans.MultiplyPoint3x4(origVerts[i]);
        }
        
        // ...and finally, update the mesh with the new vertex array.
        mf.mesh.vertices = newVerts;
    }

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Vector3 stretchAxis;
    public float stretchFactor = 1.0F;
    private MeshFilter mf;
    private Vector3[] origVerts;
    private Vector3[] newVerts;
    private Vector3 basisA;
    private Vector3 basisB;
    private Vector3 basisC;
    void Start() {
        mf = GetComponent<MeshFilter>();
        origVerts = mf.mesh.vertices;
        newVerts = new Vector3[origVerts.Length];
    }
    void Update() {
        basisA = stretchAxis;
        Vector3.OrthoNormalize(ref basisA, ref basisB, ref basisC);
        Matrix4x4 toNewSpace = new Matrix4x4();
        toNewSpace.SetRow(0, basisA);
        toNewSpace.SetRow(1, basisB);
        toNewSpace.SetRow(2, basisC);
        toNewSpace[3, 3] = 1.0F;
        Matrix4x4 scale = new Matrix4x4();
        scale[0, 0] = stretchFactor;
        scale[1, 1] = 1.0F / stretchFactor;
        scale[2, 2] = 1.0F / stretchFactor;
        scale[3, 3] = 1.0F;
        Matrix4x4 fromNewSpace = toNewSpace.transpose;
        Matrix4x4 trans = toNewSpace * scale * fromNewSpace;
        int i = 0;
        while (i < origVerts.Length) {
            newVerts[i] = trans.MultiplyPoint3x4(origVerts[i]);
            i++;
        }
        mf.mesh.vertices = newVerts;
    }
}

import UnityEngine
import System.Collections

class example(MonoBehaviour):

    public stretchAxis as Vector3

    public stretchFactor as single = 1.0F

    private mf as MeshFilter

    private origVerts as (Vector3)

    private newVerts as (Vector3)

    private basisA as Vector3

    private basisB as Vector3

    private basisC as Vector3

    def Start():
        mf = GetComponent[of MeshFilter]()
        origVerts = mf.mesh.vertices
        newVerts = array[of Vector3](origVerts.Length)

    def Update():
        basisA = stretchAxis
        Vector3.OrthoNormalize(basisA, basisB, basisC)
        toNewSpace as Matrix4x4 = Matrix4x4()
        toNewSpace.SetRow(0, basisA)
        toNewSpace.SetRow(1, basisB)
        toNewSpace.SetRow(2, basisC)
        toNewSpace[3, 3] = 1.0F
        scale as Matrix4x4 = Matrix4x4()
        scale[0, 0] = stretchFactor
        scale[1, 1] = (1.0F / stretchFactor)
        scale[2, 2] = (1.0F / stretchFactor)
        scale[3, 3] = 1.0F
        fromNewSpace as Matrix4x4 = toNewSpace.transpose
        trans as Matrix4x4 = ((toNewSpace * scale) * fromNewSpace)
        i as int = 0
        while i < origVerts.Length:
            newVerts[i] = trans.MultiplyPoint3x4(origVerts[i])
            i++
        mf.mesh.vertices = newVerts