mittsu 0.4.0 → 0.5.0

data/lib/mittsu/renderers/generic_lib.rb

@@ -1,122 +0,0 @@
-module Mittsu
-  module GenericLib
-    def discover
-      case OpenGL.get_platform
-      when :OPENGL_PLATFORM_WINDOWS
-        self::Windows.new
-      when :OPENGL_PLATFORM_MACOSX
-        self::MacOS.new
-      when :OPENGL_PLATFORM_LINUX
-        self::Linux.new
-      else
-        warn "WARNING: Unsupported platform: #{OpenGL.get_platform}"
-        Base.new
-      end
-    end
-
-    class Base
-      def path; nil; end
-      def file; nil; end
-    end
-
-    class Linux < Base
-      def path
-        return nil if file_path.nil?
-        File.dirname file_path
-      end
-
-      def file
-        return nil if file_path.nil?
-        File.basename file_path
-      end
-
-      class << self
-        def kernel_module_in_use
-          lspci_line = `lspci -nnk | grep -i vga -A3 | grep 'in use'`
-          /in use:\s*(\S+)/ =~ lspci_line && $1
-        rescue
-          ''
-        end
-
-        def libgl_paths
-          Dir.glob('/usr/lib*/**/libGL.so*')
-        rescue
-          []
-        end
-
-        def sixtyfour_bits?
-          1.size == 8
-        end
-
-        def ldconfig
-          `ldconfig -p | grep 'libGL\\.so'`.lines
-        rescue
-          []
-        end
-      end
-
-      private
-        def file_path
-          @_file_path ||= begin
-            ldconfig_lib || driver_specific_lib || sixtyfour_bit_lib || fallback_lib || give_up
-          end.tap do |result|
-            print_debug_info(result) if DEBUG
-          end
-        end
-
-        def ldconfig_lib
-          return nil if ldconfig.empty?
-          @_debug = { source: 'ldconfig', info: ldconfig.inspect } if DEBUG
-          ldconfig_for_arch = ldconfig.reject { |lib| @loader.sixtyfour_bits? ^ ldconfig_64?(lib) }
-          ldconfig_for_arch.first.match(/=> (\/.*)$/)[1]
-        end
-
-        def ldconfig_64?(lib)
-          lib =~ /\([^\)]*64[^\)]*\) =>/
-        end
-
-        def driver_specific_lib
-          return nil if libs.empty?
-          @_debug = { source: 'driver', info: kernel_module } if DEBUG
-          libs.select { |lib| lib =~ /nvidia/ }.first if kernel_module =~ /nvidia/
-        end
-
-        def sixtyfour_bit_lib
-          return nil if libs.empty?
-          sixtyfour_bit_libs = libs.select { |lib| lib =~ /64/ }
-          @_debug = { source: '64', info: sixtyfour_bit_libs.inspect } if DEBUG
-          sixtyfour_bit_libs.first if @loader.sixtyfour_bits?
-        end
-
-        def fallback_lib
-          return nil if libs.empty?
-          @_debug = { source: 'fallback', info: libs.inspect } if DEBUG
-          libs.first
-        end
-
-        def give_up
-          @_debug = { source: 'none', info: nil } if DEBUG
-          nil
-        end
-
-        def kernel_module
-          @_kernel_module ||= @loader.kernel_module_in_use
-        end
-
-        def libs
-          @_libs ||= @loader.libgl_paths.sort_by(&:length)
-        end
-
-        def ldconfig
-          @_ldconfig ||= @loader.ldconfig
-        end
-
-        def print_debug_info(result)
-          puts "Loading lib path: #{result.inspect}"
-          puts "Source: #{@_debug[:source]}"
-          puts "Info: #{@_debug[:info]}"
-          puts "64-bit? #{@loader.sixtyfour_bits?}"
-        end
-    end
-  end
-end

data/lib/mittsu/renderers/glfw_lib.rb

@@ -1,62 +0,0 @@
-require 'mittsu/renderers/generic_lib'
-
-module Mittsu
-  module GLFWLib
-    extend GenericLib
-
-    class Linux < GenericLib::Linux
-      def initialize(loader = Linux)
-        @loader = loader
-      end
-
-      class << self
-        def libgl_paths
-          Dir.glob('/usr/lib*/**/libglfw*.so*')
-        rescue
-          []
-        end
-
-        def ldconfig
-          `ldconfig -p | grep 'libglfw3\\?\\.so'`.lines
-        rescue
-          []
-        end
-      end
-    end
-
-    class Windows < GenericLib::Base
-      def file
-        'glfw3.dll'
-      end
-    end
-
-    class MacOS < GenericLib::Base
-      SEARCH_GLOBS = ['/usr/local/lib/**',
-                      '/usr/lib/**',
-                      '/opt/homebrew/**']
-
-      def path
-        File.dirname(match)
-      end
-
-      def file
-        File.basename(match)
-      end
-
-      private
-
-        def match
-          @match ||= find_match
-        end
-
-        def find_match
-          SEARCH_GLOBS.each do |glob|
-            matches = Dir.glob("#{glob}/libglfw*.dylib")
-            next if matches.empty?
-
-            return matches.find { |m| m.end_with?('libglfw3.dylib') || m.end_with?('libglfw.3.dylib') } || matches.first
-          end
-        end
-    end
-  end
-end

data/lib/mittsu/renderers/glfw_window.rb

@@ -1,233 +0,0 @@
-require 'opengl'
-require 'glfw'
-
-require 'mittsu/utils'
-require 'mittsu/renderers/glfw_lib'
-glfw_lib = Mittsu::GLFWLib.discover
-GLFW.load_lib(ENV["MITTSU_LIBGLFW_FILE"] || glfw_lib.file, ENV["MITTSU_LIBGLFW_PATH"] || glfw_lib.path) unless Mittsu.test?
-
-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, antialias: 0)
-        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
-
-        if antialias > 0
-          glfwWindowHint GLFW_SAMPLES, antialias
-        end
-
-        @width, @height, @title = width, height, title
-        @handle = glfwCreateWindow(@width, @height, @title, nil, nil)
-        if @handle.null?
-          raise "Unable to create window."
-        end
-        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
-
-      def set_mouselock(value)
-        if value
-          glfwSetInputMode(@handle, GLFW_CURSOR, GLFW_CURSOR_DISABLED)
-        else
-          glfwSetInputMode(@handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL)
-        end
-      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

data/lib/mittsu/renderers/opengl/core/buffer_geometry.rb

@@ -1,11 +0,0 @@
-module Mittsu
-  class BufferGeometry
-    include OpenGLGeometryLike
-
-    attr_accessor :initted
-
-    def init
-      @initted = true
-    end
-  end
-end