mittsu 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a15eb90a730149936c85793e1a878839f6498c71
-  data.tar.gz: 4e56fb37a5f51f36ecc2a8b68ce3dcae28fd3466
+  metadata.gz: 5a1f361bd9c5e37267db5e1e076dcb88d5149678
+  data.tar.gz: 32b0587711b8409e79e420f5ec3a5e41508ca7dc
 SHA512:
-  metadata.gz: cbf90e07efcdc8d6412e928bfbea0bb2026fb6e834450672f80b9c5cabc4be395fbef0dd3511f00b716baed2397a1256475e09461032fd6fdd12559c04739374
-  data.tar.gz: c8807939aa277079aeff28dc2b13b450b7d6161e122a0aed7903be7ac64220016e436992604052502a6ad9a2847f285f3f918cc54b9d2958a89c43e6a2c63070
+  metadata.gz: a69094dcb1f20b7d5582cc24d6e260fc4ee7194877a1687e6d6bf851b576eda7e18dc094d424cb4ecafb13eb0913cf11e8038d8d1c87d212161de798a8e83e38
+  data.tar.gz: 96272baf7be394553b5e1019b029209b029f89787dfa6de84e086fc848e1d9bfa5c7e61c0730afe971d799f6e26741e156b9cba40dc78b51ca0c70ec2c29cf95

data/.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+rvm:
+  2.4.0
+
+env:
+- MITTSU_LIBGLFW_PATH=/usr/local/lib MITTSU_LIBGLFW_FILE=libglfw.so MINITEST_REPORTER=JUnit
+
+addons:
+  apt:
+    sources:
+      - george-edison55-precise-backports # cmake 3.2.3 / doxygen 1.8.3
+    packages:
+      - cmake
+      - cmake-data
+
+before_install:
+  - sudo apt-get update; sudo apt-get install xorg-dev libgl1-mesa-dev
+  - bash ./install-glfw-3.1.2.sh
+
+script: bundle exec rake test

data/circle.yml

@@ -1,8 +1,11 @@
 ## Customize the test machine
 machine:
+  xcode:
+    version: 8.2
+
   environment:
     MITTSU_LIBGLFW_PATH: /usr/local/lib
-    MITTSU_LIBGLFW_FILE: libglfw.so
+    MITTSU_LIBGLFW_FILE: libglfw.dylib
     MINITEST_REPORTER: JUnit
 
   # Version of ruby to use
@@ -12,11 +15,8 @@ machine:
 
 ## Customize dependencies
 dependencies:
-  cache_directories:
-    - glfw-3.1.2
   pre:
-    - sudo apt-get update; sudo apt-get install cmake xorg-dev libgl1-mesa-dev
-    - bash ./install-glfw-3.1.2.sh
+    - brew install glfw
 
 test:
   post:

data/lib/mittsu/core/raycaster.rb

@@ -2,9 +2,9 @@ require 'mittsu'
 
 module Mittsu
   class Raycaster
-    attr_accessor :near, :far, :ray, :params
+    attr_accessor :near, :far, :ray, :params, :precision
 
-    def initialize(origin, direction, near = 0.0, far = Float::INFINITY)
+    def initialize(origin = Vector3.new, direction = Vector3.new, near = 0.0, far = Float::INFINITY)
       @ray = Mittsu::Ray.new(origin, direction)
       # direction is assumed to be normalized (for accurate distance calculations)
 
@@ -16,7 +16,7 @@ module Mittsu
       @params = {
         sprite: {},
         mesh: {},
-        point_cloud: { threshold: 1 },
+        point_cloud: { threshold: 1.0 },
         lod:{},
         line: {}
       }
@@ -49,7 +49,7 @@ module Mittsu
       end
     end
 
-    def intersect_objects(objects, recursive)
+    def intersect_objects(objects, recursive = false)
       intersects = []
       if !objects.is_a? Array
         puts 'WARNING: Mittsu::Raycaster#intersect_objects: objects is not an array'
@@ -61,7 +61,7 @@ module Mittsu
       end
 
       intersects.sort do |a, b|
-        a.distance <=> b.distance
+        a[:distance] <=> b[:distance]
       end
     end
 

data/lib/mittsu/materials.rb

@@ -5,3 +5,5 @@ require 'mittsu/materials/mesh_phong_material'
 require 'mittsu/materials/shader_material'
 require 'mittsu/materials/line_basic_material'
 require 'mittsu/materials/mesh_face_material'
+require 'mittsu/materials/sprite_material'
+require 'mittsu/materials/point_cloud_material'

data/lib/mittsu/materials/point_cloud_material.rb

@@ -0,0 +1,53 @@
+# parameters = {
+#  color: <hex>,
+#  opacity: <float>,
+#  map: new THREE.Texture( <Image> ),
+#
+#  size: <float>,
+#  sizeAttenuation: <bool>,
+#
+#  blending: THREE.NormalBlending,
+#  depthTest: <bool>,
+#  depthWrite: <bool>,
+#
+#  vertexColors: <bool>,
+#
+#  fog: <bool>
+# }
+
+module Mittsu
+  class PointCloudMaterial < Material
+    attr_accessor :size, :size_attenuation
+
+    def initialize(parameters = {})
+      super()
+
+      @type = 'PointCloudMaterial'
+
+      @color = Color.new(0xffffff)
+
+      @map = nil
+
+      @size = 1.0
+      @size_attenuation = true
+
+      @vertex_colors = NoColors
+
+      @fog = true
+
+      self.set_values(parameters)
+    end
+
+    def clone
+      material = PointCloudMaterial.new
+      super(material)
+      material.color.copy(@color)
+      material.map = @map
+      material.size = @size
+      material.size_attenuation = @size_attenuation
+      material.vertex_colors = @vertex_colors
+      material.fog = @fog
+      material
+    end
+  end
+end

data/lib/mittsu/materials/sprite_material.rb

@@ -0,0 +1,53 @@
+require 'mittsu/math'
+require 'mittsu/materials/material'
+
+# @author alteredq / http://alteredqualia.com/
+#
+# parameters = {
+#  color: <hex>,
+#  opacity: <float>,
+#  map: new THREE.Texture( <Image> ),
+#
+#  blending: THREE.NormalBlending,
+#  depthTest: <bool>,
+#  depthWrite: <bool>,
+#
+#	uvOffset: new THREE.Vector2(),
+#	uvScale: new THREE.Vector2(),
+#
+#  fog: <bool>
+# }
+module Mittsu
+  class SpriteMaterial < Material
+    attr_accessor :map, :rotation, :fog
+
+    def initialize(parameters = {})
+      super()
+
+      @type = 'SpriteMaterial'
+
+      @color = Color.new(0xffffff)
+      @map = nil
+
+      @rotation = 0.0
+
+      @fog = false
+
+      set_values(parameters)
+    end
+
+    def clone
+      material = SpriteMaterial.new
+      super(material)
+
+      material.color.copy(@color)
+      material.map = @map
+
+      material.rotation = @rotation
+
+      material.fog = @fog
+
+      material
+    end
+  end
+end

data/lib/mittsu/math/euler.rb

@@ -11,7 +11,7 @@ module Mittsu
       @x, @y, @z, @order = x.to_f, y.to_f, z.to_f, order
     end
 
-    def set(x, y, z, order)
+    def set(x, y, z, order = nil)
       @x = x.to_f
       @y = y.to_f
       @z = z.to_f

data/lib/mittsu/math/ray.rb

@@ -245,7 +245,6 @@ module Mittsu
       #   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
       #   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
       d_dot_n = @direction.dot(normal)
-      sign
       if d_dot_n > 0
         return nil if backface_culling
         sign = 1.0

data/lib/mittsu/objects.rb

@@ -1,3 +1,5 @@
 require 'mittsu/objects/mesh'
 require 'mittsu/objects/line'
 require 'mittsu/objects/group'
+require 'mittsu/objects/sprite'
+require 'mittsu/objects/point_cloud'

data/lib/mittsu/objects/mesh.rb

@@ -37,6 +37,39 @@ module Mittsu
       end
     end
 
+    def check_intersection object, raycaster, ray, pA, pB, pC, point
+
+      intersect = nil;
+      material = object.material;
+
+      if material.side == BackSide
+
+        intersect = ray.intersect_triangle( pC, pB, pA, true, point );
+
+      else
+
+        intersect = ray.intersect_triangle( pA, pB, pC, material.side != DoubleSide, point );
+
+      end
+
+       return nil if intersect.nil?
+
+       @intersectionPointWorld ||= Vector3.new
+        @intersectionPointWorld.copy( point );
+        @intersectionPointWorld.apply_matrix4( @matrix_world );
+
+        distance = raycaster.ray.origin.distance_to( @intersectionPointWorld );
+
+        return nil if ( distance < raycaster.near || distance > raycaster.far )
+
+          return {
+            distance: distance,
+            point: @intersectionPointWorld.clone(),
+            object: object
+          };
+
+    end
+
     def raycast(raycaster, intersects)
       @_inverse_matrix ||= Matrix4.new
       @_ray ||= Ray.new
@@ -45,25 +78,30 @@ module Mittsu
       @_v_a ||= Vector3.new
       @_v_b ||= Vector3.new
       @_v_c ||= Vector3.new
+      v_a = @_v_a
+      v_b = @_v_b
+      v_c = @_v_c
 
       # 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)
+      @_sphere.copy(geometry.bounding_sphere)
+      @_sphere.apply_matrix4(@matrix_world)
 
-      return unless raycaster.intersection_sphere?(sphere)
+      return unless raycaster.ray.intersection_sphere?(@_sphere)
 
       # check bounding box before continuing
 
-      inverse_matrix.inverse(@matrix_world)
-      ray.copy(raycaster.ray).apply_matrix4(inverse_matrix)
+      @_inverse_matrix = Matrix4.new
+      @_inverse_matrix.inverse(@matrix_world)
+      @_ray.copy(raycaster.ray).apply_matrix4(@_inverse_matrix)
 
-      if !geometry.bounding_bounding_box.nil?
+      if !geometry.bounding_box.nil?
         return unless ray.intersection_box?(geometry.bounding_box)
       end
 
+
       if geometry.is_a?(BufferGeometry)
         return if @material.nil?
 
@@ -93,13 +131,13 @@ module Mittsu
               v_b.from_array(positions, b * 3)
               v_c.from_array(positions, c * 3)
 
-              if material.side = BackSide
+              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?
+              next if intersection_point.nil?
 
               intersection_point.apply_matrix4(@matrix_world)
 
@@ -138,7 +176,7 @@ module Mittsu
               intersection_point = ray.intersect_triangle(v_a, v_b, v_c, material.side != DoubleSide)
             end
 
-            next if intersect_point.nil?
+            next if intersection_point.nil?
 
             intersection_point.apply_matrix4(@matrix_world)
 
@@ -210,27 +248,15 @@ module Mittsu
             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 = Vector3.new
+          intersection = check_intersection self, raycaster, @_ray, a, b, c, intersection_point
 
-          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
-          }
+          next if not intersection
+          if intersection
+            intersection[:face] = face
+          end
+          intersects << intersection
         end
       end
     end

data/lib/mittsu/objects/point_cloud.rb

@@ -0,0 +1,100 @@
+module Mittsu
+  class PointCloud < Object3D
+    attr_accessor :geometry, :material
+
+    def initialize(geometry = Geometry.new, material = PointCloudMaterial.new(color: rand * 0xffffff))
+      super()
+
+      @type = 'PointCloud'
+
+      @geometry = geometry
+      @material = material
+
+      @_inverse_matrix = Matrix4.new
+      @_ray = Ray.new
+    end
+
+    def raycast(raycaster, intersects)
+      threshold = raycaster.params[:point_cloud][:threshold]
+      @_inverse_matrix.inverse(self.materix_world)
+      @_ray.copy(raycaster.ray).apply_matrix4(@_inverse_matrix)
+
+      if !geometry.bounding_box.nil?
+        return if ray.intersection_box?(geometry.bounding_box) == false
+      end
+
+      local_threshold = threshold / ((self.scale.x + self.scale.y + self.scale.z) / 3.0)
+      position = Vector3.new
+
+      if geometry.is_a?(BufferGeometry)
+        attributes = geometry.attributes
+        positions = attributes.position.array
+
+        if !attributes[:index].nil?
+          indices = attributes[:index][:array]
+          offsets = geometry.compute_offsets
+
+          if offsets.empty?
+            offsets = [{
+              start: 0,
+              count: indices.length,
+              index: 0
+            }]
+          end
+
+          offsets.each do |offset|
+            start = offset[:start]
+            count = offset[:count]
+            index = offset[:index]
+
+            (start...start+count).each do |i|
+              a = index + indices[i]
+              position.from_array(positions, a * 3)
+              test_point(position, a, local_threshold, raycaster, intersects)
+            end
+          end
+        else
+          point_count = positions.count / 3
+
+          point_count.times do |i|
+            position.set(
+              positions[3 * i],
+              positions[3 * i + 1],
+              positions[3 * i + 2]
+            )
+
+            test_point(position, i, local_threshold, raycaster, intersects)
+          end
+        end
+      else
+        geometry.vertices.each_with_index do |vertex, i|
+          test_point(vertex, i, local_threshold, raycaster, intersects)
+        end
+      end
+    end
+
+    def clone(object = PointCloud.new(@geometry, @material))
+      super(object)
+    end
+
+    private
+
+    def test_point(point, index, local_threshold, raycaster, intersects)
+      ray_point_distance = @_ray.distance_to_point(point)
+      if ray_point_distance < local_threshold
+        intersect_point = @_ray.closes_point_to_point(point)
+        intersect_point.apply_matrix4(self.matrix_world)
+
+        distance = raycaster.ray.origin.distance_to(intersect_point)
+        intersects << {
+          distance: distance,
+          distance_to_ray: ray_point_distance,
+          point: intersect_point.clone,
+          index: index,
+          face: nil,
+          object: self
+        }
+      end
+    end
+  end
+end