mittsu 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3a8c66b2c63737be22e4495e20bc62888391dc63907e604d31eb8cbbf5fa432
-  data.tar.gz: f88e54369ac3e9c2b0534135f485310469d5dd37889504cf049eb23223cf0f2a
+  metadata.gz: 620d1bf034251f9514abec4fb1e28357bccbe984f517d6763c5f1e544e3c9728
+  data.tar.gz: 157868417127b487b51b8ccbc1bfa901063f557915a3f0f66f43f0a6cfe600da
 SHA512:
-  metadata.gz: ea2ee4ab085e40061f432ed835f8f40948557467f85f33b7b4238a2d18cc4756ac43bb052d6631e4d8707f62d1ebce382cf5790727c28b257b73f71a08446458
-  data.tar.gz: fb77a518a9002b201a52590be84e13b9b57c1716b2e13d5c38b0d81265c6c26d8e440fb700d92e3759f8bfbd5323435c28dd780497da133fba4a09023800b3fd
+  metadata.gz: 611d3f4d2aa790e21f04cd22b45b3a8ed3901dbc60e97e1a2f72574bdb846d12773b552397131cda37471f39ed97d4702f0976ca83438d2202f1439e0e722b6e
+  data.tar.gz: 0d2fd2ab7d43a2ebbe523103b33fc1ce8a0bcd3ce046f2c82fd2e633e8e2b6b80cfede3ffc7758a82d753d69afb7f75c3ce49f69aa278161dbb1586603c017a6

data/.github/workflows/build-workflow.yml

@@ -8,24 +8,20 @@ on:
       - main
 
 jobs:
-  linux:
-    name: Linux
+  test:
+    name: Test
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', 'head']
+        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', '3.3', 'head']
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - run: sudo apt-get update; sudo apt-get install cmake xorg-dev libgl1-mesa-dev
-      - run: bash install-glfw.sh
-      - run: gem install bundler
-      - run: bundle install --path vendor/bundle
       - name: Test & publish code coverage
-        uses: paambaati/codeclimate-action@v2.2.1
+        uses: paambaati/codeclimate-action@v9.0.0
         if: github.event_name == 'push'
         env:
           CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
@@ -34,38 +30,3 @@ jobs:
       - name: Test
         if: github.event_name != 'push'
         run: bundle exec rake test
-
-  macos:
-    name: macOS
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', 'head']
-    steps:
-      - uses: actions/checkout@v1
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - run: brew install glfw
-      - run: bundle install --path vendor/bundle
-      - run: bundle exec rake test
-
-  windows:
-    name: Windows
-    runs-on: windows-latest
-    env:
-      MITTSU_LIBGLFW_PATH: c:\projects\mittsu\glfw-3.3.1.bin.WIN32\lib-mingw
-    strategy:
-      matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', 'head']
-    steps:
-      - uses: actions/checkout@v1
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - run: .\install-glfw.ps1
-      - run: gem install bundler
-      - run: bundle install --path vendor/bundle
-      - run: bundle exec rake test

data/Gemfile

@@ -1,7 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-if /darwin/ === RUBY_PLATFORM
-  gem 'ffi', '~> 1.9', '!= 1.11.1'
-end

data/README.md

@@ -1,13 +1,13 @@
 # Mittsu
 
 [![Gem Version](https://badge.fury.io/rb/mittsu.svg)](https://badge.fury.io/rb/mittsu)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/22be300984d81fa10af8/test_coverage)](https://codeclimate.com/github/danini-the-panini/mittsu/test_coverage)
-[![Maintainability](https://api.codeclimate.com/v1/badges/22be300984d81fa10af8/maintainability)](https://codeclimate.com/github/danini-the-panini/mittsu/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/339a016dc2e7fc51c82a/test_coverage)](https://codeclimate.com/github/danini-the-panini/mittsu/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/339a016dc2e7fc51c82a/maintainability)](https://codeclimate.com/github/danini-the-panini/mittsu/maintainability)
 [![Build Status](https://github.com/danini-the-panini/mittsu/workflows/Build/badge.svg)](https://github.com/danini-the-panini/mittsu/actions?query=workflow%3A%22Build%22)
 
 3D Graphics Library for Ruby
 
-Mittsu makes 3D graphics easier by providing an abstraction over OpenGL, and is based heavily off of [THREE.js](http://threejs.org). No more weird pointers and wondering about the difference between a VAO and a VBO (besides the letter). Simply think of something awesome and make it!
+Mittsu is a 3D Graphics Library for Ruby, based heavily on Three.js
 
 ## GIFs!
 
@@ -19,26 +19,6 @@ Mittsu makes 3D graphics easier by providing an abstraction over OpenGL, and is
 
 ## Installation
 
-Install the prerequisites:
-
-Mittsu depends on Ruby 2.x, OpenGL 3.3+, and GLFW 3.1.x
-
-```bash
-# OSX
-$ brew install glfw3
-
-# Ubuntu
-$ sudo apt-get install libglfw3
-```
-
-**NOTE:** On Windows, you will have to manually specify the glfw3.dll path in an environment variable
-(you can download it [here](http://www.glfw.org/download.html))
-```bash
-# ex) set MITTSU_LIBGLFW_PATH=C:\Users\username\lib-mingw-w64
-> set MITTSU_LIBGLFW_PATH=C:\path\to\glfw3.dll
-> ruby your_awesome_mittsu_app.rb
-```
-
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -55,22 +35,14 @@ Or install it yourself as:
 
 ## Usage
 
-### tl;dr
-
-Copy-Paste and Run:
+Create a basic scene with a perspective camera and a green box:
 
 ```ruby
 require 'mittsu'
 
-SCREEN_WIDTH = 800
-SCREEN_HEIGHT = 600
-ASPECT = SCREEN_WIDTH.to_f / SCREEN_HEIGHT.to_f
-
-renderer = Mittsu::OpenGLRenderer.new width: SCREEN_WIDTH, height: SCREEN_HEIGHT, title: 'Hello, World!'
-
 scene = Mittsu::Scene.new
 
-camera = Mittsu::PerspectiveCamera.new(75.0, ASPECT, 0.1, 1000.0)
+camera = Mittsu::PerspectiveCamera.new(75.0, 1.0, 0.1, 1000.0)
 camera.position.z = 5.0
 
 box = Mittsu::Mesh.new(
@@ -79,116 +51,30 @@ box = Mittsu::Mesh.new(
 )
 
 scene.add(box)
-
-renderer.window.run do
-  box.rotation.x += 0.1
-  box.rotation.y += 0.1
-
-  renderer.render(scene, camera)
-end
-```
-
-### Step by Step
-
-First, we need to require Mittsu in order to use it:
-```ruby
-require 'mittsu'
-```
-
-Then, we'll define some constants to help us with setting up our 3D environment:
-```ruby
-SCREEN_WIDTH = 800
-SCREEN_HEIGHT = 600
-ASPECT = SCREEN_WIDTH.to_f / SCREEN_HEIGHT.to_f
-```
-
-The aspect ratio will be used for setting up the camera later.
-
-Once we have all that we can create the canvas we will use to draw our graphics onto. In Mittsu this is called a renderer. It provides a window and an OpenGL context:
-
-```ruby
-renderer = Mittsu::OpenGLRenderer.new width: SCREEN_WIDTH, height: SCREEN_HEIGHT, title: 'Hello, World!'
-```
-This will give us an 800x600 window with the title `Hello, World!`.
-
-Now that we have our canvas, let's start setting up the scene we wish to draw onto it:
-
-```ruby
-scene = Mittsu::Scene.new
 ```
 
-A scene is like a stage where all our 3D objects live and animate.
-
-We can't draw a 3D scene without knowing where we're looking:
-
-```ruby
-camera = Mittsu::PerspectiveCamera.new(75.0, ASPECT, 0.1, 1000.0)
-```
-
-This camera has a 75° field-of-view (FOV), the aspect ratio of the window (which we defined earlier), and shows everything between a distance of 0.1 to 1000.0 away from the camera.
-
-The camera starts off at the origin `[0,0,0]` and faces the negative Z-axis. We'll position it somewhere along the positive Z-axis so that it is looking at the center of the scene from a short distance:
+## More Resources
 
-```ruby
-camera.position.z = 5.0
-```
-
-Our scene isn't going to be very exciting if there is nothing in it, so we'll create a box:
-
-```ruby
-box = Mittsu::Mesh.new(
-  Mittsu::BoxGeometry.new(1.0, 1.0, 1.0),
-  Mittsu::MeshBasicMaterial.new(color: 0x00ff00)
-)
-```
-
-A `Mesh` in Mittsu is the combination of a `Geometry` (the shape of the object) and a `Material` (the "look" of the object). Here we've created a 1x1x1 box that is colored green.
-
-Box in hand, we make it part of our scene:
-
-```ruby
-scene.add(box)
-```
-
-Here comes the fun part... the render loop!
-
-```ruby
-renderer.window.run do
-```
-
-The given block is called every frame. This is where you can tell the renderer what scene to draw, and do any updates to the objects in your scene.
-
-Just to make things a bit more interesting, we'll make the box rotate around its X and Y axes, so that it spins like crazy.
-
-```ruby
-box.rotation.x += 0.1
-box.rotation.y += 0.1
-```
-
-Last but not least, we tell the renderer to draw our scene this frame, which will tell the graphics processor to draw our green box with its updated rotation.
-
-```ruby
-renderer.render(scene, camera)
-```
-
-Easy peasy! :)
+Mittsu follows a similar structure to THREE.js, so you can generally use [the same documentation](http://threejs.org/docs/) for a description of the various classes and how they work.
 
-```ruby
-end
-```
+If you want to actually render scenes, you'll need a renderer. There is a reference OpenGL renderer [here](https://github.com/danini-the-panini/mittsu-opengl).
 
+## See also
 
-### More Resources
+- [Tank Demo](https://github.com/danini-the-panini/mittsu-tank-demo)
+- [OpenGL Renderer](https://github.com/danini-the-panini/mittsu-opengl)
+- [Mesh Analysis](https://github.com/manyfold3d/mittsu-mesh_analysis)
+- [3MF Support](https://github.com/manyfold3d/mittsu-3mf)
 
-Mittsu follows a similar structure to THREE.js, so you can generally use [the same documentation](http://threejs.org/docs/) for a description of the various classes and how they work.
+## Where is Mittsu used?
 
-If you just want to see what Mittsu can do and how to do it, take a peek inside the `examples` folder.
+- [Manyfold](https://github.com/manyfold3d/manyfold) - A self-hosted digital asset manager for 3d print files.
 
 ## Where you can help
 
 1. Testing!
 
-    Currently the only unit tests are for most of the maths library, otherwise the library is tested by running the examples and checking that they look correct.
+    Currently the only unit tests are for most of the maths library.
 
 2. Refactoring!
 

data/bin/console

@@ -6,9 +6,5 @@ require "mittsu"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
 require "irb"
 IRB.start

data/lib/mittsu/cameras/cube_camera.rb

@@ -40,7 +40,7 @@ module Mittsu
       @camera_nz.look_at(Mittsu::Vector3.new(0.0, 0.0, -1.0))
       self.add(@camera_nz)
 
-      @render_target = Mittsu::OpenGLRenderTargetCube(cube_resolution, cube_resolution, format: Mittsu::RGBFormat, mag_filter: Mittsu::LinearFilter, min_filter: Mittsu::LinearFilter)
+      @render_target = Mittsu::RenderTargetCube(cube_resolution, format: Mittsu::RGBFormat, mag_filter: Mittsu::LinearFilter, min_filter: Mittsu::LinearFilter)
     end
 
     def update_cube_map(renderer, scene)

data/lib/mittsu/core/geometry.rb

@@ -397,7 +397,7 @@ module Mittsu
     end
 
     def merge_mesh(mesh)
-      if mesh instanceof Mittsu::Mesh == false
+      if mesh.is_a?(Mittsu::Mesh) == false
         puts('ERROR: Mittsu::Geometry#merge_mesh: mesh not an instance of Mittsu::Mesh.', mesh.inspect)
         return
       end
@@ -469,7 +469,7 @@ module Mittsu
       end
       vertices = []
       @vertices.each do |vert|
-        vertices << vertex.x << vertex.y << vertex.z
+        vertices << vert.x << vert.y << vert.z
       end
       faces = []
       normals = []
@@ -507,7 +507,7 @@ module Mittsu
           faces << get_uv_index(face_vertex_uvs[2], uvs_hash, uvs)
         end
         if has_face_normal
-          faces << get_normal_index(face.normal)
+          faces << get_normal_index(face.normal, normals_hash, normals)
         end
         if has_face_vertex_normal
           vertex_normals = face.vertex_normals

data/lib/mittsu/core/object_3d.rb

@@ -305,17 +305,13 @@ module Mittsu
     end
 
     def to_json
-      @_output = {
+      {
         metadata: {
           version: 4.3,
           type: 'Object',
           generator: 'ObjectExporter'
-        }
-      }
-      @_geometries = {}
-      @_materials = {}
-      @_output[:object] = self.jsonify
-      @_output
+        },
+      }.merge(jsonify)
     end
 
     def clone(object = nil, recursive = true)
@@ -346,46 +342,32 @@ module Mittsu
     protected
 
     def jsonify
-      data = {
-        uuid: @uuid,
-        type: @type,
-        matrix: @matrix.to_a
-      }
-      data[:name] = @name unless @name.nil? || @name.empty?
-      data[:user_data] = @user_data unless @user_data.nil? || @user_data.empty?
-      data[:visible] = @visible unless @visible
-
-      if !self.children.empty?
-        data[:children] = @children.map do |child|
-          child.jsonify
-        end
-      end
-
-      # TODO: implement jsonify for PointCloud
-
-      data
-    end
-
-    def jsonify_geometry(geometry)
-      @_output[:geometries] ||= []
-      if @_geometries[geometry.uuid].nil?
-        json = geometry.to_json
-        json.delete :metadata
-        @_geometries[geometry.uuid] = json
-        @_output[:geometries] << json
-      end
-      geometry.uuid
-    end
-
-    def jsonify_material(material)
-      @_output[:materials] ||= []
-      if @_materials[material.uuid].nil?
-        json = material.to_json
-        json.delete :metadata
-        @_materials[material.uuid] = json
-        @_output[:materials] << json
-      end
-      material.uuid
+      children = @children.map(&:to_json)
+      {
+        object: {
+          uuid: @uuid,
+          type: @type,
+          matrix: @matrix.to_a,
+          geometry: @geometry&.uuid,
+          material: @material&.uuid,
+          name: @name&.empty? ? nil : @name,
+          user_data: @user_data&.empty? ? nil : @user_data,
+          visible: @visible ? nil : @visible,
+          children: children.map { |x| x[:object] }.flatten
+        }.reject { |k,v| v.nil? || v == [] },
+        geometries: ([jsonify_geometry] + children.map { |x| x[:geometries] }).flatten.compact,
+        materials: ([jsonify_material] + children.map { |x| x[:materials] }).flatten.compact
+      }.reject { |k,v| v.nil? || v == [] }
+    end
+
+    def jsonify_geometry
+      return nil if @geometry.nil?
+      @geometry.to_json.delete_if {|k, v| k == :metadata }
+    end
+
+    def jsonify_material
+      return nil if @material.nil?
+      @material.to_json.delete_if {|k, v| k == :metadata }
     end
   end
 end

data/lib/mittsu/core/uniform.rb

@@ -0,0 +1,23 @@
+module Mittsu
+  class Uniform
+    attr_accessor :type, :value, :needs_update, :array
+
+    def initialize(type, value)
+      super()
+      @type, @value = type, value
+      @needs_update = nil
+    end
+
+    def clone
+      new_value = case self.value
+      when Color, Vector2, Vector3, Vector4, Matrix4#, Texture # TODO: when Texture exists
+        self.value.clone
+      when Array
+        self.value.dup
+      else
+        self.value
+      end
+      Uniform.new(self.type, new_value)
+    end
+  end
+end

data/lib/mittsu/core.rb

@@ -8,3 +8,4 @@ require "mittsu/core/geometry"
 require "mittsu/core/object_3d"
 require "mittsu/core/raycaster"
 require "mittsu/core/hash_array"
+require "mittsu/core/uniform"

data/lib/mittsu/loaders/obj_loader.rb

@@ -53,7 +53,7 @@ module Mittsu
 
       when FACE_PATTERN         then parse_face(line)
 
-      when OBJECT_PATTERN       then new_object($1) and reset_vertices
+      when OBJECT_PATTERN       then handle_object($1)
       when GROUP_PATTERN        # ignore
       when SMOOTH_GROUP_PATTERN # ignore
 
@@ -105,9 +105,15 @@ module Mittsu
       raw_lines.split("\n").map(&:strip).reject(&:empty?).reject{|l| l.start_with? '#'}
     end
 
-    def new_object(object_name = '')
-      end_object
-      @object = Object3D.new
+    def handle_object(object_name = '')
+      # Reset if we're already working on a named object
+      # otherwise, just name the one we have in progress
+      unless @object&.name.nil?
+        end_object
+        reset_vertices
+        @object = nil
+      end
+      @object ||= Object3D.new
       @object.name = object_name
     end
 
@@ -120,7 +126,7 @@ module Mittsu
 
     def new_mesh
       end_mesh
-      new_object if @object.nil?
+      handle_object if @object.nil?
       @geometry = Geometry.new
       @mesh = Mesh.new(@geometry, @material || MeshLambertMaterial.new)
       @mesh.name = @object.name

data/lib/mittsu/loaders/stl_loader.rb

@@ -0,0 +1,186 @@
+require 'stringio'
+
+module Mittsu
+  class STLLoader
+    include EventDispatcher
+
+    FLOAT = /[\d|.|+|\-|e]+/
+    NORMAL_PATTERN = /normal\s+(#{FLOAT})\s+(#{FLOAT})\s+(#{FLOAT})/
+    VERTEX_PATTERN = /^\s*vertex\s+(#{FLOAT})\s+(#{FLOAT})\s+(#{FLOAT})/
+
+    def initialize(manager = DefaultLoadingManager)
+      @manager = manager
+      @_listeners = {}
+    end
+
+    def load(url)
+      loader = FileLoader.new(@manager)
+
+      data = loader.load(url)
+      parse(data)
+    end
+
+    def parse(data)
+      reset_loader_vars
+      stream = StringIO.new(data, "rb")
+      # Load STL header (first 80 bytes max)
+      header = stream.read(80)
+      if header.slice(0,5) === "solid"
+        stream.rewind
+        parse_ascii(stream)
+      else
+        parse_binary(stream)
+      end
+      @group
+    end
+
+    private
+
+    def reset_loader_vars
+      @vertex_hash = {}
+      @vertex_count = 0
+      @line_num = 0
+      @group = Group.new
+    end
+
+    def parse_ascii(stream)
+      while line = read_line(stream)
+        case line
+        when /^\s*solid/
+          parse_ascii_solid(stream)
+        else
+          raise_error
+        end
+      end
+    end
+
+    def parse_ascii_solid(stream)
+      vertices = []
+      faces = []
+      while line = read_line(stream)
+        case line
+        when /^\s*facet/
+          facet_vertices, face = parse_ascii_facet(line, stream)
+          vertices += facet_vertices
+          faces << face
+        when /^\s*endsolid/
+          break
+        else
+          raise_error
+        end
+      end
+      add_mesh vertices, faces
+    end
+
+    def parse_ascii_facet(line, stream)
+      vertices = []
+      normal = nil
+      if line.match NORMAL_PATTERN
+        normal = Vector3.new($1, $2, $3)
+      end
+      while line = read_line(stream)
+        case line
+        when /^\s*outer loop/
+          nil # Ignored
+        when /^\s*endloop/
+          nil # Ignored
+        when VERTEX_PATTERN
+          vertices << Vector3.new($1, $2, $3)
+        when /^\s*endfacet/
+          break
+        else
+          raise_error
+        end
+      end
+      return nil if vertices.length != 3
+      # Merge with existing vertices
+      face, new_vertices = face_with_merged_vertices(vertices)
+      face.normal = normal
+      return new_vertices, face
+    end
+
+    def parse_binary(stream)
+      vertices = []
+      faces = []
+      num_faces = stream.read(4).unpack('L<').first
+      num_faces.times do |i|
+        # Face normal
+        normal = read_binary_vector(stream)
+        # Vertices
+        face_vertices = []
+        face_vertices << read_binary_vector(stream)
+        face_vertices << read_binary_vector(stream)
+        face_vertices << read_binary_vector(stream)
+        # Throw away the attribute bytes
+        stream.read(2)
+        # Store data
+        face, new_vertices = face_with_merged_vertices(face_vertices)
+        face.normal = normal
+        faces << face
+        vertices += new_vertices
+      end
+      add_mesh vertices, faces
+    end
+
+    def face_with_merged_vertices(vertices)
+      new_vertices = []
+      indices = []
+      vertices.each do |v|
+        index, is_new = vertex_index(v)
+        indices << index
+        if is_new
+          new_vertices << v
+          @vertex_count += 1
+        end
+      end
+      # Return face and new vertex list
+      return Face3.new(
+        indices[0],
+        indices[1],
+        indices[2]
+      ), new_vertices
+    end
+
+    def vertex_index(vertex)
+      key = vertex_key(vertex)
+      if i = @vertex_hash[key]
+        return i, false
+      else
+        return (@vertex_hash[key] = @vertex_count), true
+      end
+    end
+
+    def vertex_key(vertex)
+      vertex.elements.pack("D*")
+    end
+
+    def add_mesh(vertices, faces)
+      geometry = Geometry.new
+      geometry.vertices = vertices
+      geometry.faces = faces
+      geometry.compute_bounding_sphere
+      @group.add Mesh.new(geometry)
+    end
+
+    def read_binary_vector(stream)
+      Vector3.new(
+        read_le_float(stream),
+        read_le_float(stream),
+        read_le_float(stream)
+      )
+    end
+
+    def read_le_float(stream)
+      stream.read(4).unpack('e').first
+    end
+
+    def read_line(stream)
+      @line_num += 1
+      stream.gets
+    end
+
+    def raise_error
+      raise "Mittsu::STLLoader: Unhandled line #{@line_num}"
+    end
+  end
+end

data/lib/mittsu/loaders.rb

@@ -6,3 +6,4 @@ require 'mittsu/loaders/file_loader'
 require 'mittsu/loaders/obj_loader'
 require 'mittsu/loaders/mtl_loader'
 require 'mittsu/loaders/obj_mtl_loader'
+require 'mittsu/loaders/stl_loader'