mittsu 0.1.0

data/lib/mittsu/loaders.rb

@@ -0,0 +1,7 @@
+require 'mittsu/loaders/cache'
+require 'mittsu/loaders/loader'
+require 'mittsu/loaders/loading_manager'
+require 'mittsu/loaders/image_loader'
+require 'mittsu/loaders/file_loader'
+require 'mittsu/loaders/mtl_loader'
+require 'mittsu/loaders/obj_mtl_loader'

data/lib/mittsu/loaders/cache.rb

@@ -0,0 +1,53 @@
+module Mittsu
+  module Cache
+    @@files = {}
+
+    def self.add(key, file)
+      @@files[key] = file
+    end
+
+    def self.get(key)
+      @@files[key]
+    end
+
+    def self.remove(key)
+      @@files.delete(key)
+    end
+
+    def self.clear
+      @@files.clear
+    end
+  end
+end
+
+# 	files: {},
+#
+# 	add: function ( key, file ) {
+#
+# 		// console.log( 'THREE.Cache', 'Adding key:', key );
+#
+# 		this.files[ key ] = file;
+#
+# 	},
+#
+# 	get: function ( key ) {
+#
+# 		// console.log( 'THREE.Cache', 'Checking key:', key );
+#
+# 		return this.files[ key ];
+#
+# 	},
+#
+# 	remove: function ( key ) {
+#
+# 		delete this.files[ key ];
+#
+# 	},
+#
+# 	clear: function () {
+#
+# 		this.files = {}
+#
+# 	}
+#
+# };

data/lib/mittsu/loaders/file_loader.rb

@@ -0,0 +1,22 @@
+module Mittsu
+  class FileLoader
+    def initialize(manager = nil)
+      @manager = manager || DefaultLoadingManager
+    end
+
+    def load(url)
+      cached = Cache.get(url)
+
+      return cached unless cached.nil?
+
+      @manager.item_start(url)
+
+      text = File.read(url)
+      Cache.add(url, text)
+
+      @manager.item_end(url)
+
+      text
+    end
+  end
+end

data/lib/mittsu/loaders/image_loader.rb

@@ -0,0 +1,32 @@
+require 'rmagick'
+require 'mittsu/extras/image'
+
+module Mittsu
+  class ImageLoader
+    attr_accessor :manager
+
+    def initialize(manager = DefaultLoadingManager)
+      @manager = manager
+    end
+
+    def load(url, flip: false, flop: false)
+      chache_url = "#{url}?flip=#{flip}&flop=#{flop}"
+      cached = Cache.get(url)
+      return cached unless cached.nil?
+
+      rm_image = Magick::Image.read(url).first
+      rm_image = rm_image.flip if flip
+      rm_image = rm_image.flop if flop
+      rgba_data = rm_image.to_blob { |i|
+        i.format = "RGBA"
+        i.depth = 8
+      }
+
+      image = Image.new(rm_image.columns, rm_image.rows, rgba_data)
+
+      Cache.add(url, image)
+      @manager.item_start(url)
+      image
+    end
+  end
+end

data/lib/mittsu/loaders/loader.rb

@@ -0,0 +1,212 @@
+module Mittsu
+  class Loader
+    def initialize(show_status = false)
+      @image_loader = ImageLoader.new
+    end
+
+    def init_materials(materials, texture_path)
+      materials.map do |m|
+        create_material(m, texture_path)
+      end
+    end
+
+    def needs_tangents(materials)
+      materials.each do |m|
+        return true if m.is_a?(ShareMaterial)
+      end
+      false
+    end
+
+    def create_material(m, texture_path)
+      # defaults
+
+      mtype = 'MeshLambertMaterial'
+      mpars = {
+        color: 0xeeeeee,
+        opactity: 1.0,
+        map: nil,
+        light_map: nil,
+        normal_map: nil,
+        bump_map: nil,
+        wireframe: false
+      }
+
+      # parameters from model file
+
+      if m.shading
+        shading = m.shading.downcase
+
+        if shading == 'phong'
+          mtype = 'MeshPhongMaterial'
+        elsif shading == 'basic'
+          mtype = 'MeshBasicMaterial'
+        end
+      end
+
+      if m.blending && Mittsu.const_get(m.blending)
+        mpars[:blending] = Mittsu.const_get(m.blending)
+      end
+
+      mpars[:transparent] = m.transparent if !m.transparent.nil?
+      mpars[:transparent] = true if m.opacity && m.opacity < 1.0
+      mpars[:depth_test] = m.depth_test if !m.depth_test.nil?
+      mpars[:depth_write] = m.depth_write if !m.depth_write.nil?
+      mpars[:visible] = m.visible if !m.visible.nil?
+      mpars[:flip_sided] = BackSide if !m.flip_sided.nil?
+      mpars[:double_sided] = DoubleSide if !m.double_sided.nil?
+      mpars[:wireframe] = m.wireframe if !m.wireframe.nil?
+
+      if !m.vertex_colors.nil?
+        if m.vertex_colors == 'face'
+          mpars[:vertex_colors] = FaceColors
+        elsif !m.vertex_colors.empty?
+          mpars[:vertex_colors] = VertexColors
+        end
+      end
+
+      # colors
+
+      if m.color_diffuse
+        mpars[:color] = rgb2hex(m.color_diffuse)
+      elsif m.dgb_color
+        mpars[:color] = m.dgb_color
+      end
+
+      if m.color_specular
+        mpars[:specular] = rgb2hex(m.color_specular)
+      end
+
+      if m.color_emissive
+        mpars[:emissive] = rgb2hex(m.color_emissive)
+      end
+
+      # modifiers
+
+      if !m.transparency.nil?
+        puts "WARNING: Mitsu::Loader: transparency has been renamed to opacity"
+        m.opacity = m.transparency
+      end
+
+      if !m.opacity.nil?
+        mpars[:opacity] = m.opacity
+      end
+
+      if m.specular_coef
+        mpars[:shininess] = m.specular_coef
+      end
+
+      # textures
+
+      if m.map_diffuse && texture_path
+        create_texture(mpars, 'map', m.map_diffuse, m.map_diffuse_repeat, m.map_diffuse_offset, m.map_diffuse_wrap, m.map_diffuse_anisotropy)
+      end
+
+      if m.map_light && texture_path
+        create_texture(mpars, 'light_map', m.map_light, m.map_light_repeat, m.map_light_offset, m.map_light_wrap, m.map_light_anisotropy)
+      end
+
+      if m.map_bump && texture_path
+        create_texture(mpars, 'bump_map', m.map_bump, m.map_bump_repeat, m.map_bump_offset, m.map_bump_wrap, m.map_bump_anisotropy)
+      end
+
+      if m.map_normal && texture_path
+        create_texture(mpars, 'normal_map', m.map_normal, m.map_normal_repeat, m.map_normal_offset, m.map_normal_wrap, m.map_normal_anisotropy)
+      end
+
+      if m.map_specular && texture_path
+        create_texture(mpars, 'specular_map', m.map_specular, m.map_specular_repeat, m.map_specular_offset, m.map_specular_wrap, m.map_specular_anisotropy)
+      end
+
+      if m.map_alpha && texture_path
+        create_texture(mpars, 'alpha_map', m.map_alpha, m.map_alpha_repeat, m.map_alpha_offset, m.map_alpha_wrap, m.map_alpha_anisotropy)
+      end
+
+      #
+
+      if m.map_bump_scale
+        mpars[:bump_scale] = m.map_bump_scale
+      end
+
+      if m.map_normal_factor
+        mpars[:normal_scale] = Vector2.new(m.map_normal_factor, m.map_normal_factor)
+      end
+
+      Mittsu.const_get(mtype).new(mpars).tap do |material|
+        material.name = m.dbg_name if !m.dbg_name.nil?
+      end
+    end
+
+    module Handlers
+      def self.add(regex, loader)
+        @@handlers ||= {}
+        @@handlers[regex] = loader
+      end
+
+      def self.get(file)
+        @@handlers ||= {}
+        @@handlers.find(-> () { [nil, nil] }) { |regex, loader| regex =~ file }[1]
+      end
+    end
+
+    private
+
+    def nearest_pow2(n)
+      l = Math.log(n) / Math::LN2
+      Math.pow(2, Math.round(l))
+    end
+
+    def create_texture(where, name, source_file, repeat, offset, wrap, anisotropy)
+      full_path = File.join(texture_path, source_file)
+
+      loader = Handlers.get(full_path)
+
+      if !loader.nil?
+        texture = loader.load full_path
+      else
+        texture = Texture.new
+
+        loader = @image_loader
+        image = loader.load full_path
+
+        if !Math.power_of_two?(image.width) || !Math.power_of_two?(image.height)
+          # TODO: resize image to power of two
+        else
+          texture.image = image
+        end
+
+        texture.needs_update = true
+      end
+
+      texture.source_file = source_file
+
+      if repeat
+        texture.repeat.set(repeat[0], repeat[1])
+
+        texture.wrap_s = RepeatWrapping if repeat[0] != 1
+        texture.wrap_t = RepeatWrapping if repeat[1] != 1
+      end
+
+      if offset
+        texture.offset.set(offset[0], offset[1])
+      end
+
+      if wrap
+        wrap_map = {
+          repeat: RepeatWrapping,
+          mirror: MirroredRepeatWrapping
+        }
+
+        texture.wrap_s = wrap_map[wrap[0]] unless wrap_map[wrap[0]].nil?
+        texture.wrap_t = wrap_map[wrap[1]] unless wrap_map[wrap[1]].nil?
+      end
+
+      texture.anisotropy = anisotropy if anisotropy
+
+      where[name] = texture
+    end
+
+    def rgb2hex(rgb)
+      (rgb[0] * 255 << 16) + (rgb[1] * 255 << 8) + rgb[2] * 255
+    end
+  end
+end

data/lib/mittsu/loaders/loading_manager.rb

@@ -0,0 +1,17 @@
+module Mittsu
+  class LoadingManager
+    def initialize
+      @loaded, @total = 0, 0
+    end
+
+    def item_start(url)
+      @total += 1
+    end
+
+    def item_end(url)
+      @loaded += 1
+    end
+  end
+
+  DefaultLoadingManager = LoadingManager.new
+end

data/lib/mittsu/loaders/mtl_loader.rb

@@ -0,0 +1,242 @@
+module Mittsu
+  class MTLLoader
+    include EventDispatcher
+
+    def initialize(base_url, options = {}) # TODO: cross_origin?
+      @base_url = base_url
+      @options = options
+      # @cross_origin = cross_origin
+    end
+
+    def load(url)
+      loader = FileLoader.new
+      # loader.cross_origin = @cross_origin
+
+      text = loader.load File.join(@base_url, url)
+      parse(text)
+    end
+
+    def parse(text)
+      lines = text.split("\n")
+      info = {}
+      delimiter_pattern = /\s+/
+      materials_info = {}
+
+      lines.each do |line|
+  			line = line.strip
+
+  			next if line.empty? || line.start_with?('#')
+
+  			pos = line.index(' ')
+
+  			key = ( pos >= 0 ) ? line[0...pos] : line
+  			key = key.downcase
+
+  			value = ( pos >= 0 ) ? line[pos + 1..-1] : ""
+  			value = value.strip
+
+  			if key == "newmtl"
+  				# New material
+
+  				info = { name: value };
+  				materials_info[value] = info
+  			elsif info
+  				if key == "ka" || key == "kd" || key == "ks"
+  					ss = value.split(delimiter_pattern).take(3)
+  					info[key] = [ss[0].to_f, ss[1].to_f, ss[2].to_f]
+  				else
+  					info[key] = value
+  				end
+  			end
+      end
+
+      MaterialCreator.new(@base_url, @options).tap do |material_creator|
+        material_creator.set_materials(materials_info)
+      end
+    end
+
+    class MaterialCreator
+      def initialize(base_url, options = nil)
+        @base_url = base_url
+        @options = options
+        @material_info = {}
+        @materials = {}
+        @materials_array = []
+        @name_lookup = {}
+
+        @side = (@options || {}).fetch(:side, FrontSide)
+        @wrap = (@options || {}).fetch(:wrap, RepeatWrapping)
+      end
+
+      def set_materials(materials_info)
+        @materials_info = convert materials_info
+        @materials = {}
+        @materials_array = []
+        @name_lookup = {}
+      end
+
+      def convert(materials_info)
+        return materials_info if !@options
+
+        converted = {}
+
+        materials_info.each do |mn, mat|
+          covmat = {}
+          converted[mn] = covmat
+
+          mat.each do |prop, value|
+            save = true
+            lprop = prop.to_s.downcase
+
+            case lprop
+            when 'kd', 'ka', 'ks'
+              # Diffuse color, (color under white light) using RGB values
+
+              if @options && @options[:normalize_rgb]
+                value = [value[0] / 255.0, value[1] / 255.0, value[2] / 255.0]
+              end
+
+              if @options && @options[:ignore_zero_rgbs]
+                if value.take(3).any?(&:zero?)
+                  # ignore
+                  save = false
+                end
+              end
+            when 'd'
+  						# According to MTL format (http://paulbourke.net/dataformats/mtl/):
+  						#   d is dissolve for current material
+  						#   factor of 1.0 is fully opaque, a factor of 0 is fully dissolved (completely transparent)
+
+              if @options && @options[:invert_transparency]
+                value = 1.0 - value
+              end
+            end
+
+            covmat[lprop] = value if save
+          end
+        end
+
+        converted
+      end
+
+      def preload
+        @materials_info.each_key do |mn|
+          create mn
+        end
+      end
+
+      def get_index(material_name)
+        @name_lookup[material_name]
+      end
+
+      def get_as_array
+        @materials_info.keys.each_with_index do |mn, index|
+          @materials_array[index] = create mn
+          @name_lookup[mn] = index
+        end
+
+        @materials_array
+      end
+
+      def create(material_name)
+        if @materials[material_name].nil?
+          create_material(material_name)
+        end
+
+        @materials[material_name]
+      end
+
+      def load_texture(url, mapping = nil)
+        loader = Loader::Handlers.get(url)
+
+        if !loader.nil?
+          texture = loader.load url
+        else
+          texture = Texture.new
+
+          loader = ImageLoader.new
+          # loader.cross_origin = @cross_origin # TODO: ???
+          image = loader.load url
+
+          texture.image = ensure_power_of_two(image)
+          texture.needs_update = true
+        end
+
+        texture.mapping = mapping unless mapping.nil?
+
+        texture
+      end
+
+      private
+
+      def create_material(material_name)
+        mat = @materials_info[material_name]
+        params = {
+          name: material_name,
+          side: @side
+        }
+
+        mat.each do |prop, value|
+          case prop.downcase
+          when 'kd'
+            # Diffuse color (color under white light) using RGB values
+            params[:diffuse] = Color.new.from_array(value)
+          when 'ka'
+            # Ambient color (color under shadow) using RGB value
+          when 'ks'
+            # Specular color (color when light is reflected from shiny surface) using RGB values
+            params[:specular] = Color.new.from_array(value)
+          when 'map_kd'
+            # Diffuse texture map
+            params[:map] = load_texture File.join(@base_url, value)
+            params[:map].wrap_s = @wrap
+            params[:map].wrap_t = @wrap
+          when 'ns'
+            # The specular exponent (defines the focus of the specular highlight)
+            # A high exponent results in a tight, concentrated highlight. Ns values normally range from 0 to 1000.
+            params[:shininess] = value.to_f
+          when 'd'
+  					# According to MTL format (http://paulbourke.net/dataformats/mtl/):
+  					#   d is dissolve for current material
+  					#   factor of 1.0 is fully opaque, a factor of 0 is fully dissolved (completely transparent)
+
+            if value.to_f < 1
+              params[:transparent] = true
+              params[:opacity] = value.to_f
+            end
+          when 'map_bump', 'bump'
+            # Bump texture map
+            if !params[:bump_map]
+              params[:bump_map] = load_texture File.join(@base_url, value)
+              params[:bump_map].wrap_s = @wrap
+              params[:bump_map].wrap_t = @wrap
+            end
+          end
+        end
+
+        if params[:diffuse]
+          params[:color] = params[:diffuse]
+        end
+
+        @materials[material_name] = MeshPhongMaterial.new(params)
+      end
+
+      def ensure_power_of_two(image)
+        if !Math.power_of_two?(image.width) || !Math.power_of_two?(image.height)
+          # TODO: resize image ???
+        end
+        image
+      end
+
+      def next_highest_power_of_two(x)
+        x -= 1
+        i = 1
+        while i < 32
+          x = x | x >> i
+          i <<= 1
+        end
+        x + 1
+      end
+    end
+  end
+end