cyberarm_engine 0.13.1 → 0.17.1

data/lib/cyberarm_engine/opengl/perspective_camera.rb

@@ -0,0 +1,38 @@
+module CyberarmEngine
+  class PerspectiveCamera
+    attr_accessor :position, :orientation, :aspect_ratio, :field_of_view,
+                  :min_view_distance, :max_view_distance
+
+    def initialize(position:, aspect_ratio:, orientation: Vector.new(0, 0,
+                                                                     0), field_of_view: 70.0, min_view_distance: 0.1, max_view_distance: 155.0)
+      @position = position
+      @orientation = orientation
+
+      @aspect_ratio = aspect_ratio
+      @field_of_view = field_of_view
+
+      @min_view_distance = min_view_distance
+      @max_view_distance = max_view_distance
+    end
+
+    def draw
+      glMatrixMode(GL_PROJECTION)
+      glLoadIdentity
+      gluPerspective(@field_of_view, @aspect_ratio, @min_view_distance, @max_view_distance)
+      glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
+      glRotatef(@orientation.x, 1, 0, 0)
+      glRotatef(@orientation.y, 0, 1, 0)
+      glTranslatef(-@position.x, -@position.y, -@position.z)
+      glMatrixMode(GL_MODELVIEW)
+      glLoadIdentity
+    end
+
+    def projection_matrix
+      Transform.perspective(@field_of_view, @aspect_ratio, @min_view_distance, @max_view_distance)
+    end
+
+    def view_matrix
+      Transform.translate_3d(@position * -1) * Transform.rotate_3d(@orientation)
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+module CyberarmEngine
+  class BoundingBoxRenderer
+    attr_reader :bounding_boxes, :vertex_count
+
+    def initialize
+      @bounding_boxes = {}
+      @vertex_count = 0
+    end
+
+    def render(entities)
+      entities.each do |entity|
+        create_bounding_box(entity, color = nil)
+        draw_bounding_boxes
+      end
+
+      (@bounding_boxes.keys - entities.map { |e| e.object_id }).each do |key|
+        @bounding_boxes.delete(key)
+      end
+    end
+
+    def create_bounding_box(entity, color = nil)
+      color ||= entity.debug_color
+      entity_id = entity.object_id
+
+      if @bounding_boxes[entity_id]
+        if @bounding_boxes[entity_id][:color] != color
+          @bounding_boxes[entity_id][:colors] = mesh_colors(color).pack("f*")
+          @bounding_boxes[entity_id][:color]  = color
+          return
+        else
+          return
+        end
+      end
+
+      @bounding_boxes[entity_id] = {
+        entity: entity,
+        color: color,
+        objects: []
+      }
+
+      box = entity.normalize_bounding_box
+
+      normals  = mesh_normals
+      colors   = mesh_colors(color)
+      vertices = mesh_vertices(box)
+
+      @vertex_count += vertices.size
+
+      @bounding_boxes[entity_id][:vertices_size] = vertices.size
+      @bounding_boxes[entity_id][:vertices]      = vertices.pack("f*")
+      @bounding_boxes[entity_id][:normals]       = normals.pack("f*")
+      @bounding_boxes[entity_id][:colors]        = colors.pack("f*")
+
+      entity.model.objects.each do |mesh|
+        data = {}
+        box = mesh.bounding_box.normalize(entity)
+
+        normals  = mesh_normals
+        colors   = mesh_colors(mesh.debug_color)
+        vertices = mesh_vertices(box)
+
+        @vertex_count += vertices.size
+
+        data[:vertices_size] = vertices.size
+        data[:vertices]      = vertices.pack("f*")
+        data[:normals]       = normals.pack("f*")
+        data[:colors]        = colors.pack("f*")
+
+        @bounding_boxes[entity_id][:objects] << data
+      end
+    end
+
+    def mesh_normals
+      [
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0,
+
+        0, -1, 0,
+        0, -1, 0,
+        0, -1, 0,
+        0, -1, 0,
+        0, -1, 0,
+        0, -1, 0,
+
+        0, 0, 1,
+        0, 0, 1,
+        0, 0, 1,
+        0, 0, 1,
+        0, 0, 1,
+        0, 0, 1,
+
+        1, 0, 0,
+        1, 0, 0,
+        1, 0, 0,
+        1, 0, 0,
+        1, 0, 0,
+        1, 0, 0,
+
+        -1, 0, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+
+        -1, 0, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+
+        -1, 0, 0,
+        -1, 0, 0,
+        -1, 0, 0
+      ]
+    end
+
+    def mesh_colors(color)
+      [
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue,
+        color.red, color.green, color.blue
+      ]
+    end
+
+    def mesh_vertices(box)
+      [
+        box.min.x, box.max.y, box.max.z,
+        box.min.x, box.max.y, box.min.z,
+        box.max.x, box.max.y, box.min.z,
+
+        box.min.x, box.max.y, box.max.z,
+        box.max.x, box.max.y, box.max.z,
+        box.max.x, box.max.y, box.min.z,
+
+        box.max.x, box.min.y, box.min.z,
+        box.max.x, box.min.y, box.max.z,
+        box.min.x, box.min.y, box.max.z,
+
+        box.max.x, box.min.y, box.min.z,
+        box.min.x, box.min.y, box.min.z,
+        box.min.x, box.min.y, box.max.z,
+
+        box.min.x, box.max.y, box.max.z,
+        box.min.x, box.max.y, box.min.z,
+        box.min.x, box.min.y, box.min.z,
+
+        box.min.x, box.min.y, box.max.z,
+        box.min.x, box.min.y, box.min.z,
+        box.min.x, box.max.y, box.max.z,
+
+        box.max.x, box.max.y, box.max.z,
+        box.max.x, box.max.y, box.min.z,
+        box.max.x, box.min.y, box.min.z,
+
+        box.max.x, box.min.y, box.max.z,
+        box.max.x, box.min.y, box.min.z,
+        box.max.x, box.max.y, box.max.z,
+
+        box.min.x, box.max.y, box.max.z,
+        box.max.x, box.max.y, box.max.z,
+        box.max.x, box.min.y, box.max.z,
+
+        box.min.x, box.max.y, box.max.z,
+        box.max.x, box.min.y, box.max.z,
+        box.min.x, box.min.y, box.max.z,
+
+        box.max.x, box.min.y, box.min.z,
+        box.min.x, box.min.y, box.min.z,
+        box.min.x, box.max.y, box.min.z,
+
+        box.max.x, box.min.y, box.min.z,
+        box.min.x, box.max.y, box.min.z,
+        box.max.x, box.max.y, box.min.z
+      ]
+    end
+
+    def draw_bounding_boxes
+      @bounding_boxes.each do |key, bounding_box|
+        glPushMatrix
+
+        glTranslatef(
+          bounding_box[:entity].position.x,
+          bounding_box[:entity].position.y,
+          bounding_box[:entity].position.z
+        )
+        draw_bounding_box(bounding_box)
+        @bounding_boxes[key][:objects].each { |o| draw_bounding_box(o) }
+
+        glPopMatrix
+      end
+    end
+
+    def draw_bounding_box(bounding_box)
+      glEnableClientState(GL_VERTEX_ARRAY)
+      glEnableClientState(GL_COLOR_ARRAY)
+      glEnableClientState(GL_NORMAL_ARRAY)
+
+      glVertexPointer(3, GL_FLOAT, 0, bounding_box[:vertices])
+      glColorPointer(3, GL_FLOAT, 0, bounding_box[:colors])
+      glNormalPointer(GL_FLOAT, 0, bounding_box[:normals])
+
+      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+      glDisable(GL_LIGHTING)
+      glDrawArrays(GL_TRIANGLES, 0, bounding_box[:vertices_size] / 3)
+      glEnable(GL_LIGHTING)
+      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+
+      glDisableClientState(GL_VERTEX_ARRAY)
+      glDisableClientState(GL_COLOR_ARRAY)
+      glDisableClientState(GL_NORMAL_ARRAY)
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+module CyberarmEngine
+  class GBuffer
+    attr_reader :screen_vbo, :vertices, :uvs
+
+    def initialize(width:, height:)
+      @width = width
+      @height = height
+
+      @framebuffer = nil
+      @buffers = %i[position diffuse normal texcoord]
+      @textures = {}
+      @screen_vbo = nil
+      @ready = false
+
+      @vertices = [
+        -1.0, -1.0, 0,
+        1.0,  -1.0, 0,
+        -1.0,  1.0, 0,
+
+        -1.0,  1.0, 0,
+        1.0, -1.0, 0,
+        1.0, 1.0, 0
+      ].freeze
+
+      @uvs = [
+        0, 0,
+        1, 0,
+        0, 1,
+
+        0, 1,
+        1, 0,
+        1, 1
+      ].freeze
+
+      create_framebuffer
+      create_screen_vbo
+    end
+
+    def create_framebuffer
+      buffer = " " * 4
+      glGenFramebuffers(1, buffer)
+      @framebuffer = buffer.unpack1("L2")
+
+      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, @framebuffer)
+
+      create_textures
+
+      status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
+
+      if status != GL_FRAMEBUFFER_COMPLETE
+        message = ""
+
+        message = case status
+                  when GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
+                    "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"
+                  when GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
+                    "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"
+                  when GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
+                    "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER"
+                  when GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
+                    "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER"
+                  when GL_FRAMEBUFFER_UNSUPPORTED
+                    "GL_FRAMEBUFFER_UNSUPPORTED"
+                  else
+                    "Unknown error!"
+                  end
+        puts "Incomplete framebuffer: #{status}\nError: #{message}"
+      else
+        @ready = true
+      end
+
+      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0)
+    end
+
+    def create_textures
+      @buffers.size.times do |i|
+        buffer = " " * 4
+        glGenTextures(1, buffer)
+        texture_id = buffer.unpack1("L2")
+        @textures[@buffers[i]] = texture_id
+
+        glBindTexture(GL_TEXTURE_2D, texture_id)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, @width, @height, 0, GL_RGBA, GL_FLOAT, nil)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, texture_id, 0)
+      end
+
+      buffer = " " * 4
+      glGenTextures(1, buffer)
+      texture_id = buffer.unpack1("L2")
+      @textures[:depth] = texture_id
+
+      glBindTexture(GL_TEXTURE_2D, texture_id)
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32F, @width, @height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nil)
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture_id, 0)
+
+      draw_buffers = [GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3]
+      glDrawBuffers(draw_buffers.size, draw_buffers.pack("I*"))
+    end
+
+    def create_screen_vbo
+      buffer = " " * 4
+      glGenVertexArrays(1, buffer)
+      @screen_vbo = buffer.unpack1("L2")
+
+      buffer = " " * 4
+      glGenBuffers(1, buffer)
+      @positions_buffer_id = buffer.unpack1("L2")
+
+      buffer = " " * 4
+      glGenBuffers(1, buffer)
+      @uvs_buffer_id = buffer.unpack1("L2")
+
+      glBindVertexArray(@screen_vbo)
+      glBindBuffer(GL_ARRAY_BUFFER, @positions_buffer_id)
+      glBufferData(GL_ARRAY_BUFFER, @vertices.size * Fiddle::SIZEOF_FLOAT, @vertices.pack("f*"), GL_STATIC_DRAW)
+      glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
+
+      glBindBuffer(GL_ARRAY_BUFFER, @uvs_buffer_id)
+      glBufferData(GL_ARRAY_BUFFER, @uvs.size * Fiddle::SIZEOF_FLOAT, @uvs.pack("f*"), GL_STATIC_DRAW)
+      glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nil)
+
+      glEnableVertexAttribArray(0)
+      glEnableVertexAttribArray(1)
+
+      glBindVertexArray(0)
+    end
+
+    def bind_for_writing
+      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, @framebuffer)
+    end
+
+    def bind_for_reading
+      glBindFramebuffer(GL_READ_FRAMEBUFFER, @framebuffer)
+    end
+
+    def set_read_buffer(buffer)
+      glReadBuffer(GL_COLOR_ATTACHMENT0 + @textures.keys.index(buffer))
+    end
+
+    def set_read_buffer_depth
+      glReadBuffer(GL_DEPTH_ATTACHMENT)
+    end
+
+    def unbind_framebuffer
+      glBindFramebuffer(GL_FRAMEBUFFER, 0)
+    end
+
+    def texture(type)
+      @textures[type]
+    end
+
+    def clean_up
+      glDeleteFramebuffers(1, [@framebuffer].pack("L"))
+
+      glDeleteTextures(@textures.values.size, @textures.values.pack("L*"))
+
+      glDeleteBuffers(2, [@positions_buffer_id, @uvs_buffer_id].pack("L*"))
+      glDeleteVertexArrays(1, [@screen_vbo].pack("L"))
+      gl_error?
+    end
+  end
+end