opengl3 0.0.1.pre1

data/examples/ogl-3_2-cube.rb

@@ -0,0 +1,203 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'opengl'
+require 'glut'
+require_relative 'math3d'
+
+class TestApp
+  include GLUT
+  include OpenGL::Constants
+  
+  def initialize
+    caps = GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE
+    if FFI::Platform.mac?
+      caps |= GLUT_3_2_CORE_PROFILE
+    else
+      glutInitContextVersion(3, 2)
+      glutInitContextProfile(:core)
+    end
+    glutInitDisplayMode(caps)
+    glutInitWindowPosition(300, 200)
+    glutInitWindowSize(512, 512)
+    glutCreateWindow('cube')
+    
+    glutDisplayFunc(@draw_method ||= method(:draw))
+    glutReshapeFunc(@resize_method ||= method(:resize))
+    glutMouseFunc(@mouse_press_method ||= method(:mouse_press))
+    glutMotionFunc(@mouse_track_method ||= method(:mouse_track))
+  end
+  
+  def start
+    self.extend OpenGL::GL.entrypoints
+    puts glGetString(GL_VERSION)
+    
+    @cube = begin
+      vertex_buffer, index_buffer = glGenBuffers(2)
+      glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
+      glBufferData(GL_ARRAY_BUFFER, 3 * 4 * 8, nil, GL_STATIC_DRAW)
+      glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        ptr.put_array_of_GLfloat( 0, [-1.0, 1.0, 1.0]) # 0
+        ptr.put_array_of_GLfloat(12, [-1.0,-1.0, 1.0]) # 1
+        ptr.put_array_of_GLfloat(24, [ 1.0, 1.0, 1.0]) # 2
+        ptr.put_array_of_GLfloat(36, [ 1.0,-1.0, 1.0]) # 3
+        ptr.put_array_of_GLfloat(48, [ 1.0, 1.0,-1.0]) # 4
+        ptr.put_array_of_GLfloat(60, [ 1.0,-1.0,-1.0]) # 5
+        ptr.put_array_of_GLfloat(72, [-1.0, 1.0,-1.0]) # 6
+        ptr.put_array_of_GLfloat(84, [-1.0,-1.0,-1.0]) # 7
+      end
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer)
+      glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2 * 4 * 6, nil, GL_STATIC_DRAW)
+      glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        ptr.write_array_of_GLushort [0,1,2,3,4,5,6,7,0,1,0xffff]
+        ptr.put_array_of_GLushort(22, [6,0,4,2,0xffff,1,7,3,5])
+        #ptr.put_array_of_GLushort( 0, [0, 1, 2, 3]) # front
+        #ptr.put_array_of_GLushort( 8, [2, 3, 4, 5]) # right
+        #ptr.put_array_of_GLushort(16, [4, 5, 6, 7]) # back
+        #ptr.put_array_of_GLushort(24, [6, 7, 0, 1]) # left
+        #ptr.put_array_of_GLushort(32, [6, 0, 4, 2]) # top
+        #ptr.put_array_of_GLushort(40, [1, 7, 3, 5]) # bottom
+      end
+      
+      array = glGenVertexArrays(1)[0]
+      glBindVertexArray(array)
+      glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
+      glEnableVertexAttribArray(0)
+      glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer)
+      
+      glBindVertexArray(0)
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
+      
+      array
+    end
+    
+    @program = begin
+      vertex_shader = glCreateShader(:vertex)
+      glShaderSource(vertex_shader, VS_CODE)
+      glCompileShader(vertex_shader)
+      unless glIsShaderCompiled?(vertex_shader)
+        msg = glGetShaderInfoLog(vertex_shader)
+        raise RuntimeError, "vertex_shader:\n#{msg}"
+      end
+      
+      fragment_shader = glCreateShader(:fragment)
+      glShaderSource(fragment_shader, FS_CODE)
+      glCompileShader(fragment_shader)
+      unless glIsShaderCompiled?(fragment_shader)
+        msg = glGetShaderInfoLog(fragment_shader)
+        raise RuntimeError, "fragment_shader:\n#{msg}"
+      end
+      
+      program = glCreateProgram()
+      glAttachShader(program, vertex_shader)
+      glAttachShader(program, fragment_shader)
+      glBindAttribLocation(program, 0, "in_Position")
+      glBindFragDataLocation(program, 0, "fs_FragColor")
+      glLinkProgram(program)
+      unless glIsProgramLinked?(program)
+        msg = glGetProgramInfoLog(program)
+        raise RuntimeError, "program:\n#{msg}"
+      end
+      glDeleteShader(vertex_shader)
+      glDeleteShader(fragment_shader)
+      program
+    end
+    
+    @view = Matrix.translate(0, 0, -5)
+    @world = Matrix.identity(4)
+    
+    glutMainLoop()
+  end
+  
+  def draw
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    glEnable(GL_CULL_FACE)
+    #glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+    glEnable(GL_DEPTH_TEST)
+    
+    glUseProgram(@program)
+    
+    if (loc = glGetUniformLocation(@program, "u_Projection")) != -1
+      #glUniformMatrix4fv(loc, [ @projection ], true)
+      OpenGL::Type.GLfloat(16) do |ptr|
+        ptr.write_array_of_GLfloat(@projection.to_a.flatten)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, ptr)
+      end
+    end
+    
+    if (loc = glGetUniformLocation(@program, "u_ModelView")) != -1
+      OpenGL::Type.GLfloat(16) do |ptr|
+        modelview = @view * @world
+        ptr.write_array_of_GLfloat(modelview.to_a.flatten)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, ptr)
+      end
+    end
+    
+    glBindVertexArray(@cube)
+    glEnable(GL_PRIMITIVE_RESTART)
+    glPrimitiveRestartIndex(0xffff)
+    glDrawElements(GL_TRIANGLE_STRIP, 20, GL_UNSIGNED_SHORT, nil)
+    
+    glutSwapBuffers()
+  end
+  
+  def resize(width, height)
+    glViewport(0, 0, width, height)
+    
+    fovy = 45.0 / 180.0 * Math::PI
+    aspect = Float(width) / Float(height)
+    z_near, z_far = 1.0, 100.0
+    @projection = Matrix.perspective(fovy, aspect, z_near, z_far)
+  end
+  
+  def mouse_press(button, button_state, x, y)
+    if button == :LEFT
+      case button_state
+      when :DOWN
+        @mouse_tracking_pos = [x, y]
+      when :UP
+        remove_instance_variable(:@mouse_tracking_pos)
+      end
+    end
+  end
+  
+  def mouse_track(x, y)
+    if defined? @mouse_tracking_pos
+      delta_x = (x - @mouse_tracking_pos[0]) * 0.01
+      delta_y = (y - @mouse_tracking_pos[1]) * 0.01
+      
+      @world = Matrix.rotate_x(delta_y) * Matrix.rotate_y(delta_x) * @world
+      
+      @mouse_tracking_pos = [x, y]
+      glutPostRedisplay()
+    end
+  end
+  
+  VS_CODE =<<-GLSL
+#version 150 core
+uniform mat4 u_Projection;
+uniform mat4 u_ModelView;
+in vec4 in_Position;
+out vec3 vs_Vertex;
+void main()
+{
+  gl_Position = u_Projection * u_ModelView * in_Position;
+  vs_Vertex = in_Position.xyz;
+}
+  GLSL
+  
+  FS_CODE =<<-GLSL
+#version 150 core
+in vec3 vs_Vertex;
+out vec4 fs_FragColor;
+void main()
+{
+  fs_FragColor = vec4(vs_Vertex * 0.5 + 0.5, 1.0);
+}
+  GLSL
+  
+end
+
+TestApp.new.start

data/examples/ogl-4_0-quad_tessellation.rb

@@ -0,0 +1,283 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'opengl'
+require 'glut'
+require_relative 'math3d'
+
+class TestApp
+  include GLUT
+  include OpenGL::Constants
+  
+  def initialize
+    caps = GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE
+    if FFI::Platform.mac?
+      caps |= GLUT_4_0_CORE_PROFILE
+    else
+      glutInitContextVersion(4, 0)
+      glutInitContextProfile(:core)
+    end
+    glutInitDisplayMode(caps)
+    glutInitWindowPosition(300, 200)
+    glutInitWindowSize(512, 512)
+    glutCreateWindow('tessellation')
+    
+    glutDisplayFunc(@draw_method ||= method(:draw))
+    glutReshapeFunc(@resize_method ||= method(:resize))
+    glutMouseFunc(@mouse_press_method ||= method(:mouse_press))
+    glutMotionFunc(@mouse_track_method ||= method(:mouse_track))
+  end
+  
+  def start
+    self.extend OpenGL::GL.entrypoints
+    puts glGetString(GL_VERSION)
+    
+    @quad = begin
+      vertex_buffer, index_buffer = glGenBuffers(2)
+      glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer)
+      n, m = 4, 4
+      @quad_count = 4*m*n
+      glBufferData(GL_ARRAY_BUFFER, 4*2*(n+1)*(m+1), nil, GL_STATIC_DRAW)
+      glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*@quad_count, nil, GL_STATIC_DRAW)
+      glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        inv_n, inv_m, off = 1.0/n, 1.0/m, 0
+        0.upto(m) do |i|
+          y = 0.5 - i * inv_m
+          0.upto(n) do |j|
+            x = j * inv_n - 0.5
+            ptr.put_array_of_GLfloat(off, [x, y])
+            off += 4*2
+          end
+        end
+      end
+      glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        off = 0
+        0.upto(m-1) do |i|
+          0.upto(n-1) do |j|
+            v0 = i*(n+1)+j
+            ptr.put_array_of_GLushort(off, [v0, v0+n+1, v0+n+2, v0+1])
+            off += 2*4
+          end
+        end
+      end
+      
+      array = glGenVertexArrays(1)[0]
+      glBindVertexArray(array)
+      glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
+      glEnableVertexAttribArray(0)
+      glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nil)
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer)
+      
+      glBindVertexArray(0)
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
+      
+      array
+    end
+    
+    @program = begin
+      vertex_shader = glCreateShader(:vertex)
+      glShaderSource(vertex_shader, VS_CODE)
+      glCompileShader(vertex_shader)
+      unless glIsShaderCompiled?(vertex_shader)
+        msg = glGetShaderInfoLog(vertex_shader)
+        raise RuntimeError, "vertex_shader:\n#{msg}"
+      end
+      
+      tess_control_shader = glCreateShader(:tess_control)
+      glShaderSource(tess_control_shader, TC_CODE)
+      glCompileShader(tess_control_shader)
+      unless glIsShaderCompiled?(tess_control_shader)
+        msg = glGetShaderInfoLog(tess_control_shader)
+        raise RuntimeError, "tess_control_shader:\n#{msg}"
+      end
+      
+      tess_eval_shader = glCreateShader(:tess_eval)
+      glShaderSource(tess_eval_shader, TE_CODE)
+      glCompileShader(tess_eval_shader)
+      unless glIsShaderCompiled?(tess_eval_shader)
+        msg = glGetShaderInfoLog(tess_eval_shader)
+        raise RuntimeError, "tess_eval_shader:\n#{msg}"
+      end
+      
+      geometry_shader = glCreateShader(:geometry)
+      glShaderSource(geometry_shader, GS_CODE)
+      glCompileShader(geometry_shader)
+      unless glIsShaderCompiled?(geometry_shader)
+        msg = glGetShaderInfoLog(geometry_shader)
+        raise RuntimeError, "geometry_shader:\n#{msg}"
+      end
+      
+      fragment_shader = glCreateShader(:fragment)
+      glShaderSource(fragment_shader, FS_CODE)
+      glCompileShader(fragment_shader)
+      unless glIsShaderCompiled?(fragment_shader)
+        msg = glGetShaderInfoLog(fragment_shader)
+        raise RuntimeError, "fragment_shader:\n#{msg}"
+      end
+      
+      program = glCreateProgram()
+      glAttachShader(program, vertex_shader)
+      glAttachShader(program, tess_control_shader)
+      glAttachShader(program, tess_eval_shader)
+      glAttachShader(program, geometry_shader)
+      glAttachShader(program, fragment_shader)
+      glLinkProgram(program)
+      unless glIsProgramLinked?(program)
+        msg = glGetProgramInfoLog(program)
+        raise RuntimeError, "program:\n#{msg}"
+      end
+      glDeleteShader(vertex_shader)
+      glDeleteShader(tess_control_shader)
+      glDeleteShader(tess_eval_shader)
+      glDeleteShader(geometry_shader)
+      glDeleteShader(fragment_shader)
+      program
+    end
+    
+    @view = Matrix.translate(0, 0, -5)
+    @world = Matrix.scale(5, 5, 5)
+    
+    glutMainLoop()
+  end
+  
+  def draw
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+    
+    glUseProgram(@program)
+    if (loc = glGetUniformLocation(@program, "u_Projection")) != -1
+      OpenGL::Type.GLfloat(16) do |ptr|
+        ptr.write_array_of_GLfloat(@projection.to_a.flatten)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, ptr)
+      end
+    end
+    if (loc = glGetUniformLocation(@program, "u_ModelView")) != -1
+      OpenGL::Type.GLfloat(16) do |ptr|
+        modelview = @view * @world
+        ptr.write_array_of_GLfloat(modelview.to_a.flatten)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, ptr)
+      end
+    end
+    glPatchParameteri(GL_PATCH_VERTICES, 4)
+    
+    glBindVertexArray(@quad)
+    glDrawElements(GL_PATCHES, @quad_count, GL_UNSIGNED_SHORT, nil)
+    
+    glutSwapBuffers()
+  end
+  
+  def resize(width, height)
+    glViewport(0, 0, width, height)
+    
+    fovy = 45.0 / 180.0 * Math::PI
+    aspect = Float(width) / Float(height)
+    z_near, z_far = 1.0, 100.0
+    @projection = Matrix.perspective(fovy, aspect, z_near, z_far)
+  end
+  
+  def mouse_press(button, button_state, x, y)
+    if button == :LEFT
+      case button_state
+      when :DOWN
+        @mouse_tracking_pos = [x, y]
+      when :UP
+        remove_instance_variable(:@mouse_tracking_pos)
+      end
+    end
+  end
+  
+  def mouse_track(x, y)
+    if defined? @mouse_tracking_pos
+      delta_x = (x - @mouse_tracking_pos[0]) * 0.01
+      delta_y = (y - @mouse_tracking_pos[1]) * 0.01
+      
+      #@world = Matrix.rotate_x(delta_y) * Matrix.rotate_y(delta_x) * @world
+      @world = Matrix.translate(0,0,delta_y) * @world
+      
+      @mouse_tracking_pos = [x, y]
+      glutPostRedisplay()
+    end
+  end
+  
+  VS_CODE =<<-GLSL
+#version 400 core
+uniform mat4 u_Projection;
+uniform mat4 u_ModelView;
+layout(location = 0) in vec4 in_Position;
+//out vec3 vs_Position;
+//out vec2 vs_TexCoord;
+void main()
+{
+  gl_Position = u_Projection * u_ModelView * in_Position;
+  //vs_Position = in_Position.xyz;
+  //vs_TexCoord = in_Position.xy + 0.5;
+}
+  GLSL
+  
+  TC_CODE =<<-GLSL
+#version 400 core
+layout(vertices=4) out;
+#define ID gl_InvocationID
+void main()
+{
+  gl_out[ID].gl_Position = gl_in[ID].gl_Position;
+  if (ID == 0) {
+    float sum = 0.0;
+    for (int i = 0; i < 4; ++i) {
+      vec4 v = gl_in[i].gl_Position;
+      sum += v.z / v.w;
+    }
+    sum *= 0.25;
+    float k = 20 * clamp(1.0 - sum, 0.0, 2.0);
+    gl_TessLevelInner[0] = k;
+    gl_TessLevelInner[1] = k;
+    gl_TessLevelOuter[0] = k;
+    gl_TessLevelOuter[1] = k;
+    gl_TessLevelOuter[2] = k;
+    gl_TessLevelOuter[3] = k;
+  }
+}
+  GLSL
+  
+  TE_CODE =<<-GLSL
+#version 400 core
+layout(quads, fractional_even_spacing, ccw) in;
+void main()
+{
+  float u = gl_TessCoord.x, v = gl_TessCoord.y;
+  vec4 upper = mix(gl_in[0].gl_Position, gl_in[3].gl_Position, v);
+  vec4 lower = mix(gl_in[1].gl_Position, gl_in[2].gl_Position, v);
+  gl_Position = mix(upper, lower, u);
+}
+  GLSL
+  
+  GS_CODE =<<-GLSL
+#version 400 core
+layout(triangles) in;
+layout(triangle_strip, max_vertices=3) out;
+void main()
+{
+  for (int i = 0; i < 3; ++i) {
+    gl_Position = gl_in[i].gl_Position;
+    EmitVertex();
+  }
+  EndPrimitive();
+}
+  GLSL
+  
+  FS_CODE =<<-GLSL
+#version 400 core
+//in vec2 vs_TexCoord;
+layout(location = 0) out vec4 fs_FragColor;
+void main()
+{
+  //fs_FragColor = vec4(vs_TexCoord, 0.0, 1.0);
+  fs_FragColor = vec4(1.0);
+}
+  GLSL
+  
+end
+
+TestApp.new.start