class Mittsu::Loader

Public Class Methods

new(show_status = false) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 3
def initialize(show_status = false)
  @image_loader = ImageLoader.new
end

Public Instance Methods

create_material(m, texture_path) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 20
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
init_materials(materials, texture_path) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 7
def init_materials(materials, texture_path)
  materials.map do |m|
    create_material(m, texture_path)
  end
end
needs_tangents(materials) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 13
def needs_tangents(materials)
  materials.each do |m|
    return true if m.is_a?(ShareMaterial)
  end
  false
end

Private Instance Methods

create_texture(where, name, source_file, repeat, offset, wrap, anisotropy) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 158
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
nearest_pow2(n) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 153
def nearest_pow2(n)
  l = ::Math.log(n) / Math::LN2
  ::Math.pow(2, ::Math.round(l))
end
rgb2hex(rgb) click to toggle source
# File lib/mittsu/loaders/loader.rb, line 208
def rgb2hex(rgb)
  (rgb[0] * 255 << 16) + (rgb[1] * 255 << 8) + rgb[2] * 255
end