nbio: add examples (#161)

* nbio: add examples

* fix shadowing

Author: laytan

.github/workflows/check.yml

@@ -158,6 +158,14 @@ jobs:
           odin check nanovg/example.odin -file $FLAGS
           odin check nanovg/fbo.odin -file $FLAGS
 
+          odin check nbio/context $FLAGS
+          odin check nbio/game-loop $FLAGS
+          odin check nbio/no-callbacks $FLAGS
+          odin check nbio/sendfile $FLAGS
+          odin check nbio/tcp-echo $FLAGS
+          odin check nbio/udp-echo $FLAGS
+          odin check nbio/workers $FLAGS
+
           # TODO: fix orca examples after update.
           # odin check orca/breakout -target:orca_wasm32 $FLAGS
           # odin check orca/clock -target:orca_wasm32 $FLAGS

nbio/context/main.odin

@@ -0,0 +1,30 @@
+package main
+
+import "base:runtime"
+
+import "core:nbio"
+import "core:time"
+
+main :: proc() {
+	nbio.acquire_thread_event_loop()
+	defer nbio.release_thread_event_loop()
+
+	{
+		context.user_index = 2
+
+		// By default, the context you receive in callbacks is the one that `nbio.run`/`tick` receives.
+		nbio.timeout(time.Second, proc(op: ^nbio.Operation) {
+			assert(context.user_index == 1)
+		})
+
+		// If you want to pass through the current context, you could clone it, pass it through user data, and restore it.
+		nbio.timeout_poly(time.Second, new_clone(context), proc(op: ^nbio.Operation, ctx: ^runtime.Context) {
+			context = ctx^
+			free(ctx)
+			assert(context.user_index == 2)
+		})
+	}
+
+	context.user_index = 1
+	nbio.run()
+}

nbio/game-loop/main.odin

@@ -0,0 +1,121 @@
+/*
+Example game loop integrated with nbio, using Raylib here.
+
+Showcases a simple async asset loader, textures are assigned a default texture at the start.
+When the texture is asked to be loaded it is done so using the event loop.
+*/
+package main
+
+import "core:nbio"
+import "core:log"
+import "core:strings"
+
+import rl "vendor:raylib"
+
+Texture :: struct {
+	path:   cstring,
+	width:  int,
+	height: int,
+	data:   rl.Texture2D,
+}
+
+Texture_Name :: enum {
+	Default,
+	Raylib_Logo,
+}
+
+g_textures := [Texture_Name]Texture{
+	.Default     = {#directory + "/missing.png", 32, 32, {}},
+	.Raylib_Logo = {#directory + "/raylib_logo.png", 256, 256, {}},
+}
+
+main :: proc() {
+	context.logger = log.create_console_logger()
+
+	nbio.acquire_thread_event_loop()
+	defer nbio.release_thread_event_loop()
+
+	rl.InitWindow(800, 600, "nbio")
+	defer rl.CloseWindow()
+
+	load_texture(&g_textures[.Default])
+
+	rl.SetTargetFPS(60)
+
+	for !rl.WindowShouldClose() {
+		// Note that it is probably not good to run your event loop bound by the frame rate.
+		// There is this cool story about GTA5, which does this, and people had to develop a mod
+		// that turned off vsync during loading screens (causing much more fps) which would speed
+		// up the event loop and make the loading screen go by much faster.
+		if err := nbio.tick(timeout=0); err != nil {
+			log.errorf("nbio.tick: %v", err)
+		}
+
+		w, h := f32(rl.GetScreenWidth()), f32(rl.GetScreenHeight())
+
+		{
+			rl.BeginDrawing()
+			defer rl.EndDrawing()
+
+			rl.ClearBackground(rl.RAYWHITE)
+
+			txt := &g_textures[.Raylib_Logo]
+			draw_texture(txt^, {w/2 - f32(txt.width)/2, h/2 - f32(txt.height)/2, f32(txt.width), f32(txt.height)}, rl.WHITE)
+
+			if rl.GuiButton({w/2 - f32(txt.width)/2, h/2 + f32(txt.height)/2, f32(txt.width), 50}, "Load texture") {
+				if rl.IsTextureReady(txt.data) {
+					rl.UnloadTexture(txt.data)
+					txt.data = {}
+				} else {
+					load_texture(txt)
+				}
+			}
+		}
+	}
+}
+
+draw_texture :: proc(txt: Texture, dest: rl.Rectangle, tint: rl.Color) {
+	txt := txt
+	if !rl.IsTextureReady(txt.data) {
+		txt.data = g_textures[.Default].data
+	}
+
+	rl.DrawTexturePro(
+		txt.data,
+		{0, 0, f32(txt.data.width), f32(txt.data.height)},
+		dest,
+		{},
+		0,
+		rl.WHITE,
+	)
+}
+
+load_texture :: proc(txt: ^Texture) {
+	assert(txt.width > 0)
+	assert(txt.height > 0)
+	assert(txt.path != nil)
+	txt.data = g_textures[.Default].data
+
+	nbio.read_entire_file(string(txt.path), txt, on_read)
+
+	on_read :: proc(txt: rawptr, buf: []byte, err: nbio.Read_Entire_File_Error) {
+		txt := (^Texture)(txt)
+		if err.value != nil {
+			log.errorf("load_texture(%q): %v: %v", txt.path, err.operation, err.value)
+			return
+		}
+
+		spath := string(txt.path)
+		i := strings.last_index(spath, ".")
+		assert(i > 0)
+		ext := spath[i:]
+
+		image := rl.LoadImageFromMemory(cstring(raw_data(ext)), raw_data(buf), i32(len(buf)))
+		txt.data = rl.LoadTextureFromImage(image)
+
+		rl.UnloadImage(image)
+		delete(buf)
+
+		log.infof("load_texture: %q loaded", txt.path)
+	}
+}

nbio/game-loop/missing.png

@@ -0,0 +1,73 @@
+/*
+Example shows how you could poll completions instead of being pushed completions through callbacks.
+
+Completions are added to a queue by a single simple callback, and handled whenever wanted.
+
+It is a UDP echo server.
+*/
+package main
+
+import "core:container/queue"
+import "core:fmt"
+import "core:nbio"
+
+main :: proc() {
+	nbio.acquire_thread_event_loop()
+	defer nbio.release_thread_event_loop()
+
+	socket, err := nbio.create_udp_socket(.IP4)
+	if err != nil {
+		fmt.eprintfln("create_udp_socket: %v", err)
+		return
+	}
+	if err := nbio.bind(socket, {nbio.IP4_Loopback, 1234}); err != nil {
+		fmt.eprintfln("bind: %v", err)
+		return
+	}
+
+	buf: [1024]byte
+	nbio.recv(socket, {buf[:]}, queue_callback)
+
+	for {
+		fmt.println("tick")
+
+		for op in queue.pop_front_safe(&g_queue) {
+			defer nbio.reattach(op) // Releases ownership of the operation.
+
+			fmt.printfln("%v completed", op.type)
+
+			#partial switch op.type {
+			case .Recv:
+				if op.recv.err != nil {
+					fmt.eprintfln("recv: %v", op.recv.err)
+					nbio.recv(socket, {buf[:]}, queue_callback)
+					continue
+				}
+
+				fmt.printfln("received %M", op.recv.received)
+				nbio.send(socket, {buf[:op.recv.received]}, queue_callback, op.recv.source)
+
+			case .Send:
+				if op.send.err != nil {
+					fmt.eprintfln("send: %v", op.send.err)
+				}
+				fmt.printfln("sent %M", op.send.sent)
+				nbio.recv(socket, {buf[:]}, queue_callback)
+
+			case:
+				fmt.eprintfln("unimplemented: %v", op.type)
+			}
+		}
+
+		if err := nbio.tick(); err != nil {
+			fmt.eprintfln("tick: %v", err)
+		}
+	}
+}
+
+g_queue: queue.Queue(^nbio.Operation)
+
+queue_callback :: proc(op: ^nbio.Operation) {
+	nbio.detach(op) // Takes ownership of the operation.
+	queue.push_back(&g_queue, op)
+}

nbio/game-loop/raylib_logo.png

@@ -0,0 +1,66 @@
+/*
+Example that shows the `sendfile` operation.
+
+Dials a TCP server (localhost:1234) (use `nc -l 1234` to start a netcat server)
+and sends the contents of this file to it.
+
+Try it with a big file and you will see progress updates as the file is sent.
+*/
+package main
+
+import "core:fmt"
+import "core:nbio"
+import "core:os"
+import "core:terminal/ansi"
+
+main :: proc() {
+	if len(os.args) <= 1 {
+		fmt.eprintfln("usage: %s <path>", os.args[0])
+		return
+	}
+
+	err := nbio.acquire_thread_event_loop()
+	assert(err == nil)
+	defer nbio.release_thread_event_loop()
+
+	nbio.dial({nbio.IP4_Loopback, 1234}, on_dial)
+
+	err = nbio.run()
+	assert(err == nil)
+
+	on_dial :: proc(op: ^nbio.Operation) {
+		fmt.assertf(op.dial.err == nil, "dial: %v", op.dial.err)
+
+		file, err := nbio.open_sync(os.args[1])
+		assert(err == nil)
+
+		// Call can also take an offset, a length, a timeout.
+		// By default it sends the entire file, without a timeout.
+		sendfile_op := nbio.sendfile(op.dial.socket, file, on_sent, progress_updates=true)
+
+		fmt.print(ansi.CSI + ansi.DECTCEM_HIDE)
+		render_progress(sendfile_op, clear=false)
+	}
+
+	on_sent :: proc(op: ^nbio.Operation) {
+		fmt.assertf(op.sendfile.err == nil, "sendfile: %v", op.sendfile.err)
+
+		render_progress(op, clear=true)
+		if op.sendfile.sent < op.sendfile.nbytes {
+			// Progress update, not done.
+			return
+		}
+
+		fmt.print(ansi.CSI + ansi.DECTCEM_SHOW)
+		nbio.close(op.sendfile.file)
+	}
+}
+
+render_progress :: proc(op: ^nbio.Operation, clear: bool) {
+	if clear {
+		fmt.print(ansi.CSI + "1" + ansi.CUU)
+	}
+
+	fmt.print(ansi.CSI + "2" + ansi.EL + ansi.CSI + "0" + ansi.CHA)
+	fmt.printfln("%M/%M", op.sendfile.sent, op.sendfile.nbytes)
+}

nbio/no-callbacks/main.odin

@@ -0,0 +1,69 @@
+/*
+This example shows a simple TCP server that echos back anything it receives.
+
+Better error handling and closing/freeing connections are left for the reader.
+
+You can run this with the netcat utility as the client like so: `nc 127.0.0.1 1234`.
+*/
+package main
+
+import "core:container/xar"
+import "core:fmt"
+import "core:nbio"
+
+Server :: struct {
+	socket:      nbio.TCP_Socket,
+	// Xar is used in favor of `[dynamic]Connection` so pointers are stable.
+	connections: xar.Array(Connection, 4),
+}
+
+Connection :: struct {
+	server: ^Server,
+	sock:   nbio.TCP_Socket,
+	buf:    [50]byte,
+}
+
+main :: proc() {
+	err := nbio.acquire_thread_event_loop()
+	fmt.assertf(err == nil, "Could not initialize nbio: %v", err)
+	defer nbio.release_thread_event_loop()
+
+	server: Server
+
+	socket, listen_err := nbio.listen_tcp({nbio.IP4_Loopback, 1234})
+	fmt.assertf(listen_err == nil, "Error listening on localhost:1234: %v", err)
+	server.socket = socket
+
+	nbio.accept_poly(socket, &server, on_accept)
+
+	rerr := nbio.run()
+	fmt.assertf(rerr == nil, "Server stopped with error: %v", rerr)
+}
+
+on_accept :: proc(op: ^nbio.Operation, server: ^Server) {
+	fmt.assertf(op.accept.err == nil, "Error accepting a connection: %v", op.accept.err)
+
+	// Register a new accept for the next client.
+	nbio.accept_poly(server.socket, server, on_accept)
+
+	connection, alloc_err := xar.push_back_elem_and_get_ptr(&server.connections, Connection{
+		server = server,
+		sock   = op.accept.client,
+	})
+	assert(alloc_err == nil)
+
+	nbio.recv_poly(op.accept.client, {connection.buf[:]}, connection, on_recv)
+}
+
+on_recv :: proc(op: ^nbio.Operation, connection: ^Connection) {
+	fmt.assertf(op.recv.err == nil, "Error receiving from client: %v", op.recv.err)
+
+	nbio.send_poly(connection.sock, {connection.buf[:op.recv.received]}, connection, on_sent)
+}
+
+on_sent :: proc(op: ^nbio.Operation, connection: ^Connection) {
+	fmt.assertf(op.send.err == nil, "Error sending to client: %v", op.send.err)
+
+	// Accept the next message, to then ultimately echo back again.
+	nbio.recv_poly(connection.sock, {connection.buf[:]}, connection, on_recv)
+}