public bool Read(ref R reader, ref T obj, ref T template)
{
unsafe
{
T result = new T();
fixed(T *lh = &obj)
fixed(T * rh = &template)
{
UInt16 size = 0;
reader.Read(out size);
if (size >= 2 * sizeof(T))
{
return(false);
}
byte *buffer = stackalloc byte[size];
reader.ReadPtr(buffer, size);
var toSize = CoreSDK.SDK_UnCompress_RLE(buffer, (UInt32)size, null);
if (toSize != sizeof(T))
{
return(false);
}
CoreSDK.SDK_UnCompress_RLE(buffer, (UInt32)size, (byte *)&result);
CoreSDK.SDK_ByteArray_Add((byte *)&result, (byte *)rh, (byte *)lh, sizeof(T));
return(true);
}
}
}
public T this[int index]
{
get
{
T result = default(T);
var ptr = mImpl.AddressAt(index);
if (ptr == IntPtr.Zero)
{
return(result);
}
unsafe
{
CoreSDK.SDK_Memory_Copy(&result, ptr.ToPointer(), (UInt32)mStructSize);
}
return(result);
}
set
{
var ptr = mImpl.AddressAt(index);
if (ptr == IntPtr.Zero)
{
return;
}
unsafe
{
CoreSDK.SDK_Memory_Copy(ptr.ToPointer(), &value, (UInt32)mStructSize);
}
}
}
public override void SendBuffer(IntPtr ptr, int count)
{
#warning 这里性能问题严重，需要以后处理
//这里性能问题严重，需要以后处理
byte[] temp = new byte[count];
unsafe
{
var pHeader = (NetCore.PkgHeader *)ptr;
pHeader->PackageSize = (ushort)count;
fixed(byte *dest = &temp[0])
{
CoreSDK.SDK_Memory_Copy(dest, (void *)ptr, (UInt32)count);
}
}
Session.Send(temp, 0, count);
}
public unsafe bool PushData(byte *p, int len)
{
if (len < 0)
{
return(false);
}
if (Size + len >= Buffers.Length)
return(false);
fixed(byte *tar = &Buffers[Size])
{
CoreSDK.SDK_Memory_Copy(tar, p, (uint)len);
}
Size += len;
return(true);
}
public int Write(ref W writer, ref T obj, ref T template)
{
unsafe
{
T sub = new T();
fixed(T *lh = &obj)
fixed(T * rh = &template)
{
CoreSDK.SDK_ByteArray_Sub((byte *)lh, (byte *)rh, (byte *)&sub, sizeof(T));
UInt16 size = (UInt16)CoreSDK.SDK_Compress_RLE((byte *)&sub, (UInt32)sizeof(T), null);
byte * buffer = stackalloc byte[size];
CoreSDK.SDK_Compress_RLE((byte *)&sub, (UInt32)sizeof(T), buffer);
writer.Write(size);
writer.WritePtr(buffer, size);
return(size);
}
}
}
public override void SendBuffer(IntPtr ptr, int count)
{
unsafe
{
var pHeader = (RPCHeader *)ptr;
pHeader->PackageSize = (ushort)count;
}
lock (mSendingBuffer)
{
var buffer = mSendingBuffer;
if (buffer.mPos1 + count > buffer.mBuffer.Length)
{
while (mIsSendFinish == 1)
{
break;
}
//InternalSend();
}
//lock (mSendBufferQueue)
//{
unsafe
{
fixed(byte *dest = &buffer.mBuffer[buffer.mPos1])
{
CoreSDK.SDK_Memory_Copy(dest, (void *)ptr, (UInt32)count);
}
}
//Array.Copy(data, offset, buffer.mBuffer, buffer.mPos1, count);
buffer.mPos1 += count;
//}
}
//if (System.Threading.Interlocked.CompareExchange(ref mIsSendFinish, 0, 1) == 1)
//{
// InternalSend();
//}
}
private void Init(PkgPoolManager mgr, byte[] src, int len)
{
if (len >= UInt16.MaxValue)
{
PkgData = new byte[len];
}
else
{
PkgMgr = mgr;
PkgData = mgr.AllocPkg((UInt16)len);
}
Length = len;
RecvTime = Support.Time.GetTickCount();
unsafe
{
//Buffer.BlockCopy(src, 0, PkgData, 0, (int)len);
fixed(byte *ps = &src[0])
fixed(byte *dest = &PkgData[0])
{
CoreSDK.SDK_Memory_Copy(dest, ps, (UInt32)len);
}
}
}
public unsafe void UpdateGpuBufferVTF(CRenderContext rc, EngineNS.CCommandList cmd, Graphics.CGfxCamera Camera)
{
CTexture2DDesc desc = new CTexture2DDesc();
desc.Init();
var spDesc = new CSamplerStateDesc();
spDesc.SetDefault();
spDesc.Filter = ESamplerFilter.SPF_MIN_MAG_MIP_POINT;
mSamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(rc, spDesc);
int vertStride = sizeof(Cluster.GpuSceneVertex);
int size = mAllVertices.Count * vertStride;
int side = (int)Math.Sqrt((float)size) + 1;
desc.Width = 512;
desc.Height = 512;
desc.MipLevels = 1;
desc.Format = EPixelFormat.PXF_R32G32B32A32_FLOAT;
mVertexTexture = rc.CreateTexture2D(desc);
CShaderResourceViewDesc srvDesc = new CShaderResourceViewDesc();
srvDesc.mFormat = desc.Format;
srvDesc.mTexture2D = mVertexTexture.CoreObject;
mVertexTextureView = rc.CreateShaderResourceView(srvDesc);
mVertexTextureView.ResourceState.StreamState = EStreamingState.SS_Valid;
{
var copyArray = mAllVertices.ToArray();
fixed(Vector4 *p = &mVertexTexData[0])
fixed(Cluster.GpuSceneVertex * v = ©Array[0])
{
CoreSDK.SDK_Memory_Copy(p, v, (uint)size);
mVertexTexture.UpdateMipData(cmd, 0, p, 512, 512, 512 * 4 * 4);
}
}
int InstStride = sizeof(GpuMeshInstanceData);
size = mGpuInstanceDatas.Count * InstStride;
side = (int)Math.Sqrt((float)size) + 1;
desc.Width = 256;
desc.Height = 256;
desc.MipLevels = 1;
desc.Format = EPixelFormat.PXF_R32G32B32A32_FLOAT;
mInstanceDataTexture = rc.CreateTexture2D(desc);
srvDesc.mFormat = desc.Format;
srvDesc.mTexture2D = mInstanceDataTexture.CoreObject;
mInstanceDataTextureView = rc.CreateShaderResourceView(srvDesc);
mInstanceDataTextureView.ResourceState.StreamState = EStreamingState.SS_Valid;
{
var copyArray = mGpuInstanceDatas.ToArray();
fixed(Vector4 *p = &mInstTexData[0])
fixed(GpuMeshInstanceData * v = ©Array[0])
{
CoreSDK.SDK_Memory_Copy(p, v, (uint)size);
mInstanceDataTexture.UpdateMipData(cmd, 0, p, 256, 256, 256 * 4 * 4);
}
}
}
public void PushInstance(ref Vector3 pos, ref Vector3 scale, ref Quaternion quat, ref UInt32_4 f41, int lightNum)
{
var rc = CEngine.Instance.RenderContext;
if (mCurSize == mMaxNumber)
{
var savedNum = mMaxNumber;
mMaxNumber = mCurSize * 2;
VSInstantData[] newInstData = null;
Vector3[] newPos = null;
Vector4[] newScale = null;
Quaternion[] newQuat = null;
UInt32_4[] newF41 = null;
if (CRenderContext.ShaderModel >= 4)
{
newInstData = new VSInstantData[mMaxNumber];
}
else
{
newPos = new Vector3[mMaxNumber];
newScale = new Vector4[mMaxNumber];
newQuat = new Quaternion[mMaxNumber];
newF41 = new UInt32_4[mMaxNumber];
}
unsafe
{
if (CRenderContext.ShaderModel >= 4)
{
fixed(VSInstantData *src = &mInstDataArray[0])
fixed(VSInstantData * dest = &newInstData[0])
{
CoreSDK.SDK_Memory_Copy(dest, src, (UInt32)(sizeof(VSInstantData) * savedNum));
}
var bfDesc = new CGpuBufferDesc();
bfDesc.SetMode(true, false);
bfDesc.ByteWidth = (uint)(mMaxNumber * sizeof(VSInstantData));
bfDesc.StructureByteStride = (uint)sizeof(VSInstantData);
mInstDataBuffer = rc.CreateGpuBuffer(bfDesc, IntPtr.Zero);
var srvDesc = new ISRVDesc();
srvDesc.ToDefault();
srvDesc.ViewDimension = EResourceDimension.RESOURCE_DIMENSION_BUFFER;
srvDesc.Buffer.ElementOffset = 0;
srvDesc.Buffer.NumElements = (uint)mMaxNumber;
mInstDataView = rc.CreateShaderResourceViewFromBuffer(mInstDataBuffer, srvDesc);
mAttachSRVs.VSBindTexture(13, mInstDataView);
}
else
{
fixed(Vector3 *src = &mPosData[0])
fixed(Vector3 * dest = &newPos[0])
{
CoreSDK.SDK_Memory_Copy(dest, src, (UInt32)(sizeof(Vector3) * savedNum));
}
fixed(Vector4 *src = &mScaleData[0])
fixed(Vector4 * dest = &newScale[0])
{
CoreSDK.SDK_Memory_Copy(dest, src, (UInt32)(sizeof(Vector3) * savedNum));
}
fixed(Quaternion *src = &mRotateData[0])
fixed(Quaternion * dest = &newQuat[0])
{
CoreSDK.SDK_Memory_Copy(dest, src, (UInt32)(sizeof(Quaternion) * savedNum));
}
fixed(UInt32_4 *src = &mF41Data[0])
fixed(UInt32_4 * dest = &newF41[0])
{
CoreSDK.SDK_Memory_Copy(dest, src, (UInt32)(sizeof(UInt32_4) * savedNum));
}
CVertexBufferDesc desc = new CVertexBufferDesc();
desc.ByteWidth = (UInt32)(sizeof(Vector3) * mMaxNumber);
desc.Stride = (UInt32)sizeof(Vector3);
mPosVB = rc.CreateVertexBuffer(desc);
desc.ByteWidth = (UInt32)(sizeof(Vector4) * mMaxNumber);
desc.Stride = (UInt32)sizeof(Vector4);
mScaleVB = rc.CreateVertexBuffer(desc);
desc.ByteWidth = (UInt32)(sizeof(Quaternion) * mMaxNumber);
desc.Stride = (UInt32)sizeof(Quaternion);
mRotateVB = rc.CreateVertexBuffer(desc);
desc.ByteWidth = (UInt32)(sizeof(Vector4) * mMaxNumber);
desc.Stride = (UInt32)sizeof(Vector4);
mF41VB = rc.CreateVertexBuffer(desc);
mAttachVBs.BindVertexBuffer(EVertexSteamType.VST_InstPos, mPosVB);
mAttachVBs.BindVertexBuffer(EVertexSteamType.VST_InstScale, mScaleVB);
mAttachVBs.BindVertexBuffer(EVertexSteamType.VST_InstQuat, mRotateVB);
mAttachVBs.BindVertexBuffer(EVertexSteamType.VST_F4_1, mF41VB);
}
}
mInstDataArray = newInstData;
mPosData = newPos;
mScaleData = newScale;
mRotateData = newQuat;
mF41Data = newF41;
}
if (CRenderContext.ShaderModel >= 4)
{
mInstDataArray[mCurSize].WorldMatrix = Matrix.Transformation(scale, quat, pos);
mInstDataArray[mCurSize].WorldMatrix.Transpose();
mInstDataArray[mCurSize].CustomData.x = (uint)lightNum;
mInstDataArray[mCurSize].PointLightIndices = f41;
}
else
{
mPosData[mCurSize] = pos;
mScaleData[mCurSize].X = scale.X;
mScaleData[mCurSize].Y = scale.Y;
mScaleData[mCurSize].Z = scale.Z;
mScaleData[mCurSize].W = lightNum;
mRotateData[mCurSize] = quat;
mF41Data[mCurSize] = f41;
}
mCurSize++;
}
