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 new void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
var previousMeshVertexCount = package.MeshVertexCount;
var previousLineVertexCount = package.LineVertexCount;
foreach (var geometry in GetDynGeometry())
{
if (geometry == null)
{
continue;
}
geometry.Tessellate(package, parameters);
}
if (package is IRenderPackageSupplement packageSupplement)
{
int size = (package.MeshVertexCount - previousMeshVertexCount) * 4;
packageSupplement.AddTextureMapForMeshVerticesRange(previousMeshVertexCount, package.MeshVertexCount - 1, CreateColorByteArrayOfSize(size, DefR, DefG, DefB, DefA), size);
if (package.LineVertexCount > previousLineVertexCount)
{
packageSupplement.UpdateLineVertexColorForRange(previousLineVertexCount, package.LineVertexCount - 1, DefR, DefG, DefB, DefA);
}
}
}
public void TessellateVisibilityGraph(IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
var rangeColors = this.colorRange.Values.ToList();
for (var i = 0; i < base.graph.edges.Count; i++)
{
var e = base.graph.edges[i];
var factor = this.Factors[i];
DSCore.Color color;
if (factor <= this.colorRange.First().Key)
{
color = this.colorRange.First().Value;
}
else if (factor >= this.colorRange.Last().Key)
{
color = this.colorRange.Last().Value;
}
else
{
int index = this.colorRange.Keys.ToList().BisectIndex(factor);
color = DSCore.Color.Lerp(rangeColors[index - 1], rangeColors[index], this.Factors[i]);
}
AddColouredEdge(package, e, color);
}
}
public HelixRenderPackageFactory()
{
TessellationParameters = new TessellationParameters()
{
MaxTessellationDivisions = MaxTessellationDivisionsDefault
};
}
public DefaultRenderPackageFactory()
{
TessellationParameters = new TessellationParameters()
{
MaxTessellationDivisions = 32
};
}
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;
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
//could increase performance further by cacheing this tesselation
Geometry.Tessellate(package, parameters);
//we use reflection here because this API was added in Dynamo 1.1 and might not exist for a user in Dynamo 1.0
//if you do not care about ensuring comptability of your zero touch node with 1.0 you can just call SetTransform directly
//by casting the rendering package to ITransformable.
//look for the method SetTransform with the double[] argument list.
var method = package.GetType().
GetMethod("SetTransform", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance,
null,
new[] { typeof(double[]) }, null);
//if the method exists call it using our current transform.
if (method != null)
{
method.Invoke(package, new object[] { new double[]
{ transform.XAxis.X, transform.XAxis.Y, transform.XAxis.Z, 0,
transform.YAxis.X, transform.YAxis.Y, transform.YAxis.Z, 0,
transform.ZAxis.X, transform.ZAxis.Y, transform.ZAxis.Z, 0,
transform.Origin.X, transform.Origin.Y, transform.Origin.Z, 1 } });
}
}
/// <summary>
/// This is the method that takes care of custom rendering...
/// </summary>
/// <param name="package"></param>
/// <param name="parameters"></param>
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
Point[] pts = mesh.VertexPositions;
Vector[] normals = mesh.VertexNormals;
IndexGroup[] indices = mesh.FaceIndices;
bool foo = package.DisplayLabels;
int i = 0;
foreach (Point p in pts)
{
package.AddPointVertex(p.X, p.Y, p.Z);
package.AddPointVertexColor(255, 0, 0, 255);
}
foreach (IndexGroup ig in indices)
{
if (ig.Count == 3)
{
DrawColoredLine(package, this, pts[ig.A], pts[ig.B]);
DrawColoredLine(package, this, pts[ig.B], pts[ig.C]);
DrawColoredLine(package, this, pts[ig.C], pts[ig.A]);
}
else if (ig.Count == 4)
{
DrawColoredLine(package, this, pts[ig.A], pts[ig.B]);
DrawColoredLine(package, this, pts[ig.B], pts[ig.C]);
DrawColoredLine(package, this, pts[ig.C], pts[ig.D]);
DrawColoredLine(package, this, pts[ig.D], pts[ig.A]);
}
}
}
public new void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
//Ensure that the object is still alive
if (!IsAlive)
{
return;
}
//Location Point
DB.LocationPoint locPoint = InternalElement.Location as DB.LocationPoint;
GeometryPrimitiveConverter.ToPoint(InternalTransform.OfPoint(locPoint.Point)).Tessellate(package, parameters);
package.ApplyPointVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, 255, 0, 0, 0));
//Boundaries
foreach (DB.BoundarySegment segment in InternalBoundarySegments)
{
Curve crv = RevitToProtoCurve.ToProtoType(segment.GetCurve().CreateTransformed(InternalTransform));
crv.Tessellate(package, parameters);
if (package.LineVertexCount > 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, 255, 0, 0, 0));
}
}
}
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 void TessellateVisibilityGraph(IRenderPackage package, TessellationParameters parameters)
{
//foreach(Vertex v in graph.vertices)
//{
// AddColouredVertex(package, v, vertexDefaultColour);
//}
package.RequiresPerVertexColoration = true;
var rangeColors = colorRange.Values.ToList();
for (var i = 0; i < base.graph.edges.Count; i++)
{
var e = base.graph.edges[i];
var factor = Factors[i];
DSCore.Color color;
if (factor <= colorRange.First().Key)
{
color = colorRange.First().Value;
}
else if (factor >= colorRange.Last().Key)
{
color = colorRange.Last().Value;
}
else
{
int index = colorRange.Keys.ToList().BisectIndex(factor);
color = DSCore.Color.Lerp(rangeColors[index - 1], rangeColors[index], Factors[i]);
}
AddColouredEdge(package, e, color);
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
// Vertices
if (vertices != null)
{
RenderNetworkFrame(this, verticesDouble, package, parameters);
}
}
public new void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
using (var crv = GetDynCurve())
{
crv.Tessellate(package, parameters);
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, DefR, DefG, DefB, DefA));
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
if (network.frames != null)
{
double[][] frame = network.frameDoubles[it % frameCount];
CompasNetwork.RenderNetworkFrame(network, frame, package, parameters);
}
}
public new void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
// Offset for text adjustments
double horizontalOffset = 0;
// Get Conversion factor according to the documents units
double factor = Revit.GeometryConversion.UnitConverter.DynamoToHostFactor(UnitType.UT_Length);
// Get Text outline path at 0,0
PathGeometry path = CreateText(this.Value, this.Bold, this.Italic, new FontFamily(this.FontFamilyName), this.FontSize * Scale / factor, new System.Windows.Point(0, 0));
// Apply horizontal Text offset
if (Alignment == HorizontalTextAlignment.Center)
{
horizontalOffset = path.Bounds.Width / 2;
}
if (Alignment == HorizontalTextAlignment.Right)
{
horizontalOffset = path.Bounds.Width;
}
// Walk thorugh all figures and draw lines
foreach (PathFigure figure in path.Figures)
{
// Rotate the start point and apply offsets
var startPoint = RotatePoint(new System.Windows.Point(figure.StartPoint.X - horizontalOffset, figure.StartPoint.Y * -1), this.Rotation);
package.AddLineStripVertex(startPoint.X + Location.X, startPoint.Y + Location.Y, this.Location.Z);
foreach (PathSegment segment in figure.Segments)
{
if (segment is System.Windows.Media.PolyLineSegment)
{
System.Windows.Media.PolyLineSegment pline = segment as System.Windows.Media.PolyLineSegment;
for (int i = 0; i < pline.Points.Count; i++)
{
System.Windows.Point point = pline.Points[i];
// rotate point and apply offsets
var pLinePoint = RotatePoint(new System.Windows.Point(point.X - horizontalOffset, point.Y * -1), this.Rotation);
package.AddLineStripVertex(pLinePoint.X + Location.X, pLinePoint.Y + Location.Y, this.Location.Z);
// send the same point again to continue drawing
if (i < pline.Points.Count - 1)
{
package.AddLineStripVertex(pLinePoint.X + Location.X, pLinePoint.Y + Location.Y, this.Location.Z);
}
}
}
}
}
if (package.LineVertexCount > 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, DefR, DefG, DefB, DefA));
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
package.AddPointVertex(point.X, point.Y, point.Z);
package.DisplayLabels = true;
if (package is IRenderLabels renderLabels)
{
renderLabels.AddLabel(label, point.X, point.Y, point.Z);
renderLabels.AutoGenerateLabels = false;
}
}
public override void DrawGraphics(IRenderPackage package, TessellationParameters parameters, List <Node> allNodes)
{
List <Triple> vertices = new List <Triple>();
for (int i = 0; i < NodeCount; i++)
{
vertices.Add(allNodes[NodeIndices[i]].Position);
}
GeometryRender.DrawPolyline(package, vertices, Color);
}
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 need to use a per-vertex color shader.
package.RequiresPerVertexColoration = true;
AddColoredQuadToPackage(package);
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
for (int i = 0; i < solver.Nodes.Count; i++)
{
GeometryRender.DrawPoint(package, solver.Nodes[i].Position);
}
for (int i = 0; i < solver.GeometryBinders.Count; i++)
{
solver.GeometryBinders[i].DrawGraphics(package, parameters, solver.Nodes);
}
//=======================================================================================
// Draw a cursor to highlight the node that is being manipulated by the mouse
// ... the curor is 2D, so we need to draw it in the camera coordinate system, manually
//=======================================================================================
CameraData camera = ((HelixWatch3DViewModel)Solver.Viewport).Camera.Dispatcher.Invoke(() => Solver.Viewport.GetCameraInformation());
Triple camOrigin = new Triple(camera.EyePosition.X, -camera.EyePosition.Z, camera.EyePosition.Y);
Triple camZ = new Triple(camera.LookDirection.X, -camera.LookDirection.Z, camera.LookDirection.Y).Normalise();
Triple camY = new Triple(camera.UpDirection.X, -camera.UpDirection.Z, camera.UpDirection.Y).Normalise();
Triple camX = camZ.Cross(camY);
if (solver.HandleNodeIndex != -1 || solver.NearestNodeIndex != -1)
{
int i = solver.HandleNodeIndex != -1 ? solver.HandleNodeIndex : solver.NearestNodeIndex;
Color handleColor = solver.HandleNodeIndex != -1 ? Color.OrangeRed : Color.Black;
Triple v = solver.Nodes[i].Position - camOrigin;
v = camOrigin + ((float)camera.NearPlaneDistance + 0.5f) * v / v.Dot(camZ);
float handleSize = 0.008f;
Triple v1 = v + camX * handleSize;
Triple v2 = v - camY * handleSize;
Triple v3 = v - camX * handleSize;
Triple v4 = v + camY * handleSize;
GeometryRender.DrawPolyline(package, new List <Triple> {
v1, v2, v3, v4, v1
}, handleColor);
handleSize = 0.015f;
v1 = v + camX * handleSize;
v2 = v - camY * handleSize;
v3 = v - camX * handleSize;
v4 = v + camY * handleSize;
GeometryRender.DrawLine(package, v1, v3, handleColor);
GeometryRender.DrawLine(package, v2, v4, handleColor);
}
}
/// <summary>
/// Tessellate Reference Point to render package for visualization.
/// </summary>
void IGraphicItem.Tessellate(IRenderPackage package, TessellationParameters parameters)
{
if (!IsAlive)
{
return;
}
if (this.InternalElement.IsValidObject)
{
package.AddPointVertex(X, Y, Z);
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
var counter = 0;
foreach (var v in _mesh.Vertices())
{
package.AddTriangleVertex(v.X, v.Y, v.Z);
var p = _mesh.VertexNormals()[counter];
package.AddTriangleVertexNormal(p.X, p.Y, p.Z);
counter++;
}
}
internal void TesselateBaseGraph(IRenderPackage package, TessellationParameters parameters)
{
foreach (gVertex v in graph.vertices)
{
AddColouredVertex(package, v, vertexDefaultColour);
}
foreach (gEdge e in graph.edges)
{
AddColouredEdge(package, e, edgeDefaultColour);
}
}
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);
package.AddPointVertex(0, 1, 1);
package.AddPointVertexColor(255, 0, 0, 255);
package.AddPointVertex(0, 2, 2 + counter / 10.0);
package.AddPointVertexColor(255, 0, 0, 255);
package.AddPointVertex(0, 3, 3 + counter / 10.0);
package.AddPointVertexColor(255, 0, 0, 255);
package.AddPointVertex(0, 4, 4 + counter / 10.0);
package.AddPointVertexColor(255, 0, 0, 255);
}
public new void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
//Ensure that the object is still alive
if (!IsAlive)
{
return;
}
this.Curve.Tessellate(package, parameters);
if (package.LineVertexCount > 0)
{
package.ApplyLineVertexColors(CreateColorByteArrayOfSize(package.LineVertexCount, DefR, DefG, DefB, DefA));
}
}
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));
}
}
internal void TesselateBaseGraph(
IRenderPackage package,
TessellationParameters parameters)
{
for (var i = 0; i < graph.vertices.Count; i++)
{
var v = graph.vertices[i];
AddColouredVertex(package, v, vertexDefaultColour);
}
for (var i = 0; i < graph.edges.Count; i++)
{
var e = graph.edges[i];
AddColouredEdge(package, e, edgeDefaultColour);
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
if (singleColor != null)
{
CreateGeometryRenderData(singleColor, package, parameters);
}
else if (colorMap != null)
{
if (!colorMap.Any())
{
return;
}
CreateColorMapOnSurface(colorMap, package, parameters);
}
}
public void Tessellate(List <object> objects, IRenderPackage package, TessellationParameters parameters)
{
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, parameters);
}
}
}
public void Tessellate(IRenderPackage package, TessellationParameters parameters)
{
package.RequiresPerVertexColoration = true;
Autodesk.DesignScript.Geometry.Geometry geometry = bbox.ToCuboid();
byte[] color = new byte[] { 0, 200, 200, 50 };
// 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 (package.MeshVertexCount > 0)
{
package.ApplyMeshVertexColors(CreateColorByteArrayOfSize(package.MeshVertexCount, color[0], color[1], color[2], color[3]));
}
geometry.Dispose();
}
void IGraphicItem.Tessellate(IRenderPackage package, TessellationParameters parameters)
{
if (!_preview)
{
return;
}
uint fid;
for (int i = 0; i < Faces.Length; i++)
{
fid = 3 * Faces[i];
package.AddTriangleVertex(verticesTrans[fid], verticesTrans[fid + 1], verticesTrans[fid + 2]);
package.AddTriangleVertexColor(_red, _green, _blue, _alpha);
package.AddTriangleVertexNormal(normalTrans[fid], normalTrans[fid + 1], normalTrans[fid + 2]);
package.AddTriangleVertexUV(0, 0);
}
}
private void Run()
{
var window = new TesselationParameterForm();
window.Show();
var deviceManager = new DeviceManager();
deviceManager.Initialize(deviceCreationFlags: DeviceCreationFlags.Debug);
var settings = new RenderFormSettings(800, 600, false, false, "hello!", WindowAssociationFlags.IgnoreAll);
var renderWindow = new PresentationWindow(settings);
renderWindow.SwapChain = deviceManager.CreateSwapChainForWindow(renderWindow.Handle, settings);
var rtCreationSettings = new RenderTarget.Configuration.CreationSettings(
new Size(settings.Width, settings.Height),
true,
new SampleDescription(1, 0),
RenderTarget.Configuration.RenderTargetClearSettings.Default,
RenderTarget.Configuration.DepthStencilClearSettings.Default);
var renderTarget = deviceManager.RenderTargetManager.CreateRenderTargetFromSwapChain(renderWindow.SwapChain, rtCreationSettings);
var context = deviceManager.Context;
context.Rasterizer.SetViewports(new Viewport(0, 0, settings.Width, settings.Height, 0.0f, 1.0f));
var vertexData = new[]
{
new VertexPosition {Position = new Vector3(0.0f, 0.5f, 0.5f)},
new VertexPosition {Position = new Vector3(0.5f, -0.5f, 0.5f)},
new VertexPosition {Position = new Vector3(-0.5f, -0.5f, 0.5f)},
};
var stride = Marshal.SizeOf(typeof (VertexPosition));
var vertexBufferDesc = new BufferDescription(
stride*vertexData.Length,
ResourceUsage.Immutable,
BindFlags.VertexBuffer,
CpuAccessFlags.None,
ResourceOptionFlags.None,
stride);
var vertexBuffer = Buffer.Create(deviceManager.Device, vertexData, vertexBufferDesc);
var binding = new VertexBufferBinding(vertexBuffer, stride, 0);
var inputLayout = new InputLayoutCache(deviceManager.Device).GetLayout<VertexPosition>();
var fileName = "../../Shaders/triangle.fx";
var hullShader = new HullShader(deviceManager.Device, deviceManager.ShaderCompiler.LoadByteCodeFromFile(ShaderCompiler.ShaderType.HullShader, fileName, "HS"));
var domainerShader = new DomainShader(deviceManager.Device, deviceManager.ShaderCompiler.LoadByteCodeFromFile(ShaderCompiler.ShaderType.DomainShader, fileName, "DS"));
var vertexShader = new VertexShader(deviceManager.Device, deviceManager.ShaderCompiler.LoadByteCodeFromFile(ShaderCompiler.ShaderType.VertexShader, fileName, "VS"));
var pixelShader = new PixelShader(deviceManager.Device, deviceManager.ShaderCompiler.LoadByteCodeFromFile(ShaderCompiler.ShaderType.PixelShader, fileName, "PS"));
Console.Out.WriteLine("");
var rasterizerState = new RasterizerState(deviceManager.Device, new RasterizerStateDescription
{
CullMode = CullMode.None,
FillMode = FillMode.Wireframe,
IsDepthClipEnabled = false,
IsFrontCounterClockwise = false,
IsScissorEnabled = false
});
var constantBuffer = new ConstantBuffer<TessellationParameters>(deviceManager.Device);
var parameters = new TessellationParameters
{
TessellationFactor = 5
};
RenderLoop.Run(renderWindow, () =>
{
renderTarget.SetActive(context);
renderTarget.Clear(context);
context.InputAssembler.SetVertexBuffers(0, binding);
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.PatchListWith3ControlPoints;
context.InputAssembler.InputLayout = inputLayout;
context.VertexShader.Set(vertexShader);
context.PixelShader.Set(pixelShader);
context.HullShader.Set(hullShader);
context.DomainShader.Set(domainerShader);
parameters.TessellationFactor = window.TesselationFactor;
constantBuffer.UpdateValue(parameters);
context.HullShader.SetConstantBuffer(0, constantBuffer.Buffer);
//context.OutputMerger.DepthStencilState = null;
context.Rasterizer.State = rasterizerState;
context.Draw(3, 0);
renderWindow.Present();
});
deviceManager.Dispose();
}
