Sync tutorials 01 to 04

Uses haxenme/nme#496

Author: madrazo

tutorial01_first_window/Source/Main.hx

@@ -7,21 +7,25 @@ import nme.Lib;
 
 
 class Main extends Sprite {
-    
-    
+
+
     public function new ()
     {        
         super ();
 
         var ogl = new OpenGLView();
+        addChild(ogl);
 
+        // Dark blue background: For NME, use "opaqueBackground" instead of "clearColor"
+        //GL.clearColor(0.0, 0.0, 0.4, 0.0);
+        nme.Lib.stage.opaqueBackground = 0x000066;
+	
         ogl.render = function(rect:Rectangle)
         {
- 			// Dark blue background
-            GL.clearColor(0.0, 0.0, 0.4, 0.0);
-
             // Clear the screen. It's not mentioned before Tutorial 02, but it can cause flickering, so it's there nonetheless.
-            GL.clear(GL.COLOR_BUFFER_BIT);
+            //NME already calls GL.clear with "opaqueBackground" color
+            //GL.clear(GL.COLOR_BUFFER_BIT);
+
         }
     }
 

tutorial02_red_triangle/Source/Main.hx

@@ -21,10 +21,10 @@ class Main extends Sprite {
 
         var fragShader:String = 
 "// Ouput data
-"+Utils.OUT_COLOR("color")+"
-
-void main()
-{
+" + 
+Utils.OUT_COLOR("color") +
+"
+void main(){
     // Output color = red 
     color = vec4(1.0,0.0,0.0,1.0);
 }
@@ -33,7 +33,8 @@ void main()
 
         var vertShader:String = 
 "// Input vertex data, different for all executions of this shader.
-"+Utils.IN(0)+" vec3 vertexPosition_modelspace;
+" +
+Utils.IN(0) + " vec3 vertexPosition_modelspace;
 
 void main(){
     gl_Position.xyz = vertexPosition_modelspace;

tutorial03_matrices/Source/Main.hx

@@ -5,122 +5,110 @@ import nme.gl.GL;
 import nme.Assets;
 import nme.Lib;
 import nme.utils.Float32Array;
-import nme.geom.Matrix3D;
+
 import nme.gl.GLProgram;
+import nme.gl.Utils;
+
+import nme.geom.Matrix3D;
 
 class Main extends Sprite {
-    
-   public function createShader(source:String, type:Int)
-   {
-      var shader = GL.createShader(type);
-      GL.shaderSource(shader, source);
-      GL.compileShader(shader);
-      if (GL.getShaderParameter(shader, GL.COMPILE_STATUS)==0)
-      {
-         trace("--- ERR ---\n" + source);
-         var err = GL.getShaderInfoLog(shader);
-         if (err!="")
-            throw err;
-      }
-      return shader;
-   }
-
-   public function createProgram(inVertexSource:String, inFragmentSource:String)
-   {
-      var program = GL.createProgram();
-      var vshader = createShader(inVertexSource, GL.VERTEX_SHADER);
-      var fshader = createShader(inFragmentSource, GL.FRAGMENT_SHADER);
-      GL.attachShader(program, vshader);
-      GL.attachShader(program, fshader);
-      GL.linkProgram(program);
-      if (GL.getProgramParameter(program, GL.LINK_STATUS)==0)
-      {
-         var result = GL.getProgramInfoLog(program);
-         if (result!="")
-            throw result;
-      }
-
-      return program;
-   }
 
 
-    
     public function new ()
     {        
         super ();
 
         var ogl = new OpenGLView();
         addChild(ogl);
 
-var fragShader = 
+        var fragShader:String = 
+"// Ouput data
+" + 
+Utils.OUT_COLOR("color") +
 "
-#version 330 core
-
-// Ouput data
-out vec3 color;
-
-void main()
-{
-  // Output color = red 
-  color = vec3(1,0,0);
+void main(){
+    // Output color = red 
+    color = vec4(1.0,0.0,0.0,1.0);
 }
 ";
 
-var vertShader =
-"
-#version 330 core
 
-// Input vertex data, different for all executions of this shader.
-layout(location = 0) in vec3 vertexPosition_modelspace;
+        var vertShader:String = 
+"// Input vertex data, different for all executions of this shader.
+" +
+Utils.IN(0) + " vec3 vertexPosition_modelspace;
 
 // Values that stay constant for the whole mesh.
 uniform mat4 MVP;
 
 void main(){
   // Output position of the vertex, in clip space : MVP * position
-  gl_Position =  MVP * vec4(vertexPosition_modelspace,1);
+  gl_Position =  MVP * vec4(vertexPosition_modelspace,1.0);
 }
 ";
 
+        // Dark blue background: For NME, use "opaqueBackground" instead of "clearColor"
+        //GL.clearColor(0.0, 0.0, 0.4, 0.0);
+        nme.Lib.stage.opaqueBackground = 0x000066;
 
-        // Create and compile our GLSL program from the shaders
-        var prog = createProgram(vertShader,fragShader);
-
-
-//        var frameBuffer = GL.createFramebuffer();
-//        GL.bindFramebuffer(GL.FRAMEBUFFER,frameBuffer);
+        //GLES3
+        if (Utils.isGLES3compat())
+        {
+            var vertexarray = GL.createVertexArray();
+            GL.bindVertexArray(vertexarray);
+        }
 
+        // Create and compile our GLSL program from the shaders
+        var prog = Utils.createProgram(vertShader,fragShader);
 
         // Get a handle for our "MVP" uniform
         var matrixID = GL.getUniformLocation(prog, "MVP");
-
-        var projection = Matrix3D.createOrtho(-10.0,10.0,-10.0,10.0,0.0,100.0);
         var model = new Matrix3D();
-        var view = new Matrix3D();
-
-        var mvp = projection;
-        mvp.append(model);
+#if true
+        //Ortho camera
+        var view:Matrix3D = new Matrix3D();
+        var projection = Matrix3D.createOrtho(-10.0,10.0,-10.0,10.0,0.0,100.0);
+#else
+       //Perp camera
+        var view:Matrix3D = GLM.lookAt(
+          new Vector3D(4,3,-3), // Camera is at (4,3,-3), in World Space
+          new Vector3D(0,0,0), // and looks at the origin
+          new Vector3D(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
+          );
+    
+        var fov = 45 * Math.PI / 180;
+        var aspect = 4 / 3;
+        var zNear = 0.1;
+        var zFar = 1000;
+        var projection = GLM.perspective(fov, aspect, zNear, zFar);
+#end
+
+        var mvp = model;
         mvp.append(view);
+        mvp.append(projection);
 
          var g_vertex_buffer_data = [
-         -1.0, -1.0, 0.0, 1.0,
-         1.0, -1.0, 0.0, 1.0,
-         0.0,  1.0, 0.0, 1.0
-        ];
+         -1.0, -1.0, 0.0, 1.0, //vertex 0 x,y,z,w
+          1.0, -1.0, 0.0, 1.0, //vertex 1
+          0.0,  1.0, 0.0, 1.0  //vertex2
+        ]; //3 vertex of size 4
 
 
         var vertexbuffer = GL.createBuffer();
         GL.bindBuffer(GL.ARRAY_BUFFER, vertexbuffer);
         GL.bufferData(GL.ARRAY_BUFFER, new Float32Array(g_vertex_buffer_data), GL.STATIC_DRAW);
 
+        var posAttrib = 0;
+        if (!Utils.isGLES3compat())
+        {
+          posAttrib = GL.getAttribLocation(prog, "vertexPosition_modelspace");
+        }
 
         ogl.render = function(rect:Rectangle)
         {
- 			// Dark blue background
-            GL.clearColor(0.0, 0.0, 0.4, 0.0);
-
+            //NME already calls GL.clear with "opaqueBackground" color
             // Clear the screen.
-            GL.clear(GL.COLOR_BUFFER_BIT);
+            //GL.clear(GL.COLOR_BUFFER_BIT);
 
             // Use our shader
             GL.useProgram(prog);
@@ -130,11 +118,11 @@ void main(){
             GL.uniformMatrix4fv(matrixID, false, Float32Array.fromMatrix(mvp));
 
             // 1rst attribute buffer : vertices
-            GL.enableVertexAttribArray(0);
+            GL.enableVertexAttribArray(posAttrib);
             GL.bindBuffer(GL.ARRAY_BUFFER, vertexbuffer);
             GL.vertexAttribPointer(
-                0, // attribute 0. No particular reason for 0, but must match the layout in the shader 
-                4, // size
+                posAttrib, // attribute 0. No particular reason for 0, but must match the layout in the shader 
+                4,  // size
                 GL.FLOAT, // type
                 false, // normalized?
                 0, // stride
@@ -144,6 +132,8 @@ void main(){
             // Draw the triangle !
             GL.drawArrays(GL.TRIANGLES, 0, 3);
             GL.disableVertexAttribArray(0);
+
+           // Swap buffers: is done automatically
         }
     }