private void OnDraw(DrawCallsCollector collector)
{
for (int i = 0; i < Gizmos.Count; i++)
{
Gizmos[i].Draw(collector);
}
}
/// <inheritdoc />
public override void Draw(DrawCallsCollector collector)
{
base.Draw(collector);
if (!IsActive)
{
return;
}
var terrain = SelectedTerrain;
if (!terrain)
{
return;
}
if (Mode.HasValidHit)
{
var brushPosition = Mode.CursorPosition;
var brushColor = new Color(1.0f, 0.85f, 0.0f); // TODO: expose to editor options
var brushMaterial = Mode.CurrentBrush.GetBrushMaterial(ref brushPosition, ref brushColor);
if (!brushMaterial)
{
return;
}
for (int i = 0; i < Mode.ChunksUnderCursor.Count; i++)
{
var chunk = Mode.ChunksUnderCursor[i];
collector.AddDrawCall(terrain, ref chunk.PatchCoord, ref chunk.ChunkCoord, brushMaterial);
}
}
}
/// <inheritdoc />
public override void Draw(DrawCallsCollector collector)
{
base.Draw(collector);
if (!IsActive)
{
return;
}
var terrain = SelectedTerrain;
if (!terrain)
{
return;
}
GetAssets();
switch (Mode.EditMode)
{
case EditTerrainGizmoMode.Modes.Edit:
{
// Highlight selected chunk
var patchCoord = Mode.SelectedPatchCoord;
var chunkCoord = Mode.SelectedChunkCoord;
collector.AddDrawCall(terrain, ref patchCoord, ref chunkCoord, _highlightTerrainMaterial);
break;
}
case EditTerrainGizmoMode.Modes.Add:
{
// Highlight patch to add location
var patchCoord = Mode.SelectedPatchCoord;
if (!terrain.HasPatch(ref patchCoord) && _planeModel)
{
var planeSize = 256.0f;
var patchSize = terrain.ChunkSize * FlaxEngine.Terrain.UnitsPerVertex * FlaxEngine.Terrain.PatchEdgeChunksCount;
Matrix world = Matrix.RotationZ(-Mathf.PiOverTwo) *
Matrix.Scaling(patchSize / planeSize) *
Matrix.Translation(patchSize * (0.5f + patchCoord.X), 0, patchSize * (0.5f + patchCoord.Y)) *
Matrix.Scaling(terrain.Scale) *
Matrix.RotationQuaternion(terrain.Orientation) *
Matrix.Translation(terrain.Position);
collector.AddDrawCall(_planeModel, 0, _highlightMaterial, 0, ref world);
}
break;
}
case EditTerrainGizmoMode.Modes.Remove:
{
// Highlight selected patch
var patchCoord = Mode.SelectedPatchCoord;
collector.AddDrawCall(terrain, ref patchCoord, _highlightTerrainMaterial);
break;
}
}
}
private void RenderTaskOnDraw(DrawCallsCollector collector)
{
if (_previewStaticModel)
{
_debugDrawData.HighlightModel(_previewStaticModel, _previewModelEntryIndex);
}
_debugDrawData.OnDraw(collector);
}
/// <summary>
/// Called when task calls <see cref="SceneRenderTask.Draw" /> event.
/// </summary>
/// <param name="collector">The draw calls collector.</param>
public virtual void OnDraw(DrawCallsCollector collector)
{
if (_highlightMaterial == null)
{
return;
}
Matrix m1, m2, world;
for (var i = 0; i < _highlights.Count; i++)
{
HighlightData highlight = _highlights[i];
if (highlight.Target is StaticModel staticModel)
{
if (staticModel.Model == null)
{
continue;
}
staticModel.Transform.GetWorld(out m1);
staticModel.Entries[highlight.EntryIndex].Transform.GetWorld(out m2);
Matrix.Multiply(ref m2, ref m1, out world);
BoundingSphere bounds = BoundingSphere.FromBox(staticModel.Box);
collector.AddDrawCall(staticModel.Model, highlight.EntryIndex, _highlightMaterial, ref bounds, ref world);
}
}
if (_highlightTriangles.Count > 0)
{
var mesh = _highlightTrianglesModel.LODs[0].Meshes[0];
if (!Utils.ArraysEqual(_highlightTrianglesSet, _highlightTriangles))
{
_highlightIndicesSet = new int[_highlightTriangles.Count];
for (int i = 0; i < _highlightIndicesSet.Length; i++)
{
_highlightIndicesSet[i] = i;
}
_highlightTrianglesSet = _highlightTriangles.ToArray();
mesh.UpdateMesh(_highlightTrianglesSet, _highlightIndicesSet);
}
world = Matrix.Identity;
collector.AddDrawCall(mesh, _highlightMaterial, ref world);
}
}
/// <inheritdoc />
public override void Draw(DrawCallsCollector collector)
{
base.Draw(collector);
if (!IsActive)
{
return;
}
var foliage = SelectedFoliage;
if (!foliage)
{
return;
}
if (Mode.HasValidHit)
{
var brushPosition = Mode.CursorPosition;
var brushNormal = Mode.CursorNormal;
var brushColor = new Color(1.0f, 0.85f, 0.0f); // TODO: expose to editor options
var sceneDepth = Owner.RenderTask.Buffers.DepthBuffer;
var brushMaterial = Mode.CurrentBrush.GetBrushMaterial(ref brushPosition, ref brushColor, sceneDepth);
if (!_brushModel)
{
_brushModel = FlaxEngine.Content.LoadAsyncInternal <Model>("Editor/Primitives/Sphere");
}
// Draw paint brush
if (_brushModel && brushMaterial)
{
Quaternion rotation;
if (brushNormal == Vector3.Down)
{
rotation = Quaternion.RotationZ(Mathf.Pi);
}
else
{
rotation = Quaternion.LookRotation(Vector3.Cross(Vector3.Cross(brushNormal, Vector3.Forward), brushNormal), brushNormal);
}
Matrix transform = Matrix.Scaling(Mode.CurrentBrush.Size * 0.01f) * Matrix.RotationQuaternion(rotation) * Matrix.Translation(brushPosition);
collector.AddDrawCall(_brushModel, 0, brushMaterial, 0, ref transform, StaticFlags.None, false);
}
}
}
/// <inheritdoc />
public override void Draw(DrawCallsCollector collector)
{
base.Draw(collector);
if (!IsActive || !_highlightMaterial)
{
return;
}
var foliage = Mode.SelectedFoliage;
if (!foliage)
{
return;
}
var instanceIndex = Mode.SelectedInstanceIndex;
if (instanceIndex < 0 || instanceIndex >= foliage.InstancesCount)
{
return;
}
foliage.GetInstance(instanceIndex, out var instance);
var model = foliage.GetFoliageTypeModel(instance.Type);
if (model)
{
Matrix world;
foliage.GetLocalToWorldMatrix(out world);
Matrix matrix;
instance.Transform.GetWorld(out matrix);
Matrix instanceWorld;
Matrix.Multiply(ref matrix, ref world, out instanceWorld);
collector.AddDrawCall(model, _highlightMaterial, ref instance.Bounds, ref instanceWorld, StaticFlags.None, false);
}
}
/// <inheritdoc />
public override void Draw(DrawCallsCollector collector)
{
if (!_isActive || !IsActive)
{
return;
}
Matrix m1, m2, m3;
bool isXAxis = _activeAxis == Axis.X || _activeAxis == Axis.XY || _activeAxis == Axis.ZX;
bool isYAxis = _activeAxis == Axis.Y || _activeAxis == Axis.XY || _activeAxis == Axis.YZ;
bool isZAxis = _activeAxis == Axis.Z || _activeAxis == Axis.YZ || _activeAxis == Axis.ZX;
bool isCenter = _activeAxis == Axis.Center;
// Switch mode
const float gizmoModelsScale2RealGizmoSize = 0.075f;
switch (_activeMode)
{
case Mode.Translate:
{
if (!_modelTranslateAxis || !_modelTranslateAxis.IsLoaded || !_modelBox || !_modelBox.IsLoaded)
{
break;
}
// Cache data
Matrix.Scaling(gizmoModelsScale2RealGizmoSize, out m3);
Matrix.Multiply(ref m3, ref _gizmoWorld, out m1);
var axisMesh = _modelTranslateAxis.LODs[0].Meshes[0];
var boxMesh = _modelBox.LODs[0].Meshes[0];
var boxSize = 10.0f;
// XY plane
m2 = Matrix.Transformation(new Vector3(boxSize, 1.0f, boxSize), Quaternion.RotationX(Mathf.PiOverTwo), new Vector3(boxSize * 0.5f, boxSize * 0.5f, 0.0f));
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(boxMesh, _activeAxis == Axis.XY ? _materialWireFocus : _materialWire, ref m3);
// ZX plane
m2 = Matrix.Transformation(new Vector3(boxSize, 1.0f, boxSize), Quaternion.Identity, new Vector3(boxSize * 0.5f, 0.0f, boxSize * 0.5f));
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(boxMesh, _activeAxis == Axis.ZX ? _materialWireFocus : _materialWire, ref m3);
// YZ plane
m2 = Matrix.Transformation(new Vector3(boxSize, 1.0f, boxSize), Quaternion.RotationZ(Mathf.PiOverTwo), new Vector3(0.0f, boxSize * 0.5f, boxSize * 0.5f));
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(boxMesh, _activeAxis == Axis.YZ ? _materialWireFocus : _materialWire, ref m3);
// X axis
collector.AddDrawCall(axisMesh, isXAxis ? _materialAxisFocus : _materialAxisX, ref m1);
// Y axis
Matrix.RotationZ(Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(axisMesh, isYAxis ? _materialAxisFocus : _materialAxisY, ref m3);
// Z axis
Matrix.RotationY(-Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(axisMesh, isZAxis ? _materialAxisFocus : _materialAxisZ, ref m3);
break;
}
case Mode.Rotate:
{
if (!_modelCircle || !_modelCircle.IsLoaded || !_modelBox || !_modelBox.IsLoaded)
{
break;
}
// Cache data
var circleMesh = _modelCircle.LODs[0].Meshes[0];
var boxMesh = _modelBox.LODs[0].Meshes[0];
Matrix.Scaling(8.0f, out m3);
Matrix.Multiply(ref m3, ref _gizmoWorld, out m1);
// X axis
Matrix.RotationZ(Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(circleMesh, isXAxis ? _materialAxisFocus : _materialAxisX, ref m3);
// Y axis
collector.AddDrawCall(circleMesh, isYAxis ? _materialAxisFocus : _materialAxisY, ref m1);
// Z axis
Matrix.RotationX(-Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(circleMesh, isZAxis ? _materialAxisFocus : _materialAxisZ, ref m3);
// Center box
Matrix.Scaling(gizmoModelsScale2RealGizmoSize, out m3);
Matrix.Multiply(ref m3, ref _gizmoWorld, out m1);
Matrix.Scaling(1.0f, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(boxMesh, isCenter ? _materialWireFocus : _materialWire, ref m3);
break;
}
case Mode.Scale:
{
if (!_modelScaleAxis || !_modelScaleAxis.IsLoaded || !_modelBox || !_modelBox.IsLoaded)
{
break;
}
// Cache data
Matrix.Scaling(gizmoModelsScale2RealGizmoSize, out m3);
Matrix.Multiply(ref m3, ref _gizmoWorld, out m1);
var axisMesh = _modelScaleAxis.LODs[0].Meshes[0];
var boxMesh = _modelBox.LODs[0].Meshes[0];
// X axis
Matrix.RotationY(-Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(axisMesh, isXAxis ? _materialAxisFocus : _materialAxisX, ref m3);
// Y axis
Matrix.RotationX(Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(axisMesh, isYAxis ? _materialAxisFocus : _materialAxisY, ref m3);
// Z axis
Matrix.RotationX(Mathf.Pi, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(axisMesh, isZAxis ? _materialAxisFocus : _materialAxisZ, ref m3);
// Center box
Matrix.Scaling(10.0f, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(boxMesh, isCenter ? _materialWireFocus : _materialWire, ref m3);
break;
}
}
}
private void RenderTaskOnDraw(DrawCallsCollector collector)
{
_debugDrawData.OnDraw(collector);
}
/// <inheritdoc />
public override void Draw(DrawCallsCollector collector)
{
if (!_isActive || !IsActive)
{
return;
}
Matrix m1, m2, m3;
bool isXAxis = _activeAxis == Axis.X || _activeAxis == Axis.XY || _activeAxis == Axis.ZX;
bool isYAxis = _activeAxis == Axis.Y || _activeAxis == Axis.XY || _activeAxis == Axis.YZ;
bool isZAxis = _activeAxis == Axis.Z || _activeAxis == Axis.YZ || _activeAxis == Axis.ZX;
// Switch mode
const float gizmoModelsScale2RealGizmoSize = 0.075f;
switch (_activeMode)
{
case Mode.Translate:
{
if (!_modelTranslateAxis || !_modelTranslateAxis.IsLoaded)
{
break;
}
// Cache data
Matrix.Scaling(gizmoModelsScale2RealGizmoSize, out m3);
Matrix.Multiply(ref m3, ref _gizmoWorld, out m1);
var mesh = _modelTranslateAxis.LODs[0].Meshes[0];
// X axis
collector.AddDrawCall(mesh, isXAxis ? _materialAxisFocus : _materialAxisX, ref m1);
// Y axis
Matrix.RotationZ(Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(mesh, isYAxis ? _materialAxisFocus : _materialAxisY, ref m3);
// Z axis
Matrix.RotationY(-Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(mesh, isZAxis ? _materialAxisFocus : _materialAxisZ, ref m3);
break;
}
case Mode.Scale:
{
if (!_modelScaleAxis || !_modelScaleAxis.IsLoaded)
{
break;
}
// Cache data
Matrix.Scaling(gizmoModelsScale2RealGizmoSize, out m3);
Matrix.Multiply(ref m3, ref _gizmoWorld, out m1);
var mesh = _modelScaleAxis.LODs[0].Meshes[0];
// X axis
Matrix.RotationY(-Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(mesh, isXAxis ? _materialAxisFocus : _materialAxisX, ref m3);
// Y axis
Matrix.RotationX(Mathf.PiOverTwo, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(mesh, isYAxis ? _materialAxisFocus : _materialAxisY, ref m3);
// Z axis
Matrix.RotationX(Mathf.Pi, out m2);
Matrix.Multiply(ref m2, ref m1, out m3);
collector.AddDrawCall(mesh, isZAxis ? _materialAxisFocus : _materialAxisZ, ref m3);
break;
}
}
}
/// <summary>
/// Draws the gizmo.
/// </summary>
/// <param name="collector">The draw calls collector.</param>
public virtual void Draw(DrawCallsCollector collector)
{
}
/// <inheritdoc />
public void DrawEditorPrimitives(GPUContext context, SceneRenderTask task, GPUTexture target, GPUTexture targetDepth, DrawCallsCollector collector)
{
}
