public RendererConfigurationTestBase()
{
Renderers = new List <IViewRenderer>();
Config = new RendererConfiguration(Renderers);
AddAllRenderers();
}
public void Setup(LightweightForwardRenderer renderer, ref ScriptableRenderContext context,
ref CullResults cullResults, ref RenderingData renderingData)
{
Init(renderer);
renderer.Clear();
renderer.SetupPerObjectLightIndices(ref cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = renderer.CreateRTDesc(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
renderer.EnqueuePass(m_SetupForwardRenderingPass);
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
Camera camera = renderingData.cameraData.camera;
bool dynamicBatching = renderingData.supportsDynamicBatching;
RendererConfiguration rendererConfiguration = LightweightForwardRenderer.GetRendererConfiguration(renderingData.lightData.totalAdditionalLightsCount);
renderer.EnqueuePass(m_SetupLightweightConstants);
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, LightweightForwardRenderer.GetCameraClearFlag(camera), camera.backgroundColor, rendererConfiguration, dynamicBatching);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
}
public VXGIRenderPipeline(VXGIRenderPipelineAsset asset)
{
_renderer = new VXGIRenderer(this);
_command = new CommandBuffer()
{
name = "VXGI.RenderPipeline"
};
_filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
_drawRendererFlags = DrawRendererFlags.None;
if (asset.dynamicBatching)
{
_drawRendererFlags |= DrawRendererFlags.EnableDynamicBatching;
}
_rendererConfiguration = RendererConfiguration.None;
if (asset.environmentLighting)
{
_rendererConfiguration |= RendererConfiguration.PerObjectLightProbe;
}
if (asset.environmentReflections)
{
_rendererConfiguration |= RendererConfiguration.PerObjectReflectionProbes;
}
Shader.globalRenderPipeline = "VXGI";
GraphicsSettings.lightsUseLinearIntensity = true;
GraphicsSettings.useScriptableRenderPipelineBatching = asset.SRPBatching;
}
#pragma warning restore 414
public DrawRendererSettings(Camera camera, ShaderPassName shaderPassName)
{
rendererConfiguration = RendererConfiguration.None;
flags = DrawRendererFlags.EnableInstancing;
m_OverrideMaterialInstanceId = 0;
m_OverrideMaterialPassIdx = 0;
fixed(int *p = shaderPassNames)
{
for (int i = 0; i < maxShaderPasses; i++)
{
p[i] = -1;
}
}
fixed(int *p = shaderPassNames)
{
p[0] = shaderPassName.nameIndex;
}
rendererConfiguration = RendererConfiguration.None;
flags = DrawRendererFlags.EnableInstancing;
InitializeSortSettings(camera, out sorting);
}
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
{
Init();
renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
shadowDescriptor.dimension = TextureDimension.Tex2D;
renderer.EnqueuePass(m_SetupForwardRenderingPass);
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
Camera camera = renderingData.cameraData.camera;
RendererConfiguration rendererConfiguration = ScriptableRenderer.GetRendererConfiguration(renderingData.lightData.totalAdditionalLightsCount);
m_SetupLightweightConstants.Setup(renderer.maxVisibleLocalLights, renderer.perObjectLightIndices);
renderer.EnqueuePass(m_SetupLightweightConstants);
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ScriptableRenderer.GetCameraClearFlag(camera), camera.backgroundColor, rendererConfiguration);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
}
public DrawRendererSettings(CullResults cullResults, Camera camera, ShaderPassName shaderPassName)
{
this._cullResults = cullResults.cullResults;
this.shaderPassName = shaderPassName;
this.rendererConfiguration = RendererConfiguration.None;
this.flags = DrawRendererFlags.EnableInstancing;
this.inputFilter = InputFilter.Default();
DrawRendererSettings.InitializeSortSettings(camera, out this.sorting);
}
public void Setup(RenderTextureDescriptor baseDesc, RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle, ClearFlag clearFlag, Color clearColor, RendererConfiguration config)
{
this.colorAttachmentHandle = colorAttachmentHandle;
this.depthAttachmentHandle = depthAttachmentHandle;
this.clearColor = clearColor;
this.clearFlag = clearFlag;
this.desc = baseDesc;
this.rendererConfig = config;
}
RendererConfiguration GetRendererSettings(ref LightData lightData)
{
RendererConfiguration settings = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
if (lightData.totalAdditionalLightsCount > 0)
{
settings |= RendererConfiguration.PerObjectLightIndices8;
}
return(settings);
}
/// <summary>
/// Configure the pass before execution
/// </summary>
/// <param name="baseDescriptor">Current target descriptor</param>
/// <param name="colorAttachmentHandle">Color attachment to render into</param>
/// <param name="depthAttachmentHandle">Depth attachment to render into</param>
/// <param name="configuration">Specific render configuration</param>
public void Setup(
RenderTextureDescriptor baseDescriptor,
RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle,
RendererConfiguration configuration)
{
this.colorAttachmentHandle = colorAttachmentHandle;
this.depthAttachmentHandle = depthAttachmentHandle;
descriptor = baseDescriptor;
rendererConfiguration = configuration;
}
public EngineApplication(Control control, RendererConfiguration rendererConfig, DeferredShadingConfiguration deferredShadingConfig)
{
services = new ServiceContainer();
windowsControlProvider = new WindowsControlProvider(control, Services);
resourceManager = new ResourceManager(Services);
renderer = new Renderer(rendererConfig, deferredShadingConfig, Services);
worldManager = new WorldManager(Services);
timer = new Timer(Services);
inputManager = new InputManager(Services);
}
public static RendererConfiguration GetRendererConfiguration(int additionalLightsCount)
{
RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
if (additionalLightsCount > 0)
{
configuration |= RendererConfiguration.ProvideLightIndices;
}
return(configuration);
}
/// <summary>
/// Configure the pass before execution
/// </summary>
/// <param name="baseDescriptor">Current target descriptor</param>
/// <param name="colorAttachmentHandle">Color attachment to render into</param>
/// <param name="depthAttachmentHandle">Depth attachment to render into</param>
/// <param name="configuration">Specific render configuration</param>
public void Setup(
RenderTextureDescriptor baseDescriptor,
RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle,
RendererConfiguration configuration,
SampleCount samples)
{
this._ColorAttachmentHandle = colorAttachmentHandle;
this._DepthAttachmentHandle = depthAttachmentHandle;
_Descriptor = baseDescriptor;
_RendererConfiguration = configuration;
if ((int)samples > 1)
{
baseDescriptor.bindMS = false;
baseDescriptor.msaaSamples = (int)samples;
}
baseDescriptor.colorFormat = RenderTextureFormat.ARGBHalf;
baseDescriptor.depthBufferBits = 0;
_DescriptorAC = baseDescriptor;
baseDescriptor.colorFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RHalf)
? RenderTextureFormat.RHalf
: RenderTextureFormat.ARGBHalf;
_DescriptorAA = baseDescriptor;
_AccumColorHandle.Init("_AccumColor");
_AccumGIHandle.Init("_AccumGI");
_AccumAlphaHandle.Init("_AccumAlpha");
_AccumBinding = new RenderTargetBinding(new RenderTargetIdentifier[]
{
_AccumColorHandle.Identifier(),
_AccumGIHandle.Identifier(),
_AccumAlphaHandle.Identifier(),
},
new RenderBufferLoadAction[]
{
RenderBufferLoadAction.DontCare,
RenderBufferLoadAction.DontCare,
RenderBufferLoadAction.DontCare,
},
new RenderBufferStoreAction[]
{
RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store,
},
_DepthAttachmentHandle.Identifier(),
RenderBufferLoadAction.Load,
RenderBufferStoreAction.DontCare);
}
private void ForwardPass(List <VisibleLight> visibleLights, FrameRenderingConfiguration frameRenderingConfiguration, ref ScriptableRenderContext context, ref LightData lightData, CameraContext cameraContext, CullResults cullResults)
{
SetupShaderConstants(visibleLights, ref context, ref lightData, ref cullResults);
RendererConfiguration rendererSettings = GetRendererSettings(ref lightData);
BeginForwardRendering(ref context, frameRenderingConfiguration, cameraContext);
RenderOpaques(ref context, rendererSettings, cullResults.visibleRenderers, cameraContext);
AfterOpaque(ref context, frameRenderingConfiguration, cameraContext);
RenderTransparents(ref context, rendererSettings, cullResults.visibleRenderers, cameraContext);
AfterTransparent(ref context, frameRenderingConfiguration, cameraContext);
EndForwardRendering(ref context, frameRenderingConfiguration, cameraContext);
}
/// <summary>
/// Configure the pass before execution
/// </summary>
/// <param name="baseDescriptor">Current target descriptor</param>
/// <param name="colorAttachmentHandle">Color attachment to render into</param>
/// <param name="depthAttachmentHandle">Depth attachment to render into</param>
/// <param name="clearFlag">Camera clear flag</param>
/// <param name="clearColor">Camera clear color</param>
/// <param name="configuration">Specific render configuration</param>
public void Setup(
RenderTextureDescriptor baseDescriptor,
RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle,
ClearFlag clearFlag,
Color clearColor,
RendererConfiguration configuration)
{
this.colorAttachmentHandle = colorAttachmentHandle;
this.depthAttachmentHandle = depthAttachmentHandle;
this.clearColor = CoreUtils.ConvertSRGBToActiveColorSpace(clearColor);
this.clearFlag = clearFlag;
descriptor = baseDescriptor;
this.rendererConfiguration = configuration;
}
public override void Execute(ref ScriptableRenderContext context, ref CullResults cullResults, ref RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
bool dynamicBatching = renderingData.supportsDynamicBatching;
SetupShaderConstants(ref context, ref renderingData.cameraData, ref renderingData.lightData, ref renderingData.shadowData);
RendererConfiguration rendererConfiguration = GetRendererConfiguration(renderingData.lightData.totalAdditionalLightsCount);
if (renderingData.cameraData.isStereoEnabled)
{
context.StartMultiEye(camera);
}
RenderOpaques(ref context, ref cullResults, ref renderingData.cameraData, rendererConfiguration, dynamicBatching);
if (renderingData.cameraData.postProcessEnabled &&
renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessRenderContext))
{
OpaquePostProcessSubPass(ref context, ref renderingData.cameraData);
}
if (depthAttachmentHandle != -1)
{
CopyDepthSubPass(ref context, ref renderingData.cameraData);
}
if (renderingData.cameraData.requiresOpaqueTexture)
{
CopyColorSubpass(ref context, ref renderingData.cameraData);
}
RenderTransparents(ref context, ref cullResults, ref renderingData.cameraData, rendererConfiguration, dynamicBatching);
if (renderingData.cameraData.postProcessEnabled)
{
PostProcessPass(ref context, ref renderingData.cameraData);
}
else if (!renderingData.cameraData.isOffscreenRender && colorAttachmentHandle != -1)
{
FinalBlitPass(ref context, ref renderingData.cameraData);
}
if (renderingData.cameraData.isStereoEnabled)
{
context.StopMultiEye(camera);
context.StereoEndRender(camera);
}
}
public Engine(int x, int y)
{
_renderConfig = new RendererConfiguration
{
Width = x,
Height = y
};
// Manager must be set before Initialize is called
_graphics = new GraphicsDeviceManager(this)
{
PreferredBackBufferWidth = _renderConfig.Width,
PreferredBackBufferHeight = _renderConfig.Height
};
_graphics.ApplyChanges();
}
public DepthStencilBufferArrayHolder(Device device,
RendererConfiguration rendererConfiguration, DeferredShadingConfiguration deferredShadingConfiguration)
{
Debug.Assert(device != null && rendererConfiguration != null && deferredShadingConfiguration != null);
this.device = device;
this.rendererConfiguration = rendererConfiguration;
this.deferredShadingConfiguration = deferredShadingConfiguration;
depthStencilViewsReadOnly = new ReadOnlyCollection <DepthStencilView>(depthStencilViews);
shaderResourceViewsReadOnly = new ReadOnlyCollection <ShaderResourceView>(shaderResourceViews);
CreateTexture();
CreateDepthStencilViews();
CreateShaderResourceViews();
}
public DepthStencilBufferArrayHolder(Device device,
RendererConfiguration rendererConfiguration, DeferredShadingConfiguration deferredShadingConfiguration)
{
Debug.Assert(device != null && rendererConfiguration != null && deferredShadingConfiguration != null);
this.device = device;
this.rendererConfiguration = rendererConfiguration;
this.deferredShadingConfiguration = deferredShadingConfiguration;
depthStencilViewsReadOnly = new ReadOnlyCollection<DepthStencilView>(depthStencilViews);
shaderResourceViewsReadOnly = new ReadOnlyCollection<ShaderResourceView>(shaderResourceViews);
CreateTexture();
CreateDepthStencilViews();
CreateShaderResourceViews();
}
private void RenderRendererList(CullResults cullResults,
Camera cam,
ScriptableRenderContext renderContext,
CommandBuffer cmd,
ShaderPassName[] passNames,
RenderQueueRange inRenderQueueRange,
RendererConfiguration rendererConfig = 0,
RenderStateBlock?stateBlock = null,
Material overrideMaterial = null)
{
//if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.displayOpaqueObjects)
// return;
// This is done here because DrawRenderers API lives outside command buffers so we need to make call this before doing any DrawRenders
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
var drawSettings = new DrawRendererSettings(cam, ClusterShaderPassNames.s_EmptyName)
{
rendererConfiguration = rendererConfig,
sorting = { flags = SortFlags.CommonOpaque }
};
for (int i = 0; i < passNames.Length; ++i)
{
drawSettings.SetShaderPassName(i, passNames[i]);
}
if (overrideMaterial != null)
{
drawSettings.SetOverrideMaterial(overrideMaterial, 0);
}
var filterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = inRenderQueueRange
};
if (stateBlock == null)
{
renderContext.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, filterSettings);
}
else
{
renderContext.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, filterSettings, stateBlock.Value);
}
}
public RenderTargetArrayHolder(Device device, RenderTargetDescription description,
RendererConfiguration rendererConfiguration, DeferredShadingConfiguration deferredShadingConfiguration)
{
Debug.Assert(device != null && description != null && rendererConfiguration != null &&
deferredShadingConfiguration != null);
this.device = device;
this.description = description;
this.rendererConfiguration = rendererConfiguration;
this.deferredShadingConfiguration = deferredShadingConfiguration;
renderTargetViewsReadOnly = new ReadOnlyCollection<RenderTargetView>(renderTargetViews);
CreateTexture();
CreateRenderTargetViews();
CreateShaderResourceView();
}
public void Setup(
RenderTextureDescriptor baseDescriptor,
RenderTargetHandle colorAttachmentHandle,
RenderTargetHandle depthAttachmentHandle,
ClearFlag clearFlag,
Color clearColor,
RendererConfiguration configuration,
bool dynamicbatching)
{
this.colorAttachmentHandle = colorAttachmentHandle;
this.depthAttachmentHandle = depthAttachmentHandle;
this.clearColor = clearColor;
this.clearFlag = clearFlag;
descriptor = baseDescriptor;
this.rendererConfiguration = configuration;
this.dynamicBatching = dynamicbatching;
}
public RenderTargetArrayHolder(Device device, RenderTargetDescription description,
RendererConfiguration rendererConfiguration, DeferredShadingConfiguration deferredShadingConfiguration)
{
Debug.Assert(device != null && description != null && rendererConfiguration != null &&
deferredShadingConfiguration != null);
this.device = device;
this.description = description;
this.rendererConfiguration = rendererConfiguration;
this.deferredShadingConfiguration = deferredShadingConfiguration;
renderTargetViewsReadOnly = new ReadOnlyCollection <RenderTargetView>(renderTargetViews);
CreateTexture();
CreateRenderTargetViews();
CreateShaderResourceView();
}
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
{
Init();
Camera camera = renderingData.cameraData.camera;
RenderTextureDescriptor baseDesc = CoreUtils.CreateRenderTextureDescriptor(ref renderingData.cameraData);
RenderTextureDescriptor shadowDesc = baseDesc;
shadowDesc.dimension = TextureDimension.Tex2D;
m_DirectionalShadowPass.Setup(DirectionalShadowmap, ref renderingData.shadowData);
renderer.EnqueuePass(m_DirectionalShadowPass);
if (renderingData.shadowData.supportSoftShadows)
{
if (renderingData.shadowData.shadowType == SoftShadowType.VSM)
{
m_BlurPass.Setup(DirectionalShadowmap, BluredDirectionalShadowmap);
renderer.EnqueuePass(m_BlurPass);
}
}
renderer.EnqueuePass(m_SetupForwardRenderingPass);
m_DepthOnlyPass.Setup(baseDesc, DepthTexture, 1);
renderer.EnqueuePass(m_DepthOnlyPass);
m_ScreenSpaceShadowPass.Setup(baseDesc, ScreenSpaceShadowmap);
renderer.EnqueuePass(m_ScreenSpaceShadowPass);
//m_SetupLWDConstants.Setup();
//renderer.EnqueuePass(m_SetupLWDConstants);
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
RendererConfiguration rendererConfig = RendererConfiguration.None;
m_RenderOpaqueForwardPass.Setup(baseDesc, colorHandle, depthHandle, ScriptableRenderer.GetClearFlag(camera), camera.backgroundColor, rendererConfig);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
//m_FinalBlitPass.Setup(baseDesc, colorHandle);
//renderer.EnqueuePass(m_FinalBlitPass);
}
private void RenderTransparents(ref ScriptableRenderContext context, RendererConfiguration config, FilterResults visibleRenderers, CameraContext cameraContext)
{
var transparentSettings = new DrawRendererSettings(cameraContext.Camera, m_LitPassName);
transparentSettings.SetShaderPassName(1, m_UnlitPassName);
transparentSettings.sorting.flags = SortFlags.CommonTransparent;
transparentSettings.rendererConfiguration = config;
var transparentFilterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.transparent
};
context.DrawRenderers(visibleRenderers, ref transparentSettings, transparentFilterSettings);
// Render objects that did not match any shader pass with error shader
RenderObjectsWithError(ref context, transparentFilterSettings, SortFlags.None, visibleRenderers, cameraContext);
}
public static RendererConfiguration GetRendererConfiguration(int localLightsCount)
{
RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
if (localLightsCount > 0)
{
if (useComputeBufferForPerObjectLightIndices)
{
configuration |= RendererConfiguration.ProvideLightIndices;
}
else
{
configuration |= RendererConfiguration.PerObjectLightIndices8;
}
}
return(configuration);
}
public static RendererConfiguration GetRendererConfiguration(int additionalLightsCount)
{
RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
if (additionalLightsCount > 0)
{
if (useStructuredBufferForLights)
{
configuration |= RendererConfiguration.ProvideLightIndices;
}
else
{
configuration |= RendererConfiguration.PerObjectLightIndices8;
}
}
return(configuration);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
RendererConfiguration config = new RendererConfiguration
{
ShadowsEnabled = true, BloomEnabled = true, HDREnabled = true, PBREnabled = true
};
mViroView = new ViroViewARCore(this, this);
SetContentView(mViroView);
var intent = Intent;
string key = intent.GetStringExtra(IntentProductKey);
ProductApplicationContext context = new ProductApplicationContext();
mSelectedProduct = context.GetProductDb().GetProductByName(key);
View.Inflate(this, Resource.Layout.ar_hud, mViroView);
mHudGroupView = FindViewById <View>(Resource.Id.main_hud_layout);
mHudGroupView.Visibility = ViewStates.Gone;
}
public RayTracer(RendererConfiguration renderConfig)
{
this.renderConfig = renderConfig;
frameBuffer = new Color[renderConfig.Width * renderConfig.Height];
for (int i = 0; i < frameBuffer.Length; i++)
{
frameBuffer[i] = new Color();
}
World = new HitableList(RandomScene());
camera = new Camera(
new Vector3(13f, 2f, 3f),
new Vector3(0f, 0f, 0f),
new Vector3(0f, 1f, 0f),
20,
(float)renderConfig.Width / renderConfig.Height,
0.1f,
10f
);
}
public unsafe DrawRendererSettings(Camera camera, ShaderPassName shaderPassName)
{
this.rendererConfiguration = RendererConfiguration.None;
this.flags = DrawRendererFlags.EnableInstancing;
this.m_OverrideMaterialInstanceId = 0;
this.m_OverrideMaterialPassIdx = 0;
fixed(int *ptr = &this.shaderPassNames.FixedElementField)
{
for (int i = 0; i < DrawRendererSettings.maxShaderPasses; i++)
{
ptr[(IntPtr)i * 4] = -1;
}
}
fixed(int *ptr2 = &this.shaderPassNames.FixedElementField)
{
*ptr2 = shaderPassName.nameIndex;
}
this.rendererConfiguration = RendererConfiguration.None;
this.flags = DrawRendererFlags.EnableInstancing;
DrawRendererSettings.InitializeSortSettings(camera, out this.sorting);
}
private void RenderOpaques(ref ScriptableRenderContext context, RendererConfiguration settings, FilterResults visibleRenderers, CameraContext cameraContext)
{
var camera = cameraContext.Camera;
var opaqueDrawSettings = new DrawRendererSettings(camera, m_LitPassName);
opaqueDrawSettings.SetShaderPassName(1, m_UnlitPassName);
opaqueDrawSettings.sorting.flags = SortFlags.CommonOpaque;
opaqueDrawSettings.rendererConfiguration = settings;
var opaqueFilterSettings = new FilterRenderersSettings(true)
{
renderQueueRange = RenderQueueRange.opaque
};
context.DrawRenderers(visibleRenderers, ref opaqueDrawSettings, opaqueFilterSettings);
// Render objects that did not match any shader pass with error shader
RenderObjectsWithError(ref context, opaqueFilterSettings, SortFlags.None, visibleRenderers, cameraContext);
if (camera.clearFlags == CameraClearFlags.Skybox)
{
context.DrawSkybox(camera);
}
}
public ViewRendererFactory(RendererConfiguration configuration)
{
_configuration = configuration;
_defaultRenderer = _configuration.Renderers.OfType <JsonViewRenderer>().Single();
}
public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
{
Init();
Camera camera = renderingData.cameraData.camera;
renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData);
RenderTextureDescriptor baseDescriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
RenderTextureDescriptor shadowDescriptor = baseDescriptor;
ClearFlag clearFlag = ScriptableRenderer.GetCameraClearFlag(renderingData.cameraData.camera);
shadowDescriptor.dimension = TextureDimension.Tex2D;
bool requiresRenderToTexture = ScriptableRenderer.RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor);
RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;
if (requiresRenderToTexture)
{
colorHandle = ColorAttachment;
depthHandle = DepthAttachment;
var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;
m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
}
bool mainLightShadows = false;
if (renderingData.shadowData.supportsMainLightShadows)
{
mainLightShadows = m_MainLightShadowCasterPass.Setup(MainLightShadowmap, ref renderingData);
if (mainLightShadows)
{
renderer.EnqueuePass(m_MainLightShadowCasterPass);
}
}
renderer.EnqueuePass(m_SetupForwardRenderingPass);
RendererConfiguration rendererConfiguration = ScriptableRenderer.GetRendererConfiguration(renderingData.lightData.additionalLightsCount);
m_SetupLightweightConstants.Setup(renderer.maxVisibleAdditionalLights, renderer.perObjectLightIndices);
renderer.EnqueuePass(m_SetupLightweightConstants);
// GameView at LGRP
if (!renderingData.cameraData.isSceneViewCamera)
{
LookingGlassRenderingInfo info = renderingData.cameraData.lookingGlassInfo;
LookingGlassDeviceConfig config;
LookingGlassRenderInfoPerCamera perCameraInfo;
var cameraDeviceInfo = camera.GetComponent <LookingGlassCameraInfo>();
if (cameraDeviceInfo != null)
{
config = cameraDeviceInfo.config;
perCameraInfo = cameraDeviceInfo.renderInfo;
}
else
{
config = new LookingGlassDeviceConfig();
config.SetUpDefault();
perCameraInfo = new LookingGlassRenderInfoPerCamera();
perCameraInfo.SetupDefault();
}
int depthValue = (info.renderMethod == LookingGlassRenderingInfo.RenderingMethod.RenderMultiPass) ? 0 : 32;
if (tileTexture != null && oldLookingRenderInfo.HaveToRemakeRenderTexture(ref info))
{
tileTexture.Release();
tileTexture = null;
Debug.Log("Recreate RenderTexture");
}
if (tileTexture == null || !tileTexture)
{
tileTexture = new RenderTexture(info.renderTargetW, info.renderTargetH, depthValue);
tileTexture.name = "LookingGlassQuiltTexture";
}
// tile texture draw( changed by method)
switch (info.renderMethod)
{
case LookingGlassRenderingInfo.RenderingMethod.RenderMultiPass:
m_LookingMultiTexturePass.Setup(tileTexture, ref info, ref perCameraInfo);
renderer.EnqueuePass(m_LookingMultiTexturePass);
break;
case LookingGlassRenderingInfo.RenderingMethod.RenderSinglePassInstancing:
m_LookingInstancingRenderPass.Setup(tileTexture, ref info, ref perCameraInfo);
renderer.EnqueuePass(m_LookingInstancingRenderPass);
break;
}
m_LookingFinalPass.SetUp(colorHandle, tileTexture, ref info, ref config);
renderer.EnqueuePass(m_LookingFinalPass);
// info setup
oldLookingRenderInfo = info;
}
// SceneView
else
{
m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, clearFlag, camera.backgroundColor, rendererConfiguration);
renderer.EnqueuePass(m_RenderOpaqueForwardPass);
if (camera.clearFlags == CameraClearFlags.Skybox && RenderSettings.skybox != null)
{
m_DrawSkyboxPass.Setup(colorHandle, depthHandle);
renderer.EnqueuePass(m_DrawSkyboxPass);
}
m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, rendererConfiguration);
renderer.EnqueuePass(m_RenderTransparentForwardPass);
if (!renderingData.cameraData.isOffscreenRender && colorHandle != RenderTargetHandle.CameraTarget)
{
m_FinalBlitPass.Setup(baseDescriptor, colorHandle);
renderer.EnqueuePass(m_FinalBlitPass);
}
}
#if UNITY_EDITOR
if (renderingData.cameraData.isSceneViewCamera)
{
m_SceneViewDepthCopyPass.Setup(DepthTexture);
renderer.EnqueuePass(m_SceneViewDepthCopyPass);
}
#endif
}
