public void OnImportsSatisfied()
{
var attr = new InputAttribute("Input");
attr.Order = 0;
FInput = new GenericInput(FPluginHost, attr);
}
public DX11CubeRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
this.FInFormat = iofactory.CreateDiffSpread <EnumEntry>(tattr);
lookatvectors.Add(new Vector3(1, 0, 0));
lookatvectors.Add(new Vector3(-1, 0, 0));
lookatvectors.Add(new Vector3(0, 1, 0));
lookatvectors.Add(new Vector3(0, -1, 0));
lookatvectors.Add(new Vector3(0, 0, 1));
lookatvectors.Add(new Vector3(0, 0, -1));
upvectors.Add(new Vector3(0, 1, 0));
upvectors.Add(new Vector3(0, 1, 0));
upvectors.Add(new Vector3(0, 0, -1));
upvectors.Add(new Vector3(0, 0, 1));
upvectors.Add(new Vector3(0, 1, 0));
upvectors.Add(new Vector3(0, 1, 0));
//this.depthmanager = new DepthBufferManager(FHost,iofactory);
}
private void SetInputs()
{
if (this.FInputCount[0] != FLayers.Count)
{
if (this.FInputCount[0] > FLayers.Count)
{
while (this.FInputCount[0] > FLayers.Count)
{
InputAttribute attr = new InputAttribute("Layer " + Convert.ToString(this.FLayers.Count + 1));
attr.IsSingle = false;
attr.CheckIfChanged = true;
attr.AutoValidate = false;
//Create new layer Pin
IIOContainer <Pin <DX11Resource <DX11Layer> > > newlayer = this.FIOFactory.CreateIOContainer <Pin <DX11Resource <DX11Layer> > >(attr);
newlayer.IOObject.SliceCount = 1;
this.FLayers.Add(newlayer);
newlayer.IOObject[0] = new DX11Resource <DX11Layer>();
}
}
else
{
while (this.FInputCount[0] < FLayers.Count)
{
this.FLayers[this.FLayers.Count - 1].Dispose();
this.FLayers.RemoveAt(this.FLayers.Count - 1);
}
}
}
}
void HandleCountSpreadChanged(IDiffSpread <int> spread)
{
int oldCount = FIOContainers.Count;
int newCount = Math.Max(spread[0], 0);
for (int i = oldCount; i < newCount; i++)
{
var attribute = new InputAttribute(string.Format("{0} {1}", FInputAttribute.Name, i + 1))
{
IsPinGroup = false,
Order = FInputAttribute.Order + FOffsetCounter * 1000 + i,
BinOrder = FInputAttribute.Order + FOffsetCounter * 1000 + i,
AutoValidate = FInputAttribute.AutoValidate
};
var io = FFactory.CreateIOContainer(typeof(IInStream <T>), attribute);
FIOContainers.Add(io);
}
for (int i = oldCount - 1; i >= newCount; i--)
{
var io = FIOContainers[i];
FIOContainers.Remove(io);
io.Dispose();
}
FStreams.Length = FIOContainers.Count;
using (var writer = FStreams.GetWriter())
{
foreach (var io in FIOContainers)
{
writer.Write(io.RawIOObject as IInStream <T>);
}
}
}
protected override InputAttribute GetEnumPin()
{
InputAttribute attr = new InputAttribute("Mode");
attr.EnumName = DX11DepthStencilStates.Instance.EnumName;
return(attr);
}
public DX11CubeRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.IsSingle = true;
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
this.FInFormat = iofactory.CreateDiffSpread<EnumEntry>(tattr);
this.depthmanager = new DepthBufferManager(FHost, iofactory);
this.lookats.Add(new Vector3(1.0f, 0.0f, 0.0f));
this.lookats.Add(new Vector3(-1.0f, 0.0f, 0.0f));
this.lookats.Add(new Vector3(0.0f, 1.0f, 0.0f));
this.lookats.Add(new Vector3(0.0f, - 1.0f, 0.0f));
this.lookats.Add(new Vector3(0.0f, 0.0f, 1.0f));
this.lookats.Add(new Vector3(0.0f, 0.0f, -1.0f));
this.upvectors.Add(new Vector3(0.0f, 1.0f, 0.0f));
this.upvectors.Add(new Vector3(0.0f, 1.0f, 0.0f));
this.upvectors.Add(new Vector3(0.0f, 0.0f, -1.0f));
this.upvectors.Add(new Vector3(0.0f, 0.0f, 1.0f));
this.upvectors.Add(new Vector3(0.0f, 1.0f, 0.0f));
this.upvectors.Add(new Vector3(0.0f, 1.0f, 0.0f));
}
public MultiDimInStream(IIOFactory factory, InputAttribute attribute)
{
FDataContainer = factory.CreateIOContainer <IInStream <T> >(attribute, false);
FBinSizeContainer = factory.CreateIOContainer <IInStream <int> >(attribute.GetBinSizeInputAttribute(), false);
FDataStream = FDataContainer.IOObject;
FBinSizeStream = (IntInStream)FBinSizeContainer.IOObject;
}
public ClassConstructor(ConstructorInfo cinfo, Parameter[] parameters)
{
_constructorInfo = cinfo;
object[] attrs = cinfo.GetCustomAttributes(false);
List <string> inputs = new List <string>();
foreach (object obj in attrs)
{
if (obj is InputAttribute)
{
InputAttribute attr = obj as InputAttribute;
_error |= ~FlagsError.InputInfoNotFound;
inputs.AddRange(attr.Parameters);
}
}
foreach (string input in inputs)
{
bool find = false;
foreach (Parameter param in parameters)
{
if (param.Name == input)
{
_parameters.Add(param);
find = true;
}
}
if (!find)
{
_error |= FlagsError.ParameterNotFound;
}
}
}
private void SetInputs()
{
if (this.FInputCount[0] != FInputs.Count)
{
if (this.FInputCount[0] > FInputs.Count)
{
while (this.FInputCount[0] > FInputs.Count)
{
InputAttribute attr = new InputAttribute("Input " + Convert.ToString(this.FInputs.Count + 1));
//attr.IsSingle = true;
attr.CheckIfChanged = true;
//Create new layer Pin
IIOContainer <Pin <DX11Resource <DX11IndexedGeometry> > > newlayer = this.FIOFactory.CreateIOContainer <Pin <DX11Resource <DX11IndexedGeometry> > >(attr);
newlayer.IOObject.SliceCount = 1;
this.FInputs.Add(newlayer);
}
}
else
{
while (this.FInputCount[0] < FInputs.Count)
{
this.FInputs[this.FInputs.Count - 1].Dispose();
this.FInputs.RemoveAt(this.FInputs.Count - 1);
}
}
}
}
protected override void SetDefault(InputAttribute attr, EffectVariable var)
{
Vector4 vec = var.AsVector().GetVector();
attr.DefaultValues = new double[] { vec.X, vec.Y, vec.Z, vec.W };
attr.AsInt = true;
}
public bool CreateIO(IIOFactory ioFactory, Dictionary <Field, IOContainer> ioContainers, Field field, bool isInput = true, bool isBinSized = false, int order = 0)
{
if (ioContainers.ContainsKey(field))
{
ioContainers[field].SetOrder(order);
return(false);
}
else
{
if (isInput)
{
var inAttr = new InputAttribute(field.Name)
{
Order = order, AutoValidate = false, Visibility = PinVisibility.Hidden
};
var ioCont = ioFactory.CreateIOContainer(typeof(INodeIn), inAttr);
ioContainers.Add(field, new IOContainer(ioCont, isInput, false, order));
}
else
{
var outAttr = new OutputAttribute(field.Name)
{
Order = order, Visibility = PinVisibility.Hidden
}; //, AutoFlush = false
var ioCont = ioFactory.CreateIOContainer(typeof(INodeOut), outAttr);
ioContainers.Add(field, new IOContainer(ioCont, isInput, false, order));
//(ioContainers[field].RawIOObject as ISpread).SliceCount = 0;
}
}
return(true);
}
private void SetInputs()
{
if (this.FInputCount[0] != FInputs.Count)
{
if (this.FInputCount[0] > FInputs.Count)
{
while (this.FInputCount[0] > FInputs.Count)
{
InputAttribute attr = new InputAttribute("Input " + Convert.ToString(this.FInputs.Count + 1));
//attr.IsSingle = true;
attr.CheckIfChanged = true;
//Create new layer Pin
IIOContainer<Pin<DX11Resource<DX11Texture2D>>> newlayer = this.FIOFactory.CreateIOContainer<Pin<DX11Resource<DX11Texture2D>>>(attr);
newlayer.IOObject.SliceCount = 1;
this.FInputs.Add(newlayer);
}
}
else
{
while (this.FInputCount[0] < FInputs.Count)
{
this.FInputs[this.FInputs.Count - 1].Dispose();
this.FInputs.RemoveAt(this.FInputs.Count - 1);
}
}
}
}
void SyncPins(BuildResult buildResult)
{
var updateOperation = buildResult.Operation;
var compilation = buildResult.Compilation;
var scope = buildResult.Scope;
FPluginHost.Plugin = null;
foreach (var input in FInputs)
{
input.Dispose();
}
foreach (var output in FOutputs)
{
output.Dispose();
}
FInputs.Clear();
FOutputs.Clear();
if (updateOperation != null)
{
foreach (var input in updateOperation.GetRegularInputs())
{
var clrType = compilation.GetClrType(input.Type, typeof(object));
var spreadType = typeof(IInStream <>).MakeGenericType(clrType);
var inputAttribute = new InputAttribute(input.Name);
if (input.DefaultValue.IsNotDummy())
{
SetDefaultValue(inputAttribute, input.DefaultValue.GetClrValue(buildResult.Compilation), scope);
}
else
{
var genericTypeDefinition = clrType.IsGenericType ? clrType.GetGenericTypeDefinition() : null;
var dataType = (genericTypeDefinition == typeof(IEnumerable <>) || genericTypeDefinition == typeof(global::VL.Lib.Collections.Spread <>))
? clrType.GenericTypeArguments[0]
: clrType;
var defaultValue = compilation.DefaultClrValue(dataType, scope);
if (defaultValue != null)
{
SetDefaultValue(inputAttribute, defaultValue, scope);
}
}
var ioContainer = this.CreateIOContainer(spreadType, inputAttribute) as IIOContainer <IInStream>;
FInputs.Add(ioContainer);
}
}
FInStreams = FInputs.Select(c => c.IOObject).ToArray();
if (updateOperation != null)
{
foreach (var output in updateOperation.GetRegularOutputs())
{
var clrType = compilation.GetClrType(output.Type, typeof(object));
var spreadType = typeof(IOutStream <>).MakeGenericType(clrType);
var inputAttribute = new OutputAttribute(output.Name);
var ioContainer = this.CreateIOContainer(spreadType, inputAttribute) as IIOContainer <IOutStream>;
FOutputs.Add(ioContainer);
}
}
FOutStreams = FOutputs.Select(c => c.IOObject).ToArray();
FPluginHost.Plugin = this;
}
private void ManageDiffOutput(IDiffSpread <bool> advanced)
{
if (FAdvanced[0])
{
Keep.QuickMode = false;
var ia = new InputAttribute("Include input in Diff");
ia.Order = 2;
ia.IsSingle = true;
ia.IsToggle = true;
ia.DefaultBoolean = true;
Type pinType = typeof(IDiffSpread <>).MakeGenericType(typeof(bool));
DoAllChange = FIOFactory.CreateIOContainer(pinType, ia);
var pin = DoAllChange.RawIOObject as IDiffSpread <bool>;
pin.Changed += UpdateChangeAll;
var attr = new OutputAttribute("Message Diff");
attr.AutoFlush = false;
attr.Order = 2;
pinType = typeof(Pin <>).MakeGenericType(typeof(Message));
Change = FIOFactory.CreateIOContainer(pinType, attr);
FChangeOut = Change.RawIOObject as Pin <Message>;
attr = new OutputAttribute("Changed Message Index");
attr.AutoFlush = false;
attr.Order = 3;
pinType = typeof(ISpread <>).MakeGenericType(typeof(int));
ChangeIndex = FIOFactory.CreateIOContainer(pinType, attr);
FChangeIndexOut = ChangeIndex.RawIOObject as Pin <int>;
}
else
{
Keep.QuickMode = true;
if (DoAllChange != null)
{
DoAllChange.Dispose();
DoAllChange = null;
ManageAllChanges = true;
}
if (ChangeIndex != null)
{
ChangeIndex.Dispose();
ChangeIndex = null;
FChangeIndexOut = null;
}
if (FChangeOut != null)
{
Change.Dispose();
Change = null;
FChangeOut = null;
}
}
}
protected override void ConstructFieldTemplates(NodeProvider nodeProvider, Dictionary <Type, NodeFieldTemplate> templates)
{
NodeLibrary library = nodeProvider.GetNodeLibrary();
foreach (var nodeTemplate in library.nodeTemplates)
{
Type type = nodeTemplate.RuntimeNodeType;
var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
var template = new NodeFieldTemplate();
var supressInput = type.GetCustomAttribute <SupressInputAttribute>();
// All tasks (nodes in this case) need to have an input, that isnt in the code of the behaviours
// so we just add it in the first thing we do.
if (supressInput == null)
{
template.InputPorts.Add(new PortDescription("Input", typeof(Task), PortDirection.Input, false, false));
}
foreach (var field in fields)
{
OutputAttribute output = field.GetCustomAttribute <OutputAttribute>();
InputAttribute input = field.GetCustomAttribute <InputAttribute>();
SerializeField property = field.GetCustomAttribute <SerializeField>();
bool autoAdd = false;
bool isInput = input == null ? false : true;
bool isOutput = output == null ? false : true;
if (output != null)
{
autoAdd = output.AutoAddPortOnConnect;
}
if (input != null)
{
autoAdd = input.AutoAddPortOnConnect;
}
bool isList = IsListType(field);
if (output != null || input != null)
{
if (IsListType(field))
{
AddGenericPort(template, field, isInput, isOutput, autoAdd);
}
else
{
AddNonGenericPort(template, field.FieldType, field.Name, field.Name, isInput, isOutput, autoAdd);
}
}
else if (property != null)
{
AddNonGenericProperty(template, field, field.Name, field.Name);
}
}
templates.Add(type, template);
}
}
public void OnImportsSatisfied()
{
var inputAttribute = new InputAttribute("Input")
{
};
CountIn.Changed += HandlePinCountChanged;
FMainLoop.OnPrepareGraph += HandleOnPrepareGraph;
}
protected override void PreInitialize()
{
ConfigPinCopy = FCount;
var attr = new InputAttribute("Input");
attr.Order = 0;
FInput = new GenericInput(FPluginHost, attr);
pd = new PinDictionary(FIOFactory);
}
private Struct CreatePins(Definition definition)
{
Struct s = new Struct(FStructDefName);
var pins = new Dictionary <string, IIOContainer>();
foreach (var entry in definition.Types)
{
string key = entry.Key + entry.Value;
if (FPins.ContainsKey(key))
{
pins.Add(key, FPins[key]);
s.Data.Add(key, FPins[key].RawIOObject);
FPins.Remove(key);
if (!FIsJoin) //create output bin size
{
string binKey = "Bin" + key;
pins.Add(binKey, FPins[binKey]);
FPins.Remove(binKey);
}
}
else
{
Type pinType = typeof(ISpread <>).MakeGenericType(entry.Value);
IOAttribute attr;
if (FIsJoin)
{
attr = new InputAttribute(entry.Key);
attr = TrySetDefault(attr as InputAttribute, entry.Value, definition.Defaults[entry.Key]);
}
else
{
attr = new OutputAttribute(entry.Key);
}
var pin = FIOFactory.CreateIOContainer(pinType, attr);
pins.Add(key, pin);
s.Data.Add(key, pin.RawIOObject);
if (!FIsJoin) //create output bin size
{
attr.Name = attr.Name + " Bin Size";
attr.Visibility = PinVisibility.OnlyInspector;
pinType = typeof(ISpread <>).MakeGenericType(typeof(int));
pins.Add("Bin" + key, FIOFactory.CreateIOContainer(pinType, attr));
}
}
}
foreach (var oldPin in FPins.Values)
{
oldPin.Dispose();
}
FPins = pins;
return(s);
}
public bool CreateIO(IIOFactory ioFactory, Dictionary <Field, IOContainer> ioContainers, Field field, bool isInput = true, bool isBinSized = false, int order = 0)
{
Type t = typeof(IIOStream <IInStream <double> >);
if (isBinSized)
{
t = typeof(IInStream <>).MakeGenericType(field.FieldType);
if (isInput)
{
t = typeof(IInStream <>).MakeGenericType(t);
}
else
{
t = typeof(IIOStream <>).MakeGenericType(t);
}
}
else
if (isInput)
{
t = typeof(IInStream <>).MakeGenericType(field.FieldType);
}
else
{
t = typeof(IOutStream <>).MakeGenericType(field.FieldType);
}
if (ioContainers.ContainsKey(field))
{
ioContainers[field].SetOrder(order);
return(false);
}
else
{
if (isInput)
{
var inAttr = new InputAttribute(field.Name)
{
Order = order, BinOrder = order + 1, AutoValidate = false
};
inAttr.SetDefaultAttribute(field);
var ioCont = ioFactory.CreateIOContainer(t, inAttr);
ioContainers.Add(field, new IOContainer(ioCont, isInput, isBinSized, order));
}
else
{
var outAttr = new OutputAttribute(field.Name)
{
Order = order, BinOrder = order + 1
}; //, AutoFlush = false
var ioCont = ioFactory.CreateIOContainer(t, outAttr);
ioContainers.Add(field, new IOContainer(ioCont, isInput, isBinSized, order));
(ioContainers[field].RawIOObject as IOutStream).Length = 0;
}
}
return(true);
}
private InputAttribute TrySetDefault(InputAttribute attr, Type type, string defaultString)
{
if (!string.IsNullOrEmpty(defaultString))
{
double doubleDefault = 0;
switch (type.ToString())
{
case "System.Boolean":
bool boolDefault = false;
if (bool.TryParse(defaultString, out boolDefault))
{
attr.DefaultBoolean = boolDefault;
}
break;
case "System.Double":
case "System.Single":
case "System.Int32":
if (double.TryParse(defaultString, out doubleDefault))
{
attr.DefaultValue = doubleDefault;
}
break;
case "System.String":
attr.DefaultString = defaultString;
break;
case "VVVV.Utils.VMath.Vector2D":
case "VVVV.Utils.VMath.Vector3D":
case "VVVV.Utils.VMath.Vector4D":
var vectorString = defaultString.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
attr.DefaultValues = new double[vectorString.Length];
for (int i = 0; i < vectorString.Length; i++)
{
if (double.TryParse(vectorString[i].Trim(), out doubleDefault))
{
attr.DefaultValues[i] = doubleDefault;
}
}
break;
case "VVVV.Utils.VColor.RGBAColor":
var colorString = defaultString.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
attr.DefaultColor = new double[colorString.Length];
for (int i = 0; i < colorString.Length; i++)
{
if (double.TryParse(colorString[i].Trim(), out doubleDefault))
{
attr.DefaultColor[i] = doubleDefault;
}
}
break;
}
}
return(attr);
}
private void CreateTextureIn()
{
if (this.texinputpin == null)
{
InputAttribute tattr = new InputAttribute("Texture In");
tattr.Order = -1;
this.texinputpin = this.iofactory.CreateIOContainer <Pin <DX11Resource <DX11Texture2D> > >(tattr);
}
}
public void AddInputBinSized(Type T, InputAttribute attr)
{
Type pinType = typeof(IDiffSpread <>).MakeGenericType(typeof(ISpread <>).MakeGenericType(T));
var ioc = FIOFactory.CreateIOContainer(pinType, attr);
var ispread = ioc.ToIDiffSpread();
var pin = new DiffSpreadPin(ispread, attr, ioc);
InputPins.Add(attr.Name, pin);
pin.Type = T;
}
public BaseDX11RenderStateSimple(IPluginHost host, IIOFactory iofactory)
{
this.FHost = host;
this.FIOFactory = iofactory;
InputAttribute attr = this.GetEnumPin();
attr.CheckIfChanged = true;
this.FInPreset = this.FIOFactory.CreatePin <EnumEntry>(attr);
}
#pragma warning restore
protected override IOAttribute DefinePin(string name, Type type, int binSize = -1)
{
var attr = new InputAttribute(name);
attr.BinVisibility = PinVisibility.Hidden;
attr.BinSize = binSize;
attr.Order = FCount;
attr.BinOrder = FCount + 1;
attr.AutoValidate = false; // need to sync all pins manually. Don't forget to Flush()
return attr;
}
protected override IOAttribute DefinePin(string name, Type type)
{
var attr = new InputAttribute(name);
attr.BinVisibility = PinVisibility.Hidden;
attr.BinSize = 1;
attr.Order = FCount;
attr.BinOrder = FCount + 1;
// attr.AutoValidate = false; // need to sync all pins manually
return attr;
}
public DX11Texture1dArrayRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.UnorderedAccessView);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
this.FInFormat = iofactory.CreateDiffSpread<EnumEntry>(tattr);
}
#pragma warning restore
protected override IOAttribute DefinePin(FormularFieldDescriptor configuration)
{
var attr = new InputAttribute(configuration.Name);
attr.BinVisibility = PinVisibility.Hidden;
attr.BinSize = configuration.DefaultSize;
attr.Order = DynPinCount;
attr.BinOrder = DynPinCount + 1;
return attr;
}
protected override IIOContainer <ISpread <ISpread <T> > > CreatePin <T>(string name)
{
var attr = new InputAttribute(name);
attr.BinVisibility = PinVisibility.Hidden;
attr.BinSize = 1;
attr.Order = Count;
attr.BinOrder = Count + 1;
return(IOFactory.CreateIOContainer <IDiffSpread <ISpread <T> > >(attr));
}
protected override void ProcessAttribute(InputAttribute attr, EffectVariable var)
{
this.classes = var.LinkClassesStr();
eid = Guid.NewGuid().ToString();
string def = this.UpdateEnum(var);
attr.DefaultEnumEntry = def;
attr.EnumName = eid;
}
public InputElementJoinNode(IPluginHost host,IIOFactory iofactory)
{
this.FHost = host;
this.FIOFactory = iofactory;
InputAttribute fmtAttr = new InputAttribute("Format");
fmtAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.VertexBuffer);
fmtAttr.DefaultEnumEntry = "R32G32B32A32_Float";
FInFormat = this.FIOFactory.CreateDiffSpread<EnumEntry>(fmtAttr);
}
public void OnImportsSatisfied()
{
AutomataUI.Connected += Input_Connected;
AutomataUI.Disconnected += Input_Disconnected;
//new way of enums
InputAttribute attr = new InputAttribute("State");
StatesEnum = FIOFactory.CreateIOContainer <IDiffSpread <EnumEntry> >(attr, true);
}
public void AddInputEnum(List<IIOContainer<Pin<EnumEntry>>> FInput, int pinOrder, string pinName, string enumName, string enumDefault, string[] enums)
{
EnumManager.UpdateEnum(enumName, enumDefault, enums);
InputAttribute ioAttribute = new InputAttribute(enumName);
ioAttribute.Name = pinName;
ioAttribute.EnumName = enumName;
ioAttribute.Order = pinOrder;
FInput.Add(FIOFactory.CreateIOContainer<Pin<EnumEntry>>(ioAttribute));
}
public async Task CreateShouldSucceed()
{
// Arrange
var id = Guid.NewGuid();
var name = "name";
var description = "description";
var icon = Guid.NewGuid();
var instruction = "instruction";
var input = new Input(id, name, description, icon, instruction);
var tag = new Tag("tag");
input.AddTag(tag);
var image = new Image("image", "url");
input.AddImage(image);
var video = new Video("image", "url");
input.AddVideo(video);
var inputAttributeName = "any name";
var inputAttributeNotMandatory = true;
var inputAttributeScanningOnly = true;
var inputAttributeMinLenght = new Random().Next();
var inputAttributeMaxLenght = new Random().Next();
var inputAttributePrefix = "any prefix";
var inputAttributeCheckLastXCharacters = new Random().Next();
var inputAttribute = new InputAttribute(inputAttributeName, inputAttributeNotMandatory, inputAttributeScanningOnly, inputAttributeMinLenght, inputAttributeMaxLenght, inputAttributePrefix, inputAttributeCheckLastXCharacters);
input.AddInputAttribute(inputAttribute);
// Act
await _repository.CreateAsync(input);
// Assert
var data = RepositoryHelper.ForInput.GetInputs();
data.Should().HaveCount(1);
var result = data.First();
result.Name.Should().Be(name);
result.Description.Should().Be(description);
result.Icon.Should().Be(icon);
result.Instruction.Should().Be(instruction);
result.Tags.Should().HaveCount(1);
result.Tags.First().Should().Be(tag);
result.Images.Should().HaveCount(1);
result.Images.First().Should().Be(image);
result.Videos.Should().HaveCount(1);
result.Videos.First().Should().Be(video);
result.InputAttributes.Should().HaveCount(1);
result.InputAttributes.First().Should().Be(inputAttribute);
}
private void HandleTransitionPins(IDiffSpread <string> sender)
{
//FLogger.Log(LogType.Debug, "Update Pins");
//empty automata tree ? -> create a reset pin
if (TransitionNames[0] == "")
{
TransitionNames[0] = "Init";
}
// CREATE INIT
if (stateList.Count == 0)
{
stateList.Add(new State()
{
ID = "Init",
Name = "Init",
Bounds = new Rectangle(new Point(0, 0), new Size(p.StateSize, p.StateSize))
});
}
//delete pins which are not in the new list
foreach (var name in FPins.Keys)
{
if (TransitionNames.IndexOf(name) == -1)
{
FPins[name].Dispose();
}
}
Dictionary <string, IIOContainer> newPins = new Dictionary <string, IIOContainer>();
foreach (var name in TransitionNames)
{
if (!string.IsNullOrEmpty(name)) //ignore empty slices
{
if (FPins.ContainsKey(name)) //pin already exists, copy to new dict
{
newPins.Add(name, FPins[name]);
FPins.Remove(name);
}
else if (!newPins.ContainsKey(name)) //just checking in case of duplicate names
{
var attr = new InputAttribute(name);
attr.IsBang = true;
var type = typeof(IDiffSpread <bool>);
var container = FIOFactory.CreateIOContainer(type, attr);
newPins.Add(name, container);
}
}
}
//FPins now only holds disposed IIOContainers, since we copied the reusable ones to newPins
FPins = newPins;
}
public InputBinSpreadStream(IIOFactory ioFactory, InputAttribute attribute, bool checkIfChanged, Func <IIOContainer <IInStream <int> > > binSizeIOContainerFactory)
{
// Don't do this, as spread max won't get computed for this pin
// attribute.AutoValidate = false;
attribute.CheckIfChanged = checkIfChanged;
FDataContainer = ioFactory.CreateIOContainer <IInStream <T> >(attribute, false);
FBinSizeContainer = binSizeIOContainerFactory();
FDataStream = FDataContainer.IOObject;
FBinSizeStream = FBinSizeContainer.IOObject;
FDataIO = FDataContainer.GetPluginIO();
}
public DX11VolumeRendererNode(IPluginHost FHost,IIOFactory factory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
tattr.CheckIfChanged = true;
this.FInFormat = factory.CreateDiffSpread<EnumEntry>(tattr);
}
public InputElementJoinNode(IPluginHost host, IIOFactory iofactory)
{
this.FHost = host;
this.FIOFactory = iofactory;
InputAttribute fmtAttr = new InputAttribute("Format");
fmtAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.VertexBuffer);
fmtAttr.DefaultEnumEntry = "R32G32B32A32_Float";
FInFormat = this.FIOFactory.CreateDiffSpread <EnumEntry>(fmtAttr);
}
public DX11SamplerStatePresetNode(IPluginHost host, IIOFactory iofactory)
{
string[] enums = DX11SamplerStates.Instance.StateKeys;
host.UpdateEnum(DX11SamplerStates.Instance.EnumName, enums[0], enums);
InputAttribute attr = new InputAttribute("Mode");
attr.EnumName = DX11SamplerStates.Instance.EnumName;
attr.DefaultEnumEntry = enums[0];
this.FInPreset = iofactory.CreateDiffSpread<EnumEntry>(attr);
}
public DX11Texture1dRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.UnorderedAccessView);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
this.FInFormat = iofactory.CreateDiffSpread <EnumEntry>(tattr);
}
public virtual IOAttribute PinAttribute(string name, int order)
{
InputAttribute attr = new InputAttribute(name);
attr.BinVisibility = PinVisibility.True;
attr.BinSize = 1;
attr.Order = order * 2;
attr.BinOrder = order * 2 + 1;
return(attr);
}
public DX11TextureArrayRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
this.FInFormat = iofactory.CreateDiffSpread<EnumEntry>(tattr);
//this.depthmanager = new DepthBufferManager(FHost,iofactory);
}
public DX11TempRTRendererNode(IPluginHost FHost)
{
string ename = VDX11.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
this.FInFormat = PinFactory.CreateDiffSpread<EnumEntry>(FHost, tattr);
this.FDepthManager = new DepthBufferManager(FHost);
}
protected override InputAttribute GetEnumPin()
{
string[] enums = DX11DepthStencilStates.Instance.StateKeys;
this.FHost.UpdateEnum(DX11DepthStencilStates.Instance.EnumName,enums[0],enums);
InputAttribute attr = new InputAttribute("Mode");
attr.EnumName = DX11DepthStencilStates.Instance.EnumName;
attr.DefaultEnumEntry = enums[0];
return attr;
}
public DX11RenderStatePresetNode(IPluginHost host, IIOFactory iofactory)
{
InputAttribute attr = new InputAttribute("Blend Mode");
attr.EnumName = DX11BlendStates.Instance.EnumName;
this.FInBlendPreset = iofactory.CreateDiffSpread<EnumEntry>(attr);
attr = new InputAttribute("Rasterizer Mode");
attr.EnumName = DX11RasterizerStates.Instance.EnumName;
this.FInRasterPreset = iofactory.CreateDiffSpread<EnumEntry>(attr);
attr = new InputAttribute("Depth Stencil Mode");
attr.EnumName = DX11DepthStencilStates.Instance.EnumName;
this.FInDepthPreset = iofactory.CreateDiffSpread<EnumEntry>(attr);
}
public DX11ImageShaderNode(IPluginHost host, IIOFactory factory)
{
this.FHost = host;
this.FFactory = factory;
this.TechniqueEnumId = Guid.NewGuid().ToString();
InputAttribute inAttr = new InputAttribute("Technique");
inAttr.EnumName = this.TechniqueEnumId;
//inAttr.DefaultEnumEntry = defaultenum;
inAttr.Order = 1000;
this.FInTechnique = this.FFactory.CreateDiffSpread<EnumEntry>(inAttr);
this.varmanager = new DX11ImageShaderVariableManager(host, factory);
}
protected override IOAttribute SetPinAttributes(FormularFieldDescriptor field)
{
var attr = new InputAttribute(field.Name);
attr.BinVisibility = PinVisibility.Hidden;
attr.BinSize = field.DefaultSize;
attr.Order = DynPinCount;
attr.BinOrder = DynPinCount + 1;
attr.CheckIfChanged = false; // very lazy inputs. only do something when New is hit.
attr.AutoValidate = false;
return attr;
}
public void CreateEnumPin(string pinName, IEnumerable<string> entries)
{
EnumName = "Enum_" + this.GetHashCode().ToString();
EnumManager.UpdateEnum(EnumName, entries.First(), entries.ToArray());
var attr = new InputAttribute(pinName);
attr.Order = 2;
attr.AutoValidate = true;
attr.EnumName = EnumName;
Type pinType = typeof(IDiffSpread<EnumEntry>);
var pin = FIOFactory.CreateIOContainer(pinType, attr);
FUseAsID = (IDiffSpread<EnumEntry>)(pin.RawIOObject);
}
public void CreateEnumPin(string pinName, string[] entries)
{
EnumName = "Enum_" + this.GetHashCode().ToString();
EnumManager.UpdateEnum(EnumName, entries[0], entries);
var attr = new InputAttribute(pinName);
attr.Order = 3;
attr.AutoValidate = true;
attr.EnumName = EnumName;
Type pinType = typeof(ISpread<EnumEntry>);
var pin = FIOFactory.CreateIOContainer(pinType, attr);
FEnum = (ISpread<EnumEntry>)(pin.RawIOObject);
}
public DX11TextureSpreadRendererNode(IPluginHost FHost, IIOFactory iofactory)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
ConfigAttribute dfAttr = new ConfigAttribute("Depth Buffer Format");
dfAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.DepthStencil);
dfAttr.DefaultEnumEntry = "D32_Float";
dfAttr.IsSingle = true;
this.depthformatpin = iofactory.CreateDiffSpread<EnumEntry>(dfAttr);
this.depthformatpin[0] = new EnumEntry(dfAttr.EnumName, 1);
this.FInFormat = iofactory.CreateDiffSpread<EnumEntry>(tattr);
}
public void CreateEnumPin(string pinName, IEnumerable<string> entries)
{
EnumName = "Enum_" + this.GetHashCode().ToString();
FillEnum(entries);
var attr = new InputAttribute(pinName);
attr.Order = 2;
attr.AutoValidate = true;
attr.BinVisibility = PinVisibility.OnlyInspector;
attr.BinSize = -1;
attr.BinOrder = 3;
attr.CheckIfChanged = true;
attr.EnumName = EnumName;
Type pinType = typeof(ISpread<ISpread<EnumEntry>>);
var pin = FIOFactory.CreateIOContainer(pinType, attr);
FUseFields = (ISpread<ISpread<EnumEntry>>)(pin.RawIOObject);
}
private void CreateSize()
{
if (this.FInTextureSize == null)
{
InputAttribute a = new InputAttribute("Texture Size");
a.Order = 8;
a.DefaultValues = new double[] { 400, 300 };
a.CheckIfChanged = true;
this.FInTextureSize = this.iofactory.CreateIOContainer<IDiffSpread<Vector2D>>(a);
a.Name = "Texture Scale";
a.DefaultValues = new double[] { 1, 1 };
this.FInTextureScale = this.iofactory.CreateIOContainer<IDiffSpread<Vector2D>>(a);
}
}
private void CreateFormat()
{
if (this.FInFormat == null)
{
string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);
InputAttribute tattr = new InputAttribute("Target Format");
tattr.EnumName = ename;
tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";
tattr.DefaultString = "R8G8B8A8_UNorm";
tattr.AllowDefault = true;
tattr.Order = 0;
tattr.CheckIfChanged = true;
tattr.DefaultString = "R8G8B8A8_UNorm";
this.FInFormat = this.iofactory.CreateIOContainer<IDiffSpread<EnumEntry>>(tattr);
}
}
private void Pinmode_Changed(IDiffSpread<eDepthBufferMode> spread)
{
if (this.currentmode != spread[0])
{
if (this.currentmode == eDepthBufferMode.Standard)
{
if (this.depthoutputpin != null)
{
//Destroy depth stencil
if (this.depthoutputpin.IOObject[0] != null)
{
this.depthoutputpin.IOObject[0].Dispose();
}
this.depthoutputpin.Dispose();
this.depthformatpin.Dispose();
this.depthformatpin = null;
this.depthoutputpin = null;
}
}
if (this.currentmode == eDepthBufferMode.ReadOnly)
{
if (this.depthinputpin != null)
{
this.depthinputpin.Dispose();
this.depthinputpin = null;
}
}
this.currentmode = spread[0];
if (this.currentmode == eDepthBufferMode.Standard)
{
OutputAttribute oattr = new OutputAttribute("Depth Buffer");
oattr.IsSingle = true;
this.depthoutputpin = this.factory.CreateIOContainer<Pin<DX11Resource<DX11DepthStencil>>>(oattr);
this.depthoutputpin.IOObject[0] = new DX11Resource<DX11DepthStencil>();
ConfigAttribute dfAttr = new ConfigAttribute("Depth Buffer Format");
dfAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.DepthStencil);
dfAttr.DefaultEnumEntry = DX11EnumFormatHelper.NullDeviceFormats.GetAllowedFormats(FormatSupport.DepthStencil)[0];
dfAttr.IsSingle = true;
this.depthformatpin = this.factory.CreateIOContainer<IDiffSpread<EnumEntry>>(dfAttr);
this.depthformatpin.IOObject[0] = new EnumEntry(dfAttr.EnumName, 1);
this.depthformatpin.IOObject.Changed += depthformatpin_Changed;
}
if (this.currentmode == eDepthBufferMode.ReadOnly)
{
InputAttribute oattr = new InputAttribute("Depth Buffer");
oattr.IsSingle = true;
this.depthinputpin = this.factory.CreateIOContainer<Pin<DX11Resource<DX11DepthStencil>>>(oattr);
}
this.NeedReset = true;
}
}
protected override void OnConfigChange(IDiffSpread<string> configSpread)
{
base.OnConfigChange(configSpread);
var attr = new InputAttribute("AvoidNil");
attr.BinVisibility = PinVisibility.OnlyInspector;
attr.Order = 6;
attr.BinOrder = 7;
attr.BinSize = 1;
attr.CheckIfChanged = true;
Type pinType = typeof(ISpread<>).MakeGenericType((typeof(ISpread<>)).MakeGenericType(TargetDynamicType)); // the Pin is always a binsized one
if (FAvoidNil != null) FAvoidNil.Dispose();
FAvoidNil = FIOFactory.CreateIOContainer(pinType, attr);
}
void ParameterNamesConfig_Changed(IDiffSpread<string> spread)
{
//temp pin dictionary
var prevPins = new Dictionary<string, ParamPin>(FParamPins);
//create pin?
foreach (var pinString in spread)
{
if(string.IsNullOrWhiteSpace(pinString))
continue;
if (!prevPins.ContainsKey(pinString))
{
var paramPin = ParamPin.Parse(pinString);
var oa = new InputAttribute(paramPin.ParamName);
//FLogger.Log(LogType.Debug, col.DataType.ToString());
paramPin.Pin = FHost.CreateValueInput(oa, typeof(float));
FParamPins[pinString] = paramPin;
}
else
{
prevPins.Remove(pinString);
}
}
//any pin which is left over can be removed
foreach (var pin in prevPins)
{
FHost.DeletePin(pin.Value.Pin);
FParamPins.Remove(pin.Key);
}
}
protected override InputAttribute GetEnumPin()
{
InputAttribute attr = new InputAttribute("Mode");
attr.EnumName = DX11RasterizerStates.Instance.EnumName;
return attr;
}
private void CreateTextureIn()
{
if (this.texinputpin == null)
{
InputAttribute tattr = new InputAttribute("Texture In");
tattr.Order = -1;
this.texinputpin = this.iofactory.CreateIOContainer<Pin<DX11Resource<DX11Texture2D>>>(tattr);
}
}
#pragma warning restore
protected override IOAttribute DefinePin(string name, Type type, int binSize = -1)
{
var attr = new InputAttribute(name);
attr.BinVisibility = PinVisibility.Hidden;
attr.BinSize = binSize;
attr.Order = FCount;
attr.BinOrder = FCount + 1;
return attr;
}
protected override IOAttribute DefinePin(FormularFieldDescriptor field)
{
var attr = new InputAttribute("Field");
attr.BinVisibility = PinVisibility.Hidden;
attr.Order = 4;
attr.BinOrder = 5;
attr.BinSize = 1;
attr.CheckIfChanged = true;
return attr;
}
public override void SetShader(DX11Effect shader, bool isnew, string fileName)
{
this.FShader = shader;
this.varmanager.SetShader(shader);
FOutPath.SliceCount = 1;
FOutPath[0] = fileName;
//Only set technique if new, otherwise do it on update/evaluate
if (isnew)
{
string defaultenum;
if (shader.IsCompiled)
{
defaultenum = shader.TechniqueNames[0];
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.CreateShaderPins();
}
else
{
defaultenum = "";
this.FHost.UpdateEnum(this.TechniqueEnumId, "", new string[0]);
}
//Create Technique enum pin
InputAttribute inAttr = new InputAttribute("Technique");
inAttr.EnumName = this.TechniqueEnumId;
inAttr.DefaultEnumEntry = defaultenum;
inAttr.Order = 1000;
this.FInTechnique = this.FFactory.CreateDiffSpread<EnumEntry>(inAttr);
this.FoutCS.AssignFrom(this.varmanager.GetCustomData());
}
else
{
if (shader.IsCompiled)
{
this.FHost.UpdateEnum(this.TechniqueEnumId, shader.TechniqueNames[0], shader.TechniqueNames);
this.varmanager.UpdateShaderPins();
this.FoutCS.AssignFrom(this.varmanager.GetCustomData());
}
}
this.shaderupdated = true;
this.FInvalidate = true;
}
