;;;; 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.fln ;;;; 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.fln: ;;;; ;;;; - `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.fln. ;;;; - 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" const screen-width = 800 const screen-height = 450 once camera: rl/Camera3D once cube-position: rl/Vector3 once 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. once ray: rl/Ray once collision: rl/RayCollision ;; The same centre/size to min/max conversion as in ;; examples/models-box-collisions.fln. 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.fln. 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. fn 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)} fn main() -> () rl/init-window(screen-width, screen-height, "raylib [core] example - 3d picking") defer rl/close-window() 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 :projection-perspective} cube-position = rl/Vector3{.x 0.0 .y 1.0 .z 0.0} 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. 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}} 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. if rl/is-cursor-hidden() rl/update-camera(addr(camera), :camera-first-person) if rl/is-mouse-button-pressed(:mouse-right) if rl/is-cursor-hidden() then rl/enable-cursor() else rl/disable-cursor() if rl/is-mouse-button-pressed(:mouse-left) if not collision.hit ;; The pixel under the pointer, as a line through the scene, tested ;; against the cube's bounds. ray = rl/get-screen-to-world-ray(rl/get-mouse-position(), camera) 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. else collision.hit = false ;; Draw rl/with-drawing: rl/clear-background(rl/raywhite) rl/with-mode-3d(camera): if collision.hit rl/draw-cube(cube-position, cube-size.x, cube-size.y, cube-size.z, rl/red) rl/draw-cube-wires(cube-position, cube-size.x, cube-size.y, cube-size.z, rl/maroon) ;; A slightly larger wireframe around the selection, which is the ;; whole visual feedback of the example. rl/draw-cube-wires(cube-position, cube-size.x + 0.2, cube-size.y + 0.2, cube-size.z + 0.2, rl/green) else rl/draw-cube(cube-position, cube-size.x, cube-size.y, cube-size.z, rl/gray) rl/draw-cube-wires(cube-position, cube-size.x, cube-size.y, cube-size.z, 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/draw-text("Try clicking on the box with your mouse!", 240, 10, 20, rl/darkgray) if collision.hit 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)