public static HostingComponent Initialize(Configuration configuration,
ContainerComponent containerComponent,
PipelineSettings pipelineSettings)
{
var hostingComponent = new HostingComponent(configuration);
containerComponent.ContainerConfiguration.ConfigureComponent(() => hostingComponent.HostInformation, DependencyLifecycle.SingleInstance);
pipelineSettings.Register("AuditHostInformation", new AuditHostInformationBehavior(hostingComponent.HostInformation, configuration.EndpointName), "Adds audit host information");
pipelineSettings.Register("AddHostInfoHeaders", new AddHostInfoHeadersBehavior(hostingComponent.HostInformation, configuration.EndpointName), "Adds host info headers to outgoing headers");
hostingComponent.AddStartupDiagnosticsSection("Hosting", new
{
hostingComponent.HostInformation.HostId,
HostDisplayName = hostingComponent.HostInformation.DisplayName,
RuntimeEnvironment.MachineName,
OSPlatform = Environment.OSVersion.Platform,
OSVersion = Environment.OSVersion.VersionString,
GCSettings.IsServerGC,
GCLatencyMode = GCSettings.LatencyMode,
Environment.ProcessorCount,
Environment.Is64BitProcess,
CLRVersion = Environment.Version,
Environment.WorkingSet,
Environment.SystemPageSize,
HostName = Dns.GetHostName(),
Environment.UserName,
PathToExe = PathUtilities.SanitizedPath(Environment.CommandLine)
});
return(hostingComponent);
}
public void Save(out SynthesisGuiSettings guiSettings, out PipelineSettings pipeSettings)
{
Configuration.Save(out guiSettings, out pipeSettings);
guiSettings.Ide = this.Ide;
guiSettings.MainRepositoryFolder = Settings.MainRepositoryFolder;
guiSettings.OpenIdeAfterCreating = Settings.OpenIdeAfterCreating;
}
static void EnableBestPracticeEnforcement(Conventions conventions, PipelineSettings pipeline)
{
var validations = new Validations(conventions);
pipeline.Register(
"EnforceSendBestPractices",
new EnforceSendBestPracticesBehavior(validations),
"Enforces send messaging best practices");
pipeline.Register(
"EnforceReplyBestPractices",
new EnforceReplyBestPracticesBehavior(validations),
"Enforces reply messaging best practices");
pipeline.Register(
"EnforcePublishBestPractices",
new EnforcePublishBestPracticesBehavior(validations),
"Enforces publish messaging best practices");
pipeline.Register(
"EnforceSubscribeBestPractices",
new EnforceSubscribeBestPracticesBehavior(validations),
"Enforces subscribe messaging best practices");
pipeline.Register(
"EnforceUnsubscribeBestPractices",
new EnforceUnsubscribeBestPracticesBehavior(validations),
"Enforces unsubscribe messaging best practices");
}
/// <summary>
/// Initializes the endpoint configuration builder.
/// </summary>
/// <param name="endpointName">The name of the endpoint being configured.</param>
public EndpointConfiguration(string endpointName)
: base(new SettingsHolder())
{
ValidateEndpointName(endpointName);
Settings.Set("NServiceBus.Routing.EndpointName", endpointName);
Settings.SetDefault("Endpoint.SendOnly", false);
Settings.SetDefault("Transactions.IsolationLevel", IsolationLevel.ReadCommitted);
Settings.SetDefault("Transactions.DefaultTimeout", TransactionManager.DefaultTimeout);
Settings.Set(new AssemblyScanningComponent.Configuration(Settings));
Settings.Set(new InstallationComponent.Configuration(Settings));
Settings.Set(new HostingComponent.Settings(Settings));
Settings.Set(new TransportComponent.Settings(Settings));
Settings.Set(new RoutingComponent.Configuration(Settings));
Settings.Set(new ReceiveComponent.Configuration(Settings));
Settings.Set(new RecoverabilityComponent.Configuration());
Settings.Set(Pipeline = new PipelineSettings(Settings));
Notifications = new Notifications();
Settings.Set(Notifications);
ConventionsBuilder = new ConventionsBuilder(Settings);
}
/// <summary>
/// Initializes the endpoint configuration builder.
/// </summary>
/// <param name="endpointName">The name of the endpoint being configured.</param>
public EndpointConfiguration(string endpointName)
: base(new SettingsHolder())
{
ValidateEndpointName(endpointName);
Settings.Set <StartupDiagnosticEntries>(new StartupDiagnosticEntries());
Settings.Set("NServiceBus.Routing.EndpointName", endpointName);
pipelineCollection = new PipelineConfiguration();
Settings.Set <PipelineConfiguration>(pipelineCollection);
Pipeline = new PipelineSettings(pipelineCollection.Modifications, Settings);
Settings.Set <QueueBindings>(new QueueBindings());
Settings.SetDefault("Endpoint.SendOnly", false);
Settings.SetDefault("Transactions.IsolationLevel", IsolationLevel.ReadCommitted);
Settings.SetDefault("Transactions.DefaultTimeout", TransactionManager.DefaultTimeout);
Notifications = new Notifications();
Settings.Set <Notifications>(Notifications);
Settings.Set <NotificationSubscriptions>(new NotificationSubscriptions());
conventionsBuilder = new ConventionsBuilder(Settings);
}
public IPipeline CreatePipeline(string assemblyOutputDirectory)
{
var remotionPipelineFactory = new RemotionPipelineFactory();
var defaultPipeline = SafeServiceLocator.Current.GetInstance <IPipelineRegistry>().DefaultPipeline;
var participants = defaultPipeline.Participants.ToArray();
var participantTypeNames = participants.Select(p => p.GetType().Name).ToArray();
s_log.InfoFormat(
"Using pipeline '{0}' with the following participants: {1}.",
defaultPipeline.ParticipantConfigurationID,
string.Join(", ", participantTypeNames));
Assertion.DebugAssert(participants.OfType <MixinParticipant>().Any(), "Mixin participant must be present.");
var pipelineSettings = PipelineSettings.From(defaultPipeline.Settings)
.SetAssemblyDirectory(assemblyOutputDirectory)
.SetAssemblyNamePattern(_assemblyName)
.SetDegreeOfParallelism(_degreeOfParallelism);
var pipeline = remotionPipelineFactory.Create(
defaultPipeline.ParticipantConfigurationID,
pipelineSettings.Build(),
participants);
return(pipeline);
}
/// <summary>
/// Subscribes to notifications for completed receive pipelines.
/// </summary>
public static void OnReceivePipelineCompleted(this PipelineSettings pipelineSettings, Func <ReceivePipelineCompleted, CancellationToken, Task> subscription)
{
Guard.AgainstNull(nameof(pipelineSettings), pipelineSettings);
Guard.AgainstNull(nameof(subscription), subscription);
pipelineSettings.Settings.Get <ReceiveComponent.Settings>().PipelineCompletedSubscribers.Subscribe(subscription);
}
public FeaturesReport SetupFeatures(IConfigureComponents container, PipelineSettings pipelineSettings, RoutingComponent routing)
{
// featuresToActivate is enumerated twice because after setting defaults some new features might got activated.
var sourceFeatures = Sort(features);
var enabledFeatures = new List <FeatureInfo>();
while (true)
{
var featureToActivate = sourceFeatures.FirstOrDefault(x => settings.IsFeatureEnabled(x.Feature.GetType()));
if (featureToActivate == null)
{
break;
}
sourceFeatures.Remove(featureToActivate);
enabledFeatures.Add(featureToActivate);
featureToActivate.Feature.ConfigureDefaults(settings);
}
foreach (var feature in enabledFeatures)
{
ActivateFeature(feature, enabledFeatures, container, pipelineSettings, routing);
}
settings.PreventChanges();
return(new FeaturesReport(features.Select(t => t.Diagnostics).ToList()));
}
public FeaturesReport SetupFeatures(IConfigureComponents container, PipelineSettings pipelineSettings)
{
// featuresToActivate is enumerated twice because after setting defaults some new features might got activated.
var sourceFeatures = Sort(features);
var enabledFeatures = new List<FeatureInfo>();
while (true)
{
var featureToActivate = sourceFeatures.FirstOrDefault(x => settings.IsFeatureEnabled(x.Feature.GetType()));
if (featureToActivate == null)
{
break;
}
sourceFeatures.Remove(featureToActivate);
enabledFeatures.Add(featureToActivate);
featureToActivate.Feature.ConfigureDefaults(settings);
}
foreach (var feature in enabledFeatures)
{
ActivateFeature(feature, enabledFeatures, container, pipelineSettings);
}
settings.PreventChanges();
return new FeaturesReport(features.Select(t => t.Diagnostics).ToList());
}
static void InitializeShadowData(PipelineSettings settings, bool hasDirectionalShadowCastingLight, bool hasLocalShadowCastingLight, out ShadowData shadowData)
{
// Until we can have keyword stripping forcing single cascade hard shadows on gles2
bool supportsScreenSpaceShadows = SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
shadowData.renderDirectionalShadows = settings.supportsDirectionalShadows && hasDirectionalShadowCastingLight;
// we resolve shadows in screenspace when cascades are enabled to save ALU as computing cascade index + shadowCoord on fragment is expensive
shadowData.requiresScreenSpaceShadowResolve = shadowData.renderDirectionalShadows && supportsScreenSpaceShadows && settings.cascadeCount > 1;
shadowData.directionalLightCascadeCount = (shadowData.requiresScreenSpaceShadowResolve) ? settings.cascadeCount : 1;
shadowData.directionalShadowAtlasWidth = settings.directionalShadowAtlasResolution;
shadowData.directionalShadowAtlasHeight = settings.directionalShadowAtlasResolution;
switch (shadowData.directionalLightCascadeCount)
{
case 1:
shadowData.directionalLightCascades = new Vector3(1.0f, 0.0f, 0.0f);
break;
case 2:
shadowData.directionalLightCascades = new Vector3(settings.cascade2Split, 1.0f, 0.0f);
break;
default:
shadowData.directionalLightCascades = settings.cascade4Split;
break;
}
shadowData.renderLocalShadows = settings.supportsLocalShadows && hasLocalShadowCastingLight;
shadowData.localShadowAtlasWidth = shadowData.localShadowAtlasHeight = settings.localShadowAtlasResolution;
shadowData.supportsSoftShadows = settings.supportsSoftShadows;
shadowData.bufferBitCount = 16;
}
public static PipelineSettings Create(LightweightPipelineAsset asset)
{
var cache = new PipelineSettings();
cache.msaaSampleCount = asset.msaaSampleCount;
cache.supportsHDR = asset.supportsHDR;
cache.savedXRGraphicsConfig = asset.savedXRGraphicsConfig;
cache.renderScale = asset.renderScale;
cache.supportsCameraDepthTexture = asset.supportsCameraDepthTexture;
cache.opaqueDownsampling = asset.opaqueDownsampling;
cache.supportsCameraOpaqueTexture = asset.supportsCameraOpaqueTexture;
cache.supportsDynamicBatching = asset.supportsDynamicBatching;
cache.maxPixelLights = asset.maxPixelLights;
cache.supportsDirectionalShadows = asset.supportsDirectionalShadows;
cache.supportsSoftParticles = asset.supportsSoftParticles;
cache.supportsLocalShadows = asset.supportsLocalShadows;
cache.shadowDistance = asset.shadowDistance;
cache.cascadeCount = asset.cascadeCount;
cache.directionalShadowAtlasResolution = asset.directionalShadowAtlasResolution;
cache.cascade2Split = asset.cascade2Split;
cache.cascade4Split = asset.cascade4Split;
cache.supportsVertexLight = asset.supportsVertexLight;
cache.localShadowAtlasResolution = asset.localShadowAtlasResolution;
cache.supportsSoftShadows = asset.supportsSoftShadows;
cache.savedXRGraphicsConfig.renderScale = cache.renderScale;
cache.savedXRGraphicsConfig.viewportScale = 1.0f; // Placeholder until viewportScale is all hooked up
// Apply any changes to XRGConfig prior to this point
cache.savedXRGraphicsConfig.SetConfig();
return(cache);
}
static void InitializeRenderingData(PipelineSettings settings, ref CameraData cameraData, ref CullResults cullResults,
int maxSupportedLocalLightsPerPass, int maxSupportedVertexLights,
out RenderingData renderingData)
{
List <VisibleLight> visibleLights = cullResults.visibleLights;
List <int> localLightIndices = new List <int>();
bool hasDirectionalShadowCastingLight = false;
bool hasLocalShadowCastingLight = false;
if (cameraData.maxShadowDistance > 0.0f)
{
for (int i = 0; i < visibleLights.Count; ++i)
{
Light light = visibleLights[i].light;
bool castShadows = light != null && light.shadows != LightShadows.None;
if (visibleLights[i].lightType == LightType.Directional)
{
hasDirectionalShadowCastingLight |= castShadows;
}
else
{
hasLocalShadowCastingLight |= castShadows;
localLightIndices.Add(i);
}
}
}
renderingData.cullResults = cullResults;
renderingData.cameraData = cameraData;
InitializeLightData(settings, visibleLights, maxSupportedLocalLightsPerPass, maxSupportedVertexLights, localLightIndices, out renderingData.lightData);
InitializeShadowData(settings, hasDirectionalShadowCastingLight, hasLocalShadowCastingLight, out renderingData.shadowData);
renderingData.supportsDynamicBatching = settings.supportsDynamicBatching;
}
public static PipelineSettings Create(LightweightPipelineAsset asset)
{
var cache = new PipelineSettings();
cache.msaaSampleCount = asset.msaaSampleCount;
cache.supportsHDR = asset.supportsHDR;
cache.savedXRGraphicsConfig = asset.savedXRGraphicsConfig;
cache.renderScale = asset.renderScale;
cache.supportsCameraDepthTexture = asset.supportsCameraDepthTexture;
cache.opaqueDownsampling = asset.opaqueDownsampling;
cache.supportsCameraOpaqueTexture = asset.supportsCameraOpaqueTexture;
cache.supportsDynamicBatching = asset.supportsDynamicBatching;
cache.maxPixelLights = asset.maxPixelLights;
cache.supportsDirectionalShadows = asset.supportsDirectionalShadows;
cache.supportsSoftParticles = asset.supportsSoftParticles;
cache.supportsLocalShadows = asset.supportsLocalShadows;
cache.shadowDistance = asset.shadowDistance;
cache.cascadeCount = asset.cascadeCount;
cache.directionalShadowAtlasResolution = asset.directionalShadowAtlasResolution;
cache.cascade2Split = asset.cascade2Split;
cache.cascade4Split = asset.cascade4Split;
cache.supportsVertexLight = asset.supportsVertexLight;
cache.localShadowAtlasResolution = asset.localShadowAtlasResolution;
cache.supportsSoftShadows = asset.supportsSoftShadows;
return(cache);
}
// Main Light is always a directional light
static int GetMainLight(PipelineSettings settings, List <VisibleLight> visibleLights)
{
int totalVisibleLights = visibleLights.Count;
if (totalVisibleLights == 0 || settings.maxPixelLights == 0)
{
return(-1);
}
for (int i = 0; i < totalVisibleLights; ++i)
{
VisibleLight currLight = visibleLights[i];
// Particle system lights have the light property as null. We sort lights so all particles lights
// come last. Therefore, if first light is particle light then all lights are particle lights.
// In this case we either have no main light or already found it.
if (currLight.light == null)
{
break;
}
// In case no shadow light is present we will return the brightest directional light
if (currLight.lightType == LightType.Directional)
{
return(i);
}
}
return(-1);
}
public LightweightRenderPipeline(LightweightRenderPipelineAsset asset)
{
settings = PipelineSettings.Create(asset);
renderer = new ScriptableRenderer(asset);
SetSupportedRenderingFeatures();
GraphicsSettings.useScriptableRenderPipelineBatching = asset.useSRPBatcher;
PerFrameBuffer._GlossyEnvironmentColor = Shader.PropertyToID("_GlossyEnvironmentColor");
PerFrameBuffer._SubtractiveShadowColor = Shader.PropertyToID("_SubtractiveShadowColor");
PerCameraBuffer._InvCameraViewProj = Shader.PropertyToID("_InvCameraViewProj");
PerCameraBuffer._ScaledScreenParams = Shader.PropertyToID("_ScaledScreenParams");
// Let engine know we have MSAA on for cases where we support MSAA backbuffer
if (QualitySettings.antiAliasing != settings.msaaSampleCount)
{
QualitySettings.antiAliasing = settings.msaaSampleCount;
}
Shader.globalRenderPipeline = "LightweightPipeline";
Lightmapping.SetDelegate(lightsDelegate);
CameraCaptureBridge.enabled = true;
}
public void Initialize(TransportComponent transportComponent, PipelineSettings pipelineSettings, ReceiveConfiguration receiveConfiguration)
{
var conventions = settings.Get <Conventions>();
var configuredUnicastRoutes = settings.GetOrDefault <ConfiguredUnicastRoutes>();
if (settings.TryGet(out List <DistributionStrategy> distributionStrategies))
{
foreach (var distributionStrategy in distributionStrategies)
{
DistributionPolicy.SetDistributionStrategy(distributionStrategy);
}
}
configuredUnicastRoutes?.Apply(UnicastRoutingTable, conventions);
pipelineSettings.Register("UnicastSendRouterConnector", b =>
{
var router = new UnicastSendRouter(receiveConfiguration == null, receiveConfiguration?.QueueNameBase, receiveConfiguration?.InstanceSpecificQueue, DistributionPolicy, UnicastRoutingTable, EndpointInstances, i => transportComponent.ToTransportAddress(LogicalAddress.CreateRemoteAddress(i)));
return(new SendConnector(router));
}, "Determines how the message being sent should be routed");
pipelineSettings.Register("UnicastReplyRouterConnector", new ReplyConnector(), "Determines how replies should be routed");
EnforceBestPractices = ShouldEnforceBestPractices(settings);
if (EnforceBestPractices)
{
EnableBestPracticeEnforcement(conventions, pipelineSettings);
}
}
protected override void Setup(FeatureConfigurationContext context)
{
PipelineSettings satelliteMessagePipeline = context.AddSatellitePipeline("CustomSatellite", TransportTransactionMode.TransactionScope, PushRuntimeSettings.Default, "targetQueue");
// register the critical error
satelliteMessagePipeline.Register("Satellite Identifier", b => new MyAdvancedSatelliteBehavior(b.Build <CriticalError>()),
"Description of what the advanced satellite does");
}
/// <summary>
/// Subscribes to notifications for completed receive pipelines.
/// </summary>
public static void OnReceivePipelineCompleted(this PipelineSettings pipelineSettings, Func <ReceivePipelineCompleted, Task> subscription)
{
Guard.AgainstNull(nameof(pipelineSettings), pipelineSettings);
Guard.AgainstNull(nameof(subscription), subscription);
pipelineSettings.Settings.GetOrCreate <Notification <ReceivePipelineCompleted> >()
.Subscribe(subscription);
}
protected override void Setup(FeatureConfigurationContext context)
{
PipelineSettings pipeline = context.Pipeline;
pipeline.Replace("NServiceBus.DeserializeLogicalMessagesConnector", typeof(DeserializeConnector));
pipeline.Replace("NServiceBus.SerializeMessageConnector", typeof(SerializeConnector));
context.Container.ConfigureComponent <SerializationMapper>(DependencyLifecycle.SingleInstance);
}
protected virtual IPipeline NewPipeline(
PipelineSettings settings,
ICodeManager codeManager,
IReflectionService reflectionService,
ITypeAssembler typeAssembler)
{
return(new Pipeline(settings, codeManager, reflectionService, typeAssembler));
}
internal FeatureConfigurationContext(ReadOnlySettings settings, IConfigureComponents container, PipelineSettings pipelineSettings)
{
Settings = settings;
Container = container;
Pipeline = pipelineSettings;
TaskControllers = new List <FeatureStartupTaskController>();
}
public void SetUp()
{
var assemblyTrackingPipelineFactory = new AssemblyTrackingPipelineFactory();
var settings = PipelineSettings.New().SetEnableSerializationWithoutAssemblySaving(true).Build();
var participants = new IParticipant[] { new MixinParticipant() };
s_pipeline = assemblyTrackingPipelineFactory.Create("re-mix-tests", settings, participants);
s_assemblyTrackingCodeManager = assemblyTrackingPipelineFactory.AssemblyTrackingCodeManager;
}
protected override IPipeline CreatePipelineForSerialization(params Func <IParticipant>[] participantProviders)
{
_participantProviders = participantProviders;
var participants = _participantProviders.Select(pp => pp()).ToArray();
var settings = PipelineSettings.New().SetEnableSerializationWithoutAssemblySaving(true).Build();
return(CreatePipelineWithIntegrationTestAssemblyLocation(c_participantConfigurationID, settings, participants));
}
public PipelineSettings GetSettings()
{
return(PipelineSettings
.New()
.SetForceStrongNaming(ForceStrongNaming)
.SetKeyFilePath(KeyFilePath)
.SetEnableSerializationWithoutAssemblySaving(EnableSerializationWithoutAssemblySaving)
.Build());
}
public void Build_SetDegreeOfParallelism_LessThanOne_ThrowsArgumentOutOfRangeException()
{
var builder = PipelineSettings.New();
Assert.That(
() => builder.SetDegreeOfParallelism(0),
Throws.TypeOf <ArgumentOutOfRangeException>()
.With.ArgumentOutOfRangeExceptionMessageEqualTo("The degree of parallelism must be greater than 0.", "value", 0));
}
public void Build_SetDegreeOfParallelism_LessThanOne_ThrowsArgumentOutOfRangeException()
{
var builder = PipelineSettings.New();
Assert.That(
() => builder.SetDegreeOfParallelism(0),
Throws.TypeOf <ArgumentOutOfRangeException>()
.With.Message.EqualTo("The degree of parallelism must be greater than 0.\r\nParameter name: value\r\nActual value was 0."));
}
public static void RenderSingleCamera(LightweightRenderPipeline pipelineInstance, ScriptableRenderContext context, Camera camera, IRendererSetup setup = null)
{
if (pipelineInstance == null)
{
Debug.LogError("Trying to render a camera with an invalid render pipeline instance.");
return;
}
if (!camera.TryGetCullingParameters(IsStereoEnabled(camera), out var cullingParameters))
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_RenderCameraTag);
using (new ProfilingSample(cmd, k_RenderCameraTag))
{
PipelineSettings settings = pipelineInstance.settings;
ScriptableRenderer renderer = pipelineInstance.renderer;
InitializeCameraData(settings, camera, out var cameraData);
SetupPerCameraShaderConstants(cameraData);
if (pipelineInstance.settings.additionalLightsRenderingMode == LightRenderingMode.Disabled ||
pipelineInstance.settings.maxAdditionalLights == 0)
{
cullingParameters.cullingOptions |= CullingOptions.DisablePerObjectCulling;
}
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
var cullResults = context.Cull(ref cullingParameters);
InitializeRenderingData(settings, ref cameraData, ref cullResults,
renderer.maxVisibleAdditionalLights, renderer.maxPerObjectAdditionalLights, out var renderingData);
renderer.Clear();
var rendererSetup = setup ?? settings.rendererSetup;
rendererSetup.Setup(renderer, ref renderingData);
renderer.Execute(context, ref renderingData);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
public static void RenderSingleCamera(ScriptableRenderContext context, PipelineSettings settings, Camera camera, ref CullResults cullResults, IRendererSetup setup, ScriptableRenderer renderer)
{
string renderCameraTag = camera.name;
CommandBuffer cmd = CommandBufferPool.Get(renderCameraTag);
using (new ProfilingSample(cmd, renderCameraTag))
{
CameraData cameraData;
InitializeCameraData(settings, camera, out cameraData);
SetupPerCameraShaderConstants(cameraData);
ScriptableCullingParameters cullingParameters;
if (!CullResults.GetCullingParameters(camera, cameraData.isStereoEnabled, out cullingParameters))
{
CommandBufferPool.Release(cmd);
return;
}
cullingParameters.shadowDistance = Mathf.Min(cameraData.maxShadowDistance, camera.farClipPlane);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#if UNITY_EDITOR
// Emit scene view UI
if (cameraData.isSceneViewCamera)
{
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
}
#endif
CullResults.Cull(ref cullingParameters, context, ref cullResults);
List <VisibleLight> visibleLights = cullResults.visibleLights;
RenderingData renderingData;
InitializeRenderingData(settings, ref cameraData, visibleLights,
renderer.maxSupportedLocalLightsPerPass, renderer.maxSupportedVertexLights,
out renderingData);
var setupToUse = setup;
if (setupToUse == null)
{
setupToUse = defaultRendererSetup;
}
setupToUse.Setup(renderer, ref context, ref cullResults, ref renderingData);
renderer.Execute(ref context, ref cullResults, ref renderingData);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
#if UNITY_EDITOR
Handles.DrawGizmos(camera);
#endif
}
}
public void Register_ThrowsWhenChangesArePrevented()
{
var settingsHolder = new SettingsHolder();
var pipelineSettings = new PipelineSettings(settingsHolder);
pipelineSettings.PreventChanges();
Assert.Throws <InvalidOperationException>(() => pipelineSettings.Register(typeof(Behavior1), "newStep"));
Assert.Throws <InvalidOperationException>(() => pipelineSettings.Replace("newStep", typeof(Behavior1)));
}
private IPipeline CreateObjectFactoryForStrongNaming(IParticipant participant, bool forceStrongNaming, string keyFilePath = null)
{
var settings = PipelineSettings
.New()
.SetForceStrongNaming(forceStrongNaming)
.SetKeyFilePath(keyFilePath)
.Build();
return(CreatePipelineWithIntegrationTestAssemblyLocation("StrongNamingTest", settings, participant));
}
internal FeatureConfigurationContext(ReadOnlySettings settings, IConfigureComponents container, PipelineSettings pipelineSettings, RoutingComponent routing, ReceiveConfiguration receiving)
{
Settings = settings;
Container = container;
Pipeline = pipelineSettings;
Routing = routing;
this.receiving = receiving;
TaskControllers = new List <FeatureStartupTaskController>();
}
public InitializableEndpoint(SettingsHolder settings, IContainer container, List<Action<IConfigureComponents>> registrations, PipelineSettings pipelineSettings, PipelineConfiguration pipelineConfiguration)
{
this.settings = settings;
this.pipelineSettings = pipelineSettings;
this.pipelineConfiguration = pipelineConfiguration;
RegisterContainerAdapter(container);
RunUserRegistrations(registrations);
this.container.RegisterSingleton(this);
this.container.RegisterSingleton<ReadOnlySettings>(settings);
}
bool ActivateFeature(FeatureInfo featureInfo, List<FeatureInfo> featuresToActivate, IConfigureComponents container, PipelineSettings pipelineSettings)
{
if (featureInfo.Feature.IsActive)
{
return true;
}
Func<List<string>, bool> dependencyActivator = dependencies =>
{
var dependantFeaturesToActivate = new List<FeatureInfo>();
foreach (var dependency in dependencies.Select(dependencyName => featuresToActivate
.SingleOrDefault(f => f.Feature.Name == dependencyName))
.Where(dependency => dependency != null))
{
dependantFeaturesToActivate.Add(dependency);
}
return dependantFeaturesToActivate.Aggregate(false, (current, f) => current | ActivateFeature(f, featuresToActivate, container, pipelineSettings));
};
var featureType = featureInfo.Feature.GetType();
if (featureInfo.Feature.Dependencies.All(dependencyActivator))
{
featureInfo.Diagnostics.DependenciesAreMet = true;
var context = new FeatureConfigurationContext(settings, container, pipelineSettings);
if (!HasAllPrerequisitesSatisfied(featureInfo.Feature, featureInfo.Diagnostics, context))
{
settings.MarkFeatureAsDeactivated(featureType);
return false;
}
settings.MarkFeatureAsActive(featureType);
featureInfo.Feature.SetupFeature(context);
featureInfo.TaskControllers = context.TaskControllers;
featureInfo.Diagnostics.StartupTasks = context.TaskControllers.Select(d => d.Name).ToList();
featureInfo.Diagnostics.Active = true;
return true;
}
settings.MarkFeatureAsDeactivated(featureType);
featureInfo.Diagnostics.DependenciesAreMet = false;
return false;
}
