178 lines
8.2 KiB
Plaintext
178 lines
8.2 KiB
Plaintext
;;;; raylib [core] example - window flags
|
|
;;;;
|
|
;;;; examples/core/core_window_flags.c. The reason to port this one is the
|
|
;;;; flags themselves: raylib.flan carried four of ConfigFlags' sixteen
|
|
;;;; members — the four sand.flan sets before the window exists — and this
|
|
;;;; example reads and writes eleven of them after it exists. All sixteen are
|
|
;;;; in raylib.flan now, read off raylib.h 5.5, in the header's order and not
|
|
;;;; in bit order (FLAG_VSYNC_HINT is 0x40 and FLAG_FULLSCREEN_MODE is 0x02,
|
|
;;;; which is the kind of thing nobody remembers correctly).
|
|
;;;;
|
|
;;;; They are `defconst u32`s and not a `defenum` for the reason the file
|
|
;;;; already gives about gestures: raylib wants the OR of several and a
|
|
;;;; keyword can only ever name one member.
|
|
;;;;
|
|
;;;; window-state?, set-window-state, clear-window-state, toggle-fullscreen,
|
|
;;;; minimize-window, maximize-window and restore-window all come from the
|
|
;;;; generated half. That is the line drawn in vendor/raylib/bindings and it
|
|
;;;; is worth saying why it falls here: the rule in docs/PORTING.md §1 exists so
|
|
;;;; that a build with no header set can still draw, and generated.flan is
|
|
;;;; committed, so it can. What a hand-written line adds on top of that is a
|
|
;;;; Flan face the C signature does not have — a Key instead of an int, a
|
|
;;;; (Ptr Camera3D) instead of a raw pointer — and these seven have no such
|
|
;;;; face to add. They are u32 in and bool out in both languages.
|
|
;;;;
|
|
;;;; Not faithful in one place, deliberately: the C draws twelve lines of
|
|
;;;; on/off state through TextFormat and a two-branch if each time. Flan has
|
|
;;;; no TextFormat, so the pair is one helper here — which also removes the
|
|
;;;; C's own copy-paste bug, where the UNFOCUSED line says "[G]" when it is on
|
|
;;;; and "[U]" when it is off.
|
|
|
|
(import rl "vendor:raylib")
|
|
(import d "digits.flan")
|
|
|
|
(defconst screen-width 800)
|
|
(defconst screen-height 450)
|
|
|
|
;; Frames the window has been hidden or minimized for. H and N both put the
|
|
;; window somewhere it cannot be typed at, so the only way back is a count.
|
|
(defconst restore-after 240)
|
|
|
|
(defvar ball-pos rl/Vector2)
|
|
(defvar ball-speed rl/Vector2)
|
|
(defvar frames i32)
|
|
|
|
(defconst ball-radius f32 20.0)
|
|
|
|
;; One line of the state list: the label, then "on" or "off" in lime or
|
|
;; maroon, at the x the label ended. The C writes two whole DrawText calls per
|
|
;; flag with the text repeated; this says it once.
|
|
(defn draw-flag [label string flag u32 y i32] ()
|
|
(rl/draw-text label 10 y 10 rl/gray)
|
|
(let [x (+ 10 (rl/measure-text label 10))]
|
|
(if (rl/window-state? flag)
|
|
(rl/draw-text " on" x y 10 rl/lime)
|
|
(rl/draw-text " off" x y 10 rl/maroon))))
|
|
|
|
;; A flag the program owns: pressing the key turns it off if it is on and on
|
|
;; if it is off. Nine of the C's eleven key handlers are exactly this.
|
|
(defn toggle-flag [flag u32] ()
|
|
(if (rl/window-state? flag)
|
|
(rl/clear-window-state flag)
|
|
(rl/set-window-state flag)))
|
|
|
|
(defn main [] ()
|
|
;; The C leaves its SetConfigFlags call commented out, so that every flag
|
|
;; the list shows starts off. Kept that way: the point of the example is
|
|
;; which of them can be changed afterwards.
|
|
(rl/init-window screen-width screen-height
|
|
"raylib [core] example - window flags")
|
|
(defer (rl/close-window))
|
|
|
|
(set ball-pos (rl/Vector2 {.x (/ (f32 (rl/get-screen-width)) 2.0)
|
|
.y (/ (f32 (rl/get-screen-height)) 2.0)}))
|
|
(set ball-speed (rl/Vector2 {.x 5.0 .y 4.0}))
|
|
|
|
;; No set-target-fps, as in the C: with FLAG_VSYNC_HINT among the flags the
|
|
;; example toggles, a frame limiter on top of it would hide what V-Sync
|
|
;; does to the number draw-fps reports.
|
|
|
|
(until (rl/window-should-close?)
|
|
;; Update
|
|
(when (rl/key-pressed? :f) (rl/toggle-fullscreen))
|
|
(when (rl/key-pressed? :r) (toggle-flag rl/flag-window-resizable))
|
|
(when (rl/key-pressed? :d) (toggle-flag rl/flag-window-undecorated))
|
|
(when (rl/key-pressed? :u) (toggle-flag rl/flag-window-unfocused))
|
|
(when (rl/key-pressed? :t) (toggle-flag rl/flag-window-topmost))
|
|
(when (rl/key-pressed? :a) (toggle-flag rl/flag-window-always-run))
|
|
(when (rl/key-pressed? :v) (toggle-flag rl/flag-vsync-hint))
|
|
|
|
;; Hidden and minimized are not toggles: the window they hide is also the
|
|
;; window the key would have to be pressed in, so each comes back on a
|
|
;; timer instead.
|
|
(when (rl/key-pressed? :h)
|
|
(unless (rl/window-state? rl/flag-window-hidden)
|
|
(rl/set-window-state rl/flag-window-hidden))
|
|
(set frames 0))
|
|
|
|
(when (rl/window-state? rl/flag-window-hidden)
|
|
(set frames (+ frames 1))
|
|
(when (>= frames restore-after)
|
|
(rl/clear-window-state rl/flag-window-hidden)))
|
|
|
|
(when (rl/key-pressed? :n)
|
|
(unless (rl/window-state? rl/flag-window-minimized)
|
|
(rl/minimize-window))
|
|
(set frames 0))
|
|
|
|
(when (rl/window-state? rl/flag-window-minimized)
|
|
(set frames (+ frames 1))
|
|
(when (>= frames restore-after) (rl/restore-window)))
|
|
|
|
;; Maximize needs FLAG_WINDOW_RESIZABLE first, which is what R is for.
|
|
(when (rl/key-pressed? :m)
|
|
(if (rl/window-state? rl/flag-window-maximized)
|
|
(rl/restore-window)
|
|
(rl/maximize-window)))
|
|
|
|
;; The ball bounces off whatever the window is right now, so resizing,
|
|
;; maximizing and going fullscreen all show up in its path.
|
|
(set (.x ball-pos) (+ (.x ball-pos) (.x ball-speed)))
|
|
(set (.y ball-pos) (+ (.y ball-pos) (.y ball-speed)))
|
|
(when (or (>= (.x ball-pos) (- (f32 (rl/get-screen-width)) ball-radius))
|
|
(<= (.x ball-pos) ball-radius))
|
|
(set (.x ball-speed) (* (.x ball-speed) -1.0)))
|
|
(when (or (>= (.y ball-pos) (- (f32 (rl/get-screen-height)) ball-radius))
|
|
(<= (.y ball-pos) ball-radius))
|
|
(set (.y ball-speed) (* (.y ball-speed) -1.0)))
|
|
|
|
;; Draw
|
|
(rl/with-drawing
|
|
|
|
;; A transparent framebuffer wants a transparent clear; anything else
|
|
;; paints over the desktop the flag exists to show.
|
|
(if (rl/window-state? rl/flag-window-transparent)
|
|
(rl/clear-background rl/blank)
|
|
(rl/clear-background rl/raywhite))
|
|
|
|
(rl/draw-circle-v ball-pos ball-radius rl/maroon)
|
|
(rl/draw-rectangle-lines-ex
|
|
(rl/Rectangle {.x 0.0 .y 0.0
|
|
.width (f32 (rl/get-screen-width))
|
|
.height (f32 (rl/get-screen-height))})
|
|
4.0 rl/raywhite)
|
|
|
|
(rl/draw-circle-v (rl/get-mouse-position) 10.0 rl/darkblue)
|
|
|
|
(rl/draw-fps 10 10)
|
|
|
|
;; The C's TextFormat("Screen Size: [%i, %i]", ...), reassembled out of
|
|
;; literals and examples/digits.flan the way the other ports do it: `x`
|
|
;; walks along the line, and draw-int hands back the width it drew.
|
|
(let [x 10]
|
|
(rl/draw-text "Screen Size: [" x 40 10 rl/green)
|
|
(set x (+ x (rl/measure-text "Screen Size: [" 10)))
|
|
(set x (+ x (d/draw-int (rl/get-screen-width) x 40 10 rl/green)))
|
|
(rl/draw-text ", " x 40 10 rl/green)
|
|
(set x (+ x (rl/measure-text ", " 10)))
|
|
(set x (+ x (d/draw-int (rl/get-screen-height) x 40 10 rl/green)))
|
|
(rl/draw-text "]" x 40 10 rl/green))
|
|
(rl/draw-text "Following flags can be set after window creation:"
|
|
10 60 10 rl/gray)
|
|
(draw-flag "[F] FLAG_FULLSCREEN_MODE:" rl/flag-fullscreen-mode 80)
|
|
(draw-flag "[R] FLAG_WINDOW_RESIZABLE:" rl/flag-window-resizable 100)
|
|
(draw-flag "[D] FLAG_WINDOW_UNDECORATED:" rl/flag-window-undecorated 120)
|
|
(draw-flag "[H] FLAG_WINDOW_HIDDEN:" rl/flag-window-hidden 140)
|
|
(draw-flag "[N] FLAG_WINDOW_MINIMIZED:" rl/flag-window-minimized 160)
|
|
(draw-flag "[M] FLAG_WINDOW_MAXIMIZED:" rl/flag-window-maximized 180)
|
|
(draw-flag "[U] FLAG_WINDOW_UNFOCUSED:" rl/flag-window-unfocused 200)
|
|
(draw-flag "[T] FLAG_WINDOW_TOPMOST:" rl/flag-window-topmost 220)
|
|
(draw-flag "[A] FLAG_WINDOW_ALWAYS_RUN:" rl/flag-window-always-run 240)
|
|
(draw-flag "[V] FLAG_VSYNC_HINT:" rl/flag-vsync-hint 260)
|
|
|
|
(rl/draw-text "Following flags can only be set before window creation:"
|
|
10 300 10 rl/gray)
|
|
(draw-flag "FLAG_WINDOW_HIGHDPI:" rl/flag-window-highdpi 320)
|
|
(draw-flag "FLAG_WINDOW_TRANSPARENT:" rl/flag-window-transparent 340)
|
|
(draw-flag "FLAG_MSAA_4X_HINT:" rl/flag-msaa-4x-hint 360))))
|