void CollectSubAssets(Subassets subassets, AlembicTreeNode node)
        {
            var mesh = node.GetAlembicObj <AlembicMesh>();

            if (mesh != null)
            {
                var sum = mesh.summary;
                if (mesh.summary.topologyVariance == aiTopologyVariance.Heterogeneous)
                {
                    varyingTopologyMeshNames.Add(node.gameObject.name);
                }
                else if (mesh.sampleSummary.splitCount > 1)
                {
                    splittingMeshNames.Add(node.gameObject.name);
                }
            }

            int submeshCount = 0;
            var meshFilter   = node.gameObject.GetComponent <MeshFilter>();

            if (meshFilter != null)
            {
                var m = meshFilter.sharedMesh;
                submeshCount = m.subMeshCount;
                m.name       = node.gameObject.name;
                subassets.Add(node.abcObject.abcObject.fullname, m);
            }

            var renderer = node.gameObject.GetComponent <MeshRenderer>();

            if (renderer != null)
            {
                var mats = new Material[submeshCount];
                for (int i = 0; i < submeshCount; ++i)
                {
                    mats[i] = subassets.defaultMaterial;
                }
                renderer.sharedMaterials = mats;
            }

            var apr = node.gameObject.GetComponent <AlembicPointsRenderer>();

            if (apr != null)
            {
                var cubeGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
                apr.sharedMesh = cubeGO.GetComponent <MeshFilter>().sharedMesh;
                DestroyImmediate(cubeGO);

                apr.sharedMaterials      = new Material[] { subassets.pointsMaterial };
                apr.motionVectorMaterial = subassets.pointsMotionVectorMaterial;
            }

            foreach (var child in node.children)
            {
                CollectSubAssets(subassets, child);
            }
        }
Esempio n. 2
0
        private void CollectSubAssets(AssetImportContext ctx, AlembicTreeNode node, Material mat)
        {
            AlembicMesh mesh = node.GetAlembicObj <AlembicMesh>();

            if (mesh != null)
            {
                if ((streamSettings.shareVertices || streamSettings.treatVertexExtraDataAsStatics) &&
                    mesh.summary.topologyVariance == AbcAPI.aiTopologyVariance.Heterogeneous)
                {
                    varyingTopologyMeshNames.Add(node.linkedGameObj.name);
                }
                else if (streamSettings.shareVertices && mesh.sampleSummary.splitCount > 1)
                {
                    splittingMeshNames.Add(node.linkedGameObj.name);
                }
            }

            var meshFilter = node.linkedGameObj.GetComponent <MeshFilter>();

            if (meshFilter != null)
            {
                var m = meshFilter.sharedMesh;
                m.name = node.linkedGameObj.name;
                AddObjectToAsset(ctx, m.name, m);
            }

            var renderer = node.linkedGameObj.GetComponent <MeshRenderer>();

            if (renderer != null)
            {
                renderer.sharedMaterial = mat;
            }

            foreach (var child in node.children)
            {
                CollectSubAssets(ctx, child, mat);
            }
        }