per matrix buttons

libraries/snths_ui/ui.odin

@@ -273,12 +273,12 @@ _resolve_element_outer_size_axis :: proc(size: Size, axis: Axis) -> f32 {
 		if element := _element_container_previous(); element != nil {
 			container_inner := get_element_inner_area(_container_current()^)
 			last_element_outer := get_element_outer_area(element^)
-			remaining_container_size: f32
+			element_br := rect_get_br(last_element_outer)
+			container_tl := rect_get_tl(container_inner)
 			switch axis {
-			case .X: remaining_container_size = container_inner.width - rect_get_tr(last_element_outer).x
-			case .Y: remaining_container_size = container_inner.height - rect_get_bl(last_element_outer).y
+			case .X: return (container_inner.width - (element_br.x - container_tl.x)) * f32(value)
+			case .Y: return (container_inner.height - (element_br.y - container_tl.y)) * f32(value)
 			}
-			return remaining_container_size * f32(value)
 		} else {
 			inner := get_element_inner_area(_container_current()^)
 			container_size := inner.width if axis == .X else inner.height

program.odin

@@ -2,6 +2,7 @@ package main
 
 import rl "libraries/raylib"
 import ui "libraries/snths_ui"
+import "core:mem"
 import "core:fmt"
 import "core:math/linalg"
 import "core:math/ease"
@@ -12,6 +13,9 @@ import "core:os"
 RAYGUI_ICON_PLAY :: "#131#"
 RAYGUI_ICON_PAUSE :: "#132#"
 RAYGUI_ICON_RESET :: "#211#"
+RAYGUI_ICON_TRASH :: "#143#"
+RAYGUI_ICON_DOWN :: "#120#"
+RAYGUI_ICON_UP :: "#121#"
 
 TRANSFORMATION_RECTANGLE_COLOR_ORIGIN :: rl.RED
 TRANSFORMATION_RECTANGLE_COLOR_MIDDLE :: rl.MAGENTA
@@ -52,6 +56,7 @@ UiElementData_Dropdown :: struct {
 }
 
 UiButtonType :: enum {
+	Nothing,
 	AddIdentity,
 	AddTranslation,
 	AddScale,
@@ -65,6 +70,9 @@ UiButtonType :: enum {
 	ResumeTransformation,
 	ResetTransformation,
 	SaveProjectConfirm,
+	MatrixDelete,
+	MatrixMoveUp,
+	MatrixMoveDown,
 }
 
 UiButtonRecalculateFinishGroup :: bit_set[UiButtonType]{
@@ -76,6 +84,7 @@ UiButtonRecalculateFinishGroup :: bit_set[UiButtonType]{
 
 UiElementData_Button :: struct {
 	type: UiButtonType,
+	target_matrix: int,
 	options: cstring,
 }
 
@@ -236,8 +245,13 @@ program_save_project :: proc(program: ^Program, path: string) -> os.Error {
 
 program_load_project :: proc(program: ^Program, path: string) -> ProjectReadError {
 	project: ProjectData
-	project_read(&project, path) or_return
-	fmt.println(project.version)
+	project_read(&project, path, context.temp_allocator) or_return
+	program.matrix_count = int(project.matrix_count)
+	mem.copy(raw_data(program.matrix_float_pool), raw_data(project.matrices), len(project.matrices) * size_of(f32) * 9)
+	for val, i in program.matrix_float_pool[:program.matrix_count * 9] {
+		fmt.bprint(program.matrix_value_string_pool[i][:], val)
+	}
+	animation_update_last(&program.animation, program_get_master_matrix())
 	return nil
 }
 
@@ -280,7 +294,7 @@ program_init :: proc(allocator := context.allocator) {
 	program.animation_ease = .Quadratic_Out
 
 	if err := program_load_project(&program, DEFAULT_PROJECT_LOAD_LOCATION); err != nil {
-		fmt.println(err)
+		fmt.println("ERROR:", err)
 	}
 }
 
@@ -570,10 +584,10 @@ program_build_workspace_ui :: proc(ctx: ^ui.Context) -> (elements: []ui.Element,
 	matrix_container = ui.container_begin({ui.Size_Percentage(0.2), ui.Size_PercentageRemainder(1.0)}, side_bar_container_config, side_bar_container_data)
 	for i in 0..<program.matrix_count {
 		container_config := ui.ElementConfiguration{margin = 8.0, label = fmt.ctprintf("Matrix %d", i)}
-		container_dimensions := ui.Dimensions {ui.Size_Percentage(1.0), ui.Size_Pixels(112.0)}
+		container_dimensions := ui.Dimensions {ui.Size_Percentage(1.0), ui.Size_Pixels(140.0)}
 		mat := program.matrix_float_pool[i * 9 : i * 9 + 9]
 		value_strings := program.matrix_value_string_pool[i * 9 : i * 9 + 9]
-		ui_mat3(mat, value_strings, container_dimensions, container_config)
+		ui_mat3(i, mat, value_strings, container_dimensions, container_config)
 	}
 	ui.container_end()
 	elements = ui.end()
@@ -659,6 +673,7 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 				}
 				data := cast(^UiElementData_Button)element.data
 				switch data.type {
+				case .Nothing:
 				case .AddIdentity:    program_add_identity_matrix()
 				case .AddTranslation: program_show_dialog(&program, .CreateTranslationMatrix)
 				case .AddScale:       program_show_dialog(&program, .CreateScaleMatrix)
@@ -696,6 +711,20 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 					} else {
 						program.state = .Normal
 					}
+				case .MatrixDelete:
+					if data.target_matrix + 1 < program.matrix_count {
+						floats := program.matrix_float_pool
+						inputs := program.matrix_value_string_pool
+						amount := program.matrix_count - data.target_matrix
+						matrix_values_size := size_of(f32) * 9
+						matrix_inputs_size := size_of(InputFloatField) * 9
+						mem.copy(&floats[data.target_matrix * 9], &floats[data.target_matrix * 9 + 9], matrix_values_size * amount)
+						mem.copy(&inputs[data.target_matrix * 9][0], &inputs[data.target_matrix * 9 + 9][0], matrix_inputs_size * amount)
+					}
+					program.matrix_count = max(program.matrix_count - 1, 0)
+					animation_update_last(&program.animation, program_get_master_matrix())
+				case .MatrixMoveUp:
+				case .MatrixMoveDown:
 				}
 				if data.type in UiButtonRecalculateFinishGroup {
 					animation_update_last(&program.animation, program_get_master_matrix())
@@ -778,12 +807,37 @@ ui_measure_text :: proc(str: cstring, font_data: rawptr) -> ui.v2 {
 	return rl.MeasureTextEx(style.font, str, style.size, style.spacing)
 }
 
-ui_mat3 :: proc(mat: []f32, value_strings: []InputFloatField, dimensions: ui.Dimensions, config: ui.ElementConfiguration, allocator := context.temp_allocator) {
-	container_data := new(UiElementData_Container, allocator)
-	container_data^ = {type = .Matrix, thickness = 2.0}
-	ui.container_begin(dimensions, config, container_data)
-		matrix_input_config := ui.ElementConfiguration {margin = 4.0}
+ui_mat3 :: proc(idx: int, mat: []f32, value_strings: []InputFloatField, dimensions: ui.Dimensions, config: ui.ElementConfiguration, allocator := context.temp_allocator) {
+	ui.container_begin(dimensions, config)
+	defer ui.container_end()
+
+	button_config := ui.ElementConfiguration {margin = 4.0}
+	button_data: ^UiElementData_Button
+
+	button_config.label = RAYGUI_ICON_TRASH
+	button_data = new(UiElementData_Button, allocator)
+	button_data^ = {target_matrix = idx, type = .MatrixDelete}
+	ui.element(.Button, ui.dimensions_pixels(32.0), button_config, button_data)
+
+	button_config.label = RAYGUI_ICON_UP
+	button_data = new(UiElementData_Button, allocator)
+	button_data^ = {target_matrix = idx}
+	ui.same_line()
+	ui.element(.Button, ui.dimensions_pixels(32.0), button_config, button_data)
+
+	button_config.label = RAYGUI_ICON_DOWN
+	button_data = new(UiElementData_Button, allocator)
+	button_data^ = {target_matrix = idx}
+	ui.same_line()
+	ui.element(.Button, ui.dimensions_pixels(32.0), button_config, button_data)
+
+	matrix_container_dimensions := ui.Dimensions {ui.Size_Percentage(1.0), ui.Size_PercentageRemainder(1.0)}
+	matrix_container_config := ui.ElementConfiguration {margin = 4.0}
+	matrix_container_data := new(UiElementData_Container, allocator)
+	matrix_container_data^ = {type = .Matrix, thickness = 2.0}
+	ui.container_begin(matrix_container_dimensions, matrix_container_config, matrix_container_data)
 		matrix_input_dimensions := ui.Dimensions {ui.Size_Percentage(1.0 / 3.0), ui.Size_Percentage(1.0 / 3.0)}
+		matrix_input_config := ui.ElementConfiguration {margin = 4.0}
 		// column first matrices
 		#unroll for j in 0..<3 {
 			#unroll for i in 0..<3 {

project.odin

@@ -48,7 +48,7 @@ ProjectReadErrorType :: enum {
 	VersionNeedsUpgrade,
 }
 
-project_read :: proc(project: ^ProjectData, path: string) -> ProjectReadError {
+project_read :: proc(project: ^ProjectData, path: string, allocator: mem.Allocator) -> ProjectReadError {
 	f := os.open(path, {.Read}) or_return
 	defer os.close(f)
 	r := io.to_reader(os.to_stream(f))
@@ -57,14 +57,15 @@ project_read :: proc(project: ^ProjectData, path: string) -> ProjectReadError {
 	if num, err := io.read_full(r, header_buffer[:]); err != nil {
 		return ProjectReadErrorType.FailedReadingHeader
 	}
-	if mem.compare(transmute([]byte)header[:], header_buffer[:]) != 0 {
+	if mem.compare(transmute([]byte)header, header_buffer[:]) != 0 {
 		return ProjectReadErrorType.BadHeader
 	}
-	version: u32
-	_ = io.read_ptr(r, &version, size_of(u32)) or_return
-	if version != PROJECT_DATA_VERSION {
+	_ = io.read_ptr(r, &project.version, size_of(project.matrix_count)) or_return
+	if project.version != PROJECT_DATA_VERSION {
 		return ProjectReadErrorType.VersionNeedsUpgrade
 	}
-	project.version = version
+	_ = io.read_ptr(r, &project.matrix_count, size_of(project.matrix_count)) or_return
+	project.matrices = make([]f32, size_of(f32) * int(project.matrix_count) * 9)
+	_ = io.read_ptr(r, raw_data(project.matrices), size_of(f32) * len(project.matrices)) or_return
 	return nil
 }