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

project update

Browse Source
This commit is contained in:
h z
2024-06-30 01:52:44 +08:00
parent 117835b503
commit 59d257c06a
67 changed files with 2268 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
Modules/TerminalModules/MemoryModule.cs Normal file
View File

@@ -0,0 +1,91 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Modules.Other;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using TabulaSmaragdina;
using TabulaSmaragdina.Constants;
namespace Enigmos.Modules.TerminalModules;
public partial class MemoryModule : TerminalModule, IPolymorphismModule, IComputationalCompositeModule
{
private DataInPort? Input1 { get; set; }
private DataInPort? Input2 { get; set; }
private DataInPort? Input3 { get; set; }
private IDataPackage? Memory { get; set; }
private IDataPortGroup? MemoryPortGroup { get; set; }
public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
private OutputSubModule? Output1 { get; set; }
private OutputSubModule? Output2 { get; set; }
private OutputSubModule? Output3 { get; set; }
private OutputSubModule? Output4 { get; set; }
public override IEnumerable<BasePort> Ports => new BasePort[] { Input1!, Input2!, Input3! };
public IBaseModule[] SubModules() => new IBaseModule[] { Output1!, Output2!, Output3!, Output4! };
protected OutputSubModule GetOutputModule(string path)
{
OutputSubModule res = GetNode<OutputSubModule>(path);
res.Init();
res.ParentModule = this;
res.Board = Board;
return res;
}
public override void Init()
{
base.Init();
Memory = GlobalProvider.DataStructureProvider!.NewDataPackage();
Input1 = GetPort<DataInPort>("Input1");
Input2 = GetPort<DataInPort>("Input2");
Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Input3 = GetPort<DataInPort>("Input3");
Input3.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Output1 = GetOutputModule("Output1");
Output2 = GetOutputModule("Output2");
Output3 = GetOutputModule("Output3");
Output4 = GetOutputModule("Output4");
MemoryPortGroup =GlobalProvider.DataStructureProvider!.NewDataPortGroup(
this,
new IDataPort[] { Input1, Output1.DataOut, Output2.DataOut, Output3.DataOut, Output4.DataOut },
"Memory Data Type:",
EnigmosConstant.DataPortTypes.Real,
EnigmosConstant.DataPortTypes.AnyType
);
ConfigurablePortGroups = new HashSet<IDataPortGroup>() { MemoryPortGroup };
PostInit();
}
public void Inference()
{
}
public void Compute(IRootModule root)
{
Output1!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup!.SelectedType);
Output2!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType);
Output3!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType);
Output4!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType);
}
protected override void Consume(RootModule root)
{
bool setValue = Input2!.GetData(root).Bit;
bool resetValue = Input3!.GetData(root).Bit;
if (setValue)
Memory!.Assign(Input1!.GetData(root), MemoryPortGroup!.SelectedType);
else if(resetValue)
Memory!.Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, MemoryPortGroup!.SelectedType);
Finished = true;
}
public override void UpdateCables()
{
base.UpdateCables();
foreach (BaseModule subModule in SubModules())
subModule.UpdateCables();
}
}

66
Modules/TerminalModules/SRLatchModule.cs Normal file
View File

@@ -0,0 +1,66 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Modules.Other;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.Enigmos.Modules;
using TabulaSmaragdina.Constants;
namespace Enigmos.Modules.TerminalModules;
public partial class SRLatchModule : TerminalModule, IComputationalCompositeModule
{
private DataInPort? Input1 { get; set; }
private DataInPort? Input2 { get; set; }
public OutputSubModule? Output1 { get; set; }
public OutputSubModule? Output2 { get; set; }
public override IEnumerable<BasePort> Ports => new[] { Input1, Input2 }!;
private bool State { get; set; }
public IBaseModule[] SubModules() => new IBaseModule[] { Output1, Output2 };
public void Compute(IRootModule root)
{
Output1!.DataOut.ResultData.Bit = State;
Output2!.DataOut.ResultData.Bit = State;
}
protected override void Consume(RootModule root)
{
bool set = Input1!.GetData(root).Bit;
bool reset = Input2!.GetData(root).Bit;
if (set && reset)
State = false;
else if (set)
State = true;
else if (reset)
State = false;
}
protected OutputSubModule GetOutputModule(string path)
{
OutputSubModule res = GetNode<OutputSubModule>(path);
res.Init();
res.ParentModule = this;
res.Board = Board;
return res;
}
public override void Init()
{
base.Init();
Input1 = GetPort<DataInPort>("Input1");
Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Input2 = GetPort<DataInPort>("Input2");
Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Output1 = GetOutputModule("Output1");
Output1.DataOut.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Output2 = GetOutputModule("Output2");
Output2.DataOut.SetDataType(EnigmosConstant.DataPortTypes.Bit);
PostInit();
}
public override void UpdateCables()
{
base.UpdateCables();
foreach (IBaseModule subModule in SubModules())
subModule.UpdateCables();
}
}

38
Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs Normal file
View File

@@ -0,0 +1,38 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Godot;
using Nocturnis.Enigmos.Ports;
using TabulaSmaragdina.Constants;
namespace Enigmos.Modules.TerminalModules.TestingModules;
public partial class LightEmittingDiodeModule : TerminalModule
{
private Sprite2D LightEmittingDiode { get; set; }
private DataInPort Input { get; set; }
public override IEnumerable<IBasePort> Ports => new[] { Input };
private static readonly Texture2D TrueTexture =
ResourceLoader.Load<Texture2D>("res://Resources/Circuits/Modules/Terminal/Testing/LEDBubble-T.png");
private static readonly Texture2D FalseTexture =
ResourceLoader.Load<Texture2D>("res://Resources/Circuits/Modules/Terminal/Testing/LEDBubble-F.png");
public override void Init()
{
base.Init();
Finished = true;
LightEmittingDiode = GetNode<Sprite2D>("LightEmittingDiode");
Input = GetPort<DataInPort>("Input");
Input.SetDataType(EnigmosConstant.DataPortTypes.Bit);
PostInit();
}
protected override void Consume(RootModule root)
{
if (Input.GetData(root).Bit)
LightEmittingDiode.Texture = TrueTexture;
else
LightEmittingDiode.Texture = FalseTexture;
Finished = true;
}
}

34
Modules/TerminalModules/TestingModules/R2Reader.cs Normal file
View File

@@ -0,0 +1,34 @@
using Godot;
using Skeleton.Utils.Helpers;
using R2 = Skeleton.Algebra.CategoryOf<Skeleton.Algebra.DimensionProviders.IDim2>.OnField<double>.FVector;
namespace Enigmos.Modules.TerminalModules.TestingModules;
public partial class R2Reader : Control
{
private AnimatedSprite2D Direction { get; set; }
private AnimatedSprite2D Magnitude { get; set; }
public R2 UnderlyingVector { get; set; }
private double TargetPhase() => Math.Atan2(UnderlyingVector[2], UnderlyingVector[1]);
private double TargetLength() => UnderlyingVector.Magnitude;
private int TargetPhaseFrame =>
Mathf.FloorToInt((TargetPhase() % (2d * Math.PI) + 2d * Math.PI) % (2d * Math.PI) * 44d / (2d * Math.PI));
private int TargetLengthFrame =>
Mathf.FloorToInt(TargetLength().DoubleCut() * 9d);
public override void _Process(double delta)
{
Magnitude.SpeedScale = (TargetLengthFrame - Magnitude.Frame) / 7f;
var debug = new[] { TargetPhaseFrame - Direction.Frame, TargetPhaseFrame + 44 - Direction.Frame };
Direction.SpeedScale = debug.MinBy(Math.Abs) / 25f;
}
public void Init()
{
Direction = GetNode<AnimatedSprite2D>("Direction");
Magnitude = GetNode<AnimatedSprite2D>("Magnitude");
Direction.Play();
Magnitude.Play();
}
}

29
Modules/TerminalModules/TestingModules/R2ReaderModule.cs Normal file
View File

@@ -0,0 +1,29 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using TabulaSmaragdina.Constants;
namespace Enigmos.Modules.TerminalModules.TestingModules;
public partial class R2ReaderModule : TerminalModule
{
private DataInPort DataIn { get; set; }
private R2Reader R2Reader { get; set; }
public override IEnumerable<BasePort> Ports => new[] { DataIn };
public override void Init()
{
base.Init();
DataIn = GetPort<DataInPort>("DataIn");
DataIn.SetDataType(EnigmosConstant.DataPortTypes.R2);
R2Reader = GetNode<R2Reader>("R2Reader");
R2Reader.Init();
PostInit();
}
protected override void Consume(RootModule root)
{
R2Reader.UnderlyingVector = DataIn.GetData(root).R2;
}
}

45
Modules/TerminalModules/TestingModules/RealReaderModule.cs Normal file
View File

@@ -0,0 +1,45 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Godot;
using Skeleton.Utils.Helpers;
using TabulaSmaragdina.Constants;
namespace Enigmos.Modules.TerminalModules.TestingModules;
public partial class RealReaderModule : TerminalModule
{
private DataInPort Input1 { get; set; }
private DataInPort Input2 { get; set; }
private DataInPort Input3 { get; set; }
private AnimatedSprite2D RealReader { get; set; }
public override IEnumerable<BasePort> Ports => new[] { Input1, Input2, Input3 };
public override void Init()
{
base.Init();
Input1 = GetPort<DataInPort>("Input1");
Input2 = GetPort<DataInPort>("Input2");
Input3 = GetPort<DataInPort>("Input3");
Input1.SetDataType(EnigmosConstant.DataPortTypes.Real);
Input2.SetDataType(EnigmosConstant.DataPortTypes.Real);
Input3.SetDataType(EnigmosConstant.DataPortTypes.Real);
RealReader = GetNode<AnimatedSprite2D>("RealReader");
RealReader.SpeedScale = 0;
RealReader.Play();
PostInit();
}
protected override void Consume(RootModule root)
{
double max = Input1.GetData(root).Real;
double min = Input3.GetData(root).Real;
double value = Input2.GetData(root).Real;
//DebugToolWindow.FreeInfo = $"{value}";
double range = max - min;
double percentage = (range == 0 ? 0d : value / range).DoubleCut();
int frame = Mathf.FloorToInt(percentage * 122);
RealReader.SpeedScale = (frame - RealReader.Frame) / 60f;
Finished = true;
}
}