pgtools 1.0.0

data/lib/bayonetta/tools/scr_creator.rb

@@ -0,0 +1,63 @@
+require 'optparse'
+require 'yaml'
+require_relative '../../bayonetta'
+
+$options = {
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: scr_creator target_directory
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+input_dir = ARGV[0]
+
+raise "Not a directory: #{input_dir}!" unless input_dir && File.directory?(input_dir)
+
+pwd = Dir.pwd
+Dir.chdir(input_dir)
+Dir.mkdir("scr_output") unless Dir.exist?("scr_output")
+
+big = YAML::load_file(".metadata/big.yaml")
+bayo2 = YAML::load_file(".metadata/bayo2.yaml")
+
+if bayo2
+  scr = Bayonetta::SCR2File::new(nil, big)
+else
+  scr = Bayonetta::SCRFile::new(nil, big)
+end
+
+scr.models_metadata = YAML::load_file(".metadata/models_metadata.yaml")
+scr.unknown = YAML::load_file(".metadata/unknown.yaml")
+
+files = Dir.entries(".")
+models = files.select { |name| name.match "wmb" }
+models.sort!
+textures = files.select { |name| name.match "wtb" }.first
+
+models.each { |name|
+  scr.push_model(File::new(name, "rb"))
+}
+
+scr.textures = File::new("000.wtb", "rb") unless bayo2
+
+output_file = $options[:output]
+if !output_file
+  Dir.mkdir("scr_output") unless Dir.exist?("scr_output")
+  Dir.chdir("scr_output")
+  output_file = "#{File.basename(input_dir).gsub("_scr", ".scr")}"
+else
+  Dir.chdir(pwd)
+end
+
+scr.dump(output_file)

data/lib/bayonetta/tools/scr_extractor.rb

@@ -0,0 +1,78 @@
+require 'optparse'
+require 'yaml'
+require_relative '../../bayonetta'
+
+$options = {
+  output: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: scr_extractor file
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=dirname", "directory to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+save_pwd = Dir.pwd
+
+raise "Invalid output directory #{$options[:output]}" if $options[:output] && !Dir.exist?($options[:output])
+
+filename = ARGV[0]
+raise "Invalid file: #{filename}!" unless filename && File.exist?(filename)
+directory = File.dirname(filename)
+name = File.basename(filename)
+ext_name = File.extname(name)
+
+raise "Invalid file: #{filename}!" unless ext_name == ".scr"
+
+f = File::open(filename, "rb")
+
+if $options[:output]
+  Dir.chdir(save_pwd)
+  Dir.chdir($options[:output])
+else
+  Dir.chdir(directory)
+end
+dir_name = File.basename(name, ext_name) + "#{ext_name.gsub(".","_")}"
+Dir.mkdir(dir_name) unless Dir.exist?(dir_name)
+Dir.chdir(dir_name)
+
+scr = Bayonetta::SCRFile::load(f)
+
+scr.each_model.each_with_index { |f1, i|
+  File::open("%03d.wmb" % [i] , "wb") { |f2|
+    f1.rewind
+    f2.write(f1.read)
+  }
+}
+
+f1 = scr.textures
+if f1
+  File::open("000.wtb", "wb") { |f2|
+    f1.rewind
+    f2.write(f1.read)
+  }
+end
+
+Dir.mkdir(".metadata") unless Dir.exist?(".metadata")
+Dir.chdir(".metadata")
+File::open("models_metadata.yaml", "w") { |fl|
+  fl.print YAML::dump( scr.models_metadata )
+}
+File::open("big.yaml","w") { |fl|
+  fl.print YAML::dump( scr.big )
+}
+File::open("bayo2.yaml","w") { |fl|
+  fl.print YAML::dump( scr.bayo2? )
+}
+File::open("unknown.yaml", "w") { |fl|
+  fl.print YAML::dump( scr.unknown )
+}

data/lib/bayonetta/tools/wmb_cleanup.rb

@@ -0,0 +1,250 @@
+require 'optparse'
+require 'yaml'
+require_relative '../../bayonetta'
+include Bayonetta
+
+$options = {
+  :vertexes => false,
+  :bones => false,
+  :remap_bones => false,
+  :textures => false,
+  :cleanup_mat => false,
+  :cleanup_mat_sizes => false,
+  :maximize_mat_sizes => false,
+  :delete_bones => nil,
+  :offsets => false,
+  :fix => false,
+  :swap => nil,
+  :swap_meshes => nil,
+  :move_meshes => nil,
+  :delete_meshes => nil,
+  :delete_batches => nil,
+  :merge_meshes => nil,
+  :overwrite => nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: wmb_cleanup.rb target_file [options]"
+
+  opts.on("--[no-]bone-refs", "Cleanup bone refs in batches") do |bone_refs|
+    $options[:bone_refs] = bone_refs
+  end
+
+  opts.on("--[no-]add-parents-bone-refs", "Add ancestry to bone refs and sort them") do |bone_refs|
+    $options[:submodel_bone_refs] = bone_refs
+  end
+
+  opts.on("--[no-]add-previous-bone-refs", "Add all previous bones to bone refs and sort them") do |bone_refs|
+    $options[:previous_bone_refs] = bone_refs
+  end
+
+  opts.on("-b", "--[no-]bones", "Cleanup bones") do |bones|
+    $options[:bones] = bones
+  end
+
+  opts.on("--remap-bones=BONEMAP", "Remaps specified local bones to global bone indexes") do |bone_map|
+    if File.exist?(bone_map)
+      $options[:remap_bones] = YAML::load_file(bone_map)
+    else
+      $options[:remap_bones] = eval(bone_map).to_h
+    end
+  end
+
+  opts.on("--[no-]order-bones", "Order bones in their global numbering if possible") do |order_bones|
+    $options[:order_bones] = order_bones
+  end
+
+  opts.on("-v", "--[no-]vertexes", "Cleanup vertexes") do |vertexes|
+    $options[:vertexes] = vertexes
+  end
+
+  opts.on("--[no-]remove_duplicate_vertexes", "Ensure no vertex is used more than once") do |rdv|
+    $options[:remove_duplicate_vertexes] = rdv
+  end
+
+  opts.on("--[no-]normalize-vertex-usage", "Ensure no vertex is used in more than 1 batch") do |nvu|
+    $options[:normalize_vertex_usage] = nvu
+  end
+
+  opts.on("-o", "--[no-]remove-batch-offsets", "Remove batch vertex offsets") do |o|
+    $options[:offsets] = o
+  end
+
+  opts.on("--[no-]check-normals", "Try to detect wide normals (Switch)") do |cn|
+    $options[:check_normals] = cn
+  end
+
+  opts.on("-f", "--[no-]fix-ex-data", "Put normal map u v in ex data") do |fix|
+    $options[:fix] = fix
+  end
+
+  opts.on("--copy-uv1to2=MESHLIST", "Copy the first UV mapping to the second one") do |copy_uv|
+    $options[:copy_uv] = eval(copy_uv).to_a
+  end
+
+  opts.on("--[no-]remove-triangle-strips", "Remove triangle strips and replace by triangles") do |strips|
+    $options[:strips] = strips
+  end
+
+  opts.on("--revert-triangles=MESHLIST", "Revert traiangle faces") do |revert|
+    $options[:revert] = eval(revert).to_a
+  end
+
+  opts.on("-e", "--swap-endianness", "Swap endianness") do |swap|
+    $options[:swap] = swap
+  end
+
+  opts.on("--duplicate-meshes=MESHLIST", "Duplicate specified meshes") do |mesh_list|
+    $options[:duplicate_meshes] = eval(mesh_list).to_a
+  end
+
+  opts.on("-s", "--swap-meshes=MESHHASH", "Swap specified meshes") do |mesh_hash|
+    $options[:swap_meshes] = eval(mesh_hash).to_h
+  end
+
+  opts.on("--merge-meshes=MESHHASH", "Merge specified meshes") do |mesh_hash|
+    $options[:merge_meshes] = eval(mesh_hash).to_h
+  end
+
+  opts.on("--move-meshes=MESHHASH", "Move the specified meshes to the specified positions") do |mesh_positions|
+    $options[:move_meshes] = eval(mesh_positions).to_h
+  end
+
+  opts.on("-m", "--delete-meshes=MESHLIST", "Delete specified meshes") do |mesh_list|
+    $options[:delete_meshes] = eval(mesh_list).to_a
+  end
+
+  opts.on("--delete-batches=BATCHLIST", "Delete specified batch list (WMB3) or { mesh => batch list } hash") do |batch_list|
+    $options[:delete_batches] = eval(batch_list).to_a
+  end
+
+  opts.on("--dummy=MESHHLIST", "Replace a given meshes by dummy mesh with one dummy batch") do |mesh_list|
+    $options[:dummy_meshes] = eval(mesh_list).to_a
+  end
+
+  opts.on("--split-meshes=MESHLIST", "Split the selected meshes into meshes containing only one batch") do |split_meshes|
+    $options[:split_meshes] = eval(split_meshes).to_a
+  end
+
+  opts.on("-d", "--delete-bones=BONELIST", "Delete specified bones") do |bone_list|
+    $options[:delete_bones] = eval(bone_list).to_a
+  end
+
+  opts.on("-t", "--[no-]textures", "Cleanup textures") do |textures|
+    $options[:textures] = textures
+  end
+
+  opts.on("-c", "--cleanup-materials", "Cleanup materials") do |cleanup_mat|
+    $options[:cleanup_mat] = cleanup_mat
+  end
+
+  opts.on("--cleanup-material-sizes", "Cleanup material sizes") do |cleanup_mat_sizes|
+    $options[:cleanup_mat_sizes] = cleanup_mat_sizes
+  end
+
+  opts.on("--maximize-material-sizes", "Maximize material sizes") do |maximize_mat_sizes|
+    $options[:maximize_mat_sizes] = maximize_mat_sizes
+  end
+
+  opts.on("--overwrite", "Overwrite input file") do |overwrite|
+    $options[:overwrite] = overwrite
+  end
+
+  opts.on("--scale=SCALE", "Scales the model by a factor") do |scale|
+    $options[:scale] = scale.to_f
+  end
+
+  opts.on("--shift=SHIFT_VECTOR", "Shifts the model") do |shift|
+    $options[:shift] = eval(shift).to_a
+  end
+
+  opts.on("--reverse-tangents-byte-order=MESH_LIST", "Fixes the tangents import that was buggy, only use on bayo 2 imported meshes...") do |tan|
+    $options[:reverse_tangents] = eval(tan).to_a
+  end
+
+  opts.on("--[no-]recompute-relative-positions", "Recomputes relative bone positions...") do |recomp|
+    $options[:recompute_relative_positions] = recomp
+  end
+
+  opts.on("--set-pose=POSE_FILE", "Set model to the given pose") do |pose|
+    $options[:set_pose] = YAML::load_file(pose)
+  end
+
+  opts.on("--[no-]set-t-pose", "Set the model to a t pose (WMB3)") do |tpose|
+    $options[:set_tpose] = tpose
+  end
+
+  opts.on("--rotate=ROTATE_INFO", "Rotates the model.",
+                                  "  ROTATE_INFO is either:",
+                                  "    [rx, ry, rz] rotation (in radian) respectively around the x, y and z axis (in this order)",
+                                  "    [[rx, ry, rz], [x, y, z]] with the center of the rotation specified" ) do |rotate|
+    $options[:rotate] = eval(rotate).to_a
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+
+input_file = ARGV[0]
+
+raise "Invalid file: #{input_file}" unless input_file && File::file?(input_file)
+Dir.mkdir("wmb_output") unless Dir.exist?("wmb_output")
+Dir.mkdir("wtb_output") unless Dir.exist?("wtb_output")
+wmb = WMBFile::load(input_file)
+wmb.check_normals if $options[:check_normals]
+wmb.scale($options[:scale]) if $options[:scale]
+wmb.rotate(*($options[:rotate])) if $options[:rotate]
+wmb.shift(*($options[:shift])) if $options[:shift]
+wmb.delete_batches($options[:delete_batches]) if $options[:delete_batches]
+wmb.split_meshes($options[:split_meshes]) if $options[:split_meshes]
+wmb.duplicate_meshes($options[:duplicate_meshes]) if $options[:duplicate_meshes]
+wmb.move_meshes($options[:move_meshes]) if $options[:move_meshes]
+wmb.swap_meshes($options[:swap_meshes]) if $options[:swap_meshes]
+wmb.merge_meshes($options[:merge_meshes]) if $options[:merge_meshes]
+wmb.dummy_meshes($options[:dummy_meshes]) if $options[:dummy_meshes]
+wmb.delete_meshes($options[:delete_meshes]) if $options[:delete_meshes]
+wmb.cleanup_bone_refs if $options[:bone_refs]
+wmb.add_ancestors_bone_refs if $options[:submodel_bone_refs]
+wmb.add_previous_bone_refs if $options[:previous_bone_refs]
+wmb.cleanup_bones if $options[:bones]
+wmb.recompute_relative_positions if $options[:recompute_relative_positions]
+wmb.remove_duplicate_vertexes if $options[:remove_duplicate_vertexes]
+wmb.normalize_vertex_usage if $options[:normalize_vertex_usage]
+wmb.remove_triangle_strips if $options[:strips]
+wmb.revert_triangles($options[:revert]) if $options[:revert]
+wmb.cleanup_vertexes if $options[:vertexes]
+wmb.remove_batch_vertex_offsets if $options[:offsets]
+wmb.fix_ex_data if $options[:fix]
+wmb.copy_uv12($options[:copy_uv]) if $options[:copy_uv]
+wmb.reverse_tangents_byte_order($options[:reverse_tangents]) if $options[:reverse_tangents]
+if $options[:set_pose]
+  exp_name = input_file.gsub(".wmb", ".exp")
+  exp = nil
+  if File::file?(exp_name)
+    exp = EXPFile::load(exp_name)
+  end
+  wmb.set_pose($options[:set_pose], exp)
+end
+if $options[:set_tpose]
+  wmb.set_tpose
+end
+wmb.delete_bones($options[:delete_bones]) if $options[:delete_bones]
+wmb.remap_bones($options[:remap_bones]) if $options[:remap_bones]
+wmb.order_bones if $options[:order_bones]
+wmb.cleanup_materials if $options[:cleanup_mat]
+wmb.cleanup_material_sizes if $options[:cleanup_mat_sizes]
+wmb.maximize_material_sizes if $options[:maximize_mat_sizes]
+wmb.cleanup_textures(input_file, $options[:overwrite]) if $options[:textures]
+unless wmb.class == WMB3File
+  wmb.renumber_batches
+end
+wmb.recompute_layout
+if $options[:overwrite]
+  wmb.dump(input_file, $options[:swap] ? !wmb.was_big? : wmb.was_big? )
+else
+  wmb.dump("wmb_output/"+File.basename(input_file), $options[:swap] ? !wmb.was_big? : wmb.was_big? )
+end

data/lib/bayonetta/tools/wmb_common_bones.rb

@@ -0,0 +1,45 @@
+require 'set'
+require 'yaml'
+require 'optparse'
+require_relative '../../bayonetta'
+include Bayonetta
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: wmb_common_bones target_file [target_file2 ...]
+  This script finds the common bones between a list of models.
+  This was used to find the minimal skeleton.
+  Target files should be dat files or wmb files.
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+bone_set = Set::new
+bone_set.merge((0..0xfff).to_a)
+found = false
+ARGV.each { |input_file|
+  raise "Invalid file #{input_file}" unless File::file?(input_file)
+  if File.extname(input_file) == ".dat"
+    search = File.basename(input_file, ".dat")+".wmb"
+    wmb = DATFile::load(input_file).each.select { |name, f|
+      name == search
+    }.first
+    if !wmb
+      warn "Could not find #{search} in #{File.basename(input_file)}"
+      next
+    end
+    wmb = wmb[1]
+    wmb = WMBFile::load(wmb)
+  else
+    wmb = WMBFile::load(input_file)
+  end
+  found = true
+  tt = wmb.bone_index_translate_table.table
+  bone_set &= tt.collect{ |mot_index, bone_index| mot_index }
+}
+
+puts YAML::dump(bone_set.to_a) if found

data/lib/bayonetta/tools/wmb_convert_pc_switch.rb

@@ -0,0 +1,35 @@
+require 'optparse'
+require_relative '../../bayonetta.rb'
+include Bayonetta
+
+$options = {
+  output: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: wmb_convert_pc_switch target_file
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+input_file = ARGV[0]
+
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+wmb = WMBFile::load(input_file)
+wmb.normals_to_wide
+
+output_file = $options[:output]
+if !output_file
+  Dir.mkdir("wmb_output") unless Dir.exist?("wmb_output")
+  output_file = File.join("wmb_output", File.basename(input_file))
+end
+wmb.dump(output_file, wmb.was_big?)

data/lib/bayonetta/tools/wmb_convert_wiiu_pc.rb

@@ -0,0 +1,33 @@
+require 'optparse'
+require_relative '../../bayonetta'
+include Bayonetta
+
+$options = {
+  output: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: wmb_convert_wiiu_pc target_file
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+input_file = ARGV[0]
+
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+if !output_file
+  Dir.mkdir("wmb_output") unless Dir.exist?("wmb_output")
+  output_file = File.join("wmb_output", File.basename(input_file))
+end
+WMBFile::convert(input_file, output_file)