Sunag.SEA3D.SEA3DAssimp.AppendGeometry C# (CSharp) Method

        private SEAGeometry AppendGeometry(Scene scene, Node node, List<Mesh> geometryList)
        {
            int sIndex = GetIndexByTag(node);

            if (sIndex != -1) return (SEAGeometry)Writer.Objects[sIndex];

            List<float> vertex = new List<float>();
            List<List<float>> uvs = new List<List<float>>();
            List<float> normal = new List<float>();
            List<float> tangent = new List<float>();
            List<uint> joints = new List<uint>();
            List<float> weights = new List<float>();
            List<List<float>> colors = new List<List<float>>();
            List<List<uint>> indexes = new List<List<uint>>();

            uint countUV = 0;
            uint countColor = 0;
            uint jointPerVertex = 0;
            uint indexOffset = 0;

            bool containsNormal = false;
            bool containsTangent = false;

            foreach(Mesh mesh in geometryList)
            {
                countUV = (uint)Math.Max(countUV, mesh.TextureCoordinateChannelCount);
                countColor = (uint)Math.Max(countColor, mesh.VertexColorChannelCount);

                if (mesh.HasNormals) containsNormal = mesh.HasNormals;
                if (mesh.HasTangentBasis) containsTangent = mesh.HasTangentBasis;

                if (mesh.HasBones)
                {
                    foreach (Bone bone in mesh.Bones)
                    {
                        if (bone.VertexWeightCount > jointPerVertex)
                            jointPerVertex = (uint)bone.VertexWeightCount;
                    }
                }
            }

            for (int i = 0; i < countUV; i++)
            {
                uvs.Add(new List<float>());
            }

            for (int i = 0; i < countColor; i++)
            {
                colors.Add(new List<float>());
            }

            foreach (Mesh geometry in geometryList)
            {
                if (!geometry.HasVertices || !geometry.HasFaces) continue;

                int NumVertex = geometry.VertexCount;

                for (int i = 0; i < NumVertex; i++)
                {
                    vertex.Add(geometry.Vertices[i].X);
                    vertex.Add(geometry.Vertices[i].Y);
                    vertex.Add(geometry.Vertices[i].Z);
                }

                for (int i = 0; i < countUV; i++)
                {
                    List<float> uv = uvs[i];

                    if (geometry.HasTextureCoords(i))
                    {
                        List<Vector3D> uv3d = geometry.TextureCoordinateChannels[i];

                        for (int j = 0; j < NumVertex; j++)
                        {
                            uv.Add(uv3d[j].X);
                            uv.Add(1 - uv3d[j].Y);
                        }
                    }
                    else
                    {
                        for (int j = 0; j < NumVertex; j++)
                        {
                            uv.Add(0);
                            uv.Add(0);
                        }
                    }
                }

                if (containsNormal)
                {
                    if (geometry.HasNormals)
                    {
                        for (int i = 0; i < NumVertex; i++)
                        {
                            normal.Add(geometry.Normals[i].X);
                            normal.Add(geometry.Normals[i].Y);
                            normal.Add(geometry.Normals[i].Z);
                        }
                    }
                    else
                    {
                        for (int i = 0; i < NumVertex; i++)
                        {
                            normal.Add(0);
                            normal.Add(0);
                            normal.Add(0);
                        }
                    }
                }

                if (containsTangent)
                {
                    if (geometry.HasTangentBasis)
                    {
                        for (int i = 0; i < NumVertex; i++)
                        {
                            tangent.Add(geometry.Tangents[i].X);
                            tangent.Add(geometry.Tangents[i].Y);
                            tangent.Add(geometry.Tangents[i].Z);
                        }
                    }
                    else
                    {
                        for (int i = 0; i < NumVertex; i++)
                        {
                            tangent.Add(0);
                            tangent.Add(0);
                            tangent.Add(0);
                        }
                    }
                }

                for (int i = 0; i < colors.Count; i++)
                {
                    List<float> color = colors[i];

                    if (geometry.HasVertexColors(i))
                    {
                        List<Color4D> clr = geometry.VertexColorChannels[i];

                        int j = 0;

                        while (j < NumVertex)
                        {
                            color.Add(clr[j].R);
                            color.Add(clr[j].G);
                            color.Add(clr[j].B);
                            color.Add(clr[j].A);
                        }
                    }
                    else
                    {
                        int j = 0;

                        while (j < NumVertex)
                        {
                            color.Add(0);
                            color.Add(0);
                            color.Add(0);
                            color.Add(0);
                        }
                    }
                }

                if (Modifiers && jointPerVertex > 0)
                {
                    foreach (Bone bone in geometry.Bones)
                    {
                        int i = 0;

                        for (; i < bone.VertexWeights.Count; i++)
                        {
                            joints.Add(indexOffset + (uint)bone.VertexWeights[i].VertexID);
                            weights.Add((uint)bone.VertexWeights[i].Weight);
                        }

                        for (; i < jointPerVertex; i++)
                        {
                            joints.Add(0);
                            weights.Add(0);
                        }
                    }
                }

                List<uint> index = geometry.GetUnsignedIndices().ToList();

                for (int i = 0; i < index.Count; i++)
                {
                    index[i] += indexOffset;
                }

                indexOffset += (uint)NumVertex;

                indexes.Add(index);
            }

            float[][] _uv = new float[uvs.Count][];
            float[][] _color = new float[colors.Count][];
            uint[][] _indexes = new uint[indexes.Count][];

            for (int i = 0; i < uvs.Count; i++) _uv[i] = uvs[i].ToArray();
            for (int i = 0; i < colors.Count; i++) _color[i] = colors[i].ToArray();
            for (int i = 0; i < indexes.Count; i++) _indexes[i] = indexes[i].ToArray();

            SEAGeometry geo = new SEAGeometry(GetValidString(geometries, node.Name));
            geo.vertex = vertex.ToArray();
            geo.uv = uvs.Count > 0 ? _uv : null;
            geo.normal = normal.Count > 0 ? normal.ToArray() : null;
            geo.tangent = tangent.Count > 0 ? tangent.ToArray() : null;
            geo.color = colors.Count > 0 ? _color : null;
            geo.weight = weights.Count > 0 ? weights.ToArray() : null;
            geo.joint = joints.Count > 0 ? joints.ToArray() : null;
            geo.jointPerVertex = jointPerVertex;
            geo.indexes = _indexes;

            geo.tag = node;

            geometries.Add(geo);
            Writer.AddObject(geo);

            return geo;
        }