longlene / cl-raylib Goto Github PK

View Code? Open in Web Editor NEW

136.0 136.0 19.0 473 KB

Common Lisp binding of raylib

License: MIT License

Common Lisp 100.00%

common-lisp game-development raylib

cl-raylib's People

Contributors

Stargazers

Watchers

Forkers

lionturtle compufox armontoubman dreac0nic nagy dawranliou kiran-kp bejer stacksmith qoocku spazzylemons natefusion bohonghuang lygaret lambdart sarvex alxbnct williewillus goosecoid

cl-raylib's Issues

How usable is this? Could you provide more examples?

Hey there,

I'm very interested in using raylib + common lisp, however your example isn't really enough of an introduction to a beginner when paired with (the lack of) documentation. I really want to use your project, but I'm a little bit stuck.

Could you perhaps show a very simple 3D example just to show that it's functional and as a demonstration of how it will work? There are plenty of examples on Raylib's website that you could port over - I can see that most of the functions have the same names but I'm struggling to understand how to use them (particularly, creating a camera for beginning a 3D game).

I would love to use your library and even help out if I learn a bit more, because raylib is an awesome library and lisp is an awesome language!

audio_sound_loading.lisp makes no sound

Ubuntu 20.04.4 LTS x86_64
5.4.0-122-generic
SBCL 2.2.6

A soft click when it starts. That's all, no change on spacebar.

Also, the 'press enter to play ogg sound' message is not displayed. It seems to be outside the window display loop. Alas, fixing that did not help with playback.

Support for `raygui`

raygui helps build immediate mode GUI with raylib. It's useful in writing debug interfaces and could become a good option for writing GUI in Common Lisp. Any plan to wrap it along with raylib?

Camera first person and third person constants are not defined correctly in raylib.lisp

Those 2 constants are defined with underscore but exported with dash, see below:

line 1850 in raylib.lisp

(define-constant +camera-first_person+ 3)
(define-constant +camera-third_person+ 4)

line 210 in package.lisp

    #:+camera-first-person+
    #:+camera-third-person+

Tests failed

Hi,

I am about to pack the project for Guix but it faild on running tests:

Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING
                                                             {100AFB01B3}>:
  Component "cl-raylib-test" not found

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {100AFB01B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK Component "cl-raylib-test" not found #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* Component "cl-raylib-test" not found)
2: (INVOKE-DEBUGGER Component "cl-raylib-test" not found)
3: (ERROR ASDF/FIND-COMPONENT:MISSING-COMPONENT :REQUIRES "cl-raylib-test")
4: ((:METHOD ASDF/OPERATE:OPERATE (SYMBOL T)) ASDF/LISP-ACTION:LOAD-OP "cl-raylib-test") [fast-method]
5: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "cl-raylib-test")
6: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
7: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-raylib-test") [fast-method]
8: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10034C504B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
9: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
10: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10034C3FBB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
11: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-raylib-test") [fast-method]
12: (ASDF/OPERATE:LOAD-SYSTEM "cl-raylib-test")
13: (SB-INT:SIMPLE-EVAL-IN-LEXENV (ASDF/OPERATE:LOAD-SYSTEM "cl-raylib-test") #<NULL-LEXENV>)
14: (EVAL (ASDF/OPERATE:LOAD-SYSTEM "cl-raylib-test"))
15: (SB-IMPL::PROCESS-EVAL/LOAD-OPTIONS ((:EVAL . "(require :asdf)") (:EVAL . #<(SIMPLE-ARRAY CHARACTER (260)) (asdf:initialize-source-registry (list :source-registry (list :tree (uiop:ensure-pathname "/gnu/store/wjfzk3hflmy766abplhddwn9nbivwyr1-sbcl-cl-raylib-0.0.1-0.985ceeb/share/common-lisp/sbcl/cl-raylib" ... {100B0E800F}>) (:EVAL . "(asdf:load-system \"cl-raylib\")") (:EVAL . "(asdf:load-system \"cl-raylib-test\")") (:QUIT)))
16: (SB-IMPL::TOPLEVEL-INIT)
17: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
18: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
19: (SB-IMPL::%START-LISP)

Thanks

Functions that require pointers signal error

I could be doing this wrong (I'm new to ffi programming) but when I try and call a function like update-camera or draw-triangle-fan with the appropriate struct (camera3d and vector2 respectfully) the function signals an error saying that the struct is not a pointer.

When trying various ways to get a pointer for the object I get errors as well.

Unsure if this is a bug, or my misunderstanding, but I figured an issue wouldn't hurt.

Thank you for your work!

Efficient handling of RGBA translation

Thank you for cl-raylib, and please consider what follows as completely constructive.

In C rgba values map nicely as a struct packed into a 32-bit value. A literal translation to Lisp CFFI (such as yours) results in repeated packing/unpacking of color data, stored on the Lisp side as a list of four values. Unnecessary packing and unpacking of color values, in every drawing primitive in the hotpath reduces performance, and unnecessary consing results in GC delays.

It would be much more efficient to handle colors as 32-bit integers in Lisp, and have all CFFI calls requiring color take it as a U32 integer. On rare occasions when manipulation of color components is needed, extraction/insertion is trivial and efficient (shift/mask in compiled code).

The component packing, performed in every call with color parameters, is hoisted into the usually non-critical-path code which prepares the colors. And any color return values will no longer get unpacked and cons up lists.

I believe the result will be a tangible performance improvement, and a lot of consing in the main loop eliminated, avoiding GC issues. And allowing for more work to be done inside the main loop.

Work plan

If you are interested, I could give it a whack.

The work scope covers:

Changing color constants to 32-bit values;
Altering call color parameters to take unsigned 32-bit values instead of current structure-by-value scheme.

The change would be transparent to all code that uses color constants.

Why you deleted a constants?

Hello!
You deleted a key constants and i don't know, how to use keys. I must to define key constants myself?
Thanks!

cl-raylib support load-texture?

I can not load texture in cl-raylib, what must i do?

Raylib 3.0.0 support

Hello,

I would like to know if cl-raylib can support the new release of Raylib.

Best regards.

Add to quicklisp

Are there any plans to add cl-raylib to quicklisp? Seems like it's at least ready to be added to ultralisp

Supporting Vector and Matrix operations

Would you be open to integrating Shinmera/3d-vectors and Shinmera/3d-matrices? The alternative is to implement all the required operations in this library but that seems unnecessary.

If you're open to this, I can submit a pull request with the required changes.

Consider adding finalizers to resource heavy objects

I think it might make sense to add finalizers to objects like images. Finalizers allow the garbage-collector to call a function, when an object is no longer referenced. This way, more memory can be automatically freed, for example of images. It could come in useful in situations like the following pseudocode:

(defparameter *level-images* (make-hash-table))
;; prepare level1 
(setf (gethash 1 *level-images*) (load-image "level1-image1.jpg"))
(setf (gethash 2 *level-images*) (load-image "level1-image2.jpg"))
;; load more images of level 1...
;; ... now the player enters level 2
;; all we need to do here is make a new hash table.
(setq *level-images* (make-hash-table))
;; Since the old one is unreferenced, all its contents could be eventually freed.

We do not need to iterate over the content of the container and call #'unload-image. I have had success with the following wrapper.

(defun load-image-gced (filename)
  (let* ((res (load-image filename))
         (cpy (raylib::copy-image res)))
    (sb-ext:finalize res (lambda () (unload-image cpy)))
    res))

Keep in mind, that with the #'copy-image function, the struct is not deeply copied, so it will not use much more memory. Also keep in mind, that this is only additional and you are still free to do some manual memory management where it makes sense. So this would not break existing code. With help from "trivial-garbage" we can write portable code for this.

https://trivial-garbage.common-lisp.dev/

https://www.sbcl.org/manual/#Finalization

why draw-rectangle takes arguments of type integers instead of float?

draw-rectange arguments take integer but when we multiply it with get-frame-time the argument becomes float and we no longer put them into draw-rectangle.

Information on camera update

With setting the camera3d's mode to free I have to update it on every frame. But the function require the camera to be passed as a pointer. I actually have +camera+ storing the camera3d struct. There is a function or a macro I'm not aware to pass it to the update-camera function?

Memory fault with struct passed by value

Problem

sbcl-2.1.9-macosx-x64 (macOS Monteray)

I haven't been using this library for a long, but when I upgraded to Monteray I started getting this error:

;; cl-raylib-bug.lisp
(ql:quickload :cl-raylib)

(in-package #:raylib)

(init-audio-device)
(defvar boom (load-sound "boom.wav"))
(format t "Sound: ~a~%" boom)
(format t "type q to quit, otherwise play sound~%")
(loop :while (not (char= #\q (read-char)))
      :do (play-sound boom))
(sb-ext:quit)

$ sbcl --load cl-raylib-bug.lisp
INFO: AUDIO: Device initialized successfully
INFO:     > Backend:       miniaudio / Core Audio
INFO:     > Format:        32-bit IEEE Floating Point -> 32-bit IEEE Floating Point
INFO:     > Channels:      2 -> 2
INFO:     > Sample rate:   44100 -> 44100
INFO:     > Periods size:  1323
INFO: FILEIO: [boom.wav] File loaded successfully
INFO: WAVE: Data loaded successfully (48000 Hz, 16 bit, 2 channels)
INFO: WAVE: Unloaded wave data from RAM
Sound: (1291890176 (44100 32 2 #.(SB-SYS:INT-SAP #X0000E7F0)))
type q to quit, otherwise play sound
a
CORRUPTION WARNING in SBCL pid 58696 pthread 0x8d23600:
Memory fault at 0x6a817178 (pc=0x1288cb8, fp=0x65ef40, sp=0x65ef40) pthread 0x8d23600
The integrity of this image is possibly compromised.
Continuing with fingers crossed.
While evaluating the form starting at line 8, column 0
  of #P"/Users/ayman/git/github.com/aymanosman/common-lisp-study-group/apps/game/cl-raylib-bug.lisp":

debugger invoked on a SB-SYS:MEMORY-FAULT-ERROR in thread
#<THREAD "main thread" RUNNING {10015301C3}>:
  Unhandled memory fault at #x6A817178.

("bogus stack frame")

Solution

I made incomplete bindings using cffi-grovel to handle defining the C structs and it fixed the issue, leading me to think that it something to do with struct fields being wrongly defined in this library.

The bindings are here https://github.com/aymanosman/cl-raylib

Using them, I don't see the error anymore. The most obvious difference is the frameCount in your version of the library is wrong, it reports 1291890176 while the correct number is 59376.

Sound: (FRAME-COUNT 59376 STREAM
        (CHANNELS 2 SAMPLE-SIZE 32 SAMPLE-RATE 44100 BUFFER
         #.(SB-SYS:INT-SAP #X7FC69F011800)))

Generate bindings via `cl-autowrap`

It seems like the raylib.lisp file is a rather manually written binding file to raylib.
Would it make to you to generate these via https://github.com/rpav/cl-autowrap ?

If you want I can draft something out.

Can you please write this in "cl-raylib", i could not get a working version of it?

This is from the plane rotations example:
model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texture; // Set map diffuse texture

Requesting example of how to load/draw a model

When I try to load and draw a simple model, such as in this example, I get pointer errors in (draw-model):

The value
  (1065353216 0 #.(SB-SYS:INT-SAP #X00000000)
   #.(SB-SYS:INT-SAP #X3F80000000000000)
   #.(SB-SYS:INT-SAP #X00000000) #.(SB-SYS:INT-SAP #X00000000)
   #.(SB-SYS:INT-SAP #X3F800000) #.(SB-SYS:INT-SAP #X00000000)
   #.(SB-SYS:INT-SAP #X3F80000000000000)
   #.(SB-SYS:INT-SAP #X10000001)
   #.(SB-SYS:INT-SAP #X7FAA9C405CF0)
   #.(SB-SYS:INT-SAP #X7FAA9C406E40)
   #.(SB-SYS:INT-SAP #X7FAA9C406FD0) 0
   #.(SB-SYS:INT-SAP #X00000000))

is not of type
  SB-SYS:SYSTEM-AREA-POINTER

This works in C so at least on some level I am using the library correctly. Do you have a working Lisp example? Am I doing something wrong or is this related to #3?

Update raylib's BINDINGS.md file

This library appears in Raylib's BINDINGS.md file, but the file shows it in the Older or Unmaintained Language Bindings section, saying that the supported version is 3.0.

Would it be correct to update the BINDINGS file so that cl-raylib appears as a maintained project as well as that it supports version 4.0?

Have you managed to compile this for the web?

I'm thinking of using your system to speed up writing, but I'm afraid that I won't be able to compile it for the web, have you tried this before?

Because in the past I tried compile ECL together with emscripten and I couldn't this.

core_world_screen example fails to place text correctly

Ubuntu 20.04.4 LTS x86_64
5.4.0-122-generic
SBCL 2.2.6

The text in the example states 'text is always on top of the cube', and the C example keeps text on top of cube.

The cl example code fails to do so. The x position of text is always the same.

̶I̶ ̶j̶u̶s̶t̶ ̶s̶t̶a̶r̶t̶e̶d̶ ̶l̶o̶o̶k̶i̶n̶g̶ ̶a̶t̶ ̶r̶a̶y̶l̶i̶b̶ ̶a̶n̶d̶ ̶c̶l̶-̶r̶a̶y̶l̶i̶b̶,̶ ̶a̶n̶d̶ ̶c̶a̶n̶'̶t̶ ̶t̶e̶l̶l̶ ̶w̶h̶y̶ ̶t̶h̶i̶s̶ ̶i̶s̶ ̶h̶a̶p̶p̶e̶n̶i̶n̶g̶.̶

Couldn't execute "gcc": The system cannot find the file specified

I am running SBCL on Windows, I have MSYS2 and their UCRT64 GCC installed. Raylib was installed using the raylib installer from their website. I can use GCC from the command line.
Yet when I load cl-raylib (git cloned into local projects and loaded via (ql:quickload :cl-raylib)) the following error message appears:

Couldn't execute "gcc": The system cannot find the file specified.
   [Condition of type CFFI-GROVEL:GROVEL-ERROR]

Restarts:
 0: [RETRY] Retry #<PROCESS-OP > on #<GROVEL-FILE "cffi-libffi" "libffi" "libffi-types">.
 1: [ACCEPT] Continue, treating #<PROCESS-OP > on #<GROVEL-FILE "cffi-libffi" "libffi" "libffi-types"> as having been successful.
 2: [RETRY] Retry ASDF operation.
 3: [CLEAR-CONFIGURATION-AND-RETRY] Retry ASDF operation after resetting the configuration.
 4: [RETRY] Retry ASDF operation.
 5: [CLEAR-CONFIGURATION-AND-RETRY] Retry ASDF operation after resetting the configuration.
 6: [ABORT] Give up on "cl-raylib"
 7: [REGISTER-LOCAL-PROJECTS] Register local projects and try again.
 8: [RETRY] Retry SLIME REPL evaluation request.
 9: [*ABORT] Return to SLIME's top level.
 10: [ABORT] abort thread (#<THREAD "repl-thread" RUNNING {1001940143}>)

Backtrace:
  0: (CFFI-GROVEL:GROVEL-ERROR "~a" #<SIMPLE-ERROR "Couldn't execute ~S: ~A" {1001E49153}>)
  1: ((FLET "THUNK" :IN CFFI-GROVEL:PROCESS-GROVEL-FILE))
  2: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<FUNCTION (FLET "THUNK" :IN CFFI-GROVEL:PROCESS-GROVEL-FILE) {5B9DABB}>)
  3: (CFFI-GROVEL:PROCESS-GROVEL-FILE #P"C:/Users/david/quicklisp/dists/quicklisp/software/cffi-20231021-git/libffi/libffi-types.lisp" #P"C:/Users/david/AppData/Local/cache/common-lisp/sbcl-2.3.2-win-x64/C..
  4: ((:METHOD ASDF/ACTION:PERFORM (CFFI-GROVEL::PROCESS-OP CFFI-GROVEL:GROVEL-FILE)) #<CFFI-GROVEL::PROCESS-OP > #<CFFI-GROVEL:GROVEL-FILE "cffi-libffi" "libffi" "libffi-types">) [fast-method]
  5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<CFFI-GROVEL::PROCESS-OP > #<CFFI-GROVEL:GROVEL-FILE "cffi-libffi" "libffi" "libffi-types">)
  6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
  7: ((:METHOD ASDF/ACTION:PERFORM :AROUND (CFFI-GROVEL::PROCESS-OP CFFI-GROVEL::CC-FLAGS-MIXIN)) #<CFFI-GROVEL::PROCESS-OP > #<CFFI-GROVEL:GROVEL-FILE "cffi-libffi" "libffi" "libffi-types">) [fast-method]
  8: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<CFFI-GROVEL::PROCESS-OP > #<CFFI-GROVEL:GROVEL-FILE "cffi-libffi" "libffi" "libffi-types">) [fast-method]
  9: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1001BB3823}>) [fast-method]
 10: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
 11: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1001BB3823}>) [fast-method]
 12: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cl-raylib"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
 13: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cl-raylib"> :VERBOSE NIL)
 14: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
 15: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cl-raylib"> :VERBOSE NIL) [fast-method]
 16: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "cl-raylib" :VERBOSE NIL)
 17: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
 18: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-raylib" :VERBOSE NIL) [fast-method]
 19: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1001B9EA3B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
 20: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
 21: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1001B99BAB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
 22: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cl-raylib" :VERBOSE NIL) [fast-method]
 23: (ASDF/OPERATE:LOAD-SYSTEM "cl-raylib" :VERBOSE NIL)
 24: (QUICKLISP-CLIENT::CALL-WITH-MACROEXPAND-PROGRESS #<FUNCTION (LAMBDA NIL :IN QUICKLISP-CLIENT::APPLY-LOAD-STRATEGY) {1001B9973B}>)
 25: (QUICKLISP-CLIENT::AUTOLOAD-SYSTEM-AND-DEPENDENCIES "cl-raylib" :PROMPT NIL)
 26: ((:METHOD QL-IMPL-UTIL::%CALL-WITH-QUIET-COMPILATION (T T)) #<unused argument> #<FUNCTION (FLET QUICKLISP-CLIENT::QL :IN QUICKLISP-CLIENT:QUICKLOAD) {100196C91B}>) [fast-method]
 27: ((:METHOD QL-IMPL-UTIL::%CALL-WITH-QUIET-COMPILATION :AROUND (QL-IMPL:SBCL T)) #<QL-IMPL:SBCL {1004C68FD3}> #<FUNCTION (FLET QUICKLISP-CLIENT::QL :IN QUICKLISP-CLIENT:QUICKLOAD) {100196C91B}>) [fast-m..
 28: ((:METHOD QUICKLISP-CLIENT:QUICKLOAD (T)) :CL-RAYLIB :PROMPT NIL :SILENT NIL :VERBOSE NIL) [fast-method]
 29: (QL-DIST::CALL-WITH-CONSISTENT-DISTS #<FUNCTION (LAMBDA NIL :IN QUICKLISP-CLIENT:QUICKLOAD) {10019685CB}>)
 30: (SB-INT:SIMPLE-EVAL-IN-LEXENV (QUICKLISP-CLIENT:QUICKLOAD :CL-RAYLIB) #<NULL-LEXENV>)
 31: (EVAL (QUICKLISP-CLIENT:QUICKLOAD :CL-RAYLIB))
 32: (SWANK::EVAL-REGION "(ql:quickload :cl-raylib) ..)
 33: ((LAMBDA NIL :IN SWANK-REPL::REPL-EVAL))
 34: (SWANK-REPL::TRACK-PACKAGE #<FUNCTION (LAMBDA NIL :IN SWANK-REPL::REPL-EVAL) {100196852B}>)
 35: (SWANK::CALL-WITH-RETRY-RESTART "Retry SLIME REPL evaluation request." #<FUNCTION (LAMBDA NIL :IN SWANK-REPL::REPL-EVAL) {10019684CB}>)
 36: (SWANK::CALL-WITH-BUFFER-SYNTAX NIL #<FUNCTION (LAMBDA NIL :IN SWANK-REPL::REPL-EVAL) {10019684AB}>)
 37: (SWANK-REPL::REPL-EVAL "(ql:quickload :cl-raylib) ..)
 38: (SB-INT:SIMPLE-EVAL-IN-LEXENV (SWANK-REPL:LISTENER-EVAL "(ql:quickload :cl-raylib) ..)
 39: (EVAL (SWANK-REPL:LISTENER-EVAL "(ql:quickload :cl-raylib) ..)
 40: (SWANK:EVAL-FOR-EMACS (SWANK-REPL:LISTENER-EVAL "(ql:quickload :cl-raylib) ..)
 41: (SWANK::PROCESS-REQUESTS NIL)
 42: ((LAMBDA NIL :IN SWANK::HANDLE-REQUESTS))
 43: ((LAMBDA NIL :IN SWANK::HANDLE-REQUESTS))
 44: (SWANK/SBCL::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<FUNCTION (LAMBDA NIL :IN SWANK::HANDLE-REQUESTS) {100196802B}>)
 45: ((FLET SWANK/BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "c:/Users/david/.emacs.d/.local/straight/build-29.2/slime/swank/sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<FUNCTION (LAMBDA NIL :IN SWANK::HAN..
 46: (SWANK::CALL-WITH-BINDINGS ((*STANDARD-INPUT* . #<SWANK/GRAY::SLIME-INPUT-STREAM {1001750D73}>)) #<FUNCTION (LAMBDA NIL :IN SWANK::HANDLE-REQUESTS) {100196804B}>)
 47: (SWANK::HANDLE-REQUESTS #<SWANK::MULTITHREADED-CONNECTION {100403CC43}> NIL)
 48: ((FLET SB-UNIX::BODY :IN SB-THREAD::RUN))
 49: ((FLET "WITHOUT-INTERRUPTS-BODY-138" :IN SB-THREAD::RUN))
 50: ((FLET SB-UNIX::BODY :IN SB-THREAD::RUN))
 51: ((FLET "WITHOUT-INTERRUPTS-BODY-131" :IN SB-THREAD::RUN))
 52: (SB-THREAD::RUN)
 53: ("foreign function: #x14003EBE5")
 54: ("foreign function: #x14000685A")

`load-render-texture` causes a type error about `SB-SYS:SYSTEM-AREA-POINTER`

When attempting to invoke (load-render-texture 100 100) the spirits from within this library sing these omenous messages:

The value
  #S(CL-RAYLIB::TEXTURE
     :ID 3
     :WIDTH 100
     :HEIGHT 100
     :MIPMAPS 1
     :FORMAT 7)

is not of type
  SB-SYS:SYSTEM-AREA-POINTER
   [Condition of type TYPE-ERROR]

Could this, perhaps, be related to 10?