Matrix4x4.MultiplyPoint3x4

Description

Transforms a position by this matrix (fast).

Returns a position v transformed by the current transformation matrix. This function is a faster version of MultiplyPoint; but it can only handle regular 3D transformations. MultiplyPoint is slower, but can handle projective transformations as well. See Also: MultiplyPoint, MultiplyVector.

	// 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 ExampleClass : 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

public class ExampleClass(MonoBehaviour):

	public rotAngle as float

	public stretch as float

	private mf as MeshFilter

	private origVerts as (Vector3)

	private newVerts as (Vector3)

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

	def Update() as void:
		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