diff --git a/animation.odin b/animation.odin index fa9d302..9837af9 100644 --- a/animation.odin +++ b/animation.odin @@ -1,141 +1,149 @@ package main import rl "libraries/raylib" +import "core:math/ease" import "core:math/linalg" +import "core:slice" import "core:fmt" +ANIMATION_COLOR_ORIGIN :: rl.RED +ANIMATION_COLOR_END :: rl.BLUE + +RectangleCorners :: struct {tl, tr, br, bl: v2} + +rectangle_corners_from_rect :: proc "contextless" (rect: rect2) -> RectangleCorners { + return { + tl = {rect.x, rect.y}, + tr = {rect.x + rect.width, rect.y}, + bl = {rect.x + rect.width, rect.y + rect.height}, + br = {rect.x, rect.y + rect.height} + } +} + +rectangle_corners_transform_mat3 :: proc "contextless" (corners: RectangleCorners, transform: mat3) -> RectangleCorners { + return { + (v3{**corners.tl, 1.0} * transform).xy, + (v3{**corners.tr, 1.0} * transform).xy, + (v3{**corners.br, 1.0} * transform).xy, + (v3{**corners.bl, 1.0} * transform).xy, + } +} + +rectangle_corners_transform_mat2 :: proc "contextless" (corners: RectangleCorners, transform: mat2) -> RectangleCorners { + return {corners.tl * transform, corners.tr * transform, corners.br * transform, corners.bl * transform} +} + +draw_animation_rectangle_corners :: proc(corners: RectangleCorners, color: rl.Color) { + rect := rect_from_corners(corners.tl, corners.tr, corners.br, corners.bl) + rl.DrawRectangleRec(rect, {**color.rgb, color.a << 1}) + rl.DrawRectangleLinesEx(rect, 2, color) +} + /* Maybe it is possible to have everything 3d be mathed the same way as in 2d. But I'm not sure if that's actually how it works. */ -AnimationInterface :: struct { - data: rawptr, - reset: proc(animation: ^AnimationInterface), - update_last: proc(animation: ^AnimationInterface, master_matrix: mat3), - update: proc(animation: ^AnimationInterface, animation_progress: f32), - next_matrix: proc(animation: ^AnimationInterface, next_matrix: mat3), - draw_idle: proc(animation: AnimationInterface), - draw_active: proc(animation: AnimationInterface), +AnimationShape_Rectangle :: struct { + origin: RectangleCorners, } -animation_update_last :: proc(animation: ^AnimationInterface, master_matrix: mat3) { - animation.update_last(animation, master_matrix) +AnimationShapes :: struct { + rectangle: AnimationShape_Rectangle, } -animation_update :: proc(animation: ^AnimationInterface, animation_progress: f32) { - animation.update(animation, animation_progress) +Animation :: struct { + matrices: []f32, + matrix_index: int, + matrix_count: int, + matrix_type: AnimationMatrixType, + shapes: AnimationShapes, + ease: ease.Ease, + state: AnimationState, + type: AnimationType, } -animation_next_matrix :: proc(animation: ^AnimationInterface, next_matrix: mat3) { - animation.next_matrix(animation, next_matrix) +AnimationMatrixType :: enum { + Mat2, + Mat3, + Mat4, } -animation_draw_idle :: proc(animation: AnimationInterface) { - animation.draw_idle(animation) -} - -animation_draw_active :: proc(animation: AnimationInterface) { - animation.draw_active(animation) +@private @rodata animation_matrix_type_size := [AnimationMatrixType]int { + .Mat2 = size_of(mat2), + .Mat3 = size_of(mat3), + .Mat4 = size_of(mat4), } AnimationType :: enum { Rectangle, } -RectangleCorners :: struct { - tl, tr, br, bl: v2, +AnimationState :: enum { + Ready, + Playing, + Paused, + Finished, } -rectangle_corners_transform :: proc(m: mat3, corners: RectangleCorners) -> RectangleCorners { - return { - tl = (v3{**corners.tl, 1.0} * m).xy, - tr = (v3{**corners.tr, 1.0} * m).xy, - br = (v3{**corners.br, 1.0} * m).xy, - bl = (v3{**corners.bl, 1.0} * m).xy, +animation_init :: proc(animation: ^Animation, matrices: []f32) { + animation^ = { + ease = .Cubic_Out, + type = .Rectangle, + matrices = matrices, + shapes = { + rectangle = { + origin = rectangle_corners_from_rect(rect2{-16, -16, 32, 32}) + } + }, } } -AnimationData_Rectangle :: struct { - origin, middle, previous, next, last: RectangleCorners, +animation_play :: proc(animation: ^Animation) { + } -draw_transformation_rectangle :: proc(rectangle: RectangleCorners, color: rl.Color) { - rect := rect_from_corners(rectangle.tl, rectangle.tr, rectangle.br, rectangle.bl) - rl.DrawRectangleRec(rect, rl.Color{**color.rgb, color.a / 2}) - rl.DrawRectangleLinesEx(rect, 1.0, color) +animation_reset :: proc(animation: ^Animation) { + } -draw_transformation_rectangle_with_handles :: proc(rectangle: RectangleCorners, color: rl.Color) { - rect := rect_from_corners(rectangle.tl, rectangle.tr, rectangle.br, rectangle.bl) - rl.DrawRectangleRec(rect, rl.Color{**color.rgb, color.a / 2}) - rl.DrawRectangleLinesEx(rect, 1.0, color) - rl.DrawCircleV(rectangle.tl, 4.0, color) - rl.DrawCircleV(rectangle.tr, 4.0, color) - rl.DrawCircleV(rectangle.br, 4.0, color) - rl.DrawCircleV(rectangle.bl, 4.0, color) +animation_pause :: proc(animation: ^Animation) { + } -_animation_rectangle_draw_idle :: proc(animation: AnimationInterface) { - data := cast(^AnimationData_Rectangle)animation.data - draw_transformation_rectangle(data.last, TRANSFORMATION_RECTANGLE_COLOR_LAST) - draw_transformation_rectangle_with_handles(data.origin, TRANSFORMATION_RECTANGLE_COLOR_ORIGIN) +animation_update :: proc(animation: ^Animation, matrices: []mat3) { + } -_animation_rectangle_draw_active :: proc(animation: AnimationInterface) { - data := cast(^AnimationData_Rectangle)animation.data - draw_transformation_rectangle(data.last, TRANSFORMATION_RECTANGLE_COLOR_LAST) - draw_transformation_rectangle(data.next, TRANSFORMATION_RECTANGLE_COLOR_NEXT) - draw_transformation_rectangle(data.middle, TRANSFORMATION_RECTANGLE_COLOR_MIDDLE) - draw_transformation_rectangle(data.origin, TRANSFORMATION_RECTANGLE_COLOR_ORIGIN) -} +animation_draw :: proc(animation: Animation) { + switch animation.type { + case .Rectangle: + shape := animation.shapes.rectangle + transformation := linalg.identity(mat3) + previous, next := shape.origin, shape.origin + color_origin := cast([4]f32)(ANIMATION_COLOR_ORIGIN) + color_end := cast([4]f32)(ANIMATION_COLOR_END) + draw_animation_rectangle_corners(next, ANIMATION_COLOR_ORIGIN) -_animation_rectangle_reset :: proc(animation: ^AnimationInterface) { - data := cast(^AnimationData_Rectangle)animation.data - data.middle = data.origin - data.next = data.origin - data.previous = data.origin -} - -_animation_rectangle_next_matrix :: proc(animation: ^AnimationInterface, next_matrix: mat3) { - data := cast(^AnimationData_Rectangle)animation.data - data.previous = data.next - data.middle = data.next - data.next = rectangle_corners_transform(next_matrix, data.next) -} - -_animation_rectangle_update_last :: proc(animation: ^AnimationInterface, master_matrix: mat3) { - data := cast(^AnimationData_Rectangle)animation.data - data.last = { - tl = (master_matrix * v3{**data.origin.tl, 1.0}).xy, - tr = (master_matrix * v3{**data.origin.tr, 1.0}).xy, - br = (master_matrix * v3{**data.origin.br, 1.0}).xy, - bl = (master_matrix * v3{**data.origin.bl, 1.0}).xy, + matrices := slice.reinterpret([]mat3, animation.matrices) + for m, i in matrices { + progress := f32(i + 1) / f32(len(animation.matrices)) + transformation *= m + previous = next + next := rectangle_corners_transform_mat3(previous, transformation) + draw_animation_rectangle_corners(next, cast(rl.Color)linalg.lerp(color_origin, color_end, progress)) + } } } -_animation_rectangle_update :: proc(animation: ^AnimationInterface, animation_progress: f32) { - data := cast(^AnimationData_Rectangle)animation.data - data.middle = { - tl = linalg.lerp(data.previous.tl, data.next.tl, animation_progress), - tr = linalg.lerp(data.previous.tr, data.next.tr, animation_progress), - br = linalg.lerp(data.previous.br, data.next.br, animation_progress), - bl = linalg.lerp(data.previous.bl, data.next.bl, animation_progress), - } +animation_set_playback_speed :: proc(animation: ^Animation) { + } -animation_reset :: proc(animation: ^AnimationInterface) { - animation.reset(animation) +animation_set_type :: proc(animation: ^Animation, type: AnimationType) { + animation.type = type } -animation_create_rectangle :: proc(rectangle: ^AnimationData_Rectangle) -> AnimationInterface { - return { - data = rectangle, - reset = _animation_rectangle_reset, - update_last = _animation_rectangle_update_last, - update = _animation_rectangle_update, - next_matrix = _animation_rectangle_next_matrix, - draw_idle = _animation_rectangle_draw_idle, - draw_active = _animation_rectangle_draw_active, - } +animation_is_finished :: proc() -> bool { + return false } diff --git a/program.odin b/program.odin index 0b52ab2..ab31ed9 100644 --- a/program.odin +++ b/program.odin @@ -197,25 +197,7 @@ Program :: struct { message_type: ProgramMessageType, dialog_type: ProgramDialogType, dialog_data: ProgramData_DialogState, - animation_data: AnimationData, - animation_state: AnimationState, - animations: [AnimationType]AnimationInterface, - animation: AnimationInterface, - animation_matrix_index: int, - animation_matrix_progress: f32, - animation_speed: f32, - animation_ease: ease.Ease, -} - -AnimationData :: struct { - rectangle: AnimationData_Rectangle, -} - -AnimationState :: enum { - Ready, - Playing, - Paused, - Finished, + animation: Animation, } float_slice_get_mat3 :: proc(floats: []f32, index: int) -> ^mat3 { @@ -254,7 +236,7 @@ program_load_project :: proc(program: ^Program, path: string) -> ProjectReadErro 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()) + animation_update(&program.animation, (cast([^]mat3)(raw_data(program.matrix_float_pool)))[:program.matrix_count]) return nil } @@ -286,16 +268,7 @@ program_init :: proc(allocator := context.allocator) { ui.init(&program.ui_overlay_context, 200, ui_measure_text, &program.font_style, allocator) program.ui_overlay_element_focus = ui.element_id_invalid() - animation_rectangle := RectangleCorners {{320.0, 320.0}, {352.0, 320.0}, {352.0, 352.0}, {320.0, 352.0}} - program.animation_data = { - rectangle = {animation_rectangle,animation_rectangle,animation_rectangle,animation_rectangle,animation_rectangle}, - } - program.animations = { - .Rectangle = animation_create_rectangle(&program.animation_data.rectangle) - } - program.animation = program.animations[.Rectangle] - program.animation_speed = 0.02 - program.animation_ease = .Quadratic_Out + animation_init(&program.animation, program.matrix_float_pool) if err := program_load_project(&program, DEFAULT_PROJECT_LOAD_LOCATION); err != nil { fmt.println("ERROR:", err) @@ -312,12 +285,11 @@ program_get_master_matrix :: proc() -> mat3 { } program_set_transformation_state :: proc(state: AnimationState) { - if program.animation_state == state do return - previous_state := program.animation_state - program.animation_state = state - switch program.animation_state { + if program.animation.state == state do return + previous_state := program.animation.state + program.animation.state = state + switch program.animation.state { case .Ready: - program.animation_matrix_index = -1 animation_reset(&program.animation) case .Playing: @@ -404,7 +376,7 @@ program_update :: proc() { } case .LoadProject: } - animation_update_last(&program.animation, program_get_master_matrix()) + animation_update(&program.animation, (cast([^]mat3)(raw_data(program.matrix_float_pool)))[:program.matrix_count]) program.state = .Normal } } @@ -414,27 +386,7 @@ program_update :: proc() { grid_text_clip := rect_from_area(v2{matrix_container_br.x, top_bar_container_br.y}, v2{WINDOW_WIDTH, WINDOW_HEIGHT}) draw_grid(program.grid, rect_grow(grid_text_clip, -4.0), rect_grow(grid_text_clip, -32.0)) - if program.animation_state == .Playing { - program.animation_matrix_progress += program.animation_speed * delta_time_fraction() - if program.animation_matrix_progress >= 1.0 { - if program.animation_matrix_index + 1 < program.matrix_count { - program.animation_matrix_index += 1 - animation_next_matrix(&program.animation, float_slice_get_mat3(program.matrix_float_pool, program.animation_matrix_index)^) - program.animation_matrix_progress = fract(program.animation_matrix_progress) - } else { - program.animation_matrix_progress = 1.0; - program.animation_state = .Finished - } - } - animation_update(&program.animation, ease.ease(program.animation_ease, program.animation_matrix_progress)) - } - - switch program.animation_state { - case .Ready: - animation_draw_idle(program.animation) - case .Playing, .Paused, .Finished: - animation_draw_active(program.animation) - } + animation_draw(program.animation) ui_element_focus := program.state == .Normal ? program.ui_element_focus : ui.element_id_invalid() program.ui_element_focus = program_render_ui_and_handle_focus(&program.ui_context, ui_element_focus, program.font_style, ui_elements) @@ -576,7 +528,7 @@ program_build_workspace_ui :: proc(ctx: ^ui.Context) -> play_button_label: cstring button_data = new(UiElementData_Button, context.temp_allocator) - switch program.animation_state { + switch program.animation.state { case .Ready, .Finished: button_config.label = RAYGUI_ICON_PLAY button_data^ = {type = .StartTransformation} @@ -723,14 +675,13 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u program.state = .Normal case .StartTransformation: if program.matrix_count > 0 { - program.animation_state = .Playing + program.animation.state = .Playing animation_reset(&program.animation) - animation_next_matrix(&program.animation, (cast(^mat3)raw_data(program.matrix_float_pool))^) } case .PauseTransformation: - program.animation_state = .Paused + program.animation.state = .Paused case .ResumeTransformation: - program.animation_state = .Playing + program.animation.state = .Playing case .ResetTransformation: animation_reset(&program.animation) case .SaveProjectConfirm: @@ -760,7 +711,7 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u matrix_move_to(program.matrix_float_pool, program.matrix_value_string_pool, data.target_matrix, data.target_matrix + 1) } if data.type in UiButtonRecalculateFinishGroup { - animation_update_last(&program.animation, program_get_master_matrix()) + animation_update(&program.animation, (cast([^]mat3)(raw_data(program.matrix_float_pool)))[:program.matrix_count]) } } case .Slider: @@ -773,7 +724,7 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u focus_element_id = element.id } if value_previous != data.value^ && .UpdateMatrix in data.tag { - animation_update_last(&program.animation, program_get_master_matrix()) + animation_update(&program.animation, (cast([^]mat3)(raw_data(program.matrix_float_pool)))[:program.matrix_count]) } case .InputText: data := cast(^UiElementData_TextInput)element.data diff --git a/utils.odin b/utils.odin index 5ca9c4f..83546dd 100644 --- a/utils.odin +++ b/utils.odin @@ -76,6 +76,10 @@ fract :: proc(val: f32) -> f32 { return val - math.trunc(val) } +color_to_fcolor :: proc(color: rl.Color) -> [4]f32 { + return cast([4]f32)(color) / 255.0 +} + /// ### TYPES ### /// v1 :: [1]f32 v2 :: [2]f32