cyberarm_engine 0.14.0 → 0.15.0

data/lib/cyberarm_engine/opengl/renderer/opengl_renderer.rb

@@ -0,0 +1,289 @@
+module CyberarmEngine
+  class OpenGLRenderer
+    @@immediate_mode_warning = false
+
+    attr_accessor :show_wireframe
+
+    def initialize(width:, height:, show_wireframe: false)
+      @width = width
+      @height = height
+      @show_wireframe = show_wireframe
+
+      @g_buffer = GBuffer.new(width: @width, height: @height)
+    end
+
+    def canvas_size_changed
+      @g_buffer.unbind_framebuffer
+      @g_buffer.clean_up
+
+      @g_buffer = GBuffer.new(width: @width, height: @height)
+    end
+
+    def render(camera, lights, entities)
+      glViewport(0, 0, @width, @height)
+      glEnable(GL_DEPTH_TEST)
+
+      if Shader.available?("g_buffer") && Shader.available?("lighting")
+        @g_buffer.bind_for_writing
+        gl_error?
+
+        glClearColor(0.0, 0.0, 0.0, 0.0)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        Shader.use("g_buffer") do |shader|
+          gl_error?
+
+          entities.each do |entity|
+            next unless entity.visible && entity.renderable
+
+            shader.uniform_transform("projection", camera.projection_matrix)
+            shader.uniform_transform("view", camera.view_matrix)
+            shader.uniform_transform("model", entity.model_matrix)
+            shader.uniform_vec3("cameraPosition", camera.position)
+
+            gl_error?
+            draw_model(entity.model, shader)
+            entity.draw
+          end
+        end
+
+        @g_buffer.unbind_framebuffer
+        gl_error?
+
+        @g_buffer.bind_for_reading
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0)
+
+        lighting(lights)
+        gl_error?
+
+        post_processing
+        gl_error?
+
+        # render_framebuffer
+        gl_error?
+
+        @g_buffer.unbind_framebuffer
+        gl_error?
+      else
+        unless @@immediate_mode_warning
+          puts "Shaders are disabled or failed to compile, using immediate mode for rendering..."
+        end
+        @@immediate_mode_warning = true
+
+        gl_error?
+        lights.each(&:draw)
+        camera.draw
+
+        glEnable(GL_NORMALIZE)
+        entities.each do |entity|
+          next unless entity.visible && entity.renderable
+
+          glPushMatrix
+
+          glTranslatef(entity.position.x, entity.position.y, entity.position.z)
+          glScalef(entity.scale.x, entity.scale.y, entity.scale.z)
+          glRotatef(entity.orientation.x, 1.0, 0, 0)
+          glRotatef(entity.orientation.y, 0, 1.0, 0)
+          glRotatef(entity.orientation.z, 0, 0, 1.0)
+
+          gl_error?
+          draw_mesh(entity.model)
+          entity.draw
+          glPopMatrix
+        end
+      end
+
+      gl_error?
+    end
+
+    def copy_g_buffer_to_screen
+      @g_buffer.set_read_buffer(:position)
+      glBlitFramebuffer(0, 0, @g_buffer.width, @g_buffer.height,
+                        0, 0, @g_buffer.width / 2, @g_buffer.height / 2,
+                        GL_COLOR_BUFFER_BIT, GL_LINEAR)
+
+      @g_buffer.set_read_buffer(:diffuse)
+      glBlitFramebuffer(0, 0, @g_buffer.width, @g_buffer.height,
+                        0, @g_buffer.height / 2, @g_buffer.width / 2, @g_buffer.height,
+                        GL_COLOR_BUFFER_BIT, GL_LINEAR)
+
+      @g_buffer.set_read_buffer(:normal)
+      glBlitFramebuffer(0, 0, @g_buffer.width, @g_buffer.height,
+                        @g_buffer.width / 2, @g_buffer.height / 2, @g_buffer.width, @g_buffer.height,
+                        GL_COLOR_BUFFER_BIT, GL_LINEAR)
+
+      @g_buffer.set_read_buffer(:texcoord)
+      glBlitFramebuffer(0, 0, @g_buffer.width, @g_buffer.height,
+                        @g_buffer.width / 2, 0, @g_buffer.width, @g_buffer.height / 2,
+                        GL_COLOR_BUFFER_BIT, GL_LINEAR)
+    end
+
+    def lighting(lights)
+      Shader.use("lighting") do |shader|
+        glBindVertexArray(@g_buffer.screen_vbo)
+
+        glDisable(GL_DEPTH_TEST)
+        glEnable(GL_BLEND)
+
+        glActiveTexture(GL_TEXTURE0)
+        glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:diffuse))
+        shader.uniform_integer("diffuse", 0)
+
+        glActiveTexture(GL_TEXTURE1)
+        glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:position))
+        shader.uniform_integer("position", 1)
+
+        glActiveTexture(GL_TEXTURE2)
+        glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:texcoord))
+        shader.uniform_integer("texcoord", 2)
+
+        glActiveTexture(GL_TEXTURE3)
+        glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:normal))
+        shader.uniform_integer("normal", 3)
+
+        glActiveTexture(GL_TEXTURE4)
+        glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:depth))
+        shader.uniform_integer("depth", 4)
+
+        lights.each_with_index do |light, _i|
+          shader.uniform_integer("light[0].type", light.type)
+          shader.uniform_vec3("light[0].direction", light.direction)
+          shader.uniform_vec3("light[0].position", light.position)
+          shader.uniform_vec3("light[0].diffuse", light.diffuse)
+          shader.uniform_vec3("light[0].ambient", light.ambient)
+          shader.uniform_vec3("light[0].specular", light.specular)
+
+          glDrawArrays(GL_TRIANGLES, 0, @g_buffer.vertices.size)
+        end
+
+        glBindVertexArray(0)
+      end
+    end
+
+    def post_processing
+    end
+
+    def render_framebuffer
+      if Shader.available?("lighting")
+        Shader.use("lighting") do |shader|
+          glBindVertexArray(@g_buffer.screen_vbo)
+
+          glDisable(GL_DEPTH_TEST)
+          glEnable(GL_BLEND)
+
+          glActiveTexture(GL_TEXTURE0)
+          glBindTexture(GL_TEXTURE_2D, @g_buffer.texture(:diffuse))
+          shader.uniform_integer("diffuse_texture", 0)
+
+          glDrawArrays(GL_TRIANGLES, 0, @g_buffer.vertices.size)
+
+          glBindVertexArray(0)
+        end
+      end
+    end
+
+    def draw_model(model, shader)
+      glBindVertexArray(model.vertex_array_id)
+      glEnableVertexAttribArray(0)
+      glEnableVertexAttribArray(1)
+      glEnableVertexAttribArray(2)
+      if model.has_texture?
+        glEnableVertexAttribArray(3)
+        glEnableVertexAttribArray(4)
+      end
+
+      if @show_wireframe
+        glLineWidth(2)
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+        Shader.active_shader.uniform_boolean("disableLighting", true)
+
+        glDrawArrays(GL_TRIANGLES, 0, model.faces.count * 3)
+
+        Shader.active_shader.uniform_boolean("disableLighting", false)
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+        glLineWidth(1)
+      end
+
+      offset = 0
+      model.objects.each do |object|
+        shader.uniform_boolean("hasTexture", object.has_texture?)
+
+        if object.has_texture?
+          glBindTexture(GL_TEXTURE_2D, object.materials.find { |mat| mat.texture_id }.texture_id)
+        else
+          glBindTexture(GL_TEXTURE_2D, 0)
+        end
+
+        glDrawArrays(GL_TRIANGLES, offset, object.faces.count * 3)
+        offset += object.faces.count * 3
+      end
+
+      if model.has_texture?
+        glDisableVertexAttribArray(4)
+        glDisableVertexAttribArray(3)
+
+        glBindTexture(GL_TEXTURE_2D, 0)
+      end
+      glDisableVertexAttribArray(2)
+      glDisableVertexAttribArray(1)
+      glDisableVertexAttribArray(0)
+
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+      glBindVertexArray(0)
+    end
+
+    def draw_mesh(model)
+      model.objects.each_with_index do |o, _i|
+        glEnable(GL_COLOR_MATERIAL)
+        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
+        glShadeModel(GL_FLAT) unless o.faces.first[4]
+        glShadeModel(GL_SMOOTH) if o.faces.first[4]
+        glEnableClientState(GL_VERTEX_ARRAY)
+        glEnableClientState(GL_COLOR_ARRAY)
+        glEnableClientState(GL_NORMAL_ARRAY)
+
+        if o.has_texture?
+          glEnable(GL_TEXTURE_2D)
+          glBindTexture(GL_TEXTURE_2D, o.materials.find { |mat| mat.texture_id }.texture_id)
+          glEnableClientState(GL_TEXTURE_COORD_ARRAY)
+          glTexCoordPointer(3, GL_FLOAT, 0, o.flattened_uvs)
+        end
+
+        glVertexPointer(4, GL_FLOAT, 0, o.flattened_vertices)
+        glColorPointer(3, GL_FLOAT, 0, o.flattened_materials)
+        glNormalPointer(GL_FLOAT, 0, o.flattened_normals)
+
+        if @show_wireframe # This is kinda expensive
+          glDisable(GL_LIGHTING)
+          glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+          glPolygonOffset(2, 0.5)
+          glLineWidth(3)
+
+          glDrawArrays(GL_TRIANGLES, 0, o.flattened_vertices_size / 4)
+
+          glLineWidth(1)
+          glPolygonOffset(0, 0)
+          glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+          glEnable(GL_LIGHTING)
+
+          glDrawArrays(GL_TRIANGLES, 0, o.flattened_vertices_size / 4)
+        else
+          glDrawArrays(GL_TRIANGLES, 0, o.flattened_vertices_size / 4)
+        end
+
+        # glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glDisableClientState(GL_VERTEX_ARRAY)
+        glDisableClientState(GL_COLOR_ARRAY)
+        glDisableClientState(GL_NORMAL_ARRAY)
+
+        if o.has_texture?
+          glDisableClientState(GL_TEXTURE_COORD_ARRAY)
+          glDisable(GL_TEXTURE_2D)
+        end
+
+        glDisable(GL_COLOR_MATERIAL)
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/opengl/renderer/renderer.rb

@@ -0,0 +1,22 @@
+module CyberarmEngine
+  class Renderer
+    attr_reader :opengl_renderer, :bounding_box_renderer
+
+    def initialize
+      @bounding_box_renderer = BoundingBoxRenderer.new
+      @opengl_renderer = OpenGLRenderer.new(width: $window.width, height: $window.height)
+    end
+
+    def draw(camera, lights, entities)
+      @opengl_renderer.render(camera, lights, entities)
+      @bounding_box_renderer.render(entities) if @show_bounding_boxes
+    end
+
+    def canvas_size_changed
+      @opengl_renderer.canvas_size_changed
+    end
+
+    def finalize # cleanup
+    end
+  end
+end

data/lib/cyberarm_engine/{shader.rb → opengl/shader.rb}

@@ -22,9 +22,7 @@ module CyberarmEngine
       if shader
         @@shaders.delete(name)
 
-        if shader.compiled?
-          glDeleteProgram(shader.program)
-        end
+        glDeleteProgram(shader.program) if shader.compiled?
       end
     end
 
@@ -68,15 +66,15 @@ module CyberarmEngine
     # returns currently active {Shader}, if one is active
     #
     # @return [Shader?]
-    def self.active_shader
-      @active_shader
+    class << self
+      attr_reader :active_shader
     end
 
     # sets currently active {Shader}
     #
     # @param instance [Shader] instance of {Shader} to set as active
-    def self.active_shader=(instance)
-      @active_shader = instance
+    class << self
+      attr_writer :active_shader
     end
 
     # stops using currently active {Shader}
@@ -94,7 +92,8 @@ module CyberarmEngine
     #
     # @param variable [String]
     def self.attribute_location(variable)
-      raise RuntimeError, "No active shader!" unless Shader.active_shader
+      raise "No active shader!" unless Shader.active_shader
+
       Shader.active_shader.attribute_location(variable)
     end
 
@@ -103,12 +102,14 @@ module CyberarmEngine
     # @param variable [String]
     # @param value
     def self.set_uniform(variable, value)
-      raise RuntimeError, "No active shader!" unless Shader.active_shader
+      raise "No active shader!" unless Shader.active_shader
+
       Shader.active_shader.set_uniform(variable, value)
     end
 
     attr_reader :name, :program
-    def initialize(name:, includes_dir: nil, vertex: "shaders/default.vert", fragment:)
+
+    def initialize(name:, fragment:, includes_dir: nil, vertex: "shaders/default.vert")
       raise "Shader name can not be blank" if name.length == 0
 
       @name = name
@@ -120,7 +121,7 @@ module CyberarmEngine
       @error_buffer_size = 1024 * 8
       @variable_missing = {}
 
-      @data = {shaders: {}}
+      @data = { shaders: {} }
 
       unless shader_files_exist?(vertex: vertex, fragment: fragment)
         raise ArgumentError, "Shader files not found: #{vertex} or #{fragment}"
@@ -133,7 +134,7 @@ module CyberarmEngine
       compile_shader(type: :fragment)
       link_shaders
 
-      @data[:shaders].each { |key, id| glDeleteShader(id) }
+      @data[:shaders].each { |_key, id| glDeleteShader(id) }
 
       # Only add shader if it successfully compiles
       if @compiled
@@ -175,7 +176,7 @@ module CyberarmEngine
       _size = [processed_source.length].pack("I")
       glShaderSource(_shader, 1, _source, _size)
 
-      @data[:shaders][type] =_shader
+      @data[:shaders][type] = _shader
     end
 
     # evaluates shader preprocessors
@@ -199,22 +200,25 @@ module CyberarmEngine
       lines = source.lines
 
       lines.each_with_index do |line, i|
-        if line.start_with?(PREPROCESSOR_CHARACTER)
-          preprocessor = line.strip.split(" ")
-          lines.delete(line)
+        next unless line.start_with?(PREPROCESSOR_CHARACTER)
 
-          case preprocessor.first
-          when "@include"
-            raise ArgumentError, "Shader preprocessor include directory was not given for shader #{@name}" unless @includes_dir
+        preprocessor = line.strip.split(" ")
+        lines.delete(line)
 
-            preprocessor[1..preprocessor.length - 1].join.scan(/"([^"]*)"/).flatten.each do |file|
-              source = File.read("#{@includes_dir}/#{file}.glsl")
+        case preprocessor.first
+        when "@include"
+          unless @includes_dir
+            raise ArgumentError,
+                  "Shader preprocessor include directory was not given for shader #{@name}"
+          end
+
+          preprocessor[1..preprocessor.length - 1].join.scan(/"([^"]*)"/).flatten.each do |file|
+            source = File.read("#{@includes_dir}/#{file}.glsl")
 
-              lines.insert(i, source)
-            end
-          else
-            warn "Unsupported preprocessor #{preprocessor.first} for #{@name}"
+            lines.insert(i, source)
           end
+        else
+          warn "Unsupported preprocessor #{preprocessor.first} for #{@name}"
         end
       end
 
@@ -230,12 +234,12 @@ module CyberarmEngine
       raise ArgumentError, "No shader for #{type.inspect}" unless _shader
 
       glCompileShader(_shader)
-      buffer = '    '
+      buffer = "    "
       glGetShaderiv(_shader, GL_COMPILE_STATUS, buffer)
-      compiled = buffer.unpack('L')[0]
+      compiled = buffer.unpack1("L")
 
       if compiled == 0
-        log = ' ' * @error_buffer_size
+        log = " " * @error_buffer_size
         glGetShaderInfoLog(_shader, @error_buffer_size, nil, log)
         puts "Shader Error: Program \"#{@name}\""
         puts "  #{type.to_s.capitalize} Shader InfoLog:", "  #{log.strip.split("\n").join("\n  ")}\n\n"
@@ -246,7 +250,7 @@ module CyberarmEngine
         _compiled = true
       end
 
-      return _compiled
+      _compiled
     end
 
     # link compiled OpenGL Shaders in to a OpenGL Program
@@ -261,18 +265,18 @@ module CyberarmEngine
       end
       glLinkProgram(@program)
 
-      buffer = '    '
+      buffer = "    "
       glGetProgramiv(@program, GL_LINK_STATUS, buffer)
-      linked = buffer.unpack('L')[0]
+      linked = buffer.unpack1("L")
 
       if linked == 0
-        log = ' ' * @error_buffer_size
+        log = " " * @error_buffer_size
         glGetProgramInfoLog(@program, @error_buffer_size, nil, log)
         puts "Shader Error: Program \"#{@name}\""
         puts "  Program InfoLog:", "  #{log.strip.split("\n").join("\n  ")}\n\n"
       end
 
-      @compiled = linked == 0 ? false : true
+      @compiled = !(linked == 0)
     end
 
     # Returns the location of a uniform _variable_
@@ -281,18 +285,22 @@ module CyberarmEngine
     # @return [Integer] location of uniform
     def variable(variable)
       loc = glGetUniformLocation(@program, variable)
-      if (loc == -1)
-        puts "Shader Error: Program \"#{@name}\" has no such uniform named \"#{variable}\"", "  Is it used in the shader? GLSL may have optimized it out.", "  Is it miss spelled?" unless @variable_missing[variable]
+      if loc == -1
+        unless @variable_missing[variable]
+          puts "Shader Error: Program \"#{@name}\" has no such uniform named \"#{variable}\"",
+               "  Is it used in the shader? GLSL may have optimized it out.", "  Is it miss spelled?"
+        end
         @variable_missing[variable] = true
       end
-      return loc
+      loc
     end
 
     # @see Shader.use Shader.use
     def use(&block)
       return unless compiled?
       raise "Another shader is already in use! #{Shader.active_shader.name.inspect}" if Shader.active_shader
-      Shader.active_shader=self
+
+      Shader.active_shader = self
 
       glUseProgram(@program)
 
@@ -331,7 +339,7 @@ module CyberarmEngine
     # @param location [Integer]
     # @return [void]
     def uniform_transform(variable, value, location = nil)
-      attr_loc = location ? location : attribute_location(variable)
+      attr_loc = location || attribute_location(variable)
 
       glUniformMatrix4fv(attr_loc, 1, GL_FALSE, value.to_gl.pack("F16"))
     end
@@ -343,7 +351,7 @@ module CyberarmEngine
     # @param location [Integer]
     # @return [void]
     def uniform_boolean(variable, value, location = nil)
-      attr_loc = location ? location : attribute_location(variable)
+      attr_loc = location || attribute_location(variable)
 
       glUniform1i(attr_loc, value ? 1 : 0)
     end
@@ -354,7 +362,7 @@ module CyberarmEngine
     # @param location [Integer]
     # @return [void]
     def uniform_integer(variable, value, location = nil)
-      attr_loc = location ? location : attribute_location(variable)
+      attr_loc = location || attribute_location(variable)
 
       glUniform1i(attr_loc, value)
     end
@@ -366,7 +374,7 @@ module CyberarmEngine
     # @param location [Integer]
     # @return [void]
     def uniform_float(variable, value, location = nil)
-      attr_loc = location ? location : attribute_location(variable)
+      attr_loc = location || attribute_location(variable)
 
       glUniform1f(attr_loc, value)
     end
@@ -378,7 +386,7 @@ module CyberarmEngine
     # @param location [Integer]
     # @return [void]
     def uniform_vec3(variable, value, location = nil)
-      attr_loc = location ? location : attribute_location(variable)
+      attr_loc = location || attribute_location(variable)
 
       glUniform3f(attr_loc, *value.to_a[0..2])
     end
@@ -390,7 +398,7 @@ module CyberarmEngine
     # @param location [Integer]
     # @return [void]
     def uniform_vec4(variable, value, location = nil)
-      attr_loc = location ? location : attribute_location(variable)
+      attr_loc = location || attribute_location(variable)
 
       glUniform4f(attr_loc, *value.to_a)
     end