mittsu 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db458484a3c4620067a0a3d7c58751e0a7588cbb4320f10be9ed49441db5ba07
-  data.tar.gz: 8af94bffbd0c624f0b5e676e9da2b5e72de09eaf3f921d9650617b56e84fad5d
+  metadata.gz: 1d75b0ef6c6615fff22f50ab9f3bc438e5c2631d5924f30da913df6403d5ccd0
+  data.tar.gz: 4656d50526e5be69dd19f3f0de87b4f93de5ad0a2e664b6277b023b885d7c3a0
 SHA512:
-  metadata.gz: f45a750a1557b6f9fdbe46a1cb652b9d6e731294da4d00af0602ec2d64f0fbb47c63dba9ec249f94c006ebbe76066d67dad50c6c94ca066c0d376e9dd38f67ee
-  data.tar.gz: d3f6931cf6301e53bcbc2296213fc1da27996f46d6211a4d949af16ecc1489cd2e909a5ce6b934b6c3cad55ad21beb81c71c92cea63625146d8b1a38a9d99b1d
+  metadata.gz: 4093db783cef7214c92fa5ce723cf84466a4dcd30d1e7a8fe6c5b9ff41f4be13d04eaeb072e30e6e039191d410303adf47c55288429439412e746ba300e05918
+  data.tar.gz: e3bafbb95cff8e606f36e6e456314a75cbfc9c0284022ef73258d40316918fd87dce5b11b21aa1b25802a071b91b413df53de8220f1294eadf892600f79868fd

data/lib/mittsu/core/geometry.rb

@@ -1,5 +1,6 @@
 require 'securerandom'
 require 'mittsu'
+require 'securerandom'
 
 module Mittsu
   class Geometry
@@ -19,6 +20,8 @@ module Mittsu
 
       @id = (@@id ||= 1).tap { @@id += 1 }
 
+      @uuid = SecureRandom.uuid
+
       @name = ''
       @type = 'Geometry'
 
@@ -105,7 +108,7 @@ module Mittsu
       }
       if indices
         draw_calls = geometry.draw_calls
-        if !draw_calls.length.empty?
+        if !draw_calls.empty?
           draw_calls.each do |draw_call|
             start = draw_call.start
             count = draw_call.count
@@ -119,7 +122,7 @@ module Mittsu
           end
         else
           indices.each_slice(3).with_index do |index|
-            add_face(*index)
+            add_face[*index]
           end
         end
       else
@@ -130,10 +133,10 @@ module Mittsu
         end
       end
       self.compute_face_normals
-      if geometry.boundingBox
+      if geometry.bounding_box
         @bounding_box = geometry.bounding_box.clone
       end
-      if geometry.boundingSphere
+      if geometry.bounding_sphere
         @bounding_sphere = geometry.bounding_sphere.clone
       end
       self
@@ -160,12 +163,12 @@ module Mittsu
       end
     end
 
-    def compute_vertex_normals(area_weigted)
+    def compute_vertex_normals(area_weighted = false)
       vertices = Array.new(@vertices.length)
       @vertices.length.times do |v|
         vertices[v] = Mittsu::Vector3.new
       end
-      if area_weigted
+      if area_weighted
         # vertex normals weighted by triangle areas
         # http:#www.iquilezles.org/www/articles/normals/normals.htm
         cb = Mittsu::Vector3.new, ab = Mittsu::Vector3.new

data/lib/mittsu/extras/geometries.rb

@@ -1,2 +1,15 @@
 require 'mittsu/extras/geometries/box_geometry'
 require 'mittsu/extras/geometries/sphere_geometry'
+require 'mittsu/extras/geometries/ring_geometry'
+require 'mittsu/extras/geometries/circle_geometry'
+require 'mittsu/extras/geometries/cylinder_geometry'
+require 'mittsu/extras/geometries/dodecahedron_geometry'
+require 'mittsu/extras/geometries/icosahedron_geometry'
+require 'mittsu/extras/geometries/octahedron_geometry'
+require 'mittsu/extras/geometries/tetrahedron_geometry'
+require 'mittsu/extras/geometries/plane_buffer_geometry'
+require 'mittsu/extras/geometries/plane_geometry'
+require 'mittsu/extras/geometries/torus_geometry'
+require 'mittsu/extras/geometries/torus_knot_geometry'
+require 'mittsu/extras/geometries/parametric_geometry'
+require 'mittsu/extras/geometries/lathe_geometry'

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

@@ -0,0 +1,48 @@
+require 'mittsu/core'
+require 'mittsu/math'
+
+module Mittsu
+  class CircleGeometry < Geometry
+    def initialize(radius = 50.0, segments = 8, theta_start = 0.0, theta_length = (Math::PI * 2.0))
+      super()
+
+      @type = 'CircleGeometry'
+
+      @parameters = {
+        radius:       radius,
+        segments:     segments,
+        theta_start:  theta_start,
+        theta_length: theta_length
+      }
+
+      segments = [3, segments].max
+
+      center = Vector3.new
+      center_uv = Vector2.new(0.5, 0.5)
+
+      @vertices << center
+      uvs = [center_uv]
+
+      for i in 0..segments do
+        vertex = Vector3.new
+        segment = theta_start + i.to_f / segments.to_f * theta_length
+
+        vertex.x = radius * Math.cos(segment)
+        vertex.y = radius * Math.sin(segment)
+
+        @vertices << vertex
+        uvs << Vector2.new((vertex.x / radius + 1.0) / 2.0, (vertex.y / radius + 1.0) / 2.0)
+      end
+
+      n = Vector3.new
+
+      for i in 1..segments do
+        @faces << Face3.new(i, i + 1, 0, [n.clone, n.clone, n.clone])
+        @face_vertex_uvs[0] << [uvs[i].clone, uvs[i + 1].clone, center_uv.clone]
+      end
+
+      compute_face_normals
+      @bounding_sphere = Sphere.new(Vector3.new, radius)
+    end
+  end
+end

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

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/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

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

@@ -0,0 +1,120 @@
+module Mittsu
+  class TorusKnotBufferGeometry < BufferGeometry
+    def initialize(radius = 100.0, tube = 40.0, radial_segments = 64, tubular_segments = 8, p_val = 2, q_val = 3)
+      super()
+
+      @type = 'TorusKnotBufferGeometry'
+
+      @parameters = {
+        radius:           radius,
+        tube:             tube,
+        radial_segments:  radial_segments,
+        tubular_segments: tubular_segments,
+        p_val:            p_val,
+        q_val:            q_val
+      }
+
+      # buffers
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      # helper variables
+
+      vertex = Vector3.new
+      normal = Vector3.new
+
+      p1 = Vector3.new
+      p2 = Vector3.new
+
+      b = Vector3.new
+      t = Vector3.new
+      n = Vector3.new
+
+      # generate vertices, normals and uvs
+
+      for i in 0..tubular_segments do
+        # the radian "u" is used to calculate the position on the torus curve of the current tubular segement
+        u = i.to_f / tubular_segments.to_f * p_val.to_f * Math::PI * 2.0
+
+        # now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
+        # these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions
+        calculate_position_on_curve(u,        p_val, q_val, radius, p1)
+        calculate_position_on_curve(u + 0.01, p_val, q_val, radius, p2)
+
+        # calculate orthonormal basis
+        t.sub_vectors(p2, p1)
+        n.add_vectors(p2, p1)
+        b.cross_vectors(t, n)
+        n.cross_vectors(b, t)
+
+        # normalize B, N. T can be ignored, we don't use it
+        b.normalize
+        n.normalize
+
+        for j in 0..radial_segments do
+          # now calculate the vertices. they are nothing more than an extrusion of the torus curve.
+          # because we extrude a shape in the xy-plane, there is no need to calculate a z-value.
+          v = j.to_f / radial_segments.to_f * Math::PI * 2.0
+          cx = -tube * Math.cos(v)
+          cy = tube * Math.sin(v)
+
+          # now calculate the final vertex position.
+          # first we orient the extrusion with our basis vectos, then we add it to the current position on the curve
+          vertex.x = p1.x + (cx * n.x + cy * b.x)
+          vertex.y = p1.y + (cx * n.y + cy * b.y)
+          vertex.z = p1.z + (cx * n.z + cy * b.z)
+
+          vertices += vertex.elements
+
+          # normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)
+          normal.sub_vectors(vertex, p1).normalize
+          
+          normals += normal.elements
+
+          # uv
+          uvs << i.to_f / tubular_segments.to_f
+          uvs << j.to_f / radial_segments.to_f
+        end
+      end
+
+      # generate indices
+
+      for j in 1..tubular_segments do
+        for i in 1..radial_segments do
+          # indices
+          a = (radial_segments + 1) * (j - 1) + (i - 1)
+          b = (radial_segments + 1) * j + (i - 1)
+          c = (radial_segments + 1) * j + i
+          d = (radial_segments + 1) * (j - 1) + i
+
+          # faces
+          indices += [a, b, d]
+          indices += [b, c, d]
+        end
+      end
+
+      # build geometry
+
+      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
+
+    private
+
+    def calculate_position_on_curve(u, p_val, q_val, radius, position)
+      cu = Math.cos(u)
+      su = Math.sin(u)
+      qu_over_p = q_val.to_f / p_val.to_f * u
+      cs = Math.cos(qu_over_p)
+
+      position.x = radius * (2.0 + cs) * 0.5 * cu
+      position.y = radius * (2.0 + cs) * su * 0.5
+      position.z = radius * Math.sin(qu_over_p) * 0.5
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'mittsu/core'
+require 'mittsu/math'
+require 'mittsu/extras/geometries/torus_knot_buffer_geometry'
+
+module Mittsu
+  class TorusKnotGeometry < Geometry
+    def initialize(radius = 100.0, tube = 40.0, radial_segments = 64, tubular_segments = 8, p_val = 2, q_val = 3)
+      super()
+
+      @type = 'TorusKnotGeometry'
+
+      @parameters = {
+        radius:           radius,
+        tube:             tube,
+        radial_segments:  radial_segments,
+        tubular_segments: tubular_segments,
+        p_val:            p_val,
+        q_val:            q_val
+      }
+
+      from_buffer_geometry(TorusKnotBufferGeometry.new(radius, tube, tubular_segments, radial_segments, p_val, q_val))
+      merge_vertices
+    end
+  end
+end

data/lib/mittsu/math/vector.rb

@@ -1,6 +1,6 @@
 module Mittsu
   class Vector
-    attr_accessor :elements
+    attr_accessor :elements, :uv, :index
 
     def initialize(elements)
       @elements = elements

data/lib/mittsu/version.rb

@@ -1,4 +1,4 @@
 module Mittsu
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
   REVISION = "71"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mittsu
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-16 00:00:00.000000000 Z
+date: 2018-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opengl-bindings
@@ -181,7 +181,23 @@ files:
 - lib/mittsu/extras.rb
 - lib/mittsu/extras/geometries.rb
 - lib/mittsu/extras/geometries/box_geometry.rb
+- lib/mittsu/extras/geometries/circle_geometry.rb
+- lib/mittsu/extras/geometries/cylinder_geometry.rb
+- lib/mittsu/extras/geometries/dodecahedron_geometry.rb
+- lib/mittsu/extras/geometries/icosahedron_geometry.rb
+- lib/mittsu/extras/geometries/lathe_geometry.rb
+- lib/mittsu/extras/geometries/octahedron_geometry.rb
+- lib/mittsu/extras/geometries/parametric_buffer_geometry.rb
+- lib/mittsu/extras/geometries/parametric_geometry.rb
+- lib/mittsu/extras/geometries/plane_buffer_geometry.rb
+- lib/mittsu/extras/geometries/plane_geometry.rb
+- lib/mittsu/extras/geometries/polyhedron_geometry.rb
+- lib/mittsu/extras/geometries/ring_geometry.rb
 - lib/mittsu/extras/geometries/sphere_geometry.rb
+- lib/mittsu/extras/geometries/tetrahedron_geometry.rb
+- lib/mittsu/extras/geometries/torus_geometry.rb
+- lib/mittsu/extras/geometries/torus_knot_buffer_geometry.rb
+- lib/mittsu/extras/geometries/torus_knot_geometry.rb
 - lib/mittsu/extras/helpers.rb
 - lib/mittsu/extras/helpers/camera_helper.rb
 - lib/mittsu/extras/image.rb