package;

import lime.graphics.opengl.GLBuffer;
import lime.graphics.opengl.GLProgram;
import lime.graphics.opengl.GLShader;
import lime.graphics.GLRenderContext;
import lime.utils.Float32Array;
import lime.utils.GLUtils;
import openfl.display.OpenGLRenderer;
import openfl.display.Sprite;
import openfl.events.Event;
import openfl.events.RenderEvent;

class GLSprite extends Sprite {

    private var positionAttributeLocation:Int;
    private var positionBuffer:GLBuffer;
    private var glCurrentProgram:GLProgram;

    private var vertexShader:GLShader;
    private var fragmentShader:GLShader;

    private var inited:Bool = false;

    var tri:Float32Array;

    var vertexSource = "
        attribute vec2 a_position;

        void main (void) {
            gl_Position = vec4 (a_position, 0.0, 1.0);
        }

    ";

    var fragmentSource =
    #if (!desktop || rpi)
    "precision mediump float;"+
    #end
    "
        void main (void) {
            gl_FragColor = vec4 (1, 0, 0.5, 1);
        }
    ";

    public function new () {
        super ();
        addEventListener (RenderEvent.RENDER_OPENGL, render);
        addEventListener (Event.ENTER_FRAME, enterFrame);
    }

    /* INIT */

    private function initGL(gl:GLRenderContext) {
        //create shader
        glCurrentProgram = GLUtils.createProgram(vertexSource, fragmentSource);
        gl.useProgram(glCurrentProgram);

        positionAttributeLocation = gl.getAttribLocation(glCurrentProgram, "a_position");

        //create buffer
        positionBuffer = gl.createBuffer();

        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);

        tri = new Float32Array([100,100, 200,100, 200,100]);

        gl.bufferData(gl.ARRAY_BUFFER, Float32Array.BYTES_PER_ELEMENT*tri.length, tri, gl.STATIC_DRAW);

        gl.bindBuffer(gl.ARRAY_BUFFER, null);
    }

    /* UPDATE */

    public function enterFrame(event:Event):Void {
        invalidate();
    }

    public function render(event):Void {
        var renderer:OpenGLRenderer = cast event.renderer;
        var gl:GLRenderContext = renderer.gl;

        if (!inited) {
            inited = true;
            initGL(gl);
        }

        gl.useProgram(glCurrentProgram);

        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);

        gl.enableVertexAttribArray(positionAttributeLocation);
        gl.vertexAttribPointer(positionAttributeLocation, 2, gl.FLOAT, false, 0, 0);

        gl.blendFunc (gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
        gl.enable (gl.BLEND);
        gl.viewport (0, 0, 500, 500);

        gl.drawArrays(gl.TRIANGLES, 0, 1);

        gl.bindBuffer(gl.ARRAY_BUFFER, null);
    }
}