Exemple #1
0
        public void InitializePipeline(ISyncModelProvider provider)
        {
            if (pipelineAsset == null)
            {
                Debug.LogError("Unable start pipeline. Please assign a Pipeline Asset.");
                return;
            }

            beforeInitialize?.Invoke();

            if (m_Reflect == null)
            {
                m_Reflect = FindObjectOfType <RuntimeReflectBootstrapper>();
            }

            if (m_Reflect == null)
            {
                m_Reflect = gameObject.AddComponent <RuntimeReflectBootstrapper>();
            }

            m_PipelineRunner              = new PipelineRunner(m_Reflect.Hook);
            m_PipelineRunner.onException += onException;

            m_PipelineRunner.CreateProcessors(this, provider);

            m_PipelineRunner.Initialize();

            afterInitialize?.Invoke();
        }
Exemple #2
0
        protected override GameObjectReplacer Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new GameObjectReplacer(settings);

            input.streamEvent = node.OnGameObjectEvent;
            return(node);
        }
        public DataProvider(EventHub hub,
                            MemoryTracker memTracker,
                            ISyncModelProvider client,
                            IHashProvider hashProvider,
                            DataOutput <SyncMesh> syncMeshOutput,
                            DataOutput <SyncMaterial> syncMaterialOutput,
                            DataOutput <SyncTexture> syncTextureOutput,
                            DataOutput <StreamInstanceData> instanceDataOutput)
        {
            m_Hub          = hub;
            m_MemTracker   = memTracker;
            m_Client       = client;
            m_HashProvider = hashProvider;

            m_SyncMaterialOutput = syncMaterialOutput;
            m_SyncMeshOutput     = syncMeshOutput;
            m_SyncTextureOutput  = syncTextureOutput;
            m_InstanceDataOutput = instanceDataOutput;

            m_DownloadRequests    = new ConcurrentQueue <IStream>();
            m_DownloadedInstances = new ConcurrentQueue <DownloadResult>();
            m_DownloadedModels    = new ConcurrentQueue <ObjectDownloadResult>();

            m_StreamCaches  = new Dictionary <StreamKey, StreamCache>();
            m_InstanceCache = new Dictionary <StreamKey, StreamInstanceData>();

            m_AddedModels = new HashSet <StreamKey>();

            m_HubHandle = m_Hub.Subscribe <MemoryTrackerCacheCreatedEvent <Mesh> >(e => m_MeshesHandle = e.handle);
        }
Exemple #4
0
        protected override LightFilter Create(ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new LightFilter(settings);

            gameObjectInput.streamEvent = p.OnStreamEvent;

            return(p);
        }
        protected override MaterialConverter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var converter = new SampleMaterialConverter(hook.services.eventHub, hook.services.memoryTracker, textureCacheParam.value, output, opaqueShader, transparentShader);

            input.streamEvent = converter.OnStreamEvent;

            return(converter);
        }
Exemple #6
0
        protected override TextureConverter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new TextureConverter(hook.services.eventHub, hook.services.memoryTracker, output);

            input.streamEvent = p.OnStreamEvent;

            return(p);
        }
        protected override URPMaterialConverter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new URPMaterialConverter(hook.Services.EventHub, hook.Services.MemoryTracker, textureCacheParam.value, output, m_ReflectUniversalRp);

            input.streamEvent = p.OnStreamEvent;

            return(p);
        }
        protected override URPMaterialConverter Create(ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new URPMaterialConverter(textureCacheParam.value, output, m_ReflectUniversalRp);

            input.streamEvent = p.OnStreamEvent;

            return(p);
        }
Exemple #9
0
        protected override MetadataFilter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new MetadataFilter(settings, outputTrue, outputFalse);

            input.streamEvent = node.OnStreamInstanceEvent;

            return(node);
        }
Exemple #10
0
        protected override MetadataSoftFilter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var filter = new MetadataSoftFilter();

            instanceInput.streamEvent   = filter.OnStreamInstanceEvent;
            gameObjectInput.streamEvent = filter.OnGameObjectEvent;

            return(filter);
        }
        protected override BoundingBoxFilter Create(ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new BoundingBoxFilter(settings);

            input.streamEvent = node.OnStreamEvent;
            input.streamEnd   = node.OnEnd;

            return(node);
        }
Exemple #12
0
        protected override MetadataHardFilter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var filter = new MetadataHardFilter(output);

            input.streamBegin = filter.OnBegin;
            input.streamEvent = filter.OnStreamEvent;
            input.streamEnd   = filter.OnEnd;

            return(filter);
        }
        protected override StreamLimiter <StreamInstance> Create(ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new StreamLimiter <StreamInstance>(settings, instanceOutput);

            instanceInput.streamBegin = node.OnStreamInstanceBegin;
            instanceInput.streamEvent = node.OnStreamInstanceEvent;
            instanceInput.streamEnd   = node.OnStreamInstanceEnd;

            return(node);
        }
        protected override StreamCounter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new StreamCounter(settings);

            var input = GetInput();

            input.streamBegin = node.OnBegin;
            input.streamEvent = (stream, eventType) => node.OnStreamEvent(eventType);

            return(node);
        }
Exemple #15
0
        public ProjectStreamer(ISyncModelProvider client, DataOutput <StreamAsset> assetOutput)
        {
            m_Client = client;

            m_AssetOutput = assetOutput;

            m_Manifests = new Dictionary <string, IReadOnlyDictionary <PersistentKey, ManifestEntry> >();

            m_PendingAdded    = new ConcurrentQueue <IStream>();
            m_PendingRemoved  = new ConcurrentQueue <IStream>();
            m_PendingModified = new ConcurrentQueue <IStream>();
        }
Exemple #16
0
        protected override MetadataFilter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new MetadataFilter(settings);

            instanceInput.streamEvent = p.OnStreamInstanceEvent;
            instanceInput.streamEnd   = p.OnStreamInstanceEnd;

            gameObjectInput.streamEvent = p.OnGameObjectAdded;
            gameObjectInput.streamEnd   = p.OnGameObjectEnd;

            return(p);
        }
        protected override SpatialFilter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new SpatialFilter(hook.helpers.clock, hook.helpers.memoryStats, hook.services.eventHub, hook.systems.memoryCleaner.memoryLevel,
                settings, assetOutput, visibilityOutput, resolver);

            assetInput.streamBegin = assetOutput.SendBegin;
            assetInput.streamEvent = p.OnStreamAssetEvent;
            assetInput.streamEnd = p.OnStreamInstanceEnd;

            gameObjectInput.streamEvent = p.OnStreamGameObjectEvent;

            return p;
        }
        protected override SpatialFilter Create(ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var root = settings.boundingBoxRoot.Resolve(resolver);
            var p    = new SpatialFilter(root, settings, assetOutput);

            assetInput.streamBegin = assetOutput.SendBegin;
            assetInput.streamEvent = p.OnStreamAssetEvent;
            assetInput.streamEnd   = p.OnStreamInstanceEnd;

            gameObjectInput.streamEvent = p.OnStreamGameObjectEvent;

            return(p);
        }
Exemple #19
0
        public SyncObjectInstanceProvider(EventHub hub, ISyncModelProvider client, DataOutput <StreamInstance> instanceDataOutput)
        {
            m_Hub    = hub;
            m_Client = client;

            m_InstanceDataOutput = instanceDataOutput;

            m_DownloadRequests = new ConcurrentQueue <StreamAsset>();
            m_DownloadResults  = new ConcurrentQueue <DownloadResult>();

            m_Cache           = new Dictionary <StreamKey, StreamInstance>();
            m_DirtySyncObject = new HashSet <StreamKey>();
            m_Instances       = new Dictionary <StreamKey, HashSet <StreamAsset> >();
        }
        protected override BoundingBoxController Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new BoundingBoxController(hook.Services.EventHub, settings.boundingBoxRoot.Resolve(resolver), settings);

            assetInput.streamEvent        = p.OnAssetEvent;
            filteredInput.streamEvent     = p.OnFilteredAssetEvent;
            instanceInput.streamEvent     = p.OnInstanceEvent;
            instanceDataInput.streamEvent = p.OnInstanceDataEvent;
            gameObjectInput.streamEvent   = p.OnGameObjectEvent;
            visibilityInput.streamEvent   = p.OnVisibilityEvent;

            assetInput.streamEnd = p.OnAssetEnd;

            return(p);
        }
        protected override DataProvider Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var p = new DataProvider(hook.services.eventHub, hook.services.memoryTracker, provider, hashCacheParam.value,
                                     syncMeshOutput, syncMaterialOutput, syncTextureOutput, instanceDataOutput);

            instanceInput.streamBegin = p.OnStreamInstanceBegin;
            instanceInput.streamEvent = p.OnStreamInstanceEvent;
            instanceInput.streamEnd   = p.OnStreamInstanceEnd;

            assetInput.streamEvent = p.OnStreamAssetEvent;

            p.Run();

            return(p);
        }
Exemple #22
0
        protected override InstanceConverter Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var root = m_Root.Resolve(resolver);

            if (root == null)
            {
                root = new GameObject("root").transform;
            }

            var node = new InstanceConverter(hook.services.eventHub, hook.services.memoryTracker, root, m_GenerateSourceRoots,
                                             materialCacheParam.value, meshCacheParam.value, output);

            input.streamBegin = output.SendBegin;
            input.streamEvent = node.OnStreamEvent;
            input.streamEnd   = output.SendEnd;

            return(node);
        }
Exemple #23
0
        protected override StreamIndicator Create(ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new StreamIndicator(settings);

            streamAssetInput.streamBegin = node.OnAssetStreamBegin;
            streamAssetInput.streamEvent = node.OnAssetStreamEvent;
            streamAssetInput.streamEnd   = node.OnAssetStreamEnd;

            streamInstanceInput.streamBegin = node.OnInstanceStreamBegin;
            streamInstanceInput.streamEvent = node.OnInstanceStreamEvent;
            streamInstanceInput.streamEnd   = node.OnInstanceStreamEnd;

            streamInstanceDataInput.streamBegin = node.OnInstanceDataStreamBegin;
            streamInstanceDataInput.streamEnd   = node.OnInstanceDataStreamEnd;

            gameObjectInput.streamBegin = node.OnGameObjectStreamBegin;
            gameObjectInput.streamEvent = node.OnGameObjectStreamEvent;
            gameObjectInput.streamEnd   = node.OnGameObjectStreamEnd;

            return(node);
        }
Exemple #24
0
 protected override ProjectStreamer Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
 {
     return(new ProjectStreamer(provider, assetOutput));
 }
Exemple #25
0
 public void InitializeAndRefreshPipeline(ISyncModelProvider provider)
 {
     InitializePipeline(provider);
     RefreshPipeline();
 }
 public IReflectNodeProcessor CreateProcessor(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
 {
     processor = Create(hook, provider, resolver);
     return(processor);
 }
Exemple #27
0
        protected override SyncObjectInstanceProvider Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver)
        {
            var node = new SyncObjectInstanceProvider(hook.services.eventHub, provider, output);

            input.streamBegin = node.OnStreamInstanceBegin;
            input.streamEvent = node.OnStreamInstanceEvent;
            input.streamEnd   = node.OnStreamInstanceEnd;

            node.Run();

            return(node);
        }
 protected abstract T Create(ReflectBootstrapper hook, ISyncModelProvider provider, IExposedPropertyTable resolver);