protected override void PrepareCore(RenderContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
{
skyboxProcessor = SceneInstance.GetProcessor <SkyboxProcessor>();
if (skyboxProcessor == null)
{
return;
}
var skybox = skyboxProcessor.ActiveSkyboxBackground;
// do not draw if no active skybox or the skybox is not included in the current entity group
if (skybox == null || !CurrentCullingMask.Contains(skybox.Entity.Group))
{
return;
}
// Copy camera/pass parameters
context.Parameters.CopySharedTo(skyboxEffect.Parameters);
// Show irradiance in the background
if (skybox.Background == SkyboxBackground.Irradiance)
{
foreach (var parameterKeyValue in skybox.Skybox.DiffuseLightingParameters)
{
if (parameterKeyValue.Key == SkyboxKeys.Shader)
{
skyboxEffect.Parameters.Set(SkyboxKeys.Shader, (ShaderSource)parameterKeyValue.Value);
}
else
{
skyboxEffect.Parameters.SetObject(parameterKeyValue.Key.ComposeWith("skyboxColor"), parameterKeyValue.Value);
}
}
}
else
{
// TODO: Should we better use composition on "skyboxColor" for parameters?
// Copy Skybox parameters
if (skybox.Skybox != null)
{
foreach (var parameterKeyValue in skybox.Skybox.Parameters)
{
if (parameterKeyValue.Key == SkyboxKeys.Shader)
{
skyboxEffect.Parameters.Set(SkyboxKeys.Shader, (ShaderSource)parameterKeyValue.Value);
}
else
{
skyboxEffect.Parameters.SetObject(parameterKeyValue.Key, parameterKeyValue.Value);
}
}
}
}
// Fake as the skybox was in front of all others (as opaque are rendered back to front)
opaqueList.Add(new RenderItem(this, skybox, float.NegativeInfinity));
}
protected override void PrepareCore(RenderDrawContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
{
var uiProcessor = SceneInstance.GetProcessor <UIComponentProcessor>();
if (uiProcessor == null)
{
return;
}
foreach (var uiRoot in uiProcessor.UIRoots)
{
// Perform culling on group and accept
if (!CurrentCullingMask.Contains(uiRoot.UIComponent.Entity.Group))
{
continue;
}
// skips empty UI elements
if (uiRoot.UIComponent.RootElement == null)
{
continue;
}
// Project the position
// TODO: This code is duplicated from SpriteComponent -> unify it at higher level?
var worldPosition = new Vector4(uiRoot.TransformComponent.WorldMatrix.TranslationVector, 1.0f);
float projectedZ;
if (uiRoot.UIComponent.IsFullScreen)
{
projectedZ = -uiRoot.TransformComponent.WorldMatrix.M43;
}
else
{
Vector4 projectedPosition;
var cameraComponent = context.Tags.Get(CameraComponentRendererExtensions.Current);
if (cameraComponent == null)
{
continue;
}
Vector4.Transform(ref worldPosition, ref cameraComponent.ViewProjectionMatrix, out projectedPosition);
projectedZ = projectedPosition.Z / projectedPosition.W;
}
transparentList.Add(new RenderItem(this, uiRoot, projectedZ));
}
}
protected override void PrepareCore(RenderContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
{
spriteProcessor = SceneInstance.GetProcessor <SpriteProcessor>();
if (spriteProcessor == null)
{
return;
}
// If no camera, early exit
var camera = context.GetCurrentCamera();
if (camera == null)
{
return;
}
var viewProjectionMatrix = camera.ViewProjectionMatrix;
foreach (var spriteState in spriteProcessor.Sprites)
{
var sprite = spriteState.SpriteComponent.CurrentSprite;
if (sprite == null)
{
continue;
}
// Perform culling on group and accept
if (!CurrentCullingMask.Contains(spriteState.SpriteComponent.Entity.Group))
{
continue;
}
// Project the position
// TODO: This could be done in a SIMD batch, but we need to figure-out how to plugin in with RenderMesh object
var worldPosition = new Vector4(spriteState.TransformComponent.WorldMatrix.TranslationVector, 1.0f);
Vector4 projectedPosition;
Vector4.Transform(ref worldPosition, ref viewProjectionMatrix, out projectedPosition);
var projectedZ = projectedPosition.Z / projectedPosition.W;
var list = sprite.IsTransparent ? transparentList : opaqueList;
list.Add(new RenderItem(this, spriteState, projectedZ));
}
}
protected override void PrepareCore(RenderContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
{
// If EffectName is not setup, exit
if (effectName == null)
{
return;
}
if (dynamicEffectCompiler == null)
{
dynamicEffectCompiler = new DynamicEffectCompiler(Services, effectName);
}
// If we don't have yet a render slot, create a new one
if (modelRenderSlot < 0)
{
var pipelineModelState = GetOrCreateModelRendererState(context);
// Allocate (or reuse) a slot for the pass of this processor
// Note: The slot is passed as out, so that when ModelRendererState.ModelSlotAdded callback is fired,
// ModelRenderer.modelRenderSlot is valid (it might call PrepareModelForRendering recursively).
modelRenderSlot = pipelineModelState.AllocateModelSlot(EffectName);
}
if (UseCustomRenderModelList)
{
PrepareModels(context, CustomRenderModelList, opaqueList, transparentList);
}
else
{
// Get all meshes from the render model processor
var modelProcessor = SceneInstance.GetProcessor <ModelProcessor>();
foreach (var renderModelGroup in modelProcessor.ModelGroups)
{
// Perform culling on group and accept
if (!CurrentCullingMask.Contains(renderModelGroup.Group))
{
continue;
}
PrepareModels(context, renderModelGroup, opaqueList, transparentList);
}
}
}
protected override void PrepareCore(RenderContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
{
var backgroundProcessor = SceneInstance.GetProcessor <BackgroundComponentProcessor>();
if (backgroundProcessor == null)
{
return;
}
foreach (var backgroundComponent in backgroundProcessor.Backgrounds)
{
// Perform culling on group and accept
if (!CurrentCullingMask.Contains(backgroundComponent.Entity.Group))
{
continue;
}
opaqueList.Add(new RenderItem(this, backgroundComponent, float.NegativeInfinity)); // render background first so that it can replace a clear frame
return; // draw only one background by group
}
}
protected override void PrepareCore(RenderContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
{
// Early out if particle system processor doesn't exist
particleSystemProcessor = SceneInstance.GetProcessor <ParticleSystemProcessor>();
if (particleSystemProcessor == null)
{
return;
}
// Early out if camera doesn't exist
var camera = context.GetCurrentCamera();
if (camera == null)
{
return;
}
var viewProjectionMatrix = camera.ViewProjectionMatrix;
foreach (var particleSystemState in particleSystemProcessor.ParticleSystems)
{
// Perform culling on group and accept
// TODO Should culling be performed on a per-sprite basis or batched?
if (!CurrentCullingMask.Contains(particleSystemState.ParticleSystemComponent.Entity.Group))
{
continue;
}
// Project the position to find depth for sorting
var worldPosition = new Vector4(particleSystemState.TransformComponent.WorldMatrix.TranslationVector, 1.0f);
Vector4 projectedPosition;
Vector4.Transform(ref worldPosition, ref viewProjectionMatrix, out projectedPosition);
var projectedZ = projectedPosition.Z / projectedPosition.W;
//var list = true ? transparentList : opaqueList;
//list.Add(new RenderItem(this, particleSystemState, projectedZ));
transparentList.Add(new RenderItem(this, particleSystemState, projectedZ));
}
}
