protected override void Definition()
{
EnterNode = ControlInput("EnterNode", DoInjection);
ExitNode = ControlOutput("ExitNode");
Object = ValueInput <object>("Object");
Context = ValueInput <Context>("Context");
InjectedObject = ValueOutput("InjectedObject", delegate { return(_output); });
}
protected override void Definition()
{
target = ValueInput <EditorWindowView>("target");
result = ValueOutput("result", (flow) =>
{
return(flow.GetValue <EditorWindowView>(target).asset == asset);
});
}
protected override void Definition()
{
inputEnter = ControlInput("enter", OnEnter);
inputExit = ControlInput("exit", OnExit);
scenesIn = ValueInput <string[]>("scenes");
loadAdditiveIn = ValueInput <bool>("loadAdditive");
}
protected override void Definition()
{
base.Definition();
key = ValueInput(keyType, nameof(key));
key.SetDefaultValue(GetDefaultValue(keyType));
}
protected override void Definition()
{
enter = ControlInput("enter", new Action <Flow>(Enter));
returnUnit = ValueInput <TriggerReturnEvent>("returnUnit");
returnValue = ValueInput <object>("return");
}
protected override void Definition()
{
save = ValueInput <BinarySave>("save");
enter = ControlInput("enter", (flow) => { flow.GetValue <BinarySave>(save).variables.Clear(); return(exit); });
exit = ControlOutput("exit");
Succession(enter, exit);
}
protected override void Definition()
{
base.Definition();
Material = ValueInput <Material>(nameof(Material)).AllowsNull();
TrailMaterial = ValueInput <Material>(nameof(TrailMaterial)).AllowsNull();
Requirement(Material, Enter);
Requirement(TrailMaterial, Enter);
}
protected override void RegisterPorts()
{
becameTrue = AddFlowOutput("Became True");
becameFalse = AddFlowOutput("Became False");
//isTrue = AddFlowOutput("Is True");
//isFalse = AddFlowOutput("Is False");
condition = AddValueInput <bool>("Condition");
}
protected override void Definition()
{
base.Definition();
RateOverDistance = ValueInput <float>(nameof(RateOverDistance), 0f);
RateOverTime = ValueInput <float>(nameof(RateOverTime), 10f);
Requirement(RateOverDistance, Enter);
Requirement(RateOverTime, Enter);
}
protected override void RegisterPorts()
{
if (useReturnValue)
{
returnPort = AddValueInput <object>("Value");
}
AddFlowInput(" ", (f) => { f.Return(useReturnValue ? returnPort.value : null, this); });
}
protected override void Definition()
{
inputStart = ControlInput("enter", Enter);
inputStart = ControlInput("exit", Destroy);
inputStop = ControlInput("destroy", Destroy);
valueIn = ValueInput <Object>("prefab");
}
protected override void Definition()
{
binary = ValueInput <BinarySave>(nameof(binary));
variableName = ValueInput <string>(nameof(variableName), string.Empty);
value = ValueOutput <object>(nameof(value), GetVariable);
Requirement(binary, value);
Requirement(variableName, value);
}
protected override void Definition()
{
base.Definition();
if (_func != null)
{
@return = ValueInput(_func.ReturnType, "return");
}
}
protected override void Definition()
{
input = ControlInput("In", Enter);
output = ControlOutput("Out");
selfTransformIn = ValueInput <Transform>("Self");
Requirement(selfTransformIn, input);
}
public async Task <Value> Add(ValueInput value)
{
var entity = mapper.Map <ValueEntity>(value);
this.dbContext.Add(entity);
await this.dbContext.SaveChangesAsync();
return(mapper.Map <Value>(entity));
}
public async Task <Value> Add(ValueInput value)
{
var entity = mapper.MapValue(value, new ValueEntity());
this.dbContext.Add(entity);
await SaveChanges();
return(mapper.MapValue(entity, new Value()));
}
protected override void Definition()
{
base.Definition();
// Input
inputHDA = ValueInput <HEU_HoudiniAssetRoot>("HDA", null);
// Output
outputHDAAsset = ValueOutput <HEU_HoudiniAsset>("Output HDA", (flow) => { return(hdaAsset); });
}
protected override void Definition()
{
binary = ValueInput <BinarySave>(nameof(binary));
variableName = ValueInput <string>(nameof(variableName), string.Empty);
result = ValueOutput <bool>(nameof(result), HasVariable);
Requirement(binary, result);
Requirement(variableName, result);
}
protected override void Definition()
{
base.Definition();
Color = ValueInput <UnityEngine.Color>(nameof(Color), UnityEngine.Color.white);
SpeedMin = ValueInput <float>(nameof(SpeedMin), 0f);
SpeedMax = ValueInput <float>(nameof(SpeedMax), 1f);
Requirement(Color, Enter);
Requirement(SpeedMin, Enter);
Requirement(SpeedMax, Enter);
}
public async Task <IActionResult> PutAsync(string key, [FromBody] ValueInput input)
{
var result = await _simpleKeyValueService.Update(ContainerName, key, input.Value);
if (result)
{
return(Ok());
}
return(NoContent());
}
protected override void Definition()
{
EnterNode = ControlInput("EnterNode", DoInjection);
ExitNode = ControlOutput("ExitNode");
Prototype = ValueInput <Object>("Prototype", null);
Context = ValueInput <Context>("Context", null);
Position = ValueInput <Vector3>("Position", Vector3.zero);
Orientation = ValueInput <Quaternion>("Orientation", Quaternion.identity);
InjectedObject = ValueOutput("InjectedObject", delegate { return(_output); });
}
protected override void Definition()
{
a = ValueInput <float>(nameof(a));
b = ValueInput <float>(nameof(b), 0);
AllowEquals = ValueInput <bool>(nameof(AllowEquals), false);
base.Definition();
Relation(AllowEquals, ifTrue);
Relation(AllowEquals, ifFalse);
}
protected override void DefinePorts()
{
base.DefinePorts();
value = ValueInput <object>("value");
type = ValueInput("type", typeof(UnityEngine.Object));
result = ValueOutput <bool>("result", new System.Func <Flow, bool>((flow) =>
{
return(flow.GetValue <object>(value).IsConvertibleTo(flow.GetValue <System.Type>(type), false));
}));
}
protected override void Definition()
{
enter = ControlInput("enter", RemoveVariable);
binary = ValueInput <UniversalSave>(nameof(binary));
variableName = ValueInput <string>(nameof(variableName), string.Empty);
exit = ControlOutput("exit");
Succession(enter, exit);
Requirement(binary, enter);
Requirement(variableName, enter);
}
protected override void Definition()
{
A = ValueInput <Database>("a");
B = ValueInput <Database>("b");
Func <Recursion, Database> database = newDatabase => GetNewDatabase();
databaseOut = ValueOutput <Database>("databaseOut", database);
Relation(A, databaseOut);
Relation(B, databaseOut);
}
protected override void Definition()
{
a = ValueInput <float>(nameof(a));
b = ValueInput <float>(nameof(b), 0);
AllowEquals = ValueInput <bool>(nameof(AllowEquals), false);
base.Definition();
Requirement(AllowEquals, enter);
Requirement(AllowEquals, enter);
}
public override string GenerateValue(ValueInput input)
{
if (input == Unit.input)
{
if (Unit.input.hasAnyConnection)
{
return((Unit.input.connection.source.unit as Unit).GenerateValue(Unit.input.connection.source));
}
}
return(base.GenerateValue(input));
}
protected override void RegisterPorts()
{
eventListener = AddValueInput <CustomEventListener>("EventListener", "");
outPutFlow = AddFlowOutput("Out", "");
AddFlowInput("In", (f) => {
eventListener.value.UnRegister();
//eventListener.value.target=null;
//eventListener.value.targets=null;
outPutFlow.Call(f);
});
}
protected override void Definition()
{
databaseIn = ValueInput <Database>("database");
value = ValueInput <object>("value");
Func <Recursion, IList <Vector3> > getCells = GetCells => ReturnCells();
cells = ValueOutput <IList <Vector3> >("cells", getCells);
Relation(databaseIn, cells);
Relation(value, cells);
}
protected override void DefinePorts()
{
base.DefinePorts();
value = ValueInput <object>("value");
type = ValueInput("type", typeof(UnityEngine.Object));
result = ValueOutput <object>("result", new System.Func <Flow, object>((flow) =>
{
var output = flow.GetValue <object>(value).ConvertTo(flow.GetValue <System.Type>(type));
return(output);
}));
}
