;;;; 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.fln 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.fln'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.fln 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"

const screen-width = 800
const 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.
const col-left = 160  ; screen-width / 5
const col-mid = 400
const col-right = 600

once rotation: f32

fn main() -> ()
  rl/init-window(screen-width, screen-height,
                 "raylib [shapes] example - basic shapes drawing")
  defer rl/close-window()
  rotation = 0.0
  rl/set-target-fps(60)
  until rl/window-should-close()
    ;; Update. The polygons spin; nothing else moves.
    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)