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