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.
159 lines
7.0 KiB
Plaintext
159 lines
7.0 KiB
Plaintext
;;;; raylib [core] example - 3d picking
|
|
;;;;
|
|
;;;; examples/core/core_3d_picking.c. The one `core` example in this batch,
|
|
;;;; and it is here for surface and not for category: it is the only example
|
|
;;;; anywhere upstream that uses Ray and RayCollision without also loading a
|
|
;;;; Model, so it is the only way those two structs get a caller at all.
|
|
;;;;
|
|
;;;; Picking is the round trip the corpus was missing. core-world-screen.flan
|
|
;;;; already runs get-world-to-screen — a point in the scene to a pixel. This
|
|
;;;; is the inverse and it is a different shape: a pixel does not name a
|
|
;;;; point, it names a *line* through the scene, which is what a Ray is, and
|
|
;;;; the answer to "what did I click on" is where that line first meets
|
|
;;;; something, which is what a RayCollision is. Two structs the package could
|
|
;;;; not describe, for one operation that cannot be written without them.
|
|
;;;;
|
|
;;;; What was added, all in vendor/raylib/raylib.flan:
|
|
;;;;
|
|
;;;; - `Ray` — two Vector3s, origin and direction.
|
|
;;;; - `RayCollision` — a C `bool`, a float and two Vector3s. This is the
|
|
;;;; one of the three new structs a layout check can actually fail:
|
|
;;;; `hit` is one byte and `distance` is four, so there are three padding
|
|
;;;; bytes between them that a permutation destroys. BoundingBox's two
|
|
;;;; Vector3s are interchangeable and nothing would catch swapping them.
|
|
;;;; - `BoundingBox` — shared with examples/models-box-collisions.flan.
|
|
;;;; - get-screen-to-world-ray and draw-ray, hand-written beside
|
|
;;;; get-world-to-screen and the cube draws for the reasons `bindings`
|
|
;;;; gives: the first reads the same camera as its inverse, and the second
|
|
;;;; is inside a frame.
|
|
;;;;
|
|
;;;; get-ray-collision-box came free out of the generated half the moment Ray
|
|
;;;; and BoundingBox existed, along with the sphere, triangle and quad forms.
|
|
;;;; get-ray-collision-mesh is still refused and will stay refused: Mesh owns
|
|
;;;; seven arrays and a GPU handle, and describing it is a different job.
|
|
;;;;
|
|
;;;; raylib 5.5 renamed GetMouseRay to GetScreenToWorldRay and left the old
|
|
;;;; name as a #define. A #define is not a symbol, so there is nothing to bind
|
|
;;;; it to and nothing lost by not trying.
|
|
|
|
(import rl "vendor:raylib")
|
|
|
|
(defconst screen-width 800)
|
|
(defconst screen-height 450)
|
|
|
|
(defvar camera rl/Camera3D)
|
|
|
|
(defvar cube-position rl/Vector3)
|
|
(defvar cube-size rl/Vector3)
|
|
|
|
;; The picking ray, kept between frames because draw-ray draws it every frame
|
|
;; whether or not it hit anything — that is how the example shows where the
|
|
;; click went.
|
|
(defvar ray rl/Ray)
|
|
(defvar collision rl/RayCollision)
|
|
|
|
;; The same centre/size to min/max conversion as in
|
|
;; examples/models-box-collisions.flan. Written out here rather than shared
|
|
;; because an example is a single file the reader can follow end to end.
|
|
;;
|
|
;; It used to be eight expressions of field arithmetic; it is the half-extent
|
|
;; subtracted and added, which is what the C means, now that the package
|
|
;; carries vector arithmetic — see vendor/raylib/vector.flan. That file
|
|
;; exists because raymath is `static inline` and has no symbol to bind, so
|
|
;; v3-sub and v3-add are Flan and not C.
|
|
(defn box-around [centre rl/Vector3 size rl/Vector3] rl/BoundingBox
|
|
(let [half (rl/v3-scale size 0.5)]
|
|
(rl/BoundingBox {.min (rl/v3-sub centre half)
|
|
.max (rl/v3-add centre half)})))
|
|
|
|
(defn main [] ()
|
|
(rl/init-window screen-width screen-height
|
|
"raylib [core] example - 3d picking")
|
|
(defer (rl/close-window))
|
|
|
|
(set camera (rl/Camera3D {.position (rl/Vector3 {.x 10.0 .y 10.0 .z 10.0})
|
|
.target (rl/Vector3 {.x 0.0 .y 0.0 .z 0.0})
|
|
.up (rl/Vector3 {.x 0.0 .y 1.0 .z 0.0})
|
|
.fovy 45.0
|
|
.projection :perspective}))
|
|
|
|
(set cube-position (rl/Vector3 {.x 0.0 .y 1.0 .z 0.0}))
|
|
(set cube-size (rl/Vector3 {.x 2.0 .y 2.0 .z 2.0}))
|
|
|
|
;; Both start zeroed, which is the C's `= { 0 }`. A zero Ray draws as a
|
|
;; degenerate line at the origin and a zero RayCollision has hit false, so
|
|
;; neither needs a "not yet" flag beside it.
|
|
(set ray (rl/Ray {.position (rl/Vector3 {.x 0.0 .y 0.0 .z 0.0})
|
|
.direction (rl/Vector3 {.x 0.0 .y 0.0 .z 0.0})}))
|
|
(set collision (rl/RayCollision {.hit false .distance 0.0
|
|
.point (rl/Vector3 {.x 0.0 .y 0.0 .z 0.0})
|
|
.normal (rl/Vector3 {.x 0.0 .y 0.0 .z 0.0})}))
|
|
|
|
(rl/set-target-fps 60)
|
|
|
|
(until (rl/window-should-close?)
|
|
;; Update. The first-person controls only run while the cursor is
|
|
;; captured, which is what the right button toggles — otherwise the mouse
|
|
;; could not be used to aim at anything.
|
|
(when (rl/cursor-hidden?) (rl/update-camera (addr camera) :first-person))
|
|
|
|
(when (rl/mouse-button-pressed? :right)
|
|
(if (rl/cursor-hidden?) (rl/enable-cursor) (rl/disable-cursor)))
|
|
|
|
(when (rl/mouse-button-pressed? :left)
|
|
(if (not (.hit collision))
|
|
;; The pixel under the pointer, as a line through the scene, tested
|
|
;; against the cube's bounds.
|
|
(do
|
|
(set ray (rl/get-screen-to-world-ray (rl/get-mouse-position) camera))
|
|
(set collision
|
|
(rl/get-ray-collision-box ray (box-around cube-position cube-size))))
|
|
;; A second click deselects. Only `hit` is cleared; the ray stays put
|
|
;; and keeps being drawn, as in the C.
|
|
(set (.hit collision) false)))
|
|
|
|
;; Draw
|
|
(rl/begin-drawing)
|
|
(rl/clear-background rl/raywhite)
|
|
|
|
(rl/begin-mode-3d camera)
|
|
|
|
(if (.hit collision)
|
|
(do
|
|
(rl/draw-cube cube-position (.x cube-size) (.y cube-size) (.z cube-size)
|
|
rl/red)
|
|
(rl/draw-cube-wires cube-position (.x cube-size) (.y cube-size)
|
|
(.z cube-size) rl/maroon)
|
|
;; A slightly larger wireframe around the selection, which is the
|
|
;; whole visual feedback of the example.
|
|
(rl/draw-cube-wires cube-position (+ (.x cube-size) 0.2)
|
|
(+ (.y cube-size) 0.2) (+ (.z cube-size) 0.2)
|
|
rl/green))
|
|
(do
|
|
(rl/draw-cube cube-position (.x cube-size) (.y cube-size) (.z cube-size)
|
|
rl/gray)
|
|
(rl/draw-cube-wires cube-position (.x cube-size) (.y cube-size)
|
|
(.z cube-size) rl/darkgray)))
|
|
|
|
;; raylib draws the ray a thousand units long, so it reads as a line
|
|
;; crossing the scene rather than as a segment with an end.
|
|
(rl/draw-ray ray rl/maroon)
|
|
(rl/draw-grid 10 1.0)
|
|
|
|
(rl/end-mode-3d)
|
|
|
|
(rl/draw-text "Try clicking on the box with your mouse!" 240 10 20
|
|
rl/darkgray)
|
|
|
|
(when (.hit collision)
|
|
(rl/draw-text "BOX SELECTED"
|
|
(/ (- screen-width (rl/measure-text "BOX SELECTED" 30)) 2)
|
|
(i32 (* (f32 screen-height) 0.1)) 30 rl/green))
|
|
|
|
(rl/draw-text "Right click mouse to toggle camera controls" 10 430 10
|
|
rl/gray)
|
|
|
|
(rl/draw-fps 10 10)
|
|
|
|
(rl/end-drawing)))
|