public InsertOperatorCommand(OperatorPart sourceOutput, OperatorPart targetInput, Operator compositionOp, Operator opToInsert, int multiInputIndexAtTarget)
{
_name = "Insert Operator";
var usedSingleInputs = new List <MetaInput>();
var usedMultiInputsCounter = new Dictionary <MetaInput, int>();
var compositionMeta = opToInsert.Parent.Definition;
if (opToInsert.Outputs.Count == 1)
{
var sourceOp = sourceOutput.Parent;
var targetOp = targetInput.Parent;
var sourceOpID = (sourceOp.ID == compositionOp.ID) ? Guid.Empty : sourceOp.ID;
var targetOpID = (targetOp.ID == compositionOp.ID) ? Guid.Empty : targetOp.ID;
var sourceOpPartID = sourceOutput.ID;
var targetOpPartID = targetInput.ID;
var inputOpType = sourceOutput.Type;
Func <FunctionType, bool> isValidInputType = type => inputOpType == type || type == FunctionType.Generic;
Func <MetaInput, bool> isInputUsable = input => input.IsMultiInput || !usedSingleInputs.Contains(input);
var matchingTargetInput = (from input in opToInsert.Definition.Inputs
where isValidInputType(input.OpPart.Type) && isInputUsable(input)
select input).FirstOrDefault();
if (matchingTargetInput == null)
{
return;
}
// extract previous connection
var matchingConnections = (from con in compositionMeta.Connections
where con.TargetOpPartID == targetOpPartID && con.TargetOpID == targetOpID
select con).ToList();
var prevConnection = matchingConnections[multiInputIndexAtTarget];
// Split existing connections for single selected operators
if (prevConnection != null)
{
var conNewOpToPrevTarget = new MetaConnection(opToInsert.ID, opToInsert.Definition.Outputs[0].ID, prevConnection.TargetOpID, prevConnection.TargetOpPartID);
_commands.Add(new RemoveConnectionCommand(compositionMeta, prevConnection, multiInputIndexAtTarget));
_commands.Add(new InsertConnectionCommand(compositionMeta, conNewOpToPrevTarget, multiInputIndexAtTarget));
}
// insert new connection
var newConnection = new MetaConnection(sourceOpID, sourceOpPartID, opToInsert.ID, matchingTargetInput.ID);
int index = 0;
if (matchingTargetInput.IsMultiInput)
{
usedMultiInputsCounter.TryGetValue(matchingTargetInput, out index);
usedMultiInputsCounter[matchingTargetInput] = index + 1;
}
else
{
usedSingleInputs.Add(matchingTargetInput);
}
_commands.Add(new InsertConnectionCommand(compositionMeta, newConnection, index));
}
}
/// <summary>
/// Invokes the operator as instructed via the <paramref name="op"/> and <paramref name="args"/>.
/// </summary>
/// <typeparam name="THost"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="host"></param>
/// <param name="op"></param>
/// <param name="filter"></param>
/// <param name="argTypes"></param>
/// <param name="args"></param>
/// <returns></returns>
/// <a href="!:http://stackoverflow.com/questions/3016429/reflection-and-operator-overloads-in-c-sharp">
/// reflection-and-operator-overloads-in-c-sharp</a>
public static TResult InvokeOperator <THost, TResult>(this THost host, OperatorPart op,
IEnumerable <Type> argTypes, Func <object, TResult> filter, params object[] args)
{
var result = host.InvokeOperator(op, argTypes, args);
return(filter(result));
}
public ResetInputToDefault(OperatorPart input)
{
_instanceID = input.ID;
_valueBeforeReset = ((Utilities.ValueFunction)input.Func).Value;
_parentInstanceID = input.Parent.ID;
_parentMetaID = input.Parent.Definition.ID;
}
public RemoveInputCommand(Operator compOp, OperatorPart input)
{
Name = "Remove Input Parameter";
_metaOpID = compOp.Definition.ID;
_inputID = input.ID;
bool isHomeOp = compOp.Parent == null;
_parentID = isHomeOp ? Guid.Empty : compOp.Parent.Definition.ID;
_metaInputIndex = compOp.Inputs.IndexOf(input);
var metaInput = compOp.Definition.Inputs[_metaInputIndex];
_metaInputID = metaInput.ID;
_metaInputName = metaInput.Name;
_metaInputDefaultValue = metaInput.DefaultValue;
_metaOpPartType = metaInput.OpPart.Type;
_metaInputIsMultiInput = metaInput.IsMultiInput;
_metaInputRelevance = metaInput.Relevance;
if (!isHomeOp)
{
_connectionsIntoInput = (from connection in compOp.Parent.Definition.Connections
where connection.TargetOpID == compOp.ID
where connection.TargetOpPartID == _inputID
select connection).ToArray();
}
_connectionsFromInput = (from connection in compOp.Definition.Connections
where !compOp.Definition.IsBasic // connections from input to code op part (basic op) doesn't need to be restored
where connection.SourceOpPartID == _inputID
select connection).ToArray();
}
public EnumParameterValue(OperatorPart input)
{
ValueHolder = input;
InitializeComponent();
_metaInput = input.Parent.GetMetaInput(input);
var enumValues = _metaInput.EnumValues;
foreach (var enumEntry in enumValues)
{
XComboBox.Items.Add(enumEntry.Name);
}
XComboBox.SelectionChanged += (o, e) =>
{
if (!_changeEventsEnabled)
{
return;
}
var idx = XComboBox.SelectedIndex;
var value = new Float((float)enumValues[idx].Value);
var _setValueCommand = new UpdateOperatorPartValueFunctionCommand(input, value);
App.Current.UndoRedoStack.AddAndExecute(_setValueCommand);
App.Current.UpdateRequiredAfterUserInteraction = true;
};
UpdateGUI();
ValueHolder.ManipulatedEvent += ValueHolder_ManipulatedHandler;
ValueHolder.ChangedEvent += ValueHolder_ChangedHandler;
Unloaded += UnloadHandler;
}
public Rect GetRangeForInputConnectionLine(OperatorPart input, int multiInputIndex, bool insertConnection = false)
{
int inputIndex = 0;
double inputWidth = Width;
double bottom = Height;
double minX = inputIndex * inputWidth;
double maxX = minX + inputWidth;
if (input.IsMultiInput)
{
double slotWidth = inputWidth / (input.Connections.Count() + 0.5);
double slotLeft = minX + multiInputIndex * slotWidth;
double slotRight = slotLeft + slotWidth;
// This needs not be validated
if (insertConnection)
{
slotLeft += 0.5 * slotWidth;
}
else
{
slotRight = slotLeft = slotLeft + 0.25 * slotWidth;
}
return(new Rect(slotLeft, Height, slotRight - slotLeft, 0));
}
else
{
return(new Rect(minX, Height, maxX - minX, 0));
}
}
public void PreEvaluate(OperatorPart opPart)
{
if (opPart.Disabled)
{
return;
}
var transformFunc = opPart.Func as ISceneTransform;
if (transformFunc != null)
{
_transforms.Push(transformFunc.Transform * _transforms.Peek());
}
var meshSupplier = opPart.Func as IMeshSupplier;
if (meshSupplier != null)
{
if (!CollectedMeshes.ContainsKey(_transforms.Peek()))
{
CollectedMeshes.Add(_transforms.Peek(), new List <Mesh>());
}
meshSupplier.AddMeshesTo(CollectedMeshes[_transforms.Peek()]);
}
}
public AddOrUpdateKeyframeCommand(double time, double value, OperatorPart opPartToAddKeyframe)
{
var newKey = new VDefinition();
OperatorPart curveOpPart = Animation.GetRegardingAnimationOpPart(opPartToAddKeyframe);
if (curveOpPart != null)
{
// already existing animation, so check for previous keyframe
var curve = curveOpPart.Func as ICurve;
if (curve.HasVAt(time))
{
_previousKeyframeValue = curve.GetV(time);
}
double?prevU = curve.GetPreviousU(time);
if (prevU != null)
{
newKey = curve.GetV(prevU.Value);
}
}
newKey.Value = value;
KeyframeTime = time;
_initialKeyframeTime = time;
_previousKeyframeTime = time;
KeyframeValue = newKey;
StoreRelevantIds(curveOpPart);
}
private void StoreRelevantIds(OperatorPart curveOpPart)
{
_curveOpToAddKeyframeInstanceID = curveOpPart.Parent.ID;
var compositionOp = curveOpPart.Parent.Parent;
StoreCompositionOpIds(compositionOp);
}
private void UpdateMetaInput()
{
var opPartDefinition = BasicMetaTypes.GetMetaOperatorPartOf((FunctionType)TypeComboBox.SelectedIndex);
_metaInput.Name = NameTextBox.Text;
_metaInput.OpPart = opPartDefinition;
_metaInput.DefaultValue = _defaultValue;
_metaInput.IsMultiInput = IsMultiInputComboBox.SelectedIndex == 1 ? true : false;
OperatorPart newOpPart = _metaInput.CreateInstance();
if (_operatorPart.Type != newOpPart.Type)
{
_operatorPart.Type = newOpPart.Type;
_operatorPart.Func = newOpPart.Func;
}
if (_operatorPart.Name != newOpPart.Name)
{
_operatorPart.Name = newOpPart.Name;
}
if (_operatorPart.IsMultiInput != newOpPart.IsMultiInput)
{
_operatorPart.IsMultiInput = newOpPart.IsMultiInput;
}
App.Current.UpdateRequiredAfterUserInteraction = true;
}
private void RebuiltAnimationContainer()
{
foreach (var el in m_Animations)
{
el.Value.ChangedEvent -= CurveChangedHandler;
}
m_Animations.Clear();
foreach (var opPart in m_OperatorParts)
{
OperatorPart animationOpPart = Animation.GetRegardingAnimationOpPart(opPart);
if (animationOpPart == null)
{
continue;
}
var curve = animationOpPart.Func as ICurve;
if (curve != null)
{
m_Animations[opPart] = curve;
}
}
foreach (var el in m_Animations)
{
el.Value.ChangedEvent += CurveChangedHandler;
}
}
public Rect GetRangeForInputConnectionLine(OperatorPart input, int multiInputIndex, bool insertConnection = false)
{
var zones = OperatorWidgetInputZoneManager.ComputeInputZonesForOp(this);
OperatorWidgetInputZone matchingZone = null;
foreach (var zone in zones)
{
if (zone.Input == input && zone.MultiInputIndex == multiInputIndex)
{
if (!insertConnection && zone.InsertAtMultiInputIndex)
{
continue;
}
matchingZone = zone;
break;
}
}
// Animations on non-relevant paraemters don't have a matching zone...
if (matchingZone == null)
{
return(new Rect(0, 0, 0, 0));
}
double minX = matchingZone.LeftPosition;
double maxX = matchingZone.LeftPosition + matchingZone.Width;
return(new Rect(minX, Height, maxX - minX, 0));
}
public PublishAsInputCommand(OperatorPart inputToPublish, string newName)
{
_inputToPublishID = inputToPublish.ID;
_operatorID = inputToPublish.Parent.ID;
_compOpMetaID = inputToPublish.Parent.Parent.Definition.ID;
_compOpID = inputToPublish.Parent.Parent.ID;
_newName = newName;
}
public static void ClassInit(TestContext context)
{
_parentOperator = new Operator(Guid.NewGuid(), new MetaOperator(Guid.NewGuid()), new List <OperatorPart>(), new List <OperatorPart>(), new List <Operator>(), new List <OperatorPart>());
_parentFunc = new ParentFunc();
_parentOpPart = new OperatorPart(Guid.NewGuid(), _parentFunc)
{
Parent = _parentOperator
};
}
public void PostEvaluate(OperatorPart opPart)
{
var transformFunc = opPart.Func as ISceneTransform;
if (transformFunc != null)
{
_transforms.Pop();
}
}
public void Collect(OperatorPart startPoint)
{
Clear();
startPoint.TraverseWithFunction(this, this);
if (!CollectedMeshes.Any())
{
Logger.Warn(_parent, "Found no mesh supplier, have you forgotten to add an input?");
}
}
public void PreEvaluate(OperatorPart opPart)
{
NumTotalEvaluations++;
if (!_uniqueOpParts.Contains(opPart))
{
NumTotalOpParts++;
_uniqueOpParts.Add(opPart);
}
}
public UpdateOperatorPartValueFunctionCommand(OperatorPart opPart, IValue newValue)
{
_isDefaultFuncSet = opPart.IsDefaultFuncSet;
_previousValue = (opPart.Func as Utilities.ValueFunction).Value;
Value = newValue;
_opPartInstanceID = opPart.ID;
_parentOperatorInstanceID = opPart.Parent.ID;
_parentOperatorMetaID = opPart.Parent.Definition.ID;
}
/// <summary>
/// Returns the string representation of the given <see cref="OperatorPart"/>.
/// </summary>
/// <param name="op"></param>
/// <param name="assignment"></param>
/// <returns></returns>
public static string GetCharacter(this OperatorPart op, bool assignment = false)
{
var text = string.Empty;
switch (op)
{
case OperatorPart.Modulus:
text = "%";
break;
case OperatorPart.Addition:
case OperatorPart.UnaryPlus:
text = "+";
break;
case OperatorPart.Subtraction:
case OperatorPart.UnaryNegation:
text = "-";
break;
case OperatorPart.Multiply:
text = "*";
break;
case OperatorPart.Division:
text = "/";
break;
case OperatorPart.Equality:
text = "==";
break;
case OperatorPart.Inequality:
text = "!=";
break;
case OperatorPart.LessThan:
text = "<";
break;
case OperatorPart.GreaterThan:
text = ">";
break;
case OperatorPart.LessThanOrEqual:
text = "<=";
break;
case OperatorPart.GreaterThanOrEqual:
text = ">=";
break;
}
Assert.That(text, Has.Length.GreaterThan(0), "Operator {0} is unsupported at ths time.", op);
return(text + (assignment ? "=" : string.Empty));
}
public static float GetCurrentValueAtTime(OperatorPart opPart, double time)
{
OperatorPartContext context = new OperatorPartContext()
{
Time = (float)time
};
return(opPart.Eval(context).Value);
}
OperatorPart FindInput(Operator op, String name)
{
OperatorPart matchingInput = null;
foreach (var input in op.Inputs.Where(input => input.Name == name))
{
matchingInput = input;
}
return(matchingInput);
}
public SetInputAsDefault(OperatorPart input)
{
var metaInput = input.Parent.GetMetaInput(input);
_inputMetaID = metaInput.ID;
_instanceID = input.ID;
_previousDefaultValue = ((Utilities.ValueFunction)input.DefaultFunc).Value;
_newDefaultValue = ((Utilities.ValueFunction)input.Func).Value;
_parentInstanceID = input.Parent.ID;
_parentMetaID = input.Parent.Definition.ID;
}
public void PreEvaluate(OperatorPart opPart)
{
Framefield.Core.OperatorPartTraits.ITimeClip clip = opPart.Func as Framefield.Core.OperatorPartTraits.ITimeClip;
if ((clip != null) && !_uniqueClips.Contains(clip))
{
_times.Add(clip.StartTime);
_times.Add(0.5 * (clip.StartTime + clip.EndTime));
_times.Add(clip.EndTime - 1.0 / 60);
_uniqueClips.Add(clip);
}
}
public SetFloatValueCommand(OperatorPart opPart, float value)
{
var valueFunc = opPart.Func as Utilities.ValueFunction;
var floatValue = valueFunc.Value as Float;
_previousValue = floatValue.Val;
_value = value;
_opPartInstanceID = opPart.ID;
_opInstanceID = opPart.Parent.ID;
_parentMetaID = opPart.Parent.Parent.Definition.ID;
}
public static TResult InvokeOperator <THost, TResult>(this THost host, OperatorPart op,
params object[] args)
{
return(host.InvokeOperator(op, from a in args select a.GetType(),
x =>
{
Assert.That(x, Is.Not.Null);
Assert.That(x, Is.TypeOf <TResult>());
return (TResult)x;
}, args));
}
// Creates an unfinished Connection that should be updated during DragDelta events and either removed or connected
public ConnectionLine(Operator parentOp, IConnectionLineSource source, OperatorPart output)
{
ParentOp = parentOp;
Source = source;
Output = output;
CreateLineGeometry();
IsSelected = false;
ID = Guid.Empty;
IsHitTestVisible = false;
_thumb.IsHitTestVisible = false;
MouseLeftButtonDown += ConnectionLine_MouseLeftButtonDownHandler;
}
public void Collect_1MeshSupplier_TransformEntryIsIdentity()
{
var scene = new OperatorPart(Guid.NewGuid(), new Utilities.ValueFunction());
var mesh1Supplier = new OperatorPart(Guid.NewGuid(), new MeshSupplier1Mesh());
scene.Connections.Add(mesh1Supplier);
var meshCollector = new MeshCollector(_parentFunc);
meshCollector.Collect(scene);
Assert.AreEqual(Matrix.Identity, meshCollector.CollectedMeshes.First().Key);
}
public void Collect_1MeshSupplierWith1Mesh_1MeshIsFound()
{
var scene = new OperatorPart(Guid.NewGuid(), new Utilities.ValueFunction());
var mesh1Supplier = new OperatorPart(Guid.NewGuid(), new MeshSupplier1Mesh());
scene.Connections.Add(mesh1Supplier);
var meshCollector = new MeshCollector(_parentFunc);
meshCollector.Collect(scene);
Assert.AreEqual(1, meshCollector.NumberOfCollectedMeshes);
}
private List <ICurve> GetAnimationCurves()
{
List <ICurve> animationCurves = new List <ICurve>();
foreach (var opPart in m_OperatorParts)
{
OperatorPart animationOpPart = Animation.GetRegardingAnimationOpPart(opPart);
if (animationOpPart != null)
{
animationCurves.Add(animationOpPart.Func as ICurve);
}
}
return(animationCurves);
}
public void PreEvaluate(OperatorPart opPart)
{
if (!_uniqueOpParts.Contains(opPart))
{
opPart.Eval(_context);
_uniqueOpParts.Add(opPart);
if (_uniqueOpParts.Count % 100 == 0)
{
float progress = Math.Min((float)_uniqueOpParts.Count / _totalNumOpParts, 1.0f);
_progressVisualizer.Update(0.3f + 0.7f * progress);
}
}
}
