mittsu 0.1.1 → 0.1.2

data/lib/mittsu/loaders/obj_mtl_loader.rb

@@ -6,220 +6,24 @@ module Mittsu
       @manager = manager
     end
 
-    def load(url, mtlurl)
-      mtl_loader = MTLLoader.new(File.dirname(url))
-      # mtl_loader.cross_origin = @cross_origin # TODO: not needed?
-      materials_creator = mtl_loader.load(mtlurl)
+    def load(url, mtlurl = nil)
+      object = OBJLoader.new(@manager).load(url)
 
-      materials_creator.preload
+      if !mtlurl.nil?
+        mtl_loader = MTLLoader.new(File.dirname(url))
+        materials_creator = mtl_loader.load(mtlurl)
 
-      loader = FileLoader.new(@manager)
-      # loader.cross_origin = @cross_origin # TODO: not needed?
+        materials_creator.preload
 
-      text = loader.load(url)
-      object = parse(text)
-
-      object.traverse do |child_object|
-        if child_object.is_a?(Mesh) && child_object.material.name && !child_object.material.name.empty?
-          material = materials_creator.create(child_object.material.name)
-          child_object.material = material if material
+        object.traverse do |child_object|
+          if child_object.is_a?(Mesh) && child_object.material.name && !child_object.material.name.empty?
+            material = materials_creator.create(child_object.material.name)
+            child_object.material = material if material
+          end
         end
       end
 
       object
     end
-
-    def parse(data)
-      @face_offset = 0
-      @group = Group.new
-      @object = @group
-
-      @geometry = Geometry.new
-      @material = MeshLambertMaterial.new
-      @mesh = Mesh.new(@geometry, @material)
-
-      @vertices = []
-      @normals = []
-      @uvs = []
-
-      # v float float float
-      vertex_pattern = /v( +[\d|.|+|\-|e]+)( +[\d|.|+|\-|e]+)( +[\d|.|+|\-|e]+)/
-
-      # vn float float float
-      normal_pattern = /vn( +[\d|.|+|\-|e]+)( +[\d|.|+|\-|e]+)( +[\d|.|+|\-|e]+)/
-
-      # vt float flot
-      uv_pattern = /vt( +[\d|.|+|\-|e]+)( +[\d|.|+|\-|e]+)/
-
-      # f vertex vertex vertex
-      face_pattern1 = /f( +\d+)( +\d+)( +\d+)?/
-
-      # f vertex/uv vertex/uv vertex/uv
-  		face_pattern2 = /f( +(\d+)\/(\d+))( +(\d+)\/(\d+))( +(\d+)\/(\d+))( +(\d+)\/(\d+))?/
-
-  		# f vertex/uv/normal vertex/uv/normal vertex/uv/normal ...
-  		face_pattern3 = /f( +(\d+)\/(\d+)\/(\d+))( +(\d+)\/(\d+)\/(\d+))( +(\d+)\/(\d+)\/(\d+))( +(\d+)\/(\d+)\/(\d+))?/
-
-  		# f vertex//normal vertex//normal vertex//normal ...
-  		face_pattern4 = /f( +(\d+)\/\/(\d+))( +(\d+)\/\/(\d+))( +(\d+)\/\/(\d+))( +(\d+)\/\/(\d+))?/
-
-      lines = data.split("\n")
-
-      lines.each do |line|
-  			line = line.strip
-
-  			next if line.empty? || line.start_with?('#')
-
-  			if vertex_pattern =~ line
-  				# ["v 1.0 2.0 3.0", "1.0", "2.0", "3.0"]
-  				@vertices << vector($1.to_f, $2.to_f, $3.to_f)
-  			elsif normal_pattern =~ line
-  				# ["vn 1.0 2.0 3.0", "1.0", "2.0", "3.0"]
-  				@normals << vector($1.to_f, $2.to_f, $3.to_f)
-  			elsif uv_pattern =~ line
-  				# ["vt 0.1 0.2", "0.1", "0.2"]
-  				@uvs << uv($1.to_f, $2.to_f)
-  			elsif face_pattern1 =~ line
-  				# ["f 1 2 3", "1", "2", "3", undefined]
-  				handle_face_line([ $1, $2, $3, $4 ])
-  			elsif face_pattern2 =~ line
-  				# ["f 1/1 2/2 3/3", " 1/1", "1", "1", " 2/2", "2", "2", " 3/3", "3", "3", undefined, undefined, undefined]
-  				handle_face_line(
-  					[ $2, $5, $8, $11 ], #faces
-  					[ $3, $6, $9, $12 ] #uv
-  				)
-  			elsif face_pattern3 =~ line
-  				# ["f 1/1/1 2/2/2 3/3/3", " 1/1/1", "1", "1", "1", " 2/2/2", "2", "2", "2", " 3/3/3", "3", "3", "3", undefined, undefined, undefined, undefined]
-  				handle_face_line(
-  					[ $2, $6, $10, $14 ], #faces
-  					[ $3, $7, $11, $15 ], #uv
-  					[ $4, $8, $12, $16 ] #normal
-  				)
-  			elsif face_pattern4 =~ line
-  				# ["f 1//1 2//2 3//3", " 1//1", "1", "1", " 2//2", "2", "2", " 3//3", "3", "3", undefined, undefined, undefined]
-  				handle_face_line(
-  					[ $2, $5, $8, $11 ], #faces
-  					[ ], #uv
-  					[ $3, $6, $9, $12 ] #normal
-  				)
-  			elsif /^o / =~ line
-  				# object
-  				mesh_n
-  				@face_offset = @face_offset + @vertices.length
-  				@vertices = []
-  				object = Object3D.new
-  				object.name = line[2..-1].strip
-  				@group.add(object)
-  			elsif /^g / =~ line
-  				# group
-  				mesh_n(line[2..-1].strip, nil)
-  			elsif /^usemtl / =~ line
-  				# material
-  				mesh_n(nil, line[7..-1].strip)
-  			elsif /^mtllib / =~ line
-  				# mtl file
-
-          # TODO: ???
-  				# if mtllib_callback
-  				# 	mtlfile = line[7..-1].strip
-  				# 	mtllib_callback.(mtlfile)
-  				# end
-  			elsif /^s / =~ line
-  				# Smooth shading
-  			else
-  				puts "Mittsu::OBJMTLLoader: Unhandled line #{line}"
-  			end
-      end
-
-      mesh_n(nil, nil)
-
-      @group
-    end
-
-    private
-
-    def vector(x, y, z)
-      Vector3.new(x, y, z)
-    end
-
-    def uv(u, v)
-      Vector2.new(u, v)
-    end
-
-    def face3(a, b, c, normals = nil)
-      Face3.new(a, b, c, normals)
-    end
-
-    def mesh_n(mesh_name = nil, material_name = nil)
-      if !@vertices.empty?
-        @geometry.vertices = @vertices
-
-        @geometry.merge_vertices
-        @geometry.compute_face_normals
-        @geometry.compute_bounding_sphere
-
-        @object.add(@mesh)
-
-        @geometry = Geometry.new
-        @mesh = Mesh.new(@geometry, @material)
-      end
-
-      @mesh.name = mesh_name unless mesh_name.nil?
-
-      if !material_name.nil?
-        @material = MeshLambertMaterial.new
-        @material.name = material_name
-
-        @mesh.material = @material
-      end
-    end
-
-    def add_face(a, b, c, normal_inds = nil)
-      if normal_inds.nil?
-        @geometry.faces << face3(
-          a.to_i - (@face_offset + 1),
-          b.to_i - (@face_offset + 1),
-          c.to_i - (@face_offset + 1)
-        )
-      else
-        @geometry.faces << face3(
-          a.to_i - (@face_offset + 1),
-          b.to_i - (@face_offset + 1),
-          c.to_i - (@face_offset + 1),
-          normal_inds.take(3).map { |i| @normals[i.to_i - 1].clone }
-        )
-      end
-    end
-
-    def add_uvs(a, b, c)
-      @geometry.face_vertex_uvs[0] << [
-        @uvs[a.to_i - 1].clone,
-        @uvs[b.to_i - 1].clone,
-        @uvs[c.to_i - 1].clone
-      ]
-    end
-
-    def handle_face_line(faces, uvs = nil, normal_inds = nil)
-      if faces[3].nil?
-        add_face(faces[0], faces[1], faces[2], normal_inds)
-
-        if !uvs.nil? && !uvs.empty?
-          add_uvs(uvs[0], uvs[1], uvs[2])
-        end
-      else
-        if !normal_inds.nil? && !normal_inds.empty?
-          add_face(faces[0], faces[1], fances[3], [normal_inds[0], normal_inds[1], normal_inds[3]])
-          add_face(faces[1], faces[2], fances[3], [normal_inds[1], normal_inds[2], normal_inds[3]])
-        else
-          add_face(faces[0], faces[1], faces[3])
-          add_face(faces[1], faces[2], faces[3])
-        end
-
-        if !uvs.nil? && !uvs.empty?
-          add_uvs(uvs[0], uvs[1], uvs[2])
-          add_uvs(uvs[1], uvs[2], uvs[2])
-        end
-      end
-    end
   end
 end

data/lib/mittsu/materials/material.rb

@@ -1,9 +1,8 @@
 require 'securerandom'
 require 'mittsu'
-require 'mittsu/core/hash_object'
 
 module Mittsu
-  class Material < HashObject
+  class Material
     include EventDispatcher
 
     attr_reader :id, :uuid, :type
@@ -136,6 +135,10 @@ module Mittsu
       dispatch_event type: :dispose
     end
 
+    def implementation(renderer)
+      @_implementation ||= renderer.create_implementation(self)
+    end
+
     private
 
     def has_property?(key)

data/lib/mittsu/materials/mesh_basic_material.rb

@@ -109,14 +109,5 @@ module Mittsu
 
       material
     end
-
-    def to_json
-      output = super
-      output[:color] = @color.hex
-      output[:vertex_colors] = @vertex_colors unless @vertex_colors == NoColors
-      output[:blending] = @blending unless @blending == NormalBlending
-      output[:side] = @side unless @side == FrontSide
-      output
-    end
   end
 end

data/lib/mittsu/math/color.rb

@@ -1,10 +1,13 @@
 require 'mittsu/math'
+require 'mittsu/math/vector3'
 
 module Mittsu
-  class Color
-    attr_accessor :r, :g, :b
+  class Color < Vector3
+    ELEMENTS = { r: 0, g: 1, b: 2 }
+    DIMENSIONS = ELEMENTS.count
 
     def initialize(*args)
+      super(0, 0, 0)
       case args.length
       when 3 then self.set_rgb(*args)
       when 1 then self.set(args.first)
@@ -13,6 +16,14 @@ module Mittsu
       end
     end
 
+    alias :r :x
+    alias :g :y
+    alias :b :z
+
+    alias :r= :x=
+    alias :g= :y=
+    alias :b= :z=
+
     def set(value)
       case value
       when Color
@@ -29,29 +40,27 @@ module Mittsu
 
     def set_hex(hex)
       hex = hex.floor
-      @r = (hex >> 16 & 255) / 255.0
-      @g = (hex >> 8 & 255) / 255.0
-      @b = (hex & 255) / 255.0
+      self.r = (hex >> 16 & 255) / 255.0
+      self.g = (hex >> 8 & 255) / 255.0
+      self.b = (hex & 255) / 255.0
       self
     end
 
     def set_rgb(r, g, b)
-      @r = r.to_f
-      @g = g.to_f
-      @b = b.to_f
+      @elements = [r.to_f, g.to_f, b.to_f]
       self
     end
 
     def set_hsl(h, s, l)
       # h,s,l ranges are in 0.0 - 1.0
       if s.zero?
-        @r = @g = @b = l
+        self.r = self.g = self.b = l
       else
         p = l <= 0.5 ? l * (1.0 + s) : l + s - (l * s)
         q = (2.0 * l) - p
-        @r = hue2rgb(q, p, h + 1.0 / 3.0)
-        @g = hue2rgb(q, p, h)
-        @b = hue2rgb(q, p, h - 1.0 / 3.0)
+        self.r = hue2rgb(q, p, h + 1.0 / 3.0)
+        self.g = hue2rgb(q, p, h)
+        self.b = hue2rgb(q, p, h - 1.0 / 3.0)
       end
       self
     end
@@ -59,16 +68,16 @@ module Mittsu
     def set_style(style)
       # rgb(255,0,0)
       if /^rgb\((\d+), ?(\d+), ?(\d+)\)$/i =~ style
-        @r = [255.0, $1.to_f].min / 255.0
-        @g = [255.0, $2.to_f].min / 255.0
-        @b = [255.0, $3.to_f].min / 255.0
+        self.r = [255.0, $1.to_f].min / 255.0
+        self.g = [255.0, $2.to_f].min / 255.0
+        self.b = [255.0, $3.to_f].min / 255.0
         return self
       end
       # rgb(100%,0%,0%)
       if /^rgb\((\d+)\%, ?(\d+)\%, ?(\d+)\%\)$/i =~ style
-        @r = [100.0, $1.to_f].min / 100.0
-        @g = [100.0, $2.to_f].min / 100.0
-        @b = [100.0, $3.to_f].min / 100.0
+        self.r = [100.0, $1.to_f].min / 100.0
+        self.g = [100.0, $2.to_f].min / 100.0
+        self.b = [100.0, $3.to_f].min / 100.0
         return self
       end
       # #ff0000
@@ -88,45 +97,38 @@ module Mittsu
       end
     end
 
-    def copy(color)
-      @r = color.r
-      @g = color.g
-      @b = color.b
-      self
-    end
-
     def copy_gamma_to_linear(color, gamma_factor = 2.0)
-      @r = color.r ** gamma_factor
-      @g = color.g ** gamma_factor
-      @b = color.b ** gamma_factor
+      self.r = color.r ** gamma_factor
+      self.g = color.g ** gamma_factor
+      self.b = color.b ** gamma_factor
       self
     end
 
     def copy_linear_to_gamma(color, gamma_factor = 2.0)
       safe_inverse = (gamma_factor > 0) ? (1.0 / gamma_factor) : 1.0
-      @r = color.r ** safe_inverse
-      @g = color.g ** safe_inverse
-      @b = color.b ** safe_inverse
+      self.r = color.r ** safe_inverse
+      self.g = color.g ** safe_inverse
+      self.b = color.b ** safe_inverse
       self
     end
 
     def convert_gamma_to_linear
-      rr, gg, bb = @r, @g, @b
-      @r = rr * rr
-      @g = gg * gg
-      @b = bb * bb
+      rr, gg, bb = self.r, self.g, self.b
+      self.r = rr * rr
+      self.g = gg * gg
+      self.b = bb * bb
       self
     end
 
     def convert_linear_to_gamma
-      @r = Math.sqrt(@r)
-      @g = Math.sqrt(@g)
-      @b = Math.sqrt(@b)
+      self.r = Math.sqrt(self.r)
+      self.g = Math.sqrt(self.g)
+      self.b = Math.sqrt(self.b)
       self
     end
 
     def hex
-      (@r * 255).to_i << 16 ^ (@g * 255).to_i << 8 ^ (@b * 255).to_i << 0
+      (self.r * 255).to_i << 16 ^ (self.g * 255).to_i << 8 ^ (self.b * 255).to_i << 0
     end
 
     def hex_string
@@ -136,7 +138,7 @@ module Mittsu
     def hsl(target = nil)
       # h,s,l ranges are in 0.0 - 1.0
       hsl = target || { h: 0.0, s: 0.0, l: 0.0 }
-      rr, gg, bb = @r, @g, @b
+      rr, gg, bb = self.r, self.g, self.b
       max = [r, g, b].max
       min = [r, g, b].min
       hue, saturation = nil, nil
@@ -161,7 +163,7 @@ module Mittsu
     end
 
     def style
-      "rgb(#{ (@r * 255).to_i },#{ (@g * 255).to_i },#{ (@b * 255).to_i })"
+      "rgb(#{ (self.r * 255).to_i },#{ (self.g * 255).to_i },#{ (self.b * 255).to_i })"
     end
 
     def offset_hsl(h, s, l)
@@ -173,69 +175,7 @@ module Mittsu
       self
     end
 
-    def add(color)
-      @r += color.r
-      @g += color.g
-      @b += color.b
-      self
-    end
-
-    def add_colors(color1, color2)
-      @r = color1.r + color2.r
-      @g = color1.g + color2.g
-      @b = color1.b + color2.b
-      self
-    end
-
-    def add_scalar(s)
-      @r += s
-      @g += s
-      @b += s
-      self
-    end
-
-    def multiply(color)
-      @r *= color.r
-      @g *= color.g
-      @b *= color.b
-      self
-    end
-
-    def multiply_scalar(s)
-      @r *= s
-      @g *= s
-      @b *= s
-      self
-    end
-
-    def lerp(color, alpha)
-      @r += (color.r - @r) * alpha
-      @g += (color.g - @g) * alpha
-      @b += (color.b - @b) * alpha
-      self
-    end
-
-    def equals(c)
-      (c.r == @r) && (c.g == @g) && (c.b == @b)
-    end
-
-    def from_array(array)
-      @r = array[0]
-      @g = array[1]
-      @b = array[2]
-      self
-    end
-
-    def to_array(array = [], offset = 0)
-      array[offset] = @r
-      array[offset + 1] = @g
-      array[offset + 2] = @b
-      array
-    end
-
-    def clone
-      Mittsu::Color.new(@r, @g, @b)
-    end
+    alias :add_colors :add_vectors
 
     private