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()));
}
public RenderPackageCache BuildRenderPackage()
{
var packages = new RenderPackageCache();
foreach (var subManipulator in subManipulators)
{
packages.Add(subManipulator.BuildRenderPackage());
}
return(packages);
}
private void GetRenderPackagesFromMirrorData(
Guid outputPortId,
MirrorData mirrorData,
string tag,
bool displayLabels)
{
if (mirrorData.IsNull)
{
return;
}
var package = factory.CreateRenderPackage();
package.DisplayLabels = displayLabels;
package.Description = tag;
package.IsSelected = isNodeSelected;
//Initialize the package here assuming we will only generate a single renderPackage for this node
//We set the AllowLegacyColorOperations so that we can catch tessellation implementations which
//use the deprecated calls. At that point we will roll back the changes to the renderPackage
//and call tessellate with a new renderPackage object with AllowLegacyColorOperations set to true.
if (package is IRenderPackageSupplement packageSupplement)
{
packageSupplement.AllowLegacyColorOperations = false;
}
GetRenderPackagesFromMirrorDataImp(outputPortId, mirrorData, package, tag);
if (package.MeshVertexColors.Any())
{
package.RequiresPerVertexColoration = true;
}
if (package.HasRenderingData)
{
renderPackageCache.Add(package, outputPortId);
}
}
/// <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>
/// 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);
}
private void GetRenderPackagesFromMirrorData(
Guid outputPortId,
MirrorData mirrorData,
string tag,
bool displayLabels)
{
if (mirrorData.IsNull)
{
return;
}
if (mirrorData.IsCollection)
{
int count = 0;
foreach (var el in mirrorData.GetElements())
{
if (el.IsCollection || el.Data is IGraphicItem)
{
string newTag = tag + ":" + count;
GetRenderPackagesFromMirrorData(outputPortId, el, newTag, displayLabels);
}
count = count + 1;
}
}
else
{
var graphicItem = mirrorData.Data as IGraphicItem;
if (graphicItem == null)
{
return;
}
var package = factory.CreateRenderPackage();
var packageWithTransform = package as ITransformable;
package.Description = tag;
try
{
graphicItem.Tessellate(package, factory.TessellationParameters);
if (package.MeshVertexColors.Count() > 0)
{
package.RequiresPerVertexColoration = true;
}
//If the package has a transform that is not the identity matrix
//then set requiresCustomTransform to true.
if (packageWithTransform != null && packageWithTransform.Transform.SequenceEqual(
new double[] { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }) == false)
{
(packageWithTransform).RequiresCustomTransform = true;
}
if (factory.TessellationParameters.ShowEdges)
{
var topology = graphicItem as Topology;
if (topology != null)
{
var surf = graphicItem as Surface;
if (surf != null)
{
foreach (var curve in surf.PerimeterCurves())
{
curve.Tessellate(package, factory.TessellationParameters);
curve.Dispose();
}
}
else
{
var edges = topology.Edges;
foreach (var geom in edges.Select(edge => edge.CurveGeometry))
{
geom.Tessellate(package, factory.TessellationParameters);
geom.Dispose();
}
edges.ForEach(x => x.Dispose());
}
}
}
var plane = graphicItem as Plane;
if (plane != null)
{
package.RequiresPerVertexColoration = true;
var s = 2.5;
var cs = CoordinateSystem.ByPlane(plane);
var a = Point.ByCartesianCoordinates(cs, s, s, 0);
var b = Point.ByCartesianCoordinates(cs, -s, s, 0);
var c = Point.ByCartesianCoordinates(cs, -s, -s, 0);
var d = Point.ByCartesianCoordinates(cs, s, -s, 0);
// Get rid of the original plane geometry.
package.Clear();
package.AddTriangleVertex(a.X, a.Y, a.Z);
package.AddTriangleVertex(b.X, b.Y, b.Z);
package.AddTriangleVertex(c.X, c.Y, c.Z);
package.AddTriangleVertex(c.X, c.Y, c.Z);
package.AddTriangleVertex(d.X, d.Y, d.Z);
package.AddTriangleVertex(a.X, a.Y, a.Z);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
// Draw plane edges
package.AddLineStripVertex(a.X, a.Y, a.Z);
package.AddLineStripVertex(b.X, b.Y, b.Z);
package.AddLineStripVertex(b.X, b.Y, b.Z);
package.AddLineStripVertex(c.X, c.Y, c.Z);
package.AddLineStripVertex(c.X, c.Y, c.Z);
package.AddLineStripVertex(d.X, d.Y, d.Z);
package.AddLineStripVertex(d.X, d.Y, d.Z);
package.AddLineStripVertex(a.X, a.Y, a.Z);
// Draw normal
package.AddLineStripVertex(plane.Origin.X, plane.Origin.Y, plane.Origin.Z);
var nEnd = plane.Origin.Add(plane.Normal.Scale(2.5));
package.AddLineStripVertex(nEnd.X, nEnd.Y, nEnd.Z);
for (var i = 0; i < package.LineVertexCount / 2; i++)
{
package.AddLineStripVertexCount(2);
}
for (var i = 0; i < package.LineVertexCount; i++)
{
package.AddLineStripVertexColor(MidTone, MidTone, MidTone, 255);
}
for (var i = 0; i < package.MeshVertexCount; i++)
{
package.AddTriangleVertexNormal(plane.Normal.X, plane.Normal.Y, plane.Normal.Z);
}
for (var i = 0; i < package.MeshVertexCount; i++)
{
package.AddTriangleVertexColor(0, 0, 0, 10);
}
}
// The default color coming from the geometry library for
// curves is 255,255,255,255 (White). Because we want a default
// color of 0,0,0,255 (Black), we adjust the color components here.
if (graphicItem is Curve || graphicItem is Surface || graphicItem is Solid || graphicItem is Point)
{
if (package.LineVertexCount > 0 && package.LineStripVertexColors.Count() <= 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, DefR, DefG, DefB, DefA));
}
if (package.PointVertexCount > 0 && package.PointVertexColors.Count() <= 0)
{
package.ApplyPointVertexColors(CreateColorByteArrayOfSize(package.PointVertexCount, DefR, DefG, DefB, DefA));
}
}
}
catch (Exception e)
{
Debug.WriteLine(
"PushGraphicItemIntoPackage: " + e);
}
package.DisplayLabels = displayLabels;
package.IsSelected = isNodeSelected;
renderPackageCache.Add(package, outputPortId);
}
}
