pgtools 1.0.0 → 1.0.1

data/lib/bayonetta/exp.rb

@@ -1,768 +1,768 @@
-module Bayonetta
-
-  module ExpQuantizedValues
-    def get_p(i)
-      @p + @keys[i].cp * @dp
-    end
-
-    def get_m1(i)
-      @m1 + @keys[i].cm1 * @dm1
-    end
-
-    def get_m0(i)
-      @m0 + @keys[i].cm0 * @dm0
-    end
-  end
-
-  module ExpDirectValues
-    def get_p(i)
-      @keys[i].p
-    end
-
-    def get_m1(i)
-      @keys[i].m1
-    end
-
-    def get_m0(i)
-      @keys[i].m0
-    end
-  end
-
-  module ExpAbsolutePositions
-    def key_positions
-      @key_positions ||= @keys.collect { |k| k.v }
-    end
-  end
-
-  module ExpRelativePositions
-    def key_positions
-      @key_positions ||= begin
-        sum = 0
-        @keys.collect { |k| sum += k.v }
-      end
-    end
-  end
-
-  module ExpKeyInterpolate
-    def interpol(position, start, stop, key_index)
-      p_0 = get_p(key_index)
-      p_1 = get_p(key_index + 1)
-      m_0 = get_m1(key_index)
-      m_1 = get_m0(key_index + 1)
-      t = (value - start).to_f / (stop - start)
-      t3 = t*t*t
-      t2 = t*t
-      (2 * t3 - 3 * t2 + 1)*p_0 + (t3 - 2 * t2 + t)*m_0 + (-2 * t3 + 3 * t2)*p_1 + (t3 - t2)*m_1
-    end
-
-    def interpolate(position)
-      if positions <= key_positions.first
-        get_p(0)
-      elsif positions >= key_positions.last
-        get_p(key_positions.length -1)
-      else
-        key_positions.each_cons(2).each_with_index { |(start, stop), i|
-          if position <= stop && position >= start
-            return interpol(position, start, stop)
-          end
-        }
-      end
-    end
-  end
-
-  class EXPFile2 < LibBin::Structure
-
-    class EXPFileHeader < LibBin::Structure
-      int8 :id, count: 4
-      int32 :version
-      uint32 :offset_records
-      uint32 :num_records
-      uint32 :offset_interpolations
-      uint32 :num_interpolations
-
-      def initialize
-        @id = "exp\0".b
-        @version = 0x20110714
-        @offset_records = 0
-        @num_records = 0
-        @offset_interpolations = 0
-        @num_interpolations = 0
-      end
-    end
-
-    class Record < LibBin::Structure
-      int16 :bone_index
-      int8 :animation_track
-      int8 :padding
-      int16 :num_operations
-      int16 :unknown
-      uint32 :offset
-
-      def initialize
-        @bone_index = 0
-        @animation_track = 0
-        @padding = 0
-        @num_operations = 0
-        @unknown = 0
-        @offset = 0
-      end
-
-    end
-
-    class Operation < LibBin::Structure
-      int8 :type
-      int8 :info
-      int16 :number
-      float :value
-
-      def initialize
-        @type = 0
-        @info = 0
-        @number = 0
-        @value = 0.0
-      end
-
-    end
-
-    class Entry < LibBin::Structure
-      register_field :operations, Operation, count: '..\records[__index]\num_operations'
-
-      def initialize
-        @operations = []
-      end
-
-      def abs(v)
-        v.abs
-      end
-
-      def get_value(tracks, table, interpolation_entries)
-        s = ""
-        @operations.each { |o|
-          case o.type
-          when 0
-            nil
-          when 1
-            s << "("
-          when 2
-            s << ")"
-          when 3
-            s << "tracks[table[#{o.number}]][#{o.info}]"
-          when 4
-            s << "#{o.value}"
-          when 5
-            case o.number
-            when 0
-              s << " + "
-            when 2
-              s << " * "
-            else
-              raise "Unknown arithmetic operation: #{o.number}!"
-            end
-          when 6
-            raise "Unknown function argument number: #{o.info}!" if o.info != 1
-            case o.number
-            when 1
-              s << "abs("
-            else
-              raise "Unknown function: #{o.number}!"
-            end
-          when 7
-            s << ")"
-          when 8
-            s << "interpolation_entries[#{o.number}].get_value("
-          else
-            raise "Unknown operation: #{o.type}!"
-          end
-        }
-        eval s
-      end
-
-    end
-
-    class Interpolation < LibBin::Structure
-      int16 :num_points
-      int16 :padding
-      uint32 :offset
-
-      def initialize
-        @num_points = 0
-        @padding = 0
-        @offset = 0
-      end
-
-    end
-
-    class Point < LibBin::Structure
-      float :v
-      float :p
-      float :m0
-      float :m1
-
-      def initialize
-        @v = 0.0
-        @p = 0.0
-        @m0 = 0.0
-        @m1 = 0.0
-      end
-
-    end
-
-    class InterpolationEntry < LibBin::Structure
-      register_field :points, Point, count: '..\interpolations[__index]\num_points'
-
-      def get_value(val)
-        @points.each_cons(2) { |left, right|
-          if left.v <= val && right.v >= val
-            p0 = left.p
-            p1 = right.p
-            m0 = left.m1
-            m1 = right.m0
-            t = (val - left.v).to_f / (right.v - left.v)
-            return (2 * t*t*t - 3 * t*t + 1)*p0 + (t*t*t - 2 * t*t + t)*m0 + (-2 * t*t*t + 3 * t*t)*p1 + (t*t*t - t * t)*m1
-          end
-
-        }
-        return 0.0
-      end
-
-    end
-
-    register_field :header, EXPFileHeader
-    register_field :records, Record, count: 'header\num_records', offset: 'header\offset_records'
-    register_field :entries, Entry, count: 'header\num_records', sequence: true,
-      offset: 'records[__iterator]\offset + header\offset_records + 12*__iterator'
-    register_field :interpolations, Interpolation, count: 'header\num_interpolations', offset: 'header\offset_interpolations'
-    register_field :interpolation_entries, InterpolationEntry, count: 'header\num_interpolations', sequence: true,
-      offset: 'interpolations[__iterator]\offset + header\offset_interpolations + 8*__iterator'
-
-    def apply(tracks, table)
-      rad_to_deg = 180.0 / Math::PI
-      deg_to_rad = Math::PI / 180.0
-      tracks.each { |tr|
-        tr[0] *= 10.0
-        tr[1] *= 10.0
-        tr[2] *= 10.0
-        tr[3] *= rad_to_deg
-        tr[4] *= rad_to_deg
-        tr[5] *= rad_to_deg
-      }
-      @records.each_with_index { |r, i|
-        bone_index = table[r.bone_index]
-        next unless bone_index
-        animation_track = r.animation_track
-        if @entries[i]
-          value = @entries[i].get_value(tracks, table, interpolation_entries)
-        end
-        tracks[bone_index][animation_track] = value
-      }
-      tracks.each { |tr|
-        tr[0] *= 0.1
-        tr[1] *= 0.1
-        tr[2] *= 0.1
-        tr[3] *= deg_to_rad
-        tr[4] *= deg_to_rad
-        tr[5] *= deg_to_rad
-      }
-    end
-
-    def recompute_layout
-      self
-    end
-
-    def was_big?
-      @__was_big
-    end
-
-    def dump(output_name, output_big = false)
-      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
-        output = output_name
-      else
-        output = File.open(output_name, "wb")
-      end
-      output.rewind
-
-      __set_dump_state(output, output_big, nil, nil)
-      __dump_fields
-      __unset_dump_state
-      output.close unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
-      self
-    end
-
-  end
-
-  class EXPFile < LibBin::Structure
-
-    class EXPFileHeader < LibBin::Structure
-      int8 :id, count: 4
-      int32 :version
-      uint32 :offset_records
-      uint32 :num_records
-
-      def initialize
-        @id = "exp\0".b
-        @version = 0
-        @offset_records = 0
-        @num_records = 0
-      end
-
-    end
-
-    class Record < LibBin::Structure
-      int16 :u_a
-      int16 :bone_index
-      int8 :animation_track
-      int8 :entry_type
-      int8 :u_b
-      int8 :interpolation_type
-      int16 :num_points
-      int16 :u_c
-      uint32 :offset
-      uint32 :offset_interpolation
-
-      def initialize
-        @u_a = 0
-        @bone_index = 0
-        @animation_track = 0
-        @entry_type = 0
-        @u_b = 0
-        @interpolation_type = 0
-        @num_points = 0
-        @offset = 0
-        @offset_interpolation = 0
-      end
-
-    end
-
-    class Operation < LibBin::Structure
-      uint32 :flags
-      float :value
-
-      def initialize
-        @flags = 0
-        @value = 0.0
-      end
-
-      def transform_value( v )
-        if @flags == 0x4
-          v *= @value
-        elsif @flags == 0x20004
-          v = v.abs * @value
-        elsif @flags == 0x1
-          v += @value
-        else
-          raise "Unknown operation #{ "%x" % @flags }, please report!"
-        end
-        v
-      end
-
-    end
-
-    class Entry1 < LibBin::Structure
-      uint32 :flags
-      int16 :bone_index
-      int8 :animation_track
-      int8 :padding
-
-      def initialize
-        @flags = 0x80000001
-        @bone_index = 0
-        @animation_track = 0
-        @padding = 0
-      end
-
-      def get_value(pose, table)
-        pose[table[@bone_index]][@animation_track]
-      end
-
-    end
-
-    class Entry2 < LibBin::Structure
-      uint32 :flags
-      int16 :bone_index
-      int8 :animation_track
-      int8 :padding
-      register_field :operation, Operation
-
-      def initialize
-        @flags = 0x80000001
-        @bone_index = 0
-        @animation_track = 0
-        @padding = 0
-        @operation = Operation::new
-      end
-
-      def get_value(pose, table)
-        @operation.transform_value( pose[table[@bone_index]][@animation_track] )
-      end
-
-    end
-
-    class Entry3 < LibBin::Structure
-      uint32 :flags
-      int16 :bone_index
-      int8 :animation_track
-      int8 :padding
-      register_field :operations, Operation, count: 2
-
-      def initialize
-        @flags = 0x80000001
-        @bone_index = 0
-        @animation_track = 0
-        @padding = 0
-        @operations = [Operation::new, Operation::new]
-      end
-
-      def get_value(pose, table)
-        v = @operations[0].transform_value( pose[table[@bone_index]][@animation_track] )
-        v = @operations[1].transform_value( v )
-      end
-
-    end
-
-    class Entry < LibBin::Structure
-
-      def self.convert(input, output, input_big, output_big, parent, index, length = nil)
-        entry_type = parent.records[index].entry_type
-        entry = nil
-        case entry_type
-        when 1
-          entry = Entry1::convert(input, output, input_big, output_big, parent, index, length)
-        when 2
-          entry = Entry2::convert(input, output, input_big, output_big, parent, index, length)
-        when 3
-          entry = Entry3::convert(input, output, input_big, output_big, parent, index, length)
-        end
-        entry
-      end
-
-      def self.load(input, input_big, parent, index, length = nil)
-        entry_type = parent.records[index].entry_type
-        entry = nil
-        case entry_type
-        when 1
-          entry = Entry1::load(input, input_big, parent, index, length)
-        when 2
-          entry = Entry2::load(input, input_big, parent, index, length)
-        when 3
-          entry = Entry3::load(input, input_big, parent, index, length)
-        end
-        entry
-      end
-
-    end
-
-    class Key2 < LibBin::Structure
-      float :v
-      float :p
-      float :m0
-      float :m1
-
-      def initialize
-        @v = 0.0
-        @p = 0.0
-        @m0 = 0.0
-        @m1 = 0.0
-      end
-
-      def size
-        3 * 4
-      end
-    end
-
-    class Interpolation2 < LibBin::Structure
-      include ExpDirectValues
-      include ExpAbsolutePositions
-      include ExpKeyInterpolate
-      register_field :keys, Key2, count: '..\records[__index]\num_points'
-
-      def size
-        @keys.collect(&:size).reduce(:+)
-      end
-    end
-
-    class Key4 < LibBin::Structure
-      float :v
-      uint16 :dummy
-      uint16 :cp
-      uint16 :cm0
-      uint16 :cm1
-
-      def initialize
-        @v = 0.0
-        @dummy = 0
-        @cp = 0
-        @cm0 = 0
-        @cm1 = 0
-      end
-
-      def size
-        3 * 4
-      end
-    end
-
-    class Interpolation4 < LibBin::Structure
-      include ExpQuantizedValues
-      include ExpAbsolutePositions
-      include ExpKeyInterpolate
-      float :p
-      float :dp
-      float :m0
-      float :dm0
-      float :m1
-      float :dm1
-      register_field :keys, Key4, count: '..\records[__index]\num_points'
-
-      def size
-        4 * 6 + @keys.collect(&:size).reduce(:+)
-      end
-    end
-
-    class Key6 < LibBin::Structure
-      uint8 :v
-      uint8 :cp
-      uint8 :cm0
-      uint8 :cm1
-
-      def initialize
-        @v = 0
-        @cp = 0
-        @cm0 = 0
-        @cm1 = 0
-      end
-
-      def size
-        4
-      end
-    end
-
-    class Interpolation6 < LibBin::Structure
-      include ExpQuantizedValues
-      include ExpRelativePositions
-      include ExpKeyInterpolate
-      pghalf :p
-      pghalf :dp
-      pghalf :m0
-      pghalf :dm0
-      pghalf :m1
-      pghalf :dm1
-      register_field :keys, Key6, count: '..\records[__index]\num_points'
-
-      def size
-        2 * 6 + @keys.collect(&:size).reduce(:+)
-      end
-    end
-
-    class Interpolation < LibBin::Structure
-
-      def self.convert(input, output, input_big, output_big, parent, index, length = nil)
-        case parent.records[index].interpolation_type
-        when 2
-          Interpolation2::convert(input, output, input_big, output_big, parent, index, length)
-        when 4
-          Interpolation4::convert(input, output, input_big, output_big, parent, index, length)
-        when 6
-          Interpolation6::convert(input, output, input_big, output_big, parent, index, length)
-        when -1
-          nil
-        else
-          raise "Unknown Interpolation type: #{interpolation_type}, please report!"
-        end
-      end
-
-      def self.load(input, input_big, parent, index, length = nil)
-        case parent.records[index].interpolation_type
-        when 2
-          Interpolation2::load(input, input_big, parent, index, length)
-        when 4
-          Interpolation4::load(input, input_big, parent, index, length)
-        when 6
-          Interpolation6::load(input, input_big, parent, index, length)
-        when -1
-          nil
-        else
-          raise "Unknown Interpolation type: #{interpolation_type}, please report!"
-        end
-      end
-
-    end
-
-    register_field :header, EXPFileHeader
-    register_field :records, Record, count: 'header\num_records', offset: 'header\offset_records'
-    register_field :entries, Entry, count: 'header\num_records', sequence: true,
-      offset: 'records[__iterator]\offset'
-    register_field :interpolations, Interpolation, count: 'header\num_records', sequence: true,
-      offset: 'records[__iterator]\offset_interpolation'
-
-    def was_big?
-      @__was_big
-    end
-
-    def apply(tracks, table)
-      rad_to_deg = 180.0 / Math::PI
-      deg_to_rad = Math::PI / 180.0
-      tracks.each { |tr|
-        tr[3] *= rad_to_deg
-        tr[4] *= rad_to_deg
-        tr[5] *= rad_to_deg
-      }
-      @records.each_with_index { |r, i|
-        bone_index = table[r.bone_index]
-        next unless bone_index
-        animation_track = r.animation_track
-        if @entries[i]
-          value = @entries[i].get_value(tracks, table)
-        end
-        if @interpolations[i]
-          value = @interpolations[i].interpolate(value)
-        end
-        tracks[bone_index][animation_track] = value
-      }
-      tracks.each { |tr|
-        tr[3] *= deg_to_rad
-        tr[4] *= deg_to_rad
-        tr[5] *= deg_to_rad
-      }
-    end
-
-    def add_entries(hash)
-      hash.each { |k, v|
-        raise "Invalid entry type #{k}!" if k>3 || k<1
-        v.times {
-          r = Record::new
-          r.entry_type = k
-          r.u_c = -1
-          @records.insert(-2, r)
-          case k
-          when 1
-            entry = Entry1::new
-          when 2
-            entry = Entry2::new
-          when 3
-            entry = Entry3::new
-          end
-          @entries.insert(-2, entry)
-        }
-      }
-      self
-    end
-
-    def recompute_layout
-      @header.num_records = @records.length
-      last_offset = @header.offset_records
-      last_offset += @records.collect(&:__size).reduce(:+)
-
-      table = @records.zip(@entries).to_h
-      reverse_table = table.invert
-      interpolation_table = @records.zip(@interpolations).to_h
-      reverse_interpolation_table = interpolation_table.invert
-
-      @records.sort_by! { |r| [r.bone_index, r.animation_track] }
-      @entries.sort_by! { |e| e ? [e.bone_index, e.animation_track] : [32767, -1] }
-      
-      @entries.each { |e|
-        if e
-          reverse_table[e].offset = last_offset
-          last_offset += e.__size
-        else
-          reverse_table[e].offset = 0
-        end
-      }
-      @interpolations.each { |i|
-        if i
-          reverse_interpolation_table[i].offset_interpolation = last_offset
-          last_offset += i.size
-        end
-      }
-
-      @entries = @records.collect { |r| table[r] }
-      @interpolation = @records.collect { |r| interpolation_table[r] }
-      self
-    end
-
-    def self.is_big?(f)
-      f.rewind
-      block = lambda { |int|
-        id = f.read(4)
-        raise "Invalid id #{id.inspect}!" if id != "exp\0".b
-        u_a = f.read(4).unpack(int).first
-        offset_record = f.read(4).unpack(int).first
-        num_record = f.read(4).unpack(int).first
-
-        num_record >= 0 && offset_record > 0 && offset_record < f.size
-      }
-      big = block.call("l>")
-      f.rewind
-      small = block.call("l<")
-      f.rewind
-      raise "Invalid data!" unless big ^ small
-      return big
-    end
-
-    def self.is_bayo2?(f, big)
-      f.rewind
-      id = f.read(4)
-      uint = "L<"
-      uint = "L>" if big
-      version = f.read(4).unpack(uint).first
-      f.rewind
-      return version == 0x20110714
-    end
-
-    def self.convert(input_name, output_name, input_big = true, output_big = false)
-      input = File.open(input_name, "rb")
-      id = input.read(4).unpack("a4").first
-      raise "Invalid file type #{id}!" unless id == "exp\0".b
-      output = File.open(output_name, "wb")
-      output.write("\x00"*input.size)
-      input.seek(0);
-      output.seek(0);
-
-      if is_bayo2?(input, input_big)
-        exp = EXPFile2::new
-      else
-        exp = self::new
-      end
-      exp.__convert(input, output, input_big, output_big)
-
-      input.close
-      output.close
-    end
-
-    def self.load(input_name)
-      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
-        input = input_name
-      else
-        input = File.open(input_name, "rb")
-      end
-      input_big = is_big?(input)
-
-      if is_bayo2?(input, input_big)
-        exp = EXPFile2::new
-      else
-        exp = self::new
-      end
-      exp.instance_variable_set(:@__was_big, input_big)
-      exp.__load(input, input_big)
-      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
-
-      exp
-    end
-
-    def dump(output_name, output_big = false)
-      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
-        output = output_name
-      else
-        output = File.open(output_name, "wb")
-      end
-      output.rewind
-
-      __set_dump_state(output, output_big, nil, nil)
-      __dump_fields
-      __unset_dump_state
-      output.close unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
-      self
-    end
-
-  end
-
-end
+module Bayonetta
+
+  module ExpQuantizedValues
+    def get_p(i)
+      @p + @keys[i].cp * @dp
+    end
+
+    def get_m1(i)
+      @m1 + @keys[i].cm1 * @dm1
+    end
+
+    def get_m0(i)
+      @m0 + @keys[i].cm0 * @dm0
+    end
+  end
+
+  module ExpDirectValues
+    def get_p(i)
+      @keys[i].p
+    end
+
+    def get_m1(i)
+      @keys[i].m1
+    end
+
+    def get_m0(i)
+      @keys[i].m0
+    end
+  end
+
+  module ExpAbsolutePositions
+    def key_positions
+      @key_positions ||= @keys.collect { |k| k.v }
+    end
+  end
+
+  module ExpRelativePositions
+    def key_positions
+      @key_positions ||= begin
+        sum = 0
+        @keys.collect { |k| sum += k.v }
+      end
+    end
+  end
+
+  module ExpKeyInterpolate
+    def interpol(position, start, stop, key_index)
+      p_0 = get_p(key_index)
+      p_1 = get_p(key_index + 1)
+      m_0 = get_m1(key_index)
+      m_1 = get_m0(key_index + 1)
+      t = (value - start).to_f / (stop - start)
+      t3 = t*t*t
+      t2 = t*t
+      (2 * t3 - 3 * t2 + 1)*p_0 + (t3 - 2 * t2 + t)*m_0 + (-2 * t3 + 3 * t2)*p_1 + (t3 - t2)*m_1
+    end
+
+    def interpolate(position)
+      if positions <= key_positions.first
+        get_p(0)
+      elsif positions >= key_positions.last
+        get_p(key_positions.length -1)
+      else
+        key_positions.each_cons(2).each_with_index { |(start, stop), i|
+          if position <= stop && position >= start
+            return interpol(position, start, stop)
+          end
+        }
+      end
+    end
+  end
+
+  class EXPFile2 < LibBin::Structure
+
+    class EXPFileHeader < LibBin::Structure
+      int8 :id, count: 4
+      int32 :version
+      uint32 :offset_records
+      uint32 :num_records
+      uint32 :offset_interpolations
+      uint32 :num_interpolations
+
+      def initialize
+        @id = "exp\0".b
+        @version = 0x20110714
+        @offset_records = 0
+        @num_records = 0
+        @offset_interpolations = 0
+        @num_interpolations = 0
+      end
+    end
+
+    class Record < LibBin::Structure
+      int16 :bone_index
+      int8 :animation_track
+      int8 :padding
+      int16 :num_operations
+      int16 :unknown
+      uint32 :offset
+
+      def initialize
+        @bone_index = 0
+        @animation_track = 0
+        @padding = 0
+        @num_operations = 0
+        @unknown = 0
+        @offset = 0
+      end
+
+    end
+
+    class Operation < LibBin::Structure
+      int8 :type
+      int8 :info
+      int16 :number
+      float :value
+
+      def initialize
+        @type = 0
+        @info = 0
+        @number = 0
+        @value = 0.0
+      end
+
+    end
+
+    class Entry < LibBin::Structure
+      register_field :operations, Operation, count: '..\records[__index]\num_operations'
+
+      def initialize
+        @operations = []
+      end
+
+      def abs(v)
+        v.abs
+      end
+
+      def get_value(tracks, table, interpolation_entries)
+        s = ""
+        @operations.each { |o|
+          case o.type
+          when 0
+            nil
+          when 1
+            s << "("
+          when 2
+            s << ")"
+          when 3
+            s << "tracks[table[#{o.number}]][#{o.info}]"
+          when 4
+            s << "#{o.value}"
+          when 5
+            case o.number
+            when 0
+              s << " + "
+            when 2
+              s << " * "
+            else
+              raise "Unknown arithmetic operation: #{o.number}!"
+            end
+          when 6
+            raise "Unknown function argument number: #{o.info}!" if o.info != 1
+            case o.number
+            when 1
+              s << "abs("
+            else
+              raise "Unknown function: #{o.number}!"
+            end
+          when 7
+            s << ")"
+          when 8
+            s << "interpolation_entries[#{o.number}].get_value("
+          else
+            raise "Unknown operation: #{o.type}!"
+          end
+        }
+        eval s
+      end
+
+    end
+
+    class Interpolation < LibBin::Structure
+      int16 :num_points
+      int16 :padding
+      uint32 :offset
+
+      def initialize
+        @num_points = 0
+        @padding = 0
+        @offset = 0
+      end
+
+    end
+
+    class Point < LibBin::Structure
+      float :v
+      float :p
+      float :m0
+      float :m1
+
+      def initialize
+        @v = 0.0
+        @p = 0.0
+        @m0 = 0.0
+        @m1 = 0.0
+      end
+
+    end
+
+    class InterpolationEntry < LibBin::Structure
+      register_field :points, Point, count: '..\interpolations[__index]\num_points'
+
+      def get_value(val)
+        @points.each_cons(2) { |left, right|
+          if left.v <= val && right.v >= val
+            p0 = left.p
+            p1 = right.p
+            m0 = left.m1
+            m1 = right.m0
+            t = (val - left.v).to_f / (right.v - left.v)
+            return (2 * t*t*t - 3 * t*t + 1)*p0 + (t*t*t - 2 * t*t + t)*m0 + (-2 * t*t*t + 3 * t*t)*p1 + (t*t*t - t * t)*m1
+          end
+
+        }
+        return 0.0
+      end
+
+    end
+
+    register_field :header, EXPFileHeader
+    register_field :records, Record, count: 'header\num_records', offset: 'header\offset_records'
+    register_field :entries, Entry, count: 'header\num_records', sequence: true,
+      offset: 'records[__iterator]\offset + header\offset_records + 12*__iterator'
+    register_field :interpolations, Interpolation, count: 'header\num_interpolations', offset: 'header\offset_interpolations'
+    register_field :interpolation_entries, InterpolationEntry, count: 'header\num_interpolations', sequence: true,
+      offset: 'interpolations[__iterator]\offset + header\offset_interpolations + 8*__iterator'
+
+    def apply(tracks, table)
+      rad_to_deg = 180.0 / Math::PI
+      deg_to_rad = Math::PI / 180.0
+      tracks.each { |tr|
+        tr[0] *= 10.0
+        tr[1] *= 10.0
+        tr[2] *= 10.0
+        tr[3] *= rad_to_deg
+        tr[4] *= rad_to_deg
+        tr[5] *= rad_to_deg
+      }
+      @records.each_with_index { |r, i|
+        bone_index = table[r.bone_index]
+        next unless bone_index
+        animation_track = r.animation_track
+        if @entries[i]
+          value = @entries[i].get_value(tracks, table, interpolation_entries)
+        end
+        tracks[bone_index][animation_track] = value
+      }
+      tracks.each { |tr|
+        tr[0] *= 0.1
+        tr[1] *= 0.1
+        tr[2] *= 0.1
+        tr[3] *= deg_to_rad
+        tr[4] *= deg_to_rad
+        tr[5] *= deg_to_rad
+      }
+    end
+
+    def recompute_layout
+      self
+    end
+
+    def was_big?
+      @__was_big
+    end
+
+    def dump(output_name, output_big = false)
+      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = File.open(output_name, "wb")
+      end
+      output.rewind
+
+      __set_dump_state(output, output_big, nil, nil)
+      __dump_fields
+      __unset_dump_state
+      output.close unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+      self
+    end
+
+  end
+
+  class EXPFile < LibBin::Structure
+
+    class EXPFileHeader < LibBin::Structure
+      int8 :id, count: 4
+      int32 :version
+      uint32 :offset_records
+      uint32 :num_records
+
+      def initialize
+        @id = "exp\0".b
+        @version = 0
+        @offset_records = 0
+        @num_records = 0
+      end
+
+    end
+
+    class Record < LibBin::Structure
+      int16 :u_a
+      int16 :bone_index
+      int8 :animation_track
+      int8 :entry_type
+      int8 :u_b
+      int8 :interpolation_type
+      int16 :num_points
+      int16 :u_c
+      uint32 :offset
+      uint32 :offset_interpolation
+
+      def initialize
+        @u_a = 0
+        @bone_index = 0
+        @animation_track = 0
+        @entry_type = 0
+        @u_b = 0
+        @interpolation_type = 0
+        @num_points = 0
+        @offset = 0
+        @offset_interpolation = 0
+      end
+
+    end
+
+    class Operation < LibBin::Structure
+      uint32 :flags
+      float :value
+
+      def initialize
+        @flags = 0
+        @value = 0.0
+      end
+
+      def transform_value( v )
+        if @flags == 0x4
+          v *= @value
+        elsif @flags == 0x20004
+          v = v.abs * @value
+        elsif @flags == 0x1
+          v += @value
+        else
+          raise "Unknown operation #{ "%x" % @flags }, please report!"
+        end
+        v
+      end
+
+    end
+
+    class Entry1 < LibBin::Structure
+      uint32 :flags
+      int16 :bone_index
+      int8 :animation_track
+      int8 :padding
+
+      def initialize
+        @flags = 0x80000001
+        @bone_index = 0
+        @animation_track = 0
+        @padding = 0
+      end
+
+      def get_value(pose, table)
+        pose[table[@bone_index]][@animation_track]
+      end
+
+    end
+
+    class Entry2 < LibBin::Structure
+      uint32 :flags
+      int16 :bone_index
+      int8 :animation_track
+      int8 :padding
+      register_field :operation, Operation
+
+      def initialize
+        @flags = 0x80000001
+        @bone_index = 0
+        @animation_track = 0
+        @padding = 0
+        @operation = Operation::new
+      end
+
+      def get_value(pose, table)
+        @operation.transform_value( pose[table[@bone_index]][@animation_track] )
+      end
+
+    end
+
+    class Entry3 < LibBin::Structure
+      uint32 :flags
+      int16 :bone_index
+      int8 :animation_track
+      int8 :padding
+      register_field :operations, Operation, count: 2
+
+      def initialize
+        @flags = 0x80000001
+        @bone_index = 0
+        @animation_track = 0
+        @padding = 0
+        @operations = [Operation::new, Operation::new]
+      end
+
+      def get_value(pose, table)
+        v = @operations[0].transform_value( pose[table[@bone_index]][@animation_track] )
+        v = @operations[1].transform_value( v )
+      end
+
+    end
+
+    class Entry < LibBin::Structure
+
+      def self.convert(input, output, input_big, output_big, parent, index, length = nil)
+        entry_type = parent.records[index].entry_type
+        entry = nil
+        case entry_type
+        when 1
+          entry = Entry1::convert(input, output, input_big, output_big, parent, index, length)
+        when 2
+          entry = Entry2::convert(input, output, input_big, output_big, parent, index, length)
+        when 3
+          entry = Entry3::convert(input, output, input_big, output_big, parent, index, length)
+        end
+        entry
+      end
+
+      def self.load(input, input_big, parent, index, length = nil)
+        entry_type = parent.records[index].entry_type
+        entry = nil
+        case entry_type
+        when 1
+          entry = Entry1::load(input, input_big, parent, index, length)
+        when 2
+          entry = Entry2::load(input, input_big, parent, index, length)
+        when 3
+          entry = Entry3::load(input, input_big, parent, index, length)
+        end
+        entry
+      end
+
+    end
+
+    class Key2 < LibBin::Structure
+      float :v
+      float :p
+      float :m0
+      float :m1
+
+      def initialize
+        @v = 0.0
+        @p = 0.0
+        @m0 = 0.0
+        @m1 = 0.0
+      end
+
+      def size
+        3 * 4
+      end
+    end
+
+    class Interpolation2 < LibBin::Structure
+      include ExpDirectValues
+      include ExpAbsolutePositions
+      include ExpKeyInterpolate
+      register_field :keys, Key2, count: '..\records[__index]\num_points'
+
+      def size
+        @keys.collect(&:size).reduce(:+)
+      end
+    end
+
+    class Key4 < LibBin::Structure
+      float :v
+      uint16 :dummy
+      uint16 :cp
+      uint16 :cm0
+      uint16 :cm1
+
+      def initialize
+        @v = 0.0
+        @dummy = 0
+        @cp = 0
+        @cm0 = 0
+        @cm1 = 0
+      end
+
+      def size
+        3 * 4
+      end
+    end
+
+    class Interpolation4 < LibBin::Structure
+      include ExpQuantizedValues
+      include ExpAbsolutePositions
+      include ExpKeyInterpolate
+      float :p
+      float :dp
+      float :m0
+      float :dm0
+      float :m1
+      float :dm1
+      register_field :keys, Key4, count: '..\records[__index]\num_points'
+
+      def size
+        4 * 6 + @keys.collect(&:size).reduce(:+)
+      end
+    end
+
+    class Key6 < LibBin::Structure
+      uint8 :v
+      uint8 :cp
+      uint8 :cm0
+      uint8 :cm1
+
+      def initialize
+        @v = 0
+        @cp = 0
+        @cm0 = 0
+        @cm1 = 0
+      end
+
+      def size
+        4
+      end
+    end
+
+    class Interpolation6 < LibBin::Structure
+      include ExpQuantizedValues
+      include ExpRelativePositions
+      include ExpKeyInterpolate
+      pghalf :p
+      pghalf :dp
+      pghalf :m0
+      pghalf :dm0
+      pghalf :m1
+      pghalf :dm1
+      register_field :keys, Key6, count: '..\records[__index]\num_points'
+
+      def size
+        2 * 6 + @keys.collect(&:size).reduce(:+)
+      end
+    end
+
+    class Interpolation < LibBin::Structure
+
+      def self.convert(input, output, input_big, output_big, parent, index, length = nil)
+        case parent.records[index].interpolation_type
+        when 2
+          Interpolation2::convert(input, output, input_big, output_big, parent, index, length)
+        when 4
+          Interpolation4::convert(input, output, input_big, output_big, parent, index, length)
+        when 6
+          Interpolation6::convert(input, output, input_big, output_big, parent, index, length)
+        when -1
+          nil
+        else
+          raise "Unknown Interpolation type: #{interpolation_type}, please report!"
+        end
+      end
+
+      def self.load(input, input_big, parent, index, length = nil)
+        case parent.records[index].interpolation_type
+        when 2
+          Interpolation2::load(input, input_big, parent, index, length)
+        when 4
+          Interpolation4::load(input, input_big, parent, index, length)
+        when 6
+          Interpolation6::load(input, input_big, parent, index, length)
+        when -1
+          nil
+        else
+          raise "Unknown Interpolation type: #{interpolation_type}, please report!"
+        end
+      end
+
+    end
+
+    register_field :header, EXPFileHeader
+    register_field :records, Record, count: 'header\num_records', offset: 'header\offset_records'
+    register_field :entries, Entry, count: 'header\num_records', sequence: true,
+      offset: 'records[__iterator]\offset'
+    register_field :interpolations, Interpolation, count: 'header\num_records', sequence: true,
+      offset: 'records[__iterator]\offset_interpolation'
+
+    def was_big?
+      @__was_big
+    end
+
+    def apply(tracks, table)
+      rad_to_deg = 180.0 / Math::PI
+      deg_to_rad = Math::PI / 180.0
+      tracks.each { |tr|
+        tr[3] *= rad_to_deg
+        tr[4] *= rad_to_deg
+        tr[5] *= rad_to_deg
+      }
+      @records.each_with_index { |r, i|
+        bone_index = table[r.bone_index]
+        next unless bone_index
+        animation_track = r.animation_track
+        if @entries[i]
+          value = @entries[i].get_value(tracks, table)
+        end
+        if @interpolations[i]
+          value = @interpolations[i].interpolate(value)
+        end
+        tracks[bone_index][animation_track] = value
+      }
+      tracks.each { |tr|
+        tr[3] *= deg_to_rad
+        tr[4] *= deg_to_rad
+        tr[5] *= deg_to_rad
+      }
+    end
+
+    def add_entries(hash)
+      hash.each { |k, v|
+        raise "Invalid entry type #{k}!" if k>3 || k<1
+        v.times {
+          r = Record::new
+          r.entry_type = k
+          r.u_c = -1
+          @records.insert(-2, r)
+          case k
+          when 1
+            entry = Entry1::new
+          when 2
+            entry = Entry2::new
+          when 3
+            entry = Entry3::new
+          end
+          @entries.insert(-2, entry)
+        }
+      }
+      self
+    end
+
+    def recompute_layout
+      @header.num_records = @records.length
+      last_offset = @header.offset_records
+      last_offset += @records.collect(&:__size).reduce(:+)
+
+      table = @records.zip(@entries).to_h
+      reverse_table = table.invert
+      interpolation_table = @records.zip(@interpolations).to_h
+      reverse_interpolation_table = interpolation_table.invert
+
+      @records.sort_by! { |r| [r.bone_index, r.animation_track] }
+      @entries.sort_by! { |e| e ? [e.bone_index, e.animation_track] : [32767, -1] }
+      
+      @entries.each { |e|
+        if e
+          reverse_table[e].offset = last_offset
+          last_offset += e.__size
+        else
+          reverse_table[e].offset = 0
+        end
+      }
+      @interpolations.each { |i|
+        if i
+          reverse_interpolation_table[i].offset_interpolation = last_offset
+          last_offset += i.size
+        end
+      }
+
+      @entries = @records.collect { |r| table[r] }
+      @interpolation = @records.collect { |r| interpolation_table[r] }
+      self
+    end
+
+    def self.is_big?(f)
+      f.rewind
+      block = lambda { |int|
+        id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if id != "exp\0".b
+        u_a = f.read(4).unpack(int).first
+        offset_record = f.read(4).unpack(int).first
+        num_record = f.read(4).unpack(int).first
+
+        num_record >= 0 && offset_record > 0 && offset_record < f.size
+      }
+      big = block.call("l>")
+      f.rewind
+      small = block.call("l<")
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    end
+
+    def self.is_bayo2?(f, big)
+      f.rewind
+      id = f.read(4)
+      uint = "L<"
+      uint = "L>" if big
+      version = f.read(4).unpack(uint).first
+      f.rewind
+      return version == 0x20110714
+    end
+
+    def self.convert(input_name, output_name, input_big = true, output_big = false)
+      input = File.open(input_name, "rb")
+      id = input.read(4).unpack("a4").first
+      raise "Invalid file type #{id}!" unless id == "exp\0".b
+      output = File.open(output_name, "wb")
+      output.write("\x00"*input.size)
+      input.seek(0);
+      output.seek(0);
+
+      if is_bayo2?(input, input_big)
+        exp = EXPFile2::new
+      else
+        exp = self::new
+      end
+      exp.__convert(input, output, input_big, output_big)
+
+      input.close
+      output.close
+    end
+
+    def self.load(input_name)
+      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+        input = input_name
+      else
+        input = File.open(input_name, "rb")
+      end
+      input_big = is_big?(input)
+
+      if is_bayo2?(input, input_big)
+        exp = EXPFile2::new
+      else
+        exp = self::new
+      end
+      exp.instance_variable_set(:@__was_big, input_big)
+      exp.__load(input, input_big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+
+      exp
+    end
+
+    def dump(output_name, output_big = false)
+      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = File.open(output_name, "wb")
+      end
+      output.rewind
+
+      __set_dump_state(output, output_big, nil, nil)
+      __dump_fields
+      __unset_dump_state
+      output.close unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+      self
+    end
+
+  end
+
+end