public void OnRenderTaskBegin(SceneRenderTask task, GPUContext context)
{
var size = Size;
_modelActor.LocalPosition = new Vector3(size.X * -0.5f, size.Y * -0.5f, DistanceFromOrigin);
if (_cachedSize != size)
{
GenerateGridMesh(_model.LODs[0].Meshes[0], size);
_cachedSize = size;
}
if (!_materialInstance)
{
return;
}
for (int i = 0; i < _inputParameters.Length; i++)
{
if (!HasInput(i + 1))
{
continue;
}
_inputParameters[i].Value = GetInput(i + 1);
}
}
private void OnEnable()
{
// Create backbuffer
if (output == null)
{
output = RenderTarget.New();
}
output.Init(PixelFormat.R8G8B8A8_UNorm, (int)resolution.X, (int)resolution.Y);
// Create rendering task
if (task == null)
{
task = RenderTask.Create <SceneRenderTask>();
}
task.Order = -100;
task.Camera = Cam;
task.Output = output;
task.Enabled = false;
// Use dynamic material instance
if (Material && material == null)
{
material = Material.CreateVirtualInstance();
}
setMaterial = true;
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, RenderTarget input, RenderTarget output)
{
if (Viewport == null)
{
throw new NullReferenceException();
}
Profiler.BeginEventGPU("Editor Primitives");
// Check if use MSAA
var format = output.Format;
GraphicsDevice.GetFeatures(format, out var formatSupport);
bool enableMsaa = formatSupport.MSAALevelMax >= MSAALevel.X4 && Editor.Instance.Options.Options.Visual.EnableMSAAForDebugDraw;
// Prepare
var msaaLevel = enableMsaa ? MSAALevel.X4 : MSAALevel.None;
var width = output.Width;
var height = output.Height;
var target = RenderTarget.GetTemporary(format, width, height, TextureFlags.RenderTarget | TextureFlags.ShaderResource, msaaLevel);
var targetDepth = RenderTarget.GetTemporary(PixelFormat.D24_UNorm_S8_UInt, width, height, TextureFlags.DepthStencil, msaaLevel);
// Copy frame and clear depth
context.Draw(target, input);
context.ClearDepth(targetDepth);
// Draw gizmos (collect draw calls only)
_drawCallsCollector.Clear();
for (int i = 0; i < Viewport.Gizmos.Count; i++)
{
Viewport.Gizmos[i].Draw(_drawCallsCollector);
}
// Draw selected objects debug shapes and visuals
if (DrawDebugDraw)
{
var debugDrawData = Viewport.DebugDrawData;
DebugDraw.Draw(task, debugDrawData.ActorsPtrs, target, context, targetDepth, true);
}
// Draw gizmos (actual drawing)
_drawCallsCollector.ExecuteDrawCalls(context, task, target, RenderPass.ForwardPass);
_drawCallsCollector.ExecuteDrawCalls(context, task, target, RenderPass.GBufferFill);
// Resolve MSAA texture
if (enableMsaa)
{
context.ResolveMultisample(target, output);
}
else
{
context.Draw(output, target);
}
// Cleanup
RenderTarget.ReleaseTemporary(targetDepth);
RenderTarget.ReleaseTemporary(target);
Profiler.EndEventGPU();
}
private void OnUpdate()
{
if (_queue.Count == 0 || (_task != null && _task.Enabled))
{
return;
}
// TODO: add delay when processing the requests to reduce perf impact (eg. 0.2s before actual rendering)
// Setup pipeline
if (_atlases == null)
{
_atlases = new List <Atlas>(4);
}
if (_output == null)
{
_output = GPUDevice.Instance.CreateTexture("CameraCutMedia.Output");
var desc = GPUTextureDescription.New2D(Width, Height, PixelFormat.R8G8B8A8_UNorm);
_output.Init(ref desc);
}
if (_task == null)
{
_task = Object.New <SceneRenderTask>();
_task.Output = _output;
_task.Begin += OnBegin;
_task.End += OnEnd;
}
// Kick off the rendering
_task.Enabled = true;
}
private void OnBegin(SceneRenderTask task, GPUContext context)
{
// Setup
var req = _queue[0];
req.Media.OnThumbnailRenderingBegin(task, context, ref req);
}
/// <summary>
/// Initializes a new instance of the <see cref="EditorGizmoViewport"/> class.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="undo">The undo.</param>
public EditorGizmoViewport(SceneRenderTask task, Undo undo)
: base(task, new FPSCamera(), true)
{
Undo = undo;
SetUpdate(ref _update, OnUpdate);
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, RenderTarget input, RenderTarget output)
{
// Pick a temporary depth buffer
var customDepth = RenderTarget.GetTemporary(PixelFormat.R32_Typeless, input.Width, input.Height, TextureFlags.DepthStencil | TextureFlags.ShaderResource);
context.ClearDepth(customDepth);
// Render selected objects depth
var actors = Editor.Instance.SceneEditing.Selection.ConvertAll(x => (x as ActorNode)?.Actor).ToArray();
context.DrawSceneDepth(task, customDepth, true, actors, ActorsSources.CustomActors);
var near = task.View.Near;
var far = task.View.Far;
var projection = task.View.Projection;
// Render outline
_material.GetParam("OutlineColor0").Value = OutlineColor0;
_material.GetParam("OutlineColor1").Value = OutlineColor1;
_material.GetParam("CustomDepth").Value = customDepth;
_material.GetParam("ViewInfo").Value = new Vector4(1.0f / projection.M11, 1.0f / projection.M22, far / (far - near), (-far * near) / (far - near) / far);
context.DrawPostFxMaterial(_material, output, input, task);
// Cleanup
RenderTarget.ReleaseTemporary(customDepth);
}
/// <summary>
/// Called when thumbnail rendering ends. The task output buffer contains ready frame.
/// </summary>
/// <param name="task">The scene rendering task to customize.</param>
/// <param name="context">The GPU rendering context.</param>
/// <param name="req">The request data.</param>
/// <param name="sprite">The thumbnail sprite.</param>
public void OnThumbnailRenderingEnd(SceneRenderTask task, GPUContext context, ref CameraCutThumbnailRenderer.Request req, ref Sprite sprite)
{
var image = _thumbnails[req.ThumbnailIndex];
if (image == null)
{
if (req.ThumbnailIndex == 0)
{
image = new Image(2, 2, CameraCutThumbnailRenderer.Width, CameraCutThumbnailRenderer.Height)
{
AnchorStyle = AnchorStyle.Left,
}
}
;
else
{
image = new Image(Width - 2 - CameraCutThumbnailRenderer.Width, 2, CameraCutThumbnailRenderer.Width, CameraCutThumbnailRenderer.Height)
{
AnchorStyle = AnchorStyle.Right,
}
};
image.Parent = this;
image.UnlockChildrenRecursive();
_thumbnails[req.ThumbnailIndex] = image;
UpdateUI();
}
else if (image.Brush != null)
{
Timeline.CameraCutThumbnailRenderer.ReleaseThumbnail(((SpriteBrush)image.Brush).Sprite);
image.Brush = null;
}
image.Brush = new SpriteBrush(sprite);
}
private void OnUpdate()
{
if (_queue.Count == 0 || (_task != null && _task.Enabled))
{
return;
}
// TODO: add delay when processing the requests to reduce perf impact (eg. 0.2s before actual rendering)
// Setup pipeline
if (_atlases == null)
{
_atlases = new List <Atlas>(4);
}
if (_output == null)
{
_output = RenderTarget.New();
_output.Init(PixelFormat.R8G8B8A8_UNorm, Width, Height);
}
if (_task == null)
{
_task = Object.New <SceneRenderTask>();
_task.Output = _output;
_task.Begin += OnBegin;
_task.End += OnEnd;
}
// Kick off the rendering
_task.Enabled = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="EditorViewportArcBallCam"/> class.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="useWidgets">Enable/disable viewport widgets.</param>
/// <param name="orbitRadius">The orbit radius.</param>
/// <param name="orbitCenter">The orbit center position.</param>
public EditorViewportArcBallCam(SceneRenderTask task, bool useWidgets, float orbitRadius, Vector3 orbitCenter)
: base(task, useWidgets)
{
_orbitRadius = orbitRadius;
_orbitCenter = orbitCenter;
UpdatePosition();
}
/// <summary>
/// Initializes a new instance of the <see cref="EditorGizmoViewport"/> class.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="undo">The undo.</param>
/// <param name="sceneGraphRoot">The scene graph root.</param>
public EditorGizmoViewport(SceneRenderTask task, Undo undo, SceneGraph.RootNode sceneGraphRoot)
: base(task, new FPSCamera(), true)
{
Undo = undo;
SceneGraphRoot = sceneGraphRoot;
SetUpdate(ref _update, OnUpdate);
}
private void RenderTaskOnEnd(SceneRenderTask task, GPUContext context)
{
// Render editor primitives, gizmo and debug shapes in debug view modes
if (task.Mode != ViewMode.Default)
{
// Note: can use Output buffer as both input and output because EditorPrimitives is using a intermediate buffers
EditorPrimitives.Render(context, task, task.Output, task.Output);
}
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, GPUTexture input, GPUTexture output)
{
if (Viewport == null)
{
throw new NullReferenceException();
}
Profiler.BeginEventGPU("Editor Primitives");
// Check if use MSAA
var format = output.Format;
GPUDevice.GetFeatures(format, out var formatSupport);
bool enableMsaa = formatSupport.MSAALevelMax >= MSAALevel.X4 && Editor.Instance.Options.Options.Visual.EnableMSAAForDebugDraw;
// Prepare
var msaaLevel = enableMsaa ? MSAALevel.X4 : MSAALevel.None;
var width = output.Width;
var height = output.Height;
var desc = GPUTextureDescription.New2D(width, height, format, GPUTextureFlags.RenderTarget | GPUTextureFlags.ShaderResource, 1, 1, msaaLevel);
var target = RenderTargetPool.Get(ref desc);
desc = GPUTextureDescription.New2D(width, height, PixelFormat.D24_UNorm_S8_UInt, GPUTextureFlags.DepthStencil, 1, 1, msaaLevel);
var targetDepth = RenderTargetPool.Get(ref desc);
// Copy frame and clear depth
context.Draw(target, input);
context.ClearDepth(targetDepth);
// Draw gizmos and other editor primitives (collect draw calls only)
_drawCallsCollector.Clear();
for (int i = 0; i < Viewport.Gizmos.Count; i++)
{
Viewport.Gizmos[i].Draw(_drawCallsCollector);
}
Viewport.DrawEditorPrimitives(context, task, target, targetDepth, _drawCallsCollector);
// Draw gizmos (actual drawing)
_drawCallsCollector.ExecuteDrawCalls(context, task, target, DrawPass.GBuffer);
_drawCallsCollector.ExecuteDrawCalls(context, task, target, DrawPass.Forward);
// Resolve MSAA texture
if (enableMsaa)
{
context.ResolveMultisample(target, output);
}
else
{
context.Draw(output, target);
}
// Cleanup
RenderTargetPool.Release(targetDepth);
RenderTargetPool.Release(target);
Profiler.EndEventGPU();
}
public override void OnEnable()
{
base.OnEnable();
Output = CreateOutputTexture(Size);
RenderTask = FlaxEngine.Object.New <SceneRenderTask>();
RenderTask.Order = Order;
RenderTask.Camera = Camera;
RenderTask.ActorsSource = ActorsSources.Scenes;
RenderTask.Output = Output;
RenderTask.Begin += OnRenderTaskBegin;
RenderTask.End += OnRenderTaskEnd;
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, GPUTexture input, GPUTexture output)
{
Profiler.BeginEventGPU("Editor Primitives");
for (int i = 0; i < SceneManager.ScenesCount; i++)
{
var scene = SceneManager.GetScene(i);
ViewportIconsRenderer.DrawIcons(context, task, input, task.Buffers.DepthBuffer, scene);
}
Profiler.EndEventGPU();
}
/// <summary>
/// Called when ask rendering ends.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="context">The GPU execution context.</param>
protected virtual void OnEnd(SceneRenderTask task, GPUContext context)
{
// Check if was using old backbuffer
if (_backBufferOld)
{
_oldBackbufferLiveTimeLeft--;
if (_oldBackbufferLiveTimeLeft < 0)
{
Object.Destroy(ref _backBufferOld);
}
}
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, RenderTarget input, RenderTarget output)
{
Profiler.BeginEventGPU("Editor Primitives");
// Check if use MSAA
// TODO: add edito option to switch between msaa and non-msaa
bool enableMsaa = true;
// Prepare
var editor = Editor.Instance;
var viewport = editor.Windows.EditWin.Viewport;
var msaaLevel = enableMsaa ? MSAALevel.X4 : MSAALevel.None;
var width = output.Width;
var height = output.Height;
var target = RenderTarget.GetTemporary(output.Format, width, height, TextureFlags.RenderTarget | TextureFlags.ShaderResource, msaaLevel);
var targetDepth = RenderTarget.GetTemporary(PixelFormat.D24_UNorm_S8_UInt, width, height, TextureFlags.DepthStencil, msaaLevel);
// Copy frame and clear depth
context.Draw(target, input);
context.ClearDepth(targetDepth);
// Draw gizmos (collect draw calls only)
_drawCallsCollector.Clear();
for (int i = 0; i < viewport.Gizmos.Count; i++)
{
viewport.Gizmos[i].Draw(_drawCallsCollector);
}
// Draw selected objects debug shapes and visuals
var debugDrawData = viewport.DebugDrawData;
DebugDraw.Draw(task, debugDrawData.ActorsPtrs, target, context, targetDepth, true);
// Draw gizmos (actual drawing)
_drawCallsCollector.ExecuteDrawCalls(context, task, target, RenderPass.ForwardPass);
// Resolve MSAA texture
if (enableMsaa)
{
context.ResolveMultisample(target, output);
}
else
{
context.Draw(output, target);
}
// Cleanup
RenderTarget.ReleaseTemporary(targetDepth);
RenderTarget.ReleaseTemporary(target);
Profiler.EndEventGPU();
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, RenderTarget input, RenderTarget output)
{
Profiler.BeginEventGPU("Selection Outline");
// Pick a temporary depth buffer
var customDepth = RenderTarget.GetTemporary(PixelFormat.R32_Typeless, input.Width, input.Height, TextureFlags.DepthStencil | TextureFlags.ShaderResource);
context.ClearDepth(customDepth);
// Get selected actors
var selection = SelectionGetter();
if (_actors == null)
{
_actors = new List <Actor>();
}
else
{
_actors.Clear();
}
_actors.Capacity = Mathf.NextPowerOfTwo(Mathf.Max(_actors.Capacity, selection.Count));
for (int i = 0; i < selection.Count; i++)
{
if (selection[i] is ActorNode actorNode)
{
_actors.Add(actorNode.Actor);
}
}
// Render selected objects depth
context.DrawSceneDepth(task, customDepth, true, _actors, ActorsSources.CustomActors);
_actors.Clear();
var near = task.View.Near;
var far = task.View.Far;
var projection = task.View.Projection;
// Render outline
_material.GetParam("OutlineColor0").Value = _color0;
_material.GetParam("OutlineColor1").Value = _color1;
_material.GetParam("CustomDepth").Value = customDepth;
_material.GetParam("ViewInfo").Value = new Vector4(1.0f / projection.M11, 1.0f / projection.M22, far / (far - near), (-far * near) / (far - near) / far);
context.DrawPostFxMaterial(_material, output, input, task);
// Cleanup
RenderTarget.ReleaseTemporary(customDepth);
Profiler.EndEventGPU();
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderOutputControl"/> class.
/// </summary>
/// <param name="task">The task. Cannot be null.</param>
/// <exception cref="System.ArgumentNullException">Invalid task.</exception>
public RenderOutputControl(SceneRenderTask task)
{
if (task == null)
{
throw new ArgumentNullException();
}
_backBuffer = RenderTarget.New();
_resizeTime = ResizeCheckTime;
_task = task;
_task.Output = _backBuffer;
_task.CanSkipRendering += CanSkipRendering;
_task.End += OnEnd;
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderOutputControl"/> class.
/// </summary>
/// <param name="task">The task. Cannot be null.</param>
/// <exception cref="System.ArgumentNullException">Invalid task.</exception>
public RenderOutputControl(SceneRenderTask task)
{
if (task == null)
{
throw new ArgumentNullException();
}
_backBuffer = GPUDevice.Instance.CreateTexture();
_resizeTime = ResizeCheckTime;
_task = task;
_task.Output = _backBuffer;
_task.End += OnEnd;
Scripting.Update += OnUpdate;
}
/// <summary>
/// Draws the selected object to depth buffer.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="task">The task.</param>
/// <param name="customDepth">The custom depth (output).</param>
protected virtual void DrawSelectionDepth(GPUContext context, SceneRenderTask task, RenderTarget customDepth)
{
// Get selected actors
var selection = SelectionGetter();
_actors.Capacity = Mathf.NextPowerOfTwo(Mathf.Max(_actors.Capacity, selection.Count));
for (int i = 0; i < selection.Count; i++)
{
if (selection[i] is ActorNode actorNode)
{
_actors.Add(actorNode.Actor);
}
}
// Render selected objects depth
context.DrawSceneDepth(task, customDepth, true, _actors, ActorsSources.CustomActors);
}
public override void OnEnable()
{
base.OnEnable();
if (!Material || !Material.IsSurface)
{
return;
}
Material.WaitForLoaded();
_materialInstance = Material.CreateVirtualInstance();
_inputParameters = GetPublicParameters(_materialInstance);
var size = Size;
_orthographicCamera = CreateOrthographicCamera();
_model = Content.CreateVirtualAsset <Model>();
_model.SetupLODs(1);
_model.SetupMaterialSlots(1);
_model.MinScreenSize = 0;
// TODO: Optimize, use instanced rendering and whatnot
GenerateGridMesh(_model.LODs[0].Meshes[0], size);
_cachedSize = size;
_modelActor = FlaxEngine.Object.New <StaticModel>();
_modelActor.Model = _model;
_modelActor.DrawModes = DrawPass.Depth | DrawPass.GBuffer; // TODO: Optionally enable transparency?
_modelActor.Entries[0].ReceiveDecals = false;
_modelActor.Entries[0].ShadowsMode = ShadowsCastingMode.None;
_modelActor.Entries[0].Material = _materialInstance;
_modelActor.LocalPosition = new Vector3(size * -0.5f, DistanceFromOrigin);
Output = CreateOutputTexture(Size);
RenderTask = FlaxEngine.Object.New <SceneRenderTask>();
RenderTask.AllowGlobalCustomPostFx = false;
RenderTask.Order = Order;
RenderTask.Camera = _orthographicCamera;
RenderTask.ActorsSource = ActorsSources.CustomActors;
RenderTask.Output = Output;
RenderTask.Begin += OnRenderTaskBegin;
RenderTask.End += OnRenderTaskEnd;
RenderTask.CustomActors.Add(_modelActor);
RenderTask.View.MaxShadowsQuality = Quality.Low;
RenderTask.View.Mode = ViewMode.Emissive;
RenderTask.View.Flags = ViewFlags.None;
}
/// <summary>
/// Called when thumbnail rendering ends. The task output buffer contains ready frame.
/// </summary>
/// <param name="task">The scene rendering task to customize.</param>
/// <param name="context">The GPU rendering context.</param>
/// <param name="req">The request data.</param>
/// <param name="sprite">The thumbnail sprite.</param>
public void OnThumbnailRenderingEnd(SceneRenderTask task, GPUContext context, ref CameraCutThumbnailRenderer.Request req, ref SpriteHandle sprite)
{
var image = _thumbnails[req.ThumbnailIndex];
if (image == null)
{
if (req.ThumbnailIndex == 0)
{
image = new Image
{
AnchorPreset = AnchorPresets.MiddleLeft,
Parent = this,
Bounds = new Rectangle(2, 2, CameraCutThumbnailRenderer.Width, CameraCutThumbnailRenderer.Height),
};
}
else if (req.ThumbnailIndex == 1)
{
image = new Image
{
AnchorPreset = AnchorPresets.MiddleRight,
Parent = this,
Bounds = new Rectangle(Width - 2 - CameraCutThumbnailRenderer.Width, 2, CameraCutThumbnailRenderer.Width, CameraCutThumbnailRenderer.Height),
};
}
else
{
image = new Image
{
AnchorPreset = AnchorPresets.MiddleCenter,
Parent = this,
Bounds = new Rectangle(Width * 0.5f - 1 - CameraCutThumbnailRenderer.Width * 0.5f, 2, CameraCutThumbnailRenderer.Width, CameraCutThumbnailRenderer.Height),
};
}
image.UnlockChildrenRecursive();
_thumbnails[req.ThumbnailIndex] = image;
UpdateUI();
}
else if (image.Brush != null)
{
Timeline.CameraCutThumbnailRenderer.ReleaseThumbnail(((SpriteBrush)image.Brush).Sprite);
image.Brush = null;
}
image.Brush = new SpriteBrush(sprite);
}
private void RenderTaskOnBegin(SceneRenderTask task, GPUContext context)
{
_debugDrawData.Clear();
// Collect selected objects debug shapes and visuals
var selectedParents = TransformGizmo.SelectedParents;
if (selectedParents.Count > 0)
{
for (int i = 0; i < selectedParents.Count; i++)
{
if (selectedParents[i].IsActiveInHierarchy)
{
selectedParents[i].OnDebugDraw(_debugDrawData);
}
}
}
}
/// <summary>
/// Takes the screenshot of the current viewport.
/// </summary>
public void TakeScreenshot()
{
// Select task
SceneRenderTask target = null;
if (Editor.Windows.EditWin.IsSelected)
{
// Use editor window
target = EditWin.Viewport.Task;
}
else
{
// Use game window
GameWin.FocusOrShow();
}
// Fire screenshot taking
Screenshot.Capture(target);
}
private void OnEnable()
{
// Create backbuffer
if (_output == null)
{
_output = RenderTarget.New();
}
_output.Init(PixelFormat.R8G8B8A8_UNorm, (int)_resolution.X, (int)_resolution.Y);
// Create rendering task
if (_task == null)
{
_task = RenderTask.Create <SceneRenderTask>();
}
_task.Order = -100;
_task.Camera = Cam;
_task.Output = _output;
_task.Enabled = false;
if (Material && _material == null)
{
// Use dynamic material instance
if (Material.WaitForLoaded())
{
throw new Exception("Failed to load material.");
}
_material = Material.CreateVirtualInstance();
// Set render task output to draw on model
_material.GetParam("Image").Value = _output;
// Bind material to parent model
if (Actor is StaticModel staticModel && staticModel.Model)
{
staticModel.Model.WaitForLoaded();
staticModel.Entries[0].Material = _material;
}
}
_task.Enabled = true;
}
/// <inheritdoc />
protected override void DrawSelectionDepth(GPUContext context, SceneRenderTask task, GPUTexture customDepth)
{
var foliage = GizmoMode.SelectedFoliage;
if (!foliage)
{
return;
}
var instanceIndex = GizmoMode.SelectedInstanceIndex;
if (instanceIndex < 0 || instanceIndex >= foliage.InstancesCount)
{
return;
}
// Draw single instance
var instance = foliage.GetInstance(instanceIndex);
var model = foliage.GetFoliageType(instance.Type).Model;
if (model)
{
Transform instanceWorld = foliage.Transform.LocalToWorld(instance.Transform);
if (!_staticModel)
{
_staticModel = new StaticModel
{
StaticFlags = StaticFlags.None
};
}
_staticModel.Model = model;
_staticModel.Transform = instanceWorld;
_actors.Add(_staticModel);
Renderer.DrawSceneDepth(context, task, customDepth, _actors);
}
}
/// <inheritdoc />
public override void Render(GPUContext context, SceneRenderTask task, RenderTarget input, RenderTarget output)
{
Profiler.BeginEventGPU("Selection Outline");
// Pick a temporary depth buffer
var customDepth = RenderTarget.GetTemporary(PixelFormat.R32_Typeless, input.Width, input.Height, TextureFlags.DepthStencil | TextureFlags.ShaderResource);
context.ClearDepth(customDepth);
// Draw objects to depth buffer
if (_actors == null)
{
_actors = new List <Actor>();
}
else
{
_actors.Clear();
}
DrawSelectionDepth(context, task, customDepth);
_actors.Clear();
var near = task.View.Near;
var far = task.View.Far;
var projection = task.View.Projection;
// Render outline
_material.GetParam("OutlineColor0").Value = _color0;
_material.GetParam("OutlineColor1").Value = _color1;
_material.GetParam("CustomDepth").Value = customDepth;
_material.GetParam("ViewInfo").Value = new Vector4(1.0f / projection.M11, 1.0f / projection.M22, far / (far - near), (-far * near) / (far - near) / far);
context.DrawPostFxMaterial(_material, output, input, task);
// Cleanup
RenderTarget.ReleaseTemporary(customDepth);
Profiler.EndEventGPU();
}
/// <inheritdoc />
protected override void DrawSelectionDepth(GPUContext context, SceneRenderTask task, RenderTarget customDepth)
{
var foliage = GizmoMode.SelectedFoliage;
if (!foliage)
{
return;
}
var instanceIndex = GizmoMode.SelectedInstanceIndex;
if (instanceIndex < 0 || instanceIndex >= foliage.InstancesCount)
{
return;
}
// Draw single instance
foliage.GetInstance(instanceIndex, out var instance);
var model = foliage.GetFoliageTypeModel(instance.Type);
if (model)
{
Transform instanceWorld = foliage.Transform.LocalToWorld(instance.Transform);
if (!_staticModel)
{
_staticModel = StaticModel.New();
_staticModel.StaticFlags = StaticFlags.None;
}
_staticModel.Model = model;
_staticModel.Transform = instanceWorld;
_actors.Add(_staticModel);
context.DrawSceneDepth(task, customDepth, true, _actors, ActorsSources.CustomActors);
}
}
/// <summary> /// Performs custom postFx rendering. /// </summary> /// <param name="context">The GPU commands context.</param> /// <param name="task">The current rendering task.</param> /// <param name="input">The input texture.</param> /// <param name="output">The output texture.</param> public abstract void Render(GPUContext context, SceneRenderTask task, RenderTarget input, RenderTarget output);
