mittsu 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 806e8ad78d34edc7dfa72cbe35414c0fe765628b5dd074d691d5bf0f45dd52cb
-  data.tar.gz: b477a885ca405bd5ad8b71464b06ce794567c00abceb56738f3ace06885fe4d3
+  metadata.gz: 620d1bf034251f9514abec4fb1e28357bccbe984f517d6763c5f1e544e3c9728
+  data.tar.gz: 157868417127b487b51b8ccbc1bfa901063f557915a3f0f66f43f0a6cfe600da
 SHA512:
-  metadata.gz: d65b207aaaf6136a1e6d7fd39237bd5710192748338eb388fd974d4128069cbc41b6df4132bc2597793f507ed7349abdb0f3d28e9df1584ff9d4e1f9a39c8bc2
-  data.tar.gz: b4eb049497dc7f46d4285d8d8d677f3221f08d904dcc21b1efa3e7044edea42a1d49e8979d74bd26c3bc9470598fd9755c460865cc324ce71b6c87fec036d07e
+  metadata.gz: 611d3f4d2aa790e21f04cd22b45b3a8ed3901dbc60e97e1a2f72574bdb846d12773b552397131cda37471f39ed97d4702f0976ca83438d2202f1439e0e722b6e
+  data.tar.gz: 0d2fd2ab7d43a2ebbe523103b33fc1ce8a0bcd3ce046f2c82fd2e633e8e2b6b80cfede3ffc7758a82d753d69afb7f75c3ce49f69aa278161dbb1586603c017a6

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

@@ -8,23 +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', '3.2', '3.3', 'head']
     steps:
       - uses: actions/checkout@v4
-      - uses: awalsh128/cache-apt-pkgs-action@v1
-        with:
-          packages: libglfw3
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
       - 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 }}
@@ -33,35 +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', '3.2', '3.3', 'head']
-    steps:
-      - uses: actions/checkout@v4
-      - run: brew install glfw
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - 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', '3.2', '3.3', 'head']
-    steps:
-      - uses: actions/checkout@v4
-      - run: .\install-glfw.ps1
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - 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/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/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'

data/lib/mittsu/textures/render_target.rb

@@ -0,0 +1,93 @@
+module Mittsu
+  class RenderTarget < Texture
+    include EventDispatcher
+
+    attr_accessor :width,
+                  :height,
+                  :wrap_s,
+                  :wrap_t,
+                  :mag_filter,
+                  :min_filter,
+                  :anisotropy,
+                  :offset,
+                  :repeat,
+                  :format,
+                  :type,
+                  :depth_buffer,
+                  :stencil_buffer,
+                  :generate_mipmaps,
+                  :share_depth_from
+
+    attr_reader :framebuffer
+
+    attr_writer :renderer
+
+    def initialize(width, height, options = {})
+      super(self, nil)
+
+      @width = width
+      @height = height
+
+      @wrap_s = options.fetch(:wrap_s, ClampToEdgeWrapping)
+      @wrap_t = options.fetch(:wrap_t, ClampToEdgeWrapping)
+
+      @mag_filter = options.fetch(:mag_filter, LinearFilter)
+      @min_filter = options.fetch(:min_filter, LinearMipMapLinearFilter)
+
+      @anisotropy = options.fetch(:anisotropy, 1.0);
+
+      @offset = Vector2.new(0.0, 0.0)
+      @repeat = Vector2.new(1.0, 1.0)
+
+      @format = options.fetch(:format, RGBAFormat)
+      @type = options.fetch(:type, UnsignedByteType)
+
+      @depth_buffer = options.fetch(:depth_buffer, true)
+      @stencil_buffer = options.fetch(:stencil_buffer, true)
+
+      @generate_mipmaps = true
+
+      @share_depth_from = options.fetch(:share_depth_from, nil)
+    end
+
+    def set_size(width, height)
+      @width = width
+      @height = height
+    end
+
+    def needs_update?
+      false
+    end
+
+    def clone
+      RenderTarget.new(@width, @height).tap do |tmp|
+        tmp.renderer = @renderer
+
+    		tmp.wrap_s = @wrap_s
+    		tmp.wrap_t = @wrap_t
+
+    		tmp.mag_filter = @mag_filter
+    		tmp.min_filter = @min_filter
+
+    		tmp.anisotropy = @anisotropy
+
+    		tmp.offset.copy(@offset)
+    		tmp.repeat.copy(@repeat)
+
+    		tmp.format = @format
+    		tmp.type = @type
+
+    		tmp.depth_buffer = @depth_buffer
+    		tmp.stencil_buffer = @stencil_buffer
+
+    		tmp.generate_mipmaps = @generate_mipmaps
+
+    		tmp.share_depth_from = @share_depth_from
+      end
+    end
+
+    def dispose
+      dispatch_event(type: :dispose)
+    end
+  end
+end

data/lib/mittsu/textures/render_target_cube.rb

@@ -0,0 +1,8 @@
+module Mittsu
+  class RenderTargetCube < RenderTarget
+    def initialize(size = 1, options = {})
+      super(size, size, options)
+      # TODO
+    end
+  end
+end

data/lib/mittsu/textures/texture.rb

@@ -39,7 +39,7 @@ module Mittsu
       @generate_mipmaps = true
       @premultiply_alpha = false
       @filp_y = true
-      @unpack_alignment = 4 # valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
+      @unpack_alignment = 4 # valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/GL.PixelStorei.xml)
 
       @_needs_update = false
       @on_update = nil

data/lib/mittsu/textures.rb

@@ -3,3 +3,5 @@ require 'mittsu/textures/compressed_texture'
 require 'mittsu/textures/cube_texture'
 require 'mittsu/textures/data_texture'
 require 'mittsu/textures/video_texture'
+require 'mittsu/textures/render_target'
+require 'mittsu/textures/render_target_cube'

data/lib/mittsu/version.rb

@@ -1,3 +1,3 @@
 module Mittsu
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/mittsu.rb

@@ -8,7 +8,6 @@ require "mittsu/lights"
 require "mittsu/loaders"
 require "mittsu/materials"
 require "mittsu/objects"
-require "mittsu/renderers"
 require "mittsu/scenes"
 require "mittsu/textures"
 require "mittsu/constants"