mittsu 0.2.3 → 0.3.3

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

@@ -0,0 +1,145 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class CylinderGeometry < Geometry
+    def initialize(radius_top = 20.0, radius_bottom = 20.0, height = 100.0, radial_segments = 8, height_segments = 1, open_ended = false, theta_start = 0.0, theta_length = (::Math::PI * 2.0))
+      super()
+
+      @type = 'CylinderGeometry'
+
+      @parameters = {
+        radius_top:      radius_top,
+        radius_bottom:   radius_bottom,
+        height:          height,
+        radial_segments: radial_segments,
+        height_segments: height_segments,
+        open_ended:      open_ended,
+        theta_start:     theta_start,
+        theta_length:    theta_length
+      }
+
+      height_half = height / 2.0
+
+      index_rows = []
+      uv_rows = []
+
+      for y in 0..height_segments do
+        index_row = []
+        uv_row = []
+
+        v = y.to_f / height_segments.to_f
+        radius = v * (radius_bottom - radius_top) + radius_top
+
+        for x in 0..radial_segments do
+          u = x.to_f / radial_segments
+
+          vertex = Vector3.new
+          vertex.x = radius * ::Math.sin(u * theta_length + theta_start)
+          vertex.y = -v * height + height_half
+          vertex.z = radius * ::Math.cos(u * theta_length + theta_start)
+
+          @vertices << vertex
+
+          index_row << (vertices.length - 1)
+          uv_row << Vector2.new(u, 1.0 - v)
+        end
+
+        index_rows << index_row
+        uv_rows << uv_row
+      end
+
+      tan_theta = (radius_bottom - radius_top) / height
+
+      na = nil
+      nb = nil
+
+      for x in 0...radial_segments do
+        if radius_top != 0
+          na = @vertices[index_rows[0][x]].clone
+          nb = @vertices[index_rows[0][x + 1]].clone
+        else
+          na = @vertices[index_rows[1][x]].clone
+          nb = @vertices[index_rows[1][x + 1]].clone
+        end
+
+        na.y = ::Math.sqrt(na.x * na.x + na.z * na.z) * tan_theta
+        na.normalize
+
+        nb.y = ::Math.sqrt(nb.x * nb.x + nb.z * nb.z) * tan_theta
+        nb.normalize
+
+        for y in 0...height_segments do
+          v1 = index_rows[y][x]
+          v2 = index_rows[y + 1][x]
+          v3 = index_rows[y + 1][x + 1]
+          v4 = index_rows[y][x + 1]
+
+          n1 = na.clone
+          n2 = na.clone
+          n3 = nb.clone
+          n4 = nb.clone
+
+          uv1 = uv_rows[y][x].clone
+          uv2 = uv_rows[y + 1][x].clone
+          uv3 = uv_rows[y + 1][x + 1].clone
+          uv4 = uv_rows[y][x + 1].clone
+
+          @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
+
+      # top cap
+
+      if !open_ended && radius_top > 0.0
+        @vertices << Vector3.new(0, height_half, 0)
+
+        for x in 0...radial_segments do
+          v1 = index_rows[0][x]
+          v2 = index_rows[0][x + 1]
+          v3 = @vertices.length - 1
+
+          n1 = Vector3.new(0, 1, 0)
+          n2 = Vector3.new(0, 1, 0)
+          n3 = Vector3.new(0, 1, 0)
+
+          uv1 = uv_rows[0][x].clone
+          uv2 = uv_rows[0][x + 1].clone
+          uv3 = Vector2.new(uv2.x, 0)
+
+          @faces << Face3.new(v1, v2, v3, [n1, n2, n3])
+          @face_vertex_uvs[0] << [uv1, uv2, uv3]
+        end
+      end
+
+      # bottom cap
+
+      if !open_ended && radius_bottom > 0.0
+        @vertices << Vector3.new(0, -height_half, 0)
+
+        for x in 0...radial_segments do
+          v1 = index_rows[height_segments][x + 1]
+          v2 = index_rows[height_segments][x]
+          v3 = @vertices.length - 1
+
+          n1 = Vector3.new(0, -1, 0)
+          n2 = Vector3.new(0, -1, 0)
+          n3 = Vector3.new(0, -1, 0)
+
+          uv1 = uv_rows[height_segments][x].clone
+          uv2 = uv_rows[height_segments][x + 1].clone
+          uv3 = Vector2.new(uv2.x, 0)
+
+          @faces << Face3.new(v1, v2, v3, [n1, n2, n3])
+          @face_vertex_uvs[0] << [uv1, uv2, uv3]
+        end
+      end
+
+      compute_face_normals
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'mittsu/core'
+require 'mittsu/math'
+require 'mittsu/extras/geometries/polyhedron_geometry'
+
+module Mittsu
+  class DodecahedronGeometry < PolyhedronGeometry
+    def initialize(radius = 1.0, detail = 0)
+      t = (1.0 + ::Math.sqrt(5.0)) / 2.0
+      r = 1.0 / t
+
+      vertices = [
+        # (±1, ±1, ±1)
+        -1, -1, -1,    -1, -1,  1,
+        -1,  1, -1,    -1,  1,  1,
+        1, -1, -1,     1, -1,  1,
+        1,  1, -1,     1,  1,  1,
+
+        # (0, ±1/φ, ±φ)
+        0, -r, -t,     0, -r,  t,
+        0,  r, -t,     0,  r,  t,
+
+        # (±1/φ, ±φ, 0)
+        -r, -t,  0,    -r,  t,  0,
+        r, -t,  0,     r,  t,  0,
+
+        # (±φ, 0, ±1/φ)
+        -t,  0, -r,     t,  0, -r,
+        -t,  0,  r,     t,  0,  r
+      ]
+
+      indices = [
+        3, 11,  7,      3,  7, 15,      3, 15, 13,
+        7, 19, 17,      7, 17,  6,      7,  6, 15,
+        17,  4,  8,     17,  8, 10,     17, 10,  6,
+        8,  0, 16,      8, 16,  2,      8,  2, 10,
+        0, 12,  1,      0,  1, 18,      0, 18, 16,
+        6, 10,  2,      6,  2, 13,      6, 13, 15,
+        2, 16, 18,      2, 18,  3,      2,  3, 13,
+        18,  1,  9,     18,  9, 11,     18, 11,  3,
+        4, 14, 12,      4, 12,  0,      4,  0,  8,
+        11,  9,  5,     11,  5, 19,     11, 19,  7,
+        19,  5, 14,     19, 14,  4,     19,  4, 17,
+        1, 12, 14,      1, 14,  5,      1,  5,  9
+      ]
+
+      super(vertices, indices, radius, detail)
+
+      @type = 'DodecahedronGeometry'
+
+      @parameters = {
+        radius: radius,
+        detail: detail
+      }
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'mittsu/core'
+require 'mittsu/math'
+require 'mittsu/extras/geometries/polyhedron_geometry'
+
+module Mittsu
+  class IcosahedronGeometry < PolyhedronGeometry
+    def initialize(radius = 1.0, detail = 0)
+      t = (1.0 + ::Math.sqrt(5)) / 2.0
+
+      vertices = [
+        - 1,  t,  0,    1,  t,  0,   - 1, - t,  0,    1, - t,  0,
+        0, - 1,  t,    0,  1,  t,    0, - 1, - t,    0,  1, - t,
+        t,  0, - 1,    t,  0,  1,   - t,  0, - 1,   - t,  0,  1
+      ]
+
+      indices = [
+        0, 11,  5,    0,  5,  1,    0,  1,  7,    0,  7, 10,    0, 10, 11,
+        1,  5,  9,    5, 11,  4,   11, 10,  2,   10,  7,  6,    7,  1,  8,
+        3,  9,  4,    3,  4,  2,    3,  2,  6,    3,  6,  8,    3,  8,  9,
+        4,  9,  5,    2,  4, 11,    6,  2, 10,    8,  6,  7,    9,  8,  1
+      ]
+
+      super(vertices, indices, radius, detail)
+
+      @type = 'IcosahedronGeometry'
+
+      @parameters = {
+        radius: radius,
+        detail: detail
+      }
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class LatheGeometry < Geometry
+    def initialize(points, segments = 12, phi_start = 0.0, phi_length = (::Math::PI * 2.0))
+      super()
+
+      @type = 'LatheGeometry'
+
+      @parameters = {
+        points:     points,
+        segments:   segments,
+        phi_start:  phi_start,
+        phi_length: phi_length
+      }
+
+      inverse_point_length = 1.0 / (points.length.to_f - 1.0)
+      inverse_segments = 1.0 / segments.to_f
+
+      for i in 0..segments do
+        phi = phi_start + i.to_f * inverse_segments * phi_length
+
+        c = ::Math.cos(phi)
+        s = ::Math.sin(phi)
+
+        for j in 0...points.length do
+          pt = points[j]
+
+          vertex = Vector3.new
+
+          vertex.x = c * pt.x
+          vertex.y = pt.y
+          vertex.z = s * pt.x
+
+          @vertices << vertex
+        end
+      end
+
+      np = points.length
+
+      for i in 0...segments do
+        for j in 0...(points.length - 1) do
+          base = j + np * i
+          a = base
+          b = base + np
+          c = base + 1 + np
+          d = base + 1
+
+          u0 = i.to_f * inverse_segments
+          v0 = j.to_f * inverse_point_length
+          u1 = u0 + inverse_segments
+          v1 = v0 + inverse_point_length
+
+          @faces << Face3.new(a, b, d)
+
+          @face_vertex_uvs[0] << [
+            Vector2.new(u0, v0),
+            Vector2.new(u1, v0),
+            Vector2.new(u0, v1)
+          ]
+
+          @faces << Face3.new(b, c, d)
+
+          @face_vertex_uvs[0] << [
+            Vector2.new(u1, v0),
+            Vector2.new(u1, v1),
+            Vector2.new(u0, v1)
+          ]
+        end
+      end
+
+      merge_vertices
+      compute_face_normals
+      compute_vertex_normals
+    end
+  end
+end

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

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

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

@@ -0,0 +1,92 @@
+module Mittsu
+  class ParametricBufferGeometry < BufferGeometry
+    EPS = 0.00001
+
+    def initialize(func, slices, stacks)
+      super()
+
+      @type = 'ParametricBufferGeometry'
+
+      @parameters = {
+        func:   func,
+        slices: slices,
+        stacks: stacks
+      }
+
+      # buffers
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      normal = Vector3.new
+
+      p0 = Vector3.new
+      p1 = Vector3.new
+
+      pu = Vector3.new
+      pv = Vector3.new
+
+      # generate vertices, normals, and uvs
+
+      slice_count = slices + 1
+
+      for i in 0..stacks do
+        v = i.to_f / stacks.to_f
+
+        for j in 0..slices do
+          u = j.to_f / slices.to_f
+
+          # vertex
+          func.call(u, v, p0)
+          vertices += p0.elements
+
+          # normal
+
+          # approximate tangent vectors via finite differences
+          if u - EPS >= 0
+            func.call(u - EPS, v, p1)
+            pu.sub_vectors(p0, p1)
+          else
+            func.call(u + EPS, v, p1)
+            pu.sub_vectors(p1, p0)
+          end
+
+          if v - EPS >= 0
+            func.call(u, v - EPS, p1)
+            pv.sub_vectors(p0, p1)
+          else
+            func.call(u, v + EPS, p1)
+            pv.sub_vectors(p1, p0)
+          end
+
+          # cross product of tangent vectors returns surface normal
+          normal.cross_vectors(pu, pv).normalize
+          normals += normal.elements
+
+          # uv
+          uvs << u << v
+        end
+      end
+
+      for i in 0...stacks do
+        for j in 0...slices do
+          a = i * slice_count + j
+          b = i * slice_count + j + 1
+          c = (i + 1) * slice_count + j + 1
+          d = (i + 1) * slice_count + j
+
+          # faces one and two
+          indices << a << b << d
+          indices << b << c << d
+        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/parametric_geometry.rb

@@ -0,0 +1,93 @@
+require 'mittsu/extras/geometries/parametric_buffer_geometry'
+
+module Mittsu
+  class ParametricGeometry < Geometry
+    def initialize(func, slices, stacks)
+      super()
+
+      @type = 'ParametricGeometry'
+
+      @parameters = {
+        func:   func,
+        slices: slices,
+        stacks: stacks
+      }
+
+      from_buffer_geometry(ParametricBufferGeometry.new(func, slices, stacks))
+      merge_vertices
+    end
+
+    def self.klein
+      -> (v, u, target = Vector3.new) {
+        u *= ::Math::PI
+        v *= 2.0 * ::Math::PI
+
+        u = u * 2.0
+        x = nil
+        y = nil
+        z = nil
+
+        if u < ::Math::PI
+          x = 3.0 * ::Math.cos(u) * (1.0 + ::Math.sin(u)) + (2.0 * (1.0 - ::Math.cos(u) / 2.0)) * ::Math.cos(u) * ::Math.cos(v)
+          z = -8.0 * ::Math.sin(u) - 2.0 * (1.0 - ::Math.cos(u) / 2.0) * ::Math.sin(u) * ::Math.cos(v)
+        else
+          x = 3.0 * ::Math.cos(u) * (1.0 + ::Math.sin(u)) + (2.0 * (1.0 - ::Math.cos(u) / 2.0)) * ::Math.cos(v + ::Math::PI)
+          z = -8.0 * ::Math.sin(u)
+        end
+
+        y = -2.0 * (1.0 - ::Math.cos(u) / 2.0) * ::Math.sin(v)
+
+        target.set(x, y, z)
+      }
+    end
+
+    def self.plane(width, height)
+      -> (u, v, target = Vector3.new) {
+        x = u.to_f * width.to_f
+        y = 0.0
+        z = v.to_f * height.to_f
+
+        target.set(x, y, z)
+      }
+    end
+
+    def self.mobius
+      -> (u, t, target = Vector3.new) {
+        # flat mobius strip
+        # http://www.wolframalpha.com/input/?i=M%C3%B6bius+strip+parametric+equations&lk=1&a=ClashPrefs_*Surface.MoebiusStrip.SurfaceProperty.ParametricEquations-
+        u = u - 0.5
+        v = 2.0 * ::Math::PI * t
+
+        a = 2.0
+
+        x = ::Math.cos(v) * (a + u * ::Math.cos(v / 2.0))
+        y = ::Math.sin(v) * (a + u * ::Math.cos(v / 2.0))
+        z = u * ::Math.sin(v / 2)
+
+        target.set(x, y, z)
+      }
+    end
+
+    def self.mobius3d
+      -> (u, t, target = Vector3.new) {
+        # volumetric mobius strip
+
+        u *= ::Math::PI
+        t *= 2.0 * ::Math::PI
+
+        u = u * 2.0
+        phi = u / 2.0
+        major = 2.25
+        a = 0.125
+        b = 0.65
+
+        x = a * ::Math.cos(t) * ::Math.cos(phi) - b * ::Math.sin(t) * ::Math.sin(phi)
+        z = a * ::Math.cos(t) * ::Math.sin(phi) + b * ::Math.sin(t) * ::Math.cos(phi)
+        y = (major + x) * ::Math.sin(u)
+        x = (major + x) * ::Math.cos(u)
+
+        target.set(x, y, z)
+      }
+    end
+  end
+end