private async void StoreImage(WriteableBitmap bmp, SpriteTextureType spriteTextureType)
        {
            if (!EnableImageStoring)
            {
                return;
            }
            var folderDesc = await FolderOfType(spriteTextureType);

            IRandomAccessStream stream = null;

            DeleteFilesUntilIndex(folderDesc.folder, folderDesc.lastIndex);
            try
            {
                folderDesc.lastIndex++;
                var file = await folderDesc.folder.CreateFileAsync(folderDesc.lastIndex.ToString());

                stream = await file.OpenAsync(FileAccessMode.ReadWrite);

                if (stream.CanWrite)
                {
                    await bmp.WriteBinAsync(stream);

                    await stream.FlushAsync();

                    stream.Dispose();
                    stream = null;
                    return;
                }
            }
            catch
            {
            }
        }
        public async Task <WriteableBitmap> GetTexture(SpriteTextureType spriteTextureType)
        {
            try
            {
                var folderDesc = await FolderOfType(spriteTextureType);

                int tIndex = folderDesc.lastIndex;
                var file   = await folderDesc.folder.GetFileAsync(tIndex.ToString());

                using (var stream = await file.OpenAsync(FileAccessMode.Read))
                {
                    if (stream.CanRead)
                    {
                        if (stream.Size == 0)
                        {
                            return(null);
                        }
                        var bmp = await WritableBitmapBinSave.ReadBinAsync(stream);

                        this.Log("GetTexture ended", spriteTextureType);
                        return(bmp);
                    }
                }
            }
            catch (Exception e)
            {
                e.DebugDesc().Log("GetTexture", this);
            }
            return(null);
        }
        private async Task <FolderDesc> FolderOfType(SpriteTextureType type)
        {
            FolderDesc res;

            if (folders.TryGetValue(type, out res))
            {
                return(res);
            }

            var rootThis = await GetThisRoot();

            var typeFolder = await rootThis.CreateFolderAsync(type.ToString(), CreationCollisionOption.OpenIfExists);


            if (folders.TryGetValue(type, out res))
            {
                return(res);
            }
            res = new FolderDesc()
            {
                folder    = typeFolder,
                lastIndex = 0
            };
            folders.Add(type, res);
            return(res);
        }
 public void SetImage(WriteableBitmap bmp, SpriteTextureType type)
 {
     ObjectMonitorExt.AddToObjectMonitor(bmp, ObjectMonitor.DefaultCategories.Bitmap);
     if (DXMenager.EnableRestoring)
     {
         StoreImage(bmp, type);
     }
     SetTexture(bmp, type);
 }
 private async Task RestoreTexture(SpriteTextureType spriteTextureType)
 {
     try
     {
         this.Log("RestoreTexture started", spriteTextureType);
         SetTexture(await GetTexture(spriteTextureType), spriteTextureType);
         this.Log("RestoreTexture ended", spriteTextureType);
     }
     catch { }
     return;
 }
        private async void ClearStorage(SpriteTextureType type)
        {
            this.Log("Want to delete", type);
            try
            {
                var t = await FolderOfType(type);

                await t.folder.DeleteAsync();

                folders.Remove(type);
                this.Log("Deleted", type);
            }
            catch (Exception e)
            {
                e.Log("Cant remove", type, this);
            }
        }
        public void ClearTexture(SpriteTextureType type)
        {
            ClearStorage(type);
            int[] bmpPix = null;
            switch (type)
            {
            case SpriteTextureType.Main:
                m_d3dInterop.SpriteCreateMainTexture(id, out bmpPix[0], 0, 0);
                break;

            case SpriteTextureType.Blend:
                m_d3dInterop.SpriteCreateBlendTexture(id, out bmpPix[0], 0, 0);
                break;

            case SpriteTextureType.Mask:
                m_d3dInterop.SpriteCreateMaskTexture(id, out bmpPix[0], 0, 0);
                break;

            default:
                break;
            }
        }
        private void SetTexture(WriteableBitmap bmp, SpriteTextureType type)
        {
            if (bmp == null)
            {
                return;
            }
            switch (type)
            {
            case SpriteTextureType.Main:
                m_d3dInterop.SpriteCreateMainTexture(id, out bmp.Pixels[0], bmp.PixelWidth, bmp.PixelHeight);
                break;

            case SpriteTextureType.Blend:
                m_d3dInterop.SpriteCreateBlendTexture(id, out bmp.Pixels[0], bmp.PixelWidth, bmp.PixelHeight);
                break;

            case SpriteTextureType.Mask:
                m_d3dInterop.SpriteCreateMaskTexture(id, out bmp.Pixels[0], bmp.PixelWidth, bmp.PixelHeight);
                break;

            default:
                break;
            }
        }