コード例 #1
0
#pragma warning restore 649

        protected override void Import(RpcContext <ConvertResource <SyncMesh> > ctx, SyncedData <SyncMesh> resource)
        {
            MeshImportJob jobData;
            var           vCount = resource.data.Vertices.Count;

            if (vCount > k_MaxUInt16VertexCount)
            {
                jobData = ImportMesh <uint>(resource.data);
            }
            else
            {
                jobData = ImportMesh <ushort>(resource.data);
            }

            var rpc = m_DelegateJobOutput.Call(this, ctx, jobData, new DelegateJob(jobData, MeshConverterMainThreadJob));

            rpc.Success <MeshImportJob>((self, ctx, jobData, _) =>
            {
                ctx.SendSuccess(new ConvertedResource {
                    MainResource = jobData.Result, Dependencies = new List <Guid>()
                });
            });

            rpc.Failure((self, ctx, meshImport, ex) =>
            {
                ctx.SendFailure(ex);
            });
        }
コード例 #2
0
        static void ForwardCall <T, TResult>(RpcContext <T> rpcCtx, RpcOutput <T> rpcOutput)
            where T : class
            where TResult : class
        {
            var rpc = rpcOutput.Call((object)null, rpcCtx, (object)null, rpcCtx.Data);

            rpc.Success <TResult>((self, ctx, userCtx, res) => ctx.SendSuccess(res));
            rpc.Failure((self, ctx, userCtx, ex) => ctx.SendFailure(ex));
        }
コード例 #3
0
        void SendUpdateManifests()
        {
            var rpc = m_UpdateManifestsOutput.Call(this, (object)null, (object)null, new UpdateManifests());

            rpc.Success <object>((self, ctx, userCtx, res) =>
            {
                Debug.Log("Manifests loaded");
            });
            rpc.Failure((self, ctx, userCtx, ex) =>
            {
                Debug.LogException(ex);
            });
        }
コード例 #4
0
        void PickFromDistance(int distance, Action <List <ISpatialObject> > callback)
        {
            var rpc = m_PickFromDistanceOutput.Call((object)null, (object)null, callback, new PickFromDistance(distance));

            rpc.Success <List <ISpatialObject> >((self, ctx, callback, result) =>
            {
                callback(result);
            });
            rpc.Failure((self, ctx, userCtx, ex) =>
            {
                Debug.LogException(ex);
            });
        }
コード例 #5
0
        void PickFromSamplePoints(Vector3[] samplePoints, int count, Action <List <ISpatialObject> > callback)
        {
            var rpc = m_PickFromSamplePointsOutput.Call((object)null, (object)null, callback, new PickFromSamplePoints(samplePoints, count));

            rpc.Success <List <ISpatialObject> >((self, ctx, callback, result) =>
            {
                callback(result);
            });
            rpc.Failure((self, ctx, userCtx, ex) =>
            {
                Debug.LogException(ex);
            });
        }
コード例 #6
0
        void GetFilterStates(string groupKey, Action <List <FilterState> > callback)
        {
            var rpc = m_GetFilterStatesOutput.Call((object)null, (object)null, callback, new GetFilterStates(groupKey));

            rpc.Success <List <FilterState> >((self, ctx, callback, result) =>
            {
                callback(result);
            });
            rpc.Failure((self, ctx, userCtx, ex) =>
            {
                Debug.LogException(ex);
            });
        }
コード例 #7
0
        void OnCreateGameObject(RpcContext <CreateGameObject> ctx)
        {
            if (!m_EmbeddedProject)
            {
                ForwardCall <CreateGameObject, GameObject>(ctx, m_CreateGameObjectFallback);
                return;
            }

            var tracker = new Tracker();

            var instanceEntryRpc = m_AcquireDynamicEntryDataOutput.Call(this, ctx, tracker, new AcquireDynamicEntry(ctx.Data.InstanceId));

            instanceEntryRpc.Success <DynamicEntry>((self, ctx, tracker, entryData) =>
            {
                var streamKey = new StreamKey(entryData.Data.SourceId, entryData.Data.IdInSource);
                var original  = m_GameObjectLookup[streamKey];

                original.SetActive(true);

                ctx.SendSuccess(original);
            });
        }
コード例 #8
0
        void OnAcquireUnityResource(RpcContext <AcquireUnityResource> ctx)
        {
            if (CompleteIfStreamCanceled(ctx))
            {
                return;
            }

            if (CompleteIfResourceInCache(ctx))
            {
                return;
            }

            var tracker = new Tracker {
                Ctx = ctx
            };

            if (m_Waiters.TryGetValue(ctx.Data.ResourceData.Id, out var trackers))
            {
                trackers.Add(tracker);
                return;
            }

            m_Waiters.Add(ctx.Data.ResourceData.Id, new List <Tracker> {
                tracker
            });

            // From this point a request won't be cancellable because it's too complicated to track interlaced resource requests.
            // We may implement it later but the overhead may outweigh the benefits
            var rpc = m_AcquireResourceOutput.Call(this, ctx, (object)null, new AcquireResource(new StreamState(), ctx.Data.ResourceData));

            rpc.Success <ISyncModel>((self, ctx, _, syncModel) =>
            {
                var(entry, trackers) = self.GetCommonData(ctx);

                RpcOutput <ConvertResource <object> > output;
                object msg;
                // Hack to toggle between different output based on previous request result.
                // Needs a standard way to do this. It could be a native mechanism that does the same as this
                if (syncModel is SyncMesh mesh)
                {
                    output = Unsafe.As <RpcOutput <ConvertResource <object> > >(m_ConvertMeshOutput);
                    msg    = new ConvertResource <SyncMesh>(ctx.Data.ResourceData, mesh);
                }
                else if (syncModel is SyncMaterial material)
                {
                    output = Unsafe.As <RpcOutput <ConvertResource <object> > >(m_ConvertMaterialOutput);
                    msg    = new ConvertResource <SyncMaterial>(ctx.Data.ResourceData, material);
                }
                else if (syncModel is SyncTexture texture)
                {
                    output = Unsafe.As <RpcOutput <ConvertResource <object> > >(m_ConvertTextureOutput);
                    msg    = new ConvertResource <SyncTexture>(ctx.Data.ResourceData, texture);
                }
                else
                {
                    foreach (var tracker in trackers)
                    {
                        tracker.Ctx.SendFailure(new Exception($"No converter exists for type {syncModel.GetType()}"));
                    }

                    self.m_ReleaseResourceOutput.Send(new ReleaseResource(entry.Id));
                    self.m_Waiters.Remove(entry.Id);
                    return;
                }

                var rpc = output.Call(self, ctx, (object)null, Unsafe.As <ConvertResource <object> >(msg));
                rpc.Success <ConvertedResource>((self, ctx, _, convertedResource) =>
                {
                    var(entry, trackers) = self.GetCommonData(ctx);
                    var resource         = new Resource {
                        MainResource = convertedResource.MainResource, Dependencies = convertedResource.Dependencies
                    };

                    self.m_LoadedResources[entry.Id] = resource;

                    foreach (var tracker in trackers)
                    {
                        tracker.Ctx.SendSuccess(resource.MainResource);
                    }

                    self.m_Waiters.Remove(entry.Id);
                    resource.Count = trackers.Count;

                    self.m_ReleaseResourceOutput.Send(new ReleaseResource(entry.Id));
                });

                rpc.Failure((self, ctx, _, ex) =>
                {
                    var(entry, trackers) = self.GetCommonData(ctx);

                    foreach (var tracker in trackers)
                    {
                        tracker.Ctx.SendFailure(ex);
                    }

                    self.m_Waiters.Remove(entry.Id);

                    self.m_ReleaseResourceOutput.Send(new ReleaseResource(entry.Id));
                });
            });

            rpc.Failure((self, ctx, _, ex) =>
            {
                var(entry, trackers) = GetCommonData(ctx);

                foreach (var tracker in trackers)
                {
                    tracker.Ctx.SendFailure(ex);
                }

                m_Waiters.Remove(entry.Id);

                m_ReleaseResourceOutput.Send(new ReleaseResource(entry.Id));
            });
        }