90 lines
4.7 KiB
Plaintext
90 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.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)
|