Beispiel #1
0
        protected virtual bool UpdateSlots(List <VFXDataAnchorController> newAnchors, IEnumerable <VFXSlot> slotList, bool expanded, bool input)
        {
            VFXSlot[] slots   = slotList.ToArray();
            bool      changed = false;

            foreach (VFXSlot slot in slots)
            {
                VFXDataAnchorController propController = GetPropertyController(slot, input);

                if (propController == null)
                {
                    propController = AddDataAnchor(slot, input, !expanded);
                    changed        = true;
                }
                newAnchors.Add(propController);

                if (!VFXDataAnchorController.SlotShouldSkipFirstLevel(slot))
                {
                    changed |= UpdateSlots(newAnchors, slot.children, expanded && propController.expandedSelf, input);
                }
                else
                {
                    VFXSlot firstSlot = slot.children.First();
                    changed |= UpdateSlots(newAnchors, firstSlot.children, expanded && propController.expandedSelf, input);
                }
            }

            return(changed);
        }
 public override void OnEdgeFromOutputGoingToBeRemoved(VFXDataAnchorController myOutput, VFXDataAnchorController otherInput)
 {
     base.OnEdgeFromOutputGoingToBeRemoved(myOutput, otherInput);
     if (!parentController.isOutput)
     {
         infos.linkedSlots.RemoveAll(t => t.outputSlot == myOutput.model && t.inputSlot == otherInput.model);
     }
 }
Beispiel #3
0
        public override VFXDataAnchor InstantiateDataAnchor(VFXDataAnchorController controller, VFXNodeUI node)
        {
            VFXContextDataAnchorController anchorController = controller as VFXContextDataAnchorController;

            VFXEditableDataAnchor anchor = VFXBlockDataAnchor.Create(anchorController, node);

            return(anchor);
        }
        public static new VFXInputParameterDataAnchor Create(VFXDataAnchorController controller, VFXNodeUI node)
        {
            var anchor = new VFXInputParameterDataAnchor(controller.orientation, controller.direction, controller.portType, node);

            anchor.m_EdgeConnector = new EdgeConnector <VFXDataEdge>(anchor);
            anchor.controller      = controller;
            anchor.AddManipulator(anchor.m_EdgeConnector);
            return(anchor);
        }
        public void RemoveOperand(VFXDataAnchorController myInput)
        {
            var slotIndex = model.GetSlotIndex(myInput.model);

            if (slotIndex != -1)
            {
                RemoveOperand(slotIndex);
            }
        }
 public override VFXDataAnchor InstantiateDataAnchor(VFXDataAnchorController controller, VFXNodeUI node)
 {
     if (controller.direction == Direction.Input)
     {
         return(VFXInputParameterDataAnchor.Create(controller, node));
     }
     else
     {
         return(VFXOutputParameterDataAnchor.Create(controller, node));
     }
 }
Beispiel #7
0
 public bool CouldLink(VFXDataAnchorController myAnchor, VFXDataAnchorController otherAnchor, VFXDataAnchorController.CanLinkCache cache)
 {
     if (myAnchor.direction == Direction.Input)
     {
         return(CouldLinkMyInputTo(myAnchor, otherAnchor, cache));
     }
     else
     {
         return(otherAnchor.sourceNode.CouldLinkMyInputTo(otherAnchor, myAnchor, cache));
     }
 }
        // TODO This is a workaround to avoid having a generic type for the anchor as generic types mess with USS.
        public static new VFXEditableDataAnchor Create(VFXDataAnchorController controller, VFXNodeUI node)
        {
            Profiler.BeginSample("VFXEditableDataAnchor.Create");

            var anchor = new VFXEditableDataAnchor(controller.orientation, controller.direction, controller.portType, node);

            anchor.m_EdgeConnector = new VFXEdgeConnector(anchor);
            anchor.controller      = controller;
            anchor.AddManipulator(anchor.m_EdgeConnector);
            Profiler.EndSample();
            return(anchor);
        }
        protected override bool CouldLinkMyInputTo(VFXDataAnchorController myInput, VFXDataAnchorController otherOutput, VFXDataAnchorController.CanLinkCache cache)
        {
            if (otherOutput.direction == myInput.direction)
            {
                return(false);
            }

            if (!myInput.CanLinkToNode(otherOutput.sourceNode, cache))
            {
                return(false);
            }
            return(model.GetBestAffinityType(otherOutput.portType) != null);
        }
Beispiel #10
0
        public virtual VFXDataAnchor InstantiateDataAnchor(VFXDataAnchorController controller, VFXNodeUI node)
        {
            if (controller.direction == Direction.Input)
            {
                VFXEditableDataAnchor anchor = VFXEditableDataAnchor.Create(controller, node);

                return(anchor);
            }
            else
            {
                return(VFXOutputDataAnchor.Create(controller, node));
            }
        }
Beispiel #11
0
        public VFXDataAnchorController GetPropertyController(VFXSlot slot, bool input)
        {
            VFXDataAnchorController result = null;

            if (input)
            {
                result = inputPorts.Cast <VFXDataAnchorController>().Where(t => t.model == slot).FirstOrDefault();
            }
            else
            {
                result = outputPorts.Cast <VFXDataAnchorController>().Where(t => t.model == slot).FirstOrDefault();
            }

            return(result);
        }
Beispiel #12
0
        public virtual VFXParameter.NodeLinkedSlot CreateLinkTo(VFXDataAnchorController output)
        {
            var slotOutput = output != null ? output.model : null;
            var slotInput  = model;

            sourceNode.WillCreateLink(ref slotInput, ref slotOutput);

            if (slotInput != null && slotOutput != null && slotInput.Link(slotOutput))
            {
                return(new VFXParameter.NodeLinkedSlot()
                {
                    inputSlot = slotInput, outputSlot = slotOutput
                });
            }

            return(new VFXParameter.NodeLinkedSlot());
        }
Beispiel #13
0
        public virtual bool CanLink(VFXDataAnchorController controller, CanLinkCache cache = null)
        {
            if (controller.model != null)
            {
                if (model.CanLink(controller.model) && controller.model.CanLink(model))
                {
                    if (!CanLinkToNode(controller.sourceNode, cache))
                    {
                        return(false);
                    }

                    return(true);
                }
                return(sourceNode.CouldLink(this, controller, cache));
            }

            return(controller.CanLink(this, cache));
        }
Beispiel #14
0
        public override VFXParameter.NodeLinkedSlot CreateLinkTo(VFXDataAnchorController output)
        {
            var slotOutput = output != null ? output.model : null;

            VFXOperatorNumericCascadedUnified op = sourceNode.model;

            op.AddOperand(op.GetBestAffinityType(output.model.property.type));

            var slotInput = op.GetInputSlot(op.GetNbInputSlots() - 1);

            if (slotInput != null && slotOutput != null && slotInput.Link(slotOutput))
            {
                return(new VFXParameter.NodeLinkedSlot()
                {
                    inputSlot = slotInput, outputSlot = slotOutput
                });
            }

            return(new VFXParameter.NodeLinkedSlot());
        }
Beispiel #15
0
        public override bool CanLink(VFXDataAnchorController controller, CanLinkCache cache = null)
        {
            var op = (sourceNode as VFXCascadedOperatorController);

            if (op == null)
            {
                return(false);
            }

            if (controller is VFXUpcommingDataAnchorController)
            {
                return(false);
            }

            if (!CanLinkToNode(controller.sourceNode, cache))
            {
                return(false);
            }

            return(op.model.GetBestAffinityType(controller.model.property.type) != null);
        }
        protected override bool CouldLinkMyInputTo(VFXDataAnchorController myInput, VFXDataAnchorController otherOutput, VFXDataAnchorController.CanLinkCache cache)
        {
            if (!myInput.model.IsMasterSlot())
            {
                return(false);
            }
            if (otherOutput.direction == myInput.direction)
            {
                return(false);
            }

            if (!myInput.CanLinkToNode(otherOutput.sourceNode, cache))
            {
                return(false);
            }

            int inputIndex = model.GetSlotIndex(myInput.model);
            IVFXOperatorNumericUnifiedConstrained constraintInterface = model as IVFXOperatorNumericUnifiedConstrained;


            var bestAffinityType = model.GetBestAffinityType(otherOutput.portType);

            if (bestAffinityType == null)
            {
                return(false);
            }
            if (constraintInterface.slotIndicesThatCanBeScalar.Contains(inputIndex))
            {
                if (VFXTypeUtility.GetComponentCount(otherOutput.model) != 0)  // If it is a vector or float type, then conversion to float exists
                {
                    return(true);
                }
            }

            return(model.GetBestAffinityType(otherOutput.portType) != null);
        }
Beispiel #17
0
 protected virtual bool CouldLinkMyInputTo(VFXDataAnchorController myInput, VFXDataAnchorController otherOutput, VFXDataAnchorController.CanLinkCache cache)
 {
     return(false);
 }
Beispiel #18
0
 public override void OnEdgeFromInputGoingToBeRemoved(VFXDataAnchorController myInput)
 {
     base.OnEdgeFromInputGoingToBeRemoved(myInput);
     if (parentController.isOutput)
         infos.linkedSlots.RemoveAll(t => t.inputSlot == myInput.model);
 }
Beispiel #19
0
            void TransfertDataEdges()
            {
                m_SourceControllersWithBlocks = m_SourceControllers.Concat(m_SourceControllers.OfType <VFXContextController>().SelectMany(t => t.blockControllers));

                // Search for links between with inputs in the selected part and the output in other parts of the graph.
                Dictionary <VFXDataAnchorController, List <VFXDataAnchorController> > traversingInEdges = new Dictionary <VFXDataAnchorController, List <VFXDataAnchorController> >();

                foreach (var edge in m_SourceController.dataEdges.Where(
                             t =>
                {
                    if (parameterNodeControllers.Contains(t.output.sourceNode))
                    {
                        return(false);
                    }
                    var inputInControllers = m_SourceControllersWithBlocks.Contains(t.input.sourceNode);
                    var outputInControllers = m_SourceControllersWithBlocks.Contains(t.output.sourceNode);

                    return(inputInControllers && !outputInControllers);
                }
                             ))
                {
                    List <VFXDataAnchorController> outputs = null;
                    if (!traversingInEdges.TryGetValue(edge.input, out outputs))
                    {
                        outputs = new List <VFXDataAnchorController>();
                        traversingInEdges[edge.input] = outputs;
                    }

                    outputs.Add(edge.output);
                }

                var newSourceInputs = traversingInEdges.Keys.ToArray();

                for (int i = 0; i < newSourceInputs.Length; ++i)
                {
                    VFXParameter newTargetParameter = m_TargetController.AddVFXParameter(Vector2.zero, VFXLibrary.GetParameters().First(t => t.model.type == newSourceInputs[i].portType));

                    m_TargetController.LightApplyChanges();

                    VFXParameterController newTargetParamController = m_TargetController.GetParameterController(newTargetParameter);
                    newTargetParamController.exposed = true;

                    var outputs = traversingInEdges[newSourceInputs[i]];

                    var linkedParameter = outputs.FirstOrDefault(t => t.sourceNode is VFXParameterNodeController);
                    if (linkedParameter != null)
                    {
                        newTargetParamController.exposedName = (linkedParameter.sourceNode as VFXParameterNodeController).parentController.exposedName;
                    }
                    else
                    {
                        newTargetParamController.exposedName = newSourceInputs[i].name;
                    }

                    //first the equivalent of sourceInput in the target

                    VFXNodeController targetNode = null;
                    Vector2           position;

                    if (newSourceInputs[i].sourceNode is VFXBlockController)
                    {
                        var blockController = newSourceInputs[i].sourceNode as VFXBlockController;
                        if (m_TargetBlocks != null)
                        {
                            targetNode = m_TargetBlocks[m_SourceBlockControllers.IndexOf(blockController)];
                            position   = blockController.contextController.position;
                        }
                        else
                        {
                            var targetContext = m_TargetControllers[m_SourceControllers.IndexOf(blockController.contextController)] as VFXContextController;

                            targetNode = targetContext.blockControllers[blockController.index];
                            position   = blockController.contextController.position;
                        }
                    }
                    else
                    {
                        targetNode = m_TargetControllers[m_SourceControllers.IndexOf(newSourceInputs[i].sourceNode)];
                        position   = targetNode.position;
                    }

                    VFXDataAnchorController targetAnchor = targetNode.inputPorts.First(t => t.path == newSourceInputs[i].path);


                    position.y += targetAnchor.model.owner.inputSlots.IndexOf(targetAnchor.model) * 32;

                    VFXNodeController parameterNode = m_TargetController.AddVFXParameter(position - new Vector2(200, 0), newTargetParamController, null);

                    // Link the parameternode and the input in the target
                    m_TargetController.CreateLink(targetAnchor, parameterNode.outputPorts[0]);

                    if (m_SourceSlotContainer is VFXOperator)
                    {
                        (m_SourceSlotContainer as VFXOperator).ResyncSlots(true);
                    }
                    else if (m_SourceSlotContainer is VFXSubgraphBlock)
                    {
                        VFXSubgraphBlock blk = (m_SourceSlotContainer as VFXSubgraphBlock);
                        blk.RecreateCopy();
                        blk.ResyncSlots(true);
                    }
                    else if (m_SourceSlotContainer is VFXSubgraphContext)
                    {
                        VFXSubgraphContext ctx = (m_SourceSlotContainer as VFXSubgraphContext);
                        ctx.RecreateCopy();
                        ctx.ResyncSlots(true);
                    }

                    m_SourceNodeController.ApplyChanges();
                    //Link all the outputs to the matching input of the subgraph
                    foreach (var output in outputs)
                    {
                        m_SourceController.CreateLink(m_SourceNodeController.inputPorts.First(t => t.model == m_SourceSlotContainer.inputSlots.Last()), output);
                    }
                }
            }
Beispiel #20
0
            void TransfertOperatorOutputEdges()
            {
                var traversingOutEdges = new Dictionary <VFXDataAnchorController, List <VFXDataAnchorController> >();

                foreach (var edge in m_SourceController.dataEdges.Where(
                             t =>
                {
                    if (t.output.sourceNode is VFXParameterNodeController)
                    {
                        return(false);
                    }
                    var inputInControllers = m_SourceControllersWithBlocks.Contains(t.input.sourceNode);
                    var outputInControllers = m_SourceControllersWithBlocks.Contains(t.output.sourceNode);

                    return(!inputInControllers && outputInControllers);
                }
                             ))
                {
                    List <VFXDataAnchorController> inputs = null;
                    if (!traversingOutEdges.TryGetValue(edge.output, out inputs))
                    {
                        inputs = new List <VFXDataAnchorController>();
                        traversingOutEdges[edge.output] = inputs;
                    }

                    inputs.Add(edge.input);
                }

                var newSourceOutputs = traversingOutEdges.Keys.ToArray();

                for (int i = 0; i < newSourceOutputs.Length; ++i)
                {
                    VFXParameter newTargetParameter = m_TargetController.AddVFXParameter(Vector2.zero, VFXLibrary.GetParameters().First(t => t.model.type == newSourceOutputs[i].portType));

                    m_TargetController.LightApplyChanges();

                    VFXParameterController newTargetParamController = m_TargetController.GetParameterController(newTargetParameter);
                    newTargetParamController.isOutput = true;

                    var inputs = traversingOutEdges[newSourceOutputs[i]];

                    var linkedParameter = inputs.FirstOrDefault(t => t.sourceNode is VFXParameterNodeController);
                    if (linkedParameter != null)
                    {
                        newTargetParamController.exposedName = (linkedParameter.sourceNode as VFXParameterNodeController).parentController.exposedName;
                    }
                    else
                    {
                        newTargetParamController.exposedName = newSourceOutputs[i].name;
                    }

                    //first the equivalent of sourceInput in the target

                    VFXNodeController targetNode = null;

                    if (newSourceOutputs[i].sourceNode is VFXBlockController)
                    {
                        var blockController = newSourceOutputs[i].sourceNode as VFXBlockController;
                        if (m_TargetBlocks != null)
                        {
                            targetNode = m_TargetBlocks[m_SourceBlockControllers.IndexOf(blockController)];
                        }
                        else
                        {
                            var targetContext = m_TargetControllers[m_SourceControllers.IndexOf(blockController.contextController)] as VFXContextController;

                            targetNode = targetContext.blockControllers[blockController.index];
                        }
                    }
                    else
                    {
                        targetNode = m_TargetControllers[m_SourceControllers.IndexOf(newSourceOutputs[i].sourceNode)];
                    }

                    VFXDataAnchorController targetAnchor = targetNode.outputPorts.FirstOrDefault(t => t.path == newSourceOutputs[i].path);

                    if (targetAnchor != null)
                    {
                        VFXNodeController parameterNode = m_TargetController.AddVFXParameter(targetNode.position + new Vector2(400, 0), newTargetParamController, null);

                        // Link the parameternode and the input in the target
                        m_TargetController.CreateLink(parameterNode.inputPorts[0], targetAnchor);

                        if (m_SourceSlotContainer is VFXOperator)
                        {
                            (m_SourceSlotContainer as VFXOperator).ResyncSlots(true);
                        }
                        m_SourceNodeController.ApplyChanges();
                    }
                    //Link all the outputs to the matching input of the subgraph
                    foreach (var input in inputs)
                    {
                        var port = m_SourceNodeController.outputPorts.FirstOrDefault(t => t.model == m_SourceSlotContainer.outputSlots.Last());
                        if (port != null)
                        {
                            m_SourceController.CreateLink(input, port);
                        }
                    }
                }
            }
Beispiel #21
0
 public virtual void OnEdgeFromInputGoingToBeRemoved(VFXDataAnchorController myInput)
 {
 }
        public override void OnEdgeFromInputGoingToBeRemoved(VFXDataAnchorController myInput)
        {
            base.OnEdgeFromInputGoingToBeRemoved(myInput);

            RemoveOperand(myInput);
        }
Beispiel #23
0
 public virtual void OnEdgeFromOutputGoingToBeRemoved(VFXDataAnchorController myOutput, VFXDataAnchorController otherInput)
 {
 }
Beispiel #24
0
 public override VFXDataAnchor InstantiateDataAnchor(VFXDataAnchorController controller, VFXNodeUI node)
 {
     return(VFXParameterDataAnchor.Create(controller, node));
 }
Beispiel #25
0
 // Provider
 internal VFXDataAnchorGizmoContext(VFXDataAnchorController controller)
 {
     m_Controller = controller;
 }
 public void RemoveOperand(VFXDataAnchorController myInput)
 {
     RemoveOperand(model.GetSlotIndex(myInput.model));
 }