void OnParticlesDrawing(ScriptableRenderContext context, RenderingData data, ScriptableRenderer render)
{
UpdateParticles(data);
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
ForwardRenderer forwardRenderer = render as ForwardRenderer;
cmd.SetRenderTarget(forwardRenderer.ActiveCameraColorRT, forwardRenderer.DepthRT);
cmd.SetGlobalBuffer("particles", m_pingpongBuffer[1 - m_currentBufferIndex]);
cmd.SetGlobalBuffer("quad", quad);
if (enableSorting)
{
cmd.SetGlobalBuffer("indexBuffer", indexBuffer);
particalMat.EnableKeyword("ENABLE_SORTINT");
}
else
{
particalMat.DisableKeyword("ENABLE_SORTINT");
}
cmd.DrawProceduralIndirect(Matrix4x4.identity, particalMat, 0, MeshTopology.Triangles, indirectdrawbuffer);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
public static ForwardRenderer SetClearOptions(this ForwardRenderer forwardRenderer, Color4 color, float depth = 1, byte stencilValue = 0, ClearRendererFlags clearFlags = ClearRendererFlags.ColorAndDepth)
{
forwardRenderer.Clear.Color = new XenkoMath.Color4(color.Red, color.Green, color.Blue, color.Alpha);
forwardRenderer.Clear.ClearFlags = clearFlags;
forwardRenderer.Clear.Depth = depth;
forwardRenderer.Clear.Stencil = stencilValue;
return(forwardRenderer);
}
private void UpdateForwardRenderTag()
{
Camera.main.TryGetComponent <UniversalAdditionalCameraData>(out var baseCameraAdditionalData);
if (baseCameraAdditionalData != null)
{
var render = baseCameraAdditionalData.scriptableRenderer;
ForwardRenderer forwardRenderer = render as ForwardRenderer;
if (forwardRenderer != null)
{
forwardRenderer.ChangeSplitUICameraAndSceneCameraRenderer(out m_RecordTag);
}
}
}
protected override void Initialize()
{
base.Initialize();
_gameTime = new GameTime(TimeSpan.Zero, TimeSpan.Zero);
_gameComponents = new List <GameComponent>();
_services = new GameServiceContainer();
_services.AddService <IGraphicsDeviceService>(new GraphicsDeviceService(graphicsDevice));
_content = new ContentManager(this);
_content.RootDirectory = "Content";
_projectContent = new ContentManager(this);
_projectContent.RootDirectory = EDRegistry.ContentTempPath;
AssetImporter.CreateFolderStructure("Temp");
Application.Content = _content;
Application.GraphicsDevice = GraphicsDevice;
_gameComponents.Add(EDRegistry.Mouse);
_gameComponents.Add(EDRegistry.Keys);
_gameComponents.Add(new Time());
_renderer = new ForwardRenderer();
_renderer.Initialize(_content);
foreach (var component in _gameComponents)
{
component.Initialize();
}
gizmoComponent = new GizmoComponent(GraphicsDevice);
gizmoComponent.ActiveMode = GizmoMode.Translate;
_scene = new EDScene("Root", gizmoComponent);
_scene.Initialize();
_scene.RenderSettings.Skybox.Generate();
MouseDown += C3DEGameHost_MouseDown;
MouseUp += C3DEGameHost_MouseUp;
if (EngineReady != null)
{
EngineReady();
}
}
void OnDepthBounds(ScriptableRenderContext context, RenderingData data, ScriptableRenderer render)
{
if (!enableHizCulling)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(m_DepthboundProfilerTag);
using (new ProfilingSample(cmd, m_DepthboundProfilerTag))
{
ForwardRenderer forwardRenderer = render as ForwardRenderer;
hizBuffer.GeneragteHizTexture(cmd, forwardRenderer.DepthRT, hizBufferCS);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
context.Submit();
}
private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
(shaderFeatures & ShaderFeatures.AdditionalLightShadows) != 0;
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
if (pipelineAsset.supportsTerrainHoles)
{
shaderFeatures |= ShaderFeatures.TerrainHoles;
}
if (pipelineAsset.useFastSRGBLinearConversion)
{
shaderFeatures |= ShaderFeatures.UseFastSRGBLinearConversion;
}
bool hasScreenSpaceShadows = false;
bool hasScreenSpaceOcclusion = false;
bool hasDeferredRenderer = false;
bool withAccurateGbufferNormals = false;
bool withoutAccurateGbufferNormals = false;
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(rendererIndex);
if (renderer is ForwardRenderer)
{
ForwardRenderer forwardRenderer = (ForwardRenderer)renderer;
if (forwardRenderer.renderingMode == RenderingMode.Deferred)
{
hasDeferredRenderer |= true;
withAccurateGbufferNormals |= forwardRenderer.accurateGbufferNormals;
withoutAccurateGbufferNormals |= !forwardRenderer.accurateGbufferNormals;
}
}
// Check for Screen Space Ambient Occlusion Renderer Feature
ScriptableRendererData rendererData = pipelineAsset.m_RendererDataList[rendererIndex];
if (rendererData != null)
{
for (int rendererFeatureIndex = 0; rendererFeatureIndex < rendererData.rendererFeatures.Count; rendererFeatureIndex++)
{
ScriptableRendererFeature rendererFeature = rendererData.rendererFeatures[rendererFeatureIndex];
ScreenSpaceShadows ssshadows = rendererFeature as ScreenSpaceShadows;
hasScreenSpaceShadows |= ssshadows != null;
ScreenSpaceAmbientOcclusion ssao = rendererFeature as ScreenSpaceAmbientOcclusion;
hasScreenSpaceOcclusion |= ssao != null;
}
}
}
if (hasDeferredRenderer)
{
shaderFeatures |= ShaderFeatures.DeferredShading;
}
// We can only strip accurateGbufferNormals related variants if all DeferredRenderers use the same option.
if (withAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithAccurateGbufferNormals;
}
if (withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithoutAccurateGbufferNormals;
}
if (hasScreenSpaceShadows)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceShadows;
}
if (hasScreenSpaceOcclusion)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceOcclusion;
}
return(shaderFeatures);
}
/// <summary>
/// Creates a graphics compositor programatically that renders into a Rendertarget. It can render everything the default Compositor can
/// </summary>
public static GraphicsCompositor CreateOffscreenCompositor(
bool enablePostEffects,
Texture renderTarget,
CameraComponent camera = null,
RenderGroupMask groupMask = RenderGroupMask.All)
{
#region Render stages
var opaqueRenderStage = new RenderStage("Opaque", "Main")
{
SortMode = new StateChangeSortMode()
};
var transparentRenderStage = new RenderStage("Transparent", "Main")
{
SortMode = new BackToFrontSortMode()
};
var shadowMapCaster = new RenderStage("ShadowMapCaster", "ShadowMapCaster")
{
SortMode = new FrontToBackSortMode()
};
var shadowMapCasterrParaboloidRenderStage = new RenderStage("ShadowMapCasterParaboloid", "ShadowMapCasterParaboloid")
{
SortMode = new FrontToBackSortMode()
};
var shadowMapCasterCubeMapRenderStage = new RenderStage("ShadowMapCasterCubeMap", "ShadowMapCasterCubeMap")
{
SortMode = new FrontToBackSortMode()
};
var gBuffer = new RenderStage("GBuffer", "GBuffer")
{
SortMode = new FrontToBackSortMode()
};
#endregion
#region RenderFeatures
var meshRenderFeature = new MeshRenderFeature
{
PipelineProcessors =
{
new MeshPipelineProcessor()
{
TransparentRenderStage = transparentRenderStage
},
new ShadowMeshPipelineProcessor()
{
DepthClipping = false, ShadowMapRenderStage = shadowMapCaster
},
new ShadowMeshPipelineProcessor()
{
DepthClipping = true, ShadowMapRenderStage = shadowMapCasterrParaboloidRenderStage
},
new ShadowMeshPipelineProcessor()
{
DepthClipping = true, ShadowMapRenderStage = shadowMapCasterCubeMapRenderStage
}
},
RenderFeatures =
{
new TransformRenderFeature(),
new SkinningRenderFeature(),
new MaterialRenderFeature(),
new ShadowCasterRenderFeature(),
new ForwardLightingRenderFeature()
{
LightRenderers =
{
new LightAmbientRenderer(),
new LightDirectionalGroupRenderer(),
new LightSkyboxRenderer(),
new LightClusteredPointSpotGroupRenderer(),
new LightPointGroupRenderer()
}
}
},
RenderStageSelectors =
{
new MeshTransparentRenderStageSelector()
{
EffectName = "XenkoForwardShadingEffect",
OpaqueRenderStage = opaqueRenderStage,
TransparentRenderStage = transparentRenderStage,
RenderGroup = groupMask
},
new ShadowMapRenderStageSelector()
{
EffectName = "XenkoForwardShadingEffect.ShadowMapCaster",
ShadowMapRenderStage = shadowMapCaster,
RenderGroup = groupMask
},
new ShadowMapRenderStageSelector()
{
EffectName = "XenkoForwardShadingEffect.ShadowMapCasterParaboloid",
ShadowMapRenderStage = shadowMapCasterrParaboloidRenderStage,
RenderGroup = groupMask
},
new ShadowMapRenderStageSelector()
{
EffectName = "XenkoForwardShadingEffect.ShadowMapCasterCubeMap",
ShadowMapRenderStage = shadowMapCasterCubeMapRenderStage,
RenderGroup = groupMask
},
new MeshTransparentRenderStageSelector()
{
EffectName = "XenkoForwardShadingEffect.ShadowMapCaster",
OpaqueRenderStage = gBuffer,
RenderGroup = groupMask
}
}
};
var spriteRenderFeature = new SpriteRenderFeature()
{
RenderStageSelectors =
{
new SpriteTransparentRenderStageSelector()
{
EffectName = "Test", // TODO: Check this
OpaqueRenderStage = opaqueRenderStage,
TransparentRenderStage = transparentRenderStage,
RenderGroup = groupMask
}
}
};
var backgroundRenderFeature = new BackgroundRenderFeature()
{
RenderStageSelectors =
{
new SimpleGroupToRenderStageSelector()
{
EffectName = "Test",
RenderStage = opaqueRenderStage,
RenderGroup = groupMask
}
}
};
var uiRenderFeature = new UIRenderFeature()
{
RenderStageSelectors =
{
new SimpleGroupToRenderStageSelector()
{
EffectName = "Test",
RenderStage = transparentRenderStage,
RenderGroup = groupMask
}
}
};
var particleEmitterRenderFeature = new ParticleEmitterRenderFeature()
{
RenderStageSelectors =
{
new ParticleEmitterTransparentRenderStageSelector()
{
OpaqueRenderStage = opaqueRenderStage,
TransparentRenderStage = transparentRenderStage,
RenderGroup = groupMask
}
}
};
//TODO: add that when in VL Context (needs VL.Xenko nuget)
//var vlLayerRenderfeature = new LayerRenderFeature()
//{
// RenderStageSelectors =
// {
// new SimpleGroupToRenderStageSelector()
// {
// RenderStage = opaqueRenderStage,
// RenderGroup = groupMask
// }
// }
//};
#endregion
#region Camera slots
var offscreenCameraSlot = new SceneCameraSlot();
if (camera != null)
{
camera.Slot = offscreenCameraSlot.ToSlotId();
}
#endregion
#region post fx
var postProcessingEffects = enablePostEffects
? new PostProcessingEffects
{
ColorTransforms =
{
Transforms =
{
new ToneMap(),
},
},
}
: null;
if (postProcessingEffects != null)
{
postProcessingEffects.DisableAll();
postProcessingEffects.ColorTransforms.Enabled = true;
}
#endregion
#region Renderers
var forwardRenderer = new ForwardRenderer
{
Clear = { ClearFlags = ClearRendererFlags.ColorAndDepth, Color = new Color4(0, 0, 0, 0) },
GBufferRenderStage = gBuffer,
LightProbes = true,
MSAALevel = MultisampleCount.None,
//MSAAResolver = new MSAAResolver() { FilterType = MSAAResolver.FilterTypes.BSpline, FilterRadius = 1.0f },
OpaqueRenderStage = opaqueRenderStage,
ShadowMapRenderStages = { shadowMapCaster },
//SubsurfaceScatteringBlurEffect,
TransparentRenderStage = transparentRenderStage,
// TODO: add postFX once their alpha is sorted out
PostEffects = postProcessingEffects
};
var singleViewforwardRenderer = new ForwardRenderer
{
Clear = { ClearFlags = ClearRendererFlags.ColorAndDepth, Color = new Color4(0, 0, 0, 0) },
GBufferRenderStage = gBuffer,
LightProbes = true,
MSAALevel = MultisampleCount.None,
//MSAAResolver = new MSAAResolver() { FilterType = MSAAResolver.FilterTypes.BSpline, FilterRadius = 1.0f },
OpaqueRenderStage = opaqueRenderStage,
ShadowMapRenderStages = { shadowMapCaster },
//SubsurfaceScatteringBlurEffect,
TransparentRenderStage = transparentRenderStage
};
#endregion
#region Game
var game = new SceneCameraRenderer()
{
Camera = offscreenCameraSlot,
Child = new RenderTextureSceneRenderer()
{
RenderTexture = renderTarget,
Child = forwardRenderer,
}
};
#endregion
return(new GraphicsCompositor
{
Cameras = { offscreenCameraSlot },
RenderStages =
{
opaqueRenderStage,
transparentRenderStage,
shadowMapCaster,
shadowMapCasterrParaboloidRenderStage,
shadowMapCasterCubeMapRenderStage,
gBuffer
},
RenderFeatures =
{
meshRenderFeature,
spriteRenderFeature,
backgroundRenderFeature,
uiRenderFeature,
particleEmitterRenderFeature,
//vlLayerRenderfeature
},
Game = game
});
}
public static GraphicsCompositor GetFirstForwardRenderer(this GraphicsCompositor compositor, out ForwardRenderer forwardRenderer)
{
var topChildRenderer = ((SceneCameraRenderer)compositor.Game).Child;
forwardRenderer = (topChildRenderer as SceneRendererCollection)?.Children.OfType <ForwardRenderer>().FirstOrDefault() ?? (ForwardRenderer)topChildRenderer;
return(compositor);
}
