public static string BuildDepMaterial(Material mat, float scaleTexture = 1f)
    {
        CDepCollectInfo buildResult = KDepCollectInfoCaching.GetCache(mat);

        if (buildResult != null)
        {
            return(buildResult.Path);
        }

        KSerializeMaterial sMat = __DoExportMaterial(mat, scaleTexture);

        if (sMat != null)
        {
            string path = AssetDatabase.GetAssetPath(mat);

            bool needBuild = AssetVersionControl.TryCheckNeedBuildWithMeta(path);
            if (needBuild)
            {
                AssetVersionControl.TryMarkBuildVersion(path);
            }

            path        = KDependencyBuild.__GetPrefabBuildPath(path);
            buildResult = KDependencyBuild.__DoBuildScriptableObject("Material/Material_" + path, sMat, needBuild);

            KDepCollectInfoCaching.SetCache(mat, buildResult);

            return(buildResult.Path);
        }

        // 可能没路径的材质,直接忽略
        return("");
    }
示例#2
0
        /// <summary>
        /// NGUI 的字体集
        /// </summary>
        public static string BuildUIFont(UIFont uiFont)
        {
            CDepCollectInfo result;

            if (KDepCollectInfoCaching.HasCache(uiFont))
            {
                result = KDepCollectInfoCaching.GetCache(uiFont);
                return(result.Path);
            }
            if (uiFont.atlas == null)
            {
                Logger.LogError("[BuildUIFont]uiFont Null Atlas: {0}, Scene: {1}", uiFont.name, EditorApplication.currentScene);
                return("");
            }
            string uiFontPrefabPath = AssetDatabase.GetAssetPath(uiFont.gameObject);
            bool   needBuild        = KAssetVersionControl.TryCheckNeedBuildWithMeta(uiFontPrefabPath);

            if (needBuild)
            {
                KAssetVersionControl.TryMarkBuildVersion(uiFontPrefabPath);
            }

            var copyUIFontObj = GameObject.Instantiate(uiFont.gameObject) as GameObject;
            var copyUIFont    = copyUIFontObj.GetComponent <UIFont>();

            var uiAtlas = BuildUIAtlas(copyUIFont.atlas); // 依赖的UI Atlas

            copyUIFont.atlas    = null;                   // 清空依赖
            copyUIFont.material = null;
            //CResourceDependencies.Create(copyUIFont, CResourceDependencyType.NGUI_UIFONT, uiAtlas);
            KAssetDep.Create <KUIFontDep>(copyUIFont, uiAtlas);

            result = KDependencyBuild.DoBuildAssetBundle("UIFont/UIFont_" + uiFont.name, copyUIFontObj, needBuild);

            GameObject.DestroyImmediate(copyUIFontObj);
            KDepCollectInfoCaching.SetCache(uiFont, result);
            return(result.Path);
        }
示例#3
0
        /// <summary>
        /// 图集 打包结果缓存起来加速
        /// </summary>
        /// <param name="atlas"></param>
        /// <returns></returns>
        public static string BuildUIAtlas(UIAtlas atlas)
        {
            CDepCollectInfo result;

            // 使用缓存,确保Atlas不会重复处理,浪费性能
            if (KDepCollectInfoCaching.HasCache(atlas))
            {
                result = KDepCollectInfoCaching.GetCache(atlas);
                return(result.Path);
            }
            var        scale       = 1f; // TODO: scale read
            GameObject atlasPrefab = PrefabUtility.FindPrefabRoot(atlas.gameObject) as GameObject;

            Logger.Assert(atlasPrefab);
            string path      = AssetDatabase.GetAssetPath(atlasPrefab); // prefab只用来获取路径,不打包不挖空
            bool   needBuild = KAssetVersionControl.TryCheckNeedBuildWithMeta(path);

            if (needBuild)
            {
                KAssetVersionControl.TryMarkBuildVersion(path);
            }

            Logger.Assert(path);

            path = KDependencyBuild.__GetPrefabBuildPath(path);

            GameObject copyAtlasObj = GameObject.Instantiate(atlasPrefab) as GameObject;

            UIAtlas copyAtlas = copyAtlasObj.GetComponent <UIAtlas>();

            if (BeforeBuildUIAtlasFilter != null)
            {
                BeforeBuildUIAtlasFilter(copyAtlas);
            }

            Material cacheMat = copyAtlas.spriteMaterial;
            string   matPath  = KDepBuild_Material.BuildDepMaterial(cacheMat, scale); // 缩放

            // 缩放
            copyAtlas.pixelSize = 1 / PictureScale;
            foreach (var spriteData in copyAtlas.spriteList)
            {
                spriteData.x            = Mathf.FloorToInt(spriteData.x * PictureScale);
                spriteData.y            = Mathf.FloorToInt(spriteData.y * PictureScale);
                spriteData.width        = Mathf.FloorToInt(spriteData.width * PictureScale);
                spriteData.height       = Mathf.FloorToInt(spriteData.height * PictureScale);
                spriteData.borderLeft   = Mathf.FloorToInt(spriteData.borderLeft * PictureScale);
                spriteData.borderRight  = Mathf.FloorToInt(spriteData.borderRight * PictureScale);
                spriteData.borderTop    = Mathf.FloorToInt(spriteData.borderTop * PictureScale);
                spriteData.borderBottom = Mathf.FloorToInt(spriteData.borderBottom * PictureScale);
                // padding 不变, ngui bug
                spriteData.paddingBottom = Mathf.FloorToInt(spriteData.paddingBottom * PictureScale);
                spriteData.paddingTop    = Mathf.FloorToInt(spriteData.paddingTop * PictureScale);
                spriteData.paddingLeft   = Mathf.FloorToInt(spriteData.paddingLeft * PictureScale);
                spriteData.paddingRight  = Mathf.FloorToInt(spriteData.paddingRight * PictureScale);
            }

            KAssetDep.Create <KUIAtlasDep>(copyAtlas, matPath);

            copyAtlas.spriteMaterial = null;                                                                  // 挖空atlas

            result = KDependencyBuild.DoBuildAssetBundle("UIAtlas/UIAtlas_" + path, copyAtlasObj, needBuild); // Build主对象, 被挖空Material了的

            if (AfterBuildUIAtlasFilter != null)
            {
                AfterBuildUIAtlasFilter(copyAtlas);
            }
            GameObject.DestroyImmediate(copyAtlasObj);

            KDepCollectInfoCaching.SetCache(atlas, result);
            return(result.Path);
        }
示例#4
0
    //static HashSet<string> _depTextureScaleList = new HashSet<string>();  // 进行过Scale的图片
    public static string BuildDepTexture(Texture tex, float scale = 1f)
    {
        Debuger.Assert(tex);
        CDepCollectInfo result = KDepCollectInfoCaching.GetCache(tex);

        if (result != null)
        {
            return(result.Path);
        }

        string assetPath = AssetDatabase.GetAssetPath(tex);
        bool   needBuild = AssetVersionControl.TryCheckNeedBuildWithMeta(assetPath);

        if (needBuild)
        {
            AssetVersionControl.TryMarkBuildVersion(assetPath);
        }

        Texture newTex;

        if (tex is Texture2D)
        {
            var tex2d = (Texture2D)tex;

            if (needBuild &&
                !scale.Equals(1f)) // 需要进行缩放,才进来拷贝
            {
                var cacheDir      = "Assets/" + KEngineDef.ResourcesBuildCacheDir + "/BuildDepTexture/";
                var cacheFilePath = cacheDir + Path.GetFileName(assetPath);

                //var needScale = !BuildedCache.ContainsKey("BuildDepTexture:" + assetPath);
                //if (needScale && !IsJustCollect)
                //{
                //    CFolderSyncTool.TexturePackerScaleImage(assetPath, cacheFilePath, scale);  // do scale
                //    var actionName = "BuildDepTexture:" + assetPath;
                //    //BuildedCache[actionName] = true;  // 下次就别scale了!蛋痛
                //    AddCache(actionName);
                //}

                newTex = AssetDatabase.LoadAssetAtPath(cacheFilePath, typeof(Texture2D)) as Texture2D;
                if (newTex == null)
                {
                    Log.Error("TexturePacker scale failed... {0}", assetPath);
                    newTex = tex2d;
                }

                SyncTextureImportSetting(tex2d, newTex as Texture2D);

                // TODO: mark to write
                //var texPath = AssetDatabase.GetAssetPath(tex2d);

                //var newTex2D = new Texture2D(tex2d.width, tex2d.height);
                //if (!string.IsNullOrEmpty(texPath)) // Assets内的纹理
                //{
                //    var bytes = File.ReadAllBytes(texPath);
                //    newTex2D.LoadImage(bytes);
                //}
                //else
                //{
                //    var bytes = tex2d.EncodeToPNG();
                //    newTex2D.LoadImage(bytes);
                //}

                //newTex2D.Apply();
                //GC.CollectMaterial();
                //// 进行缩放
                //TextureScaler.Bilinear(newTex2D, (int) (tex.width*scale), (int) (tex.height*scale));
                //GC.CollectMaterial();

                //newTex = newTex2D;
            }
            else
            {
                newTex = tex2d;
            }
        }
        else
        {
            newTex = tex;
            if (!scale.Equals(1f))
            {
                Log.Warning("[BuildDepTexture]非Texture2D: {0}, 无法进行Scale缩放....", tex);
            }
        }
        //if (!IsJustCollect)
        //    CTextureCompressor.CompressTextureAsset(assetPath, newTex as Texture2D);

        string path = __GetPrefabBuildPath(assetPath);

        if (string.IsNullOrEmpty(path))
        {
            Log.Warning("[BuildTexture]不是文件的Texture, 估计是Material的原始Texture?");
        }
        result = DoBuildAssetBundle("Texture/Texture_" + path, newTex, needBuild);

        KDepCollectInfoCaching.SetCache(tex, result);
        GC.Collect(0);
        return(result.Path);
    }