/// <summary> /// Builds all vertex structures for the given detail level. /// </summary> /// <param name="buildOptions">Some generic options for structure building</param> public override VertexStructure BuildStructure(StructureBuildOptions buildOptions) { VertexStructure structureFromChild = m_objTypeToStack.BuildStructure(buildOptions); structureFromChild.EnsureNotNull(nameof(structureFromChild)); BoundingBox childStructBox = structureFromChild.GenerateBoundingBox(); Vector3 correctionVector = -childStructBox.GetBottomCenter(); // Copy metadata infomration of the VertexStructures VertexStructure result = structureFromChild.Clone( copyGeometryData: false, capacityMultiplier: m_stackSize); // Build geometry for (int loop = 0; loop < m_stackSize; loop++) { float actYCorrection = childStructBox.Height * loop; Vector3 localCorrection = new Vector3(correctionVector.X, correctionVector.Y + actYCorrection, correctionVector.Z); int baseVertex = loop * structureFromChild.CountVertices; foreach (Vertex actVertex in structureFromChild.Vertices) { // Change vertex properties based on stack position Vertex changedVertex = actVertex; changedVertex.Position = changedVertex.Position + localCorrection; if (loop % 2 == 1) { changedVertex.Color = changedVertex.Color.ChangeColorByLight(0.05f); } // Add the vertex result.AddVertex(changedVertex); } // Clone all surfaces foreach (VertexStructureSurface actSurfaceFromChild in structureFromChild.Surfaces) { VertexStructureSurface newSurface = result.CreateSurface(actSurfaceFromChild.CountTriangles); foreach (Triangle actTriangle in actSurfaceFromChild.Triangles) { newSurface.AddTriangle( baseVertex + actTriangle.Index1, baseVertex + actTriangle.Index2, baseVertex + actTriangle.Index3); } } } return(result); }
/// <summary> /// Fills the given vertex structure using information from the given AC-File-Objects. /// </summary> /// <param name="objInfo">The object information from the AC file.</param> /// <param name="acMaterials">A list containing all materials from the AC file.</param> /// <param name="structure">The VertexStructure to be filled.</param> /// <param name="transformStack">Current matrix stack (for stacked objects).</param> private static void FillVertexStructure(VertexStructure structure, List <ACMaterialInfo> acMaterials, ACObjectInfo objInfo, Matrix4Stack transformStack) { List <Tuple <int, int> > standardShadedVertices = new List <Tuple <int, int> >(); transformStack.Push(); try { // Perform local transformation for the current AC object transformStack.TransformLocal(objInfo.Rotation); transformStack.TranslateLocal(objInfo.Translation); // Build structures material by material for (int actMaterialIndex = 0; actMaterialIndex < acMaterials.Count; actMaterialIndex++) { ACMaterialInfo actMaterial = acMaterials[actMaterialIndex]; VertexStructureSurface actStructSurface = structure.CreateOrGetExistingSurface(actMaterial.CreateMaterialProperties()); bool isNewSurface = actStructSurface.CountTriangles == 0; // Create and configure vertex structure actStructSurface.Material = NamedOrGenericKey.Empty; actStructSurface.TextureKey = !string.IsNullOrEmpty(objInfo.Texture) ? new NamedOrGenericKey(objInfo.Texture) : NamedOrGenericKey.Empty; actStructSurface.MaterialProperties.DiffuseColor = actMaterial.Diffuse; actStructSurface.MaterialProperties.AmbientColor = actMaterial.Ambient; actStructSurface.MaterialProperties.EmissiveColor = actMaterial.Emissive; actStructSurface.MaterialProperties.Shininess = actMaterial.Shininess; actStructSurface.MaterialProperties.SpecularColor = actMaterial.Specular; // Initialize local index table (needed for vertex reuse) int oneSideVertexCount = objInfo.Vertices.Count; int[] localIndices = new int[oneSideVertexCount * 2]; for (int loop = 0; loop < localIndices.Length; loop++) { localIndices[loop] = int.MaxValue; } // Process all surfaces foreach (ACSurface actSurface in objInfo.Surfaces) { // Get the vertex index on which to start int startVertexIndex = structure.CountVertices; int startTriangleIndex = actStructSurface.CountTriangles; // Only handle surfaces of the current material if (actSurface.Material != actMaterialIndex) { continue; } // Sort out unsupported surfaces if (actSurface.VertexReferences.Count < 3) { continue; } if (actSurface.IsLine) { continue; } if (actSurface.IsClosedLine) { continue; } // Preprocess referenced vertices int oneSideSurfaceVertexCount = actSurface.VertexReferences.Count; int countSurfaceSides = actSurface.IsTwoSided ? 2 : 1; int[] onStructureReferencedVertices = new int[oneSideSurfaceVertexCount * countSurfaceSides]; List <int> surfaceVertexReferences = actSurface.VertexReferences; for (int loop = 0; loop < surfaceVertexReferences.Count; loop++) { Vector2 actTexCoord = actSurface.TextureCoordinates[loop]; if (!actSurface.IsFlatShaded) { // Try to reuse vertices on standard shading if (localIndices[surfaceVertexReferences[loop]] == int.MaxValue) { Vector3 position = Vector3.Transform( objInfo.Vertices[surfaceVertexReferences[loop]].Position, transformStack.Top); localIndices[surfaceVertexReferences[loop]] = structure.AddVertex(new Vertex( position, Color4.White, actTexCoord, Vector3.Zero)); if (actSurface.IsTwoSided) { localIndices[surfaceVertexReferences[loop] + oneSideVertexCount] = structure.AddVertex(new Vertex( position, Color4.White, actTexCoord, Vector3.Zero)); } } // Store vertex reference for this surface's index onStructureReferencedVertices[loop] = localIndices[surfaceVertexReferences[loop]]; if (actSurface.IsTwoSided) { onStructureReferencedVertices[loop + oneSideSurfaceVertexCount] = localIndices[surfaceVertexReferences[loop] + oneSideVertexCount]; } } else { // Create one vertex for one reference for flat shading Vector3 position = Vector3.Transform( objInfo.Vertices[surfaceVertexReferences[loop]].Position, transformStack.Top); onStructureReferencedVertices[loop] = structure.AddVertex(new Vertex( position, Color4.White, actTexCoord, Vector3.Zero)); if (actSurface.IsTwoSided) { onStructureReferencedVertices[loop + oneSideSurfaceVertexCount] = structure.AddVertex(new Vertex( position, Color4.White, actTexCoord, Vector3.Zero)); } } } // Build object geometry switch (actSurface.VertexReferences.Count) { case 3: // Front side actStructSurface.AddTriangle( onStructureReferencedVertices[0], onStructureReferencedVertices[1], onStructureReferencedVertices[2]); // Back side if (actSurface.IsTwoSided) { actStructSurface.AddTriangle( onStructureReferencedVertices[5], onStructureReferencedVertices[4], onStructureReferencedVertices[3]); } break; case 4: // Front side actStructSurface.AddTriangle( onStructureReferencedVertices[0], onStructureReferencedVertices[1], onStructureReferencedVertices[2]); actStructSurface.AddTriangle( onStructureReferencedVertices[2], onStructureReferencedVertices[3], onStructureReferencedVertices[0]); // Back side if (actSurface.IsTwoSided) { actStructSurface.AddTriangle( onStructureReferencedVertices[6], onStructureReferencedVertices[5], onStructureReferencedVertices[4]); actStructSurface.AddTriangle( onStructureReferencedVertices[4], onStructureReferencedVertices[7], onStructureReferencedVertices[6]); } break; default: if (!actSurface.IsTwoSided) { // Front side actStructSurface.AddPolygonByCuttingEars(onStructureReferencedVertices); } else { // Front and back side actStructSurface.AddPolygonByCuttingEars(onStructureReferencedVertices.Subset(0, oneSideSurfaceVertexCount)); actStructSurface.AddPolygonByCuttingEars(onStructureReferencedVertices.Subset(oneSideSurfaceVertexCount, oneSideSurfaceVertexCount)); } break; } // Perform shading if (actSurface.IsFlatShaded) { actStructSurface.CalculateNormalsFlat( startTriangleIndex, actStructSurface.CountTriangles - startTriangleIndex); } else { // Nothing to be done for now.. int vertexCount = structure.CountVertices - startVertexIndex; if (vertexCount > 0) { standardShadedVertices.Add( Tuple.Create((int)startVertexIndex, vertexCount)); } } } // Calculate default shading finally (if any) foreach (var actStandardShadedPair in standardShadedVertices) { structure.CalculateNormals( actStandardShadedPair.Item1, actStandardShadedPair.Item2); } standardShadedVertices.Clear(); // Append generated VertexStructure to the output collection if ((actStructSurface.CountTriangles <= 0) && (isNewSurface)) { structure.RemoveSurface(actStructSurface); } } //Fill in all child object data foreach (ACObjectInfo actObjInfo in objInfo.Childs) { FillVertexStructure(structure, acMaterials, actObjInfo, transformStack); } } finally { transformStack.Pop(); } }
/// <summary> /// IDWriteTextLayout::Draw calls this function to instruct the client to render a run of glyphs. /// </summary> /// <param name="clientDrawingContext">The application-defined drawing context passed to <see cref="M:SharpDX.DirectWrite.TextLayout.Draw_(System.IntPtr,System.IntPtr,System.Single,System.Single)" />.</param> /// <param name="baselineOriginX">The pixel location (X-coordinate) at the baseline origin of the glyph run.</param> /// <param name="baselineOriginY">The pixel location (Y-coordinate) at the baseline origin of the glyph run.</param> /// <param name="measuringMode">The measuring method for glyphs in the run, used with the other properties to determine the rendering mode.</param> /// <param name="glyphRun">Pointer to the glyph run instance to render.</param> /// <param name="glyphRunDescription">A pointer to the optional glyph run description instance which contains properties of the characters associated with this run.</param> /// <param name="clientDrawingEffect">Application-defined drawing effects for the glyphs to render. Usually this argument represents effects such as the foreground brush filling the interior of text.</param> /// <returns> /// If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. /// </returns> /// <unmanaged>HRESULT DrawGlyphRun([None] void* clientDrawingContext,[None] FLOAT baselineOriginX,[None] FLOAT baselineOriginY,[None] DWRITE_MEASURING_MODE measuringMode,[In] const DWRITE_GLYPH_RUN* glyphRun,[In] const DWRITE_GLYPH_RUN_DESCRIPTION* glyphRunDescription,[None] IUnknown* clientDrawingEffect)</unmanaged> /// <remarks> /// The <see cref="M:SharpDX.DirectWrite.TextLayout.Draw_(System.IntPtr,System.IntPtr,System.Single,System.Single)" /> function calls this callback function with all the information about glyphs to render. The application implements this callback by mostly delegating the call to the underlying platform's graphics API such as {{Direct2D}} to draw glyphs on the drawing context. An application that uses GDI can implement this callback in terms of the <see cref="M:SharpDX.DirectWrite.BitmapRenderTarget.DrawGlyphRun(System.Single,System.Single,SharpDX.Direct2D1.MeasuringMode,SharpDX.DirectWrite.GlyphRun,SharpDX.DirectWrite.RenderingParams,SharpDX.Color4)" /> method. /// </remarks> public override SDX.Result DrawGlyphRun( object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, SDX.ComObject clientDrawingEffect) { if ((glyphRun.Indices == null) || (glyphRun.Indices.Length == 0)) { return(SDX.Result.Ok);; } SharpDX.DirectWrite.Factory dWriteFactory = GraphicsCore.Current.FactoryDWrite; SharpDX.Direct2D1.Factory d2DFactory = GraphicsCore.Current.FactoryD2D; // Extrude geometry data out of given glyph run SimplePolygon2DGeometrySink geometryExtruder = new SimplePolygon2DGeometrySink(new Vector2(baselineOriginX, baselineOriginY)); using (PathGeometry pathGeometry = new PathGeometry(d2DFactory)) { // Write all geometry data into a standard PathGeometry object using (GeometrySink geoSink = pathGeometry.Open()) { glyphRun.FontFace.GetGlyphRunOutline( glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 == 1, geoSink); geoSink.Close(); } // Simplify written geometry and write it into own structure pathGeometry.Simplify(GeometrySimplificationOption.Lines, m_geometryOptions.SimplificationFlatternTolerance, geometryExtruder); } // Structure for caching the result VertexStructure tempStructure = new VertexStructure(); VertexStructureSurface tempSurface = tempStructure.CreateSurface(); // Create the text surface if (m_geometryOptions.MakeSurface) { // Separate polygons by clock direction // Order polygons as needed for further hole finding algorithm IEnumerable <Polygon2D> fillingPolygons = geometryExtruder.GeneratedPolygons .Where(actPolygon => actPolygon.EdgeOrder == EdgeOrder.CounterClockwise) .OrderBy(actPolygon => actPolygon.BoundingBox.Size.X * actPolygon.BoundingBox.Size.Y); List <Polygon2D> holePolygons = geometryExtruder.GeneratedPolygons .Where(actPolygon => actPolygon.EdgeOrder == EdgeOrder.Clockwise) .OrderByDescending(actPolygon => actPolygon.BoundingBox.Size.X * actPolygon.BoundingBox.Size.Y) .ToList(); // Build geometry for all polygons int loopPolygon = 0; foreach (Polygon2D actFillingPolygon in fillingPolygons) { // Find all corresponding holes BoundingBox2D actFillingPolygonBounds = actFillingPolygon.BoundingBox; IEnumerable <Polygon2D> correspondingHoles = holePolygons .Where(actHolePolygon => actHolePolygon.BoundingBox.IsContainedBy(actFillingPolygonBounds)) .ToList(); // Two steps here: // - Merge current filling polygon and all its holes. // - Remove found holes from current hole list Polygon2D polygonForRendering = actFillingPolygon; Polygon2D polygonForTriangulation = actFillingPolygon.Clone(); List <Vector2> cutPoints = new List <Vector2>(); foreach (Polygon2D actHole in correspondingHoles) { holePolygons.Remove(actHole); polygonForRendering = polygonForRendering.MergeWithHole(actHole, Polygon2DMergeOptions.Default, cutPoints); polygonForTriangulation = polygonForTriangulation.MergeWithHole(actHole, new Polygon2DMergeOptions() { MakeMergepointSpaceForTriangulation = true }); } loopPolygon++; int actBaseIndex = (int)tempStructure.CountVertices; EdgeOrder edgeOrder = polygonForRendering.EdgeOrder; float edgeSize = edgeOrder == EdgeOrder.CounterClockwise ? 0.1f : 0.4f; // Append all vertices to temporary VertexStructure for (int loop = 0; loop < polygonForRendering.Vertices.Count; loop++) { // Calculate 3d location and texture coordinate Vector3 actVertexLocation = new Vector3( polygonForRendering.Vertices[loop].X, 0f, polygonForRendering.Vertices[loop].Y); Vector2 actTexCoord = new Vector2( (polygonForRendering.Vertices[loop].X - polygonForRendering.BoundingBox.Location.X) / polygonForRendering.BoundingBox.Size.X, (polygonForRendering.Vertices[loop].Y - polygonForRendering.BoundingBox.Location.Y) / polygonForRendering.BoundingBox.Size.Y); if (float.IsInfinity(actTexCoord.X) || float.IsNaN(actTexCoord.X)) { actTexCoord.X = 0f; } if (float.IsInfinity(actTexCoord.Y) || float.IsNaN(actTexCoord.Y)) { actTexCoord.Y = 0f; } // Append the vertex to the result tempStructure.AddVertex( new Vertex( actVertexLocation, m_geometryOptions.SurfaceVertexColor, actTexCoord, new Vector3(0f, 1f, 0f))); } // Generate cubes on each vertex if requested if (m_geometryOptions.GenerateCubesOnVertices) { for (int loop = 0; loop < polygonForRendering.Vertices.Count; loop++) { Color4 colorToUse = Color4.GreenColor; float pointRenderSize = 0.1f; if (cutPoints.Contains(polygonForRendering.Vertices[loop])) { colorToUse = Color4.RedColor; pointRenderSize = 0.15f; } Vector3 actVertexLocation = new Vector3( polygonForRendering.Vertices[loop].X, 0f, polygonForRendering.Vertices[loop].Y); tempSurface.BuildCube24V(actVertexLocation, pointRenderSize, colorToUse); } } // Triangulate the polygon IEnumerable <int> triangleIndices = polygonForTriangulation.TriangulateUsingCuttingEars(); if (triangleIndices == null) { continue; } if (triangleIndices == null) { throw new SeeingSharpGraphicsException("Unable to triangulate given PathGeometry object!"); } // Append all triangles to the temporary structure using (IEnumerator <int> indexEnumerator = triangleIndices.GetEnumerator()) { while (indexEnumerator.MoveNext()) { int index1 = indexEnumerator.Current; int index2 = 0; int index3 = 0; if (indexEnumerator.MoveNext()) { index2 = indexEnumerator.Current; } else { break; } if (indexEnumerator.MoveNext()) { index3 = indexEnumerator.Current; } else { break; } tempSurface.AddTriangle( (int)(actBaseIndex + index3), (int)(actBaseIndex + index2), (int)(actBaseIndex + index1)); } } } } // Make volumetric outlines int triangleCountWithoutSide = tempSurface.CountTriangles; if (m_geometryOptions.MakeVolumetricText) { float volumetricTextDepth = m_geometryOptions.VolumetricTextDepth; if (m_geometryOptions.VerticesScaleFactor > 0f) { volumetricTextDepth = volumetricTextDepth / m_geometryOptions.VerticesScaleFactor; } // Add all side surfaces foreach (Polygon2D actPolygon in geometryExtruder.GeneratedPolygons) { foreach (Line2D actLine in actPolygon.Lines) { tempSurface.BuildRect4V( new Vector3(actLine.StartPosition.X, -volumetricTextDepth, actLine.StartPosition.Y), new Vector3(actLine.EndPosition.X, -volumetricTextDepth, actLine.EndPosition.Y), new Vector3(actLine.EndPosition.X, 0f, actLine.EndPosition.Y), new Vector3(actLine.StartPosition.X, 0f, actLine.StartPosition.Y), m_geometryOptions.VolumetricSideSurfaceVertexColor); } } } // Do also make back surface? if (m_geometryOptions.MakeBackSurface) { for (int loop = 0; loop < triangleCountWithoutSide; loop++) { Triangle triangle = tempSurface.Triangles[loop]; Vertex vertex0 = tempStructure.Vertices[triangle.Index1]; Vertex vertex1 = tempStructure.Vertices[triangle.Index2]; Vertex vertex2 = tempStructure.Vertices[triangle.Index3]; Vector3 changeVector = new Vector3(0f, -m_geometryOptions.VolumetricTextDepth, 0f); tempSurface.AddTriangle( vertex2.Copy(vertex2.Position - changeVector, Vector3.Negate(vertex2.Normal)), vertex1.Copy(vertex1.Position - changeVector, Vector3.Negate(vertex1.Normal)), vertex0.Copy(vertex0.Position - changeVector, Vector3.Negate(vertex0.Normal))); } } // TODO: Make this configurable tempStructure.ToggleCoordinateSystem(); // Scale the text using given scale factor if (m_geometryOptions.VerticesScaleFactor > 0f) { Matrix4x4 scaleMatrix = Matrix4x4.CreateScale( m_geometryOptions.VerticesScaleFactor, m_geometryOptions.VerticesScaleFactor, m_geometryOptions.VerticesScaleFactor); Matrix4Stack transformMatrix = new Matrix4Stack(scaleMatrix); transformMatrix.TransformLocal(m_geometryOptions.VertexTransform); tempStructure.UpdateVerticesUsingRelocationFunc((actVector) => Vector3.Transform(actVector, transformMatrix.Top)); } // Calculate all normals before adding to target structure if (m_geometryOptions.CalculateNormals) { tempStructure.CalculateNormalsFlat(); } // Merge temporary structure to target structure m_targetSurface.AddStructure(tempStructure); return(SDX.Result.Ok); }
/// <summary> /// Reads a facet. /// </summary> private void ReadFacet(StreamReader reader, string normalString, VertexStructure newStructure, StlImportOptions importOptions) { m_cachedPoints.Clear(); // Read all geometry Vector3 normal = ParseNormal(normalString); ReadLine(reader, "outer"); while (true) { string line = reader.ReadLine(); Vector3 point; if (TryParseVertex(line, out point)) { m_cachedPoints.Add(point); continue; } string id, values; ParseLine(line, out id, out values); if (id == "endloop") { break; } } // Read end ReadLine(reader, "endfacet"); // Overtake geometry data VertexStructureSurface targetSurfae = newStructure.FirstSurface; int pointCount = m_cachedPoints.Count; switch (m_cachedPoints.Count) { case 0: case 1: case 2: break; case 3: if (importOptions.IsChangeTriangleOrderNeeded()) { targetSurfae.AddTriangle( new Vertex(m_cachedPoints[2], Color4.Transparent, Vector2.Zero, normal), new Vertex(m_cachedPoints[1], Color4.Transparent, Vector2.Zero, normal), new Vertex(m_cachedPoints[0], Color4.Transparent, Vector2.Zero, normal)); } else { targetSurfae.AddTriangle( new Vertex(m_cachedPoints[0], Color4.Transparent, Vector2.Zero, normal), new Vertex(m_cachedPoints[1], Color4.Transparent, Vector2.Zero, normal), new Vertex(m_cachedPoints[2], Color4.Transparent, Vector2.Zero, normal)); } break; default: int[] indices = new int[pointCount]; if (importOptions.IsChangeTriangleOrderNeeded()) { for (int loop = pointCount - 1; loop > -1; loop--) { indices[loop] = newStructure.AddVertex( new Vertex(m_cachedPoints[loop], Color4.Transparent, Vector2.Zero, normal)); } } else { for (int loop = 0; loop < pointCount; loop++) { indices[loop] = newStructure.AddVertex( new Vertex(m_cachedPoints[loop], Color4.Transparent, Vector2.Zero, normal)); } } targetSurfae.AddPolygonByCuttingEars(indices); break; } }