private static void AddColoredQuadToPackage(IRenderPackage package)
{
// Triangle 1
package.AddTriangleVertex(0, 0, 0);
package.AddTriangleVertex(1, 0, 0);
package.AddTriangleVertex(1, 1, 0);
// For each vertex, add a color.
package.AddTriangleVertexColor(255, 0, 0, 255);
package.AddTriangleVertexColor(0, 255, 0, 255);
package.AddTriangleVertexColor(0, 0, 255, 255);
//Triangle 2
package.AddTriangleVertex(0, 0, 0);
package.AddTriangleVertex(1, 1, 0);
package.AddTriangleVertex(0, 1, 0);
package.AddTriangleVertexColor(255, 0, 0, 255);
package.AddTriangleVertexColor(0, 255, 0, 255);
package.AddTriangleVertexColor(0, 0, 255, 255);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
}
private static void AddColoredLineToPackage(IRenderPackage package)
{
package.AddLineStripVertex(0,0,0);
package.AddLineStripVertex(5,5,5);
package.AddLineStripVertexColor(255,0,0,255);
package.AddLineStripVertexColor(255,0,0,255);
// Specify line segments by adding a line vertex count.
// Ex. The above line has two vertices, so we add a line
// vertex count of 2. If we had tessellated a curve with n
// vertices, we would add a line vertex count of n.
package.AddLineStripVertexCount(2);
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
// Dynamo's renderer uses IRenderPackage objects
// to store data for rendering. The Tessellate method
// give you an IRenderPackage object which you can fill
// with render data.
// Set RequiresPerVertexColoration to let the renderer
// know that you needs to use a per-vertex color shader.
package.RequiresPerVertexColoration = true;
AddColoredQuadToPackage(package);
AddColoredLineToPackage(package);
}
public void Tessellate(List<object> objects, IRenderPackage package)
{
foreach (var item in objects)
{
List<IGraphicItem> graphicItems = GetGraphicItems(item);
if (null == graphicItems || graphicItems.Count == 0)
continue;
foreach (var g in graphicItems)
{
g.Tessellate(package);
}
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
// As you add more data to the render package, you need
// to keep track of the index where this coloration will
// start from.
geometry.Tessellate(package, parameters);
if (parameters.ShowEdges)
{
var surf = geometry as Surface;
if (surf != null)
{
foreach (var curve in surf.PerimeterCurves())
{
curve.Tessellate(package, parameters);
curve.Dispose();
}
}
var solid = geometry as Solid;
if (solid != null)
{
foreach (var geom in solid.Edges.Select(edge => edge.CurveGeometry))
{
geom.Tessellate(package, parameters);
geom.Dispose();
}
}
}
if (package.LineVertexCount > 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, color.Red, color.Green, color.Blue, color.Alpha));
}
if (package.PointVertexCount > 0)
{
package.ApplyPointVertexColors(CreateColorByteArrayOfSize(package.PointVertexCount, color.Red, color.Green, color.Blue, color.Alpha));
}
if (package.MeshVertexCount > 0)
{
package.ApplyMeshVertexColors(CreateColorByteArrayOfSize(package.MeshVertexCount, color.Red, color.Green, color.Blue, color.Alpha));
}
}
public static void PushMesh(Autodesk.Revit.DB.Mesh mesh, IRenderPackage package)
{
for (var i = 0; i < mesh.NumTriangles; i++)
{
var triangle = mesh.get_Triangle(i);
for (var j = 0; j < 3; j++)
{
var xyz = triangle.get_Vertex(j);
package.PushTriangleVertex(xyz.X, xyz.Y, xyz.Z);
}
var a = mesh.get_Triangle(i).get_Vertex(1).Subtract(mesh.get_Triangle(i).get_Vertex(0)).Normalize();
var b = mesh.get_Triangle(i).get_Vertex(2).Subtract(mesh.get_Triangle(i).get_Vertex(0)).Normalize();
var norm = a.CrossProduct(b);
package.PushTriangleVertexNormal(norm.X, norm.Y, norm.Z);
package.PushTriangleVertexNormal(norm.X, norm.Y, norm.Z);
package.PushTriangleVertexNormal(norm.X, norm.Y, norm.Z);
}
}
/// <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>
/// Gets drawables to render this Gizmo
/// </summary>
/// <param name="factory">Render package factory</param>
/// <returns>List of render package</returns>
public IEnumerable <IRenderPackage> GetDrawables(IRenderPackageFactory factory)
{
List <IRenderPackage> drawables = new List <IRenderPackage>();
foreach (var axis in axes)
{
IRenderPackage package = factory.CreateRenderPackage();
DrawAxis(ref package, axis);
drawables.Add(package);
}
var p = Planes.xyPlane;
foreach (var plane in planes)
{
IRenderPackage package = factory.CreateRenderPackage();
DrawPlane(ref package, plane, p++);
drawables.Add(package);
}
drawables.AddRange(GetDrawablesForTransientGeometry(factory));
return(drawables);
}
private static int TotalCurvesOfColor(this IRenderPackage package, Color4 color)
{
var count = 0;
var idx = 0;
for (var i = 0; i < package.LineStripVertexCounts.Count(); i++)
{
var currCount = package.LineStripVertexCounts.ElementAt(i);
if (currCount == 0)
{
continue;
}
var colorBytes = package.LineStripVertexColors.Skip(idx).Take(currCount * 4);
if (colorBytes.IsArrayOfColor(color))
{
count++;
}
idx += currCount * 4;
}
return(count);
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
for (var i = 0; i < width - 1; i++)
{
for (var j = 0; j < length - 1; j++)
{
var a = vertexCoords[i , j];
var b = vertexCoords[i , j + 1];
var c = vertexCoords[i + 1, j];
var d = vertexCoords[i + 1, j + 1];
var v1 = Vector.ByTwoPoints(b, a).Cross(Vector.ByTwoPoints(c, b)).Normalized().Reverse();
var v2 = Vector.ByTwoPoints(c, d).Cross(Vector.ByTwoPoints(b, d)).Normalized().Reverse();
PushTriangleVertex(package, a, v1);
PushTriangleVertex(package, b, v1);
PushTriangleVertex(package, c, v1);
PushTriangleVertex(package, d, v2);
PushTriangleVertex(package, c, v2);
PushTriangleVertex(package, b, v2);
}
}
}
public void Tessellate(IRenderPackage package, double tol = -1, int maxGridLines = 512)
{
for (var i = 0; i < width - 1; i++)
{
for (var j = 0; j < length - 1; j++)
{
var a = vertexCoords[i, j];
var b = vertexCoords[i, j + 1];
var c = vertexCoords[i + 1, j];
var d = vertexCoords[i + 1, j + 1];
var v1 = Vector.ByTwoPoints(b, a).Cross(Vector.ByTwoPoints(c, b)).Normalized().Reverse();
var v2 = Vector.ByTwoPoints(c, d).Cross(Vector.ByTwoPoints(b, d)).Normalized().Reverse();
PushTriangleVertex(package, a, v1);
PushTriangleVertex(package, b, v1);
PushTriangleVertex(package, c, v1);
PushTriangleVertex(package, d, v2);
PushTriangleVertex(package, c, v2);
PushTriangleVertex(package, b, v2);
}
}
}
/// <summary>
/// Pushes an uncolored quad into a package.
/// </summary>
private static void PushQuadIntoPackage(IRenderPackage package)
{
package.AddTriangleVertex(0, 0, 0);
package.AddTriangleVertex(1, 0, 0);
package.AddTriangleVertex(1, 1, 0);
package.AddTriangleVertex(0, 0, 0);
package.AddTriangleVertex(1, 1, 0);
package.AddTriangleVertex(0, 1, 0);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
}
private void CreateColorMapOnSurface(IRenderPackage package, TessellationParameters parameters)
{
const byte gray = 80;
var previousMeshVertexCount = package.MeshVertexCount;
var previousLineVertexCount = package.LineVertexCount;
geometry.Tessellate(package, parameters);
var colorBytes = new List <byte>();
foreach (var colorArr in colorMap)
{
foreach (var c in colorArr)
{
colorBytes.Add(c.Blue);
colorBytes.Add(c.Green);
colorBytes.Add(c.Red);
colorBytes.Add(c.Alpha);
}
}
TessellateEdges(package, parameters);
if (package is IRenderPackageSupplement packageSupplement)
{
packageSupplement.AddTextureMapForMeshVerticesRange(previousMeshVertexCount, package.MeshVertexCount - 1, colorBytes.ToArray(),
colorMap.First().Length * 4);
if (package.LineVertexCount > previousLineVertexCount)
{
packageSupplement.UpdateLineVertexColorForRange(previousLineVertexCount, package.LineVertexCount - 1,
gray, gray,
gray, 255);
}
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
// This example contains information to draw a point
package.AddPointVertex(point.X, point.Y, point.Z);
package.AddPointVertexColor(255, 0, 0, 255);
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
}
internal override bool TessellateCore(IRenderPackage package)
{
if(!base.TessellateCore(package))
this.Geometry.Tessellate(package);
return true;
}
public void Tessellate(IRenderPackage package, double tol = -1, int maxGridLines = 512)
{
AsVector().Tessellate(package, tol, maxGridLines);
}
private void TessellateEdges(IRenderPackage package, TessellationParameters parameters)
{
if (!parameters.ShowEdges) return;
var surf = geometry as Surface;
if (surf != null)
{
foreach (var curve in surf.PerimeterCurves())
{
curve.Tessellate(package, parameters);
curve.Dispose();
}
}
var solid = geometry as Solid;
if (solid != null)
{
foreach (var geom in solid.Edges.Select(edge => edge.CurveGeometry))
{
geom.Tessellate(package, parameters);
geom.Dispose();
}
}
}
public void Tessellate(List<object> objects, IRenderPackage package, TessellationParameters parameters)
{
throw new NotImplementedException();
}
/// <summary>
/// Draws plane at half the scale.
/// </summary>
/// <param name="package"></param>
/// <param name="plane"></param>
/// <param name="name"></param>
private void DrawPlane(ref IRenderPackage package, Plane plane, Planes name)
{
package.Description = string.Format("{0}_{1}_{2}", RenderDescriptions.ManipulatorPlane, Name, name.ToString());
var p1 = Origin.Add(plane.XAxis.Scale(scale/2));
var p2 = p1.Add(plane.YAxis.Scale(scale/2));
var p3 = Origin.Add(plane.YAxis.Scale(scale/2));
package.AddLineStripVertexCount(3);
package.AddLineStripVertexColor(0, 0, 255, 255);
package.AddLineStripVertex(p1.X, p1.Y, p1.Z);
package.AddLineStripVertexColor(0, 0, 255, 255);
package.AddLineStripVertex(p2.X, p2.Y, p2.Z);
package.AddLineStripVertexColor(0, 0, 255, 255);
package.AddLineStripVertex(p3.X, p3.Y, p3.Z);
}
public static void DrawLine(IRenderPackage package, Triple start, Triple end) => DrawLine(package, start, end, DefaultLineColor);
public static void DrawPolyline(IRenderPackage package, List <Triple> vertices) => DrawPolyline(package, vertices, DefaultLineColor);
public static void DrawPoints(IRenderPackage package, List <Triple> points) => DrawPoints(package, points, DefaultPointColor);
public static void DrawPoint(IRenderPackage package, Triple point) => DrawPoint(package, point, DefaultPointColor);
public static void DrawPoint(IRenderPackage package, Triple point, Color color)
{
package.AddPointVertex(point.X, point.Y, point.Z);
package.AddPointVertexColor(color.R, color.G, color.B, color.A);
}
public void Tessellate(IRenderPackage package, double tol = -1, int maxGridLines = 512)
{
// This example contains information to draw a point
package.AddPointVertex(point.X, point.Y, point.Z);
package.AddPointVertexColor(255, 0, 0, 255);
}
private static void PushGraphicItemIntoPackage(IGraphicItem graphicItem, IRenderPackage package, string tag, double size)
{
graphicItem.Tessellate(package, -1.0, 32);
package.Tag = tag;
}
private void PushTriangleVertex(IRenderPackage package, Point p, Vector n)
{
package.PushTriangleVertex(p.X, p.Y, p.Z);
package.PushTriangleVertexColor(255, 255, 0, 255);
package.PushTriangleVertexNormal(n.X, n.Y, n.Z);
}
public void Tessellate(IRenderPackage package, double tol, int gridLines)
{
// Do nothing. We implement this method only to prevent the GraphicDataProvider from
// attempting to interrogate the public properties, some of which may require regeneration
// or transactions and which must necessarily be threaded in a specific way.
}
public void Tessellate(List <object> objects, IRenderPackage package)
{
throw new NotImplementedException();
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
// This example contains information to draw a point
package.AddPointVertex(point.X, point.Y, point.Z);
package.AddPointVertexColor(255, 0, 0, 255);
}
private void CreateGeometryRenderData(Color color, IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
// As you add more data to the render package, you need
// to keep track of the index where this coloration will
// start from.
geometry.Tessellate(package, parameters);
TessellateEdges(package, parameters);
if (package.LineVertexCount > 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, color.Red, color.Green,
color.Blue, color.Alpha));
}
if (package.PointVertexCount > 0)
{
package.ApplyPointVertexColors(CreateColorByteArrayOfSize(package.PointVertexCount, color.Red, color.Green,
color.Blue, color.Alpha));
}
if (package.MeshVertexCount > 0)
{
package.ApplyMeshVertexColors(CreateColorByteArrayOfSize(package.MeshVertexCount, color.Red, color.Green,
color.Blue, color.Alpha));
}
}
public override void DrawGraphics(IRenderPackage package, TessellationParameters parameters, List <Node> allNodes)
=> GeometryRender.DrawLine(
package,
allNodes[NodeIndices[0]].Position,
allNodes[NodeIndices[1]].Position,
Color);
private static void CreateVertexColoredMesh(Point[] vertices, Color[] colors, IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
for (var i = 0; i <= vertices.Count()-3; i+=3)
{
var ptA = vertices[i];
var ptB = vertices[i+1];
var ptC = vertices[i+2];
if (ptA.IsAlmostEqualTo(ptB) ||
ptB.IsAlmostEqualTo(ptC) ||
ptA.IsAlmostEqualTo(ptC))
{
continue;
}
var alongLine = false;
using (var l = Line.ByStartPointEndPoint(ptA, ptC))
{
alongLine = ptB.DistanceTo(l) < 0.00001;
}
if (alongLine)
{
continue;
}
var cA = colors[i];
var cB = colors[i+1];
var cC = colors[i+2];
var s1 = ptB.AsVector().Subtract(ptA.AsVector()).Normalized();
var s2 = ptC.AsVector().Subtract(ptA.AsVector()).Normalized();
var n = s1.Cross(s2);
package.AddTriangleVertex(ptA.X, ptA.Y, ptA.Z);
package.AddTriangleVertexNormal(n.X, n.Y, n.Z);
package.AddTriangleVertexColor(cA.Red, cA.Green, cA.Blue, cA.Alpha);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(ptB.X, ptB.Y, ptB.Z);
package.AddTriangleVertexNormal(n.X, n.Y, n.Z);
package.AddTriangleVertexColor(cB.Red, cB.Green, cB.Blue, cB.Alpha);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(ptC.X, ptC.Y, ptC.Z);
package.AddTriangleVertexNormal(n.X, n.Y, n.Z);
package.AddTriangleVertexColor(cC.Red, cC.Green, cC.Blue, cC.Alpha);
package.AddTriangleVertexUV(0, 0);
}
}
/// <summary>
/// Pushes an uncolored line into a package.
/// </summary>
internal static void PushLineIntoPackage(IRenderPackage package)
{
package.AddLineStripVertex(0, 0, 0);
package.AddLineStripVertex(1, 1, 1);
package.AddLineStripVertexCount(2);
}
/// <summary>
/// Pushes an uncolored quad into a package.
/// </summary>
private static void PushQuadIntoPackage(IRenderPackage package)
{
package.AddTriangleVertex(0,0,0);
package.AddTriangleVertex(1,0,0);
package.AddTriangleVertex(1,1,0);
package.AddTriangleVertex(0,0,0);
package.AddTriangleVertex(1,1,0);
package.AddTriangleVertex(0,1,0);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexNormal(0, 0, 1);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertexUV(0, 0);
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
AsVector().Tessellate(package, parameters);
}
/// <summary>
/// Pushes an uncolored line into a package.
/// </summary>
internal static void PushLineIntoPackage(IRenderPackage package)
{
package.AddLineStripVertex(0,0,0);
package.AddLineStripVertex(1,1,1);
package.AddLineStripVertexCount(2);
}
/// <summary>
/// Pushes a point into a package.
/// </summary>
private static void PushPointIntoPackage(IRenderPackage package)
{
package.AddPointVertex(0,0,0);
}
/// <summary>
/// Pushes a point into a package.
/// </summary>
private static void PushPointIntoPackage(IRenderPackage package)
{
package.AddPointVertex(0, 0, 0);
}
public void Tessellate(IRenderPackage package)
{
mEntity.Tessellate(package);
}
public override void Tessellate(IRenderPackage package, double tol, int gridLines)
{
InternalEdge.AsCurve().Tessellate()
.ToList()
.ForEach(x => package.PushLineStripVertex(x.X, x.Y, x.Z));
}
internal virtual bool TessellateCore(IRenderPackage package)
{
//Does nothing
return(false);
}
private void PushGraphicItemIntoPackage(IGraphicItem graphicItem, IRenderPackage package, string tag, double size)
{
try
{
graphicItem.Tessellate(package, -1.0, dynSettings.Controller.VisualizationManager.MaxTesselationDivisions);
package.Tag = tag;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("PushGraphicItemIntoPackage: " + e);
}
}
/// <summary>
/// Draws plane at half the scale.
/// </summary>
/// <param name="package"></param>
/// <param name="plane"></param>
/// <param name="name"></param>
private void DrawPlane(ref IRenderPackage package, Plane plane, Planes name)
{
package.Description = string.Format("{0}_{1}_{2}", RenderDescriptions.ManipulatorPlane, Name, name);
using (var vec1 = plane.XAxis.Scale(scale/3))
using (var vec2 = plane.YAxis.Scale(scale/3))
using (var vec3 = plane.YAxis.Scale(scale/3))
{
using (var p1 = Origin.Add(vec1))
using (var p2 = p1.Add(vec2))
using (var p3 = Origin.Add(vec3))
{
var axis = plane.Normal;
var color = GetAxisColor(GetAlignedAxis(axis));
package.AddLineStripVertexCount(3);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(p1.X, p1.Y, p1.Z);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(p2.X, p2.Y, p2.Z);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(p3.X, p3.Y, p3.Z);
}
}
}
public void Tessellate(IRenderPackage package, double tol, int gridLines)
{
//Ensure that the object is still alive
if (!IsAlive) return;
this.Curve.Tessellate(package, tol);
}
public void Tessellate(IRenderPackage package)
{
mEntity.Tessellate(package);
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
// Do nothing. We implement this method only to prevent the GraphicDataProvider from
// attempting to interrogate the public properties, some of which may require regeneration
// or transactions and which must necessarily be threaded in a specific way.
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
package.AddPointVertex(point.X, point.Y, point.Z);
package.Description = label;
}
/// <summary>
/// Draws axis line
/// </summary>
/// <param name="package"></param>
/// <param name="axis"></param>
/// <param name="name"></param>
private void DrawAxisLine(ref IRenderPackage package, Vector axis, string name)
{
package.Description = string.Format("{0}_{1}_{2}", RenderDescriptions.AxisLine, Name, name);
using (var line = RayExtensions.ToOriginCenteredLine(Origin, axis))
{
var color = GetAxisColor(GetAlignedAxis(axis));
package.AddLineStripVertexCount(2);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(line.StartPoint.X, line.StartPoint.Y, line.StartPoint.Z);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(line.EndPoint.X, line.EndPoint.Y, line.EndPoint.Z);
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
if(vertices != null)
{
CreateVertexColoredMesh(vertices, meshVertexColors, package, parameters);
return;
}
if (singleColor != null)
{
CreateGeometryRenderData(singleColor, package, parameters);
return;
}
if (colorMap != null)
{
if (!colorMap.Any())
{
return;
}
CreateColorMapOnSurface(colorMap, package, parameters);
return;
}
}
/// <summary>
/// Draws axis as 3D arrow based on scale factor.
/// </summary>
/// <param name="package"></param>
/// <param name="axis"></param>
private void DrawAxis(ref IRenderPackage package, Vector axis)
{
var axisType = GetAlignedAxis(axis);
package.Description = string.Format("{0}_{1}_{2}", RenderDescriptions.ManipulatorAxis, Name, axisType.ToString());
using (var axisEnd = Origin.Add(axis.Scale(scale)))
{
var color = GetAxisColor(axisType);
package.AddLineStripVertexCount(2);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(Origin.X, Origin.Y, Origin.Z);
package.AddLineStripVertexColor(color.R, color.G, color.B, color.A);
package.AddLineStripVertex(axisEnd.X, axisEnd.Y, axisEnd.Z);
}
}
private void CreateColorMapOnSurface(Color[][] colorMap , IRenderPackage package, TessellationParameters parameters)
{
const byte gray = 80;
geometry.Tessellate(package, parameters);
var colorBytes = new List<byte>();
foreach (var colorArr in colorMap)
{
foreach (var c in colorArr)
{
colorBytes.Add(c.Blue);
colorBytes.Add(c.Green);
colorBytes.Add(c.Red);
colorBytes.Add(c.Alpha);
}
}
package.SetColors(colorBytes.ToArray());
package.ColorsStride = colorMap.First().Length * 4;
TessellateEdges(package, parameters);
if (package.LineVertexCount > 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, gray, gray,
gray, 255));
}
}
private static void CreateVertexColoredMesh(Point[] vertices, Color[] colors, IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
for (var i = 0; i <= vertices.Count() - 3; i += 3)
{
var ptA = vertices[i];
var ptB = vertices[i + 1];
var ptC = vertices[i + 2];
if (ptA.IsAlmostEqualTo(ptB) ||
ptB.IsAlmostEqualTo(ptC) ||
ptA.IsAlmostEqualTo(ptC))
{
continue;
}
var alongLine = false;
using (var l = Line.ByStartPointEndPoint(ptA, ptC))
{
alongLine = ptB.DistanceTo(l) < 0.00001;
}
if (alongLine)
{
continue;
}
var cA = colors[i];
var cB = colors[i + 1];
var cC = colors[i + 2];
var s1 = ptB.AsVector().Subtract(ptA.AsVector()).Normalized();
var s2 = ptC.AsVector().Subtract(ptA.AsVector()).Normalized();
var n = s1.Cross(s2);
package.AddTriangleVertex(ptA.X, ptA.Y, ptA.Z);
package.AddTriangleVertexNormal(n.X, n.Y, n.Z);
package.AddTriangleVertexColor(cA.Red, cA.Green, cA.Blue, cA.Alpha);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(ptB.X, ptB.Y, ptB.Z);
package.AddTriangleVertexNormal(n.X, n.Y, n.Z);
package.AddTriangleVertexColor(cB.Red, cB.Green, cB.Blue, cB.Alpha);
package.AddTriangleVertexUV(0, 0);
package.AddTriangleVertex(ptC.X, ptC.Y, ptC.Z);
package.AddTriangleVertexNormal(n.X, n.Y, n.Z);
package.AddTriangleVertexColor(cC.Red, cC.Green, cC.Blue, cC.Alpha);
package.AddTriangleVertexUV(0, 0);
}
}
private IRenderPackage RollBackPackage(IRenderPackage package, int previousPointVertexCount, int previousLineVertexCount, int previousMeshVertexCount)
{
var newPackage = factory.CreateRenderPackage();
newPackage.Description = package.Description;
newPackage.IsSelected = package.IsSelected;
newPackage.DisplayLabels = package.DisplayLabels;
var ptVertices = package.PointVertices.ToArray();
for (var i = 0; i < previousPointVertexCount * 3 && i < ptVertices.Length; i += 3)
{
newPackage.AddPointVertex(ptVertices[i], ptVertices[i + 1], ptVertices[i + 2]);
}
var ptColors = package.PointVertexColors.ToArray();
for (var i = 0; i < previousPointVertexCount * 4 && i < ptColors.Length; i += 4)
{
newPackage.AddPointVertexColor(ptColors[i], ptColors[i + 1], ptColors[i + 2], ptColors[i + 3]);
}
var lineVertices = package.LineStripVertices.ToArray();
for (var i = 0; i < previousLineVertexCount * 3 && i < lineVertices.Length; i += 3)
{
newPackage.AddLineStripVertex(lineVertices[i], lineVertices[i + 1], lineVertices[i + 2]);
}
var lineColors = package.LineStripVertexColors.ToArray();
for (var i = 0; i < previousLineVertexCount * 4 && i < lineColors.Length; i += 4)
{
newPackage.AddLineStripVertexColor(lineColors[i], lineColors[i + 1], lineColors[i + 2], lineColors[i + 3]);
}
var lineVerticesCounts = package.LineStripVertexCounts.ToArray();
var count = 0;
var index = 0;
while (count < lineVerticesCounts.Length && count < previousLineVertexCount)
{
newPackage.AddLineStripVertexCount(lineVerticesCounts[index]);
count += lineVerticesCounts[index];
index++;
}
var meshVertices = package.MeshVertices.ToArray();
for (var i = 0; i < previousMeshVertexCount * 3 && i < meshVertices.Length; i += 3)
{
newPackage.AddTriangleVertex(meshVertices[i], meshVertices[i + 1], meshVertices[i + 2]);
}
var meshNormals = package.MeshNormals.ToArray();
for (var i = 0; i < previousMeshVertexCount * 3 && i < meshNormals.Length; i += 3)
{
newPackage.AddTriangleVertexNormal(meshNormals[i], meshNormals[i + 1], meshNormals[i + 2]);
}
var meshUV = package.MeshTextureCoordinates.ToArray();
for (var i = 0; i < previousMeshVertexCount * 2 && i < meshUV.Length; i += 2)
{
newPackage.AddTriangleVertexUV(meshUV[i], meshUV[i + 1]);
}
var meshColors = package.MeshVertexColors.ToArray();
for (var i = 0; i < previousMeshVertexCount * 4 && i < meshColors.Length; i += 4)
{
newPackage.AddTriangleVertexColor(meshColors[i], meshColors[i + 1], meshColors[i + 2], meshColors[i + 3]);
}
//Todo Need to obsolete ITransformable
if (package is ITransformable transformable && newPackage is ITransformable newTransformable)
{
newTransformable.RequiresCustomTransform = transformable.RequiresCustomTransform;
var t = transformable.Transform;
if (t.Length == 16)
{
newTransformable.SetTransform(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11], t[12], t[13], t[14], t[15]);
}
}
if (package is IRenderPackageSupplement packageSupplement && newPackage is IRenderPackageSupplement newPackageSupplement)
{
var textureMapsList = packageSupplement.TextureMapsList;
var textureMapsStrideList = packageSupplement.TextureMapsStrideList;
var meshVerticesRange = packageSupplement.MeshVerticesRangesAssociatedWithTextureMaps;
packageSupplement.AllowLegacyColorOperations = false;
for (var i = 0; i < textureMapsList.Count; i++)
{
newPackageSupplement.AddTextureMapForMeshVerticesRange(meshVerticesRange[i].Item1, meshVerticesRange[i].Item2, textureMapsList[i], textureMapsStrideList[i]);
}
}
if (package is IRenderLabels renderLabels && newPackage is IRenderLabels newRenderLabels)
{
var labelData = renderLabels.LabelData;
foreach (var(label, pt) in labelData)
{
newRenderLabels.AddLabel(label, pt[0], pt[1], pt[2]);
}
}
return(newPackage);
}
public void Tessellate(List<object> objects, IRenderPackage package, double tol)
{
throw new NotImplementedException();
}
public void Tessellate(IRenderPackage package, double tol = -1, int maxGridLines = 512)
{
package.AddPointVertex(point.X, point.Y, point.Z);
package.Description = label;
}
internal static void AddColouredVertex(IRenderPackage package, gVertex vertex, DSCore.Color color)
{
package.AddPointVertex(vertex.X, vertex.Y, vertex.Z);
package.AddPointVertexColor(color.Red, color.Green, color.Blue, color.Alpha);
}
internal override sealed bool TessellateCore(IRenderPackage package)
{
if (base.TessellateCore(package))
return true;
DSColor c = (this.Color == null) ? DSColor.Yellow : this.Color;
int nMaxSamples = 16;
IPointEntity[] samples = GetSamplePoints(nMaxSamples);
foreach (var item in samples)
{
package.PushLineStripVertex(item.X, item.Y, item.Z);
package.PushLineStripVertexColor(c.RedValue, c.GreenValue, c.BlueValue, c.AlphaValue);
}
int nSamples = samples.Length;
if (this.IsClosed)
{
package.PushLineStripVertex(samples[0].X, samples[0].Y, samples[0].Z);
package.PushLineStripVertexColor(c.RedValue, c.GreenValue, c.BlueValue, c.AlphaValue);
++nSamples;
}
package.PushLineStripVertexCount(nSamples);
return true;
}
