birkeh
/
o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

DebugDraw gem fixes for Atom (#885)

Browse Source 
* Work in progress on adapting the DebugDraw gem to use AzFramework::DebugDisplayRequests API

* Cleanup fixes for DebugDisplayRequestBus & DebugDraw gem.

Remove SandboxIntegration implementation of the DebugDisplayRequestBus
Add DrawWireCylinder & DrawWireCone to the DebugDisplayRequestBus interface
Remove SetFillMode & DrawTexture functions from the DebugDisplayRequestBus interface
Fixup uses of the SetFillMode api, replace with new Draw[Wire|Solid]X functions.
Fixes to the DebugDraw gem to get it compiling with new warnings settings.

* Changes to get the DebugDraw gem working with Atom/RHI/Code/Include/Atom/RHI

Add GetWidth, GetHeight, GetDepth utility accessors to RHI::Viewport
Start cleaning out unnecessary Cry includes from DebugDraw gem
Fixes for AtomFont FFont.cpp 3d screen aligned text drawing.
Clean out no longer supported code for 3d text to render multiple strings for the same entity location

* Cleanup some unused or commented code

* Update with PR feedback from Nick Van Sickle
main
rgba16f 5 years ago committed by GitHub
parent 503848632c
commit d4bad61f9a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 180 additions and 907 deletions
Show Stats Download Patch File Download Diff File

11
Code/Framework/AzFramework/AzFramework/Entity/EntityDebugDisplayBus.h
Unescape Escape View File

@ -60,6 +60,7 @@ namespace AzFramework
virtual void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) { (void)vertices; (void)indices, (void)color; } virtual void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) { (void)vertices; (void)indices, (void)color; }
virtual void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) { (void)min; (void)max; } virtual void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) { (void)min; (void)max; }
virtual void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) { (void)min; (void)max; } virtual void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) { (void)min; (void)max; }
virtual void DrawWireOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) { (void)center; (void)axisX; (void)axisY; (void)axisZ; (void)halfExtents; }
virtual void DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) { (void)center; (void)axisX; (void)axisY; (void)axisZ; (void)halfExtents; } virtual void DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) { (void)center; (void)axisX; (void)axisY; (void)axisZ; (void)halfExtents; }
virtual void DrawPoint(const AZ::Vector3& p, int nSize = 1) { (void)p; (void)nSize; } virtual void DrawPoint(const AZ::Vector3& p, int nSize = 1) { (void)p; (void)nSize; }
virtual void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2) { (void)p1; (void)p2; } virtual void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2) { (void)p1; (void)p2; }
@ -70,18 +71,15 @@ namespace AzFramework
virtual void DrawLine2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z) { (void)p1; (void)p2; (void)z; } virtual void DrawLine2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z) { (void)p1; (void)p2; (void)z; }
virtual void DrawLine2dGradient(const AZ::Vector2& p1, const AZ::Vector2& p2, float z, const AZ::Vector4& firstColor, const AZ::Vector4& secondColor) { (void)p1; (void)p2; (void)z; (void)firstColor; (void)secondColor; } virtual void DrawLine2dGradient(const AZ::Vector2& p1, const AZ::Vector2& p2, float z, const AZ::Vector4& firstColor, const AZ::Vector4& secondColor) { (void)p1; (void)p2; (void)z; (void)firstColor; (void)secondColor; }
virtual void DrawWireCircle2d(const AZ::Vector2& center, float radius, float z) { (void)center; (void)radius; (void)z; } virtual void DrawWireCircle2d(const AZ::Vector2& center, float radius, float z) { (void)center; (void)radius; (void)z; }
virtual void DrawTerrainCircle(const AZ::Vector3& worldPos, float radius, float height) { (void)worldPos; (void)radius; (void)height; }
virtual void DrawTerrainCircle(const AZ::Vector3& center, float radius, float angle1, float angle2, float height) { (void)center; (void)radius; (void)angle1; (void)angle2; (void)height; }
virtual void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, int referenceAxis = 2) { (void)pos; (void)radius; (void)startAngleDegrees; (void)sweepAngleDegrees; (void)angularStepDegrees; (void)referenceAxis; } virtual void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, int referenceAxis = 2) { (void)pos; (void)radius; (void)startAngleDegrees; (void)sweepAngleDegrees; (void)angularStepDegrees; (void)referenceAxis; }
virtual void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis) { (void)pos; (void)radius; (void)startAngleDegrees; (void)sweepAngleDegrees; (void)angularStepDegrees; (void)fixedAxis; } virtual void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis) { (void)pos; (void)radius; (void)startAngleDegrees; (void)sweepAngleDegrees; (void)angularStepDegrees; (void)fixedAxis; }
virtual void DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis = 2 /*z axis*/) { (void)pos; (void)radius; (void)nUnchangedAxis; } virtual void DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis = 2 /*z axis*/) { (void)pos; (void)radius; (void)nUnchangedAxis; }
virtual void DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis = 2 /*z axis*/) { (void)pos; (void)radius; (void)viewPos; (void)nUnchangedAxis; } virtual void DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis = 2 /*z axis*/) { (void)pos; (void)radius; (void)viewPos; (void)nUnchangedAxis; }
virtual void DrawCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded = true) { (void)pos; (void)dir; (void)radius; (void)height; (void)drawShaded; } virtual void DrawWireCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height) { (void)pos; (void)dir; (void)radius; (void)height; }
virtual void DrawSolidCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded = true) { (void)pos; (void)dir; (void)radius; (void)height; (void)drawShaded; }
virtual void DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) { (void)center; (void)axis; (void)radius; (void)height; } virtual void DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) { (void)center; (void)axis; (void)radius; (void)height; }
virtual void DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded = true) { (void)center; (void)axis; (void)radius; (void)height; (void)drawShaded; } virtual void DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded = true) { (void)center; (void)axis; (void)radius; (void)height; (void)drawShaded; }
virtual void DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float heightStraightSection) { (void)center; (void)axis; (void)radius; (void)heightStraightSection; } virtual void DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float heightStraightSection) { (void)center; (void)axis; (void)radius; (void)heightStraightSection; }
virtual void DrawTerrainRect(float x1, float y1, float x2, float y2, float height) { (void)x1; (void)y1; (void)x2; (void)y2; (void)height; }
virtual void DrawTerrainLine(AZ::Vector3 worldPos1, AZ::Vector3 worldPos2) { (void)worldPos1; (void)worldPos2; }
virtual void DrawWireSphere(const AZ::Vector3& pos, float radius) { (void)pos; (void)radius; } virtual void DrawWireSphere(const AZ::Vector3& pos, float radius) { (void)pos; (void)radius; }
virtual void DrawWireSphere(const AZ::Vector3& pos, const AZ::Vector3 radius) { (void)pos; (void)radius; } virtual void DrawWireSphere(const AZ::Vector3& pos, const AZ::Vector3 radius) { (void)pos; (void)radius; }
virtual void DrawWireDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius) { (void)pos; (void)dir; (void)radius; } virtual void DrawWireDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius) { (void)pos; (void)dir; (void)radius; }
@ -91,11 +89,8 @@ namespace AzFramework
virtual void DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter = false, int srcOffsetX = 0, int srcOffsetY = 0) { (void)pos; (void)size; (void)text; (void)bCenter; (void)srcOffsetX; (void)srcOffsetY; } virtual void DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter = false, int srcOffsetX = 0, int srcOffsetY = 0) { (void)pos; (void)size; (void)text; (void)bCenter; (void)srcOffsetX; (void)srcOffsetY; }
virtual void Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter = false) { (void)x; (void)y; (void)size; (void)text; (void)bCenter; } virtual void Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter = false) { (void)x; (void)y; (void)size; (void)text; (void)bCenter; }
virtual void DrawTextOn2DBox(const AZ::Vector3& pos, const char* text, float textScale, const AZ::Vector4& TextColor, const AZ::Vector4& TextBackColor) { (void)pos; (void)text; (void)textScale; (void)TextColor; (void)TextBackColor; } virtual void DrawTextOn2DBox(const AZ::Vector3& pos, const char* text, float textScale, const AZ::Vector4& TextColor, const AZ::Vector4& TextBackColor) { (void)pos; (void)text; (void)textScale; (void)TextColor; (void)TextBackColor; }
virtual void DrawTextureLabel(ITexture* texture, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) { (void)texture; (void)pos; (void)sizeX; (void)sizeY; (void)texIconFlags; }
virtual void DrawTextureLabel(int textureId, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) { (void)textureId; (void)pos; (void)sizeX; (void)sizeY; (void)texIconFlags; }
virtual void SetLineWidth(float width) { (void)width; } virtual void SetLineWidth(float width) { (void)width; }
virtual bool IsVisible(const AZ::Aabb& bounds) { (void)bounds; return false; } virtual bool IsVisible(const AZ::Aabb& bounds) { (void)bounds; return false; }
virtual int SetFillMode(int nFillMode) { (void)nFillMode; return 0; }
virtual float GetLineWidth() { return 0.0f; } virtual float GetLineWidth() { return 0.0f; }
virtual float GetAspectRatio() { return 0.0f; } virtual float GetAspectRatio() { return 0.0f; }
virtual void DepthTestOff() {} virtual void DepthTestOff() {}

19
Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorView.cpp
Unescape Escape View File

@ -447,17 +447,14 @@ namespace AzToolsFramework
m_radius * viewScale); m_radius * viewScale);
debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4()); debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
if (m_shouldCorrect)
// show wireframe if the axis has been corrected/flipped {
// note: please see IRenderAuxGeom.h for the definition of e_FillModeWireframe and e_FillModeSolid. debugDisplay.DrawWireCone(coneBound.m_base, coneBound.m_axis, coneBound.m_radius, coneBound.m_height);
// it is not possible to include IRenderAuxGeom from here and we also don't want to introduce that dependency. }
// these legacy enums should be wrapped so set SetFillMode can be used in a type safe way, until then, else
// use the values directly until the API has been updated. {
const AZ::u32 prevFillMode = debugDisplay.SetFillMode( debugDisplay.DrawSolidCone(coneBound.m_base, coneBound.m_axis, coneBound.m_radius, coneBound.m_height, false);
m_shouldCorrect ? /*e_FillModeWireframe =*/ 0x1 << 26 : /*e_FillModeSolid =*/ 0); }
debugDisplay.DrawCone(coneBound.m_base, coneBound.m_axis, coneBound.m_radius, coneBound.m_height, false);
debugDisplay.SetFillMode(prevFillMode);
RefreshBoundInternal(managerId, manipulatorId, coneBound); RefreshBoundInternal(managerId, manipulatorId, coneBound);
} }

6
Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.cpp
Unescape Escape View File

@ -233,9 +233,9 @@ namespace AzToolsFramework
}(); }();
debugDisplay.SetColor(iconHighlight); debugDisplay.SetColor(iconHighlight);
debugDisplay.DrawTextureLabel( // debugDisplay.DrawTextureLabel(
iconTextureId, entityPosition, iconSize, iconSize, // iconTextureId, entityPosition, iconSize, iconSize,
/*DisplayContext::ETextureIconFlags::TEXICON_ON_TOP=*/ 0x0008); // /*DisplayContext::ETextureIconFlags::TEXICON_ON_TOP=*/ 0x0008);
} }
} }
} }

677
Code/Sandbox/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
Unescape Escape View File

@ -382,11 +382,6 @@ void SandboxIntegrationManager::Teardown()
{ {
AzToolsFramework::Layers::EditorLayerComponentNotificationBus::Handler::BusDisconnect(); AzToolsFramework::Layers::EditorLayerComponentNotificationBus::Handler::BusDisconnect();
AzFramework::DisplayContextRequestBus::Handler::BusDisconnect(); AzFramework::DisplayContextRequestBus::Handler::BusDisconnect();
if( m_debugDisplayBusImplementationActive)
{
AzFramework::DebugDisplayRequestBus::Handler::BusDisconnect();
m_debugDisplayBusImplementationActive = false;
}
AzToolsFramework::SliceEditorEntityOwnershipServiceNotificationBus::Handler::BusDisconnect(); AzToolsFramework::SliceEditorEntityOwnershipServiceNotificationBus::Handler::BusDisconnect();
AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusDisconnect(); AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusDisconnect();
AzToolsFramework::EditorEvents::Bus::Handler::BusDisconnect(); AzToolsFramework::EditorEvents::Bus::Handler::BusDisconnect();
@ -2041,678 +2036,6 @@ void SandboxIntegrationManager::BrowseForAssets(AssetSelectionModel& selection)
AssetBrowserComponentRequestBus::Broadcast(&AssetBrowserComponentRequests::PickAssets, selection, GetMainWindow()); AssetBrowserComponentRequestBus::Broadcast(&AssetBrowserComponentRequests::PickAssets, selection, GetMainWindow());
} }
void SandboxIntegrationManager::SetColor(float r, float g, float b, float a)
{
if (m_dc)
{
m_dc->SetColor(Vec3(r, g, b), a);
}
}
void SandboxIntegrationManager::SetColor(const AZ::Color& color)
{
if (m_dc)
{
m_dc->SetColor(AZColorToLYColorF(color));
}
}
void SandboxIntegrationManager::SetColor(const AZ::Vector4& color)
{
if (m_dc)
{
m_dc->SetColor(AZVec3ToLYVec3(color.GetAsVector3()), color.GetW());
}
}
void SandboxIntegrationManager::SetAlpha(float a)
{
if (m_dc)
{
m_dc->SetAlpha(a);
}
}
void SandboxIntegrationManager::DrawQuad(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3, const AZ::Vector3& p4)
{
if (m_dc)
{
m_dc->DrawQuad(
AZVec3ToLYVec3(p1),
AZVec3ToLYVec3(p2),
AZVec3ToLYVec3(p3),
AZVec3ToLYVec3(p4));
}
}
void SandboxIntegrationManager::DrawQuad(float width, float height)
{
if (m_dc)
{
m_dc->DrawQuad(width, height);
}
}
void SandboxIntegrationManager::DrawWireQuad(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3, const AZ::Vector3& p4)
{
if (m_dc)
{
m_dc->DrawWireQuad(
AZVec3ToLYVec3(p1),
AZVec3ToLYVec3(p2),
AZVec3ToLYVec3(p3),
AZVec3ToLYVec3(p4));
}
}
void SandboxIntegrationManager::DrawWireQuad(float width, float height)
{
if (m_dc)
{
m_dc->DrawWireQuad(width, height);
}
}
void SandboxIntegrationManager::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_dc)
{
m_dc->DrawQuadGradient(
AZVec3ToLYVec3(p1),
AZVec3ToLYVec3(p2),
AZVec3ToLYVec3(p3),
AZVec3ToLYVec3(p4),
ColorF(AZVec3ToLYVec3(firstColor.GetAsVector3()), firstColor.GetW()),
ColorF(AZVec3ToLYVec3(secondColor.GetAsVector3()), secondColor.GetW()));
}
}
void SandboxIntegrationManager::DrawTri(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3)
{
if (m_dc)
{
m_dc->DrawTri(
AZVec3ToLYVec3(p1),
AZVec3ToLYVec3(p2),
AZVec3ToLYVec3(p3));
}
}
void SandboxIntegrationManager::DrawTriangles(const AZStd::vector<AZ::Vector3>& vertices, const AZ::Color& color)
{
if (m_dc)
{
// transform to world space
const auto vecTransform = [this](const AZ::Vector3& vec)
{
return m_dc->GetMatrix() * AZVec3ToLYVec3(vec);
};
AZStd::vector<Vec3> cryVertices;
cryVertices.reserve(vertices.size());
AZStd::transform(vertices.begin(), vertices.end(), AZStd::back_inserter(cryVertices), vecTransform);
m_dc->DrawTriangles(
cryVertices,
AZColorToLYColorF(color));
}
}
void SandboxIntegrationManager::DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color)
{
if (m_dc)
{
// transform to world space
const auto vecTransform = [this](const AZ::Vector3& vec)
{
return m_dc->GetMatrix() * AZVec3ToLYVec3(vec);
};
AZStd::vector<Vec3> cryVertices;
cryVertices.reserve(vertices.size());
AZStd::transform(vertices.begin(), vertices.end(), AZStd::back_inserter(cryVertices), vecTransform);
m_dc->DrawTrianglesIndexed(
cryVertices,
indices,
AZColorToLYColorF(color));
}
}
void SandboxIntegrationManager::DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max)
{
if (m_dc)
{
m_dc->DrawWireBox(
AZVec3ToLYVec3(min),
AZVec3ToLYVec3(max));
}
}
void SandboxIntegrationManager::DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max)
{
if (m_dc)
{
m_dc->DrawSolidBox(
AZVec3ToLYVec3(min),
AZVec3ToLYVec3(max));
}
}
void SandboxIntegrationManager::DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents)
{
if (m_dc)
{
m_dc->DrawSolidOBB(AZVec3ToLYVec3(center), AZVec3ToLYVec3(axisX), AZVec3ToLYVec3(axisY), AZVec3ToLYVec3(axisZ), AZVec3ToLYVec3(halfExtents));
}
}
void SandboxIntegrationManager::DrawPoint(const AZ::Vector3& p, int nSize)
{
if (m_dc)
{
m_dc->DrawPoint(AZVec3ToLYVec3(p), nSize);
}
}
void SandboxIntegrationManager::DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2)
{
if (m_dc)
{
m_dc->DrawLine(
AZVec3ToLYVec3(p1),
AZVec3ToLYVec3(p2));
}
}
void SandboxIntegrationManager::DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector4& col1, const AZ::Vector4& col2)
{
if (m_dc)
{
m_dc->DrawLine(
AZVec3ToLYVec3(p1),
AZVec3ToLYVec3(p2),
ColorF(AZVec3ToLYVec3(col1.GetAsVector3()), col1.GetW()),
ColorF(AZVec3ToLYVec3(col2.GetAsVector3()), col2.GetW()));
}
}
void SandboxIntegrationManager::DrawLines(const AZStd::vector<AZ::Vector3>& lines, const AZ::Color& color)
{
if (m_dc)
{
// transform to world space
const auto vecTransform = [this](const AZ::Vector3& vec)
{
return m_dc->GetMatrix() * AZVec3ToLYVec3(vec);
};
AZStd::vector<Vec3> cryLines;
cryLines.reserve(cryLines.size());
AZStd::transform(lines.begin(), lines.end(), AZStd::back_inserter(cryLines), vecTransform);
m_dc->DrawLines(cryLines, AZColorToLYColorF(color));
}
}
void SandboxIntegrationManager::DrawPolyLine(const AZ::Vector3* pnts, int numPoints, bool cycled)
{
if (m_dc)
{
Vec3* points = new Vec3[numPoints];
for (int i = 0; i < numPoints; ++i)
{
points[i] = AZVec3ToLYVec3(pnts[i]);
}
m_dc->DrawPolyLine(points, numPoints, cycled);
delete[] points;
}
}
void SandboxIntegrationManager::DrawWireQuad2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z)
{
if (m_dc)
{
m_dc->DrawWireQuad2d(
QPoint(static_cast<int>(p1.GetX()), static_cast<int>(p1.GetY())),
QPoint(static_cast<int>(p2.GetX()), static_cast<int>(p2.GetY())),
z);
}
}
void SandboxIntegrationManager::DrawLine2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z)
{
if (m_dc)
{
m_dc->DrawLine2d(
QPoint(static_cast<int>(p1.GetX()), static_cast<int>(p1.GetY())),
QPoint(static_cast<int>(p2.GetX()), static_cast<int>(p2.GetY())),
z);
}
}
void SandboxIntegrationManager::DrawLine2dGradient(const AZ::Vector2& p1, const AZ::Vector2& p2, float z, const AZ::Vector4& firstColor, const AZ::Vector4& secondColor)
{
if (m_dc)
{
m_dc->DrawLine2dGradient(
QPoint(static_cast<int>(p1.GetX()), static_cast<int>(p1.GetY())),
QPoint(static_cast<int>(p2.GetX()), static_cast<int>(p2.GetY())),
z,
ColorF(AZVec3ToLYVec3(firstColor.GetAsVector3()), firstColor.GetW()),
ColorF(AZVec3ToLYVec3(secondColor.GetAsVector3()), secondColor.GetW()));
}
}
void SandboxIntegrationManager::DrawWireCircle2d(const AZ::Vector2& center, float radius, float z)
{
if (m_dc)
{
m_dc->DrawWireCircle2d(
QPoint(static_cast<int>(center.GetX()), static_cast<int>(center.GetY())),
radius, z);
}
}
void SandboxIntegrationManager::DrawTerrainCircle(const AZ::Vector3& worldPos, float radius, float height)
{
if (m_dc)
{
m_dc->DrawTerrainCircle(
AZVec3ToLYVec3(worldPos), radius, height);
}
}
void SandboxIntegrationManager::DrawTerrainCircle(const AZ::Vector3& center, float radius, float angle1, float angle2, float height)
{
if (m_dc)
{
m_dc->DrawTerrainCircle(
AZVec3ToLYVec3(center), radius, angle1, angle2, height);
}
}
void SandboxIntegrationManager::DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, int referenceAxis)
{
if (m_dc)
{
m_dc->DrawArc(
AZVec3ToLYVec3(pos),
radius,
startAngleDegrees,
sweepAngleDegrees,
angularStepDegrees,
referenceAxis);
}
}
void SandboxIntegrationManager::DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis)
{
if (m_dc)
{
m_dc->DrawArc(
AZVec3ToLYVec3(pos),
radius,
startAngleDegrees,
sweepAngleDegrees,
angularStepDegrees,
AZVec3ToLYVec3(fixedAxis));
}
}
void SandboxIntegrationManager::DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis)
{
if (m_dc)
{
m_dc->DrawCircle(
AZVec3ToLYVec3(pos),
radius,
nUnchangedAxis);
}
}
void SandboxIntegrationManager::DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis)
{
if (m_dc)
{
m_dc->DrawHalfDottedCircle(
AZVec3ToLYVec3(pos),
radius,
AZVec3ToLYVec3(viewPos),
nUnchangedAxis);
}
}
void SandboxIntegrationManager::DrawCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded)
{
if (m_dc)
{
m_dc->DrawCone(
AZVec3ToLYVec3(pos),
AZVec3ToLYVec3(dir),
radius,
height,
drawShaded);
}
}
void SandboxIntegrationManager::DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height)
{
if (m_dc)
{
m_dc->DrawWireCylinder(
AZVec3ToLYVec3(center),
AZVec3ToLYVec3(axis),
radius,
height);
}
}
void SandboxIntegrationManager::DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded)
{
if (m_dc)
{
m_dc->DrawSolidCylinder(
AZVec3ToLYVec3(center),
AZVec3ToLYVec3(axis),
radius,
height,
drawShaded);
}
}
void SandboxIntegrationManager::DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height)
{
if (m_dc)
{
m_dc->DrawWireCapsule(
AZVec3ToLYVec3(center),
AZVec3ToLYVec3(axis),
radius,
height);
}
}
void SandboxIntegrationManager::DrawTerrainRect(float x1, float y1, float x2, float y2, float height)
{
if (m_dc)
{
m_dc->DrawTerrainRect(x1, y1, x2, y2, height);
}
}
void SandboxIntegrationManager::DrawTerrainLine(AZ::Vector3 worldPos1, AZ::Vector3 worldPos2)
{
if (m_dc)
{
m_dc->DrawTerrainLine(
AZVec3ToLYVec3(worldPos1),
AZVec3ToLYVec3(worldPos2));
}
}
void SandboxIntegrationManager::DrawWireSphere(const AZ::Vector3& pos, float radius)
{
if (m_dc)
{
m_dc->DrawWireSphere(AZVec3ToLYVec3(pos), radius);
}
}
void SandboxIntegrationManager::DrawWireSphere(const AZ::Vector3& pos, const AZ::Vector3 radius)
{
if (m_dc)
{
m_dc->DrawWireSphere(
AZVec3ToLYVec3(pos),
AZVec3ToLYVec3(radius));
}
}
void SandboxIntegrationManager::DrawWireDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius)
{
if (m_dc)
{
m_dc->DrawWireDisk(
AZVec3ToLYVec3(pos),
AZVec3ToLYVec3(dir),
radius);
}
}
void SandboxIntegrationManager::DrawBall(const AZ::Vector3& pos, float radius, bool drawShaded)
{
if (m_dc)
{
m_dc->DrawBall(AZVec3ToLYVec3(pos), radius, drawShaded);
}
}
void SandboxIntegrationManager::DrawDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius)
{
if (m_dc)
{
m_dc->DrawDisk(
AZVec3ToLYVec3(pos),
AZVec3ToLYVec3(dir),
radius);
}
}
void SandboxIntegrationManager::DrawArrow(const AZ::Vector3& src, const AZ::Vector3& trg, float fHeadScale, bool b2SidedArrow)
{
if (m_dc)
{
m_dc->DrawArrow(
AZVec3ToLYVec3(src),
AZVec3ToLYVec3(trg),
fHeadScale,
b2SidedArrow);
}
}
void SandboxIntegrationManager::DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter, int srcOffsetX, int srcOffsetY)
{
if (m_dc)
{
m_dc->DrawTextLabel(
AZVec3ToLYVec3(pos),
size,
text,
bCenter,
srcOffsetX,
srcOffsetY);
}
}
void SandboxIntegrationManager::Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter)
{
if (m_dc)
{
m_dc->Draw2dTextLabel(x, y, size, text, bCenter);
}
}
void SandboxIntegrationManager::DrawTextureLabel(ITexture* texture, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags)
{
if (m_dc)
{
if (texture)
{
float textureWidth = aznumeric_caster(texture->GetWidth());
float textureHeight = aznumeric_caster(texture->GetHeight());
// resize the label in proportion to the actual texture size
if (textureWidth > textureHeight)
{
sizeY = sizeX * (textureHeight / textureWidth);
}
else
{
sizeX = sizeY * (textureWidth / textureHeight);
}
m_dc->DrawTextureLabel(AZVec3ToLYVec3(pos), sizeX, sizeY, texture->GetTextureID(), texIconFlags);
}
}
}
void SandboxIntegrationManager::DrawTextureLabel(int textureId, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags)
{
// ToDo: With Atom?
AZ_UNUSED(textureId);
AZ_UNUSED(pos);
AZ_UNUSED(sizeX);
AZ_UNUSED(sizeY);
AZ_UNUSED(texIconFlags);
}
void SandboxIntegrationManager::SetLineWidth(float width)
{
if (m_dc)
{
m_dc->SetLineWidth(width);
}
}
bool SandboxIntegrationManager::IsVisible(const AZ::Aabb& bounds)
{
if (m_dc)
{
const AABB aabb(
AZVec3ToLYVec3(bounds.GetMin()),
AZVec3ToLYVec3(bounds.GetMax()));
return m_dc->IsVisible(aabb);
}
return 0;
}
int SandboxIntegrationManager::SetFillMode(int nFillMode)
{
if (m_dc)
{
return m_dc->SetFillMode(nFillMode);
}
return 0;
}
float SandboxIntegrationManager::GetLineWidth()
{
if (m_dc)
{
return m_dc->GetLineWidth();
}
return 0.f;
}
float SandboxIntegrationManager::GetAspectRatio()
{
if (m_dc && m_dc->GetView())
{
return m_dc->GetView()->GetAspectRatio();
}
return 0.f;
}
void SandboxIntegrationManager::DepthTestOff()
{
if (m_dc)
{
m_dc->DepthTestOff();
}
}
void SandboxIntegrationManager::DepthTestOn()
{
if (m_dc)
{
m_dc->DepthTestOn();
}
}
void SandboxIntegrationManager::DepthWriteOff()
{
if (m_dc)
{
m_dc->DepthWriteOff();
}
}
void SandboxIntegrationManager::DepthWriteOn()
{
if (m_dc)
{
m_dc->DepthWriteOn();
}
}
void SandboxIntegrationManager::CullOff()
{
if (m_dc)
{
m_dc->CullOff();
}
}
void SandboxIntegrationManager::CullOn()
{
if (m_dc)
{
m_dc->CullOn();
}
}
bool SandboxIntegrationManager::SetDrawInFrontMode(bool bOn)
{
if (m_dc)
{
return m_dc->SetDrawInFrontMode(bOn);
}
return 0.f;
}
AZ::u32 SandboxIntegrationManager::GetState()
{
if (m_dc)
{
return m_dc->GetState();
}
return 0;
}
AZ::u32 SandboxIntegrationManager::SetState(AZ::u32 state)
{
if (m_dc)
{
return m_dc->SetState(state);
}
return 0;
}
void SandboxIntegrationManager::PushMatrix(const AZ::Transform& tm)
{
if (m_dc)
{
const Matrix34 m = AZTransformToLYTransform(tm);
m_dc->PushMatrix(m);
}
}
void SandboxIntegrationManager::PopMatrix()
{
if (m_dc)
{
m_dc->PopMatrix();
}
}
bool SandboxIntegrationManager::DisplayHelpersVisible() bool SandboxIntegrationManager::DisplayHelpersVisible()
{ {
return GetIEditor()->GetDisplaySettings()->IsDisplayHelpers(); return GetIEditor()->GetDisplaySettings()->IsDisplayHelpers();

65
Code/Sandbox/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.h
Unescape Escape View File

@ -100,7 +100,6 @@ class SandboxIntegrationManager
, private AzToolsFramework::EditorEvents::Bus::Handler , private AzToolsFramework::EditorEvents::Bus::Handler
, private AzToolsFramework::EditorWindowRequests::Bus::Handler , private AzToolsFramework::EditorWindowRequests::Bus::Handler
, private AzFramework::AssetCatalogEventBus::Handler , private AzFramework::AssetCatalogEventBus::Handler
, private AzFramework::DebugDisplayRequestBus::Handler
, private AzFramework::DisplayContextRequestBus::Handler , private AzFramework::DisplayContextRequestBus::Handler
, private AzToolsFramework::EditorEntityContextNotificationBus::Handler , private AzToolsFramework::EditorEntityContextNotificationBus::Handler
, private AzToolsFramework::SliceEditorEntityOwnershipServiceNotificationBus::Handler , private AzToolsFramework::SliceEditorEntityOwnershipServiceNotificationBus::Handler
@ -202,70 +201,6 @@ private:
const AzFramework::SliceInstantiationTicket& ticket) override; const AzFramework::SliceInstantiationTicket& ticket) override;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// AzToolsFramework::DebugDisplayRequestBus
void SetColor(float r, float g, float b, float a) override;
void SetColor(const AZ::Color& color) override;
void SetColor(const AZ::Vector4& color) override;
void SetAlpha(float a) override;
void DrawQuad(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3, const AZ::Vector3& p4) override;
void DrawQuad(float width, float height) override;
void DrawWireQuad(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3, const AZ::Vector3& p4) override;
void DrawWireQuad(float width, float height) override;
void 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) override;
void DrawTri(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector3& p3) override;
void DrawTriangles(const AZStd::vector<AZ::Vector3>& vertices, const AZ::Color& color) override;
void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) override;
void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) override;
void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) override;
void DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) override;
void DrawPoint(const AZ::Vector3& p, int nSize) override;
void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2) override;
void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2, const AZ::Vector4& col1, const AZ::Vector4& col2) override;
void DrawLines(const AZStd::vector<AZ::Vector3>& lines, const AZ::Color& color) override;
void DrawPolyLine(const AZ::Vector3* pnts, int numPoints, bool cycled) override;
void DrawWireQuad2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z) override;
void DrawLine2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z) override;
void DrawLine2dGradient(const AZ::Vector2& p1, const AZ::Vector2& p2, float z, const AZ::Vector4& firstColor, const AZ::Vector4& secondColor) override;
void DrawWireCircle2d(const AZ::Vector2& center, float radius, float z) override;
void DrawTerrainCircle(const AZ::Vector3& worldPos, float radius, float height) override;
void DrawTerrainCircle(const AZ::Vector3& center, float radius, float angle1, float angle2, float height) override;
void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, int referenceAxis) override;
void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis) override;
void DrawCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded = true) override;
void DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis) override;
void DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis) override;
void DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) override;
void DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded = true) override;
void DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) override;
void DrawTerrainRect(float x1, float y1, float x2, float y2, float height) override;
void DrawTerrainLine(AZ::Vector3 worldPos1, AZ::Vector3 worldPos2) override;
void DrawWireSphere(const AZ::Vector3& pos, float radius) override;
void DrawWireSphere(const AZ::Vector3& pos, const AZ::Vector3 radius) override;
void DrawWireDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius) override;
void DrawBall(const AZ::Vector3& pos, float radius, bool drawShaded = true) override;
void DrawDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius) override;
void DrawArrow(const AZ::Vector3& src, const AZ::Vector3& trg, float fHeadScale, bool b2SidedArrow) override;
void DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter, int srcOffsetX, int scrOffsetY) override;
void Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter) override;
void DrawTextureLabel(ITexture* texture, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) override;
void DrawTextureLabel(int textureId, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) override;
void SetLineWidth(float width) override;
bool IsVisible(const AZ::Aabb& bounds) override;
int SetFillMode(int nFillMode) override;
float GetLineWidth() override;
float GetAspectRatio() override;
void DepthTestOff() override;
void DepthTestOn() override;
void DepthWriteOff() override;
void DepthWriteOn() override;
void CullOff() override;
void CullOn() override;
bool SetDrawInFrontMode(bool bOn) override;
AZ::u32 GetState() override;
AZ::u32 SetState(AZ::u32 state) override;
void PushMatrix(const AZ::Transform& tm) override;
void PopMatrix() override;
// AzFramework::DisplayContextRequestBus (and @deprecated EntityDebugDisplayRequestBus) // AzFramework::DisplayContextRequestBus (and @deprecated EntityDebugDisplayRequestBus)
// AzFramework::DisplayContextRequestBus // AzFramework::DisplayContextRequestBus
void SetDC(DisplayContext* dc) override; void SetDC(DisplayContext* dc) override;

19
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/Viewport.h
Unescape Escape View File

@ -51,6 +51,25 @@ namespace AZ
float m_maxY = 0.0f; float m_maxY = 0.0f;
float m_minZ = 0.0f; float m_minZ = 0.0f;
float m_maxZ = 1.0f; float m_maxZ = 1.0f;
float GetWidth() const;
float GetHeight() const;
float GetDepth() const;
}; };
} // namespace RHI } // namespace RHI
} // namespace AZ } // namespace AZ
inline float AZ::RHI::Viewport::GetWidth() const
{
return m_maxX - m_minX;
}
inline float AZ::RHI::Viewport::GetHeight() const
{
return m_maxY - m_minY;
}
inline float AZ::RHI::Viewport::GetDepth() const
{
return m_maxZ - m_minZ;
}

48
Gems/AtomLyIntegration/AtomBridge/Code/Source/AtomDebugDisplayViewportInterface.cpp
Unescape Escape View File

@ -576,6 +576,29 @@ namespace AZ::AtomBridge
} }
} }
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( void AtomDebugDisplayViewportInterface::DrawSolidOBB(
const AZ::Vector3& center, const AZ::Vector3& center,
const AZ::Vector3& axisX, const AZ::Vector3& axisX,
@ -906,7 +929,28 @@ namespace AZ::AtomBridge
} }
} }
void AtomDebugDisplayViewportInterface::DrawCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded) 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) if (m_auxGeomPtr)
{ {
@ -1336,8 +1380,6 @@ namespace AZ::AtomBridge
{ {
AZ_Assert(false, "Unexpected use of legacy api, please file a feature request with the rendering team to get this implemented!"); AZ_Assert(false, "Unexpected use of legacy api, please file a feature request with the rendering team to get this implemented!");
} }
// unhandledled on Atom - virtual void DrawTextureLabel(ITexture* texture, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) override;
// void AtomDebugDisplayViewportInterface::DrawTextureLabel(int textureId, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) override;
void AtomDebugDisplayViewportInterface::SetLineWidth(float width) void AtomDebugDisplayViewportInterface::SetLineWidth(float width)
{ {

7
Gems/AtomLyIntegration/AtomBridge/Code/Source/AtomDebugDisplayViewportInterface.h
Unescape Escape View File

@ -153,6 +153,7 @@ namespace AZ::AtomBridge
void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) override; void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) override;
void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) override; void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) override;
void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) override; void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) override;
void DrawWireOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) override;
void DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) override; void DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) override;
void DrawPoint(const AZ::Vector3& p, int nSize = 1) override; void DrawPoint(const AZ::Vector3& p, int nSize = 1) override;
void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2) override; void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2) override;
@ -167,7 +168,8 @@ namespace AZ::AtomBridge
void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis) override; void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis) override;
void DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis = 2 /*z axis*/) override; void DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis = 2 /*z axis*/) override;
void DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis = 2 /*z axis*/) override; void DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis = 2 /*z axis*/) override;
void DrawCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded) override; void DrawWireCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height) override;
void DrawSolidCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded) override;
void DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) override; void DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) override;
void DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded) override; void DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded) override;
void DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float heightStraightSection) override; void DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float heightStraightSection) override;
@ -180,11 +182,8 @@ namespace AZ::AtomBridge
void DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter = false, int srcOffsetX = 0, int srcOffsetY = 0) override; void DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter = false, int srcOffsetX = 0, int srcOffsetY = 0) override;
void Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter = false) override; void Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter = false) override;
void DrawTextOn2DBox(const AZ::Vector3& pos, const char* text, float textScale, const AZ::Vector4& TextColor, const AZ::Vector4& TextBackColor) override; void DrawTextOn2DBox(const AZ::Vector3& pos, const char* text, float textScale, const AZ::Vector4& TextColor, const AZ::Vector4& TextBackColor) override;
// unhandled on Atom - virtual void DrawTextureLabel(ITexture* texture, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) override;
// void DrawTextureLabel(int textureId, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) override;
void SetLineWidth(float width) override; void SetLineWidth(float width) override;
bool IsVisible(const AZ::Aabb& bounds) override; bool IsVisible(const AZ::Aabb& bounds) override;
// int SetFillMode(int nFillMode) override;
float GetLineWidth() override; float GetLineWidth() override;
float GetAspectRatio() override; float GetAspectRatio() override;
void DepthTestOff() override; void DepthTestOff() override;

11
Gems/AtomLyIntegration/AtomFont/Code/Source/FFont.cpp
Unescape Escape View File

@ -1786,18 +1786,17 @@ void AZ::FFont::DrawScreenAlignedText3d(
} }
AZ::Vector3 positionNDC = AzFramework::WorldToScreenNDC( AZ::Vector3 positionNDC = AzFramework::WorldToScreenNDC(
params.m_position, params.m_position,
currentView->GetViewToWorldMatrix(), currentView->GetWorldToViewMatrix(),
currentView->GetViewToClipMatrix() currentView->GetViewToClipMatrix()
); );
AzFramework::TextDrawParameters param2d = params; internalParams.m_ctx.m_sizeIn800x600 = false;
param2d.m_position = positionNDC;
DrawStringUInternal( DrawStringUInternal(
*internalParams.m_viewport, *internalParams.m_viewport,
internalParams.m_viewportContext, internalParams.m_viewportContext,
internalParams.m_position.GetX(), positionNDC.GetX() * internalParams.m_viewport->GetWidth(),
internalParams.m_position.GetY(), (1.0f - positionNDC.GetY()) * internalParams.m_viewport->GetHeight(),
params.m_position.GetZ(), // Z positionNDC.GetZ(), // Z
text.data(), text.data(),
params.m_multiline, params.m_multiline,
internalParams.m_ctx internalParams.m_ctx

6
Gems/DebugDraw/Code/CMakeLists.txt
Unescape Escape View File

@ -21,6 +21,9 @@ ly_add_target(
Include Include
BUILD_DEPENDENCIES BUILD_DEPENDENCIES
PUBLIC PUBLIC
AZ::AtomCore
Gem::Atom_RPI.Public
Gem::Atom_Bootstrap.Headers
Legacy::CryCommon Legacy::CryCommon
) )
@ -51,6 +54,9 @@ if(PAL_TRAIT_BUILD_HOST_TOOLS)
Source Source
PUBLIC PUBLIC
Include Include
COMPILE_DEFINITIONS
PRIVATE
DEBUGDRAW_GEM_EDITOR=1
BUILD_DEPENDENCIES BUILD_DEPENDENCIES
PRIVATE PRIVATE
Gem::DebugDraw.Static Gem::DebugDraw.Static

5
Gems/DebugDraw/Code/Source/DebugDrawObbComponent.h
Unescape Escape View File

@ -41,9 +41,8 @@ namespace DebugDraw
, m_worldLocation(AZ::Vector3::CreateZero()) , m_worldLocation(AZ::Vector3::CreateZero())
, m_owningEditorComponent(AZ::InvalidComponentId) , m_owningEditorComponent(AZ::InvalidComponentId)
, m_scale(AZ::Vector3(1.0f, 1.0f, 1.0f)) , m_scale(AZ::Vector3(1.0f, 1.0f, 1.0f))
{ , m_obb(AZ::Obb::CreateFromPositionRotationAndHalfLengths(m_worldLocation, AZ::Quaternion::CreateIdentity(), AZ::Vector3::CreateOne()))
m_obb.CreateFromPositionRotationAndHalfLengths(m_worldLocation, AZ::Quaternion::CreateIdentity(), AZ::Vector3::CreateOne()); {}
}
}; };
class DebugDrawObbComponent class DebugDrawObbComponent

178
Gems/DebugDraw/Code/Source/DebugDrawSystemComponent.cpp
Unescape Escape View File

@ -19,11 +19,6 @@
#include <AzCore/RTTI/BehaviorContext.h> #include <AzCore/RTTI/BehaviorContext.h>
#include <AzCore/std/parallel/lock.h> #include <AzCore/std/parallel/lock.h>
#include <IRenderAuxGeom.h>
#include <Cry_Camera.h>
#include <MathConversion.h>
#include "DebugDrawSystemComponent.h" #include "DebugDrawSystemComponent.h"
// Editor specific // Editor specific
@ -37,6 +32,9 @@
#include <AzToolsFramework/Entity/EditorEntityContextComponent.h> #include <AzToolsFramework/Entity/EditorEntityContextComponent.h>
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
#include <Atom/RPI.Public/RPISystemInterface.h>
#include <Atom/RPI.Public/Scene.h>
namespace DebugDraw namespace DebugDraw
{ {
void DebugDrawSystemComponent::Reflect(AZ::ReflectContext* context) void DebugDrawSystemComponent::Reflect(AZ::ReflectContext* context)
@ -96,7 +94,7 @@ namespace DebugDraw
void DebugDrawSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required) void DebugDrawSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
{ {
(void)required; required.push_back(AZ_CRC("RPISystem", 0xf2add773));
} }
void DebugDrawSystemComponent::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent) void DebugDrawSystemComponent::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent)
@ -112,7 +110,7 @@ namespace DebugDraw
{ {
DebugDrawInternalRequestBus::Handler::BusConnect(); DebugDrawInternalRequestBus::Handler::BusConnect();
DebugDrawRequestBus::Handler::BusConnect(); DebugDrawRequestBus::Handler::BusConnect();
AZ::TickBus::Handler::BusConnect(); AZ::Render::Bootstrap::NotificationBus::Handler::BusConnect();
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusConnect(); AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusConnect();
@ -125,7 +123,7 @@ namespace DebugDraw
AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusDisconnect(); AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusDisconnect();
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
AZ::TickBus::Handler::BusDisconnect(); AZ::RPI::SceneNotificationBus::Handler::BusDisconnect();
DebugDrawRequestBus::Handler::BusDisconnect(); DebugDrawRequestBus::Handler::BusDisconnect();
DebugDrawInternalRequestBus::Handler::BusDisconnect(); DebugDrawInternalRequestBus::Handler::BusDisconnect();
@ -155,6 +153,13 @@ namespace DebugDraw
} }
} }
void DebugDrawSystemComponent::OnBootstrapSceneReady(AZ::RPI::Scene* scene)
{
AZ_Assert(scene, "Invalid scene received in OnBootstrapSceneReady");
AZ::RPI::SceneNotificationBus::Handler::BusConnect(scene->GetId());
AZ::Render::Bootstrap::NotificationBus::Handler::BusDisconnect();
}
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
void DebugDrawSystemComponent::OnStopPlayInEditor() void DebugDrawSystemComponent::OnStopPlayInEditor()
{ {
@ -255,16 +260,26 @@ namespace DebugDraw
} }
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
void DebugDrawSystemComponent::OnTick([[maybe_unused]] float deltaTime, AZ::ScriptTimePoint time) void DebugDrawSystemComponent::OnBeginPrepareRender()
{ {
AZ::ScriptTimePoint time;
AZ::TickRequestBus::BroadcastResult(time, &AZ::TickRequestBus::Events::GetTimeAtCurrentTick);
m_currentTime = time.GetSeconds(); m_currentTime = time.GetSeconds();
OnTickAabbs(); AzFramework::DebugDisplayRequestBus::BusPtr debugDisplayBus;
OnTickLines(); AzFramework::DebugDisplayRequestBus::Bind(
OnTickObbs(); debugDisplayBus, AzFramework::g_defaultSceneEntityDebugDisplayId);
OnTickRays(); AZ_Assert(debugDisplayBus, "Invalid DebugDisplayRequestBus.");
OnTickSpheres();
OnTickText(); AzFramework::DebugDisplayRequests* debugDisplay =
AzFramework::DebugDisplayRequestBus::FindFirstHandler(debugDisplayBus);
OnTickAabbs(*debugDisplay);
OnTickLines(*debugDisplay);
OnTickObbs(*debugDisplay);
OnTickRays(*debugDisplay);
OnTickSpheres(*debugDisplay);
OnTickText(*debugDisplay);
} }
template <typename F> template <typename F>
@ -277,7 +292,7 @@ namespace DebugDraw
vectorToExpire.erase(removalCondition, std::end(vectorToExpire)); vectorToExpire.erase(removalCondition, std::end(vectorToExpire));
} }
void DebugDrawSystemComponent::OnTickAabbs() void DebugDrawSystemComponent::OnTickAabbs(AzFramework::DebugDisplayRequests& debugDisplay)
{ {
AZStd::lock_guard<AZStd::mutex> locker(m_activeAabbsMutex); AZStd::lock_guard<AZStd::mutex> locker(m_activeAabbsMutex);
@ -295,17 +310,14 @@ namespace DebugDraw
AZ::Vector3 currentCenter = transformedAabb.GetCenter(); AZ::Vector3 currentCenter = transformedAabb.GetCenter();
transformedAabb.Set(transformedAabb.GetMin() - currentCenter + aabbElement.m_worldLocation, transformedAabb.GetMax() - currentCenter + aabbElement.m_worldLocation); transformedAabb.Set(transformedAabb.GetMin() - currentCenter + aabbElement.m_worldLocation, transformedAabb.GetMax() - currentCenter + aabbElement.m_worldLocation);
} }
debugDisplay.SetColor(aabbElement.m_color);
ColorB lyColor(aabbElement.m_color.ToU32()); debugDisplay.DrawSolidBox(transformedAabb.GetMin(), transformedAabb.GetMax());
Vec3 worldLocation(AZVec3ToLYVec3(aabbElement.m_worldLocation));
AABB lyAABB(AZAabbToLyAABB(transformedAabb));
gEnv->pRenderer->GetIRenderAuxGeom()->DrawAABB(lyAABB, false, lyColor, EBoundingBoxDrawStyle::eBBD_Extremes_Color_Encoded);
} }
removeExpiredDebugElementsFromVector(m_activeAabbs); removeExpiredDebugElementsFromVector(m_activeAabbs);
} }
void DebugDrawSystemComponent::OnTickLines() void DebugDrawSystemComponent::OnTickLines(AzFramework::DebugDisplayRequests& debugDisplay)
{ {
AZStd::lock_guard<AZStd::mutex> locker(m_activeLinesMutex); AZStd::lock_guard<AZStd::mutex> locker(m_activeLinesMutex);
size_t numActiveLines = m_activeLines.size(); size_t numActiveLines = m_activeLines.size();
@ -339,26 +351,14 @@ namespace DebugDraw
&AZ::TransformBus::Events::GetWorldTranslation); &AZ::TransformBus::Events::GetWorldTranslation);
} }
Vec3 start(AZVec3ToLYVec3(lineElement.m_startWorldLocation)); debugDisplay.SetColor(lineElement.m_color);
Vec3 end(AZVec3ToLYVec3(lineElement.m_endWorldLocation)); debugDisplay.DrawLine(lineElement.m_startWorldLocation, lineElement.m_endWorldLocation);
ColorB lyColor(lineElement.m_color.ToU32());
m_batchPoints.push_back(start);
m_batchPoints.push_back(end);
m_batchColors.push_back(lyColor);
m_batchColors.push_back(lyColor);
}
if (!m_batchPoints.empty())
{
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLines(m_batchPoints.begin(), m_batchPoints.size(), m_batchColors.begin(), 1.0f);
} }
removeExpiredDebugElementsFromVector(m_activeLines); removeExpiredDebugElementsFromVector(m_activeLines);
} }
void DebugDrawSystemComponent::OnTickObbs() void DebugDrawSystemComponent::OnTickObbs(AzFramework::DebugDisplayRequests& debugDisplay)
{ {
AZStd::lock_guard<AZStd::mutex> locker(m_activeObbsMutex); AZStd::lock_guard<AZStd::mutex> locker(m_activeObbsMutex);
@ -382,20 +382,18 @@ namespace DebugDraw
transformedObb.SetHalfLength(i, obbElement.m_scale.GetElement(i)); transformedObb.SetHalfLength(i, obbElement.m_scale.GetElement(i));
} }
} }
else
{
obbElement.m_worldLocation = transformedObb.GetPosition(); obbElement.m_worldLocation = transformedObb.GetPosition();
}
ColorB lyColor(obbElement.m_color.ToU32()); debugDisplay.SetColor(obbElement.m_color);
Vec3 worldLocation(AZVec3ToLYVec3(obbElement.m_worldLocation)); debugDisplay.DrawSolidOBB(obbElement.m_worldLocation, transformedObb.GetAxisX(), transformedObb.GetAxisY(), transformedObb.GetAxisZ(), transformedObb.GetHalfLengths());
OBB lyOBB(AZObbToLyOBB(transformedObb));
lyOBB.c = Vec3(0.f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawOBB(lyOBB, worldLocation, false, lyColor, EBoundingBoxDrawStyle::eBBD_Extremes_Color_Encoded);
} }
removeExpiredDebugElementsFromVector(m_activeObbs); removeExpiredDebugElementsFromVector(m_activeObbs);
} }
void DebugDrawSystemComponent::OnTickRays() void DebugDrawSystemComponent::OnTickRays(AzFramework::DebugDisplayRequests& debugDisplay)
{ {
AZStd::lock_guard<AZStd::mutex> locker(m_activeRaysMutex); AZStd::lock_guard<AZStd::mutex> locker(m_activeRaysMutex);
@ -415,22 +413,20 @@ namespace DebugDraw
rayElement.m_worldDirection = (endWorldLocation - rayElement.m_worldLocation); rayElement.m_worldDirection = (endWorldLocation - rayElement.m_worldLocation);
} }
ColorB lyColor(rayElement.m_color.ToU32());
Vec3 start(AZVec3ToLYVec3(rayElement.m_worldLocation));
Vec3 end(AZVec3ToLYVec3(endWorldLocation));
Vec3 direction(AZVec3ToLYVec3(rayElement.m_worldDirection));
float conePercentHeight = 0.5f; float conePercentHeight = 0.5f;
float coneHeight = direction.GetLength() * conePercentHeight; float coneHeight = rayElement.m_worldDirection.GetLength() * conePercentHeight;
Vec3 coneBaseLocation = end - direction * conePercentHeight; AZ::Vector3 coneBaseLocation = endWorldLocation - rayElement.m_worldDirection * conePercentHeight;
float coneRadius = AZ::GetClamp(coneHeight * 0.07f, 0.05f, 0.2f); float coneRadius = AZ::GetClamp(coneHeight * 0.07f, 0.05f, 0.2f);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(start, lyColor, coneBaseLocation, lyColor, 5.0f); debugDisplay.SetColor(rayElement.m_color);
gEnv->pRenderer->GetIRenderAuxGeom()->DrawCone(coneBaseLocation, direction, coneRadius, coneHeight, lyColor, false); debugDisplay.SetLineWidth(5.0f);
debugDisplay.DrawLine(rayElement.m_worldLocation, coneBaseLocation);
debugDisplay.DrawSolidCone(coneBaseLocation, rayElement.m_worldDirection, coneRadius, coneHeight, false);
} }
removeExpiredDebugElementsFromVector(m_activeRays); removeExpiredDebugElementsFromVector(m_activeRays);
} }
void DebugDrawSystemComponent::OnTickSpheres() void DebugDrawSystemComponent::OnTickSpheres(AzFramework::DebugDisplayRequests& debugDisplay)
{ {
AZStd::lock_guard<AZStd::mutex> locker(m_activeSpheresMutex); AZStd::lock_guard<AZStd::mutex> locker(m_activeSpheresMutex);
@ -442,19 +438,14 @@ namespace DebugDraw
{ {
AZ::TransformBus::EventResult(sphereElement.m_worldLocation, sphereElement.m_targetEntityId, &AZ::TransformBus::Events::GetWorldTranslation); AZ::TransformBus::EventResult(sphereElement.m_worldLocation, sphereElement.m_targetEntityId, &AZ::TransformBus::Events::GetWorldTranslation);
} }
debugDisplay.SetColor(sphereElement.m_color);
if (gEnv->pRenderer) debugDisplay.DrawBall(sphereElement.m_worldLocation, sphereElement.m_radius, true);
{
ColorB lyColor(sphereElement.m_color.ToU32());
Vec3 worldLocation(AZVec3ToLYVec3(sphereElement.m_worldLocation));
gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(worldLocation, sphereElement.m_radius, lyColor, true);
}
} }
removeExpiredDebugElementsFromVector(m_activeSpheres); removeExpiredDebugElementsFromVector(m_activeSpheres);
} }
void DebugDrawSystemComponent::OnTickText() void DebugDrawSystemComponent::OnTickText(AzFramework::DebugDisplayRequests& debugDisplay)
{ {
AZStd::lock_guard<AZStd::mutex> locker(m_activeTextsMutex); AZStd::lock_guard<AZStd::mutex> locker(m_activeTextsMutex);
@ -471,30 +462,20 @@ namespace DebugDraw
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
// Draw text elements and remove any that are expired // Draw text elements and remove any that are expired
AZStd::unordered_map<AZ::EntityId, AZ::u32> textPerEntityCount;
int numScreenTexts = 0; int numScreenTexts = 0;
AZ::EntityId lastTargetEntityId; AZ::EntityId lastTargetEntityId;
for (auto& textElement : m_activeTexts) for (auto& textElement : m_activeTexts)
{ {
const AZ::Color textColor = needsGammaConversion ? textElement.m_color.GammaToLinear() : textElement.m_color;
debugDisplay.SetColor(textColor);
if (textElement.m_drawMode == DebugDrawTextElement::DrawMode::OnScreen) if (textElement.m_drawMode == DebugDrawTextElement::DrawMode::OnScreen)
{ {
const AZ::Color textColor = needsGammaConversion ? textElement.m_color.GammaToLinear() : textElement.m_color; debugDisplay.Draw2dTextLabel(100.0f, 20.f + ((float)numScreenTexts * 15.0f), 1.4f, textElement.m_text.c_str() );
gEnv->pRenderer->GetIRenderAuxGeom()->Draw3dLabel(Vec3(20.f, 20.f + ((float)numScreenTexts * 15.0f), 0.5f), 1.4f, AZColorToLYColorF(textColor), textElement.m_text.c_str());
++numScreenTexts; ++numScreenTexts;
} }
else if (textElement.m_drawMode == DebugDrawTextElement::DrawMode::InWorld) else if (textElement.m_drawMode == DebugDrawTextElement::DrawMode::InWorld)
{ {
SDrawTextInfo ti;
ti.xscale = ti.yscale = 1.4f;
ti.flags = eDrawText_2D | eDrawText_FixedSize | eDrawText_Monospace | eDrawText_Center;
const AZ::Color textColor = needsGammaConversion ? textElement.m_color.GammaToLinear() : textElement.m_color;
ti.color[0] = textColor.GetR();
ti.color[1] = textColor.GetG();
ti.color[2] = textColor.GetB();
ti.color[3] = textColor.GetA();
AZ::Vector3 worldLocation; AZ::Vector3 worldLocation;
if (textElement.m_targetEntityId.IsValid()) if (textElement.m_targetEntityId.IsValid())
{ {
@ -507,32 +488,7 @@ namespace DebugDraw
worldLocation = textElement.m_worldLocation; worldLocation = textElement.m_worldLocation;
} }
const CCamera& camera = gEnv->pSystem->GetViewCamera(); debugDisplay.DrawTextLabel(worldLocation, 1.4f, textElement.m_text.c_str() );
const AZ::Vector3 cameraTranslation = LYVec3ToAZVec3(camera.GetPosition());
Vec3 lyWorldLoc = AZVec3ToLYVec3(worldLocation);
Vec3 screenPos(0.f);
if (camera.Project(lyWorldLoc, screenPos, Vec2i(0, 0), Vec2i(0, 0)))
{
// Handle spacing for world text so it doesn't draw on top of each other
// This works for text drawing on entities (considered one block), but not for world text.
// World text will get handled when we have screen-aware positioning of text elements
if (textElement.m_targetEntityId.IsValid())
{
auto iter = textPerEntityCount.find(textElement.m_targetEntityId);
if (iter != textPerEntityCount.end())
{
AZ::u32 count = iter->second;
screenPos.y += ((float)count * 15.0f);
iter->second = count + 1;
}
else
{
auto newEntry = textPerEntityCount.insert_key(textElement.m_targetEntityId);
newEntry.first->second = 1;
}
}
gEnv->pRenderer->GetIRenderAuxGeom()->Draw3dLabel(Vec3(screenPos.x, screenPos.y, 0.5f), 1.4f, AZColorToLYColorF(textColor), textElement.m_text.c_str());
}
} }
} }
@ -550,9 +506,9 @@ namespace DebugDraw
CreateLineEntryForComponent(lineComponent->GetEntityId(), lineComponent->m_element); CreateLineEntryForComponent(lineComponent->GetEntityId(), lineComponent->m_element);
} }
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
else if (EditorDebugDrawLineComponent* lineComponent = azrtti_cast<EditorDebugDrawLineComponent*>(component)) else if (EditorDebugDrawLineComponent* editorLineComponent = azrtti_cast<EditorDebugDrawLineComponent*>(component))
{ {
CreateLineEntryForComponent(lineComponent->GetEntityId(), lineComponent->m_element); CreateLineEntryForComponent(editorLineComponent->GetEntityId(), editorLineComponent->m_element);
} }
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
else if (DebugDrawRayComponent* rayComponent = azrtti_cast<DebugDrawRayComponent*>(component)) else if (DebugDrawRayComponent* rayComponent = azrtti_cast<DebugDrawRayComponent*>(component))
@ -560,9 +516,9 @@ namespace DebugDraw
CreateRayEntryForComponent(rayComponent->GetEntityId(), rayComponent->m_element); CreateRayEntryForComponent(rayComponent->GetEntityId(), rayComponent->m_element);
} }
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
else if (EditorDebugDrawRayComponent* rayComponent = azrtti_cast<EditorDebugDrawRayComponent*>(component)) else if (EditorDebugDrawRayComponent* editorRayComponent = azrtti_cast<EditorDebugDrawRayComponent*>(component))
{ {
CreateRayEntryForComponent(rayComponent->GetEntityId(), rayComponent->m_element); CreateRayEntryForComponent(editorRayComponent->GetEntityId(), editorRayComponent->m_element);
} }
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
else if (DebugDrawSphereComponent* sphereComponent = azrtti_cast<DebugDrawSphereComponent*>(component)) else if (DebugDrawSphereComponent* sphereComponent = azrtti_cast<DebugDrawSphereComponent*>(component))
@ -570,9 +526,9 @@ namespace DebugDraw
CreateSphereEntryForComponent(sphereComponent->GetEntityId(), sphereComponent->m_element); CreateSphereEntryForComponent(sphereComponent->GetEntityId(), sphereComponent->m_element);
} }
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
else if (EditorDebugDrawSphereComponent* sphereComponent = azrtti_cast<EditorDebugDrawSphereComponent*>(component)) else if (EditorDebugDrawSphereComponent* editorSphereComponent = azrtti_cast<EditorDebugDrawSphereComponent*>(component))
{ {
CreateSphereEntryForComponent(sphereComponent->GetEntityId(), sphereComponent->m_element); CreateSphereEntryForComponent(editorSphereComponent->GetEntityId(), editorSphereComponent->m_element);
} }
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
else if (DebugDrawObbComponent* obbComponent = azrtti_cast<DebugDrawObbComponent*>(component)) else if (DebugDrawObbComponent* obbComponent = azrtti_cast<DebugDrawObbComponent*>(component))
@ -581,9 +537,9 @@ namespace DebugDraw
} }
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
else if (EditorDebugDrawObbComponent* obbComponent = azrtti_cast<EditorDebugDrawObbComponent*>(component)) else if (EditorDebugDrawObbComponent* editorObbComponent = azrtti_cast<EditorDebugDrawObbComponent*>(component))
{ {
CreateObbEntryForComponent(obbComponent->GetEntityId(), obbComponent->m_element); CreateObbEntryForComponent(editorObbComponent->GetEntityId(), editorObbComponent->m_element);
} }
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
@ -593,9 +549,9 @@ namespace DebugDraw
} }
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
else if (EditorDebugDrawTextComponent* textComponent = azrtti_cast<EditorDebugDrawTextComponent*>(component)) else if (EditorDebugDrawTextComponent* editorTextComponent = azrtti_cast<EditorDebugDrawTextComponent*>(component))
{ {
CreateTextEntryForComponent(textComponent->GetEntityId(), textComponent->m_element); CreateTextEntryForComponent(editorTextComponent->GetEntityId(), editorTextComponent->m_element);
} }
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
} }

30
Gems/DebugDraw/Code/Source/DebugDrawSystemComponent.h
Unescape Escape View File

@ -32,6 +32,9 @@
#include <AzToolsFramework/Entity/EditorEntityContextBus.h> #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
#endif // DEBUGDRAW_GEM_EDITOR #endif // DEBUGDRAW_GEM_EDITOR
#include <Atom/RPI.Public/SceneBus.h>
#include <Atom/Bootstrap/BootstrapNotificationBus.h>
namespace DebugDraw namespace DebugDraw
{ {
// DebugDraw elements that don't have corresponding component representations yet // DebugDraw elements that don't have corresponding component representations yet
@ -61,10 +64,11 @@ namespace DebugDraw
class DebugDrawSystemComponent class DebugDrawSystemComponent
: public AZ::Component : public AZ::Component
, public AZ::TickBus::Handler
, public AZ::EntityBus::MultiHandler , public AZ::EntityBus::MultiHandler
, protected DebugDrawRequestBus::Handler , protected DebugDrawRequestBus::Handler
, protected DebugDrawInternalRequestBus::Handler , protected DebugDrawInternalRequestBus::Handler
, public AZ::RPI::SceneNotificationBus::Handler
, public AZ::Render::Bootstrap::NotificationBus::Handler
#ifdef DEBUGDRAW_GEM_EDITOR #ifdef DEBUGDRAW_GEM_EDITOR
, protected AzToolsFramework::EditorEntityContextNotificationBus::Handler , protected AzToolsFramework::EditorEntityContextNotificationBus::Handler
@ -113,20 +117,22 @@ namespace DebugDraw
void Activate() override; void Activate() override;
void Deactivate() override; void Deactivate() override;
// TickBus // SceneNotificationBus
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override; void OnBeginPrepareRender() override;
int GetTickOrder() override { return AZ::ComponentTickBus::TICK_DEFAULT; }
// AZ::Render::Bootstrap::NotificationBus
void OnBootstrapSceneReady(AZ::RPI::Scene* scene);
// EntityBus // EntityBus
void OnEntityDeactivated(const AZ::EntityId& entityId) override; void OnEntityDeactivated(const AZ::EntityId& entityId) override;
// Ticking functions for drawing debug elements // Ticking functions for drawing debug elements
void OnTickAabbs(); void OnTickAabbs(AzFramework::DebugDisplayRequests& debugDisplay);
void OnTickLines(); void OnTickLines(AzFramework::DebugDisplayRequests& debugDisplay);
void OnTickObbs(); void OnTickObbs(AzFramework::DebugDisplayRequests& debugDisplay);
void OnTickRays(); void OnTickRays(AzFramework::DebugDisplayRequests& debugDisplay);
void OnTickSpheres(); void OnTickSpheres(AzFramework::DebugDisplayRequests& debugDisplay);
void OnTickText(); void OnTickText(AzFramework::DebugDisplayRequests& debugDisplay);
// Element creation functions, used when DebugDraw components register themselves // Element creation functions, used when DebugDraw components register themselves
void CreateAabbEntryForComponent(const AZ::EntityId& componentEntityId, const DebugDrawAabbElement& element); void CreateAabbEntryForComponent(const AZ::EntityId& componentEntityId, const DebugDrawAabbElement& element);
@ -154,7 +160,7 @@ namespace DebugDraw
double m_currentTime; double m_currentTime;
AZStd::vector<Vec3> m_batchPoints; AZStd::vector<AZ::Vector3> m_batchPoints;
AZStd::vector<ColorB> m_batchColors; AZStd::vector<AZ::Color> m_batchColors;
}; };
} }

3
Gems/DebugDraw/Code/Source/DebugDraw_precompiled.h
Unescape Escape View File

@ -11,6 +11,3 @@
*/ */
#pragma once #pragma once
#include <platform.h> // Many CryCommon files require that this is included first.
#include <Cry_Color.h>

Write Preview
Loading…
Cancel
Save