jak-project/goal_src/jak1/engine/load/loader-h.gc

;;-*-Lisp-*-
(in-package goal)
(bundles "ENGINE.CGO" "GAME.CGO")
(require "kernel/gkernel-h.gc")

;; The loader is responsible for managing streaming loads.

;; note: lower values are more important.
;; negative values will preload.
(defconstant SPOOL_PRIORITY_LOWEST 100000000.0)

(defconstant SPOOL_PRIORITY_RECALC -99.0)

(defconstant SPOOL_PRIORITY_HIGHEST -20.0)

(defconstant SPOOL_PRIORITY_HIGH -10.0)

(defconstant SPOOL_HEAP_SIZE (* 247 1024)) ;; size of the heap to be used for each spool

;; DECOMP BEGINS

;; A load-dir is a collection of references to loaded art.
;; This type didn't have a normal inspect method, so these field names are made up.
(declare-type art-group basic)

(deftype load-dir (basic)
  ((lev          level)
   (string-array (array string)) ;; these are the names
   (data-array   (array basic)) ;; this is the file data.
   )
  (:methods
   (new (symbol type int level) _type_)
   (load-to-heap-by-name "Return the named art group, optionally reloading an existing entry, or append a successful
     debug load." (_type_ string symbol kheap int) art-group)
   (set-loaded-art "Replace the art group with the same name or append the supplied group to both parallel arrays." (_type_ art-group) art-group)))

;; specialization of load-dir where the data-array holds art-groups.
(deftype load-dir-art-group (load-dir)
  ((art-group-array (array art-group) :overlay-at data-array))
  (:methods
   (new (symbol type int level) _type_)))

(defmethod new load-dir ((allocation symbol) (type-to-make type) (length int) (lev level))
  "Allocate a load directory and its parallel name and data arrays with capacity for length entries."
  (let ((this (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> this lev) lev)
    ;; create the name array
    (set! (-> this string-array) (the-as (array string) ((method-of-type array new) allocation array string length)))
    (set! (-> this string-array length) 0)
    ;; create the data array
    (set! (-> this data-array) (the-as (array basic) ((method-of-type array new) allocation array basic length)))
    (set! (-> this data-array length) 0)
    this))

(defmethod new load-dir-art-group ((allocation symbol) (type-to-make type) (length int) (lev level))
  "Allocate a load directory whose data array contains art groups."
  ;; call parent ctor.
  (let ((this ((method-of-type load-dir new) allocation type-to-make length lev)))
    ;; override the content type
    (set! (-> this data-array content-type) art-group)
    ;; and cast to child.
    (the-as load-dir-art-group this)))

;; An external-art-buffer owns some memory for loading files.
;; the "external" means it's not part of the level's (or common, always loaded) static data
;; status:
;;  - 'active: file is loaded and art group is linked to level's art group.
;;  - 'reserved: buffer is reserved for other purpose
;;  - 'error: load has encountered an error, goes to 'inactive
;;  - 'inactive: not in use
;;  - 'loading: loading is in progress
;;  - 'loaded: loading has finished, goes to 'locked or 'active
;;  - 'locked: loaded, but another buffer is active and blocks this one.
;; Note: a locked buffer has loaded/linked the file, but hasn't linked the file
;;  to the "master" art group, located in the level.
(deftype external-art-buffer (basic)
  ((index                      int32)
   (other                      external-art-buffer)
   (status                     symbol)
   (locked?                    symbol)
   (frame-lock                 symbol)
   (heap                       kheap :inline)
   (pending-load-file          string)
   (pending-load-file-part     int32)
   (pending-load-file-owner    handle)
   (pending-load-file-priority float)
   (load-file                  string)
   (load-file-part             int32)
   (load-file-owner            handle)
   (load-file-priority         float)
   (buf                        pointer)
   (len                        int32)
   (art-group                  art-group))
  (:methods
   (new (symbol type int) _type_)
   (set-pending-file "Set the file part, owner, and priority to service on the next update." (_type_ string int handle float) int)
   (update "Advance this buffer's request, STR transfer, link, activation, and unloading state." (_type_) int)
   (inactive? "Return true unless this buffer currently has an active, linked art group." (_type_) symbol)
   (file-status "Return this buffer's state for a requested file part, pending if queued, or #f if absent." (_type_ string int) symbol)
   (link-file "Link an art group's joint animations and make it this buffer's active group." (_type_ art-group) art-group)
   (unlink-file "Unlink an art group's joint animations and clear this buffer's active group." (_type_ art-group) int)
   (unlock! "Clear the inter-buffer activation lock." (_type_) symbol)))

(defmethod new external-art-buffer ((allocation symbol) (type-to-make type) (idx int))
  "Allocate an external art buffer in its initialized, empty state."
  (let ((this (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (set! (-> this index) idx)
    (set! (-> this load-file) #f)
    (set! (-> this load-file-part) -1)
    (set! (-> this load-file-owner) (the-as handle #f))
    (set! (-> this load-file-priority) SPOOL_PRIORITY_LOWEST)
    (set! (-> this pending-load-file) #f)
    (set! (-> this pending-load-file-part) -1)
    (set! (-> this pending-load-file-owner) (the-as handle #f))
    (set! (-> this pending-load-file-priority) SPOOL_PRIORITY_LOWEST)
    (set! (-> this art-group) #f)
    (set! (-> this status) 'initialize)
    (set! (-> this locked?) #f)
    (set! (-> this other) #f)
    this))

;; A spool-anim tracks the buffers holding chunks of a spooled animation. The first
;; two payload words change meaning as a request advances: queued records use
;; name/index, while records being serviced use those same words as buf1/buf2.
(deftype spool-anim (basic)
  ((name         string :offset 16)
   (buf1         external-art-buffer :overlay-at name)
   (index        int32 :offset 20)
   (buf2         external-art-buffer :overlay-at index)
   (parts        int32)
   (priority     float)
   (owner        handle)
   (command-list pair))
  :pack-me)

;; This is the main controller for the streaming loader.
;; It has two buffers for holding chunks of a spooling animation
;; The buffer can also be reused to hold other things.
(deftype external-art-control (basic)
  ((buffer               external-art-buffer 2)
   (rec                  spool-anim 3 :inline)
   (spool-lock           handle)
   (reserve-buffer       external-art-buffer)
   (reserve-buffer-count int32)
   (active-stream        string)
   (preload-stream       spool-anim :inline)
   (last-preload-stream  spool-anim :inline)
   (end-pad              uint32))
  (:methods
   (new (symbol type) _type_)
   (update "Assign and advance the two buffers, then queue the best audio preload candidate." (_type_ symbol) int)
   (clear-rec "Clear ranked streaming requests, retaining non-reservation requests outside game mode." (_type_) int)
   (spool-push "Insert a request into the three-entry list when its priority is high enough." (_type_ string int process float) int)
   (file-status "Return the first matching buffer state or #f." (_type_ string int) symbol)
   (reserve-alloc "Request a buffer for general heap use and return its heap once active." (_type_) kheap)
   (reserve-free "Release the reservation backed by the supplied heap." (_type_ kheap) int)
   (none-reserved? "Return true when no general-use buffer reservation has been requested." (_type_) symbol)
   (try-preload-stream "Replace the speculative audio preload candidate when this request has better priority." (_type_ string int process float) int)))

(defmethod new external-art-control ((allocation symbol) (type-to-make type))
  "Allocate the streaming controller, cross-link its two buffers, and initialize its request records."
  (let ((this (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    ;; allocate buffers.
    (dotimes (i 2)
      (set! (-> this buffer i) ((method-of-type external-art-buffer new) allocation external-art-buffer i)))
    ;; point buffers to each other
    (set! (-> this buffer 0 other) (-> this buffer 1))
    (set! (-> this buffer 1 other) (-> this buffer 0))
    ;; set up recs
    (dotimes (i 3)
      (set! (-> this rec i name) #f)
      (set! (-> this rec i priority) SPOOL_PRIORITY_LOWEST)
      (set! (-> this rec i owner) (the-as handle #f)))
    ;; set up defaults.
    (set! (-> this spool-lock) (the-as handle #f))
    (set! (-> this reserve-buffer) #f)
    (set! (-> this active-stream) #f)
    (set! (-> this preload-stream name) #f)
    (set! (-> this preload-stream priority) SPOOL_PRIORITY_LOWEST)
    (set! (-> this preload-stream owner) (the-as handle #f))
    (set! (-> this last-preload-stream name) #f)
    (set! (-> this last-preload-stream priority) SPOOL_PRIORITY_LOWEST)
    (set! (-> this last-preload-stream owner) (the-as handle #f))
    this))

(define-extern *art-control* external-art-control)

(defun-extern art-group-load-check string kheap int art-group)