Example #1
0
        public static void Show(PatternTexture patternTexture, string selection, Action <string> onSelectAction, Action onCloseAction)
        {
            if (instance != null)
            {
                instance.Close();
                instance = null;
            }

            var comp = DisplayWizard <PatternSpriteSelector>("Select Sprite");

            comp.onSelectAction = onSelectAction;
            comp.onCloseAction  = onCloseAction;

            comp.patternTexture       = patternTexture;
            comp.selectionTextureName = selection;
            comp.preViewSize          = 200f;

            comp.sourceTextures = patternTexture.GetAllPatternData()
                                  .Select(x =>
            {
                var path = AssetDatabase.GUIDToAssetPath(x.Guid);
                return(AssetDatabase.LoadMainAssetAtPath(path) as Texture2D);
            })
                                  .Where(x => x != null)
                                  .ToArray();
        }
Example #2
0
        private void CalcPerformance(PatternTexture patternTexture)
        {
            calcPerformance = false;

            if (patternTexture != null)
            {
                var assetPath = AssetDatabase.GetAssetPath(patternTexture);
                var fullPath  = UnityPathUtility.ConvertAssetPathToFullPath(assetPath);

                var fileInfo = new FileInfo(fullPath);

                infoFileSize = (float)fileInfo.Length / MB;
            }
            else
            {
                return;
            }

            var textures = patternTexture.GetAllPatternData()
                           .Select(x => AssetDatabase.GUIDToAssetPath(x.Guid))
                           .Select(x => AssetDatabase.LoadMainAssetAtPath(x) as Texture2D)
                           .Where(x => x != null)
                           .ToArray();

            // 消費メモリサイズを計測.
            totalMemSize = 0;
            textures.ForEach(x =>
            {
                var mem       = Mathf.NextPowerOfTwo(x.width) * Mathf.NextPowerOfTwo(x.height);
                mem          *= !x.alphaIsTransparency ? 3 : 4;
                totalMemSize += mem;
            });
            totalMemSize /= MB;

            if (patternTexture.Texture != null)
            {
                var mem = Mathf.NextPowerOfTwo(patternTexture.Texture.width) * Mathf.NextPowerOfTwo(patternTexture.Texture.height);
                mem *= !patternTexture.Texture.alphaIsTransparency ? 3 : 4;
                totalAtlasMemSize = (float)mem / MB;
            }

            // ファイルサイズ.
            totalFileSize = 0f;
            textures.Select(x => AssetDatabase.GetAssetPath(x))
            .Select(x => UnityPathUtility.ConvertAssetPathToFullPath(x))
            .Select(x => new FileInfo(x))
            .ForEach(x => totalFileSize += (float)x.Length / MB);

            if (patternTexture.Texture != null)
            {
                var assetPath = AssetDatabase.GetAssetPath(patternTexture.Texture);
                var fullPath  = UnityPathUtility.ConvertAssetPathToFullPath(assetPath);

                var fileInfo = new FileInfo(fullPath);

                atlasFileSize = (float)fileInfo.Length / MB;
            }

            calcPerformance = true;
        }
Example #3
0
        public string[] GetAllPatternName()
        {
            if (patternTexture == null)
            {
                return(new string[0]);
            }

            var patternData  = patternTexture.GetAllPatternData();
            var patternNames = patternData.Select(x => x.TextureName).ToArray();

            return(patternNames);
        }
Example #4
0
        public void BuildTextureInfos(Texture2D[] addTextures)
        {
            // パック済みのテクスチャは除外.
            if (selectPatternTexture != null && addTextures != null)
            {
                addTextures = addTextures
                              .Where(x => x != selectPatternTexture.Texture)
                              .ToArray();
            }

            var allPatternData = selectPatternTexture != null?
                                 selectPatternTexture.GetAllPatternData() :
                                     new PatternData[0];

            var textureInfoByGuid = new Dictionary <string, TextureInfo>();

            foreach (var item in allPatternData)
            {
                if (string.IsNullOrEmpty(item.Guid))
                {
                    continue;
                }

                var assetPath = AssetDatabase.GUIDToAssetPath(item.Guid);
                var texture   = AssetDatabase.LoadMainAssetAtPath(assetPath) as Texture2D;

                var info = new TextureInfo();

                info.status = texture != null ? TextureStatus.Exist : TextureStatus.Missing;

                if (info.status == TextureStatus.Exist)
                {
                    var fullPath   = UnityPathUtility.ConvertAssetPathToFullPath(assetPath);
                    var lastUpdate = File.GetLastWriteTime(fullPath).ToUnixTime();

                    if (item.LastUpdate != lastUpdate)
                    {
                        info.status = TextureStatus.Update;
                    }

                    info.texture = texture;
                }

                textureInfoByGuid.Add(item.Guid, info);
            }

            if (addTextures != null)
            {
                foreach (var texture in addTextures)
                {
                    var assetPath = AssetDatabase.GetAssetPath(texture);
                    var guid      = AssetDatabase.AssetPathToGUID(assetPath);

                    var info = textureInfoByGuid.GetValueOrDefault(guid);

                    if (info == null)
                    {
                        info = new TextureInfo()
                        {
                            status  = TextureStatus.Add,
                            texture = texture,
                        };

                        textureInfoByGuid.Add(guid, info);
                    }
                    else
                    {
                        textureInfoByGuid[guid].status = TextureStatus.Update;
                    }
                }
            }

            textureInfos = textureInfoByGuid.Values.ToArray();

            CalcPerformance(selectPatternTexture);

            Repaint();
        }