lightwave 0.0.3

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006 Alex Young (alex@shaxam.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,46 @@
+= Read Me
+
+by Alex Young
+
+== Description
+
+A simple Lightwave object file reader.
+
+This library provides functions for reading Lightwave object files (.lwo), and
+converting them to either a Yaml (http://www.yaml.org) or Xaml (http://msdn.microsoft.com/windowsvista/about/) representation.
+
+Specifically, it generates a Xaml ResourceDictionary file with the following
+contents:
+
+ - A Model3DGroup for each Lightwave object layer.  Child layers are 
+   included as StaticResources which point to Model3DGroups.
+ - A GeometryModel3D tag within each Model3DGroup for each surface.  The 
+   Geometry attribute is a StaticResource that points to a MeshGeometry3D,
+   and the Material attribute is a StaticResource that points to a
+   MaterialGroup.[1]
+ - A Model3DGroup.Transform tag to shift the contained geometry to the 
+   pivot point of the Lightwave layer.  This allows child hierarchies to be 
+   transported from Lightwave through to Xaml.
+
+Currently only colour textures are supported, and it's an either/or situation:
+either you have a single image texture, or a single colour texture.  This is
+planned to change imminently.
+
+[1] Lightwave supports surfaces per polygon.  Xaml supports materialgroups
+    per GeometryModel3D.  Splitting the Lightwave geometry along surface
+    boundaries is the simplest way to emulate the former with the latter.
+
+== Documentation
+
+== Examples
+
+Simple:
+
+ $ ruby lw2xaml.rb MyLightwaveObject > MyLightwaveObject.xaml
+
+See the test/ directory of this project for more examples of code using the
+internals.
+
+== Questions and/or Comments
+
+Feel free to email {Alex Young}[mailto:alex@shaxam.com] with any questions.

data/Rakefile

@@ -0,0 +1,51 @@
+require "rake/rdoctask"
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = ['test/test_lightwave.rb']
+  test.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.include( "README",
+                           "TODO", "LICENSE", "lib/" )
+  rdoc.main     = "README"
+  rdoc.rdoc_dir = "doc/html"
+  rdoc.title    = "Lightwave Documentation"
+end
+
+spec = Gem::Specification.new do |spec|
+  spec.name     = "lightwave"
+  spec.version  = "0.0.3"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary  = "Lightwave is a package to read and manipulate Lightwave object files."
+  spec.files    = ["{lib,test}/**/*.rb", "test/**/*.lwo", "test/**/*.yaml"].collect{|s| Dir.glob(s)}.flatten + ["Rakefile"]
+
+  spec.test_suite_file  =  "test/test_lightwave.rb"
+  spec.has_rdoc         =  true
+  spec.extra_rdoc_files =  %w{README TODO LICENSE}
+  spec.rdoc_options     << '--title' << 'Lightwave Documentation' <<
+                           '--main'  << 'README'
+
+  spec.add_dependency("activesupport")
+
+  spec.require_path      = 'lib'
+  spec.autorequire       = "lightwave"
+  spec.author            = "Alex Young"
+  spec.email             = "alex@shaxam.com"
+  spec.homepage          = "http://www.shaxam.com"
+  spec.description       = <<END_DESC
+A set of libraries that handle reading Lightwave object files and (for the moment)
+turning them into a set of Xaml objects.
+END_DESC
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+

data/TODO

@@ -0,0 +1,15 @@
+The test coverage isn't as good as I'd like it, so anybody who thinks they've
+found a bug should send me a failing model with as complete a description of
+what *should* be happening as possible.
+
+The tests need to be factored out more.
+
+The code structure stinks at the moment, and needs to be simplified.  Don't
+assume that the module structure that you see will last for very long.
+
+SPEEDUPS:  There is currently a big bottleneck in the polygon reader, according
+to Ruby's profiler.  I'll look at converting various parts of the reader to C
+to speed things up.  There are also several places where the algorithms I'm
+using are almost certainly not the fastest, but without more runtime data (and
+more accurate profiling information than the built-in profiler gives me) it's
+not been worthwhile hammering them out.

data/lib/lightwave/lw2yaml.rb

@@ -0,0 +1,8 @@
+%w{matrices lightwave}.each do |f| 
+  require File.join(File.expand_path(File.dirname(__FILE__)), f)
+end
+require 'yaml'
+
+include Lightwave
+
+puts YAML::dump(LightwaveObject::read(File.read(ARGV[0]), ARGV[0]))

data/lib/lightwave.rb

@@ -0,0 +1,534 @@
+require 'stringio'
+require 'delegate'
+require 'rubygems'
+require 'active_support'
+
+DEBUG = false
+
+module Lightwave
+  class LightwaveStringIO < StringIO
+    def read_vector
+      read(12).unpack('g3')
+    end
+    def read_type
+      read(4)
+    end
+    def read_vx
+      # Reads a variable-length index.
+      marker_str = read(2, "  ")
+      #if !marker_str then raise "Null marker." end # These tests *seriously* slow things down
+      if marker_str[0] != 255
+        return marker_str.unpack('n')[0]
+      else
+        #if !low_byte then raise "Null low byte." end
+        return ("\0#{marker_str[1]}" + read(2, "  ")).unpack('N')[0]
+      end
+    end
+    def read_poly_set
+      spec = self.read(2).unpack('n')[0]
+      vert_count = spec & 0x03FF
+      flags = spec & 0xFC00
+      return Array.new(vert_count){self.read_vx}
+    end
+    def read_string
+      result = readline("\0")
+      if result.length % 2 == 1
+        read(1)
+      end
+      return result.strip
+    end
+    def read_string_list
+      # used in the TAGS block
+      result  = []
+      while !self.eof?
+        result << read_string
+      end
+      return result
+    end
+    def read_float
+      read(4).unpack('g')[0]
+    end
+    def read_u2
+      read(2).unpack('n')[0]
+    end
+    def read_u4
+      read(4).unpack('N')[0]
+    end
+    def read_chunk(size=4)
+      label = read_type
+      size_in = read(size)
+      if size_in.length != size
+        raise 'String was shorter than expected.'
+      end
+      size_str = (["\0"]*(4-size)).join + size_in
+      chunk_size = size_str.unpack('N')[0]
+      data = read(chunk_size)
+      if data.length % 2 == 1
+        read(1)
+      end
+      if data.length != chunk_size
+        raise 'Chunk was shorter than expected.  Size string was ' + size_in.inspect + ', expected ' + chunk_size.to_s + ', read ' + data.length.to_s
+      end
+      return [label, LightwaveStringIO.new(data), size_str]
+    end
+    def read_colour
+      result = [read_float, read_float, read_float]
+    end
+  end
+
+  class VCR
+    def initialize
+      @messages = []
+    end
+    def method_missing(method, *args, &block)
+      @messages << [method, args, block]
+    end
+    def play_back_to(obj)
+      @messages.each do |method, args, block|
+        obj.send(method, *args, &block)
+      end
+    end
+  end
+
+  module LightwaveObject
+    AXES=[:x,:y,:z]
+    PROJECTION_MODES = [:planar, :cylindrical, :spherical, :cubic, :front, :uv]
+    WRAP_TYPES = [:reset, :repeat, :mirror, :edge]
+
+
+    class ChunkError
+      attr_accessor :message
+      def initialize(msg)
+        @message = msg
+      end
+    end
+    class ChunkReader
+      attr_writer :errors
+      class_inheritable_hash :matched_chunks
+      class_inheritable_accessor :chunk_length
+      def self.chunk_map(sym, method=nil, &var)
+        if method and method.respond_to? :to_sym
+          pr = Proc.new{|s,c| s.send(method.to_sym, c) }
+          write_inheritable_hash(:matched_chunks, {sym => pr})
+        else
+          write_inheritable_hash(:matched_chunks, {sym => var})
+        end
+      end
+      def self.set_chunk_length(len)
+        write_inheritable_attribute(:chunk_length,len)
+      end
+
+      def process_tags(strio)
+        while !strio.eof?
+          label, chunk, length = strio.read_chunk(chunk_length || 2)
+          #p self.class.to_s + ' reading ' + label
+          #p "Contents: " + chunk.string
+          if matched_chunks and matched_chunks.has_key?(label) and matched_chunks[label].respond_to?(:call)
+            begin
+              matched_chunks[label].call(self, chunk)
+            rescue
+              error_message = "#{label} Tag reading broke, length was " + length.inspect + "\n" + chunk.string.inspect
+              errors << ChunkError.new(error_message)
+            end
+          else 
+            error_message = self.class.to_s + ' Unhandled chunk:' + label
+            errors << ChunkError.new(error_message)
+          end
+        end
+      end
+      def errors
+        @errors ||= []
+      end
+      def make_defaults
+      end
+      def initialize(strio)
+        process_tags(strio)
+        make_defaults
+      end
+    end
+
+    class SurfaceProperty
+      attr_accessor :intensity
+      def initialize(strio)
+        @intensity = strio.read_float
+      end
+    end
+
+    class Diffuse < SurfaceProperty; end
+    class Specular < SurfaceProperty; end
+    class Luminosity < SurfaceProperty; end
+    class Glossiness < SurfaceProperty; end
+
+    class Colour < SurfaceProperty
+      attr_accessor :rgb
+      def initialize(strio)
+        @rgb = strio.read_vector
+      end
+    end
+
+    class Opacity
+      attr_accessor :type
+      attr_accessor :opacity
+      TYPEMAP = [:normal,:subtractive,:difference,:multiply,:divide,:alpha,:texture_displacement,:additive]
+      def initialize(strio)
+        @type = TYPEMAP[strio.read_u2]
+        @opacity = strio.read_float
+      end
+    end
+
+    class TextureHeader < ChunkReader
+      attr_accessor :channel, :opacity, :enabled, :negative, :displacement_axis
+      alias :enabled? :enabled
+      chunk_map('CHAN'){|s,c| s.channel = c.read_type}
+      chunk_map('OPAC'){|s,c| s.opacity = Opacity.new(c)}
+      chunk_map('ENAB'){|s,c| s.enabled = c.read_u2 != 0}
+      chunk_map('NEGA'){|s,c| s.negative = c.read_u2 != 0}
+      chunk_map('AXIS'){|s,c| s.displacement_axis = AXES[c.read_u2]}
+      def make_defaults
+        if !@opacity
+          @opacity = Opacity.new
+          @opacity.type=:additive
+          @opacity.opacity = 1.0
+        end
+        if @enabled.nil? then @enabled = true end
+        if @negative.nil? then @negative = false end
+      end
+    end
+
+    class TextureFalloff
+      FALLOFF_TYPES = [:cubic, :spherical, :linear_x, :linear_y, :linear_z]
+      attr_accessor :type, :vector, :envelope
+      def initialize(strio)
+        @type, @vector  = FALLOFF_TYPES[strio.read_u2], strio.read_vector
+      end
+    end
+
+    class TextureMapping < ChunkReader
+      attr_accessor :center, :size, :rotation, :falloff, :object_name, :coordinate_system
+      COORDINATE_SYSTEMS = [:object, :world]
+      chunk_map('CNTR'){|s,c| s.center = c.read_vector}
+      chunk_map('SIZE'){|s,c| s.size = c.read_vector}
+      chunk_map('ROTA'){|s,c| s.rotation = c.read_vector}
+      chunk_map('FALL'){|s,c| s.falloff = TextureFalloff.new(c)}
+      chunk_map('OREF'){|s,c| s.object_name = c.read_string}
+      chunk_map('CSYS'){|s,c| s.coordinate_system = COORDINATE_SYSTEMS[c.read_u2]}
+    end
+
+    class TextureError
+      attr_accessor :message
+      def initialize(msg)
+        @message = msg
+      end
+    end
+
+    class TextureLayer < ChunkReader
+      # Bodgetastic.  Assumes that we're only ever an IMAP texture block.  Must change.
+      # The UV file has a NEGA as part of the header.  I don't think that can be right,
+      # according to the docs, but it does make sense in context.
+      attr_accessor :type , :ordinal , :header , :mapping, :projection_mode, :axis
+      attr_accessor :image_index, :width_wrap, :height_wrap
+      attr_accessor :width_repeat, :height_repeat
+      attr_accessor :vertex_map_name
+      attr_accessor :aa, :aa_strength
+      attr_accessor :pixel_blending
+      attr_accessor :sticky, :sticky_time
+      attr_accessor :amplitude
+
+      alias :aa? :aa
+      alias :pixel_blending? :pixel_blending
+      alias :sticky? :sticky
+
+
+      chunk_map('TMAP'){|s,c| s.mapping = TextureMapping.new(c)}
+      chunk_map('PROJ'){|s,c| s.projection_mode = PROJECTION_MODES[c.read_u2]}
+      chunk_map('AXIS'){|s,c| s.axis = AXES[c.read_u2]}
+      chunk_map('IMAG'){|s,c| s.image_index = c.read_u2}
+      chunk_map 'WRAP', :read_wraps
+      chunk_map('WRPW'){|s,c| s.width_repeat = c.read_float}
+      chunk_map('WRPH'){|s,c| s.height_repeat = c.read_float}
+      chunk_map('VMAP'){|s,c| s.vertex_map_name = c.read_string}
+      chunk_map 'AAST', :read_aa
+      chunk_map('PIXB'){|s,c| s.pixel_blending = (c.read_u2 % 2) == 1}
+      chunk_map 'STCK', :read_sticky
+      chunk_map('TAMP'){|s,c| s.amplitude = c.read_float}
+
+      def read_sticky(c)
+        self.sticky = c.read_u2 != 0
+        self.sticky_time = c.read_float
+      end
+      def read_wraps(c)
+        self.width_wrap, self.height_wrap = [c.read_u2, c.read_u2].collect{|i| WRAP_TYPES[i]}
+      end
+      def read_aa(c)
+        self.aa = c.read_u2 != 0
+        self.aa_strength = c.read_float
+      end
+      def initialize(strio)
+        @type, header_chunk = strio.read_chunk(2)
+        @errors = []
+        if @type != 'IMAP'
+          @errors << TextureError.new("#{@type} (non image-mapped) texture layer found.")
+        end
+        @ordinal = header_chunk.read_string
+
+        @header = TextureHeader.new(header_chunk)
+        super(strio)
+      end
+    end
+
+    class Surface < ChunkReader
+      attr_accessor :name # Matched up to polygons by this name
+      # and the index of this string in the
+      # Form#tags attribute.
+      attr_accessor :parent_name
+      attr_accessor :colour
+      attr_accessor :diffuse
+      attr_accessor :specular
+      attr_accessor :luminosity
+      attr_accessor :glossiness
+      attr_accessor :textures
+      attr_accessor :comment
+
+
+      chunk_map('COLR'){|s,c| s.colour = Colour.new(c)}
+      chunk_map('DIFF'){|s,c| s.diffuse = Diffuse.new(c)}
+      chunk_map('SPEC'){|s,c| s.specular = Specular.new(c)}
+      chunk_map('LUMI'){|s,c| s.luminosity = Luminosity.new(c)}
+      chunk_map('GLOS'){|s,c| s.glossiness = Glossiness.new(c)}
+      chunk_map('BLOK'){|s,c| s.textures << TextureLayer.new(c)}
+      chunk_map('CMNT'){|s,c| s.comment = c.read_string}
+      chunk_map('TRAN'){}
+      chunk_map('BUMP'){}
+      chunk_map('SMAN'){}
+
+
+
+      def initialize(strio)
+        @errors = []
+        @name = strio.read_string
+        @parent_name = strio.read_string
+        @textures = []
+        process_tags(strio)
+        @textures.each {|t| @errors += t.errors}
+      end
+    end
+
+    class Polygon < Array
+      attr_accessor :flags
+      attr_accessor :points
+      attr_accessor :surface_id
+      def new(poly_set, flags=nil)
+        @points = poly_set
+        @flags = flags
+      end
+    end
+
+    class Polygons
+      attr_accessor :faces
+      attr_accessor :curves
+      attr_accessor :patches
+      attr_accessor :metaballs
+      attr_accessor :bones
+      attr_accessor :latest
+      attr_accessor :surface_groups
+      def initialize
+        @surface_groups = Hash.new(){|h,k| h[k] = []}
+        @faces = []
+      end
+      def <<(strio)
+        label = strio.read_type
+        lookup = {'FACE' => @faces, 'PTCH' => @faces}
+        target = lookup[label]
+        points = []
+        while !strio.eof?
+          poly_set = strio.read_poly_set
+          points << Polygon.new(poly_set)
+        end
+        target.concat points
+        @latest = points # Need to keep this hanging around for the surface assignments
+      end
+    end
+
+    class GeomLayer
+      attr_accessor :number # an ID
+      attr_accessor :hidden # boolean
+      attr_accessor :pivot # Vector of the layer origin
+      attr_accessor :name # Label
+      attr_accessor :parent # Another layer number or nil.
+      attr_accessor :points
+      attr_accessor :max, :min # Bounding box points.
+      attr_accessor :polygons
+      attr_accessor :uvmaps
+      attr_accessor :morphs
+      attr_accessor :children #Not actually used here.  Used by the lw2xaml code.
+      def read_ptag(strio)
+        type = strio.read_type
+        while !strio.eof?
+          vertex_id = strio.read_vx
+          tag_id = strio.read_u2
+          @polygons.latest[vertex_id].surface_id = tag_id
+          @polygons.surface_groups[tag_id] << @polygons.latest[vertex_id]
+        end
+      end
+      def read_polygons(strio)
+        @polygons ||= Polygons.new
+        @polygons << strio
+      end
+      def read_bbox(strio)
+        @min = strio.read_vector
+        @max = strio.read_vector   
+      end
+      def read_points(strio)
+        @zero_offset = @points.length
+        while !strio.eof?
+          @points << strio.read_vector
+        end
+      end
+      def read_uvmap(strio)
+        @uvmaps ||= {}
+        dimension = strio.read_u2
+        name = strio.read_string
+        map = {}
+        while !strio.eof?
+          index = strio.read_vx
+          vector = []
+          dimension.times do vector << strio.read_float end
+          map[@zero_offset + index] = vector
+        end
+        @uvmaps[name] = map
+      end
+      def read_morph(strio)
+        @morphs ||= {}
+        dimension = strio.read_u2
+        name = strio.read_string
+        map = {}
+        while !strio.eof?
+          index = strio.read_vx
+          vector = []
+          dimension.times do vector << strio.read_float end
+          map[@zero_offset + index] = vector
+        end
+        @morphs[name] = map
+      end
+      def read_vmap(strio)
+        type = strio.read_type
+        case type
+        when 'TXUV'
+          read_uvmap(strio)
+        when 'MORF'
+          read_morph(strio)
+
+        end
+      end
+      def initialize(scene, strio)
+        strio.read(4) # discard number and flags for now
+        @pivot = strio.read_vector
+        @name = strio.read_string
+        @parent = strio.eof? ? nil : strio.read_u2
+        @points = []
+        @uvmaps = {}
+      end
+    end
+
+    class Clip < ChunkReader
+      attr_accessor :still
+      chunk_map('STIL'){|s,c| s.still = c.read_string}
+      chunk_map('FLAG'){}
+    end
+    class Scene  < ChunkReader
+      attr_accessor :filename
+      attr_accessor :type # Version
+      attr_accessor :tags # list of strings
+      attr_accessor :layers # list of layers
+      attr_accessor :surfaces
+      attr_accessor :icon
+      attr_accessor :current_layer
+      attr_accessor :clips
+      attr_accessor :text
+      attr_accessor :description
+      attr_accessor :min, :max
+      set_chunk_length 4
+
+      chunk_map('ICON'){|s,c| s.icon = c.read}
+      chunk_map('TEXT'){|s,c| s.text = c.read_string}
+      chunk_map('DESC'){|s,c| s.description = c.read_string}
+      chunk_map('TAGS'){|s,c| s.tags = c.read_string_list}
+      chunk_map 'LAYR', :read_layer 
+      chunk_map 'SURF', :read_surface
+      chunk_map 'PNTS', :read_points
+      chunk_map 'BBOX', :read_bbox
+      chunk_map 'POLS', :read_polygons
+      chunk_map 'PTAG', :read_ptag
+      chunk_map 'VMAP', :read_vmap
+      chunk_map 'CLIP', :read_clip
+      chunk_map('VMPA'){}
+
+      def method_missing(sym, *args, &block)
+        @current_layer.send(sym, *args, &block)
+      end
+      def init_lists 
+        @errors = []
+        @layers = []
+        @surfaces = {} 
+        @tags = []
+        @clips = {}
+      end
+      def initialize(string)
+        init_lists
+
+        ext_reader = LightwaveStringIO.new(string)
+        discard, reader = ext_reader.read_chunk
+        @type = reader.read_type
+
+        @current_layer = VCR.new 
+
+        super(reader)
+        read_scene_bbox
+      end
+      def read_scene_bbox
+        @min = @layers[0].min.dup
+        @max = @layers[0].max.dup
+        @layers.each do |layer|
+          (0..2).each do |i|
+            @min[i] = layer.min[i] < @min[i] ? layer.min[i] : @min[i]
+            @max[i] = layer.max[i] > @max[i] ? layer.max[i] : @max[i]
+          end
+        end
+      end
+      def read_clip(strio)
+        @clips[strio.read_u4] = Clip.new(strio)
+      end
+      def read_layer(strio)
+        new_layer = GeomLayer.new(self,strio)
+        if @current_layer.respond_to? :play_back_to
+          @current_layer.play_back_to new_layer
+        end
+        @layers << new_layer
+        @current_layer = new_layer
+      end
+      def read_surface(strio)
+        s = Surface.new(strio)
+        @surfaces[s.name] = s
+       # @errors += s.errors
+      end
+    end
+
+    def self.read_file(file, object_name = nil)
+      result = Scene.new(file)
+      result.filename = object_name 
+      return result
+    end
+    def self.read(filename, object_name = nil)
+      self.read_file(filename, object_name)
+    end
+  end
+  def scene_data(file, object_name)
+    LightwaveObject.read(file, object_name)
+  end
+end
+
+if __FILE__==$0
+  filename = ARGV[0]
+  scene = Lightwave::LightwaveObject::read(File.read(filename), filename)
+  puts "Done!"
+end

data/test/fixtures/yaml/test_triangles.yaml

@@ -0,0 +1,115 @@
+--- !ruby/object:Lightwave::LightwaveObject::Scene 
+clips: {}
+current_layer: &id003 !ruby/object:Lightwave::LightwaveObject::GeomLayer 
+  max: 
+    - -1.0
+    - 1.0
+    - 0.0
+  min: 
+    - -1.5
+    - 0.0
+    - 0.0
+  name: Small -X tri
+  parent: 0
+  pivot: 
+    - -1.0
+    - 0.0
+    - 0.0
+  points: 
+    - 
+      - -1.0
+      - 0.0
+      - 0.0
+    - 
+      - -1.5
+      - 1.0
+      - 0.0
+    - 
+      - -1.5
+      - 0.0
+      - 0.0
+  polygons: !ruby/object:Lightwave::LightwaveObject::Polygons 
+    faces: 
+      - &id001 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 0
+        - 1
+        - 2
+    latest: 
+      - *id001
+    surface_groups: 
+      0: 
+        - *id001
+      1: 
+        - *id001
+  uvmaps: {}
+  zero_offset: 0
+filename: triangles.lwo
+layers: 
+  - !ruby/object:Lightwave::LightwaveObject::GeomLayer 
+    max: 
+      - 1.5
+      - 2.0
+      - 0.0
+    min: 
+      - 0.5
+      - 0.0
+      - 0.0
+    name: Large +X tri
+    parent: 
+    pivot: 
+      - 0.5
+      - 0.0
+      - 0.0
+    points: 
+      - 
+        - 0.5
+        - 0.0
+        - 0.0
+      - 
+        - 0.5
+        - 2.0
+        - 0.0
+      - 
+        - 1.5
+        - 0.0
+        - 0.0
+    polygons: !ruby/object:Lightwave::LightwaveObject::Polygons 
+      faces: 
+        - &id002 !ruby/array:Lightwave::LightwaveObject::Polygon 
+          - 0
+          - 1
+          - 2
+      latest: 
+        - *id002
+      surface_groups: 
+        0: 
+          - *id002
+        1: 
+          - *id002
+    uvmaps: {}
+    zero_offset: 0
+  - *id003
+max:
+  - 1.5
+  - 2.0
+  - 0.0
+min:
+  - -1.5
+  - 0.0
+  - 0.0
+surfaces: 
+  Default: !ruby/object:Lightwave::LightwaveObject::Surface 
+    colour: !ruby/object:Lightwave::LightwaveObject::Colour 
+      rgb: 
+        - 0.7843137383461
+        - 0.7843137383461
+        - 0.7843137383461
+    diffuse: !ruby/object:Lightwave::LightwaveObject::Diffuse 
+      intensity: 1.0
+    name: Default
+    parent_name: ''
+    textures: []
+tags: 
+  - DkBlu
+  - Default
+type: LWO2

data/test/fixtures/yaml/uvmap.yaml

@@ -0,0 +1,201 @@
+--- !ruby/object:Lightwave::LightwaveObject::Scene 
+clips: 
+  1: !ruby/object:Lightwave::LightwaveObject::Clip 
+    still: Images/testbars.iff
+filename: uvmap.lwo
+current_layer: &id007 !ruby/object:Lightwave::LightwaveObject::GeomLayer 
+  max: 
+    - 0.5
+    - 0.5
+    - 0.5
+  min: 
+    - -0.5
+    - -0.5
+    - -0.5
+  name: ''
+  parent: 
+  pivot: 
+    - 0.0
+    - 0.0
+    - 0.0
+  points: 
+    - 
+      - -0.5
+      - -0.5
+      - -0.5
+    - 
+      - 0.5
+      - -0.5
+      - -0.5
+    - 
+      - 0.5
+      - -0.5
+      - 0.5
+    - 
+      - -0.5
+      - -0.5
+      - 0.5
+    - 
+      - -0.5
+      - 0.5
+      - -0.5
+    - 
+      - 0.5
+      - 0.5
+      - -0.5
+    - 
+      - 0.5
+      - 0.5
+      - 0.5
+    - 
+      - -0.5
+      - 0.5
+      - 0.5
+  polygons: !ruby/object:Lightwave::LightwaveObject::Polygons 
+    faces: 
+      - &id001 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 0
+        - 1
+        - 2
+        - 3
+      - &id002 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 0
+        - 4
+        - 5
+        - 1
+      - &id003 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 1
+        - 5
+        - 6
+        - 2
+      - &id004 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 3
+        - 2
+        - 6
+        - 7
+      - &id005 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 0
+        - 3
+        - 7
+        - 4
+      - &id006 !ruby/array:Lightwave::LightwaveObject::Polygon 
+        - 4
+        - 7
+        - 6
+        - 5
+    latest: 
+      - *id001
+      - *id002
+      - *id003
+      - *id004
+      - *id005
+      - *id006
+    surface_groups: 
+      0: 
+        - *id001
+        - *id002
+        - *id003
+        - *id005
+        - *id006
+      1: 
+        - *id004
+  uvmaps: 
+    UV Texture: 
+      6: 
+        - 0.0
+        - 1.0
+      7: 
+        - 1.0
+        - 1.0
+      2: 
+        - 0.5
+        - 0.0
+      3: 
+        - 1.0
+        - 0.0
+  zero_offset: 0
+layers: 
+  - *id007
+max: 
+  - 0.5
+  - 0.5
+  - 0.5
+min: 
+  - -0.5
+  - -0.5
+  - -0.5
+surfaces: 
+  UVExample: !ruby/object:Lightwave::LightwaveObject::Surface 
+    colour: !ruby/object:Lightwave::LightwaveObject::Colour 
+      rgb: 
+        - 0.7843137383461
+        - 0.7843137383461
+        - 0.7843137383461
+    diffuse: !ruby/object:Lightwave::LightwaveObject::Diffuse 
+      intensity: 1.0
+    name: UVExample
+    parent_name: ''
+    specular: !ruby/object:Lightwave::LightwaveObject::Specular 
+      intensity: 0.0
+    textures: 
+      - !ruby/object:Lightwave::LightwaveObject::TextureLayer 
+        aa: true
+        aa_strength: 1.0
+        amplitude: 1.0
+        axis: :z
+        header: !ruby/object:Lightwave::LightwaveObject::TextureHeader 
+          channel: COLR
+          displacement_axis: :y
+          enabled: true
+          negative: false
+          opacity: !ruby/object:Lightwave::LightwaveObject::Opacity 
+            opacity: 1.0
+            type: :normal
+        height_repeat: 1.0
+        height_wrap: :repeat
+        image_index: 1
+        mapping: !ruby/object:Lightwave::LightwaveObject::TextureMapping 
+          center: 
+            - 0.0
+            - 0.0
+            - 0.0
+          coordinate_system: :object
+          falloff: !ruby/object:Lightwave::LightwaveObject::TextureFalloff 
+            type: :cubic
+            vector: 
+              - 0.0
+              - 0.0
+              - 0.0
+          object_name: "(none)"
+          rotation: 
+            - 0.0
+            - 0.0
+            - 0.0
+          size: 
+            - 1.0
+            - 1.0
+            - 1.0
+        ordinal: "�"
+        pixel_blending: true
+        projection_mode: :uv
+        sticky: false
+        sticky_time: 0.0
+        type: IMAP
+        vertex_map_name: UV Texture
+        width_repeat: 1.0
+        width_wrap: :repeat
+  Default: !ruby/object:Lightwave::LightwaveObject::Surface 
+    colour: !ruby/object:Lightwave::LightwaveObject::Colour 
+      rgb: 
+        - 0.7843137383461
+        - 0.7843137383461
+        - 0.7843137383461
+    diffuse: !ruby/object:Lightwave::LightwaveObject::Diffuse 
+      intensity: 1.0
+    name: Default
+    parent_name: ''
+    textures: []
+tags: 
+  - Default
+  - UVExample
+type: LWO2

data/test/test_lightwave.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby -w
+#
+require 'test/unit'
+file = File.expand_path(File.join(File.dirname(__FILE__), '..','lib','lightwave'))
+require file
+
+fixtures_base = File.join(File.dirname(File.expand_path(__FILE__)), 'fixtures')
+
+LWO_DIR  = File.join(fixtures_base, 'lwo')
+YAML_DIR = File.join(fixtures_base, 'yaml')
+def read_file(dir, filename)
+  File.open(File.join(dir,filename), 'rb'){|f|
+    f.read
+  }
+end
+def lwo_file(filename)
+  read_file(LWO_DIR,filename)
+end
+
+def yaml_file(filename)
+  read_file(YAML_DIR, filename)
+end
+
+module TestHelperFuncs
+  def get_scene_data(filename)
+    case filename
+    when /\.lwo\Z/
+      file = lwo_file(filename)
+      Lightwave::LightwaveObject.read(file, filename)
+    when /\.yaml\Z/
+      YAML::load(yaml_file(filename))
+    end
+  end
+end
+
+class LightwaveStringIOTest < Test::Unit::TestCase
+  def lwstrio(string)
+    Lightwave::LightwaveStringIO.new(string)
+  end
+  def pair_equal(a,bstring,method)
+    assert_equal a, lwstrio(bstring).send(method)
+  end
+  def test_basic_read_methods
+    [ [1, "\000\001", :read_u2],
+      [1, "\000\000\000\001", :read_u4],
+      [1.0, "?\200\000\000", :read_float],
+      [[1.0, 1.0, 1.0], "?\200\000\000" * 3, :read_vector],
+      ["foo", "foo\000", :read_string],
+      ["foo", "foo\000\000", :read_string] ].each do |a, bstring, method|
+      pair_equal(a, bstring, method)
+    end
+  end
+end
+
+class VCRTest < Test::Unit::TestCase
+  def test_vcr
+    my_vcr = Lightwave::VCR.new
+    my_vcr.concat('foo')
+    my_vcr.gsub!(/o/, 'e')
+    a = ''
+    my_vcr.play_back_to(a)
+    assert_equal 'fee', a
+  end
+end
+
+class BBoxTest < Test::Unit::TestCase
+  include TestHelperFuncs
+  def setup
+    @cube_scene = self.get_scene_data('parented_cubes.lwo')
+    @triangles_scene = self.get_scene_data('test_triangles.yaml')
+  end
+  def test_layers_bbox
+    assert_equal [-0.5, -0.5, -0.5], @cube_scene.layers[0].min
+    assert_equal [ 0.5,  0.5,  0.5], @cube_scene.layers[0].max
+    assert_equal [ 0.5, -0.5, -0.5], @cube_scene.layers[1].min
+    assert_equal [ 1.5,  0.5,  0.5], @cube_scene.layers[1].max
+  end
+  def test_scene_bbox
+    assert_equal [-0.5, -0.5, -0.5], @cube_scene.min
+    assert_equal [ 1.5,  0.5,  0.5], @cube_scene.max
+  end
+  def test_tri_layers_bbox
+    assert_equal [ 0.5,  0.0,  0.0], @triangles_scene.layers[0].min
+    assert_equal [ 1.5,  2.0,  0.0], @triangles_scene.layers[0].max
+    assert_equal [-1.5,  0.0,  0.0], @triangles_scene.layers[1].min
+    assert_equal [-1.0,  1.0,  0.0], @triangles_scene.layers[1].max
+  end
+  def test_tri_scene_bbox
+    assert_equal [-1.5,  0.0,  0.0], @triangles_scene.min
+    assert_equal [ 1.5,  2.0,  0.0], @triangles_scene.max
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: lightwave
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+date: 2006-06-13 00:00:00 +01:00
+summary: Lightwave is a package to read and manipulate Lightwave object files.
+require_paths: 
+- lib
+email: alex@shaxam.com
+homepage: http://www.shaxam.com
+rubyforge_project: 
+description: A set of libraries that handle reading Lightwave object files and (for the moment) turning them into a set of Xaml objects.
+autorequire: lightwave
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Alex Young
+files: 
+- lib/lightwave.rb
+- lib/lightwave/lw2yaml.rb
+- test/test_lightwave.rb
+- test/fixtures/lwo/parented_cubes.lwo
+- test/fixtures/yaml/uvmap.yaml
+- test/fixtures/yaml/test_triangles.yaml
+- Rakefile
+- README
+- TODO
+- LICENSE
+test_files: 
+- test/test_lightwave.rb
+rdoc_options: 
+- --title
+- Lightwave Documentation
+- --main
+- README
+extra_rdoc_files: 
+- README
+- TODO
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: