private void OnRequestCreateModels(RenderPackageCache packages, bool forceAsyncCall = false) { if (RequestCreateModels != null) { RequestCreateModels(packages, forceAsyncCall); } }
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())); }
private void CurrentWorkspaceModel_UpdateViewportGeometry(NodeModel nodeModel, RenderPackageCache packages) { PackageContent = packages; DisplayPreview = nodeModel.ShouldDisplayPreview; NodeGuid = nodeModel.GUID.ToString(); TransactionType = "update"; RaisePropertyChanged("RenderData"); }
public override void AddGeometryForRenderPackages(RenderPackageCache packages, bool forceAsyncCall = false) { if (Active) { // Raise request for model objects to be created on the UI thread. OnRequestCreateModels(packages, forceAsyncCall); } }
public RenderPackageCache BuildRenderPackage() { var packages = new RenderPackageCache(); foreach (var subManipulator in subManipulators) { packages.Add(subManipulator.BuildRenderPackage()); } return(packages); }
private void RequestCreateModelsHandler(RenderPackageCache packages, bool forceAsyncCall = false) { if (!forceAsyncCall && CheckAccess()) { ViewModel.GenerateViewGeometryFromRenderPackagesAndRequestUpdate(packages); } else { Dispatcher.BeginInvoke(DispatcherPriority.Render, new Action(() => ViewModel.GenerateViewGeometryFromRenderPackagesAndRequestUpdate(packages))); } }
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); } }
void NodeRenderPackagesUpdated(NodeModel node, RenderPackageCache packages) { var curvePackage = packages.Packages.FirstOrDefault(p => p.LineVertexCount > 0); if (curvePackage == null) { return; } var expectedColor = (Color)SharedDictionaryManager.DynamoColorsAndBrushesDictionary["EdgeColor"]; Assert.True(curvePackage.AllLineStripVerticesHaveColor(expectedColor)); }
private void NodeRenderPackagesUpdated(NodeModel nodeModel, RenderPackageCache renderPackages) { if (renderPackages.Packages.Any()) { data = new GeometryData(nodeModel.GUID.ToString(), renderPackages.Packages); // We have geometry HasGeometry = true; } // We are 'Done' Done.Set(); }
protected override void OnRenderPackagesUpdated(NodeModel node, RenderPackageCache renderPackages) { var updatedNode = dynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.GUID == node.GUID); if (updatedNode == null) { return; } var visibleUpstream = new List <NodeModel>(); watchModel.VisibleUpstreamNodes(visibleUpstream); if (!visibleUpstream.Contains(updatedNode)) { return; } base.OnRenderPackagesUpdated(node, renderPackages); }
/// <summary> /// Builds render packages as required for rendering this manipulator. /// </summary> /// <returns>List of render packages</returns> public RenderPackageCache BuildRenderPackage() { Debug.Assert(IsMainThread()); warning = string.Empty; var packages = new RenderPackageCache(); try { var gizmos = GetGizmos(true); foreach (var item in gizmos) { packages.Add(item.GetDrawables()); } } catch (Exception e) { warning = Properties.Resources.DirectManipulationError + ": " + e.Message; Node.Warning(warning); } return(packages); }
/// <summary> /// Returns drawables for transient geometry associated with Gizmo /// </summary> /// <returns></returns> public override RenderPackageCache GetDrawablesForTransientGraphics() { var drawables = new RenderPackageCache(); if (null != hitAxis) { IRenderPackage package = RenderPackageFactory.CreateRenderPackage(); DrawAxisLine(ref package, hitAxis, "xAxisLine"); drawables.Add(package); } if (null != hitPlane) { IRenderPackage package = RenderPackageFactory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.XAxis, "xAxisLine"); drawables.Add(package); package = RenderPackageFactory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.YAxis, "yAxisLine"); drawables.Add(package); } return(drawables); }
/// <summary> /// Returns drawables to render this Gizmo /// </summary> /// <returns>List of render package</returns> public override RenderPackageCache GetDrawables() { var drawables = new RenderPackageCache(); foreach (Vector axis in axes) { IRenderPackage package = RenderPackageFactory.CreateRenderPackage(); DrawAxis(ref package, axis); drawables.Add(package); } var p = Planes.xyPlane; foreach (Plane plane in planes) { IRenderPackage package = RenderPackageFactory.CreateRenderPackage(); DrawPlane(ref package, plane, p++); drawables.Add(package); } drawables.Add(GetDrawablesForTransientGraphics()); return(drawables); }
/// <summary> /// Generates render packages for all the drawables of this manipulator. /// Before actually generating the render packages it ensures that this /// object is properly updated. This method is called when the output /// of the node is rendered. /// This function can only be called on the UI thread if there's a node selection OR /// called on the scheduler thread if there's a node update /// </summary> /// <returns>List of render packages</returns> private RenderPackageCache GenerateRenderPackages() { var packages = new RenderPackageCache(); // This can happen only when the node is updating along with the manipulator // and meanwhile it is deselected in the UI before the manipulator is killed if (!Node.IsSelected) { return(packages); } // This check is required as for some reason LibG fails to load, geometry nodes are null // and we must return immediately before proceeding with further calls to ProtoGeometry if (IsNodeNull(Node.CachedValue)) { return(packages); } AssignInputNodes(); active = UpdatePosition(); if (!IsEnabled()) { return(packages); } // Blocking call to build render packages only in UI thread // to avoid race condition with gizmo members b/w scheduler and UI threads. // Race condition can occur if say one gizmo is moving due to another gizmo // and it is highlighted when it comes near the mouse pointer. RenderPackageCache result = null; BackgroundPreviewViewModel.Invoke(() => result = BuildRenderPackage()); return(result); }
/// <summary> /// Call this method to add the render package. /// </summary> /// <param name="packages"></param> /// <param name="forceAsyncCall"></param> public virtual void AddGeometryForRenderPackages(RenderPackageCache packages, bool forceAsyncCall = false) { // Override in inherited classes. }
private void NodeRenderPackagesUpdated(NodeModel nodeModel, RenderPackageCache renderPackages) { if (renderPackages.Packages.Count() > 0) { List <double[]> verts = new List <double[]>(); List <List <byte> > vertColors = new List <List <byte> >(); List <double[]> normals = new List <double[]>(); List <List <double> > points = new List <List <double> >(); List <List <byte> > pointColors = new List <List <byte> >(); List <List <double> > lines = new List <List <double> >(); List <List <byte> > lineColors = new List <List <byte> >(); foreach (IRenderPackage p in renderPackages.Packages) { var meshVertices = p.MeshVertices.ToArray(); if (meshVertices.Length > 0) { verts.Add(meshVertices); } var meshVertexColors = p.MeshVertexColors.ToList(); if (meshVertexColors.Count > 0) { vertColors.Add(meshVertexColors); } var meshNormals = p.MeshNormals.ToArray(); if (meshNormals.Length > 0) { normals.Add(meshNormals); } var pointVertices = p.PointVertices.ToList(); if (pointVertices.Count > 0) { points.Add(pointVertices); } var pointVertexColors = p.PointVertexColors.ToList(); if (pointVertexColors.Count > 0) { pointColors.Add(pointVertexColors); } var lineStripVertices = p.LineStripVertices.ToList(); if (lineStripVertices.Count > 0) { lines.Add(lineStripVertices); } var lineStripVertexColors = p.LineStripVertexColors.ToList(); if (lineStripVertexColors.Count > 0) { lineColors.Add(lineStripVertexColors); } } groupData.Add("name", nodeModel.GUID.ToString()); groupData.Add("vertices", verts); groupData.Add("verticeColors", vertColors); groupData.Add("normals", normals); groupData.Add("points", points); groupData.Add("pointColors", pointColors); groupData.Add("lines", lines); groupData.Add("lineColors", lineColors); // We have geometry HasGeometry = true; } // We are 'Done' Done.Set(); }
/// <summary> /// Called from derived classes when a collection of render packages /// are available to be processed as render geometry. /// </summary> /// <param name="taskPackages">A collection of packages from which to /// create render geometry.</param> public virtual void GenerateViewGeometryFromRenderPackagesAndRequestUpdate( RenderPackageCache taskPackages) { // Override in derived classes }
internal UpdateRenderPackageAsyncTask(IScheduler scheduler) : base(scheduler) { nodeGuid = Guid.Empty; renderPackageCache = new RenderPackageCache(); }