public Viewport Next(StorageBlock block) { var vp = new Viewport(_blockId, _offset, block); Next(); return(vp); }
public ScalePointRender(IPointRender render, float scale, float offset) { _render = render; _scale = scale; _offset = offset; _block = new StorageBlock(Viewport.ViewportSize); }
public WaveTaskScheduler( IBaseDataSource source, IRealDataCollector collector, RealDataFile file, RenderTask listRenderTask, RenderTask viewRenderTask, StatisticTask statisticTask, ScrollTask scrollTask, RenderingStartedDelegate startedCallback, RenderingStopedDeletegate stopedCallback ) { _baseBlock = new StorageBlock(); _preBaseBlock = new StorageBlock(); _realBlock = new StorageBlock(); _source = source; _collector = collector; _file = file; _listRenderTask = listRenderTask; _viewRenderTask = viewRenderTask; _statisticTask = statisticTask; _scrollTask = scrollTask; _startedCallback = startedCallback; _stopedCallback = stopedCallback; }
public Viewport Next(StorageBlock block, out bool needNewBlock) { var vp = new Viewport(_blockId, _offset, block); needNewBlock = Next(); return(vp); }
internal void Register(StorageBlock storageBlock) { if (!Storages.Contains(storageBlock)) { Storages.Add(storageBlock); resourceCapacity += storageBlock.storageCapacity; // resourceAmount += storageBlock.StoredAmount; } }
public void Begin(StorageBlock realBlock, StorageBlock baseBlock, StorageBlock preBaseBlock) { _baseVpGenerator.Reset(0); _realVpGenerator.Reset(0); _isCreated.Reset(); RenderBasePointsBlock(baseBlock); RenderBasePointsBlock(preBaseBlock); _needNewItem = true; PrepareRenderItem(realBlock); }
internal void UnRegister(StorageBlock storageBlock) { if (Storages.Contains(storageBlock)) { Storages.Remove(storageBlock); resourceCapacity -= storageBlock.storageCapacity; if (resourceAmount < resourceCapacity) { resourceAmount = resourceCapacity; } } }
public void PrepareRenderItem(StorageBlock block) { var vp = _realVpGenerator.Next(block); _dispatcher.BeginInvoke( (GetRenderingItemDelegate)((viewport) => { _item = _pool.GetNextRenderingRealPointItem(); _item.RealViewport = viewport; _item.BeginRenderRealData(); _isCreated.Set(); }), vp ); }
public void RenderBasePointsBlock(StorageBlock block) { bool need; do { var vp = _baseVpGenerator.Next(block, out need); _dispatcher.BeginInvoke( (RenderBaseDataDelegate)((viewport) => { var item = _pool.CreateRenderItem(_render); item.BaseViewport = viewport; item.RenderBasePoints(); }), vp ); } while (!need); }
public void Statistics(StorageBlock baseBlock, StorageBlock realBlock, int index, int length) { var boundary = index + length; for (; index < boundary; index++) { var bp = baseBlock[index]; var rp = realBlock[index]; if (rp > bp) { var diff = rp - bp; var percent = diff / bp; if (percent > _breakLimitPercent) { _result.ExceedAmount += diff; var item = CreateExceedLimitItem(true); OnExceedLimitOccur(item); } else if (percent > _bluntLimitPercent) { _result.ExceedAmount += diff; var item = CreateExceedLimitItem(false); OnExceedLimitOccur(item); } else if (percent > _exceedPercent) { _result.ExceedAmount += diff; _result.ExceedCount++; } } else if (rp < bp) { var diff = bp - rp; var percent = (bp - rp) / bp; if (percent > _underPercent) { _result.UnderAmount += diff; _result.UnderCount++; } } _baseAmount += bp; } _result.Count += length; }
private void ReadHeaderAndBlocksInfo(EndianBinaryReader reader) { var isCompressed = m_Header.signature == "UnityWeb"; m_Header.version = reader.ReadUInt32(); m_Header.unityVersion = reader.ReadStringToNull(); m_Header.unityRevision = reader.ReadStringToNull(); if (m_Header.version >= 4) { var hash = reader.ReadBytes(16); var crc = reader.ReadUInt32(); } var minimumStreamedBytes = reader.ReadUInt32(); var headerSize = reader.ReadUInt32(); var numberOfLevelsToDownloadBeforeStreaming = reader.ReadUInt32(); var levelCount = reader.ReadInt32(); m_BlocksInfo = new StorageBlock[1]; for (int i = 0; i < levelCount; i++) { var storageBlock = new StorageBlock() { compressedSize = reader.ReadUInt32(), uncompressedSize = reader.ReadUInt32(), flags = (ushort)(isCompressed ? 1 : 0) }; if (i == levelCount - 1) { m_BlocksInfo[0] = storageBlock; } } if (m_Header.version >= 2) { var completeFileSize = reader.ReadUInt32(); } if (m_Header.version >= 3) { var fileInfoHeaderSize = reader.ReadUInt32(); } reader.Position = headerSize; }
private void ReadHeaderAndBlocksInfo(EndianBinaryReader reader) { if (m_Header.version >= 4) { var hash = reader.ReadBytes(16); var crc = reader.ReadUInt32(); } var minimumStreamedBytes = reader.ReadUInt32(); m_Header.size = reader.ReadUInt32(); var numberOfLevelsToDownloadBeforeStreaming = reader.ReadUInt32(); var levelCount = reader.ReadInt32(); m_BlocksInfo = new StorageBlock[1]; for (int i = 0; i < levelCount; i++) { var storageBlock = new StorageBlock() { compressedSize = reader.ReadUInt32(), uncompressedSize = reader.ReadUInt32(), }; if (i == levelCount - 1) { m_BlocksInfo[0] = storageBlock; } } if (m_Header.version >= 2) { var completeFileSize = reader.ReadUInt32(); } if (m_Header.version >= 3) { var fileInfoHeaderSize = reader.ReadUInt32(); } reader.Position = m_Header.size; }
private void TaskSpecificProcess() { _collector.Start(); _realBlock.Clear(); _baseBlock.Clear(); _preBaseBlock.Clear(); _source.LoadBlock(_baseBlock); _source.LoadBlock(_preBaseBlock); _listRenderTask.Begin(_realBlock, _baseBlock, _preBaseBlock); if (_viewRenderTask != null) { _viewRenderTask.Begin(_realBlock, _baseBlock, _preBaseBlock); } if (_statisticTask != null) { _statisticTask.Start(); } if (_startedCallback != null) { _startedCallback(); } while (_rendering) { int index = _realBlock.Length; int length = Math.Min(_realBlock.Capacity, CollectStep); length = _collector.CollectPoints(_realBlock, length); if (length == 0) { _rendering = false; break; } bool needNewList, needNewView = false; needNewList = _listRenderTask.RenderRealPoints(length); if (_viewRenderTask != null) { needNewView = _viewRenderTask.RenderRealPoints(length); } if (_statisticTask != null) { _statisticTask.Statistics(_baseBlock, _realBlock, index, length); } if (_scrollTask != null && _scrollTask.IsEnable) { _scrollTask.Scroll(_statisticTask.StatisticResult.Count); } Debug.Assert(!_realBlock.IsFull || needNewList); if (_realBlock.IsFull) { _file.WriteBlock(_realBlock); _realBlock.Clear(); var tb = _baseBlock; _baseBlock = _preBaseBlock; _preBaseBlock = tb; _preBaseBlock.Clear(); _source.LoadBlock(_preBaseBlock); _listRenderTask.RenderBasePointsBlock(_preBaseBlock); if (_viewRenderTask != null) { _viewRenderTask.RenderBasePointsBlock(_preBaseBlock); } } if (needNewList) { _listRenderTask.PrepareRenderItem(_realBlock); } if (_viewRenderTask != null && needNewView) { _viewRenderTask.PrepareRenderItem(_realBlock); } } _collector.Stop(); _listRenderTask.Finish(); if (_viewRenderTask != null) { _viewRenderTask.Finish(); } if (_statisticTask != null) { _statisticTask.Stop(); } _file.WriteBlock(_realBlock); if (_stopedCallback != null) { _stopedCallback(); } }
public Viewport(int blockId, int offset, StorageBlock storage) { _blockId = blockId; _offset = offset; _storageBlock = storage; }
private void ReadBlocksInfoAndDirectory(EndianBinaryReader reader) { byte[] blocksInfoBytes; if (m_Header.version >= 7) { reader.AlignStream(16); } if ((m_Header.flags & 0x80) != 0) //kArchiveBlocksInfoAtTheEnd { var position = reader.Position; reader.Position = reader.BaseStream.Length - m_Header.compressedBlocksInfoSize; blocksInfoBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize); reader.Position = position; } else //0x40 kArchiveBlocksAndDirectoryInfoCombined { blocksInfoBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize); } MemoryStream blocksInfoUncompresseddStream; var uncompressedSize = m_Header.uncompressedBlocksInfoSize; switch (m_Header.flags & 0x3F) //kArchiveCompressionTypeMask { default: //None { blocksInfoUncompresseddStream = new MemoryStream(blocksInfoBytes); break; } case 1: //LZMA { blocksInfoUncompresseddStream = new MemoryStream((int)(uncompressedSize)); using (var blocksInfoCompressedStream = new MemoryStream(blocksInfoBytes)) { SevenZipHelper.StreamDecompress(blocksInfoCompressedStream, blocksInfoUncompresseddStream, m_Header.compressedBlocksInfoSize, m_Header.uncompressedBlocksInfoSize); } blocksInfoUncompresseddStream.Position = 0; break; } case 2: //LZ4 case 3: //LZ4HC { var uncompressedBytes = new byte[uncompressedSize]; var numWrite = LZ4Codec.Decode(blocksInfoBytes, uncompressedBytes); if (numWrite != uncompressedSize) { throw new IOException($"Lz4 decompression error, write {numWrite} bytes but expected {uncompressedSize} bytes"); } blocksInfoUncompresseddStream = new MemoryStream(uncompressedBytes); break; } } using (var blocksInfoReader = new EndianBinaryReader(blocksInfoUncompresseddStream)) { var uncompressedDataHash = blocksInfoReader.ReadBytes(16); var blocksInfoCount = blocksInfoReader.ReadInt32(); m_BlocksInfo = new StorageBlock[blocksInfoCount]; for (int i = 0; i < blocksInfoCount; i++) { m_BlocksInfo[i] = new StorageBlock { uncompressedSize = blocksInfoReader.ReadUInt32(), compressedSize = blocksInfoReader.ReadUInt32(), flags = blocksInfoReader.ReadUInt16() }; } var nodesCount = blocksInfoReader.ReadInt32(); m_DirectoryInfo = new Node[nodesCount]; for (int i = 0; i < nodesCount; i++) { m_DirectoryInfo[i] = new Node { offset = blocksInfoReader.ReadInt64(), size = blocksInfoReader.ReadInt64(), flags = blocksInfoReader.ReadUInt32(), path = blocksInfoReader.ReadStringToNull(), }; } } }
private void ReadBlocksInfoAndDirectory(EndianBinaryReader reader) { byte[] blocksInfoBytes; if (m_Header.version >= 7) { reader.AlignStream(16); } if ((m_Header.flags & ArchiveFlags.BlocksInfoAtTheEnd) != 0) { var position = reader.Position; reader.Position = reader.BaseStream.Length - m_Header.compressedBlocksInfoSize; blocksInfoBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize); reader.Position = position; } else //0x40 BlocksAndDirectoryInfoCombined { blocksInfoBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize); } MemoryStream blocksInfoUncompresseddStream; var uncompressedSize = m_Header.uncompressedBlocksInfoSize; var compressionType = (CompressionType)(m_Header.flags & ArchiveFlags.CompressionTypeMask); switch (compressionType) { case CompressionType.None: { blocksInfoUncompresseddStream = new MemoryStream(blocksInfoBytes); break; } case CompressionType.Lzma: { blocksInfoUncompresseddStream = new MemoryStream((int)(uncompressedSize)); using (var blocksInfoCompressedStream = new MemoryStream(blocksInfoBytes)) { SevenZipHelper.StreamDecompress(blocksInfoCompressedStream, blocksInfoUncompresseddStream, m_Header.compressedBlocksInfoSize, m_Header.uncompressedBlocksInfoSize); } blocksInfoUncompresseddStream.Position = 0; break; } case CompressionType.Lz4: case CompressionType.Lz4HC: { var uncompressedBytes = new byte[uncompressedSize]; var numWrite = LZ4Codec.Decode(blocksInfoBytes, uncompressedBytes); if (numWrite != uncompressedSize) { throw new IOException($"Lz4 decompression error, write {numWrite} bytes but expected {uncompressedSize} bytes"); } blocksInfoUncompresseddStream = new MemoryStream(uncompressedBytes); break; } default: throw new IOException($"Unsupported compression type {compressionType}"); } using (var blocksInfoReader = new EndianBinaryReader(blocksInfoUncompresseddStream)) { var uncompressedDataHash = blocksInfoReader.ReadBytes(16); var blocksInfoCount = blocksInfoReader.ReadInt32(); m_BlocksInfo = new StorageBlock[blocksInfoCount]; for (int i = 0; i < blocksInfoCount; i++) { m_BlocksInfo[i] = new StorageBlock { uncompressedSize = blocksInfoReader.ReadUInt32(), compressedSize = blocksInfoReader.ReadUInt32(), flags = (StorageBlockFlags)blocksInfoReader.ReadUInt16() }; } var nodesCount = blocksInfoReader.ReadInt32(); m_DirectoryInfo = new Node[nodesCount]; for (int i = 0; i < nodesCount; i++) { m_DirectoryInfo[i] = new Node { offset = blocksInfoReader.ReadInt64(), size = blocksInfoReader.ReadInt64(), flags = blocksInfoReader.ReadUInt32(), path = blocksInfoReader.ReadStringToNull(), }; } } if ((m_Header.flags & ArchiveFlags.BlockInfoNeedPaddingAtStart) != 0) { reader.AlignStream(16); } }
private long ReadBlocksInfoAndDirectory(EndianBinaryReader varReader) { byte[] blocksInfoBytes; if (HeaderInfo.version >= 7) { varReader.AlignStream(16); } if ((HeaderInfo.flags & (int)ArchiveFlags.kArchiveBlocksInfoAtTheEnd) != 0) { var tempPosition = varReader.Position; { varReader.Position = varReader.BaseStream.Length - HeaderInfo.compressedBlocksInfoSize; blocksInfoBytes = varReader.ReadBytes((int)HeaderInfo.compressedBlocksInfoSize); } varReader.Position = tempPosition; } else //0x40 kArchiveBlocksAndDirectoryInfoCombined { blocksInfoBytes = varReader.ReadBytes((int)HeaderInfo.compressedBlocksInfoSize); } var blocksInfoCompressedStream = new MemoryStream(blocksInfoBytes); MemoryStream blocksInfoUncompresseddStream; switch (HeaderInfo.GetBlocksInfoCompressionType()) { default: //None { blocksInfoUncompresseddStream = blocksInfoCompressedStream; break; } case Compression.CompressionType.kCompressionLzma: { blocksInfoUncompresseddStream = new MemoryStream((int)(HeaderInfo.uncompressedBlocksInfoSize)); SevenZipHelper.StreamDecompress(blocksInfoCompressedStream, blocksInfoUncompresseddStream, HeaderInfo.compressedBlocksInfoSize, HeaderInfo.uncompressedBlocksInfoSize); blocksInfoUncompresseddStream.Position = 0; blocksInfoCompressedStream.Close(); break; } case Compression.CompressionType.kCompressionLz4: case Compression.CompressionType.kCompressionLz4HC: { var uncompressedBytes = new byte[HeaderInfo.uncompressedBlocksInfoSize]; using (var decoder = new Lz4DecoderStream(blocksInfoCompressedStream)) { decoder.Read(uncompressedBytes, 0, uncompressedBytes.Length); } blocksInfoUncompresseddStream = new MemoryStream(uncompressedBytes); break; } } using (var blocksInfoReader = new EndianBinaryReader(blocksInfoUncompresseddStream)) { var uncompressedDataHash = blocksInfoReader.ReadBytes(16); var blocksInfoCount = blocksInfoReader.ReadInt32(); BlocksInfo = new List <StorageBlock>(blocksInfoCount); for (int i = 0; i < blocksInfoCount; i++) { var tempBlock = new StorageBlock().Parse(blocksInfoReader); BlocksInfo.Add(tempBlock); } var nodesCount = blocksInfoReader.ReadInt32(); DirectoryInfo = new List <Node>(nodesCount); for (int i = 0; i < nodesCount; i++) { var tempDirInfo = new Node().Parse(blocksInfoReader); DirectoryInfo.Add(tempDirInfo); } } return(varReader.Position); }
private void ReadBlocksInfoAndDirectory(EndianBinaryReader reader) { byte[] blocksInfoBytes; if (m_Header.version >= 7) { reader.AlignStream(16); } if ((m_Header.flags & 0x80) != 0) //kArchiveBlocksInfoAtTheEnd { var position = reader.Position; reader.Position = reader.BaseStream.Length - m_Header.compressedBlocksInfoSize; blocksInfoBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize); reader.Position = position; } else //0x40 kArchiveBlocksAndDirectoryInfoCombined { blocksInfoBytes = reader.ReadBytes((int)m_Header.compressedBlocksInfoSize); } var blocksInfoCompressedStream = new MemoryStream(blocksInfoBytes); MemoryStream blocksInfoUncompresseddStream; switch (m_Header.flags & 0x3F) //kArchiveCompressionTypeMask { default: //None { blocksInfoUncompresseddStream = blocksInfoCompressedStream; break; } case 2: //LZ4 case 3: //LZ4HC { var uncompressedBytes = new byte[m_Header.uncompressedBlocksInfoSize]; using (var decoder = new Lz4DecoderStream(blocksInfoCompressedStream)) { decoder.Read(uncompressedBytes, 0, uncompressedBytes.Length); } blocksInfoUncompresseddStream = new MemoryStream(uncompressedBytes); break; } } using (var blocksInfoReader = new EndianBinaryReader(blocksInfoUncompresseddStream)) { var uncompressedDataHash = blocksInfoReader.ReadBytes(16); var blocksInfoCount = blocksInfoReader.ReadInt32(); m_BlocksInfo = new StorageBlock[blocksInfoCount]; uint offset = 0; for (int i = 0; i < blocksInfoCount; i++) { m_BlocksInfo[i] = new StorageBlock { offset = offset, uncompressedSize = blocksInfoReader.ReadUInt32(), compressedSize = blocksInfoReader.ReadUInt32(), flags = blocksInfoReader.ReadUInt16() }; offset += m_BlocksInfo[i].compressedSize; } var nodesCount = blocksInfoReader.ReadInt32(); m_DirectoryInfo = new Node[nodesCount]; for (int i = 0; i < nodesCount; i++) { m_DirectoryInfo[i] = new Node { offset = blocksInfoReader.ReadInt64(), size = blocksInfoReader.ReadInt64(), flags = blocksInfoReader.ReadUInt32(), path = blocksInfoReader.ReadStringToNull(), }; } } }
// Use this for initialization void Awake() { storage = GetComponent <StorageBlock>(); text = GetComponentInChildren <Text>(); }