jak-project/goal_src/jak1/pc/pckernel-h.gc

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

(require "engine/ps2/pad.gc")


#|

  This file contains code that we need for the PC port of the game specifically.
  It should be included as part of the game engine package (engine.cgo).

  This file contains various types and functions to store PC-specific information
  and also to communicate between the game (GOAL) and the operating system.
  This way we can poll, change and display information about the system the game
  is running on, such as:
  - display devices and their settings, such as fullscreen, DPI, refresh rate, etc.
  - audio devices and their settings, such as audio latency, channel number, etc.
  - graphics devices and their settings, such as resolution, FPS, anisotropy, shaders, etc.
  - input devices and their settings, such as controllers, keyboards, mice, etc.
  - information about the game window (position, size)
  - PC-specific goodies, enhancements, fixes and settings.
  - whatever else.

  If you do not want to include these PC things, you should exclude it from the build system.

 |#


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; constants
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(deftype pckernel-version (int64)
  ((build     int16 :offset 0)
   (revision  int16 :offset 16)
   (minor     int16 :offset 32)
   (major     int16 :offset 48)
   )
  )

(defmacro static-pckernel-version (major minor rev build)
  `(new 'static 'pckernel-version :major ,major :minor ,minor :revision ,rev :build ,build))
(defconstant PC_KERNEL_INVALID_VERSION (static-pckernel-version #xffff #xffff #xffff #xffff))
                                                  ;; version: invalid
(defconstant PC_KERNEL_VERSION PC_KERNEL_INVALID_VERSION)
(defconstant PC_KERNEL_VER_MAJOR (-> PC_KERNEL_VERSION major))
(defconstant PC_KERNEL_VER_MINOR (-> PC_KERNEL_VERSION minor))
(defconstant PC_KERNEL_VER_REVISION (-> PC_KERNEL_VERSION revision))
(defconstant PC_KERNEL_VER_BUILD (-> PC_KERNEL_VERSION build))

(defun-extern get-pckernel-version pckernel-version)


(defconstant PS2_VOICE_AMOUNT 48)
(defconstant PC_VOICE_AMOUNT 256)

(defconstant ASPECT_4X3 (/ 4.0 3.0))
(defconstant ASPECT_16X9 (/ 16.0 9.0))
(defconstant ASPECT_16X9_SCALE (/ ASPECT_16X9 ASPECT_4X3))
(defconstant PC_BASE_WIDTH 640)
(defconstant PC_BASE_HEIGHT 480)
(defconstant PC_MIN_WIDTH 320)
(defconstant PC_MIN_HEIGHT 240)
(defconstant PC_DEFAULT_MSAA 2)


;; how many entries the music log has. the game only has 21 tracks but let's have more space for no reason.
(defconstant PC_MUSIC_LOG_LENGTH 30)
;; how many entries the spool anim log has. only 164 are used in-game.
(defconstant PC_SPOOL_LOG_LENGTH 170)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; types and enums
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;; graphics renderers
(defenum pc-gfx-renderer
  :type uint8
  (software)
  (opengl)
  (vulkan)
  (direct3d)
  )

;; music log info
(deftype pc-music-log-entry (structure)
  ((name  symbol)
   (flava-mask  int32)
   )
  :pack-me
  )

;; bingo integration. placeholder for now.
(deftype pc-bingo-info (structure)
  ()
  :pack-me
  )


;; All of the configuration for the PC port in GOAL. Access things from here!
;; Includes some methods to change parameters.
(deftype pc-settings (basic)
  ((version pckernel-version) ;; version of this settings

   ;; "generic" graphics settings
   (target-fps int16) ;; the target framerate of the game
   ;; game resolution?
   (width int64)
   (height int64)
   ;; window size. resolution = window size in windowed mode.
   (window-width int64)
   (window-height int64)
   ;; reported window framebuffer size from OS
   (framebuffer-width int64)
   (framebuffer-height int64)
   ;; the region to draw in that framebuffer. rest is cleared to black.
   (framebuffer-scissor-width int64)
   (framebuffer-scissor-height int64)
   (dpi-x float) ;; DPI width scale
   (dpi-y float) ;; DPI height scale
   (aspect-ratio-auto? symbol) ;; if on, aspect ratio is calculated automatically based on game display size.
   (aspect-ratio float) ;; the desired aspect ratio. set auto to off and then this to 4/3 to force 4x3 aspect.
   (aspect-ratio-scale float) ;; aspect ratio compared to 4x3
   (aspect-ratio-reciprocal float) ;; reciprocal of that
   (aspect-custom-x int)
   (aspect-custom-y int)
   (display-mode symbol) ;; display mode. can be windowed, fullscreen or borderless
   (letterbox? symbol) ;; letterbox. #f = stretched
   (vsync? symbol) ;; vsync.
   (font-scale float) ;; font scaling.
   (monitor int32) ;; index of which monitor to use when fullscreen or borderless

   ;; debug settings
   (os symbol) ;; windows, linux, macos
   (user symbol) ;; username. not system username, just debug thing.
   (debug? symbol) ;; more debug stuff just in case.
   (debug-font-scale        float)  ;; debug font scaling factor.
   (debug-font-scale-auto?  symbol) ;; auto-scale debug font by screen height.

   ;; device settings
   (ignore-controller-win-unfocused? symbol)
   (controller-led-hp?    symbol)
   (controller-led-eco?   symbol)
   (controller-led-heat?  symbol)
   (controller-led-brightness     float)
   (controller-led-min-brightness float)
   (controller-led-max-brightness float)
   (controller-led-color          rgbaf :inline)
   (stick-deadzone float) ;; analog stick deadzone. 0-1
   (keyboard-enabled? symbol) ;; NOTE - this is here solely to satisfy jak 1's menu design, the setting has been moved into `input-settings.json`
   (mouse-enabled? symbol)
   (mouse-camera? symbol)
   (mouse-xsens float)
   (mouse-ysens float)
   (mouse-movement? symbol)
   (auto-hide-cursor? symbol)

   ;; audio settings
   (audio-latency-ms int16) ;; audio latency in milliseconds
   (audio-pan-override float) ;; audio pan modifier
   (audio-volume-override float) ;; audio volume modifier
   (audio-channel-nb int16) ;; audio channel amount. will be 48 on PS2 mode.

   ;; graphics settings
   (gfx-renderer pc-gfx-renderer) ;; the renderer to use
   (gfx-resolution float) ;; for supersampling
   (gfx-anisotropy float) ;; for anisotropy
   (gfx-msaa int32) ;; for MSAA

   ;; ps2 settings
   (ps2-read-speed? symbol) ;; emulate DVD loads
   (ps2-parts? symbol) ;; if off, increase particle cap
   (ps2-music? symbol) ;; if off, use .wav files stored somewhere
   (ps2-se? symbol) ;; if off, use adjusted sound effects
   (ps2-hints? symbol) ;; if off, enables extra game hints

   ;; lod settings
   (ps2-shadow? symbol) ;; if off, enables extended object shadows
   (ps2-lod-dist? symbol) ;; use original lod distances
   (force-envmap? symbol) ;; dont use envmap fading (force max).
   (shrub-dist-mod float) ;; shrub render distance modifier
   (lod-dist-mod float) ;; non-shrub lod distance modifier
   (lod-force-tfrag int8) ;; tfrag lod tier override. 0 = highest detail
   (lod-force-tie int8) ;; tie lod tier override
   (lod-force-ocean int8) ;; ocean lod tier override
   (lod-force-actor int8) ;; merc lod tier override

   ;; misc settings
   (ps2-actor-vis? symbol) ;; skips vis check for actor entity if disabled
   (use-vis? symbol) ;; if off, don't use vis trees. this MUST be off for custom (non-cropping) aspect ratios.
   (hinttitles? symbol) ;; if on, non-cutscene subtitles will show up
   (subtitle-speaker? symbol) ;; #f (force off), #t (force on), auto (on for offscreen)
   (first-camera-h-inverted? symbol) ;; first-person horizontal camera inverted
   (first-camera-v-inverted? symbol) ;; first-person vertical camera inverted
   (third-camera-h-inverted? symbol) ;; third-person horizontal camera inverted
   (third-camera-v-inverted? symbol) ;; third-person vertical camera inverted
   (music-fadeout?  symbol) ;; music fadeout toggle.
   (music-fadein?   symbol) ;; music fadein toggle.

   (territory   int16)

   (bingo pc-bingo-info :inline) ;; bingo integration. does nothing for now.

   (discord-rpc? symbol) ;; enable discord rich presence integration
   (speedrunner-mode? symbol) ;; enable speedrunner mode

   (flava-hack int64)

   ;; TODO - save/restore original settings (language/sound/etc)
   )

  (:methods
    (new (symbol type) _type_)
    (initialize (_type_) _type_)
    (update (_type_) none)
    (update-from-os (_type_) none)
    (update-to-os (_type_) none)
    (update-discord-rpc (_type_) none)
    (update-speedrun (_type_) none)
    (update-video-hacks (_type_) object)
    (reset (_type_ symbol) int)
    (reset-audio (_type_ symbol) int)
    (reset-input (_type_ symbol symbol) int)
    (reset-gfx (_type_ symbol) int)
    (reset-ps2 (_type_ symbol) int)
    (reset-misc (_type_ symbol) int)
    (reset-camera (_type_ symbol) int)
    (reset-extra (_type_ symbol) int)
    (print-debug-misc (_type_) object)
    (draw (_type_ dma-buffer) object)
    (draw-memory (_type_ dma-buffer) symbol)
    (set-display-mode! (_type_ symbol symbol) int)
    (set-size! (_type_ int int symbol) none)
    (set-aspect! (_type_ int int) none)
    (set-aspect-ratio! (_type_ float) none)
    (set-frame-rate! (_type_ int symbol) int)
    (set-monitor! (_type_ int) none)
    (set-game-setting! (_type_ symbol symbol) object)
    (get-game-setting (_type_ symbol) symbol)
    (set-game-language! (_type_ language-enum) language-enum)
    (get-game-language (_type_) language-enum)
    (get-current-game-width (_type_) int)
    (get-current-game-height (_type_) int)
    (read-from-file (_type_ string) symbol)
    (write-to-file (_type_ string) symbol)
    (handle-input-settings (_type_ file-stream) object)
    (handle-output-settings (_type_ file-stream) object)
    (led-enabled? (_type_) symbol)
    (update-led (_type_) symbol)
    (update-cheats (_type_) int)
    (update-music-log (_type_) int)
    (add-to-music-log (_type_ symbol int) int)
    (commit-to-file (_type_) none)
    (load-settings (_type_) int)
    (set-ignore-controller-in-bg! (_type_ symbol) none)
    (update-mouse-controls! (_type_) none)
    (debug-font-scale-factor (_type_) float)
    )
  )

(defconstant PC_TEMP_STRING_LEN 1024)
(define *pc-temp-string* (new 'global 'string PC_TEMP_STRING_LEN (the string #f)))

(define *pc-temp-string-1* (new 'global 'string 2048 (the string #f)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; debug settings
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define *display-actor-bank* #f)
(define *display-pad-debug* #f)
(define *display-led* #f)
(define *display-led-rgba* (new 'static 'rgba))
(define *display-heap-status* #f)
(define *display-actor-counts* #f)
(define *display-text-box* #f)
(define *display-sha* *debug-segment*)

;; collision renderer things. debug only.
(define *collision-renderer* #f)
(define *collision-wireframe* #f)
(define *collision-mode* (pc-collision-mode mode))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; resets
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(defmethod reset pc-settings ((obj pc-settings) (call-handlers symbol))
  "Reset everything back to default settings

   If call-handlers = #t then events will be sent to the runtime kernel to update OS settings
   such as window size, etc.
   If you just want to set the settings and handle the fields yourself later, set call-handlers to #f
   such as if you're setting the initial values right before reading the settings file that changes them."

  (format 0 "pc settings reset~%")

  (set! (-> obj version) (get-pckernel-version))

  (set! (-> obj os) (pc-get-os))
  (set! (-> obj user) #f)
  (set! (-> obj debug?) #f)
  (set! (-> obj font-scale) 1.0)
  (set! (-> obj aspect-custom-x) 4)
  (set! (-> obj aspect-custom-y) 3)
  (set! (-> obj discord-rpc?) #t)
  (set! (-> obj speedrunner-mode?) #f)
  (set! (-> obj debug-font-scale) 1.0)
  (set! (-> obj debug-font-scale-auto?) #t)

  (reset-gfx obj call-handlers)
  (reset-audio obj call-handlers)
  (reset-input obj 'all call-handlers)
  (reset-ps2 obj call-handlers)
  (reset-misc obj call-handlers)
  (reset-extra obj call-handlers)

  0)


(defmethod reset-gfx pc-settings ((obj pc-settings) (call-handlers symbol))
  "Set the default graphics settings"

  ;; temporarily "set" to windowed so we can change window size
  ;; we set our actual target display mode later.
  (set! (-> obj display-mode) 'windowed)
  (set-size! obj PC_BASE_WIDTH PC_BASE_HEIGHT #f)

  (set-aspect! obj 4 3)
  (set-frame-rate! obj 60 call-handlers)

  (set! (-> obj use-vis?) #f)
  (set! (-> obj aspect-ratio-auto?) #t)
  (set! (-> obj vsync?) #t)
  (set! (-> obj letterbox?) #t)

  ;; get screen size and set to borderless at screen res (if retail)
  (cond
    ((> (pc-get-num-resolutions) 0)
     ;; pick first available resolution by default
     (pc-get-resolution 0 (&-> obj width) (&-> obj height))
     )
    (else
     ;; somehow didn't get a single resolution. this is pretty bad.
     (pc-get-active-display-size (&-> obj width) (&-> obj height))
     (max! (-> obj width) PC_MIN_WIDTH)
     (max! (-> obj height) PC_MIN_HEIGHT)
     (format 0 "!!!! failed to get any screen resolutions !!!!")
     )
    )
  (format 0 "fullscreen resolution defaulted to ~D x ~D~%" (-> obj width) (-> obj height))
  (if (not *debug-segment*)
      (set-display-mode! obj 'borderless call-handlers)
      (set-display-mode! obj 'windowed call-handlers))
  (set! (-> obj gfx-msaa) PC_DEFAULT_MSAA) ;; default msaa
  0)

(defmethod reset-audio pc-settings ((obj pc-settings) (call-handlers symbol))
  "Set the default audio settings"

  (set! (-> obj audio-latency-ms) 80)
  (set! (-> obj audio-pan-override) 0.0)
  (set! (-> obj audio-volume-override) 1.0)
  (set! (-> obj audio-channel-nb) PS2_VOICE_AMOUNT)

  (set! (-> obj music-fadeout?) #t)
  (set! (-> obj music-fadein?) #t)
  0)

(defmethod reset-input pc-settings ((obj pc-settings) (device symbol) (call-handlers symbol))
  "Set the default input settings"

  (when (or (= device 'all) (= device 'controller))
    (set! (-> obj ignore-controller-win-unfocused?) #f)
    (set! (-> obj controller-led-hp?) #t)
    (set! (-> obj controller-led-eco?) #t)
    (set! (-> obj controller-led-heat?) #t)
    (set! (-> obj stick-deadzone) 0.3)
    (set! (-> obj controller-led-brightness) 1.0)
    (set! (-> obj controller-led-min-brightness) 0.25)
    (set! (-> obj controller-led-max-brightness) 1.0)
    )

  (when (or (= device 'all) (= device 'input))
    (set! (-> obj keyboard-enabled?) #f)
    (set! (-> obj mouse-enabled?) #f)
    (set! (-> obj auto-hide-cursor?) #t)
    )

  (when (or (= device 'all) (= device 'mouse))
    (set! (-> obj mouse-camera?) #f)
    (set! (-> obj mouse-xsens) -15.0)
    (set! (-> obj mouse-ysens) 10.0)
    (set! (-> obj mouse-movement?) #f)
    )
  0)

(defmethod reset-ps2 pc-settings ((obj pc-settings) (call-handlers symbol))
  "Set the default ps2 settings"

  (set! (-> obj ps2-read-speed?) #f)
  (set! (-> obj ps2-parts?) #f)
  (set! (-> obj ps2-music?) #t)
  (set! (-> obj ps2-se?) #t)
  (set! (-> obj ps2-hints?) #t)

  (set! (-> obj ps2-shadow?) #f)
  (set! (-> obj ps2-lod-dist?) #f)
  (set! (-> obj force-envmap?) #t)
  (set! (-> obj shrub-dist-mod) 1.0)
  (set! (-> obj lod-dist-mod) 1.0)
  (set! (-> obj lod-force-tfrag) 0)
  (set! (-> obj lod-force-tie) 0)
  (set! (-> obj lod-force-ocean) 0)
  (set! (-> obj lod-force-actor) 0)
  0)

(defmethod reset-misc pc-settings ((obj pc-settings) (call-handlers symbol))
  "Set the default misc settings"

  (set! (-> obj ps2-actor-vis?) #t)
  (set! (-> obj hinttitles?) #t)
  (set! (-> obj subtitle-speaker?) 'auto)
  (reset-camera obj call-handlers)

  (set! (-> obj territory) -1) ;; auto
  0)

(defmethod reset-camera pc-settings ((obj pc-settings) (call-handlers symbol))
  "Set the original game's camera controls"

  (set! (-> obj first-camera-h-inverted?) #f) ;; first-person horizontal is NOT inverted in original game
  (set! (-> obj first-camera-v-inverted?) #t) ;; first-person vertical IS inverted in original game
  (set! (-> obj third-camera-h-inverted?) #t) ;; third person horizontal IS inverted in original game
  (set! (-> obj third-camera-v-inverted?) #t) ;; third-person vertical IS inverted in original game
  0)

(defmethod reset-extra pc-settings ((obj pc-settings) (call-handlers symbol))
  "Set the default goodies settings"

  0)

(defmacro with-pc (&rest body)
  "encapsulates the code around PC-specific checks"
  `(#when PC_PORT (when (and *pc-settings*)
      ,@body
      ))
  )


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; quick helpers
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(defmacro get-debug-font-scale-factor ()
  "return the debug font scale factor to be used."
  `(debug-font-scale-factor *pc-settings*))


(defmacro fullscreen? ()
  `(symbol-member? (-> *pc-settings* display-mode) '(fullscreen borderless)))


(defun bcd->dec ((bcd uint))
  "Convert a number encoded in BCD to its decimal equivalent"
  (+ (* (shr (logand bcd #xf0) 4) 10) (logand bcd #x0f)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; cheats
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(seval (define *pc-cheat-map*
          '((#\a (circle triangle))
            (#\b (square x))
            (#\c (circle))
            (#\d (down))
            (#\e (right right))
            ;; #\f
            ;; #\g
            ;; #\h
            (#\i (up))
            ;; #\j
            (#\k (circle))
            (#\l (left))
            (#\m (triangle))
            (#\n (up up))
            (#\o (square))
            (#\p (square circle))
            ;; #\q
            (#\r (right))
            (#\s (down down))
            (#\t (triangle))
            (#\u (up))
            (#\v (down))
            (#\w (left left))
            (#\x (x))
            (#\y (triangle))
            (#\z (x x))
            ))
        )

(desfun pc-cheat-encode (word extra)
  "turn a cheat word into input names."
  (let ((out '())
        (word-str (symbol->string word)))

  (dotimes (i (string-length word-str))
    (let ((char-to-inputs (assoc (string-ref word-str i) *pc-cheat-map*)))
    (if (not char-to-inputs)
        (ferror "bad input for pc cheat name: {}" (string-ref word-str i))
        (dolist (button (cadr char-to-inputs))
          (set! out (cons (car button) out))
          ))
    ))

  (dolist (ex extra)
    (set! out (cons (car ex) out)))

  out)
  )

(defmacro pc-check-cheat-code (cheat-var pad-idx input &key (extra ()) &rest body)
  "execute body when a cheat code made up of sequential inputs has been inputted"

  (let ((buttons (pc-cheat-encode input extra)))
  `(when (nonzero? (cpad-pressed ,pad-idx)) ;; only check when some button has been pressed
    (case ,cheat-var
      ,@(apply-i
          (lambda (x i)
            `((,i)
              (if (cpad-pressed? ,pad-idx ,x)
                ,(if (< i (- (length buttons) 1))
                    `(1+! ,cheat-var)

                    `(begin
                      (cond
                        ((-> *pc-settings* speedrunner-mode?)
                          (sound-play "cursor-options"))
                        (else
                          ,@body)
                        )
                      (set! ,cheat-var 0)
                      )
                    )

                (set! ,cheat-var 0)
                )
              )
            )
        buttons)
      )
    )
  ))



(defun-extern real-movie? symbol)



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; entity debugging
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(when *debug-segment*

(deftype entity-debug-inspect (basic)
  (
   (scroll-y int16)
   (scroll-y-max int16)
   (entity entity)
   (show-actor-info symbol)
   (show-long-info symbol)
   )
  (:methods
    (new (symbol type) _type_)
    (set-entity! (_type_ entity) entity)
    (update-pad (_type_ int) none)
    )
  )

(defmethod new entity-debug-inspect ((allocation symbol) (type-to-make type))
  "make a new entity-debug-inspect object"

  (let ((obj (object-new allocation type-to-make (the-as int (-> type-to-make size)))))

    (set! (-> obj scroll-y) 0)
    (set! (-> obj scroll-y-max) 0)
    (set! (-> obj entity) (the entity #f))
    (set! (-> obj show-actor-info) #f)
    (set! (-> obj show-long-info) #f)
    obj
    )
  )


(define *entity-debug-inspect* (new 'debug 'entity-debug-inspect))


) ;; when debug_segment