hzhang/Enigmos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor programmable modules

Browse Source
This commit is contained in:
h z
2024-07-06 02:12:54 +01:00
parent be5428d708
commit 3eec8a1345
26 changed files with 329 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Modules/BaseModule.cs
View File

@@ -97,7 +97,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
{
if (!Draggable)
return default;
Board!.ModuleMovingLayer.DraggingModule = this;
Board!.ModuleMovingLayer!.DraggingModule = this;
Board!.ModuleMovingLayer.MouseOffset = GetLocalMousePosition();
return GlobalProvider.DataStructureProvider!.NewVariantWithType("Module", this);
}
@@ -121,7 +121,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
{
if (!HasManual)
return;
if (Board.ManualOpened)
if (Board!.ManualOpened)
return;
if (Manual == null)
{
@@ -131,7 +131,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
Manual.Init(this);
}
Board.ModuleManualLayer.AddChild(Manual);
Board.ModuleManualLayer!.AddChild(Manual);
Manual.Position = Board.ModuleManualLayer.ManualPosition.Position - Manual.Size / 2;
Board.ManualOpened = true;
return;
@@ -148,7 +148,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
.Select(p => Board.CablePairing[p])
.ToHashSet();
if (this is ICompositeModule thisCompositeModule)
foreach (IBasePort port in thisCompositeModule.SubModules().SelectMany(module => module.Ports).Where(Board.CablePairing.ContainsKey))
foreach (IBasePort port in thisCompositeModule.SubModules.SelectMany(module => module.Ports).Where(Board.CablePairing.ContainsKey))
Board.FocusedCables.Add(Board.CablePairing[port]);
foreach (IBaseCable cable in Board.FocusedCables)
cable.Modulate = Color.Color8(255, 255, 255, 255);

2
Modules/ComputationalModules/ComputationalModule.cs
View File

@@ -1,5 +1,3 @@
using Enigmos.Exceptions;
using Enigmos.Ports.DataPorts;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;

43
Modules/InterlayerModules/FilterOutputModule.cs
View File

@@ -1,43 +0,0 @@
using Godot;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Enigmos.Modules.ComputationalModules;
using Nocturnis.GlobalManagement.Constants;
namespace Enigmos.Modules.InterlayerModules;
public partial class FilterOutputModule : NullaryComputationalModule, IInterlayerModule
{
public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
public IFilterModule FilterModule
{
get => (ParentModule as IFilterModule)!;
set => ParentModule = value;
}
public IDataOutPort? Output { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { Output! };
protected override bool Draggable => false;
protected override bool HasManual => false;
public override void Init()
{
base.Init();
this.DataOutInit("Output", 1);
Output = DataOutPorts[0];
PostInit();
}
public override void Define()
{
FilterModule.Filter();
Output!.OutData.UpdateCalculation(
cache => (FilterModule.CachedResult, EnigmosConstant.DataPortTypes.AnyArrayType)
);
}
public IBasePort UnderlyingPort => Output!;
public IProgrammableModule? ParentModule { get; set; }
}

13
Modules/InterlayerModules/InterlayerDataInModule.cs
View File

@@ -1,17 +1,18 @@
using Godot;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.InterlayerModules;
public partial class InterlayerDataInModule : BaseModule, IInterlayerDataInModule
public partial class InterlayerDataInModule : SubModule, IInterlayerDataInModule
{
protected override bool HasManual => false;
public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
public IProgrammableModule? ParentModule { get; set; }
protected override bool Draggable => false;
public IBasePort? UnderlyingPort => DataIn;
public new IProgrammableModule? ParentModule
{
get => base.ParentModule as IProgrammableModule;
set => base.ParentModule = value;
}
public IInterlayerDataOutModule? DualModule { get; set; }
public IDataInPort? DataIn { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { DataIn }!;

14
Modules/InterlayerModules/InterlayerDataOutModule.cs
View File

@@ -8,13 +8,15 @@ using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.InterlayerModules;
public partial class InterlayerDataOutModule : ComputationalModule, IInterlayerDataOutModule
public partial class InterlayerDataOutModule : SubModule, IComputationalModule, IInterlayerDataOutModule
{
public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
public IProgrammableModule? ParentModule { get; set; }
public new IProgrammableModule? ParentModule
{
get => base.ParentModule as IProgrammableModule;
set => base.ParentModule = value;
}
protected override bool Draggable => false;
protected override bool HasManual => false;
public IDataOutPort[] DataOutPorts { get; set; }
public IBasePort UnderlyingPort => DataOut!;
public IInterlayerDataInModule? DualModule { get; set; }
public IDataOutPort? DataOut { get; set; }
@@ -28,7 +30,7 @@ public partial class InterlayerDataOutModule : ComputationalModule, IInterlayerD
PostInit();
}
public override void Define()
public void Define()
{
DataOut!.OutData = DualModule!.DataIn!.GetData;
}

11
Modules/InterlayerModules/InterlayerSignalInModule.cs
View File

@@ -6,12 +6,13 @@ using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
namespace Enigmos.Modules.InterlayerModules;
public partial class InterlayerSignalInModule : BaseModule, IInterlayerSignalInModule
public partial class InterlayerSignalInModule : SubModule, IInterlayerSignalInModule
{
public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
public IProgrammableModule? ParentModule { get; set; }
protected override bool Draggable => false;
protected override bool HasManual => false;
public new IProgrammableModule? ParentModule
{
get => base.ParentModule as IProgrammableModule;
set => base.ParentModule = value;
}
public IBasePort UnderlyingPort => SignalIn!;
public IInterlayerSignalOutModule? DualModule { get; set; }
public ISignalInPort? SignalIn { get; set; }

16
Modules/InterlayerModules/InterlayerSignalOutModule.cs
View File

@@ -1,4 +1,3 @@
using Godot;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
@@ -6,13 +5,13 @@ using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
namespace Enigmos.Modules.InterlayerModules;
public partial class InterlayerSignalOutModule : BaseModule, IInterlayerSignalOutModule
public partial class InterlayerSignalOutModule : SubModule, IInterlayerSignalOutModule
{
public override Vector2 PositionToBoard =>
base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
public IProgrammableModule? ParentModule { get; set; }
protected override bool Draggable => false;
protected override bool HasManual => false;
public new IProgrammableModule? ParentModule
{
get => base.ParentModule as IProgrammableModule;
set => base.ParentModule = value;
}
public IBasePort UnderlyingPort => SignalOut!;
public IInterlayerSignalInModule? DualModule { get; set; }
public ISignalOutPort? SignalOut { get; set; }
@@ -27,7 +26,4 @@ public partial class InterlayerSignalOutModule : BaseModule, IInterlayerSignalOu
SignalOut = SignalOutPorts[0];
PostInit();
}
public bool Visited { get; set; }
}

39
Modules/InterlayerModules/IterativeOutputModule.cs
View File

@@ -1,39 +0,0 @@
using Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
namespace Enigmos.Modules.InterlayerModules;
public partial class IterativeOutputModule : NullaryComputationalModule, IInterlayerModule, IDuplicateOutputModule
{
protected override bool Draggable => false;
protected override bool HasManual => false;
public IDataOutPort? Output { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { Output }!;
public override void Init()
{
base.Init();
this.DataOutInit("DataOut", 1);
Output = DataOutPorts[0];
PostInit();
}
public override void Define()
{
if (ParentModule is IOptimizationModule opm)
this.Define(cache => (opm.CachedResult.Data, opm.CachedResult.Type)!);
if (ParentModule is IFilterModule fm)
this.Define(cache => (fm.CachedResult, EnigmosConstant.DataPortTypes.AnyArrayType));
}
//protected override void Compute(IRootModule root) => throw new Exception("Should be Handled by Other Module");
public IBasePort UnderlyingPort => Output!;
public IProgrammableModule? ParentModule { get; set; }
}

42
Modules/InterlayerModules/OptimizationItemOutputModule.cs
View File

@@ -1,42 +0,0 @@
using Enigmos.Modules.ComputationalModules;
using Godot;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.InterlayerModules;
public partial class OptimizationItemOutputModule : NullaryComputationalModule, IInterlayerModule
{
public override Vector2 PositionToBoard =>
base.PositionToBoard + (OptimizationModule?.PositionToBoard ?? Vector2.Zero);
protected override bool Draggable => false;
protected override bool HasManual => false;
public IOptimizationModule OptimizationModule
{
get => (ParentModule as IOptimizationModule)!;
set => ParentModule = value;
}
public IDataOutPort DataOut { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { DataOut };
//protected override void Compute(IRootModule root) => OptimizationModule.OptimizeWithTimeoutHandle(root);
public override void Init()
{
base.Init();
this.DataOutInit("DataOut", 1);
DataOut = DataOutPorts[0];
PostInit();
}
public IBasePort UnderlyingPort => DataOut;
public IProgrammableModule? ParentModule { get; set; }
public override void Define()
{
IOptimizationModule im = (ParentModule as IOptimizationModule)!;
DataOut.OutData.UpdateCalculation(cache => (im.CachedResult.Data, im.CachedResult.Type)!);
}
}

44
Modules/InterlayerModules/OptimizationValueOutputModule.cs
View File

@@ -1,44 +0,0 @@
using Enigmos.Modules.ComputationalModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Godot;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.GlobalManagement.Constants;
namespace Enigmos.Modules.InterlayerModules;
public partial class OptimizationValueOutputModule : NullaryComputationalModule,
IInterlayerModule,
IDuplicateOutputModule
{
public override Vector2 PositionToBoard =>
base.PositionToBoard + (OptimizationModule?.PositionToBoard ?? Vector2.Zero);
protected override bool Draggable => false;
protected override bool HasManual => false;
public DataOutPort? DataOut { get; set; }
public IOptimizationModule OptimizationModule
{
get => (ParentModule as IOptimizationModule)!;
set => ParentModule = value;
}
public override IEnumerable<BasePort> Ports => new[] { DataOut }!;
public override void Init()
{
base.Init();
this.DataOutInit("DataOut", 1);
DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real);
PostInit();
}
public override void Define()
{
this.Define(cache => (OptimizationModule.CachedResult.Data, OptimizationModule.CachedResult.Type) );
}
public IBasePort UnderlyingPort => DataOut;
public IProgrammableModule? ParentModule { get; set; }
}

22
Modules/Other/IndicateInputModule.cs
View File

@@ -1,22 +0,0 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.Other;
public partial class IndicateInputModule : BaseModule, IParameterModule
{
public IDataInPort? Input { get; set; }
protected override bool Draggable => false;
protected override bool HasManual => false;
public override IEnumerable<IBasePort> Ports => new[] { Input! };
public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
public override void Init()
{
base.Init();
this.DataInInit("Input", 1);
Input = DataInPorts[0];
PostInit();
}
}

24
Modules/Other/OptimizationValueInputModule.cs
View File

@@ -1,24 +0,0 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
namespace Enigmos.Modules.Other;
public partial class OptimizationValueInputModule : BaseModule, IParameterModule
{
protected override bool Draggable => false;
protected override bool HasManual => false;
public IDataInPort? DataIn { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { DataIn! };
public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
public override void Init()
{
base.Init();
this.DataInInit("DataIn", 1);
DataIn = DataInPorts[0];
DataIn.SetDataType(EnigmosConstant.DataPortTypes.Real);
DataIn.Module = this;
}
}

15
Modules/ProgrammableModules/FilterModule/FilterIndicateModule.cs Normal file
View File

@@ -0,0 +1,15 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ProgrammableModules.FilterModule;
public partial class FilterIndicateModule : SubModule
{
public IDataInPort? Indicate { get; set; }
public override void Init()
{
base.Init();
Indicate = this.GetPort<IDataInPort>("Indicate");
}
}

37
Modules/ProgrammableModules/FilterModule/FilterInputProviderModule.cs Normal file
View File

@@ -0,0 +1,37 @@
using Enigmos.Boards;
using Godot;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ProgrammableModules.FilterModule;
public partial class FilterInputProviderModule : SubModule, IComputationalModule
{
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public IDataOutPort? Output { get; set; }
public FilterModuleBoard? ParentBoard { get; set; }
public void Init(FilterModuleBoard board)
{
base.Init();
ParentBoard = board;
this.DataOutInit("Output", 1);
Output = DataOutPorts[0];
PostInit();
}
public void Define()
{
(object, StringName) Func(CacheItem c)
{
IData w = ParentBoard!.FilterModule!.CachedInputArray[ParentBoard.FilterModule.ProcessingIndex];
return (w.Data, w.Type)!;
}
Output!.OutData.UpdateCalculation(Func);
}
}

99
Modules/ProgrammableModules/FilterModule.cs → Modules/ProgrammableModules/FilterModule/FilterModule.cs
View File

@@ -1,9 +1,5 @@
using Enigmos.Boards;
using Enigmos.Exceptions;
using Enigmos.Modules.ControllingModules;
using Enigmos.Modules.InterlayerModules;
using Enigmos.Modules.Other;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Nocturnis.DataStructures.DataPortGroups;
using Nocturnis.Enigmos.Modules;
@@ -14,107 +10,100 @@ using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
namespace Enigmos.Modules.ProgrammableModules;
namespace Enigmos.Modules.ProgrammableModules.FilterModule;
public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFilterModule
{
private IDataInPort? Input { get; set; }
public IDataInPort? InputArray { get; set; }
public FilterOutputModule? OutputArrayModule { get; set; }
private IInterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
private FilterOutputModule? Output { get; set; }
private IterativeOutputModule? IterativeOutput { get; set; }
private IndicateInputModule? Indicate { get; set; }
private IDataPortGroup[] InterLayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
private IDataPortGroup? ArrayGroup { get; set; }
private bool FilterEnded { get; set; }
private IData[] CachedInputArray { get; set; } = Array.Empty<IData>();
public IData[] CachedInputArray { get; set; } = Array.Empty<IData>();
public IData[] CachedResult { get; set; } = Array.Empty<IData>();
public bool FilterFinished { get; set; }
public bool FilterStarted { get; set; }
private List<IData> CachedListResult { get; set; } = new();
//private List<IData> CachedResult { get; set; } = new();
private int CachedIndex { get; set; }
public int ProcessingIndex { get; set; }
public new FilterModuleBoard UnderlyingBoard
{
get => (base.UnderlyingBoard as FilterModuleBoard)!;
set => base.UnderlyingBoard = value;
}
public override IEnumerable<IBasePort> Ports => new IBasePort[] { InputArray!, OutputArrayModule!.Output! };
public override IEnumerable<IBasePort> Ports => new[] { Input! };
public override IBaseModule[] SubModules() => ExplicitInputs.Union<IBaseModule>(new[] { Output! }).ToArray();
public override IBaseModule[] SubModules => ExplicitInputs;
public override IEnumerable<IBasePort> ExplicitPorts =>
new IBasePort[] { Output!.Output! }
new IBasePort[] { InputArray!, OutputArrayModule!.Output! }
.Union(ExplicitInputs.Select(c => c.DataIn))!
.ToArray<IBasePort>();
public override IEnumerable<IBasePort> ImplicitPorts =>
new IBasePort[] { IterativeOutput!.Output!, Indicate!.Input! }
.Union(UnderlyingBoard.Outputs.Select(c => c.DataOut))
new IBasePort[] { OutputArrayModule!.Output!, InputArray! }
.Union(UnderlyingBoard.FilterInputProxy.Select(c => c.DataOut))
.ToArray()!;
public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
public void Inference() => IterativeOutput!.Output!
.SetDataType(GlobalProvider.DataStructureProvider!.ArrayToElement(ArrayGroup!.SelectedType));
public void Inference()
{
}
public void Filter()
{
if (FilterEnded)
if (!FilterStarted)
{
CachedInputArray = Input!.GetData.Get!.Array;
CachedIndex = 0;
CachedInputArray = InputArray!.GetData.Get!.Array;
ProcessingIndex = 0;
CachedListResult = new List<IData>();
FilterStarted = true;
}
while (CachedIndex < CachedInputArray.Length)
while (ProcessingIndex < CachedInputArray.Length)
{
SoftReset();
IterativeOutput!.Output!.OutData.UpdateCalculation(cache =>
(CachedInputArray[CachedIndex].Data, IterativeOutput.Output.DataType)!);
IterativeOutput.Output.OutData.Expire();
if(Indicate!.Input!.GetData.Get!.Bit)
CachedListResult.Add(CachedInputArray[CachedIndex]);
CachedIndex += 1;
UnderlyingBoard.InputProvider!.Define();
UnderlyingBoard.InputProvider.Output!.OutData.Expire();
if(UnderlyingBoard.Indicate!.Indicate!.GetData.Get!.Bit)
CachedListResult.Add(CachedInputArray[ProcessingIndex]);
ProcessingIndex += 1;
}
CachedResult = CachedListResult.ToArray();
FilterEnded = true;
FilterFinished = true;
FilterStarted = false;
}
private void SoftReset() => UnderlyingBoard.Reset();
public override void Init()
{
base.Init();
InputArray = this.GetPort<IDataInPort>("InputArray");
OutputArrayModule = GetModule<FilterOutputModule>("OutputArray");
UnderlyingBoard = GlobalProvider.SceneProvider!
.AssetMapper<FilterModuleBoard>()
.Instantiate<FilterModuleBoard>();
UnderlyingBoard.Init();
ExplicitInputs = new InterlayerDataInModule[3];
InterLayerGroups = new IDataPortGroup[3];
IterativeOutput = UnderlyingBoard.IterativeOutput;
IterativeOutput.Output.SetDataType(EnigmosConstant.DataPortTypes.Real);
Indicate = UnderlyingBoard.Indicate;
ExplicitInputs = new IInterlayerDataInModule[3];
for (int i = 0; i < 3; i++)
{
ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
ExplicitInputs[i].DualModule = UnderlyingBoard.Outputs[i];
UnderlyingBoard.Outputs[i].DualModule = ExplicitInputs[i];
}
FilterEnded = true;
OutputArrayModule.Init(this);
UnderlyingBoard.Init(this);
FilterFinished = false;
FilterStarted = false;
Input = this.GetPort<DataInPort>("Input");
Output = GetModule<FilterOutputModule>("Output");
for (int i = 0; i < 3; i++)
{
InterLayerGroups[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
InterLayerGroups[i] = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
this,
new IDataPort[] { ExplicitInputs[i].DataIn, UnderlyingBoard.Outputs[i].DataOut },
new IDataPort[] { ExplicitInputs[i].DataIn!, UnderlyingBoard.FilterInputProxy[i].DataOut! },
$"Exterior In -> Interior Out{i}",
EnigmosConstant.DataPortTypes.Real,
EnigmosConstant.DataPortTypes.AnyType
@@ -124,7 +113,7 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
ArrayGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
this,
new IDataPort[] { Input, Output.Output! },
new IDataPort[] { InputArray, OutputArrayModule.Output! },
"Array Type",
EnigmosConstant.DataPortTypes.RealArray,
EnigmosConstant.DataPortTypes.AnyArray
@@ -133,8 +122,6 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
ConfigurablePortGroups = InterLayerGroups.Union(new[] { ArrayGroup }).ToHashSet();
PostInit();
}
}
}

41
Modules/ProgrammableModules/FilterModule/FilterOutputModule.cs Normal file
View File

@@ -0,0 +1,41 @@
using Godot;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ProgrammableModules.FilterModule;
public partial class FilterOutputModule : SubModule, IComputationalModule
{
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public IDataOutPort? Output { get; set; }
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public new IFilterModule? ParentModule {
get => base.ParentModule as IFilterModule;
set => base.ParentModule = value;
}
public void Init(IFilterModule parent)
{
base.Init();
this.DataOutInit("Output", 1);
Output = DataOutPorts[0];
ParentModule = parent;
PostInit();
}
public void Define()
{
(object, StringName) Func(CacheItem c)
{
if (!ParentModule!.FilterFinished)
ParentModule!.Filter();
return (ParentModule!.CachedResult, EnigmosConstant.DataPortTypes.AnyArrayType);
}
Output!.OutData.UpdateCalculation(Func);
}
}

4
Modules/ProgrammableModules/FunctionModule.cs → Modules/ProgrammableModules/FunctionModule/FunctionModule.cs
View File

@@ -8,7 +8,7 @@ using Nocturnis.Enigmos.Ports.DataPorts;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
namespace Enigmos.Modules.ProgrammableModules;
namespace Enigmos.Modules.ProgrammableModules.FunctionModule;
public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
{
private IDataPortGroup[] ExteriorToInterior { get; set; } = Array.Empty<IDataPortGroup>();
@@ -34,7 +34,7 @@ public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
private static readonly PackedScene FunctionModuleBoardScene = GlobalProvider.SceneProvider!
.AssetMapper<FunctionModuleBoard>();
public override BaseModule[] SubModules() =>
public override BaseModule[] SubModules =>
ExplicitDataInModules
.Union<BaseModule>(ExplicitDataOutModules)
.Union(ExplicitSignalInModules)

36
Modules/ProgrammableModules/OptimizationModule/OptimizationInputProviderModule.cs Normal file
View File

@@ -0,0 +1,36 @@
using Enigmos.Boards;
using Godot;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationInputProviderModule : SubModule, IComputationalModule
{
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public IDataOutPort? Output { get; set; }
public OptimizationModuleBoard? ParentBoard { get; set; }
public void Init(OptimizationModuleBoard board)
{
base.Init();
ParentBoard = board;
this.DataOutInit("Output", 1);
Output = DataOutPorts[0];
PostInit();
}
public void Define()
{
(object, StringName) Func(CacheItem c)
{
IData w = ParentBoard!.OptimizationModule!.CachedInput[ParentBoard.OptimizationModule.ProcessingIndex];
return (w.Data, w.Type)!;
}
Output!.OutData.UpdateCalculation(Func);
}
}

78
Modules/ProgrammableModules/OptimizationModule.cs → Modules/ProgrammableModules/OptimizationModule/OptimizationModule.cs
View File

@@ -1,46 +1,47 @@
using Enigmos.Boards;
using Enigmos.Exceptions;
using Enigmos.Modules.ControllingModules;
using Enigmos.Modules.InterlayerModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Godot;
using Nocturnis.DataStructures;
using Nocturnis.DataStructures.ConfigurableParameters;
using Nocturnis.DataStructures.DataPortGroups;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.InterlayerModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
namespace Enigmos.Modules.ProgrammableModules;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationModule : ProgrammableModule,
IPolymorphismModule,
IParameterizedModule,
public partial class OptimizationModule : ProgrammableModule,
IPolymorphismModule,
IParameterizedModule,
IOptimizationModule
{
private bool OptimizationEnded { get; set; }
public bool OptimizationFinished { get; set; }
public bool OptimizationStarted { get; set; }
private double? CachedOptimizeValue { get; set; }
public IDataInPort? InternalIterOut { get; set; }
public IDataOutPort? InternalArrayIn { get; set; }
public IDataInPort? ArrayInput { get; set; }
public IInterlayerDataInModule[] ExplicitOutputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
public IInterlayerDataOutModule[] ImplicitInputs { get; set; } = Array.Empty<IInterlayerDataOutModule>();
public IData[] CachedInput { get; set; } = Array.Empty<IData>();
public int ProcessingIndex { get; set; }
private IBoolParameter? UsingMax { get; set; }
public IData CachedResult { get; set; } =
GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
private IData[] CachedInput { get; set; } = Array.Empty<IData>();
private int ProcessingIndex { get; set; }
private IBoolParameter? UsingMax { get; set; }
public IDataInPort? InternalIterOut { get; set; }
public IDataOutPort? InternalArrayIn { get; set; }
private IDataPortGroup[] InterlayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
private IDataPortGroup? OptimizationGroup { get; set; }
private DataInPort? ArrayInput { get; set; }
private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
private OptimizationItemOutputModule? ItemOut { get; set; }
private OptimizationValueOutputModule? ValueOut { get; set; }
private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
private OptimizationSelectorModule? Selector { get; set; }
private OptimizationOutputModule? Output { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { ArrayInput! };
public new OptimizationModuleBoard UnderlyingBoard
@@ -53,17 +54,17 @@ public partial class OptimizationModule : ProgrammableModule,
public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
public override IEnumerable<IBasePort> ExplicitPorts =>
new IBasePort[] { ItemOut!.DataOut, ValueOut!.DataOut! }
new IBasePort[] { ArrayInput!, Output!.Output! }
.Union<IBasePort>(ExplicitInputs.Select(c => c.DataIn)!);
public override BaseModule[] SubModules() =>
public override BaseModule[] SubModules =>
ExplicitInputs
.Union(new BaseModule[] { ItemOut, ValueOut })
.Union(new BaseModule[] { Output! })
.ToArray();
public override IEnumerable<IBasePort> ImplicitPorts =>
new IBasePort[] { UnderlyingBoard.IterOut.Output, UnderlyingBoard.ValueIn.DataIn }
.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut));
new IBasePort[] { UnderlyingBoard.InputProvider!.Output!, UnderlyingBoard.Selector!.Selector! }
.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut))!;
public override void Init()
{
@@ -75,7 +76,8 @@ public partial class OptimizationModule : ProgrammableModule,
InterlayerGroups = new IDataPortGroup[3];
ExplicitInputs = new InterlayerDataInModule[3];
InternalIterOut = this.GetPort<IDataInPort>("InternalIterOut");
Output = GetModule<OptimizationOutputModule>("Output");
Output.Init();
for (int i = 0; i < 3; i++)
{
ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
@@ -83,7 +85,7 @@ public partial class OptimizationModule : ProgrammableModule,
UnderlyingBoard.ImplicitDataOuts[i].DualModule = ExplicitInputs[i];
}
OptimizationEnded = true;
OptimizationFinished = true;
CachedInput = Array.Empty<IData>();
//CachedArray = Array.Empty<DataPackage>();
ProcessingIndex = 0;
@@ -91,9 +93,7 @@ public partial class OptimizationModule : ProgrammableModule,
CachedOptimizeValue = null;
ArrayInput = this.GetPort<DataInPort>("ArrayInput");
ItemOut = GetModule<OptimizationItemOutputModule>("ItemOut");
ValueOut = GetModule<OptimizationValueOutputModule>("ValueOut");
for (int i = 0; i < 3; i++)
{
InterlayerGroups[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
@@ -119,8 +119,8 @@ public partial class OptimizationModule : ProgrammableModule,
"Min",
true
);
ItemOut.DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real);
ValueOut.DataOut!.SetDataType(EnigmosConstant.DataPortTypes.Real);
Output.Output!.SetDataType(EnigmosConstant.DataPortTypes.Real);
Selector!.Selector!.SetDataType(EnigmosConstant.DataPortTypes.Real);
ConfigurableParameters = new HashSet<IConfigurableParameter> { UsingMax };
ConfigurablePortGroups =
InterlayerGroups.Union(new[] { OptimizationGroup }).ToHashSet();
@@ -132,31 +132,31 @@ public partial class OptimizationModule : ProgrammableModule,
public void Inference()
{
StringName elementType = GlobalProvider.DataPackageTypeProvider!.ToElement(OptimizationGroup!.SelectedType);
ItemOut!.DataOut.SetDataType(elementType);
UnderlyingBoard.IterOut!.Output!.SetDataType(elementType);
Output!.Output!.SetDataType(elementType);
UnderlyingBoard.InputProvider!.Output!.SetDataType(elementType);
}
private void SoftReset() => UnderlyingBoard.Reset();
public void Optimize()
{
if (OptimizationEnded)
if (OptimizationFinished)
{
CachedOptimizeValue = null;
CachedInput = InternalArrayIn!.OutData.Get!.Array;
CachedResult = GlobalProvider.DataStructureProvider.NewData(0, EnigmosConstant.DataPortTypes.Null);
CachedResult = GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
ProcessingIndex = 0;
}
while (ProcessingIndex < CachedInput.Length)
{
SoftReset();
UnderlyingBoard.IterOut!.Output!.OutData.UpdateCalculation(
UnderlyingBoard.InputProvider!.Output!.OutData.UpdateCalculation(
cache =>
(CachedInput[ProcessingIndex].Data, CachedInput[ProcessingIndex].Type)!
);
UnderlyingBoard.IterOut.Output.OutData.Expire();
double currentValue = UnderlyingBoard.ValueIn!.DataIn!.GetData.Get!.Double;
UnderlyingBoard.InputProvider.Output.OutData.Expire();
double currentValue = UnderlyingBoard.Selector!.Selector!.GetData.Get!.Double;
IData currentOut = InternalIterOut!.GetData.Get!;
if (UsingMax!.ParameterValue)
{
@@ -177,8 +177,8 @@ public partial class OptimizationModule : ProgrammableModule,
ProcessingIndex++;
}
ValueOut!.Define();
OptimizationEnded = true;
Output!.Define();
OptimizationFinished = true;
}
public bool Calculated { get; set; }

25
Modules/ProgrammableModules/OptimizationModule/OptimizationOutputModule.cs Normal file
View File

@@ -0,0 +1,25 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationOutputModule : SubModule, IComputationalModule
{
public IDataOutPort? Output { get; set; }
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public override void Init()
{
this.DataOutInit("DataOut", 1);
Output = DataOutPorts[0];
}
public void Define()
{
throw new NotImplementedException();
}
}

14
Modules/ProgrammableModules/OptimizationModule/OptimizationSelectorModule.cs Normal file
View File

@@ -0,0 +1,14 @@
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationSelectorModule : SubModule
{
public IDataInPort? Selector { get; set; }
public override void Init()
{
base.Init();
Selector = this.GetPort<IDataInPort>("Selector");
}
}

4
Modules/ProgrammableModules/ProgrammableModule.cs
View File

@@ -9,7 +9,7 @@ namespace Enigmos.Modules.ProgrammableModules;
public abstract partial class ProgrammableModule : BaseModule, ICompositeModule, IProgrammableModule
{
public BaseBoard? UnderlyingBoard { get; set; }
public abstract IBaseModule[] SubModules();
public abstract IBaseModule[] SubModules { get; }
public void EnterProgrammableBoard() => GlobalProvider.SceneProvider!.RootScene.ChangeScene(UnderlyingBoard!);
public abstract IEnumerable<IBasePort> ExplicitPorts { get; }
public abstract IEnumerable<IBasePort> ImplicitPorts { get; }
@@ -24,7 +24,7 @@ public abstract partial class ProgrammableModule : BaseModule, ICompositeModule,
base.UpdateCables();
}
protected T GetModule<T>(string path) where T : BaseModule, IInterlayerModule
protected T GetModule<T>(string path) where T : SubModule
{
T res = GetNode<T>(path);
res.Init();

13
Modules/SubModule.cs Normal file
View File

@@ -0,0 +1,13 @@
using Godot;
using Nocturnis.Enigmos.Modules;
namespace Enigmos.Modules;
public class SubModule : BaseModule
{
public IBaseModule? ParentModule { get; set; }
public sealed override Vector2 PositionToBoard =>
base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
protected sealed override bool Draggable => false;
protected sealed override bool HasManual => false;
}