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

Began drawing nodes, laying them out, and am working on node interface functionality

This commit is contained in:
Peter Slattery 2019-12-29 18:28:59 -08:00
parent e3705842dc
commit c5404e3296
8 changed files with 358 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/foldhaus_app.cpp
View File

@ -1,16 +1,6 @@
#include "foldhaus_platform.h"
#include "foldhaus_app.h"
internal void
SetPanelDefinitionExternal(panel* Panel, s32 OldPanelDefinitionIndex, s32 NewPanelDefinitionIndex)
{
if(OldPanelDefinitionIndex >= 0)
{
GlobalPanelDefs[OldPanelDefinitionIndex].Cleanup(Panel);
}
GlobalPanelDefs[NewPanelDefinitionIndex].Init(Panel);
}
internal v4
MouseToWorldRay(r32 MouseX, r32 MouseY, camera* Camera, rect WindowBounds)
{
@ -203,7 +193,7 @@ INITIALIZE_APPLICATION(InitializeApplication)
InitializePanelSystem(&State->PanelSystem);
panel* Panel = TakeNewPanel(&State->PanelSystem);
SetPanelDefinition(Panel, 0);
SetPanelDefinition(Panel, 0, State);
}
internal void
@ -223,6 +213,7 @@ HandleInput (app_state* State, rect WindowBounds, input_queue InputQueue, mouse_
{
panel_and_bounds PanelWithMouseOverIt = GetPanelContainingPoint(Mouse.Pos, &State->PanelSystem, WindowBounds);
if (!PanelWithMouseOverIt.Panel) { return; }
State->HotPanel = PanelWithMouseOverIt.Panel;
panel_definition PanelDefinition = GlobalPanelDefs[PanelWithMouseOverIt.Panel->PanelDefinitionIndex];
if (!PanelDefinition.InputCommands) { return; }

17
src/foldhaus_app.h
View File

@ -10,7 +10,9 @@
#include "foldhaus_assembly.h"
#include "assembly_parser.h"
#include "foldhaus_node.h"
#include "assembly_parser.cpp"
#include "test_patterns.h"
@ -67,6 +69,7 @@ struct app_state
animation_block_handle SelectedAnimationBlockHandle;
panel_system PanelSystem;
panel* HotPanel;
};
internal void OpenColorPicker(app_state* State, v4* Address);
@ -198,10 +201,19 @@ TestPatternThree(assembly* Assembly, r32 Time)
#include "foldhaus_text_entry.cpp"
#include "foldhaus_search_lister.cpp"
#define PANEL_INIT_PROC(name) void name(panel* Panel)
#include "foldhaus_default_nodes.h"
#include "generated/foldhaus_nodes_generated.cpp"
#include "foldhaus_node.cpp"
FOLDHAUS_INPUT_COMMAND_PROC(EndCurrentOperationMode)
{
DeactivateCurrentOperationMode(&State->Modes);
}
#define PANEL_INIT_PROC(name) void name(panel* Panel, app_state* State)
typedef PANEL_INIT_PROC(panel_init_proc);
#define PANEL_CLEANUP_PROC(name) void name(panel* Panel)
#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, mouse_state Mouse)
@ -212,6 +224,7 @@ typedef PANEL_RENDER_PROC(panel_render_proc);
#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 "generated/foldhaus_panels_generated.h"

29
src/foldhaus_interface.cpp
View File

@ -141,6 +141,19 @@ enum panel_edit_mode
PanelEdit_Count,
};
internal void
SetPanelDefinition(panel* Panel, s32 NewPanelDefinitionIndex, app_state* State)
{
s32 OldPanelDefinitionIndex = Panel->PanelDefinitionIndex;
Panel->PanelDefinitionIndex = NewPanelDefinitionIndex;
if(OldPanelDefinitionIndex >= 0)
{
GlobalPanelDefs[OldPanelDefinitionIndex].Cleanup(Panel, State);
}
GlobalPanelDefs[NewPanelDefinitionIndex].Init(Panel, State);
}
//
// Drag Panel Border Operation Mode
@ -359,6 +372,12 @@ FOLDHAUS_INPUT_COMMAND_PROC(EndSplitPanelOperation)
SplitPanelHorizontally(Panel, YPercent, PanelBounds, &State->PanelSystem);
}
Panel->Left->Panel.PanelDefinitionIndex = Panel->PanelDefinitionIndex;
Panel->Left->Panel.PanelStateMemory = Panel->PanelStateMemory;
Panel->Left->Panel.PanelStateMemorySize = Panel->PanelStateMemorySize;
SetPanelDefinition(&Panel->Right->Panel, Panel->PanelDefinitionIndex, State);
DeactivateCurrentOperationMode(&State->Modes);
}
@ -497,7 +516,7 @@ DrawPanelBorder(panel Panel, v2 PanelMin, v2 PanelMax, v4 Color, mouse_state Mou
}
internal void
DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect FooterBounds, interface_config Interface, mouse_state Mouse)
DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect 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);
@ -525,10 +544,10 @@ DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect FooterBo
string DefName = MakeString(Def.PanelName, Def.PanelNameLength);
button_result DefinitionButton = EvaluateButton(RenderBuffer,
ButtonMin, ButtonMin + ButtonDimension,
DefName, Interface, Mouse);
DefName, State->Interface, Mouse);
if (DefinitionButton.Pressed)
{
SetPanelDefinition(Panel, i);
SetPanelDefinition(Panel, i, State);
Panel->PanelSelectionMenuOpen = false;
}
@ -539,7 +558,7 @@ DrawPanelFooter(panel* Panel, render_command_buffer* RenderBuffer, rect FooterBo
button_result ButtonResult = EvaluateButton(RenderBuffer,
PanelSelectButtonMin,
PanelSelectButtonMax,
MakeStringLiteral("Select"), Interface, Mouse);
MakeStringLiteral("Select"), State->Interface, Mouse);
if (ButtonResult.Pressed)
{
Panel->PanelSelectionMenuOpen = !Panel->PanelSelectionMenuOpen;
@ -565,7 +584,7 @@ RenderPanel(panel* Panel, rect PanelBounds, rect WindowBounds, render_command_bu
Definition.Render(*Panel, PanelViewBounds, RenderBuffer, State, Context, Mouse);
PushRenderOrthographic(RenderBuffer, WindowBounds.Min.x, WindowBounds.Min.y, WindowBounds.Max.x, WindowBounds.Max.y);
DrawPanelFooter(Panel, RenderBuffer, FooterBounds, State->Interface, Mouse);
DrawPanelFooter(Panel, RenderBuffer, FooterBounds, Mouse, State);
}
internal void

2
src/foldhaus_node.cpp
View File

@ -189,7 +189,7 @@ PushNodeOnListFromSpecification (node_list* List, node_type Type, v2 Min, memory
Node->PersistentData = PushArray(Storage, u8, Spec.DataStructSize);
node_struct_member* MemberList = Spec.MemberList;
for (s32 MemberIdx = 0; MemberIdx < Spec.MemberListLength; MemberIdx++)
for (u32 MemberIdx = 0; MemberIdx < Spec.MemberListLength; MemberIdx++)
{
node_struct_member Member = MemberList[MemberIdx];
InitializeNodeConnection(Node->Connections + MemberIdx, Member, Node);

4
src/foldhaus_node.h
View File

@ -169,9 +169,9 @@ struct node_specification
s32 NameLength;
node_struct_member* MemberList;
s32 DataStructSize;
u32 DataStructSize;
s32 MemberListLength;
u32 MemberListLength;
b32 IsPattern;
};

13
src/foldhaus_panel.h
View File

@ -34,6 +34,9 @@ struct panel
// Probably belongs in a more generalized PanelInterfaceState or something
b32 PanelSelectionMenuOpen;
u8* PanelStateMemory;
u32 PanelStateMemorySize;
union{
panel_entry* Left;
panel_entry* Top;
@ -80,8 +83,6 @@ struct panel_layout
u32 PanelsMax;
};
internal void SetPanelDefinitionExternal(panel* Panel, s32 OldPanelDefinitionIndex, s32 NewPanelDefinitionIndex);
/////////////////////////////////
//
// Book-Keeping
@ -201,14 +202,6 @@ ConsolidatePanelsKeepOne(panel* Parent, panel_entry* PanelEntryToKeep, panel_sys
FreePanelEntryRecursive(PanelEntryToDestroy, PanelSystem);
}
internal void
SetPanelDefinition(panel* Panel, s32 NewDefinitionIndex)
{
s32 OldDefinitionIndex = Panel->PanelDefinitionIndex;
Panel->PanelDefinitionIndex = NewDefinitionIndex;
SetPanelDefinitionExternal(Panel, OldDefinitionIndex, NewDefinitionIndex);
}
/////////////////////////////////
//
// Rendering And Interaction

3
src/generated/foldhaus_panels_generated.h
View File

@ -8,11 +8,12 @@ struct panel_definition
input_command* InputCommands;
};
global_variable s32 GlobalPanelDefsCount = 5;
global_variable s32 GlobalPanelDefsCount = 6;
global_variable panel_definition GlobalPanelDefs[] = {
{ "Sculpture View", 14, SculptureView_Init, SculptureView_Cleanup, SculptureView_Render, SculptureView_Commands},
{ "Animation Timeline", 18, AnimationTimeline_Init, AnimationTimeline_Cleanup, AnimationTimeline_Render, AnimationTimeline_Commands },
{ "DMX View", 8, DMXView_Init, DMXView_Cleanup, DMXView_Render, 0 },
{ "Profiler", 8, ProfilerView_Init, ProfilerView_Cleanup, ProfilerView_Render, 0 },
{ "Hierarchy", 9, HierarchyView_Init, HierarchyView_Cleanup, HierarchyView_Render, 0 },
{ "Node Graph", 10, NodeGraph_Init, NodeGraph_Cleanup, NodeGraph_Render, NodeGraph_Commands },
};

309
src/panels/foldhaus_panel_node_graph.h Normal file
View File

@ -0,0 +1,309 @@
struct node_graph_state
{
v2 ViewOffset;
};
//
// Pan Node Graph
//
OPERATION_STATE_DEF(pan_node_graph_operation_state)
{
v2 InitialViewOffset;
// TODO(Peter): I DON"T LIKE THIS!!!!
// We should have a way to access the panel that created an operation mode or something
v2* ViewOffset;
};
OPERATION_RENDER_PROC(UpdatePanNodeGraph)
{
pan_node_graph_operation_state* OpState = (pan_node_graph_operation_state*)Operation.OpStateMemory;
v2 MouseDelta = Mouse.Pos - Mouse.DownPos;
*OpState->ViewOffset = MouseDelta + OpState->InitialViewOffset;
}
input_command PanNodeGraphCommands[] = {
{ KeyCode_MouseLeftButton, KeyCode_Invalid, Command_Ended, EndCurrentOperationMode },
};
FOLDHAUS_INPUT_COMMAND_PROC(BeginPanNodeGraph)
{
operation_mode* PanNodeGraph = ActivateOperationModeWithCommands(&State->Modes, PanNodeGraphCommands, UpdatePanNodeGraph);
pan_node_graph_operation_state* OpState = CreateOperationState(PanNodeGraph, &State->Modes, pan_node_graph_operation_state);
panel* NodeGraphPanel = State->HotPanel;
node_graph_state* NodeGraphState = (node_graph_state*)NodeGraphPanel->PanelStateMemory;
OpState->InitialViewOffset = NodeGraphState->ViewOffset;
OpState->ViewOffset = &NodeGraphState->ViewOffset;
}
//
// Node Graph Panel
//
input_command NodeGraph_Commands[] = {
{ KeyCode_MouseLeftButton, KeyCode_Invalid, Command_Began, BeginPanNodeGraph }
};
PANEL_INIT_PROC(NodeGraph_Init)
{
// TODO(Peter): We aren't able to free this memory. We need a system for
// taking fixed size chunks off the Memory stack and then reusing them. THis
// should probably live outside the paneling system.
Panel->PanelStateMemory = (u8*)PushStruct(&State->Permanent, node_graph_state);
}
PANEL_CLEANUP_PROC(NodeGraph_Cleanup)
{
}
internal void
DrawGrid (v2 Offset, v2 GridSquareDim, rect PanelBounds, render_command_buffer* RenderBuffer)
{
r32 LineValue = .16f;
v4 LineColor = v4{LineValue, LineValue, LineValue, 1.f};
v2 GridSquareOffset = v2{
GSModF(Offset.x, GridSquareDim.x),
GSModF(Offset.y, GridSquareDim.y),
};
v2 GridOrigin = PanelBounds.Min + GridSquareOffset;
// Draw Vertical Lines
r32 XOffset = 0;
while (GridOrigin.x + XOffset < PanelBounds.Max.x)
{
v2 LineMin = v2{ GridOrigin.x + XOffset, PanelBounds.Min.y };
v2 LineMax = v2{ LineMin.x + 1, PanelBounds.Max.y };
PushRenderQuad2D(RenderBuffer, LineMin, LineMax, LineColor);
XOffset += GridSquareDim.x;
}
// Draw Horizontal Lines
r32 YOffset = 0;
while (GridOrigin.y + YOffset < PanelBounds.Max.y)
{
v2 LineMin = v2{ PanelBounds.Min.x, GridOrigin.y + YOffset };
v2 LineMax = v2{ PanelBounds.Max.x, LineMin.y + 1, };
PushRenderQuad2D(RenderBuffer, LineMin, LineMax, LineColor);
YOffset += GridSquareDim.y;
}
}
internal void
DrawNodePorts(node_specification Spec, b32 InputMask, v2 Position, r32 LineHeight, string_alignment TextAlign, v2 TextOffset, interface_config Interface, render_command_buffer* RenderBuffer)
{
v2 LinePosition = Position;
for (u32 i = 0; i < Spec.MemberListLength; i++)
{
node_struct_member Member = Spec.MemberList[i];
if ((Member.IsInput & InputMask) > 0)
{
string MemberName = MakeString(Member.Name, CharArrayLength(Member.Name));
DrawString(RenderBuffer, MemberName, Interface.Font, LinePosition + TextOffset, WhiteV4, TextAlign);
LinePosition.y -= LineHeight;
}
}
}
internal void
DrawNode (v2 Position, node_specification NodeSpecification, r32 NodeWidth, r32 LineHeight, interface_config Interface, render_command_buffer* RenderBuffer)
{
u32 InputMembers = 0;
u32 OutputMembers = 0;
for (u32 i = 0; i < NodeSpecification.MemberListLength; i++)
{
node_struct_member Member = NodeSpecification.MemberList[i];
if ((Member.IsInput & IsOutputMember) > 0) { OutputMembers++; }
if ((Member.IsInput & IsInputMember) > 0) { InputMembers++; }
}
u32 LineCount = 1 + GSMax(InputMembers, OutputMembers);
v2 NodeDim = v2{
NodeWidth,
(LineHeight * LineCount) + Interface.Margin.y,
};
rect NodeBounds = rect{
v2{ Position.x, Position.y - NodeDim.y },
v2{ Position.x + NodeDim.x, Position.y },
};
PushRenderQuad2D(RenderBuffer, NodeBounds.Min, NodeBounds.Max, v4{.16f, .16f, .16f, 1.f});
v2 LinePosition = v2{ NodeBounds.Min.x, NodeBounds.Max.y - LineHeight };
v2 TextOffset = v2{Interface.Margin.x, 0};
PushRenderQuad2D(RenderBuffer, LinePosition, LinePosition + v2{NodeWidth, LineHeight}, v4{1.f, .24f, .39f, 1.f});
string NodeName = MakeString(NodeSpecification.Name, NodeSpecification.NameLength);
DrawString(RenderBuffer, NodeName, Interface.Font, LinePosition + TextOffset, WhiteV4);
LinePosition.y -= LineHeight;
// Draw Ports
DrawNodePorts(NodeSpecification, IsInputMember, LinePosition, LineHeight, Align_Left, TextOffset, Interface, RenderBuffer);
v2 OutputLinePosition = v2{LinePosition.x + NodeDim.x, LinePosition.y };
v2 OutputTextOffset = v2{-TextOffset.x, TextOffset.y};
DrawNodePorts(NodeSpecification, IsOutputMember, OutputLinePosition, LineHeight, Align_Right, OutputTextOffset, Interface, RenderBuffer);
}
struct temp_node_connection
{
u32 DownstreamNodeIndex;
u32 DownstreamNodePort;
u32 UpstreamNodeIndex;
u32 UpstreamNodePort;
};
struct visual_node
{
node_specification Spec;
v2 Position;
};
#define TEMP_NODE_LIST_MAX 10
global_variable u32 TEMP_NodeListUsed = 0;
global_variable node_specification TEMP_NodeList[TEMP_NODE_LIST_MAX];
#define TEMP_CONNECTIONS_LIST_MAX 10
global_variable u32 TEMP_NodeConnectionsUsed = 0;
global_variable temp_node_connection TEMP_NodeConnections[TEMP_CONNECTIONS_LIST_MAX];
internal void
PushNodeOnNodeList(node_specification Spec)
{
if (TEMP_NodeListUsed < TEMP_NODE_LIST_MAX)
{
u32 Index = TEMP_NodeListUsed++;
TEMP_NodeList[Index] = Spec;
}
}
internal visual_node*
ArrangeNodes(node_specification* NodeList, u32 NodesCount, temp_node_connection* ConnectionList, u32 ConnectionsCount, r32 NodeWidth, r32 LayerDistance, memory_arena* Storage)
{
// Figure out how to arrange nodes
u32 LayerCount = 1;
u32* NodeLayers = PushArray(Storage, u32, NodesCount);
GSZeroMemory((u8*)NodeLayers, sizeof(u32) * NodesCount);
for (u32 c = 0; c < ConnectionsCount; c++)
{
temp_node_connection Connection = TEMP_NodeConnections[c];
u32 UpstreamNodeInitialLayer = NodeLayers[Connection.UpstreamNodeIndex];
u32 DownstreamNodeLayer = NodeLayers[Connection.DownstreamNodeIndex];
NodeLayers[Connection.UpstreamNodeIndex] = GSMax(UpstreamNodeInitialLayer, DownstreamNodeLayer + 1);
LayerCount = GSMax(NodeLayers[Connection.UpstreamNodeIndex] + 1, LayerCount);
}
// Place Layer Columns
v2* LayerPositions = PushArray(Storage, v2, LayerCount);
for (u32 l = 0; l < LayerCount; l++)
{
u32 FromRight = LayerCount - l;
LayerPositions[l] = v2{ (NodeWidth + LayerDistance) * FromRight, 0 };
}
// Place nodes
visual_node* VisualNodes = PushArray(Storage, visual_node, NodesCount);
for (u32 n = 0; n < NodesCount; n++)
{
VisualNodes[n].Spec = TEMP_NodeList[n];
u32 NodeLayer = NodeLayers[n];
VisualNodes[n].Position = LayerPositions[NodeLayer];
LayerPositions[NodeLayer].y -= 200;
}
return VisualNodes;
}
internal
PANEL_RENDER_PROC(NodeGraph_Render)
{
node_graph_state* GraphState = (node_graph_state*)Panel.PanelStateMemory;
rect NodeSelectionWindowBounds = rect{
PanelBounds.Min,
v2{PanelBounds.Min.x + 300, PanelBounds.Max.y},
};
rect GraphBounds = rect{
v2{NodeSelectionWindowBounds.Max.x, PanelBounds.Min.y},
PanelBounds.Max,
};
r32 NodeWidth = 150;
r32 LayerDistance = 100;
r32 LineHeight = (State->Interface.Font->PixelHeight + (2 * State->Interface.Margin.y));
visual_node* VisualNodes = ArrangeNodes(&TEMP_NodeList[0], TEMP_NodeListUsed,
&TEMP_NodeConnections[0], TEMP_NodeConnectionsUsed,
NodeWidth, LayerDistance,
&State->Transient);
DrawGrid(GraphState->ViewOffset, v2{100, 100}, GraphBounds, RenderBuffer);
render_quad_batch_constructor ConnectionsLayer = PushRenderQuad2DBatch(RenderBuffer, TEMP_NodeConnectionsUsed);
for (u32 i = 0; i < TEMP_NodeConnectionsUsed; i++)
{
temp_node_connection Connection = TEMP_NodeConnections[i];
visual_node UpstreamNode = VisualNodes[Connection.UpstreamNodeIndex];
visual_node DownstreamNode = VisualNodes[Connection.DownstreamNodeIndex];
v2 LineStart = GraphState->ViewOffset + UpstreamNode.Position + v2{NodeWidth, 0} - (v2{0, LineHeight} * (Connection.UpstreamNodePort + 2)) + v2{0, LineHeight / 3};
v2 LineEnd = GraphState->ViewOffset + DownstreamNode.Position - (v2{0, LineHeight} * (Connection.DownstreamNodePort + 2)) + v2{0, LineHeight / 3};
PushLine2DOnBatch(&ConnectionsLayer, LineStart, LineEnd, 1.5f, WhiteV4);
}
for (u32 i = 0; i < TEMP_NodeListUsed; i++)
{
visual_node VisualNode = VisualNodes[i];
DrawNode(VisualNode.Position + GraphState->ViewOffset, VisualNode.Spec, NodeWidth, LineHeight, State->Interface, RenderBuffer);
}
// Node Selection Panel
v4 LineBGColors[] = {
{ .16f, .16f, .16f, 1.f },
{ .18f, .18f, .18f, 1.f },
};
interface_list List = {};
List.LineBGColors = LineBGColors;
List.LineBGColorsCount = sizeof(LineBGColors) / sizeof(LineBGColors[0]);
List.LineBGHoverColor = v4{ .22f, .22f, .22f, 1.f };
List.TextColor = WhiteV4;
List.ListBounds = NodeSelectionWindowBounds;
List.ListElementDimensions = v2{
Width(NodeSelectionWindowBounds),
(r32)(State->Interface.Font->PixelHeight + 8),
};
List.ElementLabelIndent = v2{10, 4};
string TitleString = MakeStringLiteral("Available Nodes");
DrawListElement(TitleString, &List, Mouse, RenderBuffer, State->Interface);
for (s32 i = 0; i < NodeSpecificationsCount; i++)
{
node_specification Spec = NodeSpecifications[i];
string NodeName = MakeString(Spec.Name, Spec.NameLength);
rect ElementBounds = DrawListElement(NodeName, &List, Mouse, RenderBuffer, State->Interface);
if (MouseButtonTransitionedDown(Mouse.LeftButtonState)
&& PointIsInRect(Mouse.DownPos, ElementBounds))
{
PushNodeOnNodeList(Spec);
}
}
}