From 50c2ef929054e2ec27b4b3cf96b96e1a90967bab Mon Sep 17 00:00:00 2001 From: Peter Slattery Date: Sat, 18 Jul 2020 12:00:14 -0700 Subject: [PATCH] Cleaning up, converting over to using new gs files. --- build/build_app_msvc_win32_debug.bat | 2 +- src/app/animation/foldhaus_animation.h | 10 +- src/app/assembly_parser.cpp | 140 +- .../{ => deprecated}/foldhaus_default_nodes.h | 8 +- .../foldhaus_panel_node_graph.h | 42 +- .../foldhaus_search_lister.cpp | 12 +- .../{ => deprecated}/foldhaus_search_lister.h | 6 +- .../{ => deprecated}/foldhaus_text_entry.cpp | 46 +- .../{ => deprecated}/foldhaus_text_entry.h | 6 +- .../node/foldhaus_node_interface.cpp | 90 +- src/app/foldhaus_app.cpp | 88 +- src/app/foldhaus_app.h | 69 +- src/app/foldhaus_assembly.cpp | 36 +- src/app/foldhaus_assembly.h | 8 +- src/app/foldhaus_command_dispatch.h | 12 +- src/app/foldhaus_debug.h | 24 +- src/app/foldhaus_interface.cpp | 119 +- src/app/foldhaus_log.h | 8 +- src/app/foldhaus_node.cpp | 34 +- src/app/foldhaus_node.h | 4 +- src/app/foldhaus_operation_mode.h | 73 +- src/app/foldhaus_panel.h | 68 +- src/app/foldhaus_platform.h | 142 +- src/app/foldhaus_renderer.cpp | 8 +- src/app/foldhaus_renderer.h | 168 +- ...oldhaus_util_radialumia_file_converter.cpp | 120 +- src/app/generated/foldhaus_panels_generated.h | 31 +- .../generated/gs_meta_generated_typeinfo.h | 168 +- src/app/gs_osx_window.mm | 2 +- src/app/handmade_math.h | 3239 ++++++++++++++++ src/app/interface.h | 141 +- .../foldhaus_panel_animation_timeline.h | 147 +- src/app/panels/foldhaus_panel_dmx_view.h | 8 +- src/app/panels/foldhaus_panel_file_view.h | 14 +- src/app/panels/foldhaus_panel_hierarchy.h | 31 +- src/app/panels/foldhaus_panel_profiler.h | 69 +- .../panels/foldhaus_panel_sculpture_view.h | 115 +- src/app/sacn/sacn.h | 10 +- src/app/test_patterns.h | 28 +- src/app/win32_foldhaus.cpp | 623 ++- src/app/win32_foldhaus_dll.h | 20 +- src/app/win32_foldhaus_fileio.h | 133 - src/app/win32_foldhaus_memory.h | 22 +- src/gs_libs/gs_language.h | 39 +- src/gs_libs/gs_memory_arena.h | 4 +- src/gs_libs/gs_string.h | 2123 +---------- src/gs_libs/gs_string_builder.h | 6 +- src/gs_libs/gs_types.cpp | 3383 +++++++++++++++++ src/gs_libs/gs_types.h | 1053 +++++ src/gs_libs/gs_vector_matrix.h | 35 +- src/gs_libs/gs_win32.cpp | 169 +- src/meta/foldhaus_meta.cpp | 6 +- src/meta/gs_meta_error.h | 25 +- src/meta/gs_meta_lexer.h | 84 +- src/meta/gs_meta_type_table.h | 30 +- 55 files changed, 9546 insertions(+), 3555 deletions(-) rename src/app/{ => deprecated}/foldhaus_default_nodes.h (90%) rename src/app/{panels => deprecated}/foldhaus_panel_node_graph.h (92%) rename src/app/{ => deprecated}/foldhaus_search_lister.cpp (68%) rename src/app/{ => deprecated}/foldhaus_search_lister.h (81%) rename src/app/{ => deprecated}/foldhaus_text_entry.cpp (88%) rename src/app/{ => deprecated}/foldhaus_text_entry.h (81%) rename src/app/{ => deprecated}/node/foldhaus_node_interface.cpp (90%) create mode 100644 src/app/handmade_math.h create mode 100644 src/gs_libs/gs_types.cpp create mode 100644 src/gs_libs/gs_types.h diff --git a/build/build_app_msvc_win32_debug.bat b/build/build_app_msvc_win32_debug.bat index e38e31d..6151e16 100644 --- a/build/build_app_msvc_win32_debug.bat +++ b/build/build_app_msvc_win32_debug.bat @@ -16,7 +16,7 @@ pushd %BuildPath% del *.pdb > NUL 2> NUL REM Run the Preprocessor -%MetaProgramPath%\foldhaus_meta.exe %SourceCodePath%\foldhaus_app.cpp +REM %MetaProgramPath%\foldhaus_meta.exe %SourceCodePath%\foldhaus_app.cpp echo WAITING FOR PDB TO WRITE > lock.tmp diff --git a/src/app/animation/foldhaus_animation.h b/src/app/animation/foldhaus_animation.h index 0c22ee7..613a940 100644 --- a/src/app/animation/foldhaus_animation.h +++ b/src/app/animation/foldhaus_animation.h @@ -31,7 +31,7 @@ enum blend_mode struct anim_layer { - string Name; + gs_string Name; blend_mode BlendMode; }; @@ -39,7 +39,7 @@ struct anim_layer #define ANIMATION_SYSTEM_BLOCKS_MAX 128 struct animation_system { - memory_arena* Storage; + gs_memory_arena* Storage; gs_list Blocks; anim_layer* Layers; @@ -75,7 +75,7 @@ FrameIsInRange(s32 Frame, frame_range Range) internal u32 GetFrameCount(frame_range Range) { - u32 Result = (u32)GSMax(0, Range.Max - Range.Min); + u32 Result = (u32)Max(0, Range.Max - Range.Min); return Result; } @@ -133,7 +133,7 @@ RemoveAnimationBlock(gs_list_handle AnimationBlockHandle, animation_system* Anim // Layers internal u32 -AddLayer (string Name, animation_system* AnimationSystem, blend_mode BlendMode = BlendMode_Overwrite) +AddLayer (gs_string Name, animation_system* AnimationSystem, blend_mode BlendMode = BlendMode_Overwrite) { // NOTE(Peter): If this assert fires its time to make the layer buffer system // resizable. @@ -144,7 +144,7 @@ AddLayer (string Name, animation_system* AnimationSystem, blend_mode BlendMode = anim_layer* NewLayer = AnimationSystem->Layers + Result; *NewLayer = {0}; NewLayer->Name = MakeString(PushArray(AnimationSystem->Storage, char, Name.Length), Name.Length); - CopyStringTo(Name, &NewLayer->Name); + PrintF(&NewLayer->Name, "%S", Name); NewLayer->BlendMode = BlendMode; return Result; } diff --git a/src/app/assembly_parser.cpp b/src/app/assembly_parser.cpp index 4b06fc7..8e229e0 100644 --- a/src/app/assembly_parser.cpp +++ b/src/app/assembly_parser.cpp @@ -28,7 +28,7 @@ enum assembly_field AssemblyField_Count, }; -global_variable char* AssemblyFieldIdentifiers[] = { +global char* AssemblyFieldIdentifiers[] = { "assembly_name", // AssemblyField_AssemblyName "assembly_scale", // AssemblyField_AssemblyScale "led_strip_count", // AssemblyField_LedStripCount @@ -52,20 +52,32 @@ global_variable char* AssemblyFieldIdentifiers[] = { "value", // AssemblyField_Value }; +struct assembly_error_list +{ + gs_string String; + assembly_error_list* Next; +}; + struct assembly_tokenizer { - string Text; + gs_string Text; char* At; + gs_const_string FileName; u32 LineNumber; bool ParsingIsValid; + + gs_memory_arena* ErrorArena; + assembly_error_list* ErrorsRoot; + assembly_error_list* ErrorsTail; }; internal bool AtValidPosition(assembly_tokenizer* T) { - bool Result = ((T->At - T->Text.Memory) < T->Text.Length); + u64 Offset = T->At - T->Text.Str; + bool Result = (Offset < T->Text.Length); return Result; } @@ -88,6 +100,16 @@ EatWhitespace(assembly_tokenizer* T) } } +internal void +EatToNewLine(assembly_tokenizer* T) +{ + while(AtValidPosition(T) && !IsNewline(T->At[0])) + { + AdvanceChar(T); + } + EatWhitespace(T); +} + internal bool AdvanceIfTokenEquals(assembly_tokenizer* T, char* Value) { @@ -118,6 +140,22 @@ AdvanceIfTokenEquals(assembly_tokenizer* T, char* Value) return Result; } +internal void +TokenizerPushError(assembly_tokenizer* T, char* ErrorString) +{ + // NOTE(Peter): We can make this more expressive if we need to + assembly_error_list* Error = PushStruct(T->ErrorArena, assembly_error_list); + Error->String = PushString(T->ErrorArena, 512); + PrintF(&Error->String, "%S(%d): %s", T->FileName, T->LineNumber, ErrorString); + SLLPushOrInit(T->ErrorsRoot, T->ErrorsTail, Error); + T->ParsingIsValid = false; + + // NOTE(Peter): I'm not sure this is the best idea, but at least this way, + // if there's multiple errors, you'll get a number of them, rather than + // a bunch of erroneous errors happening on the same line + EatToNewLine(T); +} + internal bool ReadFieldIdentifier(assembly_field Field, assembly_tokenizer* T) { @@ -130,12 +168,12 @@ ReadFieldIdentifier(assembly_field Field, assembly_tokenizer* T) } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Field identifier is missing a colon"); } } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Field Identifier Invalid"); } return Result; } @@ -150,15 +188,15 @@ ReadFieldEnd(assembly_tokenizer* T) } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Missing a semicolon"); } return Result; } -internal string +internal gs_string ReadString(assembly_tokenizer* T) { - string Result = {}; + gs_string Result = {}; if (AdvanceIfTokenEquals(T, "\"")) { char* StringStart = T->At; @@ -166,32 +204,36 @@ ReadString(assembly_tokenizer* T) { T->At++; } - Result.Memory = StringStart; - Result.Max = T->At - StringStart; - Result.Length = Result.Max; + Result.Str = StringStart; + Result.Size = T->At - StringStart; + Result.Length = Result.Size; if (AdvanceIfTokenEquals(T, "\"")) { // Success } else { - // TODO(Peter): Error + TokenizerPushError(T, "String not closed with a \""); } } + else + { + TokenizerPushError(T, "Expecting a string, but none was found"); + } return Result; } -internal string +internal gs_string GetNumberString(assembly_tokenizer* T) { - string Result = {}; - Result.Memory = T->At; + gs_string Result = {}; + Result.Str = T->At; while(AtValidPosition(T) && IsNumericExtended(T->At[0])) { AdvanceChar(T); } - Result.Length = T->At - Result.Memory; - Result.Max = Result.Length; + Result.Length = T->At - Result.Str; + Result.Size = Result.Length; return Result; } @@ -199,9 +241,8 @@ internal r32 ReadFloat(assembly_tokenizer* T) { r32 Result = 0; - string NumberString = GetNumberString(T); - parse_result ParsedFloat = ParseFloat(StringExpand(NumberString)); - Result = ParsedFloat.FloatValue; + gs_string NumberString = GetNumberString(T); + Result = (r32)ParseFloat(NumberString.ConstString); return Result; } @@ -209,28 +250,23 @@ internal s32 ReadInt(assembly_tokenizer* T) { s32 Result = 0; - string NumberString = GetNumberString(T); - parse_result ParsedInt = ParseSignedInt(StringExpand(NumberString)); - Result = ParsedInt.SignedIntValue; + gs_string NumberString = GetNumberString(T); + Result = (r32)ParseInt(NumberString.ConstString); return Result; } -internal string -ReadStringField(assembly_field Field, assembly_tokenizer* T, memory_arena* Arena) +internal gs_string +ReadStringField(assembly_field Field, assembly_tokenizer* T, gs_memory_arena* Arena) { - string Result = {}; + gs_string Result = {}; if (ReadFieldIdentifier(Field, T)) { - string ExistingString = ReadString(T); + gs_string ExistingString = ReadString(T); if (ReadFieldEnd(T)) { // Success Result = PushString(Arena, ExistingString.Length); - CopyStringTo(ExistingString, &Result); - } - else - { - T->ParsingIsValid = false; + PrintF(&Result, "%S", ExistingString); } } return Result; @@ -290,22 +326,22 @@ ReadV3Field(assembly_field Field, assembly_tokenizer* T) } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Vector 3 doesn't end with a ')'"); } } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Vector 3: unable to read a field"); } } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Vector 3: unable to read a field"); } } else { - T->ParsingIsValid = false; + TokenizerPushError(T, "Vector 3: unable to read a field"); } } return Result; @@ -333,14 +369,18 @@ ReadStructClosing(assembly_tokenizer* T) } internal bool -ParseAssemblyFile(assembly* Assembly, string FileText, memory_arena* Transient) +ParseAssemblyFile(assembly* Assembly, gs_const_string FileName, gs_string FileText, gs_memory_arena* Transient) { Assembly->LedCountTotal = 0; + r32 Value = ParseFloat(ConstString("-2.355")); + assembly_tokenizer Tokenizer = {}; Tokenizer.Text = FileText; - Tokenizer.At = Tokenizer.Text.Memory; + Tokenizer.At = Tokenizer.Text.Str; Tokenizer.ParsingIsValid = true; + Tokenizer.ErrorArena = Transient; + Tokenizer.FileName = FileName; Assembly->Name = ReadStringField(AssemblyField_AssemblyName, &Tokenizer, &Assembly->Arena); Assembly->Scale = ReadFloatField(AssemblyField_AssemblyScale, &Tokenizer); @@ -358,7 +398,7 @@ ParseAssemblyFile(assembly* Assembly, string FileText, memory_arena* Transient) StripAt->StartChannel = ReadIntField(AssemblyField_StartChannel, &Tokenizer); // TODO(Peter): Need to store this - string PointPlacementType = ReadStringField(AssemblyField_PointPlacementType, &Tokenizer, &Assembly->Arena); + gs_string PointPlacementType = ReadStringField(AssemblyField_PointPlacementType, &Tokenizer, &Assembly->Arena); // TODO(Peter): Switch on value of PointPlacementType if (ReadStructOpening(AssemblyField_InterpolatePoints, &Tokenizer)) { @@ -367,6 +407,10 @@ ParseAssemblyFile(assembly* Assembly, string FileText, memory_arena* Transient) if (!ReadStructClosing(&Tokenizer)) { Tokenizer.ParsingIsValid = false; + // TODO(Peter): @ErrorHandling + // Have this function prepend the filename and line number. + // Create an error display popup window, or an error log window that takes over a panel automatically + // TokenizerPushError(&Tokenizer, "Unable to read } } @@ -380,31 +424,31 @@ ParseAssemblyFile(assembly* Assembly, string FileText, memory_arena* Transient) v2_tag* TagAt = StripAt->Tags + Tag; if (ReadStructOpening(AssemblyField_Tag, &Tokenizer)) { - // TODO(Peter): Need to store the string somewhere we can look it up for display in the interface + // TODO(Peter): Need to store the gs_string somewhere we can look it up for display in the interface // right now they are stored in temp memory and won't persist - string TagName = ReadStringField(AssemblyField_Name, &Tokenizer, Transient); - string TagValue = ReadStringField(AssemblyField_Value, &Tokenizer, Transient); - TagAt->NameHash = HashString(TagName); - TagAt->ValueHash = HashString(TagValue); + gs_string TagName = ReadStringField(AssemblyField_Name, &Tokenizer, Transient); + gs_string TagValue = ReadStringField(AssemblyField_Value, &Tokenizer, Transient); + TagAt->NameHash = HashDJB2ToU32(StringExpand(TagName)); + TagAt->ValueHash = HashDJB2ToU32(StringExpand(TagValue)); if (!ReadStructClosing(&Tokenizer)) { - Tokenizer.ParsingIsValid = false; + TokenizerPushError(&Tokenizer, "Struct doesn't close where expected"); } } else { - Tokenizer.ParsingIsValid = false; + TokenizerPushError(&Tokenizer, "Expected a struct opening, but none was found"); } } if (!ReadStructClosing(&Tokenizer)) { - Tokenizer.ParsingIsValid = false; + TokenizerPushError(&Tokenizer, "Struct doesn't close where expected"); } } else { - Tokenizer.ParsingIsValid = false; + TokenizerPushError(&Tokenizer, "Expected a struct opening, but none was found"); } } diff --git a/src/app/foldhaus_default_nodes.h b/src/app/deprecated/foldhaus_default_nodes.h similarity index 90% rename from src/app/foldhaus_default_nodes.h rename to src/app/deprecated/foldhaus_default_nodes.h index 7083ce2..3fddaa0 100644 --- a/src/app/foldhaus_default_nodes.h +++ b/src/app/deprecated/foldhaus_default_nodes.h @@ -100,10 +100,10 @@ NODE_PROC(SinWave, sin_wave_data) Data->Accumulator -= Data->Period; } - r32 ActualMin = GSMin(Data->Min, Data->Max); - r32 ActualMax = GSMax(Data->Min, Data->Max); - r32 SinResult = GSSin((Data->Accumulator / Data->Period) * PI * 2); - Data->Result = GSRemap(SinResult, -1.f, 1.f, ActualMin, ActualMax); + r32 ActualMin = Min(Data->Min, Data->Max); + r32 ActualMax = Max(Data->Min, Data->Max); + r32 SinResult = SinR32((Data->Accumulator / Data->Period) * PiR32 * 2); + Data->Result = RemapR32(SinResult, -1.f, 1.f, ActualMin, ActualMax); } else { diff --git a/src/app/panels/foldhaus_panel_node_graph.h b/src/app/deprecated/foldhaus_panel_node_graph.h similarity index 92% rename from src/app/panels/foldhaus_panel_node_graph.h rename to src/app/deprecated/foldhaus_panel_node_graph.h index 80aa175..6830d2f 100644 --- a/src/app/panels/foldhaus_panel_node_graph.h +++ b/src/app/deprecated/foldhaus_panel_node_graph.h @@ -15,7 +15,7 @@ struct visual_port { gs_list_handle SparseNodeHandle; u32 PortIndex; - rect PortBounds; + rect2 PortBounds; }; struct visual_connection @@ -57,7 +57,7 @@ struct node_graph_state { v2 ViewOffset; - memory_arena LayoutMemory; + gs_memory_arena LayoutMemory; node_layout Layout; b32 LayoutIsDirty; @@ -128,7 +128,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndConnectNodesOperation) for (u32 p = 0; p < GraphState->Layout.VisualPortsCount; p++) { visual_port VisualPort = GraphState->Layout.VisualPorts[p]; - rect ViewAdjustedBounds = gs_RectOffsetByVector(VisualPort.PortBounds, GraphState->ViewOffset); + rect2 ViewAdjustedBounds = gs_RectOffsetByVector(VisualPort.PortBounds, GraphState->ViewOffset); if (gs_PointIsInRect(Mouse.Pos, ViewAdjustedBounds)) { visual_port UpstreamPort = (OpState->IsInput & IsInputMember) ? VisualPort : OpState->VisualPort; @@ -196,7 +196,7 @@ NodeGraph_Cleanup(panel* Panel, app_state* State) } internal void -DrawGrid (v2 Offset, v2 GridSquareDim, rect PanelBounds, render_command_buffer* RenderBuffer) +DrawGrid (v2 Offset, v2 GridSquareDim, rect2 PanelBounds, render_command_buffer* RenderBuffer) { r32 LineValue = .16f; v4 LineColor = v4{LineValue, LineValue, LineValue, 1.f}; @@ -232,9 +232,9 @@ DrawGrid (v2 Offset, v2 GridSquareDim, rect PanelBounds, render_command_buffer* } internal void -DrawNodePorts(gsm_struct_type_info NodeDataTypeInfo, b32 InputMask, v2 Position, r32 LineHeight, string_alignment TextAlign, v2 TextOffset, interface_config Interface, render_command_buffer* RenderBuffer, mouse_state Mouse) +DrawNodePorts(gsm_struct_type_info NodeDataTypeInfo, b32 InputMask, v2 Position, r32 LineHeight, gs_string_alignment TextAlign, v2 TextOffset, interface_config Interface, render_command_buffer* RenderBuffer, mouse_state Mouse) { - rect PortBounds = rect{v2{0, 0}, v2{6, 6}}; + rect2 PortBounds = rect2{v2{0, 0}, v2{6, 6}}; v2 LinePosition = Position; for (u32 i = 0; i < NodeDataTypeInfo.MembersCount; i++) @@ -244,7 +244,7 @@ DrawNodePorts(gsm_struct_type_info NodeDataTypeInfo, b32 InputMask, v2 Position, { // TODO(Peter): Can we make this rely on the same data that we use to // render the actual connection points? - string MemberName = MakeString(Member.Identifier, Member.IdentifierLength); + gs_string MemberName = MakeString(Member.Identifier, Member.IdentifierLength); DrawString(RenderBuffer, MemberName, Interface.Font, LinePosition + TextOffset, WhiteV4, TextAlign); LinePosition.y -= LineHeight; } @@ -252,7 +252,7 @@ DrawNodePorts(gsm_struct_type_info NodeDataTypeInfo, b32 InputMask, v2 Position, } internal void -DrawNode (v2 Position, node_specification_ NodeSpecification, gs_list_handle NodeHandle, r32 NodeWidth, r32 LineHeight, interface_config Interface, render_command_buffer* RenderBuffer, mouse_state Mouse, memory_arena* Scratch) +DrawNode (v2 Position, node_specification_ NodeSpecification, gs_list_handle NodeHandle, r32 NodeWidth, r32 LineHeight, interface_config Interface, render_command_buffer* RenderBuffer, mouse_state Mouse, gs_memory_arena* Scratch) { gsm_struct_type_info NodeDataTypeInfo = StructTypes[NodeSpecification.DataType]; @@ -264,13 +264,13 @@ DrawNode (v2 Position, node_specification_ NodeSpecification, gs_list_handle Nod if (MemberIsInput(Member)) { InputMembers++; } if (MemberIsOutput(Member)) { OutputMembers++; } } - u32 LineCount = 1 + GSMax(InputMembers, OutputMembers); + u32 LineCount = 1 + Max(InputMembers, OutputMembers); v2 NodeDim = v2{ NodeWidth, (LineHeight * LineCount) + Interface.Margin.y, }; - rect NodeBounds = rect{ + rect2 NodeBounds = rect2{ v2{ Position.x, Position.y - NodeDim.y }, v2{ Position.x + NodeDim.x, Position.y }, }; @@ -282,7 +282,7 @@ DrawNode (v2 Position, node_specification_ NodeSpecification, gs_list_handle Nod PushRenderQuad2D(RenderBuffer, LinePosition, LinePosition + v2{NodeWidth, LineHeight}, v4{1.f, .24f, .39f, 1.f}); - string NodePrintName = MakeString(PushArray(Scratch, char, 256), 0, 256); + gs_string NodePrintName = MakeString(PushArray(Scratch, char, 256), 0, 256); PrintF(&NodePrintName, "%S [%d]", NodeSpecification.Identifier, NodeHandle.Index); DrawString(RenderBuffer, NodePrintName, Interface.Font, LinePosition + TextOffset, WhiteV4); LinePosition.y -= LineHeight; @@ -293,7 +293,7 @@ DrawNode (v2 Position, node_specification_ NodeSpecification, gs_list_handle Nod for (u32 i = 0; i < NodeDataTypeInfo.MembersCount; i++) { gsm_struct_member_type_info Member = NodeDataTypeInfo.Members[i]; - string MemberName = MakeString(Member.Identifier, Member.IdentifierLength); + gs_string MemberName = MakeString(Member.Identifier, Member.IdentifierLength); // TODO(Peter): Can we make this rely on the same data that we use to // render the actual connection points? @@ -329,7 +329,7 @@ GetVisualPortIndexForNode(gs_list_handle SparseNodeHandle, u32 PortIndex, node_l } internal node_layout -ArrangeNodes(pattern_node_workspace Workspace, r32 NodeWidth, r32 LayerDistance, r32 LineHeight, memory_arena* Storage, app_state* State) +ArrangeNodes(pattern_node_workspace Workspace, r32 NodeWidth, r32 LayerDistance, r32 LineHeight, gs_memory_arena* Storage, app_state* State) { node_layout Result = {}; @@ -373,7 +373,7 @@ ArrangeNodes(pattern_node_workspace Workspace, r32 NodeWidth, r32 LayerDistance, { gsm_struct_member_type_info Member = NodeDataTypeInfo.Members[p]; - rect PortBounds = {0}; + rect2 PortBounds = {0}; v2 PortDim = v2{8, 8}; PortBounds.Min = VisualNode->Position + v2{0, PortDim.y / 2}; if (MemberIsInput(Member)) @@ -420,16 +420,16 @@ ArrangeNodes(pattern_node_workspace Workspace, r32 NodeWidth, r32 LayerDistance, GSMetaTag(panel_render); GSMetaTag(panel_type_node_graph); internal void -NodeGraph_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +NodeGraph_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { node_graph_state* GraphState = (node_graph_state*)Panel.PanelStateMemory; b32 MouseHandled = false; - rect NodeSelectionWindowBounds = rect{ + rect2 NodeSelectionWindowBounds = rect2{ PanelBounds.Min, v2{PanelBounds.Min.x + 300, PanelBounds.Max.y}, }; - rect GraphBounds = rect{ + rect2 GraphBounds = rect2{ v2{NodeSelectionWindowBounds.Max.x, PanelBounds.Min.y}, PanelBounds.Max, }; @@ -513,18 +513,18 @@ NodeGraph_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuf List.TextColor = WhiteV4; List.ListBounds = NodeSelectionWindowBounds; List.ListElementDimensions = v2{ - gs_Width(NodeSelectionWindowBounds), + Rect2Width(NodeSelectionWindowBounds), ui_GetTextLineHeight(State->Interface) }; List.ElementLabelIndent = v2{10, 4}; - string TitleString = MakeStringLiteral("Available Nodes"); - DrawListElement(TitleString, &List, Context.Mouse, RenderBuffer, State->Interface.Style); + gs_string Titlegs_string = MakeStringLiteral("Available Nodes"); + DrawListElement(Titlegs_string, &List, Context.Mouse, RenderBuffer, State->Interface.Style); for (u32 i = 0; i < NodeType_Count; i++) { node_specification_ Spec = NodeSpecifications[i]; - rect ElementBounds = DrawListElement(Spec.Identifier, &List, Context.Mouse, RenderBuffer, State->Interface.Style); + rect2 ElementBounds = DrawListElement(Spec.Identifier, &List, Context.Mouse, RenderBuffer, State->Interface.Style); if (MouseButtonTransitionedDown(Context.Mouse.LeftButtonState) && gs_PointIsInRect(Context.Mouse.DownPos, ElementBounds)) diff --git a/src/app/foldhaus_search_lister.cpp b/src/app/deprecated/foldhaus_search_lister.cpp similarity index 68% rename from src/app/foldhaus_search_lister.cpp rename to src/app/deprecated/foldhaus_search_lister.cpp index 78734b5..cb0725b 100644 --- a/src/app/foldhaus_search_lister.cpp +++ b/src/app/deprecated/foldhaus_search_lister.cpp @@ -6,7 +6,7 @@ #ifndef FOLDHAUS_SEARCH_LISTER_CPP internal b32 -NamePassesFilter (string Target, string Filter) +NamePassesFilter (gs_string Target, gs_string Filter) { return (Filter.Length == 0 || StringContainsStringCaseInsensitive(Target, Filter)); } @@ -21,14 +21,14 @@ FilterSearchLister (search_lister* SearchLister) for (s32 i = 0; i < SearchLister->SourceListCount; i++) { - string* NameString = SearchLister->SourceList + i; - if (NamePassesFilter(*NameString, SearchLister->Filter)) + gs_string* Namegs_string = SearchLister->SourceList + i; + if (NamePassesFilter(*Namegs_string, SearchLister->Filter)) { SearchLister->FilteredIndexLUT[SearchLister->FilteredListCount++] = i; } } - SearchLister->HotItem = GSClamp(0, SearchLister->HotItem, SearchLister->FilteredListCount - 1); + SearchLister->HotItem = Clamp(0, SearchLister->HotItem, SearchLister->FilteredListCount - 1); if (SearchLister->FilteredListCount == 0) { @@ -39,14 +39,14 @@ FilterSearchLister (search_lister* SearchLister) internal s32 GetNextFilteredItem (search_lister SearchLister) { - s32 Result = GSMin(SearchLister.HotItem + 1, SearchLister.FilteredListCount - 1); + s32 Result = Min(SearchLister.HotItem + 1, SearchLister.FilteredListCount - 1); return Result; } internal s32 GetPrevFilteredItem (search_lister SearchLister) { - s32 Result = GSMax(SearchLister.HotItem - 1, 0); + s32 Result = Max(SearchLister.HotItem - 1, 0); return Result; } diff --git a/src/app/foldhaus_search_lister.h b/src/app/deprecated/foldhaus_search_lister.h similarity index 81% rename from src/app/foldhaus_search_lister.h rename to src/app/deprecated/foldhaus_search_lister.h index 8cc4d15..e2d502e 100644 --- a/src/app/foldhaus_search_lister.h +++ b/src/app/deprecated/foldhaus_search_lister.h @@ -8,11 +8,11 @@ struct search_lister { // TODO(Peter): Giving up trying to just use the source list for now. At the moment - // we are copying the strings you want to filter from and storing them here. Come back + // we are copying the gs_strings you want to filter from and storing them here. Come back // once its working and make the memory efficient version (ie store the existing memory // location, the element stride and the offset to the char*) s32 SourceListCount; - string* SourceList; + gs_string* SourceList; // NOTE(Peter): stores the source indecies of each filtered item // For example: @@ -23,7 +23,7 @@ struct search_lister s32* FilteredIndexLUT; s32 HotItem; - string Filter; + gs_string Filter; }; diff --git a/src/app/foldhaus_text_entry.cpp b/src/app/deprecated/foldhaus_text_entry.cpp similarity index 88% rename from src/app/foldhaus_text_entry.cpp rename to src/app/deprecated/foldhaus_text_entry.cpp index 1d59e10..7deb830 100644 --- a/src/app/foldhaus_text_entry.cpp +++ b/src/app/deprecated/foldhaus_text_entry.cpp @@ -17,15 +17,14 @@ PipeSearchStringToDestination (text_entry* Input) { switch (Input->Destination.Type) { - case TextTranslateTo_String: + case TextTranslateTo_gs_string: { - CopyStringTo(Input->Buffer, Input->Destination.StringDest); + PrintF(Input->Destination.StringDest, "%S", Input->Buffer); }break; case TextTranslateTo_R32: { - parse_result FloatParseResult = ParseFloat(StringExpand(Input->Buffer)); - *Input->Destination.FloatDest = FloatParseResult.FloatValue; + *Input->Destination.FloatDest = (r32)ParseFloat(Input->Buffer.ConstString); }break; InvalidDefaultCase; @@ -37,19 +36,22 @@ RemoveCharacterAtCursor (text_entry* TextEntry) { if (TextEntry->CursorPosition > 0) { - RemoveCharAt(&TextEntry->Buffer, - TextEntry->CursorPosition - 1); + for (u32 i = TextEntry->CursorPosition - 1; i < TextEntry->Buffer.Length; i++) + { + Assert(i + 1 < TextEntry->Buffer.Size); + TextEntry->Buffer.Str[i] = TextEntry->Buffer.Str[i + 1]; + } TextEntry->CursorPosition--; } } -internal void -SetTextInputDestinationToString (text_entry* TextInput, string* DestinationString) +internal void +SetTextInputDestinationToString (text_entry* TextInput, gs_string* DestinationString) { ResetTextInput(TextInput); - TextInput->Destination.Type = TextTranslateTo_String; + TextInput->Destination.Type = TextTranslateTo_gs_string; TextInput->Destination.StringDest = DestinationString; - CopyStringTo(*DestinationString, &TextInput->Buffer); + PrintF(&TextInput->Buffer, "%S", *DestinationString); } internal void @@ -69,14 +71,13 @@ SetTextInputDestinationToFloat (text_entry* TextInput, r32* DestinationFloat) internal void MoveCursorRight (text_entry* TextEntry) { - TextEntry->CursorPosition = GSMin(TextEntry->Buffer.Length, - TextEntry->CursorPosition + 1); + TextEntry->CursorPosition = Min(TextEntry->Buffer.Length, TextEntry->CursorPosition + 1); } internal void MoveCursorLeft (text_entry* TextEntry) { - TextEntry->CursorPosition = GSMax(0, TextEntry->CursorPosition - 1); + TextEntry->CursorPosition = Max(0, TextEntry->CursorPosition - 1); } FOLDHAUS_INPUT_COMMAND_PROC(TextEntryInsertChar) @@ -88,12 +89,21 @@ FOLDHAUS_INPUT_COMMAND_PROC(TextEntryInsertChar) Char += ('a' - 'A'); } - InsertChar(&State->ActiveTextEntry.Buffer, Char, State->ActiveTextEntry.CursorPosition); + // Shift string forward + Assert(State->ActiveTextEntry.Buffer.Length < State->ActiveTextEntry.Buffer.Size); + for (u32 i = State->ActiveTextEntry.Buffer.Length; + i > (u32)State->ActiveTextEntry.CursorPosition; + i--) + { + State->ActiveTextEntry.Buffer.Str[i] = State->ActiveTextEntry.Buffer.Str[i - 1]; + } + // Insert new Character + State->ActiveTextEntry.Buffer.Str[State->ActiveTextEntry.CursorPosition] = Char; State->ActiveTextEntry.CursorPosition++; PipeSearchStringToDestination(&State->ActiveTextEntry); } -FOLDHAUS_INPUT_COMMAND_PROC(RemoveCharacterFromEntryString) +FOLDHAUS_INPUT_COMMAND_PROC(RemoveCharacterFromEntrygs_string) { RemoveCharacterAtCursor(&State->ActiveTextEntry); } @@ -109,11 +119,11 @@ FOLDHAUS_INPUT_COMMAND_PROC(TextEntryMoveCursorLeft) } internal void -InitializeTextInputCommands (input_command_registry* Commands, memory_arena* PermanentStorage) +InitializeTextInputCommands (input_command_registry* Commands, gs_memory_arena* PermanentStorage) { if (Commands->Size > 0) { - RegisterKeyPressCommand(Commands, KeyCode_Backspace, Command_Began | Command_Held, KeyCode_Invalid, RemoveCharacterFromEntryString); + RegisterKeyPressCommand(Commands, KeyCode_Backspace, Command_Began | Command_Held, KeyCode_Invalid, RemoveCharacterFromEntrygs_string); RegisterKeyPressCommand(Commands, KeyCode_LeftArrow, Command_Began | Command_Held, KeyCode_Invalid, TextEntryMoveCursorLeft); RegisterKeyPressCommand(Commands, KeyCode_RightArrow, Command_Began | Command_Held, KeyCode_Invalid, TextEntryMoveCursorRight); @@ -126,7 +136,7 @@ InitializeTextInputCommands (input_command_registry* Commands, memory_arena* Per } #define DEFAULT_TEXT_ENTRY_INPUT_COMMANDS_ARRAY_ENTRY \ -{ KeyCode_Backspace, KeyCode_Invalid, Command_Began | Command_Held, RemoveCharacterFromEntryString }, \ +{ KeyCode_Backspace, KeyCode_Invalid, Command_Began | Command_Held, RemoveCharacterFromEntrygs_string }, \ { KeyCode_LeftArrow, KeyCode_Invalid, Command_Began | Command_Held, TextEntryMoveCursorLeft }, \ { KeyCode_RightArrow, KeyCode_Invalid, Command_Began | Command_Held, TextEntryMoveCursorRight }, \ { KeyCode_a, KeyCode_Invalid, Command_Began | Command_Held, TextEntryInsertChar }, \ diff --git a/src/app/foldhaus_text_entry.h b/src/app/deprecated/foldhaus_text_entry.h similarity index 81% rename from src/app/foldhaus_text_entry.h rename to src/app/deprecated/foldhaus_text_entry.h index dd8ba00..e25608f 100644 --- a/src/app/foldhaus_text_entry.h +++ b/src/app/deprecated/foldhaus_text_entry.h @@ -7,7 +7,7 @@ enum text_translation_type { - TextTranslateTo_String, + TextTranslateTo_gs_string, TextTranslateTo_R32, TextTranslateTo_S32, TextTranslateTo_U32, @@ -17,7 +17,7 @@ struct text_entry_destination { text_translation_type Type; union { - string* StringDest; + gs_string* StringDest; r32* FloatDest; s32* SignedIntDest; u32* UnsignedIntDest; @@ -26,7 +26,7 @@ struct text_entry_destination struct text_entry { - string Buffer; + gs_string Buffer; s32 CursorPosition; text_entry_destination Destination; diff --git a/src/app/node/foldhaus_node_interface.cpp b/src/app/deprecated/node/foldhaus_node_interface.cpp similarity index 90% rename from src/app/node/foldhaus_node_interface.cpp rename to src/app/deprecated/node/foldhaus_node_interface.cpp index 0b4c3e4..f4e3b39 100644 --- a/src/app/node/foldhaus_node_interface.cpp +++ b/src/app/deprecated/node/foldhaus_node_interface.cpp @@ -18,7 +18,7 @@ struct node_lister_operation_state }; internal void -RenderNodeLister(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) +RenderNodeLister(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) { node_lister_operation_state* OpState = (node_lister_operation_state*)Operation.OpStateMemory; @@ -30,7 +30,7 @@ RenderNodeLister(panel Panel, rect PanelBounds, render_command_buffer* RenderBuf FilterSearchLister(&OpState->SearchLister); // Display Search Lister - search_lister_result NodeListerResult = EvaluateSearchLister (&State->Interface_, TopLeft, Dimension, + search_lister_result NodeListerResult = EvaluateSearchLister (&State->Interface_, TopLeft, Dimension, MakeStringLiteral("Nodes List"), OpState->SearchLister.SourceList, OpState->SearchLister.FilteredIndexLUT, @@ -85,12 +85,12 @@ FOLDHAUS_INPUT_COMMAND_PROC(OpenNodeLister) AddNodeOperation->Render = RenderNodeLister; - node_lister_operation_state* OpState = CreateOperationState(AddNodeOperation, - &State->Modes, + node_lister_operation_state* OpState = CreateOperationState(AddNodeOperation, + &State->Modes, node_lister_operation_state); { OpState->SearchLister.SourceListCount = NodeSpecificationsCount; - OpState->SearchLister.SourceList = PushArray(&State->Modes.Arena, string, OpState->SearchLister.SourceListCount); + OpState->SearchLister.SourceList = PushArray(&State->Modes.Arena, gs_string, OpState->SearchLister.SourceListCount); { for (s32 i = 0; i < OpState->SearchLister.SourceListCount; i++) { @@ -107,7 +107,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(OpenNodeLister) } OpState->ListPosition = Mouse.Pos; - SetTextInputDestinationToString(&State->ActiveTextEntry, &OpState->SearchLister.Filter); + SetTextInputDestinationTogs_string(&State->ActiveTextEntry, &OpState->SearchLister.Filter); } //////////////////////////////////////// @@ -133,12 +133,12 @@ FOLDHAUS_INPUT_COMMAND_PROC(CloseColorPickerCommand) } internal void -RenderColorPicker(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) +RenderColorPicker(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) { color_picker_operation_state* OpState = (color_picker_operation_state*)Operation.OpStateMemory; - b32 ShouldClose = EvaluateColorPicker(RenderBuffer, OpState->ValueAddr, + b32 ShouldClose = EvaluateColorPicker(RenderBuffer, OpState->ValueAddr, v2{200, 200}, State->Interface, Mouse); if (ShouldClose) @@ -157,8 +157,8 @@ OpenColorPicker(app_state* State, node_connection* Connection) operation_mode* ColorPickerMode = ActivateOperationModeWithCommands(&State->Modes, ColorPickerCommands); ColorPickerMode->Render = RenderColorPicker; - color_picker_operation_state* OpState = CreateOperationState(ColorPickerMode, - &State->Modes, + color_picker_operation_state* OpState = CreateOperationState(ColorPickerMode, + &State->Modes, color_picker_operation_state); OpState->ValueAddr = Connection->V4ValuePtr; } @@ -184,7 +184,7 @@ input_command NodeFieldTextEditCommands [] = { internal void BeginNodeFieldTextEdit(app_state* State, node_connection* Connection) { - operation_mode* NodeFieldTextEditMode = ActivateOperationModeWithCommands(&State->Modes, + operation_mode* NodeFieldTextEditMode = ActivateOperationModeWithCommands(&State->Modes, NodeFieldTextEditCommands); SetTextInputDestinationToFloat(&State->ActiveTextEntry, Connection->R32ValuePtr); @@ -202,10 +202,10 @@ struct drag_node_port_operation_state }; internal void -RenderDraggingNodePort(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) +RenderDraggingNodePort(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) { drag_node_port_operation_state* OpState = (drag_node_port_operation_state*)Operation.OpStateMemory; - UpdateDraggingNodePort(Mouse.Pos, OpState->Interaction, State->NodeList, + UpdateDraggingNodePort(Mouse.Pos, OpState->Interaction, State->NodeList, State->NodeRenderSettings, RenderBuffer); } @@ -225,12 +225,12 @@ internal void BeginDraggingNodePort(app_state* State, node_interaction Interaction) { operation_mode* DragNodePortMode = ActivateOperationModeWithCommands( - &State->Modes, + &State->Modes, DragNodePortInputCommands); DragNodePortMode->Render = RenderDraggingNodePort; - drag_node_port_operation_state* OpState = CreateOperationState(DragNodePortMode, - &State->Modes, + drag_node_port_operation_state* OpState = CreateOperationState(DragNodePortMode, + &State->Modes, drag_node_port_operation_state); OpState->Interaction = Interaction; } @@ -242,16 +242,16 @@ BeginDraggingNodePort(app_state* State, node_interaction Interaction) /////////////////////////////////////// internal void -RenderDragNodeField(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) +RenderDragNodeField(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) { - // TODO(Peter): + // TODO(Peter): //UpdateDraggingNodeValue(Mouse.Pos, Mouse.OldPos, OpState->Interaction, State->NodeList, State->NodeRenderSettings, State); } internal void BeginInteractWithNodeField(app_state* State, node_interaction Interaction) { - // TODO(Peter): + // TODO(Peter): } //////////////////////////////////////// @@ -266,10 +266,10 @@ struct drag_node_operation_state }; internal void -RenderDraggingNode(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) +RenderDraggingNode(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) { drag_node_operation_state* OpState = GetCurrentOperationState(State->Modes, drag_node_operation_state); - UpdateDraggingNode(Mouse.Pos, OpState->Interaction, State->NodeList, + UpdateDraggingNode(Mouse.Pos, OpState->Interaction, State->NodeList, State->NodeRenderSettings); } @@ -286,12 +286,12 @@ internal void BeginDraggingNode(app_state* State, node_interaction Interaction) { operation_mode* DragNodeMode = ActivateOperationModeWithCommands( - &State->Modes, + &State->Modes, DragNodeInputCommands); DragNodeMode->Render = RenderDraggingNode; - drag_node_operation_state* OpState = CreateOperationState(DragNodeMode, - &State->Modes, + drag_node_operation_state* OpState = CreateOperationState(DragNodeMode, + &State->Modes, drag_node_operation_state); OpState->Interaction = Interaction; } @@ -314,8 +314,8 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewBeginMouseDragInteraction) node_header* Node = GetNodeUnderPoint(State->NodeList, Mouse.DownPos, State->NodeRenderSettings); if (Node) { - node_interaction NewInteraction = GetNodeInteractionType(Node, - Mouse.Pos, + node_interaction NewInteraction = GetNodeInteractionType(Node, + Mouse.Pos, State->NodeRenderSettings); if (IsDraggingNodePort(NewInteraction)) { @@ -324,7 +324,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewBeginMouseDragInteraction) else if(IsDraggingNodeValue(NewInteraction)) { // TODO(Peter): This probably wants to live in a mouse held action - // the first frame we realize we're held over a field, just transition to + // the first frame we realize we're held over a field, just transition to // drag node field //BeginInteractWithNodeField(State, NewInteraction, State->NodeRenderSettings); } @@ -347,8 +347,8 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewBeginMouseSelectInteraction) node_header* Node = GetNodeUnderPoint(State->NodeList, Mouse.Pos, State->NodeRenderSettings); if (Node) { - node_interaction NewInteraction = GetNodeInteractionType(Node, - Mouse.Pos, + node_interaction NewInteraction = GetNodeInteractionType(Node, + Mouse.Pos, State->NodeRenderSettings); if(IsDraggingNodeValue(NewInteraction)) { @@ -368,7 +368,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewBeginMouseSelectInteraction) } internal void -RenderNodeView(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) +RenderNodeView(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBufer, app_state* State, context Context, mouse_state Mouse) { node_view_operation_state* OpState = (node_view_operation_state*)Operation.OpStateMemory; @@ -383,7 +383,7 @@ RenderNodeView(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer { node_header* Node = NodeIter.At; - rect NodeBounds = CalculateNodeBounds(Node, State->NodeRenderSettings); + rect2 NodeBounds = CalculateNodeBounds(Node, State->NodeRenderSettings); b32 DrawFields = PointIsInRect(Mouse.Pos, NodeBounds); if (Node == SelectedNode) @@ -394,8 +394,8 @@ RenderNodeView(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer PushRenderQuad2D(RenderBuffer, NodeBounds.Min, NodeBounds.Max, v4{.5f, .5f, .5f, 1.f}); // TODO(Peter): This is just for debug purposes. We can remove and go back to just having - // Node->Name in DrawString - string NodeName = GetNodeName(*Node); + // Node->Name in Drawgs_string + gs_string NodeName = GetNodeName(*Node); PrintF(&NodeHeaderBuffer, "%.*s: %d", NodeName.Length, NodeName.Memory, Node->Handle); DrawString(RenderBuffer, NodeHeaderBuffer, State->NodeRenderSettings.Font, v2{NodeBounds.Min.x + 5, NodeBounds.Max.y - (State->NodeRenderSettings.Font->PixelHeight + NODE_HEADER_HEIGHT + 5)}, @@ -408,12 +408,12 @@ RenderNodeView(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer // Inputs if (ConnectionIsInput(Node, Connection)) { - rect PortBounds = CalculateNodeInputPortBounds(Node, Connection, State->NodeRenderSettings); + rect2 PortBounds = CalculateNodeInputPortBounds(Node, Connection, State->NodeRenderSettings); DrawPort(RenderBuffer, PortBounds, PortColor); // // TODO(Peter): I don't like excluding OutputNode, feels too much like a special case - // but I don't want to get in to the meta programming right now. + // but I don't want to get in to the meta programming right now. // We should just generate a spec and struct member types for NodeType_OutputNode // // :ExcludingOutputNodeSpecialCase @@ -422,21 +422,21 @@ RenderNodeView(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer { node_specification Spec = NodeSpecifications[Node->Type]; node_struct_member Member = Spec.MemberList[Connection]; - DrawString(RenderBuffer, MakeString(Member.Name), + DrawString(RenderBuffer, MakeString(Member.Name), State->NodeRenderSettings.Font, v2{PortBounds.Min.x - 8, PortBounds.Min.y}, WhiteV4, Align_Right); } - rect ValueBounds = CalculateNodeInputValueBounds(Node, Connection, State->NodeRenderSettings); + rect2 ValueBounds = CalculateNodeInputValueBounds(Node, Connection, State->NodeRenderSettings); DrawValueDisplay(RenderBuffer, ValueBounds, Node->Connections[Connection], State->NodeRenderSettings.Font); // NOTE(Peter): its way easier to draw the connection on the input port b/c its a 1:1 relationship, // whereas output ports might have many connections, they really only know about the most recent one - // Not sure if this is a problem. We mostly do everything backwards here, starting at the + // Not sure if this is a problem. We mostly do everything backwards here, starting at the // most downstream node and working back up to find dependencies. if (ConnectionHasUpstreamConnection(Node, Connection)) { - rect ConnectedPortBounds = GetBoundsOfPortConnectedToInput(Node, Connection, State->NodeList, State->NodeRenderSettings); + rect2 ConnectedPortBounds = GetBoundsOfPortConnectedToInput(Node, Connection, State->NodeList, State->NodeRenderSettings); v2 InputCenter = CalculateRectCenter(PortBounds); v2 OutputCenter = CalculateRectCenter(ConnectedPortBounds); PushRenderLine2D(RenderBuffer, OutputCenter, InputCenter, 1, WhiteV4); @@ -446,25 +446,25 @@ RenderNodeView(panel Panel, rect PanelBounds, render_command_buffer* RenderBufer // Outputs if (ConnectionIsOutput(Node, Connection)) { - rect PortBounds = CalculateNodeOutputPortBounds(Node, Connection, State->NodeRenderSettings); + rect2 PortBounds = CalculateNodeOutputPortBounds(Node, Connection, State->NodeRenderSettings); DrawPort(RenderBuffer, PortBounds, PortColor); if (DrawFields) { node_specification Spec = NodeSpecifications[Node->Type]; node_struct_member Member = Spec.MemberList[Connection]; - DrawString(RenderBuffer, MakeString(Member.Name), + DrawString(RenderBuffer, MakeString(Member.Name), State->NodeRenderSettings.Font, v2{PortBounds.Max.x + 8, PortBounds.Min.y}, WhiteV4); } - rect ValueBounds = CalculateNodeOutputValueBounds(Node, Connection, State->NodeRenderSettings); + rect2 ValueBounds = CalculateNodeOutputValueBounds(Node, Connection, State->NodeRenderSettings); DrawValueDisplay(RenderBuffer, ValueBounds, Node->Connections[Connection], State->NodeRenderSettings.Font); } for (s32 Button = 0; Button < 3; Button++) { - rect ButtonRect = CalculateNodeDragHandleBounds(NodeBounds, Button, State->NodeRenderSettings); + rect2 ButtonRect = CalculateNodeDragHandleBounds(NodeBounds, Button, State->NodeRenderSettings); PushRenderQuad2D(RenderBuffer, ButtonRect.Min, ButtonRect.Max, DragButtonColors[Button]); } } @@ -501,8 +501,8 @@ FOLDHAUS_INPUT_COMMAND_PROC(OpenNodeView) operation_mode* NodeViewMode = ActivateOperationModeWithCommands(&State->Modes, NodeViewCommands); NodeViewMode->Render = RenderNodeView; - node_view_operation_state* OpState = CreateOperationState(NodeViewMode, - &State->Modes, + node_view_operation_state* OpState = CreateOperationState(NodeViewMode, + &State->Modes, node_view_operation_state); OpState->SelectedNodeHandle = 0; diff --git a/src/app/foldhaus_app.cpp b/src/app/foldhaus_app.cpp index c3b9cb1..5d05907 100644 --- a/src/app/foldhaus_app.cpp +++ b/src/app/foldhaus_app.cpp @@ -8,27 +8,6 @@ #include "foldhaus_platform.h" #include "foldhaus_app.h" -internal v4 -MouseToWorldRay(r32 MouseX, r32 MouseY, camera* Camera, rect WindowBounds) -{ - DEBUG_TRACK_SCOPE(MouseToWorldRay); - r32 X = ((2.0f * MouseX) / gs_Width(WindowBounds)) - 1; - r32 Y = ((2.0f * MouseY) / gs_Height(WindowBounds)) - 1; - - v4 ScreenPos = v4{X, Y, -1, 1}; - - m44 InverseProjection = {}; - Inverse(GetCameraPerspectiveProjectionMatrix(*Camera), &InverseProjection); - - m44 InverseModelView = {}; - Inverse(GetCameraModelViewMatrix(*Camera), &InverseModelView); - InverseModelView = Transpose(InverseModelView); - - v4 ClipSpacePos = InverseProjection * ScreenPos; - v4 WorldPosition = InverseModelView * ClipSpacePos; - return WorldPosition; -} - struct send_sacn_job_data { @@ -72,11 +51,8 @@ INITIALIZE_APPLICATION(InitializeApplication) app_state* State = (app_state*)Context.MemoryBase; *State = {}; - State->Permanent = {}; - State->Permanent.PlatformMemory = Context.PlatformMemory; - State->Transient = {}; - State->Transient.FindAddressRule = FindAddress_InLastBufferOnly; - State->Transient.PlatformMemory = Context.PlatformMemory; + State->Permanent = CreateMemoryArena(Context.ThreadContext.Allocator); + State->Transient = CreateMemoryArena(Context.ThreadContext.Allocator); State->Assemblies.CountMax = 8; State->Assemblies.Values = PushArray(&State->Permanent, assembly, State->Assemblies.CountMax); @@ -90,13 +66,11 @@ INITIALIZE_APPLICATION(InitializeApplication) CommandQueueSize); State->CommandQueue = InitializeCommandQueue(CommandQueueMemory, CommandQueueSize); - State->ActiveTextEntry.Buffer = MakeString(PushArray(&State->Permanent, char, 256), 0, 256); - // TODO(Peter): put in InitializeInterface? r32 FontSize = 14; { - platform_memory_result FontFile = ReadEntireFile(Context, MakeStringLiteral("data/Anonymous Pro.ttf")); - if (!FontFile.Error) + gs_file FontFile = ReadEntireFile(Context.ThreadContext.FileHandler, ConstString("data/Anonymous Pro.ttf")); + if (FileNoError(FontFile)) { bitmap_font* Font = PushStruct(&State->Permanent, bitmap_font); @@ -105,7 +79,7 @@ INITIALIZE_APPLICATION(InitializeApplication) Font->BitmapBytesPerPixel = 4; Font->BitmapMemory = PushArray(&State->Permanent, u8, Font->BitmapWidth * Font->BitmapHeight * Font->BitmapBytesPerPixel); Font->BitmapStride = Font->BitmapWidth * Font->BitmapBytesPerPixel; - GSMemSet(Font->BitmapMemory, 0, Font->BitmapStride * Font->BitmapHeight); + ZeroMemoryBlock(Font->BitmapMemory, Font->BitmapStride * Font->BitmapHeight); platform_font_info FontInfo = Context.PlatformGetFontInfo("Anonymous Pro", FontSize, FontWeight_Normal, false, false, false); Font->PixelHeight = FontInfo.PixelHeight; @@ -169,17 +143,18 @@ INITIALIZE_APPLICATION(InitializeApplication) State->SACN = InitializeSACN(Context); State->NetworkProtocolHeaderSize = STREAM_HEADER_SIZE; - State->Camera.FieldOfView = DegreesToRadians(45.0f); - State->Camera.AspectRatio = gs_AspectRatio(State->WindowBounds); - State->Camera.Near = 1.0f; - State->Camera.Far = 100.0f; - State->Camera.Position = v3{0, 0, -250}; - State->Camera.LookAt = v3{0, 0, 0}; + State->Camera.FieldOfView = 45.0f; + State->Camera.AspectRatio = RectAspectRatio(State->WindowBounds); + State->Camera.Near = .1f; + State->Camera.Far = 800.0f; + State->Camera.Position = v3{0, 0, 400}; + State->Camera.LookAt = v3{0, 0, 0 + }; - State->LedSystem = LedSystemInitialize(Context.PlatformMemory, 128); + State->LedSystem = LedSystemInitialize(Context.ThreadContext.Allocator, 128); #if 1 - string SculpturePath = MakeStringLiteral("data/radialumia_v2.fold"); + gs_const_string SculpturePath = ConstString("data/radialumia_v2.fold"); LoadAssembly(&State->Assemblies, &State->LedSystem, &State->Transient, Context, SculpturePath, State->GlobalLog); #endif @@ -189,11 +164,7 @@ INITIALIZE_APPLICATION(InitializeApplication) ReloadStaticData(Context, GlobalDebugServices); - // Setup Operation Modes - State->Modes.ActiveModesCount = 0; - State->Modes.Arena = {}; - State->Modes.Arena.PlatformMemory = Context.PlatformMemory; - State->Modes.Arena.FindAddressRule = FindAddress_InLastBufferOnly; + State->Modes = OperationModeSystemInit(&State->Permanent, Context.ThreadContext); { // Animation PLAYGROUND State->AnimationSystem = {}; @@ -203,9 +174,9 @@ INITIALIZE_APPLICATION(InitializeApplication) State->AnimationSystem.PlayableRange.Max = SecondsToFrames(15, State->AnimationSystem); State->AnimationSystem.LayersMax = 32; State->AnimationSystem.Layers = PushArray(&State->Permanent, anim_layer, State->AnimationSystem.LayersMax); - AddLayer(MakeStringLiteral("Base Layer"), &State->AnimationSystem, BlendMode_Overwrite); - AddLayer(MakeStringLiteral("Color Layer"), &State->AnimationSystem, BlendMode_Multiply); - AddLayer(MakeStringLiteral("Sparkles"), &State->AnimationSystem, BlendMode_Add); + AddLayer(MakeString("Base Layer"), &State->AnimationSystem, BlendMode_Overwrite); + AddLayer(MakeString("Color Layer"), &State->AnimationSystem, BlendMode_Multiply); + AddLayer(MakeString("Sparkles"), &State->AnimationSystem, BlendMode_Add); } // End Animation Playground @@ -215,7 +186,7 @@ INITIALIZE_APPLICATION(InitializeApplication) } internal void -HandleInput (app_state* State, rect WindowBounds, input_queue InputQueue, mouse_state Mouse) +HandleInput (app_state* State, rect2 WindowBounds, input_queue InputQueue, mouse_state Mouse) { DEBUG_TRACK_FUNCTION; @@ -274,7 +245,7 @@ HandleInput (app_state* State, rect WindowBounds, input_queue InputQueue, mouse_ } internal dmx_buffer_list* -CreateDMXBuffers(assembly Assembly, led_system* LedSystem, s32 BufferHeaderSize, memory_arena* Arena) +CreateDMXBuffers(assembly Assembly, led_system* LedSystem, s32 BufferHeaderSize, gs_memory_arena* Arena) { DEBUG_TRACK_FUNCTION; @@ -322,6 +293,10 @@ CreateDMXBuffers(assembly Assembly, led_system* LedSystem, s32 BufferHeaderSize, return Result; } + +#define HANDMADE_MATH_IMPLEMENTATION +#include "handmade_math.h" + UPDATE_AND_RENDER(UpdateAndRender) { DEBUG_TRACK_FUNCTION; @@ -334,6 +309,9 @@ UPDATE_AND_RENDER(UpdateAndRender) ClearArena(&State->Transient); Context->Mouse.CursorType = CursorType_Arrow; + PushRenderClearScreen(RenderBuffer); + State->Camera.AspectRatio = RectAspectRatio(Context->WindowBounds); + HandleInput(State, State->WindowBounds, InputQueue, Context->Mouse); if (State->AnimationSystem.TimelineShouldAdvance) { @@ -355,7 +333,7 @@ UPDATE_AND_RENDER(UpdateAndRender) u32 CurrentBlocksMax = State->AnimationSystem.LayersCount; b8* CurrentBlocksFilled = PushArray(&State->Transient, b8, CurrentBlocksMax); - GSZeroArray(CurrentBlocksFilled, b8, CurrentBlocksMax); + ZeroArray(CurrentBlocksFilled, b8, CurrentBlocksMax); animation_block* CurrentBlocks = PushArray(&State->Transient, animation_block, CurrentBlocksMax); for (u32 i = 0; i < State->AnimationSystem.Blocks.Used; i++) @@ -432,9 +410,9 @@ UPDATE_AND_RENDER(UpdateAndRender) u32 G = (u32)AssemblyLedBuffer->Colors[LED].G + (u32)LayerLEDBuffers[Layer].Colors[LED].G; u32 B = (u32)AssemblyLedBuffer->Colors[LED].B + (u32)LayerLEDBuffers[Layer].Colors[LED].B; - AssemblyLedBuffer->Colors[LED].R = (u8)GSMin(R, (u32)255); - AssemblyLedBuffer->Colors[LED].G = (u8)GSMin(G, (u32)255); - AssemblyLedBuffer->Colors[LED].B = (u8)GSMin(B, (u32)255); + AssemblyLedBuffer->Colors[LED].R = (u8)Min(R, (u32)255); + AssemblyLedBuffer->Colors[LED].G = (u8)Min(G, (u32)255); + AssemblyLedBuffer->Colors[LED].B = (u8)Min(B, (u32)255); } }break; @@ -502,7 +480,7 @@ UPDATE_AND_RENDER(UpdateAndRender) - PushRenderOrthographic(RenderBuffer, 0, 0, gs_Width(State->WindowBounds), gs_Height(State->WindowBounds)); + PushRenderOrthographic(RenderBuffer, State->WindowBounds); PushRenderClearScreen(RenderBuffer); State->WindowBounds = Context->WindowBounds; @@ -521,7 +499,7 @@ UPDATE_AND_RENDER(UpdateAndRender) } } - Context->GeneralWorkQueue->DoQueueWorkUntilDone(Context->GeneralWorkQueue, 0); + Context->GeneralWorkQueue->CompleteQueueWork(Context->GeneralWorkQueue, Context->ThreadContext); Context->GeneralWorkQueue->ResetWorkQueue(Context->GeneralWorkQueue); // Checking for overflows diff --git a/src/app/foldhaus_app.h b/src/app/foldhaus_app.h index a33d179..cadf625 100644 --- a/src/app/foldhaus_app.h +++ b/src/app/foldhaus_app.h @@ -20,13 +20,8 @@ #include "foldhaus_assembly.h" #include "assembly_parser.cpp" - -#include "foldhaus_node.h" - typedef struct app_state app_state; -#include "test_patterns.h" - // TODO(Peter): something we can do later is to remove all reliance on app_state and context // from foldhaus_pane.h. It should just emit lists of things that the app can iterate over and // perform operations on, like panel_draw_requests = { bounds, panel* } etc. @@ -37,10 +32,6 @@ typedef struct app_state app_state; #include "animation/foldhaus_animation.h" -#include "foldhaus_text_entry.h" - -#include "foldhaus_search_lister.h" - enum network_protocol { NetworkProtocol_SACN, @@ -51,10 +42,11 @@ enum network_protocol struct app_state { - rect WindowBounds; + r32 CameraTheta; // TODO(Peter): @TEMPORARY + rect2 WindowBounds; - memory_arena Permanent; - memory_arena Transient; + gs_memory_arena Permanent; + gs_memory_arena Transient; s32 NetworkProtocolHeaderSize; network_protocol NetworkProtocol; @@ -69,7 +61,6 @@ struct app_state operation_mode_system Modes; input_command_queue CommandQueue; - text_entry ActiveTextEntry; ui_interface Interface; @@ -80,7 +71,7 @@ struct app_state panel_system PanelSystem; panel* HotPanel; - pattern_node_workspace NodeWorkspace; + //pattern_node_workspace NodeWorkspace; event_log* GlobalLog; }; @@ -94,8 +85,8 @@ TestPatternOne(led_buffer* Assembly, r32 Time) for (u32 LedIndex = 0; LedIndex < Assembly->LedCount; LedIndex++) { v4 LedPosition = Assembly->Positions[LedIndex]; - float PercentX = GSRemap(LedPosition.x, -150.0f, 150.0f, 0.0f, 1.0f); - float PercentY = GSRemap(LedPosition.y, -150.0f, 150.0f, 0.0f, 1.0f); + float PercentX = RemapClampedR32(LedPosition.x, -150.0f, 150.0f, 0.0f, 1.0f); + float PercentY = RemapClampedR32(LedPosition.y, -150.0f, 150.0f, 0.0f, 1.0f); Assembly->Colors[LedIndex].R = (u8)(PercentX * 255); Assembly->Colors[LedIndex].G = (u8)(PercentY * 255); } @@ -104,16 +95,16 @@ TestPatternOne(led_buffer* Assembly, r32 Time) internal void TestPatternTwo(led_buffer* Assembly, r32 Time) { - r32 PeriodicTime = (Time / PI) * 2; + r32 PeriodicTime = (Time / PiR32) * 2; - r32 ZeroOneSin = (GSSin(PeriodicTime) * .5f) + .5f; - r32 ZeroOneCos = (GSCos(PeriodicTime) * .5f) + .5f; + r32 ZeroOneSin = (SinR32(PeriodicTime) * .5f) + .5f; + r32 ZeroOneCos = (CosR32(PeriodicTime) * .5f) + .5f; pixel Color = { (u8)(ZeroOneSin * 255), 0, (u8)(ZeroOneCos * 255) }; v4 Center = v4{0, 0, 0, 1}; r32 ThetaZ = Time / 2; - v4 Normal = v4{GSCos(ThetaZ), 0, GSSin(ThetaZ), 0}; // NOTE(Peter): dont' need to normalize. Should always be 1 - v4 Right = Cross(Normal, v4{0, 1, 0, 0}); + v4 Normal = v4{CosR32(ThetaZ), 0, SinR32(ThetaZ), 0}; // NOTE(Peter): dont' need to normalize. Should always be 1 + v4 Right = V4Cross(Normal, v4{0, 1, 0, 0}); v4 FrontCenter = Center + (Normal * 25); v4 BackCenter = Center - (Normal * 25); @@ -128,13 +119,13 @@ TestPatternTwo(led_buffer* Assembly, r32 Time) v4 ToFront = Position + FrontCenter; v4 ToBack = Position + BackCenter; - r32 ToFrontDotNormal = Dot(ToFront, Normal); - r32 ToBackDotNormal = Dot(ToBack, Normal); + r32 ToFrontDotNormal = V4Dot(ToFront, Normal); + r32 ToBackDotNormal = V4Dot(ToBack, Normal); - ToFrontDotNormal = GSClamp01(ToFrontDotNormal * 1000); - ToBackDotNormal = GSClamp01(ToBackDotNormal * 1000); + ToFrontDotNormal = Clamp01(ToFrontDotNormal * 1000); + ToBackDotNormal = Clamp01(ToBackDotNormal * 1000); - r32 SqDistToCenter = MagSqr(Position); + r32 SqDistToCenter = V4MagSquared(Position); if (SqDistToCenter < OuterRadiusSquared && SqDistToCenter > InnerRadiusSquared) { if (XOR(ToFrontDotNormal > 0, ToBackDotNormal > 0)) @@ -157,10 +148,10 @@ internal void TestPatternThree(led_buffer* Assembly, r32 Time) { v4 GreenCenter = v4{0, 0, 150, 1}; - r32 GreenRadius = GSAbs(GSSin(Time)) * 200; + r32 GreenRadius = Abs(SinR32(Time)) * 200; v4 TealCenter = v4{0, 0, 150, 1}; - r32 TealRadius = GSAbs(GSSin(Time + 1.5)) * 200; + r32 TealRadius = Abs(SinR32(Time + 1.5)) * 200; r32 FadeDist = 35; @@ -172,12 +163,12 @@ TestPatternThree(led_buffer* Assembly, r32 Time) u8 Green = 0; u8 Blue = 0; - r32 GreenDist = GSAbs(Mag(LedPosition - GreenCenter) - GreenRadius); - r32 GreenBrightness = GSClamp(0.f, FadeDist - GSAbs(GreenDist), FadeDist); + r32 GreenDist = Abs(V4Mag(LedPosition - GreenCenter) - GreenRadius); + r32 GreenBrightness = Clamp(0.f, FadeDist - Abs(GreenDist), FadeDist); Green = (u8)(GreenBrightness * 255); - r32 TealDist = GSAbs(Mag(LedPosition - TealCenter) - TealRadius); - r32 TealBrightness = GSClamp(0.f, FadeDist - GSAbs(TealDist), FadeDist); + r32 TealDist = Abs(V4Mag(LedPosition - TealCenter) - TealRadius); + r32 TealBrightness = Clamp(0.f, FadeDist - Abs(TealDist), FadeDist); Red = (u8)(TealBrightness * 255); Blue = (u8)(TealBrightness * 255); @@ -191,17 +182,6 @@ TestPatternThree(led_buffer* Assembly, r32 Time) #include "foldhaus_assembly.cpp" -#include "foldhaus_text_entry.cpp" -#include "foldhaus_search_lister.cpp" - -#include "foldhaus_default_nodes.h" - -#include "./generated/gs_meta_generated_typeinfo.h" -#include "generated/foldhaus_nodes_generated.h" - - -#include "foldhaus_node.cpp" - FOLDHAUS_INPUT_COMMAND_PROC(EndCurrentOperationMode) { DeactivateCurrentOperationMode(&State->Modes); @@ -213,7 +193,7 @@ typedef PANEL_INIT_PROC(panel_init_proc); #define PANEL_CLEANUP_PROC(name) void name(panel* Panel, app_state* State) typedef PANEL_CLEANUP_PROC(panel_cleanup_proc); -#define PANEL_RENDER_PROC(name) void name(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +#define PANEL_RENDER_PROC(name) void name(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) typedef PANEL_RENDER_PROC(panel_render_proc); // NOTE(Peter): This is used by the meta system to generate panel type info @@ -233,7 +213,6 @@ struct panel_definition #include "panels/foldhaus_panel_dmx_view.h" #include "panels/foldhaus_panel_animation_timeline.h" #include "panels/foldhaus_panel_hierarchy.h" -#include "panels/foldhaus_panel_node_graph.h" #include "panels/foldhaus_panel_file_view.h" #include "generated/foldhaus_panels_generated.h" diff --git a/src/app/foldhaus_assembly.cpp b/src/app/foldhaus_assembly.cpp index ea74af2..0d7ae9a 100644 --- a/src/app/foldhaus_assembly.cpp +++ b/src/app/foldhaus_assembly.cpp @@ -6,13 +6,13 @@ #ifndef FOLDHAUS_ASSEMBLY_CPP internal led_system -LedSystemInitialize(platform_memory_handler PlatformMemory, u32 BuffersMax) +LedSystemInitialize(gs_allocator PlatformMemory, u32 BuffersMax) { led_system Result = {}; Result.PlatformMemory = PlatformMemory; // TODO(Peter): Since we have access to PlatformMemory, just realloc Buffers when we fill it up Result.BuffersCountMax = BuffersMax; - Result.Buffers = PlatformAllocArray(PlatformMemory, led_buffer, Result.BuffersCountMax); + Result.Buffers = AllocatorAllocArray(PlatformMemory, led_buffer, Result.BuffersCountMax); return Result; } @@ -43,8 +43,8 @@ LedSystemTakeFreeBuffer(led_system* System, u32 LedCount) led_buffer* Buffer = &System->Buffers[Result]; Buffer->LedCount = LedCount; - Buffer->Colors = PlatformAllocArray(System->PlatformMemory, pixel, Buffer->LedCount); - Buffer->Positions = PlatformAllocArray(System->PlatformMemory, v4, Buffer->LedCount); + Buffer->Colors = AllocatorAllocArray(System->PlatformMemory, pixel, Buffer->LedCount); + Buffer->Positions = AllocatorAllocArray(System->PlatformMemory, v4, Buffer->LedCount); System->LedsCountTotal += LedCount; @@ -56,8 +56,8 @@ LedSystemFreeBuffer(led_system* System, u32 BufferIndex) { Assert(BufferIndex < System->BuffersCountMax); led_buffer* Buffer = &System->Buffers[BufferIndex]; - PlatformFreeArray(System->PlatformMemory, Buffer->Colors, pixel, Buffer->LedCount); - PlatformFreeArray(System->PlatformMemory, Buffer->Positions, v4, Buffer->LedCount); + AllocatorFreeArray(System->PlatformMemory, Buffer->Colors, pixel, Buffer->LedCount); + AllocatorFreeArray(System->PlatformMemory, Buffer->Positions, v4, Buffer->LedCount); System->LedsCountTotal -= Buffer->LedCount; *Buffer = {}; } @@ -77,7 +77,7 @@ LedBufferSetLed(led_buffer* Buffer, u32 Led, v4 Position) } internal void -ConstructAssemblyFromDefinition (assembly* Assembly, string AssemblyName, v4 RootPosition, led_system* LedSystem) +ConstructAssemblyFromDefinition (assembly* Assembly, gs_const_string AssemblyName, v4 RootPosition, led_system* LedSystem) { Assembly->LedBufferIndex = LedSystemTakeFreeBuffer(LedSystem, Assembly->LedCountTotal); led_buffer* LedBuffer = LedSystemGetBuffer(LedSystem, Assembly->LedBufferIndex); @@ -90,8 +90,8 @@ ConstructAssemblyFromDefinition (assembly* Assembly, string AssemblyName, v4 Roo v2_strip* StripAt = &Assembly->Strips[StripIdx]; StripAt->LedLUT = PushArray(&Assembly->Arena, u32, StripAt->LedCount); - v4 WS_StripStart = RootPosition + V4(StripAt->StartPosition * Assembly->Scale, 1); - v4 WS_StripEnd = RootPosition + V4(StripAt->EndPosition * Assembly->Scale, 1); + v4 WS_StripStart = RootPosition + ToV4Point(StripAt->StartPosition * Assembly->Scale); + v4 WS_StripEnd = RootPosition + ToV4Point(StripAt->EndPosition * Assembly->Scale); v4 SingleStep = (WS_StripEnd - WS_StripStart) / (r32)StripAt->LedCount; for (u32 Step = 0; Step < StripAt->LedCount; Step++) @@ -111,25 +111,25 @@ static v4 TempAssemblyOffsets[] = { v4{0, 0, 0, 0}, v4{250, 0, 75, 0}, v4{-250, s32 TempAssemblyOffsetsCount = 3; internal void -LoadAssembly (assembly_array* Assemblies, led_system* LedSystem, memory_arena* Scratch, context Context, string Path, event_log* GlobalLog) +LoadAssembly (assembly_array* Assemblies, led_system* LedSystem, gs_memory_arena* Scratch, context Context, gs_const_string Path, event_log* GlobalLog) { - platform_memory_result AssemblyFile = ReadEntireFile(Context, Path); - if (AssemblyFile.Error == PlatformMemory_NoError && AssemblyFile.Data.Size > 0) + gs_file AssemblyFile = ReadEntireFile(Context.ThreadContext.FileHandler, Path); + if (FileNoError(AssemblyFile)) { - string AssemblyFileText = MakeString((char*)AssemblyFile.Data.Base); + gs_string AssemblyFileText = MakeString((char*)AssemblyFile.Memory); Assert(Assemblies->Count < Assemblies->CountMax); assembly* NewAssembly = &Assemblies->Values[Assemblies->Count++]; - s32 IndexOfLastSlash = FastLastIndexOfCharInCharArray(Path.Memory, Path.Length, '\\'); - string FileName = Substring(Path, IndexOfLastSlash + 1); + s32 IndexOfLastSlash = FindLast(Path, '\\'); + gs_const_string FileName = Substring(Path, IndexOfLastSlash + 1, Path.Length); - NewAssembly->Arena.PlatformMemory = Context.PlatformMemory; - if (ParseAssemblyFile(NewAssembly, AssemblyFileText, Scratch)) + NewAssembly->Arena = CreateMemoryArena(Context.ThreadContext.Allocator); + if (ParseAssemblyFile(NewAssembly, FileName, AssemblyFileText, Scratch)) { v4 Offset = v4{0,0,0,0}; //TempAssemblyOffsets[Assemblies->Count % TempAssemblyOffsetsCount]; ConstructAssemblyFromDefinition(NewAssembly, FileName, Offset, LedSystem); - PlatformFree(Context.PlatformMemory, AssemblyFile.Data.Base, AssemblyFile.Data.Size); + AllocatorFree(Context.ThreadContext.Allocator, AssemblyFile.Memory, AssemblyFile.Size); } else { diff --git a/src/app/foldhaus_assembly.h b/src/app/foldhaus_assembly.h index 97c153a..7b47451 100644 --- a/src/app/foldhaus_assembly.h +++ b/src/app/foldhaus_assembly.h @@ -25,7 +25,7 @@ struct led_buffer struct led_system { - platform_memory_handler PlatformMemory; + gs_allocator PlatformMemory; u32 BuffersCountMax; u32 BuffersCount; @@ -62,10 +62,10 @@ struct v2_strip struct assembly { - memory_arena Arena; + gs_memory_arena Arena; - string Name; - string FilePath; + gs_string Name; + gs_string FilePath; r32 Scale; s32 LedCountTotal; diff --git a/src/app/foldhaus_command_dispatch.h b/src/app/foldhaus_command_dispatch.h index 2a7fc1e..3b2d8aa 100644 --- a/src/app/foldhaus_command_dispatch.h +++ b/src/app/foldhaus_command_dispatch.h @@ -8,7 +8,7 @@ #define FOLDHAUS_INPUT_COMMAND_PROC(name) void name(app_state* State, input_entry Event, mouse_state Mouse) typedef FOLDHAUS_INPUT_COMMAND_PROC(input_command_proc); -// NOTE(Peter): Helper function so I don't have to remember the parameters to this define +// NOTE(Peter): Helper function so I don't have to remember the parameters to this define #define ExecFoldhausCommand(cmd) cmd(State, Event, Mouse) enum input_command_flags @@ -55,7 +55,7 @@ struct input_command_queue internal void InitializeInputCommandRegistry (input_command_registry* CommandRegistry, s32 Size, - memory_arena* Storage) + gs_memory_arena* Storage) { CommandRegistry->Commands = PushArray(Storage, input_command, Size); CommandRegistry->Size = Size; @@ -115,8 +115,8 @@ internal void RemoveCommandFromQueue(input_command_queue* Queue, s32 Index) { s32 CommandIndex = Index; - if (CommandIndex < Queue->Used) - { + if (CommandIndex < Queue->Used) + { Queue->Used -= 1; for (; CommandIndex < Queue->Used; CommandIndex++) @@ -132,9 +132,9 @@ RemoveCommandFromQueue(input_command_queue* Queue, input_command Command, input_ s32 CommandIndex = GetCommandIndexInQueue(Queue, Command, Event); // NOTE(Peter): If we made it through the queue without finding an event, there wasn't one - // to remove. This happens when we've changed command registries as a result of an input command, + // to remove. This happens when we've changed command registries as a result of an input command, // and the command exists in the new registry. - // For example: + // For example: // clicking a mouse button triggers a command to switch registries // the new registry tracks mouse drag (persist until release) // when the mouse is released, the event fires, but there is no mouse down event to remove diff --git a/src/app/foldhaus_debug.h b/src/app/foldhaus_debug.h index c987469..c45ad69 100644 --- a/src/app/foldhaus_debug.h +++ b/src/app/foldhaus_debug.h @@ -30,7 +30,7 @@ struct collated_scope_record struct scope_name { u32 Hash; - string Name; + gs_string Name; char Buffer[SCOPE_NAME_BUFFER_LENGTH]; }; @@ -82,7 +82,7 @@ typedef u8* debug_realloc(u8* Memory, s32 OldSize, s32 NewSize); struct debug_histogram_entry { char ScopeName_[SCOPE_NAME_LENGTH]; - string ScopeName; + gs_string ScopeName; u32 PerFrame_Cycles[HISTOGRAM_DEPTH]; u32 PerFrame_CallCount[HISTOGRAM_DEPTH]; @@ -168,12 +168,12 @@ StartDebugFrame(debug_frame* Frame, debug_services* Services) } internal void -InitDebugServices (debug_services* Services, - s64 PerformanceCountFrequency, - debug_alloc* Alloc, - debug_realloc* Realloc, - debug_timing_proc* GetWallClock, - debug_get_thread_id* GetThreadId, +InitDebugServices (debug_services* Services, + s64 PerformanceCountFrequency, + debug_alloc* Alloc, + debug_realloc* Realloc, + debug_timing_proc* GetWallClock, + debug_get_thread_id* GetThreadId, s32 ThreadCount) { Services->Alloc = Alloc; @@ -233,7 +233,7 @@ GetIndexForNameHash(debug_frame* Frame, u32 NameHash) } // NOTE(Peter): Its not technically wrong to return a -1 here, just means we didn't find it. - // At the time of writing however, this function is only being called in contexts where we + // At the time of writing however, this function is only being called in contexts where we // know there should be an entry in the Name table, so a -1 actually indicates a problem. Assert(Result >= 0); return Result; @@ -359,9 +359,9 @@ BeginTrackingScopeAndGetNameHash (debug_services* Services, char* ScopeName) if (Entry->Hash == 0) // If its new { Entry->Hash = NameHash; - // TODO(Peter): need to initialize all entry name strings to point at the buffer + // TODO(Peter): need to initialize all entry name gs_strings to point at the buffer // This will break eventually. when it does, do this ^^^^ when on startup - CopyCharArrayToString(ScopeName, &Entry->Name); + PrintF(&Entry->Name, "%s", ScopeName); } return NameHash; @@ -402,7 +402,7 @@ internal r32 DEBUGGetSecondsElapsed (s64 Start, s64 End, r32 PerformanceCountFre #define DEBUG_TRACK_FUNCTION scope_tracker ScopeTracker ((char*)__func__, GlobalDebugServices) #define DEBUG_TRACK_SCOPE(name) scope_tracker ScopeTracker_##name (#name, GlobalDebugServices) #else -#define DEBUG_TRACK_FUNCTION +#define DEBUG_TRACK_FUNCTION #define DEBUG_TRACK_SCOPE(name) #endif struct scope_tracker diff --git a/src/app/foldhaus_interface.cpp b/src/app/foldhaus_interface.cpp index f9345cb..e5e4e43 100644 --- a/src/app/foldhaus_interface.cpp +++ b/src/app/foldhaus_interface.cpp @@ -41,7 +41,7 @@ OPERATION_STATE_DEF(drag_panel_border_operation_state) // NOTE(Peter): InitialPanelBounds is the bounds of the panel we are modifying, // it stores the value calculated when the operation mode is kicked off. - rect InitialPanelBounds; + rect2 InitialPanelBounds; panel_split_direction PanelEdgeDirection; panel_edit_mode PanelEditMode; }; @@ -49,7 +49,7 @@ OPERATION_STATE_DEF(drag_panel_border_operation_state) OPERATION_RENDER_PROC(UpdateAndRenderDragPanelBorder) { drag_panel_border_operation_state* OpState = (drag_panel_border_operation_state*)Operation.OpStateMemory; - rect PanelBounds = OpState->InitialPanelBounds; + rect2 PanelBounds = OpState->InitialPanelBounds; if (OpState->PanelEditMode == PanelEdit_Modify) { @@ -72,10 +72,10 @@ OPERATION_RENDER_PROC(UpdateAndRenderDragPanelBorder) } else if (OpState->PanelEditMode == PanelEdit_Destroy) { - rect PanelToDeleteBounds = {}; + rect2 PanelToDeleteBounds = {}; if (OpState->PanelEdgeDirection == PanelSplit_Horizontal) { - r32 SplitY = GSLerp(PanelBounds.Min.y, PanelBounds.Max.y, OpState->Panel->SplitPercent); + r32 SplitY = LerpR32(OpState->Panel->SplitPercent, PanelBounds.Min.y, PanelBounds.Max.y); if (Mouse.Pos.y > SplitY) { PanelToDeleteBounds = GetTopPanelBounds(OpState->Panel, PanelBounds); @@ -87,7 +87,7 @@ OPERATION_RENDER_PROC(UpdateAndRenderDragPanelBorder) } else if (OpState->PanelEdgeDirection == PanelSplit_Vertical) { - r32 SplitX = GSLerp(PanelBounds.Min.x, PanelBounds.Max.x, OpState->Panel->SplitPercent); + r32 SplitX = LerpR32(OpState->Panel->SplitPercent, PanelBounds.Min.x, PanelBounds.Max.x); if (Mouse.Pos.x > SplitX) { PanelToDeleteBounds = GetRightPanelBounds(OpState->Panel, PanelBounds); @@ -106,7 +106,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndDragPanelBorderOperation) { drag_panel_border_operation_state* OpState = GetCurrentOperationState(State->Modes, drag_panel_border_operation_state); panel* Panel = OpState->Panel; - rect PanelBounds = OpState->InitialPanelBounds; + rect2 PanelBounds = OpState->InitialPanelBounds; if (OpState->PanelEditMode == PanelEdit_Modify) { @@ -123,7 +123,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndDragPanelBorderOperation) } else { - Panel->SplitPercent = (NewSplitY - PanelBounds.Min.y) / gs_Height(PanelBounds); + Panel->SplitPercent = (NewSplitY - PanelBounds.Min.y) / Rect2Height(PanelBounds); } } else if (Panel->SplitDirection == PanelSplit_Vertical) @@ -139,7 +139,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndDragPanelBorderOperation) } else { - Panel->SplitPercent = (NewSplitX - PanelBounds.Min.x) / gs_Width(PanelBounds); + Panel->SplitPercent = (NewSplitX - PanelBounds.Min.x) / Rect2Width(PanelBounds); } } } @@ -147,7 +147,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndDragPanelBorderOperation) { if (OpState->PanelEdgeDirection == PanelSplit_Horizontal) { - r32 SplitY = GSLerp(PanelBounds.Min.y, PanelBounds.Max.y, OpState->Panel->SplitPercent); + r32 SplitY = LerpR32(OpState->Panel->SplitPercent, PanelBounds.Min.y, PanelBounds.Max.y); if (Mouse.Pos.y > SplitY) { ConsolidatePanelsKeepOne(Panel, Panel->Bottom, &State->PanelSystem); @@ -159,7 +159,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndDragPanelBorderOperation) } else if (OpState->PanelEdgeDirection == PanelSplit_Vertical) { - r32 SplitX = GSLerp(PanelBounds.Min.x, PanelBounds.Max.x, OpState->Panel->SplitPercent); + r32 SplitX = LerpR32(OpState->Panel->SplitPercent, PanelBounds.Min.x, PanelBounds.Max.x); if (Mouse.Pos.x > SplitX) { ConsolidatePanelsKeepOne(Panel, Panel->Left, &State->PanelSystem); @@ -180,7 +180,7 @@ input_command DragPanelBorderCommands[] = { }; internal void -BeginDragPanelBorder(panel* Panel, panel_edit_mode PanelEditMode, rect PanelBounds, panel_split_direction PanelEdgeDirection, mouse_state Mouse, app_state* State) +BeginDragPanelBorder(panel* Panel, panel_edit_mode PanelEditMode, rect2 PanelBounds, panel_split_direction PanelEdgeDirection, mouse_state Mouse, app_state* State) { operation_mode* DragPanelBorder = ActivateOperationModeWithCommands(&State->Modes, DragPanelBorderCommands, UpdateAndRenderDragPanelBorder); drag_panel_border_operation_state* OpState = CreateOperationState(DragPanelBorder, &State->Modes, drag_panel_border_operation_state); @@ -202,17 +202,17 @@ OPERATION_STATE_DEF(split_panel_operation_state) // NOTE(Peter): InitialPanelBounds is the bounds of the panel we are modifying, // it stores the value calculated when the operation mode is kicked off. - rect InitialPanelBounds; + rect2 InitialPanelBounds; }; OPERATION_RENDER_PROC(UpdateAndRenderSplitPanel) { split_panel_operation_state* OpState = (split_panel_operation_state*)Operation.OpStateMemory; - rect PanelBounds = OpState->InitialPanelBounds; + rect2 PanelBounds = OpState->InitialPanelBounds; v4 EdgePreviewColor = v4{.3f, .3f, .3f, 1.f}; - r32 MouseDeltaX = GSAbs(Mouse.Pos.x - Mouse.DownPos.x); - r32 MouseDeltaY = GSAbs(Mouse.Pos.y - Mouse.DownPos.y); + r32 MouseDeltaX = Abs(Mouse.Pos.x - Mouse.DownPos.x); + r32 MouseDeltaY = Abs(Mouse.Pos.y - Mouse.DownPos.y); v2 EdgePreviewMin = {}; v2 EdgePreviewMax = {}; @@ -234,19 +234,19 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndSplitPanelOperation) { split_panel_operation_state* OpState = GetCurrentOperationState(State->Modes, split_panel_operation_state); panel* Panel = OpState->Panel; - rect PanelBounds = OpState->InitialPanelBounds; + rect2 PanelBounds = OpState->InitialPanelBounds; - r32 XDistance = GSAbs(Mouse.Pos.x - Mouse.DownPos.x); - r32 YDistance = GSAbs(Mouse.Pos.y - Mouse.DownPos.y); + r32 XDistance = Abs(Mouse.Pos.x - Mouse.DownPos.x); + r32 YDistance = Abs(Mouse.Pos.y - Mouse.DownPos.y); if (XDistance > YDistance) { - r32 XPercent = (Mouse.Pos.x - PanelBounds.Min.x) / gs_Width(PanelBounds); + r32 XPercent = (Mouse.Pos.x - PanelBounds.Min.x) / Rect2Width(PanelBounds); SplitPanelVertically(Panel, XPercent, &State->PanelSystem); } else { - r32 YPercent = (Mouse.Pos.y - PanelBounds.Min.y) / gs_Height(PanelBounds); + r32 YPercent = (Mouse.Pos.y - PanelBounds.Min.y) / Rect2Height(PanelBounds); SplitPanelHorizontally(Panel, YPercent, &State->PanelSystem); } @@ -264,7 +264,7 @@ input_command SplitPanelCommands[] = { }; internal void -BeginSplitPanelOperation(panel* Panel, rect PanelBounds, mouse_state Mouse, app_state* State) +BeginSplitPanelOperation(panel* Panel, rect2 PanelBounds, mouse_state Mouse, app_state* State) { operation_mode* SplitPanel = ActivateOperationModeWithCommands(&State->Modes, SplitPanelCommands, UpdateAndRenderSplitPanel); split_panel_operation_state* OpState = CreateOperationState(SplitPanel, &State->Modes, split_panel_operation_state); @@ -278,20 +278,22 @@ BeginSplitPanelOperation(panel* Panel, rect PanelBounds, mouse_state Mouse, app_ #define PANEL_EDGE_CLICK_MAX_DISTANCE 6 internal b32 -HandleMouseDownPanelInteractionOrRecurse(panel* Panel, panel_edit_mode PanelEditMode, rect PanelBounds, mouse_state Mouse, app_state* State) +HandleMouseDownPanelInteractionOrRecurse(panel* Panel, panel_edit_mode PanelEditMode, rect2 PanelBounds, mouse_state Mouse, app_state* State) { b32 HandledMouseInput = false; + rect2 PanelSplitButtonBounds = rect2{ PanelBounds.Min, PanelBounds.Min + v2{25, 25} }; + if (Panel->SplitDirection == PanelSplit_NoSplit - && PointIsInRange(Mouse.DownPos, PanelBounds.Min, PanelBounds.Min + v2{25, 25})) + && PointIsInRect(PanelSplitButtonBounds, Mouse.DownPos)) { BeginSplitPanelOperation(Panel, PanelBounds, Mouse, State); HandledMouseInput = true; } else if (Panel->SplitDirection == PanelSplit_Horizontal) { - r32 SplitY = GSLerp(PanelBounds.Min.y, PanelBounds.Max.y, Panel->SplitPercent); - r32 ClickDistanceFromSplit = GSAbs(Mouse.DownPos.y - SplitY); + r32 SplitY = LerpR32(Panel->SplitPercent, PanelBounds.Min.y, PanelBounds.Max.y); + r32 ClickDistanceFromSplit = Abs(Mouse.DownPos.y - SplitY); if (ClickDistanceFromSplit < PANEL_EDGE_CLICK_MAX_DISTANCE) { BeginDragPanelBorder(Panel, PanelEditMode, PanelBounds, PanelSplit_Horizontal, Mouse, State); @@ -299,13 +301,13 @@ HandleMouseDownPanelInteractionOrRecurse(panel* Panel, panel_edit_mode PanelEdit } else { - rect TopPanelBounds = GetTopPanelBounds(Panel, PanelBounds); - rect BottomPanelBounds = GetBottomPanelBounds(Panel, PanelBounds); - if (gs_PointIsInRect(Mouse.DownPos, BottomPanelBounds)) + rect2 TopPanelBounds = GetTopPanelBounds(Panel, PanelBounds); + rect2 BottomPanelBounds = GetBottomPanelBounds(Panel, PanelBounds); + if (PointIsInRect(BottomPanelBounds, Mouse.DownPos)) { HandleMouseDownPanelInteractionOrRecurse(&Panel->Bottom->Panel, PanelEditMode, BottomPanelBounds, Mouse, State); } - if (gs_PointIsInRect(Mouse.DownPos, TopPanelBounds)) + if (PointIsInRect(TopPanelBounds, Mouse.DownPos)) { HandleMouseDownPanelInteractionOrRecurse(&Panel->Top->Panel, PanelEditMode, TopPanelBounds, Mouse, State); } @@ -313,8 +315,8 @@ HandleMouseDownPanelInteractionOrRecurse(panel* Panel, panel_edit_mode PanelEdit } else if (Panel->SplitDirection == PanelSplit_Vertical) { - r32 SplitX = GSLerp(PanelBounds.Min.x, PanelBounds.Max.x, Panel->SplitPercent); - r32 ClickDistanceFromSplit = GSAbs(Mouse.DownPos.x - SplitX); + r32 SplitX = LerpR32(Panel->SplitPercent, PanelBounds.Min.x, PanelBounds.Max.x); + r32 ClickDistanceFromSplit = Abs(Mouse.DownPos.x - SplitX); if (ClickDistanceFromSplit < PANEL_EDGE_CLICK_MAX_DISTANCE) { BeginDragPanelBorder(Panel, PanelEditMode, PanelBounds, PanelSplit_Vertical, Mouse, State); @@ -322,13 +324,13 @@ HandleMouseDownPanelInteractionOrRecurse(panel* Panel, panel_edit_mode PanelEdit } else { - rect LeftPanelBounds = GetLeftPanelBounds(Panel, PanelBounds); - rect RightPanelBounds = GetRightPanelBounds(Panel, PanelBounds); - if (gs_PointIsInRect(Mouse.DownPos, LeftPanelBounds)) + rect2 LeftPanelBounds = GetLeftPanelBounds(Panel, PanelBounds); + rect2 RightPanelBounds = GetRightPanelBounds(Panel, PanelBounds); + if (PointIsInRect(LeftPanelBounds, Mouse.DownPos)) { HandleMouseDownPanelInteractionOrRecurse(&Panel->Left->Panel, PanelEditMode, LeftPanelBounds, Mouse, State); } - if (gs_PointIsInRect(Mouse.DownPos, RightPanelBounds)) + if (PointIsInRect(RightPanelBounds, Mouse.DownPos)) { HandleMouseDownPanelInteractionOrRecurse(&Panel->Right->Panel, PanelEditMode, RightPanelBounds, Mouse, State); } @@ -339,7 +341,7 @@ HandleMouseDownPanelInteractionOrRecurse(panel* Panel, panel_edit_mode PanelEdit } internal b32 -HandleMousePanelInteraction(panel_system* PanelSystem, rect WindowBounds, mouse_state Mouse, app_state* State) +HandleMousePanelInteraction(panel_system* PanelSystem, rect2 WindowBounds, mouse_state Mouse, app_state* State) { b32 HandledMouseInput = false; @@ -359,10 +361,10 @@ HandleMousePanelInteraction(panel_system* PanelSystem, rect WindowBounds, mouse_ internal void DrawPanelBorder(panel Panel, v2 PanelMin, v2 PanelMax, v4 Color, mouse_state* Mouse, render_command_buffer* RenderBuffer) { - r32 MouseLeftEdgeDistance = GSAbs(Mouse->Pos.x - PanelMin.x); - r32 MouseRightEdgeDistance = GSAbs(Mouse->Pos.x - PanelMax.x); - r32 MouseTopEdgeDistance = GSAbs(Mouse->Pos.y - PanelMax.y); - r32 MouseBottomEdgeDistance = GSAbs(Mouse->Pos.y - PanelMin.y); + r32 MouseLeftEdgeDistance = Abs(Mouse->Pos.x - PanelMin.x); + r32 MouseRightEdgeDistance = Abs(Mouse->Pos.x - PanelMax.x); + r32 MouseTopEdgeDistance = Abs(Mouse->Pos.y - PanelMax.y); + r32 MouseBottomEdgeDistance = Abs(Mouse->Pos.y - PanelMin.y); PushRenderBoundingBox2D(RenderBuffer, PanelMin, PanelMax, 1, Color); v4 HighlightColor = v4{.3f, .3f, .3f, 1.f}; @@ -398,41 +400,46 @@ DrawPanelBorder(panel Panel, v2 PanelMin, v2 PanelMax, v4 Color, mouse_state* Mo } internal void -DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect FooterBounds, mouse_state Mouse, app_state* State) +DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect2 FooterBounds, mouse_state Mouse, app_state* State) { PushRenderQuad2D(RenderBuffer, FooterBounds.Min, v2{FooterBounds.Max.x, FooterBounds.Min.y + 25}, v4{.5f, .5f, .5f, 1.f}); PushRenderQuad2D(RenderBuffer, FooterBounds.Min, FooterBounds.Min + v2{25, 25}, WhiteV4); - rect PanelSelectBtnBounds = gs_MakeRectMinWidth(FooterBounds.Min + v2{30, 1}, v2{100, 23}); + rect2 PanelSelectBtnBounds = MakeRect2MinDim(FooterBounds.Min + v2{30, 1}, v2{100, 23}); if (Panel->PanelSelectionMenuOpen) { - rect ButtonBounds = gs_MakeRectMinWidth(v2{ PanelSelectBtnBounds.Min.x, FooterBounds.Max.y }, v2{ 100, 25 }); + rect2 ButtonBounds = MakeRect2MinDim(v2{ PanelSelectBtnBounds.Min.x, FooterBounds.Max.y }, v2{ 100, 25 }); + + rect2 MenuBounds = rect2 + { + ButtonBounds.Min, + v2{ + ButtonBounds.Min.x + Rect2Width(ButtonBounds), ButtonBounds.Min.y + (Rect2Height(ButtonBounds) * GlobalPanelDefsCount) + }, + }; - v2 MenuMin = ButtonBounds.Min; - v2 MenuMax = v2{ButtonBounds.Min.x + gs_Width(ButtonBounds), ButtonBounds.Min.y + (gs_Height(ButtonBounds) * GlobalPanelDefsCount)}; if (MouseButtonTransitionedDown(Mouse.LeftButtonState) - && !PointIsInRange(Mouse.DownPos, MenuMin, MenuMax)) + && !PointIsInRect(MenuBounds, Mouse.DownPos)) { Panel->PanelSelectionMenuOpen = false; } - for (s32 i = 0; i < GlobalPanelDefsCount; i++) { panel_definition Def = GlobalPanelDefs[i]; - string DefName = MakeString(Def.PanelName, Def.PanelNameLength); + gs_string DefName = MakeString(Def.PanelName, Def.PanelNameLength); if (ui_Button(&State->Interface, DefName, ButtonBounds)) { SetPanelDefinition(Panel, i, State); Panel->PanelSelectionMenuOpen = false; } - ButtonBounds = gs_TranslateRectY(ButtonBounds, gs_Height(ButtonBounds)); + ButtonBounds = Rect2TranslateY(ButtonBounds, Rect2Height(ButtonBounds)); } } - if (ui_Button(&State->Interface, MakeStringLiteral("Select"), PanelSelectBtnBounds)) + if (ui_Button(&State->Interface, MakeString("Select"), PanelSelectBtnBounds)) { Panel->PanelSelectionMenuOpen = !Panel->PanelSelectionMenuOpen; } @@ -440,15 +447,15 @@ DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect FooterBo } internal void -RenderPanel(panel* Panel, rect PanelBounds, rect WindowBounds, render_command_buffer* RenderBuffer, app_state* State, context Context, mouse_state Mouse) +RenderPanel(panel* Panel, rect2 PanelBounds, rect2 WindowBounds, render_command_buffer* RenderBuffer, app_state* State, context Context, mouse_state Mouse) { Assert(Panel->PanelDefinitionIndex >= 0); - rect FooterBounds = rect{ + rect2 FooterBounds = rect2{ PanelBounds.Min, v2{PanelBounds.Max.x, PanelBounds.Min.y + 25}, }; - rect PanelViewBounds = rect{ + rect2 PanelViewBounds = rect2{ v2{PanelBounds.Min.x, FooterBounds.Max.y}, PanelBounds.Max, }; @@ -456,7 +463,7 @@ RenderPanel(panel* Panel, rect PanelBounds, rect WindowBounds, render_command_bu panel_definition Definition = GlobalPanelDefs[Panel->PanelDefinitionIndex]; Definition.Render(*Panel, PanelViewBounds, RenderBuffer, State, Context); - PushRenderOrthographic(RenderBuffer, WindowBounds.Min.x, WindowBounds.Min.y, WindowBounds.Max.x, WindowBounds.Max.y); + PushRenderOrthographic(RenderBuffer, WindowBounds); DrawPanelFooter(Panel, RenderBuffer, FooterBounds, Mouse, State); } @@ -467,12 +474,12 @@ DrawAllPanels(panel_layout PanelLayout, render_command_buffer* RenderBuffer, mou { panel_with_layout PanelWithLayout = PanelLayout.Panels[i]; panel* Panel = PanelWithLayout.Panel; - rect PanelBounds = PanelWithLayout.Bounds; + rect2 PanelBounds = PanelWithLayout.Bounds; RenderPanel(Panel, PanelBounds, State->WindowBounds, RenderBuffer, State, Context, *Mouse); v4 BorderColor = v4{0, 0, 0, 1}; - PushRenderOrthographic(RenderBuffer, State->WindowBounds.Min.x, State->WindowBounds.Min.y, State->WindowBounds.Max.x, State->WindowBounds.Max.y); + PushRenderOrthographic(RenderBuffer, State->WindowBounds); DrawPanelBorder(*Panel, PanelBounds.Min, PanelBounds.Max, BorderColor, Mouse, RenderBuffer); } } diff --git a/src/app/foldhaus_log.h b/src/app/foldhaus_log.h index 12ed933..0cffd1a 100644 --- a/src/app/foldhaus_log.h +++ b/src/app/foldhaus_log.h @@ -13,7 +13,7 @@ enum log_entry_type struct log_entry { - string Message; + gs_string Message; log_entry_type Type; }; @@ -25,11 +25,11 @@ struct event_log u32 NextEntry; }; -#define LogMessage(_Log, _Message) PushLogEntry(_Log, MakeStringLiteral(_Message), LogEntry_Message) -#define LogError(_Log, _Message) PushLogEntry(_Log, MakeStringLiteral(_Message), LogEntry_Error) +#define LogMessage(_Log, _Message) PushLogEntry(_Log, MakeString(_Message), LogEntry_Message) +#define LogError(_Log, _Message) PushLogEntry(_Log, MakeString(_Message), LogEntry_Error) internal void -PushLogEntry(event_log* Log, string Message, log_entry_type Type) +PushLogEntry(event_log* Log, gs_string Message, log_entry_type Type) { u32 NewLogIndex = Log->NextEntry++; if (Log->NextEntry >= LOG_ENTRIES_MAX) diff --git a/src/app/foldhaus_node.cpp b/src/app/foldhaus_node.cpp index 29e93a9..092d55f 100644 --- a/src/app/foldhaus_node.cpp +++ b/src/app/foldhaus_node.cpp @@ -45,7 +45,7 @@ SortNodeNeighbors(u32 ContiguousNodeIndex, gs_list_handle NodeHandle, adjacency_ u32 ContiguousNeighborNodeIndex = SparseToContiguousNodeMap[Neighbor->NodeHandle.Index]; if (!NodesVisited[ContiguousNeighborNodeIndex]) { - SortedNodesCount = SortNodeNeighbors(ContiguousNeighborNodeIndex, Neighbor->NodeHandle, NeighborsLists, NodesVisited, SortedNodeHandles, SortedNodesCount, SparseToContiguousNodeMap); + SortedNodesCount = SortNodeNeighbors(ContiguousNeighborNodeIndex, Neighbor->NodeHandle, NeighborsLists, NodesVisited, SortedNodeHandles, SortedNodesCount, SparseToContiguousNodeMap); } Neighbor = Neighbor->Next; } @@ -55,7 +55,7 @@ SortNodeNeighbors(u32 ContiguousNodeIndex, gs_list_handle NodeHandle, adjacency_ } internal s32* -CreateSparseToContiguousMap (pattern_node_workspace Workspace, memory_arena* Scratch) +CreateSparseToContiguousMap (pattern_node_workspace Workspace, gs_memory_arena* Scratch) { s32* Result = PushArray(Scratch, s32, Workspace.Nodes.OnePastLastUsed); s32 ContiguousIndex = 0; @@ -71,7 +71,7 @@ CreateSparseToContiguousMap (pattern_node_workspace Workspace, memory_arena* Scr } internal void -UpdateSortedNodes(pattern_node_workspace* Workspace, memory_arena* Scratch) +UpdateSortedNodes(pattern_node_workspace* Workspace, gs_memory_arena* Scratch) { ClearNodeWorkspaceStorage(Workspace); @@ -81,7 +81,7 @@ UpdateSortedNodes(pattern_node_workspace* Workspace, memory_arena* Scratch) s32* SparseToContiguousNodeMap = CreateSparseToContiguousMap(*Workspace, &Workspace->Storage); // NOTE(Peter): We need to sort this later on so I'm just storing list lengths in this format - // to begin with. + // to begin with. // NeighborsListLengths[n].Radix = the number of neighbors for the node // NeighborsListLengths[n].ID = the sparse array index of the node gs_radix_entry* NeighborsListLengths = PushArray(Scratch, gs_radix_entry, NodeCount); @@ -119,24 +119,24 @@ UpdateSortedNodes(pattern_node_workspace* Workspace, memory_arena* Scratch) RadixSortInPlace(NeighborsListLengths, Workspace->Nodes.Used); char* OutputCharArray = PushArray(Scratch, char, 1024); - string OutputString = MakeString(OutputCharArray, 0, 1024); + gs_string Outputgs_string = MakeString(OutputCharArray, 0, 1024); - PrintF(&OutputString, "Neighbors Lists: \n"); + PrintF(&Outputgs_string, "Neighbors Lists: \n"); for (u32 d = 0; d < Workspace->Nodes.Used; d++) { - PrintF(&OutputString, " %d: Node [ %d ] : neighbors { ", d, NeighborsListLengths[d].ID); + PrintF(&Outputgs_string, " %d: Node [ %d ] : neighbors { ", d, NeighborsListLengths[d].ID); adjacency_list* Neighbors = NeighborsLists[d]; while (Neighbors) { - PrintF(&OutputString, "%d, ", Neighbors->NodeHandle.Index); + PrintF(&Outputgs_string, "%d, ", Neighbors->NodeHandle.Index); Neighbors = Neighbors->Next; } - PrintF(&OutputString, " }\n"); + PrintF(&Outputgs_string, " }\n"); } - NullTerminate(&OutputString); + NullTerminate(&Outputgs_string); - // This is a contiguous array. + // This is a contiguous array. b8* NodesVisited = PushArray(Scratch, b8, NodeCount); GSZeroArray(NodesVisited, b8, NodeCount); @@ -163,7 +163,7 @@ UpdateSortedNodes(pattern_node_workspace* Workspace, memory_arena* Scratch) } internal void -PushNodeOnWorkspace(s32 NodeSpecificationIndex, pattern_node_workspace* Workspace, memory_arena* Scratch) +PushNodeOnWorkspace(s32 NodeSpecificationIndex, pattern_node_workspace* Workspace, gs_memory_arena* Scratch) { pattern_node* NewNode = Workspace->Nodes.TakeElement(); NewNode->SpecificationIndex = NodeSpecificationIndex; @@ -172,13 +172,13 @@ PushNodeOnWorkspace(s32 NodeSpecificationIndex, pattern_node_workspace* Workspac } internal void -PushNodeConnectionOnWorkspace(gs_list_handle UpstreamNodeHandle, u32 UpstreamPortIndex, gs_list_handle DownstreamNodeHandle, u32 DownstreamPortIndex, pattern_node_workspace* Workspace, memory_arena* Scratch) +PushNodeConnectionOnWorkspace(gs_list_handle UpstreamNodeHandle, u32 UpstreamPortIndex, gs_list_handle DownstreamNodeHandle, u32 DownstreamPortIndex, pattern_node_workspace* Workspace, gs_memory_arena* Scratch) { pattern_node_connection Connection = {}; - Connection.UpstreamNodeHandle = UpstreamNodeHandle; - Connection.DownstreamNodeHandle = DownstreamNodeHandle; - Connection.UpstreamPortIndex = UpstreamPortIndex; - Connection.DownstreamPortIndex = DownstreamPortIndex; + Connection.UpstreamNodeHandle = UpstreamNodeHandle; + Connection.DownstreamNodeHandle = DownstreamNodeHandle; + Connection.UpstreamPortIndex = UpstreamPortIndex; + Connection.DownstreamPortIndex = DownstreamPortIndex; Workspace->Connections.PushElementOnBucket(Connection); UpdateSortedNodes(Workspace, Scratch); diff --git a/src/app/foldhaus_node.h b/src/app/foldhaus_node.h index 17a6c7b..b286b28 100644 --- a/src/app/foldhaus_node.h +++ b/src/app/foldhaus_node.h @@ -59,7 +59,7 @@ struct node_specification struct node_specification_ { node_type Type; - string Identifier; + gs_string Identifier; gsm_struct_type DataType; }; @@ -92,7 +92,7 @@ struct pattern_node_workspace // This is storage for all the structures which follow. // It is cleared when new nodes are added so that the // acceleration structures can be recalculated - memory_arena Storage; + gs_memory_arena Storage; s32* SparseToSortedNodeMap; gs_list_handle* SortedNodeHandles; }; diff --git a/src/app/foldhaus_operation_mode.h b/src/app/foldhaus_operation_mode.h index 49d71bd..80c1641 100644 --- a/src/app/foldhaus_operation_mode.h +++ b/src/app/foldhaus_operation_mode.h @@ -16,6 +16,7 @@ struct operation_mode { input_command_registry Commands; operation_render_proc* Render; + gs_memory_cursor Memory; u8* OpStateMemory; }; @@ -24,28 +25,66 @@ struct operation_mode_system { s32 ActiveModesCount; operation_mode ActiveModes[OPERATION_MODES_MAX]; - arena_snapshot ModeMemorySnapshots[OPERATION_MODES_MAX]; + //arena_snapshot ModeMemorySnapshots[OPERATION_MODES_MAX]; + gs_data_array ModeMemoryPagesFreeList; // NOTE(Peter): This acts as mode scoped memory. When a mode gets activated, it can allocate // temporary memory which then gets freed when the mode is deactivated - memory_arena Arena; + gs_memory_arena Arena; }; +internal operation_mode_system +OperationModeSystemInit(gs_memory_arena* Storage, gs_thread_context ThreadContext) +{ + operation_mode_system Result = {0}; + // TODO(Peter): Do we really need an arena? Can this just operate in constant memory footprint? + Result.Arena.Allocator = ThreadContext.Allocator; + + Result.ModeMemoryPagesFreeList.CountMax = 16; // TODO(Peter): Static number of modes that can be active simultaneously + Result.ModeMemoryPagesFreeList.Data = PushArray(Storage, gs_data, Result.ModeMemoryPagesFreeList.CountMax); + for (u32 Page = 0; Page < Result.ModeMemoryPagesFreeList.CountMax; Page++) + { + // TODO(Peter): 4k pages = page size on windows + Result.ModeMemoryPagesFreeList.Data[Page] = PushSizeToData(Storage, KB(4)); + } + Result.ModeMemoryPagesFreeList.Count = Result.ModeMemoryPagesFreeList.CountMax; + + return Result; +} + +internal gs_data +OperationModeTakeMemoryPage(operation_mode_system* System) +{ + Assert(System->ModeMemoryPagesFreeList.Count > 0); + gs_data Result = {0}; + System->ModeMemoryPagesFreeList.Count -= 1; + u64 LastIndex = System->ModeMemoryPagesFreeList.Count; + Result = System->ModeMemoryPagesFreeList.Data[LastIndex]; + return Result; +} + +internal void +OperationModeFreeMemoryPage(operation_mode_system* System, gs_data Data) +{ + Assert(System->ModeMemoryPagesFreeList.Count < System->ModeMemoryPagesFreeList.CountMax); + u64 LastIndex = System->ModeMemoryPagesFreeList.Count; + System->ModeMemoryPagesFreeList.Count += 1; + System->ModeMemoryPagesFreeList.Data[LastIndex] = Data; +} + internal operation_mode* ActivateOperationMode (operation_mode_system* System, operation_render_proc* RenderProc) { - operation_mode* Result = 0; - Assert(System->ActiveModesCount < OPERATION_MODES_MAX); + operation_mode* Result = 0; s32 ModeIndex = System->ActiveModesCount++; - System->ModeMemorySnapshots[ModeIndex] = TakeSnapshotOfArena(&System->Arena); - - operation_mode NewMode = {}; - System->ActiveModes[ModeIndex] = NewMode; + //System->ModeMemorySnapshots[ModeIndex] = TakeSnapshotOfArena(&System->Arena); Result = &System->ActiveModes[ModeIndex]; + Result->Memory = CreateMemoryCursor(OperationModeTakeMemoryPage(System)); Result->Render = RenderProc; + return Result; } @@ -57,13 +96,18 @@ ActivateOperationModeWithCommands_(operation_mode_system* System, input_command* { operation_mode* NewMode = ActivateOperationMode(System, RenderProc); +#if 0 InitializeInputCommandRegistry(&NewMode->Commands, CommandsCount, &System->Arena); for (s32 i = 0; i < CommandsCount; i++) { input_command Command = Commands[i]; RegisterKeyPressCommand(&NewMode->Commands, Command.Key, Command.Flags, Command.Mdfr, Command.Proc); } - +#else + NewMode->Commands.Commands = Commands; + NewMode->Commands.Size = CommandsCount; + NewMode->Commands.Used = CommandsCount; +#endif return NewMode; } @@ -72,7 +116,8 @@ DeactivateCurrentOperationMode (operation_mode_system* System) { Assert(System->ActiveModesCount > 0); s32 ModeIndex = --System->ActiveModesCount; - ClearArenaToSnapshot(&System->Arena, System->ModeMemorySnapshots[ModeIndex]); + OperationModeFreeMemoryPage(System, System->ActiveModes[ModeIndex].Memory.Data); + //ClearArenaToSnapshot(&System->Arena, System->ModeMemorySnapshots[ModeIndex]); } #define CreateOperationState(mode, modeSystem, stateType) \ @@ -85,8 +130,12 @@ DeactivateCurrentOperationMode (operation_mode_system* System) internal u8* CreateOperationState_ (operation_mode* Mode, operation_mode_system* System, s32 StateSize) { - Mode->OpStateMemory = PushSize(&System->Arena, StateSize); - return Mode->OpStateMemory; + // NOTE(Peter): This isn't a problem if this fires, it just means our page size is too small, + // and its time to make the pages dynamically sized + Assert(Mode->Memory.Data.Size >= StateSize); + u8* Result = PushSizeOnCursor(&Mode->Memory, StateSize).Memory; + Mode->OpStateMemory = Result; + return Result; } diff --git a/src/app/foldhaus_panel.h b/src/app/foldhaus_panel.h index 2929c8b..53415f1 100644 --- a/src/app/foldhaus_panel.h +++ b/src/app/foldhaus_panel.h @@ -72,7 +72,7 @@ struct panel_system struct panel_with_layout { panel* Panel; - rect Bounds; + rect2 Bounds; }; struct panel_layout @@ -205,56 +205,56 @@ ConsolidatePanelsKeepOne(panel* Parent, panel_entry* PanelEntryToKeep, panel_sys // ///////////////////////////////// -internal rect -GetTopPanelBounds(panel* Panel, rect PanelBounds) +internal rect2 +GetTopPanelBounds(panel* Panel, rect2 PanelBounds) { - rect Result = {}; + rect2 Result = {}; Result.Min = v2{ PanelBounds.Min.x, - GSLerp(PanelBounds.Min.y, PanelBounds.Max.y, Panel->SplitPercent) + LerpR32(Panel->SplitPercent, PanelBounds.Min.y, PanelBounds.Max.y) }; Result.Max = PanelBounds.Max; return Result; } -internal rect -GetBottomPanelBounds(panel* Panel, rect PanelBounds) +internal rect2 +GetBottomPanelBounds(panel* Panel, rect2 PanelBounds) { - rect Result = {}; + rect2 Result = {}; Result.Min = PanelBounds.Min; Result.Max = v2{ PanelBounds.Max.x, - GSLerp(PanelBounds.Min.y, PanelBounds.Max.y, Panel->SplitPercent) + LerpR32(Panel->SplitPercent, PanelBounds.Min.y, PanelBounds.Max.y) }; return Result; } -internal rect -GetRightPanelBounds(panel* Panel, rect PanelBounds) +internal rect2 +GetRightPanelBounds(panel* Panel, rect2 PanelBounds) { - rect Result = {}; + rect2 Result = {}; Result.Min = v2{ - GSLerp(PanelBounds.Min.x, PanelBounds.Max.x, Panel->SplitPercent), + LerpR32(Panel->SplitPercent, PanelBounds.Min.x, PanelBounds.Max.x), PanelBounds.Min.y }; Result.Max = PanelBounds.Max; return Result; } -internal rect -GetLeftPanelBounds(panel* Panel, rect PanelBounds) +internal rect2 +GetLeftPanelBounds(panel* Panel, rect2 PanelBounds) { - rect Result = {}; + rect2 Result = {}; Result.Min = PanelBounds.Min; Result.Max = v2{ - GSLerp(PanelBounds.Min.x, PanelBounds.Max.x, Panel->SplitPercent), + LerpR32(Panel->SplitPercent, PanelBounds.Min.x, PanelBounds.Max.x), PanelBounds.Max.y }; return Result; } internal void -LayoutPanel(panel* Panel, rect PanelBounds, panel_layout* Layout) +LayoutPanel(panel* Panel, rect2 PanelBounds, panel_layout* Layout) { if (Panel->SplitDirection == PanelSplit_NoSplit) { @@ -264,22 +264,22 @@ LayoutPanel(panel* Panel, rect PanelBounds, panel_layout* Layout) } else if (Panel->SplitDirection == PanelSplit_Horizontal) { - rect TopPanelBounds = GetTopPanelBounds(Panel, PanelBounds); - rect BottomPanelBounds = GetBottomPanelBounds(Panel, PanelBounds); + rect2 TopPanelBounds = GetTopPanelBounds(Panel, PanelBounds); + rect2 BottomPanelBounds = GetBottomPanelBounds(Panel, PanelBounds); LayoutPanel(&Panel->Top->Panel, TopPanelBounds, Layout); LayoutPanel(&Panel->Bottom->Panel, BottomPanelBounds, Layout); } else if (Panel->SplitDirection == PanelSplit_Vertical) { - rect LeftPanelBounds = GetLeftPanelBounds(Panel, PanelBounds); - rect RightPanelBounds = GetRightPanelBounds(Panel, PanelBounds); + rect2 LeftPanelBounds = GetLeftPanelBounds(Panel, PanelBounds); + rect2 RightPanelBounds = GetRightPanelBounds(Panel, PanelBounds); LayoutPanel(&Panel->Left->Panel, LeftPanelBounds, Layout); LayoutPanel(&Panel->Right->Panel, RightPanelBounds, Layout); } } internal panel_layout -GetPanelLayout(panel_system* System, rect WindowBounds, memory_arena* Storage) +GetPanelLayout(panel_system* System, rect2 WindowBounds, gs_memory_arena* Storage) { panel_layout Result = {}; Result.PanelsMax = System->PanelsUsed; @@ -293,11 +293,11 @@ GetPanelLayout(panel_system* System, rect WindowBounds, memory_arena* Storage) struct panel_and_bounds { panel* Panel; - rect Bounds; + rect2 Bounds; }; internal panel_and_bounds -GetPanelContainingPoint(v2 Point, panel* Panel, rect PanelBounds) +GetPanelContainingPoint(v2 Point, panel* Panel, rect2 PanelBounds) { panel_and_bounds Result = {0}; @@ -308,28 +308,28 @@ GetPanelContainingPoint(v2 Point, panel* Panel, rect PanelBounds) } else if (Panel->SplitDirection == PanelSplit_Horizontal) { - rect TopPanelBounds = GetTopPanelBounds(Panel, PanelBounds); - rect BottomPanelBounds = GetBottomPanelBounds(Panel, PanelBounds); + rect2 TopPanelBounds = GetTopPanelBounds(Panel, PanelBounds); + rect2 BottomPanelBounds = GetBottomPanelBounds(Panel, PanelBounds); - if (PointIsInRange(Point, TopPanelBounds.Min, TopPanelBounds.Max)) + if (PointIsInRect(TopPanelBounds, Point)) { Result = GetPanelContainingPoint(Point, &Panel->Top->Panel, TopPanelBounds); } - else if (PointIsInRange(Point, BottomPanelBounds.Min, BottomPanelBounds.Max)) + else if (PointIsInRect(BottomPanelBounds, Point)) { Result = GetPanelContainingPoint(Point, &Panel->Bottom->Panel, BottomPanelBounds); } } else if (Panel->SplitDirection == PanelSplit_Vertical) { - rect LeftPanelBounds = GetLeftPanelBounds(Panel, PanelBounds); - rect RightPanelBounds = GetRightPanelBounds(Panel, PanelBounds); + rect2 LeftPanelBounds = GetLeftPanelBounds(Panel, PanelBounds); + rect2 RightPanelBounds = GetRightPanelBounds(Panel, PanelBounds); - if (PointIsInRange(Point, LeftPanelBounds.Min, LeftPanelBounds.Max)) + if (PointIsInRect(LeftPanelBounds, Point)) { Result = GetPanelContainingPoint(Point, &Panel->Left->Panel, LeftPanelBounds); } - else if (PointIsInRange(Point, RightPanelBounds.Min, RightPanelBounds.Max)) + else if (PointIsInRect(RightPanelBounds, Point)) { Result = GetPanelContainingPoint(Point, &Panel->Right->Panel, RightPanelBounds); } @@ -339,7 +339,7 @@ GetPanelContainingPoint(v2 Point, panel* Panel, rect PanelBounds) } internal panel_and_bounds -GetPanelContainingPoint(v2 Point, panel_system* PanelSystem, rect WindowBounds) +GetPanelContainingPoint(v2 Point, panel_system* PanelSystem, rect2 WindowBounds) { panel_and_bounds Result = {0}; if (PanelSystem->PanelsUsed > 0) diff --git a/src/app/foldhaus_platform.h b/src/app/foldhaus_platform.h index f8f801c..4f066d4 100644 --- a/src/app/foldhaus_platform.h +++ b/src/app/foldhaus_platform.h @@ -7,22 +7,30 @@ #include -#define GS_LANGUAGE_NO_PROFILER_DEFINES -#include "..\gs_libs\gs_language.h" +#include // TODO Remove -#include "..\gs_libs\gs_radix_sort.h" +#include "..\gs_libs\gs_types.h" +#include "..\gs_libs\gs_types.cpp" + +//#define GS_LANGUAGE_NO_PROFILER_DEFINES +//#include "..\gs_libs\gs_language.h" + + +//#include "..\gs_libs\gs_radix_sort.h" #include "..\gs_libs\gs_list.h" #include "..\gs_libs\gs_bucket.h" -#define GS_MEMORY_TRACK_ALLOCATIONS -#include "..\gs_libs\gs_memory_arena.h" +//#define GS_MEMORY_TRACK_ALLOCATIONS +//#include "..\gs_libs\gs_memory_arena.h" #include "..\gs_libs\gs_string.h" -#include "foldhaus_debug.h" -global_variable debug_services* GlobalDebugServices; -#include "..\gs_libs\gs_vector_matrix.h" + +#include "foldhaus_debug.h" +global debug_services* GlobalDebugServices; + +//#include "..\gs_libs\gs_vector_matrix.h" #include "..\gs_libs\gs_input.h" #include "foldhaus_renderer.h" @@ -75,15 +83,6 @@ struct platform_memory_result platform_memory_error Error; }; -struct texture_buffer -{ - u8* Memory; - s32 Width; - s32 Height; - s32 Pitch; - s32 BytesPerPixel; -}; - struct system_path { char* Path; @@ -91,20 +90,13 @@ struct system_path s32 IndexOfLastSlash; }; -#define PLATFORM_READ_ENTIRE_FILE(name) platform_memory_result name(string Path) -typedef PLATFORM_READ_ENTIRE_FILE(platform_read_entire_file); - -#define PLATFORM_WRITE_ENTIRE_FILE(name) b32 name(string Path, u8* Contents, s32 Size) -typedef PLATFORM_WRITE_ENTIRE_FILE(platform_write_entire_file); - -#define PLATFORM_GET_FILE_PATH(name) b32 name(string* PathBuffer, const char* FilterStrings) -typedef PLATFORM_GET_FILE_PATH(platform_get_file_path); - -struct platform_file_handler +struct texture_buffer { - platform_read_entire_file* ReadEntireFile; - platform_write_entire_file* WriteEntireFile; - platform_get_file_path* GetFilePath; + u8* Memory; + s32 Width; + s32 Height; + s32 Pitch; + s32 BytesPerPixel; }; #define PLATFORM_GET_GPU_TEXTURE_HANDLE(name) s32 name(u8* Memory, s32 Width, s32 Height) @@ -169,50 +161,11 @@ typedef DRAW_FONT_CODEPOINT(platform_draw_font_codepoint); #define PLATFORM_THREAD_COUNT 4 -#define THREADED_WORK_PROC(name) void name(s32 ThreadID, void* Data) -typedef THREADED_WORK_PROC(threaded_work_proc); - -typedef struct work_queue work_queue; - -#define PUSH_WORK_ON_QUEUE(name) void name(work_queue* Queue, threaded_work_proc* WorkProc, void* Data, char* JobName) -typedef PUSH_WORK_ON_QUEUE(push_work_on_queue); - -#define DO_QUEUE_WORK_UNTIL_DONE(name) void name(work_queue* Queue, s32 ThreadID) -typedef DO_QUEUE_WORK_UNTIL_DONE(do_queue_work_until_done); - -#define RESET_WORK_QUEUE(name) void name(work_queue* Queue) -typedef RESET_WORK_QUEUE(reset_work_queue); - -struct worker_thread_job -{ - void* Data; - threaded_work_proc* WorkProc; -#ifdef DEBUG - char* JobName; -#endif -}; - -struct work_queue -{ - void* SemaphoreHandle; - - u32 JobsMax; - u32 volatile JobsCount; - u32 volatile NextJobIndex; - u32 volatile JobsCompleted; - worker_thread_job* Jobs; - - // Work Queue - push_work_on_queue* PushWorkOnQueue; - do_queue_work_until_done* DoQueueWorkUntilDone; - reset_work_queue* ResetWorkQueue; -}; - RESET_WORK_QUEUE(ResetWorkQueue) { for (u32 i = 0; i < Queue->JobsMax; i++) { - Queue->Jobs[i].Data = 0; + Queue->Jobs[i].Data = {0}; Queue->Jobs[i].WorkProc = 0; } @@ -232,11 +185,13 @@ GetSecondsElapsed (s64 Start, s64 End, s64 PerformanceCountFrequency) struct context { + gs_thread_context ThreadContext; + u8* MemoryBase; u32 MemorySize; b32 WindowIsVisible; - rect WindowBounds; + rect2 WindowBounds; r32 DeltaTime; mouse_state Mouse; @@ -247,59 +202,18 @@ struct context cleanup_application* CleanupApplication; // Platform Services - work_queue* GeneralWorkQueue; + gs_work_queue* GeneralWorkQueue; - platform_memory_handler PlatformMemory; - platform_file_handler FileHandler; - - platform_write_entire_file* PlatformWriteEntireFile; - platform_get_file_path* PlatformGetFilePath; platform_get_gpu_texture_handle* PlatformGetGPUTextureHandle; platform_get_font_info* PlatformGetFontInfo; platform_draw_font_codepoint* PlatformDrawFontCodepoint; + platform_get_socket_handle* PlatformGetSocketHandle; platform_set_socket_option* PlatformSetSocketOption; platform_send_to* PlatformSendTo; platform_close_socket* PlatformCloseSocket; }; -// File Handler -internal platform_memory_result -ReadEntireFile(platform_file_handler FileHandler, string Path) -{ - platform_memory_result Result = FileHandler.ReadEntireFile(Path); - return Result; -} -internal platform_memory_result -ReadEntireFile(context Context, string Path) -{ - return ReadEntireFile(Context.FileHandler, Path); -} - -internal b32 -WriteEntireFile(platform_file_handler FileHandler, string Path, u8* Contents, u32 Size) -{ - b32 Result = FileHandler.WriteEntireFile(Path, Contents, Size); - return Result; -} -internal b32 -WriteEntireFile(context Context, string Path, u8* Contents, u32 Size) -{ - return WriteEntireFile(Context.FileHandler, Path, Contents, Size); -} - -internal b32 -GetFilePath(platform_file_handler FileHandler, string* PathBuffer, char* FilterStrings) -{ - b32 Result = FileHandler.GetFilePath(PathBuffer, (const char*)FilterStrings); - return Result; -} -internal b32 -GetFilePath(context Context, string* PathBuffer, char* FilterStrings) -{ - return GetFilePath(Context.FileHandler, PathBuffer, FilterStrings); -} - #define FOLDHAUS_PLATFORM_H #endif // FOLDHAUS_PLATFORM_H \ No newline at end of file diff --git a/src/app/foldhaus_renderer.cpp b/src/app/foldhaus_renderer.cpp index 7988e3e..ece4ee7 100644 --- a/src/app/foldhaus_renderer.cpp +++ b/src/app/foldhaus_renderer.cpp @@ -64,7 +64,7 @@ Render2DQuadBatch (u8* CommandData, s32 QuadCount) v2 P1 = Vertecies[BATCH_2D_VERTEX_INDEX(Quad, Tri, 1)]; v2 P2 = Vertecies[BATCH_2D_VERTEX_INDEX(Quad, Tri, 2)]; v2 UV0 = UVs[BATCH_2D_UV_INDEX(Quad, Tri, 0)]; - v2 UV1 = UVs[BATCH_2D_UV_INDEX(Quad, Tri, 1)]; + v2 UV1 = UVs[BATCH_2D_UV_INDEX(Quad, Tri, 1)]; v2 UV2 = UVs[BATCH_2D_UV_INDEX(Quad, Tri, 2)]; v4 C0 = Colors[BATCH_2D_COLOR_INDEX(Quad, Tri, 0)]; v4 C1 = Colors[BATCH_2D_COLOR_INDEX(Quad, Tri, 1)]; @@ -107,11 +107,11 @@ RenderCommandBuffer (render_command_buffer CommandBuffer) render_command_set_render_mode* Command = (render_command_set_render_mode*)(CommandHeader + 1); - glViewport(Command->ViewOffsetX, Command->ViewOffsetY, + glViewport(Command->ViewOffsetX, Command->ViewOffsetY, Command->ViewWidth, Command->ViewHeight); - LoadModelView(Command->ModelView.E); - LoadProjection(Command->Projection.E); + LoadModelView(Command->ModelView.Array); + LoadProjection(Command->Projection.Array); if (Command->UseDepthBuffer) { diff --git a/src/app/foldhaus_renderer.h b/src/app/foldhaus_renderer.h index facfb22..d563cf8 100644 --- a/src/app/foldhaus_renderer.h +++ b/src/app/foldhaus_renderer.h @@ -19,65 +19,71 @@ struct camera inline m44 GetCameraModelViewMatrix (camera Camera) { -#if 0 - // Forward - v4 CamForward = V4(Normalize(Camera.Position - Camera.LookAt), 0); - // Right - v4 CamRight = Normalize(Cross(v4{0, 1, 0, 0}, CamForward)); - // Up - v4 CamUp = Normalize(Cross(CamForward, CamRight)); - - r32 X = Camera.Position.x; - r32 Y = Camera.Position.y; - r32 Z = Camera.Position.z; - - m44 RotationMatrix = M44( - CamRight.x, CamUp.x, CamForward.x, 0, - CamRight.y, CamUp.y, CamForward.y, 0, - CamRight.z, CamUp.z, CamForward.z, 0, - 0, 0, 0, 1); - - m44 PositionMatrix = M44( - 1, 0, 0, 0, - 0, 1, 0, 0, - 0, 0, 1, 0, - -X, -Y, -Z, 1 - ); -#else - m44 RotationMatrix = GetLookAtMatrix(V4(Camera.Position, 1), V4(Camera.LookAt, 1)); - m44 PositionMatrix = GetPositionM44(V4(Camera.Position, 1)); -#endif - - m44 ModelViewMatrix = PositionMatrix * RotationMatrix; - + m44 RotationMatrix = M44LookAt(ToV4Point(Camera.Position), ToV4Point(Camera.LookAt)); + m44 PositionMatrix = M44Translation(ToV4Point(-Camera.Position)); + m44 ModelViewMatrix = RotationMatrix * PositionMatrix; return ModelViewMatrix; } inline m44 GetCameraPerspectiveProjectionMatrix(camera Camera) { - r32 Top = Camera.Near * GSTan((Camera.FieldOfView / 2.0f)); - r32 Bottom = -Top; - r32 Right = Top * Camera.AspectRatio; - r32 Left = -Right; + m44 Result = M44ProjectionPerspective(Camera.FieldOfView, Camera.AspectRatio, Camera.Near, Camera.Far); + return Result; +} + +internal m44 +GetCameraMatrix(camera Camera) +{ + m44 ModelView = GetCameraModelViewMatrix(Camera); + m44 Projection = GetCameraPerspectiveProjectionMatrix(Camera); + m44 Result = Projection * ModelView; + return Result; +} + +internal v2 +ProjectWorldPointToScreen(v4 WorldSpacePoint, camera Camera, rect2 WindowBounds) +{ + v2 WindowExtents = v2{Rect2Width(WindowBounds), Rect2Height(WindowBounds)}; + v4 ProjectedPosition = GetCameraMatrix(Camera) * WorldSpacePoint; + ProjectedPosition.xyz /= ProjectedPosition.w; + v2 ScreenPosition = V2MultiplyPairwise(ProjectedPosition.xy, (WindowExtents / 2)) + (WindowExtents / 2); - r32 A = ((Right + Left) / (Right - Left)); - r32 B = ((Top + Bottom) / (Top - Bottom)); - r32 C = -((Camera.Far + Camera.Near) / (Camera.Far - Camera.Near)); - r32 D = -((2 * Camera.Far * Camera.Near) / (Camera.Far - Camera.Near)); + return ScreenPosition; +} + +internal v4_ray +ProjectScreenPointToWorldRay(v2 ScreenPoint, camera Camera, rect2 WindowBounds) +{ + v4_ray Result = {0}; - r32 E = ((2 * Camera.Near) / (Right - Left)); - r32 F = ((2 * Camera.Near) / (Top - Bottom)); + r32 TanFOVOverTwo = TanR32(DegToRadR32(Camera.FieldOfView / 2.0f)); + r32 Aspect = RectAspectRatio(WindowBounds); - m44 PerspectiveProjectionMatrix = - { - E, 0, A, 0, - 0, F, B, 0, - 0, 0, C, D, - 0, 0, -1, 0 - }; + r32 NormalizedX = ScreenPoint.x / Rect2Width(WindowBounds); + r32 NormalizedY = ScreenPoint.y / Rect2Height(WindowBounds); - return PerspectiveProjectionMatrix; + r32 CenteredX = (2.0f * NormalizedX) - 1.0f; + r32 CenteredY = (2.0f * NormalizedY) - 1.0f; + + r32 ScaledX = CenteredX * Aspect; + r32 ScaledY = CenteredY; + + r32 CameraX = ScaledX * TanFOVOverTwo; + r32 CameraY = ScaledY * TanFOVOverTwo; + + r32 Near = Camera.Near; + r32 Far = Camera.Far; + v3 MousePointOnNearPlane = v3{CameraX, CameraY, -1} * Near; + v3 MousePointOnFarPlane = v3{CameraX, CameraY, -1} * Far; + + v4 MouseRayDirection = ToV4Vec(V3Normalize(MousePointOnFarPlane - MousePointOnNearPlane)); + m44 CameraTransform = M44Transpose(M44LookAt(ToV4Point(Camera.Position), ToV4Point(Camera.LookAt))); + + Result.Origin = ToV4Point(Camera.Position); + Result.Direction = CameraTransform * MouseRayDirection; + + return Result; } // Render Commands @@ -200,7 +206,7 @@ struct render_command_set_render_mode typedef u8* renderer_realloc(u8* Base, s32 CurrentSize, s32 NewSize); -#define COMMAND_BUFFER_MIN_GROW_SIZE Megabytes(2) +#define COMMAND_BUFFER_MIN_GROW_SIZE MB(2) struct render_command_buffer { @@ -257,7 +263,7 @@ ResizeBufferIfNecessary(render_command_buffer* Buffer, s32 DataSize) // NewSize = Buffer->CommandMemorySize + (2 * DataSize); s32 SpaceAvailable = Buffer->CommandMemorySize - Buffer->CommandMemoryUsed; s32 SpaceNeeded = DataSize - SpaceAvailable; // This is known to be positive at this point - s32 AdditionSize = GSMax(SpaceNeeded, COMMAND_BUFFER_MIN_GROW_SIZE); + s32 AdditionSize = Max(SpaceNeeded, COMMAND_BUFFER_MIN_GROW_SIZE); s32 NewSize = Buffer->CommandMemorySize + AdditionSize; Buffer->CommandMemory = Buffer->Realloc(Buffer->CommandMemory, Buffer->CommandMemorySize, @@ -285,7 +291,7 @@ PushQuad3DBatch (render_command_buffer* Buffer, render_quad_batch_constructor* C internal s32 PushQuad2DBatch (render_command_buffer* Buffer, render_quad_batch_constructor* Constructor, s32 QuadCount, s32 DataSize, u8* MemStart) { - GSZeroMemory(MemStart, DataSize); + ZeroMemoryBlock(MemStart, DataSize); Constructor->Max = QuadCount; Constructor->Count = 0; @@ -316,6 +322,15 @@ struct quad_batch_constructor_reserved_range s32 OnePastLast; }; +internal quad_batch_constructor_reserved_range +ReserveRangeInQuadConstructor(render_quad_batch_constructor* Constructor, s32 TrisNeeded) +{ + quad_batch_constructor_reserved_range Result = {}; + Result.OnePastLast = Constructor->Count + TrisNeeded; + Result.Start = Result.OnePastLast - TrisNeeded; + return Result; +} + internal quad_batch_constructor_reserved_range ThreadSafeReserveRangeInQuadConstructor(render_quad_batch_constructor* Constructor, s32 TrisNeeded) { @@ -331,6 +346,8 @@ SetTri3DInBatch (render_quad_batch_constructor* Constructor, s32 TriIndex, v2 UV0, v2 UV1, v2 UV2, v4 C0, v4 C1, v4 C2) { + //Assert(P0.w != 0 && P1.w != 0 && P2.w != 0); // Passing vectors, rather than positions. Will draw wrong + // Vertecies Constructor->Vertecies[BATCH_3D_VERTEX_INDEX(TriIndex, 0)] = P0; Constructor->Vertecies[BATCH_3D_VERTEX_INDEX(TriIndex, 1)] = P1; @@ -355,6 +372,7 @@ PushTri3DOnBatch (render_quad_batch_constructor* Constructor, v4 C0, v4 C1, v4 C2) { DEBUG_TRACK_FUNCTION; + // TODO(Peter): I think we avoid doing cross thread filling of a batch so do we need this? s32 Tri = ThreadSafeIncrementQuadConstructorCount(Constructor); SetTri3DInBatch(Constructor, Tri, P0, P1, P2, UV0, UV1, UV2, C0, C1, C2); }; @@ -362,7 +380,7 @@ PushTri3DOnBatch (render_quad_batch_constructor* Constructor, internal void PushQuad3DOnBatch (render_quad_batch_constructor* Constructor, v4 P0, v4 P1, v4 P2, v4 P3, v2 UVMin, v2 UVMax, v4 Color) { - Assert(Constructor->Count + 2 < Constructor->Max); + Assert(Constructor->Count + 2 <= Constructor->Max); PushTri3DOnBatch(Constructor, P0, P1, P2, UVMin, v2{UVMax.x, UVMin.y}, UVMax, Color, Color, Color); PushTri3DOnBatch(Constructor, P0, P2, P3, UVMin, UVMax, v2{UVMin.x, UVMax.y}, Color, Color, Color); } @@ -373,7 +391,7 @@ PushQuad3DOnBatch (render_quad_batch_constructor* Constructor, v2 UV0, v2 UV1, v2 UV2, v2 UV3, v4 C0, v4 C1, v4 C2, v4 C3) { - Assert(Constructor->Count < Constructor->Max); + Assert(Constructor->Count <= Constructor->Max); PushTri3DOnBatch(Constructor, P0, P1, P2, UV0, UV1, UV2, C0, C1, C2); PushTri3DOnBatch(Constructor, P0, P2, P3, UV0, UV2, UV3, C0, C2, C3); } @@ -472,7 +490,7 @@ internal void PushLine2DOnBatch (render_quad_batch_constructor* Constructor, v2 P0, v2 P1, r32 Thickness, v4 Color) { r32 HalfThickness = Thickness / 2.0f; - v2 Perpendicular = Normalize(PerpendicularCCW(P1 - P0)) * HalfThickness; + v2 Perpendicular = V2Normalize(V2PerpendicularCCW(P1 - P0)) * HalfThickness; PushQuad2DOnBatch(Constructor, P0 - Perpendicular, P1 - Perpendicular, P1 + Perpendicular, P0 + Perpendicular, v2{0, 0}, v2{1, 1}, Color); @@ -501,8 +519,8 @@ PushRenderPerspective (render_command_buffer* Buffer, s32 OffsetX, s32 OffsetY, { render_command_set_render_mode* Command = PushRenderCommand(Buffer, render_command_set_render_mode); - Command->ModelView = GetCameraModelViewMatrix(Camera); - Command->Projection = GetCameraPerspectiveProjectionMatrix(Camera); + Command->ModelView = M44Transpose(GetCameraModelViewMatrix(Camera)); + Command->Projection = M44Transpose(GetCameraPerspectiveProjectionMatrix(Camera)); Command->ViewOffsetX = (r32)OffsetX; Command->ViewOffsetY = (r32)OffsetY; @@ -514,25 +532,18 @@ PushRenderPerspective (render_command_buffer* Buffer, s32 OffsetX, s32 OffsetY, return Command; } +internal void +PushRenderPerspective(render_command_buffer* Buffer, rect2 Viewport, camera Camera) +{ + PushRenderPerspective(Buffer, Viewport.Min.x, Viewport.Min.y, Rect2Width(Viewport), Rect2Height(Viewport), Camera); +} + internal void PushRenderOrthographic (render_command_buffer* Buffer, s32 OffsetX, s32 OffsetY, s32 ViewWidth, s32 ViewHeight) { render_command_set_render_mode* Command = PushRenderCommand(Buffer, render_command_set_render_mode); - Command->ModelView = m44{ - 1, 0, 0, 0, - 0, 1, 0, 0, - 0, 0, 1, 0, - 0, 0, 0, 1 - }; - - r32 a = 2.0f / ViewWidth; - r32 b = 2.0f / ViewHeight; - Command->Projection = m44{ - a, 0, 0, 0, - 0, b, 0, 0, - 0, 0, 1, 0, - -1, -1, 0, 1 - }; + Command->ModelView = M44Identity(); + Command->Projection = M44ProjectionOrtho((r32)ViewWidth, (r32)ViewHeight, 0, 100, ViewWidth, 0, ViewHeight, 0); Command->ViewOffsetX = (r32)OffsetX; Command->ViewOffsetY = (r32)OffsetY; @@ -542,6 +553,12 @@ PushRenderOrthographic (render_command_buffer* Buffer, s32 OffsetX, s32 OffsetY, Command->UseDepthBuffer = false;; } +internal void +PushRenderOrthographic(render_command_buffer* Buffer, rect2 Viewport) +{ + PushRenderOrthographic(Buffer, Viewport.Min.x, Viewport.Min.y, Rect2Width(Viewport), Rect2Height(Viewport)); +} + internal void PushRenderClearScreen (render_command_buffer* Buffer) { @@ -571,6 +588,13 @@ PushRenderQuad2D (render_command_buffer* Buffer, v2 Min, v2 Max, v4 Color) PushQuad2DOnBatch(&Batch, Min, Max, Color); } +internal void +PushRenderQuad2D(render_command_buffer* Buffer, v2 P0, v2 P1, v2 P2, v2 P3, v4 Color) +{ + render_quad_batch_constructor Batch = PushRenderQuad2DBatch(Buffer, 1); + PushQuad2DOnBatch(&Batch, P0, P1, P2, P3, v2{0,0}, v2{1,1}, Color); +} + internal void PushRenderLine2D (render_command_buffer* Buffer, v2 P0, v2 P1, r32 Thickness, v4 Color) { diff --git a/src/app/foldhaus_util_radialumia_file_converter.cpp b/src/app/foldhaus_util_radialumia_file_converter.cpp index 32945dd..d03074f 100644 --- a/src/app/foldhaus_util_radialumia_file_converter.cpp +++ b/src/app/foldhaus_util_radialumia_file_converter.cpp @@ -10,42 +10,42 @@ #include #include -#include +#include #include "gs/gs_language.h" #include "gs/gs_string.h" #include "../meta/gs_meta_lexer.h" #include "gs/gs_vector.h" -#define STRING_BUFFER_SIZE 512 -struct string_buffer +#define gs_string_BUFFER_SIZE 512 +struct gs_string_buffer { char* Memory; s32 Size; - string_buffer* Next; + gs_string_buffer* Next; }; -struct string_writer +struct gs_string_writer { char* Cursor; - s32 UsedInString; - string_buffer* Buffer; + s32 UsedIngs_string; + gs_string_buffer* Buffer; }; -internal string_buffer* -GrowStringBuffer (string_buffer* Buffer) +internal gs_string_buffer* +Growgs_stringBuffer (gs_string_buffer* Buffer) { - string_buffer* Result; + gs_string_buffer* Result; if (Buffer->Next) { - Result = GrowStringBuffer(Buffer->Next); + Result = Growgs_stringBuffer(Buffer->Next); } else { - Result = (string_buffer*)malloc(sizeof(string_buffer)); - Result->Memory = (char*)malloc(sizeof(char) * STRING_BUFFER_SIZE); - memset(Result->Memory, 0, STRING_BUFFER_SIZE); - Result->Size = STRING_BUFFER_SIZE; + Result = (gs_string_buffer*)malloc(sizeof(gs_string_buffer)); + Result->Memory = (char*)malloc(sizeof(char) * gs_string_BUFFER_SIZE); + memset(Result->Memory, 0, gs_string_BUFFER_SIZE); + Result->Size = gs_string_BUFFER_SIZE; Result->Next = 0; Buffer->Next = Result; @@ -54,28 +54,28 @@ GrowStringBuffer (string_buffer* Buffer) } internal void -WriteString(string_writer* Writer, char* String, s32 Length) +Writegs_string(gs_string_writer* Writer, char* gs_string, s32 Length) { - char* Src = String; + char* Src = gs_string; char* Dst = Writer->Cursor; s32 LengthWritten = 0; - while (*Src && Writer->UsedInString < Writer->Buffer->Size &&LengthWritten < Length) + while (*Src && Writer->UsedIngs_string < Writer->Buffer->Size &&LengthWritten < Length) { LengthWritten++; *Dst++ = *Src++; - Writer->UsedInString++; + Writer->UsedIngs_string++; } Writer->Cursor = Dst; - if (*Src && Writer->UsedInString == Writer->Buffer->Size) + if (*Src && Writer->UsedIngs_string == Writer->Buffer->Size) { *(Dst - 1) = 0; // Null terminate the buffer - Writer->Buffer = GrowStringBuffer(Writer->Buffer); + Writer->Buffer = Growgs_stringBuffer(Writer->Buffer); Writer->Cursor = Writer->Buffer->Memory; - Writer->UsedInString = 0; - WriteString(Writer, (Src - 1), (Length - LengthWritten) + 1); + Writer->UsedIngs_string = 0; + Writegs_string(Writer, (Src - 1), (Length - LengthWritten) + 1); } } @@ -141,15 +141,15 @@ int main(int ArgCount, char* Args[]) control_box_pairs* StartPair = NextControlBoxPair; s32 PairsCount = 0; - if (StringsEqual(Tokenizer.At, "EOF")) + if (gs_stringsEqual(Tokenizer.At, "EOF")) { break; } EatToCharacterInclusive(&Tokenizer, '{'); EatWhitespace(&Tokenizer); - Assert(StringsEqual(Tokenizer.At, "neighbors: [")); - Tokenizer.At += StringLength("neighbors: ["); + Assert(gs_stringsEqual(Tokenizer.At, "neighbors: [")); + Tokenizer.At += gs_stringLength("neighbors: ["); // Parse Neighbors while(*Tokenizer.At && *Tokenizer.At != ']') @@ -177,8 +177,8 @@ int main(int ArgCount, char* Args[]) EatWhitespace(&Tokenizer); //Parse IP - Assert(StringsEqual(Tokenizer.At, "ip: ")); - Tokenizer.At += StringLength("ip: "); + Assert(gs_stringsEqual(Tokenizer.At, "ip: ")); + Tokenizer.At += gs_stringLength("ip: "); NextControlBox->Address = (char*)malloc(sizeof(char) * 13); memcpy(NextControlBox->Address, Tokenizer.At, 13); Tokenizer.At += 13; @@ -186,27 +186,27 @@ int main(int ArgCount, char* Args[]) // Parse X EatWhitespace(&Tokenizer); - Assert(StringsEqual(Tokenizer.At, "x: ")); - Tokenizer.At += StringLength("x: "); + Assert(gs_stringsEqual(Tokenizer.At, "x: ")); + Tokenizer.At += gs_stringLength("x: "); NextControlBox->X = ParseFloat(Tokenizer.At); EatToCharacterInclusive(&Tokenizer, ';'); // Parse Y EatWhitespace(&Tokenizer); - Assert(StringsEqual(Tokenizer.At, "y: ")); - Tokenizer.At += StringLength("y: "); + Assert(gs_stringsEqual(Tokenizer.At, "y: ")); + Tokenizer.At += gs_stringLength("y: "); NextControlBox->Y = ParseFloat(Tokenizer.At); EatToCharacterInclusive(&Tokenizer, ';'); // Parse Z EatWhitespace(&Tokenizer); - Assert(StringsEqual(Tokenizer.At, "z: ")); - Tokenizer.At += StringLength("z: "); + Assert(gs_stringsEqual(Tokenizer.At, "z: ")); + Tokenizer.At += gs_stringLength("z: "); NextControlBox->Z = ParseFloat(Tokenizer.At); EatToCharacterInclusive(&Tokenizer, ';'); // Parse ID EatWhitespace(&Tokenizer); - Assert(StringsEqual(Tokenizer.At, "id: ")); - Tokenizer.At += StringLength("id: "); + Assert(gs_stringsEqual(Tokenizer.At, "id: ")); + Tokenizer.At += gs_stringLength("id: "); NextControlBox->ID = ParseSignedInt(Tokenizer.At); EatToCharacterInclusive(&Tokenizer, ';'); @@ -278,36 +278,36 @@ int main(int ArgCount, char* Args[]) } - string_buffer OutputFileBuffer = {}; - OutputFileBuffer.Memory = (char*)malloc(sizeof(char) * STRING_BUFFER_SIZE); - OutputFileBuffer.Size = STRING_BUFFER_SIZE; + gs_string_buffer OutputFileBuffer = {}; + OutputFileBuffer.Memory = (char*)malloc(sizeof(char) * gs_string_BUFFER_SIZE); + OutputFileBuffer.Size = gs_string_BUFFER_SIZE; OutputFileBuffer.Next = 0; - string_writer RefWriter = {}; + gs_string_writer RefWriter = {}; RefWriter.Cursor = OutputFileBuffer.Memory; - RefWriter.UsedInString = 0; + RefWriter.UsedIngs_string = 0; RefWriter.Buffer = &OutputFileBuffer; - string_writer* Writer = &RefWriter; + gs_string_writer* Writer = &RefWriter; - char StringBuffer[512]; + char gs_stringBuffer[512]; s32 Len = 0; - Len = sprintf_s(StringBuffer, 512, "control_box_count %d\n", ControlBoxesUsed); - WriteString(Writer, StringBuffer, Len); - Len = sprintf_s(StringBuffer, 512, "led_strip_count %d\n\n", ControlBoxPairsUsed); - WriteString(Writer, StringBuffer, Len); + Len = sprintf_s(gs_stringBuffer, 512, "control_box_count %d\n", ControlBoxesUsed); + Writegs_string(Writer, gs_stringBuffer, Len); + Len = sprintf_s(gs_stringBuffer, 512, "led_strip_count %d\n\n", ControlBoxPairsUsed); + Writegs_string(Writer, gs_stringBuffer, Len); for (s32 c = 0; c < ControlBoxesUsed; c++) { control_box* Box = ControlBoxes + c; - Len = sprintf_s(StringBuffer, 512, + Len = sprintf_s(gs_stringBuffer, 512, "control_box { %d, \"%s\", (%f, %f, %f) }\n", Box->ID, Box->Address, Box->X, Box->Y, Box->Z); - WriteString(Writer, StringBuffer, Len); + Writegs_string(Writer, gs_stringBuffer, Len); } - WriteString(Writer, "\n", 1); + Writegs_string(Writer, "\n", 1); #define UNIVERSES_PER_BOX 25 s32 UniversesPerBox[64]; @@ -316,7 +316,7 @@ int main(int ArgCount, char* Args[]) UniversesPerBox[u] = UNIVERSES_PER_BOX * u; } - char LEDStripFormatString[] = "led_strip { %d, %d, %d, INTERPOLATE_POINTS, (%f, %f, %f), (%f, %f, %f), 144 } \n"; + char LEDStripFormatgs_string[] = "led_strip { %d, %d, %d, INTERPOLATE_POINTS, (%f, %f, %f), (%f, %f, %f), 144 } \n"; for (s32 s = 0; s < ControlBoxPairsUsed; s++) { control_box_pairs* Pair = ControlBoxPairs + s; @@ -332,15 +332,15 @@ int main(int ArgCount, char* Args[]) r32 EndY = ControlBoxes[Pair->End].Y; r32 EndZ = ControlBoxes[Pair->End].Z; - Len = sprintf_s(StringBuffer, 512, - LEDStripFormatString, + Len = sprintf_s(gs_stringBuffer, 512, + LEDStripFormatgs_string, Pair->Start, Universe, 0, StartX, StartY, StartZ, EndX, EndY, EndZ); - WriteString(Writer, StringBuffer, Len); + Writegs_string(Writer, gs_stringBuffer, Len); } - WriteString(Writer, "\n", 1); + Writegs_string(Writer, "\n", 1); for (s32 sp = 0; sp < ExtraStripsUsed; sp++) { @@ -349,20 +349,20 @@ int main(int ArgCount, char* Args[]) s32 Universe = UniversesPerBox[Strip->BoxID]; UniversesPerBox[Strip->BoxID]++; - Len = sprintf_s(StringBuffer, 512, - LEDStripFormatString, + Len = sprintf_s(gs_stringBuffer, 512, + LEDStripFormatgs_string, Strip->BoxID, Universe, 0, Strip->Start.x, Strip->Start.y, Strip->Start.z, Strip->End.x, Strip->End.y, Strip->End.z); - WriteString(Writer, StringBuffer, Len); + Writegs_string(Writer, gs_stringBuffer, Len); } - WriteString(Writer, "END_OF_ASSEMBLY_FILE", StringLength("END_OF_ASSEMBLY_FILE")); + Writegs_string(Writer, "END_OF_ASSEMBLY_FILE", gs_stringLength("END_OF_ASSEMBLY_FILE")); *Writer->Cursor = 0; FILE* OutputFile = fopen("F:/data/radialumia.fold", "w"); - string_buffer* BufferCursor = &OutputFileBuffer; + gs_string_buffer* BufferCursor = &OutputFileBuffer; while(BufferCursor) { fprintf(OutputFile, BufferCursor->Memory); diff --git a/src/app/generated/foldhaus_panels_generated.h b/src/app/generated/foldhaus_panels_generated.h index 48610ca..67ca2a3 100644 --- a/src/app/generated/foldhaus_panels_generated.h +++ b/src/app/generated/foldhaus_panels_generated.h @@ -1,19 +1,18 @@ enum panel_type { -PanelType_FileView, -PanelType_SculptureView, -PanelType_AnimationTimeline, -PanelType_DMXView, -PanelType_HierarchyView, -PanelType_NodeGraph, -PanelType_ProfilerView, + PanelType_FileView, + PanelType_SculptureView, + PanelType_AnimationTimeline, + PanelType_DMXView, + PanelType_HierarchyView, + PanelType_NodeGraph, + PanelType_ProfilerView, }; -global_variable s32 GlobalPanelDefsCount = 7; -global_variable panel_definition GlobalPanelDefs[] = { -{ "File View", 9, FileView_Init, FileView_Cleanup, FileView_Render, FileView_Commands, FileView_CommandsCount }, -{ "Sculpture View", 14, SculptureView_Init, SculptureView_Cleanup, SculptureView_Render, SculptureView_Commands, SculptureView_CommandsCount }, -{ "Animation Timeline", 18, AnimationTimeline_Init, AnimationTimeline_Cleanup, AnimationTimeline_Render, AnimationTimeline_Commands, AnimationTimeline_CommandsCount }, -{ "Dmx View", 8, DMXView_Init, DMXView_Cleanup, DMXView_Render, DMXView_Commands, DMXView_CommandsCount }, -{ "Hierarchy", 9, HierarchyView_Init, HierarchyView_Cleanup, HierarchyView_Render, HierarchyView_Commands, HierarchyView_CommandsCount }, -{ "Node Graph", 10, NodeGraph_Init, NodeGraph_Cleanup, NodeGraph_Render, NodeGraph_Commands, NodeGraph_CommandsCount }, -{ "Profiler", 8, ProfilerView_Init, ProfilerView_Cleanup, ProfilerView_Render, ProfilerView_Commands, ProfilerView_CommandsCount }, +global s32 GlobalPanelDefsCount = 6; +global panel_definition GlobalPanelDefs[] = { + { "File View", 9, FileView_Init, FileView_Cleanup, FileView_Render, FileView_Commands, FileView_CommandsCount }, + { "Sculpture View", 14, SculptureView_Init, SculptureView_Cleanup, SculptureView_Render, SculptureView_Commands, SculptureView_CommandsCount }, + { "Animation Timeline", 18, AnimationTimeline_Init, AnimationTimeline_Cleanup, AnimationTimeline_Render, AnimationTimeline_Commands, AnimationTimeline_CommandsCount }, + { "Dmx View", 8, DMXView_Init, DMXView_Cleanup, DMXView_Render, DMXView_Commands, DMXView_CommandsCount }, + { "Hierarchy", 9, HierarchyView_Init, HierarchyView_Cleanup, HierarchyView_Render, HierarchyView_Commands, HierarchyView_CommandsCount }, + { "Profiler", 8, ProfilerView_Init, ProfilerView_Cleanup, ProfilerView_Render, ProfilerView_Commands, ProfilerView_CommandsCount }, }; diff --git a/src/app/generated/gs_meta_generated_typeinfo.h b/src/app/generated/gs_meta_generated_typeinfo.h index fd1d779..9477f54 100644 --- a/src/app/generated/gs_meta_generated_typeinfo.h +++ b/src/app/generated/gs_meta_generated_typeinfo.h @@ -1,40 +1,41 @@ enum gsm_meta_tag_type { -MetaTag_panel_type_file_view, -MetaTag_panel_type_node_graph, -MetaTag_node_output, -MetaTag_node_struct, -MetaTag_panel_cleanup, -MetaTag_node_input, -MetaTag_panel_init, -MetaTag_panel_type_animation_timeline, -MetaTag_panel_commands, -MetaTag_panel_type_sculpture_view, -MetaTag_node_proc, -MetaTag_panel_type_hierarchy, -MetaTag_panel_type_profiler, -MetaTag_panel_render, -MetaTag_panel_type_dmx_view, + MetaTag_panel_type_file_view, + MetaTag_panel_type_node_graph, + MetaTag_node_output, + MetaTag_node_struct, + MetaTag_panel_cleanup, + MetaTag_node_input, + MetaTag_panel_init, + MetaTag_panel_type_animation_timeline, + MetaTag_panel_commands, + MetaTag_panel_type_sculpture_view, + MetaTag_node_proc, + MetaTag_panel_type_hierarchy, + MetaTag_panel_type_profiler, + MetaTag_panel_render, + MetaTag_panel_type_dmx_view, }; -gsm_meta_tag MetaTagStrings[] = { -{ "panel_type_file_view", 20 }, -{ "panel_type_node_graph", 21 }, -{ "node_output", 11 }, -{ "node_struct", 11 }, -{ "panel_cleanup", 13 }, -{ "node_input", 10 }, -{ "panel_init", 10 }, -{ "panel_type_animation_timeline", 29 }, -{ "panel_commands", 14 }, -{ "panel_type_sculpture_view", 25 }, -{ "node_proc", 9 }, -{ "panel_type_hierarchy", 20 }, -{ "panel_type_profiler", 19 }, -{ "panel_render", 12 }, -{ "panel_type_dmx_view", 19 }, +gsm_meta_tag MetaTaggs_strings[] = { + { "panel_type_file_view", 20 }, + { "panel_type_node_graph", 21 }, + { "node_output", 11 }, + { "node_struct", 11 }, + { "panel_cleanup", 13 }, + { "node_input", 10 }, + { "panel_init", 10 }, + { "panel_type_animation_timeline", 29 }, + { "panel_commands", 14 }, + { "panel_type_sculpture_view", 25 }, + { "node_proc", 9 }, + { "panel_type_hierarchy", 20 }, + { "panel_type_profiler", 19 }, + { "panel_render", 12 }, + { "panel_type_dmx_view", 19 }, }; enum gsm_struct_type { + gsm_StructType_r32, gsm_StructType_solid_color_data, gsm_StructType_v4, gsm_StructType_float, @@ -42,85 +43,68 @@ enum gsm_struct_type gsm_StructType_pixel, gsm_StructType_u8, gsm_StructType_s32, - gsm_StructType_sin_wave_data, - gsm_StructType_r32, gsm_StructType_revolving_discs_data, gsm_StructType_vertical_color_fade_data, - gsm_StructType_multiply_patterns_data, gsm_StructType_Count, }; static gsm_struct_member_type_info StructMembers_v4[] = { -{ "x", 1, (u64)&((v4*)0)->x, {}, 0}, -{ "y", 1, (u64)&((v4*)0)->y, {}, 0}, -{ "z", 1, (u64)&((v4*)0)->z, {}, 0}, -{ "w", 1, (u64)&((v4*)0)->w, {}, 0}, -{ "r", 1, (u64)&((v4*)0)->r, {}, 0}, -{ "g", 1, (u64)&((v4*)0)->g, {}, 0}, -{ "b", 1, (u64)&((v4*)0)->b, {}, 0}, -{ "a", 1, (u64)&((v4*)0)->a, {}, 0}, -{ "xy", 2, (u64)&((v4*)0)->xy, {}, 0}, -{ "yz", 2, (u64)&((v4*)0)->yz, {}, 0}, -{ "xyz", 3, (u64)&((v4*)0)->xyz, {}, 0}, -{ "z", 1, (u64)&((v4*)0)->z, {}, 0}, -{ "E", 1, (u64)&((v4*)0)->E, {}, 0}, + { "x", 1, (u64)&((v4*)0)->x, {}, 0}, + { "y", 1, (u64)&((v4*)0)->y, {}, 0}, + { "z", 1, (u64)&((v4*)0)->z, {}, 0}, + { "w", 1, (u64)&((v4*)0)->w, {}, 0}, + { "r", 1, (u64)&((v4*)0)->r, {}, 0}, + { "g", 1, (u64)&((v4*)0)->g, {}, 0}, + { "b", 1, (u64)&((v4*)0)->b, {}, 0}, + { "a", 1, (u64)&((v4*)0)->a, {}, 0}, + { "xy", 2, (u64)&((v4*)0)->xy, {}, 0}, + { "yz", 2, (u64)&((v4*)0)->yz, {}, 0}, + { "xyz", 3, (u64)&((v4*)0)->xyz, {}, 0}, + { "z", 1, (u64)&((v4*)0)->z, {}, 0}, + { "E", 1, (u64)&((v4*)0)->E, {}, 0}, }; static gsm_struct_member_type_info StructMembers_pixel[] = { -{ "R", 1, (u64)&((pixel*)0)->R, {}, 0}, -{ "G", 1, (u64)&((pixel*)0)->G, {}, 0}, -{ "B", 1, (u64)&((pixel*)0)->B, {}, 0}, -{ "Channels", 8, (u64)&((pixel*)0)->Channels, {}, 0}, + { "R", 1, (u64)&((pixel*)0)->R, {}, 0}, + { "G", 1, (u64)&((pixel*)0)->G, {}, 0}, + { "B", 1, (u64)&((pixel*)0)->B, {}, 0}, + { "Channels", 8, (u64)&((pixel*)0)->Channels, {}, 0}, }; static gsm_struct_member_type_info StructMembers_color_buffer[] = { -{ "LedPositions", 12, (u64)&((color_buffer*)0)->LedPositions, {}, 0}, -{ "Colors", 6, (u64)&((color_buffer*)0)->Colors, {}, 0}, -{ "LEDCount", 8, (u64)&((color_buffer*)0)->LEDCount, {}, 0}, + { "LedPositions", 12, (u64)&((color_buffer*)0)->LedPositions, {}, 0}, + { "Colors", 6, (u64)&((color_buffer*)0)->Colors, {}, 0}, + { "LEDCount", 8, (u64)&((color_buffer*)0)->LEDCount, {}, 0}, }; static gsm_struct_member_type_info StructMembers_solid_color_data[] = { -{ "Color", 5, (u64)&((solid_color_data*)0)->Color, {MetaTag_node_input, }, 1}, -{ "Result", 6, (u64)&((solid_color_data*)0)->Result, {MetaTag_node_output, }, 1}, -}; -static gsm_struct_member_type_info StructMembers_sin_wave_data[] = { -{ "Period", 6, (u64)&((sin_wave_data*)0)->Period, {MetaTag_node_input, }, 1}, -{ "Min", 3, (u64)&((sin_wave_data*)0)->Min, {MetaTag_node_input, }, 1}, -{ "Max", 3, (u64)&((sin_wave_data*)0)->Max, {MetaTag_node_input, }, 1}, -{ "Result", 6, (u64)&((sin_wave_data*)0)->Result, {MetaTag_node_input, }, 1}, -{ "Accumulator", 11, (u64)&((sin_wave_data*)0)->Accumulator, {}, 0}, + { "Color", 5, (u64)&((solid_color_data*)0)->Color, {MetaTag_node_input, }, 1}, + { "Result", 6, (u64)&((solid_color_data*)0)->Result, {MetaTag_node_output, }, 1}, }; static gsm_struct_member_type_info StructMembers_revolving_discs_data[] = { -{ "Rotation", 8, (u64)&((revolving_discs_data*)0)->Rotation, {MetaTag_node_input, }, 1}, -{ "ThetaZ", 6, (u64)&((revolving_discs_data*)0)->ThetaZ, {MetaTag_node_input, }, 1}, -{ "ThetaY", 6, (u64)&((revolving_discs_data*)0)->ThetaY, {MetaTag_node_input, }, 1}, -{ "DiscWidth", 9, (u64)&((revolving_discs_data*)0)->DiscWidth, {MetaTag_node_input, }, 1}, -{ "InnerRadius", 11, (u64)&((revolving_discs_data*)0)->InnerRadius, {MetaTag_node_input, }, 1}, -{ "OuterRadius", 11, (u64)&((revolving_discs_data*)0)->OuterRadius, {MetaTag_node_input, }, 1}, -{ "Color", 5, (u64)&((revolving_discs_data*)0)->Color, {MetaTag_node_input, }, 1}, -{ "Result", 6, (u64)&((revolving_discs_data*)0)->Result, {MetaTag_node_output, }, 1}, + { "Rotation", 8, (u64)&((revolving_discs_data*)0)->Rotation, {MetaTag_node_input, }, 1}, + { "ThetaZ", 6, (u64)&((revolving_discs_data*)0)->ThetaZ, {MetaTag_node_input, }, 1}, + { "ThetaY", 6, (u64)&((revolving_discs_data*)0)->ThetaY, {MetaTag_node_input, }, 1}, + { "DiscWidth", 9, (u64)&((revolving_discs_data*)0)->DiscWidth, {MetaTag_node_input, }, 1}, + { "InnerRadius", 11, (u64)&((revolving_discs_data*)0)->InnerRadius, {MetaTag_node_input, }, 1}, + { "OuterRadius", 11, (u64)&((revolving_discs_data*)0)->OuterRadius, {MetaTag_node_input, }, 1}, + { "Color", 5, (u64)&((revolving_discs_data*)0)->Color, {MetaTag_node_input, }, 1}, + { "Result", 6, (u64)&((revolving_discs_data*)0)->Result, {MetaTag_node_output, }, 1}, }; static gsm_struct_member_type_info StructMembers_vertical_color_fade_data[] = { -{ "Color", 5, (u64)&((vertical_color_fade_data*)0)->Color, {MetaTag_node_input, }, 1}, -{ "Min", 3, (u64)&((vertical_color_fade_data*)0)->Min, {MetaTag_node_input, }, 1}, -{ "Max", 3, (u64)&((vertical_color_fade_data*)0)->Max, {MetaTag_node_input, }, 1}, -{ "Result", 6, (u64)&((vertical_color_fade_data*)0)->Result, {MetaTag_node_output, }, 1}, -}; -static gsm_struct_member_type_info StructMembers_multiply_patterns_data[] = { -{ "A", 1, (u64)&((multiply_patterns_data*)0)->A, {MetaTag_node_input, }, 1}, -{ "B", 1, (u64)&((multiply_patterns_data*)0)->B, {MetaTag_node_input, }, 1}, -{ "Result", 6, (u64)&((multiply_patterns_data*)0)->Result, {MetaTag_node_output, }, 1}, + { "Color", 5, (u64)&((vertical_color_fade_data*)0)->Color, {MetaTag_node_input, }, 1}, + { "Min", 3, (u64)&((vertical_color_fade_data*)0)->Min, {MetaTag_node_input, }, 1}, + { "Max", 3, (u64)&((vertical_color_fade_data*)0)->Max, {MetaTag_node_input, }, 1}, + { "Result", 6, (u64)&((vertical_color_fade_data*)0)->Result, {MetaTag_node_output, }, 1}, }; static gsm_struct_type_info StructTypes[] = { -{ gsm_StructType_solid_color_data, "solid_color_data", 16, 36, 0, 0, StructMembers_solid_color_data, 2 }, -{ gsm_StructType_v4, "v4", 2, 16, 0, 0, StructMembers_v4, 5 }, -{ gsm_StructType_float, "float", 5, 4, 0, 0, 0, 0 }, -{ gsm_StructType_color_buffer, "color_buffer", 12, 20, 0, 0, StructMembers_color_buffer, 3 }, -{ gsm_StructType_pixel, "pixel", 5, 3, 0, 0, StructMembers_pixel, 2 }, -{ gsm_StructType_u8, "u8", 2, 1, 0, 0, 0, 0 }, -{ gsm_StructType_s32, "s32", 3, 4, 0, 0, 0, 0 }, -{ gsm_StructType_sin_wave_data, "sin_wave_data", 13, 20, 0, 0, StructMembers_sin_wave_data, 5 }, -{ gsm_StructType_r32, "r32", 3, 4, 0, 0, 0, 0 }, -{ gsm_StructType_revolving_discs_data, "revolving_discs_data", 20, 60, 0, 0, StructMembers_revolving_discs_data, 8 }, -{ gsm_StructType_vertical_color_fade_data, "vertical_color_fade_data", 24, 44, 0, 0, StructMembers_vertical_color_fade_data, 4 }, -{ gsm_StructType_multiply_patterns_data, "multiply_patterns_data", 22, 60, 0, 0, StructMembers_multiply_patterns_data, 3 }, + { gsm_StructType_r32, "r32", 3, 4, 0, 0, 0, 0 }, + { gsm_StructType_solid_color_data, "solid_color_data", 16, 32, 0, 0, StructMembers_solid_color_data, 2 }, + { gsm_StructType_v4, "v4", 2, 16, 0, 0, StructMembers_v4, 5 }, + { gsm_StructType_float, "float", 5, 4, 0, 0, 0, 0 }, + { gsm_StructType_color_buffer, "color_buffer", 12, 16, 0, 0, StructMembers_color_buffer, 3 }, + { gsm_StructType_pixel, "pixel", 5, 0, 0, 0, StructMembers_pixel, 2 }, + { gsm_StructType_u8, "u8", 2, 0, 0, 0, 0, 0 }, + { gsm_StructType_s32, "s32", 3, 0, 0, 0, 0, 0 }, + { gsm_StructType_revolving_discs_data, "revolving_discs_data", 20, 56, 0, 0, StructMembers_revolving_discs_data, 8 }, + { gsm_StructType_vertical_color_fade_data, "vertical_color_fade_data", 24, 40, 0, 0, StructMembers_vertical_color_fade_data, 4 }, }; static gsm_u32 StructTypesCount = 12; diff --git a/src/app/gs_osx_window.mm b/src/app/gs_osx_window.mm index 3b0d29c..eefafd3 100644 --- a/src/app/gs_osx_window.mm +++ b/src/app/gs_osx_window.mm @@ -67,7 +67,7 @@ gsosx_CreateWindow(NSApplication* App, int Width, int Height, id Title) [App setMainMenu: MenuBar]; NSMenu* AppMenu = [NSMenu alloc]; - id QuitTitle = [@"Quit " stringByAppendingString: Title]; + id QuitTitle = [@"Quit " gs_stringByAppendinggs_string: Title]; id QuitMenuItem = [[NSMenuItem alloc] initWithTitle: QuitTitle action: @selector(terminate:) keyEquivalent: @"q"]; [AppMenu addItem: QuitMenuItem]; [AppMenuItem setSubmenu: AppMenu]; diff --git a/src/app/handmade_math.h b/src/app/handmade_math.h new file mode 100644 index 0000000..049dfdb --- /dev/null +++ b/src/app/handmade_math.h @@ -0,0 +1,3239 @@ +/* + HandmadeMath.h v1.11.0 + + This is a single header file with a bunch of useful functions for game and + graphics math operations. + + ============================================================================= + + You MUST + + #define HANDMADE_MATH_IMPLEMENTATION + + in EXACTLY one C or C++ file that includes this header, BEFORE the + include, like this: + + #define HANDMADE_MATH_IMPLEMENTATION + #include "HandmadeMath.h" + + All other files should just #include "HandmadeMath.h" without the #define. + + ============================================================================= + + To disable SSE intrinsics, you MUST + + #define HANDMADE_MATH_NO_SSE + + in EXACTLY one C or C++ file that includes this header, BEFORE the + include, like this: + + #define HANDMADE_MATH_IMPLEMENTATION + #define HANDMADE_MATH_NO_SSE + #include "HandmadeMath.h" + + ============================================================================= + + If you would prefer not to use the HMM_ prefix on function names, you can + + #define HMM_PREFIX + + To use a custom prefix instead, you can + + #define HMM_PREFIX(name) YOUR_PREFIX_##name + + ============================================================================= + + To use HandmadeMath without the CRT, you MUST + + #define HMM_SINF MySinF + #define HMM_COSF MyCosF + #define HMM_TANF MyTanF + #define HMM_SQRTF MySqrtF + #define HMM_EXPF MyExpF + #define HMM_LOGF MyLogF + #define HMM_ACOSF MyACosF + #define HMM_ATANF MyATanF + #define HMM_ATAN2F MYATan2F + + Provide your own implementations of SinF, CosF, TanF, ACosF, ATanF, ATan2F, + ExpF, and LogF in EXACTLY one C or C++ file that includes this header, + BEFORE the include, like this: + + #define HMM_SINF MySinF + #define HMM_COSF MyCosF + #define HMM_TANF MyTanF + #define HMM_SQRTF MySqrtF + #define HMM_EXPF MyExpF + #define HMM_LOGF MyLogF + #define HMM_ACOSF MyACosF + #define HMM_ATANF MyATanF + #define HMM_ATAN2F MyATan2F + #define HANDMADE_MATH_IMPLEMENTATION + #include "HandmadeMath.h" + + If you do not define all of these, HandmadeMath.h will use the + versions of these functions that are provided by the CRT. + + ============================================================================= + + LICENSE + + This software is in the public domain. Where that dedication is not + recognized, you are granted a perpetual, irrevocable license to copy, + distribute, and modify this file as you see fit. + + CREDITS + + Written by Zakary Strange (strangezak@gmail.com && @strangezak) + + Functionality: + Matt Mascarenhas (@miblo_) + Aleph + FieryDrake (@fierydrake) + Gingerbill (@TheGingerBill) + Ben Visness (@bvisness) + Trinton Bullard (@Peliex_Dev) + @AntonDan + + Fixes: + Jeroen van Rijn (@J_vanRijn) + Kiljacken (@Kiljacken) + Insofaras (@insofaras) + Daniel Gibson (@DanielGibson) +*/ + +// Dummy macros for when test framework is not present. +#ifndef COVERAGE +#define COVERAGE(a, b) +#endif + +#ifndef ASSERT_COVERED +#define ASSERT_COVERED(a) +#endif + +/* let's figure out if SSE is really available (unless disabled anyway) + (it isn't on non-x86/x86_64 platforms or even x86 without explicit SSE support) + => only use "#ifdef HANDMADE_MATH__USE_SSE" to check for SSE support below this block! */ +#ifndef HANDMADE_MATH_NO_SSE + +# ifdef _MSC_VER +/* MSVC supports SSE in amd64 mode or _M_IX86_FP >= 1 (2 means SSE2) */ +# if defined(_M_AMD64) || ( defined(_M_IX86_FP) && _M_IX86_FP >= 1 ) +# define HANDMADE_MATH__USE_SSE 1 +# endif +# else /* not MSVC, probably GCC, clang, icc or something that doesn't support SSE anyway */ +# ifdef __SSE__ /* they #define __SSE__ if it's supported */ +# define HANDMADE_MATH__USE_SSE 1 +# endif /* __SSE__ */ +# endif /* not _MSC_VER */ + +#endif /* #ifndef HANDMADE_MATH_NO_SSE */ + +#ifdef HANDMADE_MATH__USE_SSE +#include +#endif + +#ifndef HANDMADE_MATH_H +#define HANDMADE_MATH_H + +#ifdef _MSC_VER +#pragma warning(disable:4201) +#endif + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wfloat-equal" +#if defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ < 8) +#pragma GCC diagnostic ignored "-Wmissing-braces" +#endif +#ifdef __clang__ +#pragma GCC diagnostic ignored "-Wgnu-anonymous-struct" +#endif +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define HMM_DEPRECATED(msg) __attribute__((deprecated(msg))) +#elif defined(_MSC_VER) +#define HMM_DEPRECATED(msg) __declspec(deprecated(msg)) +#else +#define HMM_DEPRECATED(msg) +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +#define HMM_INLINE static inline +#define HMM_EXTERN extern + +#if !defined(HMM_SINF) || !defined(HMM_COSF) || !defined(HMM_TANF) || \ + !defined(HMM_SQRTF) || !defined(HMM_EXPF) || !defined(HMM_LOGF) || \ + !defined(HMM_ACOSF) || !defined(HMM_ATANF)|| !defined(HMM_ATAN2F) +#include +#endif + +#ifndef HMM_SINF +#define HMM_SINF sinf +#endif + +#ifndef HMM_COSF +#define HMM_COSF cosf +#endif + +#ifndef HMM_TANF +#define HMM_TANF tanf +#endif + +#ifndef HMM_SQRTF +#define HMM_SQRTF sqrtf +#endif + +#ifndef HMM_EXPF +#define HMM_EXPF expf +#endif + +#ifndef HMM_LOGF +#define HMM_LOGF logf +#endif + +#ifndef HMM_ACOSF +#define HMM_ACOSF acosf +#endif + +#ifndef HMM_ATANF +#define HMM_ATANF atanf +#endif + +#ifndef HMM_ATAN2F +#define HMM_ATAN2F atan2f +#endif + +#define HMM_PI32 3.14159265359f +#define HMM_PI 3.14159265358979323846 + +#define HMM_MIN(a, b) (a) > (b) ? (b) : (a) +#define HMM_MAX(a, b) (a) < (b) ? (b) : (a) +#define HMM_ABS(a) ((a) > 0 ? (a) : -(a)) +#define HMM_MOD(a, m) ((a) % (m)) >= 0 ? ((a) % (m)) : (((a) % (m)) + (m)) +#define HMM_SQUARE(x) ((x) * (x)) + +#ifndef HMM_PREFIX +#define HMM_PREFIX(name) HMM_##name +#endif + + typedef union hmm_vec2 + { + struct + { + float X, Y; + }; + + struct + { + float U, V; + }; + + struct + { + float Left, Right; + }; + + struct + { + float Width, Height; + }; + + float Elements[2]; + +#ifdef __cplusplus + inline float &operator[](const int &Index) + { + return Elements[Index]; + } +#endif + } hmm_vec2; + + typedef union hmm_vec3 + { + struct + { + float X, Y, Z; + }; + + struct + { + float U, V, W; + }; + + struct + { + float R, G, B; + }; + + struct + { + hmm_vec2 XY; + float Ignored0_; + }; + + struct + { + float Ignored1_; + hmm_vec2 YZ; + }; + + struct + { + hmm_vec2 UV; + float Ignored2_; + }; + + struct + { + float Ignored3_; + hmm_vec2 VW; + }; + + float Elements[3]; + +#ifdef __cplusplus + inline float &operator[](const int &Index) + { + return Elements[Index]; + } +#endif + } hmm_vec3; + + typedef union hmm_vec4 + { + struct + { + union + { + hmm_vec3 XYZ; + struct + { + float X, Y, Z; + }; + }; + + float W; + }; + struct + { + union + { + hmm_vec3 RGB; + struct + { + float R, G, B; + }; + }; + + float A; + }; + + struct + { + hmm_vec2 XY; + float Ignored0_; + float Ignored1_; + }; + + struct + { + float Ignored2_; + hmm_vec2 YZ; + float Ignored3_; + }; + + struct + { + float Ignored4_; + float Ignored5_; + hmm_vec2 ZW; + }; + + float Elements[4]; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 InternalElementsSSE; +#endif + +#ifdef __cplusplus + inline float &operator[](const int &Index) + { + return Elements[Index]; + } +#endif + } hmm_vec4; + + typedef union hmm_mat4 + { + float Elements[4][4]; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 Columns[4]; + + HMM_DEPRECATED("Our matrices are column-major, so this was named incorrectly. Use Columns instead.") + __m128 Rows[4]; +#endif + +#ifdef __cplusplus + inline hmm_vec4 operator[](const int &Index) + { + float* col = Elements[Index]; + + hmm_vec4 result; + result.Elements[0] = col[0]; + result.Elements[1] = col[1]; + result.Elements[2] = col[2]; + result.Elements[3] = col[3]; + + return result; + } +#endif + } hmm_mat4; + + typedef union hmm_quaternion + { + struct + { + union + { + hmm_vec3 XYZ; + struct + { + float X, Y, Z; + }; + }; + + float W; + }; + + float Elements[4]; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 InternalElementsSSE; +#endif + } hmm_quaternion; + + typedef signed int hmm_bool; + + typedef hmm_vec2 hmm_v2; + typedef hmm_vec3 hmm_v3; + typedef hmm_vec4 hmm_v4; + typedef hmm_mat4 hmm_m4; + + + /* + * Floating-point math functions + */ + + COVERAGE(HMM_SinF, 1) + HMM_INLINE float HMM_PREFIX(SinF)(float Radians) + { + ASSERT_COVERED(HMM_SinF); + + float Result = HMM_SINF(Radians); + + return (Result); + } + + COVERAGE(HMM_CosF, 1) + HMM_INLINE float HMM_PREFIX(CosF)(float Radians) + { + ASSERT_COVERED(HMM_CosF); + + float Result = HMM_COSF(Radians); + + return (Result); + } + + COVERAGE(HMM_TanF, 1) + HMM_INLINE float HMM_PREFIX(TanF)(float Radians) + { + ASSERT_COVERED(HMM_TanF); + + float Result = HMM_TANF(Radians); + + return (Result); + } + + COVERAGE(HMM_ACosF, 1) + HMM_INLINE float HMM_PREFIX(ACosF)(float Radians) + { + ASSERT_COVERED(HMM_ACosF); + + float Result = HMM_ACOSF(Radians); + + return (Result); + } + + COVERAGE(HMM_ATanF, 1) + HMM_INLINE float HMM_PREFIX(ATanF)(float Radians) + { + ASSERT_COVERED(HMM_ATanF); + + float Result = HMM_ATANF(Radians); + + return (Result); + } + + COVERAGE(HMM_ATan2F, 1) + HMM_INLINE float HMM_PREFIX(ATan2F)(float Left, float Right) + { + ASSERT_COVERED(HMM_ATan2F); + + float Result = HMM_ATAN2F(Left, Right); + + return (Result); + } + + COVERAGE(HMM_ExpF, 1) + HMM_INLINE float HMM_PREFIX(ExpF)(float Float) + { + ASSERT_COVERED(HMM_ExpF); + + float Result = HMM_EXPF(Float); + + return (Result); + } + + COVERAGE(HMM_LogF, 1) + HMM_INLINE float HMM_PREFIX(LogF)(float Float) + { + ASSERT_COVERED(HMM_LogF); + + float Result = HMM_LOGF(Float); + + return (Result); + } + + COVERAGE(HMM_SquareRootF, 1) + HMM_INLINE float HMM_PREFIX(SquareRootF)(float Float) + { + ASSERT_COVERED(HMM_SquareRootF); + + float Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 In = _mm_set_ss(Float); + __m128 Out = _mm_sqrt_ss(In); + Result = _mm_cvtss_f32(Out); +#else + Result = HMM_SQRTF(Float); +#endif + + return(Result); + } + + COVERAGE(HMM_RSquareRootF, 1) + HMM_INLINE float HMM_PREFIX(RSquareRootF)(float Float) + { + ASSERT_COVERED(HMM_RSquareRootF); + + float Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 In = _mm_set_ss(Float); + __m128 Out = _mm_rsqrt_ss(In); + Result = _mm_cvtss_f32(Out); +#else + Result = 1.0f/HMM_PREFIX(SquareRootF)(Float); +#endif + + return(Result); + } + + HMM_EXTERN float HMM_PREFIX(Power)(float Base, int Exponent); + + COVERAGE(HMM_PowerF, 1) + HMM_INLINE float HMM_PREFIX(PowerF)(float Base, float Exponent) + { + ASSERT_COVERED(HMM_PowerF); + + float Result = HMM_EXPF(Exponent * HMM_LOGF(Base)); + + return (Result); + } + + + /* + * Utility functions + */ + + COVERAGE(HMM_ToRadians, 1) + HMM_INLINE float HMM_PREFIX(ToRadians)(float Degrees) + { + ASSERT_COVERED(HMM_ToRadians); + + float Result = Degrees * (HMM_PI32 / 180.0f); + + return (Result); + } + + COVERAGE(HMM_Lerp, 1) + HMM_INLINE float HMM_PREFIX(Lerp)(float A, float Time, float B) + { + ASSERT_COVERED(HMM_Lerp); + + float Result = (1.0f - Time) * A + Time * B; + + return (Result); + } + + COVERAGE(HMM_Clamp, 1) + HMM_INLINE float HMM_PREFIX(Clamp)(float Min, float Value, float Max) + { + ASSERT_COVERED(HMM_Clamp); + + float Result = Value; + + if(Result < Min) + { + Result = Min; + } + else if(Result > Max) + { + Result = Max; + } + + return (Result); + } + + + /* + * Vector initialization + */ + + COVERAGE(HMM_Vec2, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(Vec2)(float X, float Y) + { + ASSERT_COVERED(HMM_Vec2); + + hmm_vec2 Result; + + Result.X = X; + Result.Y = Y; + + return (Result); + } + + COVERAGE(HMM_Vec2i, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(Vec2i)(int X, int Y) + { + ASSERT_COVERED(HMM_Vec2i); + + hmm_vec2 Result; + + Result.X = (float)X; + Result.Y = (float)Y; + + return (Result); + } + + COVERAGE(HMM_Vec3, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(Vec3)(float X, float Y, float Z) + { + ASSERT_COVERED(HMM_Vec3); + + hmm_vec3 Result; + + Result.X = X; + Result.Y = Y; + Result.Z = Z; + + return (Result); + } + + COVERAGE(HMM_Vec3i, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(Vec3i)(int X, int Y, int Z) + { + ASSERT_COVERED(HMM_Vec3i); + + hmm_vec3 Result; + + Result.X = (float)X; + Result.Y = (float)Y; + Result.Z = (float)Z; + + return (Result); + } + + COVERAGE(HMM_Vec4, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(Vec4)(float X, float Y, float Z, float W) + { + ASSERT_COVERED(HMM_Vec4); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps(X, Y, Z, W); +#else + Result.X = X; + Result.Y = Y; + Result.Z = Z; + Result.W = W; +#endif + + return (Result); + } + + COVERAGE(HMM_Vec4i, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(Vec4i)(int X, int Y, int Z, int W) + { + ASSERT_COVERED(HMM_Vec4i); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps((float)X, (float)Y, (float)Z, (float)W); +#else + Result.X = (float)X; + Result.Y = (float)Y; + Result.Z = (float)Z; + Result.W = (float)W; +#endif + + return (Result); + } + + COVERAGE(HMM_Vec4v, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(Vec4v)(hmm_vec3 Vector, float W) + { + ASSERT_COVERED(HMM_Vec4v); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps(Vector.X, Vector.Y, Vector.Z, W); +#else + Result.XYZ = Vector; + Result.W = W; +#endif + + return (Result); + } + + + /* + * Binary vector operations + */ + + COVERAGE(HMM_AddVec2, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(AddVec2)(hmm_vec2 Left, hmm_vec2 Right) + { + ASSERT_COVERED(HMM_AddVec2); + + hmm_vec2 Result; + + Result.X = Left.X + Right.X; + Result.Y = Left.Y + Right.Y; + + return (Result); + } + + COVERAGE(HMM_AddVec3, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(AddVec3)(hmm_vec3 Left, hmm_vec3 Right) + { + ASSERT_COVERED(HMM_AddVec3); + + hmm_vec3 Result; + + Result.X = Left.X + Right.X; + Result.Y = Left.Y + Right.Y; + Result.Z = Left.Z + Right.Z; + + return (Result); + } + + COVERAGE(HMM_AddVec4, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(AddVec4)(hmm_vec4 Left, hmm_vec4 Right) + { + ASSERT_COVERED(HMM_AddVec4); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_add_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); +#else + Result.X = Left.X + Right.X; + Result.Y = Left.Y + Right.Y; + Result.Z = Left.Z + Right.Z; + Result.W = Left.W + Right.W; +#endif + + return (Result); + } + + COVERAGE(HMM_SubtractVec2, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(SubtractVec2)(hmm_vec2 Left, hmm_vec2 Right) + { + ASSERT_COVERED(HMM_SubtractVec2); + + hmm_vec2 Result; + + Result.X = Left.X - Right.X; + Result.Y = Left.Y - Right.Y; + + return (Result); + } + + COVERAGE(HMM_SubtractVec3, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(SubtractVec3)(hmm_vec3 Left, hmm_vec3 Right) + { + ASSERT_COVERED(HMM_SubtractVec3); + + hmm_vec3 Result; + + Result.X = Left.X - Right.X; + Result.Y = Left.Y - Right.Y; + Result.Z = Left.Z - Right.Z; + + return (Result); + } + + COVERAGE(HMM_SubtractVec4, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(SubtractVec4)(hmm_vec4 Left, hmm_vec4 Right) + { + ASSERT_COVERED(HMM_SubtractVec4); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_sub_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); +#else + Result.X = Left.X - Right.X; + Result.Y = Left.Y - Right.Y; + Result.Z = Left.Z - Right.Z; + Result.W = Left.W - Right.W; +#endif + + return (Result); + } + + COVERAGE(HMM_MultiplyVec2, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(MultiplyVec2)(hmm_vec2 Left, hmm_vec2 Right) + { + ASSERT_COVERED(HMM_MultiplyVec2); + + hmm_vec2 Result; + + Result.X = Left.X * Right.X; + Result.Y = Left.Y * Right.Y; + + return (Result); + } + + COVERAGE(HMM_MultiplyVec2f, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(MultiplyVec2f)(hmm_vec2 Left, float Right) + { + ASSERT_COVERED(HMM_MultiplyVec2f); + + hmm_vec2 Result; + + Result.X = Left.X * Right; + Result.Y = Left.Y * Right; + + return (Result); + } + + COVERAGE(HMM_MultiplyVec3, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(MultiplyVec3)(hmm_vec3 Left, hmm_vec3 Right) + { + ASSERT_COVERED(HMM_MultiplyVec3); + + hmm_vec3 Result; + + Result.X = Left.X * Right.X; + Result.Y = Left.Y * Right.Y; + Result.Z = Left.Z * Right.Z; + + return (Result); + } + + COVERAGE(HMM_MultiplyVec3f, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(MultiplyVec3f)(hmm_vec3 Left, float Right) + { + ASSERT_COVERED(HMM_MultiplyVec3f); + + hmm_vec3 Result; + + Result.X = Left.X * Right; + Result.Y = Left.Y * Right; + Result.Z = Left.Z * Right; + + return (Result); + } + + COVERAGE(HMM_MultiplyVec4, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(MultiplyVec4)(hmm_vec4 Left, hmm_vec4 Right) + { + ASSERT_COVERED(HMM_MultiplyVec4); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); +#else + Result.X = Left.X * Right.X; + Result.Y = Left.Y * Right.Y; + Result.Z = Left.Z * Right.Z; + Result.W = Left.W * Right.W; +#endif + + return (Result); + } + + COVERAGE(HMM_MultiplyVec4f, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(MultiplyVec4f)(hmm_vec4 Left, float Right) + { + ASSERT_COVERED(HMM_MultiplyVec4f); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 Scalar = _mm_set1_ps(Right); + Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Scalar); +#else + Result.X = Left.X * Right; + Result.Y = Left.Y * Right; + Result.Z = Left.Z * Right; + Result.W = Left.W * Right; +#endif + + return (Result); + } + + COVERAGE(HMM_DivideVec2, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(DivideVec2)(hmm_vec2 Left, hmm_vec2 Right) + { + ASSERT_COVERED(HMM_DivideVec2); + + hmm_vec2 Result; + + Result.X = Left.X / Right.X; + Result.Y = Left.Y / Right.Y; + + return (Result); + } + + COVERAGE(HMM_DivideVec2f, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(DivideVec2f)(hmm_vec2 Left, float Right) + { + ASSERT_COVERED(HMM_DivideVec2f); + + hmm_vec2 Result; + + Result.X = Left.X / Right; + Result.Y = Left.Y / Right; + + return (Result); + } + + COVERAGE(HMM_DivideVec3, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(DivideVec3)(hmm_vec3 Left, hmm_vec3 Right) + { + ASSERT_COVERED(HMM_DivideVec3); + + hmm_vec3 Result; + + Result.X = Left.X / Right.X; + Result.Y = Left.Y / Right.Y; + Result.Z = Left.Z / Right.Z; + + return (Result); + } + + COVERAGE(HMM_DivideVec3f, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(DivideVec3f)(hmm_vec3 Left, float Right) + { + ASSERT_COVERED(HMM_DivideVec3f); + + hmm_vec3 Result; + + Result.X = Left.X / Right; + Result.Y = Left.Y / Right; + Result.Z = Left.Z / Right; + + return (Result); + } + + COVERAGE(HMM_DivideVec4, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(DivideVec4)(hmm_vec4 Left, hmm_vec4 Right) + { + ASSERT_COVERED(HMM_DivideVec4); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); +#else + Result.X = Left.X / Right.X; + Result.Y = Left.Y / Right.Y; + Result.Z = Left.Z / Right.Z; + Result.W = Left.W / Right.W; +#endif + + return (Result); + } + + COVERAGE(HMM_DivideVec4f, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(DivideVec4f)(hmm_vec4 Left, float Right) + { + ASSERT_COVERED(HMM_DivideVec4f); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 Scalar = _mm_set1_ps(Right); + Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Scalar); +#else + Result.X = Left.X / Right; + Result.Y = Left.Y / Right; + Result.Z = Left.Z / Right; + Result.W = Left.W / Right; +#endif + + return (Result); + } + + COVERAGE(HMM_EqualsVec2, 1) + HMM_INLINE hmm_bool HMM_PREFIX(EqualsVec2)(hmm_vec2 Left, hmm_vec2 Right) + { + ASSERT_COVERED(HMM_EqualsVec2); + + hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y); + + return (Result); + } + + COVERAGE(HMM_EqualsVec3, 1) + HMM_INLINE hmm_bool HMM_PREFIX(EqualsVec3)(hmm_vec3 Left, hmm_vec3 Right) + { + ASSERT_COVERED(HMM_EqualsVec3); + + hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z); + + return (Result); + } + + COVERAGE(HMM_EqualsVec4, 1) + HMM_INLINE hmm_bool HMM_PREFIX(EqualsVec4)(hmm_vec4 Left, hmm_vec4 Right) + { + ASSERT_COVERED(HMM_EqualsVec4); + + hmm_bool Result = (Left.X == Right.X && Left.Y == Right.Y && Left.Z == Right.Z && Left.W == Right.W); + + return (Result); + } + + COVERAGE(HMM_DotVec2, 1) + HMM_INLINE float HMM_PREFIX(DotVec2)(hmm_vec2 VecOne, hmm_vec2 VecTwo) + { + ASSERT_COVERED(HMM_DotVec2); + + float Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y); + + return (Result); + } + + COVERAGE(HMM_DotVec3, 1) + HMM_INLINE float HMM_PREFIX(DotVec3)(hmm_vec3 VecOne, hmm_vec3 VecTwo) + { + ASSERT_COVERED(HMM_DotVec3); + + float Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z); + + return (Result); + } + + COVERAGE(HMM_DotVec4, 1) + HMM_INLINE float HMM_PREFIX(DotVec4)(hmm_vec4 VecOne, hmm_vec4 VecTwo) + { + ASSERT_COVERED(HMM_DotVec4); + + float Result; + + // NOTE(zak): IN the future if we wanna check what version SSE is support + // we can use _mm_dp_ps (4.3) but for now we will use the old way. + // Or a r = _mm_mul_ps(v1, v2), r = _mm_hadd_ps(r, r), r = _mm_hadd_ps(r, r) for SSE3 +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEResultOne = _mm_mul_ps(VecOne.InternalElementsSSE, VecTwo.InternalElementsSSE); + __m128 SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(2, 3, 0, 1)); + SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo); + SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(0, 1, 2, 3)); + SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo); + _mm_store_ss(&Result, SSEResultOne); +#else + Result = (VecOne.X * VecTwo.X) + (VecOne.Y * VecTwo.Y) + (VecOne.Z * VecTwo.Z) + (VecOne.W * VecTwo.W); +#endif + + return (Result); + } + + COVERAGE(HMM_Cross, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(Cross)(hmm_vec3 VecOne, hmm_vec3 VecTwo) + { + ASSERT_COVERED(HMM_Cross); + + hmm_vec3 Result; + + Result.X = (VecOne.Y * VecTwo.Z) - (VecOne.Z * VecTwo.Y); + Result.Y = (VecOne.Z * VecTwo.X) - (VecOne.X * VecTwo.Z); + Result.Z = (VecOne.X * VecTwo.Y) - (VecOne.Y * VecTwo.X); + + return (Result); + } + + + /* + * Unary vector operations + */ + + COVERAGE(HMM_LengthSquaredVec2, 1) + HMM_INLINE float HMM_PREFIX(LengthSquaredVec2)(hmm_vec2 A) + { + ASSERT_COVERED(HMM_LengthSquaredVec2); + + float Result = HMM_PREFIX(DotVec2)(A, A); + + return (Result); + } + + COVERAGE(HMM_LengthSquaredVec3, 1) + HMM_INLINE float HMM_PREFIX(LengthSquaredVec3)(hmm_vec3 A) + { + ASSERT_COVERED(HMM_LengthSquaredVec3); + + float Result = HMM_PREFIX(DotVec3)(A, A); + + return (Result); + } + + COVERAGE(HMM_LengthSquaredVec4, 1) + HMM_INLINE float HMM_PREFIX(LengthSquaredVec4)(hmm_vec4 A) + { + ASSERT_COVERED(HMM_LengthSquaredVec4); + + float Result = HMM_PREFIX(DotVec4)(A, A); + + return (Result); + } + + COVERAGE(HMM_LengthVec2, 1) + HMM_INLINE float HMM_PREFIX(LengthVec2)(hmm_vec2 A) + { + ASSERT_COVERED(HMM_LengthVec2); + + float Result = HMM_PREFIX(SquareRootF)(HMM_PREFIX(LengthSquaredVec2)(A)); + + return (Result); + } + + COVERAGE(HMM_LengthVec3, 1) + HMM_INLINE float HMM_PREFIX(LengthVec3)(hmm_vec3 A) + { + ASSERT_COVERED(HMM_LengthVec3); + + float Result = HMM_PREFIX(SquareRootF)(HMM_PREFIX(LengthSquaredVec3)(A)); + + return (Result); + } + + COVERAGE(HMM_LengthVec4, 1) + HMM_INLINE float HMM_PREFIX(LengthVec4)(hmm_vec4 A) + { + ASSERT_COVERED(HMM_LengthVec4); + + float Result = HMM_PREFIX(SquareRootF)(HMM_PREFIX(LengthSquaredVec4)(A)); + + return(Result); + } + + COVERAGE(HMM_NormalizeVec2, 2) + HMM_INLINE hmm_vec2 HMM_PREFIX(NormalizeVec2)(hmm_vec2 A) + { + ASSERT_COVERED(HMM_NormalizeVec2); + + hmm_vec2 Result = {0}; + + float VectorLength = HMM_PREFIX(LengthVec2)(A); + + /* NOTE(kiljacken): We need a zero check to not divide-by-zero */ + if (VectorLength != 0.0f) + { + ASSERT_COVERED(HMM_NormalizeVec2); + + Result.X = A.X * (1.0f / VectorLength); + Result.Y = A.Y * (1.0f / VectorLength); + } + + return (Result); + } + + COVERAGE(HMM_NormalizeVec3, 2) + HMM_INLINE hmm_vec3 HMM_PREFIX(NormalizeVec3)(hmm_vec3 A) + { + ASSERT_COVERED(HMM_NormalizeVec3); + + hmm_vec3 Result = {0}; + + float VectorLength = HMM_PREFIX(LengthVec3)(A); + + /* NOTE(kiljacken): We need a zero check to not divide-by-zero */ + if (VectorLength != 0.0f) + { + ASSERT_COVERED(HMM_NormalizeVec3); + + Result.X = A.X * (1.0f / VectorLength); + Result.Y = A.Y * (1.0f / VectorLength); + Result.Z = A.Z * (1.0f / VectorLength); + } + + return (Result); + } + + COVERAGE(HMM_NormalizeVec4, 2) + HMM_INLINE hmm_vec4 HMM_PREFIX(NormalizeVec4)(hmm_vec4 A) + { + ASSERT_COVERED(HMM_NormalizeVec4); + + hmm_vec4 Result = {0}; + + float VectorLength = HMM_PREFIX(LengthVec4)(A); + + /* NOTE(kiljacken): We need a zero check to not divide-by-zero */ + if (VectorLength != 0.0f) + { + ASSERT_COVERED(HMM_NormalizeVec4); + + float Multiplier = 1.0f / VectorLength; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEMultiplier = _mm_set1_ps(Multiplier); + Result.InternalElementsSSE = _mm_mul_ps(A.InternalElementsSSE, SSEMultiplier); +#else + Result.X = A.X * Multiplier; + Result.Y = A.Y * Multiplier; + Result.Z = A.Z * Multiplier; + Result.W = A.W * Multiplier; +#endif + } + + return (Result); + } + + COVERAGE(HMM_FastNormalizeVec2, 1) + HMM_INLINE hmm_vec2 HMM_PREFIX(FastNormalizeVec2)(hmm_vec2 A) + { + ASSERT_COVERED(HMM_FastNormalizeVec2); + + return HMM_PREFIX(MultiplyVec2f)(A, HMM_PREFIX(RSquareRootF)(HMM_PREFIX(DotVec2)(A, A))); + } + + COVERAGE(HMM_FastNormalizeVec3, 1) + HMM_INLINE hmm_vec3 HMM_PREFIX(FastNormalizeVec3)(hmm_vec3 A) + { + ASSERT_COVERED(HMM_FastNormalizeVec3); + + return HMM_PREFIX(MultiplyVec3f)(A, HMM_PREFIX(RSquareRootF)(HMM_PREFIX(DotVec3)(A, A))); + } + + COVERAGE(HMM_FastNormalizeVec4, 1) + HMM_INLINE hmm_vec4 HMM_PREFIX(FastNormalizeVec4)(hmm_vec4 A) + { + ASSERT_COVERED(HMM_FastNormalizeVec4); + + return HMM_PREFIX(MultiplyVec4f)(A, HMM_PREFIX(RSquareRootF)(HMM_PREFIX(DotVec4)(A, A))); + } + + + /* + * SSE stuff + */ + +#ifdef HANDMADE_MATH__USE_SSE + COVERAGE(HMM_LinearCombineSSE, 1) + HMM_INLINE __m128 HMM_PREFIX(LinearCombineSSE)(__m128 Left, hmm_mat4 Right) + { + ASSERT_COVERED(HMM_LinearCombineSSE); + + __m128 Result; + Result = _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x00), Right.Columns[0]); + Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0x55), Right.Columns[1])); + Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xaa), Right.Columns[2])); + Result = _mm_add_ps(Result, _mm_mul_ps(_mm_shuffle_ps(Left, Left, 0xff), Right.Columns[3])); + + return (Result); + } +#endif + + + /* + * Matrix functions + */ + + COVERAGE(HMM_Mat4, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Mat4)(void) + { + ASSERT_COVERED(HMM_Mat4); + + hmm_mat4 Result = {0}; + + return (Result); + } + + COVERAGE(HMM_Mat4d, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Mat4d)(float Diagonal) + { + ASSERT_COVERED(HMM_Mat4d); + + hmm_mat4 Result = HMM_PREFIX(Mat4)(); + + Result.Elements[0][0] = Diagonal; + Result.Elements[1][1] = Diagonal; + Result.Elements[2][2] = Diagonal; + Result.Elements[3][3] = Diagonal; + + return (Result); + } + +#ifdef HANDMADE_MATH__USE_SSE + COVERAGE(HMM_Transpose, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix) + { + ASSERT_COVERED(HMM_Transpose); + + hmm_mat4 Result = Matrix; + + _MM_TRANSPOSE4_PS(Result.Columns[0], Result.Columns[1], Result.Columns[2], Result.Columns[3]); + + return (Result); + } +#else + HMM_EXTERN hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix); +#endif + +#ifdef HANDMADE_MATH__USE_SSE + COVERAGE(HMM_AddMat4, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right) + { + ASSERT_COVERED(HMM_AddMat4); + + hmm_mat4 Result; + + Result.Columns[0] = _mm_add_ps(Left.Columns[0], Right.Columns[0]); + Result.Columns[1] = _mm_add_ps(Left.Columns[1], Right.Columns[1]); + Result.Columns[2] = _mm_add_ps(Left.Columns[2], Right.Columns[2]); + Result.Columns[3] = _mm_add_ps(Left.Columns[3], Right.Columns[3]); + + return (Result); + } +#else + HMM_EXTERN hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right); +#endif + +#ifdef HANDMADE_MATH__USE_SSE + COVERAGE(HMM_SubtractMat4, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right) + { + ASSERT_COVERED(HMM_SubtractMat4); + + hmm_mat4 Result; + + Result.Columns[0] = _mm_sub_ps(Left.Columns[0], Right.Columns[0]); + Result.Columns[1] = _mm_sub_ps(Left.Columns[1], Right.Columns[1]); + Result.Columns[2] = _mm_sub_ps(Left.Columns[2], Right.Columns[2]); + Result.Columns[3] = _mm_sub_ps(Left.Columns[3], Right.Columns[3]); + + return (Result); + } +#else + HMM_EXTERN hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right); +#endif + + HMM_EXTERN hmm_mat4 HMM_PREFIX(MultiplyMat4)(hmm_mat4 Left, hmm_mat4 Right); + +#ifdef HANDMADE_MATH__USE_SSE + COVERAGE(HMM_MultiplyMat4f, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar) + { + ASSERT_COVERED(HMM_MultiplyMat4f); + + hmm_mat4 Result; + + __m128 SSEScalar = _mm_set1_ps(Scalar); + Result.Columns[0] = _mm_mul_ps(Matrix.Columns[0], SSEScalar); + Result.Columns[1] = _mm_mul_ps(Matrix.Columns[1], SSEScalar); + Result.Columns[2] = _mm_mul_ps(Matrix.Columns[2], SSEScalar); + Result.Columns[3] = _mm_mul_ps(Matrix.Columns[3], SSEScalar); + + return (Result); + } +#else + HMM_EXTERN hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar); +#endif + + HMM_EXTERN hmm_vec4 HMM_PREFIX(MultiplyMat4ByVec4)(hmm_mat4 Matrix, hmm_vec4 Vector); + +#ifdef HANDMADE_MATH__USE_SSE + COVERAGE(HMM_DivideMat4f, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar) + { + ASSERT_COVERED(HMM_DivideMat4f); + + hmm_mat4 Result; + + __m128 SSEScalar = _mm_set1_ps(Scalar); + Result.Columns[0] = _mm_div_ps(Matrix.Columns[0], SSEScalar); + Result.Columns[1] = _mm_div_ps(Matrix.Columns[1], SSEScalar); + Result.Columns[2] = _mm_div_ps(Matrix.Columns[2], SSEScalar); + Result.Columns[3] = _mm_div_ps(Matrix.Columns[3], SSEScalar); + + return (Result); + } +#else + HMM_EXTERN hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar); +#endif + + + /* + * Common graphics transformations + */ + + COVERAGE(HMM_Orthographic, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Orthographic)(float Left, float Right, float Bottom, float Top, float Near, float Far) + { + ASSERT_COVERED(HMM_Orthographic); + + hmm_mat4 Result = HMM_PREFIX(Mat4)(); + + Result.Elements[0][0] = 2.0f / (Right - Left); + Result.Elements[1][1] = 2.0f / (Top - Bottom); + Result.Elements[2][2] = 2.0f / (Near - Far); + Result.Elements[3][3] = 1.0f; + + Result.Elements[3][0] = (Left + Right) / (Left - Right); + Result.Elements[3][1] = (Bottom + Top) / (Bottom - Top); + Result.Elements[3][2] = (Far + Near) / (Near - Far); + + return (Result); + } + + COVERAGE(HMM_Perspective, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Perspective)(float FOV, float AspectRatio, float Near, float Far) + { + ASSERT_COVERED(HMM_Perspective); + + hmm_mat4 Result = HMM_PREFIX(Mat4)(); + + // See https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml + + float Cotangent = 1.0f / HMM_PREFIX(TanF)(FOV * (HMM_PI32 / 360.0f)); + + Result.Elements[0][0] = Cotangent / AspectRatio; + Result.Elements[1][1] = Cotangent; + Result.Elements[2][3] = -1.0f; + Result.Elements[2][2] = (Near + Far) / (Near - Far); + Result.Elements[3][2] = (2.0f * Near * Far) / (Near - Far); + Result.Elements[3][3] = 0.0f; + + return (Result); + } + + COVERAGE(HMM_Translate, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Translate)(hmm_vec3 Translation) + { + ASSERT_COVERED(HMM_Translate); + + hmm_mat4 Result = HMM_PREFIX(Mat4d)(1.0f); + + Result.Elements[3][0] = Translation.X; + Result.Elements[3][1] = Translation.Y; + Result.Elements[3][2] = Translation.Z; + + return (Result); + } + + HMM_EXTERN hmm_mat4 HMM_PREFIX(Rotate)(float Angle, hmm_vec3 Axis); + + COVERAGE(HMM_Scale, 1) + HMM_INLINE hmm_mat4 HMM_PREFIX(Scale)(hmm_vec3 Scale) + { + ASSERT_COVERED(HMM_Scale); + + hmm_mat4 Result = HMM_PREFIX(Mat4d)(1.0f); + + Result.Elements[0][0] = Scale.X; + Result.Elements[1][1] = Scale.Y; + Result.Elements[2][2] = Scale.Z; + + return (Result); + } + + HMM_EXTERN hmm_mat4 HMM_PREFIX(LookAt)(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up); + + + /* + * Quaternion operations + */ + + COVERAGE(HMM_Quaternion, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(Quaternion)(float X, float Y, float Z, float W) + { + ASSERT_COVERED(HMM_Quaternion); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_setr_ps(X, Y, Z, W); +#else + Result.X = X; + Result.Y = Y; + Result.Z = Z; + Result.W = W; +#endif + + return (Result); + } + + COVERAGE(HMM_QuaternionV4, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(QuaternionV4)(hmm_vec4 Vector) + { + ASSERT_COVERED(HMM_QuaternionV4); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = Vector.InternalElementsSSE; +#else + Result.X = Vector.X; + Result.Y = Vector.Y; + Result.Z = Vector.Z; + Result.W = Vector.W; +#endif + + return (Result); + } + + COVERAGE(HMM_AddQuaternion, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(AddQuaternion)(hmm_quaternion Left, hmm_quaternion Right) + { + ASSERT_COVERED(HMM_AddQuaternion); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_add_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); +#else + + Result.X = Left.X + Right.X; + Result.Y = Left.Y + Right.Y; + Result.Z = Left.Z + Right.Z; + Result.W = Left.W + Right.W; +#endif + + return (Result); + } + + COVERAGE(HMM_SubtractQuaternion, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(SubtractQuaternion)(hmm_quaternion Left, hmm_quaternion Right) + { + ASSERT_COVERED(HMM_SubtractQuaternion); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = _mm_sub_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); +#else + + Result.X = Left.X - Right.X; + Result.Y = Left.Y - Right.Y; + Result.Z = Left.Z - Right.Z; + Result.W = Left.W - Right.W; +#endif + + return (Result); + } + + COVERAGE(HMM_MultiplyQuaternion, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(MultiplyQuaternion)(hmm_quaternion Left, hmm_quaternion Right) + { + ASSERT_COVERED(HMM_MultiplyQuaternion); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEResultOne = _mm_xor_ps(_mm_shuffle_ps(Left.InternalElementsSSE, Left.InternalElementsSSE, _MM_SHUFFLE(0, 0, 0, 0)), _mm_setr_ps(0.f, -0.f, 0.f, -0.f)); + __m128 SSEResultTwo = _mm_shuffle_ps(Right.InternalElementsSSE, Right.InternalElementsSSE, _MM_SHUFFLE(0, 1, 2, 3)); + __m128 SSEResultThree = _mm_mul_ps(SSEResultTwo, SSEResultOne); + + SSEResultOne = _mm_xor_ps(_mm_shuffle_ps(Left.InternalElementsSSE, Left.InternalElementsSSE, _MM_SHUFFLE(1, 1, 1, 1)) , _mm_setr_ps(0.f, 0.f, -0.f, -0.f)); + SSEResultTwo = _mm_shuffle_ps(Right.InternalElementsSSE, Right.InternalElementsSSE, _MM_SHUFFLE(1, 0, 3, 2)); + SSEResultThree = _mm_add_ps(SSEResultThree, _mm_mul_ps(SSEResultTwo, SSEResultOne)); + + SSEResultOne = _mm_xor_ps(_mm_shuffle_ps(Left.InternalElementsSSE, Left.InternalElementsSSE, _MM_SHUFFLE(2, 2, 2, 2)), _mm_setr_ps(-0.f, 0.f, 0.f, -0.f)); + SSEResultTwo = _mm_shuffle_ps(Right.InternalElementsSSE, Right.InternalElementsSSE, _MM_SHUFFLE(2, 3, 0, 1)); + SSEResultThree = _mm_add_ps(SSEResultThree, _mm_mul_ps(SSEResultTwo, SSEResultOne)); + + SSEResultOne = _mm_shuffle_ps(Left.InternalElementsSSE, Left.InternalElementsSSE, _MM_SHUFFLE(3, 3, 3, 3)); + SSEResultTwo = _mm_shuffle_ps(Right.InternalElementsSSE, Right.InternalElementsSSE, _MM_SHUFFLE(3, 2, 1, 0)); + Result.InternalElementsSSE = _mm_add_ps(SSEResultThree, _mm_mul_ps(SSEResultTwo, SSEResultOne)); +#else + Result.X = (Left.X * Right.W) + (Left.Y * Right.Z) - (Left.Z * Right.Y) + (Left.W * Right.X); + Result.Y = (-Left.X * Right.Z) + (Left.Y * Right.W) + (Left.Z * Right.X) + (Left.W * Right.Y); + Result.Z = (Left.X * Right.Y) - (Left.Y * Right.X) + (Left.Z * Right.W) + (Left.W * Right.Z); + Result.W = (-Left.X * Right.X) - (Left.Y * Right.Y) - (Left.Z * Right.Z) + (Left.W * Right.W); +#endif + + return (Result); + } + + COVERAGE(HMM_MultiplyQuaternionF, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(MultiplyQuaternionF)(hmm_quaternion Left, float Multiplicative) + { + ASSERT_COVERED(HMM_MultiplyQuaternionF); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 Scalar = _mm_set1_ps(Multiplicative); + Result.InternalElementsSSE = _mm_mul_ps(Left.InternalElementsSSE, Scalar); +#else + Result.X = Left.X * Multiplicative; + Result.Y = Left.Y * Multiplicative; + Result.Z = Left.Z * Multiplicative; + Result.W = Left.W * Multiplicative; +#endif + + return (Result); + } + + COVERAGE(HMM_DivideQuaternionF, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(DivideQuaternionF)(hmm_quaternion Left, float Dividend) + { + ASSERT_COVERED(HMM_DivideQuaternionF); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 Scalar = _mm_set1_ps(Dividend); + Result.InternalElementsSSE = _mm_div_ps(Left.InternalElementsSSE, Scalar); +#else + Result.X = Left.X / Dividend; + Result.Y = Left.Y / Dividend; + Result.Z = Left.Z / Dividend; + Result.W = Left.W / Dividend; +#endif + + return (Result); + } + + HMM_EXTERN hmm_quaternion HMM_PREFIX(InverseQuaternion)(hmm_quaternion Left); + + COVERAGE(HMM_DotQuaternion, 1) + HMM_INLINE float HMM_PREFIX(DotQuaternion)(hmm_quaternion Left, hmm_quaternion Right) + { + ASSERT_COVERED(HMM_DotQuaternion); + + float Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 SSEResultOne = _mm_mul_ps(Left.InternalElementsSSE, Right.InternalElementsSSE); + __m128 SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(2, 3, 0, 1)); + SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo); + SSEResultTwo = _mm_shuffle_ps(SSEResultOne, SSEResultOne, _MM_SHUFFLE(0, 1, 2, 3)); + SSEResultOne = _mm_add_ps(SSEResultOne, SSEResultTwo); + _mm_store_ss(&Result, SSEResultOne); +#else + Result = (Left.X * Right.X) + (Left.Y * Right.Y) + (Left.Z * Right.Z) + (Left.W * Right.W); +#endif + + return (Result); + } + + COVERAGE(HMM_NormalizeQuaternion, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(NormalizeQuaternion)(hmm_quaternion Left) + { + ASSERT_COVERED(HMM_NormalizeQuaternion); + + hmm_quaternion Result; + + float Length = HMM_PREFIX(SquareRootF)(HMM_PREFIX(DotQuaternion)(Left, Left)); + Result = HMM_PREFIX(DivideQuaternionF)(Left, Length); + + return (Result); + } + + COVERAGE(HMM_NLerp, 1) + HMM_INLINE hmm_quaternion HMM_PREFIX(NLerp)(hmm_quaternion Left, float Time, hmm_quaternion Right) + { + ASSERT_COVERED(HMM_NLerp); + + hmm_quaternion Result; + +#ifdef HANDMADE_MATH__USE_SSE + __m128 ScalarLeft = _mm_set1_ps(1.0f - Time); + __m128 ScalarRight = _mm_set1_ps(Time); + __m128 SSEResultOne = _mm_mul_ps(Left.InternalElementsSSE, ScalarLeft); + __m128 SSEResultTwo = _mm_mul_ps(Right.InternalElementsSSE, ScalarRight); + Result.InternalElementsSSE = _mm_add_ps(SSEResultOne, SSEResultTwo); +#else + Result.X = HMM_PREFIX(Lerp)(Left.X, Time, Right.X); + Result.Y = HMM_PREFIX(Lerp)(Left.Y, Time, Right.Y); + Result.Z = HMM_PREFIX(Lerp)(Left.Z, Time, Right.Z); + Result.W = HMM_PREFIX(Lerp)(Left.W, Time, Right.W); +#endif + Result = HMM_PREFIX(NormalizeQuaternion)(Result); + + return (Result); + } + + HMM_EXTERN hmm_quaternion HMM_PREFIX(Slerp)(hmm_quaternion Left, float Time, hmm_quaternion Right); + HMM_EXTERN hmm_mat4 HMM_PREFIX(QuaternionToMat4)(hmm_quaternion Left); + HMM_EXTERN hmm_quaternion HMM_PREFIX(Mat4ToQuaternion)(hmm_mat4 Left); + HMM_EXTERN hmm_quaternion HMM_PREFIX(QuaternionFromAxisAngle)(hmm_vec3 Axis, float AngleOfRotation); + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus + +COVERAGE(HMM_LengthVec2CPP, 1) +HMM_INLINE float HMM_PREFIX(Length)(hmm_vec2 A) +{ + ASSERT_COVERED(HMM_LengthVec2CPP); + + float Result = HMM_PREFIX(LengthVec2)(A); + + return (Result); +} + +COVERAGE(HMM_LengthVec3CPP, 1) +HMM_INLINE float HMM_PREFIX(Length)(hmm_vec3 A) +{ + ASSERT_COVERED(HMM_LengthVec3CPP); + + float Result = HMM_PREFIX(LengthVec3)(A); + + return (Result); +} + +COVERAGE(HMM_LengthVec4CPP, 1) +HMM_INLINE float HMM_PREFIX(Length)(hmm_vec4 A) +{ + ASSERT_COVERED(HMM_LengthVec4CPP); + + float Result = HMM_PREFIX(LengthVec4)(A); + + return (Result); +} + +COVERAGE(HMM_LengthSquaredVec2CPP, 1) +HMM_INLINE float HMM_PREFIX(LengthSquared)(hmm_vec2 A) +{ + ASSERT_COVERED(HMM_LengthSquaredVec2CPP); + + float Result = HMM_PREFIX(LengthSquaredVec2)(A); + + return (Result); +} + +COVERAGE(HMM_LengthSquaredVec3CPP, 1) +HMM_INLINE float HMM_PREFIX(LengthSquared)(hmm_vec3 A) +{ + ASSERT_COVERED(HMM_LengthSquaredVec3CPP); + + float Result = HMM_PREFIX(LengthSquaredVec3)(A); + + return (Result); +} + +COVERAGE(HMM_LengthSquaredVec4CPP, 1) +HMM_INLINE float HMM_PREFIX(LengthSquared)(hmm_vec4 A) +{ + ASSERT_COVERED(HMM_LengthSquaredVec4CPP); + + float Result = HMM_PREFIX(LengthSquaredVec4)(A); + + return (Result); +} + +COVERAGE(HMM_NormalizeVec2CPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Normalize)(hmm_vec2 A) +{ + ASSERT_COVERED(HMM_NormalizeVec2CPP); + + hmm_vec2 Result = HMM_PREFIX(NormalizeVec2)(A); + + return (Result); +} + +COVERAGE(HMM_NormalizeVec3CPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Normalize)(hmm_vec3 A) +{ + ASSERT_COVERED(HMM_NormalizeVec3CPP); + + hmm_vec3 Result = HMM_PREFIX(NormalizeVec3)(A); + + return (Result); +} + +COVERAGE(HMM_NormalizeVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Normalize)(hmm_vec4 A) +{ + ASSERT_COVERED(HMM_NormalizeVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(NormalizeVec4)(A); + + return (Result); +} + +COVERAGE(HMM_FastNormalizeVec2CPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(FastNormalize)(hmm_vec2 A) +{ + ASSERT_COVERED(HMM_FastNormalizeVec2CPP); + + hmm_vec2 Result = HMM_PREFIX(FastNormalizeVec2)(A); + + return (Result); +} + +COVERAGE(HMM_FastNormalizeVec3CPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(FastNormalize)(hmm_vec3 A) +{ + ASSERT_COVERED(HMM_FastNormalizeVec3CPP); + + hmm_vec3 Result = HMM_PREFIX(FastNormalizeVec3)(A); + + return (Result); +} + +COVERAGE(HMM_FastNormalizeVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(FastNormalize)(hmm_vec4 A) +{ + ASSERT_COVERED(HMM_FastNormalizeVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(FastNormalizeVec4)(A); + + return (Result); +} + +COVERAGE(HMM_NormalizeQuaternionCPP, 1) +HMM_INLINE hmm_quaternion HMM_PREFIX(Normalize)(hmm_quaternion A) +{ + ASSERT_COVERED(HMM_NormalizeQuaternionCPP); + + hmm_quaternion Result = HMM_PREFIX(NormalizeQuaternion)(A); + + return (Result); +} + +COVERAGE(HMM_DotVec2CPP, 1) +HMM_INLINE float HMM_PREFIX(Dot)(hmm_vec2 VecOne, hmm_vec2 VecTwo) +{ + ASSERT_COVERED(HMM_DotVec2CPP); + + float Result = HMM_PREFIX(DotVec2)(VecOne, VecTwo); + + return (Result); +} + +COVERAGE(HMM_DotVec3CPP, 1) +HMM_INLINE float HMM_PREFIX(Dot)(hmm_vec3 VecOne, hmm_vec3 VecTwo) +{ + ASSERT_COVERED(HMM_DotVec3CPP); + + float Result = HMM_PREFIX(DotVec3)(VecOne, VecTwo); + + return (Result); +} + +COVERAGE(HMM_DotVec4CPP, 1) +HMM_INLINE float HMM_PREFIX(Dot)(hmm_vec4 VecOne, hmm_vec4 VecTwo) +{ + ASSERT_COVERED(HMM_DotVec4CPP); + + float Result = HMM_PREFIX(DotVec4)(VecOne, VecTwo); + + return (Result); +} + +COVERAGE(HMM_DotQuaternionCPP, 1) +HMM_INLINE float HMM_PREFIX(Dot)(hmm_quaternion QuatOne, hmm_quaternion QuatTwo) +{ + ASSERT_COVERED(HMM_DotQuaternionCPP); + + float Result = HMM_PREFIX(DotQuaternion)(QuatOne, QuatTwo); + + return (Result); +} + +COVERAGE(HMM_AddVec2CPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Add)(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_AddVec2CPP); + + hmm_vec2 Result = HMM_PREFIX(AddVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddVec3CPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Add)(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_AddVec3CPP); + + hmm_vec3 Result = HMM_PREFIX(AddVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Add)(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_AddVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(AddVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddMat4CPP, 1) +HMM_INLINE hmm_mat4 HMM_PREFIX(Add)(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_AddMat4CPP); + + hmm_mat4 Result = HMM_PREFIX(AddMat4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddQuaternionCPP, 1) +HMM_INLINE hmm_quaternion HMM_PREFIX(Add)(hmm_quaternion Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_AddQuaternionCPP); + + hmm_quaternion Result = HMM_PREFIX(AddQuaternion)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractVec2CPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Subtract)(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_SubtractVec2CPP); + + hmm_vec2 Result = HMM_PREFIX(SubtractVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractVec3CPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Subtract)(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_SubtractVec3CPP); + + hmm_vec3 Result = HMM_PREFIX(SubtractVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Subtract)(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_SubtractVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(SubtractVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractMat4CPP, 1) +HMM_INLINE hmm_mat4 HMM_PREFIX(Subtract)(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_SubtractMat4CPP); + + hmm_mat4 Result = HMM_PREFIX(SubtractMat4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractQuaternionCPP, 1) +HMM_INLINE hmm_quaternion HMM_PREFIX(Subtract)(hmm_quaternion Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_SubtractQuaternionCPP); + + hmm_quaternion Result = HMM_PREFIX(SubtractQuaternion)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec2CPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Multiply)(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2CPP); + + hmm_vec2 Result = HMM_PREFIX(MultiplyVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec2fCPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Multiply)(hmm_vec2 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2fCPP); + + hmm_vec2 Result = HMM_PREFIX(MultiplyVec2f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec3CPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Multiply)(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3CPP); + + hmm_vec3 Result = HMM_PREFIX(MultiplyVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec3fCPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Multiply)(hmm_vec3 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3fCPP); + + hmm_vec3 Result = HMM_PREFIX(MultiplyVec3f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Multiply)(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(MultiplyVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec4fCPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Multiply)(hmm_vec4 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4fCPP); + + hmm_vec4 Result = HMM_PREFIX(MultiplyVec4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4CPP, 1) +HMM_INLINE hmm_mat4 HMM_PREFIX(Multiply)(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4CPP); + + hmm_mat4 Result = HMM_PREFIX(MultiplyMat4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4fCPP, 1) +HMM_INLINE hmm_mat4 HMM_PREFIX(Multiply)(hmm_mat4 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4fCPP); + + hmm_mat4 Result = HMM_PREFIX(MultiplyMat4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4ByVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Multiply)(hmm_mat4 Matrix, hmm_vec4 Vector) +{ + ASSERT_COVERED(HMM_MultiplyMat4ByVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(MultiplyMat4ByVec4)(Matrix, Vector); + + return (Result); +} + +COVERAGE(HMM_MultiplyQuaternionCPP, 1) +HMM_INLINE hmm_quaternion HMM_PREFIX(Multiply)(hmm_quaternion Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_MultiplyQuaternionCPP); + + hmm_quaternion Result = HMM_PREFIX(MultiplyQuaternion)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyQuaternionFCPP, 1) +HMM_INLINE hmm_quaternion HMM_PREFIX(Multiply)(hmm_quaternion Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyQuaternionFCPP); + + hmm_quaternion Result = HMM_PREFIX(MultiplyQuaternionF)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec2CPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Divide)(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_DivideVec2CPP); + + hmm_vec2 Result = HMM_PREFIX(DivideVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec2fCPP, 1) +HMM_INLINE hmm_vec2 HMM_PREFIX(Divide)(hmm_vec2 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec2fCPP); + + hmm_vec2 Result = HMM_PREFIX(DivideVec2f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec3CPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Divide)(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_DivideVec3CPP); + + hmm_vec3 Result = HMM_PREFIX(DivideVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec3fCPP, 1) +HMM_INLINE hmm_vec3 HMM_PREFIX(Divide)(hmm_vec3 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec3fCPP); + + hmm_vec3 Result = HMM_PREFIX(DivideVec3f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec4CPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Divide)(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_DivideVec4CPP); + + hmm_vec4 Result = HMM_PREFIX(DivideVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec4fCPP, 1) +HMM_INLINE hmm_vec4 HMM_PREFIX(Divide)(hmm_vec4 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec4fCPP); + + hmm_vec4 Result = HMM_PREFIX(DivideVec4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideMat4fCPP, 1) +HMM_INLINE hmm_mat4 HMM_PREFIX(Divide)(hmm_mat4 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideMat4fCPP); + + hmm_mat4 Result = HMM_PREFIX(DivideMat4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideQuaternionFCPP, 1) +HMM_INLINE hmm_quaternion HMM_PREFIX(Divide)(hmm_quaternion Left, float Right) +{ + ASSERT_COVERED(HMM_DivideQuaternionFCPP); + + hmm_quaternion Result = HMM_PREFIX(DivideQuaternionF)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_EqualsVec2CPP, 1) +HMM_INLINE hmm_bool HMM_PREFIX(Equals)(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_EqualsVec2CPP); + + hmm_bool Result = HMM_PREFIX(EqualsVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_EqualsVec3CPP, 1) +HMM_INLINE hmm_bool HMM_PREFIX(Equals)(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_EqualsVec3CPP); + + hmm_bool Result = HMM_PREFIX(EqualsVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_EqualsVec4CPP, 1) +HMM_INLINE hmm_bool HMM_PREFIX(Equals)(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_EqualsVec4CPP); + + hmm_bool Result = HMM_PREFIX(EqualsVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddVec2Op, 1) +HMM_INLINE hmm_vec2 operator+(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_AddVec2Op); + + hmm_vec2 Result = HMM_PREFIX(AddVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddVec3Op, 1) +HMM_INLINE hmm_vec3 operator+(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_AddVec3Op); + + hmm_vec3 Result = HMM_PREFIX(AddVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddVec4Op, 1) +HMM_INLINE hmm_vec4 operator+(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_AddVec4Op); + + hmm_vec4 Result = HMM_PREFIX(AddVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddMat4Op, 1) +HMM_INLINE hmm_mat4 operator+(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_AddMat4Op); + + hmm_mat4 Result = HMM_PREFIX(AddMat4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddQuaternionOp, 1) +HMM_INLINE hmm_quaternion operator+(hmm_quaternion Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_AddQuaternionOp); + + hmm_quaternion Result = HMM_PREFIX(AddQuaternion)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractVec2Op, 1) +HMM_INLINE hmm_vec2 operator-(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_SubtractVec2Op); + + hmm_vec2 Result = HMM_PREFIX(SubtractVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractVec3Op, 1) +HMM_INLINE hmm_vec3 operator-(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_SubtractVec3Op); + + hmm_vec3 Result = HMM_PREFIX(SubtractVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractVec4Op, 1) +HMM_INLINE hmm_vec4 operator-(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_SubtractVec4Op); + + hmm_vec4 Result = HMM_PREFIX(SubtractVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractMat4Op, 1) +HMM_INLINE hmm_mat4 operator-(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_SubtractMat4Op); + + hmm_mat4 Result = HMM_PREFIX(SubtractMat4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_SubtractQuaternionOp, 1) +HMM_INLINE hmm_quaternion operator-(hmm_quaternion Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_SubtractQuaternionOp); + + hmm_quaternion Result = HMM_PREFIX(SubtractQuaternion)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec2Op, 1) +HMM_INLINE hmm_vec2 operator*(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2Op); + + hmm_vec2 Result = HMM_PREFIX(MultiplyVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec3Op, 1) +HMM_INLINE hmm_vec3 operator*(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3Op); + + hmm_vec3 Result = HMM_PREFIX(MultiplyVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec4Op, 1) +HMM_INLINE hmm_vec4 operator*(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4Op); + + hmm_vec4 Result = HMM_PREFIX(MultiplyVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4Op, 1) +HMM_INLINE hmm_mat4 operator*(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4Op); + + hmm_mat4 Result = HMM_PREFIX(MultiplyMat4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyQuaternionOp, 1) +HMM_INLINE hmm_quaternion operator*(hmm_quaternion Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_MultiplyQuaternionOp); + + hmm_quaternion Result = HMM_PREFIX(MultiplyQuaternion)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec2fOp, 1) +HMM_INLINE hmm_vec2 operator*(hmm_vec2 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2fOp); + + hmm_vec2 Result = HMM_PREFIX(MultiplyVec2f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec3fOp, 1) +HMM_INLINE hmm_vec3 operator*(hmm_vec3 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3fOp); + + hmm_vec3 Result = HMM_PREFIX(MultiplyVec3f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec4fOp, 1) +HMM_INLINE hmm_vec4 operator*(hmm_vec4 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4fOp); + + hmm_vec4 Result = HMM_PREFIX(MultiplyVec4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4fOp, 1) +HMM_INLINE hmm_mat4 operator*(hmm_mat4 Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4fOp); + + hmm_mat4 Result = HMM_PREFIX(MultiplyMat4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyQuaternionFOp, 1) +HMM_INLINE hmm_quaternion operator*(hmm_quaternion Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyQuaternionFOp); + + hmm_quaternion Result = HMM_PREFIX(MultiplyQuaternionF)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec2fOpLeft, 1) +HMM_INLINE hmm_vec2 operator*(float Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2fOpLeft); + + hmm_vec2 Result = HMM_PREFIX(MultiplyVec2f)(Right, Left); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec3fOpLeft, 1) +HMM_INLINE hmm_vec3 operator*(float Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3fOpLeft); + + hmm_vec3 Result = HMM_PREFIX(MultiplyVec3f)(Right, Left); + + return (Result); +} + +COVERAGE(HMM_MultiplyVec4fOpLeft, 1) +HMM_INLINE hmm_vec4 operator*(float Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4fOpLeft); + + hmm_vec4 Result = HMM_PREFIX(MultiplyVec4f)(Right, Left); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4fOpLeft, 1) +HMM_INLINE hmm_mat4 operator*(float Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4fOpLeft); + + hmm_mat4 Result = HMM_PREFIX(MultiplyMat4f)(Right, Left); + + return (Result); +} + +COVERAGE(HMM_MultiplyQuaternionFOpLeft, 1) +HMM_INLINE hmm_quaternion operator*(float Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_MultiplyQuaternionFOpLeft); + + hmm_quaternion Result = HMM_PREFIX(MultiplyQuaternionF)(Right, Left); + + return (Result); +} + +COVERAGE(HMM_MultiplyMat4ByVec4Op, 1) +HMM_INLINE hmm_vec4 operator*(hmm_mat4 Matrix, hmm_vec4 Vector) +{ + ASSERT_COVERED(HMM_MultiplyMat4ByVec4Op); + + hmm_vec4 Result = HMM_PREFIX(MultiplyMat4ByVec4)(Matrix, Vector); + + return (Result); +} + +COVERAGE(HMM_DivideVec2Op, 1) +HMM_INLINE hmm_vec2 operator/(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_DivideVec2Op); + + hmm_vec2 Result = HMM_PREFIX(DivideVec2)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec3Op, 1) +HMM_INLINE hmm_vec3 operator/(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_DivideVec3Op); + + hmm_vec3 Result = HMM_PREFIX(DivideVec3)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec4Op, 1) +HMM_INLINE hmm_vec4 operator/(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_DivideVec4Op); + + hmm_vec4 Result = HMM_PREFIX(DivideVec4)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec2fOp, 1) +HMM_INLINE hmm_vec2 operator/(hmm_vec2 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec2fOp); + + hmm_vec2 Result = HMM_PREFIX(DivideVec2f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec3fOp, 1) +HMM_INLINE hmm_vec3 operator/(hmm_vec3 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec3fOp); + + hmm_vec3 Result = HMM_PREFIX(DivideVec3f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideVec4fOp, 1) +HMM_INLINE hmm_vec4 operator/(hmm_vec4 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec4fOp); + + hmm_vec4 Result = HMM_PREFIX(DivideVec4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideMat4fOp, 1) +HMM_INLINE hmm_mat4 operator/(hmm_mat4 Left, float Right) +{ + ASSERT_COVERED(HMM_DivideMat4fOp); + + hmm_mat4 Result = HMM_PREFIX(DivideMat4f)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_DivideQuaternionFOp, 1) +HMM_INLINE hmm_quaternion operator/(hmm_quaternion Left, float Right) +{ + ASSERT_COVERED(HMM_DivideQuaternionFOp); + + hmm_quaternion Result = HMM_PREFIX(DivideQuaternionF)(Left, Right); + + return (Result); +} + +COVERAGE(HMM_AddVec2Assign, 1) +HMM_INLINE hmm_vec2 &operator+=(hmm_vec2 &Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_AddVec2Assign); + + return (Left = Left + Right); +} + +COVERAGE(HMM_AddVec3Assign, 1) +HMM_INLINE hmm_vec3 &operator+=(hmm_vec3 &Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_AddVec3Assign); + + return (Left = Left + Right); +} + +COVERAGE(HMM_AddVec4Assign, 1) +HMM_INLINE hmm_vec4 &operator+=(hmm_vec4 &Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_AddVec4Assign); + + return (Left = Left + Right); +} + +COVERAGE(HMM_AddMat4Assign, 1) +HMM_INLINE hmm_mat4 &operator+=(hmm_mat4 &Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_AddMat4Assign); + + return (Left = Left + Right); +} + +COVERAGE(HMM_AddQuaternionAssign, 1) +HMM_INLINE hmm_quaternion &operator+=(hmm_quaternion &Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_AddQuaternionAssign); + + return (Left = Left + Right); +} + +COVERAGE(HMM_SubtractVec2Assign, 1) +HMM_INLINE hmm_vec2 &operator-=(hmm_vec2 &Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_SubtractVec2Assign); + + return (Left = Left - Right); +} + +COVERAGE(HMM_SubtractVec3Assign, 1) +HMM_INLINE hmm_vec3 &operator-=(hmm_vec3 &Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_SubtractVec3Assign); + + return (Left = Left - Right); +} + +COVERAGE(HMM_SubtractVec4Assign, 1) +HMM_INLINE hmm_vec4 &operator-=(hmm_vec4 &Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_SubtractVec4Assign); + + return (Left = Left - Right); +} + +COVERAGE(HMM_SubtractMat4Assign, 1) +HMM_INLINE hmm_mat4 &operator-=(hmm_mat4 &Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_SubtractMat4Assign); + + return (Left = Left - Right); +} + +COVERAGE(HMM_SubtractQuaternionAssign, 1) +HMM_INLINE hmm_quaternion &operator-=(hmm_quaternion &Left, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_SubtractQuaternionAssign); + + return (Left = Left - Right); +} + +COVERAGE(HMM_MultiplyVec2Assign, 1) +HMM_INLINE hmm_vec2 &operator*=(hmm_vec2 &Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2Assign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyVec3Assign, 1) +HMM_INLINE hmm_vec3 &operator*=(hmm_vec3 &Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3Assign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyVec4Assign, 1) +HMM_INLINE hmm_vec4 &operator*=(hmm_vec4 &Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4Assign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyVec2fAssign, 1) +HMM_INLINE hmm_vec2 &operator*=(hmm_vec2 &Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec2fAssign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyVec3fAssign, 1) +HMM_INLINE hmm_vec3 &operator*=(hmm_vec3 &Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec3fAssign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyVec4fAssign, 1) +HMM_INLINE hmm_vec4 &operator*=(hmm_vec4 &Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyVec4fAssign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyMat4fAssign, 1) +HMM_INLINE hmm_mat4 &operator*=(hmm_mat4 &Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4fAssign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_MultiplyQuaternionFAssign, 1) +HMM_INLINE hmm_quaternion &operator*=(hmm_quaternion &Left, float Right) +{ + ASSERT_COVERED(HMM_MultiplyQuaternionFAssign); + + return (Left = Left * Right); +} + +COVERAGE(HMM_DivideVec2Assign, 1) +HMM_INLINE hmm_vec2 &operator/=(hmm_vec2 &Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_DivideVec2Assign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideVec3Assign, 1) +HMM_INLINE hmm_vec3 &operator/=(hmm_vec3 &Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_DivideVec3Assign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideVec4Assign, 1) +HMM_INLINE hmm_vec4 &operator/=(hmm_vec4 &Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_DivideVec4Assign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideVec2fAssign, 1) +HMM_INLINE hmm_vec2 &operator/=(hmm_vec2 &Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec2fAssign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideVec3fAssign, 1) +HMM_INLINE hmm_vec3 &operator/=(hmm_vec3 &Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec3fAssign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideVec4fAssign, 1) +HMM_INLINE hmm_vec4 &operator/=(hmm_vec4 &Left, float Right) +{ + ASSERT_COVERED(HMM_DivideVec4fAssign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideMat4fAssign, 1) +HMM_INLINE hmm_mat4 &operator/=(hmm_mat4 &Left, float Right) +{ + ASSERT_COVERED(HMM_DivideMat4fAssign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_DivideQuaternionFAssign, 1) +HMM_INLINE hmm_quaternion &operator/=(hmm_quaternion &Left, float Right) +{ + ASSERT_COVERED(HMM_DivideQuaternionFAssign); + + return (Left = Left / Right); +} + +COVERAGE(HMM_EqualsVec2Op, 1) +HMM_INLINE hmm_bool operator==(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_EqualsVec2Op); + + return HMM_PREFIX(EqualsVec2)(Left, Right); +} + +COVERAGE(HMM_EqualsVec3Op, 1) +HMM_INLINE hmm_bool operator==(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_EqualsVec3Op); + + return HMM_PREFIX(EqualsVec3)(Left, Right); +} + +COVERAGE(HMM_EqualsVec4Op, 1) +HMM_INLINE hmm_bool operator==(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_EqualsVec4Op); + + return HMM_PREFIX(EqualsVec4)(Left, Right); +} + +COVERAGE(HMM_EqualsVec2OpNot, 1) +HMM_INLINE hmm_bool operator!=(hmm_vec2 Left, hmm_vec2 Right) +{ + ASSERT_COVERED(HMM_EqualsVec2OpNot); + + return !HMM_PREFIX(EqualsVec2)(Left, Right); +} + +COVERAGE(HMM_EqualsVec3OpNot, 1) +HMM_INLINE hmm_bool operator!=(hmm_vec3 Left, hmm_vec3 Right) +{ + ASSERT_COVERED(HMM_EqualsVec3OpNot); + + return !HMM_PREFIX(EqualsVec3)(Left, Right); +} + +COVERAGE(HMM_EqualsVec4OpNot, 1) +HMM_INLINE hmm_bool operator!=(hmm_vec4 Left, hmm_vec4 Right) +{ + ASSERT_COVERED(HMM_EqualsVec4OpNot); + + return !HMM_PREFIX(EqualsVec4)(Left, Right); +} + +#endif /* __cplusplus */ + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif + +#endif /* HANDMADE_MATH_H */ + +#ifdef HANDMADE_MATH_IMPLEMENTATION + +COVERAGE(HMM_Power, 2) +float HMM_PREFIX(Power)(float Base, int Exponent) +{ + ASSERT_COVERED(HMM_Power); + + float Result = 1.0f; + float Mul = Exponent < 0 ? 1.f / Base : Base; + int X = Exponent < 0 ? -Exponent : Exponent; + while (X) + { + if (X & 1) + { + ASSERT_COVERED(HMM_Power); + + Result *= Mul; + } + + Mul *= Mul; + X >>= 1; + } + + return (Result); +} + +#ifndef HANDMADE_MATH__USE_SSE +COVERAGE(HMM_Transpose, 1) +hmm_mat4 HMM_PREFIX(Transpose)(hmm_mat4 Matrix) +{ + ASSERT_COVERED(HMM_Transpose); + + hmm_mat4 Result; + + int Columns; + for(Columns = 0; Columns < 4; ++Columns) + { + int Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + Result.Elements[Rows][Columns] = Matrix.Elements[Columns][Rows]; + } + } + + return (Result); +} +#endif + +#ifndef HANDMADE_MATH__USE_SSE +COVERAGE(HMM_AddMat4, 1) +hmm_mat4 HMM_PREFIX(AddMat4)(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_AddMat4); + + hmm_mat4 Result; + + int Columns; + for(Columns = 0; Columns < 4; ++Columns) + { + int Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + Result.Elements[Columns][Rows] = Left.Elements[Columns][Rows] + Right.Elements[Columns][Rows]; + } + } + + return (Result); +} +#endif + +#ifndef HANDMADE_MATH__USE_SSE +COVERAGE(HMM_SubtractMat4, 1) +hmm_mat4 HMM_PREFIX(SubtractMat4)(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_SubtractMat4); + + hmm_mat4 Result; + + int Columns; + for(Columns = 0; Columns < 4; ++Columns) + { + int Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + Result.Elements[Columns][Rows] = Left.Elements[Columns][Rows] - Right.Elements[Columns][Rows]; + } + } + + return (Result); +} +#endif + +COVERAGE(HMM_MultiplyMat4, 1) +hmm_mat4 HMM_PREFIX(MultiplyMat4)(hmm_mat4 Left, hmm_mat4 Right) +{ + ASSERT_COVERED(HMM_MultiplyMat4); + + hmm_mat4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.Columns[0] = HMM_PREFIX(LinearCombineSSE)(Right.Columns[0], Left); + Result.Columns[1] = HMM_PREFIX(LinearCombineSSE)(Right.Columns[1], Left); + Result.Columns[2] = HMM_PREFIX(LinearCombineSSE)(Right.Columns[2], Left); + Result.Columns[3] = HMM_PREFIX(LinearCombineSSE)(Right.Columns[3], Left); +#else + int Columns; + for(Columns = 0; Columns < 4; ++Columns) + { + int Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + float Sum = 0; + int CurrentMatrice; + for(CurrentMatrice = 0; CurrentMatrice < 4; ++CurrentMatrice) + { + Sum += Left.Elements[CurrentMatrice][Rows] * Right.Elements[Columns][CurrentMatrice]; + } + + Result.Elements[Columns][Rows] = Sum; + } + } +#endif + + return (Result); +} + +#ifndef HANDMADE_MATH__USE_SSE +COVERAGE(HMM_MultiplyMat4f, 1) +hmm_mat4 HMM_PREFIX(MultiplyMat4f)(hmm_mat4 Matrix, float Scalar) +{ + ASSERT_COVERED(HMM_MultiplyMat4f); + + hmm_mat4 Result; + + int Columns; + for(Columns = 0; Columns < 4; ++Columns) + { + int Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + Result.Elements[Columns][Rows] = Matrix.Elements[Columns][Rows] * Scalar; + } + } + + return (Result); +} +#endif + +COVERAGE(HMM_MultiplyMat4ByVec4, 1) +hmm_vec4 HMM_PREFIX(MultiplyMat4ByVec4)(hmm_mat4 Matrix, hmm_vec4 Vector) +{ + ASSERT_COVERED(HMM_MultiplyMat4ByVec4); + + hmm_vec4 Result; + +#ifdef HANDMADE_MATH__USE_SSE + Result.InternalElementsSSE = HMM_PREFIX(LinearCombineSSE)(Vector.InternalElementsSSE, Matrix); +#else + int Columns, Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + float Sum = 0; + for(Columns = 0; Columns < 4; ++Columns) + { + Sum += Matrix.Elements[Columns][Rows] * Vector.Elements[Columns]; + } + + Result.Elements[Rows] = Sum; + } +#endif + + return (Result); +} + +#ifndef HANDMADE_MATH__USE_SSE +COVERAGE(HMM_DivideMat4f, 1); +hmm_mat4 HMM_PREFIX(DivideMat4f)(hmm_mat4 Matrix, float Scalar) +{ + ASSERT_COVERED(HMM_DivideMat4f); + + hmm_mat4 Result; + + int Columns; + for(Columns = 0; Columns < 4; ++Columns) + { + int Rows; + for(Rows = 0; Rows < 4; ++Rows) + { + Result.Elements[Columns][Rows] = Matrix.Elements[Columns][Rows] / Scalar; + } + } + + return (Result); +} +#endif + +COVERAGE(HMM_Rotate, 1) +hmm_mat4 HMM_PREFIX(Rotate)(float Angle, hmm_vec3 Axis) +{ + ASSERT_COVERED(HMM_Rotate); + + hmm_mat4 Result = HMM_PREFIX(Mat4d)(1.0f); + + Axis = HMM_PREFIX(NormalizeVec3)(Axis); + + float SinTheta = HMM_PREFIX(SinF)(HMM_PREFIX(ToRadians)(Angle)); + float CosTheta = HMM_PREFIX(CosF)(HMM_PREFIX(ToRadians)(Angle)); + float CosValue = 1.0f - CosTheta; + + Result.Elements[0][0] = (Axis.X * Axis.X * CosValue) + CosTheta; + Result.Elements[0][1] = (Axis.X * Axis.Y * CosValue) + (Axis.Z * SinTheta); + Result.Elements[0][2] = (Axis.X * Axis.Z * CosValue) - (Axis.Y * SinTheta); + + Result.Elements[1][0] = (Axis.Y * Axis.X * CosValue) - (Axis.Z * SinTheta); + Result.Elements[1][1] = (Axis.Y * Axis.Y * CosValue) + CosTheta; + Result.Elements[1][2] = (Axis.Y * Axis.Z * CosValue) + (Axis.X * SinTheta); + + Result.Elements[2][0] = (Axis.Z * Axis.X * CosValue) + (Axis.Y * SinTheta); + Result.Elements[2][1] = (Axis.Z * Axis.Y * CosValue) - (Axis.X * SinTheta); + Result.Elements[2][2] = (Axis.Z * Axis.Z * CosValue) + CosTheta; + + return (Result); +} + +COVERAGE(HMM_LookAt, 1) +hmm_mat4 HMM_PREFIX(LookAt)(hmm_vec3 Eye, hmm_vec3 Center, hmm_vec3 Up) +{ + ASSERT_COVERED(HMM_LookAt); + + hmm_mat4 Result; + + hmm_vec3 F = HMM_PREFIX(NormalizeVec3)(HMM_PREFIX(SubtractVec3)(Center, Eye)); + hmm_vec3 S = HMM_PREFIX(NormalizeVec3)(HMM_PREFIX(Cross)(F, Up)); + hmm_vec3 U = HMM_PREFIX(Cross)(S, F); + + Result.Elements[0][0] = S.X; + Result.Elements[0][1] = U.X; + Result.Elements[0][2] = -F.X; + Result.Elements[0][3] = 0.0f; + + Result.Elements[1][0] = S.Y; + Result.Elements[1][1] = U.Y; + Result.Elements[1][2] = -F.Y; + Result.Elements[1][3] = 0.0f; + + Result.Elements[2][0] = S.Z; + Result.Elements[2][1] = U.Z; + Result.Elements[2][2] = -F.Z; + Result.Elements[2][3] = 0.0f; + + Result.Elements[3][0] = -HMM_PREFIX(DotVec3)(S, Eye); + Result.Elements[3][1] = -HMM_PREFIX(DotVec3)(U, Eye); + Result.Elements[3][2] = HMM_PREFIX(DotVec3)(F, Eye); + Result.Elements[3][3] = 1.0f; + + return (Result); +} + +COVERAGE(HMM_InverseQuaternion, 1) +hmm_quaternion HMM_PREFIX(InverseQuaternion)(hmm_quaternion Left) +{ + ASSERT_COVERED(HMM_InverseQuaternion); + + hmm_quaternion Conjugate; + hmm_quaternion Result; + float Norm = 0; + float NormSquared = 0; + + Conjugate.X = -Left.X; + Conjugate.Y = -Left.Y; + Conjugate.Z = -Left.Z; + Conjugate.W = Left.W; + + Norm = HMM_PREFIX(SquareRootF)(HMM_PREFIX(DotQuaternion)(Left, Left)); + NormSquared = Norm * Norm; + + Result = HMM_PREFIX(DivideQuaternionF)(Conjugate, NormSquared); + + return (Result); +} + +COVERAGE(HMM_Slerp, 1) +hmm_quaternion HMM_PREFIX(Slerp)(hmm_quaternion Left, float Time, hmm_quaternion Right) +{ + ASSERT_COVERED(HMM_Slerp); + + hmm_quaternion Result; + hmm_quaternion QuaternionLeft; + hmm_quaternion QuaternionRight; + + float Cos_Theta = HMM_PREFIX(DotQuaternion)(Left, Right); + float Angle = HMM_PREFIX(ACosF)(Cos_Theta); + + float S1 = HMM_PREFIX(SinF)((1.0f - Time) * Angle); + float S2 = HMM_PREFIX(SinF)(Time * Angle); + float Is = 1.0f / HMM_PREFIX(SinF)(Angle); + + QuaternionLeft = HMM_PREFIX(MultiplyQuaternionF)(Left, S1); + QuaternionRight = HMM_PREFIX(MultiplyQuaternionF)(Right, S2); + + Result = HMM_PREFIX(AddQuaternion)(QuaternionLeft, QuaternionRight); + Result = HMM_PREFIX(MultiplyQuaternionF)(Result, Is); + + return (Result); +} + +COVERAGE(HMM_QuaternionToMat4, 1) +hmm_mat4 HMM_PREFIX(QuaternionToMat4)(hmm_quaternion Left) +{ + ASSERT_COVERED(HMM_QuaternionToMat4); + + hmm_mat4 Result; + + hmm_quaternion NormalizedQuaternion = HMM_PREFIX(NormalizeQuaternion)(Left); + + float XX, YY, ZZ, + XY, XZ, YZ, + WX, WY, WZ; + + XX = NormalizedQuaternion.X * NormalizedQuaternion.X; + YY = NormalizedQuaternion.Y * NormalizedQuaternion.Y; + ZZ = NormalizedQuaternion.Z * NormalizedQuaternion.Z; + XY = NormalizedQuaternion.X * NormalizedQuaternion.Y; + XZ = NormalizedQuaternion.X * NormalizedQuaternion.Z; + YZ = NormalizedQuaternion.Y * NormalizedQuaternion.Z; + WX = NormalizedQuaternion.W * NormalizedQuaternion.X; + WY = NormalizedQuaternion.W * NormalizedQuaternion.Y; + WZ = NormalizedQuaternion.W * NormalizedQuaternion.Z; + + Result.Elements[0][0] = 1.0f - 2.0f * (YY + ZZ); + Result.Elements[0][1] = 2.0f * (XY + WZ); + Result.Elements[0][2] = 2.0f * (XZ - WY); + Result.Elements[0][3] = 0.0f; + + Result.Elements[1][0] = 2.0f * (XY - WZ); + Result.Elements[1][1] = 1.0f - 2.0f * (XX + ZZ); + Result.Elements[1][2] = 2.0f * (YZ + WX); + Result.Elements[1][3] = 0.0f; + + Result.Elements[2][0] = 2.0f * (XZ + WY); + Result.Elements[2][1] = 2.0f * (YZ - WX); + Result.Elements[2][2] = 1.0f - 2.0f * (XX + YY); + Result.Elements[2][3] = 0.0f; + + Result.Elements[3][0] = 0.0f; + Result.Elements[3][1] = 0.0f; + Result.Elements[3][2] = 0.0f; + Result.Elements[3][3] = 1.0f; + + return (Result); +} + +// This method taken from Mike Day at Insomniac Games. +// https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2015/01/matrix-to-quat.pdf +// +// Note that as mentioned at the top of the paper, the paper assumes the matrix +// would be *post*-multiplied to a vector to rotate it, meaning the matrix is +// the transpose of what we're dealing with. But, because our matrices are +// stored in column-major order, the indices *appear* to match the paper. +// +// For example, m12 in the paper is row 1, column 2. We need to transpose it to +// row 2, column 1. But, because the column comes first when referencing +// elements, it looks like M.Elements[1][2]. +// +// Don't be confused! Or if you must be confused, at least trust this +// comment. :) +COVERAGE(HMM_Mat4ToQuaternion, 4) +hmm_quaternion HMM_PREFIX(Mat4ToQuaternion)(hmm_mat4 M) +{ + float T; + hmm_quaternion Q; + + if (M.Elements[2][2] < 0.0f) { + if (M.Elements[0][0] > M.Elements[1][1]) { + ASSERT_COVERED(HMM_Mat4ToQuaternion); + + T = 1 + M.Elements[0][0] - M.Elements[1][1] - M.Elements[2][2]; + Q = HMM_PREFIX(Quaternion)( + T, + M.Elements[0][1] + M.Elements[1][0], + M.Elements[2][0] + M.Elements[0][2], + M.Elements[1][2] - M.Elements[2][1] + ); + } else { + ASSERT_COVERED(HMM_Mat4ToQuaternion); + + T = 1 - M.Elements[0][0] + M.Elements[1][1] - M.Elements[2][2]; + Q = HMM_PREFIX(Quaternion)( + M.Elements[0][1] + M.Elements[1][0], + T, + M.Elements[1][2] + M.Elements[2][1], + M.Elements[2][0] - M.Elements[0][2] + ); + } + } else { + if (M.Elements[0][0] < -M.Elements[1][1]) { + ASSERT_COVERED(HMM_Mat4ToQuaternion); + + T = 1 - M.Elements[0][0] - M.Elements[1][1] + M.Elements[2][2]; + Q = HMM_PREFIX(Quaternion)( + M.Elements[2][0] + M.Elements[0][2], + M.Elements[1][2] + M.Elements[2][1], + T, + M.Elements[0][1] - M.Elements[1][0] + ); + } else { + ASSERT_COVERED(HMM_Mat4ToQuaternion); + + T = 1 + M.Elements[0][0] + M.Elements[1][1] + M.Elements[2][2]; + Q = HMM_PREFIX(Quaternion)( + M.Elements[1][2] - M.Elements[2][1], + M.Elements[2][0] - M.Elements[0][2], + M.Elements[0][1] - M.Elements[1][0], + T + ); + } + } + + Q = HMM_PREFIX(MultiplyQuaternionF)(Q, 0.5f / HMM_PREFIX(SquareRootF)(T)); + + return Q; +} + +COVERAGE(HMM_QuaternionFromAxisAngle, 1) +hmm_quaternion HMM_PREFIX(QuaternionFromAxisAngle)(hmm_vec3 Axis, float AngleOfRotation) +{ + ASSERT_COVERED(HMM_QuaternionFromAxisAngle); + + hmm_quaternion Result; + + hmm_vec3 AxisNormalized = HMM_PREFIX(NormalizeVec3)(Axis); + float SineOfRotation = HMM_PREFIX(SinF)(AngleOfRotation / 2.0f); + + Result.XYZ = HMM_PREFIX(MultiplyVec3f)(AxisNormalized, SineOfRotation); + Result.W = HMM_PREFIX(CosF)(AngleOfRotation / 2.0f); + + return (Result); +} + +#endif /* HANDMADE_MATH_IMPLEMENTATION */ \ No newline at end of file diff --git a/src/app/interface.h b/src/app/interface.h index 33a50ac..d382f4c 100644 --- a/src/app/interface.h +++ b/src/app/interface.h @@ -5,7 +5,7 @@ // #ifndef INTERFACE_H -enum string_alignment +enum gs_string_alignment { Align_Left, Align_Center, @@ -60,10 +60,10 @@ DrawCharacterRightAligned (render_quad_batch_constructor* BatchConstructor, char } internal v2 -DrawStringLeftAligned (render_quad_batch_constructor* BatchConstructor, s32 Length, char* String, v2 InitialRegisterPosition, bitmap_font* Font, v4 Color) +DrawStringLeftAligned (render_quad_batch_constructor* BatchConstructor, s32 Length, char* gs_string, v2 InitialRegisterPosition, bitmap_font* Font, v4 Color) { v2 RegisterPosition = InitialRegisterPosition; - char* C = String; + char* C = gs_string; for (s32 i = 0; i < Length; i++) { v2 PositionAfterCharacter = DrawCharacterLeftAligned(BatchConstructor, *C, *Font, RegisterPosition, Color); @@ -74,10 +74,10 @@ DrawStringLeftAligned (render_quad_batch_constructor* BatchConstructor, s32 Leng } internal v2 -DrawStringRightAligned (render_quad_batch_constructor* BatchConstructor, s32 Length, char* String, v2 InitialRegisterPosition, bitmap_font* Font, v4 Color) +DrawStringRightAligned (render_quad_batch_constructor* BatchConstructor, s32 Length, char* gs_string, v2 InitialRegisterPosition, bitmap_font* Font, v4 Color) { v2 RegisterPosition = InitialRegisterPosition; - char* C = String + Length - 1; + char* C = gs_string + Length - 1; for (s32 i = Length - 1; i >= 0; i--) { v2 PositionAfterCharacter = DrawCharacterRightAligned(BatchConstructor, *C, *Font, RegisterPosition, Color); @@ -88,7 +88,7 @@ DrawStringRightAligned (render_quad_batch_constructor* BatchConstructor, s32 Len } internal v2 -DrawString (render_command_buffer* RenderBuffer, string String, bitmap_font* Font, v2 Position, v4 Color, string_alignment Alignment = Align_Left) +DrawString(render_command_buffer* RenderBuffer, gs_string String, bitmap_font* Font, v2 Position, v4 Color, gs_string_alignment Alignment = Align_Left) { DEBUG_TRACK_FUNCTION; v2 LowerRight = Position; @@ -129,7 +129,7 @@ DrawCursor (render_quad_batch_constructor* BatchConstructor, v2 Position, v4 Col } internal v2 -DrawStringWithCursor (render_command_buffer* RenderBuffer, string String, s32 CursorPosition, bitmap_font* Font, v2 Position, v4 Color, v4 CursorColor, string_alignment Alignment = Align_Left) +Drawgs_stringWithCursor (render_command_buffer* RenderBuffer, gs_string String, s32 CursorPosition, bitmap_font* Font, v2 Position, v4 Color, v4 CursorColor, gs_string_alignment Alignment = Align_Left) { DEBUG_TRACK_FUNCTION; v2 LowerRight = Position; @@ -153,21 +153,21 @@ DrawStringWithCursor (render_command_buffer* RenderBuffer, string String, s32 Cu { RegisterPosition = DrawStringLeftAligned(&BatchConstructor, String.Length - CursorPosition, - String.Memory + CursorPosition, + String.Str + CursorPosition, RegisterPosition, Font, Color); } } else if (Alignment == Align_Right) { RegisterPosition = DrawStringRightAligned(&BatchConstructor, - CursorPosition, String.Memory, + CursorPosition, String.Str, RegisterPosition, Font, Color); DrawCursor(&CursorBatch, RegisterPosition, GreenV4, *Font); if (String.Length - CursorPosition > 0) { RegisterPosition = DrawStringRightAligned(&BatchConstructor, String.Length - CursorPosition, - String.Memory + CursorPosition, + String.Str + CursorPosition, RegisterPosition, Font, Color); } } @@ -201,7 +201,7 @@ struct interface_config struct ui_layout { - rect Bounds; + rect2 Bounds; v2 Margin; r32 RowHeight; r32 RowYAt; @@ -220,7 +220,7 @@ struct ui_interface }; static ui_layout -ui_CreateLayout(ui_interface Interface, rect Bounds) +ui_CreateLayout(ui_interface Interface, rect2 Bounds) { ui_layout Result = {0}; Result.Bounds = Bounds; @@ -263,7 +263,7 @@ ui_EndRow(ui_layout* Layout) } static b32 -ui_TryReserveElementBounds(ui_layout* Layout, rect* Bounds) +ui_TryReserveElementBounds(ui_layout* Layout, rect2* Bounds) { b32 Result = true; if (!Layout->DrawHorizontal) @@ -289,7 +289,7 @@ ui_TryReserveElementBounds(ui_layout* Layout, rect* Bounds) } else { - r32 ElementWidth = gs_Width(Layout->Bounds) / Layout->ColumnsMax; + r32 ElementWidth = Rect2Width(Layout->Bounds) / Layout->ColumnsMax; Bounds->Min = { Layout->Bounds.Min.x + (ElementWidth * Layout->ColumnsCount) + Layout->Margin.x, Layout->RowYAt @@ -309,18 +309,18 @@ ui_TryReserveElementBounds(ui_layout* Layout, rect* Bounds) return Result; } -static rect -ui_ReserveTextLineBounds(ui_interface Interface, string Text, ui_layout* Layout) +static rect2 +ui_ReserveTextLineBounds(ui_interface Interface, gs_string Text, ui_layout* Layout) { - rect Bounds = {0}; + rect2 Bounds = {0}; return Bounds; } -static rect +static rect2 ui_ReserveElementBounds(ui_layout* Layout) { - rect Bounds = {0}; + rect2 Bounds = {0}; if (!ui_TryReserveElementBounds(Layout, &Bounds)) { InvalidCodePath; @@ -328,10 +328,10 @@ ui_ReserveElementBounds(ui_layout* Layout) return Bounds; } -static rect +static rect2 ui_LayoutRemaining(ui_layout Layout) { - rect Result = Layout.Bounds; + rect2 Result = Layout.Bounds; Result.Max.y = Layout.RowYAt; if (Layout.DrawHorizontal) { @@ -352,19 +352,19 @@ ui_GetTextLineHeight(ui_interface Interface) } static void -ui_FillRect(ui_interface* Interface, rect Bounds, v4 Color) +ui_FillRect(ui_interface* Interface, rect2 Bounds, v4 Color) { - PushRenderQuad2D(Interface->RenderBuffer, gs_RectExpand(Bounds), Color); + PushRenderQuad2D(Interface->RenderBuffer, Bounds.Min, Bounds.Max, Color); } static void -ui_OutlineRect(ui_interface* Interface, rect Bounds, r32 Thickness, v4 Color) +ui_OutlineRect(ui_interface* Interface, rect2 Bounds, r32 Thickness, v4 Color) { PushRenderBoundingBox2D(Interface->RenderBuffer, Bounds.Min, Bounds.Max, Thickness, Color); } internal void -ui_DrawString(ui_interface* Interface, string String, rect Bounds, v4 Color, string_alignment Alignment = Align_Left) +ui_DrawString(ui_interface* Interface, gs_string String, rect2 Bounds, v4 Color, gs_string_alignment Alignment = Align_Left) { DEBUG_TRACK_FUNCTION; render_quad_batch_constructor BatchConstructor = PushRenderTexture2DBatch(Interface->RenderBuffer, @@ -392,9 +392,9 @@ ui_DrawString(ui_interface* Interface, string String, rect Bounds, v4 Color, str } static void -ui_LayoutDrawString(ui_interface* Interface, ui_layout* Layout, string String, v4 Color, string_alignment Alignment = Align_Left) +ui_LayoutDrawString(ui_interface* Interface, ui_layout* Layout, gs_string String, v4 Color, gs_string_alignment Alignment = Align_Left) { - rect Bounds = {0}; + rect2 Bounds = {0}; if (!ui_TryReserveElementBounds(Layout, &Bounds)) { // TODO(NAME): Not invalid, just haven't implemented yet. @@ -405,18 +405,18 @@ ui_LayoutDrawString(ui_interface* Interface, ui_layout* Layout, string String, v } static void -ui_TextBox(ui_interface* Interface, rect Bounds, string Text, v4 BGColor, v4 TextColor) +ui_TextBox(ui_interface* Interface, rect2 Bounds, gs_string Text, v4 BGColor, v4 TextColor) { ui_FillRect(Interface, Bounds, BGColor); ui_DrawString(Interface, Text, Bounds, TextColor); } static b32 -ui_Button(ui_interface* Interface, string Text, rect Bounds, v4 InactiveColor, v4 HoverColor, v4 ClickedColor) +ui_Button(ui_interface* Interface, gs_string Text, rect2 Bounds, v4 InactiveColor, v4 HoverColor, v4 ClickedColor) { b32 Pressed = false; v4 ButtonBG = InactiveColor; - if (gs_PointIsInRect(Interface->Mouse.Pos, Bounds)) + if (PointIsInRect(Bounds, Interface->Mouse.Pos)) { ButtonBG = HoverColor; if (MouseButtonTransitionedDown(Interface->Mouse.LeftButtonState)) @@ -430,7 +430,7 @@ ui_Button(ui_interface* Interface, string Text, rect Bounds, v4 InactiveColor, v } static b32 -ui_Button(ui_interface* Interface, string Text, rect Bounds) +ui_Button(ui_interface* Interface, gs_string Text, rect2 Bounds) { v4 BGColor = Interface->Style.ButtonColor_Inactive; v4 HoverColor = Interface->Style.ButtonColor_Active; @@ -463,16 +463,16 @@ ui_GetListItemColors(ui_interface* Interface, u32 ListItemIndex) } static b32 -ui_ListButton(ui_interface* Interface, string Text, rect Bounds, u32 ListItemIndex) +ui_ListButton(ui_interface* Interface, gs_string Text, rect2 Bounds, u32 ListItemIndex) { list_item_colors Colors = ui_GetListItemColors(Interface, ListItemIndex); return ui_Button(Interface, Text, Bounds, Colors.Hover, Colors.Selected, Colors.BGColor); } static b32 -ui_LayoutButton(ui_interface* Interface, ui_layout* Layout, string Text, v4 BGColor, v4 HoverColor, v4 SelectColor) +ui_LayoutButton(ui_interface* Interface, ui_layout* Layout, gs_string Text, v4 BGColor, v4 HoverColor, v4 SelectColor) { - rect ButtonBounds = {0}; + rect2 ButtonBounds = {0}; if (!ui_TryReserveElementBounds(Layout, &ButtonBounds)) { ButtonBounds = ui_ReserveTextLineBounds(*Interface, Text, Layout); @@ -481,7 +481,7 @@ ui_LayoutButton(ui_interface* Interface, ui_layout* Layout, string Text, v4 BGCo } static b32 -ui_LayoutButton(ui_interface* Interface, ui_layout* Layout, string Text) +ui_LayoutButton(ui_interface* Interface, ui_layout* Layout, gs_string Text) { v4 BGColor = Interface->Style.ButtonColor_Inactive; v4 HoverColor = Interface->Style.ButtonColor_Active; @@ -490,16 +490,16 @@ ui_LayoutButton(ui_interface* Interface, ui_layout* Layout, string Text) } static b32 -ui_LayoutListButton(ui_interface* Interface, ui_layout* Layout, string Text, u32 ListItemIndex) +ui_LayoutListButton(ui_interface* Interface, ui_layout* Layout, gs_string Text, u32 ListItemIndex) { list_item_colors Colors = ui_GetListItemColors(Interface, ListItemIndex); return ui_LayoutButton(Interface, Layout, Text, Colors.Hover, Colors.Selected, Colors.BGColor); } static b32 -ui_LayoutListEntry(ui_interface* Interface, ui_layout* Layout, string Text, u32 Index) +ui_LayoutListEntry(ui_interface* Interface, ui_layout* Layout, gs_string Text, u32 Index) { - rect Bounds = {0}; + rect2 Bounds = {0}; if (!ui_TryReserveElementBounds(Layout, &Bounds)) { // TODO(Peter): this isn't really invalid, but I don't have a concrete use case @@ -527,7 +527,7 @@ enum selection_state struct interface_list { - rect ListBounds; + rect2 ListBounds; v2 ListElementDimensions; v2 ElementLabelIndent; @@ -540,10 +540,10 @@ struct interface_list s32 ListElementsCount; }; -internal rect +internal rect2 DrawListElementBackground(interface_list* List, mouse_state Mouse, render_command_buffer* RenderBuffer) { - rect LineBounds = {}; + rect2 LineBounds = {}; LineBounds.Min = v2{ List->ListBounds.Min.x, List->ListBounds.Max.y - (List->ListElementDimensions.y * (List->ListElementsCount + 1)) @@ -551,7 +551,7 @@ DrawListElementBackground(interface_list* List, mouse_state Mouse, render_comman LineBounds.Max = LineBounds.Min + List->ListElementDimensions; v4 Color = List->LineBGColors[List->ListElementsCount % List->LineBGColorsCount]; - if (PointIsInRange(Mouse.Pos, LineBounds.Min, LineBounds.Max)) + if (PointIsInRect(LineBounds, Mouse.Pos)) { Color = List->LineBGHoverColor; } @@ -560,10 +560,10 @@ DrawListElementBackground(interface_list* List, mouse_state Mouse, render_comman return LineBounds; } -internal rect -DrawListElement(string Label, interface_list* List, mouse_state Mouse, render_command_buffer* RenderBuffer, interface_config Interface) +internal rect2 +DrawListElement(gs_string Label, interface_list* List, mouse_state Mouse, render_command_buffer* RenderBuffer, interface_config Interface) { - rect Bounds = DrawListElementBackground(List, Mouse, RenderBuffer); + rect2 Bounds = DrawListElementBackground(List, Mouse, RenderBuffer); v2 LabelPosition = Bounds.Min + List->ElementLabelIndent; DrawString(RenderBuffer, Label, Interface.Font, LabelPosition, List->TextColor); @@ -578,27 +578,34 @@ EvaluateColorChannelSlider (render_command_buffer* RenderBuffer, v4 ChannelMask, { r32 Result = Current; + // TODO(Peter): Can this come from outside the function? Would rather pass rect around than min/max + rect2 Rect = rect2{ Min, Max }; + render_quad_batch_constructor Batch = PushRenderQuad2DBatch(RenderBuffer, 2); v4 LeftColor = ChannelMask * 0; LeftColor.a = 1.f; v4 RightColor = ChannelMask; PushQuad2DOnBatch(&Batch, - Min, v2{Max.x, Min.y}, Max, v2{Min.x, Max.y}, + RectBottomLeft(Rect), RectBottomRight(Rect), + RectTopRight(Rect), RectTopLeft(Rect), v2{0, 0}, v2{1, 0}, v2{1, 1}, v2{0, 1}, LeftColor, RightColor, RightColor, LeftColor); if (MouseButtonTransitionedDown(Mouse.LeftButtonState)) { - if (PointIsInRange(Mouse.DownPos, Min, Max)) + if (PointIsInRect(Rect, Mouse.DownPos)) { Result = ((r32)Mouse.Pos.x - Min.x) / (Max.x - Min.x); - Result = GSClamp01(Result); + Result = Clamp01(Result); } } r32 DragBarWidth = 8; - v2 DragBarMin = v2{GSLerp(Min.x, Max.x, Result) - (DragBarWidth / 2), Min.y - 2}; + v2 DragBarMin = v2{ + LerpR32(Result, Min.x, Max.x) - (DragBarWidth / 2), + Min.y - 2 + }; v2 DragBarMax = DragBarMin + v2{DragBarWidth, (Max.y - Min.y) + 4}; PushQuad2DOnBatch(&Batch, DragBarMin, DragBarMax, v4{.3f, .3f, .3f, 1.f}); @@ -612,16 +619,18 @@ EvaluateColorPicker (render_command_buffer* RenderBuffer, v4* Value, v2 PanelMin b32 ShouldClose = false; v2 PanelMax = v2{400, 500}; - if (MouseButtonTransitionedDown(Mouse.LeftButtonState) && !PointIsInRange(Mouse.Pos, PanelMin, PanelMax)) + // TODO(Peter): Can this get passed from outside? rather pass rect2 than min/max pairs + rect2 PanelRect = rect2{PanelMin, PanelMax}; + if (MouseButtonTransitionedDown(Mouse.LeftButtonState) && !PointIsInRect(PanelRect, Mouse.Pos)) { ShouldClose = true; } else { - PushRenderQuad2D(RenderBuffer, PanelMin, PanelMax, v4{.5f, .5f, .5f, 1.f}); + PushRenderQuad2D(RenderBuffer, PanelRect.Min, PanelRect.Max, v4{.5f, .5f, .5f, 1.f}); - v2 TitleMin = v2{PanelMin.x + 5, PanelMax.y - (Config.Font->PixelHeight + 5)}; - DrawString(RenderBuffer, MakeStringLiteral("Color Picker"), Config.Font, + v2 TitleMin = v2{PanelRect.Min.x + 5, PanelRect.Max.y - (Config.Font->PixelHeight + 5)}; + DrawString(RenderBuffer, MakeString("Color Picker"), Config.Font, TitleMin, WhiteV4); v2 SliderDim = v2{(PanelMax.x - PanelMin.x) - 20, 32}; @@ -650,13 +659,13 @@ struct search_lister_result b32 ShouldRemainOpen; }; -typedef string search_lister_get_list_item_at_offset(u8* ListMemory, s32 ListLength, string SearchString, s32 Offset); +typedef gs_string search_lister_get_list_item_at_offset(u8* ListMemory, s32 ListLength, gs_string Searchgs_string, s32 Offset); internal search_lister_result -EvaluateSearchLister (ui_interface* Interface, v2 TopLeft, v2 Dimension, string Title, - string* ItemList, s32* ListLUT, s32 ListLength, +EvaluateSearchLister (ui_interface* Interface, v2 TopLeft, v2 Dimension, gs_string Title, + gs_string* ItemList, s32* ListLUT, s32 ListLength, s32 HotItem, - string* SearchString, s32 SearchStringCursorPosition) + gs_string* Searchgs_string, s32 Searchgs_stringCursorPosition) { search_lister_result Result = {}; Result.ShouldRemainOpen = true; @@ -666,24 +675,24 @@ EvaluateSearchLister (ui_interface* Interface, v2 TopLeft, v2 Dimension, string InvalidCodePath; #if 0 // Title Bar - rect TitleBarBounds = rect{v2{TopLeft.x, TopLeft.y - 30}, v2{TopLeft.x + 300, TopLeft.y}}; + rect2 TitleBarBounds = rect2{v2{TopLeft.x, TopLeft.y - 30}, v2{TopLeft.x + 300, TopLeft.y}}; ui_FillRect(Interface, TitleBarBounds, v4{.3f, .3f, .3f, 1.f}); - ui_DrawString(Interface, Title, TitleBarBounds, Interface->Style.TextColor); + ui_Drawgs_string(Interface, Title, TitleBarBounds, Interface->Style.TextColor); - MakeStringBuffer(DebugString, 256); - PrintF(&DebugString, "Hot Item: %d | Filtered Items: %d", HotItem, ListLength); - rect DebugBounds = MakeRectMinWidth(v2{ TopLeft.x + 256, TopLeft.y - 25}, v2{256, Interface->Style.LineHeight}); - ui_DrawString(Interface, DebugString, DebugBounds, Interface->Style.TextColor); + MakeStringBuffer(Debuggs_string, 256); + PrintF(&Debuggs_string, "Hot Item: %d | Filtered Items: %d", HotItem, ListLength); + rect2 DebugBounds = MakeRectMinWidth(v2{ TopLeft.x + 256, TopLeft.y - 25}, v2{256, Interface->Style.LineHeight}); + ui_Drawgs_string(Interface, Debuggs_string, DebugBounds, Interface->Style.TextColor); // Search Bar PushRenderQuad2D(RenderBuffer, v2{TopLeft.x, TopLeft.y - 30}, v2{TopLeft.x + 300, TopLeft.y}, v4{.3f, .3f, .3f, 1.f}); - DrawStringWithCursor(RenderBuffer, *SearchString, SearchStringCursorPosition, Font, v2{TopLeft.x, TopLeft.y - 25}, WhiteV4, GreenV4); + Drawgs_stringWithCursor(RenderBuffer, *Searchgs_string, Searchgs_stringCursorPosition, Font, v2{TopLeft.x, TopLeft.y - 25}, WhiteV4, GreenV4); TopLeft.y -= 30; for (s32 i = 0; i < ListLength; i++) { s32 FilteredIndex = ListLUT[i]; - string ListItemString = ItemList[FilteredIndex]; + gs_string ListItemgs_string = ItemList[FilteredIndex]; v2 Min = v2{TopLeft.x, TopLeft.y - 30}; v2 Max = Min + Dimension - v2{0, Config.Margin.y}; @@ -694,7 +703,7 @@ EvaluateSearchLister (ui_interface* Interface, v2 TopLeft, v2 Dimension, string ButtonColor = Config.ButtonColor_Active; } - if (ui_Button(Interface, ListItemString, rect{Min, Max})) + if (ui_Button(Interface, ListItemgs_string, rect2{Min, Max})) { Result.SelectedItem = i; } diff --git a/src/app/panels/foldhaus_panel_animation_timeline.h b/src/app/panels/foldhaus_panel_animation_timeline.h index 0f5e9b6..fcbf0c1 100644 --- a/src/app/panels/foldhaus_panel_animation_timeline.h +++ b/src/app/panels/foldhaus_panel_animation_timeline.h @@ -6,7 +6,7 @@ #ifndef FOLDHAUS_PANEL_ANIMATION_TIMELINE_H // Colors -global_variable v4 TimeSliderColor = v4{.36f, .52f, .78f, 1.f}; +global v4 TimeSliderColor = v4{.36f, .52f, .78f, 1.f}; // struct animation_timeline_state @@ -15,7 +15,7 @@ struct animation_timeline_state }; inline u32 -GetFrameFromPointInAnimationPanel(v2 Point, rect PanelBounds, frame_range VisibleRange) +GetFrameFromPointInAnimationPanel(v2 Point, rect2 PanelBounds, frame_range VisibleRange) { r32 HorizontalPercentOfBounds = (Point.x - PanelBounds.Min.x) / (PanelBounds.Max.x - PanelBounds.Min.x); u32 VisibleFramesCount = GetFrameCount(VisibleRange); @@ -24,10 +24,10 @@ GetFrameFromPointInAnimationPanel(v2 Point, rect PanelBounds, frame_range Visibl } inline s32 -GetXPositionFromFrameInAnimationPanel (u32 Frame, rect PanelBounds, frame_range VisibleRange) +GetXPositionFromFrameInAnimationPanel (u32 Frame, rect2 PanelBounds, frame_range VisibleRange) { r32 PercentOfTimeline = (r32)(Frame - VisibleRange.Min) / (r32)GetFrameCount(VisibleRange); - s32 XPositionAtFrame = (PercentOfTimeline * gs_Width(PanelBounds)) + PanelBounds.Min.x; + s32 XPositionAtFrame = (PercentOfTimeline * Rect2Width(PanelBounds)) + PanelBounds.Min.x; return XPositionAtFrame; } @@ -67,7 +67,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(DeleteAnimationBlockCommand) OPERATION_STATE_DEF(drag_time_marker_operation_state) { - rect TimelineBounds; + rect2 TimelineBounds; s32 StartFrame; s32 EndFrame; }; @@ -90,7 +90,7 @@ input_command DragTimeMarkerCommands [] = { }; internal void -StartDragTimeMarker(rect TimelineBounds, frame_range VisibleFrames, app_state* State) +StartDragTimeMarker(rect2 TimelineBounds, frame_range VisibleFrames, app_state* State) { operation_mode* DragTimeMarkerMode = ActivateOperationModeWithCommands(&State->Modes, DragTimeMarkerCommands, UpdateDragTimeMarker); @@ -112,7 +112,7 @@ StartDragTimeMarker(rect TimelineBounds, frame_range VisibleFrames, app_state* S OPERATION_STATE_DEF(drag_animation_clip_state) { - rect TimelineBounds; + rect2 TimelineBounds; frame_range VisibleRange; frame_range ClipRange; }; @@ -122,7 +122,7 @@ AttemptToSnapPosition(u32 SnappingFrame, u32 SnapToFrame) { u32 Result = SnappingFrame; s32 SnapDistance = 5; - if (GSAbs((s32)SnappingFrame - (s32)SnapToFrame) <= SnapDistance) + if (Abs((s32)SnappingFrame - (s32)SnapToFrame) <= SnapDistance) { Result = SnapToFrame; } @@ -134,13 +134,13 @@ OPERATION_RENDER_PROC(UpdateDragAnimationClip) drag_animation_clip_state* OpState = (drag_animation_clip_state*)Operation.OpStateMemory; r32 ClipInitialStartFrameXPercent = FrameToPercentRange(OpState->ClipRange.Min, OpState->VisibleRange); - u32 ClipInitialStartFrameXPosition = GSLerp(OpState->TimelineBounds.Min.x, - OpState->TimelineBounds.Max.x, - ClipInitialStartFrameXPercent); + u32 ClipInitialStartFrameXPosition = LerpR32(ClipInitialStartFrameXPercent, + OpState->TimelineBounds.Min.x, + OpState->TimelineBounds.Max.x); r32 ClipInitialEndFrameXPercent = FrameToPercentRange(OpState->ClipRange.Max, OpState->VisibleRange); - u32 ClipInitialEndFrameXPosition = GSLerp(OpState->TimelineBounds.Min.x, - OpState->TimelineBounds.Max.x, - ClipInitialEndFrameXPercent); + u32 ClipInitialEndFrameXPosition = LerpR32(ClipInitialEndFrameXPercent, + OpState->TimelineBounds.Min.x, + OpState->TimelineBounds.Max.x); u32 FrameAtMouseDownX = GetFrameFromPointInAnimationPanel(Mouse.DownPos, OpState->TimelineBounds, OpState->VisibleRange); @@ -154,7 +154,7 @@ OPERATION_RENDER_PROC(UpdateDragAnimationClip) return; } - if (GSAbs(Mouse.DownPos.x - ClipInitialStartFrameXPosition) < CLICK_ANIMATION_BLOCK_EDGE_MAX_SCREEN_DISTANCE) + if (Abs(Mouse.DownPos.x - ClipInitialStartFrameXPosition) < CLICK_ANIMATION_BLOCK_EDGE_MAX_SCREEN_DISTANCE) { s32 NewStartFrame = OpState->ClipRange.Min + FrameOffset; if (FrameOffset < 0) @@ -176,7 +176,7 @@ OPERATION_RENDER_PROC(UpdateDragAnimationClip) } AnimationBlock->Range.Min = NewStartFrame; } - else if (GSAbs(Mouse.DownPos.x - ClipInitialEndFrameXPosition) < CLICK_ANIMATION_BLOCK_EDGE_MAX_SCREEN_DISTANCE) + else if (Abs(Mouse.DownPos.x - ClipInitialEndFrameXPosition) < CLICK_ANIMATION_BLOCK_EDGE_MAX_SCREEN_DISTANCE) { r32 NewEndFrame = OpState->ClipRange.Max + FrameOffset; if (FrameOffset > 0) @@ -228,8 +228,8 @@ OPERATION_RENDER_PROC(UpdateDragAnimationClip) s32 PlayableStartFrame = State->AnimationSystem.PlayableRange.Min; s32 PlayableEndFrame = State->AnimationSystem.PlayableRange.Max; - AnimationBlock->Range.Min = (u32)GSClamp(PlayableStartFrame, (s32)AnimationBlock->Range.Min, PlayableEndFrame); - AnimationBlock->Range.Max = (u32)GSClamp(PlayableStartFrame, (s32)AnimationBlock->Range.Max, PlayableEndFrame); + AnimationBlock->Range.Min = (u32)Clamp(PlayableStartFrame, (s32)AnimationBlock->Range.Min, PlayableEndFrame); + AnimationBlock->Range.Max = (u32)Clamp(PlayableStartFrame, (s32)AnimationBlock->Range.Max, PlayableEndFrame); } input_command DragAnimationClipCommands [] = { @@ -237,7 +237,7 @@ input_command DragAnimationClipCommands [] = { }; internal void -SelectAndBeginDragAnimationBlock(gs_list_handle BlockHandle, frame_range VisibleRange, rect TimelineBounds, app_state* State) +SelectAndBeginDragAnimationBlock(gs_list_handle BlockHandle, frame_range VisibleRange, rect2 TimelineBounds, app_state* State) { SelectAnimationBlock(BlockHandle, State); @@ -289,20 +289,20 @@ AnimationTimeline_Cleanup(panel* Panel, app_state* State) } internal void -DrawFrameBar (animation_system* AnimationSystem, render_command_buffer* RenderBuffer, frame_range VisibleFrames, rect BarBounds, mouse_state Mouse, app_state* State) +DrawFrameBar (animation_system* AnimationSystem, render_command_buffer* RenderBuffer, frame_range VisibleFrames, rect2 BarBounds, mouse_state Mouse, app_state* State) { - string TempString = PushString(&State->Transient, 256); + gs_string TempString = PushString(&State->Transient, 256); s32 VisibleFrameCount = VisibleFrames.Max - VisibleFrames.Min; - r32 BarHeight = gs_Height(BarBounds); - r32 BarWidth = gs_Width(BarBounds); + r32 BarHeight = Rect2Height(BarBounds); + r32 BarWidth = Rect2Width(BarBounds); - PushRenderQuad2D(RenderBuffer, gs_RectExpand(BarBounds), v4{.16f, .16f, .16f, 1.f}); + PushRenderQuad2D(RenderBuffer, BarBounds.Min, BarBounds.Max, v4{.16f, .16f, .16f, 1.f}); // Mouse clicked inside frame nubmer bar -> change current frame on timeline if (MouseButtonTransitionedDown(Mouse.LeftButtonState) && - PointIsInRange(Mouse.DownPos, gs_RectExpand(BarBounds))) + PointIsInRect(BarBounds, Mouse.DownPos)) { StartDragTimeMarker(BarBounds, VisibleFrames, State); } @@ -315,7 +315,7 @@ DrawFrameBar (animation_system* AnimationSystem, render_command_buffer* RenderBu u32 Frame = PercentToFrameInRange(Percent, VisibleFrames); PrintF(&TempString, "%d", Frame); r32 FramePercent = FrameToPercentRange(Frame, VisibleFrames); - r32 FrameX = GSLerp(BarBounds.Min.x, BarBounds.Max.x, FramePercent); + r32 FrameX = LerpR32(FramePercent, BarBounds.Min.x, BarBounds.Max.x); v2 FrameTextPos = v2{FrameX, BarBounds.Min.y + 2}; DrawString(RenderBuffer, TempString, State->Interface.Style.Font, FrameTextPos, WhiteV4); } @@ -324,29 +324,28 @@ DrawFrameBar (animation_system* AnimationSystem, render_command_buffer* RenderBu if (FrameIsInRange(AnimationSystem->CurrentFrame, VisibleFrames)) { r32 FrameAtPercentVisibleRange = FrameToPercentRange(AnimationSystem->CurrentFrame, VisibleFrames); - r32 SliderX = GSLerp(BarBounds.Min.x, BarBounds.Max.x, FrameAtPercentVisibleRange); + r32 SliderX = LerpR32(FrameAtPercentVisibleRange, BarBounds.Min.x, BarBounds.Max.x); + + PrintF(&TempString, "%d", AnimationSystem->CurrentFrame); - u32 FrameNumberCharCount = GetU32NumberOfCharactersNeeded(AnimationSystem->CurrentFrame); // space for each character + a margin on either side - r32 SliderWidth = (8 * FrameNumberCharCount) + 8; + r32 SliderWidth = (8 * TempString.Length) + 8; r32 SliderHalfWidth = SliderWidth / 2.f; v2 HeadMin = v2{SliderX - SliderHalfWidth, BarBounds.Min.y}; v2 HeadMax = v2{SliderX + SliderHalfWidth, BarBounds.Max.y}; PushRenderQuad2D(RenderBuffer, HeadMin, HeadMax, TimeSliderColor); - - PrintF(&TempString, "%d", AnimationSystem->CurrentFrame); DrawString(RenderBuffer, TempString, State->Interface.Style.Font, HeadMin + v2{6, 4}, WhiteV4); } } internal frame_range -DrawTimelineRangeBar (animation_system* AnimationSystem, animation_timeline_state* TimelineState, render_command_buffer* RenderBuffer, rect BarBounds, mouse_state Mouse) +DrawTimelineRangeBar (animation_system* AnimationSystem, animation_timeline_state* TimelineState, render_command_buffer* RenderBuffer, rect2 BarBounds, mouse_state Mouse) { frame_range Result = {0}; - r32 BarHeight = gs_Height(BarBounds); - r32 BarWidth = gs_Width(BarBounds); - PushRenderQuad2D(RenderBuffer, gs_RectExpand(BarBounds), v4{.16f, .16f, .16f, 1.f}); + r32 BarHeight = Rect2Height(BarBounds); + r32 BarWidth = Rect2Width(BarBounds); + PushRenderQuad2D(RenderBuffer, BarBounds.Min, BarBounds.Max, v4{.16f, .16f, .16f, 1.f}); r32 PlayableFrames = (r32)GetFrameCount(AnimationSystem->PlayableRange); v2 SliderBarDim = v2{25, BarHeight}; @@ -354,22 +353,24 @@ DrawTimelineRangeBar (animation_system* AnimationSystem, animation_timeline_stat // Convert Frames To Pixels r32 VisibleMinPercentPlayable = FrameToPercentRange(TimelineState->VisibleRange.Min, AnimationSystem->PlayableRange); r32 VisibleMaxPercentPlayable = FrameToPercentRange(TimelineState->VisibleRange.Max, AnimationSystem->PlayableRange); - v2 RangeMinSliderMin = v2{BarBounds.Min.x + (VisibleMinPercentPlayable * gs_Width(BarBounds)), BarBounds.Min.y}; - v2 RangeMaxSliderMin = v2{BarBounds.Min.x + (VisibleMaxPercentPlayable * gs_Width(BarBounds)) - 25, BarBounds.Min.y}; + v2 RangeMinSliderMin = v2{BarBounds.Min.x + (VisibleMinPercentPlayable * Rect2Width(BarBounds)), BarBounds.Min.y}; + v2 RangeMaxSliderMin = v2{BarBounds.Min.x + (VisibleMaxPercentPlayable * Rect2Width(BarBounds)) - 25, BarBounds.Min.y}; + + rect2 SliderBarRange = rect2{ RangeMinSliderMin, RangeMinSliderMin + SliderBarDim }; if (MouseButtonHeldDown(Mouse.LeftButtonState) || MouseButtonTransitionedUp(Mouse.LeftButtonState)) { v2 MouseDragOffset = Mouse.Pos - Mouse.DownPos; - if (PointIsInRange(Mouse.DownPos, RangeMinSliderMin, RangeMinSliderMin + SliderBarDim)) + if (PointIsInRect(SliderBarRange, Mouse.DownPos)) { r32 NewSliderX = RangeMinSliderMin.x + MouseDragOffset.x; - RangeMinSliderMin.x = GSClamp(BarBounds.Min.x, NewSliderX, RangeMaxSliderMin.x - SliderBarDim.x); + RangeMinSliderMin.x = Clamp(BarBounds.Min.x, NewSliderX, RangeMaxSliderMin.x - SliderBarDim.x); } - if (PointIsInRange(Mouse.DownPos, RangeMaxSliderMin, RangeMaxSliderMin + SliderBarDim)) + if (PointIsInRect(SliderBarRange, Mouse.DownPos)) { r32 NewSliderX = RangeMaxSliderMin.x + MouseDragOffset.x; - RangeMaxSliderMin.x = GSClamp(RangeMinSliderMin.x + SliderBarDim.x, NewSliderX, BarBounds.Max.x - SliderBarDim.x); + RangeMaxSliderMin.x = Clamp(RangeMinSliderMin.x + SliderBarDim.x, NewSliderX, BarBounds.Max.x - SliderBarDim.x); } } @@ -396,19 +397,19 @@ DrawTimelineRangeBar (animation_system* AnimationSystem, animation_timeline_stat #define LAYER_HEIGHT 52 internal void -DrawLayerMenu(animation_system* AnimationSystem, rect PanelDim, render_command_buffer* RenderBuffer, app_state* State, mouse_state Mouse) +DrawLayerMenu(animation_system* AnimationSystem, rect2 PanelDim, render_command_buffer* RenderBuffer, app_state* State, mouse_state Mouse) { - v2 LayerDim = { gs_Width(PanelDim), LAYER_HEIGHT }; + v2 LayerDim = { Rect2Width(PanelDim), LAYER_HEIGHT }; v2 LayerListMin = PanelDim.Min + v2{0, 24}; for (u32 LayerIndex = 0; LayerIndex < AnimationSystem->LayersCount; LayerIndex++) { anim_layer* Layer = AnimationSystem->Layers + LayerIndex; - rect LayerBounds = {0}; + rect2 LayerBounds = {0}; LayerBounds.Min = { LayerListMin.x, LayerListMin.y + (LayerDim.y * LayerIndex) }; LayerBounds.Max = LayerBounds.Min + LayerDim; if (MouseButtonTransitionedDown(Mouse.LeftButtonState) && - gs_PointIsInRect(Mouse.Pos, LayerBounds)) + PointIsInRect(LayerBounds, Mouse.Pos)) { State->SelectedAnimationLayer = LayerIndex; } @@ -416,18 +417,18 @@ DrawLayerMenu(animation_system* AnimationSystem, rect PanelDim, render_command_b v2 LayerTextPos = { LayerBounds.Min.x + 6, LayerBounds.Max.y - 16}; if (State->SelectedAnimationLayer == LayerIndex) { - PushRenderBoundingBox2D(RenderBuffer, gs_RectExpand(LayerBounds), 1, WhiteV4); + PushRenderBoundingBox2D(RenderBuffer, LayerBounds.Min, LayerBounds.Max, 1, WhiteV4); } DrawString(RenderBuffer, Layer->Name, State->Interface.Style.Font, LayerTextPos, WhiteV4); } } -internal rect -DrawAnimationBlock (animation_block AnimationBlock, v4 BlockColor, frame_range VisibleFrames, rect TimelineBounds, render_command_buffer* RenderBuffer) +internal rect2 +DrawAnimationBlock (animation_block AnimationBlock, v4 BlockColor, frame_range VisibleFrames, rect2 TimelineBounds, render_command_buffer* RenderBuffer) { - rect BlockBounds = {}; + rect2 BlockBounds = {}; - r32 TimelineWidth = gs_Width(TimelineBounds); + r32 TimelineWidth = Rect2Width(TimelineBounds); u32 ClampedBlockStartFrame = ClampFrameToRange(AnimationBlock.Range.Min, VisibleFrames); r32 StartFramePercent = FrameToPercentRange(ClampedBlockStartFrame, VisibleFrames); @@ -448,18 +449,18 @@ DrawAnimationBlock (animation_block AnimationBlock, v4 BlockColor, frame_range V } internal gs_list_handle -DrawAnimationTimeline (animation_system* AnimationSystem, animation_timeline_state* TimelineState, rect PanelBounds, gs_list_handle SelectedBlockHandle, ui_interface* Interface, app_state* State) +DrawAnimationTimeline (animation_system* AnimationSystem, animation_timeline_state* TimelineState, rect2 PanelBounds, gs_list_handle SelectedBlockHandle, ui_interface* Interface, app_state* State) { - string TempString = PushString(&State->Transient, 256); + gs_string Tempgs_string = PushString(&State->Transient, 256); gs_list_handle Result = SelectedBlockHandle; - rect LayerMenuBounds, TimelineBounds; - gs_VSplitRectAtDistanceFromLeft(PanelBounds, 256, &LayerMenuBounds, &TimelineBounds); + rect2 LayerMenuBounds, TimelineBounds; + RectVSplitAtDistanceFromLeft(PanelBounds, 256, &LayerMenuBounds, &TimelineBounds); // In Top To Bottom Order - rect TimelineFrameBarBounds, TimelineBlockDisplayBounds, TimelineRangeBarBounds; - gs_HSplitRectAtDistanceFromTop(TimelineBounds, 32, &TimelineFrameBarBounds, &TimelineBounds); - gs_HSplitRectAtDistanceFromBottom(TimelineBounds, 24, &TimelineBlockDisplayBounds, &TimelineRangeBarBounds); + rect2 TimelineFrameBarBounds, TimelineBlockDisplayBounds, TimelineRangeBarBounds; + RectHSplitAtDistanceFromTop(TimelineBounds, 32, &TimelineFrameBarBounds, &TimelineBounds); + RectHSplitAtDistanceFromBottom(TimelineBounds, 24, &TimelineBlockDisplayBounds, &TimelineRangeBarBounds); // TODO(Peter): Clean Up DrawLayerMenu(AnimationSystem, LayerMenuBounds, Interface->RenderBuffer, State, Interface->Mouse); @@ -500,8 +501,8 @@ DrawAnimationTimeline (animation_system* AnimationSystem, animation_timeline_sta BlockColor = PinkV4; } // TODO(Peter): Clean Up - rect BlockBounds = DrawAnimationBlock(AnimationBlockAt, BlockColor, AdjustedViewRange, TimelineBounds, Interface->RenderBuffer); - if (gs_PointIsInRect(Interface->Mouse.Pos, BlockBounds)) + rect2 BlockBounds = DrawAnimationBlock(AnimationBlockAt, BlockColor, AdjustedViewRange, TimelineBounds, Interface->RenderBuffer); + if (PointIsInRect(BlockBounds, Interface->Mouse.Pos)) { DragBlockHandle = CurrentBlockHandle; } @@ -519,8 +520,8 @@ DrawAnimationTimeline (animation_system* AnimationSystem, animation_timeline_sta if (FrameIsInRange(AnimationSystem->CurrentFrame, AdjustedViewRange)) { r32 FrameAtPercentVisibleRange = FrameToPercentRange(AnimationSystem->CurrentFrame, AdjustedViewRange); - r32 SliderX = GSLerp(TimelineBounds.Min.x, TimelineBounds.Max.x, FrameAtPercentVisibleRange); - rect SliderBounds = { + r32 SliderX = LerpR32(FrameAtPercentVisibleRange, TimelineBounds.Min.x, TimelineBounds.Max.x); + rect2 SliderBounds = { v2{ SliderX, TimelineBounds.Min.y }, v2{ SliderX + 1, TimelineBounds.Max.y } }; @@ -531,7 +532,7 @@ DrawAnimationTimeline (animation_system* AnimationSystem, animation_timeline_sta ui_OutlineRect(Interface, TimelineFrameBarBounds, 1.f, RedV4); ui_OutlineRect(Interface, TimelineBlockDisplayBounds, 1.f, RedV4); - if (MouseDownAndNotHandled && gs_PointIsInRect(Interface->Mouse.Pos, TimelineBounds)) + if (MouseDownAndNotHandled && PointIsInRect(TimelineBounds, Interface->Mouse.Pos)) { DeselectCurrentAnimationBlock(State); } @@ -554,13 +555,13 @@ animation_clip GlobalAnimationClips[] = { }; internal void -DrawAnimationClipsList(rect PanelBounds, ui_interface* Interface, u32 SelectedAnimationLayer, animation_system* AnimationSystem) +DrawAnimationClipsList(rect2 PanelBounds, ui_interface* Interface, u32 SelectedAnimationLayer, animation_system* AnimationSystem) { ui_layout Layout = ui_CreateLayout(*Interface, PanelBounds); for (s32 i = 0; i < GlobalAnimationClipsCount; i++) { animation_clip Clip = GlobalAnimationClips[i]; - string ClipName = MakeString(Clip.Name, Clip.NameLength); + gs_string ClipName = MakeString(Clip.Name, Clip.NameLength); if (ui_LayoutListEntry(Interface, &Layout, ClipName, i)) { AddAnimationBlockAtCurrentTime(i + 1, SelectedAnimationLayer, AnimationSystem); @@ -572,7 +573,7 @@ DrawAnimationClipsList(rect PanelBounds, ui_interface* Interface, u32 SelectedAn GSMetaTag(panel_render); GSMetaTag(panel_type_animation_timeline); internal void -AnimationTimeline_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +AnimationTimeline_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { animation_timeline_state* TimelineState = (animation_timeline_state*)Panel.PanelStateMemory; gs_list_handle SelectedBlockHandle = State->SelectedAnimationBlockHandle; @@ -580,24 +581,24 @@ AnimationTimeline_Render(panel Panel, rect PanelBounds, render_command_buffer* R ui_interface* Interface = &State->Interface; animation_system* AnimationSystem = &State->AnimationSystem; - rect TitleBarBounds, PanelContentsBounds; - gs_HSplitRectAtDistanceFromTop(PanelBounds, Interface->Style.RowHeight, &TitleBarBounds, &PanelContentsBounds); - rect AnimationListBounds, TimelineBounds; - gs_VSplitRectAtDistanceFromLeft(PanelContentsBounds, 300, &AnimationListBounds, &TimelineBounds); + rect2 TitleBarBounds, PanelContentsBounds; + RectHSplitAtDistanceFromTop(PanelBounds, Interface->Style.RowHeight, &TitleBarBounds, &PanelContentsBounds); + rect2 AnimationListBounds, TimelineBounds; + RectVSplitAtDistanceFromLeft(PanelContentsBounds, 300, &AnimationListBounds, &TimelineBounds); ui_FillRect(Interface, TitleBarBounds, Interface->Style.PanelBGColors[0]); ui_layout TitleBarLayout = ui_CreateLayout(*Interface, TitleBarBounds); ui_StartRow(&TitleBarLayout, 3); { - if (ui_LayoutButton(Interface, &TitleBarLayout, MakeStringLiteral("Pause"))) + if (ui_LayoutButton(Interface, &TitleBarLayout, MakeString("Pause"))) { State->AnimationSystem.TimelineShouldAdvance = true; } - if (ui_LayoutButton(Interface, &TitleBarLayout, MakeStringLiteral("Play"))) + if (ui_LayoutButton(Interface, &TitleBarLayout, MakeString("Play"))) { State->AnimationSystem.TimelineShouldAdvance = false; } - if (ui_LayoutButton(Interface, &TitleBarLayout, MakeStringLiteral("Stop"))) + if (ui_LayoutButton(Interface, &TitleBarLayout, MakeString("Stop"))) { State->AnimationSystem.TimelineShouldAdvance = false; State->AnimationSystem.CurrentFrame = 0; @@ -605,7 +606,7 @@ AnimationTimeline_Render(panel Panel, rect PanelBounds, render_command_buffer* R } ui_EndRow(&TitleBarLayout); - if (gs_Height(TimelineBounds) > 0) + if (Rect2Height(TimelineBounds) > 0) { SelectedBlockHandle = DrawAnimationTimeline(AnimationSystem, TimelineState, TimelineBounds, SelectedBlockHandle, Interface, State); DrawAnimationClipsList(AnimationListBounds, Interface, State->SelectedAnimationLayer, &State->AnimationSystem); diff --git a/src/app/panels/foldhaus_panel_dmx_view.h b/src/app/panels/foldhaus_panel_dmx_view.h index 8d5acce..56d0352 100644 --- a/src/app/panels/foldhaus_panel_dmx_view.h +++ b/src/app/panels/foldhaus_panel_dmx_view.h @@ -74,7 +74,7 @@ DrawSACNUniversePixels (render_command_buffer* RenderBuffer, sacn_universe* ToDr GSMetaTag(panel_render); GSMetaTag(panel_type_dmx_view); internal void -DMXView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +DMXView_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { #if 0 // :NoLongerFunctionalSACNCodeButThatsOk @@ -82,7 +82,7 @@ DMXView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffe universe_view_operation_state* OpState = (universe_view_operation_state*)Operation.OpStateMemory; - string TitleBarString = InitializeEmptyString(PushArray(State->Transient, char, 64), 64); + gs_string TitleBargs_string = InitializeEmptygs_string(PushArray(State->Transient, char, 64), 64); v2 DisplayArea_Dimension = v2{600, 600}; @@ -120,8 +120,8 @@ DMXView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffe if (OpState->Zoom > .5f) { v2 TitleDisplayStart = UniverseDisplayTopLeft + v2{0, 12}; - PrintF(&TitleBarString, "Universe %d", Universe->Universe); - DrawString(RenderBuffer, TitleBarString, State->Interface.Font, + PrintF(&TitleBargs_string, "Universe %d", Universe->Universe); + DrawString(RenderBuffer, TitleBargs_string, State->Interface.Font, TitleDisplayStart, WhiteV4); } diff --git a/src/app/panels/foldhaus_panel_file_view.h b/src/app/panels/foldhaus_panel_file_view.h index bfcd34e..2fd2953 100644 --- a/src/app/panels/foldhaus_panel_file_view.h +++ b/src/app/panels/foldhaus_panel_file_view.h @@ -7,7 +7,7 @@ struct file_view_state { - string WorkingDirectory; + gs_string WorkingDirectory; }; input_command* FileView_Commands = 0; @@ -36,18 +36,18 @@ FileView_Cleanup(panel* Panel, app_state* State) GSMetaTag(panel_render); GSMetaTag(panel_type_file_view); internal void -FileView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +FileView_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { - rect HeaderBounds = {0}; + rect2 HeaderBounds = {0}; HeaderBounds.Min = {PanelBounds.Min.x, PanelBounds.Max.y - 32}; HeaderBounds.Max = PanelBounds.Max; - rect ListBounds = {0}; + rect2 ListBounds = {0}; ListBounds.Min = PanelBounds.Min; - ListBounds.Max = gs_BottomRight(HeaderBounds); + ListBounds.Max = RectBottomRight(HeaderBounds); - PushRenderQuad2D(RenderBuffer, gs_RectExpand(HeaderBounds), PinkV4); - PushRenderQuad2D(RenderBuffer, gs_RectExpand(ListBounds), RedV4); + PushRenderQuad2D(RenderBuffer, HeaderBounds.Min, HeaderBounds.Max, PinkV4); + PushRenderQuad2D(RenderBuffer, ListBounds.Min, ListBounds.Max, RedV4); } diff --git a/src/app/panels/foldhaus_panel_hierarchy.h b/src/app/panels/foldhaus_panel_hierarchy.h index 043caa0..5d0cca7 100644 --- a/src/app/panels/foldhaus_panel_hierarchy.h +++ b/src/app/panels/foldhaus_panel_hierarchy.h @@ -27,13 +27,13 @@ HierarchyView_Cleanup(panel* Panel, app_state* State) GSMetaTag(panel_render); GSMetaTag(panel_type_hierarchy); internal void -HierarchyView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +HierarchyView_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { ui_layout Layout = ui_CreateLayout(State->Interface, PanelBounds); - string TempString = PushString(&State->Transient, 256); - u32 LineCount = (u32)(gs_Height(PanelBounds) / Layout.RowHeight) + 1; - u32 AssembliesToDraw = GSMin(LineCount, State->Assemblies.Count); - rect* LineBounds = PushArray(&State->Transient, rect, LineCount); + gs_string Tempgs_string = PushString(&State->Transient, 256); + u32 LineCount = (u32)(Rect2Height(PanelBounds) / Layout.RowHeight) + 1; + u32 AssembliesToDraw = Min(LineCount, State->Assemblies.Count); + rect2* LineBounds = PushArray(&State->Transient, rect2, LineCount); // Fill in alternating color rows for the backgrounds for (u32 Line = 0; Line < LineCount; Line++) @@ -46,13 +46,13 @@ HierarchyView_Render(panel Panel, rect PanelBounds, render_command_buffer* Rende for (u32 AssemblyIndex = 0; AssemblyIndex < AssembliesToDraw; AssemblyIndex++) { assembly Assembly = State->Assemblies.Values[AssemblyIndex]; - PrintF(&TempString, "%S", Assembly.Name); + PrintF(&Tempgs_string, "%S", Assembly.Name); ui_layout ItemLayout = ui_CreateLayout(State->Interface, LineBounds[AssemblyIndex]); ui_StartRow(&ItemLayout, 2); { - ui_LayoutDrawString(&State->Interface, &ItemLayout, TempString, State->Interface.Style.TextColor); - if (ui_LayoutListButton(&State->Interface, &ItemLayout, MakeStringLiteral("X"), AssemblyIndex)) + ui_LayoutDrawString(&State->Interface, &ItemLayout, Tempgs_string, State->Interface.Style.TextColor); + if (ui_LayoutListButton(&State->Interface, &ItemLayout, MakeString("X"), AssemblyIndex)) { UnloadAssembly(AssemblyIndex, State, Context); } @@ -63,15 +63,22 @@ HierarchyView_Render(panel Panel, rect PanelBounds, render_command_buffer* Rende if (AssembliesToDraw < LineCount) { // NOTE(Peter): Add assembly button - PrintF(&TempString, "+ Add Assembly"); - if (ui_ListButton(&State->Interface, TempString, LineBounds[AssembliesToDraw], AssembliesToDraw)) + PrintF(&Tempgs_string, "+ Add Assembly"); + if (ui_ListButton(&State->Interface, Tempgs_string, LineBounds[AssembliesToDraw], AssembliesToDraw)) { - string FilePath = PushString(&State->Transient, 256); + gs_string FilePath = PushString(&State->Transient, 256); + + // TODO(Peter): Took out file opening temporarily while I get things back up and running. + // Ideally we can just write our own file lister using the new filehandler so that + // execution doesn't suspend while we try and open a file + InvalidCodePath; +#if 0 b32 Success = GetFilePath(Context, &FilePath, "Foldhaus Files\0*.fold\0\0"); if (Success) { - LoadAssembly(&State->Assemblies, &State->LedSystem, &State->Transient, Context, FilePath, State->GlobalLog); + LoadAssembly(&State->Assemblies, &State->LedSystem, &State->Transient, Context, FilePath.ConstString, State->GlobalLog); } +#endif } } } diff --git a/src/app/panels/foldhaus_panel_profiler.h b/src/app/panels/foldhaus_panel_profiler.h index 75c010a..bc18748 100644 --- a/src/app/panels/foldhaus_panel_profiler.h +++ b/src/app/panels/foldhaus_panel_profiler.h @@ -25,7 +25,7 @@ ProfilerView_Cleanup(panel* Panel, app_state* State) } internal void -RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_layout Layout, debug_frame* VisibleFrame, memory_arena* Memory) +RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_layout Layout, debug_frame* VisibleFrame, gs_memory_arena* Memory) { v4 ThreadColors[] = { v4{.73f, .33f, .83f, 1}, @@ -35,8 +35,8 @@ RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_layout Layout, deb v4{.74f, .40f, .25f, 1}, }; - rect Bounds = ui_LayoutRemaining(Layout); - r32 Width = gs_Width(Bounds); + rect2 Bounds = ui_LayoutRemaining(Layout); + r32 Width = Rect2Width(Bounds); r32 DepthHeight = 64; s64 FrameStartCycles = VisibleFrame->FrameStartCycles; @@ -48,7 +48,8 @@ RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_layout Layout, deb scope_record* HotRecord = 0; scope_name* HotRecordName = 0; - MakeStringBuffer(String, 256); + char Backbuffer[256]; + gs_string String = MakeString(Backbuffer, 0, 256); for (s32 i = 0; i < ThreadScopeCalls->Count; i++) { scope_record* Record = ThreadScopeCalls->Calls + i; @@ -59,14 +60,14 @@ RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_layout Layout, deb r32 PixelStart = Bounds.Min.x + (Width * PercentStart); r32 PixelEnd = Bounds.Min.x + (Width * PercentEnd); r32 MinY = Bounds.Max.y - ((Record->CallDepth + 1) * DepthHeight); - rect ScopeBounds = { + rect2 ScopeBounds = { v2{ PixelStart, MinY }, v2{ PixelEnd, MinY + (DepthHeight - 4) } }; - if (gs_Width(ScopeBounds) >= 1) + if (Rect2Width(ScopeBounds) >= 1) { v4 Color = ThreadColors[0]; - if (gs_PointIsInRect(Interface->Mouse.Pos, ScopeBounds)) + if (PointIsInRect(ScopeBounds, Interface->Mouse.Pos)) { Color = GreenV4; HotRecord = Record; @@ -81,23 +82,26 @@ RenderProfiler_ScopeVisualization(ui_interface* Interface, ui_layout Layout, deb if (HotRecord != 0) { PrintF(&String, "%S : %d - %d", HotRecordName->Name, HotRecord->StartCycles, HotRecord->EndCycles); - ui_TextBox(Interface, gs_MakeRectMinWidth(Interface->Mouse.Pos, v2{256, 32}), String, BlackV4, WhiteV4); + + rect2 TextBounds = MakeRect2MinDim(Interface->Mouse.Pos, v2{256, 32}); + ui_TextBox(Interface, TextBounds, String, BlackV4, WhiteV4); } } internal void -RenderProfiler_ListVisualization(ui_interface* Interface, ui_layout Layout, debug_frame* VisibleFrame, memory_arena* Memory) +RenderProfiler_ListVisualization(ui_interface* Interface, ui_layout Layout, debug_frame* VisibleFrame, gs_memory_arena* Memory) { - MakeStringBuffer(String, 256); + char Backbuffer[256]; + gs_string String = MakeString(Backbuffer, 0, 256); r32 ColumnWidths[] = {256, 128, 128, 128, 128}; ui_StartRow(&Layout, 5, &ColumnWidths[0]); { - ui_LayoutDrawString(Interface, &Layout, MakeStringLiteral("Procedure"), Interface->Style.TextColor); - ui_LayoutDrawString(Interface, &Layout, MakeStringLiteral("% Frame"), Interface->Style.TextColor); - ui_LayoutDrawString(Interface, &Layout, MakeStringLiteral("Seconds"), Interface->Style.TextColor); - ui_LayoutDrawString(Interface, &Layout, MakeStringLiteral("Cycles"), Interface->Style.TextColor); - ui_LayoutDrawString(Interface, &Layout, MakeStringLiteral("Calls"), Interface->Style.TextColor); + ui_LayoutDrawString(Interface, &Layout, MakeString("Procedure"), Interface->Style.TextColor); + ui_LayoutDrawString(Interface, &Layout, MakeString("% Frame"), Interface->Style.TextColor); + ui_LayoutDrawString(Interface, &Layout, MakeString("Seconds"), Interface->Style.TextColor); + ui_LayoutDrawString(Interface, &Layout, MakeString("Cycles"), Interface->Style.TextColor); + ui_LayoutDrawString(Interface, &Layout, MakeString("Calls"), Interface->Style.TextColor); } ui_EndRow(&Layout); @@ -133,40 +137,43 @@ RenderProfiler_ListVisualization(ui_interface* Interface, ui_layout Layout, debu GSMetaTag(panel_render); GSMetaTag(panel_type_profiler); internal void -ProfilerView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +ProfilerView_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { - memory_arena* Memory = &State->Transient; - string String = InitializeEmptyString(PushArray(Memory, char, 256), 256); + gs_memory_arena* Memory = &State->Transient; + gs_string String = PushString(Memory, 256); v4 FrameColors[] = { GreenV4, YellowV4, RedV4, WhiteV4 }; r32 FrameListHeight = 64; - rect FrameListBounds, ProcListBounds; - gs_HSplitRectAtDistanceFromTop(PanelBounds, FrameListHeight, &FrameListBounds, &ProcListBounds); - rect FrameListInner = gs_InsetRect(FrameListBounds, 4); + rect2 FrameListBounds, ProcListBounds; + RectHSplitAtDistanceFromTop(PanelBounds, FrameListHeight, &FrameListBounds, &ProcListBounds); + rect2 FrameListInner = RectInset(FrameListBounds, 4); - r32 SingleFrameStep = gs_Width(FrameListInner) / DEBUG_FRAME_COUNT; + r32 SingleFrameStep = Rect2Width(FrameListInner) / DEBUG_FRAME_COUNT; r32 SingleFrameWidth = (r32)((s32)SingleFrameStep - 2); ui_OutlineRect(&State->Interface, FrameListBounds, 2, WhiteV4); - if (gs_PointIsInRect(Context.Mouse.Pos, FrameListBounds) && MouseButtonHeldDown(Context.Mouse.LeftButtonState)) + if (MouseButtonHeldDown(Context.Mouse.LeftButtonState)) { - v2 LocalMouse = gs_TransformPointIntoRectSpace(Context.Mouse.Pos, FrameListBounds); - s32 ClosestFrameIndex = (LocalMouse.x / SingleFrameStep); - if (ClosestFrameIndex >= 0 && ClosestFrameIndex < DEBUG_FRAME_COUNT) + if (PointIsInRect(FrameListBounds, Context.Mouse.Pos)) { - GlobalDebugServices->RecordFrames = false; - GlobalDebugServices->CurrentDebugFrame = ClosestFrameIndex; + v2 LocalMouse = Rect2GetRectLocalPoint(FrameListBounds, Context.Mouse.Pos); + s32 ClosestFrameIndex = (LocalMouse.x / SingleFrameStep); + if (ClosestFrameIndex >= 0 && ClosestFrameIndex < DEBUG_FRAME_COUNT) + { + GlobalDebugServices->RecordFrames = false; + GlobalDebugServices->CurrentDebugFrame = ClosestFrameIndex; + } } } - rect FrameBounds = gs_MakeRectMinWidth(FrameListInner.Min, v2{SingleFrameWidth, gs_Height(FrameListInner)}); + rect2 FrameBounds = MakeRect2MinDim(FrameListInner.Min, v2{SingleFrameWidth, Rect2Height(FrameListInner)}); for (s32 F = 0; F < DEBUG_FRAME_COUNT; F++) { - rect PositionedFrameBounds = gs_TranslateRectX(FrameBounds, F * SingleFrameStep); + rect2 PositionedFrameBounds = Rect2TranslateX(FrameBounds, F * SingleFrameStep); s32 FramesAgo = (GlobalDebugServices->CurrentDebugFrame - F); if (FramesAgo < 0) { FramesAgo += DEBUG_FRAME_COUNT; } - v4 Color = FrameColors[GSClamp(0, FramesAgo, 3)]; + v4 Color = FrameColors[Clamp(0, FramesAgo, 3)]; ui_FillRect(&State->Interface, PositionedFrameBounds, Color); } diff --git a/src/app/panels/foldhaus_panel_sculpture_view.h b/src/app/panels/foldhaus_panel_sculpture_view.h index 304fff6..b9a31af 100644 --- a/src/app/panels/foldhaus_panel_sculpture_view.h +++ b/src/app/panels/foldhaus_panel_sculpture_view.h @@ -18,11 +18,11 @@ OPERATION_RENDER_PROC(Update3DViewMouseRotate) v2 TotalDeltaPos = Mouse.Pos - Mouse.DownPos; - m44 XRotation = GetXRotation(-TotalDeltaPos.y * State->PixelsToWorldScale); - m44 YRotation = GetYRotation(TotalDeltaPos.x * State->PixelsToWorldScale); + m44 XRotation = M44RotationX(-TotalDeltaPos.y * State->PixelsToWorldScale); + m44 YRotation = M44RotationY(TotalDeltaPos.x * State->PixelsToWorldScale); m44 Combined = XRotation * YRotation; - State->Camera.Position = V3(Combined * OpState->CameraStartPos); + State->Camera.Position = (Combined * OpState->CameraStartPos).xyz; } FOLDHAUS_INPUT_COMMAND_PROC(End3DViewMouseRotate) @@ -40,17 +40,17 @@ FOLDHAUS_INPUT_COMMAND_PROC(Begin3DViewMouseRotate) mouse_rotate_view_operation_state* OpState = CreateOperationState(RotateViewMode, &State->Modes, mouse_rotate_view_operation_state); - OpState->CameraStartPos = V4(State->Camera.Position, 1); + OpState->CameraStartPos = ToV4Point(State->Camera.Position); } // ---------------- GSMetaTag(panel_commands); GSMetaTag(panel_type_sculpture_view); -global_variable input_command SculptureView_Commands[] = { +global input_command SculptureView_Commands[] = { { KeyCode_MouseLeftButton, KeyCode_Invalid, Command_Began, Begin3DViewMouseRotate }, }; -global_variable s32 SculptureView_CommandsCount = 1; +global s32 SculptureView_CommandsCount = 1; GSMetaTag(panel_init); GSMetaTag(panel_type_sculpture_view); @@ -76,23 +76,26 @@ struct draw_leds_job_data s32 StartIndex; s32 OnePastLastIndex; render_quad_batch_constructor* Batch; - m44 ModelViewMatrix; + quad_batch_constructor_reserved_range BatchReservedRange; r32 LEDHalfWidth; }; internal void -DrawLEDsInBufferRangeJob (s32 ThreadID, void* JobData) +DrawLEDsInBufferRangeJob (gs_thread_context Context, gs_data JobData) { DEBUG_TRACK_FUNCTION; - draw_leds_job_data* Data = (draw_leds_job_data*)JobData; + draw_leds_job_data* Data = (draw_leds_job_data*)JobData.Memory; s32 LEDCount = Data->OnePastLastIndex - Data->StartIndex; +#if 0 // TODO(Peter): Why are we doing this here? Shouldn't we be able to tell what the range // needs to be at the time of creation? That way its all on one thread and we're not // worried about locking up. quad_batch_constructor_reserved_range BatchReservedRange = ThreadSafeReserveRangeInQuadConstructor(Data->Batch, LEDCount * 2); +#endif + s32 TrisUsed = 0; r32 HalfWidth = Data->LEDHalfWidth; @@ -113,77 +116,101 @@ DrawLEDsInBufferRangeJob (s32 ThreadID, void* JobData) v4 Color = v4{PixelColor.R / 255.f, PixelColor.G / 255.f, PixelColor.B / 255.f, 1.0f}; v4 Position = Data->LedBuffer.Positions[LedIndex]; - m44 FaceCameraMatrix = GetLookAtMatrix(Position, Data->CameraPosition); - v4 PositionOffset = V4(Position.xyz, 0); // Ensure PositionOffset is a vector, not a point + m44 FaceCameraMatrix = M44LookAt(Position, Data->CameraPosition); + v4 PositionOffset = ToV4Vec(Position.xyz); v4 P0 = (FaceCameraMatrix * P0_In) + PositionOffset; v4 P1 = (FaceCameraMatrix * P1_In) + PositionOffset; v4 P2 = (FaceCameraMatrix * P2_In) + PositionOffset; v4 P3 = (FaceCameraMatrix * P3_In) + PositionOffset; - SetTri3DInBatch(Data->Batch, BatchReservedRange.Start + TrisUsed++, + SetTri3DInBatch(Data->Batch, Data->BatchReservedRange.Start + TrisUsed++, P0, P1, P2, UV0, UV1, UV2, Color, Color, Color); - SetTri3DInBatch(Data->Batch, BatchReservedRange.Start + TrisUsed++, + SetTri3DInBatch(Data->Batch, Data->BatchReservedRange.Start + TrisUsed++, P0, P2, P3, UV0, UV2, UV3, Color, Color, Color); } } +internal void +DrawQuad(render_command_buffer* RenderBuffer, v4 C, r32 Rad, v4 Color) +{ + v4 P0 = C + v4{-Rad,-Rad,0,0}; + v4 P1 = C + v4{ Rad,-Rad,0,0}; + v4 P2 = C + v4{ Rad,Rad,0,0}; + v4 P3 = C + v4{ -Rad,Rad,0,0}; + PushRenderQuad3D(RenderBuffer, P0, P1, P2, P3, Color); +} + GSMetaTag(panel_render); GSMetaTag(panel_type_sculpture_view); internal void -SculptureView_Render(panel Panel, rect PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) +SculptureView_Render(panel Panel, rect2 PanelBounds, render_command_buffer* RenderBuffer, app_state* State, context Context) { DEBUG_TRACK_SCOPE(RenderSculpture); - r32 PanelWidth = PanelBounds.Max.x - PanelBounds.Min.x; - r32 PanelHeight = PanelBounds.Max.y - PanelBounds.Min.y; - State->Camera.AspectRatio = PanelWidth / PanelHeight; + // TODO(Peter): @MajorFix + // NOTE(Peter): Just returning from this function to make sure that this isn't a problem as I go and try to fix + // the other panels + return; - m44 ModelViewMatrix = GetCameraModelViewMatrix(State->Camera); - m44 ProjectionMatrix = GetCameraPerspectiveProjectionMatrix(State->Camera); - r32 LEDHalfWidth = .5f; + State->Camera.AspectRatio = RectAspectRatio(PanelBounds); - PushRenderPerspective(RenderBuffer, PanelBounds.Min.x, PanelBounds.Min.y, PanelWidth, PanelHeight, State->Camera); - - m44 FaceCameraMatrix = GetLookAtMatrix(v4{0, 0, 0, 1}, V4(State->Camera.Position, 1)); + PushRenderPerspective(RenderBuffer, PanelBounds, State->Camera); u32 MaxLEDsPerJob = 2048; render_quad_batch_constructor RenderLEDsBatch = PushRenderQuad3DBatch(RenderBuffer, State->LedSystem.LedsCountTotal); u32 FocusPixel = 256; - for (u32 i = 0; i < State->Assemblies.Count; i++) + for (u32 BufferIndex = 0; BufferIndex < State->LedSystem.BuffersCount; BufferIndex++) { - assembly Assembly = State->Assemblies.Values[i]; - led_buffer* LedBuffer = LedSystemGetBuffer(&State->LedSystem, Assembly.LedBufferIndex); - u32 JobsNeeded = IntegerDivideRoundUp(LedBuffer->LedCount, MaxLEDsPerJob); - - // TODO(Peter): TEMPORARY - identify this pixel - LedBuffer->Colors[FocusPixel] = pixel{ 255, 0, 255 }; + led_buffer* LedBuffer = LedSystemGetBuffer(&State->LedSystem, BufferIndex); + u32 JobsNeeded = U32DivideRoundUp(LedBuffer->LedCount, MaxLEDsPerJob); +#if 1 + u32 NextLEDIndex = 0; for (u32 Job = 0; Job < JobsNeeded; Job++) { - draw_leds_job_data* JobData = PushStruct(&State->Transient, draw_leds_job_data); + gs_data Data = PushSizeToData(&State->Transient, sizeof(draw_leds_job_data)); + draw_leds_job_data* JobData = (draw_leds_job_data*)Data.Memory; JobData->LedBuffer = *LedBuffer; - JobData->StartIndex = Job * MaxLEDsPerJob; - JobData->OnePastLastIndex = GSMin(JobData->StartIndex + MaxLEDsPerJob, LedBuffer->LedCount); + JobData->StartIndex = NextLEDIndex; + JobData->OnePastLastIndex = Min(JobData->StartIndex + MaxLEDsPerJob, LedBuffer->LedCount); + s32 JobLedCount = JobData->OnePastLastIndex - JobData->StartIndex; JobData->Batch = &RenderLEDsBatch; - JobData->ModelViewMatrix = ModelViewMatrix; - JobData->LEDHalfWidth = LEDHalfWidth; + JobData->BatchReservedRange = ReserveRangeInQuadConstructor(JobData->Batch, JobLedCount * 2); + JobData->LEDHalfWidth = .5f; - JobData->CameraPosition = V4(State->Camera.Position, 1); + JobData->CameraPosition = ToV4Point(State->Camera.Position); - Context.GeneralWorkQueue->PushWorkOnQueue(Context.GeneralWorkQueue, DrawLEDsInBufferRangeJob, JobData, "Sculpture Draw LEDS"); + Context.GeneralWorkQueue->PushWorkOnQueue(Context.GeneralWorkQueue, (thread_proc*)DrawLEDsInBufferRangeJob, Data, ConstString("Sculpture Draw LEDS")); + + NextLEDIndex = JobData->OnePastLastIndex; } +#else + gs_data Data = PushSizeToData(&State->Transient, sizeof(draw_leds_job_data)); + draw_leds_job_data* JobData = (draw_leds_job_data*)Data.Memory; + JobData->LedBuffer = *LedBuffer; + JobData->StartIndex = 0; + JobData->OnePastLastIndex = LedBuffer->LedCount; + s32 JobLedCount = JobData->OnePastLastIndex - JobData->StartIndex; + JobData->Batch = &RenderLEDsBatch; + JobData->BatchReservedRange = ReserveRangeInQuadConstructor(JobData->Batch, JobLedCount * 2); + JobData->LEDHalfWidth = .5f; + + JobData->CameraPosition = ToV4Point(State->Camera.Position); + + Context.GeneralWorkQueue->PushWorkOnQueue(Context.GeneralWorkQueue, (thread_proc*)DrawLEDsInBufferRangeJob, Data, ConstString("Sculpture Draw LEDS")); +#endif + + u32 f = 0; } // TODO(Peter): I don't like the fact that setting an orthographic view inside a panel render function // needs to relyon the window bounds rather than the panel bounds. Ideally the panel only needs to know where // itself is, and nothing else. - PushRenderOrthographic(RenderBuffer, - State->WindowBounds.Min.x, State->WindowBounds.Min.y, - State->WindowBounds.Max.x, State->WindowBounds.Max.y); + PushRenderOrthographic(RenderBuffer, State->WindowBounds); if (State->Assemblies.Count > 0) { @@ -196,9 +223,9 @@ SculptureView_Render(panel Panel, rect PanelBounds, render_command_buffer* Rende v4 LedProjectedPosition = Matrix * LedPosition; v2 LedOnScreenPosition = LedProjectedPosition.xy; - string TempString = PushString(&State->Transient, 256); - PrintF(&TempString, "%f %f", LedOnScreenPosition.x, LedOnScreenPosition.y); - DrawString(RenderBuffer, TempString, State->Interface.Style.Font, v2{PanelBounds.Min.x + 100, PanelBounds.Max.y - 200}, WhiteV4); + gs_string Tempgs_string = PushString(&State->Transient, 256); + PrintF(&Tempgs_string, "%f %f", LedOnScreenPosition.x, LedOnScreenPosition.y); + DrawString(RenderBuffer, Tempgs_string, State->Interface.Style.Font, v2{PanelBounds.Min.x + 100, PanelBounds.Max.y - 200}, WhiteV4); v2 BoxHalfDim = v2{ 25, 25 }; v2 BoxMin = LedOnScreenPosition - BoxHalfDim; @@ -206,7 +233,7 @@ SculptureView_Render(panel Panel, rect PanelBounds, render_command_buffer* Rende PushRenderBoundingBox2D(RenderBuffer, BoxMin, BoxMax, 2.0f, TealV4); } - Context.GeneralWorkQueue->DoQueueWorkUntilDone(Context.GeneralWorkQueue, 0); + Context.GeneralWorkQueue->CompleteQueueWork(Context.GeneralWorkQueue, Context.ThreadContext); } #define FOLDHAUS_PANEL_SCULPTURE_VIEW_H diff --git a/src/app/sacn/sacn.h b/src/app/sacn/sacn.h index 47adaa2..a871cea 100644 --- a/src/app/sacn/sacn.h +++ b/src/app/sacn/sacn.h @@ -160,11 +160,11 @@ VHD_PackLength_(u8* Buffer, u32 Length, b32 IncludeLength) } internal cid -StringToCID_ (const char* String) +gs_stringToCID_ (const char* gs_string) { cid Result = {}; - const char* Src = String; + const char* Src = gs_string; u8* Dest = &Result.Bytes[0]; b32 FirstNibble = true; @@ -215,7 +215,7 @@ InitStreamHeader (u8* Buffer, s32 BufferSize, Cursor = PackB2(Cursor, RLP_PREAMBLE_SIZE); Cursor = PackB2(Cursor, RLP_POSTAMBLE_SIZE); - GSMemCopy(ACN_IDENTIFIER, Cursor, ACN_IDENTIFIER_SIZE); + CopyMemoryTo(ACN_IDENTIFIER, Cursor, ACN_IDENTIFIER_SIZE); Cursor += ACN_IDENTIFIER_SIZE; // TODO(Peter): If you never use this anywhere else, go back and remove the parameters @@ -243,7 +243,7 @@ InitStreamHeader (u8* Buffer, s32 BufferSize, // framing source name // :Check - GSMemCopy(SourceName, (char*)Cursor, SOURCE_NAME_SIZE); + CopyMemoryTo(SourceName, (char*)Cursor, SOURCE_NAME_SIZE); Cursor[SOURCE_NAME_SIZE - 1] = '\0'; Cursor += SOURCE_NAME_SIZE; @@ -298,7 +298,7 @@ InitializeSACN (context Context) s32 Multicast_TimeToLive = 20; SACN.SendSocket = Context.PlatformGetSocketHandle(Multicast_TimeToLive); - SACN.CID = StringToCID_ ("{67F9D986-544E-4abb-8986-D5F79382586C}"); + SACN.CID = gs_stringToCID_ ("{67F9D986-544E-4abb-8986-D5F79382586C}"); return SACN; } diff --git a/src/app/test_patterns.h b/src/app/test_patterns.h index 51da616..6d4d0c6 100644 --- a/src/app/test_patterns.h +++ b/src/app/test_patterns.h @@ -18,9 +18,9 @@ struct solid_color_data GSMetaTag(node_proc); // :TagParamsForNodeParamStructs void SolidColorProc(solid_color_data* Data) { - u8 R = (u8)GSClamp(0.f, (Data->Color.r * 255), 255.f); - u8 G = (u8)GSClamp(0.f, (Data->Color.g * 255), 255.f); - u8 B = (u8)GSClamp(0.f, (Data->Color.b * 255), 255.f); + u8 R = (u8)Clamp(0.f, (Data->Color.r * 255), 255.f); + u8 G = (u8)Clamp(0.f, (Data->Color.g * 255), 255.f); + u8 B = (u8)Clamp(0.f, (Data->Color.b * 255), 255.f); for (s32 LedIndex = 0; LedIndex < Data->Result.LEDCount; LedIndex++) { @@ -64,7 +64,7 @@ void VerticalColorFadeProc(vertical_color_fade_data* Data) v4 LedPosition = Data->Result.LedPositions[LedIndex]; r32 Amount = (LedPosition.y - Data->Min) / Range; - Amount = GSClamp01(1.0f - Amount); + Amount = Clamp01(1.0f - Amount); Data->Result.Colors[LedIndex].R = (u8)(R * Amount); Data->Result.Colors[LedIndex].G = (u8)(G * Amount); @@ -107,14 +107,14 @@ void RevolvingDiscs(revolving_discs_data* Data) DEBUG_TRACK_FUNCTION; pixel Color = { - (u8)(GSClamp01(Data->Color.r) * 255), - (u8)(GSClamp01(Data->Color.g) * 255), - (u8)(GSClamp01(Data->Color.b) * 255), + (u8)(Clamp01(Data->Color.r) * 255), + (u8)(Clamp01(Data->Color.g) * 255), + (u8)(Clamp01(Data->Color.b) * 255), }; v4 Center = v4{0, 0, 0, 1}; - v4 Normal = v4{GSCos(Data->ThetaZ), 0, GSSin(Data->ThetaZ), 0}; // NOTE(Peter): dont' need to normalize. Should always be 1 - v4 Right = Cross(Normal, v4{0, 1, 0, 0}); + v4 Normal = v4{CosR32(Data->ThetaZ), 0, SinR32(Data->ThetaZ), 0}; // NOTE(Peter): dont' need to normalize. Should always be 1 + v4 Right = V4Cross(Normal, v4{0, 1, 0, 0}); v4 FrontCenter = Center + (Normal * Data->DiscWidth); v4 BackCenter = Center - (Normal * Data->DiscWidth); @@ -129,13 +129,13 @@ void RevolvingDiscs(revolving_discs_data* Data) v4 ToFront = Position + FrontCenter; v4 ToBack = Position + BackCenter; - r32 ToFrontDotNormal = Dot(ToFront, Normal); - r32 ToBackDotNormal = Dot(ToBack, Normal); + r32 ToFrontDotNormal = V4Dot(ToFront, Normal); + r32 ToBackDotNormal = V4Dot(ToBack, Normal); - ToFrontDotNormal = GSClamp01(ToFrontDotNormal * 1000); - ToBackDotNormal = GSClamp01(ToBackDotNormal * 1000); + ToFrontDotNormal = Clamp01(ToFrontDotNormal * 1000); + ToBackDotNormal = Clamp01(ToBackDotNormal * 1000); - r32 SqDistToCenter = MagSqr(Position); + r32 SqDistToCenter = V4MagSquared(Position); if (SqDistToCenter < OuterRadiusSquared && SqDistToCenter > InnerRadiusSquared) { if (XOR(ToFrontDotNormal > 0, ToBackDotNormal > 0)) diff --git a/src/app/win32_foldhaus.cpp b/src/app/win32_foldhaus.cpp index 88ff2d9..65df438 100644 --- a/src/app/win32_foldhaus.cpp +++ b/src/app/win32_foldhaus.cpp @@ -16,14 +16,13 @@ #include "../gs_libs/gs_win32.cpp" #include "win32_foldhaus_memory.h" -#include "win32_foldhaus_fileio.h" #include "win32_foldhaus_dll.h" #include "win32_foldhaus_timing.h" #include "foldhaus_renderer.cpp" -global_variable b32 Running = false; -global_variable b32 WindowIsActive = false; +global b32 Running = false; +global b32 WindowIsActive = false; char DLLName[] = "foldhaus.dll"; char WorkingDLLName[] = "foldhaus_temp.dll"; @@ -31,6 +30,317 @@ char DLLLockFileName[] = "lock.tmp"; window MainWindow; +// Utils + +internal gs_string +Win32DumpErrorAndPrepareMessageBoxString(gs_memory_arena* Arena, char* Format, ...) +{ + s32 Error = GetLastError(); + gs_string ErrorDump = PushString(Arena, 4096); + PrintF(&ErrorDump, + R"FOO(Win32 Error: %s\n +Error Code: %d\n + )FOO", + __FUNCTION__, + Error); + + va_list Args; + va_start(Args, Format); + PrintFArgsList(&ErrorDump, Format, Args); + va_end(Args); + + gs_data ErrorDumpData = StringToData(ErrorDump); + + HANDLE FileHandle = CreateFileA("./crashdump.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (FileHandle != INVALID_HANDLE_VALUE) + { + DWORD BytesWritten = 0; + if (WriteFile(FileHandle, ErrorDumpData.Memory, ErrorDumpData.Size, &BytesWritten, NULL)) + { + + } + CloseHandle(FileHandle); + } + + AppendPrintF(&ErrorDump, "Program will attempt to continue. See crashdump.txt for info"); + NullTerminate(&ErrorDump); + + return ErrorDump; +} + +DEBUG_PRINT(Win32DebugPrint) +{ + Assert(IsNullTerminated(Message)); + OutputDebugStringA(Message.Str); +} + +#define PrintLastError() PrintLastError_(__FILE__, __LINE__) +internal void +PrintLastError_(char* File, u32 Line) +{ + char DebugStringData[256]; + gs_string DebugString = MakeString(DebugStringData, 0, 256); + u32 Error = GetLastError(); + PrintF(&DebugString, "%s Line %d: Win32 Error %d\n\0", File, Line, Error); + OutputDebugStringA(DebugString.Str); +} + + +internal HINSTANCE +GetHInstance() +{ + HINSTANCE Result = GetModuleHandle(NULL); + if (Result == NULL) + { + PrintLastError(); + } + return Result; +} + +/////////////////////// +// +// Fie I/O + +internal u64 +Win32HighLowToU64(u32 LowPart, u32 HighPart) +{ + ULARGE_INTEGER Time = {}; + Time.LowPart = LowPart; + Time.HighPart = HighPart; + u64 Result = Time.QuadPart; + return Result; +} + +internal u64 +Win32FileTimeToU64(FILETIME FileTime) +{ + u64 Result = Win32HighLowToU64(FileTime.dwLowDateTime, FileTime.dwHighDateTime); + return Result; +} + +GET_FILE_INFO(Win32GetFileInfo) +{ + Assert(IsNullTerminated(Path)); + gs_file_info Result = {}; + HANDLE FileHandle = CreateFileA(Path.Str, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (FileHandle != INVALID_HANDLE_VALUE) + { + Result.Path = Path; + Result.FileSize = (u64)GetFileSize(FileHandle, NULL) + 1; + FILETIME CreationTime, LastWriteTime; + if (GetFileTime(FileHandle, &CreationTime, (LPFILETIME)0, &LastWriteTime)) + { + Result.CreationTime = Win32FileTimeToU64(CreationTime); + Result.LastWriteTime = Win32FileTimeToU64(LastWriteTime); + } + else + { + PrintLastError(); + } + CloseHandle(FileHandle); + } + return Result; +} + +READ_ENTIRE_FILE(Win32ReadEntireFile) +{ + Assert(DataIsNonEmpty(Memory)); + Assert(IsNullTerminated(Path)); + + gs_file Result = {0}; + u32 Error = 0; + Result.FileInfo.Path = Path; + + HANDLE FileHandle = CreateFileA(Path.Str, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (FileHandle != INVALID_HANDLE_VALUE) + { + DWORD BytesRead = 0; + if (ReadFile(FileHandle, (LPVOID)Memory.Memory, Memory.Size - 1, (LPDWORD)(&BytesRead), NULL)) + { + Memory.Memory[Memory.Size - 1] = 0; + Result.Data = Memory; + + gs_string AbsolutePath = PushString(FileHandler.Transient, 512); + AbsolutePath.Length = GetFullPathNameA(Path.Str, AbsolutePath.Size, AbsolutePath.Str, NULL); + if (AbsolutePath.Length == 0) + { + Error = GetLastError(); + InvalidCodePath; + } + Result.FileInfo.AbsolutePath = AbsolutePath.ConstString; + } + else + { + // NOTE(Peter): If we get to this error case, it means that the file exists, + // and was successfully opened, but we can't read from it. I'm choosing to + // treat this as a legitimate error at this point. + gs_string Message = Win32DumpErrorAndPrepareMessageBoxString(FileHandler.Transient, "Attempting to read file: %S", Path); + if (MessageBox(NULL, Message.Str, "Error", MB_OK) == IDOK) + { + PostQuitMessage(-1); + } + } + CloseHandle(FileHandle); + } + else + { + + } + + return Result; +} + +WRITE_ENTIRE_FILE(Win32WriteEntireFile) +{ + Assert(DataIsNonEmpty(Data)); + Assert(IsNullTerminated(Path)); + + bool Success = false; + HANDLE FileHandle = CreateFileA(Path.Str, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (FileHandle != INVALID_HANDLE_VALUE) + { + DWORD BytesWritten = 0; + if (WriteFile(FileHandle, Data.Memory, Data.Size, &BytesWritten, NULL)) + { + Success = (BytesWritten == Data.Size); + } + else + { + gs_string Message = Win32DumpErrorAndPrepareMessageBoxString(FileHandler.Transient, "Attempting to write to file: %S", Path); + MessageBox(NULL, Message.Str, "Error", MB_OK); + } + CloseHandle(FileHandle); + } + else + { + + } + + return Success; +} + +internal FILETIME +GetFileLastWriteTime(char* Path) +{ + FILETIME Result = {}; + + WIN32_FIND_DATA FindData = {}; + HANDLE FileHandle = FindFirstFileA(Path, &FindData); + + if (FileHandle != INVALID_HANDLE_VALUE) + { + Result = FindData.ftLastWriteTime; + FindClose(FileHandle); + } + else + { + // TODO(Peter): :ErrorLogging + } + + return Result; +} + +struct temp_file_list_entry +{ + gs_file_info Info; + temp_file_list_entry* Next; +}; + +struct temp_file_list +{ + temp_file_list_entry* First; + temp_file_list_entry* Last; +}; + +internal u32 +Win32EnumerateDirectoryIntoTempList(gs_file_handler FileHandler, temp_file_list* TempList, gs_const_string Path, gs_memory_arena* Storage, b32 Flags) +{ + u32 FilesCount = 0; + + u32 IndexOfLastSlash = FindLastFromSet(Path, "\\/"); + gs_const_string SearchPath = Substring(Path, 0, IndexOfLastSlash + 1); + + WIN32_FIND_DATA FindFileData; + HANDLE SearchHandle = FindFirstFile(Path.Str, &FindFileData); + if (SearchHandle != INVALID_HANDLE_VALUE) + { + do + { + if (HasFlag(FindFileData.dwFileAttributes, FILE_ATTRIBUTE_DIRECTORY)) + { + if (HasFlag(Flags, EnumerateDirectory_Recurse)) + { + gs_const_string SubDirName = ConstString(FindFileData.cFileName); + if (!StringsEqual(SubDirName, ConstString(".")) && + !StringsEqual(SubDirName, ConstString(".."))) + { + gs_string SubDirectoryPath = PushString(FileHandler.Transient, SearchPath.Length + SubDirName.Length + 3); + PrintF(&SubDirectoryPath, "%S%S/*\0", SearchPath, SubDirName); + FilesCount += Win32EnumerateDirectoryIntoTempList(FileHandler, TempList, SubDirectoryPath.ConstString, Storage, Flags); + } + } + + if (HasFlag(Flags, EnumerateDirectory_IncludeDirectories)) + { + FilesCount += 1; + } + } + else + { + temp_file_list_entry* File = PushStruct(FileHandler.Transient, temp_file_list_entry); + File->Info.FileSize = Win32HighLowToU64(FindFileData.nFileSizeLow, FindFileData.nFileSizeHigh); + File->Info.CreationTime = Win32FileTimeToU64(FindFileData.ftCreationTime); + File->Info.LastWriteTime = Win32FileTimeToU64(FindFileData.ftLastWriteTime); + File->Next = 0; + + u32 FileNameLength = CharArrayLength(FindFileData.cFileName); + + // NOTE(Peter): String Storage + // Storing the string in the final storage means we don't have to copy the string later, and all + // strings will be continguous in memory at the calling site, though they will be before the array + gs_string FileName = PushString(Storage, SearchPath.Length + FileNameLength + 1); + PrintF(&FileName, "%S%.*s", SearchPath, FileName.Size, FindFileData.cFileName); + NullTerminate(&FileName); + File->Info.Path = FileName.ConstString; + + SLLPushOrInit(TempList->First, TempList->Last, File); + FilesCount += 1; + } + }while(FindNextFile(SearchHandle, &FindFileData)); + } + else + { + PrintLastError(); + } + + return FilesCount; +} + +ENUMERATE_DIRECTORY(Win32EnumerateDirectory) +{ + Assert(IsNullTerminated(Path)); + gs_file_info_array Result = {}; + + temp_file_list TempList = {}; + Result.MaxCount = Win32EnumerateDirectoryIntoTempList(FileHandler, &TempList, Path, Storage, Flags); + + Result.Values = PushArray(Storage, gs_file_info, Result.MaxCount); + for (temp_file_list_entry* FileAt = TempList.First; + FileAt != 0; + FileAt = FileAt->Next) + { + // NOTE(Peter): We don't copy the file name here because its already in Storage. + // See String Storage note above ^^ + Result.Values[Result.Count++] = FileAt->Info; + } + + return Result; +} + +/////////////////////// +// +// Job System + struct worker_thread_entry { b32 IsValid; @@ -39,11 +349,42 @@ struct worker_thread_entry struct worker_thread_info { - s32 ID; + gs_thread_context ThreadContext; HANDLE Handle; - work_queue* Queue; + gs_work_queue* Queue; }; +internal s32 +Win32GetThreadId() +{ + s32 Result = GetCurrentThreadId(); + return Result; +} + +internal gs_thread_context +Win32CreateThreadContext(gs_memory_arena* Transient = 0) +{ + gs_thread_context Result = {0}; + Result.ThreadInfo.ThreadID = Win32GetThreadId(); + Result.Allocator = CreateAllocator(Win32Alloc, Win32Free); + if (Transient != 0) + { + Result.Transient = Transient; + } + else + { + Result.Transient = (gs_memory_arena*)AllocatorAlloc(Result.Allocator, sizeof(gs_memory_arena)).Memory; + *Result.Transient = CreateMemoryArena(Result.Allocator); + } + Result.FileHandler = CreateFileHandler(Win32GetFileInfo, + Win32ReadEntireFile, + Win32WriteEntireFile, + Win32EnumerateDirectory, + Result.Transient); + + return Result; +} + PUSH_WORK_ON_QUEUE(Win32PushWorkOnQueue) { #ifdef DEBUG @@ -51,18 +392,18 @@ PUSH_WORK_ON_QUEUE(Win32PushWorkOnQueue) // overflowing the buffer if (Queue->JobsCount >= Queue->JobsMax) { - string DebugString = MakeString((char*)malloc(256), 256); + gs_string DebugString = MakeString((char*)malloc(256), 256); for (u32 i = 0; i < Queue->JobsCount; i++) { PrintF(&DebugString, "%d %s\n", i, Queue->Jobs[i].JobName); NullTerminate(&DebugString); - OutputDebugStringA(DebugString.Memory); + OutputDebugStringA(DebugString.Str); } } #endif Assert(Queue->JobsCount < Queue->JobsMax); - worker_thread_job* Job = Queue->Jobs + Queue->JobsCount; + gs_threaded_job* Job = Queue->Jobs + Queue->JobsCount; Job->WorkProc = WorkProc; Job->Data = Data; #ifdef DEBUG @@ -78,7 +419,7 @@ PUSH_WORK_ON_QUEUE(Win32PushWorkOnQueue) } internal worker_thread_entry -CompleteAndTakeNextJob(work_queue* Queue, worker_thread_entry Completed) +CompleteAndTakeNextJob(gs_work_queue* Queue, worker_thread_entry Completed, gs_thread_context Context) { if (Completed.IsValid) { @@ -106,16 +447,16 @@ CompleteAndTakeNextJob(work_queue* Queue, worker_thread_entry Completed) return Result; } -DO_QUEUE_WORK_UNTIL_DONE(Win32DoQueueWorkUntilDone) +COMPLETE_QUEUE_WORK(Win32DoQueueWorkUntilDone) { worker_thread_entry Entry = {}; Entry.IsValid = false; while (Queue->JobsCompleted < Queue->JobsCount) { - Entry = CompleteAndTakeNextJob(Queue, Entry); + Entry = CompleteAndTakeNextJob(Queue, Entry, Context); if (Entry.IsValid) { - Queue->Jobs[Entry.Index].WorkProc(ThreadID, Queue->Jobs[Entry.Index].Data); + Queue->Jobs[Entry.Index].WorkProc(Context, Queue->Jobs[Entry.Index].Data); } } } @@ -124,15 +465,17 @@ DWORD WINAPI WorkerThreadProc (LPVOID InputThreadInfo) { worker_thread_info* ThreadInfo = (worker_thread_info*)InputThreadInfo; + ThreadInfo->ThreadContext = Win32CreateThreadContext(); worker_thread_entry Entry = {}; Entry.IsValid = false; while (true) { - Entry = CompleteAndTakeNextJob(ThreadInfo->Queue, Entry); + ClearArena(ThreadInfo->ThreadContext.Transient); + Entry = CompleteAndTakeNextJob(ThreadInfo->Queue, Entry, ThreadInfo->ThreadContext); if (Entry.IsValid) { - ThreadInfo->Queue->Jobs[Entry.Index].WorkProc(ThreadInfo->ID, + ThreadInfo->Queue->Jobs[Entry.Index].WorkProc(ThreadInfo->ThreadContext, ThreadInfo->Queue->Jobs[Entry.Index].Data); } else @@ -188,13 +531,13 @@ PLATFORM_GET_SOCKET_HANDLE(Win32GetSocketHandle) { s32 NewDictionaryMax = Win32SocketHandleMax + SOCKET_DICTIONARY_GROW_SIZE; s32 NewDictionaryDataSize = NewDictionaryMax * sizeof(win32_socket); - u8* DictionaryMemory = Win32Alloc(NewDictionaryDataSize); + u8* DictionaryMemory = (u8*)Win32Alloc(NewDictionaryDataSize, 0); Assert(DictionaryMemory); win32_socket* NewValues = (win32_socket*)(DictionaryMemory); if (SocketValues) { - GSMemCopy(SocketValues, NewValues, sizeof(win32_socket) * NewDictionaryMax); + CopyMemoryTo(SocketValues, NewValues, sizeof(win32_socket) * NewDictionaryMax); Win32Free((u8*)SocketValues, sizeof(win32_socket) * Win32SocketHandleCount); } SocketValues = NewValues; @@ -512,7 +855,7 @@ internal void DebugPrint (char* Format, ...) { char Buffer[256]; - string StringBuffer = MakeString(Buffer, 256); + gs_string StringBuffer = MakeString(Buffer, 256); va_list Args; va_start(Args, Format); PrintF(&StringBuffer, Format, Args); @@ -521,7 +864,7 @@ DebugPrint (char* Format, ...) } internal void -SetApplicationLinks (context* Context, win32_dll_refresh DLL, work_queue* WorkQueue) +SetApplicationLinks (context* Context, win32_dll_refresh DLL, gs_work_queue* WorkQueue) { if (DLL.IsValid) { @@ -539,27 +882,22 @@ SetApplicationLinks (context* Context, win32_dll_refresh DLL, work_queue* WorkQu } } +// TODO(Peter): :Redundant remove internal u8* DEBUGAlloc(s32 ElementSize, s32 ElementCount) { - return Win32Alloc(ElementSize * ElementCount); + return (u8*)Win32Alloc(ElementSize * ElementCount, 0); } +// TODO(Peter): :Redundant remove internal u8* Win32Realloc(u8* Buf, s32 OldSize, s32 NewSize) { - u8* NewMemory = Win32Alloc(NewSize); - GSMemCopy(Buf, NewMemory, OldSize); + u8* NewMemory = (u8*)Win32Alloc(NewSize, 0); + CopyMemoryTo(Buf, NewMemory, OldSize); return NewMemory; } -internal s32 -Win32GetThreadId() -{ - s32 Result = GetCurrentThreadId(); - return Result; -} - // NOTE(Peter): Only meant to take one of the values specified below: // IDC_APPSTARTING, IDC_ARROW, IDC_CROSS, IDC_HAND, IDC_HELP, IDC_IBEAM, // IDC_ICON, IDC_NO, IDC_SIZE, IDC_SIZEALL, IDC_SIZENESW, IDC_SIZENS, IDC_SIZENWSE, @@ -577,6 +915,36 @@ Win32LoadSystemCursor(char* CursorIdentifier) return Result; } +internal void +PrintMatrix(m44 M, gs_thread_context Context) +{ + gs_string PrintString = AllocatorAllocString(Context.Allocator, 256); + PrintF(&PrintString, "[\n %f %f %f %f\n %f %f %f %f\n %f %f %f %f\n %f %f %f %f\n]\n", + M.Array[0], M.Array[1], M.Array[2], M.Array[3], + M.Array[4], M.Array[5], M.Array[6], M.Array[7], + M.Array[8], M.Array[9], M.Array[10], M.Array[11], + M.Array[12], M.Array[13], M.Array[14], M.Array[15]); + NullTerminate(&PrintString); + OutputDebugStringA(PrintString.Str); +} + +v4 PerspectiveDivide(v4 A) +{ + v4 Result = {0, 0, 0, 1}; + Result.x = A.x / A.w; + Result.y = A.y / A.w; + Result.z = A.z / A.w; + Result.w = A.w; + return Result; +} +v4 ToScreen(v4 P, rect2 WindowBounds) +{ + v4 Result = P; + Result.x = RemapR32(P.x, -1, 1, WindowBounds.Min.x, WindowBounds.Max.x); + Result.y = RemapR32(P.y, -1, 1, WindowBounds.Min.y, WindowBounds.Max.y); + return Result; +} + int WINAPI WinMain ( HINSTANCE HInstance, @@ -585,6 +953,171 @@ WinMain ( INT NCmdShow ) { + gs_thread_context ThreadContext = Win32CreateThreadContext(); + + { + m44 Before = m44{ + 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15 + }; + m44 After = M44Transpose(Before); + OutputDebugStringA("Before:\n"); + PrintMatrix(Before, ThreadContext); + OutputDebugStringA("\n\n"); + OutputDebugStringA("After:\n"); + PrintMatrix(After, ThreadContext); + OutputDebugStringA("\n\n"); + + } + + { + v4 Before = {1, 2, 3, 4}; + m44 Transform = {}; + for (u32 i = 0; i < 16; i++) + { + Transform.Array[i] = i + 1; + } + v4 After = Transform * Before; + Assert(V4Mag(After - v4{30, 70, 110, 150}) < .00000001f); + } + + { // Translation + v4 Before = {0, 0, 0, 1}; + m44 Translation = M44Translation(v4{5, 5, 5, 0}); + v4 After = Translation * Before; + Assert((After == v4{5, 5, 5, 1})); + } + + { // X Rotation + v4 Before = {0, 5, 0, 1}; + m44 Forward = M44RotationX(HalfPiR32); + m44 Backward = M44RotationX(-HalfPiR32); + v4 After = Forward * Before; + Assert(V4Mag(After - v4{0, 0, -5, 1}) < .000001f); + After = Backward * Before; + Assert(V4Mag(After - v4{0, 0, 5, 1}) < .000001f); + } + + { // Y Rotation + v4 Before = {5, 0, 0, 1}; + m44 Forward = M44RotationY(HalfPiR32); + m44 Backward = M44RotationY(-HalfPiR32); + v4 After = Forward * Before; + Assert(V4Mag(After - v4{0, 0, -5, 1}) < .000001f); + After = Backward * Before; + Assert(V4Mag(After - v4{0, 0, 5, 1}) < .000001f); + } + + { // Z Rotation + v4 Before = {0, 5, 0, 1}; + m44 Forward = M44RotationZ(HalfPiR32); + m44 Backward = M44RotationZ(-HalfPiR32); + v4 After = Forward * Before; + Assert(V4Mag(After - v4{-5, 0, 0, 1}) < .000001f); + After = Backward * Before; + Assert(V4Mag(After - v4{5, 0, 0, 1}) < .000001f); + } + + { // Combined X Rotation + v4 Before = {0, 5, 0, 1}; + m44 Forward = M44Rotation(v3{HalfPiR32, 0, 0}); + m44 Backward = M44Rotation(v3{-HalfPiR32, 0, 0}); + v4 After = Forward * Before; + Assert(V4Mag(After - v4{0, 0, -5, 1}) < .000001f); + After = Backward * Before; + Assert(V4Mag(After - v4{0, 0, 5, 1}) < .000001f); + } + + { // Combined Y Rotation + v4 Before = {5, 0, 0, 1}; + m44 Forward = M44Rotation(v3{0, HalfPiR32, 0}); + m44 Backward = M44Rotation(v3{0, -HalfPiR32, 0}); + v4 After = Forward * Before; + Assert(V4Mag(After - v4{0, 0, -5, 1}) < .000001f); + After = Backward * Before; + Assert(V4Mag(After - v4{0, 0, 5, 1}) < .000001f); + } + + { // Combined Z Rotation + v4 Before = {0, 5, 0, 1}; + m44 Forward = M44Rotation(v3{0, 0, HalfPiR32}); + m44 Backward = M44Rotation(v3{0, 0, -HalfPiR32}); + v4 After = Forward * Before; + Assert(V4Mag(After - v4{-5, 0, 0, 1}) < .000001f); + After = Backward * Before; + Assert(V4Mag(After - v4{5, 0, 0, 1}) < .000001f); + } + + { // Translate then Rotate + v4 Before = v4{0, 0, 0, 1}; + + m44 Translation = M44Translation(v4{5, 0, 0, 0}); + m44 Rotation = M44Rotation(v3{0, 0, HalfPiR32}); + m44 Composite = Rotation * Translation; + + v4 Inbetween = Translation * Before; + v4 After = Rotation * Inbetween; + Assert(V4Mag(After - v4{0, 5, 0, 1}) < .000001f); + + After = Composite * Before; + Assert(V4Mag(After - v4{0, 5, 0, 1}) < .000001f); + } + + { // Two translations + v4 Before = v4{0, 0, 0, 1}; + m44 TranslationA = M44Translation(v4{5, 0, 0, 0}); + m44 TranslationB = M44Translation(v4{0, 5, 0, 0}); + v4 After = TranslationB * TranslationA * Before; + Assert(V4Mag(After - v4{5, 5, 0, 1}) < .000001f); + } + + { // Perspective Transform + rect2 WindowBounds = rect2{ + v2{0, 0}, + v2{1440.0f, 768.0f}, + }; + + m44 Matrix = M44Translation(v4{0, 0, -200, 0}) * M44Rotation(v3{0, DegToRadR32(45), 0}); + m44 Projection = M44ProjectionPerspective(45, RectAspectRatio(WindowBounds), 0.1f, 500); + + r32 Rad = 25; + v4 P0 = Matrix * v4{-Rad, -Rad, 0, 1}; + v4 P1 = Matrix * v4{Rad, -Rad, 0, 1}; + v4 P2 = Matrix * v4{Rad, Rad, 0, 1}; + v4 P3 = Matrix * v4{-Rad, Rad, 0, 1}; + + v4 P0P = Projection * P0; + v4 P1P = Projection * P1; + v4 P2P = Projection * P2; + v4 P3P = Projection * P3; + + v4 P0PD = PerspectiveDivide(P0P); + v4 P1PD = PerspectiveDivide(P1P); + v4 P2PD = PerspectiveDivide(P2P); + v4 P3PD = PerspectiveDivide(P3P); + + v4 P0S = ToScreen(P0PD, WindowBounds); + P0S.w = 1; + + v4 P1S = ToScreen(P1PD, WindowBounds); + P1S.w = 1; + + v4 P2S = ToScreen(P2PD, WindowBounds); + P2S.w = 1; + + v4 P3S = ToScreen(P3PD, WindowBounds); + P3S.w = 1; + + Assert(V4Mag(P0S - v4{630.11401, 256.88202, 0.99930286, 1}) < 0.00001f); + Assert(V4Mag(P1S - v4{795.28662, 277.52859, 0.99948108, 1}) < 0.00001f); + Assert(V4Mag(P2S - v4{795.28662, 490.47144, 0.99948108, 1}) < 0.00001f); + Assert(V4Mag(P3S - v4{630.11401, 511.11798, 0.99930286, 1}) < 0.00001f); + + //PushRenderQuad2D(RenderBuffer, P0S.xy, P1S.xy, P2S.xy, P3S.xy, WhiteV4); + } + MainWindow = Win32CreateWindow (HInstance, "Foldhaus", 1440, 768, HandleWindowEvents); Win32UpdateWindowDimension(&MainWindow); @@ -612,7 +1145,7 @@ WinMain ( input_queue InputQueue; { s32 InputQueueMemorySize = sizeof(input_entry) * 32; - u8* InputQueueMemory = Win32Alloc(InputQueueMemorySize); + u8* InputQueueMemory = (u8*)Win32Alloc(InputQueueMemorySize, 0); InputQueue = InitializeInputQueue(InputQueueMemory, InputQueueMemorySize); } @@ -625,31 +1158,31 @@ WinMain ( WorkerThreads = (worker_thread_info*)malloc(sizeof(worker_thread_info) * PLATFORM_THREAD_COUNT); } - work_queue WorkQueue = {}; - WorkQueue.SemaphoreHandle = CreateSemaphoreEx(0, 0, PLATFORM_THREAD_COUNT, 0, 0, SEMAPHORE_ALL_ACCESS); + HANDLE WorkQueueSemaphoreHandle = CreateSemaphoreEx(0, 0, PLATFORM_THREAD_COUNT, 0, 0, SEMAPHORE_ALL_ACCESS); + + gs_work_queue WorkQueue = {}; + WorkQueue.SemaphoreHandle = &WorkQueueSemaphoreHandle; WorkQueue.JobsMax = 512; - WorkQueue.Jobs = (worker_thread_job*)Win32Alloc(sizeof(worker_thread_job) * WorkQueue.JobsMax); + WorkQueue.Jobs = (gs_threaded_job*)Win32Alloc(sizeof(gs_threaded_job) * WorkQueue.JobsMax, 0); WorkQueue.NextJobIndex = 0; WorkQueue.PushWorkOnQueue = Win32PushWorkOnQueue; - WorkQueue.DoQueueWorkUntilDone = Win32DoQueueWorkUntilDone; + WorkQueue.CompleteQueueWork = Win32DoQueueWorkUntilDone; WorkQueue.ResetWorkQueue = ResetWorkQueue; - OutputDebugStringA("Hellooooo\n"); - for (s32 i = 0; i < PLATFORM_THREAD_COUNT; i++) { // ID = 0 is reserved for this thread - WorkerThreads[i].ID = i + 1; WorkerThreads[i].Queue = &WorkQueue; WorkerThreads[i].Handle = CreateThread(0, 0, &WorkerThreadProc, (void*)&WorkerThreads[i], 0, 0); } - s32 InitialMemorySize = Megabytes(64); - u8* InitialMemory = Win32Alloc(InitialMemorySize); + s32 InitialMemorySize = MB(64); + u8* InitialMemory = (u8*)Win32Alloc(InitialMemorySize, 0); context Context = {}; + Context.ThreadContext = ThreadContext; Context.MemorySize = InitialMemorySize; Context.MemoryBase = InitialMemory; - Context.WindowBounds = rect{v2{0, 0}, v2{(r32)MainWindow.Width, (r32)MainWindow.Height}}; + Context.WindowBounds = rect2{v2{0, 0}, v2{(r32)MainWindow.Width, (r32)MainWindow.Height}}; Context.Mouse = {0}; // Cursors @@ -663,12 +1196,6 @@ WinMain ( // Platform functions Context.GeneralWorkQueue = &WorkQueue; - Context.PlatformMemory.Alloc = Win32Alloc; - Context.PlatformMemory.Free = Win32Free; - Context.PlatformMemory.Realloc = Win32Realloc; - Context.FileHandler.ReadEntireFile = Win32ReadEntireFile; - Context.FileHandler.WriteEntireFile = Win32WriteEntireFile; - Context.FileHandler.GetFilePath = Win32SystemDialogueOpenFile; Context.PlatformGetGPUTextureHandle = Win32GetGPUTextureHandle; Context.PlatformGetSocketHandle = Win32GetSocketHandle; Context.PlatformSetSocketOption = Win32SetSocketOption; @@ -692,8 +1219,8 @@ WinMain ( WSADATA WSAData; WSAStartup(MAKEWORD(2, 2), &WSAData); - s32 RenderMemorySize = Megabytes(12); - u8* RenderMemory = Win32Alloc(RenderMemorySize); + s32 RenderMemorySize = MB(12); + u8* RenderMemory = (u8*)Win32Alloc(RenderMemorySize, 0); render_command_buffer RenderBuffer = AllocateRenderCommandBuffer(RenderMemory, RenderMemorySize, Win32Realloc); Context.InitializeApplication(Context); @@ -733,7 +1260,7 @@ WinMain ( HandleWindowMessage(Message, &MainWindow, &InputQueue, &Context.Mouse); } - Context.WindowBounds = rect{v2{0, 0}, v2{(r32)MainWindow.Width, (r32)MainWindow.Height}}; + Context.WindowBounds = rect2{v2{0, 0}, v2{(r32)MainWindow.Width, (r32)MainWindow.Height}}; RenderBuffer.ViewWidth = MainWindow.Width; RenderBuffer.ViewHeight = MainWindow.Height; Context.DeltaTime = LastFrameSecondsElapsed; diff --git a/src/app/win32_foldhaus_dll.h b/src/app/win32_foldhaus_dll.h index 01b6bea..26071e6 100644 --- a/src/app/win32_foldhaus_dll.h +++ b/src/app/win32_foldhaus_dll.h @@ -22,15 +22,15 @@ struct win32_dll_refresh }; internal int -Win32DLLStringLength(char* String) +Win32DLLgs_stringLength(char* gs_string) { - char* At = String; + char* At = gs_string; while (*At) { At++; }; - return At - String; + return At - gs_string; } internal int -Win32DLLConcatStrings(int ALength, char* A, int BLength, char* B, int DestLength, char* Dest) +Win32DLLConcatgs_strings(int ALength, char* A, int BLength, char* B, int DestLength, char* Dest) { char* Dst = Dest; char* AAt = A; @@ -112,14 +112,14 @@ InitializeDLLHotReloading(char* SourceDLLName, ExePath.Path = (char*)VirtualAlloc(NULL, ExePath.PathLength, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); GetApplicationPath(&ExePath); - Win32DLLConcatStrings(ExePath.IndexOfLastSlash, ExePath.Path, - Win32DLLStringLength(SourceDLLName), SourceDLLName, + Win32DLLConcatgs_strings(ExePath.IndexOfLastSlash, ExePath.Path, + Win32DLLgs_stringLength(SourceDLLName), SourceDLLName, MAX_PATH, Result.SourceDLLPath); - Win32DLLConcatStrings(ExePath.IndexOfLastSlash, ExePath.Path, - Win32DLLStringLength(WorkingDLLFileName), WorkingDLLFileName, + Win32DLLConcatgs_strings(ExePath.IndexOfLastSlash, ExePath.Path, + Win32DLLgs_stringLength(WorkingDLLFileName), WorkingDLLFileName, MAX_PATH, Result.WorkingDLLPath); - Win32DLLConcatStrings(ExePath.IndexOfLastSlash, ExePath.Path, - Win32DLLStringLength(LockFileName), LockFileName, + Win32DLLConcatgs_strings(ExePath.IndexOfLastSlash, ExePath.Path, + Win32DLLgs_stringLength(LockFileName), LockFileName, MAX_PATH, Result.LockFilePath); Win32Free((u8*)ExePath.Path, ExePath.PathLength); diff --git a/src/app/win32_foldhaus_fileio.h b/src/app/win32_foldhaus_fileio.h index 46a109a..a45c25e 100644 --- a/src/app/win32_foldhaus_fileio.h +++ b/src/app/win32_foldhaus_fileio.h @@ -8,138 +8,5 @@ // #ifndef WIN32_FOLDHAUS_FILEIO_H -PLATFORM_READ_ENTIRE_FILE(Win32ReadEntireFile) -{ - platform_memory_result Result = {}; - Result.Error = PlatformMemory_NoError; - - Assert(IsNullTerminated(Path)); - HANDLE FileHandle = CreateFileA (Path.Memory, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - - if (FileHandle != INVALID_HANDLE_VALUE) - { - DWORD FileSize = GetFileSize(FileHandle, NULL); - Result.Data.Base = (u8*)VirtualAlloc(NULL, FileSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); - if (Result.Data.Base) - { - Result.Data.Size = FileSize; - - s32 BytesRead = 0; - if (ReadFile(FileHandle, (LPVOID)Result.Data.Base, FileSize, (LPDWORD)(&BytesRead), NULL)) - { - - } - else - { - u32 Error = GetLastError(); - VirtualFree(Result.Data.Base, 0, MEM_RELEASE); - Result.Data.Size = 0; - Result.Error = PlatformMemory_UnknownError; - } - } - else - { - Result.Error = PlatformMemory_UnknownError; - } - CloseHandle(FileHandle); - } - else - { - Result.Error = PlatformMemory_FileNotFound; - } - - return Result; -} - -PLATFORM_WRITE_ENTIRE_FILE(Win32WriteEntireFile) -{ - Assert(IsNullTerminated(Path)); - b32 Result = false; - HANDLE FileHandle = CreateFileA ( - Path.Memory, - GENERIC_WRITE, - 0, - NULL, - CREATE_ALWAYS, - FILE_ATTRIBUTE_NORMAL, - NULL); - - if (FileHandle != INVALID_HANDLE_VALUE) - { - DWORD BytesWritten = 0; - - b32 WriteSuccess = WriteFile(FileHandle, - Contents, Size, - &BytesWritten, - NULL); - - if (WriteSuccess && BytesWritten == (u32)Size) - { - CloseHandle(FileHandle); - Result = true; - } - else - { - Result = false; - } - } - else - { - Result = false; - } - - return Result; -} - -internal FILETIME -GetFileLastWriteTime(char* Path) -{ - FILETIME Result = {}; - - WIN32_FIND_DATA FindData = {}; - HANDLE FileHandle = FindFirstFileA(Path, &FindData); - - if (FileHandle != INVALID_HANDLE_VALUE) - { - Result = FindData.ftLastWriteTime; - FindClose(FileHandle); - } - else - { - // TODO(Peter): :ErrorLogging - } - - return Result; -} - -PLATFORM_GET_FILE_PATH(Win32SystemDialogueOpenFile) -{ - b32 Result = false; - - PathBuffer->Memory[0] = 0; - - OPENFILENAMEA OpenFileName = {}; - OpenFileName.lStructSize = sizeof(OpenFileName); - OpenFileName.hwndOwner = NULL; - OpenFileName.lpstrFilter = FilterStrings; - OpenFileName.lpstrCustomFilter = NULL; // NOTE(Peter): for preserving last filter string chosen - OpenFileName.nMaxCustFilter = 0; // NOTE(Peter): ignored since we left CustomFilter null - OpenFileName.nFilterIndex = 1; - OpenFileName.lpstrFile = PathBuffer->Memory; - OpenFileName.nMaxFile = PathBuffer->Max; - OpenFileName.lpstrFileTitle = NULL; - OpenFileName.nMaxFileTitle = 0; // NOTE(Peter): Ignored since fileTitle is null - OpenFileName.lpstrInitialDir = NULL; - OpenFileName.lpstrTitle = NULL; - OpenFileName.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST; - OpenFileName.lpstrDefExt = NULL; - - Result = GetOpenFileNameA (&OpenFileName); - - PathBuffer->Length = CharArrayLength(PathBuffer->Memory); - - return Result; -} - #define WIN32_FOLDHAUS_FILEIO_H #endif // WIN32_FOLDHAUS_FILEIO_H \ No newline at end of file diff --git a/src/app/win32_foldhaus_memory.h b/src/app/win32_foldhaus_memory.h index c1c8c1c..100dd1a 100644 --- a/src/app/win32_foldhaus_memory.h +++ b/src/app/win32_foldhaus_memory.h @@ -8,17 +8,21 @@ // #ifndef WIN32_FOLDHAUS_MEMORY_H -PLATFORM_ALLOC(Win32Alloc) +ALLOCATOR_ALLOC(Win32Alloc) { u8* Result = (u8*)VirtualAlloc(NULL, Size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); + if (ResultSize != 0) + { + *ResultSize = Size; + } return Result; } -PLATFORM_FREE(Win32Free) +ALLOCATOR_FREE(Win32Free) { - b32 Result = VirtualFree(Base, 0, MEM_RELEASE); + b32 Result = VirtualFree(Ptr, 0, MEM_RELEASE); if (!Result) { s32 Error = GetLastError(); @@ -26,18 +30,6 @@ PLATFORM_FREE(Win32Free) // to know what it could possibly be. InvalidCodePath; } - return Result; -} - -PLATFORM_REALLOC(Win32Realloc) -{ - u8* NewMemory = Win32Alloc(NewSize); - if (Base) - { - GSMemCopy(Base, NewMemory, OldSize); - Win32Free(Base, OldSize); - } - return NewMemory; } #define WIN32_FOLDHAUS_MEMORY_H diff --git a/src/gs_libs/gs_language.h b/src/gs_libs/gs_language.h index 9e12e25..b95b246 100644 --- a/src/gs_libs/gs_language.h +++ b/src/gs_libs/gs_language.h @@ -1,5 +1,6 @@ #ifndef GS_LANGUAGE_H +#if 0 #if defined(_WIN32) || defined(_WIN64) || defined(__WIN32__) #include @@ -7,7 +8,7 @@ #include #elif defined(__APPLE__) && defined(__MAC__) -// TODO(Peter): +// TODO(Peter): #else // Std lib #include @@ -42,6 +43,8 @@ typedef long long int s64; typedef float r32; typedef double r64; +#endif + #ifndef _STDINT #define INT8_MIN (-128) @@ -268,15 +271,15 @@ GSLerpDef(r32) GSLerpDef(r64) #undef GSLerpDef -static r32 GSSqrt(r32 V) -{ +static r32 GSSqrt(r32 V) +{ r32 Result = _mm_cvtss_f32(_mm_sqrt_ss(_mm_set_ss(V))); - return Result; + return Result; } #if 0 // TODO(Peter): Need a way to split the input into two f32's to supply to _mm_sqrt_sd -static r64 GSSqrt(r64 V) -{ +static r64 GSSqrt(r64 V) +{ r64 Result = _mm_cvtsd_f64(_mm_sqrt_sd(_mm_set_sd(V))); return Result; } @@ -366,9 +369,9 @@ RoundToNearestPowerOfTwo (u8 V) { u8 Result = 0; - if (IsPowerOfTwo(V)) - { - Result = V; + if (IsPowerOfTwo(V)) + { + Result = V; } else { @@ -387,9 +390,9 @@ RoundToNearestPowerOfTwo (u16 V) { u16 Result = 0; - if (IsPowerOfTwo(V)) - { - Result = V; + if (IsPowerOfTwo(V)) + { + Result = V; } else { @@ -409,9 +412,9 @@ RoundToNearestPowerOfTwo (u32 V) { u32 Result = 0; - if (IsPowerOfTwo(V)) - { - Result = V; + if (IsPowerOfTwo(V)) + { + Result = V; } else { @@ -432,9 +435,9 @@ RoundToNearestPowerOfTwo (u64 V) { u64 Result = 0; - if (IsPowerOfTwo(V)) - { - Result = V; + if (IsPowerOfTwo(V)) + { + Result = V; } else { diff --git a/src/gs_libs/gs_memory_arena.h b/src/gs_libs/gs_memory_arena.h index 119656c..4fbeb3b 100644 --- a/src/gs_libs/gs_memory_arena.h +++ b/src/gs_libs/gs_memory_arena.h @@ -314,7 +314,7 @@ PlatformRealloc(platform_memory_handler Platform, gs_mem_u8* Head, gs_mem_u32 Ol Result = PlatformAlloc(Platform, NewSize); if (Head != 0 && OldSize != 0) { - GSMemCopy(Head, Result, OldSize); + CopyMemoryTo(Head, Result, OldSize); PlatformFree(Platform, Head, OldSize); } } @@ -336,8 +336,6 @@ FreeMemoryArena(memory_arena* Arena) PlatformFree(Arena->PlatformMemory, (u8*)Arena->Buffers, sizeof(memory_buffer) * Arena->BuffersCount); } -#define IsPowerOfTwo(v) ((v != 0) && ((v & (v - 1)) == 0)) - inline gs_mem_u32 GetAlignmentOffset (gs_mem_u64 Address, gs_mem_u32 Alignment, gs_mem_u32 AlignmentMask) { diff --git a/src/gs_libs/gs_string.h b/src/gs_libs/gs_string.h index 9b3f4c0..6b4efca 100644 --- a/src/gs_libs/gs_string.h +++ b/src/gs_libs/gs_string.h @@ -6,18 +6,6 @@ #ifndef GS_STRING_H #include -//////////////////////////////////////////////////////////////// -// String -//////////////////////////////////////////////////////////////// - -struct string -{ - char* Memory; - s32 Length; - // TODO(Peter): Max -> LengthMax for clarity - s32 Max; -}; - //////////////////////////////////////////////////////////////// // String Tokenizing //////////////////////////////////////////////////////////////// @@ -115,75 +103,14 @@ struct token { token_type Type; u32 LineNumber; - string Text; + gs_string Text; token* Next; // TODO(Peter): Get rid of this }; -//////////////////////////////////////////////////////////////// -// String Memory -//////////////////////////////////////////////////////////////// - -struct slot_header -{ - slot_header* Next; - s32 Size; -}; - -struct slot_arena -{ - u8* Memory; - s32 SlotSize; - s32 SlotCount; - slot_header* FreeList; -}; - -struct contiguous_slot_count_result -{ - s32 Count; - slot_header* LastContiguousSlot; -}; - - //////////////////////////////////////////////////////////////// // String Function Declarations //////////////////////////////////////////////////////////////// -// Utility -#if !defined GS_LANGUAGE_H - -static void GSZeroMemory (u8* Memory, s32 Size); -static s32 GSMin (s32 A, s32 B); -static s32 GSAbs (s32 A); -static float GSAbsF (float A); -static float GSPowF (float N, s32 Power); - -#endif - -// Setup -#define PushString(arena, size) MakeString(PushArray(arena, char, size), 0, size); - -static void InitializeEmptyString (string* String, char* Data, s32 DataSize); -static void InitializeString(string* String, char* Data, s32 Used, s32 Max); -static string InitializeEmptyString (char* Data, s32 DataSize); -static string InitializeString (char* Data, s32 Used, s32 Max); -static void ClearString (string* String); - -// Character Values -static bool IsSlash (char C); -static bool IsNewline (char C); -static bool IsWhitespace (char C); -static bool IsNewlineOrWhitespace (char C); -static bool IsAlpha (char C); -static bool IsUpper (char C); -static bool IsLower (char C); -static char ToUpper (char C); -static char ToLower (char C); -static bool IsNumeric (char C); -static bool IsNumericExtended (char C); -static bool IsAlphaNumeric (char C); -static bool IsOperator (char C); -static bool CharsEqualCaseInsensitive(char A, char B); - // Tokenizing static void EatChar(tokenizer* T); static b32 AtValidPosition(tokenizer Tokenizer); @@ -205,290 +132,6 @@ static s32 EatPastCharacter(tokenizer* T, char Char); static char* EatNumber(char* C); static s32 EatNumber(tokenizer* T); -// Char/Char Array -static u32 CharToUInt (char C); -static s32 CharArrayLength (char* CharArray); -static bool CharArraysEqual (char* A, s32 ALength, char* B, s32 BLength); -static bool CharArraysEqualUnsafe (char* A, char* B); -static void ReverseCharArray (char* Array, s32 Length); -#define FirstIndexOfCharInCharArray(array, find) IndexOfChar(array, 0, find) -static s32 IndexOfChar (char* Array, s32 Start, char Find); -#define FastLastIndexOfCharInCharArray(array, len, find) FastReverseIndexOfChar(array, len, 0, find) -static s32 FastReverseIndexOfChar (char* Array, s32 Length, s32 OffsetFromEnd, char Find); -#define LastIndexOfCharInCharArray(array, find) ReverseIndexOfChar(array, 0, find) -static s32 ReverseIndexOfChar (char* Array, s32 OffsetFromEnd, char Find); -static b32 CharArrayContains(char* Array, char* CheckFor); -static b32 CharArrayContainsSafe(char* Array, s32 ArrayLength, char* CheckFor, s32 CheckForLength); - -// String - -#define MakeStringBuffer(name, size) char name##Backbuffer[(size)]; string name = MakeString(name##Backbuffer, size); - -static string MakeString (char* Array, s32 Length, s32 Max); -static string MakeString (char* Array, s32 Length); -static string MakeString (char* Array); -static string MakeStringLiteral(char* Data); - -static bool StringsEqual (string A, string B); -static bool StringEqualsCharArray (string String, char* CharArray, s32 CharArrayLength); -static bool StringEqualsCharArray (string String, char* CharArray); -static s32 FindFirstChar (string String, char C); - -static void SetStringToChar (string* Dest, char C, s32 Count); -static void SetStringToCharArray (string* Dest, char* Source); - -static void ConcatString (string Source, string* Dest); -static void ConcatString (string Source, s32 Length, string* Dest); -static void ConcatCharToString(string* Dest, char C); -static void ConcatCharArrayToString (char* Source, string* Dest); -static void ConcatCharArrayToString (char* Source, s32 SourceLength, string* Dest); - -static void CopyStringTo (string Source, string* Dest); -static s32 CopyStringToCharArray (string Source, char* Dest, s32 DestLength); -static void CopyCharArrayToString (char* Src, string* Dest); -static void CopyCharArrayToString (char* Src, s32 SrcLength, string* Dest); -static s32 CopyCharArray (char* Source, char* Dest, s32 DestLength); -static s32 CopyCharArrayAt (char* Source, char* Dest, s32 DestLength, s32 Offset); - -static void InsertChar (string* String, char Char, s32 Index); -static void InsertStringAt (string* Dest, string Source, s32 At); -static void RemoveCharAt (string* String, s32 Index); - -static s32 IndexOfChar(string String, char C); -static s32 LastIndexOfChar(string String, char C); -static s32 SearchForCharInSet(string String, char* Set); -static s32 ReverseSearchForCharInSet(string String, char* Set); -static string Substring (string* String, s32 Start, s32 End); -static string Substring (string* String, s32 Start); - -static b32 StringContainsCharArray(string SearchIn, char* SearchFor, s32 SearchForLength); -static b32 StringContainsString(string SearchIn, string SearchFor); -static b32 StringContainsCharArrayCaseInsensitive(string SearchIn, char* SearchFor, s32 SearchForLength); -static b32 StringContainsStringCaseInsensitive(string SearchIn, string SearchFor); - -static void NullTerminate (string* String); - -static u32 HashString(string String); - -// Parsing -enum parse_type -{ - ParseType_UnsignedInt, - ParseType_SignedInt, - ParseType_Float, -}; - -struct parse_result -{ - parse_type Type; - char* OnePastLast; - union - { - u32 UnsignedIntValue; - s32 SignedIntValue; - r32 FloatValue; - }; -}; - -enum format_flags -{ - FormatFlags_LeftJustify = 0x1, - FormatFlags_ForceSign = 0x2, - FormatFlags_ForceSpaceInsteadOfSign = 0x4, - FormatFlags_ForceDecimalOrPrependOx = 0x8, - FormatFlags_PadWithZeroesInsteadOfSpaces = 0x16, -}; - -static parse_result ParseUnsignedInt (s32 Length, char* String); -static parse_result ParseSignedInt (s32 Length, char* String); -static parse_result ParseFloat (s32 Length, char* String); - -// PrintF - -#define StringExpand(str) (str).Length, (str).Memory -static void PrintFArgList(char* Dest, s32 DestMax, char* Format, va_list Args); -static void PrintF(string* String, char* Format, ...); - -// Printing Helper Functions -static u32 GetU32NumberOfCharactersNeeded(u32 Value, u32 Base = 10); -static u32 GetS32NumberOfCharactersNeeded(u32 Value, s32 Base = 10); - -//////////////////////////////////////////////////////////////// -// String Memory Function Declarations -//////////////////////////////////////////////////////////////// - -static s32 CalculateSlotCountFromSize (s32 RequestedSize, s32 SlotSize); -static bool SlotsAreContiguous (slot_header* First, slot_header* Second); -static contiguous_slot_count_result CountContiguousSlots (slot_header* First); -static slot_header* GetSlotAtOffset(slot_header* First, s32 Offset); -static slot_header* InsertSlotIntoList (slot_header* NewSlot, slot_header* ListStart); -static void AllocStringFromStringArena (string* String, s32 Size, slot_arena* Storage); -static string AllocStringFromStringArena (s32 Size, slot_arena* Storage); -static void FreeToStringArena (string* String, slot_arena* Storage); -static void ReallocFromStringArena (string* String, s32 NewSize, slot_arena* Storage); - -//////////////////////////////////////////////////////////////// -// String Utility Functions -//////////////////////////////////////////////////////////////// - -#if !defined GS_LANGUAGE_H - -static void -GSZeroMemory (u8* Memory, s32 Size) -{ - for (int i = 0; i < Size; i++) { Memory[i] = 0; } -} - -static s32 -GSMin (s32 A, s32 B) -{ - return (A < B ? A : B); -} - -static s32 -GSAbs (s32 A) -{ - return (A < 0 ? -A : A); -} - -static float -GSAbs (float A) -{ - return (A < 0 ? -A : A); -} - -static float -GSPow (float N, s32 Power) -{ - float Result = N; - for(s32 i = 1; i < Power; i++) { Result *= N; } - return Result; -} - -#endif - -//////////////////////////////////////////////////////////////// -// Init and Clear -//////////////////////////////////////////////////////////////// - -static void -InitializeEmptyString (string* String, char* Data, s32 DataSize) -{ - String->Memory = Data; - String->Max = DataSize; - String->Length = 0; -} - -static void -InitializeString(string* String, char* Data, s32 Used, s32 Max) -{ - String->Memory = Data; - String->Max = Max; - String->Length = Used; -} - -static string -InitializeEmptyString (char* Data, s32 DataSize) -{ - string Result = {}; - Result.Memory = Data; - Result.Max = DataSize; - Result.Length = 0; - return Result; -} - -static string -InitializeString (char* Data, s32 Used, s32 Max) -{ - string Result = {}; - Result.Memory = Data; - Result.Max = Max; - Result.Length = Used; - return Result; -} - -static void -ClearString (string* String) -{ - String->Memory = 0; - String->Max = 0; - String->Length = 0; -} - -//////////////////////////////////////////////////////////////// -// Char Value Types -//////////////////////////////////////////////////////////////// - -static bool IsNullTerminated(string Str) -{ - char LastChar = Str.Memory[Str.Length]; - bool Result = (LastChar == 0); - return Result; -} -static bool IsSlash (char C) { return ((C == '\\') || (C == '/')); } -static bool IsNewline (char C) { return (C == '\n') || (C == '\r'); } -static bool IsWhitespace (char C) { return (C == ' ') || (C == '\t'); } -static bool IsNewlineOrWhitespace (char C) { return (IsWhitespace(C) || IsNewline(C)); } -static bool IsAlpha (char C) -{ - // TODO(Peter): support UTF8 chars - return ((C >= 'A') && (C <= 'Z')) || ((C >= 'a') && (C <= 'z')) || (C == '_'); -} -static bool IsUpper (char C) -{ - return ((C >= 'A') && (C <= 'Z')); -} -static bool IsLower (char C) -{ - return ((C >= 'a') && (C <= 'z')); -} -static bool IsNumeric (char C) -{ - return (C >= '0') && (C <= '9'); -} -static bool IsNumericExtended (char C) -{ - return (IsNumeric(C) || (C == '-') || (C == 'x') || (C == 'f') || (C == '.')); -} -static bool IsAlphaNumeric (char C) -{ - return IsAlpha(C) || IsNumeric(C); -} -static bool IsOperator (char C) -{ - return ((C == '+') || - (C == '-') || - (C == '*') || - (C == '/') || - (C == '=') || - (C == '%') || - (C == '<') || - (C == '>')); -} -static char ToUpper (char A) -{ - char Result = A; - if (IsLower(A)) - { - Result += 'A' - 'a'; - } - return Result; -} -static char ToLower (char A) -{ - char Result = A; - if (IsUpper(A)) - { - Result -= 'A' - 'a'; - } - return Result; -} -static bool CharsEqualCaseInsensitive (char A, char B) -{ - b32 Result = (ToLower(A) == ToLower(B)); - return Result; -} - //////////////////////////////////////////////////////////////// // Tokenizing //////////////////////////////////////////////////////////////// @@ -669,1765 +312,7 @@ EatNumber(tokenizer* T) return T->At - TStart; } -//////////////////////////////////////////////////////////////// -// Basic Char Operations -//////////////////////////////////////////////////////////////// - -static u32 CharToUInt (char C) { - u32 Result = (C - '0'); - return Result; -} - -static s32 -CharArrayLength (char* Array) -{ - char* C = Array; - s32 Result = 0; - while (*C) - { - *C++; - Result++; - } - return Result; -} - -static s32 -NullTerminatedCharArrayLength (char* CharArray) -{ - char* Iter = CharArray; - while (*Iter) - { - *Iter++; - } - return (Iter - CharArray); -} - -static bool -CharArraysEqual (char* A, s32 ALength, char* B, s32 BLength) -{ - bool Result = false; - if (ALength == BLength) - { - Result = true; - char* AIter = A; - char* BIter = B; - for (s32 i = 0; i < ALength; i++) - { - if(*AIter++ != *BIter++) - { - Result = false; - break; - } - } - } - return Result; -} - -static bool -CharArraysEqualUnsafe (char* A, char* B) -{ - bool Result = true; - - char* AIter = A; - char* BIter = B; - while(*AIter && *BIter) - { - if(*AIter++ != *BIter++) - { - Result = false; - break; - } - } - - if((*AIter && !*BIter) || (!*AIter && *BIter)) - { - Result = false; - } - - return Result; -} - -static bool -CharArraysEqualUpToLength (char* A, char* B, s32 Length) -{ - bool Result = true; - - char* AIter = A; - char* BIter = B; - for (s32 i = 0; i < Length; i++) - { - if(*AIter++ != *BIter++) - { - Result = false; - break; - } - } - - return Result; -} - -static void -ReverseCharArray (char* Array, s32 Length) -{ - char* ForwardIter = Array; - char* BackwardIter = Array + Length - 1; - for (s32 i = 0; i < (Length / 2); i++) - { - char F = *ForwardIter; - char B = *BackwardIter; - *ForwardIter++ = B; - *BackwardIter-- = F; - } -} - -static s32 -IndexOfChar (char* Array, s32 After, char Find) -{ - s32 Result = -1; - - s32 Counter = After; - char* Iter = Array + After; - while (*Iter) - { - if (*Iter == Find) - { - Result = Counter; - break; - } - Counter++; - *Iter++; - } - - return Result; -} - -static s32 -FastReverseIndexOfChar (char* Array, s32 Length, s32 OffsetFromEnd, char Find) -{ - s32 Result = -1; - - s32 Counter = Length - OffsetFromEnd; - char* Iter = Array + Length - OffsetFromEnd; - for (int i = 0; i < (Length - OffsetFromEnd); i++) - { - if (*Iter == Find) - { - Result = Counter; - break; - } - - *Iter--; - Counter--; - } - - return Result; -} - -static s32 -ReverseIndexOfChar (char* Array, s32 OffsetFromEnd, char Find) -{ - s32 StringLength = NullTerminatedCharArrayLength(Array); - return FastReverseIndexOfChar(Array, StringLength, OffsetFromEnd, Find); -} - -static b32 -CharArrayContains(char* Array, char* CheckFor) -{ - b32 Result = false; - - char* Src = Array; - while (*Src) - { - if (*Src == *CheckFor) - { - char* A = CheckFor; - char* B = Src; - while (*B && *A && *A == *B) - { - *B++; *A++; - } - - if (*A == 0) - { - Result = true; - break; - } - } - - Src++; - } - - return Result; -} - -static b32 -CharArrayContainsSafe(char* Array, s32 ArrayLength, char* CheckFor, s32 CheckForLength) -{ - b32 Result = false; - - if (ArrayLength >= CheckForLength) - { - char* Src = Array; - for (s32 s = 0; s < ArrayLength; s++) - { - if (*Src == *CheckFor && (s + CheckForLength <= ArrayLength)) - { - char* A = CheckFor; - char* B = Src; - for (s32 d = 0; d < CheckForLength; d++) - { - if (*B != *A) { break; } - *B++; *A++; - } - - if (*A == 0) - { - Result = true; - break; - } - } - - Src++; - } - } - - return Result; -} - -//////////////////////////////////////////////////////////////// -// Basic String Operations -//////////////////////////////////////////////////////////////// - -static bool -StringsEqual (string A, string B) -{ - bool Result = false; - - if (A.Length == B.Length) - { - Result = true; - char* AIter = A.Memory; - char* BIter = B.Memory; - for (s32 i = 0; i < A.Length; i++) - { - if (*AIter++ != *BIter++) - { - Result = false; - break; - } - } - } - - return Result; -} - -static string -MakeString (char* Array, s32 Length, s32 Max) -{ - string Result = {}; - Result.Memory = Array; - Result.Length = Length; - Result.Max = Max; - return Result; -} - -static string -MakeString (char* Array, s32 Length) -{ - string Result = {}; - Result.Memory = Array; - Result.Length = Length; - Result.Max = Length; - return Result; -} - -static string -MakeString (char* Array) -{ - s32 Length = CharArrayLength (Array); - return MakeString(Array, Length); -} - -static string -MakeStringLiteral (char* String) -{ - string Result = {}; - Result.Memory = String; - Result.Max = CharArrayLength(String); - Result.Length = Result.Max; - return Result; -} - -static bool -StringEqualsCharArray (string String, char* CharArray, s32 CharArrayLength) -{ - bool Result = false; - - if (CharArrayLength == String.Length) - { - Result = true; - - char* S = String.Memory; - char* C = CharArray; - for (s32 i = 0; i < String.Length; i++) - { - if (*C++ != *S++) - { - Result = false; - break; - } - } - } - - return Result; -} - -static bool -StringEqualsCharArray (string String, char* CharArray) -{ - s32 CLength = CharArrayLength(CharArray); - return StringEqualsCharArray(String, CharArray, CLength); -} - -static s32 -FindFirstChar (string String, char C) -{ - s32 Result = -1; - - char* Iter = String.Memory; - for (int i = 0; i < String.Length; i++) - { - if (*Iter++ == C) - { - Result = i; - break; - } - } - - return Result; -} - -static void -SetStringToChar (string* Dest, char C, s32 Count) -{ - Assert(Count <= Dest->Max); - - char* Iter = Dest->Memory; - for (int i = 0; i < Count; i++) - { - *Iter++ = C; - } - Dest->Length = Count; -} - -static void -SetStringToCharArray (string* Dest, char* Source) -{ - Dest->Length = 0; - - char* Src = Source; - char* Dst = Dest->Memory; - while (*Src && Dest->Length < Dest->Max) - { - *Dst++ = *Src++; - Dest->Length++; - } -} - -static void -ConcatString (string Source, string* Dest) -{ - Assert((Dest->Length + Source.Length) <= Dest->Max); - - char* Dst = Dest->Memory + Dest->Length; - char* Src = Source.Memory; - for (s32 i = 0; i < Source.Length; i++) - { - *Dst++ = *Src++; - Dest->Length++; - } -} - -static void -ConcatString (string Source, s32 Length, string* Dest) -{ - Assert(Length <= Source.Length); - Assert((Dest->Length + Length) <= Dest->Max); - - char* Dst = Dest->Memory + Dest->Length; - char* Src = Source.Memory; - for (s32 i = 0; i < Length; i++) - { - *Dst++ = *Src++; - Dest->Length++; - } -} - -static void -ConcatCharToString (string* Dest, char C) -{ - Assert(Dest->Length + 1 <= Dest->Max); - - char* Dst = Dest->Memory + Dest->Length; - *Dst = C; - Dest->Length++; -} - -static void -ConcatCharArrayToString (char* Source, string* Dest) -{ - Assert(CharArrayLength(Source) + Dest->Length <= Dest->Max); - - char* Dst = Dest->Memory + Dest->Length; - char* Src = Source; - while (Dest->Length < Dest->Max && - *Src) - { - *Dst++ = *Src++; - Dest->Length++; - } -} - -static void -ConcatCharArrayToString (char* Source, s32 SourceLength, string* Dest) -{ - Assert(SourceLength + Dest->Length <= Dest->Max); - - char* Dst = Dest->Memory + Dest->Length; - char* Src = Source; - for (int i = 0; i < SourceLength && Dest->Length < Dest->Max; i++) - { - *Dst++ = *Src++; - Dest->Length++; - } -} - -static void -CopyStringTo (string Source, string* Dest) -{ - char* Src = Source.Memory; - char* Dst = Dest->Memory; - s32 CopyLength = GSMin(Source.Length, Dest->Max); - for (int i = 0; i < CopyLength; i++) - { - *Dst++ = *Src++; - } - Dest->Length = Source.Length; -} - -static s32 -CopyStringToCharArray (string Source, char* Dest, s32 DestLength) -{ - char* Src = Source.Memory; - char* Dst = Dest; - s32 CopyLength = GSMin(Source.Length, DestLength); - for (int i = 0; i < CopyLength; i++) - { - *Dst++ = *Src++; - } - return CopyLength; -} - -static void -CopyCharArrayToString (char* Source, string* Dest) -{ - char* Src = Source; - char* Dst = Dest->Memory; - s32 Copied = 0; - while (*Src && Copied < Dest->Max) - { - *Dst++ = *Src++; - Copied++; - } - *Dst++ = 0; - Dest->Length = Copied; -} - -static void -CopyCharArrayToString (char* Source, s32 SourceLength, string* Dest) -{ - Assert(SourceLength <= Dest->Max); - - char* Src = Source; - char* Dst = Dest->Memory; - for (s32 i = 0; i < SourceLength; i++) - { - *Dst++ = *Src++; - } - *Dst++ = 0; - Dest->Length = SourceLength; -} - -static s32 -CopyCharArray (char* Source, char* Dest, s32 DestLength) -{ - char* Src = Source; - char* Dst = Dest; - s32 i = 0; - while (*Src && i < DestLength) - { - *Dst++ = *Src++; - i++; - } - return i; -} - -static s32 -CopyCharArrayAt (char* Source, char* Dest, s32 DestLength, s32 Offset) -{ - Assert(Offset < DestLength); - - char* Src = Source; - char* Dst = Dest + Offset; - s32 i = Offset; - while (*Src && i < DestLength) - { - *Dst++ = *Src++; - i++; - } - return i - Offset; -} - -static void -InsertChar (string* String, char Char, s32 Index) -{ - Assert(Index >= 0 && Index < String->Max); - Assert(String->Length < String->Max); - - char* Src = String->Memory + String->Length - 1; - char* Dst = Src + 1; - for (int i = String->Length - 1; i >= Index; i--) - { - *Dst-- = *Src--; - } - - *(String->Memory + Index) = Char; - String->Length++; -} - -static void -RemoveCharAt (string* String, s32 Index) -{ - Assert(Index >= 0 && Index < String->Max); - - char* Dst = String->Memory + Index; - char* Src = Dst + 1; - for (int i = Index; i < String->Length; i++) - { - *Dst++ = *Src++; - } - *Dst = 0; - String->Length--; -} - -static s32 -IndexOfChar(string String, char C) -{ - s32 Result = -1; - char* At = String.Memory; - for (s32 i = 0; i < String.Length; i++) - { - if (*At == C) - { - Result = i; - break; - } - At++; - } - return Result; -} - -static s32 -LastIndexOfChar(string String, char C) -{ - s32 Result = -1; - char* At = String.Memory + String.Length - 1; - for (s32 i = 0; i < String.Length; i++) - { - if (*At == C) - { - Result = String.Length - i; - break; - } - At--; - } - return Result; -} - -static s32 -SearchForCharInSet(string String, char* Set) -{ - s32 Index = -1; - - char* At = String.Memory; - for (s32 i = 0; i < String.Length; i++) - { - char* Needle = Set; - while (*Needle) - { - if (*At == *Needle) - { - Index = String.Length - i; - break; - } - - Needle++; - } - - if (Index >= 0) - { - break; - } - - At++; - } - - return Index; -} - -static s32 -ReverseSearchForCharInSet(string String, char* Set) -{ - s32 Index = -1; - - for (s32 i = String.Length - 1; i >= 0; i--) - { - char* Needle = Set; - while (*Needle) - { - if (String.Memory[i] == *Needle) - { - Index = i; - break; - } - - Needle++; - } - - if (Index >= 0) - { - break; - } - } - - return Index; -} - -static string -Substring (string String, s32 Start, s32 End) -{ - Assert(Start >= 0 && End > Start && End <= String.Length); - - string Result = {}; - Result.Memory = String.Memory + Start; - Result.Length = End - Start; - return Result; -} - -static string -Substring (string String, s32 Start) -{ - Assert(Start >= 0 && Start < String.Length); - - string Result = {}; - Result.Memory = String.Memory + Start; - Result.Length = String.Length - Start; - return Result; -} - -static b32 -StringContainsCharArray(string SearchIn, char* SearchFor, s32 SearchForLength) -{ - b32 Result = false; - - char* SearchInAt = SearchIn.Memory; - for (s32 i = 0; i < (SearchIn.Length - SearchForLength) + 1; i++) - { - char* InAt = SearchInAt; - char* ForAt = SearchFor; - s32 LengthMatch = 0; - while (*InAt == *ForAt) - { - InAt++; - ForAt++; - LengthMatch++; - } - if (LengthMatch == SearchForLength) - { - Result = true; - break; - } - SearchInAt++; - } - - return Result; -} - -static b32 -StringContainsString(string SearchIn, string SearchFor) -{ - return StringContainsCharArray(SearchIn, SearchFor.Memory, SearchFor.Length); -} - -static b32 -StringContainsCharArrayCaseInsensitive(string SearchIn, char* SearchFor, s32 SearchForLength) -{ - b32 Result = false; - - char* SearchInAt = SearchIn.Memory; - for (s32 i = 0; i < (SearchIn.Length - SearchForLength) + 1; i++) - { - char* InAt = SearchInAt; - char* ForAt = SearchFor; - s32 LengthMatch = 0; - while (CharsEqualCaseInsensitive(*InAt, *ForAt)) - { - InAt++; - ForAt++; - LengthMatch++; - } - if (LengthMatch == SearchForLength) - { - Result = true; - break; - } - SearchInAt++; - } - - return Result; -} - -static b32 -StringContainsStringCaseInsensitive(string SearchIn, string SearchFor) -{ - return StringContainsCharArrayCaseInsensitive(SearchIn, SearchFor.Memory, SearchFor.Length); -} - -static void -NullTerminate (string* String) -{ - Assert(String->Length + 1 <= String->Max); - *(String->Memory + String->Length) = 0; - String->Length++; -} - -// http://www.cse.yorku.ca/~oz/hash.html -// djb2 hash -static u32 -HashString(string String) -{ - u32 Hash = 5381; - for (s32 i = 0; i < String.Length; i++) - { - Hash = ((Hash << 5) + Hash) + (u32)String.Memory[i]; /* hash * 33 + c */ - } - return Hash; -} - -static void -InsertStringAt (string* Dest, string Source, s32 At) -{ - Assert(At + Source.Length < Dest->Max); - Assert(At < Dest->Length); - - char* Src = Dest->Memory + Dest->Length; - char* Dst = Dest->Memory + Source.Length + Dest->Length; - for (s32 i = Dest->Length - 1; i >= At; i--) - { - *--Dst = *--Src; - } - - Src = Source.Memory; - Dst = Dest->Memory + At; - for (s32 j = 0; j < Source.Length; j++) - { - *Dst++ = *Src++; - } - - Dest->Length += Source.Length; -} - -//////////////////////////////////////////////////////////////// -// String Parsing -//////////////////////////////////////////////////////////////// - -// NOTE(Peter): parameters are all in order Length, String because -// that matches the order of C's printf %.*s format specifier. This -// is convenient because you can use StringExpand to parse a string -// struct -// :StringExpandNote -static parse_result -ParseUnsignedInt (s32 Length, char* String) -{ - Assert(IsNumeric(*String)); - parse_result Result = {}; - Result.Type = ParseType_UnsignedInt; - - char* Iter = String; - u32 ResultValue = 0; - for (s32 i = 0; i < Length; i++) - { - ResultValue = CharToUInt(*Iter++) + (ResultValue * 10); - } - - Result.UnsignedIntValue = ResultValue; - Result.OnePastLast = Iter; - - return Result; -} - -static parse_result -ParseUnsignedIntUnsafe (char* String) -{ - char* Start = String; - char* End = EatNumber(String + 1); - return ParseUnsignedInt(End - Start, String); -} - -// :StringExpandNote -static parse_result -ParseSignedInt (s32 Length, char* String) -{ - Assert(Length > 0); - parse_result Result = {}; - Result.Type = ParseType_SignedInt; - - s32 Negative = 1; - s32 LengthRemaining = Length; - s32 ResultValue = 0; - char* Iter = String; - - if (*Iter == '-') { - LengthRemaining--; - *Iter++; - Negative = -1; - } - - for (s32 i = 0; i < LengthRemaining; i++) - { - ResultValue = CharToUInt(*Iter++) + (ResultValue * 10); - } - - ResultValue *= Negative; - - Result.SignedIntValue = ResultValue; - Result.OnePastLast = Iter; - - return Result; -} - -static parse_result -ParseSignedIntUnsafe (char* String) -{ - char* Start = String; - char* End = EatNumber(String + 1); - return ParseSignedInt(End - Start, String); -} - -// :StringExpandNote -static parse_result -ParseFloat (s32 Length, char* String) -{ - parse_result Result = {}; - Result.Type = ParseType_Float; - - s32 Negative = 1; - s32 LengthRemaining = Length; - float ResultValue = 0; - char* Iter = String; - - if (*Iter == '-') { - LengthRemaining--; - *Iter++; - Negative = -1; - } - - for (s32 i = 0; i < LengthRemaining; i++) - { - if (IsNumeric(*Iter)) - { - ResultValue = (float)CharToUInt(*Iter++) + (ResultValue * 10); - } - else if (*Iter == '.' || *Iter == 0) - { - LengthRemaining -= i; - break; - } - } - - if (*Iter == '.') - { - *Iter++; - float AfterPoint = 0; - s32 PlacesAfterPoint = 0; - - for (s32 i = 0; i < LengthRemaining; i++) - { - if (IsNumeric(*Iter)) - { - AfterPoint = (float)CharToUInt(*Iter++) + (AfterPoint * 10); - PlacesAfterPoint++; - } - else - { - break; - } - } - - AfterPoint = AfterPoint / GSPow(10, PlacesAfterPoint); - ResultValue += AfterPoint; - } - - ResultValue *= Negative; - - Result.FloatValue = ResultValue; - Result.OnePastLast = Iter; - - return Result; -} - -static parse_result -ParseFloatUnsafe (char* String) -{ - char* Start = String; - char* End = EatNumber(String + 1); - return ParseFloat(End - Start, String); -} - -static s32 -UIntToString (u32 Int, char* String, s32 MaxLength, b32 FormatFlags = 0, s32 MinimumLength = 0) -{ - s32 Remaining = Int; - char* Iter = String; - while (Remaining > 0 && (Iter - String) < MaxLength) - { - *Iter++ = '0' + (Remaining % 10); - Remaining /= 10; - } - s32 CharsCopied = Iter - String; - ReverseCharArray(String, CharsCopied); - return CharsCopied; -} - -static s32 -IntToString (s32 Int, char* String, s32 MaxLength, b32 FormatFlags = 0, s32 MinimumLength = 0) -{ - s32 Remaining = Int; - s32 CharsCopied = 0; - - char* Iter = String; - - bool Negative = Remaining < 0; - Remaining = GSAbs(Remaining); - - if (Remaining > 0) - { - while (Remaining > 0 && CharsCopied < MaxLength) - { - *Iter++ = '0' + (Remaining % 10); - Remaining /= 10; - CharsCopied++; - } - } - else if (Remaining == 0) - { - *Iter++ = '0'; - } - - if (Negative) - { - *Iter++ = '-'; - CharsCopied++; - } - - ReverseCharArray(String, CharsCopied); - return CharsCopied; -} - -static s32 -IntToString (s32 Int, char* String, s32 MaxLength, s32 Offset, b32 FormatFlags = 0, s32 MinimumWidth = 0) -{ - char* StringStart = String + Offset; - s32 LengthWritten = IntToString(Int, StringStart, MaxLength - Offset); - return LengthWritten; -} - -static s32 -FloatToString(float Float, char *String, s32 MaxLength, s32 AfterPoint = 0, b32 FormatFlags = 0, s32 MinimumWidth = 0) -{ - s32 IPart = (s32)Float; - float FPart = GSAbs(Float - (float)IPart); - - s32 i = IntToString(IPart, String, MaxLength); - - if (AfterPoint > 1) - { - String[i++] = '.'; - - s32 FPartInt = FPart * GSPow(10, AfterPoint); - i += IntToString(FPartInt, String, MaxLength, i, 0, 0); - } - - return i; -} - -//////////////////////////////////////////////////////////////// -// PrintF -//////////////////////////////////////////////////////////////// - -static void -OutChar (string* String, char C) -{ - if (String->Length < String->Max) - { - String->Memory[String->Length] = C; - String->Length++; - } -} - -char OctalDigits[] = "01234567"; -char DecimalDigits[] = "0123456789"; -char HexDigits[] = "0123456789ABCDEF"; - -static void -U64ToASCII (string* String, u64 Value, s32 Base, char* Digits) -{ - u64 ValueRemaining = Value; - char* Start = String->Memory + String->Length; - do { - s32 DigitsIndex = ValueRemaining % Base; - char Digit = Digits[DigitsIndex]; - OutChar(String, Digit); - ValueRemaining /= Base; - }while (ValueRemaining); - char* End = String->Memory + String->Length; - - while (Start < End) - { - End--; - char Temp = *End; - *End = *Start; - *Start = Temp; - *Start++; - } -} - -static void -F64ToASCII (string* String, r64 Value, s32 Precision) -{ - if (Value < 0) - { - OutChar(String, '-'); - Value = -Value; - } - - u64 IntegerPart = (u64)Value; - Value -= IntegerPart; - - U64ToASCII(String, IntegerPart, 10, DecimalDigits); - - OutChar(String, '.'); - - for (s32 i = 0; i < Precision; i++) - { - Value *= 10.f; - u32 DecimalPlace = Value; - Value -= DecimalPlace; - OutChar(String, DecimalDigits[DecimalPlace]); - } -} - -internal s64 -ReadVarArgsSignedInteger (s32 Width, va_list* Args) -{ - s64 Result = 0; - switch (Width) - { - case 1: { Result = (s64)va_arg(*Args, s8); } break; - case 2: { Result = (s64)va_arg(*Args, s16); } break; - case 4: { Result = (s64)va_arg(*Args, s32); } break; - case 8: { Result = (s64)va_arg(*Args, s64); } break; - InvalidDefaultCase; - } - return Result; -} - -internal r64 -ReadVarArgsUnsignedInteger (s32 Width, va_list* Args) -{ - u64 Result = 0; - switch (Width) - { - case 1: { Result = (u64)va_arg(*Args, u8); } break; - case 2: { Result = (u64)va_arg(*Args, u16); } break; - case 4: { Result = (u64)va_arg(*Args, u32); } break; - case 8: { Result = (u64)va_arg(*Args, u64); } break; - InvalidDefaultCase; - } - return Result; -} - -internal r64 -ReadVarArgsFloat (s32 Width, va_list* Args) -{ - r64 Result = 0; - switch (Width) - { - case 4: { Result = (r64)va_arg(*Args, r64); } break; - case 8: { Result = (r64)va_arg(*Args, r64); } break; - InvalidDefaultCase; - } - return Result; -} - -internal s32 -PrintFArgsList (char* Dest, s32 DestMax, char* Format, va_list Args) -{ - char* DestAt = Dest; - - char* FormatAt = Format; - while (*FormatAt) - { - if (FormatAt[0] != '%') - { - *DestAt++ = *FormatAt++; - } - else if (FormatAt[0] == '%' && FormatAt[1] == '%') // Print the % symbol - { - *DestAt++ = '%'; - FormatAt += 2; - } - else - { - FormatAt++; - - // Flags - if (FormatAt[0] == '-') - { - FormatAt++; - } - else if (FormatAt[0] == '+') - { - FormatAt++; - } - else if (FormatAt[0] == ' ') - { - FormatAt++; - } - else if (FormatAt[0] == '#') - { - FormatAt++; - } - else if (FormatAt[0] == '0') - { - FormatAt++; - } - - // Width - b32 WidthSpecified = false; - s32 Width = 0; - - if (IsNumeric(FormatAt[0])) - { - WidthSpecified = true; - parse_result Parse = ParseSignedIntUnsafe(FormatAt); - FormatAt = Parse.OnePastLast; - Width = Parse.SignedIntValue; - } - else if (FormatAt[0] == '*') - { - WidthSpecified = true; - Width = va_arg(Args, s32); - Assert(Width >= 0); - FormatAt++; - } - - // Precision - b32 PrecisionSpecified = false; - s32 Precision = 0; - - if (FormatAt[0] == '.') - { - FormatAt++; - if (IsNumeric(FormatAt[0])) - { - PrecisionSpecified = true; - parse_result Parse = ParseSignedIntUnsafe(FormatAt); - FormatAt = Parse.OnePastLast; - Precision = Parse.SignedIntValue; - } - else if (FormatAt[0] == '*') - { - PrecisionSpecified = true; - Precision = va_arg(Args, s32); - Assert(Precision >= 0); - FormatAt++; - } - } - - // Length - b32 LengthSpecified = false; - s32 Length = 4; - - if (FormatAt[0] == 'h' && FormatAt[1] == 'h') - { - LengthSpecified = true; - LengthSpecified = 1; - FormatAt += 2; - } - else if (FormatAt[0] == 'h') - { - LengthSpecified = true; - LengthSpecified = 2; - FormatAt++; - } - else if (FormatAt[0] == 'l' && FormatAt[1] == 'l') - { - LengthSpecified = true; - LengthSpecified = 8; - FormatAt += 2; - } - else if (FormatAt[0] == 'l') - { - LengthSpecified = true; - LengthSpecified = 4; - FormatAt++; - } - else if (FormatAt[0] == 'j') - { - LengthSpecified = true; - LengthSpecified = 8; - FormatAt++; - } - else if (FormatAt[0] == 'z') - { - FormatAt++; - } - else if (FormatAt[0] == 't') - { - FormatAt++; - } - else if (FormatAt[0] == 'L') - { - FormatAt++; - } - - // Format Specifier - s32 DestLengthRemaining = DestMax - (DestAt - Dest); - - char Temp[64]; - string TempDest = MakeString(Temp, 0, 64); - - if (FormatAt[0] == 'd' || FormatAt[0] == 'i') - { - s64 SignedInt = ReadVarArgsSignedInteger(Length, &Args); - if (SignedInt < 0) - { - OutChar(&TempDest, '-'); - SignedInt *= -1; - } - U64ToASCII(&TempDest, (u64)SignedInt, 10, DecimalDigits); - } - else if (FormatAt[0] == 'u') - { - u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); - U64ToASCII(&TempDest, UnsignedInt, 10, DecimalDigits); - } - else if (FormatAt[0] == 'o') - { - u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); - U64ToASCII(&TempDest, UnsignedInt, 8, OctalDigits); - } - else if (FormatAt[0] == 'x' || FormatAt[0] == 'X') - { - u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); - U64ToASCII(&TempDest, UnsignedInt, 16, HexDigits); - } - else if (FormatAt[0] == 'f' || FormatAt[0] == 'F') - { - r64 Float = ReadVarArgsFloat(Length, &Args); - s32 AfterPoint = 6; - if (PrecisionSpecified) - { - AfterPoint = Precision; - } - F64ToASCII(&TempDest, Float, AfterPoint); - } - else if (FormatAt[0] == 'c') - { - char InsertChar = va_arg(Args, char); - OutChar(&TempDest, InsertChar); - } - else if (FormatAt[0] == 's') - { - char* InsertString = va_arg(Args, char*); - - s32 InsertStringLength = CharArrayLength(InsertString); - if (PrecisionSpecified) - { - InsertStringLength = GSMin(InsertStringLength, Precision); - } - InsertStringLength = GSMin(DestLengthRemaining, InsertStringLength); - - for (s32 c = 0; c < InsertStringLength; c++) - { - OutChar(&TempDest, *InsertString++); - } - } - else if (FormatAt[0] == 'S') - { - string InsertString = va_arg(Args, string); - - for (s32 c = 0; c < InsertString.Length; c++) - { - OutChar(&TempDest, InsertString.Memory[c]); - } - } - else if (FormatAt[0] == 'p') - { - // TODO(Peter): Pointer Address - } - else - { - // NOTE(Peter): Non-specifier character found - InvalidCodePath; - } - - for (s32 i = 0; i < TempDest.Length; i++) - { - *DestAt++ = TempDest.Memory[i]; - } - - *FormatAt++; - } - } - - s32 FormattedLength = DestAt - Dest; - return FormattedLength; -} - -static void -PrintF (string* String, char* Format, ...) -{ - va_list Args; - va_start(Args, Format); - String->Length = 0; - String->Length += PrintFArgsList(String->Memory + String->Length, String->Max - String->Length, Format, Args); - va_end(Args); -} - -static void -AppendPrintF (string* String, char* Format, ...) -{ - va_list Args; - va_start(Args, Format); - String->Length += PrintFArgsList(String->Memory + String->Length, String->Max - String->Length, Format, Args); - va_end(Args); -} - -// Printing Helper Functions -static u32 -GetU32NumberOfCharactersNeeded(u32 Value, u32 Base) -{ - u32 Result = 0; - u32 ValueLeft = Value; - // NOTE(Peter): This is in a do while loop because even if the number is 0, - // it'll still take one character to display that. - do - { - Result += 1; - ValueLeft /= Base; - }while (ValueLeft > 0); - return Result; -} - -static u32 -GetS32NumberOfCharactersNeeded(s32 Value, s32 Base) -{ - u32 Result = 0; - s32 ValueLeft = Value; - if (Value < 0) - { - Result += 1; - ValueLeft = Value * -1; - } - // NOTE(Peter): This is in a do while loop because even if the number is 0, - // it'll still take one character to display that. - do - { - Result += 1; - ValueLeft /= Base; - }while (ValueLeft > 0); - return Result; -} - -//////////////////////////////////////////////////////////////// -// String Memory Function Definitions -//////////////////////////////////////////////////////////////// - -static s32 -CalculateSlotCountFromSize (s32 RequestedSize, s32 SlotSize) -{ - s32 SlotCount = RequestedSize / SlotSize; - if (SlotCount * SlotSize < RequestedSize) - { - SlotCount += 1; - } - return SlotCount; -} - -static bool -SlotsAreContiguous (slot_header* First, slot_header* Second) -{ - bool Result = false; - u8* FirstSlotNextAddress = (u8*)First + First->Size; - u8* SecondAddress = (u8*)Second; - Result = FirstSlotNextAddress == SecondAddress; - return Result; -} - -static contiguous_slot_count_result -CountContiguousSlots (slot_header* First) -{ - Assert(First != 0); - - contiguous_slot_count_result Result = {}; - Result.Count = 1; - - slot_header* IterPrev = First; - slot_header* Iter = First->Next; - while (Iter && SlotsAreContiguous(IterPrev, Iter)) - { - Result.Count++; - IterPrev = Iter; - Iter = Iter->Next; - } - - Result.LastContiguousSlot = IterPrev; - return Result; -} - -static slot_header* -GetSlotAtOffset(slot_header* First, s32 Offset) -{ - slot_header* Iter = First; - s32 Count = 0; - while (Count < Offset && Iter) - { - Iter = Iter->Next; - Count++; - } - return Iter; -} - -static slot_header* -InsertSlotIntoList (slot_header* NewSlot, slot_header* ListStart) -{ - slot_header* List = ListStart; - if (NewSlot < List) - { - NewSlot->Next = List; - List = NewSlot; - } - else - { - slot_header* PrevIter = List; - slot_header* Iter = List->Next; - while (Iter && NewSlot > Iter) - { - PrevIter = Iter; - Iter = Iter->Next; - } - - Assert(PrevIter); - if (PrevIter) - { - PrevIter->Next = NewSlot; - } - - if (Iter) - { - NewSlot->Next = Iter; - } - } - return List; -} - -static void -AllocStringFromStringArena (string* String, s32 Size, slot_arena* Storage) -{ - s32 SlotCount = CalculateSlotCountFromSize(Size, Storage->SlotSize); - slot_header* Slot = Storage->FreeList; - slot_header* PrevSlot = 0; - while (Slot) - { - contiguous_slot_count_result ContiguousSlots = CountContiguousSlots(Slot); - if (ContiguousSlots.Count >= SlotCount) - { - slot_header* NextStartSlot = GetSlotAtOffset(Slot, SlotCount); - if (PrevSlot) - { - PrevSlot->Next = NextStartSlot; - } - else - { - Storage->FreeList = NextStartSlot; - } - break; - } - else - { - PrevSlot = Slot; - Slot = Slot->Next; - } - } - - if (Slot) - { - String->Memory = (char*)Slot; - GSZeroMemory((u8*)String->Memory, SlotCount * Storage->SlotSize); - String->Max = SlotCount * Storage->SlotSize; - String->Length = 0; - } -} - -static string -AllocStringFromStringArena (s32 Size, slot_arena* Storage) -{ - string Result = {0}; - AllocStringFromStringArena(&Result, Size, Storage); - return Result; -} - -static void -FreeToStringArena (string* String, slot_arena* Storage) -{ - u8* Base = (u8*)(String->Memory); - u8* End = Base + String->Max - 1; - u8* MemoryEnd = Storage->Memory + (Storage->SlotSize * Storage->SlotCount); - Assert((Base >= Storage->Memory) && (End < MemoryEnd)); - Assert((String->Max % Storage->SlotSize) == 0); - - s32 SizeReclaimed = 0; - slot_header* Slot = (slot_header*)Base; - while (SizeReclaimed < String->Max) - { - Slot->Size = Storage->SlotSize; - Storage->FreeList = InsertSlotIntoList(Slot, Storage->FreeList); - SizeReclaimed += Storage->SlotSize; - Slot = (slot_header*)(Base + SizeReclaimed); - } - - String->Memory = 0; - String->Length = 0; - String->Max = 0; -} - -static void -ReallocFromStringArena (string* String, s32 NewSize, slot_arena* Storage) -{ - string NewString = AllocStringFromStringArena(NewSize, Storage); - CopyStringTo(*String, &NewString); - FreeToStringArena(String, Storage); - *String = NewString; -} - -#if defined(DEBUG) - -void DEBUGPrintChars (string* String, s32 Count) -{ - char* Iter = String->Memory; - for (int i = 0; i < Count; i++) - { - *Iter++ = (char)('A' + i); - } - String->Length = Count; -} - -#ifdef DEBUG_GS_STRING - -#include - -static void -TestStrings() -{ - - slot_arena StringArena = {}; - - s32 TestCount = 0; - s32 SuccessCount = 0; - - DebugPrint("\n\n-------------------------------------------------\n Begin Testing Strings\n\n\n"); - - //////////////////////////////////////////////////////////////// - // Char Functions - - char ForwardArray[] = "Hello, Sailor"; - char BackwardArray[] = "roliaS ,olleH"; - TestClean(CharArraysEqual(ForwardArray, 13, ForwardArray, 13), "String Equality"); - TestClean(!CharArraysEqual(ForwardArray, 13, BackwardArray, 13), "String Equality"); - - TestClean(IndexOfChar(ForwardArray, 0, ',') == 5, "Index Of Char"); - TestClean(IndexOfChar(ForwardArray, 5, 'l') == 10, "Index of Char (skipping first 5)"); - TestClean(FastReverseIndexOfChar(ForwardArray, 13, 0, 'o') == 11, "Fast Reverse Index Of Char"); - TestClean(ReverseIndexOfChar(ForwardArray, 0, 'o') == 11, "Reverse Index of Char"); - TestClean(ReverseIndexOfChar(ForwardArray, 3, 'o') == 4, "Reverse Index of Char (skipping last 3)"); - TestClean(LastIndexOfChar(ForwardArray, 'o') == 11, "Last Index of Char"); - - ReverseCharArray(ForwardArray, 13); - TestClean(CharArraysEqual(ForwardArray, 13, BackwardArray, 13), "Reversing Char Array"); - - char UIntString[] = "1234"; - u32 UIntValue = 1234; - u32 ParsedUInt = ParseUnsignedInt(UIntString, 4); - TestClean((ParsedUInt == UIntValue), "String To U32"); - char StringifiedUInt[4] = {}; - UIntToString(UIntValue, StringifiedUInt, 4); - TestClean(CharArraysEqual(UIntString, 4, StringifiedUInt, 4), "U32 To String"); - - char IntString[] = "-1234"; - s32 IntValue = -1234; - s32 ParsedInt = ParseSignedInt(IntString, 5); - TestClean((ParsedInt == IntValue), "String To S32"); - char StringifiedInt[5] = {}; - IntToString(IntValue, StringifiedInt, 5); - TestClean(CharArraysEqual(IntString, 5, StringifiedInt, 5), "S32 to String"); - - char FloatString[] = "-1234.125"; - float FloatValue = -1234.125f; - float ParsedFloat = ParseFloat(FloatString, 8); - TestClean((ParsedFloat == FloatValue), "String To Float"); - char StringifiedFloat[10] = {}; - FloatToString(FloatValue, StringifiedFloat, 10, 3); - TestClean(CharArraysEqual(FloatString, 8, StringifiedFloat, 8), "Float To String"); - - - //////////////////////////////////////////////////////////////// - // - - StringArena.SlotSize = 256; - StringArena.SlotCount = 32; - StringArena.Memory = malloc(StringArena.SlotSize * StringArena.SlotCount); - slot_header* PrevSlotHeader = 0; - for (int i = StringArena.SlotCount - 1; i >= 0; i--) - { - u8* SlotBase = StringArena.Memory + (i * StringArena.SlotSize); - slot_header* SlotHeader = (slot_header*)SlotBase; - SlotHeader->Size = StringArena.SlotSize; - SlotHeader->Next = PrevSlotHeader; - - // TEST(peter): Should be true always, except on the first iteration, when there is no next slot - bool Contiguity = SlotsAreContiguous(SlotHeader, PrevSlotHeader); - TestClean((Contiguity || SlotHeader->Next == 0), "Contiguous Arenas"); - - PrevSlotHeader = SlotHeader; - } - StringArena.FreeList = PrevSlotHeader; - - // TEST(peter): Count Should equal StringArena.SlotCount - s32 ContiguousSlotsCountBefore = CountContiguousSlots(StringArena.FreeList).Count; - TestClean((ContiguousSlotsCountBefore == StringArena.SlotCount), "Contiguous Arenas"); - - // TEST(peter): Should be false - bool Contiguity = SlotsAreContiguous(StringArena.FreeList, StringArena.FreeList->Next->Next); - Contiguity = SlotsAreContiguous(StringArena.FreeList->Next->Next, StringArena.FreeList); - TestClean(!Contiguity, "Non Contiguous Arenas"); - - s32 Slots = CalculateSlotCountFromSize(10, 256); - TestClean(Slots == 1, "Slot Sizing"); - Slots = CalculateSlotCountFromSize(256, 256); - TestClean(Slots == 1, "Slot Sizing"); - Slots = CalculateSlotCountFromSize(345, 256); - TestClean(Slots == 2, "Slot Sizing"); - Slots = CalculateSlotCountFromSize(1024, 256); - TestClean(Slots == 4, "Slot Sizing"); - - slot_header* HeaderTen = GetSlotAtOffset(StringArena.FreeList, 10); - slot_header* HeaderThree = GetSlotAtOffset(StringArena.FreeList, 3); - slot_header* HeaderFive = GetSlotAtOffset(StringArena.FreeList, 5); - - string StringA = AllocStringFromStringArena(10, &StringArena); - string StringB = AllocStringFromStringArena(345, &StringArena); - -#if 0 - // TEST(peter): Should TestClean - u8* RandomMemory = (u8*)malloc(256); - string RandomMemString = {}; - RandomMemString.Memory = (char*)RandomMemory; - RandomMemString.Max = 256; - FreeToStringArena(&RandomMemString, &StringArena); -#endif - FreeToStringArena(&StringA, &StringArena); - FreeToStringArena(&StringB, &StringArena); - // TEST(peter): After freeing both allocations, ContiguousSlotCountBefore and ContiguousSlotCountAfter should be equal - s32 ContiguousSlotCountAfter = CountContiguousSlots(StringArena.FreeList).Count; - TestClean(ContiguousSlotCountAfter == ContiguousSlotsCountBefore, "Add and REmove Slots from Arena"); - - // TEST(peter): Set up a free list where the first element is too small, so it has to traverse to find an appropriately - // sized block - // The slots will look list [256][used][256][256][256] etc.. - StringA = AllocStringFromStringArena(256, &StringArena); - StringB = AllocStringFromStringArena(256, &StringArena); - FreeToStringArena(&StringA, &StringArena); - u32 Contiguous = CountContiguousSlots(StringArena.FreeList).Count; // Should = 1; - string StringC = AllocStringFromStringArena(512, &StringArena); - slot_header* HeaderC = (slot_header*)(StringC.Memory); - - string ReallocTestString = AllocStringFromStringArena(256, &StringArena); - DEBUGPrintChars(&ReallocTestString, 24); - ReallocFromStringArena(&ReallocTestString, 512, &StringArena); - - - string TestString = AllocStringFromStringArena(10, &StringArena); - DEBUGPrintChars(&TestString, TestString.Max); - ReallocFromStringArena(&TestString, 20, &StringArena); - DEBUGPrintChars(&TestString, TestString.Max); - ReallocFromStringArena(&TestString, 10, &StringArena); - FreeToStringArena(&TestString, &StringArena); - - string EqualityStringA = AllocStringFromStringArena(345, &StringArena); - string EqualityStringB = AllocStringFromStringArena(415, &StringArena); - // Equality should succeed despite length differences - string EqualityStringC = AllocStringFromStringArena(256, &StringArena); - string EqualityStringD = AllocStringFromStringArena(256, &StringArena); // Equality should fail - string EqualityStringEmpty = {}; - - DEBUGPrintChars(&EqualityStringA, 24); - DEBUGPrintChars(&EqualityStringB, 24); - DEBUGPrintChars(&EqualityStringC, 24); - DEBUGPrintChars(&EqualityStringD, 12); - - bool ABEquality = StringsEqual(EqualityStringA, EqualityStringB); // Should Succeed - bool ACEquality = StringsEqual(EqualityStringA, EqualityStringC); // Should Succeed - bool ADEquality = StringsEqual(EqualityStringA, EqualityStringD); // Should Fail - bool AEEquality = StringsEqual(EqualityStringA, EqualityStringEmpty); // Should Fail - - TestClean(ABEquality, "String Equality"); - TestClean(ACEquality, "String Equality"); - TestClean(!ADEquality, "String Equality"); - TestClean(!AEEquality, "String Equality"); - - string CatStringA = AllocStringFromStringArena(256, &StringArena); - SetStringToCharArray(&CatStringA, "Hello "); - string CatStringB = AllocStringFromStringArena(512, &StringArena); - SetStringToCharArray(&CatStringB, "Sailor!"); - string CatStringResult = AllocStringFromStringArena(512, &StringArena); - SetStringToCharArray(&CatStringResult, "Hello Sailor!"); - ConcatString(&CatStringA, CatStringB); - TestClean(StringsEqual(CatStringA, CatStringResult), "Cat Strings"); - - s32 FirstSpaceIndex = FindFirstChar(CatStringA, ' '); - TestClean(FirstSpaceIndex == 5, "First Index"); - - SetStringToChar(&CatStringB, 'B', 5); - TestClean(StringEqualsCharArray(CatStringB, "BBBBB"), "SetStringToChar"); - - - DebugPrint("Results: Passed %d / %d\n\n\n", SuccessCount, TestCount); -} -#endif // DEBUG_GS_STRING - -#endif // DEBUG - #define GS_STRING_H -#endif // GS_STRING_H \ No newline at end of file +#endif // GS_STRING_H + + diff --git a/src/gs_libs/gs_string_builder.h b/src/gs_libs/gs_string_builder.h index e6e5df0..1102e97 100644 --- a/src/gs_libs/gs_string_builder.h +++ b/src/gs_libs/gs_string_builder.h @@ -37,7 +37,7 @@ GrowStringBuilder(string_builder* StringBuilder) { StringBuilder->Buffers = NewBuffer; StringBuilder->Head = NewBuffer; - } + } else { StringBuilder->Head->Next = NewBuffer; @@ -60,7 +60,7 @@ Write(string Text, string_builder* StringBuilder) // Copy what there is room for s32 SpaceAvailable = StringBuilder->Head->String.Max - StringBuilder->Head->String.Length; - ConcatString(TextLeft, GSMin(SpaceAvailable, TextLeft.Length), &StringBuilder->Head->String); + ConcatString(TextLeft, Min(SpaceAvailable, TextLeft.Length), &StringBuilder->Head->String); TextLeft.Memory += SpaceAvailable; TextLeft.Length -= SpaceAvailable; @@ -93,7 +93,7 @@ WriteStringBuilderToFile(string_builder StringBuilder, FILE* WriteFile) while (BufferAt) { string String = BufferAt->String; - fwrite(String.Memory, 1, String.Length, WriteFile); + fwrite(String.Str, 1, String.Length, WriteFile); BufferAt = BufferAt->Next; } } diff --git a/src/gs_libs/gs_types.cpp b/src/gs_libs/gs_types.cpp new file mode 100644 index 0000000..d775d1e --- /dev/null +++ b/src/gs_libs/gs_types.cpp @@ -0,0 +1,3383 @@ +// +// File: gs_types.cpp +// Author: Peter Slattery +// Creation Date: 2020-04-18 +// +#ifndef GS_TYPES_CPP + +internal u32 +U32DivideRoundUp (u32 A, u32 B) +{ + r32 Result = (r32)A / (r32)B; + Result += .99999f; + return (u32)Result; +} + +inline bool XOR(bool A, bool B) { return (A == !B); } +inline bool XOR(b8 A, b8 B) { return (A == !B); } +inline bool XOR(b32 A, b32 B) { return (A == !B); } +inline bool XOR(b64 A, b64 B) { return (A == !B); } + +internal u32 +RoundUpToMultiple(u32 Value, u32 MultipleOf) +{ + u32 Result = Value; + if (MultipleOf != 0) + { + u32 Remainder = Value % MultipleOf; + Result = Value + (MultipleOf - Remainder); + } + return Result; +} +internal u32 +RoundUpToPow2U32(u32 Value) +{ + u32 Result = Value - 1; + Result |= Result >> 1; + Result |= Result >> 2; + Result |= Result >> 4; + Result |= Result >> 8; + Result |= Result >> 16; + Result++; + return Result; +} +internal u32 +RoundUpToPow2U64(u64 Value) +{ + u64 Result = Value - 1; + Result |= Result >> 1; + Result |= Result >> 2; + Result |= Result >> 4; + Result |= Result >> 8; + Result |= Result >> 16; + Result |= Result >> 32; + Result++; + return Result; +} +internal u64 +RoundUpTo64(u64 Value, u64 Alignment) +{ + Value += Alignment - 1; + Value -= Value % Alignment; + return Value; +} + +internal u8 +PowU8(u8 X, u32 Power) +{ + u8 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal u16 +PowU16(u16 X, u32 Power) +{ + u16 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal u32 +PowU32(u32 X, u32 Power) +{ + u32 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal u64 +PowU64(u64 X, u32 Power) +{ + u64 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal s8 +PowS8(s8 X, u32 Power) +{ + s8 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal s16 +PowS16(s16 X, u32 Power) +{ + s16 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal s32 +PowS32(s32 X, u32 Power) +{ + s32 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal s64 +PowS64(s64 X, u32 Power) +{ + s64 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal r32 +PowR32(r32 X, u32 Power) +{ + r32 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} +internal r64 +PowR64(r64 X, u32 Power) +{ + r64 Result = X; + for (u32 i = 1; i < Power; i++) { Result *= X; } + return Result; +} + +internal u8 +LerpU8(r32 T, u8 A, u8 B) +{ + return (u8)((A * (1.0f - T)) + (B * T)); +} +internal u16 +LerpU16(r32 T, u16 A, u16 B) +{ + return (u16)((A * (1.0f - T)) + (B * T)); +} +internal u32 +LerpU32(r32 T, u32 A, u32 B) +{ + return (u32)((A * (1.0f - T)) + (B * T)); +} +internal u64 +LerpU64(r32 T, u64 A, u64 B) +{ + return (u64)((A * (1.0f - T)) + (B * T)); +} +internal s8 +LerpS8(r32 T, s8 A, s8 B) +{ + return (s8)((A * (1.0f - T)) + (B * T)); +} +internal s16 +LerpS16(r32 T, s16 A, s16 B) +{ + return (s16)((A * (1.0f - T)) + (B * T)); +} +internal s32 +LerpS32(r32 T, s32 A, s32 B) +{ + return (s32)((A * (1.0f - T)) + (B * T)); +} +internal s64 +LerpS64(r32 T, s64 A, s64 B) +{ + return (s64)((A * (1.0f - T)) + (B * T)); +} +internal r32 +LerpR32(r32 T, r32 A, r32 B) +{ + return (r32)((A * (1.0f - T)) + (B * T)); +} +internal r64 +LerpR64(r32 T, r64 A, r64 B) +{ + return (r64)((A * (1.0f - T)) + (B * T)); +} + +internal u8 +UnlerpU8(u8 Value, u8 Min, u8 Max) +{ + return (u8)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal u16 +UnlerpU16(u16 Value, u16 Min, u16 Max) +{ + return (u16)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal u32 +UnlerpU32(u32 Value, u32 Min, u32 Max) +{ + return (u32)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal u64 +UnlerpU64(u64 Value, u64 Min, u64 Max) +{ + return (u64)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal s8 +UnlerpS8(s8 Value, s8 Min, s8 Max) +{ + return (s8)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal s16 +UnlerpS16(s16 Value, s16 Min, s16 Max) +{ + return (s16)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal s32 +UnlerpS32(s32 Value, s32 Min, s32 Max) +{ + return (s32)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal s64 +UnlerpS64(s64 Value, s64 Min, s64 Max) +{ + return (s64)((r64)(Value - Min) / (r64)(Max - Min)); +} +internal r32 +UnlerpR32(r32 Value, r32 Min, r32 Max) +{ + return (Value - Min) / (Max - Min); +} +internal r64 +UnlerpR64(r64 Value, r64 Min, r64 Max) +{ + return (Value - Min) / (Max - Min); +} + + +internal u8 +RemapU8(u8 Value, u8 OldMin, u8 OldMax, u8 NewMin, u8 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + u8 Result = (u8)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal u16 +RemapU16(u16 Value, u16 OldMin, u16 OldMax, u16 NewMin, u16 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + u16 Result = (u16)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal u32 +RemapU32(u32 Value, u32 OldMin, u32 OldMax, u32 NewMin, u32 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + u32 Result = (u32)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal u64 +RemapU64(u64 Value, u64 OldMin, u64 OldMax, u64 NewMin, u64 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + u64 Result = (u64)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal s8 +RemapS8(s8 Value, s8 OldMin, s8 OldMax, s8 NewMin, s8 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + s8 Result = (s8)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal s16 +RemapS16(s16 Value, s16 OldMin, s16 OldMax, s16 NewMin, s16 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + s16 Result = (s16)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal s32 +RemapS32(s32 Value, s32 OldMin, s32 OldMax, s32 NewMin, s32 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + s32 Result = (s32)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal s64 +RemapS64(s64 Value, s64 OldMin, s64 OldMax, s64 NewMin, s64 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + s64 Result = (s64)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal r32 +RemapR32(r32 Value, r32 OldMin, r32 OldMax, r32 NewMin, r32 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r32 Result = (r32)((A * (NewMax - NewMin)) + NewMin); + return Result; +} +internal r64 +RemapR64(r64 Value, r64 OldMin, r64 OldMax, r64 NewMin, r64 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 Result = (r64)((A * (NewMax - NewMin)) + NewMin); + return Result; +} + +internal u8 +RemapClampedU8(u8 Value, u8 OldMin, u8 OldMax, u8 NewMin, u8 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + u8 Result = (u8)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal u16 +RemapClampedU16(u16 Value, u16 OldMin, u16 OldMax, u16 NewMin, u16 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + u16 Result = (u16)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal u32 +RemapClampedU32(u32 Value, u32 OldMin, u32 OldMax, u32 NewMin, u32 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + u32 Result = (u32)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal u64 +RemapClampedU64(u64 Value, u64 OldMin, u64 OldMax, u64 NewMin, u64 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + u64 Result = (u64)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal s8 +RemapClampedS8(s8 Value, s8 OldMin, s8 OldMax, s8 NewMin, s8 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + s8 Result = (s8)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal s16 +RemapClampedS16(s16 Value, s16 OldMin, s16 OldMax, s16 NewMin, s16 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + s16 Result = (s16)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal s32 +RemapClampedS32(s32 Value, s32 OldMin, s32 OldMax, s32 NewMin, s32 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + s32 Result = (s32)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal s64 +RemapClampedS64(s64 Value, s64 OldMin, s64 OldMax, s64 NewMin, s64 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + s64 Result = (s64)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal r32 +RemapClampedR32(r32 Value, r32 OldMin, r32 OldMax, r32 NewMin, r32 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + r32 Result = (r32)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} +internal r64 +RemapClampedR64(r64 Value, r64 OldMin, r64 OldMax, r64 NewMin, r64 NewMax) +{ + r64 A = (r64)(Value - OldMin) / (r64)(OldMax - OldMin); + r64 AClamped = Clamp01(A); + r64 UnclampedResult = ((AClamped * (NewMax - NewMin)) + NewMin); + r64 Result = (r64)Clamp(NewMin, UnclampedResult, NewMax); + return Result; +} + +internal r32 +FloorR32(r32 V) +{ + return (r32)((s64)V); +} +internal r64 +FloorR64(r64 V) +{ + return (r64)((s64)V); +} + +internal r32 +FractR32(r32 V) +{ + return V - FloorR32(V); +} +internal r64 +FractR64(r64 V) +{ + return V - FloorR64(V); +} + +internal r32 +SqrtR32(r32 V) +{ + return _mm_cvtss_f32(_mm_sqrt_ss(_mm_set_ss(V))); +} +internal u32 +SqrtU32(u32 V) +{ + return sqrt(V); +} + +internal r32 +SinR32(r32 Rad) +{ + return sinf(Rad); +} +internal r64 +SinR64(r64 Rad) +{ + return sin(Rad); +} + +internal r32 +CosR32(r32 Rad) +{ + return cosf(Rad); +} +internal r64 +CosR64(r64 Rad) +{ + return cos(Rad); +} + +internal r32 +TanR32(r32 Rad) +{ + return tanf(Rad); +} +internal r64 +TanR64(r64 Rad) +{ + return tan(Rad); +} + +internal r32 +ASinR32(r32 Rad) +{ + return asinf(Rad); +} +internal r64 +ASinR64(r64 Rad) +{ + return asin(Rad); +} + +internal r32 +ACosR32(r32 Rad) +{ + return acosf(Rad); +} +internal r64 +ACosR64(r64 Rad) +{ + return acos(Rad); +} + +internal r32 +ATanR32(r32 Rad) +{ + return atanf(Rad); +} +internal r64 +ATanR64(r64 Rad) +{ + return atan(Rad); +} + +/////////////////////////// +// +// Vector + +internal v2 +V2MultiplyPairwise(v2 A, v2 B) +{ + v2 Result = v2{ + A.x * B.x, + A.y * B.y, + }; + return Result; +} + +internal v3 +V3MultiplyPairwise(v3 A, v3 B) +{ + v3 Result = v3{ + A.x * B.x, + A.y * B.y, + A.z * B.z, + }; + return Result; +} + +internal v4 +V4MultiplyPairwise(v4 A, v4 B) +{ + v4 Result = v4{ + A.x * B.x, + A.y * B.y, + A.z * B.z, + A.w * B.w, + }; + return Result; +} + + +v2 operator- (v2 A) { return { -A.x, -A.y }; } +v3 operator- (v3 A) { return { -A.x, -A.y, -A.z }; } +v4 operator- (v4 A) { return { -A.x, -A.y, -A.z, -A.w }; } + +v2 operator+ (v2 A, v2 B) { return { A.x + B.x, A.y + B.y }; } +v3 operator+ (v3 A, v3 B) { return { A.x + B.x, A.y + B.y, A.z + B.z }; } +v4 operator+ (v4 A, v4 B) { return { A.x + B.x, A.y + B.y, A.z + B.z, A.w + B.w }; } + +v2 operator- (v2 A, v2 B) { return { A.x - B.x, A.y - B.y }; } +v3 operator- (v3 A, v3 B) { return { A.x - B.x, A.y - B.y, A.z - B.z }; } +v4 operator- (v4 A, v4 B) { return { A.x - B.x, A.y - B.y, A.z - B.z, A.w - B.w }; } + +void operator+= (v2& A, v2 B) { A.x += B.x; A.y += B.y; } +void operator+= (v3& A, v3 B) { A.x += B.x; A.y += B.y; A.z += B.z; } +void operator+= (v4& A, v4 B) { A.x += B.x; A.y += B.y; A.z += B.z; A.w += B.w; } + +void operator-= (v2& A, v2 B) { A.x -= B.x; A.y -= B.y; } +void operator-= (v3& A, v3 B) { A.x -= B.x; A.y -= B.y; A.z -= B.z; } +void operator-= (v4& A, v4 B) { A.x -= B.x; A.y -= B.y; A.z -= B.z; A.w -= B.w; } + +v2 operator* (v2 A, r32 B) { return { A.x * B, A.y * B }; } +v3 operator* (v3 A, r32 B) { return { A.x * B, A.y * B, A.z * B }; } +v4 operator* (v4 A, r32 B) { return { A.x * B, A.y * B, A.z * B, A.w * B }; } + +v2 operator/ (v2 A, r32 B) { return { A.x / B, A.y / B }; } +v3 operator/ (v3 A, r32 B) { return { A.x / B, A.y / B, A.z / B }; } +v4 operator/ (v4 A, r32 B) { return { A.x / B, A.y / B, A.z / B, A.w / B }; } + +void operator*= (v2& A, r32 B) { A.x *= B; A.y *= B; } +void operator*= (v3& A, r32 B) { A.x *= B; A.y *= B; A.z *= B; } +void operator*= (v4& A, r32 B) { A.x *= B; A.y *= B; A.z *= B; A.w *= B; } + +void operator/= (v2& A, r32 B) { A.x /= B; A.y /= B; } +void operator/= (v3& A, r32 B) { A.x /= B; A.y /= B; A.z /= B; } +void operator/= (v4& A, r32 B) { A.x /= B; A.y /= B; A.z /= B; A.w /= B; } + +bool operator == (v2 A, v2 B) { return ((A.x == B.x) && (A.y == B.y)); } +bool operator == (v3 A, v3 B) { return ((A.x == B.x) && (A.y == B.y) && (A.z == B.z)); } +bool operator == (v4 A, v4 B) { return ((A.x == B.x) && (A.y == B.y) && (A.z == B.z) && (A.w == B.w)); } + +bool operator != (v2 A, v2 B) { return !((A.x == B.x) && (A.y == B.y)); } +bool operator != (v3 A, v3 B) { return !((A.x == B.x) && (A.y == B.y) && (A.z == B.z)); } +bool operator != (v4 A, v4 B) { return !((A.x == B.x) && (A.y == B.y) && (A.z == B.z) && (A.w == B.w)); } + +internal v3 ToV3(v2 V, r32 Z = 0) { return v3{V.x, V.y, Z}; } +internal v4 V2ToV4(v2 V, r32 Z = 0, r32 W = 0) { return v4{V.x, V.y, Z, W}; } +internal v4 ToV4_(v3 V, r32 W) +{ + return v4{V.x, V.y, V.z, W}; +} +#define ToV4Point(v) ToV4_((v), 1.0f) // all points have a w value of 1 +#define ToV4Vec(v) ToV4_((v), 0.0f) // all vectors have a w value of 0 ie. they cannot be translated + +internal r32 V2MagSquared(v2 V) { return ((V.x * V.x) + (V.y * V.y)); } +internal r32 V3MagSquared(v3 V) { return ((V.x * V.x) + (V.y * V.y) + (V.z * V.z)); } +internal r32 V4MagSquared(v4 V) { return ((V.x * V.x) + (V.y * V.y) + (V.z * V.z) + (V.w * V.w)); } + +internal r32 V2Mag(v2 V) { return SqrtR32((V.x * V.x) + (V.y * V.y)); } +internal r32 V3Mag(v3 V) { return SqrtR32((V.x * V.x) + (V.y * V.y) + (V.z * V.z)); } +internal r32 V4Mag(v4 V) { return SqrtR32((V.x * V.x) + (V.y * V.y) + (V.z * V.z) + (V.w * V.w)); } + +internal r32 V2DistanceSquared(v2 A, v2 B) { return V2MagSquared(A - B); } +internal r32 V3DistanceSquared(v3 A, v3 B) { return V3MagSquared(A - B); } +internal r32 V4DistanceSquared(v4 A, v4 B) { return V4MagSquared(A - B); } + +internal r32 V2Distance(v2 A, v2 B) { return V2Mag(A - B); } +internal r32 V3Distance(v3 A, v3 B) { return V3Mag(A - B); } +internal r32 V4Distance(v4 A, v4 B) { return V4Mag(A - B); } + +internal v2 +V2Normalize(v2 A) +{ + r32 Magnitude = V2Mag(A); + return A / Magnitude; +} +internal v3 +V3Normalize(v3 A) +{ + r32 Magnitude = V3Mag(A); + return A / Magnitude; +} +internal v4 +V4Normalize(v4 A) +{ + r32 Magnitude = V4Mag(A); + return A / Magnitude; +} + +internal r32 V2Dot(v2 A, v2 B) { return ((A.x * B.x) + (A.y * B.y)); } +internal r32 V3Dot(v3 A, v3 B) { return ((A.x * B.x) + (A.y * B.y) + (A.z * B.z)); } +internal r32 V4Dot(v4 A, v4 B) { return ((A.x * B.x) + (A.y * B.y) + (A.z * B.z) + (A.w * B.w)); } + +internal v2 V2PerpendicularCW(v2 A) { return v2{A.y, -A.x}; } +internal v2 V2PerpendicularCCW(v2 A) { return v2{A.y, A.x}; } + +internal r32 +V2Cross(v2 A, v2 B) +{ + return ((A.x * B.y) - (A.y * B.x)); +} + +internal v3 +V3Cross(v3 A, v3 B) +{ + v3 Result = { + (A.y * B.z) - (A.z * B.y), + (A.z * B.x) - (A.x * B.z), + (A.x * B.y) - (A.y * B.x) + }; + return Result; +} + +internal v4 +V4Cross(v4 A, v4 B) +{ + v4 Result = { + (A.y * B.z) - (A.z * B.y), + (A.z * B.x) - (A.x * B.z), + (A.x * B.y) - (A.y * B.x), + 0 + }; + return Result; +} + +internal v2 +V2Lerp(v2 A, v2 B, r32 T) +{ + v2 Result = v2{ + LerpR32(A.x, B.x, T), + LerpR32(A.y, B.y, T), + }; + return Result; +} + +internal v3 +V3Lerp(v3 A, v3 B, r32 T) +{ + v3 Result = v3{ + LerpR32(A.x, B.x, T), + LerpR32(A.y, B.y, T), + LerpR32(A.z, B.z, T), + }; + return Result; +} + +internal v4 +V4Lerp(v4 A, v4 B, r32 T) +{ + v4 Result = v4{ + LerpR32(A.x, B.x, T), + LerpR32(A.y, B.y, T), + LerpR32(A.z, B.z, T), + LerpR32(A.w, B.w, T), + }; + return Result; +} + +internal v2 +V2Remap(v2 P, v2 OldMin, v2 OldMax, v2 NewMin, v2 NewMax) +{ + v2 Result = {0}; + Result.x = RemapR32(P.x, OldMin.x, OldMax.x, NewMin.x, NewMax.x); + Result.y = RemapR32(P.y, OldMin.y, OldMax.y, NewMin.y, NewMax.y); + return Result; +} + +internal v3 +V3Remap(v3 P, v3 OldMin, v3 OldMax, v3 NewMin, v3 NewMax) +{ + v3 Result = {0}; + Result.x = RemapR32(P.x, OldMin.x, OldMax.x, NewMin.x, NewMax.x); + Result.y = RemapR32(P.y, OldMin.y, OldMax.y, NewMin.y, NewMax.y); + Result.z = RemapR32(P.z, OldMin.z, OldMax.z, NewMin.z, NewMax.z); + return Result; +} + +internal v4 +V4Remap(v4 P, v4 OldMin, v4 OldMax, v4 NewMin, v4 NewMax) +{ + v4 Result = {0}; + Result.x = RemapR32(P.x, OldMin.x, OldMax.x, NewMin.x, NewMax.x); + Result.y = RemapR32(P.y, OldMin.y, OldMax.y, NewMin.y, NewMax.y); + Result.z = RemapR32(P.z, OldMin.z, OldMax.z, NewMin.z, NewMax.z); + Result.w = RemapR32(P.w, OldMin.w, OldMax.w, NewMin.w, NewMax.w); + return Result; +} + +internal v4 +V4RemapAsV3(v4 P, v4 OldMin, v4 OldMax, v4 NewMin, v4 NewMax) +{ + v4 Result = {0}; + Result.xyz = V3Remap(P.xyz, OldMin.xyz, OldMax.xyz, NewMin.xyz, NewMax.xyz); + Result.w = P.w; + return Result; +} + +/////////////////////////// +// +// Ranges + +internal rect2 MakeRect2MinDim(v2 Min, v2 Dim) +{ + rect2 Result = {0}; + Result.Min = Min; + Result.Max = Min + Dim; + return Result; +} + +internal b32 ValueInRangeR32(r32 Min, r32 Max, r32 V) +{ + return ((V >= Min) && (V <= Max)); +} + +internal b32 ValueInRange1(range1 Range, r32 V) +{ + return ValueInRangeR32(Range.Min, Range.Max, V); +} +internal b32 ValueInRange2(range2 Range, v2 V) +{ + return (ValueInRangeR32(Range.Min.x, Range.Max.x, V.x) && + ValueInRangeR32(Range.Min.y, Range.Max.y, V.y)); +} +internal b32 ValueInRange3(range3 Range, v3 V) +{ + return (ValueInRangeR32(Range.Min.x, Range.Max.x, V.x) && + ValueInRangeR32(Range.Min.y, Range.Max.y, V.y) && + ValueInRangeR32(Range.Min.z, Range.Max.z, V.z)); +} +internal b32 ValueInRange4(range4 Range, v4 V) +{ + return (ValueInRangeR32(Range.Min.x, Range.Max.x, V.x) && + ValueInRangeR32(Range.Min.y, Range.Max.y, V.y) && + ValueInRangeR32(Range.Min.z, Range.Max.z, V.z) && + ValueInRangeR32(Range.Min.w, Range.Max.w, V.w)); +} + +#define PointIsInRect(range, point) ValueInRange2((range), (point)) + +internal r32 Range1SizeX(range1 Range) { return Range.Max - Range.Min; } +internal r32 Range2SizeX(range2 Range) { return Range.Max.x - Range.Min.x; } +internal r32 Range3SizeX(range3 Range) { return Range.Max.x - Range.Min.x; } +internal r32 Range4SizeX(range4 Range) { return Range.Max.x - Range.Min.x; } + +#define Rect2Width(r) Range2SizeX((r)) + +internal r32 Range2SizeY(range2 Range) { return Range.Max.y - Range.Min.y; } +internal r32 Range3SizeY(range3 Range) { return Range.Max.y - Range.Min.y; } +internal r32 Range4SizeY(range4 Range) { return Range.Max.y - Range.Min.y; } + +#define Rect2Height(r) Range2SizeY((r)) + +internal r32 Range3SizeZ(range3 Range) { return Range.Max.z - Range.Min.z; } +internal r32 Range4SizeZ(range4 Range) { return Range.Max.z - Range.Min.z; } + +internal r32 Range4SizeW(range4 Range) { return Range.Max.w - Range.Min.w; } + +internal r32 Range1Center(range1 Range) { return (Range.Max + Range.Min) / 2.0f; } +internal v2 Range2Center(range2 Range) { return (Range.Max + Range.Min) / 2.0f; } +internal v3 Range3Center(range3 Range) { return (Range.Max + Range.Min) / 2.0f; } +internal v4 Range4Center(range4 Range) { return (Range.Max + Range.Min) / 2.0f; } + +#define Rect2Center(r) Range2Center((r)) + +internal range1 Range1Offset(range1 Range, r32 Delta) { return range1{ Range.Min + Delta, Range.Max + Delta }; } +internal range2 Range2Offset(range2 Range, v2 Delta) { return range2{ Range.Min + Delta, Range.Max + Delta }; } +internal range3 Range3Offset(range3 Range, v3 Delta) { return range3{ Range.Min + Delta, Range.Max + Delta }; } +internal range4 Range4Offset(range4 Range, v4 Delta) { return range4{ Range.Min + Delta, Range.Max + Delta }; } + +#define Rect2Translate(r, d) Range2Offset((r), (d)) +#define Rect2TranslateX(r, dx) Range2Offset((r), v2{(dx), 0}) +#define Rect2TranslateY(r, dy) Range2Offset((r), v2{0, (dy)}) + +internal v2 RectTopLeft(rect2 Rect) +{ + return v2{ Rect.Min.x, Rect.Max.y }; +} +internal v2 RectTopRight(rect2 Rect) +{ + return Rect.Max; +} +internal v2 RectBottomLeft(rect2 Rect) +{ + return Rect.Min; +} +internal v2 RectBottomRight(rect2 Rect) +{ + return v2{ Rect.Max.x, Rect.Min.y }; +} + +internal r32 AspectRatio(r32 Width, r32 Height) { return Width / Height; } +internal r32 RectAspectRatio(rect2 Rect) { return Range2SizeX(Rect) / Range2SizeY(Rect); } + +internal void +RectHSplit(rect2 Rect, r32 YValue, rect2* Top, rect2* Bottom) +{ + r32 ClampedYValue = Clamp(Rect.Min.y, YValue, Rect.Max.y); + Top->Max = Rect.Max; + Top->Min = { Rect.Min.x, ClampedYValue }; + Bottom->Max = { Rect.Max.x, ClampedYValue }; + Bottom->Min = Rect.Min; +} +internal void +RectVSplit(rect2 Rect, r32 XValue, rect2* Left, rect2* Right) +{ + r32 ClampedXValue = Clamp(Rect.Min.x, XValue, Rect.Max.x); + Left->Max = { ClampedXValue, Rect.Max.y}; + Left->Min = Rect.Min; + Right->Max = Rect.Max; + Right->Min = { ClampedXValue, Rect.Min.y }; +} + +internal void +RectHSplitAtDistanceFromTop(rect2 Rect, r32 YDist, rect2* Top, rect2* Bottom) +{ + RectHSplit(Rect, Rect.Max.y - YDist, Top, Bottom); +} +internal void +RectHSplitAtDistanceFromBottom(rect2 Rect, r32 YDist, rect2* Top, rect2* Bottom) +{ + RectHSplit(Rect, Rect.Min.y + YDist, Top, Bottom); +} +internal void +RectVSplitAtDistanceFromRight(rect2 Rect, r32 XDist, rect2* Left, rect2* Right) +{ + RectVSplit(Rect, Rect.Max.x - XDist, Left, Right); +} +internal void +RectVSplitAtDistanceFromLeft(rect2 Rect, r32 XDist, rect2* Left, rect2* Right) +{ + RectVSplit(Rect, Rect.Min.x + XDist, Left, Right); +} +internal void +RectHSplitAtPercent(rect2 Rect, r32 YPercent, rect2* Top, rect2* Bottom) +{ + RectHSplit(Rect, LerpR32(YPercent, Rect.Min.y, Rect.Max.y), Top, Bottom); +} +internal void +RectVSplitAtPercent(rect2 Rect, r32 XPercent, rect2* Left, rect2* Right) +{ + RectVSplit(Rect, LerpR32(XPercent, Rect.Min.x, Rect.Max.x), Left, Right); +} + +internal rect2 +RectInset(rect2 Outer, v2 Amount) +{ + rect2 Result = { Outer.Min + Amount, Outer.Max - Amount }; + return Result; +} +internal rect2 +RectInset(rect2 Outer, r32 UniformAmount) +{ + return RectInset(Outer, v2{UniformAmount, UniformAmount}); +} + + +internal range1 +Range1Union(range1 A, range1 B) +{ + range1 Result = {}; + Result.Min = Max(A.Min, B.Min); + Result.Max = Min(A.Max, B.Max); + return Result; +} +#define Rect2Union(a,b) Range2Union((a), (b)) +internal range2 +Range2Union(range2 A, range2 B) +{ + range2 Result = {}; + Result.Min.x = Max(A.Min.x, B.Min.x); + Result.Min.y = Max(A.Min.y, B.Min.y); + Result.Max.x = Min(A.Max.x, B.Max.x); + Result.Max.y = Min(A.Max.y, B.Max.y); + return Result; +} +internal range3 +Range3Union(range3 A, range3 B) +{ + range3 Result = {}; + Result.Min.x = Max(A.Min.x, B.Min.x); + Result.Min.y = Max(A.Min.y, B.Min.y); + Result.Min.z = Max(A.Min.z, B.Min.z); + Result.Max.x = Min(A.Max.x, B.Max.x); + Result.Max.y = Min(A.Max.y, B.Max.y); + Result.Max.z = Min(A.Max.z, B.Max.z); + return Result; +} + +internal v2 +Rect2GetRectLocalPoint(rect2 Rect, v2 Point) +{ + v2 Result = Point - Rect.Min; + return Result; +} + +/////////////////////////// +// +// Ray + +internal v4 +RayGetPointAlong(v4 RayOrigin, v4 RayDirection, r32 T) +{ + v4 Result = RayOrigin + (RayDirection * T); + return Result; +} + +internal r32 +RayPlaneIntersectionDistance(v4 RayOrigin, v4 RayDirection, v4 PlanePoint, v4 PlaneNormal) +{ + r32 T = 0.0f; + float Denominator = V4Dot(PlaneNormal, RayDirection); + if (Abs(Denominator) > 0.00001f) + { + T = V4Dot(PlanePoint - RayDirection, PlaneNormal) / Denominator; + } + return T; +} + +internal v4 +GetRayPlaneIntersectionPoint(v4 RayOrigin, v4 RayDirection, v4 PlanePoint, v4 PlaneNormal) +{ + v4 Result = {0}; + r32 T = RayPlaneIntersectionDistance(RayOrigin, RayDirection, PlanePoint, PlaneNormal); + if (T >= 0) + { + Result = RayGetPointAlong(RayOrigin, RayDirection, T); + } + return Result; +} +internal v4 +GetRayPlaneIntersectionPoint(v4_ray Ray, v4 PlanePoint, v4 PlaneNormal) +{ + return GetRayPlaneIntersectionPoint(Ray.Origin, Ray.Direction, PlanePoint, PlaneNormal); +} + +internal bool +RayIntersectsPlane(v4 RayOrigin, v4 RayDirection, v4 PlanePoint, v4 PlaneNormal, v4* OutPoint) +{ + bool Result = false; + r32 T = RayPlaneIntersectionDistance(RayOrigin, RayDirection, PlanePoint, PlaneNormal); + if (T >= 0) + { + Result = true; + *OutPoint = RayGetPointAlong(RayOrigin, RayDirection, T); + } + return Result; +} +internal bool +RayIntersectsPlane(v4_ray Ray, v4 PlanePoint, v4 PlaneNormal, v4* OutPoint) +{ + return RayIntersectsPlane(Ray.Origin, Ray.Direction, PlanePoint, PlaneNormal, OutPoint); +} + +/////////////////////////// +// +// Matrices + +internal m44 +M44Identity() +{ + m44 M = {0}; + M.AXx = 1.0f; + M.AYy = 1.0f; + M.AZz = 1.0f; + M.Tw = 1.0f; + return M; +} + +internal m44 +M44Transpose(m44 M) +{ + m44 Result = {0}; + for (u32 Y = 0; Y < 4; Y++) + { + for (u32 X = 0; X < 4; X++) + { + Result.Array[(X * 4) + Y] = M.Array[(Y * 4) + X]; + } + } + return Result; +} + +// Matrix * Matrix + +m44 operator* (m44 L, m44 R) +{ + m44 M = {0}; + + // ci ic ci ic ci ic i ic + M.AXx = (L.AXx * R.AXx) + (L.AYx * R.AXy) + (L.AZx * R.AXz) + (L.Tx * R.AXw); + M.AXy = (L.AXy * R.AXx) + (L.AYy * R.AXy) + (L.AZy * R.AXz) + (L.Ty * R.AXw); + M.AXz = (L.AXz * R.AXx) + (L.AYz * R.AXy) + (L.AZz * R.AXz) + (L.Tz * R.AXw); + M.AXw = (L.AXw * R.AXx) + (L.AYw * R.AXy) + (L.AZw * R.AXz) + (L.Tw * R.AXw); + + M.AYx = (L.AXx * R.AYx) + (L.AYx * R.AYy) + (L.AZx * R.AYz) + (L.Tx * R.AYw); + M.AYy = (L.AXy * R.AYx) + (L.AYy * R.AYy) + (L.AZy * R.AYz) + (L.Ty * R.AYw); + M.AYz = (L.AXz * R.AYx) + (L.AYz * R.AYy) + (L.AZz * R.AYz) + (L.Tz * R.AYw); + M.AYz = (L.AXw * R.AYx) + (L.AYw * R.AYy) + (L.AZw * R.AYz) + (L.Tw * R.AYw); + + M.AZx = (L.AXx * R.AZx) + (L.AYx * R.AZy) + (L.AZx * R.AZz) + (L.Tx * R.AZw); + M.AZy = (L.AXy * R.AZx) + (L.AYy * R.AZy) + (L.AZy * R.AZz) + (L.Ty * R.AZw); + M.AZz = (L.AXz * R.AZx) + (L.AYz * R.AZy) + (L.AZz * R.AZz) + (L.Tz * R.AZw); + M.AZw = (L.AXw * R.AZx) + (L.AYw * R.AZy) + (L.AZw * R.AZz) + (L.Tw * R.AZw); + + M.Tx = (L.AXx * R.Tx) + (L.AYx * R.Ty) + (L.AZx * R.Tz) + (L.Tx * R.Tw); + M.Ty = (L.AXy * R.Tx) + (L.AYy * R.Ty) + (L.AZy * R.Tz) + (L.Ty * R.Tw); + M.Tz = (L.AXz * R.Tx) + (L.AYz * R.Ty) + (L.AZz * R.Tz) + (L.Tz * R.Tw); + M.Tw = (L.AXw * R.Tx) + (L.AYw * R.Ty) + (L.AZw * R.Tz) + (L.Tw * R.Tw); + + return M; +} + +// Matrix * Vector + +v4 operator* (m44 M, v4 V) +{ + v4 Result = {0}; + Result.x = (V.x * M.AXx) + (V.y * M.AYx) + (V.z * M.AZx) + (V.w * M.Tx); + Result.y = (V.x * M.AXy) + (V.y * M.AYy) + (V.z * M.AZy) + (V.w * M.Ty); + Result.z = (V.x * M.AXz) + (V.y * M.AYz) + (V.z * M.AZz) + (V.w * M.Tz); + Result.w = (V.x * M.AXw) + (V.y * M.AYw) + (V.z * M.AZw) + (V.w * M.Tw); + return Result; +} + +internal m44 +M44Translation(v4 Offset) +{ + m44 Result = M44Identity(); + Result.Tx = Offset.x; + Result.Ty = Offset.y; + Result.Tz = Offset.z; + return Result; +} + +internal m44 +M44RotationX(r32 Radians) +{ + r32 CosRad = CosR32(Radians); + r32 SinRad = SinR32(Radians); + m44 Result = M44Identity(); + Result.AYy = CosRad; + Result.AZy = SinRad; + Result.AYz = -SinRad; + Result.AZz = CosRad; + return Result; +} + +internal m44 +M44RotationY(r32 Radians) +{ + r32 CosRad = CosR32(Radians); + r32 SinRad = SinR32(Radians); + m44 Result = M44Identity(); + Result.AXx = CosRad; + Result.AZx = SinRad; + Result.AXz = -SinRad; + Result.AZz = CosRad; + return Result; +} + +internal m44 +M44RotationZ(r32 Radians) +{ + r32 CosRad = CosR32(Radians); + r32 SinRad = SinR32(Radians); + m44 Result = M44Identity(); + Result.AXx = CosRad; + Result.AYx = -SinRad; + Result.AXy = SinRad; + Result.AYy = CosRad; + return Result; +} + +internal m44 +M44Rotation(v3 Radians) +{ + r32 CosX = CosR32(Radians.x); + r32 SinX = SinR32(Radians.x); + r32 CosY = CosR32(Radians.y); + r32 SinY = SinR32(Radians.y); + r32 CosZ = CosR32(Radians.z); + r32 SinZ = SinR32(Radians.z); + + m44 Result = {0}; + Result.AXx = CosY * CosZ; + Result.AXy = -(SinX * SinY * CosZ) + (CosX * SinZ); + Result.AXz = -(CosX * SinY * CosZ) - (SinX * SinZ); + Result.AXw = 0; + + Result.AYx = -(SinZ * CosY); + Result.AYy = (SinX * SinY * SinZ) + (CosX * CosZ); + Result.AYz = (CosX * SinY * SinZ) - (SinX * CosZ); + Result.AYw = 0; + + Result.AZx = SinY; + Result.AZy = SinX * CosY; + Result.AZz = CosX * CosY; + Result.AZw = 0; + + Result.Tx = 0; + Result.Ty = 0; + Result.Tz = 0; + Result.Tw = 1; + + return Result; +} + +internal m44 +M44Scale(v3 Scale) +{ + m44 Result = M44Identity(); + Result.AXx = Scale.x; + Result.AYy = Scale.y; + Result.AZz = Scale.z; + return Result; +} + +internal m44 +M44ScaleUniform(r32 Scale) +{ + m44 Result = M44Identity(); + Result.AXx = Scale; + Result.AYy = Scale; + Result.AZz = Scale; + return Result; +} + +internal m44 +M44CoordinateFrame(v4 Forward, v4 Right, v4 Up) +{ + m44 Result = {0}; + Result.AXx = Right.x; + Result.AYx = Right.y; + Result.AZx = Right.z; + Result.Tx = Right.w; + + Result.AXy = Up.x; + Result.AYy = Up.y; + Result.AZy = Up.z; + Result.Ty = Up.w; + + Result.AXz = Forward.x; + Result.AYz = Forward.y; + Result.AZz = Forward.z; + Result.Tz = Forward.w; + + Result.Tw = 1.0f; + return Result; +} + +internal m44 +M44ModelMatrix(v4 Forward, v4 Right, v4 Up, v4 Position) +{ + m44 RotationMatrix = M44CoordinateFrame(Forward, Right, Up); + m44 PositionMatrix = M44Translation(-Position); + m44 ModelViewMatrix = PositionMatrix * RotationMatrix; + return ModelViewMatrix; +} + +internal m44 +M44ProjectionOrtho(r32 Width, r32 Height, r32 Near, r32 Far, r32 Right, r32 Left, r32 Top, r32 Bottom) +{ + m44 Result = {0}; + Result.AXx = 2.0f / Width; + Result.AYy = 2.0f / Height; + Result.AZz = 2.0f / (Near - Far); + Result.AXw = -(Right + Left) / (Right - Left); + Result.AYw = -(Top + Bottom) / (Top - Bottom); + Result.AZw = -(Far + Near) / (Far - Near); + Result.Tw = 1; + return Result; +} + +internal m44 +M44ProjectionOrtho(r32 Aspect, r32 Scale, r32 Near, r32 Far) +{ + m44 Result = {0}; + r32 Width = Scale * Aspect; + r32 Height = Scale; + r32 Right = Width / 2.0f; + r32 Left = -Right; + r32 Top = Height / 2.0f; + r32 Bottom = -Top; + Result = M44ProjectionOrtho(Width, Height, Near, Far, Right, Left, Top, Bottom); + return Result; +} + +internal m44 +M44ProjectionInterfaceOrtho(r32 Width, r32 Height, r32 Near, r32 Far) +{ + m44 Result = {0}; + r32 Aspect = Width / Height; + r32 Right = Width; + r32 Left = 0; + r32 Top = Height; + r32 Bottom = 0; + Result = M44ProjectionOrtho(Width, Height, Near, Far, Right, Left, Top, Bottom); + return Result; +} + +internal m44 +M44ProjectionPerspective(r32 FieldOfViewDegrees, r32 AspectRatio, r32 Near, r32 Far) +{ + m44 Result = M44Identity(); + + // The perspective divide step involves dividing x and y by -z + // Making Tz = -1 will make Tw of the result = -z + Result.Tw = 0; + Result.AZw = -1; + + // Remap z' from the range [near clip : far clip] to [0 : 1] + r32 ViewRange = Far - Near; + Result.AZz = -((Far + Near) / ViewRange); + Result.Tz = -(2 * Near * Far) / ViewRange; + + // Adjust for field of view - adjust the x' and y coordinates based + // on how + r32 FovBasedScale = TanR32(DegToRadR32(FieldOfViewDegrees / 2)); + r32 Top = Near * FovBasedScale; + r32 Bottom = -Top; + r32 Right = Top * AspectRatio; + r32 Left = -Right; + Result.AXx = (2 * Near) / (Right - Left); + Result.AZx = (Right + Left) / (Right - Left); + Result.AYy = (2 * Near) / (Top - Bottom); + Result.AZy = (Top + Bottom) / (Top - Bottom); + + return Result; +} + +internal m44 +M44LookAt(v4 Position, v4 Target) +{ + // NOTE(Peter): the camera usually points along the -z axis, hence + // Forward = a ray that points from the target back towards your position + v4 Forward = V4Normalize(Position - Target); + v4 Right = V4Normalize(V4Cross(v4{0, 1, 0, 0}, Forward)); + v4 Up = V4Normalize(V4Cross(Forward, Right)); + m44 Result = M44CoordinateFrame(Forward, Right, Up); + return Result; +} + +/////////////////////////// +// +// Strings + +internal gs_const_string ConstString(char* Data, u64 Length) { return gs_const_string{Data, Length}; } +internal gs_const_string ConstString(char* Data) { return gs_const_string{Data, CStringLength(Data)}; } +internal gs_string MakeString(char* Data, u64 Length, u64 Size) +{ + Assert(Length <= Size); + gs_string Result = {0}; + Result.Str = Data; + Result.Length = Length; + Result.Size = Size; + return Result; +} +internal gs_string MakeString(char* Data, u64 Length) +{ + return MakeString(Data, Length, Length); +} +internal gs_string MakeString(char* Data) +{ + u64 StringLength = CStringLength(Data); + return MakeString(Data, StringLength, StringLength); +} +internal gs_string MakeString(gs_const_string ConstString) +{ + return MakeString(ConstString.Str, ConstString.Length); +} + +internal gs_data StringToData(gs_const_string String) +{ + gs_data Result = gs_data{0}; + Result.Memory = (u8*)String.Str; + Result.Size = String.Length * sizeof(char); + return Result; +} +internal gs_data StringToData(gs_string String) +{ + return StringToData(String.ConstString); +} + +internal bool IsSlash(char C) { return ((C == '/') || (C == '\\')); } +internal bool IsUpper(char C) { return(('A' <= C) && (C <= 'Z')); } +internal bool IsLower(char C) { return(('a' <= C) && (C <= 'z')); } +internal bool IsWhitespace(char C) { return (C == ' ' || C == '\n' || C == '\r' || C == '\t' || C == '\f' || C == '\v'); } +internal bool IsNewline(char C) { return (C == '\n') || (C == '\r'); } +internal bool IsNewlineOrWhitespace (char C) { return IsNewline(C) || IsWhitespace(C); } +internal bool IsBase8(char C) { return (C >= '0' && C <= '7'); } +internal bool IsBase10(char C) { return (C >= '0' && C <= '9'); } +internal bool IsBase16(char C) { return (C >= '0' && C <= '9') || (C >= 'A' && C <= 'F'); } +internal bool IsNumericDecimal(char C) { return IsBase10(C) || (C == '.'); } +internal bool IsNumericExtended(char C) { return IsNumericDecimal(C) || (C == 'x') || (C == 'f') || (C == '-'); } +internal bool IsAlpha(char C) { return( (('a' <= C) && (C <= 'z')) || (('A' <= C) && (C <= 'Z')) || C == '_'); } +internal bool IsAlphaNumeric(char C) { return((('a' <= C) && (C <= 'z')) || (('A' <= C) && (C <= 'Z')) || (('0' <= C) && (C <= '9')) || C == '_'); } +internal bool IsOperator(char C) { + return ((C == '+') || (C == '-') || (C == '*') || (C == '/') || + (C == '=') || (C == '%') || (C == '<') || (C == '>')); +} + +internal char +ToUpper(char C) +{ + if ((C >= 'a') && (C <= 'z')) + { + C -= 'a' - 'A'; + } + return C; +} +internal char +ToLower(char C) +{ + if ((C >= 'A') && (C <= 'Z')) + { + C += 'a' - 'A'; + } + return C; +} +internal bool CharsEqualCaseInsensitive(char A, char B) { return ToLower(A) == ToLower(B); } + +internal u64 +CharArrayLength (char* CS) +{ + char* At = CS; + while (*At) { At++; } + return (u64)(At - CS); +} + +internal bool +IsNullTerminated(gs_const_string String) +{ + return (String.Str[String.Length - 1] != 0); +} +internal bool +IsNullTerminated(gs_string String) +{ + return IsNullTerminated(String.ConstString); +} + +internal char +GetChar(gs_const_string String, u64 I) +{ + char Result = 0; + if (I < String.Length) + { + Result = String.Str[I]; + } + return Result; +} +internal char +GetChar(gs_string String, u64 I) +{ + char Result = 0; + if (I < String.Length) + { + Result = String.Str[I]; + } + return Result; +} + +internal gs_const_string +GetStringPrefix(gs_const_string String, u64 Size) +{ + gs_const_string Result = String; + Result.Length = Min(Size, String.Length); + return Result; +} +internal gs_const_string +GetStringPostfix(gs_const_string String, u64 Size) +{ + gs_const_string Result = String; + u64 PostfixSize = Min(Size, String.Length); + Result.Str += (Result.Length - PostfixSize); + Result.Length = PostfixSize; + return Result; +} +internal gs_const_string +GetStringAfter(gs_const_string String, u64 Cut) +{ + gs_const_string Result = String; + u64 CutSize = Min(Cut, String.Length); + Result.Str += CutSize; + Result.Length -= CutSize; + return Result; +} +internal gs_string +GetStringAfter(gs_string String, u64 Cut) +{ + gs_string Result = {0}; + Result.ConstString = GetStringAfter(String.ConstString, Cut); + Result.Size = String.Size - Cut; + return Result; +} +internal gs_const_string +GetStringBefore(gs_const_string String, u64 Cut) +{ + gs_const_string Result = String; + Result.Length = Min(Cut, String.Length); + return Result; +} +internal gs_const_string +Substring(gs_const_string String, u64 First, u64 Last) +{ + gs_const_string Result = {0}; + Result.Str = String.Str + Min(First, String.Length); + Result.Length = Min(Last - First, String.Length); + return Result; +} +internal u64 +FindFirst(gs_const_string String, u64 StartIndex, char C) +{ + u64 Result = StartIndex; + for(; Result < String.Length && C != String.Str[Result]; Result++); + return Result; +} +internal u64 +FindFirst(gs_const_string String, char C) +{ + return FindFirst(String, 0, C); +} +internal u64 +FindLast(gs_const_string String, char C) +{ + s64 Result = String.Length - 1; + for(; Result >= 0 && C != String.Str[Result]; Result--); + return (u64)Result; +} +internal u64 +FindFirstFromSet(gs_const_string String, char* SetArray) +{ + gs_const_string Set = ConstString(SetArray); + u64 Result = String.Length - 1; + for(u64 At = 0; At < String.Length; At++) + { + char CharAt = String.Str[At]; + for (u64 SetAt = 0; SetAt < Set.Length; SetAt++) + { + if (CharAt == Set.Str[SetAt]) + { + Result = At; + // NOTE(Peter): The alternative to this goto is a break in the inner loop + // followed by an if check in the outer loop, that must be evaluated + // every character you check. This is more efficient + goto find_last_from_set_complete; + } + } + } + find_last_from_set_complete: + return Result; +} + +internal u64 +FindLastFromSet(gs_const_string String, char* SetArray) +{ + gs_const_string Set = ConstString(SetArray); + u64 Result = String.Length - 1; + for(s64 At = Result; At >= 0; At--) + { + char CharAt = String.Str[At]; + for (u64 SetAt = 0; SetAt < Set.Length; SetAt++) + { + if (CharAt == Set.Str[SetAt]) + { + Result = (u64)At; + // NOTE(Peter): The alternative to this goto is a break in the inner loop + // followed by an if check in the outer loop, that must be evaluated + // every character you check. This is more efficient + goto find_first_from_set_complete; + } + } + } + find_first_from_set_complete: + return Result; +} + +internal bool +StringsEqualUpToLength(gs_const_string A, gs_const_string B, u64 Length) +{ + bool Result = false; + if (A.Length >= Length && B.Length >= Length) + { + Result = true; + Length = Min(Length, A.Length); + for (u64 i = 0; i < Length; i++) + { + if (A.Str[i] != B.Str[i]) + { + Result = false; + break; + } + } + } + return Result; +} +internal bool +StringsEqual(gs_const_string A, gs_const_string B) +{ + bool Result = false; + if (A.Length == B.Length) + { + Result = StringsEqualUpToLength(A, B, A.Length); + } + return Result; +} +internal bool +StringEqualsCharArray(gs_const_string A, char* B, u64 Length) +{ + gs_const_string BStr = ConstString(B, Length); + return StringsEqual(A, BStr); +} +internal bool +StringsEqualUpToLength(gs_string A, gs_string B, u64 Length) +{ + return StringsEqualUpToLength(A.ConstString, B.ConstString, Length); +} +internal bool +StringsEqual(gs_string A, gs_string B) +{ + return StringsEqual(A.ConstString, B.ConstString); +} +internal bool +StringEqualsCharArray(gs_string A, char* B, u64 Length) +{ + gs_string BStr = MakeString(B, Length); + return StringsEqual(A, BStr); +} + +internal u64 +StringSizeLeft(gs_string String) +{ + u64 Result = String.Size - String.Length; + return Result; +} + +internal void +ReverseStringInPlace(gs_string* String) +{ + char* Start = String->Str; + char* End = String->Str + String->Length; + while (Start < End) + { + End--; + char Temp = End[0]; + End[0] = Start[0]; + Start[0] = Temp; + Start++; + } +} + +internal gs_const_string +GetCharSetForBase(u64 Base) +{ + gs_const_string Result = {0}; + switch(Base) + { + case 8: { Result = Base8Chars; }break; + case 10: { Result = Base10Chars; }break; + case 16: { Result = Base16Chars; }break; + InvalidDefaultCase; + } + return Result; +} +internal u64 +CharToUInt(char C, gs_const_string CharSet) +{ + return (u64)FindFirst(CharSet, C); +} +internal u64 +CharToUInt(char C) +{ + return (u64)CharToUInt(C, Base10Chars); +} +internal u64 +CharToUInt(char C, u64 Base) +{ + return CharToUInt(C, GetCharSetForBase(Base)); +} + +internal u64 +ParseUInt(gs_const_string String, u64 Base = 10, u64* ParsedLength = 0) +{ + u64 Result = 0; + gs_const_string CharSet = GetCharSetForBase(Base); + u64 i = 0; + for (; i < String.Length; i++) + { + u64 CharIndex = FindFirst(CharSet, String.Str[i]); + if (CharIndex < CharSet.Length) + { + Result = CharToUInt(String.Str[i], CharSet) + (Result * Base); + } + else + { + break; + } + } + if (ParsedLength != 0) + { + *ParsedLength = i; + } + return Result; +} +internal u64 +ParseUInt(u64 Length, char* String, u64 Base = 10, u64* ParsedLength = 0) +{ + return ParseUInt(ConstString(String, Length), Base, ParsedLength); +} +internal u64 +ParseUInt(char* String, u64 Base = 10, u64* ParsedLength = 0) +{ + return ParseUInt(LitString(String), Base, ParsedLength); +} + +internal s64 +ParseInt(gs_const_string String, u64 Base = 10, u64* ParsedLength = 0) +{ + s64 Result = 0; + u64 TempParsedLength = 0; + if (String.Str[0] == '-') + { + Result = -1 * (s64)ParseUInt(GetStringAfter(String, 1), Base, &TempParsedLength); + TempParsedLength += 1; + } + else + { + Result = (s64)ParseUInt(String, Base, &TempParsedLength); + } + if (ParsedLength != 0) + { + *ParsedLength = TempParsedLength; + } + return Result; +} +internal s64 +ParseInt(char* String, u64 Base = 10, u64* ParsedLength = 0) +{ + return ParseInt(LitString(String), Base, ParsedLength); +} + +internal r64 +ParseFloat(gs_const_string String, u64* ParsedLength = 0) +{ + + u64 DecimalIndex = FindFirst(String, '.'); + u64 TempParsedLength = 0; + u64 PlacesAfterPoint = 0; + + gs_const_string IntegerString = GetStringBefore(String, DecimalIndex); + gs_const_string DecimalString = GetStringAfter(String, DecimalIndex + 1); + + r32 Polarity = 1; + if (IntegerString.Str[0] == '-') + { + IntegerString = GetStringAfter(IntegerString, 1); + Polarity = -1; + } + r64 Result = (r64)ParseInt(IntegerString, 10, &TempParsedLength); + + if (TempParsedLength == IntegerString.Length) + { + r64 AfterPoint = (r64)ParseUInt(DecimalString, 10, &PlacesAfterPoint); + r64 Decimal = (AfterPoint / PowR64(10, PlacesAfterPoint)); + Result = Result + Decimal; + Result *= Polarity; + } + + if (ParsedLength != 0) + { + *ParsedLength = TempParsedLength + PlacesAfterPoint; + if (DecimalIndex < String.Length) { *ParsedLength += 1; } + } + return Result; +} +internal r64 +ParseFloat(char* String, u64* ParsedLength = 0) +{ + return ParseFloat(LitString(String), ParsedLength); +} + +internal u64 +AppendString(gs_string* Base, gs_const_string Appendix) +{ + u64 StartIndex = Base->Length; + u64 LengthAvailable = Base->Size - Base->Length; + u64 Written = 0; + for (; Written < Min(LengthAvailable, Appendix.Length); Written++) + { + Base->Str[StartIndex + Written] = Appendix.Str[Written]; + } + Base->Length += Written; + Assert(Base->Length <= Base->Size); + return Written; +} +internal u64 +AppendString(gs_string* Base, gs_string Appendix) +{ + return AppendString(Base, Appendix.ConstString); +} +internal void +NullTerminate(gs_string* String) +{ + if (String->Length < String->Size) + { + String->Str[String->Length] = 0; + } + else + { + String->Str[String->Length - 1] = 0; + } +} + +internal void +OutChar(gs_string* String, char C) +{ + if (String->Length < String->Size) + { + String->Str[String->Length++] = C; + } +} + +internal void +U64ToASCII(gs_string* String, u64 Value, u64 Base, gs_const_string Digits) +{ + u64 ValueRemaining = Value; + u64 At = 0; + do { + u64 Index = ValueRemaining % Base; + char Digit = Digits.Str[Index]; + OutChar(String, Digit); + ValueRemaining /= Base; + }while(ValueRemaining); + char* End = String->Str + String->Length; + ReverseStringInPlace(String); +} + +internal void +U64ToASCII(gs_string* String, u64 Value, u64 Base) +{ + U64ToASCII(String, Value, Base, GetCharSetForBase(Base)); +} + +internal void +R64ToASCII(gs_string* String, r64 Value, u64 Precision) +{ + if (Value < 0) + { + OutChar(String, '-'); + Value = Abs(Value); + } + u64 IntegerPart = (u64)Value; + // NOTE(Peter): If we don't use the inner string, when U64ToASCII reverses the characters + // it'll put the negative sign at the end. + gs_string IntegerString = GetStringAfter(*String, String->Length); + U64ToASCII(&IntegerString, IntegerPart, 10); + String->Length += IntegerString.Length; + Value -= IntegerPart; + if (Value > 0) + { + OutChar(String, '.'); + for (u64 i = 0; i < Precision; i++) + { + Value *= 10.0f; + u64 DecimalPlace = (u64)Value; + Value -= DecimalPlace; + OutChar(String, Base10Chars.Str[DecimalPlace]); + } + } +} + +internal s64 +ReadVarArgsSignedInteger (s32 Width, va_list* Args) +{ + s64 Result = 0; + switch (Width) + { + // NOTE(Peter): For Width lower than 4 bytes, the C++ spec specifies + // that it will get promoted to an int anyways + case 1: { Result = (s64)va_arg(*Args, s32); } break; + case 2: { Result = (s64)va_arg(*Args, s32); } break; + case 4: { Result = (s64)va_arg(*Args, s32); } break; + case 8: { Result = (s64)va_arg(*Args, s64); } break; + InvalidDefaultCase; + } + return Result; +} + +internal r64 +ReadVarArgsUnsignedInteger (s32 Width, va_list* Args) +{ + u64 Result = 0; + switch (Width) + { + // NOTE(Peter): For Width lower than 4 bytes, the C++ spec specifies + // that it will get promoted to an int anyways + case 1: { Result = (u64)va_arg(*Args, u32); } break; + case 2: { Result = (u64)va_arg(*Args, u32); } break; + case 4: { Result = (u64)va_arg(*Args, u32); } break; + case 8: { Result = (u64)va_arg(*Args, u64); } break; + InvalidDefaultCase; + } + return Result; +} + +internal r64 +ReadVarArgsFloat (s32 Width, va_list* Args) +{ + r64 Result = 0; + switch (Width) + { + case 4: { Result = (r64)va_arg(*Args, r64); } break; + case 8: { Result = (r64)va_arg(*Args, r64); } break; + InvalidDefaultCase; + } + return Result; +} + +internal s32 +PrintFArgsList (gs_string* String, char* Format, va_list Args) +{ + char* FormatAt = Format; + while (*FormatAt) + { + if (FormatAt[0] != '%') + { + if (FormatAt[0] == '\\') + { + FormatAt++; + Assert(IsBase8(FormatAt[0]) || // Octal Escape Sequences - \0 is in this set + FormatAt[0] == '\'' || + FormatAt[0] == '\"' || + FormatAt[0] == '\?' || + FormatAt[0] == '\\' || + FormatAt[0] == 'a' || // Audible Bell + FormatAt[0] == 'b' || // Backspace + FormatAt[0] == 'f' || // Form Feed - New Page + FormatAt[0] == 'n' || // Line Feed - New Line + FormatAt[0] == 'r' || // Carriage Return + FormatAt[0] == 't' || // Tab + FormatAt[0] == 'v'); // Vertical Tab + + // Not Handled (see cpp spec) \nnn \xnn \unnnn \Unnnnnnnn + Assert(FormatAt[0] != 'x' || FormatAt[0] != 'u' || FormatAt[0] != 'U'); + + if (IsBase8(FormatAt[0])) + { + // TODO(Peter): this should keep going until it finds a non-octal character code + // but the only one we really need is \0 atm so I'm just handling that one + Assert(FormatAt[0] == '0'); + OutChar(String, (char)0); + FormatAt++; + } + else + { + OutChar(String, *FormatAt++); + } + } + else + { + OutChar(String, *FormatAt++); + } + } + else if (FormatAt[0] == '%' && FormatAt[1] == '%') // Print the % symbol + { + OutChar(String, '%'); + FormatAt += 2; + } + else + { + FormatAt++; + + // Flags + if (FormatAt[0] == '-') + { + FormatAt++; + } + else if (FormatAt[0] == '+') + { + FormatAt++; + } + else if (FormatAt[0] == ' ') + { + FormatAt++; + } + else if (FormatAt[0] == '#') + { + FormatAt++; + } + else if (FormatAt[0] == '0') + { + FormatAt++; + } + + // Width + b32 WidthSpecified = false; + s32 Width = 0; + + if (IsBase10(FormatAt[0])) + { + WidthSpecified = true; + u64 Parsed = 0; + AssertMessage("ParseInt assumes whole string is an integer"); + Width = (s32)ParseInt(FormatAt, 10, &Parsed); + FormatAt += Parsed; + } + else if (FormatAt[0] == '*') + { + WidthSpecified = true; + Width = va_arg(Args, s32); + Assert(Width >= 0); + FormatAt++; + } + + // Precision + b32 PrecisionSpecified = false; + s32 Precision = 0; + + if (FormatAt[0] == '.') + { + FormatAt++; + if (IsBase10(FormatAt[0])) + { + + PrecisionSpecified = true; + u64 Parsed = 0; + AssertMessage("ParseInt assumes whole string is an integer"); + Precision = (s32)ParseInt(FormatAt, 10, &Parsed); + FormatAt += Parsed; + } + else if (FormatAt[0] == '*') + { + PrecisionSpecified = true; + Precision = va_arg(Args, s32); + Assert(Precision >= 0); + FormatAt++; + } + } + + // Length + b32 LengthSpecified = false; + s32 Length = 4; + + if (FormatAt[0] == 'h' && FormatAt[1] == 'h') + { + LengthSpecified = true; + LengthSpecified = 1; + FormatAt += 2; + } + else if (FormatAt[0] == 'h') + { + LengthSpecified = true; + LengthSpecified = 2; + FormatAt++; + } + else if (FormatAt[0] == 'l' && FormatAt[1] == 'l') + { + LengthSpecified = true; + LengthSpecified = 8; + FormatAt += 2; + } + else if (FormatAt[0] == 'l') + { + LengthSpecified = true; + LengthSpecified = 4; + FormatAt++; + } + else if (FormatAt[0] == 'j') + { + LengthSpecified = true; + LengthSpecified = 8; + FormatAt++; + } + else if (FormatAt[0] == 'z') + { + FormatAt++; + } + else if (FormatAt[0] == 't') + { + FormatAt++; + } + else if (FormatAt[0] == 'L') + { + FormatAt++; + } + + // Format Specifiers + gs_string StringRemaining = GetStringAfter(*String, String->Length); + Assert(StringRemaining.Length == 0); + if (FormatAt[0] == 'd' || FormatAt[0] == 'i') + { + s64 SignedInt = ReadVarArgsSignedInteger(Length, &Args); + if (SignedInt < 0) + { + OutChar(&StringRemaining, '-'); + SignedInt *= -1; + } + U64ToASCII(&StringRemaining, (u64)SignedInt, 10, Base10Chars); + } + else if (FormatAt[0] == 'u') + { + u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); + U64ToASCII(&StringRemaining, UnsignedInt, 10, Base10Chars); + } + else if (FormatAt[0] == 'o') + { + u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); + U64ToASCII(&StringRemaining, UnsignedInt, 8, Base8Chars); + } + else if (FormatAt[0] == 'x' || FormatAt[0] == 'X') + { + u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); + U64ToASCII(&StringRemaining, UnsignedInt, 16, Base16Chars); + } + else if (FormatAt[0] == 'f' || FormatAt[0] == 'F') + { + r64 Float = ReadVarArgsFloat(Length, &Args); + s32 AfterPoint = 6; + if (PrecisionSpecified) + { + AfterPoint = Precision; + } + R64ToASCII(&StringRemaining, Float, AfterPoint); + } + else if (FormatAt[0] == 'c') + { + char InsertChar = va_arg(Args, s32); + OutChar(&StringRemaining, InsertChar); + } + else if (FormatAt[0] == 's') + { + char* InsertString = va_arg(Args, char*); + + s32 InsertStringLength = CStringLength(InsertString); + if (PrecisionSpecified) + { + InsertStringLength = Min(InsertStringLength, Precision); + } + InsertStringLength = Min(StringSizeLeft(StringRemaining), InsertStringLength); + + for (s32 c = 0; c < InsertStringLength; c++) + { + OutChar(&StringRemaining, InsertString[c]); + } + } + else if (FormatAt[0] == 'S') + { + gs_const_string InsertString = va_arg(Args, gs_const_string); + + for (s32 c = 0; c < InsertString.Length; c++) + { + OutChar(&StringRemaining, InsertString.Str[c]); + } + } + else if (FormatAt[0] == 'p') + { + // TODO(Peter): Pointer Address + } + else + { + // NOTE(Peter): Non-specifier character found + InvalidCodePath; + } + + String->Length += StringRemaining.Length; + FormatAt++; + } + } + + return String->Length; +} + +internal void +PrintF (gs_string* String, char* Format, ...) +{ + va_list Args; + va_start(Args, Format); + String->Length = 0; + PrintFArgsList(String, Format, Args); + va_end(Args); +} +internal void +PrintF (gs_string* String, const char* Format, ...) +{ + // NOTE(Peter): This variant is here for clang/gcc - C++ spec doesn't allow + // implicit conversion from a const char* (a static c string) to char*, so this + // version of the function just provides the conversion so the compiler will be quiet + // without removing the other implementation, which is more useful + va_list Args; + va_start(Args, Format); + String->Length = 0; + PrintFArgsList(String, (char*)Format, Args); + va_end(Args); +} + +internal void +AppendPrintF (gs_string* String, char* Format, ...) +{ + va_list Args; + va_start(Args, Format); + PrintFArgsList(String, Format, Args); + va_end(Args); +} +internal void +AppendPrintF (gs_string* String, const char* Format, ...) +{ + // NOTE(Peter): This variant is here for clang/gcc - C++ spec doesn't allow + // implicit conversion from a const char* (a static c string) to char*, so this + // version of the function just provides the conversion so the compiler will be quiet + // without removing the other implementation, which is more useful + va_list Args; + va_start(Args, Format); + PrintFArgsList(String, (char*)Format, Args); + va_end(Args); +} + +/////////////////////////// +// +// Memory + +internal gs_data +CreateData(u8* Memory, u64 Size) +{ + gs_data Result = {Memory, Size}; + return Result; +} +internal bool +DataIsNonEmpty(gs_data Data) +{ + return ((Data.Size > 0) && (Data.Memory != 0)); +} + +internal void* AllocatorAlloc_NoOp(u64 Size, u64* SizeResult) { + *SizeResult = 0; + return 0; +} +internal void AllocatorFree_NoOp(void* Base, u64 Size) { return; } + +internal gs_allocator +CreateAllocator_(allocator_allocate* Alloc, allocator_free* Free) +{ + if (Alloc == 0) + { + Alloc = AllocatorAlloc_NoOp; + } + if (Free == 0) + { + Free = AllocatorFree_NoOp; + } + gs_allocator Result = {0}; + Result.Alloc = Alloc; + Result.Free = Free; + return Result; +} +#define CreateAllocator(a, f) CreateAllocator_((allocator_allocate*)(a), (allocator_free*)(f)) + +internal gs_data +AllocatorAlloc_(gs_allocator Allocator, u64 Size, char* Location) +{ + // TODO(Peter): Memory Profiling with Location + u64 SizeResult = 0; + void* Memory = Allocator.Alloc(Size, &SizeResult); + return CreateData((u8*)Memory, SizeResult); +} +internal void +AllocatorFree_(gs_allocator Allocator, void* Base, u64 Size, char* Location) +{ + // TODO(Peter): Memory Profiling with Location + if (Base != 0 && Size != 0) + { + Allocator.Free(Base, Size); + } +} + +#define AllocatorAlloc(alloc,size) AllocatorAlloc_((alloc), (size), FileNameAndLineNumberString) +#define AllocatorAllocStruct(alloc, type) (type*)(AllocatorAlloc((alloc), sizeof(type)).Memory) +#define AllocatorAllocArray(alloc, type, count) (type*)(AllocatorAlloc((alloc), sizeof(type) * (count)).Memory) +#define AllocatorAllocString(alloc, size) gs_string{ AllocatorAllocArray((alloc), char, (size)), 0, (size) } +#define AllocatorFree(alloc,base,size) AllocatorFree_((alloc), (base), (size), FileNameAndLineNumberString) +#define AllocatorFreeArray(alloc,base,type,count) AllocatorFree_((alloc), (base), sizeof(type) * count, FileNameAndLineNumberString) +internal gs_memory_cursor +CreateMemoryCursor(u8* Base, u64 Size) +{ + gs_memory_cursor Result = {0}; + Result.Data.Memory = Base; + Result.Data.Size = Size; + return Result; +}; +internal gs_memory_cursor +CreateMemoryCursor(gs_data Data) +{ + return CreateMemoryCursor(Data.Memory, Data.Size); +} +internal gs_memory_cursor +CreateMemoryCursor(gs_allocator Allocator, u64 Size) +{ + gs_data Data = AllocatorAlloc(Allocator, Size); + return CreateMemoryCursor(Data); +} +internal bool +CursorHasRoom(gs_memory_cursor Cursor, u64 Size) +{ + bool Result = ((Cursor.Position + Size) <= Cursor.Data.Size); + return Result; +} +internal gs_data +PushSizeOnCursor_(gs_memory_cursor* Cursor, u64 Size, char* Location) +{ + gs_data Result = {0}; + if (CursorHasRoom(*Cursor, Size)) + { + Result.Memory = Cursor->Data.Memory + Cursor->Position; + Result.Size = Size; + Cursor->Position += Size; + } + return Result; +} + +#define PushSizeOnCursor(cursor,size) PushSizeOnCursor_((cursor), (size), FileNameAndLineNumberString) +#define PushStructOnCursor(cursor,type) (type*)PushSizeOnCursor_((cursor), sizeof(type), FileNameAndLineNumberString).Memory +#define PushArrayOnCursor(cursor,type,count) (type*)PushSizeOnCursor_((cursor), sizeof(type) * (count), FileNameAndLineNumberString).Memory + +internal void +PopSizeOnCursor(gs_memory_cursor* Cursor, u64 Size) +{ + if (Cursor->Position > Size) + { + Cursor->Position -= Size; + } + else + { + Cursor->Position = 0; + } +} +internal gs_data +AlignCursor(gs_memory_cursor* Cursor, u64 Alignment) +{ + u64 Position = RoundUpTo64(Cursor->Position, Alignment); + Position = Min(Position, Cursor->Data.Size); + u64 NewSize = Position - Cursor->Position; + return PushSizeOnCursor(Cursor, NewSize); +} +internal void +ClearCursor(gs_memory_cursor* Cursor) +{ + Cursor->Position = 0; +} + +internal void +FreeCursorListEntry(gs_allocator Allocator, gs_memory_cursor_list* CursorEntry) +{ + AllocatorFree(Allocator, CursorEntry, CursorEntry->Cursor.Data.Size + sizeof(gs_memory_cursor)); +} + +internal gs_memory_arena +CreateMemoryArena_(arena_type ArenaType, gs_allocator Allocator, u64 ChunkSize, u64 Alignment, gs_memory_arena* ParentArena) +{ + // we only want a parent arena if the type is Arena_SubArena + Assert(((ArenaType == Arena_BaseArena) && (ParentArena == 0)) || + ((ArenaType == Arena_SubArena) && (ParentArena != 0))); + + gs_memory_arena Arena = {}; + Arena.Type = ArenaType; + Arena.Allocator = Allocator; + Arena.Parent = ParentArena; + Arena.MemoryChunkSize = ChunkSize; + Arena.MemoryAlignment = Alignment; + return Arena; +} + +internal gs_memory_arena +CreateMemoryArena(gs_allocator Allocator, u64 ChunkSize = KB(32), u64 Alignment = Bytes(8)) +{ + return CreateMemoryArena_(Arena_BaseArena, Allocator, ChunkSize, Alignment, 0); +} +internal gs_memory_arena +CreateMemorySubArena(gs_memory_arena* Parent, u64 ChunkSize = KB(32), u64 Alignment = Bytes(8)) +{ + return CreateMemoryArena_(Arena_SubArena, Parent->Allocator, ChunkSize, Alignment, Parent); +} + +internal gs_data PushSize_(gs_memory_arena* Arena, u64 Size, char* Location); + +internal void +FreeCursorList(gs_memory_cursor_list* List, gs_allocator Allocator) +{ + gs_memory_cursor_list* CursorAt = List; + while (CursorAt != 0) + { + gs_memory_cursor_list* Prev = CursorAt->Prev; + FreeCursorListEntry(Allocator, CursorAt); + CursorAt = Prev; + } +} + +internal gs_memory_cursor_list* +MemoryArenaNewCursor(gs_memory_arena* Arena, u64 MinSize, char* Location) +{ + // Allocate enough spcae for the minimum size needed + sizeo for the cursor list + u64 AllocSize = Max(MinSize, Arena->MemoryChunkSize) + sizeof(gs_memory_cursor_list); + + gs_data Data = {0}; + switch (Arena->Type) + { + case Arena_SubArena: + { + Data = PushSize_(Arena->Parent, AllocSize, Location); + }break; + + case Arena_BaseArena: + { + Data = AllocatorAlloc_(Arena->Allocator, AllocSize, Location); + }break; + + InvalidDefaultCase; + } + + // Fit the memory cursor into the region allocated + Assert(MinSize + sizeof(gs_memory_cursor_list) <= Data.Size); + gs_memory_cursor_list* Result = (gs_memory_cursor_list*)Data.Memory; + u8* CursorMemoryStart = (u8*)(Result + 1); + u64 CursorMemorySize = Data.Size - sizeof(gs_memory_cursor_list); + Result->Cursor = CreateMemoryCursor(CursorMemoryStart, CursorMemorySize); + + Result->Prev = Arena->CursorList; + Result->Next = 0; + if (Arena->CursorList != 0) + { + Arena->CursorList->Next = Result; + } + Arena->CursorList = Result; + return Result; +} + +internal gs_data +PushSize_(gs_memory_arena* Arena, u64 Size, char* Location) +{ + gs_data Result = {0}; + if (Size > 0) + { + gs_memory_cursor_list* CursorEntry = Arena->CursorList; + if (CursorEntry == 0) + { + CursorEntry = MemoryArenaNewCursor(Arena, Size, Location); + } + if (!CursorHasRoom(CursorEntry->Cursor, Size)) + { + while ((CursorEntry != 0) && !CursorHasRoom(CursorEntry->Cursor, Size)) + { + CursorEntry = CursorEntry->Next; + } + if (CursorEntry == 0) + { + CursorEntry = MemoryArenaNewCursor(Arena, Size, Location); + } + } + Assert(CursorEntry != 0); + Result = PushSizeOnCursor_(&CursorEntry->Cursor, Size, Location); + Assert(Result.Memory != 0); + + gs_data Alignment = AlignCursor(&CursorEntry->Cursor, Arena->MemoryAlignment); + Result.Size += Alignment.Size; + } + + // TODO(Peter): @Cleanup @Efficiency + // There is a case I want to handle at some point: + // You have a Cursor that is empty, but the size you want to allocate is bigger + // than the cursor. So you create a new cursor, of the exact size you need, + // immediately fill it up, and push it onto the head of the cursor list. Now, + // the list looks like this: + // [root] [cursor] ... [empty cursor] [full cursor] [new, empty cursor] + // and you'll never use the memory in 'empty cursor' + // What I'd like to do is, when you fill up a cursor, it gets pushed back until + // the next cursor is more full + // NOTE: Thought on this tho - you don't want this behavior in a scratch arena + // where usage across frames could change drastically. This matters way more in + // a permanent storage (i think) + return Result; +} + +internal void +PopSize(gs_memory_arena* Arena, u64 Size) +{ + gs_allocator Allocator = Arena->Allocator; + gs_memory_cursor_list* CursorEntry = Arena->CursorList; + for (gs_memory_cursor_list* Prev = 0; + CursorEntry != 0 && Size != 0; + CursorEntry = Prev) + { + Prev = CursorEntry->Prev; + if (Size >= CursorEntry->Cursor.Position) + { + Size -= CursorEntry->Cursor.Position; + FreeCursorListEntry(Allocator, CursorEntry); + } + else + { + PopSizeOnCursor(&CursorEntry->Cursor, Size); + break; + } + } + Arena->CursorList = CursorEntry; +} +internal void +FreeMemoryArena(gs_memory_arena* Arena) +{ + gs_allocator Allocator = Arena->Allocator; + gs_memory_cursor_list* CursorEntry = Arena->CursorList; + for (gs_memory_cursor_list* Prev = 0; + CursorEntry != 0; + CursorEntry = Prev) + { + Prev = CursorEntry->Prev; + if (CursorEntry != 0) + { + FreeCursorListEntry(Allocator, CursorEntry); + } + } +} + +#define PushSizeToData(arena, size) PushSize_((arena), (size), FileNameAndLineNumberString) +#define PushSize(arena, size) PushSize_((arena), (size), FileNameAndLineNumberString).Memory +#define PushStruct(arena, type) (type*)(PushSize_((arena), sizeof(type), FileNameAndLineNumberString).Memory) +#define PushArray(arena, type, count) (type*)(PushSize_((arena), sizeof(type) * (count), FileNameAndLineNumberString).Memory) +#define PushString(arena, length) MakeString(PushArray((arena), char, (length)), 0, (length)); + +internal void +ClearArena(gs_memory_arena* Arena) +{ + gs_memory_cursor_list* First = 0; + for (gs_memory_cursor_list* CursorEntry = Arena->CursorList; + CursorEntry != 0; + CursorEntry = CursorEntry->Prev) + { + First = CursorEntry; + CursorEntry->Cursor.Position = 0; + } + Arena->CursorList = First; +} + +internal void +FreeArena(gs_memory_arena* Arena) +{ + FreeCursorList(Arena->CursorList, Arena->Allocator); +} + +/////////////////////////// +// +// Debug Print + +inline void +DebugPrint(debug_output Output, gs_const_string Message) +{ + Output.Print(Output, Message); +} + +inline void +DebugPrint(debug_output Output, char* Message) +{ + gs_const_string String = ConstString(Message); + Output.Print(Output, String); +} + +internal void +DebugPrintF(debug_output Output, char* Format, ...) +{ + gs_string Message = PushString(Output.Storage, 1024); + va_list Args; + va_start(Args, Format); + PrintFArgsList(&Message, Format, Args); + NullTerminate(&Message); + Output.Print(Output, Message.ConstString); +} + +/////////////////////////// +// +// Dynamic Array + +internal gs_dynarray +CreateDynarrayWithStorage(gs_memory_arena Storage, u32 ElementSize, u32 ElementsPerBuffer) +{ + gs_dynarray Result = {}; + Result.Arena = Storage; + Result.ElementSize = ElementSize; + Result.ElementsPerBuffer = ElementsPerBuffer; + Result.ElementCount = 0; + return Result; +} + +internal gs_dynarray +CreateDynarray_(gs_allocator Allocator, u32 ElementSize, u32 ElementsPerBuffer) +{ + gs_memory_arena Storage = CreateMemoryArena(Allocator, ElementSize * ElementsPerBuffer); + return CreateDynarrayWithStorage(Storage, ElementSize, ElementsPerBuffer); +}; + +internal gs_dynarray +CreateDynarray_(gs_memory_arena* Arena, u32 ElementSize, u32 ElementsPerBuffer) +{ + gs_memory_arena Storage = CreateMemorySubArena(Arena, ElementSize * ElementsPerBuffer); + return CreateDynarrayWithStorage(Storage, ElementSize, ElementsPerBuffer); +}; + +internal u64 +CalculateBufferSize(gs_dynarray Array) +{ + u64 Result = Array.ElementsPerBuffer * Array.ElementSize; + return Result; +} + +internal void +GrowDynarray(gs_dynarray* Array) +{ + gs_dynarray_buffer* OldBufferList = Array->Buffers; + u64 NewBuffersCount = Array->BuffersCount + 1; + gs_dynarray_buffer* NewBufferList = AllocatorAllocArray(Array->Arena.Allocator, gs_dynarray_buffer, NewBuffersCount); + if (OldBufferList) + { + CopyArray(OldBufferList, NewBufferList, gs_dynarray_buffer, Array->BuffersCount); + AllocatorFree(Array->Arena.Allocator, OldBufferList, sizeof(gs_dynarray_buffer) * Array->BuffersCount); + } + u64 BufferSize = CalculateBufferSize(*Array); + NewBufferList[Array->BuffersCount].Memory = PushSize(&Array->Arena, BufferSize); + Array->Buffers = NewBufferList; + Array->BuffersCount = NewBuffersCount; +} +internal u64 +DynarraySize(gs_dynarray Array) +{ + u64 Result = Array.BuffersCount * Array.ElementsPerBuffer; + return Result; +} +internal gs_dynarray_handle +IndexToHandle(gs_dynarray* Array, u64 Index) +{ + gs_dynarray_handle Result = {0}; + Result.BufferIndex = Index / Array->ElementsPerBuffer; + Result.IndexInBuffer = Index % Array->ElementsPerBuffer; + return Result; +} +internal u64 +HandleToIndex(gs_dynarray Array, gs_dynarray_handle Handle) +{ + u64 Result = Handle.IndexInBuffer + (Handle.BufferIndex * Array.ElementsPerBuffer); + return Result; +} +internal gs_dynarray_handle +TakeFreeElement(gs_dynarray* Array) +{ + gs_dynarray_handle Result = {0}; + if (Array->ElementCount >= DynarraySize(*Array)) + { + GrowDynarray(Array); + } + Assert(Array->ElementCount < DynarraySize(*Array)); + u64 ElementIndex = Array->ElementCount++; + Result = IndexToHandle(Array, ElementIndex); + return Result; +} +internal bool +HandleIsValid(gs_dynarray Array, gs_dynarray_handle Handle) +{ + bool Result = Handle.IndexInBuffer < Array.ElementsPerBuffer; + Result &= Handle.BufferIndex < Array.BuffersCount; + return Result; +} +internal bool +IndexIsValid(gs_dynarray Array, u64 Index) +{ + bool Result = Index < DynarraySize(Array); + return Result; +} +internal gs_data +GetElementInList_(gs_dynarray* Array, gs_dynarray_handle Handle, u64 SizeRequested) +{ + Assert(SizeRequested == Array->ElementSize); + Assert(HandleIsValid(*Array, Handle)); + gs_dynarray_buffer Buffer = Array->Buffers[Handle.BufferIndex]; + + gs_data Result = {0}; + Result.Memory = Buffer.Memory + (Handle.IndexInBuffer * Array->ElementSize); + Result.Size = SizeRequested; + + return Result; +} +internal gs_data +GetElementInList_(gs_dynarray* Array, u64 Index, u64 SizeRequested) +{ + gs_dynarray_handle Handle = IndexToHandle(Array, Index); + return GetElementInList_(Array, Handle, SizeRequested); +} +internal void +FreeDynarray(gs_dynarray* Array) +{ + gs_allocator Allocator = Array->Arena.Allocator; + u64 BufferSize = CalculateBufferSize(*Array); + for (u64 i = 0; i < Array->BuffersCount; i++) + { + AllocatorFree(Allocator, Array->Buffers[i].Memory, BufferSize); + } + AllocatorFree(Allocator, Array->Buffers, sizeof(gs_dynarray_buffer) * Array->BuffersCount); +} + +#define HandlesAreEqual(ha, hb) ((ha.IndexInBuffer == hb.IndexInBuffer) && (ha.BufferIndex == hb.BufferIndex)) + +#define CreateDynarray(allocator,type,elePerBuf) CreateDynarray_((allocator), sizeof(type), (elePerBuf)) +#define GetElement_(array,type,size,indexOrHandle) (type*)GetElementInList_(array, indexOrHandle, size).Memory +#define GetElement(array,type,indexOrHandle) GetElement_(array, type, sizeof(type), indexOrHandle) + +/////////////////////////// +// +// String Builder + +internal void +GrowStringBuilder_(gs_string_builder* StringBuilder) +{ + gs_string_builder_buffer* NewBuffer = PushStruct(StringBuilder->Arena, gs_string_builder_buffer); + NewBuffer->String = PushString(StringBuilder->Arena, StringBuilder->BufferSize); + SLLPushOrInit(StringBuilder->Root, StringBuilder->Head, NewBuffer); +} + +internal void +OutChar(gs_string_builder* Builder, char C) +{ + if (Builder->Head == 0 || Builder->Head->String.Length >= Builder->Head->String.Size) + { + GrowStringBuilder_(Builder); + } + OutChar(&Builder->Head->String, C); +} + +#if 0 +// TODO: If you need a string builder come back here, otherwise this can stay 0'd out +// was getting in the way +internal void +StringBuilderWriteFArgsList(gs_string_builder* Builder, char* Format, va_list Args) +{ + char* FormatAt = Format; + while (*FormatAt) + { + if (FormatAt[0] != '%') + { + if (FormatAt[0] == '\\') + { + FormatAt++; + Assert(IsBase8(FormatAt[0]) || // Octal Escape Sequences - \0 is in this set + FormatAt[0] == '\'' || + FormatAt[0] == '\"' || + FormatAt[0] == '\?' || + FormatAt[0] == '\\' || + FormatAt[0] == 'a' || // Audible Bell + FormatAt[0] == 'b' || // Backspace + FormatAt[0] == 'f' || // Form Feed - New Page + FormatAt[0] == 'n' || // Line Feed - New Line + FormatAt[0] == 'r' || // Carriage Return + FormatAt[0] == 't' || // Tab + FormatAt[0] == 'v'); // Vertical Tab + + // Not Handled (see cpp spec) \nnn \xnn \unnnn \Unnnnnnnn + Assert(FormatAt[0] != 'x' || FormatAt[0] != 'u' || FormatAt[0] != 'U'); + + if (IsBase8(FormatAt[0])) + { + // TODO(Peter): this should keep going until it finds a non-octal character code + // but the only one we really need is \0 atm so I'm just handling that one + Assert(FormatAt[0] == '0'); + OutChar(Builder, (char)0); + FormatAt++; + } + else + { + OutChar(Builder, *FormatAt++); + } + } + else + { + OutChar(Builder, *FormatAt++); + } + } + else if (FormatAt[0] == '%' && FormatAt[1] == '%') // Print the % symbol + { + OutChar(Builder, '%'); + FormatAt += 2; + } + else + { + FormatAt++; + + // Flags + if (FormatAt[0] == '-') + { + FormatAt++; + } + else if (FormatAt[0] == '+') + { + FormatAt++; + } + else if (FormatAt[0] == ' ') + { + FormatAt++; + } + else if (FormatAt[0] == '#') + { + FormatAt++; + } + else if (FormatAt[0] == '0') + { + FormatAt++; + } + + // Width + b32 WidthSpecified = false; + s32 Width = 0; + + if (IsBase10(FormatAt[0])) + { + WidthSpecified = true; + u64 Parsed = 0; + AssertMessage("ParseInt assumes whole string is an integer"); + Width = (s32)ParseInt(FormatAt, 10, &Parsed); + FormatAt += Parsed; + } + else if (FormatAt[0] == '*') + { + WidthSpecified = true; + Width = va_arg(Args, s32); + Assert(Width >= 0); + FormatAt++; + } + + // Precision + b32 PrecisionSpecified = false; + s32 Precision = 0; + + if (FormatAt[0] == '.') + { + FormatAt++; + if (IsBase10(FormatAt[0])) + { + + PrecisionSpecified = true; + u64 Parsed = 0; + AssertMessage("ParseInt assumes whole string is an integer"); + Precision = (s32)ParseInt(FormatAt, 10, &Parsed); + FormatAt += Parsed; + } + else if (FormatAt[0] == '*') + { + PrecisionSpecified = true; + Precision = va_arg(Args, s32); + Assert(Precision >= 0); + FormatAt++; + } + } + + // Length + b32 LengthSpecified = false; + s32 Length = 4; + + if (FormatAt[0] == 'h' && FormatAt[1] == 'h') + { + LengthSpecified = true; + LengthSpecified = 1; + FormatAt += 2; + } + else if (FormatAt[0] == 'h') + { + LengthSpecified = true; + LengthSpecified = 2; + FormatAt++; + } + else if (FormatAt[0] == 'l' && FormatAt[1] == 'l') + { + LengthSpecified = true; + LengthSpecified = 8; + FormatAt += 2; + } + else if (FormatAt[0] == 'l') + { + LengthSpecified = true; + LengthSpecified = 4; + FormatAt++; + } + else if (FormatAt[0] == 'j') + { + LengthSpecified = true; + LengthSpecified = 8; + FormatAt++; + } + else if (FormatAt[0] == 'z') + { + FormatAt++; + } + else if (FormatAt[0] == 't') + { + FormatAt++; + } + else if (FormatAt[0] == 'L') + { + FormatAt++; + } + + // Format Specifiers + gs_string StringRemaining = GetStringAfter(*String, String->Length); + Assert(StringRemaining.Length == 0); + if (FormatAt[0] == 'd' || FormatAt[0] == 'i') + { + s64 SignedInt = ReadVarArgsSignedInteger(Length, &Args); + if (SignedInt < 0) + { + OutChar(&StringRemaining, '-'); + SignedInt *= -1; + } + U64ToASCII(&StringRemaining, (u64)SignedInt, 10, Base10Chars); + } + else if (FormatAt[0] == 'u') + { + u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); + U64ToASCII(&StringRemaining, UnsignedInt, 10, Base10Chars); + } + else if (FormatAt[0] == 'o') + { + u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); + U64ToASCII(&StringRemaining, UnsignedInt, 8, Base8Chars); + } + else if (FormatAt[0] == 'x' || FormatAt[0] == 'X') + { + u32 UnsignedInt = ReadVarArgsUnsignedInteger(Length, &Args); + U64ToASCII(&StringRemaining, UnsignedInt, 16, Base16Chars); + } + else if (FormatAt[0] == 'f' || FormatAt[0] == 'F') + { + r64 Float = ReadVarArgsFloat(Length, &Args); + s32 AfterPoint = 6; + if (PrecisionSpecified) + { + AfterPoint = Precision; + } + R64ToASCII(&StringRemaining, Float, AfterPoint); + } + else if (FormatAt[0] == 'c') + { + char InsertChar = va_arg(Args, s32); + OutChar(&StringRemaining, InsertChar); + } + else if (FormatAt[0] == 's') + { + char* InsertString = va_arg(Args, char*); + + s32 InsertStringLength = CStringLength(InsertString); + if (PrecisionSpecified) + { + InsertStringLength = Min(InsertStringLength, Precision); + } + InsertStringLength = Min(StringSizeLeft(StringRemaining), InsertStringLength); + + for (s32 c = 0; c < InsertStringLength; c++) + { + OutChar(&StringRemaining, InsertString[c]); + } + } + else if (FormatAt[0] == 'S') + { + gs_const_string InsertString = va_arg(Args, gs_const_string); + + for (s32 c = 0; c < InsertString.Length; c++) + { + OutChar(&StringRemaining, InsertString.Str[c]); + } + } + else if (FormatAt[0] == 'p') + { + // TODO(Peter): Pointer Address + } + else + { + // NOTE(Peter): Non-specifier character found + InvalidCodePath; + } + + String->Length += StringRemaining.Length; + FormatAt++; + } + } + + return String->Length; +} + +internal void +StringBuilderWriteF(gs_string_builder* Builder, char* Format, ...) +{ + va_list Args; + va_start(Args, Format); + StringBuilderWriteFArgsList(Builder, Format, Args); + va_end(Args); +} + +#endif // String builder + +/////////////////////////// +// +// File Handler + +internal u64 +FileHandlerGetFileInfo_NoOp(gs_file_handler FileHandler, gs_const_string Path) +{ + return 0; +} + +internal gs_file +FileHandlerReadFile_NoOp(gs_const_string Path) +{ + return gs_file{0}; +} + +internal bool +FileHandlerWriteFile_NoOp(gs_const_string Path, gs_data Data) +{ + return false; +} + +internal gs_const_string_array +FileHandlerEnumerateDirectory_NoOp(gs_const_string Path, bool Recursive, bool IncludeDirs) +{ + return gs_const_string_array{0}; +} + +internal gs_file_handler +CreateFileHandler(file_handler_get_file_info* GetFileInfo, + file_handler_read_entire_file* ReadEntireFile, + file_handler_write_entire_file* WriteEntireFile, + file_handler_enumerate_directory* EnumerateDirectory, + gs_memory_arena* Transient) +{ + if (GetFileInfo == 0) + { + GetFileInfo = (file_handler_get_file_info*)FileHandlerGetFileInfo_NoOp; + } + if (ReadEntireFile == 0) + { + ReadEntireFile = (file_handler_read_entire_file*)FileHandlerReadFile_NoOp; + } + if (WriteEntireFile == 0) + { + WriteEntireFile = (file_handler_write_entire_file*)FileHandlerWriteFile_NoOp; + } + if (EnumerateDirectory == 0) + { + EnumerateDirectory = (file_handler_enumerate_directory*)FileHandlerEnumerateDirectory_NoOp; + } + gs_file_handler Result = {0}; + Result.GetFileInfo = GetFileInfo; + Result.ReadEntireFile = ReadEntireFile; + Result.WriteEntireFile = WriteEntireFile; + Result.EnumerateDirectory = EnumerateDirectory; + Result.Transient = Transient; + + return Result; +} + +internal gs_const_string +GetNullTerminatedPath(gs_file_handler FileHandler, gs_const_string Path) +{ + gs_const_string NullTermPath = Path; + if (!IsNullTerminated(NullTermPath)) + { + AssertMessage("need to allocate a new string, Path to it, and null terminate"); + // TODO(Peter): Probably want to have some sort of temp memory, + // or be passing in a thread context, etc. + } + return NullTermPath; +} + +internal gs_file_info +GetFileInfo(gs_file_handler FileHandler, gs_const_string Path) +{ + Assert(FileHandler.GetFileInfo != 0); + + Path = GetNullTerminatedPath(FileHandler, Path); + gs_file_info Result = FileHandler.GetFileInfo(FileHandler, Path); + return Result; +} + +internal gs_file +ReadEntireFile(gs_file_handler FileHandler, gs_const_string Path, gs_data Memory) +{ + Assert(FileHandler.ReadEntireFile != 0); + + Path = GetNullTerminatedPath(FileHandler, Path); + gs_file Result = FileHandler.ReadEntireFile(FileHandler, Path, Memory); + return Result; +} + +internal gs_file +ReadEntireFile(gs_file_handler FileHandler, gs_const_string Path) +{ + Assert(FileHandler.GetFileInfo != 0); + Assert(FileHandler.ReadEntireFile != 0); + + Path = GetNullTerminatedPath(FileHandler, Path); + gs_file Result = {0}; + gs_file_info FileInfo = FileHandler.GetFileInfo(FileHandler, Path); + if (FileInfo.FileSize > 0) + { + gs_data FileMemory = PushSizeToData(FileHandler.Transient, FileInfo.FileSize); + Result = ReadEntireFile(FileHandler, Path, FileMemory); + } + return Result; +} + +internal bool +WriteEntireFile(gs_file_handler FileHandler, gs_const_string Path, gs_data Memory) +{ + Assert(FileHandler.WriteEntireFile != 0); + + Path = GetNullTerminatedPath(FileHandler, Path); + return FileHandler.WriteEntireFile(FileHandler, Path, Memory); +} + +internal gs_file_info_array +EnumerateDirectory(gs_file_handler FileHandler, gs_memory_arena* Storage, gs_const_string Path, u32 Flags) +{ + Assert(FileHandler.EnumerateDirectory != 0); + + Path = GetNullTerminatedPath(FileHandler, Path); + return FileHandler.EnumerateDirectory(FileHandler, Storage, Path, Flags); +} + +internal bool +FileNoError(gs_file File) +{ + bool Result = (File.Size > 0); + return Result; +} + +////////////////////////// +// +// Timing + +internal s64 +TimeHandlerGetWallClock(gs_time_handler TimeHandler) +{ + s64 Result = TimeHandler.GetWallClock(); + return Result; +} + +internal s64 +TimeHandlerGetSecondsElapsed(gs_time_handler TimeHandler, s64 StartCycles, s64 EndCycles) +{ + s64 Result = TimeHandler.GetSecondsElapsed(StartCycles, EndCycles); + return Result; +} + +/////////////////////////// +// +// Hashes + +internal u32 +HashDJB2ToU32(char* String) +{ + u32 Hash = 5381; + char* C = String; + while(*C) + { + Hash = ((Hash << 5) + Hash) + *C++; + } + return Hash; +} +internal u32 +HashDJB2ToU32(u32 Length, char* String) +{ + u32 Hash = 5381; + for (u32 i = 0; i < Length; i++) + { + Hash = ((Hash << 5) + Hash) + String[i]; + } + return Hash; +} + +internal u64 +HashDJB2ToU64(char* String) +{ + u64 Hash = 5381; + char* C = String; + while(*C) + { + Hash = ((Hash << 5) + Hash) + *C++; + } + return Hash; +} +internal u64 +HashDJB2ToU64(u32 Length, char* String) +{ + u64 Hash = 5381; + for (u32 i = 0; i < Length; i++) + { + Hash = ((Hash << 5) + Hash) + String[i]; + } + return Hash; +} + +/////////////////////////// +// +// Random Series + +internal gs_random_series +InitRandomSeries(u32 Seed) +{ + gs_random_series Result = {0}; + Result.Value = Seed; + return Result; +} + +internal u32 +NextRandom(gs_random_series* Series) +{ + u32 Result = Series->Value; + Result ^= Result << 13; + Result ^= Result >> 17; + Result ^= Result << 5; + Series->Value = Result; + return Result; +} + +internal r32 +NextRandomUnilateral(gs_random_series* Series) +{ + r32 Result = (r32)NextRandom(Series) / (r32)UINT32_MAX; + return Result; +} + +internal r32 +NextRandomBilateral(gs_random_series* Series) +{ + r32 Result = (r32)NextRandom(Series); + Result = Result / (r32)0xFFFFFFFF; + Result = (Result * 2.0f) - 1.0f; + return Result; +} + + +/////////////////////////// +// +// Sort + + +static void +RadixSortInPlace_ (gs_radix_list* List, u32 Start, u32 End, u32 Iteration) +{ + u32 Shift = Iteration; + u32 ZerosBoundary = Start; + u32 OnesBoundary = End - 1; + + for (u32 d = Start; d < End; d++) + { + u64 CurrentIndex = ZerosBoundary; + u64 Radix = List->Radixes.Values[CurrentIndex]; + u64 Place = (Radix >> Shift) & 0x1; + if (Place) + { + u64 EvictedIndex = OnesBoundary; + u64 EvictedRadix = List->Radixes.Values[EvictedIndex]; + u64 EvictedID = List->IDs.Values[EvictedIndex]; + + List->Radixes.Values[EvictedIndex] = Radix; + List->IDs.Values[EvictedIndex] = List->IDs.Values[CurrentIndex]; + + List->Radixes.Values[CurrentIndex] = EvictedRadix; + List->IDs.Values[CurrentIndex] = EvictedID; + + OnesBoundary -= 1; + } + else + { + ZerosBoundary += 1; + } + } + + if (Iteration > 0) + { + RadixSortInPlace_(List, Start, ZerosBoundary, Iteration - 1); + RadixSortInPlace_(List, ZerosBoundary, End, Iteration - 1); + } +} + +static void +RadixSortInPlace (gs_radix_list* List) +{ + u32 Highest = 0; + for (u32 i = 0; i < List->Radixes.Count; i++) + { + if (List->Radixes.Values[i] > Highest) + { + Highest = List->Radixes.Values[i]; + } + } + + u32 Iterations = 0; + while (Highest > 1) + { + ++Iterations; + Highest = Highest >> 1; + } + + RadixSortInPlace_(List, 0, List->Radixes.Count, Iterations); +} + + +/////////////////////////// +// +// Input + +inline bool +KeyIsMouseButton(gs_key Key) +{ + bool Result = (Key >= gs_Key_MouseLeftButton); + Result = Result && Key <= gs_Key_MouseRightButton; + return Result; +} +inline u32 +GetMouseButtonIndex(gs_key Button) +{ + Assert(KeyIsMouseButton(Button)); + u32 Result = Button - gs_Key_MouseLeftButton; + return Result; +} +inline bool +MouseButtonTransitionedDown(gs_mouse_state Mouse, u32 Index) +{ + bool IsDown = (Mouse.ButtonStates[Index] & (1 << MouseButton_IsDownBit)) != 0; + bool WasDown = (Mouse.ButtonStates[Index] & (1 << MouseButton_WasDownBit)) != 0; + return IsDown && !WasDown; +} +inline bool +MouseButtonTransitionedDown(gs_mouse_state Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + return MouseButtonTransitionedDown(Mouse, Index); +} +inline bool +MouseButtonIsDown(gs_mouse_state Mouse, u32 Index) +{ + bool IsDown = (Mouse.ButtonStates[Index] & (1 << MouseButton_IsDownBit)) != 0; + return IsDown; +} +inline bool +MouseButtonIsDown(gs_mouse_state Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + return MouseButtonIsDown(Mouse, Index); +} +inline bool +MouseButtonTransitionedUp(gs_mouse_state Mouse, u32 Index) +{ + bool IsDown = (Mouse.ButtonStates[Index] & (1 << MouseButton_IsDownBit)) != 0; + bool WasDown = (Mouse.ButtonStates[Index] & (1 << MouseButton_WasDownBit)) != 0; + return !IsDown && WasDown; +} +inline bool +MouseButtonTransitionedUp(gs_mouse_state Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + return MouseButtonTransitionedUp(Mouse, Index); +} +inline bool +MouseButtonIsUp(gs_mouse_state Mouse, u32 Index) +{ + bool IsDown = (Mouse.ButtonStates[Index] & (1 << MouseButton_IsDownBit)) != 0; + return !IsDown; +} +inline bool +MouseButtonIsUp(gs_mouse_state Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + return MouseButtonIsUp(Mouse, Index); +} +internal void +SetMouseButtonTransitionedDown(gs_mouse_state* Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + + Mouse->ButtonStates[Index] = 0; + Mouse->ButtonStates[Index] |= MouseButton_IsDown << MouseButton_IsDownBit; + Mouse->ButtonStates[Index] |= MouseButton_WasNotDown << MouseButton_WasDownBit; +} +internal void +SetMouseButtonTransitionedUp(gs_mouse_state* Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + + Mouse->ButtonStates[Index] = 0; + Mouse->ButtonStates[Index] |= MouseButton_IsNotDown << MouseButton_IsDownBit; + Mouse->ButtonStates[Index] |= MouseButton_WasDown << MouseButton_WasDownBit; +} +internal void +AdvanceMouseButtonState(gs_mouse_state* Mouse, gs_key Button) +{ + u32 Index = GetMouseButtonIndex(Button); + + if (MouseButtonIsDown(*Mouse, Index)) + { + Mouse->ButtonStates[Index] |= MouseButton_WasDown << MouseButton_WasDownBit; + } + else + { + Mouse->ButtonStates[Index] &= MouseButton_WasNotDown << MouseButton_WasDownBit; + } +} +internal void +AdvanceMouseButtonsState(gs_mouse_state* Mouse) +{ + AdvanceMouseButtonState(Mouse, gs_Key_MouseLeftButton); + AdvanceMouseButtonState(Mouse, gs_Key_MouseMiddleButton); + AdvanceMouseButtonState(Mouse, gs_Key_MouseRightButton); +} + +/////////////////////////// +// +// Network + + +static u32 +HostToNetU32(u32 In) +{ + unsigned char *s = (unsigned char *)&In; + u32 Result = (u32)(s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]); + return Result; +} + +static u16 +HostToNetU16(u16 In) +{ + unsigned char *s = (unsigned char *)&In; + u16 Result = (u16)(s[0] << 8 | s[1]); + return Result; +} + + + + + + + + + + +#define GS_TYPES_CPP +#endif // GS_TYPES_CPP \ No newline at end of file diff --git a/src/gs_libs/gs_types.h b/src/gs_libs/gs_types.h new file mode 100644 index 0000000..8a9736e --- /dev/null +++ b/src/gs_libs/gs_types.h @@ -0,0 +1,1053 @@ +// +// File: gs_types.h +// Author: Peter Slattery +// Creation Date: 2020-04-18 +// +#ifndef GS_TYPES_H + +#if defined(__clang__) +# pragma GCC diagnostic ignored "-Wunused-value" +# pragma GCC diagnostic ignored "-Wvarargs" +# pragma GCC diagnostic ignored "-Wwritable-strings" +#endif + +#if defined(_MSC_VER) +# include +#endif + +// Someday, we home to remove these includes +#include +#if !defined(GUESS_INTS) +# include +#endif // !defined(GUESS_INTS) + +#include + +#define Glue_(a,b) a##b +#define Glue(a,b) Glue_(a,b) + +#define Stringify_(a) #a +#define Stringify(a) Stringify_(a) + +#define internal static +#define local_persist static +#define global static +#define local_const static const +#define global_const static const +#define external extern "C" + +#if defined(GUESS_INTS) +typedef signed char s8; +typedef signed short s16; +typedef signed int s32; +typedef signed long long s64; +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; +#else +typedef int8_t s8; +typedef int16_t s16; +typedef int32_t s32; +typedef int64_t s64; +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; +#endif + +typedef s8 b8; +typedef s32 b32; +typedef s64 b64; + +typedef float r32; +typedef double r64; + +enum gs_basic_type +{ + gs_BasicType_char, + gs_BasicType_b8, + gs_BasicType_b32, + gs_BasicType_b64, + gs_BasicType_u8, + gs_BasicType_u16, + gs_BasicType_u32, + gs_BasicType_u64, + gs_BasicType_s8, + gs_BasicType_s16, + gs_BasicType_s32, + gs_BasicType_s64, + gs_BasicType_r32, + gs_BasicType_r64, + + gs_BasicType_Count, +}; + +global_const u64 gs_BasicTypeSizes[] = +{ + sizeof(char), + sizeof(b8), + sizeof(b32), + sizeof(b64), + sizeof(u8), + sizeof(u16), + sizeof(u32), + sizeof(u64), + sizeof(s8), + sizeof(s16), + sizeof(s32), + sizeof(s64), + sizeof(r32), + sizeof(r64), +}; + +internal u64 +BasicTypeSize(gs_basic_type Type) +{ + return gs_BasicTypeSizes[(u32)Type]; +} + +global_const u8 MaxU8 = 0xFF; +global_const u16 MaxU16 = 0xFFFF; +global_const u32 MaxU32 = 0xFFFFFFFF; +global_const u64 MaxU64 = 0xFFFFFFFFFFFFFFFF; + +global_const s8 MaxS8 = 127; +global_const s16 MaxS16 = 32767; +global_const s32 MaxS32 = 2147483647; +global_const s64 MaxS64 = 9223372036854775807; + +global_const s8 MinS8 = -127 - 1; +global_const s16 MinS16 = -32767 - 1; +global_const s32 MinS32 = -2147483647 - 1; +global_const s64 MinS64 = -9223372036854775807 - 1; + +global_const r32 MaxR32 = 3.402823466e+38f; +global_const r32 MinR32 = -MaxR32; +global_const r32 SmallestPositiveR32 = 1.1754943508e-38f; +global_const r32 EpsilonR32 = 5.96046448e-8f; + +global_const r32 PiR32 = 3.14159265359f; +global_const r32 HalfPiR32 = 1.5707963267f; +global_const r32 TauR32 = 6.28318530717f; + +global_const r64 MaxR64 = 1.79769313486231e+308; +global_const r64 MinR64 = -MaxR64; +global_const r64 SmallestPositiveR64 = 4.94065645841247e-324; +global_const r64 EpsilonR64 = 1.11022302462515650e-16; + +// TODO: va_start and va_arg replacements + +internal r32 +DegToRadR32(r32 Degrees) +{ + return (Degrees * (PiR32 / 180.0f)); +} + +internal r32 +RadToDegR32(r32 Radians) +{ + return (Radians * (180.0f / PiR32)); +} + +struct s8_array +{ + s8* Values; + u32 Count; + u32 CountMax; +}; + +struct s16_array +{ + s16* Values; + u32 Count; + u32 CountMax; +}; + +struct s32_array +{ + s32* Values; + u32 Count; + u32 CountMax; +}; + +struct s64_array +{ + s64* Values; + u32 Count; + u32 CountMax; +}; + +struct u8_array +{ + u8* Values; + u32 Count; + u32 CountMax; +}; + +struct u16_array +{ + u16* Values; + u32 Count; + u32 CountMax; +}; + +struct u32_array +{ + u32* Values; + u32 Count; + u32 CountMax; +}; + +struct u64_array +{ + u64* Values; + u32 Count; + u32 CountMax; +}; + + +#define PointerDifference(a,b) ((u8*)(a) - (u8*)(b)) +#define PointerToInt(a) PointerDifference(a, 0) +#define Member(type,member) (((type*)0)->member) +#define MemberOffset(type,member) PointerToInt(&Member(type,member)) + +// NOTE(Peter): Makes sure that s doesn't expand in some way that invalidates +// a nested if statement. +#define Statement(s) do{ s }while(0) + +// +// Asserts +// +// AssertAlways and AssertMessageAlways should be used sparingly, because they'll +// still assert in the final build +#define AssertBreak(m) (*((volatile s32*)0) = 0xFFFF) +#define AssertAlways(c) Statement( if (!(c)) { AssertBreak(c); } ) +#define AssertMessageAlways(m) AssertBreak(m) + +#if !SHIP_MODE +# define Assert(c) AssertAlways(c) +# define AssertMessage(m) AssertBreak(m) +# define InvalidDefaultCase default: { AssertBreak("invalid default case"); } break; +# define StaticAssert(c) \ +enum { \ +Glue(gs_AssertFail_, __LINE__) = 1 / (int)(!!(c)), \ +} +#else +# define Assert(c) +# define AssertMessage(m) +# define InvalidDefaultCase default: {} break; +# define StaticAssert(c) +#endif + +#define AssertImplies(a,b) Statement(if(a) { Assert(b); }) +#define InvalidCodePath AssertMessage("invalid code path") +#define NotImplemented AssertMessage("not implemented") +#define DontCompile ImAfraidICantDoThat + +#define LineNumberString Stringify(__LINE__) +#define FileNameAndLineNumberString_ __FILE__ ":" LineNumberString ":" +#define FileNameAndLineNumberString (char*)FileNameAndLineNumberString_ + +// + +#define Bytes(x) (x) +#define KB(x) ((x) << 10) +#define MB(x) ((x) << 20) +#define GB(x) ((x) << 30) +#define TB(x) (((u64)x) << 40) + +#define HasFlag(data, flag) (((data) & (flag)) != 0) +#define HasFlagOnly(data, flag) (((data) & (flag)) == (data)) +#define AddFlag(data, flag) ((data) |= (flag)) +#define RemoveFlag(data, flag) ((data) &= (~(flag))) + +#define Max(a,b) (((a) > (b)) ? (a) : (b)) +#define Min(a,b) (((a) > (b)) ? (b) : (a)) +#define Clamp_(a,x,b) ((x < a) ? a : ((x > b) ? b : x)) +#define Clamp(a,x,b) Clamp_((a), (x), (b)) +#define Clamp01(x) Clamp_(0.0f, (x), 1.0f) +#define Abs(x) (((x) < 0) ? ((x) * -1) : x) +#define Sign(x) ((x) < 0) ? -1 : 1; +#define IsPowerOfTwo(x) (((x) & ((x) - 1)) == 0) +#define IsOdd(x) (((x) & 1) != 0) + +internal void +ZeroMemory_(u8* Memory, u64 Size) +{ + for (u64 i = 0; i < Size; i++) + { + Memory[i] = 0; + } +} + +internal void +CopyMemory_(u8* From, u8* To, u64 Size) +{ + for (u64 i = 0; i < Size; i++) + { + To[i] = From[i]; + } +} + +#define StaticArrayLength(arr) sizeof(arr) / sizeof((arr)[0]) +#define ZeroMemoryBlock(mem,size) ZeroMemory_((u8*)(mem), (size)) +#define ZeroStruct(str) ZeroMemory_((str), sizeof(str)) +#define ZeroArray(arr, type, count) ZeroMemory_((u8*)(arr), sizeof(type) * (count)) + +#define CopyArray(from, to, type, count) CopyMemory_((u8*)(from), (u8*)(to), sizeof(type) * (count)) +#define CopyMemoryTo(from, to, size) CopyMemory_((u8*)(from), (u8*)(to), (size)) +// Singly Linked List Utilities + +#define SLLPush_(list_tail,new_ele) list_tail->Next = new_ele, list_tail = new_ele +#define SLLPush(list_tail,new_ele) (SLLPush_((list_tail), (new_ele))) + +#define SLLPop_(list_tail) list_tail=list_tail=list_tail->next +#define SLLPop(list_tail) (SLLPop_((list_tail))) + +#define SLLNext(ele_at) ele_at = ele_at->Next; +#define SLLPrev(ele_at) ele_at = ele_at->Prev; + +#define SLLInit(head,tail,first_ele) head=first_ele, tail=first_ele; + +#define SLLPushOrInit(first,last,new_ele) \ +if (last) { SLLPush(last, new_ele); } \ +else { SLLInit(first,last,new_ele); } + +// Vectors + +union v2 +{ + struct + { + r32 x; + r32 y; + }; + r32 E[2]; +}; + +union v3 +{ + struct + { + r32 x; + r32 y; + r32 z; + }; + struct + { + r32 r; + r32 g; + r32 b; + }; + struct + { + v2 xy; + r32 _z0; + }; + struct + { + r32 _x0; + v2 yz; + }; + r32 E[3]; +}; + +union v4 +{ + struct + { + r32 x; + r32 y; + r32 z; + r32 w; + }; + struct + { + r32 r; + r32 g; + r32 b; + r32 a; + }; + struct + { + v2 xy; + v2 zw; + }; + struct + { + r32 _x0; + v2 yz; + r32 _w0; + }; + struct + { + v3 xyz; + r32 _w1; + }; + r32 E[4]; +}; + +struct v4_ray +{ + v4 Origin; + v4 Direction; +}; + +#define WhiteV4 v4{1, 1, 1, 1} +#define BlackV4 v4{0, 0, 0, 1} +#define RedV4 v4{1, 0, 0, 1} +#define GreenV4 v4{0, 1, 0, 1} +#define BlueV4 v4{0, 0, 1, 1} +#define YellowV4 v4{1, 1, 0, 1} +#define TealV4 v4{0, 1, 1, 1} +#define PinkV4 v4{1, 0, 1, 1} + +#define V2Expand(v) v.x, v.y +#define V3Expand(v) v.x, v.y, v.z +#define V4Expand(v) v.x, v.y, v.z, v.w + +struct v2_array +{ + v2* Vectors; + u32 Count; + u32 CountMax; +}; + +struct v3_array +{ + v3* Vectors; + u32 Count; + u32 CountMax; +}; + +struct v4_array +{ + v4* Vectors; + u32 Count; + u32 CountMax; +}; + +struct range1 +{ + r32 Min; + r32 Max; +}; + +struct range2 +{ + v2 Min; + v2 Max; +}; +typedef range2 rect2; + +struct range3 +{ + v3 Min; + v3 Max; +}; + +struct range4 +{ + v4 Min; + v4 Max; +}; + +struct range1_array +{ + range1* Ranges; + u32 Count; + u32 CountMax; +}; + +struct range2_array +{ + range2* Ranges; + u32 Count; + u32 CountMax; +}; + +struct range3_array +{ + range3* Ranges; + u32 Count; + u32 CountMax; +}; + +struct range4_array +{ + range4* Ranges; + u32 Count; + u32 CountMax; +}; + +#define Range1Expand(r) (r).Min, (r).Max +#define Range2Expand(r) (r).Min, (r).Max +#define Rect2Expand(r) (r).Min (r).Max +#define Range3Expand(r) (r).Min, (r).Max +#define Range4Expand(r) (r).Min, (r).Max + +// Matrices +// NOTE(Peter): All matrices are stored in row major order + +union m33 +{ + float Array[9]; + struct + { + r32 AXx; r32 AYx; r32 AZx; + r32 AXy; r32 AYy; r32 AZy; + r32 AXz; r32 AYz; r32 AZz; + }; +}; + +union m44 +{ + float Array[16]; + struct + { + r32 AXx; r32 AYx; r32 AZx; r32 Tx; + r32 AXy; r32 AYy; r32 AZy; r32 Ty; + r32 AXz; r32 AYz; r32 AZz; r32 Tz; + r32 AXw; r32 AYw; r32 AZw; r32 Tw; + }; +}; + +struct m33_array +{ + m33* Matrices; + u32 Count; + u32 CountMax; +}; + +struct m44_array +{ + m44* Matrices; + u32 Count; + u32 CountMax; +}; + +////////////////////////// +// +// Strings + +struct gs_const_string +{ + union + { + char* Str; + u8* Data;; + }; + u64 Length; +}; + +struct gs_string +{ + union + { + gs_const_string ConstString; + struct + { + char* Str; + u64 Length; + }; + }; + u64 Size; +}; + +struct gs_const_string_array +{ + gs_const_string* Strings; + u64 Count; + u64 Used; +}; + +struct gs_string_array +{ + gs_string* Strings; + u64 Count; + u64 CountMax; +}; + +internal u64 +CStringLength(char* Str) +{ + char* At = Str; + while (*At) { At++; } + return PointerDifference(At, Str); +} + +#define StringExpand(str) (int)(str).Length, (str).Str +#define LitString(cstr) gs_const_string{(char*)(cstr), CStringLength((char*)cstr) } + +// The index of the character in these arrays corresponds to its value as a number in +// the relevant base, so you can do FindFirst on them with a char to get the int value +// ie. 3 is at index 3 in Base10Chars. +// ie. C is at index 12 in Base16Chars. +global_const gs_const_string Base8Chars = LitString("01234567"); +global_const gs_const_string Base10Chars = LitString("0123456789"); +global_const gs_const_string Base16Chars = LitString("0123456789ABCDEF"); + +////////////////////////// +// +// Thread Context + +typedef struct gs_thread_context gs_thread_context; + +////////////////////////// +// +// Memory + +struct gs_data +{ + u8* Memory; + u64 Size; +}; + +struct gs_data_array +{ + gs_data* Data; + u64 Count; + u64 CountMax; +}; + +enum gs_access_flag +{ + gs_AccessFlag_Read = 1 << 0, + gs_AccessFlag_Write = 1 << 1, + gs_AccessFlag_Exec = 1 << 2, +}; + +typedef s32 gs_scan_direction; +enum +{ + gs_Scan_Backward = -1, + gs_Scan_Forward = 1, +}; + +#define ALLOCATOR_ALLOC(name) void* name(u64 Size, u64* ResultSize) +typedef ALLOCATOR_ALLOC(allocator_allocate); + +#define ALLOCATOR_FREE(name) void name(void* Ptr, u64 Size) +typedef ALLOCATOR_FREE(allocator_free); + +struct gs_allocator +{ + allocator_allocate* Alloc; + allocator_free* Free; +}; + +struct gs_memory_cursor +{ + gs_data Data; + u64 Position; +}; + +struct gs_memory_cursor_list +{ + gs_memory_cursor Cursor; + gs_memory_cursor_list* Next; + gs_memory_cursor_list* Prev; +}; + +enum arena_type +{ + Arena_BaseArena, + Arena_SubArena, +}; + +struct gs_memory_arena +{ + arena_type Type; + gs_allocator Allocator; + gs_memory_arena* Parent; + + gs_memory_cursor_list* CursorList; + u64 MemoryChunkSize; + u64 MemoryAlignment; +}; + +struct gs_memory_arena_array +{ + gs_memory_arena* Arenas; + u32 Count; + u32 Size; +}; + +/////////////////////////////// +// +// String Builder +// + +struct gs_string_builder_buffer +{ + gs_string String; + gs_string_builder_buffer* Next; +}; + +struct gs_string_builder +{ + gs_memory_arena* Arena; + u32 BufferSize; + gs_string_builder_buffer* Root; + gs_string_builder_buffer* Head; +}; + +/////////////////////////////// +// +// Debug Output +// + +typedef struct debug_output debug_output; + +#define DEBUG_PRINT(name) void name(debug_output Output, gs_const_string Message) +typedef DEBUG_PRINT(debug_print); + +struct debug_output +{ + gs_memory_arena* Storage; + debug_print* Print; +}; + +/////////////////////////////// +// +// Dynamic Array +// +// I like having constant lookup times, along with growable arrays. :) +// NOTE(Peter): If you're using this, you probably want to write a Get +// procedure to auto cast the result to the type you want. I'm even providing a +// debug check for you to make sure that you're requesting a size that matches +// the ElementSize for extra safety. + +struct gs_dynarray_buffer +{ + u8* Memory; +}; + +struct gs_dynarray +{ + gs_memory_arena Arena; + + gs_dynarray_buffer* Buffers; + u64 BuffersCount; + u64 ElementCount; + + u64 ElementSize; + u64 ElementsPerBuffer; +}; + +struct gs_dynarray_handle +{ + u64 BufferIndex; + u64 IndexInBuffer; +}; + +#define INVALID_DYNARRAY_HANDLE gs_dynarray_handle{0, 0} + +struct gs_dynarray_handle_list +{ + gs_dynarray_handle* Handles; + u32 Count; + u32 Size; +}; + +/////////////////////////////// +// +// File IO + +// TODO(Peter): Error Handling Thought +// The gs_file_handler, gs_allocator, etc should contain pointers to a central error buffer +// where errors can be logged + +enum enumerate_directory_flag +{ + EnumerateDirectory_Recurse = 1 << 0, + EnumerateDirectory_IncludeDirectories = 1 << 1, +}; + +struct gs_file_info +{ + gs_const_string Path; + gs_const_string AbsolutePath; + u64 FileSize; + u64 CreationTime; + u64 LastWriteTime; +}; + +struct gs_file_info_array +{ + gs_file_info* Values; + u32 Count; + u32 MaxCount; +}; + +struct gs_file +{ + union + { + gs_data Data; + struct + { + u8* Memory; + u64 Size; + }; + }; + gs_file_info FileInfo; +}; + +typedef struct gs_file_handler gs_file_handler; + +#define GET_FILE_INFO(name) gs_file_info name(gs_file_handler FileHandler, gs_const_string Path) +typedef GET_FILE_INFO(file_handler_get_file_info); + +#define READ_ENTIRE_FILE(name) gs_file name(gs_file_handler FileHandler, gs_const_string Path, gs_data Memory) +typedef READ_ENTIRE_FILE(file_handler_read_entire_file); + +#define WRITE_ENTIRE_FILE(name) bool name(gs_file_handler FileHandler, gs_const_string Path, gs_data Data) +typedef WRITE_ENTIRE_FILE(file_handler_write_entire_file); + +#define ENUMERATE_DIRECTORY(name) gs_file_info_array name(gs_file_handler FileHandler, gs_memory_arena* Storage, gs_const_string Path, u32 Flags) +typedef ENUMERATE_DIRECTORY(file_handler_enumerate_directory); + +struct gs_file_handler +{ + file_handler_get_file_info* GetFileInfo; + file_handler_read_entire_file* ReadEntireFile; + file_handler_write_entire_file* WriteEntireFile; + file_handler_enumerate_directory* EnumerateDirectory; + gs_memory_arena* Transient; +}; + + +////////////////////////// +// +// Timing + +#define GET_WALL_CLOCK(name) s64 name() +typedef GET_WALL_CLOCK(get_wall_clock); + +#define GET_SECONDS_ELAPSED(name) r64 name(u64 StartCycles, u64 EndCycles) +typedef GET_SECONDS_ELAPSED(get_seconds_elapsed); + +struct gs_time_handler +{ + get_wall_clock* GetWallClock; + get_seconds_elapsed* GetSecondsElapsed; +}; + +/////////////////////////////// +// +// Random + +struct gs_random_series +{ + u32 Value; +}; + +/////////////////////////////// +// +// Sort + +struct gs_radix_list +{ + u64_array Radixes; + u64_array IDs; +}; + + +/////////////////////////////// +// +// Mouse/Keyboard Input + +enum gs_event_type +{ + gs_EventType_Unknown, + + // Reached end of event stream + gs_EventType_NoMoreEvents, + // There was an event but it requires no action from the using program + gs_EventType_NoEvent, + + gs_EventType_KeyPressed, + gs_EventType_KeyReleased, + + gs_EventType_MouseMoved, + gs_EventType_MouseWheel, + + gs_EventType_Count, +}; + +enum gs_key +{ + gs_Key_Invalid, + + gs_Key_Esc, + + gs_Key_Space, + gs_Key_Tab, + gs_Key_CapsLock, + gs_Key_Shift, gs_Key_LeftShift, gs_Key_RightShift, + gs_Key_Control, gs_Key_LeftCtrl, gs_Key_RightCtrl, + gs_Key_Fn, + gs_Key_Alt, + gs_Key_PageUp, gs_Key_PageDown, + gs_Key_End, gs_Key_Home, gs_Key_Select, + gs_Key_Backspace, gs_Key_Delete, + gs_Key_Enter, + + // Function Keys + gs_Key_F0, gs_Key_F1, gs_Key_F2, gs_Key_F3, gs_Key_F4, gs_Key_F5, gs_Key_F6, gs_Key_F7, + gs_Key_F8, gs_Key_F9, gs_Key_F10, gs_Key_F11, gs_Key_F12, + + // Letters + gs_Key_a, gs_Key_b, gs_Key_c, gs_Key_d, gs_Key_e, gs_Key_f, gs_Key_g, gs_Key_h, + gs_Key_i, gs_Key_j, gs_Key_k, gs_Key_l, gs_Key_m, gs_Key_n, gs_Key_o, gs_Key_p, + gs_Key_q, gs_Key_r, gs_Key_s, gs_Key_t, gs_Key_u, gs_Key_v, gs_Key_w, gs_Key_x, + gs_Key_y, gs_Key_z, + + gs_Key_A, gs_Key_B, gs_Key_C, gs_Key_D, gs_Key_E, gs_Key_F, gs_Key_G, gs_Key_H, + gs_Key_I, gs_Key_J, gs_Key_K, gs_Key_L, gs_Key_M, gs_Key_N, gs_Key_O, gs_Key_P, + gs_Key_Q, gs_Key_R, gs_Key_S, gs_Key_T, gs_Key_U, gs_Key_V, gs_Key_W, gs_Key_X, + gs_Key_Y, gs_Key_Z, + + // Numbers + gs_Key_0, gs_Key_1, gs_Key_2, gs_Key_3, gs_Key_4, gs_Key_5, gs_Key_6, gs_Key_7, + gs_Key_8, gs_Key_9, + + gs_Key_Num0, gs_Key_Num1, gs_Key_Num2, gs_Key_Num3, gs_Key_Num4, gs_Key_Num5, + gs_Key_Num6, gs_Key_Num7, gs_Key_Num8, gs_Key_Num9, + + // Symbols + gs_Key_Bang, gs_Key_At, gs_Key_Pound, gs_Key_Dollar, gs_Key_Percent, gs_Key_Carrot, + gs_Key_Ampersand, gs_Key_Star, gs_Key_LeftParen, gs_Key_RightParen, gs_Key_Minus, gs_Key_Plus, + gs_Key_Equals, gs_Key_Underscore, gs_Key_OpenSquareBracket, gs_Key_CloseSquareBracket, gs_Key_OpenCurlyBracket, + gs_Key_CloseCurlyBracket, gs_Key_Colon, gs_Key_SemiColon, gs_Key_SingleQuote, gs_Key_DoubleQuote, + gs_Key_ForwardSlash, gs_Key_Backslash, gs_Key_Pipe, gs_Key_Comma, gs_Key_Period, + gs_Key_QuestionMark, gs_Key_LessThan, gs_Key_GreaterThan, gs_Key_Tilde, gs_Key_BackQuote, + + // Arrows + gs_Key_UpArrow, + gs_Key_DownArrow, + gs_Key_LeftArrow, + gs_Key_RightArrow, + + // Mouse + // NOTE(Peter): Including this here so we can utilize the same KeyDown, KeyUp etc. functions + gs_Key_MouseLeftButton, + gs_Key_MouseMiddleButton, + gs_Key_MouseRightButton, + gs_Key_MouseX1Button, + gs_Key_MouseX2Button, + + gs_Key_Count, +}; + +enum gs_modifier_key_flags +{ + gs_ModifierKeyFlag_Shift = 1 << 0, + gs_ModifierKeyFlag_Ctrl = 1 << 1, + gs_ModifierKeyFlag_Alt = 1 << 2, +}; + +struct gs_input_event +{ + gs_event_type Type; + gs_key Key; + v2 Position; + r32 Amount; + b32 Modifiers; +}; + +struct gs_input_event_buffer +{ + gs_input_event* Values; + u32 Count; + u32 MaxCount; +}; + +struct gs_mouse_state +{ + v2 Position; + b32 ButtonStates[3]; + v2 DownPosition; +}; + +#define MouseButton_IsDownBit 0 +#define MouseButton_WasDownBit 1 +#define MouseButton_IsDown 1 +#define MouseButton_IsNotDown 0 +#define MouseButton_WasDown 1 +#define MouseButton_WasNotDown 0 + +////////////////////////// +// +// Thread Context + +struct gs_thread_info +{ + u32 ThreadID; +}; + +struct gs_thread_context +{ + gs_thread_info ThreadInfo; + + // TODO(Peter): Pull these handlers out into just a gs_context struct so + // they can be shared across threads. + // specifically the allocator + gs_allocator Allocator; + gs_file_handler FileHandler; + debug_output DebugOutput; + gs_time_handler TimeHandler; + + gs_memory_arena* Transient; +}; + +// Threads & Work Queue + +typedef struct gs_work_queue gs_work_queue; + +struct gs_worker_thread +{ + gs_thread_context Context; + gs_work_queue* Queue; + b32 ShouldExit; +}; + +#define THREAD_PROC(name) void name(gs_thread_context Context, gs_data Data) +typedef THREAD_PROC(thread_proc); + +struct gs_threaded_job +{ + thread_proc* WorkProc; + gs_data Data; + gs_const_string JobName; +}; + +#define PUSH_WORK_ON_QUEUE(name) void name(gs_work_queue* Queue, thread_proc* WorkProc, gs_data Data, gs_const_string JobName) +typedef PUSH_WORK_ON_QUEUE(push_work_on_queue); + +#define COMPLETE_QUEUE_WORK(name) void name(gs_work_queue* Queue, gs_thread_context Context) +typedef COMPLETE_QUEUE_WORK(complete_queue_work); + +#define RESET_WORK_QUEUE(name) void name(gs_work_queue* Queue) +typedef RESET_WORK_QUEUE(reset_work_queue); + +struct gs_work_queue +{ + void* SemaphoreHandle; + + u32 JobsMax; + u32 volatile JobsCount; + u32 volatile NextJobIndex; + u32 volatile JobsCompleted; + gs_threaded_job* Jobs; + + // Work Queue + push_work_on_queue* PushWorkOnQueue; + complete_queue_work* CompleteQueueWork; + reset_work_queue* ResetWorkQueue; +}; + +#define GS_TYPES_H +#endif // GS_TYPES_H \ No newline at end of file diff --git a/src/gs_libs/gs_vector_matrix.h b/src/gs_libs/gs_vector_matrix.h index 1f187bc..c089100 100644 --- a/src/gs_libs/gs_vector_matrix.h +++ b/src/gs_libs/gs_vector_matrix.h @@ -105,25 +105,12 @@ union v4 union m33 { - struct - { - float a; float b; float c; - float d; float e; float f; - float g; float h; float i; - }; - float E[9]; + float E[3][3]; }; union m44 { - struct - { - float a; float b; float c; float d; - float e; float f; float g; float h; - float i; float j; float k; float l; - float m; float n; float o; float p; - }; - float E[16]; + float E[4][4]; }; ////////////////////////////////////// @@ -648,10 +635,10 @@ PointIsInRange (v2 _P, v2 _Min, v2 _Max) static bool PointIsInRangeSafe (v2 _P, v2 _Min, v2 _Max) { - s32 MinX = GSMin(_Min.x, _Max.x); - s32 MinY = GSMin(_Min.y, _Max.y); - s32 MaxX = GSMax(_Min.x, _Max.x); - s32 MaxY = GSMax(_Min.y, _Max.y); + s32 MinX = Min(_Min.x, _Max.x); + s32 MinY = Min(_Min.y, _Max.y); + s32 MaxX = Max(_Min.x, _Max.x); + s32 MaxY = Max(_Min.y, _Max.y); return (_P.x >= MinX && _P.x <= MaxX && _P.y >= MinY && _P.y <= MaxY); @@ -1438,11 +1425,11 @@ void TestVectorMatrixMultiplication () // Utility Functions TestClean((GSSqrt(4.f) == 2.f), "Vector Square Root"); - TestClean((GSLerp(0.f, 1.f, .5f) == .5f), "Vector Lerp"); - TestClean((GSMin(-.25f, 5.f) == -.25f), "Vector Min"); - TestClean((GSMax(-.25f, 5.f) == 5.f), "Vector Max"); - TestClean((GSClamp(-2.f, -3.f, 5.f) == -2.f), "Vector Clamp, Lower Than Range"); - TestClean((GSClamp(-2.f, 6.f, 5.f) == 5.f), "Vector Clamp, Higher Than Range"); + TestClean((Lerp(0.f, 1.f, .5f) == .5f), "Vector Lerp"); + TestClean((Min(-.25f, 5.f) == -.25f), "Vector Min"); + TestClean((Max(-.25f, 5.f) == 5.f), "Vector Max"); + TestClean((Clamp(-2.f, -3.f, 5.f) == -2.f), "Vector Clamp, Lower Than Range"); + TestClean((Clamp(-2.f, 6.f, 5.f) == 5.f), "Vector Clamp, Higher Than Range"); ////////////////////////////// // Vector Functions diff --git a/src/gs_libs/gs_win32.cpp b/src/gs_libs/gs_win32.cpp index e2df025..b96ae2e 100644 --- a/src/gs_libs/gs_win32.cpp +++ b/src/gs_libs/gs_win32.cpp @@ -27,7 +27,7 @@ struct window char* ClassName; s32 Width; s32 Height; - WNDPROC WindowEventHandler; + WNDPROC WindowEventHandler; WNDCLASS Class; HWND Handle; @@ -45,7 +45,7 @@ struct handle_window_msg_result #endif }; -global_variable win32_state GlobalWin32State; +global win32_state GlobalWin32State; // Utility internal s32 Win32StringLength(char* String); @@ -66,15 +66,14 @@ internal void Win32DisplayBufferInWindow(win32_offscreen_buffer* Buffer // Memory -internal PLATFORM_ALLOC(Win32Alloc); -internal PLATFORM_FREE(Win32Free); -internal PLATFORM_REALLOC(Win32Realloc); +internal ALLOCATOR_ALLOC(Win32Alloc); +internal ALLOCATOR_FREE(Win32Free); /// // Utils /// -internal s32 +internal s32 Win32StringLength(char* String) { char* At = String; @@ -82,7 +81,7 @@ Win32StringLength(char* String) return At - String; } -internal s32 +internal s32 Win32ConcatStrings(s32 ALength, char* A, s32 BLength, char* B, s32 DestLength, char* Dest) { char* Dst = Dest; @@ -110,7 +109,7 @@ Win32ConcatStrings(s32 ALength, char* A, s32 BLength, char* B, s32 DestLength, c /// internal window -Win32CreateWindow (HINSTANCE HInstance, char* WindowName, s32 Width, s32 Height, +Win32CreateWindow (HINSTANCE HInstance, char* WindowName, s32 Width, s32 Height, WNDPROC WindowEventHandler) { window Result = {}; @@ -131,14 +130,14 @@ Win32CreateWindow (HINSTANCE HInstance, char* WindowName, s32 Width, s32 Height, Result.Handle = CreateWindowEx( 0, Result.Class.lpszClassName, - WindowName, + WindowName, WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, Width, Height, 0, - 0, + 0, HInstance, 0); Result.DeviceContext = GetDC(Result.Handle); @@ -276,9 +275,9 @@ Win32HandleWindowsEvents ( ) { handle_window_event_result EventResult = HandleWindowEventUnlessWouldUseDefault( - WindowHandle, - Msg, - wParam, + WindowHandle, + Msg, + wParam, lParam); if (!EventResult.Handled) @@ -298,92 +297,92 @@ Win32GetKeyCode (int Win32VirtualKey, bool NumpadValid, bool TranslateToChar) if (!TranslateToChar) { - if (Win32VirtualKey == VK_SPACE) { Result = KeyCode_Space; } + if (Win32VirtualKey == VK_SPACE) { Result = KeyCode_Space; } } if (Win32VirtualKey == VK_CAPITAL) { Result = KeyCode_CapsLock; } else if (Win32VirtualKey == VK_TAB) { Result = KeyCode_Tab; } - else if (Win32VirtualKey == VK_LSHIFT) { Result = KeyCode_LeftShift; } + else if (Win32VirtualKey == VK_LSHIFT) { Result = KeyCode_LeftShift; } else if (Win32VirtualKey == VK_RSHIFT) { Result = KeyCode_RightShift; } - else if (Win32VirtualKey == VK_LCONTROL) { Result = KeyCode_LeftCtrl; } + else if (Win32VirtualKey == VK_LCONTROL) { Result = KeyCode_LeftCtrl; } else if (Win32VirtualKey == VK_RCONTROL) { Result = KeyCode_RightCtrl; } // TODO(Peter): support the function key? - //else if (Win32VirtualKey == VK_) { Result = KeyCode_Fn; } + //else if (Win32VirtualKey == VK_) { Result = KeyCode_Fn; } - else if (Win32VirtualKey == VK_MENU) { Result = KeyCode_Alt; } - else if (Win32VirtualKey == VK_PRIOR) { Result = KeyCode_PageUp; } + else if (Win32VirtualKey == VK_MENU) { Result = KeyCode_Alt; } + else if (Win32VirtualKey == VK_PRIOR) { Result = KeyCode_PageUp; } else if (Win32VirtualKey == VK_NEXT) { Result = KeyCode_PageDown; } - else if (Win32VirtualKey == VK_BACK) { Result = KeyCode_Backspace; } + else if (Win32VirtualKey == VK_BACK) { Result = KeyCode_Backspace; } else if (Win32VirtualKey == VK_DELETE) { Result = KeyCode_Delete; } else if (Win32VirtualKey == VK_RETURN) { Result = KeyCode_Enter; } - else if (Win32VirtualKey == VK_F1) { Result = KeyCode_F1; } - else if (Win32VirtualKey == VK_F2) { Result = KeyCode_F2; } - else if (Win32VirtualKey == VK_F3) { Result = KeyCode_F3; } - else if (Win32VirtualKey == VK_F4) { Result = KeyCode_F4; } - else if (Win32VirtualKey == VK_F5) { Result = KeyCode_F5; } - else if (Win32VirtualKey == VK_F6) { Result = KeyCode_F6; } + else if (Win32VirtualKey == VK_F1) { Result = KeyCode_F1; } + else if (Win32VirtualKey == VK_F2) { Result = KeyCode_F2; } + else if (Win32VirtualKey == VK_F3) { Result = KeyCode_F3; } + else if (Win32VirtualKey == VK_F4) { Result = KeyCode_F4; } + else if (Win32VirtualKey == VK_F5) { Result = KeyCode_F5; } + else if (Win32VirtualKey == VK_F6) { Result = KeyCode_F6; } else if (Win32VirtualKey == VK_F7) { Result = KeyCode_F7; } - else if (Win32VirtualKey == VK_F8) { Result = KeyCode_F8; } - else if (Win32VirtualKey == VK_F9) { Result = KeyCode_F9; } - else if (Win32VirtualKey == VK_F10) { Result = KeyCode_F10; } - else if (Win32VirtualKey == VK_F11) { Result = KeyCode_F11; } - else if (Win32VirtualKey == VK_F12) { Result = KeyCode_F12; } + else if (Win32VirtualKey == VK_F8) { Result = KeyCode_F8; } + else if (Win32VirtualKey == VK_F9) { Result = KeyCode_F9; } + else if (Win32VirtualKey == VK_F10) { Result = KeyCode_F10; } + else if (Win32VirtualKey == VK_F11) { Result = KeyCode_F11; } + else if (Win32VirtualKey == VK_F12) { Result = KeyCode_F12; } if (!TranslateToChar) { - if (Win32VirtualKey == 0x30) { Result = KeyCode_0; } - else if (Win32VirtualKey == 0x31) { Result = KeyCode_1; } - else if (Win32VirtualKey == 0x32) { Result = KeyCode_2; } - else if (Win32VirtualKey == 0x33) { Result = KeyCode_3; } - else if (Win32VirtualKey == 0x34) { Result = KeyCode_4; } - else if (Win32VirtualKey == 0x35) { Result = KeyCode_5; } - else if (Win32VirtualKey == 0x36) { Result = KeyCode_6; } + if (Win32VirtualKey == 0x30) { Result = KeyCode_0; } + else if (Win32VirtualKey == 0x31) { Result = KeyCode_1; } + else if (Win32VirtualKey == 0x32) { Result = KeyCode_2; } + else if (Win32VirtualKey == 0x33) { Result = KeyCode_3; } + else if (Win32VirtualKey == 0x34) { Result = KeyCode_4; } + else if (Win32VirtualKey == 0x35) { Result = KeyCode_5; } + else if (Win32VirtualKey == 0x36) { Result = KeyCode_6; } else if (Win32VirtualKey == 0x37) { Result = KeyCode_7; } - else if (Win32VirtualKey == 0x38) { Result = KeyCode_8; } + else if (Win32VirtualKey == 0x38) { Result = KeyCode_8; } else if (Win32VirtualKey == 0x39) { Result = KeyCode_9; } - else if (Win32VirtualKey == 0x41) { Result = KeyCode_A; } - else if (Win32VirtualKey == 0x42) { Result = KeyCode_B; } - else if (Win32VirtualKey == 0x43) { Result = KeyCode_C; } - else if (Win32VirtualKey == 0x44) { Result = KeyCode_D; } - else if (Win32VirtualKey == 0x45) { Result = KeyCode_E; } - else if (Win32VirtualKey == 0x46) { Result = KeyCode_F; } - else if (Win32VirtualKey == 0x47) { Result = KeyCode_G; } + else if (Win32VirtualKey == 0x41) { Result = KeyCode_A; } + else if (Win32VirtualKey == 0x42) { Result = KeyCode_B; } + else if (Win32VirtualKey == 0x43) { Result = KeyCode_C; } + else if (Win32VirtualKey == 0x44) { Result = KeyCode_D; } + else if (Win32VirtualKey == 0x45) { Result = KeyCode_E; } + else if (Win32VirtualKey == 0x46) { Result = KeyCode_F; } + else if (Win32VirtualKey == 0x47) { Result = KeyCode_G; } else if (Win32VirtualKey == 0x48) { Result = KeyCode_H; } - else if (Win32VirtualKey == 0x49) { Result = KeyCode_I; } - else if (Win32VirtualKey == 0x4A) { Result = KeyCode_J; } - else if (Win32VirtualKey == 0x4B) { Result = KeyCode_K; } - else if (Win32VirtualKey == 0x4C) { Result = KeyCode_L; } - else if (Win32VirtualKey == 0x4D) { Result = KeyCode_M; } - else if (Win32VirtualKey == 0x4E) { Result = KeyCode_N; } - else if (Win32VirtualKey == 0x4F) { Result = KeyCode_O; } - else if (Win32VirtualKey == 0x50) { Result = KeyCode_P; } - else if (Win32VirtualKey == 0x51) { Result = KeyCode_Q; } - else if (Win32VirtualKey == 0x52) { Result = KeyCode_R; } - else if (Win32VirtualKey == 0x53) { Result = KeyCode_S; } - else if (Win32VirtualKey == 0x54) { Result = KeyCode_T; } - else if (Win32VirtualKey == 0x55) { Result = KeyCode_U; } - else if (Win32VirtualKey == 0x56) { Result = KeyCode_V; } - else if (Win32VirtualKey == 0x57) { Result = KeyCode_W; } - else if (Win32VirtualKey == 0x58) { Result = KeyCode_X; } - else if (Win32VirtualKey == 0x59) { Result = KeyCode_Y; } + else if (Win32VirtualKey == 0x49) { Result = KeyCode_I; } + else if (Win32VirtualKey == 0x4A) { Result = KeyCode_J; } + else if (Win32VirtualKey == 0x4B) { Result = KeyCode_K; } + else if (Win32VirtualKey == 0x4C) { Result = KeyCode_L; } + else if (Win32VirtualKey == 0x4D) { Result = KeyCode_M; } + else if (Win32VirtualKey == 0x4E) { Result = KeyCode_N; } + else if (Win32VirtualKey == 0x4F) { Result = KeyCode_O; } + else if (Win32VirtualKey == 0x50) { Result = KeyCode_P; } + else if (Win32VirtualKey == 0x51) { Result = KeyCode_Q; } + else if (Win32VirtualKey == 0x52) { Result = KeyCode_R; } + else if (Win32VirtualKey == 0x53) { Result = KeyCode_S; } + else if (Win32VirtualKey == 0x54) { Result = KeyCode_T; } + else if (Win32VirtualKey == 0x55) { Result = KeyCode_U; } + else if (Win32VirtualKey == 0x56) { Result = KeyCode_V; } + else if (Win32VirtualKey == 0x57) { Result = KeyCode_W; } + else if (Win32VirtualKey == 0x58) { Result = KeyCode_X; } + else if (Win32VirtualKey == 0x59) { Result = KeyCode_Y; } else if (Win32VirtualKey == 0x5A) { Result = KeyCode_Z; } } if (NumpadValid) { - if (Win32VirtualKey == VK_NUMPAD0) { Result = KeyCode_Num0; } - else if (Win32VirtualKey == VK_NUMPAD1) { Result = KeyCode_Num1; } - else if (Win32VirtualKey == VK_NUMPAD2) { Result = KeyCode_Num2; } - else if (Win32VirtualKey == VK_NUMPAD3) { Result = KeyCode_Num3; } - else if (Win32VirtualKey == VK_NUMPAD4) { Result = KeyCode_Num4; } - else if (Win32VirtualKey == VK_NUMPAD5) { Result = KeyCode_Num5; } - else if (Win32VirtualKey == VK_NUMPAD6) { Result = KeyCode_Num6; } - else if (Win32VirtualKey == VK_NUMPAD7) { Result = KeyCode_Num7; } - else if (Win32VirtualKey == VK_NUMPAD8) { Result = KeyCode_Num8; } + if (Win32VirtualKey == VK_NUMPAD0) { Result = KeyCode_Num0; } + else if (Win32VirtualKey == VK_NUMPAD1) { Result = KeyCode_Num1; } + else if (Win32VirtualKey == VK_NUMPAD2) { Result = KeyCode_Num2; } + else if (Win32VirtualKey == VK_NUMPAD3) { Result = KeyCode_Num3; } + else if (Win32VirtualKey == VK_NUMPAD4) { Result = KeyCode_Num4; } + else if (Win32VirtualKey == VK_NUMPAD5) { Result = KeyCode_Num5; } + else if (Win32VirtualKey == VK_NUMPAD6) { Result = KeyCode_Num6; } + else if (Win32VirtualKey == VK_NUMPAD7) { Result = KeyCode_Num7; } + else if (Win32VirtualKey == VK_NUMPAD8) { Result = KeyCode_Num8; } else if (Win32VirtualKey == VK_NUMPAD9) { Result = KeyCode_Num9; } } @@ -501,14 +500,14 @@ HandleWindowsMessage ( // NOTE(Peter): Always setting this to true becuase windows is stupid and doesn't // pass the press/release bit through correctly. So now the KEYDOWN/KEYUP Messages above // only translate the message to a WM_CHAR message if its a key down. Since we clear all - // keystates to false at the beginning of an input frame, this will make transitions + // keystates to false at the beginning of an input frame, this will make transitions // get registered correctly. Input.New->KeyStates[KeyIndex] = true; Result.NeedsUpdate = true; } else { - printf("Translated Char Not Recognized: %c\n", TranslatedChar); + printf("Translated Char Not Recognized: %c\n", TranslatedChar); } */ }break; @@ -570,14 +569,14 @@ Win32DisplayBufferInWindow(win32_offscreen_buffer* Win32Buffer, window Window) } ///////////////////////////////////////// -// +// // Open GL // ///////////////////////////////////////// -internal void -OpenGLRenderTriBuffer (u8* Vertecies, s32 VertexElements, +internal void +OpenGLRenderTriBuffer (u8* Vertecies, s32 VertexElements, u8* UVs, s32 UVElements, u8* Colors, s32 ColorsElements, s32 TriCount) @@ -599,7 +598,7 @@ OpenGLRenderTriBuffer (u8* Vertecies, s32 VertexElements, } internal void -OpenGLDraw3DTri (v4 P0, v4 P1, v4 P2, +OpenGLDraw3DTri (v4 P0, v4 P1, v4 P2, v2 UV0, v2 UV1, v2 UV2, v4 C0, v4 C1, v4 C2) { @@ -621,7 +620,7 @@ OpenGLDraw3DTri (v4 P0, v4 P1, v4 P2, } internal void -OpenGLDraw2DTri (v2 P0, v2 P1, v2 P2, +OpenGLDraw2DTri (v2 P0, v2 P1, v2 P2, v2 UV0, v2 UV1, v2 UV2, v4 C0, v4 C1, v4 C2) { @@ -668,14 +667,14 @@ SubmitTexture (u8* Memory, s32 Width, s32 Height) { s32 TextureHandle = NextTextureHandle++; glBindTexture(GL_TEXTURE_2D, TextureHandle); - glTexImage2D(GL_TEXTURE_2D, + glTexImage2D(GL_TEXTURE_2D, 0, // mip map level - GL_RGBA8, - Width, - Height, + GL_RGBA8, + Width, + Height, 0, // border - GL_RGBA, - GL_UNSIGNED_BYTE, + GL_RGBA, + GL_UNSIGNED_BYTE, Memory); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); diff --git a/src/meta/foldhaus_meta.cpp b/src/meta/foldhaus_meta.cpp index 3206405..47eb1a1 100644 --- a/src/meta/foldhaus_meta.cpp +++ b/src/meta/foldhaus_meta.cpp @@ -12,7 +12,7 @@ internal void GenerateNodeMetaInfo (gsm_code_generator* NodeTypeGen, string_builder* NodeSpecificationGen, string_builder* CallNodeProcGen, gs_meta_preprocessor Meta) { // TODO(Peter): Create a FilterTypesByTag function to create a contiguous array - // of type_definition** + // of type_definition** WriteF(NodeSpecificationGen, "static node_specification_ NodeSpecifications[] = {\n"); @@ -218,8 +218,8 @@ GeneratePanelMetaInfo(gs_meta_preprocessor Meta, string_builder* PanelEnumGen, s } WriteF(PanelEnumGen, "enum panel_type {\n"); - WriteF(PanelCodeGen, "global_variable s32 GlobalPanelDefsCount = %d;\n", Panels.Used); - WriteF(PanelCodeGen, "global_variable panel_definition GlobalPanelDefs[] = {\n"); + WriteF(PanelCodeGen, "global s32 GlobalPanelDefsCount = %d;\n", Panels.Used); + WriteF(PanelCodeGen, "global panel_definition GlobalPanelDefs[] = {\n"); for (u32 i = 0; i < Panels.Used; i++) { panel_elements* Panel = Panels.GetElementAtIndex(i); diff --git a/src/meta/gs_meta_error.h b/src/meta/gs_meta_error.h index 2648959..f4f1c68 100644 --- a/src/meta/gs_meta_error.h +++ b/src/meta/gs_meta_error.h @@ -14,13 +14,32 @@ struct errors u32 Used; }; -internal void +#define ErrorReallocArray(base, type, oldcount, newcount) (type*)ErrorRealloc_((u8*)(base), (u64)(sizeof(type) * oldcount), (u64)(sizeof(type) * newcount)) +internal u8* +ErrorRealloc_(u8* Base, u64 OldSize, u64 NewSize) +{ + Assert(NewSize > 0); + u8* Result = (u8*)malloc(NewSize); + if (Base != 0 && OldSize > 0) + { + GSMemCopy(Base, Result, OldSize); + free(Base); + } + return Result; +} + +internal void PushFError (errors* Errors, char* Format, ...) { if (Errors->Used >= (Errors->BuffersCount * ERROR_BUFFER_SIZE)) { +#if 0 Errors->BuffersCount += 1; Errors->Buffers = (error_buffer*)realloc(Errors->Buffers, sizeof(error_buffer*) * Errors->BuffersCount); +#else + Errors->Buffers = ErrorReallocArray(Errors->Buffers, error_buffer, Errors->BuffersCount, Errors->BuffersCount + 1); + Errors->BuffersCount += 1; +#endif error_buffer* NewBuffer = Errors->Buffers + (Errors->BuffersCount - 1); NewBuffer->Backbuffer = (char*)malloc(sizeof(char) * ERROR_MAX_LENGTH * ERROR_BUFFER_SIZE); @@ -28,8 +47,8 @@ PushFError (errors* Errors, char* Format, ...) for (u32 i = 0; i < ERROR_BUFFER_SIZE; i++) { - NewBuffer->Contents[i].Memory = NewBuffer->Backbuffer + (i * ERROR_MAX_LENGTH); - NewBuffer->Contents[i].Max = ERROR_MAX_LENGTH; + NewBuffer->Contents[i].Str = NewBuffer->Backbuffer + (i * ERROR_MAX_LENGTH); + NewBuffer->Contents[i].Size = ERROR_MAX_LENGTH; NewBuffer->Contents[i].Length = 0; } } diff --git a/src/meta/gs_meta_lexer.h b/src/meta/gs_meta_lexer.h index 557f245..60e6647 100644 --- a/src/meta/gs_meta_lexer.h +++ b/src/meta/gs_meta_lexer.h @@ -1,7 +1,7 @@ struct token_selection_spec { b32 MatchText; - string Text; + gs_string Text; }; internal s32 @@ -59,7 +59,7 @@ EatIdentifier (tokenizer* Tokenizer) { s32 Length = 0; - while (Tokenizer->At[0] && + while (Tokenizer->At[0] && (IsAlpha(Tokenizer->At[0]) || IsNumericExtended(Tokenizer->At[0]))) { ++Tokenizer->At; @@ -135,7 +135,7 @@ GetNextToken (tokenizer* Tokenizer) char C = Tokenizer->At[0]; ++Tokenizer->At; - if (C == 0) { Result.Type = Token_EndOfStream; } + if (C == 0) { Result.Type = Token_EndOfStream; } else if (C == '(') { Result.Type = Token_LeftParen; } else if (C == ')') { Result.Type = Token_RightParen; } else if (C == '[') { Result.Type = Token_LeftSquareBracket; } @@ -145,9 +145,9 @@ GetNextToken (tokenizer* Tokenizer) else if (C == ';') { Result.Type = Token_Semicolon; } else if (C == ',') { Result.Type = Token_Comma; } else if (C == '.') { Result.Type = Token_Period; } - else if (C == '-' && Tokenizer->At[0] && Tokenizer->At[0] == '>') - { - Result.Type = Token_PointerReference; + else if (C == '-' && Tokenizer->At[0] && Tokenizer->At[0] == '>') + { + Result.Type = Token_PointerReference; Result.Text.Length = 2; ++Tokenizer->At; } @@ -157,72 +157,72 @@ GetNextToken (tokenizer* Tokenizer) EatWhitespace(Tokenizer); if (TokenAtEquals(Tokenizer, "define")) - { - Result.Type = Token_PoundDefine; + { + Result.Type = Token_PoundDefine; EatPreprocessor(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "undef")) - { - Result.Type = Token_PoundUndef; + { + Result.Type = Token_PoundUndef; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "include")) - { - Result.Type = Token_PoundInclude; - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + { + Result.Type = Token_PoundInclude; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "ifdef")) - { - Result.Type = Token_PoundIfDef; + { + Result.Type = Token_PoundIfDef; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "ifndef")) - { - Result.Type = Token_PoundIfNDef; + { + Result.Type = Token_PoundIfNDef; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "if")) - { - Result.Type = Token_PoundIf; + { + Result.Type = Token_PoundIf; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "elif")) - { - Result.Type = Token_PoundElif; + { + Result.Type = Token_PoundElif; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "else")) - { - Result.Type = Token_PoundElse; + { + Result.Type = Token_PoundElse; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "endif")) - { - Result.Type = Token_PoundEndif; + { + Result.Type = Token_PoundEndif; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "error")) - { - Result.Type = Token_PoundError; + { + Result.Type = Token_PoundError; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } else if (TokenAtEquals(Tokenizer, "pragma")) - { - Result.Type = Token_PoundPragma; + { + Result.Type = Token_PoundPragma; EatToNewLine(Tokenizer); - Result.Text.Length = Tokenizer->At - Result.Text.Memory; + Result.Text.Length = Tokenizer->At - Result.Text.Str; } } - else if (IsNumeric(C)) + else if (IsNumericExtended(C)) { Result.Type = Token_Number; @@ -233,7 +233,7 @@ GetNextToken (tokenizer* Tokenizer) else if (C == '\'') { Result.Type = Token_Char; - Result.Text.Memory = Tokenizer->At; + Result.Text.Str = Tokenizer->At; if (Tokenizer->At[0] && Tokenizer->At[0] == '\\') { ++Tokenizer->At; @@ -245,7 +245,7 @@ GetNextToken (tokenizer* Tokenizer) { Result.Type = Token_String; // replace the length added by the quote - Result.Text.Memory = Tokenizer->At; + Result.Text.Str = Tokenizer->At; Result.Text.Length = EatString(Tokenizer); } // NOTE(Peter): This is after comment parsing so that the division operator diff --git a/src/meta/gs_meta_type_table.h b/src/meta/gs_meta_type_table.h index 3eb2140..d0d32d9 100644 --- a/src/meta/gs_meta_type_table.h +++ b/src/meta/gs_meta_type_table.h @@ -10,7 +10,7 @@ enum type_definition_type TypeDef_Invalid, // NOTE(Peter): tokens with this type require fixup later - TypeDef_Unknown, + TypeDef_Unknown, TypeDef_Enum, TypeDef_Struct, TypeDef_Union, @@ -59,7 +59,7 @@ struct meta_tag struct variable_decl { - // NOTE(Peter): Because of the way the tokenizer works, we don't lex and parse + // NOTE(Peter): Because of the way the tokenizer works, we don't lex and parse // at the same time. This means that not all types will be able to be matched // up on the first pass through. A TypeIndex of -1 means we need to fixup that // type at a later time @@ -161,7 +161,7 @@ HashIdentifier(string Identifier) u32 IdentHash = HashString(Identifier); if (IdentHash == 0) { - // NOTE(Peter): We are excluding a has of zero so taht + // NOTE(Peter): We are excluding a has of zero so taht // the type_table_handle where BucketIndex and IndexInBucket // are both zero is an invalid handle IdentHash += 1; @@ -301,7 +301,7 @@ FindSlotForTypeIdentifier(u32 IdentHash, type_table* TypeTable) Result.IndexInBucket = Index; } - // NOTE(Peter): Because we are growing the hashtable, this should never be an invalid + // NOTE(Peter): Because we are growing the hashtable, this should never be an invalid // type handle Assert(TypeHandleIsValid(Result)); return Result; @@ -391,7 +391,7 @@ PushMetaTagOnTable(meta_tag Tag, type_table* TypeTable) } // Guaranteed to return a valid result -internal type_definition* +internal type_definition* GetTypeDefinition(type_table_handle Handle, type_table TypeTable) { Assert(TypeHandleIsValid(Handle)); @@ -404,7 +404,7 @@ GetTypeDefinition(type_table_handle Handle, type_table TypeTable) } // May return zero -internal type_definition* +internal type_definition* GetTypeDefinitionUnsafe(type_table_handle Handle, type_table TypeTable) { type_definition* Result = 0; @@ -426,7 +426,7 @@ GetMetaTag(type_table_handle Handle, type_table TypeTable) return Result; } -internal type_definition* +internal type_definition* GetTypeDefinition(string Identifier, type_table TypeTable) { type_definition* Result = 0; @@ -588,21 +588,21 @@ internal void FixupStructMember (variable_decl* Member, type_definition* MemberTypeDef, type_table TypeTable, errors* Errors) { // NOTE(Peter): There are a lot of cases where struct members which are pointers - // to other structs cause interesting behavior here. + // to other structs cause interesting behavior here. // For example: // struct foo { foo* Next; } // could cause infinite loops if we try and fixup all structs with a size of 0 - // which would happen in this case, because we wouldn't have parsed foo's size + // which would happen in this case, because we wouldn't have parsed foo's size // yet, but would begin fixing up foo because of the type of Next // Another example: // typedef struct bar bar; // struct foo { bar* Bar; } // struct bar { foo* Foo; } - // causes the exact same problem, but we cant detect it by just excluding - // fixing up StructIndex recursively. - // + // causes the exact same problem, but we cant detect it by just excluding + // fixing up StructIndex recursively. + // // TL;DR - // The solution I've chosen to go with is just exclude all pointer members from + // The solution I've chosen to go with is just exclude all pointer members from // causing recursive fixups. Those types should be fixed up at some point in the // process, and we already know how big a pointer is in memory, no matter the type if (!Member->Pointer) @@ -617,7 +617,7 @@ FixupStructMember (variable_decl* Member, type_definition* MemberTypeDef, type_t { FixUpUnionSize(Member->TypeHandle, TypeTable, Errors); } - else + else { if (MemberTypeDef->Type == TypeDef_Unknown) { @@ -672,7 +672,7 @@ FixUpStructSize (type_table_handle TypeHandle, type_table TypeTable, errors* Err { // NOTE(Peter): Because its recursive (it makes sure all type sizes become known // if it needs them) we should never get to the end of this function and not have - // the ability to tell how big something is. + // the ability to tell how big something is. // TODO(Peter): We don't parse all types yet however, so for now, this is just an alert, // not an assert; #if 0