You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1615 lines
66 KiB
C++
1615 lines
66 KiB
C++
/*
|
|
* Copyright (c) Contributors to the Open 3D Engine Project.
|
|
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
*
|
|
*/
|
|
|
|
#include <AzCore/Serialization/SerializeContext.h>
|
|
|
|
#include <AzCore/Component/ComponentApplicationBus.h>
|
|
#include <AzCore/std/containers/array.h>
|
|
#include <AzCore/Math/Obb.h>
|
|
#include <AzCore/Math/Aabb.h>
|
|
#include <AzCore/Math/Frustum.h>
|
|
#include <AtomDebugDisplayViewportInterface.h>
|
|
#include <Atom/RPI.Public/View.h>
|
|
#include <Atom/RPI.Public/ViewportContextBus.h>
|
|
#include <AzCore/Interface/Interface.h>
|
|
|
|
#include <AzFramework/Font/FontInterface.h>
|
|
|
|
namespace // unnamed namespace to hold copies of Cry AuxGeom state enum's, this is to avoid creating a dependency on IRenderAuxGeom.h
|
|
{
|
|
// Notes:
|
|
// Don't change the xxxShift values, they need to match the values from legacy cry rendering
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflags_*!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
enum EAuxGeomPublicRenderflagBitMasks
|
|
{
|
|
e_Mode2D3DShift = 31,
|
|
e_Mode2D3DMask = 0x1 << e_Mode2D3DShift,
|
|
|
|
e_AlphaBlendingShift = 29,
|
|
e_AlphaBlendingMask = 0x3 << e_AlphaBlendingShift,
|
|
|
|
e_DrawInFrontShift = 28,
|
|
e_DrawInFrontMask = 0x1 << e_DrawInFrontShift,
|
|
|
|
e_FillModeShift = 26,
|
|
e_FillModeMask = 0x3 << e_FillModeShift,
|
|
|
|
e_CullModeShift = 24,
|
|
e_CullModeMask = 0x3 << e_CullModeShift,
|
|
|
|
e_DepthWriteShift = 23,
|
|
e_DepthWriteMask = 0x1 << e_DepthWriteShift,
|
|
|
|
e_DepthTestShift = 22,
|
|
e_DepthTestMask = 0x1 << e_DepthTestShift,
|
|
|
|
e_PublicParamsMask = e_Mode2D3DMask | e_AlphaBlendingMask | e_DrawInFrontMask | e_FillModeMask |
|
|
e_CullModeMask | e_DepthWriteMask | e_DepthTestMask
|
|
};
|
|
|
|
// Notes:
|
|
// e_Mode2D renders in normalized [0.. 1] screen space.
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_Mode2D3D
|
|
{
|
|
e_Mode3D = 0x0 << e_Mode2D3DShift,
|
|
e_Mode2D = 0x1 << e_Mode2D3DShift,
|
|
};
|
|
|
|
// Notes:
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_AlphaBlendMode
|
|
{
|
|
e_AlphaNone = 0x0 << e_AlphaBlendingShift,
|
|
e_AlphaAdditive = 0x1 << e_AlphaBlendingShift,
|
|
e_AlphaBlended = 0x2 << e_AlphaBlendingShift,
|
|
};
|
|
|
|
// Notes:
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_DrawInFrontMode
|
|
{
|
|
e_DrawInFrontOff = 0x0 << e_DrawInFrontShift,
|
|
e_DrawInFrontOn = 0x1 << e_DrawInFrontShift,
|
|
};
|
|
|
|
// Notes:
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_FillMode
|
|
{
|
|
e_FillModeSolid = 0x0 << e_FillModeShift,
|
|
e_FillModeWireframe = 0x1 << e_FillModeShift,
|
|
e_FillModePoint = 0x2 << e_FillModeShift,
|
|
};
|
|
|
|
// Notes:
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_CullMode
|
|
{
|
|
e_CullModeNone = 0x0 << e_CullModeShift,
|
|
e_CullModeFront = 0x1 << e_CullModeShift,
|
|
e_CullModeBack = 0x2 << e_CullModeShift,
|
|
};
|
|
|
|
// Notes:
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_DepthWrite
|
|
{
|
|
e_DepthWriteOn = 0x0 << e_DepthWriteShift,
|
|
e_DepthWriteOff = 0x1 << e_DepthWriteShift,
|
|
};
|
|
|
|
// Notes:
|
|
// Don't change the xxxShift values blindly as they affect the rendering output
|
|
// that is two primitives have to be rendered after 3d primitives, alpha blended
|
|
// geometry have to be rendered after opaque ones, etc.
|
|
// This also applies to the individual flags in EAuxGeomPublicRenderflagBitMasks!
|
|
// Remarks:
|
|
// Bits 0 - 22 are currently reserved for prim type and per draw call render parameters (point size, etc.)
|
|
// Check RenderAuxGeom.h in ../RenderDll/Common
|
|
// See also:
|
|
// EAuxGeomPublicRenderflagBitMasks
|
|
enum EAuxGeomPublicRenderflags_DepthTest
|
|
{
|
|
e_DepthTestOn = 0x0 << e_DepthTestShift,
|
|
e_DepthTestOff = 0x1 << e_DepthTestShift,
|
|
};
|
|
};
|
|
|
|
namespace AZ::AtomBridge
|
|
{
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
SingleColorDynamicSizeLineHelper::SingleColorDynamicSizeLineHelper(
|
|
int estimatedNumLineSegments
|
|
)
|
|
{
|
|
m_points.reserve(estimatedNumLineSegments * 2);
|
|
}
|
|
|
|
void SingleColorDynamicSizeLineHelper::AddLineSegment(
|
|
const AZ::Vector3& lineStart,
|
|
const AZ::Vector3& lineEnd
|
|
)
|
|
{
|
|
m_points.push_back(lineStart);
|
|
m_points.push_back(lineEnd);
|
|
}
|
|
|
|
void SingleColorDynamicSizeLineHelper::Draw(
|
|
AZ::RPI::AuxGeomDrawPtr auxGeomDrawPtr,
|
|
const RenderState& rendState
|
|
) const
|
|
{
|
|
if (auxGeomDrawPtr && !m_points.empty())
|
|
{
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = m_points.data();
|
|
drawArgs.m_vertCount = aznumeric_cast<uint32_t>(m_points.size());
|
|
drawArgs.m_colors = &rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = rendState.m_opacityType;
|
|
drawArgs.m_depthTest = rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = rendState.m_viewProjOverrideIndex;
|
|
auxGeomDrawPtr->DrawLines( drawArgs );
|
|
}
|
|
}
|
|
|
|
void SingleColorDynamicSizeLineHelper::Draw2d(
|
|
AZ::RPI::AuxGeomDrawPtr auxGeomDrawPtr,
|
|
const RenderState& rendState
|
|
) const
|
|
{
|
|
if (auxGeomDrawPtr && !m_points.empty())
|
|
{
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = m_points.data();
|
|
drawArgs.m_vertCount = aznumeric_cast<uint32_t>(m_points.size());
|
|
drawArgs.m_colors = &rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = rendState.m_opacityType;
|
|
drawArgs.m_depthTest = rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = auxGeomDrawPtr->GetOrAdd2DViewProjOverride();
|
|
auxGeomDrawPtr->DrawLines( drawArgs );
|
|
}
|
|
}
|
|
|
|
void SingleColorDynamicSizeLineHelper::Reset()
|
|
{
|
|
m_points.clear();
|
|
}
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
AtomDebugDisplayViewportInterface::AtomDebugDisplayViewportInterface(AZ::RPI::ViewportContextPtr viewportContextPtr)
|
|
{
|
|
ResetRenderState();
|
|
m_viewportId = viewportContextPtr->GetId();
|
|
m_defaultInstance = false;
|
|
auto setupScene = [this](RPI::ScenePtr scene)
|
|
{
|
|
auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
|
|
AZ::RPI::ViewportContextPtr viewportContextPtr = viewportContextManager->GetViewportContextById(m_viewportId);
|
|
InitInternal(scene.get(), viewportContextPtr);
|
|
};
|
|
setupScene(viewportContextPtr->GetRenderScene());
|
|
m_sceneChangeHandler = AZ::RPI::ViewportContext::SceneChangedEvent::Handler(setupScene);
|
|
viewportContextPtr->ConnectSceneChangedHandler(m_sceneChangeHandler);
|
|
}
|
|
|
|
AtomDebugDisplayViewportInterface::AtomDebugDisplayViewportInterface(uint32_t defaultInstanceAddress, RPI::Scene* scene)
|
|
{
|
|
ResetRenderState();
|
|
m_viewportId = defaultInstanceAddress;
|
|
m_defaultInstance = true;
|
|
InitInternal(scene, nullptr);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::UpdateAuxGeom(RPI::Scene* scene, AZ::RPI::View* view)
|
|
{
|
|
if (!scene)
|
|
{
|
|
m_auxGeomPtr = nullptr;
|
|
return;
|
|
}
|
|
auto auxGeomFP = scene->GetFeatureProcessor<RPI::AuxGeomFeatureProcessorInterface>();
|
|
if (!auxGeomFP)
|
|
{
|
|
m_auxGeomPtr = nullptr;
|
|
return;
|
|
}
|
|
// default instance draws to all viewports in the default scene
|
|
if (m_defaultInstance || !view)
|
|
{
|
|
m_auxGeomPtr = auxGeomFP->GetDrawQueue();
|
|
}
|
|
else
|
|
{
|
|
// cache the aux geom draw interface for the current view (aka camera)
|
|
m_auxGeomPtr = auxGeomFP->GetOrCreateDrawQueueForView(view);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::InitInternal(RPI::Scene* scene, AZ::RPI::ViewportContextPtr viewportContextPtr)
|
|
{
|
|
AzFramework::DebugDisplayRequestBus::Handler::BusDisconnect(m_viewportId);
|
|
UpdateAuxGeom(scene, viewportContextPtr ? viewportContextPtr->GetDefaultView().get() : nullptr);
|
|
AzFramework::DebugDisplayRequestBus::Handler::BusConnect(m_viewportId);
|
|
if (!m_defaultInstance) // only the per viewport instances need to listen for viewport changes
|
|
{
|
|
AZ::RPI::ViewportContextIdNotificationBus::Handler::BusConnect(viewportContextPtr->GetId());
|
|
}
|
|
}
|
|
|
|
|
|
void AtomDebugDisplayViewportInterface::OnViewportDefaultViewChanged(AZ::RPI::ViewPtr view)
|
|
{
|
|
ResetRenderState();
|
|
if (!m_defaultInstance)
|
|
{
|
|
// handle viewport update (view change, scene change, etc
|
|
auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
|
|
AZ::RPI::ViewportContextPtr viewportContextPtr = viewportContextManager->GetViewportContextById(m_viewportId);
|
|
UpdateAuxGeom(viewportContextPtr->GetRenderScene().get(), viewportContextPtr->GetDefaultView().get());
|
|
}
|
|
}
|
|
|
|
AtomDebugDisplayViewportInterface::~AtomDebugDisplayViewportInterface()
|
|
{
|
|
AzFramework::DebugDisplayRequestBus::Handler::BusDisconnect(m_viewportId);
|
|
AZ::RPI::ViewportContextIdNotificationBus::Handler::BusDisconnect();
|
|
m_viewportId = AzFramework::InvalidViewportId;
|
|
m_auxGeomPtr = nullptr;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::ResetRenderState()
|
|
{
|
|
m_rendState = RenderState();
|
|
for (int index = 0; index < RenderState::TransformStackSize; ++index)
|
|
{
|
|
m_rendState.m_transformStack[index] = AZ::Matrix3x4::Identity();
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::SetColor(float r, float g, float b, float a)
|
|
{
|
|
m_rendState.m_color = AZ::Color(r, g, b, a);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::SetColor(const AZ::Color& color)
|
|
{
|
|
m_rendState.m_color = color;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::SetColor(const AZ::Vector4& color)
|
|
{
|
|
m_rendState.m_color = AZ::Color(color);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::SetAlpha(float a)
|
|
{
|
|
m_rendState.m_color.SetA(a);
|
|
if (a < 1.0f)
|
|
{
|
|
m_rendState.m_opacityType = AZ::RPI::AuxGeomDraw::OpacityType::Opaque;
|
|
}
|
|
else
|
|
{
|
|
m_rendState.m_opacityType = AZ::RPI::AuxGeomDraw::OpacityType::Translucent;
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawQuad(
|
|
const AZ::Vector3& p1,
|
|
const AZ::Vector3& p2,
|
|
const AZ::Vector3& p3,
|
|
const AZ::Vector3& p4)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 wsPoints[4] = { ToWorldSpacePosition(p1), ToWorldSpacePosition(p2), ToWorldSpacePosition(p3), ToWorldSpacePosition(p4) };
|
|
AZ::Vector3 triangles[6];
|
|
triangles[0] = wsPoints[0];
|
|
triangles[1] = wsPoints[1];
|
|
triangles[2] = wsPoints[2];
|
|
triangles[3] = wsPoints[2];
|
|
triangles[4] = wsPoints[3];
|
|
triangles[5] = wsPoints[0];
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = triangles;
|
|
drawArgs.m_vertCount = 6;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawTriangles(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawQuad(float width, float height)
|
|
{
|
|
if (!m_auxGeomPtr || width <= 0.0f || height <= 0.0f)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_auxGeomPtr->DrawQuad(
|
|
width,
|
|
height,
|
|
GetCurrentTransform(),
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Shaded,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireQuad(
|
|
const AZ::Vector3& p1,
|
|
const AZ::Vector3& p2,
|
|
const AZ::Vector3& p3,
|
|
const AZ::Vector3& p4)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 wsPoints[4] = { ToWorldSpacePosition(p1), ToWorldSpacePosition(p2), ToWorldSpacePosition(p3), ToWorldSpacePosition(p4) };
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = wsPoints;
|
|
drawArgs.m_vertCount = 4;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawPolylines(drawArgs, AZ::RPI::AuxGeomDraw::PolylineEnd::Closed);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireQuad(float width, float height)
|
|
{
|
|
if (!m_auxGeomPtr || width <= 0.0f || height <= 0.0f)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_auxGeomPtr->DrawQuad(
|
|
width,
|
|
height,
|
|
GetCurrentTransform(),
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawQuadGradient(
|
|
const AZ::Vector3& p1,
|
|
const AZ::Vector3& p2,
|
|
const AZ::Vector3& p3,
|
|
const AZ::Vector3& p4,
|
|
const AZ::Vector4& firstColor,
|
|
const AZ::Vector4& secondColor)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 wsPoints[4] = { ToWorldSpacePosition(p1), ToWorldSpacePosition(p2), ToWorldSpacePosition(p3), ToWorldSpacePosition(p4) };
|
|
AZ::Vector3 triangles[6];
|
|
AZ::Color colors[6];
|
|
triangles[0] = wsPoints[0]; colors[0] = firstColor;
|
|
triangles[1] = wsPoints[1]; colors[1] = firstColor;
|
|
triangles[2] = wsPoints[2]; colors[2] = secondColor;
|
|
triangles[3] = wsPoints[2]; colors[3] = secondColor;
|
|
triangles[4] = wsPoints[3]; colors[4] = secondColor;
|
|
triangles[5] = wsPoints[0]; colors[5] = firstColor;
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = triangles;
|
|
drawArgs.m_vertCount = 6;
|
|
drawArgs.m_colors = colors;
|
|
drawArgs.m_colorCount = 6;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawTriangles(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawTri(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 verts[3] = {ToWorldSpacePosition(p1), ToWorldSpacePosition(p2), ToWorldSpacePosition(p3)};
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = verts;
|
|
drawArgs.m_vertCount = 3;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawTriangles(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawTriangles(const AZStd::vector<AZ::Vector3>& vertices, const AZ::Color& color)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZStd::vector<AZ::Vector3> transformedVertices = ToWorldSpacePosition(vertices);
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = transformedVertices.data();
|
|
drawArgs.m_vertCount = aznumeric_cast<uint32_t>(transformedVertices.size());
|
|
drawArgs.m_colors = &color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawTriangles(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawTrianglesIndexed(
|
|
const AZStd::vector<AZ::Vector3>& vertices,
|
|
const AZStd::vector<AZ::u32>& indices,
|
|
const AZ::Color& color)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZStd::vector<AZ::Vector3> transformedVertices = ToWorldSpacePosition(vertices);
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicIndexedDrawArguments drawArgs;
|
|
drawArgs.m_verts = transformedVertices.data();
|
|
drawArgs.m_vertCount = aznumeric_cast<uint32_t>(transformedVertices.size());
|
|
drawArgs.m_indices = indices.data();
|
|
drawArgs.m_indexCount = aznumeric_cast<uint32_t>(indices.size());
|
|
drawArgs.m_colors = &color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawTriangles(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
m_auxGeomPtr->DrawAabb(
|
|
AZ::Aabb::CreateFromMinMax(min, max),
|
|
GetCurrentTransform(),
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
m_auxGeomPtr->DrawAabb(
|
|
AZ::Aabb::CreateFromMinMax(min, max),
|
|
GetCurrentTransform(),
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Solid,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireOBB(
|
|
const AZ::Vector3& center,
|
|
const AZ::Vector3& axisX,
|
|
const AZ::Vector3& axisY,
|
|
const AZ::Vector3& axisZ,
|
|
const AZ::Vector3& halfExtents)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Quaternion rotation = AZ::Quaternion::CreateFromMatrix3x3(AZ::Matrix3x3::CreateFromColumns(axisX, axisY, axisZ));
|
|
AZ::Obb obb = AZ::Obb::CreateFromPositionRotationAndHalfLengths(center, rotation, halfExtents);
|
|
m_auxGeomPtr->DrawObb(
|
|
obb,
|
|
AZ::Vector3::CreateZero(),
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawSolidOBB(
|
|
const AZ::Vector3& center,
|
|
const AZ::Vector3& axisX,
|
|
const AZ::Vector3& axisY,
|
|
const AZ::Vector3& axisZ,
|
|
const AZ::Vector3& halfExtents)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Quaternion rotation = AZ::Quaternion::CreateFromMatrix3x3(AZ::Matrix3x3::CreateFromColumns(axisX, axisY, axisZ));
|
|
AZ::Obb obb = AZ::Obb::CreateFromPositionRotationAndHalfLengths(center, rotation, halfExtents);
|
|
m_auxGeomPtr->DrawObb(
|
|
obb,
|
|
AZ::Vector3::CreateZero(),
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Solid,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawPoint(const AZ::Vector3& p, int nSize)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 wsPoint = ToWorldSpacePosition(p);
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = &wsPoint;
|
|
drawArgs.m_vertCount = 1;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = aznumeric_cast<uint8_t>(nSize);
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawPoints(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 verts[2] = {ToWorldSpacePosition(p1), ToWorldSpacePosition(p2)};
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = verts;
|
|
drawArgs.m_vertCount = 2;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector4& col1, const AZ::Vector4& col2)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 verts[2] = {ToWorldSpacePosition(p1), ToWorldSpacePosition(p2)};
|
|
AZ::Color colors[2] = {col1, col2};
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = verts;
|
|
drawArgs.m_vertCount = 2;
|
|
drawArgs.m_colors = colors;
|
|
drawArgs.m_colorCount = 2;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawLines(const AZStd::vector<AZ::Vector3>& lines, const AZ::Color& color)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZStd::vector<AZ::Vector3> transformedLines = ToWorldSpacePosition(lines);
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = transformedLines.data();
|
|
drawArgs.m_vertCount = aznumeric_cast<uint32_t>(transformedLines.size());
|
|
drawArgs.m_colors = &color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawPolyLine(const AZ::Vector3* pnts, int numPoints, bool cycled)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZStd::vector<AZ::Vector3> wsPoints(static_cast<size_t>(numPoints));
|
|
for (int index = 0; index < numPoints; ++index)
|
|
{
|
|
wsPoints[index] = ToWorldSpacePosition(pnts[index]);
|
|
}
|
|
AZ::RPI::AuxGeomDraw::PolylineEnd polylineEnd = cycled ? AZ::RPI::AuxGeomDraw::PolylineEnd::Closed : AZ::RPI::AuxGeomDraw::PolylineEnd::Open;
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = wsPoints.data();
|
|
drawArgs.m_vertCount = aznumeric_cast<uint32_t>(numPoints);
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
m_auxGeomPtr->DrawPolylines(drawArgs, polylineEnd);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireQuad2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 points[4];
|
|
points[0] = AZ::Vector3(p1.GetX(), p1.GetY(), z);
|
|
points[1] = AZ::Vector3(p2.GetX(), p1.GetY(), z);
|
|
points[2] = AZ::Vector3(p2.GetX(), p2.GetY(), z);
|
|
points[3] = AZ::Vector3(p1.GetX(), p2.GetY(), z);
|
|
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = points;
|
|
drawArgs.m_vertCount = 4;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_auxGeomPtr->GetOrAdd2DViewProjOverride();
|
|
m_auxGeomPtr->DrawPolylines(drawArgs, AZ::RPI::AuxGeomDraw::PolylineEnd::Closed);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawLine2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 points[2];
|
|
points[0] = AZ::Vector3(p1.GetX(), p1.GetY(), z);
|
|
points[1] = AZ::Vector3(p2.GetX(), p2.GetY(), z);
|
|
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = points;
|
|
drawArgs.m_vertCount = 2;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_auxGeomPtr->GetOrAdd2DViewProjOverride();
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawLine2dGradient(const AZ::Vector2& p1, const AZ::Vector2& p2, float z, const AZ::Vector4& firstColor, const AZ::Vector4& secondColor)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
AZ::Vector3 points[2];
|
|
points[0] = AZ::Vector3(p1.GetX(), p1.GetY(), z);
|
|
points[1] = AZ::Vector3(p2.GetX(), p2.GetY(), z);
|
|
AZ::Color colors[2] = {firstColor, secondColor};
|
|
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = points;
|
|
drawArgs.m_vertCount = 2;
|
|
drawArgs.m_colors = colors;
|
|
drawArgs.m_colorCount = 2;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_auxGeomPtr->GetOrAdd2DViewProjOverride();
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireCircle2d(const AZ::Vector2& center, float radius, float z)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// Draw axis aligned arc
|
|
constexpr float angularStepDegrees = 10.0f;
|
|
constexpr float startAngleDegrees = 0.0f;
|
|
constexpr float sweepAngleDegrees = 360.0f;
|
|
const float stepAngle = DegToRad(angularStepDegrees);
|
|
const float startAngle = DegToRad(startAngleDegrees);
|
|
const float stopAngle = DegToRad(sweepAngleDegrees) + startAngle;
|
|
SingleColorDynamicSizeLineHelper lines(1+static_cast<int>(sweepAngleDegrees/angularStepDegrees));
|
|
float aspectRadius = radius / GetAspectRatio();
|
|
AZ::Vector3 radiusV3 = AZ::Vector3(aspectRadius, radius, radius);
|
|
AZ::Vector3 pos = AZ::Vector3(center.GetX(), center.GetY(), z);
|
|
CreateAxisAlignedArc(
|
|
lines,
|
|
stepAngle,
|
|
startAngle,
|
|
stopAngle,
|
|
pos,
|
|
radiusV3,
|
|
CircleAxis::CircleAxisZ
|
|
);
|
|
lines.Draw2d(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawArc(
|
|
const AZ::Vector3& pos,
|
|
float radius,
|
|
float startAngleDegrees,
|
|
float sweepAngleDegrees,
|
|
float angularStepDegrees,
|
|
int referenceAxis)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// Draw axis aligned arc
|
|
const float stepAngle = DegToRad(angularStepDegrees);
|
|
const float startAngle = DegToRad(startAngleDegrees);
|
|
const float stopAngle = DegToRad(sweepAngleDegrees) + startAngle;
|
|
SingleColorDynamicSizeLineHelper lines(1+static_cast<int>(sweepAngleDegrees/angularStepDegrees));
|
|
AZ::Vector3 radiusV3 = AZ::Vector3(radius);
|
|
CreateAxisAlignedArc(
|
|
lines,
|
|
stepAngle,
|
|
startAngle,
|
|
stopAngle,
|
|
pos,
|
|
radiusV3,
|
|
static_cast<CircleAxis>(referenceAxis)
|
|
);
|
|
lines.Draw(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawArc(
|
|
const AZ::Vector3& pos,
|
|
float radius,
|
|
float startAngleDegrees,
|
|
float sweepAngleDegrees,
|
|
float angularStepDegrees,
|
|
const AZ::Vector3& fixedAxis)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// Draw arbitraty axis arc
|
|
const float stepAngle = DegToRad(angularStepDegrees);
|
|
const float startAngle = DegToRad(startAngleDegrees);
|
|
const float stopAngle = DegToRad(sweepAngleDegrees) + startAngle;
|
|
SingleColorDynamicSizeLineHelper lines(1+static_cast<int>(sweepAngleDegrees/angularStepDegrees));
|
|
AZ::Vector3 radiusV3 = AZ::Vector3(radius);
|
|
CreateArbitraryAxisArc(
|
|
lines,
|
|
stepAngle,
|
|
startAngle,
|
|
stopAngle,
|
|
pos,
|
|
radiusV3,
|
|
fixedAxis
|
|
);
|
|
lines.Draw(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// Draw circle with default radius.
|
|
const float step = DegToRad(10.0f);
|
|
const float maxAngle = DegToRad(360.0f) + step;
|
|
SingleColorStaticSizeLineHelper<40> lines; // hard code 40 lines until DegToRad is constexpr.
|
|
AZ::Vector3 radiusV3 = AZ::Vector3(radius);
|
|
CreateAxisAlignedArc(
|
|
lines,
|
|
step,
|
|
0.0f,
|
|
maxAngle,
|
|
pos,
|
|
radiusV3,
|
|
static_cast<CircleAxis>(nUnchangedAxis));
|
|
lines.Draw(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// Draw circle with single radius.
|
|
const float step = DegToRad(10.0f);
|
|
const float maxAngle = DegToRad(360.0f);
|
|
SingleColorStaticSizeLineHelper<40> lines; // hard code 40 lines until DegToRad is constexpr.
|
|
|
|
AZ::Vector3 radiusV3 = AZ::Vector3(radius);
|
|
const AZ::Vector3 worldPos = ToWorldSpacePosition(pos);
|
|
const AZ::Vector3 worldView = ToWorldSpacePosition(viewPos);
|
|
const AZ::Vector3 worldDir = worldView - worldPos;
|
|
|
|
CreateAxisAlignedArc(lines, step, 0.0f, maxAngle, pos, radiusV3, static_cast<CircleAxis>(nUnchangedAxis%CircleAxisMax),
|
|
[&worldPos, &worldDir](const AZ::Vector3& lineStart, const AZ::Vector3& lineEnd, int segmentIndex)
|
|
{
|
|
AZ_UNUSED(lineEnd);
|
|
const float dot = (lineStart - worldPos).Dot(worldDir);
|
|
const bool facing = dot > 0.0f;
|
|
// if so skip every other line to produce a dotted effect
|
|
if (facing || segmentIndex % 2 == 0)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
lines.Draw(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
const AZ::Vector3 worldPos = ToWorldSpacePosition(pos);
|
|
const AZ::Vector3 worldDir = ToWorldSpaceVector(dir);
|
|
m_auxGeomPtr->DrawCone(
|
|
worldPos,
|
|
worldDir,
|
|
radius,
|
|
height,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawSolidCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
const AZ::Vector3 worldPos = ToWorldSpacePosition(pos);
|
|
const AZ::Vector3 worldDir = ToWorldSpaceVector(dir);
|
|
m_auxGeomPtr->DrawCone(
|
|
worldPos,
|
|
worldDir,
|
|
radius,
|
|
height,
|
|
m_rendState.m_color,
|
|
drawShaded ? AZ::RPI::AuxGeomDraw::DrawStyle::Shaded : AZ::RPI::AuxGeomDraw::DrawStyle::Solid,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
const float scale = GetCurrentTransform().RetrieveScale().GetMaxElement();
|
|
const AZ::Vector3 worldCenter = ToWorldSpacePosition(center);
|
|
const AZ::Vector3 worldAxis = ToWorldSpaceVector(axis);
|
|
m_auxGeomPtr->DrawCylinder(
|
|
worldCenter,
|
|
worldAxis,
|
|
scale * radius,
|
|
scale * height,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawSolidCylinder(
|
|
const AZ::Vector3& center,
|
|
const AZ::Vector3& axis,
|
|
float radius,
|
|
float height,
|
|
bool drawShaded)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
const float scale = GetCurrentTransform().RetrieveScale().GetMaxElement();
|
|
const AZ::Vector3 worldCenter = ToWorldSpacePosition(center);
|
|
const AZ::Vector3 worldAxis = ToWorldSpaceVector(axis);
|
|
m_auxGeomPtr->DrawCylinder(
|
|
worldCenter,
|
|
worldAxis,
|
|
scale * radius,
|
|
scale * height,
|
|
m_rendState.m_color,
|
|
drawShaded ? AZ::RPI::AuxGeomDraw::DrawStyle::Shaded : AZ::RPI::AuxGeomDraw::DrawStyle::Solid,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireCapsule(
|
|
const AZ::Vector3& center,
|
|
const AZ::Vector3& axis,
|
|
float radius,
|
|
float heightStraightSection)
|
|
{
|
|
if (m_auxGeomPtr && radius > FLT_EPSILON && axis.GetLengthSq() > FLT_EPSILON)
|
|
{
|
|
AZ::Vector3 axisNormalized = axis.GetNormalizedEstimate();
|
|
|
|
const float scale = GetCurrentTransform().RetrieveScale().GetMaxElement();
|
|
const AZ::Vector3 worldCenter = ToWorldSpacePosition(center);
|
|
const AZ::Vector3 worldAxis = ToWorldSpaceVector(axis);
|
|
|
|
// Draw cylinder part (or just a circle around the middle)
|
|
if (heightStraightSection > FLT_EPSILON)
|
|
{
|
|
m_auxGeomPtr->DrawCylinderNoEnds(
|
|
worldCenter,
|
|
worldAxis,
|
|
scale * radius,
|
|
scale * heightStraightSection,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
|
|
AZ::Vector3 ortho1Normalized, ortho2Normalized;
|
|
CalcBasisVectors(axisNormalized, ortho1Normalized, ortho2Normalized);
|
|
AZ::Vector3 centerToTopCircleCenter = axisNormalized * heightStraightSection * 0.5f;
|
|
AZ::Vector3 topCenter = center + centerToTopCircleCenter;
|
|
AZ::Vector3 bottomCenter = center - centerToTopCircleCenter;
|
|
|
|
m_auxGeomPtr->DrawHemisphere(
|
|
topCenter,
|
|
worldAxis,
|
|
scale * radius,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
|
|
m_auxGeomPtr->DrawHemisphere(
|
|
bottomCenter,
|
|
-worldAxis,
|
|
scale * radius,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireSphere(const AZ::Vector3& pos, float radius)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
const float scale = GetCurrentTransform().RetrieveScale().GetMaxElement();
|
|
m_auxGeomPtr->DrawSphere(
|
|
ToWorldSpacePosition(pos),
|
|
scale * radius,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Line,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireSphere(const AZ::Vector3& pos, const AZ::Vector3 radius)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// This matches Cry behavior, the DrawWireSphere above may need modifying to use the same approach.
|
|
// Draw 3 axis aligned circles
|
|
const float step = DegToRad(10.0f);
|
|
const float maxAngle = DegToRad(360.0f);
|
|
SingleColorStaticSizeLineHelper<40*3> lines; // hard code to 40 lines * 3 circles until DegToRad is constexpr.
|
|
|
|
// Z Axis
|
|
AZ::Vector3 axisRadius(radius.GetX(), radius.GetY(), 0.0f);
|
|
CreateAxisAlignedArc(lines, step, 0.0f, maxAngle, pos, axisRadius, CircleAxisZ);
|
|
|
|
// X Axis
|
|
axisRadius = AZ::Vector3(0.0f, radius.GetY(), radius.GetZ());
|
|
CreateAxisAlignedArc(lines, step, 0.0f, maxAngle, pos, axisRadius, CircleAxisX);
|
|
|
|
// Y Axis
|
|
axisRadius = AZ::Vector3(radius.GetX(), 0.0f, radius.GetZ());
|
|
CreateAxisAlignedArc(lines, step, 0.0f, maxAngle, pos, axisRadius, CircleAxisY);
|
|
lines.Draw(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawWireDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
|
|
// Draw 3 axis aligned circles
|
|
const float stepAngle = DegToRad(11.25f);
|
|
const float startAngle = DegToRad(0.0f);
|
|
const float stopAngle = DegToRad(360.0f);
|
|
SingleColorDynamicSizeLineHelper lines(2 + static_cast<int>(360.0f / 11.25f)); // num disk segments + 1 for axis line + 1 for spare
|
|
const AZ::Vector3 radiusV3 = AZ::Vector3(radius);
|
|
CreateArbitraryAxisArc(
|
|
lines,
|
|
stepAngle,
|
|
startAngle,
|
|
stopAngle,
|
|
pos,
|
|
radiusV3,
|
|
dir
|
|
);
|
|
|
|
lines.AddLineSegment(ToWorldSpacePosition(pos), ToWorldSpacePosition(pos + dir * (radius * 0.2f))); // 0.2f comes from Code\Editor\Objects\DisplayContextShared.inl DisplayContext::DrawWireDisk
|
|
lines.Draw(m_auxGeomPtr, m_rendState);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawBall(const AZ::Vector3& pos, float radius, bool drawShaded)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
// get the max scaled radius in case the transform on the stack is scaled non-uniformly
|
|
const float transformedRadiusX = ToWorldSpaceVector(AZ::Vector3(radius, 0.0f, 0.0f)).GetLengthEstimate();
|
|
const float transformedRadiusY = ToWorldSpaceVector(AZ::Vector3(0.0f, radius, 0.0f)).GetLengthEstimate();
|
|
const float transformedRadiusZ = ToWorldSpaceVector(AZ::Vector3(0.0f, 0.0f, radius)).GetLengthEstimate();
|
|
const float maxTransformedRadius =
|
|
AZ::GetMax(transformedRadiusX, AZ::GetMax(transformedRadiusY, transformedRadiusZ));
|
|
|
|
AZ::RPI::AuxGeomDraw::DrawStyle drawStyle = drawShaded ? AZ::RPI::AuxGeomDraw::DrawStyle::Shaded : AZ::RPI::AuxGeomDraw::DrawStyle::Solid;
|
|
m_auxGeomPtr->DrawSphere(
|
|
ToWorldSpacePosition(pos),
|
|
maxTransformedRadius,
|
|
m_rendState.m_color,
|
|
drawStyle,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
const float scale = GetCurrentTransform().RetrieveScale().GetMaxElement();
|
|
const AZ::Vector3 worldPos = ToWorldSpacePosition(pos);
|
|
const AZ::Vector3 worldDir = ToWorldSpaceVector(dir);
|
|
m_auxGeomPtr->DrawDisk(
|
|
worldPos,
|
|
worldDir,
|
|
scale * radius,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Shaded,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawArrow(const AZ::Vector3& src, const AZ::Vector3& trg, float headScale, bool dualEndedArrow)
|
|
{
|
|
if (m_auxGeomPtr)
|
|
{
|
|
float f2dScale = 1.0f;
|
|
float arrowLen = 0.4f * headScale;
|
|
float arrowRadius = 0.1f * headScale;
|
|
// if (flags & DISPLAY_2D)
|
|
// {
|
|
// f2dScale = 1.2f * ToWorldSpaceVector(Vec3(1, 0, 0)).GetLength();
|
|
// }
|
|
AZ::Vector3 dir = trg - src;
|
|
dir = ToWorldSpaceVector(dir.GetNormalized());
|
|
AZ::Vector3 verts[2] = {ToWorldSpacePosition(src), ToWorldSpacePosition(trg)};
|
|
AZ::RPI::AuxGeomDraw::AuxGeomDynamicDrawArguments drawArgs;
|
|
drawArgs.m_verts = verts;
|
|
drawArgs.m_vertCount = 2;
|
|
drawArgs.m_colors = &m_rendState.m_color;
|
|
drawArgs.m_colorCount = 1;
|
|
drawArgs.m_size = m_rendState.m_lineWidth;
|
|
drawArgs.m_opacityType = m_rendState.m_opacityType;
|
|
drawArgs.m_depthTest = m_rendState.m_depthTest;
|
|
drawArgs.m_depthWrite = m_rendState.m_depthWrite;
|
|
drawArgs.m_viewProjectionOverrideIndex = m_rendState.m_viewProjOverrideIndex;
|
|
if (!dualEndedArrow)
|
|
{
|
|
verts[1] -= dir * arrowLen;
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
m_auxGeomPtr->DrawCone(
|
|
verts[1],
|
|
dir,
|
|
arrowRadius * f2dScale,
|
|
arrowLen * f2dScale,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Shaded,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
else
|
|
{
|
|
verts[0] += dir * arrowLen;
|
|
verts[1] -= dir * arrowLen;
|
|
m_auxGeomPtr->DrawLines(drawArgs);
|
|
m_auxGeomPtr->DrawCone(
|
|
verts[0],
|
|
-dir,
|
|
arrowRadius * f2dScale,
|
|
arrowLen * f2dScale,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Shaded,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
m_auxGeomPtr->DrawCone(
|
|
verts[1],
|
|
dir,
|
|
arrowRadius * f2dScale,
|
|
arrowLen * f2dScale,
|
|
m_rendState.m_color,
|
|
AZ::RPI::AuxGeomDraw::DrawStyle::Shaded,
|
|
m_rendState.m_depthTest,
|
|
m_rendState.m_depthWrite,
|
|
m_rendState.m_faceCullMode,
|
|
m_rendState.m_viewProjOverrideIndex
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawTextLabel(
|
|
const AZ::Vector3& pos,
|
|
float size,
|
|
const char* text,
|
|
const bool center,
|
|
int srcOffsetX [[maybe_unused]],
|
|
int srcOffsetY [[maybe_unused]])
|
|
{
|
|
// abort draw if draw is invalid or font query interface is missing.
|
|
if (!text || size == 0.0f || !AZ::Interface<AzFramework::FontQueryInterface>::Get())
|
|
{
|
|
return;
|
|
}
|
|
|
|
AzFramework::FontDrawInterface* fontDrawInterface = AZ::Interface<AzFramework::FontQueryInterface>::Get()->GetDefaultFontDrawInterface();
|
|
// abort draw if font draw interface is missing
|
|
if (!fontDrawInterface)
|
|
{
|
|
return;
|
|
}
|
|
// if 2d draw need to project pos to screen first
|
|
AzFramework::TextDrawParameters params;
|
|
AZ::RPI::ViewportContextPtr viewportContext = GetViewportContext();
|
|
params.m_drawViewportId = viewportContext->GetId(); // get the viewport ID so default viewport works
|
|
params.m_position = pos;
|
|
params.m_color = m_rendState.m_color;
|
|
params.m_scale = AZ::Vector2(size);
|
|
params.m_hAlign = center ? AzFramework::TextHorizontalAlignment::Center : AzFramework::TextHorizontalAlignment::Left; //! Horizontal text alignment
|
|
params.m_monospace = false; //! disable character proportional spacing
|
|
params.m_depthTest = false; //! Test character against the depth buffer
|
|
params.m_virtual800x600ScreenSize = false; //! Text placement and size are scaled in viewport pixel coordinates
|
|
params.m_scaleWithWindow = false; //! Font gets bigger as the window gets bigger
|
|
params.m_multiline = true; //! text respects ascii newline characters
|
|
|
|
fontDrawInterface->DrawScreenAlignedText3d(params, text);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::Draw2dTextLabel(
|
|
float x,
|
|
float y,
|
|
float size,
|
|
const char* text,
|
|
bool center)
|
|
{
|
|
// abort draw if draw is invalid or font query interface is missing.
|
|
if (!text || size == 0.0f || !AZ::Interface<AzFramework::FontQueryInterface>::Get())
|
|
{
|
|
return;
|
|
}
|
|
|
|
AzFramework::FontDrawInterface* fontDrawInterface = AZ::Interface<AzFramework::FontQueryInterface>::Get()->GetDefaultFontDrawInterface();
|
|
// abort draw if font draw interface is missing
|
|
if (!fontDrawInterface)
|
|
{
|
|
return;
|
|
}
|
|
// if 2d draw need to project pos to screen first
|
|
AzFramework::TextDrawParameters params;
|
|
AZ::RPI::ViewportContextPtr viewportContext = GetViewportContext();
|
|
params.m_drawViewportId = viewportContext->GetId(); // get the viewport ID so default viewport works
|
|
params.m_position = AZ::Vector3(x, y, 1.0f);
|
|
params.m_color = m_rendState.m_color;
|
|
params.m_scale = AZ::Vector2(size);
|
|
params.m_hAlign = center ? AzFramework::TextHorizontalAlignment::Center : AzFramework::TextHorizontalAlignment::Left; //! Horizontal text alignment
|
|
params.m_monospace = false; //! disable character proportional spacing
|
|
params.m_depthTest = false; //! Test character against the depth buffer
|
|
params.m_virtual800x600ScreenSize = false; //! Text placement and size are scaled in viewport pixel coordinates
|
|
params.m_scaleWithWindow = false; //! Font gets bigger as the window gets bigger
|
|
params.m_multiline = true; //! text respects ascii newline characters
|
|
|
|
fontDrawInterface->DrawScreenAlignedText2d(params, text);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DrawTextOn2DBox(
|
|
const AZ::Vector3& pos [[maybe_unused]],
|
|
const char* text [[maybe_unused]],
|
|
float textScale [[maybe_unused]],
|
|
const AZ::Vector4& TextColor [[maybe_unused]],
|
|
const AZ::Vector4& TextBackColor [[maybe_unused]])
|
|
{
|
|
AZ_Assert(false, "Unexpected use of legacy api, please file a feature request with the rendering team to get this implemented!");
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::SetLineWidth(float width)
|
|
{
|
|
AZ_Assert(width >= 0.0f && width <= 255.0f, "Width (%f) exceeds allowable range [0 - 255]", width);
|
|
m_rendState.m_lineWidth = static_cast<AZ::u8>(width);
|
|
}
|
|
|
|
bool AtomDebugDisplayViewportInterface::IsVisible(const AZ::Aabb& bounds)
|
|
{
|
|
AZ::RPI::ViewportContextPtr viewportContext = GetViewportContext();
|
|
const AZ::Matrix4x4& worldToClip = viewportContext->GetDefaultView()->GetWorldToClipMatrix();
|
|
AZ::Frustum frustum = AZ::Frustum::CreateFromMatrixColumnMajor(worldToClip, Frustum::ReverseDepth::True);
|
|
return frustum.IntersectAabb(bounds) != AZ::IntersectResult::Exterior;
|
|
}
|
|
// int AtomDebugDisplayViewportInterface::SetFillMode(int nFillMode) override;
|
|
float AtomDebugDisplayViewportInterface::GetLineWidth()
|
|
{
|
|
return m_rendState.m_lineWidth;
|
|
}
|
|
|
|
float AtomDebugDisplayViewportInterface::GetAspectRatio()
|
|
{
|
|
AZ::RPI::ViewportContextPtr viewportContext = GetViewportContext();
|
|
auto windowSize = viewportContext->GetViewportSize();
|
|
return aznumeric_cast<float>(windowSize.m_width)/aznumeric_cast<float>(windowSize.m_height);
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DepthTestOff()
|
|
{
|
|
m_rendState.m_depthTest = AZ::RPI::AuxGeomDraw::DepthTest::Off;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DepthTestOn()
|
|
{
|
|
m_rendState.m_depthTest = AZ::RPI::AuxGeomDraw::DepthTest::On;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DepthWriteOff()
|
|
{
|
|
m_rendState.m_depthWrite = AZ::RPI::AuxGeomDraw::DepthWrite::Off;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::DepthWriteOn()
|
|
{
|
|
m_rendState.m_depthWrite = AZ::RPI::AuxGeomDraw::DepthWrite::On;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::CullOff()
|
|
{
|
|
m_rendState.m_faceCullMode = AZ::RPI::AuxGeomDraw::FaceCullMode::None;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::CullOn()
|
|
{
|
|
m_rendState.m_faceCullMode = AZ::RPI::AuxGeomDraw::FaceCullMode::Back;
|
|
}
|
|
|
|
bool AtomDebugDisplayViewportInterface::SetDrawInFrontMode(bool on)
|
|
{
|
|
AZ_UNUSED(on);
|
|
return false;
|
|
}
|
|
|
|
AZ::u32 AtomDebugDisplayViewportInterface::GetState()
|
|
{
|
|
return ConvertRenderStateToCry();
|
|
}
|
|
|
|
AZ::u32 AtomDebugDisplayViewportInterface::SetState(AZ::u32 state)
|
|
{
|
|
uint32_t currentState = ConvertRenderStateToCry();
|
|
uint32_t changedState = (state & e_PublicParamsMask) ^ currentState;
|
|
|
|
if (changedState & e_Mode2D3DMask)
|
|
{
|
|
// this is the only way to turn on 2d Mode under Atom
|
|
if (state & e_Mode2D)
|
|
{
|
|
AZ_Assert((currentState & e_DrawInFrontOn) == 0 && (changedState & e_DrawInFrontOn) == 0, "Atom doesnt support Draw In Front and 2d at the same time");
|
|
m_rendState.m_viewProjOverrideIndex = m_auxGeomPtr->GetOrAdd2DViewProjOverride();
|
|
m_rendState.m_2dMode = true;
|
|
}
|
|
else // switch back to mode 3d
|
|
{
|
|
m_rendState.m_viewProjOverrideIndex = -1;
|
|
m_rendState.m_2dMode = false;
|
|
}
|
|
}
|
|
|
|
if (changedState & e_AlphaBlendingMask)
|
|
{
|
|
switch (state&e_AlphaBlendingMask)
|
|
{
|
|
case e_AlphaNone:
|
|
m_rendState.m_opacityType = AZ::RPI::AuxGeomDraw::OpacityType::Opaque;
|
|
break;
|
|
case e_AlphaAdditive:
|
|
[[fallthrough]]; // Additive not currently supported in Atom AuxGeom implementation
|
|
case e_AlphaBlended:
|
|
m_rendState.m_opacityType = AZ::RPI::AuxGeomDraw::OpacityType::Translucent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (changedState & e_DrawInFrontMask)
|
|
{
|
|
AZ_Assert( // either state is turning DrawInFront off or Mode 2D has to be off
|
|
(state & e_DrawInFrontOn) == 0 ||
|
|
((currentState & e_Mode2D) == 0 && (changedState & e_Mode2D) == 0),
|
|
"Atom doesnt support Draw In Front and 2d at the same time");
|
|
SetDrawInFrontMode(changedState & e_DrawInFrontOn);
|
|
}
|
|
|
|
if (changedState & e_CullModeMask)
|
|
{
|
|
switch (state & e_CullModeMask)
|
|
{
|
|
case e_CullModeNone:
|
|
CullOff();
|
|
break;
|
|
case e_CullModeFront:
|
|
// Currently no other way to set front face culling in DebugDisplayRequestBus
|
|
m_rendState.m_faceCullMode = AZ::RPI::AuxGeomDraw::FaceCullMode::Front;
|
|
break;
|
|
case e_CullModeBack:
|
|
CullOn();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (changedState & e_DepthWriteMask)
|
|
{
|
|
if (state & e_DepthWriteOff)
|
|
{
|
|
DepthWriteOff();
|
|
}
|
|
else
|
|
{
|
|
DepthWriteOn();
|
|
}
|
|
}
|
|
|
|
if (changedState & e_DepthTestMask)
|
|
{
|
|
if (state & e_DepthTestOff)
|
|
{
|
|
DepthTestOff();
|
|
}
|
|
else
|
|
{
|
|
DepthTestOn();
|
|
}
|
|
}
|
|
|
|
return currentState;
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::PushMatrix(const AZ::Transform& tm)
|
|
{
|
|
AZ_Assert(m_rendState.m_currentTransform < RenderState::TransformStackSize, "Exceeded AtomDebugDisplayViewportInterface matrix stack size");
|
|
if (m_rendState.m_currentTransform < RenderState::TransformStackSize)
|
|
{
|
|
m_rendState.m_currentTransform++;
|
|
m_rendState.m_transformStack[m_rendState.m_currentTransform] = m_rendState.m_transformStack[m_rendState.m_currentTransform - 1] * AZ::Matrix3x4::CreateFromTransform(tm);
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::PopMatrix()
|
|
{
|
|
AZ_Assert(m_rendState.m_currentTransform > 0, "Underflowed AtomDebugDisplayViewportInterface matrix stack");
|
|
if (m_rendState.m_currentTransform > 0)
|
|
{
|
|
m_rendState.m_currentTransform--;
|
|
}
|
|
}
|
|
|
|
void AtomDebugDisplayViewportInterface::PushPremultipliedMatrix(const AZ::Matrix3x4& matrix)
|
|
{
|
|
AZ_Assert(m_rendState.m_currentTransform < RenderState::TransformStackSize, "Exceeded AtomDebugDisplayViewportInterface matrix stack size");
|
|
if (m_rendState.m_currentTransform < RenderState::TransformStackSize)
|
|
{
|
|
m_rendState.m_currentTransform++;
|
|
m_rendState.m_transformStack[m_rendState.m_currentTransform] = matrix;
|
|
}
|
|
}
|
|
|
|
AZ::Matrix3x4 AtomDebugDisplayViewportInterface::PopPremultipliedMatrix()
|
|
{
|
|
AZ_Assert(m_rendState.m_currentTransform > 0, "Underflowed AtomDebugDisplayViewportInterface matrix stack");
|
|
if (m_rendState.m_currentTransform > 0)
|
|
{
|
|
m_rendState.m_currentTransform--;
|
|
}
|
|
return m_rendState.m_transformStack[m_rendState.m_currentTransform + 1];
|
|
}
|
|
|
|
const AZ::Matrix3x4& AtomDebugDisplayViewportInterface::GetCurrentTransform() const
|
|
{
|
|
return m_rendState.m_transformStack[m_rendState.m_currentTransform];
|
|
}
|
|
|
|
AZStd::vector<AZ::Vector3> AtomDebugDisplayViewportInterface::ToWorldSpacePosition(const AZStd::vector<AZ::Vector3>& positions) const
|
|
{
|
|
AZStd::vector<AZ::Vector3> transformedPositions;
|
|
transformedPositions.resize_no_construct(positions.size());
|
|
AZStd::transform(positions.begin(), positions.end(), transformedPositions.begin(), [this](const AZ::Vector3& position) {
|
|
return ToWorldSpacePosition(position);
|
|
});
|
|
return transformedPositions;
|
|
}
|
|
|
|
AZStd::vector<AZ::Vector3> AtomDebugDisplayViewportInterface::ToWorldSpaceVector(const AZStd::vector<AZ::Vector3>& vectors) const
|
|
{
|
|
AZStd::vector<AZ::Vector3> transformedVectors;
|
|
transformedVectors.resize_no_construct(vectors.size());
|
|
AZStd::transform(vectors.begin(), vectors.end(), transformedVectors.begin(), [this](const AZ::Vector3& vector) {
|
|
return ToWorldSpaceVector(vector);
|
|
});
|
|
return transformedVectors;
|
|
}
|
|
|
|
AZ::RPI::ViewportContextPtr AtomDebugDisplayViewportInterface::GetViewportContext() const
|
|
{
|
|
auto viewContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
|
|
if (m_defaultInstance)
|
|
{
|
|
return viewContextManager->GetViewportContextByName(viewContextManager->GetDefaultViewportContextName());
|
|
}
|
|
else
|
|
{
|
|
return viewContextManager->GetViewportContextById(m_viewportId);
|
|
}
|
|
}
|
|
|
|
uint32_t AtomDebugDisplayViewportInterface::ConvertRenderStateToCry() const
|
|
{
|
|
uint32_t result = 0;
|
|
|
|
result |= m_rendState.m_2dMode ? e_Mode2D : e_Mode3D;
|
|
result |= m_rendState.m_opacityType == AZ::RPI::AuxGeomDraw::OpacityType::Opaque ? e_AlphaNone : e_AlphaBlended;
|
|
result |= m_rendState.m_drawInFront ? e_DrawInFrontOn : e_DrawInFrontOff;
|
|
result |= m_rendState.m_depthTest == AZ::RPI::AuxGeomDraw::DepthTest::On ? e_DepthTestOn : e_DepthTestOff;
|
|
result |= m_rendState.m_depthWrite == AZ::RPI::AuxGeomDraw::DepthWrite::On ? e_DepthWriteOn : e_DepthWriteOff;
|
|
switch (m_rendState.m_faceCullMode)
|
|
{
|
|
case AZ::RPI::AuxGeomDraw::FaceCullMode::None:
|
|
result |= e_CullModeNone;
|
|
break;
|
|
case AZ::RPI::AuxGeomDraw::FaceCullMode::Front:
|
|
result |= e_CullModeFront;
|
|
break;
|
|
case AZ::RPI::AuxGeomDraw::FaceCullMode::Back:
|
|
result |= e_CullModeBack;
|
|
break;
|
|
default:
|
|
AZ_Assert(false, "Trying to convert an unknown culling mode to cry!");
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|