Joseph Ferano
d7ceec448e
Three shapes, two text, three textures, one models and one core, picked for binding surface rather than for how they look. shapes-basic-shapes brings in six draw families nothing had called — the circle and rectangle gradients, the triangles, all three poly draws — and is the first call in the corpus to pass two Colors or three Vector2s at once. shapes-collision-area is get-collision-rec, the only binding that takes two Rectangles and answers a third, on a frame path. shapes-following-eyes is the raymath gap measured rather than worked around: every line of it is vector arithmetic written without a vector library, the way the C writes it. text-input-box drains get-char-pressed's queue, which no example had read, and needed a MouseCursor defenum for set-mouse-cursor. text-writing-anim replaces TextSubtext — unbindable, it answers a pointer into a rotating static buffer — with (string (slice b 0 n)), which is the same operation without the shared state. textures-image-generation runs nine Gen* calls and the gen/upload/unload-image path, all procedural, no file on disk. textures-fog-of-war needed a TextureFilter defenum: the smooth fog edge is entirely :bilinear on a 25x15 render texture, and it is also the first draw-texture-pro with a negative source height. textures-mouse-painting is the same render texture used as a document rather than as scratch, plus the round trip back off the GPU — load-image-from-texture, image-flip-vertical, export-image — which nothing had run. models-box-collisions is the counterexample to "a models example is a binding exercise": nothing in it is a Model, and one BoundingBox defstruct un-refuses four functions. core-3d-picking is the only caller anywhere for Ray and RayCollision, and picking is the inverse of the get-world-to-screen the corpus already had. Added to vendor/raylib: defstructs BoundingBox, Ray and RayCollision; defenums MouseCursor and TextureFilter with their mapping lines in bindings; hand-written declare-c for SetMouseCursor, SetTextureFilter, DrawCubeV, DrawSphere, DrawSphereWires, DrawRay and GetScreenToWorldRay, each excluded from the generated half on the rule bindings already states. generated.flan regenerated against raylib 5.5: 272 declarations, 117 refused, every defstruct, hand-written declare-c and mapped constant agreeing with the header.
103 lines
4.7 KiB
Plaintext
103 lines
4.7 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)
|
|
|
|
(defvar 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/begin-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)
|
|
|
|
(rl/end-drawing)))
|