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