path: root/game/src/Game/Model/XSMLoader.gd

class_name XSMLoader

# Keys: source_file (String)
# Values: loaded animation (Animation) or LOAD_FAILED_MARKER (StringName)
static var xsm_cache : Dictionary

const LOAD_FAILED_MARKER : StringName = &"XSM LOAD FAILED"

static func get_xsm_animation(source_file : String) -> Animation:
   var cached : Variant = xsm_cache.get(source_file)
   if not cached:
      cached = _load_xsm_animation(source_file)
      if cached:
         xsm_cache[source_file] = cached
      else:
         xsm_cache[source_file] = LOAD_FAILED_MARKER
         push_error("Failed to get XSM model \"", source_file, "\" (current load failed)")
         return null

   if not cached is Animation:
      push_error("Failed to get XSM model \"", source_file, "\" (previous load failed)")
      return null

   return cached

const SKELETON_PATH : String = "./skeleton:%s"

static func _load_xsm_animation(source_file : String) -> Animation:
   var source_path : String = GameSingleton.lookup_file_path(source_file)
   var file : FileAccess = FileAccess.open(source_path, FileAccess.READ)
   if file == null:
      push_error("Failed to load XSM ", source_file, " from looked up path ", source_path)
      return null

   readHeader(file)

   var metadataChunk : MetadataChunk = null
   var boneAnimationChunks : Array[BoneAnimationChunk] = []

   while file.get_position() < file.get_length():
      var type : int = FileAccessUtils.read_int32(file)
      var length : int = FileAccessUtils.read_int32(file)
      var version : int = FileAccessUtils.read_int32(file)

      match type:
         0xC9: #Metadata
            metadataChunk = readMetadataChunk(file)
         0xCA: #Bone Animation
            boneAnimationChunks.push_back(readBoneAnimationChunk(file, metadataChunk.use_quat_16()))
         _:
            push_error(">> INVALID XSM CHUNK TYPE %X" % type)
            break

   var animLength : float = 0.0
   var anim : Animation = Animation.new()
   for anim_Chunk : BoneAnimationChunk in boneAnimationChunks:
      for submotion : SkeletalSubMotion in anim_Chunk.SkeletalSubMotions:
         # NOTE: godot uses ':' to specify properties, so we replace such characters with '_'
         var skeleton_path : String = SKELETON_PATH % FileAccessUtils.replace_chars(submotion.nodeName)

         if submotion.numPosKeys > 0:
            var id : int = anim.add_track(Animation.TYPE_POSITION_3D)
            anim.track_set_path(id, skeleton_path)
            for key : PosKey in submotion.PosKeys:
               anim.position_track_insert_key(id, key.fTime, key.pos)
               if key.fTime > animLength:
                  animLength = key.fTime
         else: # EXPERIMENTAL: see if setting posePos fixes idle3
            var id : int = anim.add_track(Animation.TYPE_POSITION_3D)
            anim.track_set_path(id, skeleton_path)
            anim.position_track_insert_key(id, 0, submotion.posePos)

         if submotion.numRotKeys > 0:
            var id : int = anim.add_track(Animation.TYPE_ROTATION_3D)
            anim.track_set_path(id, skeleton_path)
            for key : RotKey in submotion.RotKeys:
               anim.rotation_track_insert_key(id, key.fTime, key.rot)
               if key.fTime > animLength:
                  animLength = key.fTime
         else: # EXPERIMENTAL: see if setting posePos fixes idle3
            var id : int = anim.add_track(Animation.TYPE_ROTATION_3D)
            anim.track_set_path(id, skeleton_path)
            anim.rotation_track_insert_key(id, 0, submotion.poseRot)

         if submotion.numScaleKeys > 0:
            var id : int = anim.add_track(Animation.TYPE_SCALE_3D)
            anim.track_set_path(id, skeleton_path)
            for key : ScaleKey in submotion.ScaleKeys:
               anim.scale_track_insert_key(id, key.fTime, key.scale)
               if key.fTime > animLength:
                  animLength = key.fTime

         # TODO: submotion.numScaleRotKeys

   anim.length = animLength
   anim.loop_mode = Animation.LOOP_LINEAR

   xsm_cache[source_file] = anim
   return anim

static func readHeader(file : FileAccess) -> void:
   var magic_bytes : PackedByteArray = [file.get_8(), file.get_8(), file.get_8(), file.get_8()]
   var magic : String = magic_bytes.get_string_from_ascii()
   var version : String = "%d.%d" % [file.get_8(), file.get_8()]
   var bBigEndian : bool = file.get_8()
   var pad : int = file.get_8()
   #print(magic, ", version: ", version, ", bigEndian: ", bBigEndian, " pad: ", pad)

# NOTE: the "pad" variable is actually very important!
# It seems to have something to do with whether paradox uses int16 or int32
# for quaternions (it's "pad" or version number, can't tell)

static func readMetadataChunk(file : FileAccess) -> MetadataChunk:
   return MetadataChunk.new(
      file.get_float(), file.get_float(), FileAccessUtils.read_int32(file),
      file.get_8(), file.get_8(), file.get_16(),
      FileAccessUtils.read_xac_str(file), FileAccessUtils.read_xac_str(file), FileAccessUtils.read_xac_str(file), FileAccessUtils.read_xac_str(file)
   )

class MetadataChunk:
   var unused : float
   var fMaxAcceptableError : float
   var fps : int # int32
   var exporterMajorVersion : int  # byte
   var exporterMinorVersion : int  # byte
   var pad : int # 2x byte
   var sourceApp : String
   var origFileName : String
   var exportDate : String
   var motionName : String

   func _init(
      unused : float,
      fMaxAcceptableError : float,
      fps : int,
      exporterMajorVersion : int,
      exporterMinorVersion : int,
      pad : int,
      sourceApp : String,
      origFileName : String,
      exportDate : String,
      motionName : String
   ) -> void:
      self.unused = unused
      self.fMaxAcceptableError = fMaxAcceptableError
      self.fps = fps
      self.exporterMajorVersion = exporterMajorVersion
      self.exporterMinorVersion = exporterMinorVersion
      self.pad = pad
      self.sourceApp = sourceApp
      self.origFileName = origFileName
      self.exportDate = exportDate
      self.motionName = motionName

   func debugPrint() -> void:
      print("FileName: %s, sourceApp: %s, exportDate: %s, ExporterV:%d.%d" %
         [origFileName, sourceApp, exportDate, exporterMajorVersion, exporterMinorVersion])
      print("MotionName: %s, fps: %d, MaxError: %s, Use 16-bit int Quaternions?:%s" %
         [motionName, fps, fMaxAcceptableError, use_quat_16()])

   func use_quat_16() -> bool:
      return pad == 0x0

static func readPosKey(file : FileAccess) -> PosKey:
   return PosKey.new(FileAccessUtils.read_pos(file), file.get_float())

class PosKey:
   var pos : Vector3
   var fTime : float

   func _init(pos : Vector3, fTime : float) -> void:
      self.pos = pos
      self.fTime = fTime

   func debugPrint() -> void:
      print("\t\tPos:%s, time:%s" % [pos, fTime])

static func readRotKey(file : FileAccess, use_quat16 : bool) -> RotKey:
   return RotKey.new(FileAccessUtils.read_quat(file, use_quat16), file.get_float())

class RotKey:
   var rot : Quaternion
   var fTime : float

   func _init(rot : Quaternion, fTime : float) -> void:
      self.rot = rot
      self.fTime = fTime

   func debugPrint() -> void:
      print("\t\tRot:%s, time:%s" % [rot, fTime])

static func readScaleKey(file : FileAccess) -> ScaleKey:
   return ScaleKey.new(FileAccessUtils.read_vec3(file), file.get_float())

class ScaleKey:
   var scale : Vector3
   var fTime : float

   func _init(scale : Vector3, fTime : float) -> void:
      self.scale = scale
      self.fTime = fTime

   func debugPrint() -> void:
      print("\t\tScale:%s, time:%s" % [scale, fTime])

static func readScaleRotKey(file : FileAccess, use_quat16 : bool) -> ScaleRotKey:
   return ScaleRotKey.new(FileAccessUtils.read_quat(file, use_quat16), file.get_float())

class ScaleRotKey:
   var rot : Quaternion
   var fTime : float

   func _init(rot : Quaternion, fTime : float) -> void:
      self.rot = rot
      self.fTime = fTime

   func debugPrint() -> void:
      print("\t\tScaleRot:%s, time:%s" % [rot, fTime])

static func readSkeletalSubMotion(file : FileAccess, use_quat16 : bool) -> SkeletalSubMotion:
   var a : Quaternion = FileAccessUtils.read_quat(file, use_quat16)
   var b : Quaternion = FileAccessUtils.read_quat(file, use_quat16)
   var c : Quaternion = FileAccessUtils.read_quat(file, use_quat16)
   var d : Quaternion = FileAccessUtils.read_quat(file, use_quat16)

   var e : Vector3 = FileAccessUtils.read_pos(file)
   var f : Vector3 = FileAccessUtils.read_vec3(file)
   var g : Vector3 = FileAccessUtils.read_pos(file)
   var h : Vector3 = FileAccessUtils.read_vec3(file)

   var p : int = FileAccessUtils.read_int32(file)
   var j : int = FileAccessUtils.read_int32(file)
   var k : int = FileAccessUtils.read_int32(file)
   var l : int = FileAccessUtils.read_int32(file)

   var m : float = file.get_float()
   var n : String = FileAccessUtils.read_xac_str(file)

   var submotion : SkeletalSubMotion = SkeletalSubMotion.new(
      a, b, c, d, # quats
      e, f, g, h, # vec3
      p, j, k, l, # ints
      m, n
   )
   var poskeys : Array[PosKey] = []
   var rotkeys : Array[RotKey] = []
   var scalekeys : Array[ScaleKey] = []
   var scalerotkeys : Array[ScaleRotKey] = []
   #FIXME: Did paradox store the number of pos keys as a float instead of int?

   for i : int in submotion.numPosKeys:
      poskeys.push_back(readPosKey(file))
   for i : int in submotion.numRotKeys:
      rotkeys.push_back(readRotKey(file, use_quat16))
   for i : int in submotion.numScaleKeys:
      scalekeys.push_back(readScaleKey(file))
   for i : int in submotion.numScaleRotKeys:
      scalerotkeys.push_back(readScaleRotKey(file, use_quat16))
   submotion.setPosKeys(poskeys)
   submotion.setRotKeys(rotkeys)
   submotion.setScaleKeys(scalekeys)
   submotion.setScaleRotKeys(scalerotkeys)
   return submotion

class SkeletalSubMotion:
   var poseRot : Quaternion
   var bindPoseRot : Quaternion
   var poseScaleRot : Quaternion
   var bindPoseScaleRot : Quaternion
   var posePos : Vector3
   var poseScale : Vector3
   var bindPosePos : Vector3
   var bindPoseScale : Vector3
   var numPosKeys : int # int32
   var numRotKeys : int # int32
   var numScaleKeys : int # int32
   var numScaleRotKeys : int # int32
   var fMaxError : float
   var nodeName : String

   var PosKeys : Array[PosKey]
   var RotKeys : Array[RotKey]
   var ScaleKeys : Array[ScaleKey]
   var ScaleRotKeys : Array[ScaleRotKey]

   func _init(
      poseRot : Quaternion,
      bindPoseRot : Quaternion,
      poseScaleRot : Quaternion,
      bindPoseScaleRot : Quaternion,
      posePos : Vector3,
      poseScale : Vector3,
      bindPosePos : Vector3,
      bindPoseScale : Vector3,
      numPosKeys : int,
      numRotKeys : int,
      numScaleKeys : int,
      numScaleRotKeys : int,
      fMaxError : float,
      nodeName : String
   ) -> void:
      self.poseRot = poseRot
      self.bindPoseRot = bindPoseRot
      self.poseScaleRot = poseScaleRot
      self.bindPoseScaleRot = bindPoseScaleRot
      self.posePos = posePos
      self.poseScale = poseScale
      self.bindPosePos = bindPosePos
      self.bindPoseScale = bindPoseScale
      self.numPosKeys = numPosKeys
      self.numRotKeys = numRotKeys
      self.numScaleKeys = numScaleKeys
      self.numScaleRotKeys = numScaleRotKeys
      self.fMaxError = fMaxError
      self.nodeName = nodeName

   func setPosKeys(PosKeys : Array[PosKey]) -> void:
      self.PosKeys = PosKeys

   func setRotKeys(RotKeys : Array[RotKey]) -> void:
      self.RotKeys = RotKeys

   func setScaleKeys(ScaleKeys : Array[ScaleKey]) -> void:
      self.ScaleKeys = ScaleKeys

   func setScaleRotKeys(ScaleRotKeys : Array[ScaleRotKey]) -> void:
      self.ScaleRotKeys = ScaleRotKeys

   func debugPrint() -> void:
      print("Node: %s, #PosKeys %d, #RotKeys %d, #ScaleKeys %d, #ScaleRotKeys %d" % [nodeName, numPosKeys, numRotKeys, numScaleKeys, numScaleRotKeys])
      print("\tposeScaleRot %s,\tbindPoseScaleRot %s,\tposeScale %s,\tbindPoseScale %s" % [poseScaleRot, bindPoseScaleRot, poseScale, bindPoseScale])
      for key : PosKey in PosKeys:
         key.debugPrint()
      for key : RotKey in RotKeys:
         key.debugPrint()
      for key : ScaleKey in ScaleKeys:
         key.debugPrint()
      for key : ScaleRotKey in ScaleRotKeys:
         key.debugPrint()

static func readBoneAnimationChunk(file : FileAccess, use_quat16 : bool) -> BoneAnimationChunk:
   var numSubMotions : int = FileAccessUtils.read_int32(file)
   var animChunk : BoneAnimationChunk = BoneAnimationChunk.new(numSubMotions)
   var submotions : Array[SkeletalSubMotion] = []
   for i : int in animChunk.numSubMotions:
      submotions.push_back(readSkeletalSubMotion(file, use_quat16))
   animChunk.setSkeletalSubMotions(submotions)
   return animChunk

class BoneAnimationChunk:
   var numSubMotions : int # int32
   var SkeletalSubMotions : Array[SkeletalSubMotion]

   func _init(numSubMotions : int) -> void:
      self.numSubMotions = numSubMotions

   func setSkeletalSubMotions(SkeletalSubMotions : Array[SkeletalSubMotion]) -> void:
      self.SkeletalSubMotions = SkeletalSubMotions

   func debugPrint() -> void:
      print("Number of Submotions: %d" % numSubMotions)
      for submotion : SkeletalSubMotion in SkeletalSubMotions:
         submotion.debugPrint()