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.
386 lines
15 KiB
C++
386 lines
15 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 "EditorCommon.h"
|
|
#include <LyShine/IDraw2d.h>
|
|
|
|
#include <Atom/RPI.Public/Image/StreamingImage.h>
|
|
#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
|
|
|
|
float ViewportIcon::m_dpiScaleFactor = 1.0f;
|
|
|
|
ViewportIcon::ViewportIcon(const char* textureFilename)
|
|
{
|
|
m_image = Draw2dHelper::LoadTexture(textureFilename);
|
|
}
|
|
|
|
ViewportIcon::~ViewportIcon()
|
|
{
|
|
}
|
|
|
|
AZ::Vector2 ViewportIcon::GetTextureSize() const
|
|
{
|
|
if (m_image)
|
|
{
|
|
AZ::RHI::Size size = m_image->GetDescriptor().m_size;
|
|
AZ::Vector2 scaledSize(static_cast<float>(size.m_width), static_cast<float>(size.m_height));
|
|
if (m_applyDpiScaleFactorToSize)
|
|
{
|
|
scaledSize *= m_dpiScaleFactor;
|
|
}
|
|
return scaledSize;
|
|
}
|
|
|
|
return AZ::Vector2(0.0f, 0.0f);
|
|
}
|
|
|
|
void ViewportIcon::DrawImageAligned(Draw2dHelper& draw2d, AZ::Vector2& pivot, float opacity)
|
|
{
|
|
draw2d.DrawImageAligned(m_image,
|
|
pivot,
|
|
GetTextureSize(),
|
|
IDraw2d::HAlign::Center,
|
|
IDraw2d::VAlign::Center,
|
|
opacity);
|
|
}
|
|
|
|
void ViewportIcon::DrawImageTiled(Draw2dHelper& draw2d, IDraw2d::VertexPosColUV* verts)
|
|
{
|
|
// Use default blending and rounding modes
|
|
IDraw2d::Rounding rounding = IDraw2d::Rounding::Nearest;
|
|
draw2d.DrawQuad(m_image, verts, rounding);
|
|
}
|
|
|
|
void ViewportIcon::DrawAxisAlignedBoundingBox(Draw2dHelper& draw2d, AZ::Vector2 bound0, AZ::Vector2 bound1)
|
|
{
|
|
AZ::Color dottedColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
const float pixelLengthForDottedLineTexture = (1.0f / 8.0f);
|
|
float endTexCoordU = fabsf((bound1.GetX() - bound0.GetX()) * pixelLengthForDottedLineTexture);
|
|
float endTexCoordV = fabsf((bound1.GetY() - bound0.GetY()) * pixelLengthForDottedLineTexture);
|
|
|
|
IDraw2d::VertexPosColUV verts[2];
|
|
{
|
|
verts[0].color = dottedColor;
|
|
verts[1].color = dottedColor;
|
|
}
|
|
|
|
// bound0
|
|
// A----B
|
|
// | |
|
|
// C----D
|
|
// bound1
|
|
//
|
|
// Draw line segment A -> B.
|
|
{
|
|
verts[0].position = AZ::Vector2(bound0.GetX(), bound0.GetY());
|
|
verts[1].position = AZ::Vector2(bound1.GetX(), bound0.GetY());
|
|
verts[0].uv = AZ::Vector2(0.0f, 0.5f);
|
|
verts[1].uv = AZ::Vector2(endTexCoordU, 0.5f);
|
|
|
|
draw2d.DrawLineTextured(m_image, verts);
|
|
}
|
|
|
|
// bound0
|
|
// A----B
|
|
// | |
|
|
// C----D
|
|
// bound1
|
|
//
|
|
// Draw line segment A -> C.
|
|
{
|
|
verts[0].position = AZ::Vector2(bound0.GetX(), bound0.GetY());
|
|
verts[1].position = AZ::Vector2(bound0.GetX(), bound1.GetY());
|
|
verts[0].uv = AZ::Vector2(0.0f, 0.5f);
|
|
verts[1].uv = AZ::Vector2(endTexCoordV, 0.5f);
|
|
|
|
draw2d.DrawLineTextured(m_image, verts);
|
|
}
|
|
|
|
// bound0
|
|
// A----B
|
|
// | |
|
|
// C----D
|
|
// bound1
|
|
//
|
|
// Draw line segment C -> D.
|
|
{
|
|
verts[0].position = AZ::Vector2(bound0.GetX(), bound1.GetY());
|
|
verts[1].position = AZ::Vector2(bound1.GetX(), bound1.GetY());
|
|
verts[0].uv = AZ::Vector2(0.0f, 0.5f);
|
|
verts[1].uv = AZ::Vector2(endTexCoordU, 0.5f);
|
|
|
|
draw2d.DrawLineTextured(m_image, verts);
|
|
}
|
|
|
|
// bound0
|
|
// A----B
|
|
// | |
|
|
// C----D
|
|
// bound1
|
|
//
|
|
// Draw line segment B -> D.
|
|
{
|
|
verts[0].position = AZ::Vector2(bound1.GetX(), bound0.GetY());
|
|
verts[1].position = AZ::Vector2(bound1.GetX(), bound1.GetY());
|
|
verts[0].uv = AZ::Vector2(0.0f, 0.5f);
|
|
verts[1].uv = AZ::Vector2(endTexCoordV, 0.5f);
|
|
|
|
draw2d.DrawLineTextured(m_image, verts);
|
|
}
|
|
}
|
|
|
|
void ViewportIcon::Draw(Draw2dHelper& draw2d, AZ::Vector2 anchorPos, const AZ::Matrix4x4& transform, float iconRot, AZ::Color color) const
|
|
{
|
|
AZ::Vector2 iconSize = GetTextureSize();
|
|
|
|
// the icon images are authored with the "point" of the anchor in the center for all icons currently
|
|
const AZ::Vector2 originRatio(0.5f, 0.5f);
|
|
float iconOriginX = iconSize.GetX() * originRatio.GetX();
|
|
float iconOriginY = iconSize.GetY() * originRatio.GetY();
|
|
|
|
AZ::Vector2 tl(anchorPos.GetX() - iconOriginX, anchorPos.GetY() - iconOriginY);
|
|
UiTransformInterface::RectPoints iconPoints;
|
|
iconPoints.TopLeft() = tl;
|
|
iconPoints.TopRight() = AZ::Vector2(tl.GetX() + iconSize.GetX(), tl.GetY());
|
|
iconPoints.BottomLeft() = AZ::Vector2(tl.GetX(), tl.GetY() + iconSize.GetY());
|
|
iconPoints.BottomRight() = AZ::Vector2(tl.GetX() + iconSize.GetX(), tl.GetY() + iconSize.GetY());
|
|
|
|
// apply the rotation that rotates the anchor icon to point in the correct direction
|
|
AZ::Vector3 pivot3(anchorPos.GetX(), anchorPos.GetY(), 0);
|
|
float rotRad = DEG2RAD(iconRot);
|
|
AZ::Matrix4x4 moveToPivotSpaceMat = AZ::Matrix4x4::CreateTranslation(-pivot3);
|
|
AZ::Matrix4x4 rotMat = AZ::Matrix4x4::CreateRotationZ(rotRad);
|
|
AZ::Matrix4x4 moveFromPivotSpaceMat = AZ::Matrix4x4::CreateTranslation(pivot3);
|
|
AZ::Matrix4x4 newTransform = transform * moveFromPivotSpaceMat * rotMat * moveToPivotSpaceMat;
|
|
|
|
IDraw2d::VertexPosColUV verts[4];
|
|
// points are a clockwise quad
|
|
static const AZ::Vector2 uvs[4] = {
|
|
AZ::Vector2(0.0f, 0.0f), AZ::Vector2(1.0f, 0.0f), AZ::Vector2(1.0f, 1.0f), AZ::Vector2(0.0f, 1.0f)
|
|
};
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
verts[i].color = color;
|
|
verts[i].uv = uvs[i];
|
|
|
|
AZ::Vector3 point3(iconPoints.pt[i].GetX(), iconPoints.pt[i].GetY(), 0.0f);
|
|
point3 = newTransform * point3;
|
|
verts[i].position = AZ::Vector2(point3.GetX(), point3.GetY());
|
|
}
|
|
|
|
// in order to align the anchor icon correctly we do want rotation, shearing and negative scale
|
|
// in the transform to affect the icon, but we do not want its size to be affected.
|
|
// So we fix up the transformed points so that it has the correct icon width and height in viewport space.
|
|
if (transform.GetElement(0, 0) != 1.0f || transform.GetElement(1, 1) != 1.0f || transform.GetElement(2, 2) != 1.0f)
|
|
{
|
|
AZ::Vector2 widthVec = verts[1].position - verts[0].position;
|
|
AZ::Vector2 heightVec = verts[3].position - verts[0].position;
|
|
|
|
AZ::Vector2 originPos = verts[0].position + widthVec * originRatio.GetX() + heightVec * originRatio.GetY();
|
|
|
|
// adjust both vectors to be of the desired length (iconW and iconH)
|
|
// Avoid a divide by zero. We could compare with 0.0f here and that would avoid a divide
|
|
// by zero. However comparing with FLT_EPSILON also avoids the rare case of an overflow.
|
|
// FLT_EPSILON is small enough to be considered equivalent to zero in this application.
|
|
float widthVecLength = widthVec.GetLength();
|
|
float heightVecLength = heightVec.GetLength();
|
|
widthVec *= (fabsf(widthVecLength) > FLT_EPSILON) ? iconSize.GetX() / widthVecLength : 0.0f;
|
|
heightVec *= (fabsf(heightVecLength) > FLT_EPSILON) ? iconSize.GetY() / heightVecLength : 0.0f;
|
|
|
|
verts[0].position = originPos - widthVec * originRatio.GetX() - heightVec * originRatio.GetY();
|
|
verts[1].position = originPos + widthVec * (1.0f - originRatio.GetX()) - heightVec * originRatio.GetY();
|
|
verts[2].position = originPos + widthVec * (1.0f - originRatio.GetX()) + heightVec * (1.0f - originRatio.GetY());
|
|
verts[3].position = originPos - widthVec * originRatio.GetX() + heightVec * (1.0f - originRatio.GetY());
|
|
}
|
|
|
|
draw2d.DrawQuad(m_image, verts);
|
|
}
|
|
|
|
void ViewportIcon::DrawAnchorLines(Draw2dHelper& draw2d, AZ::Vector2 anchorPos, AZ::Vector2 targetPos, const AZ::Matrix4x4& transform,
|
|
bool xFirst, bool xText, bool yText)
|
|
{
|
|
AZ::Vector2 cornerPos = (xFirst) ? AZ::Vector2(targetPos.GetX(), anchorPos.GetY()) : AZ::Vector2(anchorPos.GetX(), targetPos.GetY());
|
|
|
|
AZ::Vector3 start3 = EntityHelpers::MakeVec3(anchorPos);
|
|
AZ::Vector3 end3 = EntityHelpers::MakeVec3(targetPos);
|
|
AZ::Vector3 corner3 = EntityHelpers::MakeVec3(cornerPos);
|
|
|
|
start3 = transform * start3;
|
|
corner3 = transform * corner3;
|
|
end3 = transform * end3;
|
|
|
|
AZ::Vector2 start2(start3.GetX(), start3.GetY());
|
|
AZ::Vector2 corner2(corner3.GetX(), corner3.GetY());
|
|
AZ::Vector2 end2(end3.GetX(), end3.GetY());
|
|
|
|
AZ::Color solidColor(1.0f, 1.0f, 1.0f, 0.2f);
|
|
|
|
if ((xFirst && xText) || (!xFirst && yText))
|
|
{
|
|
float displayDistance = (xFirst) ? cornerPos.GetX() - anchorPos.GetX() : cornerPos.GetY() - anchorPos.GetY();
|
|
DrawDistanceLine(draw2d, start2, corner2, displayDistance);
|
|
}
|
|
else
|
|
{
|
|
draw2d.DrawLine(start2, corner2, solidColor);
|
|
}
|
|
|
|
if ((!xFirst && xText) || (xFirst && yText))
|
|
{
|
|
float displayDistance = (!xFirst) ? targetPos.GetX() - cornerPos.GetX() : targetPos.GetY() - cornerPos.GetY();
|
|
DrawDistanceLine(draw2d, corner2, end2, displayDistance);
|
|
}
|
|
else
|
|
{
|
|
draw2d.DrawLine(corner2, end2, solidColor);
|
|
}
|
|
}
|
|
|
|
void ViewportIcon::DrawDistanceLine(Draw2dHelper& draw2d, AZ::Vector2 start, AZ::Vector2 end, float displayDistance, const char* suffix)
|
|
{
|
|
// draw a dotted line with the distance displayed on it
|
|
|
|
AZ::Color dottedColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
float length = AZ::Vector2(end - start).GetLength();
|
|
const float pixelLengthForDottedLineTexture = 8.0f;
|
|
float endTexCoordU = length / pixelLengthForDottedLineTexture;
|
|
|
|
IDraw2d::VertexPosColUV verts[2];
|
|
|
|
verts[0].position = start;
|
|
verts[0].color = dottedColor;
|
|
verts[0].uv = AZ::Vector2(0.0f, 0.5f);
|
|
|
|
verts[1].position = end;
|
|
verts[1].color = dottedColor;
|
|
verts[1].uv = AZ::Vector2(endTexCoordU, 0.5f);
|
|
|
|
draw2d.DrawLineTextured(m_image, verts);
|
|
|
|
// Now draw the text rotated to match the angle of the line and slightly offset from the center point
|
|
|
|
// first swap the start end such that the line always goes left to right
|
|
if (start.GetX() == end.GetX())
|
|
{
|
|
if (start.GetY() < end.GetY())
|
|
{
|
|
std::swap(start, end);
|
|
}
|
|
}
|
|
else if (start.GetX() > end.GetX())
|
|
{
|
|
std::swap(start, end);
|
|
}
|
|
|
|
// get the angle of the line (will always be > (-90 < angle <= 90)
|
|
float rotRad = atan2f(end.GetY() - start.GetY(), end.GetX() - start.GetX());
|
|
float rotation = RAD2DEG(rotRad);
|
|
|
|
// offset the bottom center of the text from the line by a fixed offset,
|
|
// we rotate the offset to match line angle
|
|
const float offsetDist = 2.0f;
|
|
AZ::Vector2 textOffset(offsetDist * sinf(rotRad), -offsetDist * cosf(rotRad));
|
|
|
|
// position for text is the midpoint of the line plus the offset
|
|
AZ::Vector2 textPos = (start + end) * 0.5f + textOffset;
|
|
|
|
const size_t bufSize = 32;
|
|
char textBuf[bufSize];
|
|
azsnprintf(textBuf, bufSize, "%.2f%s", displayDistance, suffix ? suffix : "");
|
|
|
|
draw2d.SetTextAlignment(IDraw2d::HAlign::Center, IDraw2d::VAlign::Bottom);
|
|
draw2d.SetTextRotation(rotation);
|
|
draw2d.DrawText(textBuf, textPos, 8.0f, 1.0f);
|
|
}
|
|
|
|
void ViewportIcon::DrawAnchorLinesSplit(Draw2dHelper& draw2d, AZ::Vector2 anchorPos1, AZ::Vector2 anchorPos2,
|
|
AZ::Vector2 targetPos, const AZ::Matrix4x4& transform, bool horizSplit, const char* suffix)
|
|
{
|
|
AZ::Vector2 cornerPos = (horizSplit) ? AZ::Vector2(targetPos.GetX(), anchorPos1.GetY()) : AZ::Vector2(anchorPos1.GetX(), targetPos.GetY());
|
|
|
|
AZ::Vector3 start1_3 = EntityHelpers::MakeVec3(anchorPos1);
|
|
AZ::Vector3 start2_3 = EntityHelpers::MakeVec3(anchorPos2);
|
|
AZ::Vector3 end3 = EntityHelpers::MakeVec3(targetPos);
|
|
AZ::Vector3 corner3 = EntityHelpers::MakeVec3(cornerPos);
|
|
|
|
start1_3 = transform * start1_3;
|
|
start2_3 = transform * start2_3;
|
|
corner3 = transform * corner3;
|
|
end3 = transform * end3;
|
|
|
|
AZ::Vector2 start1_2(start1_3.GetX(), start1_3.GetY());
|
|
AZ::Vector2 start2_2(start2_3.GetX(), start2_3.GetY());
|
|
AZ::Vector2 corner2(corner3.GetX(), corner3.GetY());
|
|
AZ::Vector2 end2(end3.GetX(), end3.GetY());
|
|
|
|
AZ::Color solidColor(1.0f, 1.0f, 1.0f, 0.2f);
|
|
|
|
draw2d.DrawLine(start1_2, corner2, solidColor);
|
|
draw2d.DrawLine(corner2, start2_2, solidColor);
|
|
|
|
float displayDistance = (!horizSplit) ? targetPos.GetX() - cornerPos.GetX() : targetPos.GetY() - cornerPos.GetY();
|
|
DrawDistanceLine(draw2d, corner2, end2, displayDistance, suffix);
|
|
}
|
|
|
|
void ViewportIcon::DrawDistanceLineWithTransform(Draw2dHelper& draw2d, AZ::Vector2 sourcePos, AZ::Vector2 targetPos, const AZ::Matrix4x4& transform,
|
|
float value, const char* suffix)
|
|
{
|
|
AZ::Vector3 start3 = EntityHelpers::MakeVec3(sourcePos);
|
|
AZ::Vector3 end3 = EntityHelpers::MakeVec3(targetPos);
|
|
|
|
start3 = transform * start3;
|
|
end3 = transform * end3;
|
|
|
|
AZ::Vector2 start2(start3.GetX(), start3.GetY());
|
|
AZ::Vector2 end2(end3.GetX(), end3.GetY());
|
|
|
|
AZ::Color solidColor(1.0f, 1.0f, 1.0f, 0.2f);
|
|
DrawDistanceLine(draw2d, start2, end2, value, suffix);
|
|
}
|
|
|
|
void ViewportIcon::DrawElementRectOutline(Draw2dHelper& draw2d, AZ::EntityId entityId, AZ::Color color)
|
|
{
|
|
// get the transformed rect for the element
|
|
UiTransformInterface::RectPoints points;
|
|
EBUS_EVENT_ID(entityId, UiTransformBus, GetViewportSpacePoints, points);
|
|
|
|
// work out if we should snap to exact pixel
|
|
AZ::EntityId canvasEntityId;
|
|
EBUS_EVENT_ID_RESULT(canvasEntityId, entityId, UiElementBus, GetCanvasEntityId);
|
|
bool isPixelAligned = true;
|
|
EBUS_EVENT_ID_RESULT(isPixelAligned, canvasEntityId, UiCanvasBus, GetIsPixelAligned);
|
|
IDraw2d::Rounding pixelRounding = isPixelAligned ? IDraw2d::Rounding::Nearest : IDraw2d::Rounding::None;
|
|
|
|
// round the points to the nearest pixel if the canvas is set to do that for elements since
|
|
// we want this outline to line up with the element
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
points.pt[i] = Draw2dHelper::RoundXY(points.pt[i], pixelRounding);
|
|
}
|
|
|
|
// since the rect is transformed we have to add the offsets by multiplying them
|
|
// by unit vectors parallel with the edges of the rect. However, the rect could be
|
|
// zero width and/or height so we can't use "points" to compute these unit vectors.
|
|
// So we instead get the transform matrix and transform two unit vectors
|
|
// and then normalize them (they have to be re-normalized since the transform can scale them)
|
|
AZ::Matrix4x4 transform;
|
|
EBUS_EVENT_ID(entityId, UiTransformBus, GetTransformToViewport, transform);
|
|
AZ::Vector3 rightVec3(1.0f, 0.0f, 0.0f);
|
|
AZ::Vector3 downVec3(0.0f, 1.0f, 0.0f);
|
|
rightVec3 = transform.Multiply3x3(rightVec3);
|
|
downVec3 = transform.Multiply3x3(downVec3);
|
|
AZ::Vector2 rightVec(rightVec3.GetX(), rightVec3.GetY());
|
|
AZ::Vector2 downVec(downVec3.GetX(), downVec3.GetY());
|
|
rightVec.NormalizeSafe();
|
|
downVec.NormalizeSafe();
|
|
|
|
uint32_t lineThickness = aznumeric_cast<uint32_t>(GetTextureSize().GetY());
|
|
draw2d.DrawRectOutlineTextured(m_image, points, rightVec, downVec, color, lineThickness);
|
|
}
|