Refactored OpenGL embedder that works on Android, Mac or Linux.

samples/simplegl/web/raytrace.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This sample is based upon the Ray Tracer sample by Jonas Sicking at:
 // http://www.khronos.org/webgl/wiki/Demo_Repository
 
 /**
  * A sample GL application.
  */
 library raytrace;
 
 import 'gl.dart';
 import 'dart:math' as Math;
 
+// Note: The first line of the fragment shader ("precision mediump float")
+// is not portable. It is required for WebGL and OpenGL ES. Desktop OpenGL
+// does not use precision specifiers. Some desktop systems treat this as a
+// no-op and some treat it as a syntax error. In particular, this line needs
+// to be removed to this this shader on a MAc.
 const FRAGMENT_PROGRAM = """
   precision mediump float;
 
   const vec3 lightDir = vec3(0.577350269, 0.577350269, -0.577350269);
   varying vec3 vPosition;
   uniform vec3 cameraPos;
   uniform vec3 sphere1Center;
   uniform vec3 sphere2Center;
   uniform vec3 sphere3Center;
 
@@ skipping 122 matching lines @@
     vPosition = aPlotPosition;
  }
 """;
 
 loadShader(final type, final program) {
   final shader = gl.createShader(type);
   gl.shaderSource(shader, program);
   gl.compileShader(shader);
   if (gl.getShaderParameter(shader, WebGLRenderingContext.COMPILE_STATUS) != true) {
     final error = gl.getShaderInfoLog(shader);
+    log(error);
     throw new Exception("Shader compilation error: $error");
   }
 
   return shader;
 }
 
 var shaderProgram;
 var aVertexPosition;
 var aPlotPosition;
 var cameraPos;
 var sphere1Center;
 var sphere2Center;
 var sphere3Center;
 var ratio;
 
 void initShaders() {
-  var vertexShader = loadShader(WebGLRenderingContext.VERTEX_SHADER, VERTEX_PROGRAM);
-  var fragmentShader = loadShader(WebGLRenderingContext.FRAGMENT_SHADER, FRAGMENT_PROGRAM);
+  var vertexShader = loadShader(WebGLRenderingContext.VERTEX_SHADER,
+      VERTEX_PROGRAM);
+  var fragmentShader = loadShader(WebGLRenderingContext.FRAGMENT_SHADER,
+      FRAGMENT_PROGRAM);
 
   shaderProgram = gl.createProgram();
   if (shaderProgram == 0) {
     throw new Exception("Could not create program.");
   }
 
   gl.attachShader(shaderProgram, vertexShader);
   gl.attachShader(shaderProgram, fragmentShader);
   gl.linkProgram(shaderProgram);
 
   if (gl.getProgramParameter(shaderProgram, WebGLRenderingContext.LINK_STATUS) != true) {
     final error = gl.getProgramInfoLog(shaderProgram);
     throw new Exception("Program compilation error: $error");
   }
 
   gl.useProgram(shaderProgram);
 
   aVertexPosition = gl.getAttribLocation(shaderProgram, "aVertexPosition");
   gl.enableVertexAttribArray(aVertexPosition);
 
   aPlotPosition = gl.getAttribLocation(shaderProgram, "aPlotPosition");
   gl.enableVertexAttribArray(aPlotPosition);
 
   cameraPos = gl.getUniformLocation(shaderProgram, "cameraPos");
   sphere1Center = gl.getUniformLocation(shaderProgram, "sphere1Center");
   sphere2Center = gl.getUniformLocation(shaderProgram, "sphere2Center");
   sphere3Center = gl.getUniformLocation(shaderProgram, "sphere3Center");
 }
 
+// TODO(gram): This should go away at some point. For now it is a kludge
+// to allow us to run same .dart file with WebGL and natively; the WebGL
+// version will set this to true.
+var wrapVertexArray = false;
+
+wrapVertices(a) => wrapVertexArray ? (new Float32Array.fromList(a)) : a;
+
 void initBuffers() {
   var vertexPositionBuffer = gl.createBuffer();
   gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, vertexPositionBuffer);
   var vertices = [
       1.0,  1.0,
       -1.0,  1.0,
       1.0, -1.0,
       -1.0, -1.0,
       ];
 
-  gl.bufferData(WebGLRenderingContext.ARRAY_BUFFER, new Float32Array.fromList(vertices), WebGLRenderingContext.STATIC_DRAW);
-  gl.vertexAttribPointer(aVertexPosition, 2, WebGLRenderingContext.FLOAT, false, 0, 0);
+  gl.bufferData(WebGLRenderingContext.ARRAY_BUFFER, wrapVertices(vertices),
+      WebGLRenderingContext.STATIC_DRAW);
+  gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, vertexPositionBuffer);
+  gl.vertexAttribPointer(aVertexPosition, 2, WebGLRenderingContext.FLOAT,
+      false,0, 0);
 
   var plotPositionBuffer = gl.createBuffer();
   gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, plotPositionBuffer);
-  gl.vertexAttribPointer(aPlotPosition, 3, WebGLRenderingContext.FLOAT, false, 0, 0);
+  gl.vertexAttribPointer(aPlotPosition, 3, WebGLRenderingContext.FLOAT,
+      false, 0, 0);
 }
 
 class Vector {
   var x;
   var y;
   var z;
-
   Vector(this.x, this.y, this.z);
 }
 
+// TODO(gram): This should be using vector_math.
 crossProd(v1, v2) =>
     new Vector(v1.y*v2.z - v2.y*v1.z,
                v1.z*v2.x - v2.z*v1.x,
                v1.x*v2.y - v2.x*v1.y);
 
 Vector normalize(v) {
   var l = 1 / Math.sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
   return new Vector( v.x*l, v.y*l, v.z*l );
 }
 
@@ skipping 37 matching lines @@
   // cameraCenter + cameraUp + cameraLeft * ratio
   var cameraTopLeft  = vectAdd(vectAdd(cameraCenter, cameraUp),
              vectMul(cameraLeft, ratio));
   var cameraBotLeft  = vectAdd(vectSub(cameraCenter, cameraUp),
              vectMul(cameraLeft, ratio));
   var cameraTopRight = vectSub(vectAdd(cameraCenter, cameraUp),
              vectMul(cameraLeft, ratio));
   var cameraBotRight = vectSub(vectSub(cameraCenter, cameraUp),
              vectMul(cameraLeft, ratio));
 
-  // corners = [1.2, 1, -12, -1.2, 1, -12, 1.2, -1, -12, -1.2, -1, -12];
   var corners = [];
   pushVec(cameraTopRight, corners);
   pushVec(cameraTopLeft, corners);
   pushVec(cameraBotRight, corners);
   pushVec(cameraBotLeft, corners);
-  var cornersArray = new Float32Array.fromList(corners);
-  gl.bufferData(WebGLRenderingContext.ARRAY_BUFFER, cornersArray,
+
+  gl.bufferData(WebGLRenderingContext.ARRAY_BUFFER, wrapVertices(corners),
       WebGLRenderingContext.STATIC_DRAW);
 
   gl.uniform3f(cameraPos, cameraFrom.x, cameraFrom.y, cameraFrom.z);
   gl.uniform3f(sphere1Center, x1, y1, z1);
   gl.uniform3f(sphere2Center, x2, y2, z2);
   gl.uniform3f(sphere3Center, x3, y3, z3);
 
   gl.drawArrays(WebGLRenderingContext.TRIANGLE_STRIP, 0, 4);
 
   t += 0.03;
   if (t > Math.PI * 200) {
     t -= Math.PI * 200;
   }
 }
 
-void setup() {
+void setup(int width, int height) {
   initShaders();
   gl.clearColor(0.0, 0.0, 0.0, 1.0);
   gl.clearDepth(1.0);
   initBuffers();
+  resize(width, height);
 }
 
 void resize(int width, int height) {
   ratio = width / height;
   gl.viewport(0, 0, width, height);
   t -= 0.03;
   drawScene();
 }
 
-void draw() {
+void update() {
   drawScene();
 }
+
+/*
+TODO(gram): below are the current entry points for input events for the
+native code version. We need to integrate these somehow with the WebGL
+version:
+
+onMotionDown(num when, num x, num y) {}
+onMotionUp(num when, num x, num y) {}
+onMotionMove(num when, num x, num y) {}
+onMotionCancel(num when, num x, num y) {}
+onMotionOutside(num when, num x, num y) {}
+onMotionPointerDown(num when, num x, num y) {}
+onMotionPointerUp(num when, num x, num y) {}
+onKeyDown(num when, int flags, int keycode, int metastate, int repeat) {}
+onKeyUp(num when, int flags, int keycode, int metastate, int repeat) {}
+onKeyMultiple(num when, int flags, int keycode, int metastate, int repeat) {
+}
+*/
+