public async System.Threading.Tasks.Task <R> DoAwaitCall(T arg, long timeOut,
NetCore.ERouteTarget route = NetCore.ERouteTarget.Self,
NetCore.NetConnection conn = null,
NetCore.RPCRouter router = null,
byte userFlags = 0)
{
if (conn == null)
{
conn = RPCProcessor.DefaultConnection;
}
var pkg = new NetCore.PkgWriter(arg.GetPkgSize());
pkg.SetUserFlags(userFlags);
RPCExecuter.RPCWait waiter = null;
try
{
waiter = WritePkgHeader <T>(ref pkg, ref arg, timeOut, RPCAwaiter.NullCB, route, conn, router);
OnWriteArugment(ref arg, ref pkg);
if (conn != null)
{
pkg.SendBuffer(conn);
}
}
finally
{
pkg.Dispose();
}
waiter.Processor = this;
var result = await RPCAwaiter.RPCWaitReturn <R>(waiter);
return(result);
}
public void DoHashCall(ref T arg,
NetCore.ERouteTarget route = NetCore.ERouteTarget.Self,
NetCore.NetConnection conn = null,
NetCore.RPCRouter router = null,
byte userFlags = 0)
{
if (conn == null)
{
conn = RPCProcessor.DefaultConnection;
}
var pkg = new NetCore.PkgWriter(arg.GetPkgSize());
pkg.SetUserFlags(userFlags);
try
{
WritePkgHeader_Hash <T>(ref pkg, ref arg, 0, null, route, conn, router);
OnWriteArugment(ref arg, ref pkg);
if (conn != null)
{
pkg.SendBuffer(conn);
}
}
finally
{
pkg.Dispose();
}
}
public void Reset()
{
RouteInfo.Reset();
C2GConnect = null;
ToGConnect = null;
ToHConnect = null;
}
public void OnC2S_ReportProfiler(byte userFlags, ref C2S_ReportProfiler.ArgumentData profiler, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
if (OnReciveReportPerfCounter != null)
{
if (ProfilerTarget == profiler.ReporterName)
{
OnReciveReportPerfCounter(profiler.ReporterName, profiler.Scopes, profiler.Datas);
ProfilerConnect = connect;
}
}
}
public void SendBuffer(NetCore.NetConnection conn)
{
if (CurPtr() < 65535 - 2)
{
if (conn != null && conn.Connected == true)
{
conn.SendBuffer(this.Ptr, CurPtr());
}
}
else
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "RPC", "Error!!SendBuffer mPos>=65535-2");
}
}
public void DoReturn(ref R arg, UInt16 serialId, NetCore.NetConnection connect)
{
var pkg = new NetCore.PkgWriter(arg.GetPkgSize());
try
{
byte route = (byte)NetCore.ERouteTarget.Self | (byte)NetCore.ERouteTarget.ReturnFlag;
pkg.Write((byte)route);
pkg.Write(serialId);
OnWriteReturn(ref pkg, ref arg);
pkg.SendBuffer(connect);
}
finally
{
pkg.Dispose();
}
}
//protected async Task<R> C2S_AwaitCall<R,T>(T arg, long timeOut, ERouteTarget route = ERouteTarget.Hall)
// where R : struct, IReturnValue
// where T : struct, IArgument
//{
// AssertReturnType(this.GetType(), typeof(R));
// if (route == ERouteTarget.Gate)
// route = ERouteTarget.Self;
// RPCExecuter.RPCWait waiter = null;
// if (timeOut == 0)
// waiter = WaitDoCallImpl<T>(ref arg, 0, null, route, RPCExecuter.Instance.C2SConnect);
// else
// waiter = WaitDoCallImpl<T>(ref arg, timeOut, RPCAwaiter.NullCB, route, RPCExecuter.Instance.C2SConnect);
// var result = await RPCAwaiter.RPCWaitReturn<R>(waiter);
// return result;
//}
//protected RPCExecuter.RPCWait C2S_Call<R, T>(ref T arg, long timeOut, ERouteTarget route = ERouteTarget.Hall, FRPCTypeReturnCallBack<R> cb = null)
// where R : struct, IReturnValue
// where T : struct, IArgument
//{
// AssertReturnType(this.GetType(), typeof(R));
// if (route == ERouteTarget.Gate)
// route = ERouteTarget.Self;
// if (cb == null)
// return WaitDoCallImpl<T>(ref arg, 0, null, route, RPCExecuter.Instance.C2SConnect);
// RPCExecuter.FRPCReturnCallBack fn = (PkgReader data, bool isTimeOut) =>
// {
// if (isTimeOut)
// {
// cb(default(R), true);
// return;
// }
// R retValue = new R();
// IO.Serializer.SerializerHelper.ReadObject(retValue, data);
// cb(retValue, false);
// };
// return WaitDoCallImpl<T>(ref arg, timeOut, fn, route, RPCExecuter.Instance.C2SConnect);
//}
//protected RPCExecuter.RPCWait S2C_Call<T>(ref T arg, RPCRouter router, ERouteTarget sender = ERouteTarget.Unknown)
// where T : struct, IArgument
//{
// if (sender == ERouteTarget.Unknown)
// {
// //sender = RPCExecuter.Instance.AppTarget;
// sender = ERouteTarget.Self;
// }
// switch (sender)
// {
// case ERouteTarget.Gate:
// return WaitDoCallImpl<T>(ref arg, 0, null, ERouteTarget.Self, router.C2GConnect);
// case ERouteTarget.Hall:
// return WaitDoCallImpl<T>(ref arg, 0, null, ERouteTarget.Client, router.ToGConnect, router);
// case ERouteTarget.Keep:
// return WaitDoCallImpl<T>(ref arg, 0, null, ERouteTarget.Client, router.ToGConnect, router);
// case ERouteTarget.Data:
// return WaitDoCallImpl<T>(ref arg, 0, null, ERouteTarget.Client, router.ToGConnect, router);
// case ERouteTarget.Reg:
// return WaitDoCallImpl<T>(ref arg, 0, null, ERouteTarget.Client, router.ToGConnect, router);
// default:
// return null;
// }
//}
//protected async Task<R> S2S_AwaitCall<R, T>(T arg, long timeOut, ERouteTarget target = ERouteTarget.Data)
// where R : struct, IReturnValue
// where T : struct, IArgument
//{
// AssertReturnType(this.GetType(), typeof(R));
// RPCExecuter.RPCWait writer = null;
// if (timeOut == 0)
// writer = WaitDoCallImpl<T>(ref arg, timeOut, null, ERouteTarget.Self, RPCExecuter.Instance.GetServerConnect(target));
// else
// writer = WaitDoCallImpl<T>(ref arg, timeOut, RPCAwaiter.NullCB, ERouteTarget.Self, RPCExecuter.Instance.GetServerConnect(target));
// var result = await RPCAwaiter.RPCWaitReturn<R>(writer);
// return result;
//}
//protected RPCExecuter.RPCWait S2S_Call<R,T>(ref T arg, long timeOut, ERouteTarget target = ERouteTarget.Data, FRPCTypeReturnCallBack<R> cb = null)
// where R : struct, IReturnValue
// where T : struct, IArgument
//{
// AssertReturnType(this.GetType(), typeof(R));
// if (cb == null)
// {
// return WaitDoCallImpl<T>(ref arg, timeOut, null, ERouteTarget.Self, RPCExecuter.Instance.GetServerConnect(target));
// }
// RPCExecuter.FRPCReturnCallBack fn = (PkgReader data, bool isTimeOut) =>
// {
// if (isTimeOut)
// {
// cb(default(R), true);
// return;
// }
// R retValue = new R();
// IO.Serializer.SerializerHelper.ReadObject(retValue, data);
// cb(retValue, false);
// };
// return WaitDoCallImpl<T>(ref arg, timeOut, fn, ERouteTarget.Self, RPCExecuter.Instance.GetServerConnect(target));
//}
#endregion
#region Pkg Implement
protected RPCExecuter.RPCWait WritePkgHeader <T>(ref NetCore.PkgWriter pkg, ref T arg, long timeOut, RPCExecuter.FRPCReturnCallBack cb,
NetCore.ERouteTarget route, NetCore.NetConnection conn, NetCore.RPCRouter router) where T : IArgument
{
var Index = RPCIndex;
if (Index >= RPCExecuter.MaxRPC)
{
System.Diagnostics.Debug.WriteLine($"RPC Index is invalid:{this.GetType().FullName}");
return(null);
}
pkg.Write((byte)route);
if (router != null)
{
router.RouteInfo.Save(ref pkg, route);
}
RPCExecuter.RPCWait waiter = null;
if (cb != null)
{
waiter = RPCExecuter.Instance.AddCalBack(cb);
pkg.Waiter = waiter;
if (timeOut < 0)
{
timeOut = long.MaxValue;
}
waiter.Timout = timeOut;
Index |= RPCExecuter.WaitFlag;
pkg.SetHasReturn(true);
pkg.Write(Index);
pkg.Write(waiter.SerialId);
}
else
{
pkg.SetHasReturn(false);
pkg.Write(Index);
}
return(waiter);
}
protected override object OnCallMethod(object host, byte userFlags, ref ArgumentData arg, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
var rsh = (RemoteServicesHelper)host;
rsh.OnS2C_Shadow(userFlags, ref arg, serialId, connect, ref routeInfo);
return(null);
}
public void OnS2C_InstanceRender(byte userFlags, ref S2C_InstanceRender.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.UseInstancing = cmd.Instancing;
}
public void ReceiveData(NetCore.NetConnection sender, byte[] pData, int nLength, Int64 recvTime)
{
unsafe
{
if (nLength < sizeof(NetCore.PkgHeader))
{
return;
}
}
var router = sender.Router as NetCore.RPCRouter;
if (router == null)
{
System.Diagnostics.Debug.WriteLine($"connect bind a invalid data");
return;
}
var pkg = new NetCore.PkgReader(pData, nLength, recvTime);
try
{
if (PkgRcver != null)
{
PkgRcver.OnReceivePackage(sender, pkg);
}
byte route = 0;
pkg.Read(out route);
var isReturn = (route & (byte)NetCore.ERouteTarget.ReturnFlag) != 0 ? true : false;
route = (byte)(route & (byte)NetCore.ERouteTarget.ReturnMask);
var target = (NetCore.ERouteTarget)route;
switch (target)
{
case NetCore.ERouteTarget.Self:
{
if (isReturn)
{
UInt16 serialId = 0;
pkg.Read(out serialId);
DoCallBack(serialId, ref pkg);
}
else
{
Execute(ref pkg, sender, ref router.RouteInfo);
}
}
break;
case NetCore.ERouteTarget.Routed:
{
var routeInfo = new NetCore.RPCRouter.RouteData();
routeInfo.Load(ref pkg);
Execute(ref pkg, sender, ref routeInfo);
}
break;
case NetCore.ERouteTarget.Client:
{ //只有GateServer才有转发到客户端的需求
#if Server
var routePkg = new PkgWriter();
var routeInfo = new RPCRouter.RouteData();
try
{
routeInfo.Load(pkg);
if (Titan3D.Server.IGateServer.Instance != null)
{
if (isReturn)
{
route = (byte)((byte)ERouteTarget.Self | (byte)ERouteTarget.ReturnFlag);
routePkg.Write(route);
UInt16 seriaId;
pkg.Read(out seriaId);
routePkg.Write(seriaId);
}
else
{
route = (byte)ERouteTarget.Self;
routePkg.Write(route);
}
routePkg.AppendPkg(pkg, pkg.GetPosition());
routePkg.SendBuffer(Titan3D.Server.IGateServer.Instance.GetClientConnect(routeInfo.RouteSlot));
}
}
finally
{
routePkg.Dispose();
}
#endif
}
break;
case NetCore.ERouteTarget.Hall:
{
var routePkg = new NetCore.PkgWriter(nLength + 64);
try
{
routePkg.Write((byte)NetCore.ERouteTarget.Routed);
router.RouteInfo.Save(ref routePkg, NetCore.ERouteTarget.Hall);
routePkg.SetFlags(pkg.GetFlags());
routePkg.AppendPkg(pkg, pkg.GetPosition());
routePkg.SendBuffer(RouterTargetConnect(target, router));
}
finally
{
routePkg.Dispose();
}
}
break;
case NetCore.ERouteTarget.Data:
case NetCore.ERouteTarget.Keep:
case NetCore.ERouteTarget.Reg:
case NetCore.ERouteTarget.Path:
case NetCore.ERouteTarget.Log:
{
var routePkg = new NetCore.PkgWriter(nLength + 64);
try
{
routePkg.Write((byte)NetCore.ERouteTarget.Routed);
router.RouteInfo.Save(ref routePkg, target);
routePkg.SetFlags(pkg.GetFlags());
routePkg.AppendPkg(pkg, pkg.GetPosition());
routePkg.SendBuffer(GetServerConnect(target));
}
finally
{
routePkg.Dispose();
}
}
break;
}
}
finally
{
pkg.Dispose();
}
}
public object Execute(ref NetCore.PkgReader pkg, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
UInt16 rpcIndex = 0;
UInt32 rpcHash = 0;
bool hasReturn = false;
bool isHashIndex = pkg.IsHashIndex();
if (isHashIndex)
{
hasReturn = pkg.IsHasReturn();
pkg.Read(out rpcHash);
}
else
{
pkg.Read(out rpcIndex);
hasReturn = (rpcIndex & WaitFlag) != 0 ? true : false;
}
if (hasReturn != pkg.IsHasReturn())
{
System.Diagnostics.Debug.Assert(false);
}
UInt16 serialId = 0;
if (hasReturn)
{
pkg.Read(out serialId);
rpcIndex = (UInt16)(rpcIndex & MaxRPC);
}
RPCProcessor exec = null;
if (isHashIndex)
{
exec = GetExecByHash(rpcHash);
}
else
{
exec = GetExecByIndex(rpcIndex);
}
if (exec == null)
{
System.Diagnostics.Debug.WriteLine($"RPC GetExecByIndex is null:{rpcIndex}");
return(null);
}
object host = exec.GetHostObject(ref routeInfo);
if (host == null)
{
System.Diagnostics.Debug.WriteLine($"RPC HostObject is null:{exec.GetType().FullName}");
return(null);
}
var authority = exec.GetAuthority(host);
if (authority < exec.CallAttr.LimitLevel)
{//超越权限
//System.Diagnostics.Debug.WriteLine($"Over Authority[{authority}<{exec.CallAttr.LimitLevel.ToString()}]:{parameter.GetHostObjectName()}=>{parameter.GetRPCMethod().Name}");
return(null);
}
try
{
//这里如果反射调用就有GC，生成代码可以去掉GC
return(exec.Execute(host, ref pkg, serialId, connect, ref routeInfo));
}
catch (Exception ex)
{
Profiler.Log.WriteException(ex);
return(null);
}
finally
{
}
}
public void OnS2C_FrozenCulling(byte userFlags, ref S2C_FrozenCulling.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
if (CEngine.Instance.GameInstance != null)
{
CEngine.Instance.GameInstance.GameCamera.LockCulling = cmd.Enable;
}
}
public void OnS2C_Shadow(byte userFlags, ref S2C_Shadow.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.EnableShadow = cmd.Shadow;
}
public void OnS2C_Postprocess_Bloom(byte userFlags, ref S2C_Postprocess_Bloom.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.EnableBloom = cmd.Enable;
}
protected override object OnCallMethod(object host, byte userFlags, ref ArgumentData arg, ushort serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
((RemoteServicesHelper)host).OnS2C_InstanceRender(userFlags, ref arg, serialId, connect, ref routeInfo);
return(null);
}
public void OnS2C_IgnoreGLCall(byte userFlags, ref S2C_IgnoreGLCall.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.Instance.IgnoreGLCall = cmd.Enable;
}
protected RPCExecuter.RPCWait WritePkgHeader_Hash <T>(ref NetCore.PkgWriter pkg, ref T arg, long timeOut, RPCExecuter.FRPCReturnCallBack cb,
NetCore.ERouteTarget route, NetCore.NetConnection conn, NetCore.RPCRouter router)
where T : IArgument
{
var hash = MethodHash;
pkg.SetHashIndex(true);
pkg.Write((byte)route);
if (router != null)
{
router.RouteInfo.Save(ref pkg, route);
}
RPCExecuter.RPCWait waiter = null;
if (cb != null)
{
pkg.SetHasReturn(true);
waiter = RPCExecuter.Instance.AddCalBack(cb);
pkg.Waiter = waiter;
if (timeOut < 0)
{
timeOut = long.MaxValue;
}
waiter.Timout = timeOut;
pkg.Write(hash);
pkg.Write(waiter.SerialId);
}
else
{
pkg.SetHasReturn(false);
pkg.Write(hash);
}
return(waiter);
}
public void OnS2C_NoPixelWrite(byte userFlags, ref S2C_NoPixelWrite.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
var enable = cmd.Enable;
CEngine.Instance.EventPoster.RunOn(() =>
{
if (CEngine.Instance.GameInstance != null)
{
CEngine.Instance.GameInstance.NoPixelWrite = enable;
var policy = CEngine.Instance.GameInstance.RenderPolicy as Graphics.RenderPolicy.CGfxRP_GameMobile;
if (policy != null)
{
var profiler = CEngine.Instance.GameInstance.GetGraphicProfiler();
policy.SetGraphicsProfiler(profiler);
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "GraphicsDebugger", $"No Pixel Write:{enable}");
}
}
return(null);
}, Thread.Async.EAsyncTarget.Main);
}
public void OnS2C_ShowNavMesh(byte userFlags, ref S2C_ShowNavMesh.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.PhysicsDebug = cmd.Enable;
}
public void OnS2C_MTForeach(byte userFlags, ref S2C_MTForeach.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.Instance.EventPoster.EnableMTForeach = cmd.Enable;
}
protected virtual object OnCallMethod(object host, byte userFlags, ref T arg, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
var args = new object[] { userFlags, arg, serialId, connect, routeInfo };
return(Method.Invoke(host, args));
}
protected override object OnCallMethod(object host, byte userFlags, ref ArgumentData arg, ushort serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
return(base.OnCallMethod(host, userFlags, ref arg, serialId, connect, ref routeInfo));
}
public sealed override object Execute(object host, ref NetCore.PkgReader pkg, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
unsafe
{
T arg = new T();
OnReadArgument(ref pkg, ref arg);
return(OnCallMethod(host, pkg.GetUserFlags(), ref arg, serialId, connect, ref routeInfo));
}
}
public void OnS2C_TestAwait(byte userFlags, ref S2C_TestAwait.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
var ret = new S2C_TestAwait.ReturnData();
ret.ResultState = RPCError.OK;
ret.A1 = 100;
S2C_TestAwait.Instance.DoReturn(ref ret, serialId, connect);
}
public void OnS2C_S2C_FullGC(byte userFlags, ref S2C_FullGC.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
System.GC.Collect();
}
public void OnS2C_PVS(byte userFlags, ref S2C_PVS.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
CEngine.UsePVS = cmd.Enable;
}
public virtual object Execute(object host, ref NetCore.PkgReader pkg, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
var parameter = CreateArgument();
IO.Serializer.SerializerHelper.ReadObject(parameter, pkg);
var args = new object[] { pkg.GetUserFlags(), parameter, serialId, connect, routeInfo };
return(Method.Invoke(host, args));
}
public void OnC2S_Test(byte userFlags, ref S2C_Test.ArgumentData cmd, UInt16 serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
}
