private static bool GetSurfaceOutlineValues(Int32 brushNodeID,
                                                    Int32 surfaceID,
                                                    ref float3[]    vertices,
                                                    ref Int32[]     visibleOuterLines,
                                                    ref Int32[]     visibleInnerLines,
                                                    ref Int32[]     visibleTriangles,
                                                    ref Int32[]     invisibleOuterLines,
                                                    ref Int32[]     invisibleInnerLines,
                                                    ref Int32[]     invalidLines)
        {
            var brushInfo = CSGManager.GetBrushInfo(brushNodeID);

            if (brushInfo == null)
            {
                return(false);
            }

            if (brushInfo.brushOutlineDirty)
            {
                ChiselWireframe.UpdateOutline(brushNodeID);
                brushInfo.brushOutlineDirty = false;
            }

            var brushOutline = brushInfo.brushOutline;

            if (brushOutline == null ||
                brushOutline.vertices == null ||
                brushOutline.vertices.Length < 3)
            {
                return(false);
            }

            var surfaceOutlines = brushOutline.surfaceOutlines;

            if (surfaceOutlines == null ||
                surfaceID < 0 ||
                surfaceID >= surfaceOutlines.Length)
            {
                return(false);
            }

            var surfaceOutline = surfaceOutlines[surfaceID];

            // TODO: once we switch to managed code, remove need to copy outlines
            vertices            = brushOutline.vertices.ToArray();
            visibleOuterLines   = surfaceOutline.visibleOuterLines.ToArray();
            visibleInnerLines   = surfaceOutline.visibleInnerLines.ToArray();
            visibleTriangles    = surfaceOutline.visibleTriangles.ToArray();
            invisibleOuterLines = surfaceOutline.invisibleOuterLines.ToArray();
            invisibleInnerLines = surfaceOutline.invisibleInnerLines.ToArray();
            invalidLines        = surfaceOutline.invalidLines.ToArray();
            return(true);
        }
Example #2
0
        private static bool UpdateBrushWireframe(ChiselWireframe wireframe)
        {
            bool success = GetBrushOutlineValues(wireframe.originBrushID,
                                                 ref wireframe.vertices,
                                                 ref wireframe.visibleOuterLines,
                                                 ref wireframe.visibleInnerLines,
                                                 ref wireframe.invisibleOuterLines,
                                                 ref wireframe.invisibleInnerLines,
                                                 ref wireframe.invalidLines);

            if (!success)
            {
                return(false);
            }

            wireframe.outlineGeneration = GetBrushOutlineGeneration(wireframe.originBrushID);
            return(true);
        }
Example #3
0
        private static ChiselWireframe CreateBrushWireframe(Int32 brushNodeID)
        {
            var wireframe = new ChiselWireframe {
                originBrushID = brushNodeID
            };
            bool success = GetBrushOutlineValues(brushNodeID,
                                                 ref wireframe.vertices,
                                                 ref wireframe.visibleOuterLines,
                                                 ref wireframe.visibleInnerLines,
                                                 ref wireframe.invisibleOuterLines,
                                                 ref wireframe.invisibleInnerLines,
                                                 ref wireframe.invalidLines);

            if (!success)
            {
                return(null);
            }

            wireframe.outlineGeneration = GetBrushOutlineGeneration(brushNodeID);
            return(wireframe);
        }
Example #4
0
        private static ChiselWireframe CreateSurfaceWireframe(Int32 brushNodeID, Int32 surfaceID)
        {
            int vertexCount = 0, visibleOuterLineCount = 0;
            int visibleInnerLineCount = 0, visibleTriangleCount = 0;
            int invisibleOuterLineCount = 0, invisibleInnerLineCount = 0;
            int invalidLineCount = 0;

            if (!GetSurfaceOutlineSizes(brushNodeID,
                                        surfaceID,
                                        out vertexCount, out visibleOuterLineCount,
                                        out visibleInnerLineCount, out visibleTriangleCount,
                                        out invisibleOuterLineCount, out invisibleInnerLineCount,
                                        out invalidLineCount))
            {
                return(null);
            }

            if (vertexCount == 0 ||
                (visibleOuterLineCount == 0 && invisibleOuterLineCount == 0 &&
                 visibleInnerLineCount == 0 && invisibleInnerLineCount == 0 &&
                 visibleTriangleCount == 0 &&
                 invalidLineCount == 0))
            {
                return(null);
            }


            var wireframe = new ChiselWireframe
            {
                vertices            = new Vector3[vertexCount],
                visibleOuterLines   = new Int32[visibleOuterLineCount],
                visibleInnerLines   = new Int32[visibleInnerLineCount],
                visibleTriangles    = new Int32[visibleTriangleCount],
                invisibleOuterLines = new Int32[invisibleOuterLineCount],
                invisibleInnerLines = new Int32[invisibleInnerLineCount],
                invalidLines        = new Int32[invalidLineCount]
            };

            var verticesHandle            = GCHandle.Alloc(wireframe.vertices, GCHandleType.Pinned);
            var visibleOuterLinesHandle   = GCHandle.Alloc(wireframe.visibleOuterLines, GCHandleType.Pinned);
            var visibleInnerLinesHandle   = GCHandle.Alloc(wireframe.visibleInnerLines, GCHandleType.Pinned);
            var visibleTrianglesHandle    = GCHandle.Alloc(wireframe.visibleTriangles, GCHandleType.Pinned);
            var invisibleOuterLinesHandle = GCHandle.Alloc(wireframe.invisibleOuterLines, GCHandleType.Pinned);
            var invisibleInnerLinesHandle = GCHandle.Alloc(wireframe.invisibleInnerLines, GCHandleType.Pinned);
            var invalidLinesHandle        = GCHandle.Alloc(wireframe.invalidLines, GCHandleType.Pinned);

            var verticesPtr            = verticesHandle.AddrOfPinnedObject();
            var visibleOuterLinesPtr   = visibleOuterLinesHandle.AddrOfPinnedObject();
            var visibleInnerLinesPtr   = visibleInnerLinesHandle.AddrOfPinnedObject();
            var visibleTrianglesPtr    = visibleTrianglesHandle.AddrOfPinnedObject();
            var invisibleOuterLinesPtr = invisibleOuterLinesHandle.AddrOfPinnedObject();
            var invisibleInnerLinesPtr = invisibleInnerLinesHandle.AddrOfPinnedObject();
            var invalidLinesPtr        = invalidLinesHandle.AddrOfPinnedObject();

            bool success = GetSurfaceOutlineValues(brushNodeID, surfaceID,
                                                   vertexCount, verticesPtr,
                                                   visibleOuterLineCount, visibleOuterLinesPtr,
                                                   visibleInnerLineCount, visibleInnerLinesPtr,
                                                   visibleTriangleCount, visibleTrianglesPtr,
                                                   invisibleOuterLineCount, invisibleOuterLinesPtr,
                                                   invisibleInnerLineCount, invisibleInnerLinesPtr,
                                                   invalidLineCount, invalidLinesPtr);

            verticesHandle.Free();
            visibleOuterLinesHandle.Free();
            visibleInnerLinesHandle.Free();
            visibleTrianglesHandle.Free();
            invisibleOuterLinesHandle.Free();
            invisibleInnerLinesHandle.Free();
            invalidLinesHandle.Free();

            if (!success)
            {
                return(null);
            }

            wireframe.outlineGeneration = GetBrushOutlineGeneration(brushNodeID);
            return(wireframe);
        }
Example #5
0
        private static bool UpdateBrushWireframe(ChiselWireframe wireframe)
        {
            int vertexCount             = 0;
            int visibleOuterLineCount   = 0;
            int visibleInnerLineCount   = 0;
            int invisibleOuterLineCount = 0;
            int invisibleInnerLineCount = 0;
            int invalidLineCount        = 0;

            if (!GetBrushOutlineSizes(wireframe.originBrushID,
                                      out vertexCount, out visibleOuterLineCount,
                                      out visibleInnerLineCount, out invisibleOuterLineCount,
                                      out invisibleInnerLineCount, out invalidLineCount))
            {
                return(false);
            }

            if (vertexCount == 0 ||
                (visibleOuterLineCount == 0 && invisibleOuterLineCount == 0 &&
                 visibleInnerLineCount == 0 && invisibleInnerLineCount == 0 &&
                 invalidLineCount == 0))
            {
                return(false);
            }

            if (wireframe.vertices.Length != vertexCount)
            {
                wireframe.vertices = new Vector3[vertexCount];
            }

            if (wireframe.visibleOuterLines.Length != visibleOuterLineCount)
            {
                wireframe.visibleOuterLines = new Int32[visibleOuterLineCount];
            }

            if (wireframe.visibleInnerLines.Length != visibleInnerLineCount)
            {
                wireframe.visibleInnerLines = new Int32[visibleInnerLineCount];
            }

            if (wireframe.invisibleOuterLines.Length != invisibleOuterLineCount)
            {
                wireframe.invisibleOuterLines = new Int32[invisibleOuterLineCount];
            }

            if (wireframe.invisibleInnerLines.Length != invisibleInnerLineCount)
            {
                wireframe.invisibleInnerLines = new Int32[invisibleInnerLineCount];
            }

            if (wireframe.invalidLines.Length != invalidLineCount)
            {
                wireframe.invalidLines = new Int32[invalidLineCount];
            }

            var verticesHandle            = GCHandle.Alloc(wireframe.vertices, GCHandleType.Pinned);
            var visibleOuterLinesHandle   = GCHandle.Alloc(wireframe.visibleOuterLines, GCHandleType.Pinned);
            var visibleInnerLinesHandle   = GCHandle.Alloc(wireframe.visibleInnerLines, GCHandleType.Pinned);
            var invisibleOuterLinesHandle = GCHandle.Alloc(wireframe.invisibleOuterLines, GCHandleType.Pinned);
            var invisibleInnerLinesHandle = GCHandle.Alloc(wireframe.invisibleInnerLines, GCHandleType.Pinned);
            var invalidLinesHandle        = GCHandle.Alloc(wireframe.invalidLines, GCHandleType.Pinned);

            var verticesPtr            = verticesHandle.AddrOfPinnedObject();
            var visibleOuterLinesPtr   = visibleOuterLinesHandle.AddrOfPinnedObject();
            var visibleInnerLinesPtr   = visibleInnerLinesHandle.AddrOfPinnedObject();
            var invisibleOuterLinesPtr = invisibleOuterLinesHandle.AddrOfPinnedObject();
            var invisibleInnerLinesPtr = invisibleInnerLinesHandle.AddrOfPinnedObject();
            var invalidLinesPtr        = invalidLinesHandle.AddrOfPinnedObject();

            bool success = GetBrushOutlineValues(wireframe.originBrushID,
                                                 vertexCount, verticesPtr,
                                                 visibleOuterLineCount, visibleOuterLinesPtr,
                                                 visibleInnerLineCount, visibleInnerLinesPtr,
                                                 invisibleOuterLineCount, invisibleOuterLinesPtr,
                                                 invisibleInnerLineCount, invisibleInnerLinesPtr,
                                                 invalidLineCount, invalidLinesPtr);

            verticesHandle.Free();
            visibleOuterLinesHandle.Free();
            visibleInnerLinesHandle.Free();
            invisibleOuterLinesHandle.Free();
            invisibleInnerLinesHandle.Free();
            invalidLinesHandle.Free();

            if (!success)
            {
                return(false);
            }

            wireframe.outlineGeneration = GetBrushOutlineGeneration(wireframe.originBrushID);
            return(true);
        }