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>();
}
