mittsu 0.1.0

data/lib/mittsu/core/raycaster.rb

@@ -0,0 +1,78 @@
+require 'mittsu'
+
+module Mittsu
+  class Raycaster
+    attr_accessor :near, :far, :ray, :params
+
+    def initialize(origin, direction, near = 0.0, far = Float::INFINITY)
+      @ray = Mittsu::Ray.new(origin, direction)
+      # direction is assumed to be normalized (for accurate distance calculations)
+
+      @precision = 0.0001
+      @line_precision = 1
+
+      @near, @far = near, far
+
+      @params = {
+        sprite: {},
+        mesh: {},
+        point_cloud: { threshold: 1 },
+        lod:{},
+        line: {}
+      }
+    end
+
+    def set(origin, direction)
+      # direction is assumed to be normalized (for accurate distance calculations)
+      @ray.set(origin, direction)
+    end
+
+    def set_from_camera(coords, camera)
+      # camera is assumed _not_ to be a child of a transformed object
+
+      if camera.is_a? Mittsu::PerspectiveCamera
+        @ray.origin.copy(camera.position)
+        @ray.direction.set(coords.x, coords.y, 0.5).unproject(camera).sub(camera.position).normalize
+      elsif camera.is_a? Mittsu::OrthographicCamera
+        @ray.origin.set(coords.x, coords.y, -1.0).unproject(camera)
+        @ray.direction.set(0.0, 0.0, -1.0).transform_direction(camera.matrix_world)
+      else
+        puts 'ERROR: Mittsu::Raycaster: Unsupported camera type'
+      end
+    end
+
+    def intersect_object(object, recursive)
+      intersects = []
+      intersect(object, intersects, recursive)
+      intersects.sort do |a, b|
+        a.distance <=> b.distance
+      end
+    end
+
+    def intersect_objects(objects, recursive)
+      intersects = []
+      if !objects.is_a? Array
+        puts 'WARNING: Mittsu::Raycaster#intersect_objects: objects is not an array'
+        return intersects
+      end
+
+      objects.each do |object|
+        intersect(object, intersects, recursive)
+      end
+
+      intersects.sort do |a, b|
+        a.distance <=> b.distance
+      end
+    end
+
+    private
+
+    def intersect(object, intersects, recursive)
+      object.raycast(self, intersects)
+
+      object.children.each do |child|
+        intersect(chil, intersects, true)
+      end
+    end
+  end
+end

data/lib/mittsu/extras.rb

@@ -0,0 +1,3 @@
+require 'mittsu/extras/geometries'
+require 'mittsu/extras/image_utils'
+require 'mittsu/extras/helpers'

data/lib/mittsu/extras/geometries.rb

@@ -0,0 +1,2 @@
+require 'mittsu/extras/geometries/box_geometry'
+require 'mittsu/extras/geometries/sphere_geometry'

data/lib/mittsu/extras/geometries/box_geometry.rb

@@ -0,0 +1,108 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class BoxGeometry < Geometry
+    def initialize(width, height, depth, width_segments = nil, height_segments = nil, depth_segments = nil)
+      super()
+
+      @type = 'BoxGeometry'
+
+      @parameters = {
+        width: width,
+        height: height,
+        depth: depth,
+        width_segments: width_segments,
+        height_segments: height_segments,
+        depth_segments: depth_segments
+      }
+
+      @width_segments = width_segments || 1
+      @height_segments = height_segments || 1
+      @depth_segments = depth_segments || 1
+
+      width_half = width / 2.0
+      height_half = height / 2.0
+      depth_half = depth / 2.0
+
+      build_plane(:z, :y, -1, -1, depth.to_f, height.to_f, width_half,   0) # px
+      build_plane(:z, :y,  1, -1, depth.to_f, height.to_f, -width_half,  1) # nx
+      build_plane(:x, :z,  1,  1, width.to_f, depth.to_f,  height_half,  2) # py
+      build_plane(:x, :z,  1, -1, width.to_f, depth.to_f,  -height_half, 3) # ny
+      build_plane(:x, :y,  1, -1, width.to_f, height.to_f, depth_half,   4) # pz
+      build_plane(:x, :y, -1, -1, width.to_f, height.to_f, -depth_half,  5) # nz
+
+      merge_vertices
+    end
+
+    private
+
+    def build_plane(u, v, udir, vdir, width, height, depth, material_index)
+      grid_x = @width_segments
+      grid_y = @height_segments
+      width_half = width / 2.0
+      height_half = height / 2.0
+      offset = @vertices.length
+
+      if (u == :x && v == :y) || (u == :y && v == :x)
+        w = :z
+      elsif (u == :x && v == :z) || (u == :z && v == :x)
+        w = :y
+        grid_y = @depth_segments
+      elsif (u == :z && v == :y) || (u == :y && v == :z)
+        w = :x
+        grid_x = @depth_segments
+      end
+
+      grid_x1 = grid_x + 1
+      grid_y1 = grid_y + 1
+      segment_width = width / grid_x
+      segment_height = height / grid_y
+      normal = Vector3.new
+
+      normal[w] = depth > 0 ? 1.0 : -1.0
+
+      grid_y1.times do |iy|
+        grid_x1.times do |ix|
+          vector = Vector3.new
+          vector[u] = (ix * segment_width - width_half) * udir
+          vector[v] = (iy * segment_height - height_half) * vdir
+          vector[w] = depth
+
+          @vertices.push(vector)
+        end
+      end
+
+      grid_y.times do |iy|
+        grid_x.times do |ix|
+          a = ix + grid_x1 * iy
+          b = ix + grid_x1 * (iy + 1)
+          c = (ix + 1) + grid_x1 * (iy + 1)
+          d = (ix + 1) + grid_x1 * iy
+
+          uva = Vector2.new(ix / grid_x.to_f, 1.0 - iy / grid_y.to_f)
+          uvb = Vector2.new(ix / grid_x.to_f, 1.0 - (iy + 1.0) / grid_y.to_f)
+          uvc = Vector2.new((ix + 1.0) / grid_x.to_f, 1.0 - (iy + 1.0) / grid_y.to_f)
+          uvd = Vector2.new((ix + 1.0) / grid_x.to_f, 1.0 - iy / grid_y.to_f)
+
+          face = Face3.new(a + offset, b + offset, d + offset)
+          face.normal.copy(normal)
+          face.vertex_normals << normal.clone << normal.clone << normal.clone
+          face.material_index = material_index
+
+          faces << face
+          face_vertex_uvs[0] << [uva, uvb, uvd]
+
+          face = Face3.new(b + offset, c + offset, d + offset)
+          face.normal.copy(normal)
+          face.vertex_normals << normal.clone << normal.clone << normal.clone
+          face.material_index = material_index
+
+          faces << face
+          face_vertex_uvs[0] << [uvb.clone, uvc, uvd.clone]
+        end
+      end
+
+    end
+  end
+end

data/lib/mittsu/extras/geometries/sphere_geometry.rb

@@ -0,0 +1,88 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class SphereGeometry < Geometry
+    def initialize(radius = 50.0, width_segments = 8, height_segments = 6, phi_start = 0.0, phi_length = (Math::PI * 2.0), theta_start = 0.0, theta_length = Math::PI)
+      super()
+
+      @type = 'SphereGeometry'
+
+      @parameters = {
+        radius: radius,
+        width_segments: width_segments,
+        height_segments: height_segments,
+        phi_start: phi_start,
+        phi_length: phi_length,
+        theta_start: theta_start,
+        theta_length: theta_length
+      }
+
+      width_segments = [3, width_segments.floor].max
+      height_segments = [2, height_segments].max
+
+      _vertices = []
+      uvs = []
+
+      (height_segments + 1).times do |y|
+        vertices_row = []
+        uvs_row = []
+
+        (width_segments + 1).times do |x|
+          u = x / width_segments.to_f
+          v = y / height_segments.to_f
+
+          vertex = Vector3.new
+          vertex.x = -radius * Math.cos(phi_start + u * phi_length) * Math.sin(theta_start + v * theta_length)
+          vertex.y = radius * Math.cos(theta_start + v * theta_length)
+          vertex.z = radius * Math.sin(phi_start + u * phi_length) * Math.sin(theta_start + v * theta_length)
+
+          @vertices << vertex
+
+          vertices_row << @vertices.length - 1.0
+          uvs_row << Vector2.new(u, 1.0 - v)
+        end
+
+        _vertices << vertices_row
+        uvs << uvs_row
+      end
+
+      height_segments.times do |y|
+        width_segments.times do |x|
+          v1 = _vertices[y][x + 1]
+          v2 = _vertices[y][x]
+          v3 = _vertices[y + 1][x]
+          v4 = _vertices[y + 1][x + 1]
+
+          n1 = @vertices[v1].clone.normalize
+          n2 = @vertices[v2].clone.normalize
+          n3 = @vertices[v3].clone.normalize
+          n4 = @vertices[v4].clone.normalize
+
+          uv1 = uvs[y][x + 1].clone
+          uv2 = uvs[y][x].clone
+          uv3 = uvs[y + 1][x].clone
+          uv4 = uvs[y + 1][x + 1].clone
+
+          if @vertices[v1].y.abs == radius
+            uv1.x = (uv1.x + uv2.x) / 2.0
+            @faces << Face3.new(v1, v3, v4, [n1, n3, n4])
+            @face_vertex_uvs[0] << [uv1, uv3, uv4]
+          elsif @vertices[v3].y == radius
+            uv3.x = (uv3.x + uv4.x) / 2.0
+            @faces << Face3.new(v1, v2, v3, [n1, n2, n3])
+            @face_vertex_uvs[0] << [uv1, uv2, uv3]
+          else
+            @faces << Face3.new(v1, v2, v4, [n1, n2, n4])
+            @face_vertex_uvs[0] << [uv1, uv2, uv4]
+            @faces << Face3.new(v2, v3, v4, [n2.clone, n3, n4.clone])
+            @face_vertex_uvs[0] << [uv2.clone, uv3, uv4.clone]
+          end
+        end
+      end
+
+      compute_face_normals
+      @bounding_sphere = Sphere.new(Vector3.new, radius)
+    end
+  end
+end

data/lib/mittsu/extras/helpers.rb

@@ -0,0 +1 @@
+require 'mittsu/extras/helpers/camera_helper'

data/lib/mittsu/extras/helpers/camera_helper.rb

@@ -0,0 +1,155 @@
+require 'mittsu/objects/line'
+
+module Mittsu
+  class CameraHelper < Line
+    attr_accessor :point_map, :camera, :matrix, :matrix_auto_update, :material, :geometry
+
+    def initialize(camera)
+      @_vector = Vector3.new
+      @_camera = Camera.new
+
+      @geometry = Geometry.new
+      @material = LineBasicMaterial.new(color: 0xffffff, vertex_colors: FaceColors)
+
+      @point_map = {}
+
+      # colors
+
+      @hex_frustrum = 0xffaa00
+      @hex_cone = 0xff0000
+      @hex_up = 0x00aaff
+      @hex_target = 0xffffff
+      @hex_cross = 0x333333
+
+      # near
+
+      add_line(:n1, :n2, @hex_frustrum)
+      add_line(:n2, :n4, @hex_frustrum)
+      add_line(:n4, :n3, @hex_frustrum)
+      add_line(:n3, :n1, @hex_frustrum)
+
+      # far
+
+      add_line(:f1, :f2, @hex_frustrum)
+      add_line(:f2, :f4, @hex_frustrum)
+      add_line(:f4, :f3, @hex_frustrum)
+      add_line(:f3, :f1, @hex_frustrum)
+
+      # sides
+
+      add_line(:n1, :f1, @hex_frustrum)
+      add_line(:n2, :f2, @hex_frustrum)
+      add_line(:n3, :f3, @hex_frustrum)
+      add_line(:n4, :f4, @hex_frustrum)
+
+      # cone
+
+      add_line(:p, :n1, @hex_frustrum)
+      add_line(:p, :n2, @hex_frustrum)
+      add_line(:p, :n3, @hex_frustrum)
+      add_line(:p, :n4, @hex_frustrum)
+
+      # up
+
+      add_line(:u1, :u2, @hex_frustrum)
+      add_line(:u2, :u3, @hex_frustrum)
+      add_line(:u3, :u1, @hex_frustrum)
+
+      # target
+
+      add_line(:c, :t, @hex_frustrum)
+      add_line(:p, :c, @hex_frustrum)
+
+      # cross
+
+      add_line(:cn1, :cn2, @hex_frustrum)
+      add_line(:cn3, :cn4, @hex_frustrum)
+
+      add_line(:cf1, :cf2, @hex_frustrum)
+      add_line(:cf3, :cf4, @hex_frustrum)
+
+      super(@geometry, @material, LinePieces)
+
+      @camera = camera
+
+      @matrix = camera.matrix_world
+      @matrix_auto_update = false
+
+      update
+    end
+
+    def update
+      w = 1.0
+      h = 1.0
+
+      # we need just camera projection matrix
+      # world matrix must be identity
+
+      @_camera.projection_matrix.copy(@camera.projection_matrix)
+
+      # center / target
+
+      set_point(:c, 0.0, 0.0, -1.0)
+      set_point(:t, 0.0, 0.0, 1.0)
+
+      # near
+
+      set_point(:n1, -w, -h, -1.0)
+      set_point(:n2,  w, -h, -1.0)
+      set_point(:n3, -w,  h, -1.0)
+      set_point(:n4,  w,  h, -1.0)
+
+      # far
+
+      set_point(:f1, -w, -h, -1.0)
+      set_point(:f2,  w, -h, -1.0)
+      set_point(:f3, -w,  h, -1.0)
+      set_point(:f4,  w,  h, -1.0)
+
+      # up
+
+      set_point(:u1,  w * 0.7, h * 1.1, -1.0)
+      set_point(:u2, -w * 0.7, h * 1.1, -1.0)
+      set_point(:u3,      0.0, h * 2.0, -1.0)
+
+      # cross
+
+      set_point(:cf1,  -w, 0.0, 1.0)
+      set_point(:cf2,   w, 0.0, 1.0)
+      set_point(:cf3, 0.0,  -h, 1.0)
+      set_point(:cf4, 0.0,   h, 1.0)
+
+      set_point(:cn1,  -w, 0.0, 1.0)
+      set_point(:cn2,   w, 0.0, 1.0)
+      set_point(:cn3, 0.0,  -h, 1.0)
+      set_point(:cn4, 0.0,   h, 1.0)
+
+      @geometry.vertices_need_update = true
+    end
+
+    private
+
+    def add_line(a, b, hex)
+      add_point(a, hex)
+      add_point(b, hex)
+    end
+
+    def add_point(id, hex)
+      @geometry.vertices << Vector3.new
+      @geometry.colors << Color.new(hex)
+
+      @point_map[id] ||= []
+      @point_map[id] << geometry.vertices.length - 1
+    end
+
+    def set_point(point, x, y, z)
+      @_vector.set(x, y, z).unproject(@_camera)
+
+      points = @point_map[point]
+
+      if !points.nil?
+        points.each { |p| @geometry.vertices[p].copy(@_vector) }
+      end
+    end
+  end
+end

data/lib/mittsu/extras/image.rb

@@ -0,0 +1,3 @@
+module Mittsu
+  class Image < Struct.new(:width, :height, :data); end
+end