package main

import "core:fmt"
import "core:math/rand"

main :: proc() {
	// Allocate memory for a few 8-bit integers.
	data := make([dynamic]u8, 10)
	defer delete(data)
	for &val in data {
		val = u8(rand.int_range(0, 3))
	}

	// De-duplicate using a map.
	// Map to a struct{} (empty structure with size of 0 bytes) is a set.
	unique_data: map[u8]struct{}
	defer delete(unique_data)
	for val in data {
		unique_data[val] = {}
	}

	fmt.printfln("Original: %v\nUnique: %v", data, unique_data)

	// The result could look something like this:
	// Original: [0, 0, 2, 0, 0, 1, 0, 2, 0, 0]
	// Unique: map[1, 2, 0]
}

package main

import "core:fmt"
import "core:reflect"

My_Struct :: struct {
	name:     string,
	counter:  u8,
	position: [3]f32,
	buffer:   [64]byte,
}

main :: proc() {
	print_struct_field_sizes(My_Struct)
	// Output:
	//      name:  16 bytes
	//   counter:   1 bytes
	//              3 bytes padding
	//  position:  12 bytes
	//    buffer:  64 bytes
}

print_struct_field_sizes :: proc($T: typeid) {
	offset := 0

	for field in reflect.struct_fields_zipped(T) {
		// If offsets don't match, there's padding.
		if offset != int(field.offset) {
			fmt.printfln("% 20i bytes padding", int(field.offset) - offset)
			offset = int(field.offset)
		}

		fmt.printfln("% 12s: % 6i bytes", field.name, field.type.size)

		offset += field.type.size
	}
}

package main

import "core:fmt"

// App event
Event :: union {
	Key_Input,
	Draw,
	// ...
	Exit,
}

Key_Input :: struct { key: int }
Draw      :: struct {}
Exit      :: struct {}

main :: proc() {
	events := []Event{
		Key_Input{ key = 10 },
		Draw{},
		Key_Input{ key = 5 },
		Exit{},
		Draw{},
	}

	event_loop: for event in poll_events(&events) {
		switch v in event {
		case Exit:
			break event_loop

		case Key_Input:
			fmt.println("key pressed", v.key)

		case Draw:
			fmt.println("Drawing...")
		}
	}
}

// Custom iterator procedure over an event slice.
// The iterator stops when ok=false.
poll_events :: proc(it: ^[]Event) -> (result: Event, ok: bool) {
	if len(it) == 0 do return nil, false

	result = it[0]
	it^ = it[1:]
	return result, true
}

package main

import "core:encoding/json"
import "core:fmt"

Entity_Handle :: u32

Entity_Base :: struct {
	position: [3]f32,
	velocity: [3]f32,
}

Player_Entity :: struct {
	// 'using' brings the fields into the struct namespace.
	using base: Entity_Base,
	health:     i32,
	// Like an array of booleans, but each flag takes up 1 bit.
	flags:      bit_set[Player_Flag],
	// Enumerated array, can be indexed only with 'Hand'.
	hand_items: [Hand]Item,
}

Player_Flag :: enum u8 { Grounded, Stunned, Hungry }
Hand        :: enum { Left, Right }
Item        :: enum { None = 0, Pickaxe, Shovel, Sword, Apple }

main :: proc() {
	player := Player_Entity{
		position = {1, 10, 0},
		health   = 10,
		flags    = {.Grounded},
		hand_items = {
			.Left  = .None,
			.Right = .Pickaxe,
		},
	}

	serialized := json.marshal(player, {pretty = true}, context.temp_allocator) or_else nil
	fmt.println(string(serialized))
}

package main

import "base:intrinsics"
import "core:fmt"

f32x8 :: #simd[8]f32

dot_product_simd :: proc(a, b: [3]f32x8) -> f32x8 {
	ab := a * b
	return ab.x + ab.y + ab.z
}

sum_vector_lengths_simd :: proc(vectors: #soa[][3]f32) -> f32 {
	lane_sums: f32x8

	// This loop is processing 8 values at a time!
	for i := 0; i + 7 < len(vectors); i += 8 {
		vec := [3]f32x8{ // Raw aligned memory loads
			(cast(^f32x8)&vectors.x[i])^,
			(cast(^f32x8)&vectors.y[i])^,
			(cast(^f32x8)&vectors.z[i])^,
		}
		length_squared := dot_product_simd(vec, vec)
		lane_sums += intrinsics.sqrt(length_squared)
	}

	return intrinsics.simd_reduce_add_pairs(lane_sums)
}

main :: proc() {
	// X, Y and Z components live in separate contiguous blocks of memory.
	data := make_soa_aligned(#soa[][3]f32, 64, 32)
	data[0] = {1, 0, 0}
	data[1] = {2, 2, 2}
	// fill data...
	length_sum := sum_vector_lengths_simd(data)
	fmt.println(length_sum)
}

package main

import "core:fmt"
import "core:mem"

main :: proc() {
	tracking_state: mem.Tracking_Allocator
	mem.tracking_allocator_init(&tracking_state, context.allocator)
	context.allocator = mem.tracking_allocator(&tracking_state)

	// The context is passed implicitly everywhere,
	// so all allocations now go through the tracking allocator.

	// Do allocations and intentionally forget to free...
	// In practice, use context.temp_allocator for short-lived data.
	_ = make([]f32, 1000)
	for i in 1..=5 {
		_ = make([]byte, i * 10)
	}

	// Print all leaks.
	for addr, entry in tracking_state.allocation_map {
		fmt.printfln("%s:%i leaked %i bytes",
			entry.location.file_path, entry.location.line, entry.size)
	}

	// Output looks something like:
	// test.odin:18 leaked 40 bytes
	// test.odin:18 leaked 20 bytes
	// test.odin:18 leaked 10 bytes
	// test.odin:18 leaked 30 bytes
	// test.odin:18 leaked 50 bytes
	// test.odin:15 leaked 4000 bytes
}

package main

import rl "vendor:raylib"

main :: proc() {
	rl.InitWindow(800, 600, "Hello Odin + Raylib!")
	defer rl.CloseWindow()

	for !rl.WindowShouldClose() {
		rl.BeginDrawing()
		defer rl.EndDrawing()

		rl.ClearBackground(rl.DARKBLUE)
		rl.DrawText("Hellope!", 20, 20, 40, rl.WHITE)
	}
}

package raylib_orrery

import "core:math"
import rl "vendor:raylib"

Body :: struct {
	distance: f32, // In AU
	radius:   f32, // In km
	period:   f32, // In Earth years
	color:    rl.Color, // Average-ish color
}

@(rodata)
bodies := [?]Body{
	{0.39,  2_440,  0.241, { 26,  26,  26, 255}}, // Mercury
	{0.72,  6_052,  0.615, {240, 235, 220, 255}}, // Venus
	{1.00,  6_371,  1.000, { 40, 106, 105, 255}}, // Earth
	{1.52,  3_390,  1.881, {153,  80,  50, 255}}, // Mars
	{5.20, 69_911, 11.862, {190, 188, 172, 255}}, // Jupiter
	{9.54, 58_232, 29.457, {198, 183, 153, 255}}, // Saturn
}

main :: proc() {
	window := [2]i32{1024, 1024}
	rl.InitWindow(window.x, window.y, "Odin Orrery")
	defer rl.CloseWindow()

	rl.SetTargetFPS(60)
	for !rl.WindowShouldClose() {
		rl.BeginDrawing()
		defer rl.EndDrawing()

		rl.ClearBackground(rl.BLACK)
		rl.DrawCircle(window.x / 2, window.y / 2, 20, {250, 245, 240, 255}) // Draw "sun"

		for body, i in bodies {
			scale := f32(100) if i < 4 else 50
			distance := body.distance * scale
			period := f32(rl.GetTime()) / body.period
			pos := rl.Vector2{
				f32(window.x) / 2 + math.cos(period) * distance,
				f32(window.y) / 2 + math.sin(period) * distance,
			}

			// Draw orbit + planet
			rl.DrawCircleLinesV({f32(window.x) / 2, f32(window.y) / 2}, distance, rl.GRAY)
			rl.DrawCircleV(pos, body.radius / bodies[4].radius * scale, body.color)
		}
	}
}