initial commit

Author: Evan Wallace

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+lightgl.js

LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Evan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,56 @@
+# lightgl.js
+
+This library makes it easier to quickly prototype WebGL applications. It's lower level than many other WebGL libraries and while it doesn't provide a scene graph, it re-implements OpenGL's modelview/projection matrix stack to provide similar functionality. It also re-introduces some built-in uniforms from GLSL, including `gl_Vertex` and `gl_ModelViewProjectionMatrix`.
+
+## Building Library
+
+* `python build.py`: build `lightgl.js` from the files in the `src` directory
+* `python build.py debug`: rebuild the library any time the contents of the `src` directory change
+* `python build.py release`: minify the library using Google Closure Compiler, which assumes there is a `closure` command in your path that runs `compiler.jar`
+
+## Sample Code
+
+    <script src="lightgl.js"></script>
+    <script>
+
+    var mesh;
+    var shader;
+    var angle = 0;
+
+    function setup() {
+        document.body.appendChild(gl.canvas);
+        gl.clearColor(0, 0, 0, 1);
+        gl.matrixMode(gl.PROJECTION);
+        gl.loadIdentity();
+        gl.perspective(45, gl.canvas.width / gl.canvas.height, 0.01, 100);
+        gl.matrixMode(gl.MODELVIEW);
+        mesh = Mesh.plane(1, 1, 5, 5);
+        shader = new Shader('\
+            void main() {\
+                gl_Position = gl_ModelViewProjectionMatrix * vec4(gl_Vertex, 1.0);\
+            }\
+        ', '\
+            void main() {\
+                gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\
+            }\
+        ');
+    }
+
+    function update(seconds) {
+        angle += 45 * seconds;
+    }
+
+    function draw() {
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.loadIdentity();
+        gl.translate(0, 0, -5);
+        gl.rotate(30, 1, 0, 0);
+        gl.rotate(angle, 0, 1, 0);
+
+        gl.pushMatrix();
+        gl.rotate(-90, 1, 0, 0);
+        shader.draw(mesh);
+        gl.popMatrix();
+    }
+
+    </script>

build.py

@@ -0,0 +1,68 @@
+#!/usr/bin/python
+
+input_path = 'src/'
+output_path = 'lightgl.js'
+
+import re, os, sys, time, tempfile
+
+header = '''/*
+ * lightgl.js
+ * http://github.com/evanw/lightgl.js/
+ *
+ * Copyright 2011 Evan Wallace
+ * Released under the MIT license
+ */
+'''
+
+def sources():
+    return [os.path.join(base, f) for base, folders, files in \
+        os.walk(input_path) for f in files if f.endswith('.js')]
+
+def compile(sources):
+    return '\n'.join('// %s\n%s' % (path, open(path).read()) for path in sources)
+
+def compress_glsl(text):
+    def compress(match):
+        text = match.group(0)
+        if '  ' in text: # assume all strings with two consecutive spaces are glsl
+            text = re.sub('/\*.*?\*/', '', text) # remove all comments
+            text = re.sub(' +', ' ', text) # replace consecutive spaces with one space
+            text = re.sub(r' ?(\+|\-|\*|/|,|=|{|}|;|\(|\)|<|>|!|\'|\") ?', r'\1', text) # tighten spaces around some tokens
+        return text
+
+    text = re.sub(r"('([^'\\]|\\(.|\n))*'|\"([^\"\\]|\\(.|\n))*\")", compress, text) # replace all strings
+    return text
+
+def build():
+    data = '(function() {\n\n%s\n})();\n' % compile(sources())
+    if 'release' in sys.argv:
+        f1, temp1_path = tempfile.mkstemp()
+        f2, temp2_path = tempfile.mkstemp()
+        os.write(f1, data)
+        os.close(f1)
+        os.close(f2)
+        os.system('closure --js %s --js_output_file %s' % (temp1_path, temp2_path))
+        os.remove(temp1_path)
+        data = open(temp2_path).read()
+        os.remove(temp2_path)
+        data = compress_glsl(data)
+    data = header + data
+    open(output_path, 'w').write(data)
+    print 'built %s (%u lines)' % (output_path, len(data.split('\n')))
+
+def stat():
+    return [os.stat(file).st_mtime for file in sources()]
+
+def monitor():
+    a = stat()
+    while True:
+        time.sleep(0.5)
+        b = stat()
+        if a != b:
+            a = b
+            build()
+
+if __name__ == '__main__':
+    build()
+    if 'debug' in sys.argv:
+        monitor()

src/main.js

@@ -0,0 +1,127 @@
+window.onload = function() {
+    // Set up WebGL
+    var canvas = document.createElement('canvas');
+    canvas.width = 800;
+    canvas.height = 600;
+    try { gl = canvas.getContext('webgl'); } catch (e) {}
+    try { gl = gl || canvas.getContext('experimental-webgl'); } catch (e) {}
+    if (!gl) throw 'WebGL not supported';
+
+    // Add custom enums
+    var ENUM = 0x12340000;
+    gl.MODELVIEW = ENUM | 1;
+    gl.PROJECTION = ENUM | 2;
+
+    // Add matrix funcitons
+    gl.modelviewMatrix = new Matrix();
+    gl.projectionMatrix = new Matrix();
+    var modelviewStack = [];
+    var projectionStack = [];
+    var matrix, stack;
+    gl.matrixMode = function(mode) {
+        switch (mode) {
+        case gl.MODELVIEW:
+            matrix = gl.modelviewMatrix;
+            stack = modelviewStack;
+            break;
+        case gl.PROJECTION:
+            matrix = gl.projectionMatrix;
+            stack = projectionStack;
+            break;
+        default:
+            throw 'invalid matrix mode ' + mode;
+        }
+    };
+    gl.loadIdentity = function() {
+        matrix.m = new Matrix().m;
+    };
+    gl.perspective = function(fov, aspect, near, far) {
+        var y = Math.tan(fov * Math.PI / 360) * near;
+        var x = y * aspect;
+        gl.frustum(-x, x, -y, y, near, far);
+    };
+    gl.frustum = function(l, r, b, t, n, f) {
+        matrix.concat(
+            2*n/(r-l), 0, (r+l)/(r-l), 0,
+            0, 2*n/(t-b), (t+b)/(t-b), 0,
+            0, 0, -(f+n)/(f-n), -2*f*n/(f-n),
+            0, 0, -1, 0
+        );
+    };
+    gl.ortho = function(l, r, b, t, n, f) {
+        matrix.concat(
+            2/(r-l), 0, 0, (r+l)/(r-l),
+            0, 2/(t-b), 0, (t+b)/(t-b),
+            0, 0, -2/(f-n), (f+n)/(f-n),
+            0, 0, 0, 1
+        );
+    };
+    gl.scale = function(x, y, z) {
+        matrix.concat(
+            x, 0, 0, 0,
+            0, y, 0, 0,
+            0, 0, z, 0,
+            0, 0, 0, 1
+        );
+    };
+    gl.translate = function(x, y, z) {
+        matrix.concat(
+            1, 0, 0, x,
+            0, 1, 0, y,
+            0, 0, 1, z,
+            0, 0, 0, 1
+        );
+    };
+    gl.rotate = function(a, x, y, z) {
+        if (a && (x || y || z)) {
+            var d = Math.sqrt(x*x + y*y + z*z);
+            a *= Math.PI / 180; x /= d; y /= d; z /= d;
+            var c = Math.cos(a), s = Math.sin(a), t = 1 - c;
+            matrix.concat(
+                x*x*t+c, x*y*t-z*s, x*z*t+y*s, 0,
+                y*x*t+z*s, y*y*t+c, y*z*t-x*s, 0,
+                z*x*t-y*s, z*y*t+x*s, z*z*t+c, 0,
+                0, 0, 0, 1
+            );
+        }
+    };
+    gl.lookAt = function(ex, ey, ez, cx, cy, cz, ux, uy, uz) {
+        var e = new Vector(ex, ey, ez);
+        var c = new Vector(cx, cy, cz);
+        var u = new Vector(ux, uy, uz);
+        var f = e.subtract(c).unit();
+        var s = u.cross(f).unit();
+        var t = f.cross(s).unit();
+        matrix.concat(
+            s.x, s.y, s.z, -s.dot(e),
+            t.x, t.y, t.z, -t.dot(e),
+            f.x, f.y, f.z, -f.dot(e),
+            0, 0, 0, 1
+        );
+    };
+    gl.pushMatrix = function() {
+        stack.push(Array.prototype.slice.call(matrix.m));
+    };
+    gl.popMatrix = function() {
+        matrix.m = stack.pop();
+    };
+    gl.matrixMode(gl.MODELVIEW);
+
+    // Set up the animation loop
+    var post =
+        window.webkitRequestAnimationFrame ||
+        window.mozRequestAnimationFrame ||
+        function(callback) { setTimeout(callback, 1000 / 60); };
+    var time = new Date();
+    function frame() {
+        var now = new Date();
+        if (window.update) window.update((now - time) / 1000);
+        time = now;
+        if (window.draw) window.draw();
+        post(frame);
+    }
+
+    // Draw the initial frame and start the animation loop
+    if (window.setup) window.setup();
+    frame();
+};

src/matrix.js

@@ -0,0 +1,42 @@
+Matrix = function() {
+    this.m = Array.prototype.concat.apply([], arguments);
+    if (!this.m.length) {
+        this.m = [
+            1, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1
+        ];
+    }
+};
+
+Matrix.prototype.multiply = function(matrix) {
+    var a = this.m, b = matrix.m;
+    return new Matrix(
+        a[0] * b[0] + a[1] * b[4] + a[2] * b[8] + a[3] * b[12],
+        a[0] * b[1] + a[1] * b[5] + a[2] * b[9] + a[3] * b[13],
+        a[0] * b[2] + a[1] * b[6] + a[2] * b[10] + a[3] * b[14],
+        a[0] * b[3] + a[1] * b[7] + a[2] * b[11] + a[3] * b[15],
+
+        a[4] * b[0] + a[5] * b[4] + a[6] * b[8] + a[7] * b[12],
+        a[4] * b[1] + a[5] * b[5] + a[6] * b[9] + a[7] * b[13],
+        a[4] * b[2] + a[5] * b[6] + a[6] * b[10] + a[7] * b[14],
+        a[4] * b[3] + a[5] * b[7] + a[6] * b[11] + a[7] * b[15],
+
+        a[8] * b[0] + a[9] * b[4] + a[10] * b[8] + a[11] * b[12],
+        a[8] * b[1] + a[9] * b[5] + a[10] * b[9] + a[11] * b[13],
+        a[8] * b[2] + a[9] * b[6] + a[10] * b[10] + a[11] * b[14],
+        a[8] * b[3] + a[9] * b[7] + a[10] * b[11] + a[11] * b[15],
+
+        a[12] * b[0] + a[13] * b[4] + a[14] * b[8] + a[15] * b[12],
+        a[12] * b[1] + a[13] * b[5] + a[14] * b[9] + a[15] * b[13],
+        a[12] * b[2] + a[13] * b[6] + a[14] * b[10] + a[15] * b[14],
+        a[12] * b[3] + a[13] * b[7] + a[14] * b[11] + a[15] * b[15]
+    );
+};
+
+Matrix.prototype.concat = function() {
+    var m = {};
+    Matrix.apply(m, arguments);
+    this.m = this.multiply(m).m;
+};