mittsu 0.2.3 → 0.3.3

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

@@ -0,0 +1,81 @@
+module Mittsu
+  class PlaneBufferGeometry < BufferGeometry
+    def initialize(width, height, width_segments = 1, height_segments = 1)
+      super()
+
+      @type = 'PlaneBufferGeometry'
+
+      @parameters = {
+        width:           width,
+        height:          height,
+        width_segments:  width_segments,
+        height_segments: height_segments
+      }
+
+      width_half = width / 2.0
+      height_half = height / 2.0
+
+      grid_x = width_segments || 1
+      grid_y = height_segments || 1
+
+      grid_x1 = grid_x + 1
+      grid_y1 = grid_y + 1
+
+      segment_width = width.to_f / grid_x.to_f
+      segment_height = height.to_f / grid_y.to_f
+
+      vertices = Array.new(grid_x1 * grid_y1 * 3) # Float32Array
+      normals = Array.new(grid_x1 * grid_y1 * 3) #Float32Array
+      uvs = Array.new(grid_x1 * grid_y1 * 2) # Float32Array
+
+      offset = 0
+      offset2 = 0
+
+      for iy in 0...grid_y1 do
+        y = iy.to_f * segment_height - height_half
+        for ix in 0...grid_x1 do
+          x = ix.to_f * segment_width - width_half
+
+          vertices[offset] = x
+          vertices[offset + 1] = -y
+
+          normals[offset + 2] = 1.0
+
+          uvs[offset2] = ix.to_f / grid_x.to_f
+          uvs[offset2 + 1] = 1.0 - (iy.to_f / grid_y.to_f)
+
+          offset += 3
+          offset2 += 2
+        end
+      end
+
+      offset = 0
+
+      indices = Array.new(grid_x * grid_y * 6) # ( ( vertices.length / 3 ) > 65535 ? Uint32Array : Uint16Array )
+
+      for iy in 0...grid_y do
+        for ix in 0...grid_x do
+          a = ix + grid_x1 * iy
+          b = ix + grid_x1 * (iy + 1)
+          c = (ix + 1) + grid_x1 * (iy + 1)
+          d = (ix + 1) + grid_x1 * iy
+
+          indices[offset    ] = a
+          indices[offset + 1] = b
+          indices[offset + 2] = d
+
+          indices[offset + 3] = b
+          indices[offset + 4] = c
+          indices[offset + 5] = d
+
+          offset += 6
+        end
+      end
+
+      self[:index]    = BufferAttribute.new(indices, 1)
+      self[:position] = BufferAttribute.new(vertices, 3)
+      self[:normal]   = BufferAttribute.new(normals, 3)
+      self[:uv]       = BufferAttribute.new(uvs, 2)
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'mittsu/extras/geometries/plane_buffer_geometry'
+
+module Mittsu
+  class PlaneGeometry < Geometry
+    def initialize(width, height, width_segments = 1, height_segments = 1)
+      puts 'Mittsu::PlaneGeometry: Consider using Mittsu::PlaneBufferGeometry for lower memory footprint.'
+
+      super()
+
+      @type = 'PlaneGeometry'
+
+      @parameters = {
+        width:           width,
+        height:          height,
+        width_segments:  width_segments,
+        height_segments: height_segments
+      }
+
+      from_buffer_geometry(PlaneBufferGeometry.new(width, height, width_segments, height_segments))
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class PolyhedronGeometry < Geometry
+    def initialize(vertices, indices, radius = 1.0, detail = 0)
+      super()
+
+      @type = 'PolyhedronGeometry'
+
+      @parameters = {
+        vertices: vertices,
+        indices:  indices,
+        radius:   radius,
+        detail:   detail
+      }
+
+      for i in (0...vertices.length).step(3) do
+        prepare(Vector3.new(vertices[i], vertices[i + 1], vertices[i + 2]))
+      end
+
+      faces = []
+
+      i = 0
+      j = 0
+      while i < indices.length do
+        v1 = @vertices[indices[i]]
+        v2 = @vertices[indices[i + 1]]
+        v3 = @vertices[indices[i + 2]]
+        binding.irb if v1.nil? || v2.nil? || v3.nil?
+
+        faces[j] = Face3.new(v1.index, v2.index, v3.index, [v1.clone, v2.clone, v3.clone])
+
+        i += 3
+        j += 1
+      end
+
+      @centroid = Vector3.new
+
+      for i in 0...faces.length do
+        subdivide(faces[i], detail)
+      end
+
+      # Handle case when face straddles the seam
+
+      @face_vertex_uvs[0].each do |uv0, uv1, uv2|
+        x0 = uv0.x
+        x1 = uv1.x
+        x2 = uv2.x
+
+        max = [x0, x1, x2].max
+        min = [x0, x1, x2].min
+
+        if max > 0.9 && min < 0.1 # 0.9 is somewhat arbitrary
+          uv0.x += 1.0 if x0 < 0.2
+          uv1.x += 1.0 if x1 < 0.2
+          uv2.x += 1.0 if x2 < 0.2
+        end
+      end
+
+      # Apply radius
+
+      @vertices.each do |v|
+        v.multiply_scalar(radius)
+      end
+
+      merge_vertices
+
+      compute_face_normals
+      @bounding_sphere = Sphere.new(Vector3.new, radius)
+    end
+
+    private
+
+    # Project vector onto sphere's surface
+    def prepare(vector)
+      vertex = vector.normalize.clone
+      vertex.index = @vertices.push(vertex).length - 1
+
+      # Texture coords are equivalent to map coords, calculate angle and convert to fraction of a circle.
+      u = azimuth(vector) / 2.0 / ::Math::PI + 0.5
+      v = inclination(vector) / ::Math::PI + 0.5
+      vertex.uv = Vector2.new(u, 1.0 - v)
+
+      vertex
+    end
+
+    # Approximate a curved face with recursively sub-divided triangles.
+    def make(v1, v2, v3)
+      face = Face3.new(v1.index, v2.index, v3.index, [v1.clone, v2.clone, v3.clone])
+      @faces << face
+
+      @centroid.copy(v1).add(v2).add(v3).divide_scalar(3)
+
+      azi = azimuth(@centroid)
+
+      @face_vertex_uvs[0] << [
+        correct_uv(v1.uv, v1, azi),
+        correct_uv(v2.uv, v2, azi),
+        correct_uv(v3.uv, v3, azi)
+      ]
+    end
+
+    # Analytically subdivide a face to the required detail level.
+    def subdivide(face, detail)
+      cols = 2.0 ** detail
+      a = prepare(@vertices[face.a])
+      b = prepare(@vertices[face.b])
+      c = prepare(@vertices[face.c])
+      v = []
+
+      # Construct all of the vertices for this subdivision.
+      for i in 0..cols do
+        v[i] = []
+
+        aj = prepare(a.clone.lerp(c, i.to_f / cols.to_f))
+        bj = prepare(b.clone.lerp(c, i.to_f / cols.to_f))
+        rows = cols - i
+
+        for j in 0..rows do
+          v[i][j] = if j.zero? && i == cols
+                      aj
+                    else
+                      prepare(aj.clone.lerp(bj, j.to_f / rows.to_f))
+                    end
+        end
+      end
+
+      # Construct all of the faces
+      for i in 0...cols do
+        for j in (0...(2 * (cols - i) - 1)) do
+          k = j/2
+
+          if j.even?
+            make(
+              v[i][k + 1],
+              v[i + 1][k],
+              v[i][k]
+            )
+          else
+            make(
+              v[i][k + 1],
+              v[i + 1][k + 1],
+              v[i + 1][k]
+            )
+          end
+        end
+      end
+    end
+
+    # Angle around the Y axis, counter-clockwise when looking from above.
+    def azimuth(vector)
+      ::Math.atan2(vector.z, -vector.x)
+    end
+
+    # Angle above the XZ plane.
+    def inclination(vector)
+      ::Math.atan2(-vector.y, ::Math.sqrt(vector.x * vector.x + vector.z * vector.z))
+    end
+
+    # Texture fixing helper. Spheres have some odd behaviours.
+    def correct_uv(uv, vector, azimuth)
+      return Vector2.new(uv.x - 1.0, uv.y) if azimuth < 0
+      return Vector2.new(azimuth / 2.0 / ::Math::PI + 0.5, uv.y) if vector.x.zero? && vector.z.zero?
+      uv.clone
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class RingGeometry < Geometry
+    def initialize(inner_radius = 0.0, outer_radius = 50.0, theta_segments = 8, phi_segments = 8, theta_start = 0.0, theta_length = (::Math::PI * 2.0))
+      super()
+
+      @type = 'RingGeometry'
+
+      @parameters = {
+        inner_radius:   inner_radius,
+        outer_radius:   outer_radius,
+        theta_segments: theta_segments,
+        phi_segments:   phi_segments,
+        theta_start:    theta_start,
+        theta_length:   theta_length
+      }
+
+      theta_segments = [3, theta_segments].max
+      phi_segments = [1, phi_segments].max
+
+      uvs = []
+      radius = inner_radius
+      radius_step = ((outer_radius - inner_radius) / phi_segments.to_f)
+
+      for i in 0..phi_segments do # concentric circles inside ring
+        for o in 0..theta_segments do # number of segments per circle
+          vertex = Vector3.new
+          segment = theta_start + o.to_f / theta_segments.to_f * theta_length
+          vertex.x = radius * ::Math.cos(segment)
+          vertex.y = radius * ::Math.sin(segment)
+
+          @vertices << vertex
+          uvs << Vector2.new((vertex.x / outer_radius + 1.0) / 2.0, (vertex.y / outer_radius + 1.0) / 2.0)
+        end
+
+        radius += radius_step
+      end
+
+      n = Vector3.new(0.0, 0.0, 1.0)
+
+      for i in 0...phi_segments do # concentric circles inside ring
+        theta_segment = i * (theta_segments + 1)
+
+        for o in 0...theta_segments do # number of segments per circle
+          segment = o + theta_segment
+
+          v1 = segment
+          v2 = segment + theta_segments + 1
+          v3 = segment + theta_segments + 2
+
+          @faces << Face3.new(v1, v2, v3, [n.clone, n.clone, n.clone])
+          @face_vertex_uvs[0] << [uvs[v1].clone, uvs[v2].clone, uvs[v3].clone]
+
+          v1 = segment
+          v2 = segment + theta_segments + 2
+          v3 = segment + 1
+
+          @faces << Face3.new(v1, v2, v3, [n.clone, n.clone, n.clone])
+          @face_vertex_uvs[0] << [uvs[v1].clone, uvs[v2].clone, uvs[v3].clone]
+        end
+      end
+
+      compute_face_normals
+      @bounding_sphere = Sphere.new(Vector3.new, radius)
+    end
+
+    def clone
+      RingGeometry.new(
+        @parameters[:inner_radius],
+        @parameters[:outer_radius],
+        @parameters[:theta_segments],
+        @parameters[:phi_segments],
+        @parameters[:theta_start],
+        @parameters[:theta_length]
+      )
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ 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)
+    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'
@@ -33,9 +33,9 @@ module Mittsu
           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)
+          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
 

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

@@ -0,0 +1,26 @@
+require 'mittsu/core'
+require 'mittsu/math'
+require 'mittsu/extras/geometries/polyhedron_geometry'
+
+module Mittsu
+  class TetrahedronGeometry < PolyhedronGeometry
+    def initialize(radius = 1.0, detail = 0)
+      vertices = [
+        1,  1,  1,   - 1, - 1,  1,   - 1,  1, - 1,    1, - 1, - 1
+      ]
+
+      indices = [
+         2,  1,  0,    0,  3,  2,    1,  3,  0,    2,  3,  1
+      ]
+
+      super(vertices, indices, radius, detail)
+
+      @type = 'TetrahedronGeometry'
+
+      @parameters = {
+        radius: radius,
+        detail: detail
+      }
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class TorusGeometry < Geometry
+    def initialize(radius = 100.0, tube = 40.0, radial_segments = 8, tubular_segments = 6, arc = (::Math::PI * 2.0))
+      super()
+
+      @type = 'TorusGeometry'
+
+      @parameters = {
+        radius:           radius,
+        tube:             tube,
+        radial_segments:  radial_segments,
+        tubular_segments: tubular_segments,
+        arc:              arc
+      }
+
+      center = Vector3.new
+      uvs = []
+      normals = []
+
+      for j in 0..radial_segments do
+        for i in 0..tubular_segments do
+          u = i.to_f / tubular_segments * arc
+          v = j.to_f / radial_segments * ::Math::PI * 2.0
+
+          center.x = radius * ::Math.cos(u)
+          center.y = radius * ::Math.sin(u)
+
+          vertex = Vector3.new
+          vertex.x = (radius + tube * ::Math.cos(v)) * ::Math.cos(u)
+          vertex.y = (radius + tube * ::Math.cos(v)) * ::Math.sin(u)
+          vertex.z = tube * ::Math.sin(v)
+
+          @vertices << vertex
+
+          uvs << Vector2.new(i.to_f / tubular_segments, j.to_f / radial_segments)
+          normals << vertex.clone.sub(center).normalize
+        end
+      end
+
+      for j in 1..radial_segments do
+        for i in 1..tubular_segments do
+          a = (tubular_segments + 1) * j + i - 1
+          b = (tubular_segments + 1) * (j - 1) + i - 1
+          c = (tubular_segments + 1) * (j - 1) + i
+          d = (tubular_segments + 1) * j + i
+
+          face = Face3.new(a, b, d, [normals[a].clone, normals[b].clone, normals[d].clone])
+          @faces << face
+          @face_vertex_uvs[0] << [uvs[a].clone, uvs[b].clone, uvs[d].clone]
+
+          face = Face3.new(b, c, d, [normals[b].clone, normals[c].clone, normals[d].clone])
+          @faces << face
+          @face_vertex_uvs[0] << [uvs[b].clone, uvs[c].clone, uvs[d].clone]
+        end
+      end
+
+      compute_face_normals
+    end
+  end
+end