pgtools 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7e36398b3fbef0f7e869fce605df24a9cd6e22ac5c6b391f49254474d129d942
+  data.tar.gz: 92d27315789a8c08f6dcefa721bf32a1af992bb4b848e1597b402494208bbe5e
+SHA512:
+  metadata.gz: 904a07ac609d5d594d80f94e9611dd48ac747dca93407188081e1e678b82a0084592d039cfbad5082670223e09a068ae844fd2b536b148fcad6ace8eb54f2a62
+  data.tar.gz: 2767aca08e04ec6a22de97726bd482c59d90aeea08349a102902139c80e6168ab5032443d043da2664c519be935714f4293dc77900c615d7cdbc7e7d07e60d2e

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017-2021, Brice Videau
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/bin/bxm_decoder

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/bxm_decoder'

data/bin/bxm_encoder

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/bxm_encoder'

data/bin/clh_convert

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/clh_convert'

data/bin/clp_convert

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/clp_convert'

data/bin/clw_convert

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/clw_convert'

data/bin/dat_creator

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/dat_creator'

data/bin/dat_extractor

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/dat_extractor'

data/bin/dat_ls

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/dat_ls'

data/bin/eff_idd_creator

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/eff_idd_creator'

data/bin/eff_idd_extractor

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/eff_idd_extractor'

data/bin/exp_convert_wiiu_pc

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/exp_convert_wiiu_pc'

data/bin/exp_tool

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/exp_tool'

data/bin/mot_convert_wiiu_pc

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/mot_convert_wiiu_pc'

data/bin/mot_tool

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/mot_tool'

data/bin/pkz_extractor

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/pkz_extractor'

data/bin/scr_creator

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/scr_creator'

data/bin/scr_extractor

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/scr_extractor'

data/bin/wmb_cleanup

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_cleanup'

data/bin/wmb_common_bones

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_common_bones'

data/bin/wmb_convert_pc_switch

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_convert_pc_switch'

data/bin/wmb_convert_wiiu_pc

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_convert_wiiu_pc'

data/bin/wmb_export_assimp

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_export_assimp'

data/bin/wmb_get_bone_map

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_get_bone_map'

data/bin/wmb_import_assimp

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_import_assimp'

data/bin/wmb_import_nier

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_import_nier'

data/bin/wmb_import_wiiu

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wmb_import_geometry_wiiu_pc'

data/bin/wtb_convert_wiiu_pc

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wtb_convert_wiiu_pc'

data/bin/wtx_creator

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wtx_creator'

data/bin/wtx_extractor

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'bayonetta/tools/wtx_extractor'

data/lib/bayonetta/alignment.rb

@@ -0,0 +1,14 @@
+module Bayonetta
+
+  module Alignment
+
+    def align(val, alignment)
+      remainder = val % alignment
+      val += alignment - remainder if remainder > 0
+      val
+    end
+    private :align
+
+  end
+
+end

data/lib/bayonetta/bone.rb

@@ -0,0 +1,55 @@
+module Bayonetta
+
+  class Bone
+    attr_accessor :parent
+    attr_accessor :children
+    attr_accessor :index
+    attr_accessor :position
+    attr_accessor :relative_position
+    attr_accessor :symmetric
+    attr_accessor :flag
+    def initialize( position )
+      @position = position
+      @children = []
+      @parent = nil
+      @relative_position = nil
+      @symmetric = nil
+      @flag = nil
+      @index = nil
+    end
+
+    def depth
+      if parent then
+        return parent.depth + 1
+      else
+        return 0
+      end
+    end
+
+    def to_s
+      "<#{@index}#{@parent ? " (#{@parent.index})" : ""}: #{@position.x}, #{@position.y}, #{@position.z}, d: #{depth}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def distance(other)
+      d = (@position.x - other.position.x)**2 +
+          (@position.y - other.position.y)**2 +
+          (@position.z - other.position.z)**2
+      d = Math::sqrt(d)
+      dd = (depth - other.depth).abs
+      [d, dd]
+    end
+
+    def parents
+      return [] unless parent
+      return [parent] + parent.parents
+    end
+
+  end
+
+end
+
+

data/lib/bayonetta/bxm.rb

@@ -0,0 +1,180 @@
+require 'nokogiri'
+require 'set'
+
+module Bayonetta
+#=begin
+  class BXMFile < LibBin::Structure
+
+    class Datum < LibBin::Structure
+      uint16 :name_offset
+      int16 :value_offset
+    end
+
+    class Node < LibBin::Structure
+      uint16 :child_count
+      uint16 :first_child_index
+      uint16 :attribute_count
+      uint16 :datum_index
+    end
+
+    class Header < LibBin::Structure
+      string :id, 4
+      uint32 :unknown
+      uint16 :node_count
+      uint16 :datum_count
+      uint32 :data_size
+    end
+
+    register_field :header, Header
+    register_field :nodes, Node, count: 'header\node_count'
+    register_field :datums, Datum, count: 'header\datum_count'
+    string :data, 'header\data_size'
+
+    def get_data_strings
+      io = StringIO::new(data, "rb")
+      pos = 0
+      data_strings = {-1 => nil}
+      while (l = io.gets("\0"))
+        data_strings[pos] = l.unpack("Z*").first
+        pos = io.tell
+      end
+      data_strings
+    end
+
+    def get_datas
+      data_strings = get_data_strings
+      datums.collect { |d| [data_strings[d.name_offset], data_strings[d.value_offset]] }
+    end
+
+    def build_xml_tree(doc, index, datas)
+      node = nodes[index]
+      name, value = datas[node.datum_index]
+      n = Nokogiri::XML::Node.new(name, doc)
+      n.content = value if value
+      node.attribute_count.times { |i|
+        name, value = datas[node.datum_index + i + 1]
+        n[name] = value
+      }
+      node.child_count.times { |i|
+        n << build_xml_tree(doc, node.first_child_index + i, datas)
+      }
+      n
+    end
+
+    def to_xml
+      datas = get_datas
+      doc = Nokogiri::XML::Document::new
+      doc << build_xml_tree(doc, 0, datas) if header.node_count > 0
+      doc
+    end
+
+    def process_node(node, index, next_node_index)
+      name = node.name
+      children = node.elements
+      value = node.content if children.empty?
+      value = value.strip if value
+      value = nil if value == ''
+      attributes = node.attributes
+
+      n = Node.new
+      n.child_count = children.size
+      n.first_child_index = next_node_index
+      n.attribute_count = attributes.size
+      nodes[index] = n
+
+      node_datums = [[name, value]]
+      attributes.each { |k, v| node_datums.push [k, v.value] }
+      datum_index = datums.each_cons(node_datums.size).find_index { |sub| sub == node_datums }
+      if datum_index
+        n.datum_index = datum_index
+      else
+        n.datum_index = datums.size
+        datums.push *node_datums
+        node_datums.flatten.each { |v| data.add v if v }
+      end
+      next_node_index += children.size
+      children.each_with_index { |c, i|
+        next_node_index = process_node(c, n.first_child_index + i, next_node_index)
+      }
+      next_node_index
+    end
+
+    def from_xml(xml, tag)
+      @header = Header.new
+      @nodes = []
+      @datums = []
+      @data = Set.new
+      header.id = tag
+      header.unknown = 0
+      process_node(xml.children.first, 0, 1)
+      header.node_count = nodes.length
+      header.datum_count = datums.length
+      io = StringIO::new("", "wb")
+      data_map = data.collect { |d|
+        pos = io.tell
+        io.write(d, "\0")
+        [d, pos]
+      }.to_h
+      data_map[nil] = -1
+      datums.collect! { |n, v|
+        d = Datum.new
+        d.name_offset = data_map[n]
+        d.value_offset = data_map[v]
+        d
+      }
+      @data = io.string
+      header.data_size = data.bytesize
+      self
+    end
+
+    def self.from_xml(xml, tag="BXM\x00".b)
+      bxm = self.new
+      bxm.from_xml(xml, tag)
+    end
+
+    def self.is_big?(f)
+      true
+    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
+      tag = input.read(4).unpack("a4").first
+      raise "invalid file type #{tag}!" if tag != "XML\x00".b && tag != "BXM\x00".b
+      input.rewind
+      bxm = self.new
+      big = input_big = is_big?(input)
+      bxm.instance_variable_set(:@__was_big, big)
+      bxm.__load(input, big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      bxm
+    end
+
+    def dump(output_name, output_big = true)
+      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = StringIO::new("".b, "wb")
+      end
+
+      __set_dump_state(output, 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

data/lib/bayonetta/clh.rb

@@ -0,0 +1,159 @@
+module Bayonetta
+
+  class CLHFile < 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 ClothAT < LibBin::Structure
+      int16 :p1
+      int16 :p2
+      float :weight
+      float :radius
+      register_field :offset1, FVector
+      register_field :offset2, FVector
+
+      def from_bxm_cloth_at(h)
+        @p1 = h.at_css("p1").content.to_i
+        @p2 = h.at_css("p2").content.to_i
+        @weight = h.at_css("weight").content.to_f
+        @radius = h.at_css("radius").content.to_f
+        @offset1 = FVector.from_bxm_vector(h.at_css("offset1").content)
+        @offset2 = FVector.from_bxm_vector(h.at_css("offset2").content)
+        self
+      end
+
+      def self.from_bxm_cloth_at(c)
+        clat = self::new
+        clat.from_bxm_cloth_at(c)
+        clat
+      end
+
+      def remap(map)
+        @p1 = check_and_remap_bone(map, @p1)
+        @p2 = check_and_remap_bone(map, @p2)
+      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_at_num
+    register_field :cloth_at, ClothAT, count: 'cloth_at_num'
+
+    def was_big?
+      @__was_big
+    end
+
+    def remap(map)
+      @cloth_at.each { |c|
+        c.remap(map)
+      }
+    end
+
+    def self.load_bxm(input_name)
+      bxm = BXMFile::load(input_name)
+      clat = self::new
+
+      doc = bxm.to_xml
+      clat.cloth_at_num = doc.at_css("//CLOTH_AT//CLOTH_AT_NUM").content.to_i
+
+      clat.cloth_at = doc.css("//CLOTH_AT//CLOTH_AT_WK").collect { |c|
+        ClothAT.from_bxm_cloth_at(c)
+      }
+      clat
+    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