// Stretch a mesh at an arbitrary angle around the X axis.
    
    // Angle and amount of stretching.
    var rotAngle: float;
    var stretch: float;
    
    
    private var mf: MeshFilter;
    private var origVerts: Vector3[];
    private var newVerts: Vector3[];
    
    
    function Start () {
        // Get the Mesh Filter component, save its original vertices
        // and make a new vertex array for processing.
        mf = GetComponent.<MeshFilter>();
        origVerts = mf.mesh.vertices;
        newVerts = new Vector3[origVerts.Length];
    }
    
    
    function Update () {
        // Create a rotation matrix from a Quaternion.
        var rot = Quaternion.Euler(rotAngle, 0, 0);
        var m = Matrix4x4.TRS(Vector3.zero, rot, Vector3.one);
        
        // Get the inverse of the matrix (ie, to undo the rotation).
        var inv = m.inverse;
        
        // For each vertex...
        for (var i = 0; i < origVerts.Length; i++) {
            // Rotate the vertex and scale it along its new Y axis.
            var pt = m.MultiplyPoint3x4(origVerts[i]);
            pt.y *= stretch;
            
            // Return the vertex to its original rotation (but with the
            // scaling still applied).
            newVerts[i] = inv.MultiplyPoint3x4(pt);
        }
        
        // Copy the transformed vertices back to the mesh.
        mf.mesh.vertices = newVerts;
    }

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float rotAngle;
    public float stretch;
    private MeshFilter mf;
    private Vector3[] origVerts;
    private Vector3[] newVerts;
    void Start() {
        mf = GetComponent<MeshFilter>();
        origVerts = mf.mesh.vertices;
        newVerts = new Vector3[origVerts.Length];
    }
    void Update() {
        Quaternion rot = Quaternion.Euler(rotAngle, 0, 0);
        Matrix4x4 m = Matrix4x4.TRS(Vector3.zero, rot, Vector3.one);
        Matrix4x4 inv = m.inverse;
        int i = 0;
        while (i < origVerts.Length) {
            Vector3 pt = m.MultiplyPoint3x4(origVerts[i]);
            pt.y *= stretch;
            newVerts[i] = inv.MultiplyPoint3x4(pt);
            i++;
        }
        mf.mesh.vertices = newVerts;
    }
}

import UnityEngine
import System.Collections

class example(MonoBehaviour):

    public rotAngle as single

    public stretch as single

    private mf as MeshFilter

    private origVerts as (Vector3)

    private newVerts as (Vector3)

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

    def Update():
        rot as Quaternion = Quaternion.Euler(rotAngle, 0, 0)
        m as Matrix4x4 = Matrix4x4.TRS(Vector3.zero, rot, Vector3.one)
        inv as Matrix4x4 = m.inverse
        i as int = 0
        while i < origVerts.Length:
            pt as Vector3 = m.MultiplyPoint3x4(origVerts[i])
            pt.y *= stretch
            newVerts[i] = inv.MultiplyPoint3x4(pt)
            i++
        mf.mesh.vertices = newVerts