Joseph Ferano
a4c6b996ff
The trio the author decided on 2026-09-20 is now all built: def is CL's defparameter — its initialiser runs on every daemon re-run, unguarded, so an edited initialiser repaints the same storage on C-c C-c plus re-run — defonce (Clojure's name for CL's defvar, per the author) initialises once behind the .init~once. flag, and defconst stays the image. One parse arm reads both forms; the difference is Ast.reinit, carried to Tast.global's grerun. Emit.startup_plan gives a def no guard flag, and Check.check_global lifts every def initialiser — zero and literal included — into global/<n>, so the host's startup reaches it through the function cell and a re-evaluated def swaps it (Session's def_inits; Emit.redefinition declares the cell for a non-sibling target). The old defvar spelling is refused with the rename and both compiling spellings, and every program, test, doc and editor list is swept — except sand.flan, the author's live WIP, whose seven defvar lines are flagged in FIX.org and keep its three dependent tests red on this branch.
101 lines
4.8 KiB
Plaintext
101 lines
4.8 KiB
Plaintext
;;;; raylib [shapes] example - basic shapes drawing
|
|
;;;;
|
|
;;;; examples/shapes/shapes_basic_shapes.c. Ported first of the shapes batch
|
|
;;;; because it is the widest single file in the category: six draw families
|
|
;;;; the corpus had never called — draw-circle-gradient, the two rectangle
|
|
;;;; gradients, draw-triangle and draw-triangle-lines, and all three of the
|
|
;;;; poly draws — in one frame, beside the four the core examples already
|
|
;;;; exercise. Every one of them came out of the generated half of the
|
|
;;;; bindings and none needed a new line anywhere; that is the result worth
|
|
;;;; recording, because the whole point of a committed generated.flan is that
|
|
;;;; a build with no FLAN_RAYLIB_H set can draw with all of it.
|
|
;;;;
|
|
;;;; What it is actually a test of. The gradient calls are the first thing in
|
|
;;;; the corpus to pass *two* Colors in one call, and draw-triangle is the
|
|
;;;; first to pass three Vector2s. A struct argument crosses the FFI by
|
|
;;;; pointer into a generated shim (vendor/raylib/raylib.flan's header note),
|
|
;;;; so the arity of that copying is what a call with several small structs in
|
|
;;;; a row puts under load. Nothing here can be asserted headless — every line
|
|
;;;; needs a GL context — so the check is the link and the screen, which is
|
|
;;;; what the Shapes comment in raylib.flan already says about this family.
|
|
;;;;
|
|
;;;; The one deliberate difference from the C: the C writes `screenWidth/4*2`
|
|
;;;; and `screenWidth/4.0f*3.0f` for the same column and gets 400 and 600 out
|
|
;;;; of integer and float division respectively. Both are written here as the
|
|
;;;; arithmetic they are, in the type the call wants, rather than copied with
|
|
;;;; a cast on the end — `(/ screen-width 5)` is an i32 division for the i32
|
|
;;;; parameters of draw-circle, and the poly centre is built from f32
|
|
;;;; literals because a Vector2 holds f32.
|
|
|
|
(import rl "vendor:raylib")
|
|
|
|
(defconst screen-width 800)
|
|
(defconst screen-height 450)
|
|
|
|
;; The three columns the C lays the shapes out in. The middle one is
|
|
;; screenWidth/4*2 and the right one screenWidth/4*3, which is 400 and 600.
|
|
(defconst col-left 160) ; screen-width / 5
|
|
(defconst col-mid 400)
|
|
(defconst col-right 600)
|
|
|
|
(defonce rotation f32)
|
|
|
|
(defn main [] ()
|
|
(rl/init-window screen-width screen-height
|
|
"raylib [shapes] example - basic shapes drawing")
|
|
(defer (rl/close-window))
|
|
|
|
(set rotation 0.0)
|
|
|
|
(rl/set-target-fps 60)
|
|
|
|
(until (rl/window-should-close?)
|
|
;; Update. The polygons spin; nothing else moves.
|
|
(set rotation (+ rotation 0.2))
|
|
|
|
;; Draw
|
|
(rl/with-drawing
|
|
(rl/clear-background rl/raywhite)
|
|
|
|
(rl/draw-text "some basic shapes available on raylib" 20 20 20 rl/darkgray)
|
|
|
|
;; Circles. The gradient one takes an inner and an outer colour and is the
|
|
;; first call in the corpus to pass two Colors at once.
|
|
(rl/draw-circle col-left 120 35.0 rl/darkblue)
|
|
(rl/draw-circle-gradient col-left 220 60.0 rl/green rl/skyblue)
|
|
(rl/draw-circle-lines col-left 340 80.0 rl/darkblue)
|
|
|
|
;; Rectangles. draw-rectangle-gradient-h runs the colour left to right;
|
|
;; the -v form runs it top to bottom and the -ex form takes all four
|
|
;; corners. The C uses the horizontal one here.
|
|
(rl/draw-rectangle (- col-mid 60) 100 120 60 rl/red)
|
|
(rl/draw-rectangle-gradient-h (- col-mid 90) 170 180 130 rl/maroon rl/gold)
|
|
;; raylib draws this with quads internally rather than with lines, which
|
|
;; is why its thickness does not follow the line width anywhere.
|
|
(rl/draw-rectangle-lines (- col-mid 40) 320 80 60 rl/orange)
|
|
|
|
;; Triangles. raylib wants the three vertices in counter-clockwise order
|
|
;; and draws nothing at all for a clockwise one, so the order here is not
|
|
;; cosmetic.
|
|
(rl/draw-triangle (rl/Vector2 {.x 600.0 .y 80.0})
|
|
(rl/Vector2 {.x 540.0 .y 150.0})
|
|
(rl/Vector2 {.x 660.0 .y 150.0})
|
|
rl/violet)
|
|
|
|
(rl/draw-triangle-lines (rl/Vector2 {.x 600.0 .y 160.0})
|
|
(rl/Vector2 {.x 580.0 .y 230.0})
|
|
(rl/Vector2 {.x 620.0 .y 230.0})
|
|
rl/darkblue)
|
|
|
|
;; Polygons, all three at the same centre and the same rotation, at three
|
|
;; radii, so the filled hexagon sits inside the two outlines.
|
|
(let [centre (rl/Vector2 {.x (f32 col-right) .y 330.0})]
|
|
(rl/draw-poly centre 6 80.0 rotation rl/brown)
|
|
(rl/draw-poly-lines centre 6 90.0 rotation rl/brown)
|
|
(rl/draw-poly-lines-ex centre 6 85.0 rotation 6.0 rl/beige))
|
|
|
|
;; The C draws every LINES-based shape together so raylib can batch them
|
|
;; into one pass. This last line is part of that comment and not an
|
|
;; afterthought, so it stays where the C has it.
|
|
(rl/draw-line 18 42 (- screen-width 18) 42 rl/black))))
|