You are looking at historical revision 32882 of this page. It may differ significantly from its current revision.

sdl2

Introduction

The sdl2 egg provides bindings to Simple DirectMedia Layer version 2 (SDL2). SDL is a popular library used in games and other media-rich software.

The sdl2 egg provides a programmer-friendly, convenient, and CHICKEN-idiomatic interface to SDL2. It takes care of the annoying low-level C stuff for you, so you can focus on making your game.

If a feature you need is not yet available, please file a feature request or contact a maintainer, so we can prioritize adding it.

Project / Source Code Repository

https://gitlab.com/chicken-sdl2/chicken-sdl2

Issue Tracker

https://gitlab.com/chicken-sdl2/chicken-sdl2/issues

Maintainer

John Croisant (john+chicken at croisant dot net)

License

BSD 2-Clause

Help Wanted!

This egg needs volunteers to help with several things:

• Manual testing (installing, running examples) on different platforms
• Writing unit tests and semi-automated test programs
• Writing API reference docs, guides, and tutorials
• Creating detailed installation instructions for different platforms
• Creating feature demos and example games/programs

If you wish to help in any way, please contact the project maintainer.

Requirements

The sdl2 egg requires Simple DirectMedia Layer version 2.0.0 or higher. It will not work with older versions of SDL.

The unit tests depend on the test egg, and many demos and examples depend on the miscmacros egg. Some demos and examples have other dependencies as well.

Installation

ATTENTION: The sdl2 egg has not been released yet. For now, you must download it from its source code repository and follow the instructions in the README.

When installing the egg, you should set the SDL2_FLAGS environment variable to a string of compiler flags to be used when compiling the egg. If you have the sdl2-config helper program installed on your system, you can set appropriate flags and install the extension like so (notice these are back ticks, not quotes):

export SDL2_FLAGS=`sdl2-config --cflags --libs`
chicken-install sdl2

If you do not have the sdl2-config helper program installed on your computer, you may manually specify SDL-related compiler flags (notice these are double quotes, not back ticks):

export SDL2_FLAGS="-I/usr/local/include/SDL2 -L/usr/local/lib -lSDL2"
chicken-install sdl2

The SDL2_FLAGS environment variable only needs to be set during installation of the egg, not during normal use.

Usage and Examples

It is recommended that you import the sdl2 module using the prefix "sdl2:", like so:

(use (prefix sdl2 sdl2:))
(sdl2:init! '(everything))
(sdl2:create-window! "Test" 0 0 600 400)
(sdl2:delay! 1000)
(sdl2:quit!)

The demos directory contains small programs demonstrating how to use various features of sdl2. E.g. to compile and run the basics demo:

csc demos/basics.scm
demos/basics

The chicken-sdl2-examples repository contains complete example games and programs made with sdl2.

Related Libraries

The sdl2-image egg provides bindings to version 2 of the SDL_image library, which provides the ability to load many image formats. It is built to be compatible with sdl2.

The sdl-base egg provides bindings to older versions of SDL. Its API is not compatible with sdl2.

Version History

The sdl2 egg has not yet been released. Coming soon!

Backwards Compatibility and Stability

The sdl2 egg follows "semantic versioning". The API is not stable until version 1.0 is released. That means the API may change in ways that break backwards compatibility with previous versions. After version 1.0 is released, the API will remain stable (no backwards-incompatible changes) until the next new major version (e.g. going from version 1.x to 2.0, or 2.x to 3.0).

The sdl2 egg's API is not cross-compatible with the sdl-base egg.

API

Conventions

• Procedure names are lower case and hyphenated, with no "SDL_" prefix.
• Procedures that return #t or #f are suffixed with "?".
• Procedures that cause a mutation or side effect are suffixed with "!".
• Procedures that set the value of an attribute are named like TYPE-ATTR-set!, e.g. rect-x-set!.
  • In most cases, it is also possible to use (set! ...) to set the value of attributes, e.g. (set! (rect-x my-rect) 42).
• Some procedures return multiple values, e.g. window-size returns two values, the width and height. You can use receive, let-values, etc. to catch all the return values.
• Procedures that allocate a new struct often have two versions, one that returns a managed struct record and one that returns an unmanaged struct record, e.g. make-surface and make-surface*. See the Struct Memory Management section below for more information.
• Some procedures have a "raw" version, which returns a value that is "lower level", such as an integer constant or memory pointer. These are intended for advanced usage, such as interoperating with other libraries, or for situations where performance is more important than convenience or safety.
• Many procedures that return an enum symbol or a list of enum symbols, also have a "raw" version that returns an integer value, e.g. event-type and event-type-raw.
  • Setters that accept an enum symbol will also accept the corresponding integer value. Setters that accept a list of enum symbols will also accept an integer representing bitwise-or'd integer flags or masks.
• Procedures with a name containing the word "color" have an alias spelled as "colour", for the convenience of anyone who spells it that way. Both names refer to exactly the same procedure.

Enums

The sdl2 egg uses symbols instead of integer constants, for things like event types, keyboard keys, and init flags. It uses lists of symbols instead of bitwise-or'd integer masks or flags. See the enum tables for details.

Struct Record Types

The sdl2 egg has many "struct record types", which are record types that wrap a pointer to a certain kind of C structure from SDL. For example, the sdl2:surface record type wraps a pointer to an SDL_Surface struct.

Each struct record type has some associated procedures, which get or set the value of a certain field of the underlying C struct.

Struct Memory Management

Some struct record types have procedures for allocating or freeing an instance of that type. Each type that can be allocated has two "make" procedures:

• The procedure with NO asterisk (e.g. make-event) returns a managed struct record, whose underlying struct will be automatically freed when the record is garbage collected.
• The procedure with an asterisk (e.g. make-event*) returns an unmanaged struct record, which must be manually freed when you are done with it (e.g. using free-event!).

Certain other procedures that return new struct records also follow this convention, for example load-bmp vs. load-bmp*.

In general, it is recommended to create managed struct records, so that you don't have to worry about manually freeing them. However, there is a slight performance overhead for each managed struct record, so if you are creating and destroying very many struct records, you can improve performance by creating unmanaged struct records and manually freeing them when you are done with them. (But be careful! If you forget to free them, your program will leak memory.)

If you create an unmanaged struct record but later change your mind, you can start managing it by using set-finalizer! with the appropriate "free" procedure. (Note: it is not currently possible to stop managing a struct record.) For example:

;; Allocate an unmanaged sdl2:event.
(let ((my-event (sdl2:make-event*)))
  ;; Overwrite its data with the next pending event.
  (sdl2:wait-event! my-event)

  (case (sdl2:event-type my-event)
    ;; Put keyboard events in a queue for later processing. We aren't
    ;; sure how long it will live, so start managing it, to be safe.
    ((key-down key-up)
     (set-finalizer! my-event sdl2:free-event!)
     (put-in-queue my-event))
    ;; If it is any other type of event, perform an immediate action
    ;; on it, then free it.
    (else
     (perform-immediate-action my-event)
     (sdl2:free-event! my-event))))

It is safe to manually free managed struct records. In fact, doing so can be beneficial to your program's memory footprint and performance, because there will be less memory waiting to be freed by the garbage collector. For example:

(let ((my-surf (sdl2:make-surface 800 600 32)))
  ;; ... do stuff with my-surf ...
  ;; Once you are done with my-surf, manually free it.
  (sdl2:free-surface! my-surf))

As soon as you free a struct record, its pointer will be set to null, and it will no longer be usable for most purposes. You cannot get or set its fields, or pass it as an argument to most procedures. So be careful not to free struct records that you still want to use!

Some struct record types, such as sdl2:window, are not managed in this way. Instead, you use certain SDL functions to work with them, such as create-window! and destroy-window!.

[procedure] (struct-null? record) → boolean

Returns #t if the given record is wrapping a null pointer (i.e. a pointer with memory address 0). This procedure can be used with any struct record type provided by this library.

There are two common reasons why a record might be wrapping a null pointer:

• After you free a record (e.g. using free-surface!), its pointer will be set to null.
• Certain procedures may return a record with a null pointer if an error occurs or the requested object does not exist.

It is an error to get or set any field of a record that is wrapping a null pointer. And, it is an error to pass null struct records to many procedures. So, you can use this procedure to check whether it is safe to use the record.

sdl2:audio-cvt

sdl2:audio-cvt is a record type that wraps a pointer to an SDL_AudioCVT struct.

[procedure] (audio-cvt? obj) → boolean

Returns #t if obj is an sdl2:audio-cvt.

[procedure] (audio-cvt-needed audio-cvt) → fixnum

Get the sdl2:audio-cvt's "needed" field, as an integer.

[procedure] (audio-cvt-src-format audio-cvt) → symbol
[procedure] (audio-cvt-src-format-raw audio-cvt) → fixnum

Get the sdl2:audio-cvt's "src-format" field.

• audio-cvt-src-format returns an audio format symbol.
• audio-cvt-src-format-raw returns an integer.

[procedure] (audio-cvt-dst-format audio-cvt) → symbol
[procedure] (audio-cvt-dst-format-raw audio-cvt) → fixnum

Get the sdl2:audio-cvt's "dst-format" field.

• audio-cvt-dst-format returns an audio format symbol.
• audio-cvt-dst-format-raw returns an integer.

[procedure] (audio-cvt-rate-incr audio-cvt) → double

Get the sdl2:audio-cvt's "rate-incr" field, as a double precision floating point number.

[procedure] (audio-cvt-buf-raw audio-cvt) → pointer

Get the sdl2:audio-cvt's "buf" field, as a pointer to a C array of Uint8 numbers. Use audio-cvt-len to get the length of the array.

[procedure] (audio-cvt-len audio-cvt) → fixnum

Get the sdl2:audio-cvt's "len" field, as an integer. This is the length of the array returned by audio-cvt-buf-raw.

[procedure] (audio-cvt-len-cvt audio-cvt) → fixnum

Get the sdl2:audio-cvt's "len-cvt" field, as an integer.

[procedure] (audio-cvt-len-mult audio-cvt) → fixnum

Get the sdl2:audio-cvt's "len-mult" field, as an integer.

[procedure] (audio-cvt-len-ratio audio-cvt) → double

Get the sdl2:audio-cvt's "len-ratio" field, as a double precision floating point number.

sdl2:audio-spec

sdl2:audio-spec is a record type that wraps a pointer to an SDL_AudioSpec struct.

[procedure] (audio-spec? obj) → boolean

Returns #t if obj is an sdl2:audio-spec.

[procedure] (audio-spec-freq audio-spec) → fixnum
[setter] (set! (audio-spec-freq audio-spec) val)
[setter] (audio-spec-freq-set! audio-spec val)

Get or set the sdl2:audio-spec's "freq" field, as an integer (int).

[procedure] (audio-spec-format audio-spec) → symbol
[procedure] (audio-spec-format-raw audio-spec) → fixnum
[setter] (set! (audio-spec-format audio-spec) val)
[setter] (audio-spec-format-set! audio-spec val)

Get or set the sdl2:audio-spec's "format" field.

• audio-spec-format returns an audio format symbol.
• audio-spec-format-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (audio-spec-channels audio-spec) → fixnum
[setter] (set! (audio-spec-channels audio-spec) val)
[setter] (audio-spec-channels-set! audio-spec val)

Get or set the sdl2:audio-spec's "channels" field, as an integer (Uint8).

[procedure] (audio-spec-silence audio-spec) → fixnum

Get the sdl2:audio-spec's "silence" field, as an integer (Uint8).

[procedure] (audio-spec-samples audio-spec) → fixnum
[setter] (set! (audio-spec-samples audio-spec) val)
[setter] (audio-spec-samples-set! audio-spec val)

Get or set the sdl2:audio-spec's "samples" field, as an integer (Uint16).

[procedure] (audio-spec-size audio-spec) → fixnum

Get the sdl2:audio-spec's "size" field, as an integer (Uint32).

[procedure] (audio-spec-userdata-raw audio-spec) → pointer
[setter] (set! (audio-spec-userdata-raw audio-spec) val)
[setter] (audio-spec-userdata-raw-set! audio-spec val)

Get or set the sdl2:audio-spec's "userdata" field, as a pointer.

sdl2:color

sdl2:color is a record type that wraps a pointer to an SDL_Color struct.

[procedure] (color? obj) → boolean
[procedure] (colour? obj) → boolean

Returns #t if obj is an sdl2:color.

[procedure] (make-color #!optional r g b a) → sdl2:color
[procedure] (make-colour #!optional r g b a) → sdl2:color
[procedure] (make-color* #!optional r g b a) → sdl2:color
[procedure] (make-colour* #!optional r g b a) → sdl2:color

Allocate and initialize a new sdl2:color.

r, g, b, and a must be integers in the range 0 to 255 (inclusive). r, g, and b default to 0. a defaults to 255 (full opacity).

• make-color and make-colour return a managed sdl2:color.
• make-color* and make-colour* return an unmanaged sdl2:color, which must be freed using free-color! when you are done with it.

[procedure] (free-color! color)
[procedure] (free-colour! color)

Free the memory of the sdl2:color's underlying struct. color's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:colors. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (color-r color) → fixnum
[procedure] (colour-r color) → fixnum
[setter] (set! (color-r color) val)
[setter] (set! (colour-r color) val)
[setter] (color-r-set! color val)
[setter] (colour-r-set! color val)

Get or set the sdl2:color's "r" (red) field, as an integer in the range 0 to 255 (inclusive).

[procedure] (color-g color) → fixnum
[procedure] (colour-g color) → fixnum
[setter] (set! (color-g color) val)
[setter] (set! (colour-g color) val)
[setter] (color-g-set! color val)
[setter] (colour-g-set! color val)

Get or set the sdl2:color's "g" (green) field, as an integer in the range 0 to 255 (inclusive).

[procedure] (color-b color) → fixnum
[procedure] (colour-b color) → fixnum
[setter] (set! (color-b color) val)
[setter] (set! (colour-b color) val)
[setter] (color-b-set! color val)
[setter] (colour-b-set! color val)

Get or set the sdl2:color's "b" (blue) field, as an integer in the range 0 to 255 (inclusive).

[procedure] (color-a color) → fixnum
[procedure] (colour-a color) → fixnum
[setter] (set! (color-a color) val)
[setter] (set! (colour-a color) val)
[setter] (color-a-set! color val)
[setter] (colour-a-set! color val)

Get or set the sdl2:color's "a" (alpha) field, as an integer in the range 0 to 255 (inclusive).

[setter] (color-set! color #!optional r g b a) → color
[setter] (colour-set! color #!optional r g b a) → color

Convenient way of setting multiple fields of the sdl2:color. Any arguments that are #f will cause no change to that field. E.g. (color-set! my-color 42 #f 255 #f) will set the "r" field to 42 and the "b" field to 255, but will not change the "g" or "a" fields. Returns color after it is modified.

[procedure] (color->list color) → list of fixnums
[procedure] (colour->list color) → list of fixnums

Returns a list (r g b a) containing the value of each field of the sdl2:color.

[procedure] (color=? color1 color2) → boolean
[procedure] (colour=? color1 color2) → boolean

Efficiently compare two sdl2:colors. Returns #t if the value of every field in color1 is equal to the value of the corresponding field in color2.

[procedure] (copy-color color) → sdl2:color
[procedure] (copy-colour color) → sdl2:color
[procedure] (copy-color* color) → sdl2:color
[procedure] (copy-colour* color) → sdl2:color

Efficiently copy the given sdl2:color, returning a new sdl2:color with the same values.

• copy-color and copy-colour return a managed sdl2:color.
• copy-color* and copy-colour* return an unmanaged sdl2:color, which must be freed using free-color! when you are done with it.

sdl2:cursor

sdl2:cursor is a record type that wraps a pointer to an SDL_Cursor struct.

[procedure] (cursor? obj) → boolean

Returns #t if obj is an sdl2:cursor.

sdl2:display-mode

sdl2:display-mode is a record type that wraps a pointer to an SDL_DisplayMode struct.

[procedure] (display-mode? obj) → boolean

Returns #t if obj is an sdl2:display-mode.

[procedure] (make-display-mode #!optional format w h refresh-rate) → sdl2:display-mode
[procedure] (make-display-mode* #!optional format w h refresh-rate) → sdl2:display-mode

Allocate and initialize a new sdl2:display-mode.

format defaults to 'unknown. It must be a pixel format symbol or equivalent integer.

w, h, and refresh-rate default to 0. They must be integers.

• make-display-mode returns a managed sdl2:display-mode.
• make-display-mode* returns an unmanaged sdl2:display-mode, which must be freed with free-display-mode! when you are done with it.

[procedure] (free-display-mode! display-mode)

Free the memory of the sdl2:display-mode's underlying struct. display-mode's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:display-modes. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (display-mode-format display-mode) → symbol
[procedure] (display-mode-format-raw display-mode) → fixnum
[setter] (set! (display-mode-format display-mode) val)
[setter] (display-mode-format-set! display-mode val)

Get or set the sdl2:display-mode's "format" field.

• display-mode-format returns a pixel format symbol.
• display-mode-format-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (display-mode-w display-mode) → fixnum
[setter] (set! (display-mode-w display-mode) val)
[setter] (display-mode-w-set! display-mode val)

Get or set the sdl2:display-mode's "w" field, as an integer.

[procedure] (display-mode-h display-mode) → fixnum
[setter] (set! (display-mode-h display-mode) val)
[setter] (display-mode-h-set! display-mode val)

Get or set the sdl2:display-mode's "h" field, as an integer.

[procedure] (display-mode-refresh-rate display-mode) → fixnum
[setter] (set! (display-mode-refresh-rate display-mode) val)
[setter] (display-mode-refresh-rate-set! display-mode val)

Get or set the sdl2:display-mode's "refresh-rate" field, as an integer.

sdl2:event

sdl2:event is a record type that wraps a pointer to an SDL_Event. There are many specific event structs in SDL, and the sdl2:event type wraps them all. Each event struct has a corresponding variant of sdl2:event, described below. Each variant has one or more associated event type symbols.

Variant of sdl2:event	Underlying struct	Event type symbol(s)
sdl2:controller-axis-event	SDL_ControllerAxisEvent	controller-axis-motion
sdl2:controller-button-event	SDL_ControllerButtonEvent	controller-button-down controller-button-up
sdl2:controller-device-event	SDL_ControllerDeviceEvent	controller-device-added controller-device-removed controller-device-remapped
sdl2:dollar-gesture-event	SDL_DollarGestureEvent	dollar-gesture dollar-record
sdl2:drop-event	SDL_DropEvent	drop-file
sdl2:joy-axis-event	SDL_JoyAxisEvent	joy-axis-motion
sdl2:joy-ball-event	SDL_JoyBallEvent	joy-ball-motion
sdl2:joy-button-event	SDL_JoyButtonEvent	joy-button-down joy-button-up
sdl2:joy-device-event	SDL_JoyDeviceEvent	joy-device-added joy-device-removed
sdl2:joy-hat-event	SDL_JoyHatEvent	joy-hat-motion
sdl2:keyboard-event	SDL_KeyboardEvent	key-down key-up
sdl2:mouse-button-event	SDL_MouseButtonEvent	mouse-button-down mouse-button-up
sdl2:mouse-motion-event	SDL_MouseMotionEvent	mouse-motion
sdl2:mouse-wheel-event	SDL_MouseWheelEvent	mouse-wheel
sdl2:multi-gesture-event	SDL_MultiGestureEvent	multi-gesture
sdl2:quit-event	SDL_QuitEvent	quit
sdl2:sys-wm-event	SDL_SysWMEvent	sys-wm
sdl2:text-editing-event	SDL_TextEditingEvent	text-editing
sdl2:text-input-event	SDL_TextInputEvent	text-input
sdl2:touch-finger-event	SDL_TouchFingerEvent	finger-down finger-up finger-motion
sdl2:user-event	SDL_UserEvent	Call register-events! to register your own custom event type symbols
sdl2:window-event	SDL_WindowEvent	window

[procedure] (event? obj) → boolean

Returns #t if obj is any variant of sdl2:event.

[procedure] (make-event #!optional type) → sdl2:event
[procedure] (make-event* #!optional type) → sdl2:event

Allocate and set the type of a new sdl2:event.

type defaults to 'first. It must be a event type symbol or equivalent integer.

• make-event returns a managed sdl2:event.
• make-event* returns an unmanaged sdl2:event, which must be freed with free-event! when you are done with it.

[procedure] (free-event! event)

Free the memory of the sdl2:event's underlying struct. You can call this procedure with any variant of sdl2:event. event's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:events. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (event-type event) → symbol
[procedure] (event-type-raw event) → fixnum
[setter] (set! (event-type event) val)
[setter] (event-type-set! event val)

Get or set the sdl2:event's "type" field. You can use these procedures with any variant of sdl2:event. Setting this will change what variant of sdl2:event it is. E.g. if you set it to 'key-down, the event will become an sdl2:keyboard-event.

• event-type returns an event type symbol.
• event-type-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (event-timestamp event) → fixnum
[setter] (set! (event-timestamp event) val)
[setter] (event-timestamp-set! event val)

Get or set the sdl2:event's "timestamp" field, as a nonnegative integer representing the time that the event occurred, in milliseconds since the SDL timer system was initialized. You can use these procedures with any variant of sdl2:event.

sdl2:controller-axis-event

sdl2:controller-axis-event is a variant of sdl2:event that wraps a pointer to an SDL_ControllerAxisEvent.

[procedure] (controller-axis-event? obj) → boolean

Returns #t if obj is an sdl2:controller-axis-event.

[procedure] (controller-axis-event-which event) → fixnum
[setter] (set! (controller-axis-event-which event) val)
[setter] (controller-axis-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the controller (joystick) that the event is related to.

[procedure] (controller-axis-event-axis event) → fixnum
[setter] (set! (controller-axis-event-axis event) val)
[setter] (controller-axis-event-axis-set! event val)

Get or set the event's "axis" field, as an integer indicating the axis that the event is related to. E.g. 0 indicates the first axis on the controller.

[procedure] (controller-axis-event-value event) → fixnum
[setter] (set! (controller-axis-event-value event) val)
[setter] (controller-axis-event-value-set! event val)

Get or set the event's "value" field, as an integer in the range -32768 to 32767 (inclusive), indicating the new value of the axis.

sdl2:controller-button-event

sdl2:controller-button-event is a variant of sdl2:event that wraps a pointer to an SDL_ControllerButtonEvent.

[procedure] (controller-button-event? obj) → boolean

Returns #t if obj is an sdl2:controller-button-event.

[procedure] (controller-button-event-which event) → fixnum
[setter] (set! (controller-button-event-which event) val)
[setter] (controller-button-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the controller (joystick) that the event is related to.

[procedure] (controller-button-event-button event) → fixnum
[setter] (set! (controller-button-event-button event) val)
[setter] (controller-button-event-button-set! event val)

Get or set the event's "button" field, as an integer indicating the button that the event is related to. E.g. 0 indicates the first button on the controller.

[procedure] (controller-button-event-state event) → boolean
[setter] (set! (controller-button-event-state event) val)
[setter] (controller-button-event-state-set! event val)

Get or set the event's "state" field, as a boolean indicating whether the button was pressed (#t) or released (#f). You can also find out by checking the event type: 'controller-button-down for pressed, or 'controller-button-up for released.

sdl2:controller-device-event

sdl2:controller-device-event is a variant of sdl2:event that wraps a pointer to an SDL_ControllerDeviceEvent.

[procedure] (controller-device-event? obj) → boolean

Returns #t if obj is an sdl2:controller-device-event.

[procedure] (controller-device-event-which event) → fixnum
[setter] (set! (controller-device-event-which event) val)
[setter] (controller-device-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the controller (joystick) that the event is related to.

sdl2:dollar-gesture-event

sdl2:dollar-gesture-event is a variant of sdl2:event that wraps a pointer to an SDL_DollarGestureEvent.

[procedure] (dollar-gesture-event? obj) → boolean

Returns #t if obj is an sdl2:dollar-gesture-event.

[procedure] (dollar-gesture-event-touch-id event) → fixnum
[setter] (set! (dollar-gesture-event-touch-id event) val)
[setter] (dollar-gesture-event-touch-id-set! event val)

Get or set the event's "touch-id" field, as an integer indicating the ID number of the touch device this event is related to.

[procedure] (dollar-gesture-event-gesture-id event) → fixnum
[setter] (set! (dollar-gesture-event-gesture-id event) val)
[setter] (dollar-gesture-event-gesture-id-set! event val)

Get or set the event's "gesture-id" field, as an integer indicating the ID number of the closest gesture to the performed stroke.

[procedure] (dollar-gesture-event-num-fingers event) → fixnum
[setter] (set! (dollar-gesture-event-num-fingers event) val)
[setter] (dollar-gesture-event-num-fingers-set! event val)

Get or set the event's "num-fingers" field, as an integer indicating the number of fingers used to draw the stroke.

[procedure] (dollar-gesture-event-error event) → float
[setter] (set! (dollar-gesture-event-error event) val)
[setter] (dollar-gesture-event-error-set! event val)

Get or set the event's "error" field, as a float indicating the difference between the gesture template and the actual performed gesture. Lower error is a better match.

[procedure] (dollar-gesture-event-x event) → float
[setter] (set! (dollar-gesture-event-x event) val)
[setter] (dollar-gesture-event-x-set! event val)

Get or set the event's "x" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized X coordinate of the center of the gesture.

[procedure] (dollar-gesture-event-y event) → float
[setter] (set! (dollar-gesture-event-y event) val)
[setter] (dollar-gesture-event-y-set! event val)

Get or set the event's "y" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized Y coordinate of the center of the gesture.

sdl2:drop-event

sdl2:drop-event is a variant of sdl2:event that wraps a pointer to an SDL_DropEvent.

[procedure] (drop-event? obj) → boolean

Returns #t if obj is an sdl2:drop-event.

[procedure] (drop-event-file event) → string
[setter] (set! (drop-event-file event) val)
[setter] (drop-event-file-set! event val)

Get or set the event's "file" field, as a string indicating the path to a file that was dropped onto the application.

sdl2:joy-axis-event

sdl2:joy-axis-event is a variant of sdl2:event that wraps a pointer to an SDL_JoyAxisEvent.

[procedure] (joy-axis-event? obj) → boolean

Returns #t if obj is an sdl2:joy-axis-event.

[procedure] (joy-axis-event-which event) → fixnum
[setter] (set! (joy-axis-event-which event) val)
[setter] (joy-axis-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the joystick that the event is related to.

[procedure] (joy-axis-event-axis event) → fixnum
[setter] (set! (joy-axis-event-axis event) val)
[setter] (joy-axis-event-axis-set! event val)

Get or set the event's "axis" field, as an integer indicating the axis that the event is related to. E.g. 0 indicates the first axis on the joystick.

[procedure] (joy-axis-event-value event) → fixnum
[setter] (set! (joy-axis-event-value event) val)
[setter] (joy-axis-event-value-set! event val)

Get or set the event's "value" field, as an integer in the range -32768 to 32767 (inclusive), indicating the new value of the axis.

sdl2:joy-ball-event

sdl2:joy-ball-event is a variant of sdl2:event that wraps a pointer to an SDL_JoyBallEvent.

[procedure] (joy-ball-event? obj) → boolean

Returns #t if obj is an sdl2:joy-ball-event.

[procedure] (joy-ball-event-which event) → fixnum
[setter] (set! (joy-ball-event-which event) val)
[setter] (joy-ball-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the joystick that the event is related to.

[procedure] (joy-ball-event-ball event) → fixnum
[setter] (set! (joy-ball-event-ball event) val)
[setter] (joy-ball-event-ball-set! event val)

Get or set the event's "ball" field, as an integer indicating the trackball that the event is related to. E.g. 0 indicates the first trackball on the joystick.

[procedure] (joy-ball-event-xrel event) → fixnum
[setter] (set! (joy-ball-event-xrel event) val)
[setter] (joy-ball-event-xrel-set! event val)

Get or set the event's "xrel" field, as an integer (possibly negative) indicating how the trackball's X position changed relative to its previous position.

[procedure] (joy-ball-event-yrel event) → fixnum
[setter] (set! (joy-ball-event-yrel event) val)
[setter] (joy-ball-event-yrel-set! event val)

Get or set the event's "yrel" field, as an integer (possibly negative) indicating how the trackball's Y position changed relative to its previous position.

sdl2:joy-button-event

sdl2:joy-button-event is a variant of sdl2:event that wraps a pointer to an SDL_JoyButtonEvent.

[procedure] (joy-button-event? obj) → boolean

Returns #t if obj is an sdl2:joy-button-event.

[procedure] (joy-button-event-which event) → fixnum
[setter] (set! (joy-button-event-which event) val)
[setter] (joy-button-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the joystick that the event is related to.

[procedure] (joy-button-event-button event) → fixnum
[setter] (set! (joy-button-event-button event) val)
[setter] (joy-button-event-button-set! event val)

Get or set the event's "button" field, as an integer indicating the button that the event is related to. E.g. 0 indicates the first button on the joystick.

[procedure] (joy-button-event-state event) → boolean
[setter] (set! (joy-button-event-state event) val)
[setter] (joy-button-event-state-set! event val)

Get or set the value of the event's "state" field, as a boolean indicating whether the button was pressed (#t) or released (#f). You can also find out by checking the event type: 'joy-button-down for pressed, or 'joy-button-up for released.

sdl2:joy-device-event

sdl2:joy-device-event is a variant of sdl2:event that wraps a pointer to an SDL_JoyDeviceEvent.

[procedure] (joy-device-event? obj) → boolean

Returns #t if obj is an sdl2:joy-device-event.

[procedure] (joy-device-event-which event) → fixnum
[setter] (set! (joy-device-event-which event) val)
[setter] (joy-device-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the joystick that the event is related to.

sdl2:joy-hat-event

sdl2:joy-hat-event is a variant of sdl2:event that wraps a pointer to an SDL_JoyHatEvent.

[procedure] (joy-hat-event? obj) → boolean

Returns #t if obj is an sdl2:joy-hat-event.

[procedure] (joy-hat-event-which event) → fixnum
[setter] (set! (joy-hat-event-which event) val)
[setter] (joy-hat-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the device index of the joystick that the event is related to.

[procedure] (joy-hat-event-hat event) → fixnum
[setter] (set! (joy-hat-event-hat event) val)
[setter] (joy-hat-event-hat-set! event val)

Get or set the event's "hat" field, as an integer indicating the hat switch that the event is related to. E.g. 0 indicates the first hat switch on the joystick.

[procedure] (joy-hat-event-value event) → symbol
[procedure] (joy-hat-event-value-raw event) → fixnum
[setter] (set! (joy-hat-event-value event) val)
[setter] (joy-hat-event-value-set! event val)

Get or set the event's "value" field, indicating the new position of the hat switch.

• joy-hat-event-value returns a joystick hat position symbol.
• joy-hat-event-value-raw returns an integer.
• The setters accept either a symbol or an integer.

sdl2:keyboard-event

sdl2:keyboard-event is a variant of sdl2:event that wraps a pointer to an SDL_KeyboardEvent.

[procedure] (keyboard-event? obj) → boolean

Returns #t if obj is an sdl2:keyboard-event.

[procedure] (keyboard-event-window-id event) → fixnum
[setter] (set! (keyboard-event-window-id event) val)
[setter] (keyboard-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window that had keyboard focus at the time this event occurred, or 0 if no sdl2:window had keyboard focus.

[procedure] (keyboard-event-state event) → boolean
[setter] (set! (keyboard-event-state event) val)
[setter] (keyboard-event-state-set! event val)

Get or set the event's "state" field, as a boolean indicating whether the key was pressed (#t) or released (#f). You can also find out by checking the event type: 'key-down for pressed, or 'key-up for released.

[procedure] (keyboard-event-repeat event) → fixnum
[setter] (set! (keyboard-event-repeat event) val)
[setter] (keyboard-event-repeat-set! event val)

Get or set the event's "repeat" field, as a integer. Non-zero indicates that this is a key repeat, caused by the user pressing and holding the key for some time. Zero indicates this is not a key repeat.

[procedure] (keyboard-event-keysym event) → sdl2:keysym
[setter] (set! (keyboard-event-keysym event) val)
[setter] (keyboard-event-keysym-set! event val)

Get or set the event's "keysym" field, as an sdl2:keysym indicating the key that was pressed or released. The getter returns a copy of the sdl2:keysym stored in the event. Modifying the returned sdl2:keysym will not modify the event, but setting this field to a sdl2:keysym will modify the event.

Instead of using this procedure, it is more efficient and convenient to directly access the fields of the event's sdl2:keysym, using these procedures:

• keyboard-event-scancode
• keyboard-event-sym
• keyboard-event-mod

[procedure] (keyboard-event-scancode event) → symbol
[procedure] (keyboard-event-scancode-raw event) → fixnum
[setter] (set! (keyboard-event-scancode event) val)
[setter] (keyboard-event-scancode-set! event val)

Get or set the "scancode" field of the event's "keysym" field, indicating the physical key that was pressed or released. Setting this will modify the event.

• keyboard-event-scancode returns a keyboard scancode symbol.
• keyboard-event-scancode-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (keyboard-event-sym event) → symbol
[procedure] (keyboard-event-sym-raw event) → fixnum
[setter] (set! (keyboard-event-sym event) val)
[setter] (keyboard-event-sym-set! event val)

Get or set the "sym" field of the event's "keysym" field, indicating the logical key that was pressed or released. Setting this will modify the event.

• keyboard-event-sym returns a keyboard keycode symbol
• keyboard-event-sym-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (keyboard-event-mod event) → list of symbols
[procedure] (keyboard-event-mod-raw event) → fixnum
[setter] (set! (keyboard-event-mod event) val)
[setter] (keyboard-event-mod-set! event val)

Get or set the "sym" field of the event's "keysym" field, indicating the modifier keys that were being pressed at the time the event occurred. Setting this will modify the event.

• keyboard-event-mod returns a list of zero or more keyboard modifier symbols.
• keyboard-event-mod-raw returns an integer.
• The setters accept either a list of symbols or an integer.

sdl2:mouse-button-event

sdl2:mouse-button-event is a variant of sdl2:event that wraps a pointer to an SDL_MouseButtonEvent.

[procedure] (mouse-button-event? obj) → boolean

Returns #t if obj is an sdl2:mouse-button-event.

[procedure] (mouse-button-event-window-id event) → fixnum
[setter] (set! (mouse-button-event-window-id event) val)
[setter] (mouse-button-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window that had mouse focus at the time this event occurred, or 0 if no sdl2:window had mouse focus.

[procedure] (mouse-button-event-which event) → fixnum
[setter] (set! (mouse-button-event-which event) val)
[setter] (mouse-button-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the mouse instance ID.

[procedure] (mouse-button-event-button event) → symbol
[procedure] (mouse-button-event-button-raw event) → fixnum
[setter] (set! (mouse-button-event-button event) val)
[setter] (mouse-button-event-button-set! event val)

Get or set the event's "button" field, indicating the button that the event is related to.

• mouse-button-event-button returns a mouse button symbol:
  • 'left
  • 'middle
  • 'right
  • 'x1
  • 'x2
• mouse-button-event-button-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (mouse-button-event-state event) → boolean
[setter] (set! (mouse-button-event-state event) val)
[setter] (mouse-button-event-state-set! event val)

Get or set the event's "state" field, as a boolean indicating whether the button was pressed (#t) or released (#f). You can also find out by checking the event type: 'mouse-button-down for pressed, or 'mouse-button-up for released.

[procedure] (mouse-button-event-x event) → fixnum
[setter] (set! (mouse-button-event-x event) val)
[setter] (mouse-button-event-x-set! event val)

Get or set the event's "x" field, as an integer indicating the X position (in pixels) of the mouse at the time this event occurred.

[procedure] (mouse-button-event-y event) → fixnum
[setter] (set! (mouse-button-event-y event) val)
[setter] (mouse-button-event-y-set! event val)

Get or set the event's "y" field, as an integer indicating the Y position (in pixels) of the mouse at the time this event occurred.

sdl2:mouse-motion-event

sdl2:mouse-motion-event is a variant of sdl2:event that wraps a pointer to an SDL_MouseMotionEvent.

[procedure] (mouse-motion-event? obj) → boolean

Returns #t if obj is an sdl2:mouse-motion-event.

[procedure] (mouse-motion-event-window-id event) → fixnum
[setter] (set! (mouse-motion-event-window-id event) val)
[setter] (mouse-motion-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window that had mouse focus at the time this event occurred, or 0 if no sdl2:window had mouse focus.

[procedure] (mouse-motion-event-which event) → fixnum
[setter] (set! (mouse-motion-event-which event) val)
[setter] (mouse-motion-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the mouse instance ID.

[procedure] (mouse-motion-event-state event) → list of symbols
[procedure] (mouse-motion-event-state-raw event) → fixnum
[setter] (set! (mouse-motion-event-state event) val)
[setter] (mouse-motion-event-state-set! event val)

Get or set the event's "state" field, indicating the mouse buttons that were being pressed at the time this event occurred.

• mouse-motion-event-state returns a list of zero or more mouse button mask symbols:
  • 'left
  • 'middle
  • 'right
  • 'x1
  • 'x2
• mouse-motion-event-state-raw returns an integer.
• The setters accept either a list of zero or more symbols, or an integer.

[procedure] (mouse-motion-event-x event) → fixnum
[setter] (set! (mouse-motion-event-x event) val)
[setter] (mouse-motion-event-x-set! event val)

Get or set the event's "x" field, as an integer indicating the X position (in pixels) of the mouse at the time this event occurred.

[procedure] (mouse-motion-event-y event) → fixnum
[setter] (set! (mouse-motion-event-y event) val)
[setter] (mouse-motion-event-y-set! event val)

Get or set the event's "y" field, as an integer indicating the Y position (in pixels) of the mouse at the time this event occurred.

[procedure] (mouse-motion-event-xrel event) → fixnum
[setter] (set! (mouse-motion-event-xrel event) val)
[setter] (mouse-motion-event-xrel-set! event val)

Get or set the event's "xrel" field, as an integer (possibly negative) indicating the amount the mouse's X position changed since its previous position.

[procedure] (mouse-motion-event-yrel event) → fixnum
[setter] (set! (mouse-motion-event-yrel event) val)
[setter] (mouse-motion-event-yrel-set! event val)

Get or set the event's "yrel" field, as an integer (possibly negative) indicating the amount the mouse's Y position changed since its previous position.

sdl2:mouse-wheel-event

sdl2:mouse-wheel-event is a variant of sdl2:event that wraps a pointer to an SDL_MouseWheelEvent.

[procedure] (mouse-wheel-event? obj) → boolean

Returns #t if obj is an sdl2:mouse-wheel-event.

[procedure] (mouse-wheel-event-window-id event) → fixnum
[setter] (set! (mouse-wheel-event-window-id event) val)
[setter] (mouse-wheel-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window that had mouse focus at the time this event occurred, or 0 if no sdl2:window had mouse focus.

[procedure] (mouse-wheel-event-which event) → fixnum
[setter] (set! (mouse-wheel-event-which event) val)
[setter] (mouse-wheel-event-which-set! event val)

Get or set the event's "which" field, as an integer indicating the mouse instance ID.

[procedure] (mouse-wheel-event-x event) → fixnum
[setter] (set! (mouse-wheel-event-x event) val)
[setter] (mouse-wheel-event-x-set! event val)

Get or set the event's "x" field, as an integer (possibly negative) indicating the amount the wheel scrolled horizontally. Positive numbers indicate scrolling to the right, negative numbers indicate scrolling to the left.

[procedure] (mouse-wheel-event-y event) → fixnum
[setter] (set! (mouse-wheel-event-y event) val)
[setter] (mouse-wheel-event-y-set! event val)

Get or set the event's "y" field, as an integer (possibly negative) indicating the amount the wheel scrolled vertically. Positive numbers indicate scrolling away from the user, negative numbers indicate scrolling toward the user.

sdl2:multi-gesture-event

sdl2:multi-gesture-event is a variant of sdl2:event that wraps a pointer to an SDL_MultiGestureEvent.

[procedure] (multi-gesture-event? obj) → boolean

Returns #t if obj is an sdl2:multi-gesture-event.

[procedure] (multi-gesture-event-touch-id event) → fixnum
[setter] (set! (multi-gesture-event-touch-id event) val)
[setter] (multi-gesture-event-touch-id-set! event val)

Get or set the event's "touch-id" field, as an integer indicating the ID number of the touch device this event is related to.

[procedure] (multi-gesture-event-dtheta event) → float
[setter] (set! (multi-gesture-event-dtheta event) val)
[setter] (multi-gesture-event-dtheta-set! event val)

Get or set the event's "dtheta" field, as a float indicating the amount that the fingers rotated during this motion.

[procedure] (multi-gesture-event-ddist event) → float
[setter] (set! (multi-gesture-event-ddist event) val)
[setter] (multi-gesture-event-ddist-set! event val)

Get or set the event's "ddist" field, as a float indicating the amount that the fingers pinched during this motion.

[procedure] (multi-gesture-event-x event) → float
[setter] (set! (multi-gesture-event-x event) val)
[setter] (multi-gesture-event-x-set! event val)

Get or set the event's "x" field, as a float indicating the normalized X coordinate of the center of the gesture.

[procedure] (multi-gesture-event-y event) → float
[setter] (set! (multi-gesture-event-y event) val)
[setter] (multi-gesture-event-y-set! event val)

Get or set the event's "y" field, as a float indicating the normalized Y coordinate of the center of the gesture.

[procedure] (multi-gesture-event-num-fingers event) → fixnum
[setter] (set! (multi-gesture-event-num-fingers event) val)
[setter] (multi-gesture-event-num-fingers-set! event val)

Get or set the event's "num-fingers" field, as an integer indicating the number of fingers used in the gesture.

sdl2:quit-event

sdl2:quit-event is a variant of sdl2:event that wraps a pointer to an SDL_QuitEvent.

[procedure] (quit-event? obj) → boolean

Returns #t if obj is an sdl2:quit-event.

sdl2:sys-wm-event

sdl2:sys-wm-event is a variant of sdl2:event that wraps a pointer to an SDL_SysWMEvent. This event is for very advanced use cases. Most people can ignore it.

[procedure] (sys-wm-event? obj) → boolean

Returns #t if obj is an sdl2:sys-wm-event.

[procedure] (sys-wm-event-msg-raw event) → pointer
[setter] (set! (sys-wm-event-msg-raw event) val)
[setter] (sys-wm-event-msg-raw-set! event val)

Get or set the event's "msg" field, as a raw pointer to a SDL_SysWMmsg struct describing the platform-specific event that occurred. This is for very advanced use cases. Most people can ignore it.

sdl2:text-editing-event

sdl2:text-editing-event is a variant of sdl2:event that wraps a pointer to an SDL_TextEditingEvent.

[procedure] (text-editing-event? obj) → boolean

Returns #t if obj is an sdl2:text-editing-event.

[procedure] (text-editing-event-window-id event) → fixnum
[setter] (set! (text-editing-event-window-id event) val)
[setter] (text-editing-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window that had keyboard focus at the time this event occurred, or 0 if no sdl2:window had keyboard focus.

[procedure] (text-editing-event-text event) → string
[setter] (set! (text-editing-event-text event) val)
[setter] (text-editing-event-text-set! event val)

Get or set the event's text event, as a UTF8 string up to 32 bytes long (including the null byte), holding the text being edited.

[procedure] (text-editing-event-start event) → fixnum
[setter] (set! (text-editing-event-start event) val)
[setter] (text-editing-event-start-set! event val)

Get or set the event's "start" field, as an integer indicating the location to begin editing from.

[procedure] (text-editing-event-length event) → fixnum
[setter] (set! (text-editing-event-length event) val)
[setter] (text-editing-event-length-set! event val)

Get or set the event's "length" field, as an integer indicating the number of characters to edit from the start point.

sdl2:text-input-event

sdl2:text-input-event is a variant of sdl2:event that wraps a pointer to an SDL_TextInputEvent.

[procedure] (text-input-event? obj) → boolean

Returns #t if obj is an sdl2:text-input-event.

[procedure] (text-input-event-window-id event) → fixnum
[setter] (set! (text-input-event-window-id event) val)
[setter] (text-input-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window that had keyboard focus at the time this event occurred, or 0 if no sdl2:window had keyboard focus.

[procedure] (text-input-event-text event) → string
[setter] (set! (text-input-event-text event) val)
[setter] (text-input-event-text-set! event val)

Get or set the event's text event, as a UTF8 string up to 32 bytes long (including the null byte), holding the text that was inputted.

sdl2:touch-finger-event

sdl2:touch-finger-event is a variant of sdl2:event that wraps a pointer to an SDL_TouchFingerEvent.

[procedure] (touch-finger-event? obj) → boolean

Returns #t if obj is an sdl2:touch-finger-event.

[procedure] (touch-finger-event-touch-id event) → fixnum
[setter] (set! (touch-finger-event-touch-id event) val)
[setter] (touch-finger-event-touch-id-set! event val)

Get or set the event's "touch-id" field, as an integer indicating the ID number of the touch device this event is related to.

[procedure] (touch-finger-event-finger-id event) → fixnum
[setter] (set! (touch-finger-event-finger-id event) val)
[setter] (touch-finger-event-finger-id-set! event val)

Get or set the event's "finger-id" field, as an integer indicating the ID number of the finger this event is related to.

[procedure] (touch-finger-event-x event) → float
[setter] (set! (touch-finger-event-x event) val)
[setter] (touch-finger-event-x-set! event val)

Get or set the event's "x" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized X coordinate of the touch event.

[procedure] (touch-finger-event-y event) → float
[setter] (set! (touch-finger-event-y event) val)
[setter] (touch-finger-event-y-set! event val)

Get or set the event's "y" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized Y coordinate of the touch event.

[procedure] (touch-finger-event-dx event) → float
[setter] (set! (touch-finger-event-dx event) val)
[setter] (touch-finger-event-dx-set! event val)

Get or set the event's "dx" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized distance moved on the X axis.

[procedure] (touch-finger-event-dy event) → float
[setter] (set! (touch-finger-event-dy event) val)
[setter] (touch-finger-event-dy-set! event val)

Get or set the event's "dy" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized distance moved on the Y axis.

[procedure] (touch-finger-event-pressure event) → float
[setter] (set! (touch-finger-event-pressure event) val)
[setter] (touch-finger-event-pressure-set! event val)

Get or set the event's "pressure" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the pressure being applied.

sdl2:user-event

sdl2:user-event is a variant of sdl2:event that wraps a pointer to an SDL_UserEvent.

Call register-events! to register your own custom event type symbols.

[procedure] (user-event? obj) → boolean

Returns #t if obj is an sdl2:user-event.

[procedure] (user-event-window-id event) → fixnum
[setter] (set! (user-event-window-id event) val)
[setter] (user-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID number of the sdl2:window associated with this event.

[procedure] (user-event-code event) → fixnum
[setter] (set! (user-event-code event) val)
[setter] (user-event-code-set! event val)

Get or set the event's "code" field, as an integer in the range -32768 to 32767 (inclusive). The meaning of this field is for you to decide.

[procedure] (user-event-data1-raw event) → pointer or #f
[setter] (set! (user-event-data1-raw event) val)
[setter] (user-event-data1-rawset! event val)

Get or set the event's "data1" field, as a raw pointer or #f. The meaning of this field is for you to decide.

If you want to store a pointer to a Scheme object here, be sure to evict the object first. Otherwise the object's location in memory might change, rendering the pointer invalid.

[procedure] (user-event-data2-raw event) → pointer or #f
[setter] (set! (user-event-data2-raw event) val)
[setter] (user-event-data2-raw-set! event val)

Get or set the event's "data2" field, as a raw pointer or #f. The meaning of this field is for you to decide.

If you want to store a pointer to a Scheme object here, be sure to evict the object first. Otherwise the object's location in memory might change, rendering the pointer invalid.

sdl2:window-event

sdl2:window-event is a variant of sdl2:event that wraps a pointer to an SDL_WindowEvent.

[procedure] (window-event? obj) → boolean

Returns #t if obj is an sdl2:window-event.

[procedure] (window-event-window-id event) → fixnum
[setter] (set! (window-event-window-id event) val)
[setter] (window-event-window-id-set! event val)

Get or set the event's "window-id" field, as an integer indicating the ID of the sdl2:window that the event is related to.

[procedure] (window-event-event event) → symbol
[procedure] (window-event-event-raw event) → fixnum
[setter] (set! (window-event-event event) val)
[setter] (window-event-event-set! event val)

Get or set the event's "event" field, indicating what happened to the window.

• window-event-event returns a window event type symbol.
• window-event-event-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (window-event-data1 event) → fixnum
[setter] (set! (window-event-data1 event) val)
[setter] (window-event-data1-set! event val)

Get or set the sdl2:window-event's "data1" field, as an integer. The meaning of this value depends on what kind of window event it was (see window-event-event). E.g. if the window was resized, this will hold the new window width; if the window was moved, this will hold the new x position.

[procedure] (window-event-data2 event) → fixnum
[setter] (set! (window-event-data2 event) val)
[setter] (window-event-data2-set! event val)

Get or set the sdl2:window-event's "data2" field, as an integer. The meaning of this value depends on what kind of window event it was (see window-event-event). E.g. if the window was resized, this will hold the new window height; if the window was moved, this will hold the new y position.

sdl2:finger

sdl2:finger is a record type that wraps a pointer to an SDL_Finger struct.

[procedure] (finger? obj) → boolean

Returns #t if obj is an sdl2:finger.

[procedure] (finger-id finger) → fixnum

Get the sdl2:finger's "id" field, as an integer.

[procedure] (finger-x finger) → float

Get the sdl2:finger's "x" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized X position of the finger.

[procedure] (finger-y finger) → float

Get the sdl2:finger's "y" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized Y position of the finger.

[procedure] (finger-pressure finger) → float

Get the sdl2:finger's "pressure" field, as a float in the range 0.0 to 1.0 (inclusive), indicating the normalized pressure of the finger.

sdl2:joystick

sdl2:joystick is a record type that wraps a pointer to an SDL_Joystick struct.

[procedure] (joystick? obj) → boolean

Returns #t if obj is an sdl2:joystick.

sdl2:joystick-guid

sdl2:joystick-guid is a record type that wraps a pointer to an SDL_JoystickGUID struct.

[procedure] (joystick-guid? obj) → boolean

Returns #t if obj is an sdl2:joystick-guid.

[procedure] (free-joystick-guid! guid)

Free the memory of the sdl2:joystick-guid's underlying struct. guid's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:joystick-guids. It is safe (but has no effect) to free a struct record multiple times.

sdl2:keysym

sdl2:keysym is a record type that wraps a pointer to an SDL_Keysym struct.

[procedure] (keysym? obj) → boolean

Returns #t if obj is an sdl2:keysym.

[procedure] (make-keysym #!optional scancode sym mod) → sdl2:keysym
[procedure] (make-keysym* #!optional scancode sym mod) → sdl2:keysym

Allocate and initialize a new sdl2:keysym.

scancode defaults to 'unknown. It must be a keyboard scancode symbol or equivalent integer.

sym defaults to 'unknown. It must be a keyboard keycode symbol or equivalent integer.

mod defaults to '(). It must be a list of zero or more keyboard modifier symbols or an equivalent integer bitfield.

• make-keysym returns a managed sdl2:keysym.
• make-keysym* returns an unmanaged sdl2:keysym, which must be freed with free-keysym! when you are done with it.

[procedure] (free-keysym! keysym)

Free the memory of the sdl2:keysym's underlying struct. keysym's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:keysyms. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (keysym-scancode keysym) → symbol
[procedure] (keysym-scancode-raw keysym) → fixnum
[setter] (set! (keysym-scancode keysym) val)
[setter] (keysym-scancode-set! keysym val)

Get or set the sdl2:keysym's "scancode" field, indicating the physical key that this keysym describes.

• keysym-scancode returns a keyboard scancode symbol.
• keysym-scancode-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (keysym-sym keysym) → symbol
[procedure] (keysym-sym-raw keysym) → fixnum
[setter] (set! (keysym-sym keysym) val)
[setter] (keysym-sym-set! keysym val)

Get or set the sdl2:keysym's "sym" field, indicating the logical key that this keysym describes.

• keysym-sym returns a keyboard keycode symbol.
• keysym-sym-raw returns an integer.
• The setters accept either a symbol or an integer.

[procedure] (keysym-mod keysym) → list of symbols
[procedure] (keysym-mod-raw keysym) → fixnum
[setter] (set! (keysym-mod keysym) val)
[setter] (keysym-mod-set! keysym val)

Get or set the sdl2:keysym's "mod" field, indicating the modifier keys that this keysym describes.

• keysym-mod returns a list of zero or more keyboard modifier symbols.
• keysym-mod-raw returns an integer.
• The setters accept either a list of zero or more symbols, or an integer.

sdl2:palette

sdl2:palette is a record type that wraps a pointer to an SDL_Palette struct.

[procedure] (palette? obj) → boolean

Returns #t if obj is an sdl2:palette.

[procedure] (make-palette #!optional ncolors) → sdl2:palette
[procedure] (make-palette* #!optional ncolors) → sdl2:palette

Allocate and initialize a new sdl2:palette with the given number of colors. See SDL_AllocPalette.

ncolors defaults to 256. Common values are 2 (for a 1-bit surface), 16 (for a 4-bit surface), and 256 (for an 8-bit surface).

NOTE: Usually you do not need to manually allocate a palette. A palette will be created for you when you create a surface with a depth of 8 or lower, and the palette will be automatically freed when the surface is freed (unless the palette is still being used by other surfaces).

• make-palette returns a managed sdl2:palette.
• make-palette* returns an unmanaged sdl2:palette, which must be freed with free-palette! when you are done with it.

[procedure] (free-palette! palette)

Free the memory of the sdl2:palette's underlying struct. palette's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:palettes. It is safe (but has no effect) to free a struct record multiple times.

See SDL_FreePalette.

[procedure] (palette-ncolors palette) → fixnum
[procedure] (palette-ncolours palette) → fixnum

Returns the number of colors in the palette. Common values are 2 (for a 1-bit surface), 16 (for a 4-bit surface), and 256 (for an 8-bit surface).

sdl2:pixel-format

sdl2:pixel-format is a record type that wraps a pointer to an SDL_PixelFormat struct.

[procedure] (pixel-format? obj) → boolean

Returns #t if obj is an sdl2:pixel-format.

[procedure] (make-pixel-format #!optional format) → sdl2:pixel-format
[procedure] (make-pixel-format* #!optional format) → sdl2:pixel-format

Allocate and initialize a new sdl2:pixel-format with the given format.

format defaults to 'unknown. It must be a pixel format symbol or equivalent integer. See SDL_AllocFormat.

• make-pixel-format returns a managed sdl2:pixel-format.
• make-pixel-format* returns an unmanaged sdl2:pixel-format, which must be freed with free-pixel-format! when you are done with it.

[procedure] (free-pixel-format! pixel-format)

Free the memory of the sdl2:pixel-format's underlying struct. pixel-format's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:pixel-formats. It is safe (but has no effect) to free a struct record multiple times.

See SDL_FreeFormat.

[procedure] (pixel-format-format pixel-format) → symbol
[procedure] (pixel-format-format-raw pixel-format) → fixnum

Get the sdl2:pixel-format's "format" field.

• pixel-format-format returns a pixel format symbol.
• pixel-format-format-raw returns an integer.

[procedure] (pixel-format-palette pixel-format) → sdl2:palette or #f
[setter] (set! (pixel-format-palette pixel-format) val)
[setter] (pixel-format-palette-set! pixel-format val)

Get or set the sdl2:pixel-format's "palette" field, as an sdl2:palette, or #f if it does not have a palette. Only sdl2:pixel-formats with bits-per-pixel of 8 or less can have a palette.

See SDL_SetPixelFormatPalette.

[procedure] (pixel-format-bits-per-pixel pixel-format) → fixnum

Get the sdl2:pixel-format's "bits-per-pixel" field, as an integer. Common values are 32, 24, 16, 15, 8, 4, and 1.

[procedure] (pixel-format-bytes-per-pixel pixel-format) → fixnum

Get the sdl2:pixel-format's "bits-per-pixel" field, as an integer. Possible values are 4, 3, 2, and 1.

[procedure] (pixel-format-rmask pixel-format) → fixnum

Get the sdl2:pixel-format's "rmask" (red mask) field, as a nonnegative integer.

[procedure] (pixel-format-gmask pixel-format) → fixnum

Get the sdl2:pixel-format's "gmask" (green mask) field, as a nonnegative integer.

[procedure] (pixel-format-bmask pixel-format) → fixnum

Get the sdl2:pixel-format's "bmask" (blue mask) field, as a nonnegative integer.

[procedure] (pixel-format-amask pixel-format) → fixnum

Get the sdl2:pixel-format's "amask" (alpha mask) field, as a nonnegative integer. It will be 0 if there is no alpha channel.

sdl2:point

sdl2:point is a record type that wraps a pointer to an SDL_Point struct.

[procedure] (point? obj) → boolean

Returns #t if obj is an sdl2:point.

[procedure] (make-point #!optional x y) → sdl2:point
[procedure] (make-point* #!optional x y) → sdl2:point

Allocate and initialize a new sdl2:point.

x and y must be integers in the range -2147483648 to 2147483647 (inclusive). They both default to 0.

• make-point returns a managed sdl2:point.
• make-point* returns an unmanaged sdl2:point, which must be freed with free-point! when you are done with it.

[procedure] (free-point! point)

Free the memory of the sdl2:point's underlying struct. point's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:points. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (point-x point) → fixnum
[setter] (set! (point-x point) val)
[setter] (point-x-set! point val)

Get or set the sdl2:point's "x" field, as an integer in the range -2147483648 to 2147483647 (inclusive).

[procedure] (point-y point) → fixnum
[setter] (set! (point-y point) val)
[setter] (point-y-set! point val)

Get or set the sdl2:point's "y" field, as an integer in the range -2147483648 to 2147483647 (inclusive).

[procedure] (point-set! point #!optional x y) → point

Convenient way of setting multiple fields of the sdl2:point. Any arguments that are #f will cause no change to that field. E.g. (point-set! my-point 42 #f) will set the "x" field to 42, but will not change the "y" field. Returns point after it is modified.

[procedure] (point->list point) → list of fixnums

Returns a list (x y) containing the value of each field of the sdl2:point.

[procedure] (point=? point1 point2) → boolean

Efficiently compare two sdl2:points. Returns #t if the value of every field in point1 is equal to the value of the corresponding field in point2.

[procedure] (copy-point point) → sdl2:point
[procedure] (copy-point* point) → sdl2:point

Efficiently copy the given sdl2:point, returning a new sdl2:point with the same values.

• copy-point returns a managed sdl2:point.
• copy-point* returns an unmanaged sdl2:point, which must be freed with free-point! when you are done with it.

sdl2:rect

sdl2:rect is a record type that wraps a pointer to an SDL_Rect struct.

[procedure] (rect? obj) → boolean

Returns #t if obj is an sdl2:rect.

[procedure] (make-rect #!optional x y w h) → sdl2:rect
[procedure] (make-rect* #!optional x y w h) → sdl2:rect

Allocate and initialize a new sdl2:rect.

x, y, w, and h must be integers in the range -2147483648 to 2147483647 (inclusive). They all default to 0.

• make-rect returns a managed sdl2:rect.
• make-rect* returns an unmanaged sdl2:rect, which must be freed with free-rect! when you are done with it.

[procedure] (free-rect! rect)

Free the memory of the sdl2:rect's underlying struct. rect's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:rects. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (rect-x rect) → fixnum
[setter] (set! (rect-x rect) val)
[setter] (rect-x-set! rect val)

Get or set the sdl2:rect's "x" field, as an integer in the range -2147483648 to 2147483647 (inclusive).

[procedure] (rect-y rect) → fixnum
[setter] (set! (rect-y rect) val)
[setter] (rect-y-set! rect val)

Get or set the sdl2:rect's "y" field, as an integer in the range -2147483648 to 2147483647 (inclusive).

[procedure] (rect-w rect) → fixnum
[setter] (set! (rect-w rect) val)
[setter] (rect-w-set! rect val)

Get or set the sdl2:rect's "w" (width) field, as an integer in the range -2147483648 to 2147483647 (inclusive).

[procedure] (rect-h rect) → fixnum
[setter] (set! (rect-h rect) val)
[setter] (rect-h-set! rect val)

Get or set the sdl2:rect's "h" (height) field, as an integer in the range -2147483648 to 2147483647 (inclusive).

[procedure] (rect-set! rect #!optional x y w h) → rect

Convenient way of setting multiple fields of the sdl2:rect. Any arguments that are #f will cause no change to that field. E.g. (rect-set! my-rect 42 #f 1337 #f) will set the "x" field to 42 and the "w" field to 1337, but will not change the "y" or "h" fields. Returns rect after it is modified.

[procedure] (rect->list rect) → list of fixnums

Returns a list (x y w h) containing the value of each field of the sdl2:rect.

[procedure] (rect=? rect1 rect2) → boolean

Efficiently compare two sdl2:rects. Returns #t if the value of every field in rect1 is equal to the value of the corresponding field in rect2. See SDL_RectEquals.

[procedure] (copy-rect rect) → sdl2:rect
[procedure] (copy-rect* rect) → sdl2:rect

Efficiently copy the given sdl2:rect, returning a new sdl2:rect with the same values.

• copy-rect returns a managed sdl2:rect.
• copy-rect* returns an unmanaged sdl2:rect, which must be freed with free-rect! when you are done with it.

sdl2:rwops

sdl2:rwops is a record type that wraps a pointer to an SDL_RWops struct.

[procedure] (rwops? obj) → boolean

Returns #t if obj is an sdl2:rwops.

[procedure] (rwops-type rwops) → symbol
[procedure] (rwops-type-raw rwops) → fixnum

Get the sdl2:rwops' "type" field, indicating the data source type.

• rwops-type returns a RWops type symbol:
  • 'unknown
  • 'win-file
  • 'std-file
  • 'jni-file
  • 'memory
  • 'memory-ro
• rwops-type-raw returns an integer.

sdl2:surface

sdl2:surface is a record type that wraps a pointer to an SDL_Surface struct.

[procedure] (surface? obj) → boolean

Returns #t if obj is an sdl2:surface.

[procedure] (make-surface width height depth) → sdl2:surface or #f
[procedure] (make-surface* width height depth) → sdl2:surface or #f

Create a new sdl2:surface with the given width, height, and color depth (bits per pixel). This is a more convenient interface for create-rgb-surface. The sdl2:surface's pixel format and masks will be chosen automatically based on the requested depth and the current platform's byte order (little endian or big endian). Returns #f if the sdl2:surface could not be created (e.g. because the color depth is unsupported).

• make-surface returns a managed sdl2:surface.
• make-surface* returns an unmanaged sdl2:surface, which must be freed with free-surface! when you are done with it.

[procedure] (free-surface! surface)

Free the memory of the sdl2:surface's underlying struct. surface's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:surfaces. It is safe (but has no effect) to free a struct record multiple times.

See SDL_FreeSurface.

NOTE: if surface was created using create-rgb-surface-from, then the pixel data is not freed.

[procedure] (surface-format surface) → sdl2:pixel-format

Get the sdl2:surface's "format" field, as a sdl2:pixel-format describing the format of the surface's pixels.

[procedure] (surface-w surface) → fixnum

Get the sdl2:surface's "w" field, as a nonnegative integer indicating the surface's width in pixels.

[procedure] (surface-h surface) → fixnum

Get the sdl2:surface's "h" field, as a nonnegative integer indicating the surface's height in pixels.

[procedure] (surface-pitch surface) → fixnum

Get the sdl2:surface's "pitch" field, as a nonnegative integer indicating how many bytes are used to represent one row of pixel data.

[procedure] (surface-pixels-raw surface) → pointer or #f

Get the sdl2:surface's "pixels" field, as a raw pointer to the sdl2:surface's pixels. Don't use this unless you really know what you are doing!

If you want to get or set a pixel, use surface-ref and surface-set! instead. They are much safer, more convenient, and more efficient than accessing the pixel data using this pointer.

[procedure] (surface-userdata-raw surface) → pointer or #f
[setter] (set! (surface-userdata-raw surface) val)
[setter] (surface-userdata-raw-set! surface val)

Get or set the sdl2:surface's "userdata" field, as a pointer or #f.

If you want to store a pointer to a Scheme object here, be sure to evict the object first. Otherwise the object's location in memory might change, rendering the pointer invalid.

[procedure] (surface-refcount surface) → fixnum
[setter] (set! (surface-refcount surface) val)
[setter] (surface-refcount-set! surface val)

Get or set the sdl2:surface's "refcount" field, as an integer.

sdl2:texture

sdl2:texture is a record type that wraps a pointer to an SDL_Texture struct.

[procedure] (texture? obj) → boolean

Returns #t if obj is an sdl2:texture.

sdl2:version

sdl2:version is a record type that wraps a pointer to an SDL_version struct.

[procedure] (version? obj) → boolean

Returns #t if obj is an sdl2:version.

[procedure] (make-version #!optional major minor patch) → sdl2:version
[procedure] (make-version* #!optional major minor patch) → sdl2:version

Allocate and initialize a new sdl2:version.

major, minor, and patch must be integers in the range 0 to 255 (inclusive). They all default to 0.

• make-version returns a managed sdl2:version.
• make-version* returns an unmanaged sdl2:version, which must be freed with free-version! when you are done with it.

[procedure] (free-version! version)

Free the memory of the sdl2:version's underlying struct. version's pointer will be set to null (see struct-null?). It is safe to call this procedure with managed or unmanaged sdl2:versions. It is safe (but has no effect) to free a struct record multiple times.

[procedure] (version-major version) → fixnum
[setter] (set! (version-major version) val)
[setter] (version-major-set! version val)

Get or set the sdl2:version's "major" field, as an integer in the range 0 to 255 (inclusive).

[procedure] (version-minor version) → fixnum
[setter] (set! (version-minor version) val)
[setter] (version-minor-set! version val)

Get or set the sdl2:version's "minor" field, as an integer in the range 0 to 255 (inclusive).

[procedure] (version-patch version) → fixnum
[setter] (set! (version-patch version) val)
[setter] (version-patch-set! version val)

Get or set the sdl2:version's "patch" field, as an integer in the range 0 to 255 (inclusive).

[procedure] (version-set! version #!optional major minor patch) → version

Convenient way of setting multiple fields of the sdl2:version. Any arguments that are #f will cause no change to that field. E.g. (version-set! my-version 42 #f 255) will set the "major" field to 42 and the "patch" field to 255, but will not change the "minor" field. Returns version after it is modified.

[procedure] (version->list version) → list of fixnums

Returns a list (major minor patch) containing the value of each field of the sdl2:version.

[procedure] (version=? version1 version2) → boolean

Efficiently compare two sdl2:verisons. Returns #t if the value of every field in version1 is equal to the value of the corresponding field in version2.

sdl2:window

sdl2:window is a record type that wraps a pointer to an SDL_Window struct.

[procedure] (window? obj) → boolean

Returns #t if obj is an sdl2:window.

Procedures

General / Miscellaneous

[procedure] (init! #!optional flags-list) → fixnum

See SDL_Init. Returns zero if successful.

flags-list defaults to '(everything). It must be a list of one or more init flag symbols:

• 'timer
• 'audio
• 'video
• 'joystick
• 'haptic
• 'game-controller
• 'events
• 'everything

[procedure] (init-subsystem! flags-list) → fixnum

See SDL_InitSubSystem. Returns zero if successful.

flags-list must be a list of one or more init flag symbols.

[procedure] (quit!)

See SDL_Quit.

[procedure] (quit-subsystem! flags-list)

See SDL_QuitSubSystem.

flags-list must be a list of one or more init flag symbols.

[procedure] (was-init #!optional flags-list) → list of symbols

See SDL_WasInit.

flags-list defaults to '(everything). It must be a list of one or more init flag symbols.

[procedure] (set-main-ready!)

See SDL_SetMainReady.

[procedure] (clear-error!)

See SDL_ClearError.

[procedure] (get-error) → string

See SDL_GetError.

[procedure] (set-error! message)

See SDL_SetError.

Unlike SDL_SetError, this procedure only accepts one argument, a string. You can use sprintf to do string substitution if desired.

[procedure] (get-platform) → string

See SDL_GetPlatform.

[procedure] (disable-screen-saver!)

See SDL_DisableScreenSaver.

[procedure] (enable-screen-saver!)

See SDL_EnableScreenSaver.

[procedure] (screen-saver-enabled?) → boolean

See SDL_IsScreenSaverEnabled.

[procedure] (has-clipboard-text?) → boolean

See SDL_HasClipboardText.

[procedure] (get-clipboard-text) → string

See SDL_GetClipboardText.

[procedure] (set-clipboard-text! text) → fixnum

See SDL_SetClipboardText. Returns zero if successful.

[procedure] (get-version) → sdl2:version

See SDL_GetVersion.

Returns an sdl2:version containing the version number of SDL that the sdl2 egg is currently using. (This may be different than the version it was compiled with.)

[procedure] (get-compiled-version) → sdl2:version

See SDL_VERSION.

Returns an sdl2:version containing the version number of SDL that the sdl2 egg was compiled with. (This may be different than the version it is currently using.)

[procedure] (version-at-least? major minor patch) → boolean

See SDL_VERSION_ATLEAST.

Returns #t if the sdl2 egg was compiled with a version of SDL at least as high as specified. E.g. (version-at-least? 2 0 1) returns #t if the sdl2 egg was compiled with SDL 2.0.1 or higher. Some SDL features are only available after a certain version, so you can use this procedure to check whether the feature is available.

Pixel Format / Palette

[procedure] (map-rgb pixel-format r g b) → fixnum

See SDL_MapRGB.

[procedure] (map-rgba pixel-format r g b a) → fixnum

See SDL_MapRGBA.

[procedure] (get-rgb pixel pixel-format) → [r g b]

See SDL_GetRGB.

This procedure returns multiple values.

[procedure] (get-rgba pixel pixel-format) → [r g b a]

See SDL_GetRGBA.

This procedure returns multiple values.

[procedure] (palette-ref palette i) → sdl2:color
[setter] (set! (palette-ref palette i) color)
[setter] (palette-set! palette i color)

palette-ref returns a copy of the color at the given index of the palette, as a managed sdl2:color.

The setters set the given index of the palette to a copy of the given sdl2:color.

[procedure] (palette-colors palette) → vector of sdl2:colors
[procedure] (palette-colours palette) → vector of sdl2:colors
[setter] (set! (palette-colors palette) colors-vec) → fixnum
[setter] (set! (palette-colours palette) colors-vec) → fixnum
[setter] (palette-colors-set! colors-vec #!optional start) → fixnum
[setter] (palette-colours-set! colors-vec #!optional start) → fixnum

palette-colors and palette-colours return copies of all colors in the palette, as a Scheme vector of managed sdl2:colors.

The setters set multiple colors in the palette to copies of the given colors. colors-vec must be a Scheme vector of sdl2:colors.

palette-colors-set! and palette-colours-set! accept an optional start index, which defaults to 0. The set! form cannot accept the start index.

See SDL_SetPaletteColors.

The setters return zero if successful.

Events

[procedure] (event-state type) → boolean
[setter] (set! (event-state type) state) → boolean
[setter] (event-state-set! type state) → boolean

event-state returns #t if the given event type is currently enabled, or #f if it is currently disabled (i.e. all future events of that type will be ignored).

The setters enable (if state is #t) or disable (if state is #f) the given event type, then return the previous state of the given event type.

type must be an event type symbol or corresponding integer.

See SDL_EventState.

[procedure] (flush-event! type)

See SDL_FlushEvent.

Contrary to what its name suggests, this procedure will flush ALL events matching the given type, not just a single event.

type must be an event type symbol or corresponding integer.

[procedure] (flush-events! #!optional min-type max-type)

See SDL_FlushEvents.

min-type and max-type must be event type symbols or corresponding integers. If omitted, min-type defaults to 'first and max-type defaults to 'last.

[procedure] (has-event? type) → boolean

See SDL_HasEvent.

type must be an event type symbol or corresponding integer.

[procedure] (has-events? #!optional min-type max-type) → boolean

See SDL_HasEvents.

min-type and max-type must be event type symbols or corresponding integers. If omitted, min-type defaults to 'first and max-type defaults to 'last.

[procedure] (quit-requested?) → boolean

See SDL_QuitRequested.

[procedure] (peek-events num #!optional min-type max-type) → list of sdl2:events

See SDL_PeepEvents.

This procedure is similar to get-events!, except that this procedure does not remove the events from the SDL event queue.

min-type and max-type must be event type symbols or corresponding integers. If omitted, min-type defaults to 'first and max-type defaults to 'last.

Returns a list of managed sdl2:events.

[procedure] (get-events! num #!optional min-type max-type) → list of sdl2:events

See SDL_PeepEvents.

This procedure is similar to peek-events, except that this procedure removes the events from the SDL event queue.

min-type and max-type must be an event type symbol or corresponding integer. If omitted, min-type defaults to 'first and max-type defaults to 'last.

Returns a list of managed sdl2:events.

[procedure] (poll-event! #!optional result-event) → sdl2:event

See SDL_PollEvent.

If result-event is omitted or #f, a new managed sdl2:event will be allocated and returned. If result-event is an existing sdl2:event record, it will be modified and returned. This allows you to allocate a single event and reuse it many times in your event loop, so that your program does not create as much garbage for the garbage collector.

[procedure] (pump-events!)

See SDL_PumpEvents.

[procedure] (push-event! event) → fixnum

See SDL_PushEvent.

Returns 1 if successful.

[procedure] (wait-event! #!optional result-event) → sdl2:event

Wait for the next event to appear on the event queue, then return it. If there is already an event on the event queue, it will be returned immediately. Otherwise, this procedure will block the current thread indefinitely until an event appears. See also wait-event-timeout!.

If result-event is omitted or #f, a new managed sdl2:event will be returned. If result-event is a sdl2:event, it will be modified and returned. This allows you to allocate a single event and reuse it many times in your event loop, so that your program does not create as much garbage for the garbage collector.

This procedure is compatible with SRFI-18 multithreading. Only the current thread will block while waiting. Other threads will continue as normal.

This procedure is inspired by (but does not actually use) SDL_WaitEvent.

[procedure] (wait-event-timeout! timeout-ms #!optional result-event) → sdl2:event or #f

Similar to wait-event!, except that if no event appears on the event queue within timeout-ms milliseconds, this procedure will stop waiting and return #f. If an event does appear, this procedure immediately stops waiting and returns the event.

This procedure may actually wait a few milliseconds longer than specified. You should not rely on its timing being very precise.

This procedure is inspired by (but does not actually use) SDL_WaitEventTimeout. Please note that the argument order is reversed compared to SDL_WaitEventTimeout, to allow the result-event argument to be optional.

[procedure] (register-events! event-symbols) → list of pairs

Register zero or more symbols as new user event types. After registration, the given symbols may be used as event types, e.g. with event-type-set!. The symbols will be associated with the sdl2:user-event variant of sdl2:event.

event-symbols must be a list of symbols that are not already being used as event types. If any symbol is already being used, or if any member of the list is not a symbol, an error will be signalled and none of the new event types will be registered.

There are 32767 user event type numbers available to register. Each symbol in event-symbols will be automatically assigned a distinct number. If there are not enough remaining numbers to register all the symbols in event-symbols, this procedure will signal an error, and none of the new event types will be registered.

This procedure returns an association list (list of pairs) of each of the new event type symbols (as the pair car) with its assigned number (as the pair cdr).

This procedure is based on SDL_RegisterEvents.

[procedure] (get-num-touch-devices) → fixnum

See SDL_GetNumTouchDevices.

[procedure] (get-num-touch-fingers touch-id) → fixnum

See SDL_GetNumTouchFingers.

[procedure] (get-touch-device device-id) → fixnum

See SDL_GetTouchDevice.

[procedure] (get-touch-finger touch-id index) → sdl2:finger

See SDL_GetTouchFinger.

OpenGL integration

[procedure] (gl-create-context! window) → sdl2:gl-context

See SDL_GL_CreateContext.

[procedure] (gl-delete-context! gl-context)

See SDL_GL_DeleteContext.

[procedure] (gl-make-current! window gl-context) → fixnum

See SDL_GL_MakeCurrent.

[procedure] (gl-get-current-window) → sdl2:window

See SDL_GL_GetCurrentWindow.

[procedure] (gl-get-current-context) → sdl2:gl-context

See SDL_GL_GetCurrentContext.

[procedure] (gl-get-attribute attr) → value

See SDL_GL_GetAttribute.

attr must be an OpenGL attribute symbol or corresponding integer.

The return type varies depending on attr:

• If attr is 'context-profile-mask, an OpenGL profile symbol will be returned.
• If attr is 'context-flags, a list of zero or more OpenGL context flag symbols will be returned.
• Otherwise, an integer will be returned.

[procedure] (gl-set-attribute! attr value) → fixnum

See SDL_GL_SetAttribute. Returns zero if successful.

attr must be an OpenGL attribute symbol or corresponding integer.

value must be one of these types, depending on what attr is:

• If attr is 'context-profile-mask, value must be an OpenGL profile symbol or corresponding integer.
• If attr is 'context-flags, value must be a list of zero or more OpenGL context flag symbols or an integer bitfield.
• Otherwise, value must be an integer.

[procedure] (gl-reset-attributes!)

See SDL_GL_ResetAttributes.

Requires SDL 2.0.2 or higher. Signals an error if the compiled version of SDL is not high enough. Use (version-at-least? 2 0 2) to check before calling this procedure.

[procedure] (gl-get-drawable-size window) → [width height]

See SDL_GL_GetDrawableSize.

This procedure returns multiple values.

Requires SDL 2.0.1 or higher. Signals an error if the compiled version of SDL is not high enough. Use (version-at-least? 2 0 1) to check before calling this procedure.

[procedure] (gl-swap-window!)

See SDL_GL_SwapWindow.

[procedure] (gl-get-swap-interval) → fixnum

See SDL_GL_GetSwapInterval.

[procedure] (gl-set-swap-interval! interval) → fixnum

See SDL_GL_SetSwapInterval.

Returns zero if successful

[procedure] (gl-extension-supported? name-string) → boolean

See SDL_GL_ExtensionSupported.

Joystick

[procedure] (num-joysticks) → fixnum

See SDL_NumJoysticks.

[procedure] (joystick-open! index) → sdl2:joystick

See SDL_JoystickOpen.

[procedure] (joystick-close! joystick)

See SDL_JoystickClose.

[procedure] (joystick-update!)

See SDL_JoystickUpdate.

[procedure] (joystick-event-state) → boolean
[setter] (set! (joystick-event-state) state) → boolean
[setter] (joystick-event-state-set! state) → boolean

joystick-event-state returns #t if joystick events are currently enabled, or #f if they are disabled (i.e. all future joystick-related events will be ignored).

The setters enable (if state is #t) or disable (if state is #f) joytsick events.

See SDL_JoystickEventState.

[procedure] (joystick-attached? joystick) → boolean

See SDL_JoystickGetAttached.

[procedure] (joystick-num-axes joystick) → fixnum

See SDL_JoystickNumAxes.

[procedure] (joystick-num-balls joystick) → fixnum

See SDL_JoystickNumBalls.

[procedure] (joystick-num-buttons joystick) → fixnum

See SDL_JoystickNumButtons.

[procedure] (joystick-num-hats joystick) → fixnum

See SDL_JoystickNumHats.

[procedure] (joystick-get-axis joystick axis-num) → fixnum

See SDL_JoystickGetAxis.

[procedure] (joystick-get-ball joystick ball-num) → [dx dy]

See SDL_JoystickGetBall.

This procedure returns multiple values. Returns #f for both values if the ball values cannot be retrieved (e.g. because ball-num is invalid for the joystick).

[procedure] (joystick-get-button joystick button-num) → boolean

See SDL_JoystickGetButton.

[procedure] (joystick-get-hat joystick hat-num) → symbol
[procedure] (joystick-get-hat-raw joystick hat-num) → fixnum

See SDL_JoystickGetHat.

• joystick-get-hat returns a joystick hat position symbol.
• joystick-get-hat-raw returns an integer.

[procedure] (joystick-instance-id joystick) → fixnum

See SDL_JoystickInstanceID.

[procedure] (joystick-name joystick) → string

See SDL_JoystickName.

[procedure] (joystick-name-for-index device-index) → string

See SDL_JoystickNameForIndex.

[procedure] (joystick-get-device-guid device-index) → sdl2:joystick-guid

See SDL_JoystickGetDeviceGUID.

Returns a new managed sdl2:joystick-guid.

[procedure] (joystick-get-guid joystick) → sdl2:joystick-guid

See SDL_JoystickGetGUID.

Returns a new managed sdl2:joystick-guid.

[procedure] (joystick-get-guid-from-string str) → sdl2:joystick-guid

See SDL_JoystickGetGUIDFromString.

Returns a new managed sdl2:joystick-guid.

[procedure] (joystick-get-guid-string guid) → string

See SDL_JoystickGetGUIDString.

Keyboard

[procedure] (get-key-from-name name-str) → symbol
[procedure] (get-key-from-name-raw name-str) → fixnum

See SDL_GetKeyFromName.

• get-key-from-name returns a keyboard keycode symbol.
• get-key-from-name-raw returns an integer.

[procedure] (get-key-from-scancode scancode) → symbol
[procedure] (get-key-from-scancode-raw scancode) → fixnum

See SDL_GetKeyFromScancode.

scancode must be a keyboard scancode symbol or an integer representing a keyboard scancode.

• get-key-from-scancode returns a keyboard keycode symbol.
• get-key-from-scancode-raw returns an integer.

[procedure] (get-key-name key) → string

See SDL_GetKeyName.

key must be a keyboard keycode symbol or an integer representing a keyboard keycode.

[procedure] (get-scancode-from-name name-str) → symbol
[procedure] (get-scancode-from-name-raw name-str) → fixnum

See SDL_GetScancodeFromName.

• get-scancode-from-name returns a keyboard scancode symbol.
• get-scancode-from-name-raw returns an integer.

[procedure] (get-scancode-from-key key) → symbol
[procedure] (get-scancode-from-key-raw key) → fixnum

See SDL_GetScancodeFromKey.

key must be a keyboard keycode symbol or an integer representing a keyboard keycode.

• get-scancode-from-key returns a keyboard scancode symbol.
• get-scancode-from-key-raw returns an integer.

[procedure] (get-scancode-name scancode) → string

See SDL_GetScancodeName.

scancode must be a keyboard scancode symbol or an integer representing a keyboard scancode.

[procedure] (get-keyboard-focus) → window

See SDL_GetKeyboardFocus.

[procedure] (scancode-pressed? scancode) → boolean

Returns #t if the keyboard key with the given scancode is currently being pressed.

scancode must be either a keyboard scancode symbol or an integer representing a scancode.

This procedure queries SDL's internal keyboard state, which is tied to the event system. Call pump-events! to update the keyboard state.

This procedure is based on SDL_GetKeyboardState.

[procedure] (mod-state) → list of symbols
[procedure] (mod-state-raw) → fixnum
[setter] (set! (mod-state) state)
[setter] (mod-state-set! state)

See SDL_GetModState.

• mod-state returns a list of zero or more keyboard modifier symbols.
• mod-state-raw returns an integer representing a bitfield of keyboard modifiers.
• The setters accept either a list of zero or more symbols, or an integer.

[setter] (text-input-rect-set! rect)

rect can be an sdl2:rect or #f.

See SDL_SetTextInputRect.

[procedure] (start-text-input!)

See SDL_StartTextInput.

[procedure] (stop-text-input!)

See SDL_StopTextInput.

[procedure] (text-input-active?) → boolean

See SDL_IsTextInputActive.

[procedure] (screen-keyboard-support?) → boolean

See SDL_HasScreenKeyboardSupport.

[procedure] (screen-keyboard-shown? window) → boolean

See SDL_IsScreenKeyboardShown.

Rect / Point

[procedure] (rect-empty? rect) → boolean

See SDL_RectEmpty.

[procedure] (enclose-points points #!optional clip result-rect) → [rect any-enclosed?]

See SDL_EnclosePoints.

points must be a list of sdl2:points.

clip must be either an sdl2:rect or #f (the default). If clip is an sdl2:rect, points outside the clip rect will be ignored.

If result-rect is omitted or #f, a new managed sdl2:rect will be returned. If result-rect is an sdl2:rect, it will be modified and returned. result-rect must not be the same object as either rect1 or rect2.

This procedure returns multiple values:

rect

An sdl2:rect that encloses all matching points. Possibly the same object as result-rect.

any-enclosed?

#t if any points were enclosed, or #f if all points were clipped

[procedure] (has-intersection? rect1 rect2) → boolean

See SDL_HasIntersection.

[procedure] (intersect-rect rect1 rect2 #!optional result-rect) → [rect intersect?]

See SDL_IntersectRect.

If result-rect is omitted or #f, a new managed sdl2:rect will be returned. If result-rect is an sdl2:rect, it will be modified and returned. result-rect must not be the same object as either rect1 or rect2.

This procedure returns multiple values:

rect

An sdl2:rect of the intersection of rect1 and rect2. Possibly the same object as result-rect.

intersect?

#t if rect1 and rect2 intersect, otherwise #f

[procedure] (intersect-rect-and-line rect x1 y1 x2 y2) → [intersect? x1-new y1-new x2-new y2-new]

See SDL_IntersectRectAndLine.

This procedure returns multiple values:

intersect?

#t if the given line intersects with the rect

x1-new

the x value of the point within rect that is closest to the first point

y1-new

the y value ...

x2-new

the x value of the point within rect that is closest to the second point

y2-new

the y value ...

[procedure] (union-rect rect1 rect2 #!optional result-rect) → rect

See SDL_UnionRect.

If result-rect is omitted or #f, a new managed sdl2:rect will be returned. If result-rect is an sdl2:rect, it will be modified and returned. result-rect must not be the same object as either rect1 or rect2.

RWops

[procedure] (rw-from-file filepath) → sdl2:rwops

See SDL_RWFromFile.

You should close the sdl2:rwops when you are done with it, using rw-close! or one of the procedures that can automatically close the sdl2:rwops, such as load-bmp-rw.

[procedure] (rw-from-const-mem pointer) → sdl2:rwops

See SDL_RWFromConstMem.

You should close the sdl2:rwops when you are done with it, using rw-close! or one of the procedures that can automatically close the sdl2:rwops, such as load-bmp-rw.

[procedure] (rw-from-mem pointer) → sdl2:rwops

See SDL_RWFromMem.

You should close the sdl2:rwops when you are done with it, using rw-close! or one of the procedures that can automatically close the sdl2:rwops, such as load-bmp-rw.

[procedure] (rw-from-blob blob) → sdl2:rwops

Create a new sdl2:rwops that accesses the memory of the given blob. You should close the sdl2:rwops when you are done with it, using rw-close! or one of the procedures that can automatically close the sdl2:rwops, such as load-bmp-rw.

You can also use this procedure to create a sdl2:rwops from a SRFI-4 numeric vector, by first converting it to a blob using e.g. u8vector->blob/shared.

CAUTION: Creating a sdl2:rwops from a blob in CHICKEN-managed memory is unstable: the blob might be garbage collected or moved in memory, which would break the sdl2:rwops. To be safe, you should evict the blob and create the sdl2:rwops from the evicted blob (not the original). You may wish to release the evicted blob after you have closed the sdl2:rwops. Example:

(let* ((evicted-blob (object-evict '#${...}))
       (rwops (sdl2:rw-from-blob evicted-blob))
       (surf (sdl2:load-bmp-rw rwops #t)))
  (object-release evicted-blob)
  surf)

[procedure] (rw-from-string str) → sdl2:rwops

Create a new sdl2:rwops that accesses the memory of the given CHICKEN Scheme string. You should close the sdl2:rwops when you are done with it, using rw-close! or one of the procedures that can automatically close the sdl2:rwops, such as load-bmp-rw.

CAUTION: Creating a sdl2:rwops from a string in CHICKEN-managed memory is unstable: the string might be garbage collected or moved in memory, which would break the sdl2:rwops. To be safe, you should evict the string and create the sdl2:rwops from the evicted string (not the original). You may wish to release the evicted string after you have closed the sdl2:rwops. Example:

(let* ((evicted-string (object-evict "..."))
       (rwops (sdl2:rw-from-string evicted-string))
       (surf (sdl2:load-bmp-rw rwops #t)))
  (object-release evicted-string)
  surf)

[procedure] (rw-close! rwops) → fixnum

See SDL_RWclose.

Close and clean up the given sdl2:rwops. This frees the memory used by the SDL_RWops struct itself, but does not free or release the pointer, blob, or string that the sdl2:rwops was reading/writing from. (It does close files opened with rw-from-file, though.)

Returns zero if successful.

Surface

[procedure] (create-rgb-surface flags width height depth rmask gmask bmask amask) → sdl2:surface

See SDL_CreateRGBSurface.

Returns a new unmanaged sdl2:surface with the given properties. You must call free-surface! when you are done with it.

See also make-surface for a more convenient interface.

[procedure] (create-rgb-surface-from pixels width height depth pitch rmask gmask bmask amask) → sdl2:surface

See SDL_CreateRGBSurfaceFrom.

Returns a new unmanaged sdl2:surface with the given properties, using existing pixel data (a pointer). You must call free-surface! when you are done with it.

[procedure] (convert-surface surface pixel-format) → sdl2:surface
[procedure] (convert-surface* surface pixel-format) → sdl2:surface

Creates a copy of the given sdl2:surface, but converts it to the given sdl2:pixel-format.

See SDL_ConvertSurface.

• convert-surface returns a managed sdl2:surface.
• convert-surface* returns an unmanaged sdl2:surface, which must be freed with free-surface! when you are done with it.

[procedure] (load-bmp path-string) → sdl2:surface
[procedure] (load-bmp* filepath) → sdl2:surface

See SDL_LoadBMP.

Attempts to load a BMP image file. Returns a sdl2:surface containing the image data, or #f if the image could not be loaded.

NOTE: This procedure only supports certain kinds of BMP image. Use the sdl2-image egg for better BMP support, plus support for loading other image formats like JPG, PNG, and GIF.

• load-bmp returns a managed sdl2:surface.
• load-bmp* returns an unmanaged sdl2:surface, which must be freed with free-surface! when you are done with it.

[procedure] (load-bmp-rw rwops #!optional close?) → sdl2:surface
[procedure] (load-bmp-rw* rwops #!optional close?) → sdl2:surface

See SDL_LoadBMP_RW.

Attempts to load a BMP image from the given sdl2:rwops. Returns a sdl2:surface containing the image data, or #f if the image could not be loaded.

If close? is #t, rwops will be automatically closed (see rw-close!) after the image is loaded. If close? is #f or omitted, rwops will not be closed.

NOTE: This procedure only supports certain kinds of BMP image. Use the sdl2-image egg for better BMP support, plus support for loading other image formats like JPG, PNG, and GIF.

• load-bmp-rw returns a managed sdl2:surface.
• load-bmp-rw* returns an unmanaged sdl2:surface, which must be freed with free-surface! when you are done with it.

[procedure] (save-bmp! surface filepath) → fixnum

See SDL_SaveBMP.

Returns zero if successful.

[procedure] (save-bmp-rw! surface rwops #!optional close?) → fixnum

See SDL_SaveBMP_RW.

If close? is #t, rwops will be automatically closed (see rw-close!) after the image is loaded. If close? is #f or omitted, rwops will not be closed.

Returns zero if successful.

[procedure] (lock-surface! surface) → fixnum

See SDL_LockSurface.

Returns zero if successful.

[procedure] (unlock-surface! surface)

See SDL_UnlockSurface.

[procedure] (must-lock? surface) → boolean

See SDL_MUSTLOCK.

[procedure] (blit-surface! src src-rect dest dest-rect) → fixnum

See SDL_BlitSurface.

Returns zero if successful. May modify dest-rect.

[procedure] (blit-scaled! src src-rect dest dest-rect) → fixnum

See SDL_BlitScaled.

Returns zero if successful. May modify dest-rect.

[procedure] (fill-rect! surface rect color) → fixnum

See SDL_FillRect.

rect may be an sdl2:rect to fill part of the surface, or #f to fill the entire surface.

color may be an sdl2:color or a mapped color (an integer, like returned by map-rgba).

Returns zero if successful.

[procedure] (fill-rects! surface rects color) → fixnum

See SDL_FillRects.

rects must be a list of sdl2:rects.

color may be an sdl2:color or a mapped color (an integer, like returned by map-rgba).

Returns zero if successful.

[procedure] (surface-ref surface x y) → sdl2:color
[procedure] (surface-ref-raw surface x y) → fixnum
[setter] (set! (surface-ref surface x y) color)
[setter] (surface-set! surface x y color)

Get or set the color of the specified pixel on the surface. Signals an error if x or y is out of bounds.

• surface-ref returns an sdl2:color.
• surface-ref-raw returns a mapped color (an integer). You can use get-rgba to convert the mapped color to color fields.
• The setters accept either an sdl2:color or a mapped color.

The setters automatically lock and unlock the surface if needed. They ignore the surface's clip rect.

[procedure] (surface-clip-rect surface) → sdl2:rect
[setter] (set! (surface-clip-rect surface) rect) → boolean
[setter] (surface-clip-rect-set! surface rect) → boolean

surface-clip-rect returns a copy of the surface's clip rect. See SDL_GetClipRect.

The setters sets the surface's clip rect to a copy of the given rect. rect may be #f, which disables clipping. See SDL_SetClipRect.

The setters return #t if the given rect intersects the surface at all, or #f if the rect is out of bounds (completely clips out the surface).

[procedure] (surface-color-key surface) → sdl2:color or #f
[procedure] (surface-colour-key surface) → sdl2:color or #f
[procedure] (surface-color-key-raw surface) → fixnum or #f
[procedure] (surface-colour-key-raw surface) → fixnum or #f
[setter] (set! (surface-color-key surface) color) → boolean
[setter] (set! (surface-colour-key surface) color) → boolean
[setter] (surface-color-key-set! surface color) → boolean
[setter] (surface-colour-key-set! surface color) → boolean

Get or set the sdl2:surface's color key.

See SDL_GetColorKey and SDL_SetColorKey.

• surface-color-key and surface-colour-key return an sdl2:color if the surface has a color key, or #f if the surface does not have a color key.
• surface-color-key-raw and surface-colour-key-raw return a mapped color (an integer) if the surface has a color key, or #f if the surface does not have a color key.
• The setters accept either an sdl2:color, a mapped color (an integer), or #f to disable color keying. The setters return zero if successful.

[procedure] (surface-alpha-mod surface) → fixnum
[setter] (set! (surface-alpha-mod surface) mod) → fixnum
[setter] (surface-alpha-mod-set! surface mod) → fixnum

See SDL_GetSurfaceAlphaMod and SDL_SetSurfaceAlphaMod.

The setters return zero if successful.

[procedure] (surface-blend-mode surface) → symbol
[setter] (set! (surface-blend-mode surface) mode) → fixnum
[setter] (surface-blend-mode-set! surface mode) → fixnum

See SDL_GetSurfaceBlendMode and SDL_SetSurfaceBlendMode.

surface-blend-mode returns a blend mode symbol:

• 'none
• 'blend
• 'add
• 'mod

The setters accept either a symbol or integer. The setters return zero if successful.

[procedure] (surface-color-mod surface) → [r g b]
[procedure] (surface-colour-mod surface) → [r g b]
[setter] (set! (surface-color-mod surface) rgb)
[setter] (set! (surface-colour-mod surface) rgb)
[setter] (surface-color-mod-set! surface rgb)
[setter] (surface-colour-mod-set! surface rgb)

See SDL_GetSurfaceColorMod and SDL_SetSurfaceColorMod.

surface-color-mod and surface-colour-mod return multiple values.

The setters accept either a list (r g b) of color values, or an sdl2:color (the sdl2:color's "a" field will be ignored).

[procedure] (surface-palette surface) → sdl2:palette or #f
[setter] (set! (surface-palette surface) palette)
[setter] (surface-palette-set! surface palette)

surface-palette returns the surface's palette, or #f if it has no palette. It is equivalent to (compose pixel-format-palette surface-format).

See SDL_SetSurfacePalette.

[setter] (surface-rle-set! surface enable)

See SDL_SetSurfaceRLE.

enable is #t to enable RLE acceleration or #f to disable it.

Timer

[procedure] (delay! milliseconds)

See SDL_Delay.

CAUTION: This procedure is not compatible with SRFI-18 threads. It will cause all threads to sleep for the given duration. If you are using multiple threads, you should instead call SRFI-18's thread-sleep!, which will cause only the current thread to sleep. For example, call (thread-sleep! 0.025) instead of (delay! 25).

[procedure] (get-ticks) → fixnum

See SDL_GetTicks.

[procedure] (get-performance-counter) → fixnum

See SDL_GetPerformanceCounter.

[procedure] (get-performance-frequency) → fixnum

See SDL_GetPerformanceFrequency.

Window

[procedure] (create-window! title x y w h #!optional flags) → sdl2:window

See SDL_CreateWindow.

x and y can be integers, the symbol 'centered, or the symbol 'undefined.

flags defaults to '(). It must be a list of zero or more window flag symbols (or an equivalent integer bitfield):

• 'fullscreen
• 'fullscreen-desktop
• 'opengl
• 'shown
• 'hidden
• 'borderless
• 'resizable
• 'minimized
• 'maximized
• 'input-grabbed
• 'input-focus
• 'mouse-focus
• 'foreign

[procedure] (get-window-from-id id) → sdl2:window

See SDL_GetWindowFromID.

[procedure] (destroy-window! window)

See SDL_DestroyWindow.

[procedure] (update-window-surface! window) → fixnum

See SDL_UpdateWindowSurface.

Returns zero if successful.

[procedure] (update-window-surface-rects! window rects) → fixnum

See SDL_UpdateWindowSurfaceRects.

rects must be a list of sdl2:rects.

Returns zero if successful.

[procedure] (show-window! window)

See SDL_ShowWindow.

[procedure] (hide-window! window)

See SDL_HideWindow.

[procedure] (maximize-window! window)

See SDL_MaximizeWindow.

[procedure] (minimize-window! window)

See SDL_MinimizeWindow.

[procedure] (raise-window! window)

See SDL_RaiseWindow.

[procedure] (restore-window! window)

See SDL_RestoreWindow.

[setter] (window-bordered-set! window bordered)

See SDL_SetWindowBordered.

bordered is #t to enable window decoration or #f to disable window decoration.

(There is currently no getter.)

[procedure] (window-brightness window) → float
[setter] (set! (window-brightness window) brightness) → fixnum
[setter] (window-brightness-set! window brightness) → fixnum

See SDL_GetWindowBrightness. and SDL_SetWindowBrightness.

The setters return zero if successful.

[procedure] (window-display-index window) → fixnum

See SDL_GetWindowDisplayIndex.

[procedure] (window-display-mode window) → sdl2:display-mode
[setter] (set! (window-display-mode window) display-mode) → fixnum
[setter] (window-display-mode-set! window display-mode) → fixnum

See SDL_GetWindowDisplayMode and SDL_SetWindowDisplayMode.

The setters affect the display mode used when the window is fullscreen. The setters return zero if successful.

[procedure] (window-flags window) → list of symbols

See SDL_GetWindowFlags.

Returns a list of window flag symbols.

[setter] (window-fullscreen-set! window mode)

See SDL_SetWindowFullscreen.

mode can be:

'fullscreen or #t

fullscreen

'fullscreen-desktop

fullscreen desktop

#f

not fullscreen

Returns zero if successful.

[procedure] (window-grab window) → boolean
[setter] (set! (window-grab window) grab?)
[setter] (window-grab-set! window grab?)

See SDL_GetWindowGrab and SDL_SetWindowGrab.

[setter] (window-icon-set! window icon-surface)

See SDL_SetWindowIcon.

[procedure] (window-id window) → fixnum

See SDL_GetWindowID.

[procedure] (window-maximum-size window) → [width height]
[setter] (set! (window-maximum-size window) size)
[setter] (window-maximum-size-set! window size)

See SDL_GetWindowMaximumSize and SDL_SetWindowMaximumSize.

window-maximum-size returns multiple values.

The setters accept a list of integers (width height).

[procedure] (window-minimum-size window) → [width height]
[setter] (set! (window-minimum-size window) size)
[setter] (window-minimum-size-set! window size)

See SDL_GetWindowMinimumSize and SDL_SetWindowMinimumSize.

window-minimum-size returns multiple values.

The setters accept a list of integers (width height).

[procedure] (window-pixel-format window) → sdl2:pixel-format

See SDL_GetWindowPixelFormat.

[procedure] (window-position window) → [x y]
[setter] (set! (window-position window) pos)
[setter] (window-position-set! window pos)

See SDL_GetWindowPosition and SDL_SetWindowPosition.

window-position returns multiple values.

The setters accept a list of integers (x y).

[procedure] (window-size window) → [width height]
[setter] (set! (window-size window) size)
[setter] (window-size-set! window size)

See SDL_GetWindowSize and SDL_SetWindowSize.

window-size returns multiple values.

The setters accept a list of integers (width height).

[procedure] (window-surface window) → sdl2:surface

See SDL_GetWindowSurface.

[procedure] (window-title window) → string
[setter] (set! (window-title window) title)
[setter] (window-title-set! window title)

See SDL_GetWindowTitle and SDL_SetWindowTitle.