Isosurface.ManifoldDC.OctreeNode.ConstructLeaf C# (CSharp) Method

        public bool ConstructLeaf(ref List<VertexPositionColorNormalNormal> vertices, ref int index)
        {
            if (size != 1)
                return false;

            this.index = index++;
            type = NodeType.Leaf;
            int corners = 0;
            float[] samples = new float[8];
            for (int i = 0; i < 8; i++)
            {
                if ((samples[i] = Sampler.Sample(position + Utilities.TCornerDeltas[i])) < 0)
                    corners |= 1 << i;
            }
            this.corners = (byte)corners;

            if (corners == 0 || corners == 255)
                return false;

            int[][] v_edges = new int[Utilities.TransformedVerticesNumberTable[corners]][];
            this.vertices = new Vertex[Utilities.TransformedVerticesNumberTable[corners]];

            int v_index = 0;
            int e_index = 0;
            v_edges[0] = new int[] { -1, -1, -1, -1, -1, -1, -1, -1 };
            for (int e = 0; e < 16; e++)
            {
                int code = Utilities.TransformedEdgesTable[corners, e];
                if (code == -2)
                {
                    v_index++;
                    break;
                }
                if (code == -1)
                {
                    v_index++;
                    e_index = 0;
                    v_edges[v_index] = new int[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
                    continue;
                }

                v_edges[v_index][e_index++] = code;
            }

            if (v_index > 1)
            {
            }

            for (int i = 0; i < v_index; i++)
            {
                int k = 0;
                this.vertices[i] = new Vertex();
                this.vertices[i].qef = new QEFProper.QEFSolver();
                Vector3 normal = Vector3.Zero;
                int[] ei = new int[12];
                if (this.position.X == 6 && this.position.Y == 0 && this.position.Z == 3)
                {
                }
                while (v_edges[i][k] != -1)
                {
                    ei[v_edges[i][k]] = 1;
                    Vector3 a = position + Utilities.TCornerDeltas[Utilities.TEdgePairs[v_edges[i][k], 0]] * size;
                    Vector3 b = position + Utilities.TCornerDeltas[Utilities.TEdgePairs[v_edges[i][k], 1]] * size;
                    Vector3 intersection = Sampler.GetIntersection(a, b, samples[Utilities.TEdgePairs[v_edges[i][k], 0]], samples[Utilities.TEdgePairs[v_edges[i][k], 1]]);
                    Vector3 n = Sampler.GetNormal(intersection);
                    normal += n;
                    this.vertices[i].qef.Add(intersection, n);
                    k++;
                }

                normal /= (float)k;
                normal.Normalize();
                this.vertices[i].index = vertices.Count;
                this.vertices[i].parent = null;
                this.vertices[i].collapsible = true;
                this.vertices[i].normal = normal;
                this.vertices[i].euler = 1;
                this.vertices[i].eis = ei;
                this.vertices[i].in_cell = this.child_index;
                this.vertices[i].face_prop2 = true;
                if (this.index == 1028)
                {
                }
                this.vertices[i].qef.Solve(1e-6f, 4, 1e-6f);
                this.vertices[i].error = this.vertices[i].qef.GetError();
                //VertexPositionColorNormalNormal vert = new VertexPositionColorNormalNormal();
                //vert.Position = this.vertices[i].qef.Solve(1e-6f, 4, 1e-6f) + position;
                //vert.Normal = Sampler.GetNormal(vert.Position);
                //vert.Color = new Color(vert.Normal * 0.5f + Vector3.One * 0.5f);
                //vertices.Add(vert);
            }

            for (int i = 0; i < this.vertices.Length; i++)
            {
                if (this.vertices[i] == null)
                {
                }
            }

            return true;
        }