pgtools 1.0.0

data/lib/bayonetta/clp.rb

@@ -0,0 +1,212 @@
+module Bayonetta
+
+  class CLPFile < LibBin::Structure
+
+    class FVector < LibBin::Structure
+      float :x
+      float :y
+      float :z
+
+      def from_bxm_vector(v)
+        @x, @y, @z = v.split(" ").collect(&:to_f)
+        self
+      end
+
+      def self.from_bxm_vector(v)
+        nv = self::new
+        nv.from_bxm_vector(v)
+        nv
+      end
+
+    end
+
+    class Header < LibBin::Structure
+      int32 :num
+      float :limit_spring_rate
+      float :spd_rate
+      float :stretchy
+      int16 :bundle_num
+      int16 :bundle_num_2
+      float :thick
+      register_field :gravity_vec, FVector
+      int32 :gravity_parts_no
+      float :first_bundle_rate
+      register_field :wind_vec, FVector
+      int32 :wind_parts_no
+      register_field :wind_offset, FVector
+      float :wind_sin
+      float :hit_adjust_rate
+
+      def from_bxm_header(h)
+        @num = h.at_css("m_Num").content.to_i
+        @limit_spring_rate = h.at_css("m_LimitSpringRate").content.to_f
+        @spd_rate = h.at_css("m_SpdRate").content.to_f
+        @stretchy = h.at_css("m_Stretchy").content.to_f
+        @bundle_num = h.at_css("m_BundleNum").content.to_i
+        @bundle_num_2 = h.at_css("m_BundleNum2").content.to_i
+        @thick = h.at_css("m_Thick").content.to_f
+        @gravity_vec = FVector.from_bxm_vector(h.at_css("m_GravityVec").content)
+        @gravity_parts_no = h.at_css("m_GravityPartsNo").content.to_i
+        @first_bundle_rate = h.at_css("m_FirstBundleRate").content.to_f
+        @wind_vec = FVector.from_bxm_vector(h.at_css("m_WindVec").content)
+        @wind_parts_no = h.at_css("m_WindPartsNo").content.to_i
+        @wind_offset = FVector.from_bxm_vector(h.at_css("m_WindOffset").content)
+        @wind_sin = h.at_css("m_WindSin").content.to_f
+        @hit_adjust_rate = h.at_css("m_HitAdjustRate").content.to_f
+        self
+      end
+
+      def self.from_bxm_header(h)
+        nh = self::new
+        nh.from_bxm_header(h)
+        nh
+      end
+
+    end
+
+    class Cloth < LibBin::Structure
+      int16 :no
+      int16 :no_up
+      int16 :no_down
+      int16 :no_side
+      int16 :no_poly
+      int16 :no_fix
+      float :rot_limit
+      register_field :offset, FVector
+
+      def from_bxm_cloth(h)
+        @no = h.at_css("no").content.to_i
+        @no_up = h.at_css("noUp").content.to_i
+        @no_down = h.at_css("noDown").content.to_i
+        @no_side = h.at_css("noSide").content.to_i
+        @no_poly = h.at_css("noPoly").content.to_i
+        @no_fix = h.at_css("noFix").content.to_i
+        @rot_limit = h.at_css("rotLimit").content.to_f
+        @offset = FVector.from_bxm_vector(h.at_css("offset").content)
+        self
+      end
+
+      def self.from_bxm_cloth(c)
+        cl = self::new
+        cl.from_bxm_cloth(c)
+        cl
+      end
+
+      def remap(map, poly = true, fix = true)
+        @no = check_and_remap_bone(map, @no)
+        @no_up = check_and_remap_bone(map, @no_up)
+        @no_down = check_and_remap_bone(map, @no_down)
+        @no_side = check_and_remap_bone(map, @no_side)
+        @no_poly = ( poly ? check_and_remap_bone(map, @no_poly) : 4095 )
+        @no_fix = ( fix ? check_and_remap_bone(map, @no_fix) : 4095 )
+      end
+
+      private
+      def check_and_remap_bone(map, no)
+	tmp = map[no]
+	raise "No bone found in map for #{no}!" unless tmp
+	tmp
+      end
+
+    end
+
+    register_field :header, Header
+    register_field :cloth, Cloth, count: 'header\num'
+
+    def was_big?
+      @__was_big
+    end
+
+    def remap(map, poly = true, fix = true)
+      @cloth.each { |c|
+        c.remap(map, poly, fix)
+      }
+    end
+
+    def self.load_bxm(input_name)
+      bxm = BXMFile::load(input_name)
+      clp = self::new
+
+      doc = bxm.to_xml
+      h = doc.at_css("//CLOTH//CLOTH_HEADER")
+      clp.header = Header.from_bxm_header(h)
+
+      clp.cloth = doc.css("//CLOTH//CLOTH_WK").collect { |c|
+        Cloth.from_bxm_cloth(c)
+      }
+      clp
+    end
+
+    def self.is_big?(f)
+      f.rewind
+      f.size
+      block = lambda { |int|
+        num = f.read(4).unpack(int).first
+        ( num >= 0 ) && ( num < 256 )
+      }
+      big = block.call("l>")
+      f.rewind
+      small = block.call("l<")
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    end
+
+    def self.convert(input_name, output_name, output_big = false)
+      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 output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = File.open(output_name, "wb")
+      end
+      output.rewind
+
+      clp = self::new
+      clp.instance_variable_set(:@__was_big, input_big)
+      clp.__convert(input, output, input_big, output_big)
+
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      output.close unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+      clp
+    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)
+
+      clp = self::new
+      clp.instance_variable_set(:@__was_big, input_big)
+      clp.__load(input, input_big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      clp
+    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

data/lib/bayonetta/clw.rb

@@ -0,0 +1,166 @@
+module Bayonetta
+
+  class CLWFile < LibBin::Structure
+
+    class FVector < LibBin::Structure
+      float :x
+      float :y
+      float :z
+
+      def from_bxm_vector(v)
+        @x, @y, @z = v.split(" ").collect(&:to_f)
+        self
+      end
+
+      def self.from_bxm_vector(v)
+        nv = self::new
+        nv.from_bxm_vector(v)
+        nv
+      end
+
+    end
+
+    class ClothWind < LibBin::Structure
+      int32 :wind_type
+      int32 :parts_no
+      register_field :offset,  FVector
+      register_field :offset2, FVector
+      float :radius
+      float :power
+      float :timer
+      float :swing_rate
+      float :swing_spd
+      float :delay_max
+
+      def from_bxm_cloth_wind(h)
+        @wind_type = h.at_css("WindType").content.to_i
+        @parts_no = h.at_css("PartsNo").content.to_i
+        @offset = FVector.from_bxm_vector(h.at_css("Offset").content)
+        @offset2 = FVector.from_bxm_vector(h.at_css("Offset2").content)
+        @radius = h.at_css("Radius").content.to_f
+        @power = h.at_css("Power").content.to_f
+        @timer = h.at_css("Timer").content.to_f
+        @swing_rate = h.at_css("SwingRate").content.to_f
+        @swing_spd = h.at_css("SwingSpd").content.to_f
+        @delay_max = h.at_css("DelayMax").content.to_f
+        self
+      end
+
+      def self.from_bxm_cloth_wind(c)
+        clw = self::new
+        clw.from_bxm_cloth_wind(c)
+        clw
+      end
+
+      def remap(map)
+        @parts_no = check_and_remap_bone(map, @parts_no)
+      end
+
+      private
+      def check_and_remap_bone(map, no)
+	tmp = map[no]
+	raise "No bone found in map for #{no}!" unless tmp
+	tmp
+      end
+
+    end
+
+    int32 :cloth_wind_num
+    register_field :cloth_wind, ClothWind, count: 'cloth_wind_num'
+
+    def was_big?
+      @__was_big
+    end
+
+    def remap(map)
+      @cloth_wind.each { |c|
+        c.remap(map)
+      }
+    end
+
+    def self.load_bxm(input_name)
+      bxm = BXMFile::load(input_name)
+      clw = self::new
+
+      doc = bxm.to_xml
+      clw.cloth_wind_num = doc.at_css("//CLOTH_WIND//CLOTH_WIND_NUM").content.to_i
+
+      clw.cloth_wind = doc.css("//CLOTH_WIND//CLOTH_WIND_WK").collect { |c|
+        ClothWind.from_bxm_cloth_wind(c)
+      }
+      clw
+    end
+
+    def self.is_big?(f)
+      f.rewind
+      f.size
+      block = lambda { |int|
+        num = f.read(4).unpack(int).first
+        ( num >= 0 ) && ( num < 256 )
+      }
+      big = block.call("l>")
+      f.rewind
+      small = block.call("l<")
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    end
+
+    def self.convert(input_name, output_name, output_big = false)
+      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 output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = File.open(output_name, "wb")
+      end
+      output.rewind
+
+      clp = self::new
+      clp.instance_variable_set(:@__was_big, input_big)
+      clp.__convert(input, output, input_big, output_big)
+
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      output.close unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+      clp
+    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)
+
+      clp = self::new
+      clp.instance_variable_set(:@__was_big, input_big)
+      clp.__load(input, input_big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      clp
+    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

data/lib/bayonetta/dat.rb

@@ -0,0 +1,261 @@
+require 'stringio'
+module Bayonetta
+  class DATFile < LibBin::Structure
+    include Alignment
+    attr_reader :big
+    ALIGNMENTS = {
+      'dat' => 0x2000,
+      'wmb' => 0x1000,
+      'wtb' => 0x1000,
+      'wtp' => 0x1000,
+      'wta' =>   0x40,
+      'exp' => 0x1000,
+      'sop' =>   0x40,
+      'eff' => 0x1000,
+      'sdx' => 0x1000,
+      'bxm' =>   0x40
+    }
+    ALIGNMENTS.default = 0x10
+
+    class Header < LibBin::Structure
+      string :id, 4
+      uint32 :num_files
+      uint32 :offset_file_offsets
+      uint32 :offset_file_extensions
+      uint32 :offset_file_names
+      uint32 :offset_file_sizes
+      uint32 :offset_hash_map
+    end
+
+    class HashMap < LibBin::Structure
+      class Header < LibBin::Structure
+        uint32 :pre_hash_shift
+        uint32 :offset_bucket_ranks
+        uint32 :offset_hashes
+        uint32 :offset_file_indices
+      end
+      register_field :header, Header
+      int16 :bucket_ranks, count: '(1<<(31 - header\pre_hash_shift))', offset: 'header\offset_bucket_ranks', relative_offset: true
+      uint32 :hashes, count: '..\header\num_files', offset: 'header\offset_hashes', relative_offset: true
+      uint16 :file_indices, count: '..\header\num_files', offset: 'header\offset_file_indices', relative_offset: true
+
+      def get
+        {
+          pre_hash_shift: @header.pre_hash_shift,
+          hashes: file_indices.zip(hashes).sort { |(i1 ,h1), (i2, h2)|
+            i1 <=> i2
+          }.collect { |i, h|
+            h
+          }
+        }
+      end
+
+      def initialize
+        super
+        @header = Header::new
+      end
+
+      def set(hash_map)
+        bit_shift = hash_map[:pre_hash_shift]
+        hash_list = hash_map[:hashes]
+        num_files = hash_list.size
+        @header.pre_hash_shift = bit_shift
+        buckets = Hash::new { |h, k| h[k] = [] }
+        hash_list.each_with_index { |h, i|
+          bucket_index = h >> @header.pre_hash_shift
+          buckets[bucket_index].push [h, i]
+        }
+        @bucket_ranks = []
+        @hashes = []
+        @file_indices = []
+        bucket_rank = 0
+        num_buckets = (1 << (31 - header.pre_hash_shift))
+        num_buckets.times { |i|
+          if buckets.has_key?(i)
+            @bucket_ranks.push bucket_rank
+            bucket_rank += buckets[i].size
+            buckets[i].each { |h, ind|
+              @hashes.push h
+              @file_indices.push ind
+            }
+          else
+            @bucket_ranks.push -1
+          end
+        }
+        @header.offset_bucket_ranks = 0x10
+        @header.offset_hashes = header.offset_bucket_ranks + num_buckets * 2
+        @header.offset_file_indices = header.offset_hashes + num_files * 4
+        self
+      end
+    end
+
+    register_field :header, Header
+    uint32 :file_offsets, count: 'header\num_files', offset: 'header\offset_file_offsets'
+    string :file_extensions, 4, count: 'header\num_files', offset: 'header\offset_file_extensions'
+    uint32 :file_name_length, offset: 'header\offset_file_names'
+    string :file_names, count: 'header\num_files', offset: 'header\offset_file_names + 4 + __iterator * file_name_length', sequence: true
+    uint32 :file_sizes, count: 'header\num_files', offset: 'header\offset_file_sizes'
+    register_field :hash_map, HashMap, offset: 'header\offset_hash_map'
+    string :files, 'file_sizes[__iterator]', count: 'header\num_files', offset: 'file_offsets[__iterator]', sequence: true
+
+    def self.is_big?(f)
+      f.rewind
+      block = lambda { |big|
+        h = Header::load(f, big)
+        h.offset_file_offsets < f.size &&
+          h.offset_file_names < f.size &&
+          h.offset_file_sizes < f.size &&
+          h.offset_hash_map < f.size
+      }
+      big = block.call(true)
+      f.rewind
+      small = block.call(false)
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    end
+
+    def initialize(big = false)
+      @big = big
+      super()
+      @header = Header::new
+      @header.id = "DAT\x00".b
+      @header.num_files = 0
+      @header.offset_file_offsets = 0
+      @header.offset_file_extensions = 0
+      @header.offset_file_names = 0
+      @header.offset_file_sizes = 0
+      @header.offset_hash_map = 0
+
+      @file_offsets = []
+      @file_extensions = []
+      @file_name_length = 0
+      @file_names = []
+      @file_sizes = []
+      @files = []
+
+      @hash_map = nil
+    end
+
+    def invalidate_layout
+      @header.offset_file_offsets = 0
+      @header.offset_file_extensions = 0
+      @header.offset_file_names = 0
+      @header.offset_file_sizes = 0
+      @header.offset_hash_map = 0
+      @file_offsets = []
+      @hash_map = nil
+      self
+    end
+
+    def layout
+      @file_names.collect { |name| name[0..-2] }
+    end
+
+    def each
+      if block_given? then
+        @header.num_files.times { |i|
+          yield @file_names[i][0..-2], StringIO::new(@files[i] ? @files[i] : "", "rb")
+        }
+      else
+        to_enum(:each)
+      end
+    end
+
+    def [](i)
+      return [@file_names[i][0..-2], StringIO::new(@files[i] ? @files[i] : "", "rb")]
+    end
+
+    def push(name, file)
+      invalidate_layout
+      @file_names.push name+"\x00"
+      if file.kind_of?(StringIO)
+        data = file.string
+      else
+        file.rewind
+        data = file.read
+      end
+      @files.push data
+      @file_sizes.push file.size
+      extname = File.extname(name)
+      raise "Invalid name, missing extension!" if extname == ""
+      @file_extensions.push extname[1..-1]+"\x00"
+      @header.num_files += 1
+      self
+    end
+
+    def compute_layout
+      @header.offset_file_offsets = 0x20
+      @header.offset_file_extensions = @header.offset_file_offsets + 4 * @header.num_files
+      @header.offset_file_names = @header.offset_file_extensions + 4 * @header.num_files
+      max_file_name_length = @file_names.collect(&:length).max
+      @file_name_length = max_file_name_length
+      @header.offset_file_sizes = @header.offset_file_names + 4 + @file_name_length * @header.num_files
+      @header.offset_file_sizes = align(@header.offset_file_sizes, 4)
+      if @hash_map
+        @header.offset_hash_map = @header.offset_file_sizes + 4 * @header.num_files
+        files_offset = @header.offset_hash_map + @hash_map.__size(@header.offset_hash_map, self)
+      else
+        @offset_hash_map = 0
+        files_offset = @header.offset_file_sizes + 4 * @header.num_files
+      end
+      @file_offsets = @header.num_files.times.collect { |i|
+        if @file_sizes[i] > 0
+          tmp = align(files_offset, ALIGNMENTS[@file_extensions[i][0..-2]])
+          files_offset = align(tmp + @file_sizes[i], ALIGNMENTS[@file_extensions[i][0..-2]])
+          tmp
+        else
+          0
+        end
+      }
+      @total_size = align(files_offset, 0x1000)
+      self
+    end
+
+    def set_hash_map(hash)
+      @hash_map = HashMap::new
+      @hash_map.set hash
+    end
+
+    def self.load(input_name)
+      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+        input = input_name
+      else
+        File.open(input_name, "rb") { |f|
+          input = StringIO::new(f.read, "rb")
+        }
+      end
+      big = self::is_big?(input)
+      dat = self::new(big)
+      dat.__load(input, big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      dat
+    end
+
+    def dump(output_name)
+      compute_layout
+      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = StringIO::new("", "wb")#File.open(output_name, "wb")
+        output.write("\x00"*@total_size)
+        output.rewind
+      end
+      output.rewind
+
+      __set_dump_state(output, @big, nil, nil)
+      __dump_fields
+      __unset_dump_state
+
+      unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        File.open(output_name, "wb") { |f|
+          f.write output.string
+        }
+        output.close
+      end
+      self
+    end
+
+  end
+
+end