spark

main.odin (7569B)

---

 package main
 
 import "base:runtime"
 import "core:fmt"
 
 import sapp "sokol/sokol/app"
 import sg "sokol/sokol/gfx"
 import sgl "sokol/sokol/gl"
 import sglue "sokol/sokol/glue"
 
 import mu "vendor:microui"
 
 state := struct {
 	pip:             sgl.Pipeline,
 	mu_ctx:          mu.Context,
 	log_buf:         [1 << 16]byte,
 	log_buf_len:     int,
 	log_buf_updated: bool,
 	bg:              mu.Color,
 	atlas_img:       sg.Image,
 	atlas_smp:       sg.Sampler,
 } {
 	bg = {90, 95, 100, 255},
 }
 
 r_init :: proc() {
 	pixels := make([][4]u8, mu.DEFAULT_ATLAS_WIDTH * mu.DEFAULT_ATLAS_HEIGHT)
 	for alpha, i in mu.default_atlas_alpha {
 		pixels[i].rgb = 0xff
 		pixels[i].a = alpha
 	}
 
 	state.atlas_img = sg.make_image(
 		sg.Image_Desc {
 			width = mu.DEFAULT_ATLAS_WIDTH,
 			height = mu.DEFAULT_ATLAS_HEIGHT,
 			data = {
 				subimage = {
 					0 = {
 						0 = {
 							ptr = raw_data(pixels),
 							size = mu.DEFAULT_ATLAS_WIDTH * mu.DEFAULT_ATLAS_HEIGHT * 4,
 						},
 					},
 				},
 			},
 		},
 	)
 
 	state.atlas_smp = sg.make_sampler(
 		sg.Sampler_Desc{min_filter = .NEAREST, mag_filter = .NEAREST},
 	)
 
 
 	state.pip = sgl.make_pipeline(
 		sg.Pipeline_Desc {
 			colors = {
 				0 = {
 					blend = {
 						enabled = true,
 						src_factor_rgb = .SRC_ALPHA,
 						dst_factor_rgb = .ONE_MINUS_SRC_ALPHA,
 					},
 				},
 			},
 		},
 	)
 
 	free(raw_data(pixels))
 }
 
 init :: proc "c" () {
 	context = runtime.default_context()
 
 	sg.setup(sg.Desc{environment = sglue.environment()})
 	sgl.setup({})
 
 	r_init()
 
 	ctx := &state.mu_ctx
 	mu.init(ctx)
 
 	ctx.text_width = mu.default_atlas_text_width
 	ctx.text_height = mu.default_atlas_text_height
 }
 
 r_begin :: proc(disp_width, disp_height: i32) {
 	sgl.defaults()
 	sgl.push_pipeline()
 	sgl.load_pipeline(state.pip)
 	sgl.enable_texture()
 	sgl.texture(state.atlas_img, state.atlas_smp)
 	sgl.matrix_mode_projection()
 	sgl.push_matrix()
 	sgl.ortho(0.0, f32(disp_width), f32(disp_height), 0.0, -1.0, +1.0)
 	sgl.begin_quads()
 }
 
 r_push_quad :: proc(dst: mu.Rect, src: mu.Rect, color: mu.Color) {
 	u0 := f32(src.x) / f32(mu.DEFAULT_ATLAS_WIDTH)
 	v0 := f32(src.y) / f32(mu.DEFAULT_ATLAS_HEIGHT)
 	u1 := f32(src.x + src.w) / f32(mu.DEFAULT_ATLAS_WIDTH)
 	v1 := f32(src.y + src.h) / f32(mu.DEFAULT_ATLAS_HEIGHT)
 
 	x0 := f32(dst.x)
 	y0 := f32(dst.y)
 	x1 := f32(dst.x + dst.w)
 	y1 := f32(dst.y + dst.h)
 
 	sgl.c4b(color.r, color.g, color.b, color.a)
 	sgl.v2f_t2f(x0, y0, u0, v0)
 	sgl.v2f_t2f(x1, y0, u1, v0)
 	sgl.v2f_t2f(x1, y1, u1, v1)
 	sgl.v2f_t2f(x0, y1, u0, v1)
 }
 
 r_draw_text :: proc(text: string, pos: mu.Vec2, color: mu.Color) {
 	dst := mu.Rect{pos.x, pos.y, 0, 0}
 	for ch in text {
 		src := mu.default_atlas[mu.DEFAULT_ATLAS_FONT + int(ch)]
 		dst.w = src.w
 		dst.h = src.h
 		r_push_quad(dst, src, color)
 		dst.x += dst.w
 	}
 }
 
 r_draw_rect :: proc(rect: mu.Rect, color: mu.Color) {
 	r_push_quad(rect, mu.default_atlas[mu.DEFAULT_ATLAS_WHITE], color)
 }
 
 r_draw_icon :: proc(id: mu.Icon, rect: mu.Rect, color: mu.Color) {
 	src := mu.default_atlas[id]
 	x := rect.x + (rect.w - src.w) / 2
 	y := rect.y + (rect.h - src.h) / 2
 	r_push_quad(mu.Rect{x, y, src.w, src.h}, src, color)
 }
 
 r_set_clip_rect :: proc(rect: mu.Rect) {
 	sgl.end()
 	sgl.scissor_rect(rect.x, rect.y, rect.w, rect.h, true)
 	sgl.begin_quads()
 }
 
 r_end :: proc() {
 	sgl.end()
 	sgl.pop_matrix()
 	sgl.pop_pipeline()
 }
 
 r_draw :: proc() {
 	sgl.draw()
 }
 
 frame :: proc "c" () {
 	context = runtime.default_context()
 
 	mu_ctx := &state.mu_ctx
 	mu.begin(mu_ctx)
 	all_windows(mu_ctx)
 	mu.end(mu_ctx)
 
 	r_begin(sapp.width(), sapp.height())
 	command_backing: ^mu.Command
 	for variant in mu.next_command_iterator(mu_ctx, &command_backing) {
 		switch cmd in variant {
 		case ^mu.Command_Text:
 			r_draw_text(cmd.str, cmd.pos, cmd.color)
 		case ^mu.Command_Rect:
 			r_draw_rect(cmd.rect, cmd.color)
 		case ^mu.Command_Icon:
 			r_draw_icon(cmd.id, cmd.rect, cmd.color)
 		case ^mu.Command_Clip:
 			r_set_clip_rect(cmd.rect)
 		case ^mu.Command_Jump:
 			unreachable()
 		}
 	}
 	r_end()
 
 	sg.begin_pass(
 		sg.Pass {
 			action = {
 				colors = {
 					0 = {
 						load_action = .CLEAR,
 						clear_value = {
 							f32(state.bg.r) / 255.0,
 							f32(state.bg.g) / 255.0,
 							f32(state.bg.b) / 255.0,
 							1.0,
 						},
 					},
 				},
 			},
 			swapchain = sglue.swapchain(),
 		},
 	)
 
 	r_draw()
 	sg.end_pass()
 	sg.commit()
 }
 
 key_map := map[sapp.Keycode]mu.Key {
 	.LEFT_SHIFT    = .SHIFT,
 	.RIGHT_SHIFT   = .SHIFT,
 	.LEFT_CONTROL  = .CTRL,
 	.RIGHT_CONTROL = .CTRL,
 	.LEFT_ALT      = .ALT,
 	.RIGHT_ALT     = .ALT,
 	.ENTER         = .RETURN,
 	.KP_ENTER      = .RETURN,
 	.BACKSPACE     = .BACKSPACE,
 }
 event :: proc "c" (ev: ^sapp.Event) {
 
 	context = runtime.default_context()
 	mu_ctx := &state.mu_ctx
 	#partial switch ev.type {
 	case .MOUSE_DOWN:
 		mu.input_mouse_down(mu_ctx, i32(ev.mouse_x), i32(ev.mouse_y), mu.Mouse(ev.mouse_button))
 	case .MOUSE_UP:
 		mu.input_mouse_up(mu_ctx, i32(ev.mouse_x), i32(ev.mouse_y), mu.Mouse(ev.mouse_button))
 	case .MOUSE_MOVE:
 		mu.input_mouse_move(mu_ctx, i32(ev.mouse_x), i32(ev.mouse_y))
 	case .MOUSE_SCROLL:
 		mu.input_scroll(mu_ctx, 0, i32(ev.scroll_y))
 	case .KEY_DOWN:
 		if ev.key_code in key_map {
 			mu.input_key_down(mu_ctx, key_map[ev.key_code])
 		}
 	case .KEY_UP:
 		if ev.key_code in key_map {
 			mu.input_key_up(mu_ctx, key_map[ev.key_code])
 		}
 	case .CHAR:
 		mu.input_text(mu_ctx, fmt.tprint(rune(ev.char_code)))
 	}
 }
 
 cleanup :: proc "c" () {
 	sgl.shutdown()
 	sg.shutdown()
 }
 
 main :: proc() {
 	sapp.run(
 		{
 			init_cb = init,
 			frame_cb = frame,
 			cleanup_cb = cleanup,
 			event_cb = event,
 			width = 300,
 			height = 300,
 			sample_count = 4,
 			window_title = "sokol microui",
 			icon = {sokol_default = true},
 		},
 	)
 }
 
 u8_slider :: proc(ctx: ^mu.Context, val: ^u8, lo, hi: u8) -> (res: mu.Result_Set) {
 	mu.push_id(ctx, uintptr(val))
 
 	@(static) tmp: mu.Real
 	tmp = mu.Real(val^)
 	res = mu.slider(ctx, &tmp, mu.Real(lo), mu.Real(hi), 0, "%.0f", {.ALIGN_CENTER})
 	val^ = u8(tmp)
 	mu.pop_id(ctx)
 	return
 }
 
 write_log :: proc(str: string) {
 	state.log_buf_len += copy(state.log_buf[state.log_buf_len:], str)
 	state.log_buf_len += copy(state.log_buf[state.log_buf_len:], "\n")
 	state.log_buf_updated = true
 }
 
 read_log :: proc() -> string {
 	return string(state.log_buf[:state.log_buf_len])
 }
 reset_log :: proc() {
 	state.log_buf_updated = true
 	state.log_buf_len = 0
 }
 
 
 all_windows :: proc(ctx: ^mu.Context) {
 	window_width := sapp.width()
 	window_height := sapp.height()
 
 	if mu.window(
 		ctx,
 		"Spark",
 		{x = 0, y = 0, w = window_width, h = window_height},
 		opt = {.NO_TITLE, .NO_INTERACT, .NO_FRAME, .NO_CLOSE, .NO_RESIZE, .NO_SCROLL},
 	) {
 		// To achieve a single window layout we need to syncrhonize the microui window rectangle
 		// with the dimensions of the sokol window. 
 		cnt := mu.get_current_container(ctx)
 		cnt.rect.w = window_width
 		cnt.rect.h = window_height
 
 		mu.layout_row(ctx, {-1})
 
 		@(static) prog: mu.Real = 0.0
 		prog = min(1.0, prog + 0.001)
 		progress(ctx, &prog)
 	}
 }
 
 
 progress :: proc(
 	ctx: ^mu.Context,
 	value: ^mu.Real,
 	opt: mu.Options = {.ALIGN_CENTER},
 ) -> (
 	res: mu.Result_Set,
 ) {
 	id := mu.get_id(ctx, uintptr(value))
 	base := mu.layout_next(ctx)
 	mu.draw_control_frame(ctx, id, base, .BASE, opt)
 
 	prog := mu.Rect{base.x, base.y, base.w - i32((1.0 - value^) * f32(base.w)), base.h}
 	mu.draw_rect(ctx, prog, {50, 50, 100, 255})
 
 	return
 }
 
 draw_rrect :: proc(ctx: ^mu.Context, rect: mu.Rect, radius: i32, color: mu.Color) {
 	rect := rect
 	rect = mu.intersect_rects(rect, mu.get_clip_rect(ctx))
 	if rect.w > 0 && rect.h > 0 {
 		cmd := mu.push_command(ctx, mu.Command_Rect)
 		cmd.rect = rect
 		cmd.color = color
 	}
 }