mittsu 0.1.0

data/lib/mittsu/objects/mesh.rb

@@ -0,0 +1,243 @@
+require 'mittsu/core'
+require 'mittsu/materials'
+
+module Mittsu
+  class Mesh < Object3D
+    attr_accessor :material, :morph_target_base
+
+    def initialize(geometry = Geometry.new, material = MeshBasicMaterial.new(color: rand * 0xffffff))
+      super()
+
+      @type = 'Mesh'
+
+      @geometry, @material = geometry, material
+
+      update_morph_targets
+    end
+
+    def update_morph_targets
+      if !@morph_targets.nil? && !@morph_targets.empty?
+        @morph_targets_base = -1
+        @morph_target_forced_order = []
+        @morph_targets_influences = []
+        @morph_targets_dictionary = {}
+
+        @geometry.morph_targets.each_with_index do |target, m|
+          @morph_targets_influences << 0
+          @morph_targets_dictionary[target.name] = m
+        end
+
+        def morph_target_index_by_name(name)
+          morph_target_index = @morph_targets_dictionary[name]
+          return morph_target_index unless morph_target_index.nil?
+
+          puts "WARNING: Mittsu::Mest#morph_target_index_by_name: morph target #{name} does not exist. Returning 0."
+          0
+        end
+      end
+    end
+
+    def raycast(raycaster, intersects)
+      @_inverse_matrix = Matrix4.new
+      @_ray = Ray.new
+      @_sphere = Sphere.new
+
+      @_v_a = Vector3.new
+      @_v_b = Vector3.new
+      @_v_c = Vector3.new
+
+      # Checking bounding_sphere distance to ray
+
+      @geometry.compute_bounding_sphere if @geometry.bounding_sphere.nil?
+
+      sphere.copy(geometry.bounding_sphere)
+      sphere.apply_matrix4(@matrix_world)
+
+      return unless raycaster.intersection_sphere?(sphere)
+
+      # check bounding box before continuing
+
+      inverse_matrix.inverse(@matrix_world)
+      ray.copy(raycaster.ray).apply_matrix4(inverse_matrix)
+
+      if !geometry.bounding_bounding_box
+        return unless ray.intersection_box?(geometry.bounding_box)
+      end
+
+      if geometry.is_a?(BufferGeometry)
+        return if @material.nil?
+
+        attributes = geometry.attributes
+        precision = raycaster.precision
+
+        if !attributes[:index].nil?
+          indices = attributes[:index].array
+          positions = attributes[:position].array
+          offsets = geometry.offsets
+
+          offsets = [BufferGeometry::DrawCall.new(0, indices.length, 0)]
+
+          @offsets.each_with_index do |index, oi|
+            start = offsets[oi].start
+            count = offsets[oi].count
+            index = offsets[oi].index
+
+            i = start
+            il = start + count
+            while i < il
+              a = index + indices[i]
+              b = index + indices[i + 1]
+              c = index + indices[i + 2]
+
+              v_a.from_array(positions, a * 3)
+              v_b.from_array(positions, b * 3)
+              v_c.from_array(positions, c * 3)
+
+              if material.side = BackSide
+                intersection_point = ray.intersect_triangle(v_c, v_b, v_a, true)
+              else
+                intersection_point = ray.intersect_triangle(v_a, v_b, v_c, material.side != DoubleSide)
+              end
+
+              next if intersect_point.nil?
+
+              intersection_point.apply_matrix4(@matrix_world)
+
+              distance = racaster.ray.origin.distance_to(intersection_point)
+
+              next if distance < precision || distance < raycaster.near || distance > raycaster.far
+
+              intersects << {
+                distance: distance,
+                point: intersection_point,
+                face: Face.new(a, b, c, Triangle.normal(v_a, v_b, v_c)),
+                face_index: nil,
+                object: self
+              }
+              i += 3
+            end
+          end
+        else
+          positions = attributes[:position].array
+
+          i = 0
+          j = 0
+          il = positions.length
+          while i < il
+            a = i
+            b = i + 1
+            c = i + 2
+
+            v_a.from_array(positions, j)
+            v_b.from_array(positions, j + 3)
+            v_c.from_array(positions, j + 6)
+
+            if material.side = BackSide
+              intersection_point = ray.intersect_triangle(v_c, v_b, v_a, true)
+            else
+              intersection_point = ray.intersect_triangle(v_a, v_b, v_c, material.side != DoubleSide)
+            end
+
+            next if intersect_point.nil?
+
+            intersection_point.apply_matrix4(@matrix_world)
+
+            distance = racaster.ray.origin.distance_to(intersection_point)
+
+            next if distance < precision || distance < raycaster.near || distance > raycaster.far
+
+            intersects << {
+              distance: distance,
+              point: intersection_point,
+              face: Face.new(a, b, c, Triangle.normal(v_a, v_b, v_c)),
+              face_index: nil,
+              object: self
+            }
+
+            i += 3
+            j += 9
+          end
+        end
+      elsif geometry.is_a? Geometry
+        is_face_material = @material.is_a? MeshFaceMaterial
+        object_materials = is_face_material ? @material.materials : nil
+
+        precision = raycaster.precision
+
+        vertices = geometry.vertices
+
+        geometry.faces.each do |face|
+          material = is_face_material ? object_materials[face.material_index] : @material
+          next if material.nil?
+
+          a = vertices[face.a]
+          b = vertices[face.b]
+          c = vertices[face.c]
+
+          if material.morph_targets
+            morph_targets = geometry.morph_targets
+            morph_influences
+
+            v_a.set(0.0, 0.0, 0.0)
+            v_b.set(0.0, 0.0, 0.0)
+            v_c.set(0.0, 0.0, 0.0)
+
+            morph_targets.each_with_index do |morph_target, t|
+              influence = morph_influences[t]
+              next if influence.zero?
+
+              targets = morph_target.vertices
+
+              v_a.x += (targets[face.a].x - a.x) * influence
+              v_a.y += (targets[face.a].y - a.y) * influence
+              v_a.z += (targets[face.a].z - a.z) * influence
+
+              v_b.x += (targets[face.b].x - b.x) * influence
+              v_b.y += (targets[face.b].y - b.y) * influence
+              v_b.z += (targets[face.b].z - b.z) * influence
+
+              v_c.x += (targets[face.c].x - c.x) * influence
+              v_c.y += (targets[face.c].y - c.y) * influence
+              v_c.z += (targets[face.c].z - c.z) * influence
+            end
+
+            v_a.add(a)
+            v_b.add(b)
+            v_c.add(c)
+
+            a = v_a
+            b = v_b
+            c = v_c
+          end
+
+          if material.side = BackSide
+            intersection_point = ray.intersect_triangle(v_c, v_b, v_a, true)
+          else
+            intersection_point = ray.intersect_triangle(v_a, v_b, v_c, material.side != DoubleSide)
+          end
+
+          next if intersect_point.nil?
+
+          intersection_point.apply_matrix4(@matrix_world)
+
+          distance = racaster.ray.origin.distance_to(intersection_point)
+
+          next if distance < precision || distance < raycaster.near || distance > raycaster.far
+
+          intersects << {
+            distance: distance,
+            point: intersection_point,
+            face: face,
+            face_index: f,
+            object: self
+          }
+        end
+      end
+    end
+
+    def clone(object = Mesh.new(@geometry, @material), recursive = true)
+      super(object, recursive)
+      return object
+    end
+  end
+end

data/lib/mittsu/renderers.rb

@@ -0,0 +1 @@
+require 'mittsu/renderers/opengl_renderer'

data/lib/mittsu/renderers/glfw_window.rb

@@ -0,0 +1,216 @@
+require 'opengl'
+require 'glfw'
+
+path = `pkg-config glfw3 --libs-only-L`.chomp.strip[2..-1]
+GLFW.load_lib('libglfw3.dylib', path)
+
+include GLFW
+
+module Mittsu
+  module GLFW
+    class Window
+      attr_accessor :key_press_handler, :key_release_handler, :key_repeat_handler, :char_input_handler, :cursor_pos_handler, :mouse_button_press_handler, :mouse_button_release_handler, :scroll_handler, :framebuffer_size_handler
+
+      def initialize(width, height, title)
+        glfwInit
+
+        glfwWindowHint GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE
+        glfwWindowHint GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE
+        glfwWindowHint GLFW_CONTEXT_VERSION_MAJOR, 3
+        glfwWindowHint GLFW_CONTEXT_VERSION_MINOR, 3
+        glfwWindowHint GLFW_CONTEXT_REVISION, 0
+
+        @width, @height, @title = width, height, title
+        @handle = glfwCreateWindow(@width, @height, @title, nil, nil)
+        glfwMakeContextCurrent @handle
+        glfwSwapInterval 1
+
+        this = self
+        @key_callback = ::GLFW::create_callback(:GLFWkeyfun) do |window_handle, key, scancode, action, mods|
+          if action == GLFW_PRESS
+            this.key_press_handler.call(key) unless this.key_press_handler.nil?
+            this.key_repeat_handler.call(key) unless this.key_repeat_handler.nil?
+          elsif action == GLFW_RELEASE
+            this.key_release_handler.call(key) unless this.key_release_handler.nil?
+          elsif action == GLFW_REPEAT
+            this.key_repeat_handler.call(key) unless this.key_repeat_handler.nil?
+          end
+        end
+        glfwSetKeyCallback(@handle, @key_callback)
+
+        @char_callback = ::GLFW::create_callback(:GLFWcharfun) do |window_handle, codepoint|
+          char = [codepoint].pack('U')
+          this.char_input_handler.call(char) unless this.char_input_handler.nil?
+        end
+        glfwSetCharCallback(@handle, @char_callback)
+
+        @cursor_pos_callback = ::GLFW::create_callback(:GLFWcursorposfun) do |window_handle, xpos, ypos|
+          this.cursor_pos_handler.call(Vector2.new(xpos, ypos)) unless this.cursor_pos_handler.nil?
+        end
+        glfwSetCursorPosCallback(@handle, @cursor_pos_callback)
+
+        @mouse_button_callback = ::GLFW::create_callback(:GLFWmousebuttonfun) do |window_handle, button, action, mods|
+          mpos = this.mouse_position
+          if action == GLFW_PRESS
+            this.mouse_button_press_handler.call(button, mpos) unless this.mouse_button_press_handler.nil?
+          elsif action == GLFW_RELEASE
+            this.mouse_button_release_handler.call(button, mpos) unless this.mouse_button_release_handler.nil?
+          end
+        end
+        glfwSetMouseButtonCallback(@handle, @mouse_button_callback)
+
+        @scroll_callback = ::GLFW::create_callback(:GLFWscrollfun) do |window_handle, xoffset, yoffset|
+          this.scroll_handler.call(Vector2.new(xoffset, yoffset)) unless this.scroll_handler.nil?
+        end
+        glfwSetScrollCallback(@handle, @scroll_callback)
+
+        @frabuffer_size_callback = ::GLFW::create_callback(:GLFWframebuffersizefun) do |window_handle, new_width, new_height|
+          this.framebuffer_size_handler.call(new_width, new_height) unless this.framebuffer_size_handler.nil?
+        end
+        glfwSetFramebufferSizeCallback(@handle, @frabuffer_size_callback)
+
+        @joystick_buttons = poll_all_joysticks_buttons
+      end
+
+      def run
+        while glfwWindowShouldClose(@handle) == 0
+          yield
+
+          glfwSwapBuffers @handle
+          glfwPollEvents
+          poll_joystick_events
+        end
+        glfwDestroyWindow @handle
+        glfwTerminate
+      end
+
+      def framebuffer_size
+        width, height = ' '*8, ' '*8
+        glfwGetFramebufferSize(@handle, width, height)
+        [width.unpack('L')[0], height.unpack('L')[0]]
+      end
+
+      def on_key_pressed &block
+        @key_press_handler = block
+      end
+
+      def on_key_released &block
+        @key_release_handler = block
+      end
+
+      def on_key_typed &block
+        @key_repeat_handler = block
+      end
+
+      def key_down?(key)
+        glfwGetKey(@handle, key) == GLFW_PRESS
+      end
+
+      def on_character_input &block
+        @char_input_handler = block
+      end
+
+      def on_mouse_move &block
+        @cursor_pos_handler = block
+      end
+
+      def on_mouse_button_pressed &block
+        @mouse_button_press_handler = block
+      end
+
+      def on_mouse_button_released &block
+        @mouse_button_release_handler = block
+      end
+
+      def mouse_position
+        xpos, ypos = ' '*8, ' '*8
+        glfwGetCursorPos(@handle, xpos, ypos);
+        Vector2.new(xpos.unpack('D')[0], ypos.unpack('D')[0])
+      end
+
+      def mouse_button_down?(button)
+        glfwGetMouseButton(@handle, button) == GLFW_PRESS
+      end
+
+      def on_scroll &block
+        @scroll_handler = block
+      end
+
+      def on_resize &block
+        @framebuffer_size_handler = block
+      end
+
+      def joystick_buttons(joystick = GLFW_JOYSTICK_1)
+        @joystick_buttons = poll_all_joysticks_buttons
+        @joystick_buttons[joystick]
+      end
+
+      def joystick_axes(joystick = GLFW_JOYSTICK_1)
+        return [] unless joystick_present?(joystick)
+        count = ' ' * 4
+        array = glfwGetJoystickAxes(joystick, count)
+        count = count.unpack('l')[0]
+        array[0, count * 4].unpack('f' * count)
+      end
+
+      def on_joystick_button_pressed &block
+        @joystick_button_press_handler = block
+      end
+
+      def on_joystick_button_released &block
+        @joystick_button_release_handler = block
+      end
+
+      def joystick_present?(joystick = GLFW_JOYSTICK_1)
+        glfwJoystickPresent(joystick).nonzero?
+      end
+
+      def joystick_button_down?(button, joystick = GLFW_JOYSTICK_1)
+        @joystick_buttons[joystick][button]
+      end
+
+      def joystick_name(joystick = GLFW_JOYSTICK_1)
+        glfwGetJoystickName(joystick)
+      end
+
+      private
+
+      def poll_all_joysticks_buttons
+        (GLFW_JOYSTICK_1..GLFW_JOYSTICK_LAST).map do |joystick|
+          poll_joystick_buttons(joystick)
+        end
+      end
+
+      def poll_joystick_buttons(joystick)
+        return nil unless joystick_present?(joystick)
+        count = ' ' * 4
+        array = glfwGetJoystickButtons(joystick, count)
+        count = count.unpack('l')[0]
+        array[0, count].unpack('c' * count).map(&:nonzero?)
+      end
+
+      def poll_joystick_events
+        new_joystick_buttons = poll_all_joysticks_buttons
+        new_joystick_buttons.each_with_index do |buttons, joystick|
+          poll_single_joystick_events(joystick, buttons)
+        end
+        @joystick_buttons = new_joystick_buttons
+      end
+
+      def poll_single_joystick_events(joystick, buttons)
+        return if buttons.nil?
+        buttons.each_with_index do |pressed, button|
+          fire_joystick_button_event(joystick, button, pressed)
+        end
+      end
+
+      def fire_joystick_button_event(joystick, button, pressed)
+        if !@joystick_buttons[joystick][button] && pressed
+          @joystick_button_press_handler.call(joystick, button) unless @joystick_button_press_handler.nil?
+        elsif @joystick_buttons[joystick][button] && !pressed
+          @joystick_button_release_handler.call(joystick, button) unless @joystick_button_release_handler.nil?
+        end
+      end
+    end
+  end
+end