function webGLStart() {
        var canvas = document.getElementById("lesson09-canvas");
        initGL(canvas);
        initShaders();
        initBuffers();
        initTexture();
        initWorldObjects();
 
        gl.clearColor(0.0, 0.0, 0.0, 1.0);
 
        document.onkeydown = handleKeyDown;
        document.onkeyup = handleKeyUp;
 
        tick();
    }

    gl.enable(gl.DEPTH_TEST);

    function Animate() {
        var timeNow = new Date().getTime();
        if (lastTime != 0) {
            var elapsed = timeNow - lastTime;
 
            for (var i in stars) {
                stars[i].Animate(elapsed);
            }
        }
        lastTime = timeNow;
 
    }

    function drawScene() {
        gl.viewport(0, 0, gl.viewportWidth, gl.viewportHeight);
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
        pMatrix = okMat4Proj(45, gl.viewportWidth / gl.viewportHeight, 0.1, 100.0);

        gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
        gl.enable(gl.BLEND);

        mvMatrix = okMat4Trans(0.0, 0.0, zoom); 
        mvMatrix.rotX(OAK.SPACE_LOCAL, tilt, true);

        var twinkle = document.getElementById("twinkle").checked;

        for (var i in stars) {
            stars[i].draw(tilt, spin, twinkle);
            spin += 0.1;
        }
 
    }

    var stars = [];
 
    function initWorldObjects() {
        var numStars = 50;
 
        for (var i=0; i < numStars; i++) {
            stars.push(new Star((i / numStars) * 5.0, i / numStars));
        }
    }

    function Star(startingDistance, rotationSpeed) {
        this.angle = 0;
        this.dist = startingDistance;
        this.rotationSpeed = rotationSpeed;
 
        // Set the colors to a starting value.
        this.randomiseColors();
    }

    Star.prototype.draw = function (tilt, spin, twinkle) {
        mvPushMatrix();

        // Move to the star's position
        mvMatrix.rotY(OAK.SPACE_LOCAL, this.angle, true);
        mvMatrix.translate(OAK.SPACE_LOCAL, this.dist, 0.0, 0.0, true);

        // Rotate back so that the star is facing the viewer
        mvMatrix.rotY(OAK.SPACE_LOCAL, -this.angle, true);        
        mvMatrix.rotX(OAK.SPACE_LOCAL, -tilt, true);

        if (twinkle) {
            // Draw a non-rotating star in the alternate "twinkling" color
            gl.uniform3f(shaderProgram.colorUniform, this.twinkleR, 
this.twinkleG, this.twinkleB);
            drawStar();
        }
 
        // All stars spin around the Z axis at the same rate
        mvMatrix.rotZ(OAK.SPACE_LOCAL, spin);
 
        // Draw the star in its main color
        gl.uniform3f(shaderProgram.colorUniform, this.r, this.g, this.b);
        drawStar();

        mvPopMatrix();
    };

    var effectiveFPMS = 60 / 1000;
    Star.prototype.Animate = function (elapsedTime) {

        this.angle += this.rotationSpeed * effectiveFPMS * elapsedTime;

        // Decrease the distance, resetting the star to the outside of
        // the spiral if it's at the center.
        this.dist -= 0.01 * effectiveFPMS * elapsedTime;
        if (this.dist < 0.0) {
            this.dist += 5.0;
            this.randomiseColors();
        }
 
    };

    Star.prototype.randomiseColors = function () {
        // Give the star a random color for normal
        // circumstances...
        this.r = Math.random();
        this.g = Math.random();
        this.b = Math.random();
 
        // When the star is twinkling, we draw it twice, once
        // in the color below (not spinning) and then once in the
        // main color defined above.
        this.twinkleR = Math.random();
        this.twinkleG = Math.random();
        this.twinkleB = Math.random();
    };

    function drawStar() {
        gl.activeTexture(gl.TEXTURE0);
        gl.bindTexture(gl.TEXTURE_2D, starTexture);
        gl.uniform1i(shaderProgram.samplerUniform, 0);
 
        gl.bindBuffer(gl.ARRAY_BUFFER, starVertexTextureCoordBuffer);
        gl.vertexAttribPointer(shaderProgram.textureCoordAttribute, 
starVertexTextureCoordBuffer.itemSize, gl.FLOAT, false, 0, 0);
 
        gl.bindBuffer(gl.ARRAY_BUFFER, starVertexPositionBuffer);
        gl.vertexAttribPointer(shaderProgram.vertexPositionAttribute, 
starVertexPositionBuffer.itemSize, gl.FLOAT, false, 0, 0);
 
        setMatrixUniforms();
        gl.drawArrays(gl.TRIANGLE_STRIP, 0, starVertexPositionBuffer.numItems);
    }

 
    precision mediump float;
 
 
    varying vec2 vTextureCoord;
 
    uniform sampler2D uSampler;
 
    uniform vec3 uColor;
 
    void main(void) {
        vec4 textureColor = texture2D(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));
        gl_FragColor = textureColor * vec4(uColor, 1.0);
    }