'use strict';

var Scene = function() {
        this.canvas = createCanvas();
        this.gl = createContext(this.canvas, 'webgl2', {
            antialias: false
        });

        this.renderer = new Renderer(this.gl);

        this.debugger = false;

        this.keys = {};
        document.addEventListener('keydown', (e) = > {
            e.preventDefault();
            var key = e.key.toLowerCase()
            this.keys[key] = true;
        });
        document.addEventListener('keyup', (e) = > {
            if (this.keys['f1']) this.debugger = !this.debugger;
            e.preventDefault();
            delete this.keys[e.key.toLowerCase()];
        });
    };

Scene.prototype.load = function(callback) {
    var me = this;

    // Load shaders
    async.parallel({
        ShaderCode: function(callback) {
            async.map({
                'vertex': './shaders/vertex.glsl',
                'fragment': './shaders/fragment.glsl'
            }, loadTextResource, callback);
        }
    }, function(loadErrors, loadResults) {
        if (loadErrors) {
            callback(loadErrors);
            return;
        }

        // Create shader program
        //
        me.shader = CreateShaderProgram(me.gl, loadResults.ShaderCode[0], loadResults.ShaderCode[1]);
        if (me.shader.error) {
            callback(me.shader.error);
            return;
        }
        me.shader.uniforms = {
            matLoc: me.gl.getUniformLocation(me.shader, 'mat'),
            projLoc: me.gl.getUniformLocation(me.shader, 'proj'),
            viewLoc: me.gl.getUniformLocation(me.shader, 'view'),
            colorLoc: me.gl.getUniformLocation(me.shader, 'color'),
        };
        me.shader.attribs = {
            positionLoc: me.gl.getAttribLocation(me.shader, 'position')
        };

        // Matrices
        //
        me.proj = m4.perspective(90, me.canvas.width / me.canvas.height, 0.1, 100.0);

        me.camera = new Camera([0, 0, -5], [0, 0, 1], [0, 1, 0]);
        me.view = me.camera.updateView();

        me.gl.enableVertexAttribArray(me.shader.attribs.vPosition);
        me.gl.vertexAttribPointer(me.shader.attribs.vPosition, 3, me.gl.FLOAT, me.gl.FALSE, 0, 0);
        me.gl.enable(me.gl.DEPTH_TEST);

        callback();
    });
};


// Update scene
//
Scene.prototype.update = function(dt, gui) {
    var me = this;
    // Update canvas
    updateCanvas(me.canvas);
    // Update proj/camera matrix
    me.proj = m4.perspective(me.camera.zoom, me.canvas.width / me.canvas.height, me.camera.znear, me.camera.zfar);
    me.view = me.camera.updateView(dt);

    // Update octree
    if (me.camera.isMoving > .9) me.voxel.updateChunks(me.camera.position, me.camera.zfar);

    this.renderer.update();
    // Render scene
    me.render(gui);
};

// Renderer
//
Scene.prototype.render = function(gui) {
    var gl = this.gl;
    var me = this;

    if (me.camera.isMoving > 0) {
        gui.position = me.camera.position;
        gui.isMoving = me.camera.isMoving;
    }



    // Clear buffer
    gl.viewport(0, 0, me.canvas.width, me.canvas.height);
    gl.clearColor(1.0, 1.0, 0, 1.0);
    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

    // Setup shader uniforms
    gl.useProgram(me.shader);
    gl.uniformMatrix4fv(me.shader.uniforms.projLoc, gl.FALSE, me.proj);
    gl.uniformMatrix4fv(me.shader.uniforms.viewLoc, gl.FALSE, me.view);

    gui.elements = 0;
    gui.cubes = 0;

    me.drawLine([0, 0, 0], [1, 1, 1]);


};

Scene.prototype.drawLine = function(start, end) {
    var me = this;
    var gl = me.gl;

    var vertices = [];
    vertices.push(start[0]);
    vertices.push(start[1]);
    vertices.push(start[2]);

    vertices.push(end[0]);
    vertices.push(end[1]);
    vertices.push(end[2]);

    var vbo = gl.createBuffer();
    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);

    var mat = m4.create(); // Default identity matrix
    gl.uniformMatrix4fv(me.shader.uniforms.matLoc, gl.FALSE, mat);
    gl.uniform4fv(me.shader.uniforms.colorLoc, [1, 0, 0, 1]);
    gl.drawArrays(gl.POINTS, 0, 3);
}

Setting Validate Copy Format

///VERT
precision highp float;

attribute vec3 position;

uniform mat4 proj;
uniform mat4 view;
uniform mat4 mat;

uniform vec4 color;
varying vec4 vColor;

void main()
{
  vColor = color;
  gl_Position = proj * view * mat * vec4(position, 1.0);
}

// FRAG
precision highp float;

varying vec4 vColor;

void main()
{
  gl_FragColor = vColor;
}

Setting Validate Copy Format