// Create a texture and fill it with Perlin noise.
    // Try varying the xOrg, yOrg and scale values in the inspector
    // while in Play mode to see the effect they have on the noise.
    
    // Width and height of the texture in pixels.
    var pixWidth: int;
    var pixHeight: int;
    
    // The origin of the sampled area in the plane.
    var xOrg: float;
    var yOrg: float;
    
    // The number of cycles of the basic noise pattern that are repeated
    // over the width and height of the texture.
    var scale = 1.0;
    
    
    private var noiseTex: Texture2D;
    private var pix: Color[];
    
    
    function Start () {
        // Set up the texture and a Color array to hold pixels during processing.
        noiseTex = new Texture2D(pixWidth, pixHeight);
        pix = new Color[noiseTex.width * noiseTex.height];
        renderer.material.mainTexture = noiseTex;
    }
    
    
    function CalcNoise() {
        // For each pixel in the texture...
        for (var y = 0.0; y < noiseTex.height; y++) {
            for (var x = 0.0; x < noiseTex.width; x++) {
                // Get a sample from the corresponding position in the noise plane
                // and create a greyscale pixel from it.
                var xCoord = xOrg + x / noiseTex.width * scale;
                var yCoord = yOrg + y / noiseTex.height * scale;
                var sample = Mathf.PerlinNoise(xCoord, yCoord);
                pix[y * noiseTex.width + x] = new Color(sample, sample, sample);
            }
        }
        
        // Copy the pixel data to the texture and load it into the GPU.
        noiseTex.SetPixels(pix);
        noiseTex.Apply();
    }
    
    
    function Update () {
        CalcNoise();
    }

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public int pixWidth;
    public int pixHeight;
    public float xOrg;
    public float yOrg;
    public float scale = 1.0F;
    private Texture2D noiseTex;
    private Color[] pix;
    void Start() {
        noiseTex = new Texture2D(pixWidth, pixHeight);
        pix = new Color[noiseTex.width * noiseTex.height];
        renderer.material.mainTexture = noiseTex;
    }
    void CalcNoise() {
        float y = 0.0F;
        while (y < noiseTex.height) {
            float x = 0.0F;
            while (x < noiseTex.width) {
                float xCoord = xOrg + x / noiseTex.width * scale;
                float yCoord = yOrg + y / noiseTex.height * scale;
                float sample = Mathf.PerlinNoise(xCoord, yCoord);
                pix[y * noiseTex.width + x] = new Color(sample, sample, sample);
                x++;
            }
            y++;
        }
        noiseTex.SetPixels(pix);
        noiseTex.Apply();
    }
    void Update() {
        CalcNoise();
    }
}

import UnityEngine
import System.Collections

class example(MonoBehaviour):

    public pixWidth as int

    public pixHeight as int

    public xOrg as single

    public yOrg as single

    public scale as single = 1.0F

    private noiseTex as Texture2D

    private pix as (Color)

    def Start():
        noiseTex = Texture2D(pixWidth, pixHeight)
        pix = array[of Color]((noiseTex.width * noiseTex.height))
        renderer.material.mainTexture = noiseTex

    def CalcNoise():
        y as single = 0.0F
        while y < noiseTex.height:
            x as single = 0.0F
            while x < noiseTex.width:
                xCoord as single = (xOrg + ((x / noiseTex.width) * scale))
                yCoord as single = (yOrg + ((y / noiseTex.height) * scale))
                sample as single = Mathf.PerlinNoise(xCoord, yCoord)
                pix[((y * noiseTex.width) + x)] = Color(sample, sample, sample)
                x++
            y++
        noiseTex.SetPixels(pix)
        noiseTex.Apply()

    def Update():
        CalcNoise()

    // "Bobbing" animation from 1D Perlin noise.
    
    // Range over which height varies.
    var heightScale = 1.0;
    
    // Distance covered per second along X axis of Perlin plane.
    var xScale = 1.0;
    
    
    function Update () {
        var height = heightScale * Mathf.PerlinNoise(Time.time * xScale, 0.0);
        var pos = transform.position;
        pos.y = height;
        transform.position = pos;
    }

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float heightScale = 1.0F;
    public float xScale = 1.0F;
    void Update() {
        float height = heightScale * Mathf.PerlinNoise(Time.time * xScale, 0.0F);
        Vector3 pos = transform.position;
        pos.y = height;
        transform.position = pos;
    }
}

import UnityEngine
import System.Collections

class example(MonoBehaviour):

    public heightScale as single = 1.0F

    public xScale as single = 1.0F

    def Update():
        height as single = (heightScale * Mathf.PerlinNoise((Time.time * xScale), 0.0F))
        pos as Vector3 = transform.position
        pos.y = height
        transform.position = pos