;;;; 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)))