mittsu 0.1.0

data/lib/mittsu/loaders/obj_mtl_loader.rb

@@ -0,0 +1,225 @@
+module Mittsu
+  class OBJMTLLoader
+    include EventDispatcher
+
+    def initialize(manager = DefaultLoadingManager)
+      @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)
+
+      materials_creator.preload
+
+      loader = FileLoader.new(@manager)
+      # loader.cross_origin = @cross_origin # TODO: not needed?
+
+      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
+        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.rb

@@ -0,0 +1,7 @@
+require 'mittsu/materials/material'
+require 'mittsu/materials/mesh_basic_material'
+require 'mittsu/materials/mesh_lambert_material'
+require 'mittsu/materials/mesh_phong_material'
+require 'mittsu/materials/shader_material'
+require 'mittsu/materials/line_basic_material'
+require 'mittsu/materials/mesh_face_material'

data/lib/mittsu/materials/line_basic_material.rb

@@ -0,0 +1,39 @@
+module Mittsu
+  class LineBasicMaterial < Material
+    attr_accessor :line_width, :line_cap, :line_join
+
+    def initialize(parameters = {})
+      super()
+
+      @type = 'LineBasicMaterial'
+
+      @color = Color.new(0xffffff)
+
+      @line_width = 1.0
+      @line_cap = :round
+      @line_join = :round
+
+      @vertex_colors = NoColors
+
+      @fog = true
+
+      self.set_values(parameters)
+    end
+
+    def clone
+      LineBasicMaterial.new.tap do |material|
+        super(material)
+
+        material.color.copy(@color)
+
+        material.line_width = @line_width
+        material.line_cap = @line_cap
+        material.line_join = @line_join
+
+        material.vertex_colors = @vertex_colors
+
+        material.fog = @fog
+      end
+    end
+  end
+end

data/lib/mittsu/materials/material.rb

@@ -0,0 +1,156 @@
+require 'securerandom'
+require 'mittsu'
+require 'mittsu/core/hash_object'
+
+module Mittsu
+  class Material < HashObject
+    include EventDispatcher
+
+    attr_reader :id, :uuid, :type
+
+    attr_accessor :name, :side, :opacity, :transparent, :blending, :blend_src, :blend_dst, :blend_equation, :blend_src_alpha, :blend_dst_alpha, :blend_equation_alpha, :depth_test, :depth_write, :color_write, :polygon_offset, :polygon_offset_factor, :polygon_offset_units, :alpha_test, :overdraw, :visible, :attributes, :shading, :program
+
+    attr_accessor :map, :env_map, :light_map, :light_map, :normal_map, :specular_map, :alpha_map, :combine, :vertex_colors, :fog, :size_attenuation, :skinning, :morph_targets, :morph_normals, :metal, :wrap_around, :defines, :lights, :color, :bump_map, :reflectivity, :refraction_ratio, :wireframe, :default_attribute_values, :uniforms, :vertex_shader, :fragment_shader
+
+    def initialize
+      super
+      @id = (@@id ||= 1).tap { @@id += 1 }
+
+      @uuid = SecureRandom.uuid
+
+      @name = ''
+      @type = 'Material'
+
+      @side = FrontSide
+
+      @opacity = 1.0
+      @transparent = false
+
+      @blending = NormalBlending
+
+      @blend_src = SrcAlphaFactor
+      @blend_dst = OneMinusSrcAlphaFactor
+      @blend_equation = AddEquation
+      @blend_src_alpha = nil
+      @blend_dst_alpha = nil
+      @blend_equation_alpha = nil
+
+      @depth_test = true
+      @depth_write = true
+
+      @color_write = true
+
+      @polygon_offset = false
+      @polygon_offset_factor = 0
+      @polygon_offset_units = 0
+
+      @alpha_test = 0
+
+      # TODO: remove this maybe???
+      @overdraw = 0 # Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer
+
+      @visible = true
+
+      @_needs_update = true
+    end
+
+    def needs_update?
+      @_needs_update
+    end
+
+    def needs_update=(value)
+      update if value
+      @_needs_update = value
+    end
+
+    def set_values(values = nil)
+      return if values.nil?
+
+      values.each do |(key, new_value)|
+        if new_value.nil?
+          puts "WARNING: Mittsu::Material: #{key} parameter is undefined"
+          next
+        end
+
+        if has_property? key
+          current_value = get_property(key)
+
+          if current_value.is_a? Color
+            current_value.set(new_value)
+          elsif current_value.is_a?(Vector3) && new_value.is_a?(Vector3)
+            current_value.copy(new_value)
+          else
+            set_property(key, new_value)
+          end
+        end
+      end
+    end
+
+    def to_json
+      output = {
+        metadata: {
+          version: 4.2,
+          type: 'material',
+          generator: 'MaterialExporter'
+        },
+        uuid: @uuid,
+        type: @type
+      }
+
+      output[:name] = @name if !@name.nil? && !@name.empty?
+
+      output[:opacity] = @opacity if @opacity < 1.0
+      output[:transparent] = @transparent if @transparent
+      output[:wireframe] = @wireframe if @wireframe
+      output
+    end
+
+    def clone(material = Material.new)
+      material.name = @name
+      material.side = @side
+      material.opacity = @opacity
+      material.transparent = @transparent
+      material.blending = @blending
+      material.blend_src = @blend_src
+      material.blend_dst = @blend_dst
+      material.blend_equation = @blend_equation
+      material.blend_src_alpha = @blend_src_alpha
+      material.blend_dst_alpha = @blend_dst_alpha
+      material.blend_equation_alpha = @blend_equation_alpha
+      material.depth_test = @depth_test
+      material.depth_write = @depth_write
+      material.color_write = @color_write
+      material.polygon_offset = @polygon_offset
+      material.polygon_offset_factor = @polygon_offset_factor
+      material.polygon_offset_units = @polygon_offset_units
+      material.alpha_test = @alpha_test
+      material.overdraw = @overdraw
+      material.visible = @visible
+    end
+
+    def update
+      dispatch_event type: :update
+    end
+
+    def dispose
+      dispatch_event type: :dispose
+    end
+
+    private
+
+    def has_property?(key)
+      sym = "@#{key}".to_sym
+      self.instance_variable_defined?(sym)
+    end
+
+    def set_property(key, value)
+      sym = "@#{key}".to_sym
+      self.instance_variable_set(sym, value)
+    end
+
+    def get_property(key)
+      sym = "@#{key}".to_sym
+      self.instance_variable_get(sym)
+    end
+  end
+end

data/lib/mittsu/materials/mesh_basic_material.rb

@@ -0,0 +1,122 @@
+require 'mittsu/math'
+require 'mittsu/materials/material'
+
+# parameters = {
+#  color: <hex>,
+#  opacity: <float>,
+#  map: Mittsu::Texture.new( <Image> ),
+#
+#  light_map: Mittsu::Texture.new( <Image> ),
+#
+#  specular_map: Mittsu::Texture.new( <Image> ),
+#
+#  alpha_map: Mittsu::Texture.new( <Image> ),
+#
+#  env_map: Mittsu::TextureCube.new( [posx, negx, posy, negy, posz, negz] ),
+#  combine: Mittsu::Multiply,
+#  reflectivity: <float>,
+#  refraction_ratio: <float>,
+#
+#  shading: Mittsu::SmoothShading,
+#  blending: Mittsu::NormalBlending,
+#  depth_test: <bool>,
+#  depth_write: <bool>,
+#
+#  wireframe: <boolean>,
+#  wireframe_linewidth: <float>,
+#
+#  vertex_colors: Mittsu::NoColors / Mittsu::VertexColors / Mittsu::FaceColors,
+#
+#  skinning: <bool>,
+#  morph_targets: <bool>,
+#
+#  fog: <bool>
+# }
+module Mittsu
+  attr_accessor :color, :map, :light_map, :specular_map, :alpha_map, :env_map, :combine, :reflectivity, :refraction_ratio, :shading, :wireframe, :wireframe_linewidth, :wireframe_linecap, :wireframe_linejoin, :vertex_colors, :skinning, :morph_targets, :fog
+
+  class MeshBasicMaterial < Material
+    def initialize(parameters = {})
+      super()
+
+      @type = 'MeshBasicMaterial'
+
+      @color = Color.new(0xffffff) # emissive
+
+      @map = nil
+
+      @light_map = nil
+
+      @specular_map = nil
+
+      @alpha_map = nil
+
+      @env_map = nil
+      @combine = MultiplyOperation
+      @reflectivity = 1.0
+      @refraction_ratio = 0.98
+
+      @fog = true
+
+      @shading = SmoothShading
+
+      @wireframe = false
+      @wireframe_linewidth = 1
+      @wireframe_linecap = :round
+      @wireframe_linejoin = :round
+
+      @vertex_colors = NoColors
+
+      @skinning = false
+      @morph_targets = false
+
+      set_values(parameters)
+    end
+
+    def clone
+      material = Material.new
+
+      super(material)
+
+      material.color.copy(@color)
+
+      material.map = @map
+
+      material.lightMap = @lightMap
+
+      material.specularMap = @specularMap
+
+      material.alphaMap = @alphaMap
+
+      material.envMap = @envMap
+      material.combine = @combine
+      material.reflectivity = @reflectivity
+      material.refractionRatio = @refractionRatio
+
+      material.fog = @fog
+
+      material.shading = @shading
+
+      material.wireframe = @wireframe
+      material.wireframeLinewidth = @wireframeLinewidth
+      material.wireframeLinecap = @wireframeLinecap
+      material.wireframeLinejoin = @wireframeLinejoin
+
+      material.vertexColors = @vertexColors
+
+      material.skinning = @skinning
+      material.morphTargets = @morphTargets
+
+      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