;;-*-Lisp-*-
(in-package goal)

;; definition of type joint
(deftype joint (basic)
  ((name      basic          :offset-assert   4)
   (number    int32          :offset-assert   8)
   (parent    joint          :offset-assert  12)
   (bind-pose matrix :inline :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x50
  :flag-assert         #x900000050
  )

;; definition for method 3 of type joint
(defmethod inspect joint ((obj joint))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tname: ~A~%" (-> obj name))
  (format #t "~1Tnumber: ~D~%" (-> obj number))
  (format #t "~1Tparent: ~A~%" (-> obj parent))
  (format #t "~1Tbind-pose: #<matrix @ #x~X>~%" (-> obj bind-pose))
  (label cfg-4)
  obj
  )

;; definition of type bone-cache
(deftype bone-cache (structure)
  ((bone-matrix   uint32  :offset-assert   0)
   (parent-matrix uint32  :offset-assert   4)
   (dummy         uint32  :offset-assert   8)
   (frame         uint32  :offset-assert  12)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

;; definition for method 3 of type bone-cache
(defmethod inspect bone-cache ((obj bone-cache))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'bone-cache)
  (format #t "~1Tbone-matrix: ~D~%" (-> obj bone-matrix))
  (format #t "~1Tparent-matrix: ~D~%" (-> obj parent-matrix))
  (format #t "~1Tdummy: ~D~%" (-> obj dummy))
  (format #t "~1Tframe: ~D~%" (-> obj frame))
  (label cfg-4)
  obj
  )

;; definition of type bone
(deftype bone (structure)
  ((transform matrix :inline :offset-assert   0)
   (position  vector :inline :offset         48)
   (scale     vector :inline :offset-assert  64)
   )
  :method-count-assert 9
  :size-assert         #x50
  :flag-assert         #x900000050
  )

;; definition for method 3 of type bone
(defmethod inspect bone ((obj bone))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'bone)
  (format #t "~1Ttransform: #<matrix @ #x~X>~%" (-> obj transform))
  (format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj transform trans))
  (format #t "~1Tscale: #<vector @ #x~X>~%" (-> obj scale))
  (label cfg-4)
  obj
  )

;; definition of type skeleton
(deftype skeleton (inline-array-class)
  ((bones bone :inline :dynamic :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

;; definition for method 3 of type skeleton
(defmethod inspect skeleton ((obj skeleton))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tlength: ~D~%" (-> obj length))
  (format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
  (format #t "~1Tdata[0] @ #x~X~%" (-> obj bones))
  (label cfg-4)
  obj
  )

;; failed to figure out what this is:
(set! (-> skeleton heap-base) (the-as uint 80))

;; definition of type cspace
(deftype cspace (structure)
  ((parent    cspace    :offset-assert   0)
   (joint     joint     :offset-assert   4)
   (joint-num int16     :offset-assert   8)
   (geo       basic     :offset-assert  12)
   (bone      bone      :offset-assert  16)
   (param0    function  :offset-assert  20)
   (param1    basic     :offset-assert  24)
   (param2    basic     :offset-assert  28)
   )
  :method-count-assert 10
  :size-assert         #x20
  :flag-assert         #xa00000020
  (:methods
    (new (symbol type basic) _type_ 0)
    (reset-and-assign-geo! (_type_ basic) _type_ 9)
    )
  )

;; definition for method 3 of type cspace
(defmethod inspect cspace ((obj cspace))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'cspace)
  (format #t "~1Tparent: #<cspace @ #x~X>~%" (-> obj parent))
  (format #t "~1Tjoint: ~A~%" (-> obj joint))
  (format #t "~1Tjoint-num: ~D~%" (-> obj joint-num))
  (format #t "~1Tgeo: ~A~%" (-> obj geo))
  (format #t "~1Tbone: #<bone @ #x~X>~%" (-> obj bone))
  (format #t "~1Tparam0: ~A~%" (-> obj param0))
  (format #t "~1Tparam1: ~A~%" (-> obj param1))
  (format #t "~1Tparam2: ~A~%" (-> obj param2))
  (label cfg-4)
  obj
  )

;; definition of type cspace-array
(deftype cspace-array (inline-array-class)
  ((data cspace :inline :dynamic :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

;; definition for method 3 of type cspace-array
(defmethod inspect cspace-array ((obj cspace-array))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~1Tlength: ~D~%" (-> obj length))
  (format #t "~1Tallocated-length: ~D~%" (-> obj allocated-length))
  (format #t "~1Tdata[0] @ #x~X~%" (-> obj data))
  (label cfg-4)
  obj
  )

;; failed to figure out what this is:
(set! (-> cspace-array heap-base) (the-as uint 32))

;; definition for method 2 of type cspace
(defmethod print cspace ((obj cspace))
  (format
    #t
    "#<cspace ~S @ #x~X>"
    (if (-> obj joint)
        (-> obj joint name)
        "nojoint"
        )
    obj
    )
  obj
  )

;; failed to figure out what this is:
0