pgtools 1.0.0

data/lib/bayonetta/pkz.rb

@@ -0,0 +1,63 @@
+module Bayonetta
+
+  class PKZFile < LibBin::Structure
+
+    class FileDescriptor < LibBin::Structure
+      uint32 :offset_name
+      uint32 :offset_compression
+      uint64 :size
+      uint64 :offset
+      uint64 :compressed_size
+      string :name, offset: 'offset_name + ..\header.offset_file_descriptors + ..\header.num_files * 0x20'
+      string :compression, offset: 'offset_compression + ..\header.offset_file_descriptors + ..\header.num_files * 0x20'
+    end
+
+    class Header < LibBin::Structure
+      uint32 :id
+      int32  :unknown
+      uint64 :size
+      uint32 :num_files
+      uint32 :offset_file_descriptors
+      uint32 :length_file_name_table
+      uint32 :unknown
+    end
+
+    register_field :header, Header
+    register_field :file_descriptors, FileDescriptor, count: 'header.num_files',
+                   offset: 'header.offset_file_descriptors + __iterator * 0x20', sequence: true
+
+    def self.is_big?(f)
+      f.rewind
+      block = lambda { |int64|
+        id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if id != "pkzl".b
+        f.read(4)
+        size = f.read(8).unpack(int64).first
+        size == f.size
+      }
+      big = block.call("q>")
+      f.rewind
+      small = block.call("q<")
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    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)
+      pkz = self::new
+      pkz.instance_variable_set(:@__was_big, input_big)
+      pkz.__load(input, input_big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+
+      pkz
+    end
+
+  end
+
+end

data/lib/bayonetta/scr.rb

@@ -0,0 +1,393 @@
+module Bayonetta
+  class SCR2File
+    include Alignment
+    include Endianness
+    attr_reader :big
+    attr_accessor :unknown
+    attr_accessor :models_metadata
+
+    ALIGNMENTS = {
+      'wmb' => 0x80,
+    }
+
+    def bayo2?
+      true
+    end
+
+    def self.is_bayo?(f)
+      f.rewind
+      id = f.read(4)
+      raise "Invalid id #{id.inspect}!" if id != "SCR\0".b
+      a, b = f.read(4).unpack("S2")
+      f.rewind
+      a == 0 || b == 0
+    end
+
+    def self.is_big?(f)
+      f.rewind
+      block = lambda { |int, short|
+        id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if id != "SCR\0".b
+        unknown = f.read(2).unpack(short).first
+        model_number = f.read(2).unpack(short).first
+        offset_model_offsets = f.read(4).unpack(int).first
+        unknown >= 0 && model_number >=0 && (model_number * 0x8c + 0x10) < f.size &&
+          offset_model_offsets >= 0 && offset_model_offsets < f.size
+      }
+      big = block.call("l>", "s>")
+      f.rewind
+      small = block.call("l<", "s<")
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    end
+
+    def initialize(f = nil, big = false)
+      @big = big
+      if f
+        file_name_input = false
+        unless f.respond_to?(:read) && f.respond_to?(:seek)
+          file_name_input = true
+          f = File::new(f, "rb")
+        end
+        @big = SCR2File.is_big?(f)
+
+        f.rewind
+        uint = get_uint
+        ushort = get_ushort
+        float = get_float
+        short = get_short
+
+        @id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if @id != "SCR\0".b
+        @unknown, @num_models = f.read(4).unpack("#{ushort}2")
+        @offset_offsets_models = f.read(4).unpack(uint).first
+
+        f.seek(@offset_offsets_models)
+        @offsets_models_meta = f.read(4*@num_models).unpack("#{uint}#{@num_models}")
+        @offsets_models = []
+        @sizes_models = []
+
+
+        @models_metadata = @num_models.times.collect { |i|
+          f.seek(@offsets_models_meta[i])
+          offset = f.read(4).unpack(uint).first
+          name = f.read(64)
+          transform = f.read(4*9).unpack("#{float}9")
+          u_a = f.read(18*2).unpack("#{short}18")
+          @offsets_models.push(offset)
+          {
+            name: name,
+            transform: transform,
+            u_a: u_a
+          }
+        }
+        @num_models.times { |i|
+          if i == ( @num_models - 1 )
+            @sizes_models.push( f.size - @offsets_models[i] )
+          else
+            @sizes_models.push( @offsets_models_meta[i+1] - @offsets_models[i] )
+          end
+        }
+        @models = @num_models.times.collect { |i|
+          f.seek(@offsets_models[i])
+          StringIO::new( f.read(@sizes_models[i]), "rb")
+        }
+        @total_size = f.size
+        f.close if file_name_input
+      else
+        @id = "SCR\0".b
+        @unknown = 0x12
+        @num_models = 0
+        @offsets_models = []
+        @sizes_models = []
+        @models_metadata = []
+        @offsets_models_meta = []
+        @models = []
+        @total_size = 0
+        @offset_offsets_models = 0x10
+      end
+    end
+
+    def each_model
+      if block_given? then
+        @num_models.times { |i|
+          yield @models[i]
+        }
+      else
+        to_enum(:each_model)
+      end
+    end
+
+    def [](i)
+      return @models[i]
+    end
+
+    def invalidate_layout
+      @offsets_models = []
+      @offsets_models_meta = []
+      @total_size = 0
+      self
+    end
+
+    def compute_layout
+      invalidate_layout
+      current_offset = @offset_offsets_models + 0x4 * @num_models
+      @num_models.times { |i|
+         current_offset = align(current_offset, 0x20)
+         @offsets_models_meta.push(current_offset)
+         current_offset += 0x8c
+         current_offset = align(current_offset, ALIGNMENTS["wmb"])
+         @offsets_models.push(current_offset)
+         current_offset += @sizes_models[i]
+      }
+      @total_size = align(current_offset, 0x20)
+      self
+    end
+
+    def push_model(file)
+      invalidate_layout
+      @models.push file
+      @sizes_models.push file.size
+      @num_models += 1
+      self
+    end
+
+    def textures
+      nil
+    end
+
+    def dump(name)
+      compute_layout
+      uint = get_uint
+      ushort = get_ushort
+      File.open(name,"wb") { |f|
+        f.write("\0"*@total_size)
+        f.rewind
+        f.write([@id].pack("a4"))
+        f.write([@unknown].pack(ushort))
+        f.write([@num_models].pack(ushort))
+        f.write([@offset_offsets_models].pack(uint))
+        f.seek(@offset_offsets_models)
+        f.write(@offsets_models_meta.pack("#{uint}#{@num_models}"))
+        @num_models.times { |i|
+          f.seek(@offsets_models_meta[i])
+          f.write([@offsets_models[i]].pack(uint))
+          f.write([@models_metadata[i][:name]].pack("a64"))
+          f.write(@models_metadata[i][:transform].pack("#{get_float}9"))
+          f.write(@models_metadata[i][:u_a].pack("#{get_short}18"))
+          f.seek(@offsets_models[i])
+          @models[i].rewind
+          f.write(@models[i].read)
+        }
+      }
+      self
+    end
+
+  end
+
+  class SCRFile
+    include Alignment
+    include Endianness
+    attr_reader :big
+    attr_accessor :unknown
+    attr_accessor :models_metadata
+
+    ALIGNMENTS = {
+      'wmb' => 0x20,
+      'wtb' => 0x1000,
+    }
+
+    def bayo2?
+      false
+    end
+
+    def self.is_big?(f)
+      f.rewind
+      block = lambda { |int|
+        id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if id != "SCR\0".b
+        model_number = f.read(4).unpack(int).first
+        offset_texture = f.read(4).unpack(int).first
+        ( model_number >= 0 ) && ( (model_number * 0x8c + 0x10) < f.size  ) && ( offset_texture >= 0 ) && ( offset_texture < 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)
+      f.rewind
+      id = f.read(4)
+      raise "Invalid id #{id.inspect}!" if id != "SCR\0".b
+      a, b = f.read(4).unpack("S2")
+      f.rewind
+      a > 0 && b > 0
+    end
+
+    def self.load(f)
+      file_name_input = false
+      unless f.respond_to?(:read) && f.respond_to?(:seek)
+        f = File::new(f, "rb")
+        file_name_input = true
+      end
+      if is_bayo2?(f)
+        scr = SCR2File::new(f)
+      else
+        scr = SCRFile::new(f)
+      end
+      f.close if file_name_input
+      scr
+    end
+
+    def initialize(f = nil, big = false)
+      @big = big
+      if f
+        file_name_input = false
+        unless f.respond_to?(:read) && f.respond_to?(:seek)
+          file_name_input = true
+          f = File::new(f, "rb")
+        end
+        @big = SCRFile.is_big?(f)
+
+        f.rewind
+        uint = get_uint
+
+        @id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if @id != "SCR\0".b
+        @num_models = f.read(4).unpack(uint).first
+        @offset_texture = f.read(4).unpack(uint).first
+        @unknown = f.read(4)
+        flt = get_float
+        sh = get_short
+        @offsets_models = []
+        @sizes_models = []
+        @models_metadata = @num_models.times.collect {
+          pos = f.tell
+          name = f.read(16)
+          offset = f.read(4).unpack(uint).first
+          transform = f.read(4*9).unpack("#{flt}9")
+          u_a = f.read(42*2).unpack("#{sh}42")
+          @offsets_models.push(pos + offset)
+          {
+            name: name,
+            transform: transform,
+            u_a: u_a
+          }
+        }
+        @num_models.times { |i|
+          if i == ( @num_models - 1 )
+            @sizes_models.push( @offset_texture - @offsets_models[i] )
+          else
+            @sizes_models.push( @offsets_models[i+1] - @offsets_models[i] )
+          end
+        }
+        @size_textures = f.size - @offset_texture
+        @models = @num_models.times.collect { |i|
+          f.seek(@offsets_models[i])
+          StringIO::new( f.read(@sizes_models[i]), "rb")
+        }
+        f.seek(@offset_texture)
+        @textures = StringIO::new( f.read(@size_textures), "rb")
+        @total_size = f.size
+        f.close if file_name_input
+      else
+        @id = "SCR\0".b
+        @num_models = 0
+        @offset_texture = 0
+        @size_textures = 0
+        @unknown = "\1\0\0\0".b
+        @offsets_models = []
+        @sizes_models = []
+        @models_metadata = []
+        @models = []
+        @textures = nil
+        @total_size = 0
+      end
+    end
+
+    def each_model
+      if block_given? then
+        @num_models.times { |i|
+          yield @models[i]
+        }
+      else
+        to_enum(:each_model)
+      end
+    end
+
+    def [](i)
+      return @models[i]
+    end
+
+    def invalidate_layout
+      @offsets_models = []
+      @offset_texture = 0
+      @total_size = 0
+      self
+    end
+
+    def compute_layout
+      current_offset = 0x10 + 0x8c * @num_models
+      @offsets_models = @num_models.times.collect { |i|
+         tmp = align(current_offset, ALIGNMENTS["wmb"])
+         current_offset = tmp + @sizes_models[i]
+         tmp
+      }
+      @offset_texture = align(current_offset, ALIGNMENTS["wtb"])
+      @total_size = @offset_texture + @size_textures
+      self
+    end
+
+    def push_model(file)
+      invalidate_layout
+      @models.push file
+      @sizes_models.push file.size
+      @num_models += 1
+      self
+    end
+
+    def textures=(file)
+      invalidate_layout
+      @textures = file
+      @size_textures = file.size
+      self
+    end
+
+    def textures
+      @textures
+    end
+
+    def dump(name)
+      compute_layout
+      uint = get_uint
+      File.open(name,"wb") { |f|
+        f.write("\0"*@total_size)
+        f.rewind
+        f.write([@id].pack("a4"))
+        f.write([@num_models].pack(uint))
+        f.write([@offset_texture].pack(uint))
+        f.write([@unknown].pack("a4"))
+        @num_models.times { |i|
+          pos = f.tell
+          f.write([@models_metadata[i][:name]].pack("a16"))
+          f.write([@offsets_models[i] - pos].pack(uint))
+          f.write(@models_metadata[i][:transform].pack("#{get_float}9"))
+          f.write(@models_metadata[i][:u_a].pack("#{get_short}42"))
+        }
+        @offsets_models.each_with_index { |off, i|
+          f.seek(off)
+          @models[i].rewind
+          f.write(@models[i].read)
+        }
+        f.seek(@offset_texture)
+        @textures.rewind
+        f.write(@textures.read)
+      }
+      self
+    end
+  end
+end

data/lib/bayonetta/tools/bxm_decoder.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+require_relative '../../bayonetta'
+include Bayonetta
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: bxm_decoder target_file
+  Decode the target bxm file into xml
+
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+input_file = ARGV[0]
+
+File::open(input_file, "rb") { |f|
+  bxm = BXMFile::load(f)
+  print bxm.to_xml
+}

data/lib/bayonetta/tools/bxm_encoder.rb

@@ -0,0 +1,37 @@
+require 'optparse'
+require 'nokogiri'
+require_relative '../../bayonetta'
+include Bayonetta
+
+options = {
+  tag: :BXM,
+  output: nil
+}
+
+opts = OptionParser.new do |parser|
+  parser.banner = <<EOF
+Usage: bxm_encoder [options] [XML_FILE]
+  Encode the pecified xml file int binary xml format. Unlessspecified
+  output will be along with the original file with a bxm extension.
+  If no file is given use stdin, but --output must be specified.
+EOF
+  parser.on("-t", "--tag TAG", [:XML, :BXM], "Select tag to use (BXM, XML) default BXM")
+  parser.on("-o", "--output filename", "Select output file name")
+end
+opts.parse!(into: options)
+
+tag = (options[:tag].to_s + "\0").b
+
+output_name = options[:output]
+if ARGV[0]
+  ouput_name = File.join(File.dirname(ARGV[0]), File.basename(ARGV[0], File.extname(ARGV[0])))+".bxm" unless output_name
+  input_file = File::open(ARGV[0], "rb")
+else
+  raise "unspecified output file" unless output_name
+  input_file = $stdin
+end
+
+bxm = BXMFile::from_xml(Nokogiri::XML(input_file.read), tag)
+bxm.dump(output_name)
+
+input_file.close if ARGV[0]

data/lib/bayonetta/tools/clh_convert.rb

@@ -0,0 +1,60 @@
+require 'optparse'
+require_relative '../../bayonetta'
+require 'yaml'
+include Bayonetta
+$bone_map = { }
+$options = {
+  remap_bones: false,
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: clh_convert target_file [options]
+  Convert a Bayonetta 2 _clh.bxm file to bayonetta format, optionally
+  remapping the bones, or remap a Bayonetta 1 clh file. By default
+  output will be in the ./clx_output folder.
+EOF
+
+  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
+    $options[:remap_bones] = true
+    if File::exist?(bone_lists)
+      $bone_map.merge! YAML::load_file(bone_lists)
+    else
+      lists = bone_lists.split("/")
+      p input_list = eval(lists.first).to_a
+      p output_list = eval(lists.last).to_a
+      $bone_map.merge! input_list.zip(output_list).to_h
+    end
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+$bone_map.merge!( { 4095 => 4095 } )
+
+Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
+
+input_file = ARGV[0]
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+
+if File.extname(ARGV[0]) == ".bxm"
+  raise "Invalid clh file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clh.bxm")
+  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clh.bxm",".clh")) unless output_file
+  clh = CLHFile::load_bxm(input_file)
+else
+  raise "Invalid clh file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clh")
+  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
+  clh = CLHFile::load(input_file)
+end
+clh.remap($bone_map) if $options[:remap_bones]
+clh.dump(output_file)

data/lib/bayonetta/tools/clp_convert.rb

@@ -0,0 +1,70 @@
+require 'optparse'
+require_relative '../../bayonetta'
+require 'yaml'
+include Bayonetta
+$bone_map = { }
+$options = {
+  remap_bones: false,
+  fix: true,
+  poly: true,
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: clp_convert target_file [options]
+  Convert a Bayonetta 2 _clp.bxm file to bayonetta format, optionally
+  remapping the bones, or remap a Bayonetta 1 clp file. By default
+  output will be in the ./clx_output folder.
+EOF
+
+  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
+    $options[:remap_bones] = true
+    if File::exist?(bone_lists)
+      $bone_map.merge! YAML::load_file(bone_lists)
+    else
+      lists = bone_lists.split("/")
+      p input_list = eval(lists.first).to_a
+      p output_list = eval(lists.last).to_a
+      $bone_map.merge! input_list.zip(output_list).to_h
+    end
+  end
+
+  opts.on("-f", "--[no-]fix", "Map no_fix values (default true)") do |fix|
+    $options[:fix] = fix
+  end
+
+  opts.on("-p", "--[no-]poly", "Map no_poly values (default true)") do |poly|
+    $options[:poly] = poly
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+$bone_map.merge!( { 4095 => 4095 } )
+
+Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
+
+input_file = ARGV[0]
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+
+if File.extname(ARGV[0]) == ".bxm"
+  raise "Invalid clp file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clp.bxm")
+  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clp.bxm",".clp")) unless output_file
+  clp = CLPFile::load_bxm(input_file)
+else
+  raise "Invalid clp file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clp")
+  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
+  clp = CLPFile::load(input_file)
+end
+clp.remap($bone_map, $options[:poly], $options[:fix]) if $options[:remap_bones]
+clp.dump(output_file)

data/lib/bayonetta/tools/clw_convert.rb

@@ -0,0 +1,60 @@
+require 'optparse'
+require_relative '../../bayonetta'
+require 'yaml'
+include Bayonetta
+$bone_map = { }
+$options = {
+  remap_bones: false,
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: clw_convert target_file [options]
+  Convert a Bayonetta 2 _clw.bxm file to bayonetta format, optionally
+  remapping the bones, or remap a Bayonetta 1 clw file. By default
+  output will be in the ./clx_output folder.
+EOF
+
+  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
+    $options[:remap_bones] = true
+    if File::exist?(bone_lists)
+      $bone_map.merge! YAML::load_file(bone_lists)
+    else
+      lists = bone_lists.split("/")
+      p input_list = eval(lists.first).to_a
+      p output_list = eval(lists.last).to_a
+      $bone_map.merge! input_list.zip(output_list).to_h
+    end
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+$bone_map.merge!( { -1 => -1 } )
+
+Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
+
+input_file = ARGV[0]
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+
+if File.extname(ARGV[0]) == ".bxm"
+  raise "Invalid clw file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clw.bxm")
+  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clw.bxm",".clw")) unless output_file
+  clw = CLWFile::load_bxm(input_file)
+else
+  raise "Invalid clw file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clw")
+  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
+  clw = CLWFile::load(input_file)
+end
+clw.remap($bone_map) if $options[:remap_bones]
+clw.dump(output_file)