ps
/
Lumenarium
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Stopped storing copies of nodes names in memory with them. They now just point at the specifications name

This commit is contained in:
Peter Slattery 2019-11-11 14:42:14 -08:00
parent 275c5ac90e
commit 25d9fda391
8 changed files with 100 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
meta/build.bat
View File

@ -21,6 +21,6 @@ del *.pdb > NUL 2> NUL
REM cl %CommonCompilerFlags% ..\meta\main_meta.cpp /link %CommonLinkerFlags% user32.lib winmm.lib gdi32.lib -incremental:no REM cl %CommonCompilerFlags% ..\meta\main_meta.cpp /link %CommonLinkerFlags% user32.lib winmm.lib gdi32.lib -incremental:no
cl %CommonCompilerFlags% ..\meta\foldhaus_meta.cpp /link %CommonLinkerFlags% cl %CommonCompilerFlags% ..\meta\foldhaus_meta.cpp /link %CommonLinkerFlags%
C:\programs\ctime\ctime.exe -end C:\projects\foldhaus_meta\build\win32_gs_meta_build_time.ctm %LastError% C:\programs\ctime\ctime.exe -end C:\projects\foldhaus\build\win32_gs_meta_build_time.ctm %LastError%
C:\programs\ctime\ctime.exe -stats C:\projects\foldhaus\build\win32_gs_meta_build_time.ctm C:\programs\ctime\ctime.exe -stats C:\projects\foldhaus\build\win32_gs_meta_build_time.ctm
popd popd

2
meta/foldhaus_meta.cpp
View File

@ -579,7 +579,7 @@ int main(int ArgCount, char** ArgV)
CodeBlockPrint(&NodeSpecificationsBlock, MakeStringLiteral("node_specification NodeSpecifications[] = {\n")); CodeBlockPrint(&NodeSpecificationsBlock, MakeStringLiteral("node_specification NodeSpecifications[] = {\n"));
code_block_builder CallNodeProcBlock = InitCodeBlockBuilder(); code_block_builder CallNodeProcBlock = InitCodeBlockBuilder();
CodeBlockPrint(&CallNodeProcBlock, MakeStringLiteral("internal void CallNodeProc(interface_node* Node, u8* Data, led* LEDs, s32 LEDsCount, r32 DeltaTime)\n{\n")); CodeBlockPrint(&CallNodeProcBlock, MakeStringLiteral("internal void CallNodeProc(node_header* Node, u8* Data, led* LEDs, s32 LEDsCount, r32 DeltaTime)\n{\n"));
CodeBlockPrint(&CallNodeProcBlock, MakeStringLiteral("switch (Node->Type)\n{\n")); CodeBlockPrint(&CallNodeProcBlock, MakeStringLiteral("switch (Node->Type)\n{\n"));
// Build Search Paths Array // Build Search Paths Array

2
src/foldhaus_app.h
View File

@ -82,7 +82,7 @@ struct app_state
s32 AssembliesUsed; s32 AssembliesUsed;
node_list* NodeList; node_list* NodeList;
interface_node* OutputNode; node_header* OutputNode;
node_render_settings NodeRenderSettings; node_render_settings NodeRenderSettings;
bitmap_font* Font; bitmap_font* Font;

10
src/foldhaus_interface.cpp
View File

@ -420,7 +420,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewBeginMouseDragInteraction)
{ {
node_view_operation_state* OpState = GetCurrentOperationState(State->Modes, node_view_operation_state); node_view_operation_state* OpState = GetCurrentOperationState(State->Modes, node_view_operation_state);
interface_node* Node = GetNodeUnderPoint(State->NodeList, Mouse.DownPos, State->NodeRenderSettings); node_header* Node = GetNodeUnderPoint(State->NodeList, Mouse.DownPos, State->NodeRenderSettings);
if (Node) if (Node)
{ {
node_interaction NewInteraction = GetNodeInteractionType(Node, node_interaction NewInteraction = GetNodeInteractionType(Node,
@ -453,7 +453,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewBeginMouseSelectInteraction)
{ {
node_view_operation_state* OpState = GetCurrentOperationState(State->Modes, node_view_operation_state); node_view_operation_state* OpState = GetCurrentOperationState(State->Modes, node_view_operation_state);
interface_node* Node = GetNodeUnderPoint(State->NodeList, Mouse.Pos, State->NodeRenderSettings); node_header* Node = GetNodeUnderPoint(State->NodeList, Mouse.Pos, State->NodeRenderSettings);
if (Node) if (Node)
{ {
node_interaction NewInteraction = GetNodeInteractionType(Node, node_interaction NewInteraction = GetNodeInteractionType(Node,
@ -484,12 +484,12 @@ OPERATION_RENDER_PROC(RenderNodeView)
MakeStringBuffer(NodeHeaderBuffer, 128); MakeStringBuffer(NodeHeaderBuffer, 128);
interface_node* SelectedNode = GetNodeWithHandle(State->NodeList, OpState->SelectedNodeHandle); node_header* SelectedNode = GetNodeWithHandle(State->NodeList, OpState->SelectedNodeHandle);
node_list_iterator NodeIter = GetNodeListIterator(*State->NodeList); node_list_iterator NodeIter = GetNodeListIterator(*State->NodeList);
while (NodeIteratorIsValid(NodeIter)) while (NodeIteratorIsValid(NodeIter))
{ {
interface_node* Node = NodeIter.At; node_header* Node = NodeIter.At;
rect NodeBounds = CalculateNodeBounds(Node, State->NodeRenderSettings); rect NodeBounds = CalculateNodeBounds(Node, State->NodeRenderSettings);
b32 DrawFields = PointIsInRect(Mouse.Pos, NodeBounds); b32 DrawFields = PointIsInRect(Mouse.Pos, NodeBounds);
@ -585,7 +585,7 @@ FOLDHAUS_INPUT_COMMAND_PROC(NodeViewDeleteNode)
node_view_operation_state* OpState = GetCurrentOperationState(State->Modes, node_view_operation_state); node_view_operation_state* OpState = GetCurrentOperationState(State->Modes, node_view_operation_state);
if (OpState->SelectedNodeHandle > 0) if (OpState->SelectedNodeHandle > 0)
{ {
interface_node* SelectedNode = GetNodeWithHandle(State->NodeList, OpState->SelectedNodeHandle); node_header* SelectedNode = GetNodeWithHandle(State->NodeList, OpState->SelectedNodeHandle);
FreeNodeOnList(State->NodeList, SelectedNode); FreeNodeOnList(State->NodeList, SelectedNode);
} }
} }

154
src/foldhaus_node.cpp
View File

@ -1,14 +1,14 @@
inline s32 inline s32
GetNodeMemorySize(s32 ConnectionsCount, s32 NameLength) GetNodeMemorySize(s32 ConnectionsCount)
{ {
s32 Result = sizeof(interface_node) + (sizeof(node_connection) * ConnectionsCount) + sizeof(NameLength); s32 Result = sizeof(node_header) + (sizeof(node_connection) * ConnectionsCount);
return Result; return Result;
} }
inline s32 inline s32
GetNodeMemorySize (interface_node Node) GetNodeMemorySize (node_header Node)
{ {
return GetNodeMemorySize(Node.ConnectionsCount, Node.Name.Length); return GetNodeMemorySize(Node.ConnectionsCount);
} }
internal node_list_iterator internal node_list_iterator
@ -17,7 +17,7 @@ GetNodeListIterator(node_list List)
node_list_iterator Result = {}; node_list_iterator Result = {};
Result.List = List; Result.List = List;
Result.CurrentBuffer = List.First; Result.CurrentBuffer = List.First;
Result.At = (interface_node*)Result.CurrentBuffer->Memory; Result.At = (node_header*)Result.CurrentBuffer->Memory;
return Result; return Result;
} }
@ -37,20 +37,20 @@ Next (node_list_iterator* Iter)
{ {
node_free_list_member* FreeNode = (node_free_list_member*)Iter->At; node_free_list_member* FreeNode = (node_free_list_member*)Iter->At;
s32 SkipAmount = FreeNode->Size; s32 SkipAmount = FreeNode->Size;
Iter->At = (interface_node*)((u8*)Iter->At + SkipAmount); Iter->At = (node_header*)((u8*)Iter->At + SkipAmount);
} }
else else
{ {
s32 SkipAmount = GetNodeMemorySize(*Iter->At); s32 SkipAmount = GetNodeMemorySize(*Iter->At);
if (((u8*)Iter->At - Iter->CurrentBuffer->Memory) + SkipAmount < Iter->CurrentBuffer->Used) if (((u8*)Iter->At - Iter->CurrentBuffer->Memory) + SkipAmount < Iter->CurrentBuffer->Used)
{ {
Iter->At = (interface_node*)((u8*)Iter->At + SkipAmount); Iter->At = (node_header*)((u8*)Iter->At + SkipAmount);
if (Iter->At->Handle == 0) { Next(Iter); } if (Iter->At->Handle == 0) { Next(Iter); }
} }
else if (Iter->CurrentBuffer->Next) else if (Iter->CurrentBuffer->Next)
{ {
Iter->CurrentBuffer = Iter->CurrentBuffer->Next; Iter->CurrentBuffer = Iter->CurrentBuffer->Next;
Iter->At = (interface_node*)Iter->CurrentBuffer->Memory; Iter->At = (node_header*)Iter->CurrentBuffer->Memory;
if (Iter->At->Handle == 0) { Next(Iter); } if (Iter->At->Handle == 0) { Next(Iter); }
} }
else else
@ -83,12 +83,12 @@ AllocateNodeList (memory_arena* Storage, s32 InitialSize)
return Result; return Result;
} }
internal interface_node* internal node_header*
PushNodeOnList (node_list* List, s32 NameLength, s32 ConnectionsCount, v2 Min, v2 Dim, memory_arena* Storage) PushNodeOnList (node_list* List, s32 ConnectionsCount, v2 Min, v2 Dim, memory_arena* Storage)
{ {
interface_node* Result = 0; node_header* Result = 0;
s32 NodeMemorySize = GetNodeMemorySize(ConnectionsCount, NameLength); s32 NodeMemorySize = GetNodeMemorySize(ConnectionsCount);
if (List->TotalUsed + NodeMemorySize >= List->TotalMax) if (List->TotalUsed + NodeMemorySize >= List->TotalMax)
{ {
@ -99,12 +99,11 @@ PushNodeOnList (node_list* List, s32 NameLength, s32 ConnectionsCount, v2 Min, v
} }
Assert(List->TotalUsed + NodeMemorySize <= List->TotalMax); Assert(List->TotalUsed + NodeMemorySize <= List->TotalMax);
Result = (interface_node*)(List->Head->Memory + List->Head->Used); Result = (node_header*)(List->Head->Memory + List->Head->Used);
Result->Handle = ++List->HandleAccumulator; Result->Handle = ++List->HandleAccumulator;
Result->Name = MakeString((char*)(Result + 1), NameLength);
Result->ConnectionsCount = ConnectionsCount; Result->ConnectionsCount = ConnectionsCount;
Result->Connections = (node_connection*)(Result->Name.Memory + NameLength); Result->Connections = (node_connection*)(Result + 1);
Result->Min = Min; Result->Min = Min;
Result->Dim = Dim; Result->Dim = Dim;
@ -116,7 +115,7 @@ PushNodeOnList (node_list* List, s32 NameLength, s32 ConnectionsCount, v2 Min, v
} }
internal void internal void
FreeNodeOnList (node_list* List, interface_node* Node) FreeNodeOnList (node_list* List, node_header* Node)
{ {
// TODO(Peter): // TODO(Peter):
} }
@ -168,15 +167,17 @@ PushNodeOnListFromSpecification (node_list* List, node_specification Spec, v2 Mi
{ {
// :NodesDontNeedToKnowTheirBounds // :NodesDontNeedToKnowTheirBounds
r32 NodeHeight = CalculateNodeHeight (Spec.MemberListLength); r32 NodeHeight = CalculateNodeHeight (Spec.MemberListLength);
interface_node* Node = PushNodeOnList(List, node_header* Node = PushNodeOnList(List,
Spec.NameLength, Spec.MemberListLength,
Spec.MemberListLength, Min,
Min, v2{150, NodeHeight},
v2{150, NodeHeight}, Storage);
Storage);
Node->Type = Spec.Type; Node->Type = Spec.Type;
CopyCharArrayToString(Spec.Name, Spec.NameLength, &Node->Name); // TODO(Peter): This doesn't work with code reloading, probably just want to store the spec index
// we'll get there
// :HotCodeReloading
Node->Name = MakeString(Spec.Name, Spec.NameLength);
node_struct_member* MemberList = Spec.MemberList; node_struct_member* MemberList = Spec.MemberList;
for (s32 MemberIdx = 0; MemberIdx < Spec.MemberListLength; MemberIdx++) for (s32 MemberIdx = 0; MemberIdx < Spec.MemberListLength; MemberIdx++)
@ -188,28 +189,31 @@ PushNodeOnListFromSpecification (node_list* List, node_specification Spec, v2 Mi
Node->PersistentData = PushArray(Storage, u8, Spec.DataStructSize); Node->PersistentData = PushArray(Storage, u8, Spec.DataStructSize);
} }
internal interface_node* global_variable char* OutputName = "Output";
internal node_header*
PushOutputNodeOnList (node_list* List, v2 Min, memory_arena* Storage) PushOutputNodeOnList (node_list* List, v2 Min, memory_arena* Storage)
{ {
string OutputNodeName = MakeStringLiteral("Output"); node_header* Node = PushNodeOnList(List,
interface_node* Node = PushNodeOnList(List, 1,
OutputNodeName.Length, Min,
1, DEFAULT_NODE_DIMENSION,
Min, Storage);
DEFAULT_NODE_DIMENSION,
Storage);
Node->Type = NodeType_OutputNode; Node->Type = NodeType_OutputNode;
CopyStringTo(OutputNodeName, &Node->Name);
// :HotCodeReloading
Node->Name = MakeString(OutputName);
InitializeNodeConnection(Node->Connections, MemberType_NODE_COLOR_BUFFER, IsInputMember); InitializeNodeConnection(Node->Connections, MemberType_NODE_COLOR_BUFFER, IsInputMember);
return Node; return Node;
} }
internal interface_node* internal node_header*
GetNodeWithHandle(node_list* List, s32 Handle) GetNodeWithHandle(node_list* List, s32 Handle)
{ {
DEBUG_TRACK_FUNCTION; DEBUG_TRACK_FUNCTION;
interface_node* Result = 0; node_header* Result = 0;
node_list_iterator Iter = GetNodeListIterator(*List); node_list_iterator Iter = GetNodeListIterator(*List);
while (NodeIteratorIsValid(Iter)) while (NodeIteratorIsValid(Iter))
@ -226,7 +230,7 @@ GetNodeWithHandle(node_list* List, s32 Handle)
} }
internal rect internal rect
CalculateNodeBounds (interface_node* Node, node_render_settings Settings) CalculateNodeBounds (node_header* Node, node_render_settings Settings)
{ {
rect Result = {}; rect Result = {};
Result.Min = Node->Min; Result.Min = Node->Min;
@ -235,7 +239,7 @@ CalculateNodeBounds (interface_node* Node, node_render_settings Settings)
} }
internal rect internal rect
CalculateNodeInputPortBounds (interface_node* Node, s32 Index, node_render_settings RenderSettings) CalculateNodeInputPortBounds (node_header* Node, s32 Index, node_render_settings RenderSettings)
{ {
rect Result = {}; rect Result = {};
@ -248,7 +252,7 @@ CalculateNodeInputPortBounds (interface_node* Node, s32 Index, node_render_setti
} }
internal rect internal rect
CalculateNodeInputValueBounds (interface_node* Node, s32 Index, node_render_settings RenderSettings) CalculateNodeInputValueBounds (node_header* Node, s32 Index, node_render_settings RenderSettings)
{ {
rect Result = {}; rect Result = {};
rect Port = CalculateNodeInputPortBounds(Node, Index, RenderSettings); rect Port = CalculateNodeInputPortBounds(Node, Index, RenderSettings);
@ -258,7 +262,7 @@ CalculateNodeInputValueBounds (interface_node* Node, s32 Index, node_render_sett
} }
internal rect internal rect
CalculateNodeOutputPortBounds (interface_node* Node, s32 Index, node_render_settings RenderSettings) CalculateNodeOutputPortBounds (node_header* Node, s32 Index, node_render_settings RenderSettings)
{ {
rect Result = {}; rect Result = {};
Result.Min = v2{ Result.Min = v2{
@ -269,7 +273,7 @@ CalculateNodeOutputPortBounds (interface_node* Node, s32 Index, node_render_sett
} }
internal rect internal rect
CalculateNodeOutputValueBounds (interface_node* Node, s32 Index, node_render_settings RenderSettings) CalculateNodeOutputValueBounds (node_header* Node, s32 Index, node_render_settings RenderSettings)
{ {
rect Result = {}; rect Result = {};
rect Port = CalculateNodeOutputPortBounds(Node, Index, RenderSettings); rect Port = CalculateNodeOutputPortBounds(Node, Index, RenderSettings);
@ -279,18 +283,18 @@ CalculateNodeOutputValueBounds (interface_node* Node, s32 Index, node_render_set
} }
internal rect internal rect
GetBoundsOfPortConnectedToInput (interface_node* Node, s32 PortIndex, node_list* NodeList, node_render_settings RenderSettings) GetBoundsOfPortConnectedToInput (node_header* Node, s32 PortIndex, node_list* NodeList, node_render_settings RenderSettings)
{ {
interface_node* ConnectedNode = node_header* ConnectedNode =
GetNodeWithHandle(NodeList, Node->Connections[PortIndex].UpstreamNodeHandle); GetNodeWithHandle(NodeList, Node->Connections[PortIndex].UpstreamNodeHandle);
rect Result = CalculateNodeOutputPortBounds(ConnectedNode, Node->Connections[PortIndex].UpstreamNodePortIndex, RenderSettings); rect Result = CalculateNodeOutputPortBounds(ConnectedNode, Node->Connections[PortIndex].UpstreamNodePortIndex, RenderSettings);
return Result; return Result;
} }
internal rect internal rect
GetBoundsOfPortConnectedToOutput (interface_node* Node, s32 PortIndex, node_list* NodeList, node_render_settings RenderSettings) GetBoundsOfPortConnectedToOutput (node_header* Node, s32 PortIndex, node_list* NodeList, node_render_settings RenderSettings)
{ {
interface_node* ConnectedNode = GetNodeWithHandle(NodeList, Node->Connections[PortIndex].DownstreamNodeHandle); node_header* ConnectedNode = GetNodeWithHandle(NodeList, Node->Connections[PortIndex].DownstreamNodeHandle);
rect Result = CalculateNodeInputPortBounds(ConnectedNode, Node->Connections[PortIndex].DownstreamNodePortIndex, RenderSettings); rect Result = CalculateNodeInputPortBounds(ConnectedNode, Node->Connections[PortIndex].DownstreamNodePortIndex, RenderSettings);
return Result; return Result;
} }
@ -419,7 +423,7 @@ ConnectionIsConnected (node_connection Connection)
} }
internal b32 internal b32
ConnectionIsConnected (interface_node* Node, s32 Index) ConnectionIsConnected (node_header* Node, s32 Index)
{ {
b32 Result = ConnectionIsConnected(Node->Connections[Index]); b32 Result = ConnectionIsConnected(Node->Connections[Index]);
return Result; return Result;
@ -433,7 +437,7 @@ ConnectionHasUpstreamConnection (node_connection Connection)
} }
internal b32 internal b32
ConnectionHasUpstreamConnection (interface_node* Node, s32 Index) ConnectionHasUpstreamConnection (node_header* Node, s32 Index)
{ {
b32 Result = ConnectionHasUpstreamConnection(Node->Connections[Index]); b32 Result = ConnectionHasUpstreamConnection(Node->Connections[Index]);
return Result; return Result;
@ -447,7 +451,7 @@ ConnectionHasDownstreamConnection (node_connection Connection)
} }
internal b32 internal b32
ConnectionHasDownstreamConnection (interface_node* Node, s32 Index) ConnectionHasDownstreamConnection (node_header* Node, s32 Index)
{ {
b32 Result = ConnectionHasDownstreamConnection(Node->Connections[Index]); b32 Result = ConnectionHasDownstreamConnection(Node->Connections[Index]);
return Result; return Result;
@ -461,7 +465,7 @@ ConnectionIsInput (node_connection Connection)
} }
internal b32 internal b32
ConnectionIsInput (interface_node* Node, s32 ConnectionIdx) ConnectionIsInput (node_header* Node, s32 ConnectionIdx)
{ {
return ConnectionIsInput(Node->Connections[ConnectionIdx]); return ConnectionIsInput(Node->Connections[ConnectionIdx]);
} }
@ -474,13 +478,13 @@ ConnectionIsOutput (node_connection Connection)
} }
internal b32 internal b32
ConnectionIsOutput (interface_node* Node, s32 ConnectionIdx) ConnectionIsOutput (node_header* Node, s32 ConnectionIdx)
{ {
return ConnectionIsOutput(Node->Connections[ConnectionIdx]); return ConnectionIsOutput(Node->Connections[ConnectionIdx]);
} }
internal b32 internal b32
CheckForRecursionWithHandle (node_list* NodeList, s32 LookForNodeHandle, interface_node* StartNode) CheckForRecursionWithHandle (node_list* NodeList, s32 LookForNodeHandle, node_header* StartNode)
{ {
DEBUG_TRACK_FUNCTION; DEBUG_TRACK_FUNCTION;
b32 Result = false; b32 Result = false;
@ -497,7 +501,7 @@ CheckForRecursionWithHandle (node_list* NodeList, s32 LookForNodeHandle, interfa
if (StartNode->Connections[Connection].DownstreamNodeHandle > 0) if (StartNode->Connections[Connection].DownstreamNodeHandle > 0)
{ {
interface_node* NextNode = GetNodeWithHandle(NodeList, StartNode->Connections[Connection].DownstreamNodeHandle); node_header* NextNode = GetNodeWithHandle(NodeList, StartNode->Connections[Connection].DownstreamNodeHandle);
Result = CheckForRecursionWithHandle(NodeList, LookForNodeHandle, NextNode); Result = CheckForRecursionWithHandle(NodeList, LookForNodeHandle, NextNode);
if (Result) { break; } if (Result) { break; }
} }
@ -507,7 +511,7 @@ CheckForRecursionWithHandle (node_list* NodeList, s32 LookForNodeHandle, interfa
} }
internal b32 internal b32
PortTypesMatch (interface_node* UpstreamNode, s32 UpstreamNode_OutputPort, interface_node* DownstreamNode, s32 DownstreamNode_InputPort) PortTypesMatch (node_header* UpstreamNode, s32 UpstreamNode_OutputPort, node_header* DownstreamNode, s32 DownstreamNode_InputPort)
{ {
Assert(ConnectionIsOutput(UpstreamNode, UpstreamNode_OutputPort)); Assert(ConnectionIsOutput(UpstreamNode, UpstreamNode_OutputPort));
Assert(ConnectionIsInput(DownstreamNode, DownstreamNode_InputPort)); Assert(ConnectionIsInput(DownstreamNode, DownstreamNode_InputPort));
@ -520,8 +524,8 @@ ConnectNodes(node_list* NodeList,
s32 UpstreamNodeHandle, s32 UpstreamNodePort, s32 UpstreamNodeHandle, s32 UpstreamNodePort,
s32 DownstreamNodeHandle, s32 DownstreamNodePort) s32 DownstreamNodeHandle, s32 DownstreamNodePort)
{ {
interface_node* UpstreamNode = 0; node_header* UpstreamNode = 0;
interface_node* DownstreamNode = GetNodeWithHandle(NodeList, DownstreamNodeHandle); node_header* DownstreamNode = GetNodeWithHandle(NodeList, DownstreamNodeHandle);
if (!CheckForRecursionWithHandle(NodeList, UpstreamNodeHandle, DownstreamNode)) if (!CheckForRecursionWithHandle(NodeList, UpstreamNodeHandle, DownstreamNode))
{ {
UpstreamNode = GetNodeWithHandle(NodeList, UpstreamNodeHandle); UpstreamNode = GetNodeWithHandle(NodeList, UpstreamNodeHandle);
@ -543,8 +547,8 @@ internal void
UnconnectNodes (node_list* NodeList, UnconnectNodes (node_list* NodeList,
s32 DownstreamNodeHandle, s32 DownstreamNode_OutputPort, s32 UpstreamNodeHandle, s32 UpstreamNode_InputPort) s32 DownstreamNodeHandle, s32 DownstreamNode_OutputPort, s32 UpstreamNodeHandle, s32 UpstreamNode_InputPort)
{ {
interface_node* DownstreamNode = GetNodeWithHandle(NodeList, DownstreamNodeHandle); node_header* DownstreamNode = GetNodeWithHandle(NodeList, DownstreamNodeHandle);
interface_node* UpstreamNode = GetNodeWithHandle(NodeList, UpstreamNodeHandle); node_header* UpstreamNode = GetNodeWithHandle(NodeList, UpstreamNodeHandle);
Assert(ConnectionIsOutput(DownstreamNode, DownstreamNode_OutputPort)); Assert(ConnectionIsOutput(DownstreamNode, DownstreamNode_OutputPort));
Assert(ConnectionIsInput(UpstreamNode, UpstreamNode_InputPort)); Assert(ConnectionIsInput(UpstreamNode, UpstreamNode_InputPort));
@ -555,16 +559,16 @@ UnconnectNodes (node_list* NodeList,
UpstreamNode->Connections[UpstreamNode_InputPort].UpstreamNodePortIndex = -1; UpstreamNode->Connections[UpstreamNode_InputPort].UpstreamNodePortIndex = -1;
} }
internal interface_node* internal node_header*
GetNodeUnderPoint (node_list* NodeList, v2 Point, node_render_settings RenderSettings) GetNodeUnderPoint (node_list* NodeList, v2 Point, node_render_settings RenderSettings)
{ {
DEBUG_TRACK_FUNCTION; DEBUG_TRACK_FUNCTION;
interface_node* Result = 0; node_header* Result = 0;
node_list_iterator NodeIter = GetNodeListIterator(*NodeList); node_list_iterator NodeIter = GetNodeListIterator(*NodeList);
while (NodeIteratorIsValid(NodeIter)) while (NodeIteratorIsValid(NodeIter))
{ {
interface_node* Node = NodeIter.At; node_header* Node = NodeIter.At;
rect NodeBounds = CalculateNodeBounds(Node, RenderSettings); rect NodeBounds = CalculateNodeBounds(Node, RenderSettings);
if (PointIsInRect(Point, NodeBounds)) if (PointIsInRect(Point, NodeBounds))
{ {
@ -578,7 +582,7 @@ GetNodeUnderPoint (node_list* NodeList, v2 Point, node_render_settings RenderSet
} }
internal node_interaction internal node_interaction
GetNodeInteractionType (interface_node* ActiveNode, v2 MousePos, node_render_settings RenderSettings) GetNodeInteractionType (node_header* ActiveNode, v2 MousePos, node_render_settings RenderSettings)
{ {
DEBUG_TRACK_FUNCTION; DEBUG_TRACK_FUNCTION;
@ -651,7 +655,7 @@ TryConnectNodes (node_interaction Interaction, v2 Point, node_list* NodeList, no
if (IsDraggingNodeOutput(Interaction)) if (IsDraggingNodeOutput(Interaction))
{ {
interface_node* UpstreamNode = GetNodeUnderPoint(NodeList, Point, RenderSettings); node_header* UpstreamNode = GetNodeUnderPoint(NodeList, Point, RenderSettings);
if (UpstreamNode) if (UpstreamNode)
{ {
for (s32 Connection = 0; Connection < UpstreamNode->ConnectionsCount; Connection++) for (s32 Connection = 0; Connection < UpstreamNode->ConnectionsCount; Connection++)
@ -670,7 +674,7 @@ TryConnectNodes (node_interaction Interaction, v2 Point, node_list* NodeList, no
} }
else if (IsDraggingNodeInput(Interaction)) else if (IsDraggingNodeInput(Interaction))
{ {
interface_node* DownstreamNode = GetNodeUnderPoint(NodeList, Point, RenderSettings); node_header* DownstreamNode = GetNodeUnderPoint(NodeList, Point, RenderSettings);
if (DownstreamNode) if (DownstreamNode)
{ {
for (s32 Connection = 0; Connection < DownstreamNode->ConnectionsCount; Connection++) for (s32 Connection = 0; Connection < DownstreamNode->ConnectionsCount; Connection++)
@ -691,7 +695,7 @@ TryConnectNodes (node_interaction Interaction, v2 Point, node_list* NodeList, no
} }
internal void internal void
PlaceNode (node_list* NodeList, interface_node* Node, v2 Position, b32 Flags) PlaceNode (node_list* NodeList, node_header* Node, v2 Position, b32 Flags)
{ {
DEBUG_TRACK_FUNCTION; DEBUG_TRACK_FUNCTION;
@ -706,7 +710,7 @@ PlaceNode (node_list* NodeList, interface_node* Node, v2 Position, b32 Flags)
s32 ConnectionHandle = Node->Connections[Connection].DownstreamNodeHandle; s32 ConnectionHandle = Node->Connections[Connection].DownstreamNodeHandle;
if (ConnectionHandle > 0) if (ConnectionHandle > 0)
{ {
interface_node* ConnectedNode = GetNodeWithHandle(NodeList, ConnectionHandle); node_header* ConnectedNode = GetNodeWithHandle(NodeList, ConnectionHandle);
v2 CurrPos = ConnectedNode->Min; v2 CurrPos = ConnectedNode->Min;
v2 NewPos = CurrPos + Offset; v2 NewPos = CurrPos + Offset;
// NOTE(Peter): Have to negate the all downstream component so it doesn't turn around and try // NOTE(Peter): Have to negate the all downstream component so it doesn't turn around and try
@ -725,7 +729,7 @@ PlaceNode (node_list* NodeList, interface_node* Node, v2 Position, b32 Flags)
s32 ConnectionHandle = Node->Connections[Connection].UpstreamNodeHandle; s32 ConnectionHandle = Node->Connections[Connection].UpstreamNodeHandle;
if (ConnectionHandle > 0) if (ConnectionHandle > 0)
{ {
interface_node* ConnectedNode = GetNodeWithHandle(NodeList, ConnectionHandle); node_header* ConnectedNode = GetNodeWithHandle(NodeList, ConnectionHandle);
v2 CurrPos = ConnectedNode->Min; v2 CurrPos = ConnectedNode->Min;
v2 NewPos = CurrPos + Offset; v2 NewPos = CurrPos + Offset;
// NOTE(Peter): Have to negate the all upstream component so it doesn't turn around and try // NOTE(Peter): Have to negate the all upstream component so it doesn't turn around and try
@ -745,7 +749,7 @@ UpdateDraggingNode (v2 MousePos, node_interaction Interaction, node_list* NodeLi
if (IsDraggingNode(Interaction)) if (IsDraggingNode(Interaction))
{ {
interface_node* ActiveNode = GetNodeWithHandle(NodeList, Interaction.NodeHandle); node_header* ActiveNode = GetNodeWithHandle(NodeList, Interaction.NodeHandle);
PlaceNode(NodeList, ActiveNode, MousePos + Interaction.MouseOffset, Interaction.Flags); PlaceNode(NodeList, ActiveNode, MousePos + Interaction.MouseOffset, Interaction.Flags);
} }
} }
@ -757,7 +761,7 @@ UpdateDraggingNodePort (v2 MousePos, node_interaction Interaction, node_list* No
if (IsDraggingNodePort(Interaction)) if (IsDraggingNodePort(Interaction))
{ {
interface_node* ActiveNode = GetNodeWithHandle(NodeList, Interaction.NodeHandle); node_header* ActiveNode = GetNodeWithHandle(NodeList, Interaction.NodeHandle);
rect PortBounds = {}; rect PortBounds = {};
if (IsDraggingNodeInput(Interaction)) if (IsDraggingNodeInput(Interaction))
{ {
@ -781,7 +785,7 @@ UpdateDraggingNodeValue (v2 MousePos, v2 LastFrameMousePos, node_interaction Int
if(IsDraggingNodeValue(Interaction)) if(IsDraggingNodeValue(Interaction))
{ {
v2 MouseDelta = MousePos - LastFrameMousePos; v2 MouseDelta = MousePos - LastFrameMousePos;
interface_node* Node = GetNodeWithHandle(NodeList, Interaction.NodeHandle); node_header* Node = GetNodeWithHandle(NodeList, Interaction.NodeHandle);
node_connection* Connection = 0; node_connection* Connection = 0;
if (IsDraggingNodeInputValue(Interaction)) if (IsDraggingNodeInputValue(Interaction))
@ -819,12 +823,12 @@ UpdateDraggingNodeValue (v2 MousePos, v2 LastFrameMousePos, node_interaction Int
} }
internal void UpdateNodeCalculation (interface_node* Node, node_list* NodeList, internal void UpdateNodeCalculation (node_header* Node, node_list* NodeList,
memory_arena* Permanent, memory_arena* Transient, memory_arena* Permanent, memory_arena* Transient,
led* LEDs, sacn_pixel* ColorsInit, s32 LEDCount, r32 DeltaTime); led* LEDs, sacn_pixel* ColorsInit, s32 LEDCount, r32 DeltaTime);
internal void internal void
UpdateNodesConnectedUpstream (interface_node* Node, node_list* NodeList, UpdateNodesConnectedUpstream (node_header* Node, node_list* NodeList,
memory_arena* Permanent, memory_arena* Transient, memory_arena* Permanent, memory_arena* Transient,
led* LEDs, sacn_pixel* ColorsInit, s32 LEDCount, r32 DeltaTime) led* LEDs, sacn_pixel* ColorsInit, s32 LEDCount, r32 DeltaTime)
{ {
@ -837,7 +841,7 @@ UpdateNodesConnectedUpstream (interface_node* Node, node_list* NodeList,
if (ConnectionHasUpstreamConnection(*Connection)) if (ConnectionHasUpstreamConnection(*Connection))
{ {
interface_node* UpstreamNode = GetNodeWithHandle(NodeList, Connection->UpstreamNodeHandle); node_header* UpstreamNode = GetNodeWithHandle(NodeList, Connection->UpstreamNodeHandle);
if (!UpstreamNode->UpdatedThisFrame) if (!UpstreamNode->UpdatedThisFrame)
{ {
UpdateNodeCalculation(UpstreamNode, NodeList, Permanent, Transient, LEDs, ColorsInit, LEDCount, DeltaTime); UpdateNodeCalculation(UpstreamNode, NodeList, Permanent, Transient, LEDs, ColorsInit, LEDCount, DeltaTime);
@ -872,7 +876,7 @@ UpdateNodesConnectedUpstream (interface_node* Node, node_list* NodeList,
} }
internal void internal void
UpdateNodeCalculation (interface_node* Node, node_list* NodeList, UpdateNodeCalculation (node_header* Node, node_list* NodeList,
memory_arena* Permanent, memory_arena* Transient, memory_arena* Permanent, memory_arena* Transient,
led* LEDs, sacn_pixel* ColorsInit, s32 LEDCount, r32 DeltaTime) led* LEDs, sacn_pixel* ColorsInit, s32 LEDCount, r32 DeltaTime)
{ {
@ -984,7 +988,7 @@ UpdateNodeCalculation (interface_node* Node, node_list* NodeList,
} }
internal void internal void
UpdateOutputNodeCalculations (interface_node* OutputNode, node_list* NodeList, UpdateOutputNodeCalculations (node_header* OutputNode, node_list* NodeList,
memory_arena* Permanent, memory_arena* Transient, memory_arena* Permanent, memory_arena* Transient,
led* LEDs, sacn_pixel* Colors, s32 LEDCount, r32 DeltaTime) led* LEDs, sacn_pixel* Colors, s32 LEDCount, r32 DeltaTime)
{ {
@ -1009,7 +1013,7 @@ UpdateAllNodeCalculations (node_list* NodeList, memory_arena* Permanent, memory_
node_list_iterator NodeIter = GetNodeListIterator(*NodeList); node_list_iterator NodeIter = GetNodeListIterator(*NodeList);
while (NodeIteratorIsValid(NodeIter)) while (NodeIteratorIsValid(NodeIter))
{ {
interface_node* Node = NodeIter.At; node_header* Node = NodeIter.At;
if (!Node->UpdatedThisFrame) if (!Node->UpdatedThisFrame)
{ {
UpdateNodeCalculation(Node, NodeList, Permanent, Transient, LEDs, Colors, LEDCount, DeltaTime); UpdateNodeCalculation(Node, NodeList, Permanent, Transient, LEDs, Colors, LEDCount, DeltaTime);
@ -1024,7 +1028,7 @@ ClearTransientNodeColorBuffers (node_list* NodeList)
node_list_iterator NodeIter = GetNodeListIterator(*NodeList); node_list_iterator NodeIter = GetNodeListIterator(*NodeList);
while (NodeIteratorIsValid(NodeIter)) while (NodeIteratorIsValid(NodeIter))
{ {
interface_node* Node = NodeIter.At; node_header* Node = NodeIter.At;
for (s32 ConnectionIdx = 0; ConnectionIdx < Node->ConnectionsCount; ConnectionIdx++) for (s32 ConnectionIdx = 0; ConnectionIdx < Node->ConnectionsCount; ConnectionIdx++)
{ {
node_connection* Connection = Node->Connections + ConnectionIdx; node_connection* Connection = Node->Connections + ConnectionIdx;
@ -1086,7 +1090,7 @@ ResetNodesUpdateState (node_list* NodeList)
node_list_iterator NodeIter = GetNodeListIterator(*NodeList); node_list_iterator NodeIter = GetNodeListIterator(*NodeList);
while (NodeIteratorIsValid(NodeIter)) while (NodeIteratorIsValid(NodeIter))
{ {
interface_node* Node = NodeIter.At; node_header* Node = NodeIter.At;
Node->UpdatedThisFrame = false; Node->UpdatedThisFrame = false;
Next(&NodeIter); Next(&NodeIter);
} }

12
src/foldhaus_node.h
View File

@ -52,8 +52,10 @@ struct node_led_color_connection
struct node_connection struct node_connection
{ {
s32 NodeHandle;
struct_member_type Type; struct_member_type Type;
// TODO(Peter): probably can unify these pairs into a struct
s32 UpstreamNodeHandle; s32 UpstreamNodeHandle;
s32 UpstreamNodePortIndex; s32 UpstreamNodePortIndex;
s32 DownstreamNodeHandle; s32 DownstreamNodeHandle;
@ -72,7 +74,7 @@ struct node_connection
// TODO(Peter): cant decide if this needs to be dynamic or just a really big number // TODO(Peter): cant decide if this needs to be dynamic or just a really big number
// reevaluate once you have some examples // reevaluate once you have some examples
#define NODE_CONNECTIONS_MAX 8 #define NODE_CONNECTIONS_MAX 8
struct interface_node struct node_header
{ {
s32 Handle; // NOTE(Peter): stores a non-zero handle. must come first to match node_free_list_member s32 Handle; // NOTE(Peter): stores a non-zero handle. must come first to match node_free_list_member
string Name; string Name;
@ -90,7 +92,7 @@ struct interface_node
struct node_free_list_member struct node_free_list_member
{ {
s32 Handle; // NOTE(Peter): this will always be zero, and must come first to match interface_node s32 Handle; // NOTE(Peter): this will always be zero, and must come first to match node_header
s32 Size; s32 Size;
node_free_list_member* Next; node_free_list_member* Next;
s32 OldHandle; s32 OldHandle;
@ -105,6 +107,7 @@ struct node_list_buffer
node_list_buffer* Next; node_list_buffer* Next;
}; };
#define NODE_LIST_CONNECTIONS_MAX 256
struct node_list struct node_list
{ {
node_list_buffer* First; node_list_buffer* First;
@ -113,13 +116,16 @@ struct node_list
s32 TotalUsed; s32 TotalUsed;
s32 HandleAccumulator; s32 HandleAccumulator;
s32 ConnectionsUsed;
node_connection Connections[NODE_LIST_CONNECTIONS_MAX];
}; };
struct node_list_iterator struct node_list_iterator
{ {
node_list List; node_list List;
node_list_buffer* CurrentBuffer; node_list_buffer* CurrentBuffer;
interface_node* At; node_header* At;
}; };
enum node_interaction_flag enum node_interaction_flag

2
src/generated/foldhaus_nodes_generated.cpp
View File

@ -95,7 +95,7 @@ node_specification NodeSpecifications[] = {
}; };
s32 NodeSpecificationsCount = 10; s32 NodeSpecificationsCount = 10;
internal void CallNodeProc(interface_node* Node, u8* Data, led* LEDs, s32 LEDsCount, r32 DeltaTime) internal void CallNodeProc(node_header* Node, u8* Data, led* LEDs, s32 LEDsCount, r32 DeltaTime)
{ {
switch (Node->Type) switch (Node->Type)
{ {

4
todo.txt
View File

@ -9,6 +9,7 @@ BUGS
Switch To Nodes Switch To Nodes
- delete nodes - delete nodes
- - Simplify node storage - - Simplify node storage
- x don't pull node names into the struct, just reference the specification
- - separate storage of node headers from connections - - separate storage of node headers from connections
- - investigate if node connections can be operated on separately from the node headers - - investigate if node connections can be operated on separately from the node headers
- - Allow insertion/deletion within connection table - - Allow insertion/deletion within connection table
@ -32,12 +33,13 @@ update functions
- - Log memory allocations - - Log memory allocations
- separate rendering thread - separate rendering thread
- cache led positions. Only update if they are moving - cache led positions. Only update if they are moving
- - shift drag to 10x drag speed - :HotCodeReloading
UI Improvements UI Improvements
- highlight node field under active edit - highlight node field under active edit
- Mouse Held Commands - Mouse Held Commands
- Actual cursor states - Actual cursor states
- shift drag to 10x drag speed
- Text editing improvements - Text editing improvements
- - draw cursor in node field under active edit - - draw cursor in node field under active edit
- - better/intelligent zero padding - - better/intelligent zero padding