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); } } }