Esempio n. 1
0
        public void RenderPackageCache_Constructor()
        {
            //Arrange
            var renderingFactory           = new DefaultRenderPackageFactory();
            List <IRenderPackage> packages = new List <IRenderPackage>();

            packages.Add(renderingFactory.CreateRenderPackage());
            Guid gPort1 = Guid.NewGuid();

            //Act
            var renderPackage  = new RenderPackageCache(packages);
            var renderPackage2 = new RenderPackageCache();

            //Assert
            //This will return null because the portMap is null
            Assert.IsNull(renderPackage.GetPortPackages(Guid.NewGuid()));

            renderPackage.Add(renderingFactory.CreateRenderPackage(), gPort1);

            //In renderPackage2 we are adding again the RenderPackageCache with the same prot
            renderPackage2.Add(renderingFactory.CreateRenderPackage(), gPort1);

            //The Add method will raise an ArgumentException since we already added the port
            Assert.Throws <ArgumentException>(() => renderPackage2.Add(renderPackage));

            //This will return null because the guid was not found in the portMap dictionary
            Assert.IsNull(renderPackage.GetPortPackages(Guid.NewGuid()));
        }
Esempio n. 2
0
        protected virtual void OnRenderPackagesUpdated(NodeModel node, RenderPackageCache packages)
        {
            RemoveGeometryForNode(node);
            if (packages.IsEmpty())
            {
                return;
            }

            // If there is no attached model update for all render packages
            if (watchModel == null)
            {
                AddGeometryForRenderPackages(packages);
                return;
            }

            // If there are no input ports update for all render packages
            var inPorts = watchModel.InPorts;

            if (inPorts == null || inPorts.Count() < 1)
            {
                AddGeometryForRenderPackages(packages);
                return;
            }

            // If there are no connectors connected to the first (only) input port update for all render packages
            var inConnectors = inPorts[0].Connectors;

            if (inConnectors == null || inConnectors.Count() < 1 || inConnectors[0].Start == null)
            {
                AddGeometryForRenderPackages(packages);
                return;
            }

            // Only update for render packages from the connected output port
            var inputId = inConnectors[0].Start.GUID;

            foreach (var port in node.OutPorts)
            {
                if (port.GUID != inputId)
                {
                    continue;
                }

                RenderPackageCache portPackages = packages.GetPortPackages(inputId);
                if (portPackages == null)
                {
                    continue;
                }

                AddGeometryForRenderPackages(portPackages);
            }
        }