コード例 #1
0
        public void CreatePrefabMulti(VoxelData data, string pfName)
        {
            VoxelData dd = new VoxelData(data);

            VerifyShaders();

            GameObject obj = new GameObject(pfName);

            obj.isStatic = importStatic;

            OptimizedVoxelMesh assetDifuse = null;
            Material           diffuseMat  = new Material(importDiffuseShader);

            diffuseMat.name = "Diffuse";

            OptimizedVoxelMesh assetGlass = null;
            Material           glassMat   = new Material(importGlassShader);

            glassMat.name = "Glass";

            OptimizedVoxelMesh assetMetal = null;
            Material           metalMat   = new Material(importMetalShader);

            metalMat.name = "Metal";

            OptimizedVoxelMesh assetEmission = null;
            Material           emissionMat   = new Material(importEmissionShader);

            emissionMat.name = "Emission";

            OptimizedVoxelMesh assetPlastic = null;
            Material           plasticMat   = new Material(importPlasticShader);

            plasticMat.name = "Plastic";

            OptimizedVoxelMesh assetClouds = null;
            Material           cloudsMat   = new Material(importCloudsShader);

            cloudsMat.name = "Clouds";

            if (importMaterials)
            {
                dd.ClearByMat(VoxMaterialType._glass, true);
                dd.ClearByMat(VoxMaterialType._metal, true);
                dd.ClearByMat(VoxMaterialType._emit, true);
                dd.ClearByMat(VoxMaterialType._plastic, true);
                dd.ClearByMat(VoxMaterialType._clouds, true);
            }

            if (dd.VoxelCount() > 0)
            {
                assetDifuse              = new OptimizedVoxelMesh(dd, importPivot, importTextureScale, importPadding, importScale);
                assetDifuse.mesh.name    = "Diffuse";
                assetDifuse.texture.name = "Diffuse";

                GameObject diffuse = new GameObject("Diffuse");
                diffuse.transform.parent = obj.transform;
                diffuse.isStatic         = importStatic;

                MeshFilter mf = diffuse.AddComponent <MeshFilter>();
                mf.mesh = assetDifuse.mesh;

                diffuseMat.mainTexture = assetDifuse.texture;
                diffuseMat.SetFloat("_Metallic", 0);
                diffuseMat.SetFloat("_Glossiness", 0);

                MeshRenderer mr = diffuse.AddComponent <MeshRenderer>();
                if (import2Sided)
                {
                    mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                }

                mr.material = diffuseMat;

                AddCollider(diffuse);
                if (importRigidbody)
                {
                    diffuse.AddComponent <Rigidbody>();
                }
            }

            if (importMaterials)
            {
                VoxelData gd = new VoxelData(data);
                gd.ClearByMat(VoxMaterialType._glass, false);
                if (gd.VoxelCount() > 0)
                {
                    glassMat.SetFloat("_Glossiness", 1);
                    glassMat.SetInt("_Mode", 3);//transparent
                    glassMat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    glassMat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    glassMat.SetInt("_ZWrite", 0);
                    glassMat.DisableKeyword("_ALPHATEST_ON");
                    glassMat.DisableKeyword("_ALPHABLEND_ON");
                    glassMat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                    glassMat.renderQueue = 3000;
                    glassMat.color       = new Color(1, 1, 1, 0);

                    assetGlass           = new OptimizedVoxelMesh(gd, importPivot, importTextureScale, importPadding, importScale);
                    assetGlass.mesh.name = "Glass";

                    GameObject glass = new GameObject("Glass");
                    glass.transform.parent = obj.transform;
                    glass.isStatic         = false;//glass should not be lightmapped

                    MeshFilter   glassmf = glass.AddComponent <MeshFilter>();
                    MeshRenderer glassmr = glass.AddComponent <MeshRenderer>();
                    if (import2Sided)
                    {
                        glassmr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                    }

                    glassmf.mesh     = assetGlass.mesh;
                    glassmr.material = glassMat;

                    AddCollider(glass);
                    if (importRigidbody)
                    {
                        glass.AddComponent <Rigidbody>();
                    }
                }

                VoxelData md = new VoxelData(data);
                md.ClearByMat(VoxMaterialType._metal, false);
                if (md.VoxelCount() > 0)
                {
                    assetMetal              = new OptimizedVoxelMesh(md, importPivot, importTextureScale, importPadding, importScale);
                    assetMetal.mesh.name    = "Metal";
                    assetMetal.texture.name = "Metal";

                    GameObject metal = new GameObject("Metal");
                    metal.transform.parent = obj.transform;
                    metal.isStatic         = importStatic;

                    MeshFilter   metalmf = metal.AddComponent <MeshFilter>();
                    MeshRenderer metalmr = metal.AddComponent <MeshRenderer>();
                    if (import2Sided)
                    {
                        metalmr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                    }

                    metalMat.mainTexture = assetMetal.texture;
                    metalMat.SetFloat("_Metallic", 1);
                    metalMat.SetFloat("_Glossiness", 1);
                    metalMat.SetFloat("_GlossyReflections", 1);

                    metalmf.mesh     = assetMetal.mesh;
                    metalmr.material = metalMat;

                    AddCollider(metal);
                    if (importRigidbody)
                    {
                        metal.AddComponent <Rigidbody>();
                    }
                }

                VoxelData ed = new VoxelData(data);
                ed.ClearByMat(VoxMaterialType._emit, false);
                if (ed.VoxelCount() > 0)
                {
                    assetEmission              = new OptimizedVoxelMesh(ed, importPivot, importTextureScale, importPadding, importScale);
                    assetEmission.mesh.name    = "Emission";
                    assetEmission.texture.name = "Emission";

                    emissionMat.SetTexture("_EmissionMap", assetEmission.texture);
                    emissionMat.EnableKeyword("_EMISSION");
                    emissionMat.SetColor("_EmissionColor", Color.white);
                    emissionMat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;

                    GameObject emit = new GameObject("Emission");
                    emit.transform.parent = obj.transform;
                    emit.isStatic         = importStatic;

                    MeshFilter   emitmf = emit.AddComponent <MeshFilter>();
                    MeshRenderer emitmr = emit.AddComponent <MeshRenderer>();
                    if (import2Sided)
                    {
                        emitmr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                    }

                    emitmf.mesh     = assetEmission.mesh;
                    emitmr.material = emissionMat;

                    AddCollider(emit);
                    if (importRigidbody)
                    {
                        emit.AddComponent <Rigidbody>();
                    }
                }

                VoxelData pd = new VoxelData(data);
                pd.ClearByMat(VoxMaterialType._plastic, false);
                if (pd.VoxelCount() > 0)
                {
                    assetPlastic              = new OptimizedVoxelMesh(pd, importPivot, importTextureScale, importPadding, importScale);
                    assetPlastic.mesh.name    = "Plastic";
                    assetPlastic.texture.name = "Plastic";

                    plasticMat.mainTexture = assetPlastic.texture;
                    plasticMat.SetFloat("_Metallic", 0);
                    plasticMat.SetFloat("_Glossiness", 1);

                    GameObject plastic = new GameObject("Plastic");
                    plastic.transform.parent = obj.transform;
                    plastic.isStatic         = importStatic;

                    MeshFilter   plasticmf = plastic.AddComponent <MeshFilter>();
                    MeshRenderer plasticmr = plastic.AddComponent <MeshRenderer>();
                    if (import2Sided)
                    {
                        plasticmr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                    }

                    plasticmf.mesh     = assetPlastic.mesh;
                    plasticmr.material = plasticMat;

                    AddCollider(plastic);
                    if (importRigidbody)
                    {
                        plastic.AddComponent <Rigidbody>();
                    }
                }

                VoxelData cd = new VoxelData(data);
                cd.ClearByMat(VoxMaterialType._clouds, false);
                if (cd.VoxelCount() > 0)
                {
                    assetClouds              = new OptimizedVoxelMesh(cd, importPivot, importTextureScale, importPadding, importScale);
                    assetClouds.mesh.name    = "Clouds";
                    assetClouds.texture.name = "Clouds";

                    cloudsMat.mainTexture = assetClouds.texture;
                    cloudsMat.SetFloat("_Glossiness", 0);
                    cloudsMat.SetInt("_Mode", 3);//transparent
                    cloudsMat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    cloudsMat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    cloudsMat.SetInt("_ZWrite", 0);
                    cloudsMat.DisableKeyword("_ALPHATEST_ON");
                    cloudsMat.DisableKeyword("_ALPHABLEND_ON");
                    cloudsMat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                    cloudsMat.renderQueue = 3000;
                    cloudsMat.color       = new Color(1, 1, 1, .5f);

                    GameObject clouds = new GameObject("Clouds");
                    clouds.transform.parent = obj.transform;
                    clouds.isStatic         = importStatic;

                    MeshFilter   cloudsmf = clouds.AddComponent <MeshFilter>();
                    MeshRenderer cloudsmr = clouds.AddComponent <MeshRenderer>();
                    if (import2Sided)
                    {
                        cloudsmr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                    }

                    cloudsmf.mesh     = assetClouds.mesh;
                    cloudsmr.material = cloudsMat;

                    AddCollider(clouds);
                    if (importRigidbody)
                    {
                        clouds.AddComponent <Rigidbody>();
                    }
                }
            }

            //create prefab

            if (assetDifuse != null || assetGlass != null || assetMetal != null || assetEmission != null || assetPlastic != null || assetClouds != null)
            {
                string assetPath  = importAssetPath + pfName + ".asset";
                string prefabPath = importAssetPath + pfName + ".prefab";

                AssetDatabase.CreateAsset(new Mesh(), assetPath);

                if (assetDifuse != null)
                {
                    AssetDatabase.AddObjectToAsset(assetDifuse.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(assetDifuse.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(diffuseMat, assetPath);
                }
                if (assetGlass != null)
                {
                    AssetDatabase.AddObjectToAsset(assetGlass.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(glassMat, assetPath);
                }
                if (assetMetal != null)
                {
                    AssetDatabase.AddObjectToAsset(assetMetal.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(assetMetal.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(metalMat, assetPath);
                }
                if (assetEmission != null)
                {
                    AssetDatabase.AddObjectToAsset(assetEmission.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(assetEmission.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(emissionMat, assetPath);
                }
                if (assetPlastic != null)
                {
                    AssetDatabase.AddObjectToAsset(assetPlastic.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(assetPlastic.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(plasticMat, assetPath);
                }
                if (assetClouds != null)
                {
                    AssetDatabase.AddObjectToAsset(assetClouds.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(assetClouds.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(cloudsMat, assetPath);
                }

                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();

                PrefabUtility.CreatePrefab(prefabPath, obj);
                //GameObject prefab = PrefabUtility.CreatePrefab(prefabPath, obj);
                //Selection.activeObject = prefab;
            }

            GameObject.DestroyImmediate(obj);
        }
コード例 #2
0
        public void CreatePrefabSingle(VoxelData data, string pfName)
        {
            VoxelData dd = new VoxelData(data);

            VerifyShaders();

            GameObject obj = new GameObject(pfName);

            obj.isStatic = importStatic;

            OptimizedVoxelMesh assetDifuse = null;
            Material           diffuseMat  = new Material(importDiffuseShader);

            diffuseMat.name = "Diffuse";

            OptimizedVoxelMesh assetGlass = null;
            Material           glassMat   = new Material(importGlassShader);

            glassMat.name = "Glass";

            OptimizedVoxelMesh assetMetal = null;
            Material           metalMat   = new Material(importMetalShader);

            metalMat.name = "Metal";

            OptimizedVoxelMesh assetEmission = null;
            Material           emissionMat   = new Material(importEmissionShader);

            emissionMat.name = "Emission";

            OptimizedVoxelMesh assetPlastic = null;
            Material           plasticMat   = new Material(importPlasticShader);

            plasticMat.name = "Plastic";

            OptimizedVoxelMesh assetClouds = null;
            Material           cloudsMat   = new Material(importCloudsShader);

            cloudsMat.name = "Clouds";

            if (importMaterials)
            {
                dd.ClearByMat(VoxMaterialType._glass, true);
                dd.ClearByMat(VoxMaterialType._metal, true);
                dd.ClearByMat(VoxMaterialType._emit, true);
                dd.ClearByMat(VoxMaterialType._plastic, true);
                dd.ClearByMat(VoxMaterialType._clouds, true);
            }

            if (dd.VoxelCount() > 0)
            {
                assetDifuse              = new OptimizedVoxelMesh(dd, importPivot, importTextureScale, importPadding, importScale);
                assetDifuse.mesh.name    = "Diffuse";
                assetDifuse.texture.name = "Diffuse";

                diffuseMat.mainTexture = assetDifuse.texture;
                diffuseMat.SetFloat("_Metallic", 0);
                diffuseMat.SetFloat("_Glossiness", 0);
            }

            if (importMaterials)
            {
                VoxelData gd = new VoxelData(data);
                gd.ClearByMat(VoxMaterialType._glass, false);
                if (gd.VoxelCount() > 0)
                {
                    assetGlass           = new OptimizedVoxelMesh(gd, importPivot, importTextureScale, importPadding, importScale);
                    assetGlass.mesh.name = "Glass";

                    glassMat.SetFloat("_Glossiness", 1);
                    glassMat.SetInt("_Mode", 3);//transparent
                    glassMat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    glassMat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    glassMat.SetInt("_ZWrite", 0);
                    glassMat.DisableKeyword("_ALPHATEST_ON");
                    glassMat.DisableKeyword("_ALPHABLEND_ON");
                    glassMat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                    glassMat.renderQueue = 3000;
                    glassMat.color       = new Color(1, 1, 1, 0);
                }

                VoxelData md = new VoxelData(data);
                md.ClearByMat(VoxMaterialType._metal, false);
                if (md.VoxelCount() > 0)
                {
                    assetMetal              = new OptimizedVoxelMesh(md, importPivot, importTextureScale, importPadding, importScale);
                    assetMetal.mesh.name    = "Metal";
                    assetMetal.texture.name = "Metal";

                    metalMat.mainTexture = assetMetal.texture;
                    metalMat.SetFloat("_Metallic", 1);
                    metalMat.SetFloat("_Glossiness", 1);
                    metalMat.SetFloat("_GlossyReflections", 1);
                }

                VoxelData ed = new VoxelData(data);
                ed.ClearByMat(VoxMaterialType._emit, false);
                if (ed.VoxelCount() > 0)
                {
                    assetEmission              = new OptimizedVoxelMesh(ed, importPivot, importTextureScale, importPadding, importScale);
                    assetEmission.mesh.name    = "Emission";
                    assetEmission.texture.name = "Emission";

                    emissionMat.SetTexture("_EmissionMap", assetEmission.texture);
                    emissionMat.EnableKeyword("_EMISSION");
                    emissionMat.SetColor("_EmissionColor", Color.white);
                    emissionMat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
                }

                VoxelData pd = new VoxelData(data);
                pd.ClearByMat(VoxMaterialType._plastic, false);
                if (pd.VoxelCount() > 0)
                {
                    assetPlastic              = new OptimizedVoxelMesh(pd, importPivot, importTextureScale, importPadding, importScale);
                    assetPlastic.mesh.name    = "Plastic";
                    assetPlastic.texture.name = "Plastic";

                    plasticMat.mainTexture = assetPlastic.texture;
                    plasticMat.SetFloat("_Metallic", 0);
                    plasticMat.SetFloat("_Glossiness", 1);
                }

                VoxelData cd = new VoxelData(data);
                cd.ClearByMat(VoxMaterialType._clouds, false);
                if (cd.VoxelCount() > 0)
                {
                    assetClouds              = new OptimizedVoxelMesh(cd, importPivot, importTextureScale, importPadding, importScale);
                    assetClouds.mesh.name    = "Clouds";
                    assetClouds.texture.name = "Clouds";

                    cloudsMat.mainTexture = assetClouds.texture;
                    cloudsMat.SetFloat("_Metallic", 0);
                    cloudsMat.SetFloat("_Glossiness", 0);
                    cloudsMat.SetInt("_Mode", 3);//transparent
                    cloudsMat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                    cloudsMat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                    cloudsMat.SetInt("_ZWrite", 0);
                    cloudsMat.DisableKeyword("_ALPHATEST_ON");
                    cloudsMat.DisableKeyword("_ALPHABLEND_ON");
                    cloudsMat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                    cloudsMat.renderQueue = 3000;
                    cloudsMat.color       = new Color(1, 1, 1, .5f);
                }
            }

            Mesh objMesh = new Mesh();
            int  subMesh = 0;

            List <Vector3> buildVerts = new List <Vector3>();
            List <Vector2> buildUvs   = new List <Vector2>();
            Dictionary <int, List <int> > buildIdxs = new Dictionary <int, List <int> >();
            List <Material> mats = new List <Material>();

            if (assetDifuse != null)
            {
                buildIdxs.Add(subMesh, AddMesh(ref assetDifuse.mesh, ref buildVerts, ref buildUvs));
                mats.Add(diffuseMat);
                subMesh++;
            }

            if (assetGlass != null)
            {
                buildIdxs.Add(subMesh, AddMesh(ref assetGlass.mesh, ref buildVerts, ref buildUvs));
                mats.Add(glassMat);
                subMesh++;
            }

            if (assetMetal != null)
            {
                buildIdxs.Add(subMesh, AddMesh(ref assetMetal.mesh, ref buildVerts, ref buildUvs));
                mats.Add(metalMat);
                subMesh++;
            }

            if (assetEmission != null)
            {
                buildIdxs.Add(subMesh, AddMesh(ref assetEmission.mesh, ref buildVerts, ref buildUvs));
                mats.Add(emissionMat);
                subMesh++;
            }

            if (assetPlastic != null)
            {
                buildIdxs.Add(subMesh, AddMesh(ref assetPlastic.mesh, ref buildVerts, ref buildUvs));
                mats.Add(plasticMat);
                subMesh++;
            }

            if (assetClouds != null)
            {
                buildIdxs.Add(subMesh, AddMesh(ref assetClouds.mesh, ref buildVerts, ref buildUvs));
                mats.Add(cloudsMat);
                subMesh++;
            }

            objMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
            objMesh.vertices    = buildVerts.ToArray();
            objMesh.uv          = buildUvs.ToArray();

            objMesh.subMeshCount = subMesh;
            for (int i = 0; i < subMesh; i++)
            {
                int[] mi = buildIdxs[i].ToArray();
                //Debug.Log(i + " - " + mi.Length);
                objMesh.SetIndices(mi, MeshTopology.Triangles, i);
            }

            objMesh.RecalculateNormals();

            MeshFilter   objMf = obj.AddComponent <MeshFilter>();
            MeshRenderer objMr = obj.AddComponent <MeshRenderer>();

            //objMf.mesh = objMesh;
            //objMr.materials = mats.ToArray();
            objMf.sharedMesh      = objMesh;
            objMr.sharedMaterials = mats.ToArray();

            if (import2Sided)
            {
                objMr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
            }
            AddCollider(obj);
            if (importRigidbody)
            {
                obj.AddComponent <Rigidbody>();
            }



            //create prefab
            if (assetDifuse != null || assetGlass != null || assetMetal != null || assetEmission != null || assetPlastic != null || assetClouds != null)
            {
                string assetPath  = importAssetPath + pfName + ".asset";
                string prefabPath = importAssetPath + pfName + ".prefab";

                AssetDatabase.CreateAsset(new Mesh(), assetPath);

                AssetDatabase.AddObjectToAsset(objMesh, assetPath);

                if (assetDifuse != null)
                {
                    AssetDatabase.AddObjectToAsset(assetDifuse.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(diffuseMat, assetPath);
                }
                if (assetGlass != null)
                {
                    AssetDatabase.AddObjectToAsset(glassMat, assetPath);
                }
                if (assetMetal != null)
                {
                    AssetDatabase.AddObjectToAsset(assetMetal.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(metalMat, assetPath);
                }
                if (assetEmission != null)
                {
                    AssetDatabase.AddObjectToAsset(assetEmission.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(emissionMat, assetPath);
                }
                if (assetPlastic != null)
                {
                    AssetDatabase.AddObjectToAsset(assetPlastic.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(plasticMat, assetPath);
                }
                if (assetClouds != null)
                {
                    AssetDatabase.AddObjectToAsset(assetClouds.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(cloudsMat, assetPath);
                }

                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();

                PrefabUtility.CreatePrefab(prefabPath, obj);
            }

            GameObject.DestroyImmediate(obj);
        }
コード例 #3
0
        public void CreatePrefab(VoxelData data, string pfName)
        {
            VoxelData dd = new VoxelData(data);

            VerifyShaders();

            GameObject obj = new GameObject(pfName);

            obj.isStatic = importStatic;

            OptimizedVoxelMesh assetDifuse = null;
            Material           diffuseMat  = new Material(importDiffuseShader);

            diffuseMat.name             = "Diffuse";
            diffuseMat.enableInstancing = true;

            if (dd.VoxelCount() > 0)
            {
                assetDifuse              = new OptimizedVoxelMesh(dd, importPivot, importTextureScale, importPadding, importScale);
                assetDifuse.mesh.name    = "Diffuse";
                assetDifuse.texture.name = "Diffuse";

                MeshFilter mf = obj.AddComponent <MeshFilter>();
                mf.mesh = assetDifuse.mesh;

                diffuseMat.mainTexture = assetDifuse.texture;
                diffuseMat.SetFloat("_Metallic", 0);
                diffuseMat.SetFloat("_Glossiness", 0);

                MeshRenderer mr = obj.AddComponent <MeshRenderer>();
                if (import2Sided)
                {
                    mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                }

                mr.material = diffuseMat;

                AddCollider(obj);
                if (importRigidbody)
                {
                    obj.AddComponent <Rigidbody>();
                }
            }



            //create prefab

            if (assetDifuse != null)
            {
                string assetPath  = importAssetPath + pfName + ".asset";
                string prefabPath = importAssetPath + pfName + ".prefab";

                AssetDatabase.CreateAsset(new Mesh(), assetPath);

                if (assetDifuse != null)
                {
                    AssetDatabase.AddObjectToAsset(assetDifuse.mesh, assetPath);
                    AssetDatabase.AddObjectToAsset(assetDifuse.texture, assetPath);
                    AssetDatabase.AddObjectToAsset(diffuseMat, assetPath);
                }

                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();

                PrefabUtility.CreatePrefab(prefabPath, obj);
                //GameObject prefab = PrefabUtility.CreatePrefab(prefabPath, obj);
                //Selection.activeObject = prefab;
            }

            GameObject.DestroyImmediate(obj);
        }