Joseph Ferano
5a1c2745b0
Three kinds of Flan face over the generated set, which stays honest to C because that is what makes it checkable against the header. A slice where C takes a pointer and a count: the eleven vector-array drawing calls, all eleven rather than the three anybody calls, since a subset has its hole where the next caller looks. Each guards the empty slice, which is the part a hand-written call site gets wrong rather than merely writes out -- raylib takes a count of 0 happily, but taking the address of element 0 of an empty slice is out of bounds before raylib is reached. An Option where C signals with a sentinel: get-key-pressed and get-char-pressed, raylib's two input queues, both of which say "empty" with 0. What that buys is in text-input-box.flan, which read the queue in two places -- once to prime the loop, once at the bottom of the body -- and now reads it in one. Both of those use the `name` directive in bindings, so the generated declaration keeps the symbol and gives up the name: nothing about the C signature is hand-written and the generated half keeps its agreement-by-construction with the header. An enum where the header says int: key-up?, key-pressed-repeat?, mouse-button-up?. These are NOT wrappers -- a C enum parameter has an int's ABI, so the hand-written declare-c with the Flan type is the whole fix. They were holes in families whose other halves already took a Key, so (rl/key-down? :space) compiled and (rl/key-up? :space) did not. Not built: with-drawing and with-mode-2d. A macro cannot live in a package -- the expander collects defmacros from the prelude and from the file being compiled, and one in an imported package is refused by name. test/programs/pkg-macro.flan is that refusal. And vendor/raylib/vector.flan, which is raymath written in Flan because raymath is static inline and has no symbol to bind. A file of its own, split on declare-c and not on "idiomatic": there is not one declaration in it, so it is not part of the surface the header check reads, and raylib.flan is 1300 lines already. clamp and lerp are deliberately absent -- the prelude has both, and a second lerp would not even be the same function, since the prelude writes (1-t)a + tb where raymath writes a + t*(b - a). Examples: the identical eight-expression box-around helper in core-3d-picking and models-box-collisions is a half-extent subtracted and added. shapes-following-eyes keeps its measurement and gives up one line to v2-sub, which is the honest size of the gap in a file that is nothing but vector maths.
113 lines
5.1 KiB
Plaintext
113 lines
5.1 KiB
Plaintext
;;;; raylib [shapes] example - following eyes
|
|
;;;;
|
|
;;;; examples/shapes/shapes_following_eyes.c. Ported for the thing it needs
|
|
;;;; that raylib does not supply: the whole update is vector arithmetic —
|
|
;;;; subtract two points, take the angle, walk back out along it — and every
|
|
;;;; one of those steps is raymath. raymath is `static inline` in
|
|
;;;; raymath.h, so Vector2Subtract and Vector2Angle have no symbol in
|
|
;;;; libraylib at all and there is nothing for declare-c to bind. NEXT.md
|
|
;;;; names this as one of the three open gaps.
|
|
;;;;
|
|
;;;; What that costs here is nothing, because the C does not use raymath
|
|
;;;; either — it writes the four subtractions out and calls atan2f, cosf and
|
|
;;;; sinf from libm, and Flan's prelude already declares all three as
|
|
;;;; atan2-f32, cos-f32 and sin-f32. So this file is the *measurement* of the
|
|
;;;; gap rather than a workaround for it: an example whose every line is
|
|
;;;; vector maths, written without a vector library, in the same shape the C
|
|
;;;; has. It reads fine. A Vector2Add would have saved two lines in the whole
|
|
;;;; file.
|
|
;;;;
|
|
;;;; That measurement is what decided the answer, and the answer landed:
|
|
;;;; vendor/raylib/vector.flan is raymath written in Flan, since a C shim
|
|
;;;; re-exporting the inlines would have bought identical arithmetic at the
|
|
;;;; price of a compilation unit and a second place raylib's semantics live.
|
|
;;;; The measurement is left standing rather than rewritten away — one
|
|
;;;; subtraction below is `rl/v2-sub` and the rest of the file is unchanged,
|
|
;;;; including the atan2/cos/sin path, which is deliberate: it needs no guard
|
|
;;;; for a zero-length vector where a normalise would. One line saved, in a
|
|
;;;; file that is nothing but vector maths, is the honest size of the gap.
|
|
;;;;
|
|
;;;; The raylib call it does exercise is collision-point-circle?, which no
|
|
;;;; ported example had called, on a frame path, with the point coming
|
|
;;;; straight out of get-mouse-position — one struct out of raylib and back
|
|
;;;; into it untouched.
|
|
;;;;
|
|
;;;; The eye geometry, since the C hides it in a subtraction: the iris is
|
|
;;;; pinned inside a circle of (sclera - iris) radius about the sclera's
|
|
;;;; centre, so the iris disc is tangent to the sclera's edge at the extreme
|
|
;;;; rather than hanging over it.
|
|
|
|
(import rl "vendor:raylib")
|
|
|
|
(defconst screen-width 800)
|
|
(defconst screen-height 450)
|
|
|
|
(defconst sclera-radius f32 80.0)
|
|
(defconst iris-radius f32 24.0)
|
|
|
|
(defvar sclera-left rl/Vector2)
|
|
(defvar sclera-right rl/Vector2)
|
|
(defvar iris-left rl/Vector2)
|
|
(defvar iris-right rl/Vector2)
|
|
|
|
;; One eye's pupil, given where the mouse is and where the eye is. Answers the
|
|
;; mouse position unchanged while it is inside the eye, and the point on the
|
|
;; limit circle in that direction when it is outside.
|
|
;;
|
|
;; The C repeats this block twice with different variables; it is one function
|
|
;; here because the two copies are identical and a difference between them
|
|
;; would be invisible.
|
|
(defn track [mouse rl/Vector2 centre rl/Vector2] rl/Vector2
|
|
(let [limit (- sclera-radius iris-radius)]
|
|
(if (rl/collision-point-circle? mouse centre limit)
|
|
mouse
|
|
;; Outside: the direction from the eye to the mouse, and then `limit`
|
|
;; units back out along it. atan2 then cos/sin rather than a normalise,
|
|
;; because that is what the C does and because it needs no guard for a
|
|
;; zero-length vector — atan2(0,0) is 0 and the pupil sits at the right
|
|
;; of the eye, which is unreachable anyway since (0,0) is inside.
|
|
(let [d (rl/v2-sub mouse centre)
|
|
angle (atan2-f32 (.y d) (.x d))]
|
|
(rl/Vector2 {.x (+ (.x centre) (* limit (cos-f32 angle)))
|
|
.y (+ (.y centre) (* limit (sin-f32 angle)))})))))
|
|
|
|
(defn main [] ()
|
|
(rl/init-window screen-width screen-height
|
|
"raylib [shapes] example - following eyes")
|
|
(defer (rl/close-window))
|
|
|
|
;; The C reads these off get-screen-width/get-screen-height after the window
|
|
;; is open rather than off the constants, and so does this: on a high-DPI
|
|
;; display the two can differ.
|
|
(set sclera-left (rl/Vector2 {.x (- (/ (f32 (rl/get-screen-width)) 2.0) 100.0)
|
|
.y (/ (f32 (rl/get-screen-height)) 2.0)}))
|
|
(set sclera-right (rl/Vector2 {.x (+ (/ (f32 (rl/get-screen-width)) 2.0) 100.0)
|
|
.y (/ (f32 (rl/get-screen-height)) 2.0)}))
|
|
(set iris-left sclera-left)
|
|
(set iris-right sclera-right)
|
|
|
|
(rl/set-target-fps 60)
|
|
|
|
(until (rl/window-should-close?)
|
|
;; Update
|
|
(let [mouse (rl/get-mouse-position)]
|
|
(set iris-left (track mouse sclera-left))
|
|
(set iris-right (track mouse sclera-right)))
|
|
|
|
;; Draw
|
|
(rl/begin-drawing)
|
|
(rl/clear-background rl/raywhite)
|
|
|
|
;; White of the eye, iris, pupil — in that order, each over the last.
|
|
(rl/draw-circle-v sclera-left sclera-radius rl/lightgray)
|
|
(rl/draw-circle-v iris-left iris-radius rl/brown)
|
|
(rl/draw-circle-v iris-left 10.0 rl/black)
|
|
|
|
(rl/draw-circle-v sclera-right sclera-radius rl/lightgray)
|
|
(rl/draw-circle-v iris-right iris-radius rl/darkgreen)
|
|
(rl/draw-circle-v iris-right 10.0 rl/black)
|
|
|
|
(rl/draw-fps 10 10)
|
|
|
|
(rl/end-drawing)))
|