public void Recycle()
{
BytesPool.Recycle(m_buffer);
m_bitsPointer = 0;
m_buffer = null;
Pool.Recycle(this);
}
/// <summary>
/// Returns an instance of NetworkBuffer, from the pool.
/// </summary>
/// <param name="size">The size of the underlayer array.</param>
/// <returns></returns>
public static Buffer Create(int size)
{
var buffer = Pool.Rent();
buffer.m_buffer = BytesPool.Get(size);
return(buffer);
}
public static byte[] SerializeObject <T>(T value, MessagePackFormatterOptions options)
{
var hGBytes = BytesPool.Rent();
SerializeObject(value, hGBytes, options);
var ret = hGBytes.ToArray();
BytesPool.Return(hGBytes);
return(ret);
}
SerializeAsync <T>(T value, Stream stream)
{
var hGBytes = BytesPool.Rent();
Serialize(value, hGBytes);
var bytes = hGBytes.ToArray();
BytesPool.Return(hGBytes);
await stream.WriteAsync(bytes, 0, bytes.Length);
}
public void RentAndDisposeTest()
{
var random = new Random();
var bytesPool = BytesPool.Create();
for (int i = 0; i < 32; i++)
{
int size = random.Next(1, 1024 * 1024 * 32);
using var buffer = bytesPool.Memory.Rent(size);
Assert.True(buffer.Memory.Length >= size);
}
}
SerializeObjectAsync <T>(T value, Stream stream, MessagePackFormatterOptions options)
{
var hGBytes = BytesPool.Rent();
SerializeObject(value, hGBytes, options);
var bytes = hGBytes.ToArray();
BytesPool.Return(hGBytes);
await stream.WriteAsync(bytes, 0, bytes.Length);
}
public static byte[] SerializeObject <T>(T value)
{
var hGBytes = BytesPool.Rent();
SerializeObject(value, hGBytes);
var ret = hGBytes.ToArray();
BytesPool.Return(hGBytes);
return(ret);
}
private void EnsureBufferSpace(int additionalSpaceInBits)
{
var length = m_buffer.Length;
if (m_bitsPointer + additionalSpaceInBits > length << 3)
{
var tmpBuffer = m_buffer;
var newBuffer = BytesPool.Get((int)(length * GrowingFactor) + 1);
System.Buffer.BlockCopy(tmpBuffer, 0, newBuffer, 0, tmpBuffer.Length);
BytesPool.Recycle(m_buffer);
m_buffer = newBuffer;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PixelArea{TColor}"/> class.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="componentOrder">The component order.</param>
/// <param name="padding">The number of bytes to pad each row.</param>
public PixelArea(int width, int height, ComponentOrder componentOrder, int padding)
{
this.Width = width;
this.Height = height;
this.ComponentOrder = componentOrder;
this.RowStride = (width * GetComponentCount(componentOrder)) + padding;
this.Length = this.RowStride * height;
this.Bytes = BytesPool.Rent(this.Length);
this.isBufferRented = true;
this.pixelsHandle = GCHandle.Alloc(this.Bytes, GCHandleType.Pinned);
// TODO: Why is Resharper warning us about an impure method call?
this.dataPointer = this.pixelsHandle.AddrOfPinnedObject();
this.PixelBase = (byte *)this.dataPointer.ToPointer();
}
/// <summary>
/// Returns an instance of NetworkBuffer, from the pool.
/// It is initialized with the passed data.
/// </summary>
/// <param name="data">The data to initialize the buffer.</param>
/// <param name="createCopy">If true, data will be copied in a new array; else data will be used as internal buffer.</param>
/// <returns></returns>
public static Buffer Create(byte[] data, bool createCopy = true)
{
var buffer = Pool.Rent();
if (createCopy)
{
buffer.m_buffer = BytesPool.Get(data.Length);
System.Buffer.BlockCopy(data, 0, buffer.m_buffer, 0, data.Length);
}
else
{
buffer.m_buffer = data;
}
return(buffer);
}
public virtual void notifyConstructDone()
{
mGameFramework = GameFramework.mGameFramework;
mCommandSystem = mGameFramework.getSystem(Typeof <CommandSystem>()) as CommandSystem;
mAudioManager = mGameFramework.getSystem(Typeof <AudioManager>()) as AudioManager;
mGameSceneManager = mGameFramework.getSystem(Typeof <GameSceneManager>()) as GameSceneManager;
mCharacterManager = mGameFramework.getSystem(Typeof <CharacterManager>()) as CharacterManager;
mLayoutManager = mGameFramework.getSystem(Typeof <LayoutManager>()) as LayoutManager;
mKeyFrameManager = mGameFramework.getSystem(Typeof <KeyFrameManager>()) as KeyFrameManager;
mGlobalTouchSystem = mGameFramework.getSystem(Typeof <GlobalTouchSystem>()) as GlobalTouchSystem;
mShaderManager = mGameFramework.getSystem(Typeof <ShaderManager>()) as ShaderManager;
#if !UNITY_IOS && !NO_SQLITE
mSQLite = mGameFramework.getSystem(Typeof <SQLite>()) as SQLite;
#endif
mDataBase = mGameFramework.getSystem(Typeof <DataBase>()) as DataBase;
mCameraManager = mGameFramework.getSystem(Typeof <CameraManager>()) as CameraManager;
mResourceManager = mGameFramework.getSystem(Typeof <ResourceManager>()) as ResourceManager;
mApplicationConfig = mGameFramework.getSystem(Typeof <ApplicationConfig>()) as ApplicationConfig;
mFrameConfig = mGameFramework.getSystem(Typeof <FrameConfig>()) as FrameConfig;
mObjectPool = mGameFramework.getSystem(Typeof <ObjectPool>()) as ObjectPool;
mInputManager = mGameFramework.getSystem(Typeof <InputManager>()) as InputManager;
mSceneSystem = mGameFramework.getSystem(Typeof <SceneSystem>()) as SceneSystem;
mClassPool = mGameFramework.getSystem(Typeof <ClassPool>()) as ClassPool;
mClassPoolThread = mGameFramework.getSystem(Typeof <ClassPoolThread>()) as ClassPoolThread;
mListPool = mGameFramework.getSystem(Typeof <ListPool>()) as ListPool;
mListPoolThread = mGameFramework.getSystem(Typeof <ListPoolThread>()) as ListPoolThread;
mDictionaryPool = mGameFramework.getSystem(Typeof <DictionaryPool>()) as DictionaryPool;
mDictionaryPoolThread = mGameFramework.getSystem(Typeof <DictionaryPoolThread>()) as DictionaryPoolThread;
mBytesPool = mGameFramework.getSystem(Typeof <BytesPool>()) as BytesPool;
mBytesPoolThread = mGameFramework.getSystem(Typeof <BytesPoolThread>()) as BytesPoolThread;
mAndroidPluginManager = mGameFramework.getSystem(Typeof <AndroidPluginManager>()) as AndroidPluginManager;
mAndroidAssetLoader = mGameFramework.getSystem(Typeof <AndroidAssetLoader>()) as AndroidAssetLoader;
mHeadTextureManager = mGameFramework.getSystem(Typeof <HeadTextureManager>()) as HeadTextureManager;
mTimeManager = mGameFramework.getSystem(Typeof <TimeManager>()) as TimeManager;
mMovableObjectManager = mGameFramework.getSystem(Typeof <MovableObjectManager>()) as MovableObjectManager;
mEffectManager = mGameFramework.getSystem(Typeof <EffectManager>()) as EffectManager;
mTPSpriteManager = mGameFramework.getSystem(Typeof <TPSpriteManager>()) as TPSpriteManager;
mSocketFactory = mGameFramework.getSystem(Typeof <SocketFactory>()) as SocketFactory;
mSocketFactoryThread = mGameFramework.getSystem(Typeof <SocketFactoryThread>()) as SocketFactoryThread;
mPathKeyframeManager = mGameFramework.getSystem(Typeof <PathKeyframeManager>()) as PathKeyframeManager;
mEventSystem = mGameFramework.getSystem(Typeof <EventSystem>()) as EventSystem;
mStringBuilderPool = mGameFramework.getSystem(Typeof <StringBuilderPool>()) as StringBuilderPool;
mStringBuilderPoolThread = mGameFramework.getSystem(Typeof <StringBuilderPoolThread>()) as StringBuilderPoolThread;
#if USE_ILRUNTIME
mILRSystem = mGameFramework.getSystem(Typeof <ILRSystem>()) as ILRSystem;
#endif
}
public static void SerializeObject <T>(T value, Stream stream, MessagePackFormatterOptions options)
{
var hGBytes = BytesPool.Rent();
if ((options & ReferenceSerializerOptions) != 0)
{
SerializeObject <T, MessagePackSerializeModes.ReferenceMode>(value, hGBytes, options);
}
else
{
SerializeObject <T, MessagePackSerializeModes.StandardMode>(value, hGBytes, options);
}
hGBytes.WriteTo(stream);
BytesPool.Return(hGBytes);
}
/// <summary>
/// 以前 4 个字节作为头部协议号
/// </summary>
/// <param name="message"></param>
/// <param name="msgId"></param>
/// <returns></returns>
public static byte[] GetSendBytes(object message, int msgId)
{
byte[] messageBytes = serializer.Serialize(message);
var tempBytes = BitConverter.GetBytes(msgId);
byte[] msgIdBytes = tempBytes.GetHeadBytes();
byte[] finalBytes = BytesPool.Take(4 + messageBytes.Length);
for (int i = 0; i < 4; i++)
{
finalBytes[i] = msgIdBytes[i];
}
for (int i = 0; i < messageBytes.Length; i++)
{
finalBytes[i + 4] = messageBytes[i];
}
return(finalBytes);
}
public byte[] Handle(byte[] receiveBytes)
{
// todo
var bytes = BytesPool.Take(receiveBytes.Length + 4);
//var bytes = new byte[receiveBytes.Length + 4];
var lengthBytes = BitConverter.GetBytes(receiveBytes.Length);
for (int i = 0; i < 4; i++)
{
bytes[i] = lengthBytes[3 - i];
}
for (int i = 0; i < receiveBytes.Length; i++)
{
bytes[i + 4] = receiveBytes[i];
}
return(bytes);
}
/// <summary>
/// 调用消息对应的消息处理器
/// </summary>
/// <param name="messageId"></param>
/// <param name="message"></param>
private void InvokeRespHandler(int messageId, byte[] message)
{
var respHandler = respHandlerDic[messageId];
var redicretId = -1;
redicretId = RedirectResp.ContainsKey(messageId) ? RedirectResp[messageId] : messageId;
if (!respHandlerDic.ContainsKey(redicretId))
{
#if DEBUG
Debug.LogError($"消息编号{messageId}的消息没有对应的答复处理器存在！");
#endif
return;
}
var handler = respHandlerDic[redicretId];
handler.ReceiveMessage(message);
BytesPool.Restore(message);
}
/// <summary>
/// 接收消息分发方法，在 Unity FixedUpdate 中调用
/// </summary>
private void MessageDispatch()
{
foreach (var channel in netModule.ChannelDic.Values)
{
if (channel.MessageStorage.ReceiveCount == 0)
{
continue;
}
for (int i = 0; i < channel.MessageStorage.ReceiveCount; i++)
{
var bytes = channel.MessageStorage.GetReceiveMessage();
var messageIdBytes = bytes.GetHeadBytes();
var messageId = BitConverter.ToInt32(messageIdBytes, 0);
var messageBodyLength = bytes.Length - 4;
var finalBytes = BytesPool.Take(messageBodyLength);
Buffer.BlockCopy(bytes, 4, finalBytes, 0, messageBodyLength);
BytesPool.Restore(bytes);
InvokeRespHandler(messageId, finalBytes);
}
}
}
/// <summary>
/// 异步将 Stream 的内容缓存到 HGlobalCache 中。
/// </summary>
/// <param name="hGCache">HGlobalCache</param>
/// <param name="stream">Stream</param>
/// <param name="encoding">编码</param>
/// <returns>返回缓冲的长度</returns>
public static async Task ReadFromAsync(this HGlobalCache <char> hGCache, Stream stream, Encoding encoding)
{
var hGBytes = BytesPool.Rent();
await hGBytes.ReadFromAsync(stream);
var maxCharsCount = encoding.GetMaxCharCount(hGBytes.Count);
if (maxCharsCount > hGCache.Capacity)
{
hGCache.Expand(maxCharsCount - hGCache.Capacity);
}
unsafe
{
hGCache.Count = encoding.GetChars(
hGBytes.GetPointer(),
hGBytes.Count,
hGCache.GetPointer(),
hGCache.Capacity);
}
BytesPool.Return(hGBytes);
}
/// <summary>
/// 异步将 HGlobalCache 中的内容写入到流中。
/// </summary>
/// <param name="hGCache">HGlobalCache</param>
/// <param name="stream">流</param>
/// <param name="encoding">编码</param>
public static async Task WriteToAsync(this HGlobalCache <char> hGCache, Stream stream, Encoding encoding)
{
var hGBytes = BytesPool.Rent();
var maxBytesCount = encoding.GetMaxByteCount(hGCache.Count);
if (maxBytesCount > hGBytes.Capacity)
{
hGBytes.Expand(maxBytesCount - hGBytes.Capacity);
}
unsafe
{
hGBytes.Count = encoding.GetBytes(
hGCache.GetPointer(),
hGCache.Count,
hGBytes.GetPointer(),
hGBytes.Capacity);
}
await hGBytes.WriteToAsync(stream);
BytesPool.Return(hGBytes);
}
